text
stringlengths 70
351k
| source
stringclasses 4
values |
|---|---|
<|meta_start|><|file|> hyperswitch/crates/hyperswitch_connectors/src/connectors/cryptopay.rs<|crate|> hyperswitch_connectors<|connector|> cryptopay 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/cryptopay.rs" role="context" start="243" end="256">
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 = cryptopay::CryptopayRouterData::from((amount, req));
let connector_req = cryptopay::CryptopayPaymentsRequest::try_from(&connector_router_data)?;
Ok(RequestContent::Json(Box::new(connector_req)))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/cryptopay.rs" role="context" start="242" end="242">
fn get_content_type(&self) -> &'static str {
self.common_get_content_type()
}
fn get_url(
&self,
_req: &PaymentsAuthorizeRouterData,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
Ok(format!("{}/api/invoices", self.base_url(connectors)))
}
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 = cryptopay::CryptopayRouterData::from((amount, req));
let connector_req = cryptopay::CryptopayPaymentsRequest::try_from(&connector_router_data)?;
Ok(RequestContent::Json(Box::new(connector_req)))
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/cryptopay.rs" role="context" start="276" end="304">
fn handle_response(
&self,
data: &PaymentsAuthorizeRouterData,
event_builder: Option<&mut ConnectorEvent>,
res: Response,
) -> CustomResult<PaymentsAuthorizeRouterData, errors::ConnectorError> {
let response: cryptopay::CryptopayPaymentsResponse = res
.response
.parse_struct("Cryptopay PaymentsAuthorizeResponse")
.change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
event_builder.map(|i| i.set_response_body(&response));
router_env::logger::info!(connector_response=?response);
let capture_amount_in_minor_units = match response.data.price_amount {
Some(ref amount) => Some(utils::convert_back_amount_to_minor_units(
self.amount_converter,
amount.clone(),
data.request.currency,
)?),
None => None,
};
RouterData::foreign_try_from((
ResponseRouterData {
response,
data: data.clone(),
http_code: res.status_code,
},
capture_amount_in_minor_units,
))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/cryptopay.rs" role="context" start="258" end="274">
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/cryptopay.rs" role="context" start="235" end="241">
fn get_url(
&self,
_req: &PaymentsAuthorizeRouterData,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
Ok(format!("{}/api/invoices", self.base_url(connectors)))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/cryptopay.rs" role="context" start="231" end="233">
fn get_content_type(&self) -> &'static str {
self.common_get_content_type()
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/cryptopay.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/cryptopay/transformers.rs" role="context" start="24" end="27">
pub struct CryptopayRouterData<T> {
pub amount: StringMajorUnit,
pub router_data: T,
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/hyperswitch_connectors/src/connectors/jpmorgan/transformers.rs<|crate|> hyperswitch_connectors<|connector|> jpmorgan anchor=refund_status_from_transaction_state kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/jpmorgan/transformers.rs" role="context" start="570" end="584">
pub fn refund_status_from_transaction_state(
transaction_state: JpmorganTransactionState,
) -> common_enums::RefundStatus {
match transaction_state {
JpmorganTransactionState::Voided | JpmorganTransactionState::Closed => {
common_enums::RefundStatus::Success
}
JpmorganTransactionState::Declined | JpmorganTransactionState::Error => {
common_enums::RefundStatus::Failure
}
JpmorganTransactionState::Pending | JpmorganTransactionState::Authorized => {
common_enums::RefundStatus::Pending
}
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/jpmorgan/transformers.rs" role="context" start="569" end="569">
use common_enums::enums::CaptureMethod;
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/jpmorgan/transformers.rs" role="context" start="625" end="637">
fn try_from(
item: RefundsResponseRouterData<RSync, JpmorganRefundSyncResponse>,
) -> Result<Self, Self::Error> {
Ok(Self {
response: Ok(RefundsResponseData {
connector_refund_id: item.response.transaction_id.clone(),
refund_status: refund_status_from_transaction_state(
item.response.transaction_state,
),
}),
..item.data
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/jpmorgan/transformers.rs" role="context" start="590" end="606">
fn try_from(
item: RefundsResponseRouterData<Execute, JpmorganRefundResponse>,
) -> Result<Self, Self::Error> {
Ok(Self {
response: Ok(RefundsResponseData {
connector_refund_id: item
.response
.transaction_id
.clone()
.ok_or(errors::ConnectorError::ResponseHandlingFailed)?,
refund_status: refund_status_from_transaction_state(
item.response.transaction_state,
),
}),
..item.data
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/jpmorgan/transformers.rs" role="context" start="555" end="561">
fn from(item: RefundStatus) -> Self {
match item {
RefundStatus::Succeeded => Self::Success,
RefundStatus::Failed => Self::Failure,
RefundStatus::Processing => Self::Pending,
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/jpmorgan/transformers.rs" role="context" start="525" end="527">
fn try_from(_item: &JpmorganRouterData<&RefundsRouterData<F>>) -> Result<Self, Self::Error> {
Err(errors::ConnectorError::NotImplemented("Refunds".to_string()).into())
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/jpmorgan/transformers.rs" role="context" start="53" end="53">
type Error = error_stack::Report<errors::ConnectorError>;
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/jpmorgan/transformers.rs" role="context" start="547" end="552">
pub enum RefundStatus {
Succeeded,
Failed,
#[default]
Processing,
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/jpmorgan/transformers.rs" role="context" start="238" end="246">
pub enum JpmorganTransactionState {
Closed,
Authorized,
Voided,
#[default]
Pending,
Declined,
Error,
}
<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/authorizedotnet/transformers.rs<|crate|> hyperswitch_connectors<|connector|> authorizedotnet 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/authorizedotnet/transformers.rs" role="context" start="1635" end="1654">
fn try_from(
item: RefundsResponseRouterData<RSync, AuthorizedotnetRSyncResponse>,
) -> Result<Self, Self::Error> {
match item.response.transaction {
Some(transaction) => {
let refund_status = enums::RefundStatus::from(transaction.transaction_status);
Ok(Self {
response: Ok(RefundsResponseData {
connector_refund_id: transaction.transaction_id,
refund_status,
}),
..item.data
})
}
None => Ok(Self {
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="1634" end="1634">
use common_enums::enums;
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="1707" end="1713">
fn construct_refund_payment_details(masked_number: String) -> PaymentDetails {
PaymentDetails::CreditCard(CreditCardDetails {
card_number: masked_number.into(),
expiration_date: "XXXX".to_string().into(),
card_code: None,
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/authorizedotnet/transformers.rs" role="context" start="1662" end="1690">
fn try_from(
item: ResponseRouterData<F, AuthorizedotnetSyncResponse, Req, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
match item.response.transaction {
Some(transaction) => {
let payment_status = enums::AttemptStatus::from(transaction.transaction_status);
Ok(Self {
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(
transaction.transaction_id.clone(),
),
redirection_data: Box::new(None),
mandate_reference: Box::new(None),
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: Some(transaction.transaction_id.clone()),
incremental_authorization_allowed: None,
charges: None,
}),
status: payment_status,
..item.data
})
}
None => Ok(Self {
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="1619" end="1627">
fn from(transaction_status: RSyncStatus) -> Self {
match transaction_status {
RSyncStatus::RefundSettledSuccessfully => Self::Success,
RSyncStatus::RefundPendingSettlement => Self::Pending,
RSyncStatus::Declined | RSyncStatus::GeneralError | RSyncStatus::Voided => {
Self::Failure
}
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/authorizedotnet/transformers.rs" role="context" start="1601" end="1615">
fn from(transaction_status: SyncStatus) -> Self {
match transaction_status {
SyncStatus::SettledSuccessfully | SyncStatus::CapturedPendingSettlement => {
Self::Charged
}
SyncStatus::AuthorizedPendingCapture => Self::Authorized,
SyncStatus::Declined => Self::AuthenticationFailed,
SyncStatus::Voided => Self::Voided,
SyncStatus::CouldNotVoid => Self::VoidFailed,
SyncStatus::GeneralError => Self::Failure,
SyncStatus::RefundSettledSuccessfully
| SyncStatus::RefundPendingSettlement
| SyncStatus::FDSPendingReview => Self::Pending,
}
}
<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="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="1595" end="1598">
pub struct AuthorizedotnetRSyncResponse {
transaction: Option<RSyncTransactionResponse>,
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/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/cybersource/transformers.rs<|crate|> hyperswitch_connectors<|connector|> cybersource 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/cybersource/transformers.rs" role="context" start="3472" end="3494">
fn try_from(
item: ResponseRouterData<
F,
CybersourcePaymentsResponse,
PaymentsCancelData,
PaymentsResponseData,
>,
) -> Result<Self, Self::Error> {
let status = map_cybersource_attempt_status(
item.response
.status
.clone()
.unwrap_or(CybersourcePaymentStatus::StatusNotReceived),
false,
);
let response =
get_payment_response((&item.response, status, item.http_code)).map_err(|err| *err);
Ok(Self {
status,
response,
..item.data
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/cybersource/transformers.rs" role="context" start="3471" end="3471">
impl<F>
TryFrom<
ResponseRouterData<
F,
CybersourcePaymentsResponse,
PaymentsCancelData,
PaymentsResponseData,
>,
> for RouterData<F, PaymentsCancelData, PaymentsResponseData>
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: ResponseRouterData<
F,
CybersourcePaymentsResponse,
PaymentsCancelData,
PaymentsResponseData,
>,
) -> Result<Self, Self::Error> {
let status = map_cybersource_attempt_status(
item.response
.status
.clone()
.unwrap_or(CybersourcePaymentStatus::StatusNotReceived),
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/cybersource/transformers.rs" role="context" start="3595" end="3620">
fn try_from(
item: ResponseRouterData<
F,
CybersourcePaymentsIncrementalAuthorizationResponse,
T,
PaymentsResponseData,
>,
) -> Result<Self, Self::Error> {
Ok(Self {
response: match item.response.error_information {
Some(error) => Ok(PaymentsResponseData::IncrementalAuthorizationResponse {
status: common_enums::AuthorizationStatus::Failure,
error_code: error.reason,
error_message: error.message,
connector_authorization_id: None,
}),
None => Ok(PaymentsResponseData::IncrementalAuthorizationResponse {
status: item.response.status.into(),
error_code: None,
error_message: None,
connector_authorization_id: None,
}),
},
..item.data
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/cybersource/transformers.rs" role="context" start="3509" end="3581">
fn try_from(
item: ResponseRouterData<
SetupMandate,
CybersourcePaymentsResponse,
SetupMandateRequestData,
PaymentsResponseData,
>,
) -> Result<Self, Self::Error> {
let mandate_reference =
item.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_cybersource_attempt_status(
item.response
.status
.clone()
.unwrap_or(CybersourcePaymentStatus::StatusNotReceived),
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((&item.response, mandate_status, item.http_code));
let connector_response = item
.response
.processor_information
.as_ref()
.map(AdditionalPaymentMethodConnectorResponse::from)
.map(ConnectorResponseData::with_additional_payment_method_data);
Ok(Self {
status: mandate_status,
response: match error_response {
Some(error) => Err(error),
None => Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(item.response.id.clone()),
redirection_data: Box::new(None),
mandate_reference: Box::new(mandate_reference),
connector_metadata: None,
network_txn_id: item.response.processor_information.as_ref().and_then(
|processor_information| {
processor_information.network_transaction_id.clone()
},
),
connector_response_reference_id: Some(
item.response
.client_reference_information
.and_then(|client_reference_information| {
client_reference_information.code.clone()
})
.unwrap_or(item.response.id),
),
incremental_authorization_allowed: Some(
mandate_status == enums::AttemptStatus::Authorized,
),
charges: None,
}),
},
connector_response,
..item.data
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/cybersource/transformers.rs" role="context" start="3436" end="3458">
fn try_from(
item: ResponseRouterData<
F,
CybersourcePaymentsResponse,
PaymentsCaptureData,
PaymentsResponseData,
>,
) -> Result<Self, Self::Error> {
let status = map_cybersource_attempt_status(
item.response
.status
.clone()
.unwrap_or(CybersourcePaymentStatus::StatusNotReceived),
true,
);
let response =
get_payment_response((&item.response, status, item.http_code)).map_err(|err| *err);
Ok(Self {
status,
response,
..item.data
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/cybersource/transformers.rs" role="context" start="3411" end="3422">
fn from(processor_information: &ClientProcessorInformation) -> Self {
let payment_checks = Some(
serde_json::json!({"avs_response": processor_information.avs, "card_verification": processor_information.card_verification}),
);
Self::Card {
authentication_data: None,
payment_checks,
card_network: None,
domestic_network: None,
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/cybersource/transformers.rs" role="context" start="2594" end="2629">
pub fn map_cybersource_attempt_status(
status: CybersourcePaymentStatus,
capture: bool,
) -> enums::AttemptStatus {
match status {
CybersourcePaymentStatus::Authorized => {
if capture {
// Because Cybersource will return Payment Status as Authorized even in AutoCapture Payment
enums::AttemptStatus::Charged
} else {
enums::AttemptStatus::Authorized
}
}
CybersourcePaymentStatus::Succeeded | CybersourcePaymentStatus::Transmitted => {
enums::AttemptStatus::Charged
}
CybersourcePaymentStatus::Voided
| CybersourcePaymentStatus::Reversed
| CybersourcePaymentStatus::Cancelled => enums::AttemptStatus::Voided,
CybersourcePaymentStatus::Failed
| CybersourcePaymentStatus::Declined
| CybersourcePaymentStatus::AuthorizedRiskDeclined
| CybersourcePaymentStatus::Rejected
| CybersourcePaymentStatus::InvalidRequest
| CybersourcePaymentStatus::ServerError => enums::AttemptStatus::Failure,
CybersourcePaymentStatus::PendingAuthentication => {
enums::AttemptStatus::AuthenticationPending
}
CybersourcePaymentStatus::PendingReview
| CybersourcePaymentStatus::StatusNotReceived
| CybersourcePaymentStatus::Challenge
| CybersourcePaymentStatus::Accepted
| CybersourcePaymentStatus::Pending
| CybersourcePaymentStatus::AuthorizedPendingReview => enums::AttemptStatus::Pending,
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/cybersource/transformers.rs" role="context" start="2757" end="2799">
fn get_payment_response(
(info_response, status, http_code): (&CybersourcePaymentsResponse, enums::AttemptStatus, u16),
) -> Result<PaymentsResponseData, Box<ErrorResponse>> {
let error_response = get_error_response_if_failure((info_response, status, http_code));
match error_response {
Some(error) => Err(Box::new(error)),
None => {
let incremental_authorization_allowed =
Some(status == enums::AttemptStatus::Authorized);
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,
});
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: info_response.processor_information.as_ref().and_then(
|processor_information| processor_information.network_transaction_id.clone(),
),
connector_response_reference_id: Some(
info_response
.client_reference_information
.clone()
.and_then(|client_reference_information| client_reference_information.code)
.unwrap_or(info_response.id.clone()),
),
incremental_authorization_allowed,
charges: None,
})
}
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/cybersource/transformers.rs" role="context" start="109" end="109">
type Error = error_stack::Report<errors::ConnectorError>;
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/cybersource/transformers.rs" role="context" start="2642" end="2650">
pub struct CybersourcePaymentsResponse {
id: String,
status: Option<CybersourcePaymentStatus>,
client_reference_information: Option<ClientReferenceInformation>,
processor_information: Option<ClientProcessorInformation>,
risk_information: Option<ClientRiskInformation>,
token_information: Option<CybersourceTokenInformation>,
error_information: Option<CybersourceErrorInformation>,
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/types.rs" role="context" start="53" end="57">
pub struct ResponseRouterData<Flow, R, Request, Response> {
pub response: R,
pub data: RouterData<Flow, Request, Response>,
pub http_code: u16,
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/hyperswitch_connectors/src/connectors/recurly.rs<|crate|> hyperswitch_connectors<|connector|> recurly anchor=get_signature_elements_from_header 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="76" end="91">
fn get_signature_elements_from_header(
headers: &actix_web::http::header::HeaderMap,
) -> CustomResult<Vec<Vec<u8>>, errors::ConnectorError> {
let security_header = headers
.get("recurly-signature")
.ok_or(errors::ConnectorError::WebhookSignatureNotFound)?;
let security_header_str = security_header
.to_str()
.change_context(errors::ConnectorError::WebhookSignatureNotFound)?;
let header_parts: Vec<Vec<u8>> = security_header_str
.split(',')
.map(|part| part.trim().as_bytes().to_vec())
.collect();
Ok(header_parts)
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/recurly.rs" role="context" start="75" end="75">
use common_utils::{
consts,
errors::CustomResult,
ext_traits::BytesExt,
request::{Method, Request, RequestBuilder, RequestContent},
types::{AmountConvertor, StringMinorUnit, StringMinorUnitForConnector},
};
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 recurly;
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="137" end="139">
fn id(&self) -> &'static str {
"recurly"
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/recurly.rs" role="context" start="121" end="133">
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/recurly.rs" role="context" start="70" end="74">
pub fn new() -> &'static Self {
&Self {
amount_converter: &StringMinorUnitForConnector,
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/recurly.rs" role="context" start="801" end="817">
fn get_webhook_source_verification_message(
&self,
request: &webhooks::IncomingWebhookRequestDetails<'_>,
_merchant_id: &common_utils::id_type::MerchantId,
_connector_webhook_secrets: &api_models::webhooks::ConnectorWebhookSecrets,
) -> CustomResult<Vec<u8>, errors::ConnectorError> {
let header_values = Self::get_signature_elements_from_header(request.headers)?;
let timestamp = header_values
.first()
.ok_or(errors::ConnectorError::WebhookSignatureNotFound)?;
Ok(format!(
"{}.{}",
String::from_utf8_lossy(timestamp),
String::from_utf8_lossy(request.body)
)
.into_bytes())
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/recurly.rs" role="context" start="787" end="799">
fn get_webhook_source_verification_signature(
&self,
request: &webhooks::IncomingWebhookRequestDetails<'_>,
_connector_webhook_secrets: &api_models::webhooks::ConnectorWebhookSecrets,
) -> CustomResult<Vec<u8>, errors::ConnectorError> {
// The `recurly-signature` header consists of a Unix timestamp (in milliseconds) followed by one or more HMAC-SHA256 signatures, separated by commas.
// Multiple signatures exist when a secret key is regenerated, with the old key remaining active for 24 hours.
let header_values = Self::get_signature_elements_from_header(request.headers)?;
let signature = header_values
.get(1)
.ok_or(errors::ConnectorError::WebhookSignatureNotFound)?;
hex::decode(signature).change_context(errors::ConnectorError::WebhookSignatureNotFound)
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/hyperswitch_connectors/src/connectors/bankofamerica/transformers.rs<|crate|> hyperswitch_connectors<|connector|> bankofamerica 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/bankofamerica/transformers.rs" role="context" start="2135" end="2158">
fn try_from(
item: RefundsResponseRouterData<Execute, BankOfAmericaRefundResponse>,
) -> Result<Self, Self::Error> {
let refund_status = enums::RefundStatus::from(item.response.clone());
let response = if utils::is_refund_failure(refund_status) {
Err(get_error_response(
&item.response.error_information,
&None,
None,
item.http_code,
item.response.id,
))
} else {
Ok(RefundsResponseData {
connector_refund_id: item.response.id,
refund_status,
})
};
Ok(Self {
response,
..item.data
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/bankofamerica/transformers.rs" role="context" start="2134" end="2134">
use common_enums::{enums, FutureUsage};
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 crate::{
constants,
types::{RefundsResponseRouterData, ResponseRouterData},
unimplemented_payment_method,
utils::{
self, AddressDetailsData, ApplePayDecrypt, CardData, PaymentsAuthorizeRequestData,
PaymentsSetupMandateRequestData, PaymentsSyncRequestData, RecurringMandateData,
RouterData as OtherRouterData,
},
};
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/bankofamerica/transformers.rs" role="context" start="2324" end="2384">
fn get_error_response(
error_data: &Option<BankOfAmericaErrorInformation>,
risk_information: &Option<ClientRiskInformation>,
attempt_status: Option<enums::AttemptStatus>,
status_code: u16,
transaction_id: String,
) -> ErrorResponse {
let avs_message = risk_information
.clone()
.map(|client_risk_information| {
client_risk_information.rules.map(|rules| {
rules
.iter()
.map(|risk_info| {
risk_info.name.clone().map_or("".to_string(), |name| {
format!(" , {}", name.clone().expose())
})
})
.collect::<Vec<String>>()
.join("")
})
})
.unwrap_or(Some("".to_string()));
let detailed_error_info = error_data.to_owned().and_then(|error_info| {
error_info.details.map(|error_details| {
error_details
.iter()
.map(|details| format!("{} : {}", details.field, details.reason))
.collect::<Vec<_>>()
.join(", ")
})
});
let reason = get_error_reason(
error_data
.clone()
.and_then(|error_details| error_details.message),
detailed_error_info,
avs_message,
);
let error_message = error_data
.clone()
.and_then(|error_details| error_details.reason);
ErrorResponse {
code: error_message
.clone()
.unwrap_or(hyperswitch_interfaces::consts::NO_ERROR_CODE.to_string()),
message: error_message
.clone()
.unwrap_or(hyperswitch_interfaces::consts::NO_ERROR_MESSAGE.to_string()),
reason,
status_code,
attempt_status,
connector_transaction_id: Some(transaction_id.clone()),
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/bankofamerica/transformers.rs" role="context" start="2192" end="2264">
fn try_from(
item: RefundsResponseRouterData<RSync, BankOfAmericaRsyncResponse>,
) -> Result<Self, Self::Error> {
let response = match item
.response
.application_information
.and_then(|application_information| application_information.status)
{
Some(status) => {
let error_reason = item
.response
.error_information
.clone()
.and_then(|error_info| error_info.reason);
let refund_status = match status {
BankofamericaRefundStatus::Succeeded
| BankofamericaRefundStatus::Transmitted => enums::RefundStatus::Success,
BankofamericaRefundStatus::Cancelled
| BankofamericaRefundStatus::Failed
| BankofamericaRefundStatus::Voided => enums::RefundStatus::Failure,
BankofamericaRefundStatus::Pending => enums::RefundStatus::Pending,
BankofamericaRefundStatus::TwoZeroOne => {
if error_reason == Some("PROCESSOR_DECLINED".to_string()) {
enums::RefundStatus::Failure
} else {
enums::RefundStatus::Pending
}
}
};
if utils::is_refund_failure(refund_status) {
if status == BankofamericaRefundStatus::Voided {
Err(get_error_response(
&Some(BankOfAmericaErrorInformation {
message: Some(constants::REFUND_VOIDED.to_string()),
reason: Some(constants::REFUND_VOIDED.to_string()),
details: None,
}),
&None,
None,
item.http_code,
item.response.id.clone(),
))
} else {
Err(get_error_response(
&item.response.error_information,
&None,
None,
item.http_code,
item.response.id.clone(),
))
}
} else {
Ok(RefundsResponseData {
connector_refund_id: item.response.id,
refund_status,
})
}
}
None => Ok(RefundsResponseData {
connector_refund_id: item.response.id.clone(),
refund_status: match item.data.response {
Ok(response) => response.refund_status,
Err(_) => common_enums::RefundStatus::Pending,
},
}),
};
Ok(Self {
response,
..item.data
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/bankofamerica/transformers.rs" role="context" start="2100" end="2120">
fn from(item: BankOfAmericaRefundResponse) -> Self {
let error_reason = item
.error_information
.and_then(|error_info| error_info.reason);
match item.status {
BankofamericaRefundStatus::Succeeded | BankofamericaRefundStatus::Transmitted => {
Self::Success
}
BankofamericaRefundStatus::Cancelled
| BankofamericaRefundStatus::Failed
| BankofamericaRefundStatus::Voided => Self::Failure,
BankofamericaRefundStatus::Pending => Self::Pending,
BankofamericaRefundStatus::TwoZeroOne => {
if error_reason == Some("PROCESSOR_DECLINED".to_string()) {
Self::Failure
} else {
Self::Pending
}
}
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/bankofamerica/transformers.rs" role="context" start="2082" end="2096">
fn try_from(
item: &BankOfAmericaRouterData<&RefundsRouterData<F>>,
) -> Result<Self, Self::Error> {
Ok(Self {
order_information: OrderInformation {
amount_details: Amount {
total_amount: item.amount.clone(),
currency: item.router_data.request.currency,
},
},
client_reference_information: ClientReferenceInformation {
code: Some(item.router_data.request.refund_id.clone()),
},
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/bankofamerica/transformers.rs" role="context" start="2613" end="2622">
fn from(google_pay_data: &GooglePayWalletData) -> Self {
Self::GooglePay(Box::new(GooglePayPaymentInformation {
fluid_data: FluidData {
value: Secret::from(
consts::BASE64_ENGINE.encode(google_pay_data.tokenization_data.token.clone()),
),
descriptor: None,
},
}))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/bankofamerica/transformers.rs" role="context" start="46" end="46">
type Error = error_stack::Report<errors::ConnectorError>;
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/bankofamerica/transformers.rs" role="context" start="2125" end="2129">
pub struct BankOfAmericaRefundResponse {
id: String,
status: BankofamericaRefundStatus,
error_information: Option<BankOfAmericaErrorInformation>,
}
<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/prophetpay/transformers.rs<|crate|> hyperswitch_connectors<|connector|> prophetpay anchor=try_from kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=1<|meta_end|>
<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="346" end="346">
use common_utils::{
consts::{PROPHETPAY_REDIRECT_URL, PROPHETPAY_TOKEN},
errors::CustomResult,
request::Method,
};
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="451" end="486">
fn try_from(
item: ResponseRouterData<F, ProphetpaySyncResponse, T, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
if item.response.success {
Ok(Self {
status: enums::AttemptStatus::Charged,
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(item.response.transaction_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: 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="390" end="435">
fn try_from(
item: ResponseRouterData<
F,
ProphetpayCompleteAuthResponse,
CompleteAuthorizeData,
PaymentsResponseData,
>,
) -> Result<Self, Self::Error> {
if item.response.success {
let card_token = get_card_token(item.data.request.redirect_response.clone())?;
let card_token_data = ProphetpayCardTokenData {
card_token: Secret::from(card_token),
};
let connector_metadata = serde_json::to_value(card_token_data).ok();
Ok(Self {
status: enums::AttemptStatus::Charged,
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(item.response.transaction_id),
redirection_data: Box::new(None),
mandate_reference: Box::new(None),
connector_metadata,
network_txn_id: None,
connector_response_reference_id: None,
incremental_authorization_allowed: None,
charges: None,
}),
..item.data
})
} else {
Ok(Self {
status: enums::AttemptStatus::Failure,
response: Err(ErrorResponse {
code: item.response.response_code,
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="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="279" end="316">
fn get_card_token(
response: Option<CompleteAuthorizeRedirectResponse>,
) -> CustomResult<String, errors::ConnectorError> {
let res = response.ok_or(errors::ConnectorError::MissingRequiredField {
field_name: "redirect_response",
})?;
let queries_params = res
.params
.map(|param| {
let mut queries = HashMap::<String, String>::new();
let values = param.peek().split('&').collect::<Vec<&str>>();
for value in values {
let pair = value.split('=').collect::<Vec<&str>>();
queries.insert(
pair.first()
.ok_or(errors::ConnectorError::ResponseDeserializationFailed)?
.to_string(),
pair.get(1)
.ok_or(errors::ConnectorError::ResponseDeserializationFailed)?
.to_string(),
);
}
Ok::<_, errors::ConnectorError>(queries)
})
.transpose()?
.ok_or(errors::ConnectorError::ResponseDeserializationFailed)?;
for (key, val) in queries_params {
if key.as_str() == PROPHETPAY_TOKEN {
return Ok(val);
}
}
Err(errors::ConnectorError::MissingRequiredField {
field_name: "card_token",
}
.into())
}
<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="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>,
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/hyperswitch_connectors/src/connectors/zen/transformers.rs<|crate|> hyperswitch_connectors<|connector|> zen anchor=get_checkout_signature kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=1<|meta_end|>
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/zen/transformers.rs" role="context" start="536" end="550">
fn get_checkout_signature(
checkout_request: &CheckoutRequest,
session: &WalletSessionData,
) -> Result<Secret<String>, error_stack::Report<errors::ConnectorError>> {
let pay_wall_secret = session
.pay_wall_secret
.clone()
.ok_or(errors::ConnectorError::RequestEncodingFailed)?;
let mut signature_data = get_signature_data(checkout_request)?;
signature_data.push_str(&pay_wall_secret.expose());
let payload_digest = digest::digest(&digest::SHA256, signature_data.as_bytes());
let mut signature = hex::encode(payload_digest);
signature.push_str(";sha256");
Ok(Secret::new(signature))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/zen/transformers.rs" role="context" start="535" end="535">
use error_stack::ResultExt;
use masking::{ExposeInterface, PeekInterface, Secret};
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/zen/transformers.rs" role="context" start="607" end="615">
fn get_customer(
item: &types::PaymentsAuthorizeRouterData,
ip: Secret<String, pii::IpAddress>,
) -> Result<ZenCustomerDetails, error_stack::Report<errors::ConnectorError>> {
Ok(ZenCustomerDetails {
email: item.request.get_email()?,
ip,
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/zen/transformers.rs" role="context" start="553" end="605">
fn get_signature_data(
checkout_request: &CheckoutRequest,
) -> Result<String, errors::ConnectorError> {
let specified_payment_channel = match checkout_request.specified_payment_channel {
ZenPaymentChannels::PclCard => "pcl_card",
ZenPaymentChannels::PclGooglepay => "pcl_googlepay",
ZenPaymentChannels::PclApplepay => "pcl_applepay",
ZenPaymentChannels::PclBoacompraBoleto => "pcl_boacompra_boleto",
ZenPaymentChannels::PclBoacompraEfecty => "pcl_boacompra_efecty",
ZenPaymentChannels::PclBoacompraMultibanco => "pcl_boacompra_multibanco",
ZenPaymentChannels::PclBoacompraPagoefectivo => "pcl_boacompra_pagoefectivo",
ZenPaymentChannels::PclBoacompraPix => "pcl_boacompra_pix",
ZenPaymentChannels::PclBoacompraPse => "pcl_boacompra_pse",
ZenPaymentChannels::PclBoacompraRedcompra => "pcl_boacompra_redcompra",
ZenPaymentChannels::PclBoacompraRedpagos => "pcl_boacompra_redpagos",
};
let mut signature_data = vec![
format!("amount={}", checkout_request.amount),
format!("currency={}", checkout_request.currency),
format!("customipnurl={}", checkout_request.custom_ipn_url),
];
for index in 0..checkout_request.items.len() {
let prefix = format!("items[{index}].");
let checkout_request_items = checkout_request
.items
.get(index)
.ok_or(errors::ConnectorError::RequestEncodingFailed)?;
signature_data.push(format!(
"{prefix}lineamounttotal={}",
checkout_request_items.line_amount_total
));
signature_data.push(format!("{prefix}name={}", checkout_request_items.name));
signature_data.push(format!("{prefix}price={}", checkout_request_items.price));
signature_data.push(format!(
"{prefix}quantity={}",
checkout_request_items.quantity
));
}
signature_data.push(format!(
"merchanttransactionid={}",
checkout_request.merchant_transaction_id
));
signature_data.push(format!(
"specifiedpaymentchannel={specified_payment_channel}"
));
signature_data.push(format!(
"terminaluuid={}",
checkout_request.terminal_uuid.peek()
));
signature_data.push(format!("urlredirect={}", checkout_request.url_redirect));
let signature = signature_data.join("&");
Ok(signature.to_lowercase())
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/zen/transformers.rs" role="context" start="456" end="533">
fn try_from(
(item, wallet_data): (
&ZenRouterData<&types::PaymentsAuthorizeRouterData>,
&WalletData,
),
) -> Result<Self, Self::Error> {
let amount = item.amount.to_owned();
let connector_meta = item.router_data.get_connector_meta()?;
let session: SessionObject = connector_meta
.parse_value("SessionObject")
.change_context(errors::ConnectorError::RequestEncodingFailed)?;
let (specified_payment_channel, session_data) = match wallet_data {
WalletData::ApplePayRedirect(_) => (
ZenPaymentChannels::PclApplepay,
session
.apple_pay
.ok_or(errors::ConnectorError::InvalidWalletToken {
wallet_name: "Apple Pay".to_string(),
})?,
),
WalletData::GooglePayRedirect(_) => (
ZenPaymentChannels::PclGooglepay,
session
.google_pay
.ok_or(errors::ConnectorError::InvalidWalletToken {
wallet_name: "Google Pay".to_string(),
})?,
),
WalletData::WeChatPayRedirect(_)
| WalletData::PaypalRedirect(_)
| WalletData::ApplePay(_)
| WalletData::GooglePay(_)
| WalletData::AliPayQr(_)
| WalletData::AliPayRedirect(_)
| WalletData::AliPayHkRedirect(_)
| WalletData::AmazonPayRedirect(_)
| WalletData::MomoRedirect(_)
| WalletData::KakaoPayRedirect(_)
| WalletData::GoPayRedirect(_)
| WalletData::GcashRedirect(_)
| WalletData::ApplePayThirdPartySdk(_)
| WalletData::DanaRedirect {}
| WalletData::GooglePayThirdPartySdk(_)
| WalletData::MbWayRedirect(_)
| WalletData::MobilePayRedirect(_)
| WalletData::PaypalSdk(_)
| WalletData::Paze(_)
| WalletData::SamsungPay(_)
| WalletData::TwintRedirect {}
| WalletData::VippsRedirect {}
| WalletData::TouchNGoRedirect(_)
| WalletData::CashappQr(_)
| WalletData::SwishQr(_)
| WalletData::WeChatPayQr(_)
| WalletData::Mifinity(_) => Err(errors::ConnectorError::NotImplemented(
utils::get_unimplemented_payment_method_error_message("Zen"),
))?,
};
let terminal_uuid = session_data
.terminal_uuid
.clone()
.ok_or(errors::ConnectorError::RequestEncodingFailed)?
.expose();
let mut checkout_request = CheckoutRequest {
merchant_transaction_id: item.router_data.connector_request_reference_id.clone(),
specified_payment_channel,
currency: item.router_data.request.currency,
custom_ipn_url: item.router_data.request.get_webhook_url()?,
items: get_item_object(item.router_data)?,
amount,
terminal_uuid: Secret::new(terminal_uuid),
signature: None,
url_redirect: item.router_data.request.get_router_return_url()?,
};
checkout_request.signature =
Some(get_checkout_signature(&checkout_request, &session_data)?);
Ok(Self::CheckoutRequest(Box::new(checkout_request)))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/zen/transformers.rs" role="context" start="317" end="366">
fn try_from(
value: (
&ZenRouterData<&types::PaymentsAuthorizeRouterData>,
&Box<BankTransferData>,
),
) -> Result<Self, Self::Error> {
let (item, bank_transfer_data) = value;
let browser_info = item.router_data.request.get_browser_info()?;
let ip = browser_info.get_ip_address()?;
let amount = item.amount.to_owned();
let payment_specific_data =
ZenPaymentSpecificData::ZenGeneralPayment(ZenGeneralPaymentData {
//Connector Specific for Latam Methods
payment_type: ZenPaymentTypes::General,
return_url: item.router_data.request.get_router_return_url()?,
});
let payment_channel = match **bank_transfer_data {
BankTransferData::MultibancoBankTransfer { .. } => {
ZenPaymentChannels::PclBoacompraMultibanco
}
BankTransferData::Pix { .. } => ZenPaymentChannels::PclBoacompraPix,
BankTransferData::Pse { .. } => ZenPaymentChannels::PclBoacompraPse,
BankTransferData::SepaBankTransfer { .. }
| BankTransferData::AchBankTransfer { .. }
| BankTransferData::BacsBankTransfer { .. }
| BankTransferData::PermataBankTransfer { .. }
| BankTransferData::BcaBankTransfer { .. }
| BankTransferData::BniVaBankTransfer { .. }
| BankTransferData::BriVaBankTransfer { .. }
| BankTransferData::CimbVaBankTransfer { .. }
| BankTransferData::DanamonVaBankTransfer { .. }
| BankTransferData::LocalBankTransfer { .. }
| BankTransferData::InstantBankTransfer {}
| BankTransferData::MandiriVaBankTransfer { .. } => {
Err(errors::ConnectorError::NotImplemented(
utils::get_unimplemented_payment_method_error_message("Zen"),
))?
}
};
Ok(Self::ApiRequest(Box::new(ApiRequest {
merchant_transaction_id: item.router_data.connector_request_reference_id.clone(),
payment_channel,
currency: item.router_data.request.currency,
payment_specific_data,
customer: get_customer(item.router_data, ip)?,
custom_ipn_url: item.router_data.request.get_webhook_url()?,
items: get_item_object(item.router_data)?,
amount,
})))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/zen/transformers.rs" role="context" start="208" end="211">
pub struct WalletSessionData {
pub terminal_uuid: Option<Secret<String>>,
pub pay_wall_secret: Option<Secret<String>>,
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/zen/transformers.rs" role="context" start="98" end="108">
pub struct CheckoutRequest {
amount: String,
currency: enums::Currency,
custom_ipn_url: String,
items: Vec<ZenItemObject>,
merchant_transaction_id: String,
signature: Option<Secret<String>>,
specified_payment_channel: ZenPaymentChannels,
terminal_uuid: Secret<String>,
url_redirect: String,
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/hyperswitch_connectors/src/connectors/bitpay.rs<|crate|> hyperswitch_connectors<|connector|> bitpay 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/bitpay.rs" role="context" start="282" end="300">
fn get_url(
&self,
req: &PaymentsSyncRouterData,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
let auth = bitpay::BitpayAuthType::try_from(&req.connector_auth_type)
.change_context(errors::ConnectorError::FailedToObtainAuthType)?;
let connector_id = req
.request
.connector_transaction_id
.get_connector_transaction_id()
.change_context(errors::ConnectorError::MissingConnectorTransactionID)?;
Ok(format!(
"{}/invoices/{}?token={}",
self.base_url(connectors),
connector_id,
auth.api_key.peek(),
))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/bitpay.rs" role="context" start="281" end="281">
fn get_headers(
&self,
req: &PaymentsSyncRouterData,
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: &PaymentsSyncRouterData,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
let auth = bitpay::BitpayAuthType::try_from(&req.connector_auth_type)
.change_context(errors::ConnectorError::FailedToObtainAuthType)?;
let connector_id = req
.request
.connector_transaction_id
.get_connector_transaction_id()
.change_context(errors::ConnectorError::MissingConnectorTransactionID)?;
Ok(format!(
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/bitpay.rs" role="context" start="317" end="334">
fn handle_response(
&self,
data: &PaymentsSyncRouterData,
event_builder: Option<&mut ConnectorEvent>,
res: Response,
) -> CustomResult<PaymentsSyncRouterData, errors::ConnectorError> {
let response: bitpay::BitpayPaymentsResponse = res
.response
.parse_struct("bitpay PaymentsSyncResponse")
.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,
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/bitpay.rs" role="context" start="302" end="315">
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/bitpay.rs" role="context" start="278" end="280">
fn get_content_type(&self) -> &'static str {
self.common_get_content_type()
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/bitpay.rs" role="context" start="270" end="276">
fn get_headers(
&self,
req: &PaymentsSyncRouterData,
connectors: &Connectors,
) -> CustomResult<Vec<(String, masking::Maskable<String>)>, errors::ConnectorError> {
self.build_headers(req, connectors)
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/bitpay.rs" role="context" start="223" end="239">
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/bitpay/transformers.rs" role="context" start="67" end="69">
pub struct BitpayAuthType {
pub(super) api_key: Secret<String>,
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/hyperswitch_connectors/src/connectors/inespay.rs<|crate|> hyperswitch_connectors<|connector|> inespay anchor=get_webhook_resource_object kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/inespay.rs" role="context" start="697" end="711">
fn get_webhook_resource_object(
&self,
request: &webhooks::IncomingWebhookRequestDetails<'_>,
) -> CustomResult<Box<dyn masking::ErasedMaskSerialize>, errors::ConnectorError> {
let data_return = get_webhook_body(request.body)
.change_context(errors::ConnectorError::WebhookBodyDecodingFailed)?;
Ok(match data_return {
inespay::InespayWebhookEventData::Payment(payment_webhook_data) => {
Box::new(payment_webhook_data)
}
inespay::InespayWebhookEventData::Refund(refund_webhook_data) => {
Box::new(refund_webhook_data)
}
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/inespay.rs" role="context" start="696" end="696">
use common_utils::{
consts::BASE64_ENGINE,
crypto,
errors::CustomResult,
ext_traits::{ByteSliceExt, BytesExt},
request::{Method, Request, RequestBuilder, RequestContent},
types::{AmountConvertor, StringMinorUnit, StringMinorUnitForConnector},
};
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, Mask, Secret};
use transformers as inespay;
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/inespay.rs" role="context" start="686" end="695">
fn get_webhook_event_type(
&self,
request: &webhooks::IncomingWebhookRequestDetails<'_>,
) -> CustomResult<api_models::webhooks::IncomingWebhookEvent, errors::ConnectorError> {
let data_return = get_webhook_body(request.body)
.change_context(errors::ConnectorError::WebhookBodyDecodingFailed)?;
Ok(api_models::webhooks::IncomingWebhookEvent::from(
data_return,
))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/inespay.rs" role="context" start="664" end="684">
fn get_webhook_object_reference_id(
&self,
request: &webhooks::IncomingWebhookRequestDetails<'_>,
) -> CustomResult<api_models::webhooks::ObjectReferenceId, errors::ConnectorError> {
let data_return = get_webhook_body(request.body)
.change_context(errors::ConnectorError::WebhookBodyDecodingFailed)?;
match data_return {
inespay::InespayWebhookEventData::Payment(data) => {
Ok(api_models::webhooks::ObjectReferenceId::PaymentId(
api_models::payments::PaymentIdType::ConnectorTransactionId(
data.single_payin_id,
),
))
}
inespay::InespayWebhookEventData::Refund(data) => {
Ok(api_models::webhooks::ObjectReferenceId::RefundId(
api_models::webhooks::RefundIdType::ConnectorRefundId(data.refund_id),
))
}
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/inespay.rs" role="context" start="54" end="58">
pub fn new() -> &'static Self {
&Self {
amount_converter: &StringMinorUnitForConnector,
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/inespay.rs" role="context" start="584" end="598">
fn get_webhook_body(
body: &[u8],
) -> CustomResult<inespay::InespayWebhookEventData, errors::ConnectorError> {
let notif_item: inespay::InespayWebhookEvent =
serde_urlencoded::from_bytes::<inespay::InespayWebhookEvent>(body)
.change_context(errors::ConnectorError::WebhookBodyDecodingFailed)?;
let encoded_data_return = notif_item.data_return;
let decoded_data_return = BASE64_ENGINE
.decode(encoded_data_return)
.change_context(errors::ConnectorError::WebhookBodyDecodingFailed)?;
let data_return: inespay::InespayWebhookEventData = decoded_data_return
.parse_struct("inespay InespayWebhookEventData")
.change_context(errors::ConnectorError::WebhookBodyDecodingFailed)?;
Ok(data_return)
}
<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);
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/hyperswitch_connectors/src/connectors/nuvei/transformers.rs<|crate|> hyperswitch_connectors<|connector|> nuvei 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/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="1806" end="1806">
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 hyperswitch_interfaces::{
consts::{NO_ERROR_CODE, NO_ERROR_MESSAGE},
errors,
};
<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="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="1541" end="1567">
fn build_error_response<T>(
response: &NuveiPaymentsResponse,
http_code: u16,
) -> Option<Result<T, ErrorResponse>> {
match response.status {
NuveiPaymentStatus::Error => Some(
get_error_response(response.err_code, &response.reason, http_code).map_err(|err| *err),
),
_ => {
let err = Some(
get_error_response(response.gw_error_code, &response.gw_error_reason, http_code)
.map_err(|err| *err),
);
match response.transaction_status {
Some(NuveiTransactionStatus::Error) | Some(NuveiTransactionStatus::Declined) => err,
_ => match response
.gw_error_reason
.as_ref()
.map(|r| r.eq("Missing argument"))
{
Some(true) => err,
_ => None,
},
}
}
}
}
<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/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/aci/transformers.rs<|crate|> hyperswitch_connectors<|connector|> aci anchor=get_instruction_details kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=1<|meta_end|>
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/aci/transformers.rs" role="context" start="588" end="607">
fn get_instruction_details(
item: &AciRouterData<&PaymentsAuthorizeRouterData>,
) -> Option<Instruction> {
if item.router_data.request.setup_mandate_details.is_some() {
return Some(Instruction {
mode: InstructionMode::Initial,
transaction_type: InstructionType::Unscheduled,
source: InstructionSource::CardholderInitiatedTransaction,
create_registration: Some(true),
});
} else if item.router_data.request.mandate_id.is_some() {
return Some(Instruction {
mode: InstructionMode::Repeated,
transaction_type: InstructionType::Unscheduled,
source: InstructionSource::MerchantInitiatedTransaction,
create_registration: None,
});
}
None
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/aci/transformers.rs" role="context" start="587" end="587">
use common_utils::{id_type, pii::Email, request::Method, types::StringMajorUnit};
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},
};
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/aci/transformers.rs" role="context" start="632" end="639">
fn from(item: AciPaymentStatus) -> Self {
match item {
AciPaymentStatus::Succeeded => Self::Charged,
AciPaymentStatus::Failed => Self::Failure,
AciPaymentStatus::Pending => Self::Authorizing,
AciPaymentStatus::RedirectShopper => Self::AuthenticationPending,
}
}
<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="576" end="586">
fn get_transaction_details(
item: &AciRouterData<&PaymentsAuthorizeRouterData>,
) -> Result<TransactionDetails, error_stack::Report<errors::ConnectorError>> {
let auth = AciAuthType::try_from(&item.router_data.connector_auth_type)?;
Ok(TransactionDetails {
entity_id: auth.entity_id,
amount: item.amount.to_owned(),
currency: item.router_data.request.currency.to_string(),
payment_type: AciPaymentType::Debit,
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/aci/transformers.rs" role="context" start="557" end="573">
fn try_from(
value: (
&AciRouterData<&PaymentsAuthorizeRouterData>,
api_models::payments::MandateIds,
),
) -> Result<Self, Self::Error> {
let (item, _mandate_data) = value;
let instruction = get_instruction_details(item);
let txn_details = get_transaction_details(item)?;
Ok(Self {
txn_details,
payment_method: PaymentDetails::Mandate,
instruction,
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="532" end="547">
fn try_from(
value: (&AciRouterData<&PaymentsAuthorizeRouterData>, &Card),
) -> Result<Self, Self::Error> {
let (item, card_data) = value;
let card_holder_name = item.router_data.get_optional_billing_full_name();
let txn_details = get_transaction_details(item)?;
let payment_method = PaymentDetails::try_from((card_data.clone(), card_holder_name))?;
let instruction = get_instruction_details(item);
Ok(Self {
txn_details,
payment_method,
instruction,
shopper_result_url: None,
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/aci/transformers.rs" role="context" start="389" end="400">
pub struct Instruction {
#[serde(rename = "standingInstruction.mode")]
mode: InstructionMode,
#[serde(rename = "standingInstruction.type")]
transaction_type: InstructionType,
#[serde(rename = "standingInstruction.source")]
source: InstructionSource,
create_registration: Option<bool>,
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/aci/transformers.rs" role="context" start="380" end="385">
pub enum InstructionSource {
#[serde(rename = "CIT")]
CardholderInitiatedTransaction,
#[serde(rename = "MIT")]
MerchantInitiatedTransaction,
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/aci/transformers.rs" role="context" start="29" end="32">
pub struct AciRouterData<T> {
amount: StringMajorUnit,
router_data: T,
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/hyperswitch_connectors/src/connectors/bankofamerica/transformers.rs<|crate|> hyperswitch_connectors<|connector|> bankofamerica anchor=get_boa_mandate_action_details 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="2668" end="2688">
fn get_boa_mandate_action_details() -> (
Option<Vec<BankOfAmericaActionsList>>,
Option<Vec<BankOfAmericaActionsTokenType>>,
Option<BankOfAmericaAuthorizationOptions>,
) {
(
Some(vec![BankOfAmericaActionsList::TokenCreate]),
Some(vec![
BankOfAmericaActionsTokenType::PaymentInstrument,
BankOfAmericaActionsTokenType::Customer,
]),
Some(BankOfAmericaAuthorizationOptions {
initiator: Some(BankOfAmericaPaymentInitiator {
initiator_type: Some(BankOfAmericaPaymentInitiatorTypes::Customer),
credential_stored_on_file: Some(true),
stored_credential_used: None,
}),
merchant_intitiated_transaction: None,
}),
)
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/bankofamerica/transformers.rs" role="context" start="2704" end="2729">
pub fn get_error_reason(
error_info: Option<String>,
detailed_error_info: Option<String>,
avs_error_info: Option<String>,
) -> Option<String> {
match (error_info, detailed_error_info, avs_error_info) {
(Some(message), Some(details), Some(avs_message)) => Some(format!(
"{}, detailed_error_information: {}, avs_message: {}",
message, details, avs_message
)),
(Some(message), Some(details), None) => Some(format!(
"{}, detailed_error_information: {}",
message, details
)),
(Some(message), None, Some(avs_message)) => {
Some(format!("{}, avs_message: {}", message, avs_message))
}
(None, Some(details), Some(avs_message)) => {
Some(format!("{}, avs_message: {}", details, avs_message))
}
(Some(message), None, None) => Some(message),
(None, Some(details), None) => Some(details),
(None, None, Some(avs_message)) => Some(avs_message),
(None, None, None) => None,
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/bankofamerica/transformers.rs" role="context" start="2690" end="2702">
fn get_commerce_indicator(network: Option<String>) -> String {
match network {
Some(card_network) => match card_network.to_lowercase().as_str() {
"amex" => "aesk",
"discover" => "dipb",
"mastercard" => "spa",
"visa" => "internet",
_ => "internet",
},
None => "internet",
}
.to_string()
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/bankofamerica/transformers.rs" role="context" start="2625" end="2666">
fn convert_to_error_response_from_error_info(
error_response: &BankOfAmericaErrorInformationResponse,
status_code: u16,
) -> ErrorResponse {
let detailed_error_info =
error_response
.error_information
.to_owned()
.details
.map(|error_details| {
error_details
.iter()
.map(|details| format!("{} : {}", details.field, details.reason))
.collect::<Vec<_>>()
.join(", ")
});
let reason = get_error_reason(
error_response.error_information.message.to_owned(),
detailed_error_info,
None,
);
ErrorResponse {
code: error_response
.error_information
.reason
.clone()
.unwrap_or(hyperswitch_interfaces::consts::NO_ERROR_CODE.to_string()),
message: error_response
.error_information
.reason
.clone()
.unwrap_or(hyperswitch_interfaces::consts::NO_ERROR_MESSAGE.to_string()),
reason,
status_code,
attempt_status: None,
connector_transaction_id: Some(error_response.id.clone()),
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/bankofamerica/transformers.rs" role="context" start="2613" end="2622">
fn from(google_pay_data: &GooglePayWalletData) -> Self {
Self::GooglePay(Box::new(GooglePayPaymentInformation {
fluid_data: FluidData {
value: Secret::from(
consts::BASE64_ENGINE.encode(google_pay_data.tokenization_data.token.clone()),
),
descriptor: None,
},
}))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/bankofamerica/transformers.rs" role="context" start="620" end="682">
fn try_from(
(item, solution, network): (
&BankOfAmericaRouterData<&PaymentsAuthorizeRouterData>,
Option<PaymentSolution>,
Option<String>,
),
) -> Result<Self, Self::Error> {
let (action_list, action_token_types, authorization_options) =
if item.router_data.request.setup_future_usage == Some(FutureUsage::OffSession)
&& (item.router_data.request.customer_acceptance.is_some()
|| item
.router_data
.request
.setup_mandate_details
.clone()
.is_some_and(|mandate_details| {
mandate_details.customer_acceptance.is_some()
}))
{
get_boa_mandate_action_details()
} else if item.router_data.request.connector_mandate_id().is_some() {
let original_amount = item
.router_data
.get_recurring_mandate_payment_data()?
.get_original_payment_amount()?;
let original_currency = item
.router_data
.get_recurring_mandate_payment_data()?
.get_original_payment_currency()?;
(
None,
None,
Some(BankOfAmericaAuthorizationOptions {
initiator: None,
merchant_intitiated_transaction: Some(MerchantInitiatedTransaction {
reason: None,
original_authorized_amount: Some(utils::get_amount_as_string(
&api::CurrencyUnit::Base,
original_amount,
original_currency,
)?),
}),
}),
)
} else {
(None, None, None)
};
let commerce_indicator = get_commerce_indicator(network);
Ok(Self {
capture: Some(matches!(
item.router_data.request.capture_method,
Some(enums::CaptureMethod::Automatic) | None
)),
payment_solution: solution.map(String::from),
action_list,
action_token_types,
authorization_options,
capture_options: None,
commerce_indicator,
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/bankofamerica/transformers.rs" role="context" start="2518" end="2534">
fn try_from(
(solution, network): (Option<PaymentSolution>, Option<String>),
) -> Result<Self, Self::Error> {
let (action_list, action_token_types, authorization_options) =
get_boa_mandate_action_details();
let commerce_indicator = get_commerce_indicator(network);
Ok(Self {
capture: Some(false),
capture_options: None,
action_list,
action_token_types,
authorization_options,
commerce_indicator,
payment_solution: solution.map(String::from),
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/bankofamerica/transformers.rs" role="context" start="146" end="148">
pub enum BankOfAmericaPaymentInitiatorTypes {
Customer,
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/bankofamerica/transformers.rs" role="context" start="137" end="142">
pub struct BankOfAmericaPaymentInitiator {
#[serde(rename = "type")]
initiator_type: Option<BankOfAmericaPaymentInitiatorTypes>,
credential_stored_on_file: Option<bool>,
stored_credential_used: Option<bool>,
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/worldpay/requests.rs" role="context" start="176" end="181">
pub struct Customer {
#[serde(skip_serializing_if = "Option::is_none")]
pub risk_profile: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub authentication: Option<CustomerAuthentication>,
}
<file_sep path="hyperswitch/v2_compatible_migrations/2024-08-28-081721_add_v2_columns/up.sql" role="context" start="1" end="11">
-- This file contains all new columns being added as part of v2 refactoring.
-- The new columns added should work with both v1 and v2 applications.
ALTER TABLE customers
ADD COLUMN IF NOT EXISTS merchant_reference_id VARCHAR(64),
ADD COLUMN IF NOT EXISTS default_billing_address BYTEA DEFAULT NULL,
ADD COLUMN IF NOT EXISTS default_shipping_address BYTEA DEFAULT NULL,
ADD COLUMN IF NOT EXISTS status "DeleteStatus";
CREATE TYPE "OrderFulfillmentTimeOrigin" AS ENUM ('create', 'confirm');
ALTER TABLE business_profile
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/hyperswitch_connectors/src/connectors/square.rs<|crate|> hyperswitch_connectors<|connector|> square anchor=build_request kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<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="551" end="551">
fn get_url(
&self,
req: &PaymentsCaptureRouterData,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
Ok(format!(
"{}v2/payments/{}/complete",
self.base_url(connectors),
req.request.connector_transaction_id,
))
}
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()
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/square.rs" role="context" start="596" end="602">
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="575" end="594">
fn handle_response(
&self,
data: &PaymentsCaptureRouterData,
event_builder: Option<&mut ConnectorEvent>,
res: Response,
) -> CustomResult<PaymentsCaptureRouterData, errors::ConnectorError> {
let response: square::SquarePaymentsResponse = res
.response
.parse_struct("SquarePaymentsCaptureResponse")
.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="540" end="550">
fn get_url(
&self,
req: &PaymentsCaptureRouterData,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
Ok(format!(
"{}v2/payments/{}/complete",
self.base_url(connectors),
req.request.connector_transaction_id,
))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/square.rs" role="context" start="536" end="538">
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="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="63" end="63">
pub struct Square;
<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/migrations/2023-07-07-091223_create_captures_table/up.sql" role="context" start="1" end="17">
CREATE TYPE "CaptureStatus" AS ENUM (
'started',
'charged',
'pending',
'failed'
);
ALTER TYPE "IntentStatus" ADD VALUE If NOT EXISTS 'partially_captured' AFTER 'requires_capture';
CREATE TABLE captures(
capture_id VARCHAR(64) NOT NULL PRIMARY KEY,
payment_id VARCHAR(64) NOT NULL,
merchant_id VARCHAR(64) NOT NULL,
status "CaptureStatus" NOT NULL,
amount BIGINT NOT NULL,
currency "Currency",
connector VARCHAR(255),
error_message VARCHAR(255),
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/hyperswitch_connectors/src/connectors/cashtocode.rs<|crate|> hyperswitch_connectors<|connector|> cashtocode 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/cashtocode.rs" role="context" start="197" end="218">
fn get_headers(
&self,
req: &PaymentsAuthorizeRouterData,
_connectors: &Connectors,
) -> CustomResult<Vec<(String, masking::Maskable<String>)>, errors::ConnectorError> {
let mut header = vec![(
headers::CONTENT_TYPE.to_string(),
PaymentsAuthorizeType::get_content_type(self)
.to_owned()
.into(),
)];
let auth_type = transformers::CashtocodeAuth::try_from((
&req.connector_auth_type,
&req.request.currency,
))?;
let mut api_key = get_b64_auth_cashtocode(req.request.payment_method_type, &auth_type)?;
header.append(&mut api_key);
Ok(header)
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/cashtocode.rs" role="context" start="196" end="196">
use common_utils::{
errors::CustomResult,
ext_traits::ByteSliceExt,
request::{Method, Request, RequestBuilder, RequestContent},
types::{AmountConvertor, FloatMajorUnit, FloatMajorUnitForConnector},
};
use hyperswitch_domain_models::{
api::ApplicationResponse,
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, PaymentsSyncRouterData},
};
use hyperswitch_interfaces::{
api::{
self, ConnectorCommon, ConnectorCommonExt, ConnectorIntegration, ConnectorSpecifications,
ConnectorValidation,
},
configs::Connectors,
errors,
events::connector_api_logs::ConnectorEvent,
types::{PaymentsAuthorizeType, Response},
webhooks::{self, IncomingWebhookFlowError},
};
use masking::{Mask, PeekInterface, Secret};
use transformers as cashtocode;
use crate::{constants::headers, types::ResponseRouterData, utils};
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/cashtocode.rs" role="context" start="224" end="233">
fn get_url(
&self,
_req: &PaymentsAuthorizeRouterData,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
Ok(format!(
"{}/merchant/paytokens",
connectors.cashtocode.base_url
))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/cashtocode.rs" role="context" start="220" end="222">
fn get_content_type(&self) -> &'static str {
self.common_get_content_type()
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/cashtocode.rs" role="context" start="184" end="193">
fn build_request(
&self,
_req: &RouterData<SetupMandate, SetupMandateRequestData, PaymentsResponseData>,
_connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Err(
errors::ConnectorError::NotImplemented("Setup Mandate flow for Cashtocode".to_string())
.into(),
)
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/cashtocode.rs" role="context" start="157" end="172">
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(
utils::construct_not_supported_error_report(capture_method, self.id()),
),
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/cashtocode.rs" role="context" start="249" end="265">
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/cashtocode.rs" role="context" start="69" end="103">
fn get_b64_auth_cashtocode(
payment_method_type: Option<enums::PaymentMethodType>,
auth_type: &transformers::CashtocodeAuth,
) -> CustomResult<Vec<(String, masking::Maskable<String>)>, errors::ConnectorError> {
fn construct_basic_auth(
username: Option<Secret<String>>,
password: Option<Secret<String>>,
) -> Result<masking::Maskable<String>, errors::ConnectorError> {
let username = username.ok_or(errors::ConnectorError::FailedToObtainAuthType)?;
let password = password.ok_or(errors::ConnectorError::FailedToObtainAuthType)?;
Ok(format!(
"Basic {}",
base64::engine::general_purpose::STANDARD.encode(format!(
"{}:{}",
username.peek(),
password.peek()
))
)
.into_masked())
}
let auth_header = match payment_method_type {
Some(enums::PaymentMethodType::ClassicReward) => construct_basic_auth(
auth_type.username_classic.to_owned(),
auth_type.password_classic.to_owned(),
),
Some(enums::PaymentMethodType::Evoucher) => construct_basic_auth(
auth_type.username_evoucher.to_owned(),
auth_type.password_evoucher.to_owned(),
),
_ => return Err(errors::ConnectorError::MissingPaymentMethodType)?,
}?;
Ok(vec![(headers::AUTHORIZATION.to_string(), auth_header)])
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/cashtocode/transformers.rs" role="context" start="96" end="103">
pub struct CashtocodeAuth {
pub password_classic: Option<Secret<String>>,
pub password_evoucher: Option<Secret<String>>,
pub username_classic: Option<Secret<String>>,
pub username_evoucher: Option<Secret<String>>,
pub merchant_id_classic: Option<Secret<String>>,
pub merchant_id_evoucher: Option<Secret<String>>,
}
|
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="324" end="340">
fn get_request_body(
&self,
req: &PaymentsCaptureRouterData,
_connectors: &Connectors,
) -> CustomResult<RequestContent, errors::ConnectorError> {
let amount = utils::convert_amount(
self.amount_converter,
req.request.minor_amount_to_capture,
req.request.currency,
)?;
let connector_router_data = elavon::ElavonRouterData::from((amount, req));
let connector_req = elavon::PaymentsCaptureRequest::try_from(&connector_router_data)?;
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="323" end="323">
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;
use crate::{constants::headers, types::ResponseRouterData, utils};
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/elavon.rs" role="context" start="362" end="377">
fn handle_response(
&self,
data: &PaymentsCaptureRouterData,
event_builder: Option<&mut ConnectorEvent>,
res: Response,
) -> CustomResult<PaymentsCaptureRouterData, errors::ConnectorError> {
let response: elavon::ElavonPaymentsResponse =
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="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="316" end="322">
fn get_url(
&self,
_req: &PaymentsCaptureRouterData,
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="312" end="314">
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="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="28" end="31">
pub struct ElavonRouterData<T> {
pub amount: StringMajorUnit,
pub router_data: T,
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/hyperswitch_connectors/src/connectors/wellsfargo/transformers.rs<|crate|> hyperswitch_connectors<|connector|> wellsfargo 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/wellsfargo/transformers.rs" role="context" start="2159" end="2182">
fn try_from(
item: RefundsResponseRouterData<Execute, WellsfargoRefundResponse>,
) -> Result<Self, Self::Error> {
let refund_status = enums::RefundStatus::from(item.response.status.clone());
let response = if utils::is_refund_failure(refund_status) {
Err(get_error_response(
&item.response.error_information,
&None,
None,
item.http_code,
item.response.id.clone(),
))
} else {
Ok(RefundsResponseData {
connector_refund_id: item.response.id,
refund_status: enums::RefundStatus::from(item.response.status),
})
};
Ok(Self {
response,
..item.data
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/wellsfargo/transformers.rs" role="context" start="2158" end="2158">
use common_enums::{enums, FutureUsage};
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,
},
};
use crate::{
constants,
types::{RefundsResponseRouterData, ResponseRouterData},
unimplemented_payment_method,
utils::{
self, AddressDetailsData, ApplePayDecrypt, CardData, PaymentsAuthorizeRequestData,
PaymentsSetupMandateRequestData, PaymentsSyncRequestData, RecurringMandateData,
RouterData as OtherRouterData,
},
};
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/wellsfargo/transformers.rs" role="context" start="2332" end="2388">
pub fn get_error_response(
error_data: &Option<WellsfargoErrorInformation>,
risk_information: &Option<ClientRiskInformation>,
attempt_status: Option<enums::AttemptStatus>,
status_code: u16,
transaction_id: String,
) -> ErrorResponse {
let avs_message = risk_information
.clone()
.map(|client_risk_information| {
client_risk_information.rules.map(|rules| {
rules
.iter()
.map(|risk_info| {
risk_info.name.clone().map_or("".to_string(), |name| {
format!(" , {}", name.clone().expose())
})
})
.collect::<Vec<String>>()
.join("")
})
})
.unwrap_or(Some("".to_string()));
let detailed_error_info = error_data
.clone()
.map(|error_data| match error_data.details {
Some(details) => details
.iter()
.map(|details| format!("{} : {}", details.field, details.reason))
.collect::<Vec<_>>()
.join(", "),
None => "".to_string(),
});
let reason = get_error_reason(
error_data.clone().and_then(|error_info| error_info.message),
detailed_error_info,
avs_message,
);
let error_message = error_data.clone().and_then(|error_info| error_info.reason);
ErrorResponse {
code: error_message
.clone()
.unwrap_or(hyperswitch_interfaces::consts::NO_ERROR_CODE.to_string()),
message: error_message
.clone()
.unwrap_or(hyperswitch_interfaces::consts::NO_ERROR_MESSAGE.to_string()),
reason,
status_code,
attempt_status,
connector_transaction_id: Some(transaction_id.clone()),
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/wellsfargo/transformers.rs" role="context" start="2203" end="2256">
fn try_from(
item: RefundsResponseRouterData<RSync, WellsfargoRsyncResponse>,
) -> Result<Self, Self::Error> {
let response = match item
.response
.application_information
.and_then(|application_information| application_information.status)
{
Some(status) => {
let refund_status = enums::RefundStatus::from(status.clone());
if utils::is_refund_failure(refund_status) {
if status == WellsfargoRefundStatus::Voided {
Err(get_error_response(
&Some(WellsfargoErrorInformation {
message: Some(constants::REFUND_VOIDED.to_string()),
reason: Some(constants::REFUND_VOIDED.to_string()),
details: None,
}),
&None,
None,
item.http_code,
item.response.id.clone(),
))
} else {
Err(get_error_response(
&item.response.error_information,
&None,
None,
item.http_code,
item.response.id.clone(),
))
}
} else {
Ok(RefundsResponseData {
connector_refund_id: item.response.id,
refund_status,
})
}
}
None => Ok(RefundsResponseData {
connector_refund_id: item.response.id.clone(),
refund_status: match item.data.response {
Ok(response) => response.refund_status,
Err(_) => common_enums::RefundStatus::Pending,
},
}),
};
Ok(Self {
response,
..item.data
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/wellsfargo/transformers.rs" role="context" start="2123" end="2133">
fn from(item: WellsfargoRefundStatus) -> Self {
match item {
WellsfargoRefundStatus::Succeeded | WellsfargoRefundStatus::Transmitted => {
Self::Success
}
WellsfargoRefundStatus::Cancelled
| WellsfargoRefundStatus::Failed
| WellsfargoRefundStatus::Voided => Self::Failure,
WellsfargoRefundStatus::Pending => Self::Pending,
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/wellsfargo/transformers.rs" role="context" start="2107" end="2119">
fn try_from(item: &WellsfargoRouterData<&RefundsRouterData<F>>) -> Result<Self, Self::Error> {
Ok(Self {
order_information: OrderInformation {
amount_details: Amount {
total_amount: item.amount.clone(),
currency: item.router_data.request.currency,
},
},
client_reference_information: ClientReferenceInformation {
code: Some(item.router_data.request.refund_id.clone()),
},
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/wellsfargo/transformers.rs" role="context" start="72" end="72">
type Error = error_stack::Report<errors::ConnectorError>;
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/wellsfargo/transformers.rs" role="context" start="2149" end="2153">
pub struct WellsfargoRefundResponse {
id: String,
status: WellsfargoRefundStatus,
error_information: Option<WellsfargoErrorInformation>,
}
<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/cybersource/transformers.rs<|crate|> hyperswitch_connectors<|connector|> cybersource 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/cybersource/transformers.rs" role="context" start="3778" end="3801">
fn try_from(
item: RefundsResponseRouterData<Execute, CybersourceRefundResponse>,
) -> Result<Self, Self::Error> {
let refund_status = enums::RefundStatus::from(item.response.status.clone());
let response = if utils::is_refund_failure(refund_status) {
Err(get_error_response(
&item.response.error_information,
&None,
None,
item.http_code,
item.response.id.clone(),
))
} else {
Ok(RefundsResponseData {
connector_refund_id: item.response.id,
refund_status: enums::RefundStatus::from(item.response.status),
})
};
Ok(Self {
response,
..item.data
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/cybersource/transformers.rs" role="context" start="3777" end="3777">
#[derive(Debug, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct CybersourceRefundResponse {
id: String,
status: CybersourceRefundStatus,
error_information: Option<CybersourceErrorInformation>,
}
impl TryFrom<RefundsResponseRouterData<Execute, CybersourceRefundResponse>>
for RefundsRouterData<Execute>
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: RefundsResponseRouterData<Execute, CybersourceRefundResponse>,
) -> Result<Self, Self::Error> {
let refund_status = enums::RefundStatus::from(item.response.status.clone());
let response = if utils::is_refund_failure(refund_status) {
Err(get_error_response(
&item.response.error_information,
&None,
None,
item.http_code,
item.response.id.clone(),
))
} else {
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/cybersource/transformers.rs" role="context" start="3947" end="3999">
fn try_from(
item: &CybersourceRouterData<&PayoutsRouterData<PoFulfill>>,
) -> Result<Self, Self::Error> {
let payout_type = item.router_data.request.get_payout_type()?;
match payout_type {
enums::PayoutType::Card => {
let client_reference_information = ClientReferenceInformation {
code: Some(item.router_data.request.payout_id.clone()),
};
let order_information = OrderInformation {
amount_details: Amount {
total_amount: item.amount.to_owned(),
currency: item.router_data.request.destination_currency,
},
};
let billing_address = item.router_data.get_billing_address()?;
let phone_address = item.router_data.get_billing_phone()?;
let recipient_information =
CybersourceRecipientInfo::try_from((billing_address, phone_address))?;
let sender_information = CybersourceSenderInfo {
reference_number: item.router_data.request.payout_id.clone(),
account: CybersourceAccountInfo {
funds_source: CybersourcePayoutFundSourceType::Disbursement,
},
};
let processing_information = CybersourceProcessingInfo {
business_application_id: CybersourcePayoutBusinessType::PersonToPerson, // this means sender and receiver are different
};
let payout_method_data = item.router_data.get_payout_method_data()?;
let payment_information = PaymentInformation::try_from(payout_method_data)?;
Ok(Self {
client_reference_information,
order_information,
recipient_information,
sender_information,
processing_information,
payment_information,
})
}
enums::PayoutType::Bank | enums::PayoutType::Wallet => {
Err(errors::ConnectorError::NotSupported {
message: "PayoutType is not supported".to_string(),
connector: "Cybersource",
})?
}
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/cybersource/transformers.rs" role="context" start="3822" end="3875">
fn try_from(
item: RefundsResponseRouterData<RSync, CybersourceRsyncResponse>,
) -> Result<Self, Self::Error> {
let response = match item
.response
.application_information
.and_then(|application_information| application_information.status)
{
Some(status) => {
let refund_status = enums::RefundStatus::from(status.clone());
if utils::is_refund_failure(refund_status) {
if status == CybersourceRefundStatus::Voided {
Err(get_error_response(
&Some(CybersourceErrorInformation {
message: Some(constants::REFUND_VOIDED.to_string()),
reason: Some(constants::REFUND_VOIDED.to_string()),
details: None,
}),
&None,
None,
item.http_code,
item.response.id.clone(),
))
} else {
Err(get_error_response(
&item.response.error_information,
&None,
None,
item.http_code,
item.response.id.clone(),
))
}
} else {
Ok(RefundsResponseData {
connector_refund_id: item.response.id,
refund_status,
})
}
}
None => Ok(RefundsResponseData {
connector_refund_id: item.response.id.clone(),
refund_status: match item.data.response {
Ok(response) => response.refund_status,
Err(_) => common_enums::RefundStatus::Pending,
},
}),
};
Ok(Self {
response,
..item.data
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/cybersource/transformers.rs" role="context" start="3742" end="3752">
fn from(item: CybersourceRefundStatus) -> Self {
match item {
CybersourceRefundStatus::Succeeded | CybersourceRefundStatus::Transmitted => {
Self::Success
}
CybersourceRefundStatus::Cancelled
| CybersourceRefundStatus::Failed
| CybersourceRefundStatus::Voided => Self::Failure,
CybersourceRefundStatus::Pending => Self::Pending,
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/cybersource/transformers.rs" role="context" start="3726" end="3738">
fn try_from(item: &CybersourceRouterData<&RefundsRouterData<F>>) -> Result<Self, Self::Error> {
Ok(Self {
order_information: OrderInformation {
amount_details: Amount {
total_amount: item.amount.clone(),
currency: item.router_data.request.currency,
},
},
client_reference_information: ClientReferenceInformation {
code: Some(item.router_data.request.refund_id.clone()),
},
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/cybersource/transformers.rs" role="context" start="4181" end="4241">
pub fn get_error_response(
error_data: &Option<CybersourceErrorInformation>,
risk_information: &Option<ClientRiskInformation>,
attempt_status: Option<enums::AttemptStatus>,
status_code: u16,
transaction_id: String,
) -> ErrorResponse {
let avs_message = risk_information
.clone()
.map(|client_risk_information| {
client_risk_information.rules.map(|rules| {
rules
.iter()
.map(|risk_info| {
risk_info.name.clone().map_or("".to_string(), |name| {
format!(" , {}", name.clone().expose())
})
})
.collect::<Vec<String>>()
.join("")
})
})
.unwrap_or(Some("".to_string()));
let detailed_error_info = error_data.as_ref().and_then(|error_data| {
error_data.details.as_ref().map(|details| {
details
.iter()
.map(|detail| format!("{} : {}", detail.field, detail.reason))
.collect::<Vec<_>>()
.join(", ")
})
});
let reason = get_error_reason(
error_data
.as_ref()
.and_then(|error_info| error_info.message.clone()),
detailed_error_info,
avs_message,
);
let error_message = error_data
.as_ref()
.and_then(|error_info| error_info.reason.clone());
ErrorResponse {
code: error_message
.clone()
.unwrap_or_else(|| hyperswitch_interfaces::consts::NO_ERROR_CODE.to_string()),
message: error_message
.unwrap_or_else(|| hyperswitch_interfaces::consts::NO_ERROR_MESSAGE.to_string()),
reason,
status_code,
attempt_status,
connector_transaction_id: Some(transaction_id),
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/cybersource/transformers.rs" role="context" start="109" end="109">
type Error = error_stack::Report<errors::ConnectorError>;
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/cybersource/transformers.rs" role="context" start="3768" end="3772">
pub struct CybersourceRefundResponse {
id: String,
status: CybersourceRefundStatus,
error_information: Option<CybersourceErrorInformation>,
}
<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/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/redsys/transformers.rs<|crate|> hyperswitch_connectors<|connector|> redsys anchor=try_from kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=1<|meta_end|>
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/redsys/transformers.rs" role="context" start="851" end="863">
fn try_from(data: (&T, &RedsysAuthType)) -> Result<Self, Self::Error> {
let (request_data, auth) = data;
let merchant_parameters = request_data.get_merchant_parameters()?;
let ds_merchant_parameters = BASE64_ENGINE.encode(&merchant_parameters);
let sha256_pwd = auth.sha256_pwd.clone().expose();
let ds_merchant_order = request_data.get_order_id();
let signature = get_signature(&ds_merchant_order, &ds_merchant_parameters, &sha256_pwd)?;
Ok(Self {
ds_signature_version: SIGNATURE_VERSION.to_string(),
ds_merchant_parameters: Secret::new(ds_merchant_parameters),
ds_signature: Secret::new(signature),
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/redsys/transformers.rs" role="context" start="850" end="850">
use common_utils::{
consts::BASE64_ENGINE,
crypto::{EncodeMessage, SignMessage},
ext_traits::{Encode, ValueExt},
types::StringMinorUnit,
};
use masking::{ExposeInterface, PeekInterface, Secret};
type Error = error_stack::Report<errors::ConnectorError>;
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/redsys/transformers.rs" role="context" start="896" end="945">
fn try_from(
item: &RedsysRouterData<&PaymentsAuthorizeRouterData>,
) -> Result<Self, Self::Error> {
if !item.router_data.is_three_ds() {
Err(errors::ConnectorError::NotSupported {
message: "No-3DS cards".to_string(),
connector: "redsys",
})?
};
let auth = RedsysAuthType::try_from(&item.router_data.connector_auth_type)?;
let ds_merchant_transactiontype = if item.router_data.request.is_auto_capture()? {
RedsysTransactionType::Payment
} else {
RedsysTransactionType::Preauthorization
};
let card_data =
RedsysCardData::try_from(&Some(item.router_data.request.payment_method_data.clone()))?;
let (connector_meta_data, ds_merchant_order) = match &item.router_data.response {
Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(order_id),
connector_metadata,
..
}) => (connector_metadata.clone(), order_id.clone()),
_ => Err(errors::ConnectorError::ResponseHandlingFailed)?,
};
let threeds_meta_data =
connector_utils::to_connector_meta::<ThreeDsInvokeExempt>(connector_meta_data.clone())?;
let emv3ds_data = EmvThreedsData::new(RedsysThreeDsInfo::AuthenticationData)
.set_three_d_s_server_trans_i_d(threeds_meta_data.three_d_s_server_trans_i_d)
.set_protocol_version(threeds_meta_data.message_version)
.set_notification_u_r_l(item.router_data.request.get_complete_authorize_url()?)
.add_browser_data(item.router_data.request.get_browser_info()?)?
.set_three_d_s_comp_ind(ThreeDSCompInd::N)
.set_billing_data(item.router_data.get_optional_billing())?
.set_shipping_data(item.router_data.get_optional_shipping())?;
let payment_authorize_request = PaymentsRequest {
ds_merchant_emv3ds: Some(emv3ds_data),
ds_merchant_transactiontype,
ds_merchant_currency: item.currency.iso_4217().to_owned(),
ds_merchant_pan: card_data.card_number,
ds_merchant_merchantcode: auth.merchant_id.clone(),
ds_merchant_terminal: auth.terminal_id.clone(),
ds_merchant_order,
ds_merchant_amount: item.amount.clone(),
ds_merchant_expirydate: card_data.expiry_date,
ds_merchant_cvv2: card_data.cvv2,
};
Self::try_from((&payment_authorize_request, &auth))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/redsys/transformers.rs" role="context" start="866" end="892">
fn get_redsys_attempt_status(
ds_response: DsResponse,
capture_method: Option<enums::CaptureMethod>,
) -> Result<enums::AttemptStatus, error_stack::Report<errors::ConnectorError>> {
// Redsys consistently provides a 4-digit response code, where numbers ranging from 0000 to 0099 indicate successful transactions
if ds_response.0.starts_with("00") {
match capture_method {
Some(enums::CaptureMethod::Automatic) | None => Ok(enums::AttemptStatus::Charged),
Some(enums::CaptureMethod::Manual) => Ok(enums::AttemptStatus::Authorized),
_ => Err(errors::ConnectorError::CaptureMethodNotSupported.into()),
}
} else {
match ds_response.0.as_str() {
"0900" => Ok(enums::AttemptStatus::Charged),
"0400" => Ok(enums::AttemptStatus::Voided),
"0950" => Ok(enums::AttemptStatus::VoidFailed),
"9998" => Ok(enums::AttemptStatus::AuthenticationPending),
"9256" | "9257" | "0184" => Ok(enums::AttemptStatus::AuthenticationFailed),
"0101" | "0102" | "0106" | "0125" | "0129" | "0172" | "0173" | "0174" | "0180"
| "0190" | "0191" | "0195" | "0202" | "0904" | "0909" | "0913" | "0944" | "9912"
| "0912" | "9064" | "9078" | "9093" | "9094" | "9104" | "9218" | "9253" | "9261"
| "9915" | "9997" | "9999" => Ok(enums::AttemptStatus::Failure),
error => Err(errors::ConnectorError::ResponseHandlingFailed)
.attach_printable(format!("Received Unknown Status:{}", error))?,
}
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/redsys/transformers.rs" role="context" start="841" end="843">
fn get_order_id(&self) -> String {
self.ds_merchant_order.clone()
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/redsys/transformers.rs" role="context" start="836" end="839">
fn get_merchant_parameters(&self) -> Result<String, Error> {
self.encode_to_string_of_json()
.change_context(errors::ConnectorError::RequestEncodingFailed)
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/redsys/transformers.rs" role="context" start="803" end="817">
fn get_signature(
order_id: &str,
params: &str,
key: &str,
) -> Result<String, error_stack::Report<errors::ConnectorError>> {
let secret_ko = des_encrypt(order_id, key)?;
let result = common_utils::crypto::HmacSha256::sign_message(
&common_utils::crypto::HmacSha256,
&secret_ko,
params.as_bytes(),
)
.map_err(|_| errors::ConnectorError::RequestEncodingFailed)?;
let encoded = BASE64_ENGINE.encode(result);
Ok(encoded)
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/redsys/transformers.rs" role="context" start="135" end="156">
pub fn new(three_d_s_info: RedsysThreeDsInfo) -> Self {
Self {
three_d_s_info,
protocol_version: None,
browser_accept_header: None,
browser_user_agent: None,
browser_java_enabled: None,
browser_java_script_enabled: None,
browser_language: None,
browser_color_depth: None,
browser_screen_height: None,
browser_screen_width: None,
browser_t_z: None,
browser_i_p: None,
three_d_s_server_trans_i_d: None,
notification_u_r_l: None,
three_d_s_comp_ind: None,
cres: None,
billing_data: None,
shipping_data: None,
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/redsys/transformers.rs" role="context" start="38" end="38">
type Error = error_stack::Report<errors::ConnectorError>;
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/redsys/transformers.rs" role="context" start="421" end="425">
pub struct RedsysAuthType {
pub(super) merchant_id: Secret<String>,
pub(super) terminal_id: Secret<String>,
pub(super) sha256_pwd: Secret<String>,
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/hyperswitch_connectors/src/connectors/itaubank/transformers.rs<|crate|> hyperswitch_connectors<|connector|> itaubank 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/itaubank/transformers.rs" role="context" start="277" end="295">
fn try_from(
item: ResponseRouterData<F, ItaubankPaymentsResponse, T, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
let connector_metadata = get_qr_code_data(&item.response)?;
Ok(Self {
status: enums::AttemptStatus::from(item.response.status),
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(item.response.txid.to_owned()),
redirection_data: Box::new(None),
mandate_reference: Box::new(None),
connector_metadata,
network_txn_id: None,
connector_response_reference_id: Some(item.response.txid),
incremental_authorization_allowed: None,
charges: None,
}),
..item.data
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/itaubank/transformers.rs" role="context" start="276" end="276">
use common_enums::enums;
use hyperswitch_domain_models::{
payment_method_data::{BankTransferData, PaymentMethodData},
router_data::{AccessToken, ConnectorAuthType, RouterData},
router_flow_types::refunds::{Execute, RSync},
router_request_types::ResponseId,
router_response_types::{PaymentsResponseData, RefundsResponseData},
types,
};
use crate::{
types::{RefundsResponseRouterData, ResponseRouterData},
utils::{get_timestamp_in_milliseconds, QrImage, RouterData as _},
};
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/itaubank/transformers.rs" role="context" start="344" end="374">
fn try_from(
item: ResponseRouterData<F, ItaubankPaymentsSyncResponse, T, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
let pix_data = item
.response
.pix
.first()
.ok_or(errors::ConnectorError::MissingRequiredField {
field_name: "pix_id",
})?
.to_owned();
let connector_metadata = Some(serde_json::json!(ItaubankMetaData {
pix_id: pix_data.pix_id
}));
Ok(Self {
status: enums::AttemptStatus::from(item.response.status),
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(item.response.txid.to_owned()),
redirection_data: Box::new(None),
mandate_reference: Box::new(None),
connector_metadata,
network_txn_id: None,
connector_response_reference_id: Some(item.response.txid),
incremental_authorization_allowed: None,
charges: None,
}),
..item.data
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/itaubank/transformers.rs" role="context" start="298" end="319">
fn get_qr_code_data(
response: &ItaubankPaymentsResponse,
) -> CustomResult<Option<serde_json::Value>, errors::ConnectorError> {
let creation_time = get_timestamp_in_milliseconds(&response.calendario.criacao);
// convert expiration to milliseconds and add to creation time
let expiration_time = creation_time + (response.calendario.expiracao * 1000);
let image_data = QrImage::new_from_data(response.pix_qr_value.clone())
.change_context(errors::ConnectorError::ResponseHandlingFailed)?;
let image_data_url = Url::parse(image_data.data.clone().as_str())
.change_context(errors::ConnectorError::ResponseHandlingFailed)?;
let qr_code_info = QrCodeInformation::QrDataUrl {
image_data_url,
display_to_timestamp: Some(expiration_time),
};
Some(qr_code_info.encode_to_value())
.transpose()
.change_context(errors::ConnectorError::ResponseHandlingFailed)
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/itaubank/transformers.rs" role="context" start="245" end="252">
fn from(item: ItaubankPaymentStatus) -> Self {
match item {
ItaubankPaymentStatus::Ativa => Self::AuthenticationPending,
ItaubankPaymentStatus::Concluida => Self::Charged,
ItaubankPaymentStatus::RemovidaPeloPsp
| ItaubankPaymentStatus::RemovidaPeloUsuarioRecebedor => Self::Failure,
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/itaubank/transformers.rs" role="context" start="222" end="232">
fn try_from(
item: ResponseRouterData<F, ItaubankUpdateTokenResponse, T, AccessToken>,
) -> Result<Self, Self::Error> {
Ok(Self {
response: Ok(AccessToken {
token: item.response.access_token,
expires: item.response.expires_in,
}),
..item.data
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/itaubank/transformers.rs" role="context" start="403" end="409">
fn from(item: RefundStatus) -> Self {
match item {
RefundStatus::Devolvido => Self::Success,
RefundStatus::NaoRealizado => Self::Failure,
RefundStatus::EmProcessamento => Self::Pending,
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/itaubank/transformers.rs" role="context" start="61" end="61">
type Error = error_stack::Report<errors::ConnectorError>;
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/itaubank/transformers.rs" role="context" start="257" end="263">
pub struct ItaubankPaymentsResponse {
status: ItaubankPaymentStatus,
calendario: ItaubankPixExpireTime,
txid: String,
#[serde(rename = "pixCopiaECola")]
pix_qr_value: String,
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/types.rs" role="context" start="53" end="57">
pub struct ResponseRouterData<Flow, R, Request, Response> {
pub response: R,
pub data: RouterData<Flow, Request, Response>,
pub http_code: u16,
}
|
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="419" end="436">
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 = elavon::ElavonRouterData::from((refund_amount, req));
let connector_req = elavon::ElavonRefundRequest::try_from(&connector_router_data)?;
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="418" end="418">
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;
use crate::{constants::headers, types::ResponseRouterData, utils};
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/elavon.rs" role="context" start="457" end="472">
fn handle_response(
&self,
data: &RefundsRouterData<Execute>,
event_builder: Option<&mut ConnectorEvent>,
res: Response,
) -> CustomResult<RefundsRouterData<Execute>, errors::ConnectorError> {
let response: elavon::ElavonPaymentsResponse =
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="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="411" end="417">
fn get_url(
&self,
_req: &RefundsRouterData<Execute>,
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="407" end="409">
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="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="28" end="31">
pub struct ElavonRouterData<T> {
pub amount: StringMajorUnit,
pub router_data: T,
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/hyperswitch_connectors/src/connectors/nomupay/transformers.rs<|crate|> hyperswitch_connectors<|connector|> nomupay 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/nomupay/transformers.rs" role="context" start="377" end="396">
fn try_from(item: &PayoutsRouterData<F>) -> Result<Self, Self::Error> {
let request = item.request.to_owned();
let payout_type = request.payout_type;
let profile = get_profile(item, request.entity_type)?;
let nomupay_auth_type = NomupayAuthType::try_from(&item.connector_auth_type)?;
match payout_type {
Some(common_enums::PayoutType::Bank) => Ok(Self {
account_id: nomupay_auth_type.eid,
client_sub_account_id: Secret::new(request.payout_id),
profile,
}),
_ => Err(errors::ConnectorError::NotImplemented(
"This payment method is not implemented for Nomupay".to_string(),
)
.into()),
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/nomupay/transformers.rs" role="context" start="376" end="376">
use common_enums::enums::PayoutEntityType;
use common_enums::{enums, Currency, PayoutStatus};
use hyperswitch_domain_models::{
router_response_types::PayoutsResponseData, types::PayoutsRouterData,
};
use masking::Secret;
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/nomupay/transformers.rs" role="context" start="426" end="462">
fn try_from(item: &PayoutsRouterData<F>) -> Result<Self, Self::Error> {
let payout_method_data = item.get_payout_method_data()?;
match payout_method_data {
api_models::payouts::PayoutMethodData::Bank(bank) => match bank {
api_models::payouts::Bank::Sepa(bank_details) => {
let bank_account = BankAccount {
bank_id: bank_details.bic,
account_id: bank_details.iban,
};
let country_iso2_code = item
.get_billing_country()
.unwrap_or(enums::CountryAlpha2::CA);
let profile = get_profile(item, item.request.entity_type)?;
Ok(Self {
country_code: country_iso2_code,
currency_code: item.request.destination_currency,
transfer_method_type: TransferMethodType::BankAccount,
display_name: item.get_billing_full_name()?,
bank_account,
profile,
})
}
other_bank => Err(errors::ConnectorError::NotSupported {
message: format!("{:?} is not supported", other_bank),
connector: "nomupay",
}
.into()),
},
_ => Err(errors::ConnectorError::NotImplemented(
"This payment method is not implemented for Nomupay".to_string(),
)
.into()),
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/nomupay/transformers.rs" role="context" start="403" end="419">
fn try_from(
item: PayoutsResponseRouterData<F, OnboardSubAccountResponse>,
) -> Result<Self, Self::Error> {
let response: OnboardSubAccountResponse = item.response;
Ok(Self {
response: Ok(PayoutsResponseData {
status: Some(PayoutStatus::RequiresVendorAccountCreation),
connector_payout_id: Some(response.id.to_string()),
payout_eligible: None,
should_add_next_step_to_process_tracker: false,
error_code: None,
error_message: None,
}),
..item.data
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/nomupay/transformers.rs" role="context" start="346" end="371">
fn get_profile<F>(
item: &PayoutsRouterData<F>,
entity_type: PayoutEntityType,
) -> Result<Profile, error_stack::Report<errors::ConnectorError>> {
let my_address = Address {
country: item.get_billing_country()?,
state_province: item.get_billing_state()?,
street: item.get_billing_line1()?,
city: item.get_billing_city()?,
postal_code: item.get_billing_zip()?,
};
Ok(Profile {
profile_type: ProfileType::from(entity_type),
first_name: item.get_billing_first_name()?,
last_name: item.get_billing_last_name()?,
date_of_birth: Secret::new("1991-01-01".to_string()), // Query raised with Nomupay regarding why this field is required
gender: NomupayGender::Other, // Query raised with Nomupay regarding why this field is required
email_address: item.get_billing_email()?,
phone_number_country_code: item
.get_billing_phone()
.map(|phone| phone.country_code.clone())?,
phone_number: Some(item.get_billing_phone_number()?),
address: my_address,
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/nomupay/transformers.rs" role="context" start="331" end="342">
fn from(item: NomupayPaymentStatus) -> Self {
match item {
NomupayPaymentStatus::Processed => Self::Success,
NomupayPaymentStatus::Failed => Self::Failed,
NomupayPaymentStatus::Processing
| NomupayPaymentStatus::Pending
| NomupayPaymentStatus::Scheduled
| NomupayPaymentStatus::PendingAccountActivation
| NomupayPaymentStatus::PendingTransferMethodCreation
| NomupayPaymentStatus::PendingAccountKyc => Self::Pending,
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/nomupay/transformers.rs" role="context" start="515" end="531">
fn try_from(
item: PayoutsResponseRouterData<F, NomupayPaymentResponse>,
) -> Result<Self, Self::Error> {
let response: NomupayPaymentResponse = item.response;
Ok(Self {
response: Ok(PayoutsResponseData {
status: Some(PayoutStatus::from(response.status)),
connector_payout_id: Some(response.id),
payout_eligible: None,
should_add_next_step_to_process_tracker: false,
error_code: None,
error_message: None,
}),
..item.data
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/nomupay/transformers.rs" role="context" start="303" end="303">
type Error = error_stack::Report<errors::ConnectorError>;
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/nomupay/transformers.rs" role="context" start="296" end="300">
pub struct NomupayAuthType {
pub(super) kid: Secret<String>,
#[cfg(feature = "payouts")]
pub(super) eid: Secret<String>,
}
<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/payouts.rs" role="context" start="262" end="267">
pub enum Bank {
Ach(AchBankTransfer),
Bacs(BacsBankTransfer),
Sepa(SepaBankTransfer),
Pix(PixBankTransfer),
}
|
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="1422" end="1439">
fn try_from(item: &FiuuRouterData<&PaymentsCaptureRouterData>) -> Result<Self, Self::Error> {
let auth = FiuuAuthType::try_from(&item.router_data.connector_auth_type)?;
let merchant_id = auth.merchant_id.peek().to_string();
let amount = item.amount.clone();
let txn_id = item.router_data.request.connector_transaction_id.clone();
let verify_key = auth.verify_key.peek().to_string();
let signature = calculate_signature(format!(
"{txn_id}{}{merchant_id}{verify_key}",
amount.get_amount_as_string()
))?;
Ok(Self {
domain: merchant_id,
tran_id: txn_id,
amount,
ref_id: item.router_data.connector_request_reference_id.clone(),
skey: signature,
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/fiuu/transformers.rs" role="context" start="1421" end="1421">
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,
},
};
<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="1441" end="1461">
fn capture_status_codes() -> HashMap<&'static str, &'static str> {
[
("00", "Capture successful"),
("11", "Capture failed"),
("12", "Invalid or unmatched security hash string"),
("13", "Not a credit card transaction"),
("15", "Requested day is on settlement day"),
("16", "Forbidden transaction"),
("17", "Transaction not found"),
("18", "Missing required parameter"),
("19", "Domain not found"),
("20", "Temporary out of service"),
("21", "Authorization expired"),
("23", "Partial capture not allowed"),
("24", "Transaction already captured"),
("25", "Requested amount exceeds available capture amount"),
("99", "General error (contact payment gateway support)"),
]
.into_iter()
.collect()
}
<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="1360" end="1374">
fn try_from(webhook_status: FiuuWebhookStatus) -> Result<Self, Self::Error> {
match webhook_status.status {
FiuuPaymentWebhookStatus::Success => match webhook_status.capture_method {
Some(CaptureMethod::Automatic) | Some(CaptureMethod::SequentialAutomatic) => {
Ok(Self::Charged)
}
Some(CaptureMethod::Manual) => Ok(Self::Authorized),
_ => Err(errors::ConnectorError::UnexpectedResponseError(
bytes::Bytes::from(webhook_status.status.to_string()),
))?,
},
FiuuPaymentWebhookStatus::Failure => Ok(Self::Failure),
FiuuPaymentWebhookStatus::Pending => Ok(Self::AuthenticationPending),
}
}
<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="391" end="401">
pub fn calculate_signature(
signature_data: String,
) -> Result<Secret<String>, Report<errors::ConnectorError>> {
let message = signature_data.as_bytes();
let encoded_data = hex::encode(
crypto::Md5
.generate_digest(message)
.change_context(errors::ConnectorError::RequestEncodingFailed)?,
);
Ok(Secret::new(encoded_data))
}
<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="70" end="74">
pub struct FiuuAuthType {
pub(super) merchant_id: Secret<String>,
pub(super) verify_key: Secret<String>,
pub(super) secret_key: Secret<String>,
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/fiuu/transformers.rs" role="context" start="56" end="59">
pub struct FiuuRouterData<T> {
pub amount: StringMajorUnit,
pub router_data: T,
}
<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_webhook_object_reference_id kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/braintree.rs" role="context" start="990" end="1007">
fn get_webhook_object_reference_id(
&self,
_request: &IncomingWebhookRequestDetails<'_>,
) -> CustomResult<api_models::webhooks::ObjectReferenceId, errors::ConnectorError> {
let notif = get_webhook_object_from_body(_request.body)
.change_context(errors::ConnectorError::WebhookBodyDecodingFailed)?;
let response = decode_webhook_payload(notif.bt_payload.replace('\n', "").as_bytes())?;
match response.dispute {
Some(dispute_data) => Ok(api_models::webhooks::ObjectReferenceId::PaymentId(
api_models::payments::PaymentIdType::ConnectorTransactionId(
dispute_data.transaction.id,
),
)),
None => Err(report!(errors::ConnectorError::WebhookReferenceIdNotFound)),
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/braintree.rs" role="context" start="989" end="989">
let sha1_hash_key = Sha1::digest(&connector_webhook_secrets.secret);
let signing_key = hmac::Key::new(
hmac::HMAC_SHA1_FOR_LEGACY_USE_ONLY,
sha1_hash_key.as_slice(),
);
let signed_messaged = hmac::sign(&signing_key, &message);
let payload_sign: String = hex::encode(signed_messaged);
Ok(payload_sign.as_bytes().eq(&signature))
}
fn get_webhook_object_reference_id(
&self,
_request: &IncomingWebhookRequestDetails<'_>,
) -> CustomResult<api_models::webhooks::ObjectReferenceId, errors::ConnectorError> {
let notif = get_webhook_object_from_body(_request.body)
.change_context(errors::ConnectorError::WebhookBodyDecodingFailed)?;
let response = decode_webhook_payload(notif.bt_payload.replace('\n', "").as_bytes())?;
match response.dispute {
Some(dispute_data) => Ok(api_models::webhooks::ObjectReferenceId::PaymentId(
api_models::payments::PaymentIdType::ConnectorTransactionId(
dispute_data.transaction.id,
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/braintree.rs" role="context" start="1021" end="1031">
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::WebhookBodyDecodingFailed)?;
let response = decode_webhook_payload(notif.bt_payload.replace('\n', "").as_bytes())?;
Ok(Box::new(response))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/braintree.rs" role="context" start="1009" end="1019">
fn get_webhook_event_type(
&self,
request: &IncomingWebhookRequestDetails<'_>,
) -> CustomResult<IncomingWebhookEvent, errors::ConnectorError> {
let notif = get_webhook_object_from_body(request.body)
.change_context(errors::ConnectorError::WebhookBodyDecodingFailed)?;
let response = decode_webhook_payload(notif.bt_payload.replace('\n', "").as_bytes())?;
Ok(get_status(response.kind.as_str()))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/braintree.rs" role="context" start="950" end="988">
async fn verify_webhook_source(
&self,
request: &IncomingWebhookRequestDetails<'_>,
merchant_id: &common_utils::id_type::MerchantId,
connector_webhook_details: Option<common_utils::pii::SecretSerdeValue>,
_connector_account_details: crypto::Encryptable<Secret<serde_json::Value>>,
connector_label: &str,
) -> CustomResult<bool, errors::ConnectorError> {
let connector_webhook_secrets = self
.get_webhook_source_verification_merchant_secret(
merchant_id,
connector_label,
connector_webhook_details,
)
.await
.change_context(errors::ConnectorError::WebhookSourceVerificationFailed)?;
let signature = self
.get_webhook_source_verification_signature(request, &connector_webhook_secrets)
.change_context(errors::ConnectorError::WebhookSignatureNotFound)?;
let message = self
.get_webhook_source_verification_message(
request,
merchant_id,
&connector_webhook_secrets,
)
.change_context(errors::ConnectorError::WebhookSourceVerificationFailed)?;
let sha1_hash_key = Sha1::digest(&connector_webhook_secrets.secret);
let signing_key = hmac::Key::new(
hmac::HMAC_SHA1_FOR_LEGACY_USE_ONLY,
sha1_hash_key.as_slice(),
);
let signed_messaged = hmac::sign(&signing_key, &message);
let payload_sign: String = hex::encode(signed_messaged);
Ok(payload_sign.as_bytes().eq(&signature))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/braintree.rs" role="context" start="936" end="948">
fn get_webhook_source_verification_message(
&self,
request: &IncomingWebhookRequestDetails<'_>,
_merchant_id: &common_utils::id_type::MerchantId,
_connector_webhook_secrets: &api_models::webhooks::ConnectorWebhookSecrets,
) -> CustomResult<Vec<u8>, errors::ConnectorError> {
let notify = get_webhook_object_from_body(request.body)
.change_context(errors::ConnectorError::WebhookSourceVerificationFailed)?;
let message = notify.bt_payload.to_string();
Ok(message.into_bytes())
}
<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="1083" end="1088">
fn get_webhook_object_from_body(
body: &[u8],
) -> CustomResult<transformers::BraintreeWebhookResponse, ParsingError> {
serde_urlencoded::from_bytes::<transformers::BraintreeWebhookResponse>(body)
.change_context(ParsingError::StructParseFailure("BraintreeWebhookResponse"))
}
<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/trustpay/transformers.rs<|crate|> hyperswitch_connectors<|connector|> trustpay anchor=get_debtor_info kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/trustpay/transformers.rs" role="context" start="368" end="388">
fn get_debtor_info(
item: &PaymentsAuthorizeRouterData,
pm: TrustpayPaymentMethod,
params: TrustpayMandatoryParams,
) -> CustomResult<Option<DebtorInformation>, errors::ConnectorError> {
let billing_last_name = item
.get_billing()?
.address
.as_ref()
.and_then(|address| address.last_name.clone());
Ok(match pm {
TrustpayPaymentMethod::Blik => Some(DebtorInformation {
name: get_full_name(params.billing_first_name, billing_last_name),
email: item.request.get_email()?,
}),
TrustpayPaymentMethod::Eps
| TrustpayPaymentMethod::Giropay
| TrustpayPaymentMethod::IDeal
| TrustpayPaymentMethod::Sofort => None,
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/trustpay/transformers.rs" role="context" start="367" end="367">
use common_utils::{
errors::CustomResult,
pii::{self, Email},
request::Method,
types::StringMajorUnit,
};
use hyperswitch_domain_models::{
payment_method_data::{BankRedirectData, BankTransferData, Card, PaymentMethodData},
router_data::{AccessToken, ConnectorAuthType, ErrorResponse, RouterData},
router_request_types::{BrowserInformation, PaymentsPreProcessingData, ResponseId},
router_response_types::{
PaymentsResponseData, PreprocessingResponseId, RedirectForm, RefundsResponseData,
},
types::{
PaymentsAuthorizeRouterData, PaymentsPreProcessingRouterData, RefreshTokenRouterData,
RefundsRouterData,
},
};
type Error = error_stack::Report<errors::ConnectorError>;
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/trustpay/transformers.rs" role="context" start="409" end="441">
fn get_bank_redirection_request_data(
item: &PaymentsAuthorizeRouterData,
bank_redirection_data: &BankRedirectData,
params: TrustpayMandatoryParams,
amount: StringMajorUnit,
auth: TrustpayAuthType,
) -> Result<TrustpayPaymentsRequest, error_stack::Report<errors::ConnectorError>> {
let pm = TrustpayPaymentMethod::try_from(bank_redirection_data)?;
let return_url = item.request.get_router_return_url()?;
let payment_request =
TrustpayPaymentsRequest::BankRedirectPaymentRequest(Box::new(PaymentRequestBankRedirect {
payment_method: pm.clone(),
merchant_identification: MerchantIdentification {
project_id: auth.project_id,
},
payment_information: BankPaymentInformation {
amount: Amount {
amount,
currency: item.request.currency.to_string(),
},
references: References {
merchant_reference: item.connector_request_reference_id.clone(),
},
debtor: get_debtor_info(item, pm, params)?,
},
callback_urls: CallbackURLs {
success: format!("{return_url}?status=SuccessOk"),
cancel: return_url.clone(),
error: return_url,
},
}));
Ok(payment_request)
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/trustpay/transformers.rs" role="context" start="390" end="407">
fn get_bank_transfer_debtor_info(
item: &PaymentsAuthorizeRouterData,
pm: TrustpayBankTransferPaymentMethod,
params: TrustpayMandatoryParams,
) -> CustomResult<Option<DebtorInformation>, errors::ConnectorError> {
let billing_last_name = item
.get_billing()?
.address
.as_ref()
.and_then(|address| address.last_name.clone());
Ok(match pm {
TrustpayBankTransferPaymentMethod::SepaCreditTransfer
| TrustpayBankTransferPaymentMethod::InstantBankTransfer => Some(DebtorInformation {
name: get_full_name(params.billing_first_name, billing_last_name),
email: item.request.get_email()?,
}),
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/trustpay/transformers.rs" role="context" start="358" end="366">
fn get_full_name(
billing_first_name: Secret<String>,
billing_last_name: Option<Secret<String>>,
) -> Secret<String> {
match billing_last_name {
Some(last_name) => format!("{} {}", billing_first_name.peek(), last_name.peek()).into(),
None => billing_first_name,
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/trustpay/transformers.rs" role="context" start="310" end="356">
fn get_card_request_data(
item: &PaymentsAuthorizeRouterData,
browser_info: &BrowserInformation,
params: TrustpayMandatoryParams,
amount: StringMajorUnit,
ccard: &Card,
return_url: String,
) -> Result<TrustpayPaymentsRequest, Error> {
let email = item.request.get_email()?;
let customer_ip_address = browser_info.get_ip_address()?;
let billing_last_name = item
.get_billing()?
.address
.as_ref()
.and_then(|address| address.last_name.clone());
Ok(TrustpayPaymentsRequest::CardsPaymentRequest(Box::new(
PaymentRequestCards {
amount,
currency: item.request.currency.to_string(),
pan: ccard.card_number.clone(),
cvv: ccard.card_cvc.clone(),
expiry_date: ccard.get_card_expiry_month_year_2_digit_with_delimiter("/".to_owned())?,
cardholder: get_full_name(params.billing_first_name, billing_last_name),
reference: item.connector_request_reference_id.clone(),
redirect_url: return_url,
billing_city: params.billing_city,
billing_country: params.billing_country,
billing_street1: params.billing_street1,
billing_postcode: params.billing_postcode,
customer_email: email,
customer_ip_address,
browser_accept_header: browser_info.get_accept_header()?,
browser_language: browser_info.get_language()?,
browser_screen_height: browser_info.get_screen_height()?.to_string(),
browser_screen_width: browser_info.get_screen_width()?.to_string(),
browser_timezone: browser_info.get_time_zone()?.to_string(),
browser_user_agent: browser_info.get_user_agent()?,
browser_java_enabled: browser_info.get_java_enabled()?.to_string(),
browser_java_script_enabled: browser_info.get_java_script_enabled()?.to_string(),
browser_screen_color_depth: browser_info.get_color_depth()?.to_string(),
browser_challenge_window: "1".to_string(),
payment_action: None,
payment_type: "Plain".to_string(),
descriptor: item.request.statement_descriptor.clone(),
},
)))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/trustpay/transformers.rs" role="context" start="239" end="245">
pub struct TrustpayMandatoryParams {
pub billing_city: String,
pub billing_country: api_models::enums::CountryAlpha2,
pub billing_street1: Secret<String>,
pub billing_postcode: Secret<String>,
pub billing_first_name: Secret<String>,
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/trustpay/transformers.rs" role="context" start="132" end="135">
pub struct DebtorInformation {
pub name: Secret<String>,
pub email: Email,
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/worldline/transformers.rs" role="context" start="141" end="143">
pub struct Giropay {
pub bank_account_iban: BankAccountIban,
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/hyperswitch_connectors/src/connectors/trustpay/transformers.rs<|crate|> hyperswitch_connectors<|connector|> trustpay anchor=handle_bank_redirects_response kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/trustpay/transformers.rs" role="context" start="847" end="873">
fn handle_bank_redirects_response(
response: PaymentsResponseBankRedirect,
) -> CustomResult<
(
enums::AttemptStatus,
Option<ErrorResponse>,
PaymentsResponseData,
),
errors::ConnectorError,
> {
let status = enums::AttemptStatus::AuthenticationPending;
let error = None;
let payment_response_data = PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(response.payment_request_id.to_string()),
redirection_data: Box::new(Some(RedirectForm::from((
response.gateway_url,
Method::Get,
)))),
mandate_reference: Box::new(None),
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: None,
incremental_authorization_allowed: None,
charges: None,
};
Ok((status, error, payment_response_data))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/trustpay/transformers.rs" role="context" start="846" end="846">
use common_enums::enums;
use common_utils::{
errors::CustomResult,
pii::{self, Email},
request::Method,
types::StringMajorUnit,
};
use hyperswitch_domain_models::{
payment_method_data::{BankRedirectData, BankTransferData, Card, PaymentMethodData},
router_data::{AccessToken, ConnectorAuthType, ErrorResponse, RouterData},
router_request_types::{BrowserInformation, PaymentsPreProcessingData, ResponseId},
router_response_types::{
PaymentsResponseData, PreprocessingResponseId, RedirectForm, RefundsResponseData,
},
types::{
PaymentsAuthorizeRouterData, PaymentsPreProcessingRouterData, RefreshTokenRouterData,
RefundsRouterData,
},
};
type Error = error_stack::Report<errors::ConnectorError>;
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/trustpay/transformers.rs" role="context" start="917" end="979">
fn handle_bank_redirects_sync_response(
response: SyncResponseBankRedirect,
status_code: u16,
) -> CustomResult<
(
enums::AttemptStatus,
Option<ErrorResponse>,
PaymentsResponseData,
),
errors::ConnectorError,
> {
let status = enums::AttemptStatus::from(response.payment_information.status);
let error = if utils::is_payment_failure(status) {
let reason_info = response
.payment_information
.status_reason_information
.unwrap_or_default();
Some(ErrorResponse {
code: reason_info
.reason
.code
.clone()
.unwrap_or(consts::NO_ERROR_CODE.to_string()),
// message vary for the same code, so relying on code alone as it is unique
message: reason_info
.reason
.code
.unwrap_or(consts::NO_ERROR_MESSAGE.to_string()),
reason: reason_info.reason.reject_reason,
status_code,
attempt_status: None,
connector_transaction_id: Some(
response
.payment_information
.references
.payment_request_id
.clone(),
),
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
})
} else {
None
};
let payment_response_data = PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(
response
.payment_information
.references
.payment_request_id
.clone(),
),
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((status, error, payment_response_data))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/trustpay/transformers.rs" role="context" start="875" end="915">
fn handle_bank_redirects_error_response(
response: ErrorResponseBankRedirect,
status_code: u16,
previous_attempt_status: enums::AttemptStatus,
) -> CustomResult<
(
enums::AttemptStatus,
Option<ErrorResponse>,
PaymentsResponseData,
),
errors::ConnectorError,
> {
let status = if matches!(response.payment_result_info.result_code, 1132014 | 1132005) {
previous_attempt_status
} else {
enums::AttemptStatus::AuthorizationFailed
};
let error = Some(ErrorResponse {
code: response.payment_result_info.result_code.to_string(),
// message vary for the same code, so relying on code alone as it is unique
message: response.payment_result_info.result_code.to_string(),
reason: response.payment_result_info.additional_info,
status_code,
attempt_status: Some(status),
connector_transaction_id: None,
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
});
let payment_response_data = 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((status, error, payment_response_data))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/trustpay/transformers.rs" role="context" start="793" end="845">
fn handle_cards_response(
response: PaymentsResponseCards,
status_code: u16,
) -> CustomResult<
(
enums::AttemptStatus,
Option<ErrorResponse>,
PaymentsResponseData,
),
errors::ConnectorError,
> {
let (status, msg) = get_transaction_status(
response.payment_status.to_owned(),
response.redirect_url.to_owned(),
)?;
let form_fields = response.redirect_params.unwrap_or_default();
let redirection_data = response.redirect_url.map(|url| RedirectForm::Form {
endpoint: url.to_string(),
method: Method::Post,
form_fields,
});
let error = if msg.is_some() {
Some(ErrorResponse {
code: response
.payment_status
.unwrap_or_else(|| consts::NO_ERROR_CODE.to_string()),
message: msg
.clone()
.unwrap_or_else(|| consts::NO_ERROR_MESSAGE.to_string()),
reason: msg,
status_code,
attempt_status: None,
connector_transaction_id: Some(response.instance_id.clone()),
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
})
} else {
None
};
let payment_response_data = PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(response.instance_id.clone()),
redirection_data: Box::new(redirection_data),
mandate_reference: Box::new(None),
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: None,
incremental_authorization_allowed: None,
charges: None,
};
Ok((status, error, payment_response_data))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/trustpay/transformers.rs" role="context" start="780" end="790">
fn try_from(
item: ResponseRouterData<F, TrustpayPaymentsResponse, T, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
let (status, error, payment_response_data) =
get_trustpay_response(item.response, item.http_code, item.data.status)?;
Ok(Self {
status,
response: error.map_or_else(|| Ok(payment_response_data), Err),
..item.data
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/trustpay/transformers.rs" role="context" start="1032" end="1061">
pub fn get_trustpay_response(
response: TrustpayPaymentsResponse,
status_code: u16,
previous_attempt_status: enums::AttemptStatus,
) -> CustomResult<
(
enums::AttemptStatus,
Option<ErrorResponse>,
PaymentsResponseData,
),
errors::ConnectorError,
> {
match response {
TrustpayPaymentsResponse::CardsPayments(response) => {
handle_cards_response(*response, status_code)
}
TrustpayPaymentsResponse::BankRedirectPayments(response) => {
handle_bank_redirects_response(*response)
}
TrustpayPaymentsResponse::BankRedirectSync(response) => {
handle_bank_redirects_sync_response(*response, status_code)
}
TrustpayPaymentsResponse::BankRedirectError(response) => {
handle_bank_redirects_error_response(*response, status_code, previous_attempt_status)
}
TrustpayPaymentsResponse::WebhookResponse(response) => {
handle_webhook_response(*response, status_code)
}
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/trustpay/transformers.rs" role="context" start="1929" end="1934">
fn from(error: Errors) -> Self {
Self {
error_code: error.code.to_string(),
error_message: error.description,
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/trustpay/transformers.rs" role="context" start="739" end="746">
pub struct PaymentsResponseBankRedirect {
pub payment_request_id: i64,
pub gateway_url: Url,
pub payment_result_info: Option<ResultInfo>,
pub payment_method_response: Option<TrustpayPaymentMethod>,
pub merchant_identification_response: Option<MerchantIdentification>,
pub payment_information_response: Option<BankPaymentInformationResponse>,
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/globalpay/requests.rs" role="context" start="685" end="688">
pub enum Method {
Ksn,
Ktb,
}
<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/boku/transformers.rs<|crate|> hyperswitch_connectors<|connector|> boku 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/boku/transformers.rs" role="context" start="302" end="324">
fn try_from(
item: ResponseRouterData<F, BokuResponse, T, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
let (status, transaction_id, redirection_data) = match item.response {
BokuResponse::BeginSingleChargeResponse(response) => get_authorize_response(response),
BokuResponse::QueryChargeResponse(response) => get_psync_response(response),
}?;
Ok(Self {
status,
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(transaction_id),
redirection_data: Box::new(redirection_data),
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
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/boku/transformers.rs" role="context" start="301" end="301">
use hyperswitch_domain_models::{
payment_method_data::{PaymentMethodData, WalletData},
router_data::{ConnectorAuthType, RouterData},
router_flow_types::refunds::{Execute, RSync},
router_request_types::ResponseId,
router_response_types::{PaymentsResponseData, RedirectForm, RefundsResponseData},
types::{self, RefundsRouterData},
};
use crate::{
types::{RefundsResponseRouterData, ResponseRouterData},
utils::{self, AddressDetailsData, RouterData as _},
};
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/boku/transformers.rs" role="context" start="335" end="349">
fn get_authorize_response(
response: BokuPaymentsResponse,
) -> Result<(enums::AttemptStatus, String, Option<RedirectForm>), errors::ConnectorError> {
let status = get_response_status(response.charge_status);
let redirection_data = match response.hosted {
Some(hosted_value) => Ok(hosted_value
.redirect_url
.map(|url| RedirectForm::from((url, Method::Get)))),
None => Err(errors::ConnectorError::MissingConnectorRedirectionPayload {
field_name: "redirect_url",
}),
}?;
Ok((status, response.charge_id, redirection_data))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/boku/transformers.rs" role="context" start="327" end="333">
fn get_response_status(status: String) -> enums::AttemptStatus {
match status.as_str() {
"Success" => enums::AttemptStatus::Charged,
"Failure" => enums::AttemptStatus::Failure,
_ => enums::AttemptStatus::Pending,
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/boku/transformers.rs" role="context" start="238" end="248">
fn try_from(item: &types::PaymentsSyncRouterData) -> Result<Self, Self::Error> {
let address = item.get_billing_address()?;
let country = address.get_country()?.to_string();
let auth_type = BokuAuthType::try_from(&item.connector_auth_type)?;
Ok(Self {
country,
merchant_id: auth_type.merchant_id,
merchant_transaction_id: Secret::new(item.payment_id.to_string()),
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/boku/transformers.rs" role="context" start="216" end="224">
fn try_from(auth_type: &ConnectorAuthType) -> Result<Self, Self::Error> {
match auth_type {
ConnectorAuthType::BodyKey { api_key, key1 } => Ok(Self {
merchant_id: key1.to_owned(),
key_id: api_key.to_owned(),
}),
_ => Err(errors::ConnectorError::FailedToObtainAuthType.into()),
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/boku/transformers.rs" role="context" start="351" end="357">
fn get_psync_response(
response: BokuPsyncResponse,
) -> Result<(enums::AttemptStatus, String, Option<RedirectForm>), errors::ConnectorError> {
let status = get_response_status(response.charges.charge.charge_status);
Ok((status, response.charges.charge.charge_id, None))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/boku/transformers.rs" role="context" start="102" end="102">
type Error = error_stack::Report<errors::ConnectorError>;
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/boku/transformers.rs" role="context" start="259" end="262">
pub enum BokuResponse {
BeginSingleChargeResponse(BokuPaymentsResponse),
QueryChargeResponse(BokuPsyncResponse),
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/types.rs" role="context" start="53" end="57">
pub struct ResponseRouterData<Flow, R, Request, Response> {
pub response: R,
pub data: RouterData<Flow, Request, Response>,
pub http_code: u16,
}
<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=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/wellsfargo/transformers.rs" role="context" start="1764" end="1794">
fn try_from(
item: ResponseRouterData<
Authorize,
WellsfargoPaymentsResponse,
PaymentsAuthorizeData,
PaymentsResponseData,
>,
) -> Result<Self, Self::Error> {
let status = map_attempt_status(
item.response
.status
.clone()
.unwrap_or(WellsfargoPaymentStatus::StatusNotReceived),
item.data.request.is_auto_capture()?,
);
let response =
get_payment_response((&item.response, status, item.http_code)).map_err(|err| *err);
let connector_response = item
.response
.processor_information
.as_ref()
.map(AdditionalPaymentMethodConnectorResponse::from)
.map(ConnectorResponseData::with_additional_payment_method_data);
Ok(Self {
status,
response,
connector_response,
..item.data
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/wellsfargo/transformers.rs" role="context" start="1763" end="1763">
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,
},
};
use crate::{
constants,
types::{RefundsResponseRouterData, ResponseRouterData},
unimplemented_payment_method,
utils::{
self, AddressDetailsData, ApplePayDecrypt, CardData, PaymentsAuthorizeRequestData,
PaymentsSetupMandateRequestData, PaymentsSyncRequestData, RecurringMandateData,
RouterData as OtherRouterData,
},
};
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/wellsfargo/transformers.rs" role="context" start="1823" end="1845">
fn try_from(
item: ResponseRouterData<
F,
WellsfargoPaymentsResponse,
PaymentsCaptureData,
PaymentsResponseData,
>,
) -> Result<Self, Self::Error> {
let status = map_attempt_status(
item.response
.status
.clone()
.unwrap_or(WellsfargoPaymentStatus::StatusNotReceived),
true,
);
let response =
get_payment_response((&item.response, status, item.http_code)).map_err(|err| *err);
Ok(Self {
status,
response,
..item.data
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/wellsfargo/transformers.rs" role="context" start="1798" end="1809">
fn from(processor_information: &ClientProcessorInformation) -> Self {
let payment_checks = Some(
serde_json::json!({"avs_response": processor_information.avs, "card_verification": processor_information.card_verification}),
);
Self::Card {
authentication_data: None,
payment_checks,
card_network: None,
domestic_network: None,
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/wellsfargo/transformers.rs" role="context" start="1709" end="1751">
fn get_payment_response(
(info_response, status, http_code): (&WellsfargoPaymentsResponse, enums::AttemptStatus, u16),
) -> Result<PaymentsResponseData, Box<ErrorResponse>> {
let error_response = get_error_response_if_failure((info_response, status, http_code));
match error_response {
Some(error) => Err(Box::new(error)),
None => {
let incremental_authorization_allowed =
Some(status == enums::AttemptStatus::Authorized);
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,
});
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: info_response.processor_information.as_ref().and_then(
|processor_information| processor_information.network_transaction_id.clone(),
),
connector_response_reference_id: Some(
info_response
.client_reference_information
.clone()
.and_then(|client_reference_information| client_reference_information.code)
.unwrap_or(info_response.id.clone()),
),
incremental_authorization_allowed,
charges: None,
})
}
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/wellsfargo/transformers.rs" role="context" start="1693" end="1707">
fn get_error_response_if_failure(
(info_response, status, http_code): (&WellsfargoPaymentsResponse, enums::AttemptStatus, u16),
) -> Option<ErrorResponse> {
if utils::is_payment_failure(status) {
Some(get_error_response(
&info_response.error_information,
&info_response.risk_information,
Some(status),
http_code,
info_response.id.clone(),
))
} else {
None
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/wellsfargo/transformers.rs" role="context" start="1566" end="1603">
fn map_attempt_status(status: WellsfargoPaymentStatus, capture: bool) -> enums::AttemptStatus {
match status {
WellsfargoPaymentStatus::Authorized | WellsfargoPaymentStatus::AuthorizedPendingReview => {
if capture {
// Because Wellsfargo will return Payment Status as Authorized even in AutoCapture Payment
enums::AttemptStatus::Charged
} else {
enums::AttemptStatus::Authorized
}
}
WellsfargoPaymentStatus::Pending => {
if capture {
enums::AttemptStatus::Charged
} else {
enums::AttemptStatus::Pending
}
}
WellsfargoPaymentStatus::Succeeded | WellsfargoPaymentStatus::Transmitted => {
enums::AttemptStatus::Charged
}
WellsfargoPaymentStatus::Voided
| WellsfargoPaymentStatus::Reversed
| WellsfargoPaymentStatus::Cancelled => enums::AttemptStatus::Voided,
WellsfargoPaymentStatus::Failed
| WellsfargoPaymentStatus::Declined
| WellsfargoPaymentStatus::AuthorizedRiskDeclined
| WellsfargoPaymentStatus::Rejected
| WellsfargoPaymentStatus::InvalidRequest
| WellsfargoPaymentStatus::ServerError => enums::AttemptStatus::Failure,
WellsfargoPaymentStatus::PendingAuthentication => {
enums::AttemptStatus::AuthenticationPending
}
WellsfargoPaymentStatus::PendingReview
| WellsfargoPaymentStatus::StatusNotReceived
| WellsfargoPaymentStatus::Challenge
| WellsfargoPaymentStatus::Accepted => enums::AttemptStatus::Pending,
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/wellsfargo/transformers.rs" role="context" start="72" end="72">
type Error = error_stack::Report<errors::ConnectorError>;
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/wellsfargo/transformers.rs" role="context" start="1617" end="1625">
pub struct WellsfargoPaymentsResponse {
id: String,
status: Option<WellsfargoPaymentStatus>,
client_reference_information: Option<ClientReferenceInformation>,
processor_information: Option<ClientProcessorInformation>,
risk_information: Option<ClientRiskInformation>,
token_information: Option<WellsfargoTokenInformation>,
error_information: Option<WellsfargoErrorInformation>,
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/types.rs" role="context" start="53" end="57">
pub struct ResponseRouterData<Flow, R, Request, Response> {
pub response: R,
pub data: RouterData<Flow, Request, Response>,
pub http_code: u16,
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/hyperswitch_connectors/src/connectors/payme/transformers.rs<|crate|> hyperswitch_connectors<|connector|> payme 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/payme/transformers.rs" role="context" start="276" end="301">
fn try_from(
item: ResponseRouterData<F, SaleQueryResponse, T, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
// Only one element would be present since we are passing one transaction id in the PSync request
let transaction_response = item
.response
.items
.first()
.cloned()
.ok_or(errors::ConnectorError::ResponseHandlingFailed)?;
let status = enums::AttemptStatus::from(transaction_response.sale_status.clone());
let response = if utils::is_payment_failure(status) {
// To populate error message in case of failure
Err(get_sale_query_error_response((
&transaction_response,
item.http_code,
)))
} else {
Ok(PaymentsResponseData::from(&transaction_response))
};
Ok(Self {
status,
response,
..item.data
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/payme/transformers.rs" role="context" start="275" end="275">
use api_models::enums::{AuthenticationType, PaymentMethod};
use common_enums::enums;
use hyperswitch_domain_models::{
payment_method_data::{PaymentMethodData, WalletData},
router_data::{ConnectorAuthType, ErrorResponse, PaymentMethodToken, RouterData},
router_flow_types::{Execute, Void},
router_request_types::{PaymentsCancelData, PaymentsPreProcessingData, ResponseId},
router_response_types::{
MandateReference, PaymentsResponseData, PreprocessingResponseId, RedirectForm,
RefundsResponseData,
},
types::{
PaymentsAuthorizeRouterData, PaymentsCancelRouterData, PaymentsCaptureRouterData,
PaymentsCompleteAuthorizeRouterData, PaymentsPreProcessingRouterData,
PaymentsSyncRouterData, RefundSyncRouterData, RefundsRouterData, TokenizationRouterData,
},
};
use crate::{
types::{PaymentsCancelResponseRouterData, RefundsResponseRouterData, ResponseRouterData},
unimplemented_payment_method,
utils::{
self, AddressDetailsData, CardData, PaymentsAuthorizeRequestData,
PaymentsCancelRequestData, PaymentsCompleteAuthorizeRequestData,
PaymentsPreProcessingRequestData, PaymentsSyncRequestData, RouterData as OtherRouterData,
},
};
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/payme/transformers.rs" role="context" start="327" end="339">
fn from(value: &SaleQuery) -> Self {
Self::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(value.sale_payme_id.clone()),
redirection_data: Box::new(None),
// mandate reference will be updated with webhooks only. That has been handled with PaymePaySaleResponse struct
mandate_reference: Box::new(None),
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: None,
incremental_authorization_allowed: None,
charges: None,
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/payme/transformers.rs" role="context" start="304" end="324">
fn get_sale_query_error_response(
(sale_query_response, http_code): (&SaleQuery, u16),
) -> ErrorResponse {
ErrorResponse {
code: sale_query_response
.sale_error_code
.clone()
.unwrap_or(consts::NO_ERROR_CODE.to_string()),
message: sale_query_response
.sale_error_text
.clone()
.unwrap_or(consts::NO_ERROR_MESSAGE.to_string()),
reason: sale_query_response.sale_error_text.clone(),
status_code: http_code,
attempt_status: None,
connector_transaction_id: Some(sale_query_response.sale_payme_id.clone()),
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/payme/transformers.rs" role="context" start="243" end="269">
fn try_from(value: &PaymePaySaleResponse) -> Result<Self, Self::Error> {
let redirection_data = match value.sale_3ds {
Some(true) => value.redirect_url.clone().map(|url| RedirectForm::Form {
endpoint: url.to_string(),
method: common_utils::request::Method::Get,
form_fields: HashMap::<String, String>::new(),
}),
_ => None,
};
Ok(Self::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(value.payme_sale_id.clone()),
redirection_data: Box::new(redirection_data),
mandate_reference: Box::new(value.buyer_key.clone().map(|buyer_key| {
MandateReference {
connector_mandate_id: Some(buyer_key.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,
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/payme/transformers.rs" role="context" start="218" end="239">
fn get_pay_sale_error_response(
(pay_sale_response, http_code): (&PaymePaySaleResponse, u16),
) -> ErrorResponse {
let code = pay_sale_response
.status_error_code
.map(|error_code| error_code.to_string())
.unwrap_or(consts::NO_ERROR_CODE.to_string());
ErrorResponse {
code,
message: pay_sale_response
.status_error_details
.clone()
.unwrap_or(consts::NO_ERROR_MESSAGE.to_string()),
reason: pay_sale_response.status_error_details.to_owned(),
status_code: http_code,
attempt_status: None,
connector_transaction_id: Some(pay_sale_response.payme_sale_id.clone()),
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/payme/transformers.rs" role="context" start="1274" end="1283">
fn from(value: NotifyType) -> Self {
match value {
NotifyType::SaleComplete => Self::PaymentIntentSuccess,
NotifyType::Refund => Self::RefundSuccess,
NotifyType::SaleFailure => Self::PaymentIntentFailure,
NotifyType::SaleChargeback => Self::DisputeOpened,
NotifyType::SaleChargebackRefund => Self::DisputeWon,
NotifyType::SaleAuthorized => Self::EventNotSupported,
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/payme/transformers.rs" role="context" start="49" end="49">
type Error = error_stack::Report<errors::ConnectorError>;
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/payme/transformers.rs" role="context" start="902" end="904">
pub struct SaleQueryResponse {
items: Vec<SaleQuery>,
}
<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/cybersource/transformers.rs<|crate|> hyperswitch_connectors<|connector|> cybersource 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/cybersource/transformers.rs" role="context" start="3377" end="3407">
fn try_from(
item: ResponseRouterData<
F,
CybersourcePaymentsResponse,
CompleteAuthorizeData,
PaymentsResponseData,
>,
) -> Result<Self, Self::Error> {
let status = map_cybersource_attempt_status(
item.response
.status
.clone()
.unwrap_or(CybersourcePaymentStatus::StatusNotReceived),
item.data.request.is_auto_capture()?,
);
let response =
get_payment_response((&item.response, status, item.http_code)).map_err(|err| *err);
let connector_response = item
.response
.processor_information
.as_ref()
.map(AdditionalPaymentMethodConnectorResponse::from)
.map(ConnectorResponseData::with_additional_payment_method_data);
Ok(Self {
status,
response,
connector_response,
..item.data
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/cybersource/transformers.rs" role="context" start="3376" end="3376">
impl<F>
TryFrom<
ResponseRouterData<
F,
CybersourcePaymentsResponse,
CompleteAuthorizeData,
PaymentsResponseData,
>,
> for RouterData<F, CompleteAuthorizeData, PaymentsResponseData>
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: ResponseRouterData<
F,
CybersourcePaymentsResponse,
CompleteAuthorizeData,
PaymentsResponseData,
>,
) -> Result<Self, Self::Error> {
let status = map_cybersource_attempt_status(
item.response
.status
.clone()
.unwrap_or(CybersourcePaymentStatus::StatusNotReceived),
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/cybersource/transformers.rs" role="context" start="3436" end="3458">
fn try_from(
item: ResponseRouterData<
F,
CybersourcePaymentsResponse,
PaymentsCaptureData,
PaymentsResponseData,
>,
) -> Result<Self, Self::Error> {
let status = map_cybersource_attempt_status(
item.response
.status
.clone()
.unwrap_or(CybersourcePaymentStatus::StatusNotReceived),
true,
);
let response =
get_payment_response((&item.response, status, item.http_code)).map_err(|err| *err);
Ok(Self {
status,
response,
..item.data
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/cybersource/transformers.rs" role="context" start="3411" end="3422">
fn from(processor_information: &ClientProcessorInformation) -> Self {
let payment_checks = Some(
serde_json::json!({"avs_response": processor_information.avs, "card_verification": processor_information.card_verification}),
);
Self::Card {
authentication_data: None,
payment_checks,
card_network: None,
domestic_network: None,
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/cybersource/transformers.rs" role="context" start="3248" end="3363">
fn try_from(
item: ResponseRouterData<
F,
CybersourcePreProcessingResponse,
PaymentsPreProcessingData,
PaymentsResponseData,
>,
) -> Result<Self, Self::Error> {
match item.response {
CybersourcePreProcessingResponse::ClientAuthCheckInfo(info_response) => {
let status = enums::AttemptStatus::from(info_response.status);
let risk_info: Option<ClientRiskInformation> = None;
if utils::is_payment_failure(status) {
let response = Err(get_error_response(
&info_response.error_information,
&risk_info,
Some(status),
item.http_code,
info_response.id.clone(),
));
Ok(Self {
status,
response,
..item.data
})
} else {
let connector_response_reference_id = Some(
info_response
.client_reference_information
.code
.unwrap_or(info_response.id.clone()),
);
let redirection_data = match (
info_response
.consumer_authentication_information
.access_token,
info_response
.consumer_authentication_information
.step_up_url,
) {
(Some(token), Some(step_up_url)) => {
Some(RedirectForm::CybersourceConsumerAuth {
access_token: token.expose(),
step_up_url,
})
}
_ => None,
};
let three_ds_data = serde_json::to_value(
info_response
.consumer_authentication_information
.validate_response,
)
.change_context(errors::ConnectorError::ResponseHandlingFailed)?;
Ok(Self {
status,
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::NoResponseId,
redirection_data: Box::new(redirection_data),
mandate_reference: Box::new(None),
connector_metadata: Some(serde_json::json!({
"three_ds_data": three_ds_data
})),
network_txn_id: None,
connector_response_reference_id,
incremental_authorization_allowed: None,
charges: None,
}),
..item.data
})
}
}
CybersourcePreProcessingResponse::ErrorInformation(error_response) => {
let detailed_error_info =
error_response
.error_information
.details
.to_owned()
.map(|details| {
details
.iter()
.map(|details| format!("{} : {}", details.field, details.reason))
.collect::<Vec<_>>()
.join(", ")
});
let reason = get_error_reason(
error_response.error_information.message,
detailed_error_info,
None,
);
let error_message = error_response.error_information.reason.to_owned();
let response = Err(ErrorResponse {
code: error_message
.clone()
.unwrap_or(hyperswitch_interfaces::consts::NO_ERROR_CODE.to_string()),
message: error_message
.unwrap_or(hyperswitch_interfaces::consts::NO_ERROR_MESSAGE.to_string()),
reason,
status_code: item.http_code,
attempt_status: None,
connector_transaction_id: Some(error_response.id.clone()),
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
});
Ok(Self {
response,
status: enums::AttemptStatus::AuthenticationFailed,
..item.data
})
}
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/cybersource/transformers.rs" role="context" start="3226" end="3234">
fn from(item: CybersourceAuthEnrollmentStatus) -> Self {
match item {
CybersourceAuthEnrollmentStatus::PendingAuthentication => Self::AuthenticationPending,
CybersourceAuthEnrollmentStatus::AuthenticationSuccessful => {
Self::AuthenticationSuccessful
}
CybersourceAuthEnrollmentStatus::AuthenticationFailed => Self::AuthenticationFailed,
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/cybersource/transformers.rs" role="context" start="2594" end="2629">
pub fn map_cybersource_attempt_status(
status: CybersourcePaymentStatus,
capture: bool,
) -> enums::AttemptStatus {
match status {
CybersourcePaymentStatus::Authorized => {
if capture {
// Because Cybersource will return Payment Status as Authorized even in AutoCapture Payment
enums::AttemptStatus::Charged
} else {
enums::AttemptStatus::Authorized
}
}
CybersourcePaymentStatus::Succeeded | CybersourcePaymentStatus::Transmitted => {
enums::AttemptStatus::Charged
}
CybersourcePaymentStatus::Voided
| CybersourcePaymentStatus::Reversed
| CybersourcePaymentStatus::Cancelled => enums::AttemptStatus::Voided,
CybersourcePaymentStatus::Failed
| CybersourcePaymentStatus::Declined
| CybersourcePaymentStatus::AuthorizedRiskDeclined
| CybersourcePaymentStatus::Rejected
| CybersourcePaymentStatus::InvalidRequest
| CybersourcePaymentStatus::ServerError => enums::AttemptStatus::Failure,
CybersourcePaymentStatus::PendingAuthentication => {
enums::AttemptStatus::AuthenticationPending
}
CybersourcePaymentStatus::PendingReview
| CybersourcePaymentStatus::StatusNotReceived
| CybersourcePaymentStatus::Challenge
| CybersourcePaymentStatus::Accepted
| CybersourcePaymentStatus::Pending
| CybersourcePaymentStatus::AuthorizedPendingReview => enums::AttemptStatus::Pending,
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/cybersource/transformers.rs" role="context" start="2757" end="2799">
fn get_payment_response(
(info_response, status, http_code): (&CybersourcePaymentsResponse, enums::AttemptStatus, u16),
) -> Result<PaymentsResponseData, Box<ErrorResponse>> {
let error_response = get_error_response_if_failure((info_response, status, http_code));
match error_response {
Some(error) => Err(Box::new(error)),
None => {
let incremental_authorization_allowed =
Some(status == enums::AttemptStatus::Authorized);
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,
});
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: info_response.processor_information.as_ref().and_then(
|processor_information| processor_information.network_transaction_id.clone(),
),
connector_response_reference_id: Some(
info_response
.client_reference_information
.clone()
.and_then(|client_reference_information| client_reference_information.code)
.unwrap_or(info_response.id.clone()),
),
incremental_authorization_allowed,
charges: None,
})
}
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/cybersource/transformers.rs" role="context" start="109" end="109">
type Error = error_stack::Report<errors::ConnectorError>;
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/cybersource/transformers.rs" role="context" start="2642" end="2650">
pub struct CybersourcePaymentsResponse {
id: String,
status: Option<CybersourcePaymentStatus>,
client_reference_information: Option<ClientReferenceInformation>,
processor_information: Option<ClientProcessorInformation>,
risk_information: Option<ClientRiskInformation>,
token_information: Option<CybersourceTokenInformation>,
error_information: Option<CybersourceErrorInformation>,
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/types.rs" role="context" start="53" end="57">
pub struct ResponseRouterData<Flow, R, Request, Response> {
pub response: R,
pub data: RouterData<Flow, Request, Response>,
pub http_code: u16,
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/hyperswitch_connectors/src/connectors/cybersource/transformers.rs<|crate|> hyperswitch_connectors<|connector|> cybersource 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/cybersource/transformers.rs" role="context" start="2812" end="2842">
fn try_from(
item: ResponseRouterData<
Authorize,
CybersourcePaymentsResponse,
PaymentsAuthorizeData,
PaymentsResponseData,
>,
) -> Result<Self, Self::Error> {
let status = map_cybersource_attempt_status(
item.response
.status
.clone()
.unwrap_or(CybersourcePaymentStatus::StatusNotReceived),
item.data.request.is_auto_capture()?,
);
let response =
get_payment_response((&item.response, status, item.http_code)).map_err(|err| *err);
let connector_response = item
.response
.processor_information
.as_ref()
.map(AdditionalPaymentMethodConnectorResponse::from)
.map(ConnectorResponseData::with_additional_payment_method_data);
Ok(Self {
status,
response,
connector_response,
..item.data
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/cybersource/transformers.rs" role="context" start="2811" end="2811">
impl
TryFrom<
ResponseRouterData<
Authorize,
CybersourcePaymentsResponse,
PaymentsAuthorizeData,
PaymentsResponseData,
>,
> for RouterData<Authorize, PaymentsAuthorizeData, PaymentsResponseData>
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: ResponseRouterData<
Authorize,
CybersourcePaymentsResponse,
PaymentsAuthorizeData,
PaymentsResponseData,
>,
) -> Result<Self, Self::Error> {
let status = map_cybersource_attempt_status(
item.response
.status
.clone()
.unwrap_or(CybersourcePaymentStatus::StatusNotReceived),
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/cybersource/transformers.rs" role="context" start="2985" end="3130">
fn try_from(
item: &CybersourceRouterData<&PaymentsPreProcessingRouterData>,
) -> Result<Self, Self::Error> {
let client_reference_information = ClientReferenceInformation {
code: Some(item.router_data.connector_request_reference_id.clone()),
};
let payment_method_data = item.router_data.request.payment_method_data.clone().ok_or(
errors::ConnectorError::MissingConnectorRedirectionPayload {
field_name: "payment_method_data",
},
)?;
let payment_information = match payment_method_data {
PaymentMethodData::Card(ccard) => {
let card_type = match ccard
.card_network
.clone()
.and_then(get_cybersource_card_type)
{
Some(card_network) => Some(card_network.to_string()),
None => ccard.get_card_issuer().ok().map(String::from),
};
let is_cobadged_card = ccard
.card_number
.clone()
.is_cobadged_card()
.change_context(errors::ConnectorError::RequestEncodingFailed)
.attach_printable("error while checking is_cobadged_card")?;
let type_selection_indicator = if is_cobadged_card {
Some("1".to_owned())
} else {
None
};
Ok(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,
type_selection_indicator,
},
},
)))
}
PaymentMethodData::Wallet(_)
| 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("Cybersource"),
))
}
}?;
let redirect_response = item.router_data.request.redirect_response.clone().ok_or(
errors::ConnectorError::MissingRequiredField {
field_name: "redirect_response",
},
)?;
let amount_details = Amount {
total_amount: item.amount.clone(),
currency: item.router_data.request.currency.ok_or(
errors::ConnectorError::MissingRequiredField {
field_name: "currency",
},
)?,
};
match redirect_response.params {
Some(param) if !param.clone().peek().is_empty() => {
let reference_id = param
.clone()
.peek()
.split_once('=')
.ok_or(errors::ConnectorError::MissingConnectorRedirectionPayload {
field_name: "request.redirect_response.params.reference_id",
})?
.1
.to_string();
let email = item
.router_data
.get_billing_email()
.or(item.router_data.request.get_email())?;
let bill_to = build_bill_to(item.router_data.get_optional_billing(), email)?;
let order_information = OrderInformationWithBill {
amount_details,
bill_to: Some(bill_to),
};
Ok(Self::AuthEnrollment(Box::new(
CybersourceAuthEnrollmentRequest {
payment_information,
client_reference_information,
consumer_authentication_information:
CybersourceConsumerAuthInformationRequest {
return_url: item
.router_data
.request
.get_complete_authorize_url()?,
reference_id,
},
order_information,
},
)))
}
Some(_) | None => {
let redirect_payload: CybersourceRedirectionAuthResponse = redirect_response
.payload
.ok_or(errors::ConnectorError::MissingConnectorRedirectionPayload {
field_name: "request.redirect_response.payload",
})?
.peek()
.clone()
.parse_value("CybersourceRedirectionAuthResponse")
.change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
let order_information = OrderInformation { amount_details };
Ok(Self::AuthValidate(Box::new(
CybersourceAuthValidateRequest {
payment_information,
client_reference_information,
consumer_authentication_information:
CybersourceConsumerAuthInformationValidateRequest {
authentication_transaction_id: redirect_payload.transaction_id,
},
order_information,
},
)))
}
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/cybersource/transformers.rs" role="context" start="2856" end="2935">
fn try_from(
item: ResponseRouterData<
F,
CybersourceAuthSetupResponse,
PaymentsAuthorizeData,
PaymentsResponseData,
>,
) -> Result<Self, Self::Error> {
match item.response {
CybersourceAuthSetupResponse::ClientAuthSetupInfo(info_response) => Ok(Self {
status: enums::AttemptStatus::AuthenticationPending,
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::NoResponseId,
redirection_data: Box::new(Some(RedirectForm::CybersourceAuthSetup {
access_token: info_response
.consumer_authentication_information
.access_token,
ddc_url: info_response
.consumer_authentication_information
.device_data_collection_url,
reference_id: info_response
.consumer_authentication_information
.reference_id,
})),
mandate_reference: Box::new(None),
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: Some(
info_response
.client_reference_information
.code
.unwrap_or(info_response.id.clone()),
),
incremental_authorization_allowed: None,
charges: None,
}),
..item.data
}),
CybersourceAuthSetupResponse::ErrorInformation(error_response) => {
let detailed_error_info =
error_response
.error_information
.details
.to_owned()
.map(|details| {
details
.iter()
.map(|details| format!("{} : {}", details.field, details.reason))
.collect::<Vec<_>>()
.join(", ")
});
let reason = get_error_reason(
error_response.error_information.message,
detailed_error_info,
None,
);
let error_message = error_response.error_information.reason;
Ok(Self {
response: Err(ErrorResponse {
code: error_message
.clone()
.unwrap_or(hyperswitch_interfaces::consts::NO_ERROR_CODE.to_string()),
message: error_message.unwrap_or(
hyperswitch_interfaces::consts::NO_ERROR_MESSAGE.to_string(),
),
reason,
status_code: item.http_code,
attempt_status: None,
connector_transaction_id: Some(error_response.id.clone()),
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
}),
status: enums::AttemptStatus::AuthenticationFailed,
..item.data
})
}
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/cybersource/transformers.rs" role="context" start="2757" end="2799">
fn get_payment_response(
(info_response, status, http_code): (&CybersourcePaymentsResponse, enums::AttemptStatus, u16),
) -> Result<PaymentsResponseData, Box<ErrorResponse>> {
let error_response = get_error_response_if_failure((info_response, status, http_code));
match error_response {
Some(error) => Err(Box::new(error)),
None => {
let incremental_authorization_allowed =
Some(status == enums::AttemptStatus::Authorized);
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,
});
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: info_response.processor_information.as_ref().and_then(
|processor_information| processor_information.network_transaction_id.clone(),
),
connector_response_reference_id: Some(
info_response
.client_reference_information
.clone()
.and_then(|client_reference_information| client_reference_information.code)
.unwrap_or(info_response.id.clone()),
),
incremental_authorization_allowed,
charges: None,
})
}
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/cybersource/transformers.rs" role="context" start="2741" end="2755">
fn get_error_response_if_failure(
(info_response, status, http_code): (&CybersourcePaymentsResponse, enums::AttemptStatus, u16),
) -> Option<ErrorResponse> {
if utils::is_payment_failure(status) {
Some(get_error_response(
&info_response.error_information,
&info_response.risk_information,
Some(status),
http_code,
info_response.id.clone(),
))
} else {
None
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/cybersource/transformers.rs" role="context" start="2594" end="2629">
pub fn map_cybersource_attempt_status(
status: CybersourcePaymentStatus,
capture: bool,
) -> enums::AttemptStatus {
match status {
CybersourcePaymentStatus::Authorized => {
if capture {
// Because Cybersource will return Payment Status as Authorized even in AutoCapture Payment
enums::AttemptStatus::Charged
} else {
enums::AttemptStatus::Authorized
}
}
CybersourcePaymentStatus::Succeeded | CybersourcePaymentStatus::Transmitted => {
enums::AttemptStatus::Charged
}
CybersourcePaymentStatus::Voided
| CybersourcePaymentStatus::Reversed
| CybersourcePaymentStatus::Cancelled => enums::AttemptStatus::Voided,
CybersourcePaymentStatus::Failed
| CybersourcePaymentStatus::Declined
| CybersourcePaymentStatus::AuthorizedRiskDeclined
| CybersourcePaymentStatus::Rejected
| CybersourcePaymentStatus::InvalidRequest
| CybersourcePaymentStatus::ServerError => enums::AttemptStatus::Failure,
CybersourcePaymentStatus::PendingAuthentication => {
enums::AttemptStatus::AuthenticationPending
}
CybersourcePaymentStatus::PendingReview
| CybersourcePaymentStatus::StatusNotReceived
| CybersourcePaymentStatus::Challenge
| CybersourcePaymentStatus::Accepted
| CybersourcePaymentStatus::Pending
| CybersourcePaymentStatus::AuthorizedPendingReview => enums::AttemptStatus::Pending,
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/cybersource/transformers.rs" role="context" start="109" end="109">
type Error = error_stack::Report<errors::ConnectorError>;
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/cybersource/transformers.rs" role="context" start="2642" end="2650">
pub struct CybersourcePaymentsResponse {
id: String,
status: Option<CybersourcePaymentStatus>,
client_reference_information: Option<ClientReferenceInformation>,
processor_information: Option<ClientProcessorInformation>,
risk_information: Option<ClientRiskInformation>,
token_information: Option<CybersourceTokenInformation>,
error_information: Option<CybersourceErrorInformation>,
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/types.rs" role="context" start="53" end="57">
pub struct ResponseRouterData<Flow, R, Request, Response> {
pub response: R,
pub data: RouterData<Flow, Request, Response>,
pub http_code: u16,
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/hyperswitch_connectors/src/connectors/worldline/transformers.rs<|crate|> hyperswitch_connectors<|connector|> worldline anchor=get_status kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=1<|meta_end|>
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/worldline/transformers.rs" role="context" start="532" end="557">
fn get_status(item: (PaymentStatus, CaptureMethod)) -> AttemptStatus {
let (status, capture_method) = item;
match status {
PaymentStatus::Captured | PaymentStatus::Paid | PaymentStatus::ChargebackNotification => {
AttemptStatus::Charged
}
PaymentStatus::Cancelled => AttemptStatus::Voided,
PaymentStatus::Rejected => AttemptStatus::Failure,
PaymentStatus::RejectedCapture => AttemptStatus::CaptureFailed,
PaymentStatus::CaptureRequested => {
if matches!(
capture_method,
CaptureMethod::Automatic | CaptureMethod::SequentialAutomatic
) {
AttemptStatus::Pending
} else {
AttemptStatus::CaptureInitiated
}
}
PaymentStatus::PendingApproval => AttemptStatus::Authorized,
PaymentStatus::Created => AttemptStatus::Started,
PaymentStatus::Redirected => AttemptStatus::AuthenticationPending,
_ => AttemptStatus::Pending,
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/worldline/transformers.rs" role="context" start="531" end="531">
use common_enums::enums::{AttemptStatus, BankNames, CaptureMethod, CountryAlpha2, Currency};
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/worldline/transformers.rs" role="context" start="617" end="642">
fn try_from(
item: ResponseRouterData<F, PaymentResponse, T, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
let redirection_data = item
.response
.merchant_action
.map(|action| action.redirect_data.redirect_url)
.map(|redirect_url| RedirectForm::from((redirect_url, Method::Get)));
Ok(Self {
status: get_status((
item.response.payment.status,
item.response.payment.capture_method,
)),
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(item.response.payment.id.clone()),
redirection_data: Box::new(redirection_data),
mandate_reference: Box::new(None),
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: Some(item.response.payment.id),
incremental_authorization_allowed: None,
charges: None,
}),
..item.data
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/worldline/transformers.rs" role="context" start="574" end="591">
fn try_from(
item: ResponseRouterData<F, Payment, T, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
Ok(Self {
status: get_status((item.response.status, item.response.capture_method)),
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(item.response.id.clone()),
redirection_data: Box::new(None),
mandate_reference: Box::new(None),
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: Some(item.response.id),
incremental_authorization_allowed: None,
charges: None,
}),
..item.data
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/worldline/transformers.rs" role="context" start="497" end="512">
fn try_from(auth_type: &ConnectorAuthType) -> Result<Self, Self::Error> {
if let ConnectorAuthType::SignatureKey {
api_key,
key1,
api_secret,
} = auth_type
{
Ok(Self {
api_key: api_key.to_owned(),
api_secret: api_secret.to_owned(),
merchant_account_id: key1.to_owned(),
})
} else {
Err(errors::ConnectorError::FailedToObtainAuthType)?
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/worldline/transformers.rs" role="context" start="473" end="486">
fn from(value: hyperswitch_domain_models::address::AddressDetails) -> Self {
Self {
city: value.city,
country_code: value.country,
name: Some(Name {
first_name: value.first_name,
surname: value.last_name,
..Default::default()
}),
state: value.state,
zip: value.zip,
..Default::default()
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/worldline/transformers.rs" role="context" start="517" end="530">
pub enum PaymentStatus {
Captured,
Paid,
ChargebackNotification,
Cancelled,
Rejected,
RejectedCapture,
PendingApproval,
CaptureRequested,
#[default]
Processing,
Created,
Redirected,
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/hyperswitch_connectors/src/connectors/worldline/transformers.rs<|crate|> hyperswitch_connectors<|connector|> worldline anchor=build_customer_info kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/worldline/transformers.rs" role="context" start="431" end="458">
fn build_customer_info(
billing_address: &hyperswitch_domain_models::address::Address,
email: &Option<Email>,
) -> Result<Customer, error_stack::Report<errors::ConnectorError>> {
let (billing, address) =
get_address(billing_address).ok_or(errors::ConnectorError::MissingRequiredField {
field_name: "billing.address.country",
})?;
let number_with_country_code = 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())))
})
});
Ok(Customer {
billing_address: BillingAddress {
..address.clone().into()
},
contact_details: Some(ContactDetails {
mobile_phone_number: number_with_country_code,
email_address: email.clone(),
}),
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/worldline/transformers.rs" role="context" start="430" end="430">
use hyperswitch_domain_models::{
payment_method_data::{BankRedirectData, PaymentMethodData},
router_data::{ConnectorAuthType, RouterData},
router_flow_types::{
payments::Authorize,
refunds::{Execute, RSync},
},
router_request_types::{PaymentsAuthorizeData, ResponseId},
router_response_types::{PaymentsResponseData, RedirectForm, RefundsResponseData},
types::{PaymentsAuthorizeRouterData, PaymentsCaptureRouterData, RefundsRouterData},
};
use masking::{PeekInterface, Secret};
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/worldline/transformers.rs" role="context" start="473" end="486">
fn from(value: hyperswitch_domain_models::address::AddressDetails) -> Self {
Self {
city: value.city,
country_code: value.country,
name: Some(Name {
first_name: value.first_name,
surname: value.last_name,
..Default::default()
}),
state: value.state,
zip: value.zip,
..Default::default()
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/worldline/transformers.rs" role="context" start="461" end="469">
fn from(value: hyperswitch_domain_models::address::AddressDetails) -> Self {
Self {
city: value.city,
country_code: value.country,
state: value.state,
zip: value.zip,
..Default::default()
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/worldline/transformers.rs" role="context" start="420" end="429">
fn get_address(
billing: &hyperswitch_domain_models::address::Address,
) -> Option<(
&hyperswitch_domain_models::address::Address,
&hyperswitch_domain_models::address::AddressDetails,
)> {
let address = billing.address.as_ref()?;
address.country.as_ref()?;
Some((billing, address))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/worldline/transformers.rs" role="context" start="360" end="418">
fn make_bank_redirect_request(
req: &PaymentsAuthorizeRouterData,
bank_redirect: &BankRedirectData,
) -> Result<RedirectPaymentMethod, error_stack::Report<errors::ConnectorError>> {
let return_url = req.request.router_return_url.clone();
let redirection_data = RedirectionData { return_url };
let (payment_method_specific_data, payment_product_id) = match bank_redirect {
BankRedirectData::Giropay {
bank_account_iban, ..
} => (
{
PaymentMethodSpecificData::PaymentProduct816SpecificInput(Box::new(Giropay {
bank_account_iban: BankAccountIban {
account_holder_name: req.get_billing_full_name()?.to_owned(),
iban: bank_account_iban.clone(),
},
}))
},
816,
),
BankRedirectData::Ideal { bank_name, .. } => (
{
PaymentMethodSpecificData::PaymentProduct809SpecificInput(Box::new(Ideal {
issuer_id: bank_name
.map(|bank_name| WorldlineBic::try_from(&bank_name))
.transpose()?,
}))
},
809,
),
BankRedirectData::BancontactCard { .. }
| BankRedirectData::Bizum {}
| BankRedirectData::Blik { .. }
| BankRedirectData::Eft { .. }
| BankRedirectData::Eps { .. }
| BankRedirectData::Interac { .. }
| BankRedirectData::OnlineBankingCzechRepublic { .. }
| BankRedirectData::OnlineBankingFinland { .. }
| BankRedirectData::OnlineBankingPoland { .. }
| BankRedirectData::OnlineBankingSlovakia { .. }
| BankRedirectData::OpenBankingUk { .. }
| BankRedirectData::Przelewy24 { .. }
| BankRedirectData::Sofort { .. }
| BankRedirectData::Trustly { .. }
| BankRedirectData::OnlineBankingFpx { .. }
| BankRedirectData::OnlineBankingThailand { .. }
| BankRedirectData::LocalBankRedirect {} => {
return Err(errors::ConnectorError::NotImplemented(
utils::get_unimplemented_payment_method_error_message("worldline"),
)
.into())
}
};
Ok(RedirectPaymentMethod {
payment_product_id,
redirection_data,
payment_method_specific_data,
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/worldline/transformers.rs" role="context" start="215" end="280">
fn try_from(
item: &WorldlineRouterData<
&RouterData<Authorize, PaymentsAuthorizeData, PaymentsResponseData>,
>,
) -> Result<Self, Self::Error> {
let payment_data =
match &item.router_data.request.payment_method_data {
PaymentMethodData::Card(card) => {
let card_holder_name = item.router_data.get_optional_billing_full_name();
WorldlinePaymentMethod::CardPaymentMethodSpecificInput(Box::new(
make_card_request(&item.router_data.request, card, card_holder_name)?,
))
}
PaymentMethodData::BankRedirect(bank_redirect) => {
WorldlinePaymentMethod::RedirectPaymentMethodSpecificInput(Box::new(
make_bank_redirect_request(item.router_data, bank_redirect)?,
))
}
PaymentMethodData::CardRedirect(_)
| PaymentMethodData::Wallet(_)
| PaymentMethodData::PayLater(_)
| 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("worldline"),
))?
}
};
let billing_address = item.router_data.get_billing()?;
let customer = build_customer_info(billing_address, &item.router_data.request.email)?;
let order = Order {
amount_of_money: AmountOfMoney {
amount: item.amount,
currency_code: item.router_data.request.currency.to_string().to_uppercase(),
},
customer,
references: References {
merchant_reference: item.router_data.connector_request_reference_id.clone(),
},
};
let shipping = item
.router_data
.get_optional_shipping()
.and_then(|shipping| shipping.address.clone())
.map(Shipping::from);
Ok(Self {
payment_data,
order,
shipping,
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/worldline/transformers.rs" role="context" start="83" end="86">
pub struct Customer {
pub billing_address: BillingAddress,
pub contact_details: Option<ContactDetails>,
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/worldline/transformers.rs" role="context" start="76" end="79">
pub struct ContactDetails {
pub email_address: Option<Email>,
pub mobile_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 -----------------------
|
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="1207" end="1228">
fn try_from(item: &PaymentsSyncRouterData) -> Result<Self, Self::Error> {
let auth = FiuuAuthType::try_from(&item.connector_auth_type)?;
let txn_id = item
.request
.connector_transaction_id
.get_connector_transaction_id()
.change_context(errors::ConnectorError::MissingConnectorTransactionID)?;
let merchant_id = auth.merchant_id.peek().to_string();
let verify_key = auth.verify_key.peek().to_string();
let amount = StringMajorUnitForConnector
.convert(item.request.amount, item.request.currency)
.change_context(errors::ConnectorError::AmountConversionFailed)?;
Ok(Self {
amount: amount.clone(),
tx_id: txn_id.clone(),
domain: merchant_id.clone(),
skey: calculate_signature(format!(
"{txn_id}{merchant_id}{verify_key}{}",
amount.get_amount_as_string()
))?,
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/fiuu/transformers.rs" role="context" start="1206" end="1206">
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,
},
};
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/fiuu/transformers.rs" role="context" start="1360" end="1374">
fn try_from(webhook_status: FiuuWebhookStatus) -> Result<Self, Self::Error> {
match webhook_status.status {
FiuuPaymentWebhookStatus::Success => match webhook_status.capture_method {
Some(CaptureMethod::Automatic) | Some(CaptureMethod::SequentialAutomatic) => {
Ok(Self::Charged)
}
Some(CaptureMethod::Manual) => Ok(Self::Authorized),
_ => Err(errors::ConnectorError::UnexpectedResponseError(
bytes::Bytes::from(webhook_status.status.to_string()),
))?,
},
FiuuPaymentWebhookStatus::Failure => Ok(Self::Failure),
FiuuPaymentWebhookStatus::Pending => Ok(Self::AuthenticationPending),
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/fiuu/transformers.rs" role="context" start="1233" end="1350">
fn try_from(
item: PaymentsSyncResponseRouterData<FiuuPaymentResponse>,
) -> Result<Self, Self::Error> {
match item.response {
FiuuPaymentResponse::FiuuPaymentSyncResponse(response) => {
let stat_name = response.stat_name;
let stat_code = response.stat_code.clone();
let txn_id = response.tran_id;
let status = enums::AttemptStatus::try_from(FiuuSyncStatus {
stat_name,
stat_code,
})?;
let error_response = if status == enums::AttemptStatus::Failure {
Some(ErrorResponse {
status_code: item.http_code,
code: response
.error_code
.unwrap_or(consts::NO_ERROR_CODE.to_owned()),
message: response
.error_desc
.clone()
.unwrap_or(consts::NO_ERROR_MESSAGE.to_owned()),
reason: response.error_desc,
attempt_status: Some(enums::AttemptStatus::Failure),
connector_transaction_id: Some(txn_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(txn_id.clone().to_string()),
redirection_data: Box::new(None),
mandate_reference: Box::new(None),
connector_metadata: None,
network_txn_id: response
.scheme_transaction_id
.as_ref()
.map(|id| id.clone().expose()),
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
})
}
FiuuPaymentResponse::FiuuWebhooksPaymentResponse(response) => {
let status = enums::AttemptStatus::try_from(FiuuWebhookStatus {
capture_method: item.data.request.capture_method,
status: response.status,
})?;
let txn_id = response.tran_id;
let mandate_reference = response.extra_parameters.as_ref().and_then(|extra_p| {
let mandate_token: Result<ExtraParameters, _> = serde_json::from_str(&extra_p.clone().expose());
match mandate_token {
Ok(token) => {
token.token.as_ref().map(|token| MandateReference {
connector_mandate_id: Some(token.clone().expose()),
payment_method_id: None,
mandate_metadata: None,
connector_mandate_request_reference_id:None
})
}
Err(err) => {
router_env::logger::warn!(
"Failed to convert 'extraP' from fiuu webhook response to fiuu::ExtraParameters. \
Input: '{:?}', Error: {}",
extra_p,
err
);
None
}
}
});
let error_response = if status == enums::AttemptStatus::Failure {
Some(ErrorResponse {
status_code: item.http_code,
code: response
.error_code
.clone()
.unwrap_or(consts::NO_ERROR_CODE.to_owned()),
message: response
.error_desc
.clone()
.unwrap_or(consts::NO_ERROR_MESSAGE.to_owned()),
reason: response.error_desc.clone(),
attempt_status: Some(enums::AttemptStatus::Failure),
connector_transaction_id: Some(txn_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(txn_id.clone().to_string()),
redirection_data: Box::new(None),
mandate_reference: Box::new(mandate_reference),
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="1077" end="1133">
fn try_from(
item: RefundsResponseRouterData<Execute, FiuuRefundResponse>,
) -> Result<Self, Self::Error> {
match item.response {
FiuuRefundResponse::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
}),
FiuuRefundResponse::Success(refund_data) => {
let refund_status = match refund_data.status.as_str() {
"00" => Ok(enums::RefundStatus::Success),
"11" => Ok(enums::RefundStatus::Failure),
"22" => Ok(enums::RefundStatus::Pending),
other => Err(errors::ConnectorError::UnexpectedResponseError(
bytes::Bytes::from(other.to_owned()),
)),
}?;
if refund_status == enums::RefundStatus::Failure {
Ok(Self {
response: Err(ErrorResponse {
code: refund_data.status.clone(),
message: refund_data
.reason
.clone()
.unwrap_or(consts::NO_ERROR_MESSAGE.to_string()),
reason: refund_data.reason.clone(),
status_code: item.http_code,
attempt_status: None,
connector_transaction_id: Some(refund_data.refund_id.to_string()),
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
}),
..item.data
})
} else {
Ok(Self {
response: Ok(RefundsResponseData {
connector_refund_id: refund_data.refund_id.clone().to_string(),
refund_status,
}),
..item.data
})
}
}
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/fiuu/transformers.rs" role="context" start="1032" end="1055">
fn try_from(item: &FiuuRouterData<&RefundsRouterData<Execute>>) -> Result<Self, Self::Error> {
let auth: FiuuAuthType = FiuuAuthType::try_from(&item.router_data.connector_auth_type)?;
let merchant_id = auth.merchant_id.peek().to_string();
let txn_amount = item.amount.clone();
let reference_no = item.router_data.connector_request_reference_id.clone();
let txn_id = item.router_data.request.connector_transaction_id.clone();
let secret_key = auth.secret_key.peek().to_string();
Ok(Self {
refund_type: RefundType::Partial,
merchant_id: auth.merchant_id,
ref_id: reference_no.clone(),
txn_id: txn_id.clone(),
amount: txn_amount.clone(),
signature: calculate_signature(format!(
"{}{merchant_id}{reference_no}{txn_id}{}{secret_key}",
RefundType::Partial,
txn_amount.get_amount_as_string()
))?,
notify_url: Some(
Url::parse(&item.router_data.request.get_webhook_url()?)
.change_context(errors::ConnectorError::RequestEncodingFailed)?,
),
})
}
<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="391" end="401">
pub fn calculate_signature(
signature_data: String,
) -> Result<Secret<String>, Report<errors::ConnectorError>> {
let message = signature_data.as_bytes();
let encoded_data = hex::encode(
crypto::Md5
.generate_digest(message)
.change_context(errors::ConnectorError::RequestEncodingFailed)?,
);
Ok(Secret::new(encoded_data))
}
<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="70" end="74">
pub struct FiuuAuthType {
pub(super) merchant_id: Secret<String>,
pub(super) verify_key: Secret<String>,
pub(super) secret_key: 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/nuvei/transformers.rs<|crate|> hyperswitch_connectors<|connector|> nuvei anchor=build_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/nuvei/transformers.rs" role="context" start="1541" end="1567">
fn build_error_response<T>(
response: &NuveiPaymentsResponse,
http_code: u16,
) -> Option<Result<T, ErrorResponse>> {
match response.status {
NuveiPaymentStatus::Error => Some(
get_error_response(response.err_code, &response.reason, http_code).map_err(|err| *err),
),
_ => {
let err = Some(
get_error_response(response.gw_error_code, &response.gw_error_reason, http_code)
.map_err(|err| *err),
);
match response.transaction_status {
Some(NuveiTransactionStatus::Error) | Some(NuveiTransactionStatus::Declined) => err,
_ => match response
.gw_error_reason
.as_ref()
.map(|r| r.eq("Missing argument"))
{
Some(true) => err,
_ => None,
},
}
}
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/nuvei/transformers.rs" role="context" start="1540" end="1540">
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="1660" end="1680">
fn try_from(
item: PaymentsPreprocessingResponseRouterData<NuveiPaymentsResponse>,
) -> Result<Self, Self::Error> {
let response = item.response;
let is_enrolled_for_3ds = response
.clone()
.payment_option
.and_then(|po| po.card)
.and_then(|c| c.three_d)
.and_then(|t| t.v2supported)
.map(to_boolean)
.unwrap_or_default();
Ok(Self {
status: get_payment_status(&response),
response: Ok(PaymentsResponseData::ThreeDSEnrollmentResponse {
enrolled_v2: is_enrolled_for_3ds,
related_transaction_id: response.transaction_id,
}),
..item.data
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/nuvei/transformers.rs" role="context" start="1583" end="1653">
fn try_from(
item: ResponseRouterData<F, NuveiPaymentsResponse, T, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
let redirection_data = match item.data.payment_method {
enums::PaymentMethod::Wallet | enums::PaymentMethod::BankRedirect => item
.response
.payment_option
.as_ref()
.and_then(|po| po.redirect_url.clone())
.map(|base_url| RedirectForm::from((base_url, Method::Get))),
_ => item
.response
.payment_option
.as_ref()
.and_then(|o| o.card.clone())
.and_then(|card| card.three_d)
.and_then(|three_ds| three_ds.acs_url.zip(three_ds.c_req))
.map(|(base_url, creq)| RedirectForm::Form {
endpoint: base_url,
method: Method::Post,
form_fields: std::collections::HashMap::from([(
"creq".to_string(),
creq.expose(),
)]),
}),
};
let response = item.response;
Ok(Self {
status: get_payment_status(&response),
response: if let Some(err) = build_error_response(&response, item.http_code) {
err
} else {
Ok(PaymentsResponseData::TransactionResponse {
resource_id: response
.transaction_id
.map_or(response.order_id.clone(), Some) // For paypal there will be no transaction_id, only order_id will be present
.map(ResponseId::ConnectorTransactionId)
.ok_or(errors::ConnectorError::MissingConnectorTransactionID)?,
redirection_data: Box::new(redirection_data),
mandate_reference: Box::new(
response
.payment_option
.and_then(|po| po.user_payment_option_id)
.map(|id| MandateReference {
connector_mandate_id: Some(id),
payment_method_id: None,
mandate_metadata: None,
connector_mandate_request_reference_id: None,
}),
),
// we don't need to save session token for capture, void flow so ignoring if it is not present
connector_metadata: if let Some(token) = response.session_token {
Some(
serde_json::to_value(NuveiMeta {
session_token: token,
})
.change_context(errors::ConnectorError::ResponseHandlingFailed)?,
)
} else {
None
},
network_txn_id: None,
connector_response_reference_id: response.order_id,
incremental_authorization_allowed: None,
charges: None,
})
},
..item.data
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/nuvei/transformers.rs" role="context" start="1508" end="1539">
fn get_payment_status(response: &NuveiPaymentsResponse) -> enums::AttemptStatus {
match response.transaction_status.clone() {
Some(status) => match status {
NuveiTransactionStatus::Approved => match response.transaction_type {
Some(NuveiTransactionType::Auth) => enums::AttemptStatus::Authorized,
Some(NuveiTransactionType::Sale) | Some(NuveiTransactionType::Settle) => {
enums::AttemptStatus::Charged
}
Some(NuveiTransactionType::Void) => enums::AttemptStatus::Voided,
_ => enums::AttemptStatus::Pending,
},
NuveiTransactionStatus::Declined | NuveiTransactionStatus::Error => {
match response.transaction_type {
Some(NuveiTransactionType::Auth) => enums::AttemptStatus::AuthorizationFailed,
Some(NuveiTransactionType::Void) => enums::AttemptStatus::VoidFailed,
Some(NuveiTransactionType::Auth3D) => {
enums::AttemptStatus::AuthenticationFailed
}
_ => enums::AttemptStatus::Failure,
}
}
NuveiTransactionStatus::Processing | NuveiTransactionStatus::Pending => {
enums::AttemptStatus::Pending
}
NuveiTransactionStatus::Redirect => enums::AttemptStatus::AuthenticationPending,
},
None => match response.status {
NuveiPaymentStatus::Failed | NuveiPaymentStatus::Error => enums::AttemptStatus::Failure,
_ => enums::AttemptStatus::Pending,
},
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/nuvei/transformers.rs" role="context" start="1450" end="1456">
fn from(item: NuveiTransactionStatus) -> Self {
match item {
NuveiTransactionStatus::Approved => Self::Charged,
NuveiTransactionStatus::Declined | NuveiTransactionStatus::Error => Self::Failure,
_ => Self::Pending,
}
}
<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="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="1461" end="1489">
pub struct NuveiPaymentsResponse {
pub order_id: Option<String>,
pub user_token_id: Option<Secret<String>>,
pub payment_option: Option<PaymentOption>,
pub transaction_status: Option<NuveiTransactionStatus>,
pub gw_error_code: Option<i64>,
pub gw_error_reason: Option<String>,
pub gw_extended_error_code: Option<i64>,
pub issuer_decline_code: Option<String>,
pub issuer_decline_reason: Option<String>,
pub transaction_type: Option<NuveiTransactionType>,
pub transaction_id: Option<String>,
pub external_transaction_id: Option<String>,
pub auth_code: Option<String>,
pub custom_data: Option<String>,
pub fraud_details: Option<FraudDetails>,
pub external_scheme_transaction_id: Option<Secret<String>>,
pub session_token: Option<Secret<String>>,
//The ID of the transaction in the merchant’s system.
pub client_unique_id: Option<String>,
pub internal_request_id: Option<i64>,
pub status: NuveiPaymentStatus,
pub err_code: Option<i64>,
pub reason: Option<String>,
pub merchant_id: Option<Secret<String>>,
pub merchant_site_id: Option<Secret<String>>,
pub version: Option<String>,
pub client_request_id: Option<String>,
}
<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/trustpay/transformers.rs<|crate|> hyperswitch_connectors<|connector|> trustpay anchor=handle_cards_refund_response kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/trustpay/transformers.rs" role="context" start="1583" end="1610">
fn handle_cards_refund_response(
response: CardsRefundResponse,
status_code: u16,
) -> CustomResult<(Option<ErrorResponse>, RefundsResponseData), errors::ConnectorError> {
let (refund_status, msg) = get_refund_status(&response.payment_status)?;
let error = if msg.is_some() {
Some(ErrorResponse {
code: response.payment_status,
message: msg
.clone()
.unwrap_or_else(|| consts::NO_ERROR_MESSAGE.to_string()),
reason: msg,
status_code,
attempt_status: None,
connector_transaction_id: None,
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
})
} else {
None
};
let refund_response_data = RefundsResponseData {
connector_refund_id: response.instance_id,
refund_status,
};
Ok((error, refund_response_data))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/trustpay/transformers.rs" role="context" start="1582" end="1582">
use common_utils::{
errors::CustomResult,
pii::{self, Email},
request::Method,
types::StringMajorUnit,
};
use hyperswitch_domain_models::{
payment_method_data::{BankRedirectData, BankTransferData, Card, PaymentMethodData},
router_data::{AccessToken, ConnectorAuthType, ErrorResponse, RouterData},
router_request_types::{BrowserInformation, PaymentsPreProcessingData, ResponseId},
router_response_types::{
PaymentsResponseData, PreprocessingResponseId, RedirectForm, RefundsResponseData,
},
types::{
PaymentsAuthorizeRouterData, PaymentsPreProcessingRouterData, RefreshTokenRouterData,
RefundsRouterData,
},
};
use hyperswitch_interfaces::{consts, errors};
type Error = error_stack::Report<errors::ConnectorError>;
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/trustpay/transformers.rs" role="context" start="1651" end="1677">
fn handle_bank_redirects_refund_response(
response: BankRedirectRefundResponse,
status_code: u16,
) -> (Option<ErrorResponse>, RefundsResponseData) {
let (refund_status, msg) = get_refund_status_from_result_info(response.result_info.result_code);
let error = if msg.is_some() {
Some(ErrorResponse {
code: response.result_info.result_code.to_string(),
// message vary for the same code, so relying on code alone as it is unique
message: response.result_info.result_code.to_string(),
reason: msg.map(|message| message.to_string()),
status_code,
attempt_status: None,
connector_transaction_id: None,
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
})
} else {
None
};
let refund_response_data = RefundsResponseData {
connector_refund_id: response.payment_request_id.to_string(),
refund_status,
};
(error, refund_response_data)
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/trustpay/transformers.rs" role="context" start="1612" end="1649">
fn handle_webhooks_refund_response(
response: WebhookPaymentInformation,
status_code: u16,
) -> CustomResult<(Option<ErrorResponse>, RefundsResponseData), errors::ConnectorError> {
let refund_status = enums::RefundStatus::try_from(response.status)?;
let error = if utils::is_refund_failure(refund_status) {
let reason_info = response.status_reason_information.unwrap_or_default();
Some(ErrorResponse {
code: reason_info
.reason
.code
.clone()
.unwrap_or(consts::NO_ERROR_CODE.to_string()),
// message vary for the same code, so relying on code alone as it is unique
message: reason_info
.reason
.code
.unwrap_or(consts::NO_ERROR_MESSAGE.to_string()),
reason: reason_info.reason.reject_reason,
status_code,
attempt_status: None,
connector_transaction_id: response.references.payment_request_id.clone(),
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
})
} else {
None
};
let refund_response_data = RefundsResponseData {
connector_refund_id: response
.references
.payment_request_id
.ok_or(errors::ConnectorError::MissingConnectorRefundID)?,
refund_status,
};
Ok((error, refund_response_data))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/trustpay/transformers.rs" role="context" start="1522" end="1553">
fn try_from(item: &TrustpayRouterData<&RefundsRouterData<F>>) -> Result<Self, Self::Error> {
let amount = item.amount.to_owned();
match item.router_data.payment_method {
enums::PaymentMethod::BankRedirect => {
let auth = TrustpayAuthType::try_from(&item.router_data.connector_auth_type)
.change_context(errors::ConnectorError::FailedToObtainAuthType)?;
Ok(Self::BankRedirectRefund(Box::new(
TrustpayRefundRequestBankRedirect {
merchant_identification: MerchantIdentification {
project_id: auth.project_id,
},
payment_information: BankPaymentInformation {
amount: Amount {
amount,
currency: item.router_data.request.currency.to_string(),
},
references: References {
merchant_reference: item.router_data.request.refund_id.clone(),
},
debtor: None,
},
},
)))
}
_ => Ok(Self::CardsRefund(Box::new(TrustpayRefundRequestCards {
instance_id: item.router_data.request.connector_transaction_id.clone(),
amount,
currency: item.router_data.request.currency.to_string(),
reference: item.router_data.request.refund_id.clone(),
}))),
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/trustpay/transformers.rs" role="context" start="1488" end="1494">
fn from(value: ApplePayTotalInfo) -> Self {
Self {
label: value.label,
amount: value.amount,
total_type: None,
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/trustpay/transformers.rs" role="context" start="1744" end="1766">
fn try_from(item: RefundsResponseRouterData<F, RefundResponse>) -> Result<Self, Self::Error> {
let (error, response) = match item.response {
RefundResponse::CardsRefund(response) => {
handle_cards_refund_response(*response, item.http_code)?
}
RefundResponse::WebhookRefund(response) => {
handle_webhooks_refund_response(*response, item.http_code)?
}
RefundResponse::BankRedirectRefund(response) => {
handle_bank_redirects_refund_response(*response, item.http_code)
}
RefundResponse::BankRedirectRefundSyncResponse(response) => {
handle_bank_redirects_refund_sync_response(*response, item.http_code)
}
RefundResponse::BankRedirectError(response) => {
handle_bank_redirects_refund_sync_error_response(*response, item.http_code)
}
};
Ok(Self {
response: error.map_or_else(|| Ok(response), Err),
..item.data
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/trustpay/transformers.rs" role="context" start="1769" end="1785">
fn get_refund_status(
payment_status: &str,
) -> CustomResult<(enums::RefundStatus, Option<String>), errors::ConnectorError> {
let (is_failed, failure_message) = is_payment_failed(payment_status);
if payment_status == "000.200.000" {
Ok((enums::RefundStatus::Pending, None))
} else if is_failed {
Ok((
enums::RefundStatus::Failure,
Some(failure_message.to_string()),
))
} else if is_payment_successful(payment_status)? {
Ok((enums::RefundStatus::Success, None))
} else {
Ok((enums::RefundStatus::Pending, None))
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/trustpay/transformers.rs" role="context" start="1558" end="1564">
pub struct CardsRefundResponse {
pub status: i64,
pub description: Option<String>,
pub instance_id: String,
pub payment_status: String,
pub payment_description: Option<String>,
}
<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/cashtocode/transformers.rs<|crate|> hyperswitch_connectors<|connector|> cashtocode anchor=get_redirect_form_data kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/cashtocode/transformers.rs" role="context" start="205" end="225">
fn get_redirect_form_data(
payment_method_type: enums::PaymentMethodType,
response_data: CashtocodePaymentsResponseData,
) -> CustomResult<RedirectForm, errors::ConnectorError> {
match payment_method_type {
enums::PaymentMethodType::ClassicReward => Ok(RedirectForm::Form {
//redirect form is manually constructed because the connector for this pm type expects query params in the url
endpoint: response_data.pay_url.to_string(),
method: Method::Post,
form_fields: Default::default(),
}),
enums::PaymentMethodType::Evoucher => Ok(RedirectForm::from((
//here the pay url gets parsed, and query params are sent as formfields as the connector expects
response_data.pay_url,
Method::Get,
))),
_ => Err(errors::ConnectorError::NotImplemented(
utils::get_unimplemented_payment_method_error_message("CashToCode"),
))?,
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/cashtocode/transformers.rs" role="context" start="204" end="204">
use common_enums::enums;
use common_utils::{
errors::CustomResult, ext_traits::ValueExt, id_type, pii::Email, types::FloatMajorUnit,
};
use hyperswitch_domain_models::{
router_data::{ConnectorAuthType, ErrorResponse, RouterData},
router_request_types::{PaymentsAuthorizeData, ResponseId},
router_response_types::{PaymentsResponseData, RedirectForm},
types::PaymentsAuthorizeRouterData,
};
use crate::{
types::ResponseRouterData,
utils::{self, PaymentsAuthorizeRequestData, RouterData as OtherRouterData},
};
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/cashtocode/transformers.rs" role="context" start="298" end="317">
fn try_from(
item: ResponseRouterData<F, CashtocodePaymentsSyncResponse, T, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
Ok(Self {
status: enums::AttemptStatus::Charged, // Charged status is hardcoded because cashtocode do not support Psync, and we only receive webhooks when payment is succeeded, this tryFrom is used for CallConnectorAction.
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(
item.data.attempt_id.clone(), //in response they only send PayUrl, so we use attempt_id as connector_transaction_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
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/cashtocode/transformers.rs" role="context" start="238" end="291">
fn try_from(
item: ResponseRouterData<
F,
CashtocodePaymentsResponse,
PaymentsAuthorizeData,
PaymentsResponseData,
>,
) -> Result<Self, Self::Error> {
let (status, response) = match item.response {
CashtocodePaymentsResponse::CashtoCodeError(error_data) => (
enums::AttemptStatus::Failure,
Err(ErrorResponse {
code: error_data.error.to_string(),
status_code: item.http_code,
message: error_data.error_description.clone(),
reason: Some(error_data.error_description),
attempt_status: None,
connector_transaction_id: None,
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
}),
),
CashtocodePaymentsResponse::CashtoCodeData(response_data) => {
let payment_method_type = item
.data
.request
.payment_method_type
.ok_or(errors::ConnectorError::MissingPaymentMethodType)?;
let redirection_data = get_redirect_form_data(payment_method_type, response_data)?;
(
enums::AttemptStatus::AuthenticationPending,
Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(
item.data.attempt_id.clone(),
),
redirection_data: Box::new(Some(redirection_data)),
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/cashtocode/transformers.rs" role="context" start="169" end="174">
fn from(item: CashtocodePaymentStatus) -> Self {
match item {
CashtocodePaymentStatus::Succeeded => Self::Charged,
CashtocodePaymentStatus::Processing => Self::AuthenticationPending,
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/cashtocode/transformers.rs" role="context" start="137" end="157">
fn try_from(value: (&ConnectorAuthType, &enums::Currency)) -> Result<Self, Self::Error> {
let (auth_type, currency) = value;
if let ConnectorAuthType::CurrencyAuthKey { auth_key_map } = auth_type {
if let Some(identity_auth_key) = auth_key_map.get(currency) {
let cashtocode_auth: Self = identity_auth_key
.to_owned()
.parse_value("CashtocodeAuth")
.change_context(errors::ConnectorError::FailedToObtainAuthType)?;
Ok(cashtocode_auth)
} else {
Err(errors::ConnectorError::CurrencyNotSupported {
message: currency.to_string(),
connector: "CashToCode",
}
.into())
}
} else {
Err(errors::ConnectorError::FailedToObtainAuthType.into())
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/cashtocode/transformers.rs" role="context" start="194" end="196">
pub struct CashtocodePaymentsResponseData {
pub pay_url: url::Url,
}
<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/stripebilling.rs<|crate|> hyperswitch_connectors<|connector|> stripebilling anchor=get_signature_elements_from_header 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="893" end="913">
fn get_signature_elements_from_header(
headers: &actix_web::http::header::HeaderMap,
) -> CustomResult<HashMap<String, Vec<u8>>, errors::ConnectorError> {
let security_header = headers
.get("stripe-signature")
.ok_or(errors::ConnectorError::WebhookSignatureNotFound)?;
let security_header_str = security_header
.to_str()
.change_context(errors::ConnectorError::WebhookSignatureNotFound)?;
let header_parts = security_header_str.split(',').collect::<Vec<&str>>();
let mut header_hashmap: HashMap<String, Vec<u8>> = HashMap::with_capacity(header_parts.len());
for header_part in header_parts {
let (header_key, header_value) = header_part
.split_once('=')
.ok_or(errors::ConnectorError::WebhookSignatureNotFound)?;
header_hashmap.insert(header_key.to_string(), header_value.bytes().collect());
}
Ok(header_hashmap)
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/stripebilling.rs" role="context" start="892" end="892">
use common_utils::{
errors::CustomResult,
ext_traits::BytesExt,
request::{Method, Request, RequestBuilder, RequestContent},
types::{AmountConvertor, StringMinorUnit, StringMinorUnitForConnector},
};
use hyperswitch_interfaces::{
api::{
self, ConnectorCommon, ConnectorCommonExt, ConnectorIntegration, ConnectorSpecifications,
ConnectorValidation,
},
configs::Connectors,
errors,
events::connector_api_logs::ConnectorEvent,
types::{self, Response},
webhooks,
};
use crate::{constants::headers, types::ResponseRouterData, utils};
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/stripebilling.rs" role="context" start="882" end="890">
fn get_revenue_recovery_invoice_details(
&self,
request: &webhooks::IncomingWebhookRequestDetails<'_>,
) -> CustomResult<revenue_recovery::RevenueRecoveryInvoiceData, errors::ConnectorError> {
let webhook = stripebilling::StripebillingInvoiceBody::get_invoice_webhook_data_from_body(
request.body,
)?;
revenue_recovery::RevenueRecoveryInvoiceData::try_from(webhook)
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/stripebilling.rs" role="context" start="874" end="880">
fn get_revenue_recovery_attempt_details(
&self,
_request: &webhooks::IncomingWebhookRequestDetails<'_>,
) -> CustomResult<revenue_recovery::RevenueRecoveryAttemptData, errors::ConnectorError> {
// since stripe requires an additional call we dont need to implement this function because we get the recovery data from additional call itself
Err(report!(errors::ConnectorError::WebhooksNotImplemented))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/stripebilling.rs" role="context" start="770" end="780">
fn get_webhook_source_verification_signature(
&self,
request: &webhooks::IncomingWebhookRequestDetails<'_>,
_connector_webhook_secrets: &api_models::webhooks::ConnectorWebhookSecrets,
) -> CustomResult<Vec<u8>, errors::ConnectorError> {
let mut header_hashmap = get_signature_elements_from_header(request.headers)?;
let signature = header_hashmap
.remove("v1")
.ok_or(errors::ConnectorError::WebhookSignatureNotFound)?;
hex::decode(signature).change_context(errors::ConnectorError::WebhookSignatureNotFound)
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/stripebilling.rs" role="context" start="782" end="798">
fn get_webhook_source_verification_message(
&self,
request: &webhooks::IncomingWebhookRequestDetails<'_>,
_merchant_id: &common_utils::id_type::MerchantId,
_connector_webhook_secrets: &api_models::webhooks::ConnectorWebhookSecrets,
) -> CustomResult<Vec<u8>, errors::ConnectorError> {
let mut header_hashmap = get_signature_elements_from_header(request.headers)?;
let timestamp = header_hashmap
.remove("t")
.ok_or(errors::ConnectorError::WebhookSignatureNotFound)?;
Ok(format!(
"{}.{}",
String::from_utf8_lossy(×tamp),
String::from_utf8_lossy(request.body)
)
.into_bytes())
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/hyperswitch_connectors/src/connectors/worldline/transformers.rs<|crate|> hyperswitch_connectors<|connector|> worldline 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/worldline/transformers.rs" role="context" start="617" end="642">
fn try_from(
item: ResponseRouterData<F, PaymentResponse, T, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
let redirection_data = item
.response
.merchant_action
.map(|action| action.redirect_data.redirect_url)
.map(|redirect_url| RedirectForm::from((redirect_url, Method::Get)));
Ok(Self {
status: get_status((
item.response.payment.status,
item.response.payment.capture_method,
)),
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(item.response.payment.id.clone()),
redirection_data: Box::new(redirection_data),
mandate_reference: Box::new(None),
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: Some(item.response.payment.id),
incremental_authorization_allowed: None,
charges: None,
}),
..item.data
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/worldline/transformers.rs" role="context" start="616" end="616">
use hyperswitch_domain_models::{
payment_method_data::{BankRedirectData, PaymentMethodData},
router_data::{ConnectorAuthType, RouterData},
router_flow_types::{
payments::Authorize,
refunds::{Execute, RSync},
},
router_request_types::{PaymentsAuthorizeData, ResponseId},
router_response_types::{PaymentsResponseData, RedirectForm, RefundsResponseData},
types::{PaymentsAuthorizeRouterData, PaymentsCaptureRouterData, RefundsRouterData},
};
use crate::{
types::{RefundsResponseRouterData, ResponseRouterData},
utils::{self, CardData, RouterData as RouterDataUtils},
};
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/worldline/transformers.rs" role="context" start="661" end="668">
fn try_from(item: &RefundsRouterData<F>) -> Result<Self, Self::Error> {
Ok(Self {
amount_of_money: AmountOfMoney {
amount: item.request.refund_amount,
currency_code: item.request.currency.to_string(),
},
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/worldline/transformers.rs" role="context" start="649" end="651">
fn try_from(_item: &PaymentsCaptureRouterData) -> Result<Self, Self::Error> {
Ok(Self {})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/worldline/transformers.rs" role="context" start="574" end="591">
fn try_from(
item: ResponseRouterData<F, Payment, T, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
Ok(Self {
status: get_status((item.response.status, item.response.capture_method)),
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(item.response.id.clone()),
redirection_data: Box::new(None),
mandate_reference: Box::new(None),
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: Some(item.response.id),
incremental_authorization_allowed: None,
charges: None,
}),
..item.data
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/worldline/transformers.rs" role="context" start="532" end="557">
fn get_status(item: (PaymentStatus, CaptureMethod)) -> AttemptStatus {
let (status, capture_method) = item;
match status {
PaymentStatus::Captured | PaymentStatus::Paid | PaymentStatus::ChargebackNotification => {
AttemptStatus::Charged
}
PaymentStatus::Cancelled => AttemptStatus::Voided,
PaymentStatus::Rejected => AttemptStatus::Failure,
PaymentStatus::RejectedCapture => AttemptStatus::CaptureFailed,
PaymentStatus::CaptureRequested => {
if matches!(
capture_method,
CaptureMethod::Automatic | CaptureMethod::SequentialAutomatic
) {
AttemptStatus::Pending
} else {
AttemptStatus::CaptureInitiated
}
}
PaymentStatus::PendingApproval => AttemptStatus::Authorized,
PaymentStatus::Created => AttemptStatus::Started,
PaymentStatus::Redirected => AttemptStatus::AuthenticationPending,
_ => AttemptStatus::Pending,
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/worldline/transformers.rs" role="context" start="683" end="689">
fn from(item: RefundStatus) -> Self {
match item {
RefundStatus::Refunded => Self::Success,
RefundStatus::Cancelled | RefundStatus::Rejected => Self::Failure,
RefundStatus::Processing => Self::Pending,
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/worldline/transformers.rs" role="context" start="197" end="197">
type Error = error_stack::Report<errors::ConnectorError>;
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/worldline/transformers.rs" role="context" start="596" end="599">
pub struct PaymentResponse {
pub payment: Payment,
pub merchant_action: Option<MerchantAction>,
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/globalpay/requests.rs" role="context" start="685" end="688">
pub enum Method {
Ksn,
Ktb,
}
<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=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/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="927" end="927">
use common_enums::enums;
use hyperswitch_domain_models::{
payment_method_data::PaymentMethodData,
router_data::{ConnectorAuthType, ErrorResponse, RouterData},
router_flow_types::refunds::{Execute, RSync},
router_request_types::{CompleteAuthorizeData, PaymentsAuthorizeData, ResponseId},
router_response_types::{
MandateReference, PaymentsResponseData, RedirectForm, RefundsResponseData,
},
types,
};
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="1004" end="1061">
fn try_from(
item: ResponseRouterData<
F,
TransactionResponse,
CompleteAuthorizeData,
PaymentsResponseData,
>,
) -> Result<Self, Self::Error> {
let response = item.response.clone();
let status = 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| {
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
}),
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/paybox/transformers.rs" role="context" start="962" end="989">
fn try_from(
item: RefundsResponseRouterData<Execute, TransactionResponse>,
) -> 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: common_enums::RefundStatus::Pending,
}),
..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="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="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="60" end="60">
type Error = error_stack::Report<errors::ConnectorError>;
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/paybox/transformers.rs" role="context" start="651" end="666">
pub struct PayboxSyncResponse {
#[serde(rename = "NUMTRANS")]
pub transaction_number: String,
#[serde(rename = "NUMAPPEL")]
pub paybox_order_id: String,
#[serde(rename = "CODEREPONSE")]
pub response_code: String,
#[serde(rename = "COMMENTAIRE")]
pub response_message: String,
#[serde(rename = "STATUS")]
pub status: PayboxStatus,
}
<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/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/authorizedotnet/transformers.rs<|crate|> hyperswitch_connectors<|connector|> authorizedotnet 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/authorizedotnet/transformers.rs" role="context" start="1662" end="1690">
fn try_from(
item: ResponseRouterData<F, AuthorizedotnetSyncResponse, Req, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
match item.response.transaction {
Some(transaction) => {
let payment_status = enums::AttemptStatus::from(transaction.transaction_status);
Ok(Self {
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(
transaction.transaction_id.clone(),
),
redirection_data: Box::new(None),
mandate_reference: Box::new(None),
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: Some(transaction.transaction_id.clone()),
incremental_authorization_allowed: None,
charges: None,
}),
status: payment_status,
..item.data
})
}
None => Ok(Self {
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="1661" end="1661">
use common_enums::enums;
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="1717" end="1736">
fn try_from(capture_method: Option<enums::CaptureMethod>) -> Result<Self, Self::Error> {
match capture_method {
Some(enums::CaptureMethod::Manual) => Ok(Self::Authorization),
Some(enums::CaptureMethod::SequentialAutomatic)
| Some(enums::CaptureMethod::Automatic)
| None => Ok(Self::Payment),
Some(enums::CaptureMethod::ManualMultiple) => {
Err(utils::construct_not_supported_error_report(
enums::CaptureMethod::ManualMultiple,
"authorizedotnet",
))?
}
Some(enums::CaptureMethod::Scheduled) => {
Err(utils::construct_not_supported_error_report(
enums::CaptureMethod::Scheduled,
"authorizedotnet",
))?
}
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/authorizedotnet/transformers.rs" role="context" start="1707" end="1713">
fn construct_refund_payment_details(masked_number: String) -> PaymentDetails {
PaymentDetails::CreditCard(CreditCardDetails {
card_number: masked_number.into(),
expiration_date: "XXXX".to_string().into(),
card_code: None,
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/authorizedotnet/transformers.rs" role="context" start="1635" end="1654">
fn try_from(
item: RefundsResponseRouterData<RSync, AuthorizedotnetRSyncResponse>,
) -> Result<Self, Self::Error> {
match item.response.transaction {
Some(transaction) => {
let refund_status = enums::RefundStatus::from(transaction.transaction_status);
Ok(Self {
response: Ok(RefundsResponseData {
connector_refund_id: transaction.transaction_id,
refund_status,
}),
..item.data
})
}
None => Ok(Self {
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="1619" end="1627">
fn from(transaction_status: RSyncStatus) -> Self {
match transaction_status {
RSyncStatus::RefundSettledSuccessfully => Self::Success,
RSyncStatus::RefundPendingSettlement => Self::Pending,
RSyncStatus::Declined | RSyncStatus::GeneralError | RSyncStatus::Voided => {
Self::Failure
}
}
}
<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="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="1581" end="1584">
pub struct AuthorizedotnetSyncResponse {
transaction: Option<SyncTransactionResponse>,
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>;
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/hyperswitch_connectors/src/connectors/cashtocode/transformers.rs<|crate|> hyperswitch_connectors<|connector|> cashtocode anchor=get_mid kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/cashtocode/transformers.rs" role="context" start="40" end="57">
fn get_mid(
connector_auth_type: &ConnectorAuthType,
payment_method_type: Option<enums::PaymentMethodType>,
currency: enums::Currency,
) -> Result<Secret<String>, errors::ConnectorError> {
match CashtocodeAuth::try_from((connector_auth_type, ¤cy)) {
Ok(cashtocode_auth) => match payment_method_type {
Some(enums::PaymentMethodType::ClassicReward) => Ok(cashtocode_auth
.merchant_id_classic
.ok_or(errors::ConnectorError::FailedToObtainAuthType)?),
Some(enums::PaymentMethodType::Evoucher) => Ok(cashtocode_auth
.merchant_id_evoucher
.ok_or(errors::ConnectorError::FailedToObtainAuthType)?),
_ => Err(errors::ConnectorError::FailedToObtainAuthType),
},
Err(_) => Err(errors::ConnectorError::FailedToObtainAuthType)?,
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/cashtocode/transformers.rs" role="context" start="39" end="39">
use common_enums::enums;
use common_utils::{
errors::CustomResult, ext_traits::ValueExt, id_type, pii::Email, types::FloatMajorUnit,
};
use hyperswitch_domain_models::{
router_data::{ConnectorAuthType, ErrorResponse, RouterData},
router_request_types::{PaymentsAuthorizeData, ResponseId},
router_response_types::{PaymentsResponseData, RedirectForm},
types::PaymentsAuthorizeRouterData,
};
use masking::Secret;
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/cashtocode/transformers.rs" role="context" start="108" end="131">
fn try_from(auth_type: &ConnectorAuthType) -> Result<Self, Self::Error> {
match auth_type {
ConnectorAuthType::CurrencyAuthKey { auth_key_map } => {
let transformed_auths = auth_key_map
.iter()
.map(|(currency, identity_auth_key)| {
let cashtocode_auth = identity_auth_key
.to_owned()
.parse_value::<CashtocodeAuth>("CashtocodeAuth")
.change_context(errors::ConnectorError::InvalidDataFormat {
field_name: "auth_key_map",
})?;
Ok((currency.to_owned(), cashtocode_auth))
})
.collect::<Result<_, Self::Error>>()?;
Ok(Self {
auths: transformed_auths,
})
}
_ => Err(errors::ConnectorError::FailedToObtainAuthType.into()),
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/cashtocode/transformers.rs" role="context" start="61" end="87">
fn try_from(
(item, amount): (&PaymentsAuthorizeRouterData, FloatMajorUnit),
) -> Result<Self, Self::Error> {
let customer_id = item.get_customer_id()?;
let url = item.request.get_router_return_url()?;
let mid = get_mid(
&item.connector_auth_type,
item.request.payment_method_type,
item.request.currency,
)?;
match item.payment_method {
enums::PaymentMethod::Reward => Ok(Self {
amount,
transaction_id: item.attempt_id.clone(),
currency: item.request.currency,
user_id: Secret::new(customer_id.to_owned()),
first_name: None,
last_name: None,
user_alias: Secret::new(customer_id),
requested_url: url.to_owned(),
cancel_url: url,
email: item.request.email.clone(),
mid,
}),
_ => Err(errors::ConnectorError::NotImplemented("Payment methods".to_string()).into()),
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/cashtocode/transformers.rs" role="context" start="298" end="317">
fn try_from(
item: ResponseRouterData<F, CashtocodePaymentsSyncResponse, T, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
Ok(Self {
status: enums::AttemptStatus::Charged, // Charged status is hardcoded because cashtocode do not support Psync, and we only receive webhooks when payment is succeeded, this tryFrom is used for CallConnectorAction.
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(
item.data.attempt_id.clone(), //in response they only send PayUrl, so we use attempt_id as connector_transaction_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
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/cashtocode/transformers.rs" role="context" start="96" end="103">
pub struct CashtocodeAuth {
pub password_classic: Option<Secret<String>>,
pub password_evoucher: Option<Secret<String>>,
pub username_classic: Option<Secret<String>>,
pub username_evoucher: Option<Secret<String>>,
pub merchant_id_classic: Option<Secret<String>>,
pub merchant_id_evoucher: Option<Secret<String>>,
}
<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/admin.rs" role="context" start="1017" end="1046">
pub enum ConnectorAuthType {
TemporaryAuth,
HeaderKey {
api_key: Secret<String>,
},
BodyKey {
api_key: Secret<String>,
key1: Secret<String>,
},
SignatureKey {
api_key: Secret<String>,
key1: Secret<String>,
api_secret: Secret<String>,
},
MultiAuthKey {
api_key: Secret<String>,
key1: Secret<String>,
api_secret: Secret<String>,
key2: Secret<String>,
},
CurrencyAuthKey {
auth_key_map: HashMap<common_enums::Currency, pii::SecretSerdeValue>,
},
CertificateAuth {
certificate: Secret<String>,
private_key: Secret<String>,
},
#[default]
NoKey,
}
|
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="4541" end="4564">
fn try_from(item: &AdyenRouterData<&RefundsRouterData<F>>) -> Result<Self, Self::Error> {
let auth_type = AdyenAuthType::try_from(&item.router_data.connector_auth_type)?;
let (store, splits) = match item
.router_data
.request
.split_refunds
.as_ref()
{
Some(hyperswitch_domain_models::router_request_types::SplitRefundsRequest::AdyenSplitRefund(adyen_split_data)) => get_adyen_split_request(adyen_split_data, item.router_data.request.currency),
_ => (None, None),
};
Ok(Self {
merchant_account: auth_type.merchant_account,
amount: Amount {
currency: item.router_data.request.currency,
value: item.amount,
},
merchant_refund_reason: item.router_data.request.reason.clone(),
reference: item.router_data.request.refund_id.clone(),
store,
splits,
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/adyen/transformers.rs" role="context" start="4540" end="4540">
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,
},
};
use hyperswitch_domain_models::{
router_response_types::PayoutsResponseData, types::PayoutsRouterData,
};
type Error = error_stack::Report<errors::ConnectorError>;
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/adyen/transformers.rs" role="context" start="4679" end="4681">
pub fn is_transaction_event(event_code: &WebhookEventCode) -> bool {
matches!(event_code, WebhookEventCode::Authorisation)
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/adyen/transformers.rs" role="context" start="4570" end="4583">
fn try_from(
item: RefundsResponseRouterData<F, AdyenRefundResponse>,
) -> Result<Self, Self::Error> {
Ok(Self {
response: Ok(RefundsResponseData {
connector_refund_id: item.response.psp_reference,
// From the docs, the only value returned is "received", outcome of refund is available
// through refund notification webhook
// For more info: https://docs.adyen.com/online-payments/refund
refund_status: storage_enums::RefundStatus::Pending,
}),
..item.data
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/adyen/transformers.rs" role="context" start="4515" end="4536">
fn construct_charge_response(
store: Option<String>,
split_item: &[AdyenSplitData],
) -> common_types::payments::ConnectorChargeResponseData {
let splits: Vec<common_types::domain::AdyenSplitItem> = split_item
.iter()
.map(|split_item| common_types::domain::AdyenSplitItem {
amount: split_item.amount.as_ref().map(|amount| amount.value),
reference: split_item.reference.clone(),
split_type: split_item.split_type.clone(),
account: split_item.account.clone(),
description: split_item.description.clone(),
})
.collect();
common_types::payments::ConnectorChargeResponseData::AdyenSplitPayment(
common_types::domain::AdyenSplitData {
store,
split_items: splits,
},
)
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/adyen/transformers.rs" role="context" start="4481" end="4512">
fn try_from(
item: PaymentsCaptureResponseRouterData<AdyenCaptureResponse>,
) -> Result<Self, Self::Error> {
let connector_transaction_id = if item.data.request.multiple_capture_data.is_some() {
item.response.psp_reference.clone()
} else {
item.response.payment_psp_reference
};
let charges = match &item.response.splits {
Some(split_items) => Some(construct_charge_response(item.response.store, split_items)),
None => None,
};
Ok(Self {
// From the docs, the only value returned is "received", outcome of refund is available
// through refund notification webhook
// For more info: https://docs.adyen.com/online-payments/capture
status: storage_enums::AttemptStatus::Pending,
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(connector_transaction_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.reference),
incremental_authorization_allowed: None,
charges,
}),
amount_captured: Some(0),
..item.data
})
}
<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="5763" end="5848">
fn try_from(
value: (
&AdyenRouterData<&PaymentsAuthorizeRouterData>,
&NetworkTokenData,
),
) -> Result<Self, Self::Error> {
let (item, token_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()).transpose()?;
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((token_data, card_holder_name))?,
));
let shopper_email = item.router_data.request.email.clone();
let shopper_name = get_shopper_name(item.router_data.get_optional_billing());
let mpi_data = AdyenMpiData {
directory_response: "Y".to_string(),
authentication_response: "Y".to_string(),
token_authentication_verification_value: token_data
.get_cryptogram()
.clone()
.unwrap_or_default(),
eci: Some("02".to_string()),
};
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,
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(),
mpi_data: Some(mpi_data),
store,
splits,
device_fingerprint,
})
}
<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/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/globepay/transformers.rs<|crate|> hyperswitch_connectors<|connector|> globepay 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/globepay/transformers.rs" role="context" start="378" end="407">
fn try_from(
item: RefundsResponseRouterData<T, GlobepayRefundResponse>,
) -> Result<Self, Self::Error> {
if item.response.return_code == GlobepayReturnCode::Success {
let globepay_refund_id = item
.response
.refund_id
.ok_or(errors::ConnectorError::ResponseHandlingFailed)?;
let globepay_refund_status = item
.response
.result_code
.ok_or(errors::ConnectorError::ResponseHandlingFailed)?;
Ok(Self {
response: Ok(RefundsResponseData {
connector_refund_id: globepay_refund_id,
refund_status: enums::RefundStatus::from(globepay_refund_status),
}),
..item.data
})
} else {
Ok(Self {
response: Err(get_error_response(
item.response.return_code,
item.response.return_msg,
item.http_code,
)),
..item.data
})
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/globepay/transformers.rs" role="context" start="377" end="377">
use common_enums::enums;
use hyperswitch_domain_models::{
payment_method_data::{PaymentMethodData, WalletData},
router_data::{ConnectorAuthType, ErrorResponse, RouterData},
router_request_types::ResponseId,
router_response_types::{PaymentsResponseData, RefundsResponseData},
types::{self, RefundsRouterData},
};
use crate::{
types::{RefundsResponseRouterData, ResponseRouterData},
utils::{get_unimplemented_payment_method_error_message, RouterData as _},
};
type Error = error_stack::Report<errors::ConnectorError>;
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/globepay/transformers.rs" role="context" start="357" end="365">
fn from(item: GlobepayRefundStatus) -> Self {
match item {
GlobepayRefundStatus::Finished => Self::Success, //FINISHED: Refund success(funds has already been returned to user's account)
GlobepayRefundStatus::Failed
| GlobepayRefundStatus::CreateFailed
| GlobepayRefundStatus::Change => Self::Failure, //CHANGE: Refund can not return to user's account. Manual operation is required
GlobepayRefundStatus::Waiting | GlobepayRefundStatus::Success => Self::Pending, // SUCCESS: Submission succeeded, but refund is not yet complete. Waiting = Submission succeeded, but refund is not yet complete.
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/globepay/transformers.rs" role="context" start="341" end="343">
fn try_from(item: &GlobepayRouterData<&RefundsRouterData<F>>) -> Result<Self, Self::Error> {
Ok(Self { fee: item.amount })
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/globepay/transformers.rs" role="context" start="316" end="332">
fn get_error_response(
return_code: GlobepayReturnCode,
return_msg: Option<String>,
status_code: u16,
) -> ErrorResponse {
ErrorResponse {
code: return_code.to_string(),
message: consts::NO_ERROR_MESSAGE.to_string(),
reason: return_msg,
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/globepay/transformers.rs" role="context" start="19" end="19">
type Error = error_stack::Report<errors::ConnectorError>;
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/globepay/transformers.rs" role="context" start="369" end="374">
pub struct GlobepayRefundResponse {
pub result_code: Option<GlobepayRefundStatus>,
pub refund_id: Option<String>,
pub return_code: GlobepayReturnCode,
pub return_msg: Option<String>,
}
<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/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/bluesnap.rs<|crate|> hyperswitch_connectors<|connector|> bluesnap 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/bluesnap.rs" role="context" start="401" end="427">
fn get_url(
&self,
req: &PaymentsSyncRouterData,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
let connector_transaction_id = req.request.connector_transaction_id.clone();
match connector_transaction_id {
// if connector_transaction_id is present, we always sync with connector_transaction_id
ResponseId::ConnectorTransactionId(trans_id) => {
get_psync_url_with_connector_transaction_id(
trans_id,
self.base_url(connectors).to_string(),
)
}
_ => {
// if connector_transaction_id is not present, we sync with merchant_transaction_id
let meta_data: bluesnap::BluesnapConnectorMetaData =
to_connector_meta_from_secret(req.connector_meta_data.clone())
.change_context(errors::ConnectorError::ResponseHandlingFailed)?;
get_url_with_merchant_transaction_id(
self.base_url(connectors).to_string(),
meta_data.merchant_id,
req.attempt_id.to_owned(),
)
}
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/bluesnap.rs" role="context" start="400" end="400">
fn get_headers(
&self,
req: &PaymentsSyncRouterData,
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: &PaymentsSyncRouterData,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
let connector_transaction_id = req.request.connector_transaction_id.clone();
match connector_transaction_id {
// if connector_transaction_id is present, we always sync with connector_transaction_id
ResponseId::ConnectorTransactionId(trans_id) => {
get_psync_url_with_connector_transaction_id(
trans_id,
self.base_url(connectors).to_string(),
)
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/bluesnap.rs" role="context" start="444" end="450">
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="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="397" end="399">
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="389" end="395">
fn get_headers(
&self,
req: &PaymentsSyncRouterData,
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="1357" end="1369">
fn get_url_with_merchant_transaction_id(
base_url: String,
merchant_id: common_utils::id_type::MerchantId,
merchant_transaction_id: String,
) -> CustomResult<String, errors::ConnectorError> {
Ok(format!(
"{}{}{},{}",
base_url,
"services/2/transactions/",
merchant_transaction_id,
merchant_id.get_string_repr()
))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/bluesnap.rs" role="context" start="1371" end="1379">
fn get_psync_url_with_connector_transaction_id(
connector_transaction_id: String,
base_url: String,
) -> CustomResult<String, errors::ConnectorError> {
Ok(format!(
"{}{}{}",
base_url, "services/2/transactions/", connector_transaction_id
))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/bluesnap/transformers.rs" role="context" start="206" end="208">
pub struct BluesnapConnectorMetaData {
pub merchant_id: common_utils::id_type::MerchantId,
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/hyperswitch_connectors/src/connectors/airwallex/transformers.rs<|crate|> hyperswitch_connectors<|connector|> airwallex 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/airwallex/transformers.rs" role="context" start="686" end="715">
fn try_from(
item: ResponseRouterData<
PSync,
AirwallexPaymentsSyncResponse,
PaymentsSyncData,
PaymentsResponseData,
>,
) -> Result<Self, Self::Error> {
let status = get_payment_status(&item.response.status, &item.response.next_action);
let redirection_data = if let Some(redirect_url_data) = item.response.next_action {
get_redirection_form(redirect_url_data)
} else {
None
};
Ok(Self {
status,
reference_id: Some(item.response.id.clone()),
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(item.response.id.clone()),
redirection_data: Box::new(redirection_data),
mandate_reference: Box::new(None),
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: Some(item.response.id),
incremental_authorization_allowed: None,
charges: None,
}),
..item.data
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/airwallex/transformers.rs" role="context" start="685" end="685">
use hyperswitch_domain_models::{
payment_method_data::{PaymentMethodData, WalletData},
router_data::{AccessToken, ConnectorAuthType, RouterData},
router_flow_types::{
refunds::{Execute, RSync},
PSync,
},
router_request_types::{PaymentsSyncData, ResponseId},
router_response_types::{PaymentsResponseData, RedirectForm, RefundsResponseData},
types,
};
use crate::{
types::{RefundsResponseRouterData, ResponseRouterData},
utils::{self, BrowserInformationData, CardData as _, PaymentsAuthorizeRequestData},
};
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/airwallex/transformers.rs" role="context" start="755" end="761">
fn from(item: RefundStatus) -> Self {
match item {
RefundStatus::Succeeded => Self::Success,
RefundStatus::Failed => Self::Failure,
RefundStatus::Received | RefundStatus::Accepted => Self::Pending,
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/airwallex/transformers.rs" role="context" start="730" end="739">
fn try_from(
item: &AirwallexRouterData<&types::RefundsRouterData<F>>,
) -> Result<Self, Self::Error> {
Ok(Self {
request_id: Uuid::new_v4().to_string(),
amount: Some(item.amount.to_owned()),
reason: item.router_data.request.reason.clone(),
payment_intent_id: item.router_data.request.connector_transaction_id.clone(),
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/airwallex/transformers.rs" role="context" start="611" end="672">
fn try_from(
item: ResponseRouterData<F, AirwallexPaymentsResponse, T, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
let (status, redirection_data) = item.response.next_action.clone().map_or(
// If no next action is there, map the status and set redirection form as None
(
get_payment_status(&item.response.status, &item.response.next_action),
None,
),
|response_url_data| {
// If the connector sends a customer action response that is already under
// process from our end it can cause an infinite loop to break this this check
// is added and fail the payment
if matches!(
(
response_url_data.stage.clone(),
item.data.status,
item.response.status.clone(),
),
// If the connector sends waiting for DDC and our status is already DDC Pending
// that means we initiated the call to collect the data and now we expect a different response
(
AirwallexNextActionStage::WaitingDeviceDataCollection,
enums::AttemptStatus::DeviceDataCollectionPending,
_
)
// If the connector sends waiting for Customer Action and our status is already Authenticaition Pending
// that means we initiated the call to authenticate and now we do not expect a requires_customer action
// it will start a loop
| (
_,
enums::AttemptStatus::AuthenticationPending,
AirwallexPaymentStatus::RequiresCustomerAction,
)
) {
// Fail the payment for above conditions
(enums::AttemptStatus::AuthenticationFailed, None)
} else {
(
//Build the redirect form and update the payment status
get_payment_status(&item.response.status, &item.response.next_action),
get_redirection_form(response_url_data),
)
}
},
);
Ok(Self {
status,
reference_id: Some(item.response.id.clone()),
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(item.response.id.clone()),
redirection_data: Box::new(redirection_data),
mandate_reference: Box::new(None),
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: Some(item.response.id),
incremental_authorization_allowed: None,
charges: None,
}),
..item.data
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/airwallex/transformers.rs" role="context" start="565" end="605">
fn get_redirection_form(response_url_data: AirwallexPaymentsNextAction) -> Option<RedirectForm> {
Some(RedirectForm::Form {
endpoint: response_url_data.url.to_string(),
method: response_url_data.method,
form_fields: std::collections::HashMap::from([
//Some form fields might be empty based on the authentication type by the connector
(
"JWT".to_string(),
response_url_data
.data
.jwt
.map(|jwt| jwt.expose())
.unwrap_or_default(),
),
(
"threeDSMethodData".to_string(),
response_url_data
.data
.three_ds_method_data
.map(|three_ds_method_data| three_ds_method_data.expose())
.unwrap_or_default(),
),
(
"token".to_string(),
response_url_data
.data
.token
.map(|token: Secret<String>| token.expose())
.unwrap_or_default(),
),
(
"provider".to_string(),
response_url_data.data.provider.unwrap_or_default(),
),
(
"version".to_string(),
response_url_data.data.version.unwrap_or_default(),
),
]),
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/airwallex/transformers.rs" role="context" start="492" end="515">
fn get_payment_status(
status: &AirwallexPaymentStatus,
next_action: &Option<AirwallexPaymentsNextAction>,
) -> enums::AttemptStatus {
match status.clone() {
AirwallexPaymentStatus::Succeeded => enums::AttemptStatus::Charged,
AirwallexPaymentStatus::Failed => enums::AttemptStatus::Failure,
AirwallexPaymentStatus::Pending => enums::AttemptStatus::Pending,
AirwallexPaymentStatus::RequiresPaymentMethod => enums::AttemptStatus::PaymentMethodAwaited,
AirwallexPaymentStatus::RequiresCustomerAction => next_action.as_ref().map_or(
enums::AttemptStatus::AuthenticationPending,
|next_action| match next_action.stage {
AirwallexNextActionStage::WaitingDeviceDataCollection => {
enums::AttemptStatus::DeviceDataCollectionPending
}
AirwallexNextActionStage::WaitingUserInfoInput => {
enums::AttemptStatus::AuthenticationPending
}
},
),
AirwallexPaymentStatus::RequiresCapture => enums::AttemptStatus::Authorized,
AirwallexPaymentStatus::Cancelled => enums::AttemptStatus::Voided,
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/airwallex/transformers.rs" role="context" start="33" end="33">
type Error = error_stack::Report<errors::ConnectorError>;
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/airwallex/transformers.rs" role="context" start="555" end="563">
pub struct AirwallexPaymentsSyncResponse {
status: AirwallexPaymentStatus,
//Unique identifier for the PaymentIntent
id: String,
amount: Option<f32>,
//ID of the PaymentConsent related to this PaymentIntent
payment_consent_id: Option<Secret<String>>,
next_action: Option<AirwallexPaymentsNextAction>,
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/types.rs" role="context" start="53" end="57">
pub struct ResponseRouterData<Flow, R, Request, Response> {
pub response: R,
pub data: RouterData<Flow, Request, Response>,
pub http_code: u16,
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/hyperswitch_connectors/src/connectors/klarna/transformers.rs<|crate|> hyperswitch_connectors<|connector|> klarna anchor=get_address_info kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/klarna/transformers.rs" role="context" start="344" end="365">
fn get_address_info(
address: Option<&hyperswitch_domain_models::address::Address>,
) -> Option<Result<KlarnaShippingAddress, error_stack::Report<errors::ConnectorError>>> {
address.and_then(|add| {
add.address.as_ref().map(
|address_details| -> Result<KlarnaShippingAddress, error_stack::Report<errors::ConnectorError>> {
Ok(KlarnaShippingAddress {
city: address_details.get_city()?.to_owned(),
country: address_details.get_country()?.to_owned(),
email: add.get_email()?.to_owned(),
postal_code: address_details.get_zip()?.to_owned(),
region: address_details.to_state_code()?.to_owned(),
street_address: address_details.get_line1()?.to_owned(),
street_address2: address_details.get_optional_line2(),
given_name: address_details.get_first_name()?.to_owned(),
family_name: address_details.get_last_name()?.to_owned(),
phone: add.get_phone_with_country_code()?.to_owned(),
})
},
)
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/klarna/transformers.rs" role="context" start="343" end="343">
use error_stack::{report, ResultExt};
use hyperswitch_domain_models::{
payment_method_data::{PayLaterData, PaymentMethodData},
router_data::{
AdditionalPaymentMethodConnectorResponse, ConnectorAuthType, ConnectorResponseData,
KlarnaSdkResponse, RouterData,
},
router_flow_types::refunds::{Execute, RSync},
router_request_types::{PaymentsCaptureData, ResponseId},
router_response_types::{PaymentsResponseData, RedirectForm, RefundsResponseData},
types,
};
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/klarna/transformers.rs" role="context" start="455" end="464">
fn try_from(auth_type: &ConnectorAuthType) -> Result<Self, Self::Error> {
if let ConnectorAuthType::BodyKey { api_key, key1 } = auth_type {
Ok(Self {
username: key1.to_owned(),
password: api_key.to_owned(),
})
} else {
Err(errors::ConnectorError::FailedToObtainAuthType.into())
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/klarna/transformers.rs" role="context" start="372" end="427">
fn try_from(item: PaymentsResponseRouterData<KlarnaAuthResponse>) -> Result<Self, Self::Error> {
match item.response {
KlarnaAuthResponse::KlarnaPaymentsAuthResponse(ref response) => {
let connector_response =
response
.authorized_payment_method
.as_ref()
.map(|authorized_payment_method| {
ConnectorResponseData::with_additional_payment_method_data(
AdditionalPaymentMethodConnectorResponse::from(
authorized_payment_method.clone(),
),
)
});
Ok(Self {
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(response.order_id.clone()),
redirection_data: Box::new(None),
mandate_reference: Box::new(None),
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: Some(response.order_id.clone()),
incremental_authorization_allowed: None,
charges: None,
}),
status: get_fraud_status(
response.fraud_status.clone(),
item.data.request.is_auto_capture()?,
),
connector_response,
..item.data
})
}
KlarnaAuthResponse::KlarnaCheckoutAuthResponse(ref response) => Ok(Self {
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(response.order_id.clone()),
redirection_data: Box::new(Some(RedirectForm::Html {
html_data: response.html_snippet.clone(),
})),
mandate_reference: Box::new(None),
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: Some(response.order_id.clone()),
incremental_authorization_allowed: None,
charges: None,
}),
status: get_checkout_status(
response.status.clone(),
item.data.request.is_auto_capture()?,
),
connector_response: None,
..item.data
}),
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/klarna/transformers.rs" role="context" start="242" end="341">
fn try_from(
item: &KlarnaRouterData<&types::PaymentsAuthorizeRouterData>,
) -> Result<Self, Self::Error> {
let request = &item.router_data.request;
let payment_method_data = request.payment_method_data.clone();
let return_url = item.router_data.request.get_router_return_url()?;
let webhook_url = item.router_data.request.get_webhook_url()?;
match payment_method_data {
PaymentMethodData::PayLater(PayLaterData::KlarnaSdk { .. }) => {
match request.order_details.clone() {
Some(order_details) => Ok(Self {
purchase_country: item.router_data.get_billing_country()?,
purchase_currency: request.currency,
order_amount: item.amount,
order_lines: order_details
.iter()
.map(|data| OrderLines {
name: data.product_name.clone(),
quantity: data.quantity,
unit_price: data.amount,
total_amount: data.amount * data.quantity,
total_tax_amount: None,
tax_rate: None,
})
.collect(),
merchant_reference1: Some(
item.router_data.connector_request_reference_id.clone(),
),
merchant_reference2: item
.router_data
.request
.merchant_order_reference_id
.clone(),
auto_capture: Some(request.is_auto_capture()?),
shipping_address: get_address_info(
item.router_data.get_optional_shipping(),
)
.transpose()?,
order_tax_amount: None,
payment_method_specifics: None,
}),
None => Err(report!(errors::ConnectorError::MissingRequiredField {
field_name: "order_details"
})),
}
}
PaymentMethodData::PayLater(PayLaterData::KlarnaRedirect {}) => {
match request.order_details.clone() {
Some(order_details) => Ok(Self {
purchase_country: item.router_data.get_billing_country()?,
purchase_currency: request.currency,
order_amount: item.amount
- request.order_tax_amount.unwrap_or(MinorUnit::zero()),
order_tax_amount: request.order_tax_amount,
order_lines: order_details
.iter()
.map(|data| OrderLines {
name: data.product_name.clone(),
quantity: data.quantity,
unit_price: data.amount,
total_amount: data.amount * data.quantity,
total_tax_amount: data.total_tax_amount,
tax_rate: data.tax_rate,
})
.collect(),
payment_method_specifics: Some(PaymentMethodSpecifics::KlarnaCheckout(
KlarnaCheckoutRequestData {
merchant_urls: MerchantURLs {
terms: return_url.clone(),
checkout: return_url.clone(),
confirmation: return_url,
push: webhook_url,
},
options: CheckoutOptions {
auto_capture: request.is_auto_capture()?,
},
},
)),
shipping_address: get_address_info(
item.router_data.get_optional_shipping(),
)
.transpose()?,
merchant_reference1: Some(
item.router_data.connector_request_reference_id.clone(),
),
merchant_reference2: item
.router_data
.request
.merchant_order_reference_id
.clone(),
auto_capture: None,
}),
None => Err(report!(errors::ConnectorError::MissingRequiredField {
field_name: "order_details"
})),
}
}
_ => Err(errors::ConnectorError::NotImplemented("Payment method".to_string()).into()),
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/klarna/transformers.rs" role="context" start="223" end="236">
fn try_from(
item: PaymentsSessionResponseRouterData<KlarnaSessionResponse>,
) -> Result<Self, Self::Error> {
let response = &item.response;
Ok(Self {
response: Ok(PaymentsResponseData::SessionResponse {
session_token: SessionToken::Klarna(Box::new(KlarnaSessionTokenResponse {
session_token: response.client_token.clone().expose(),
session_id: response.session_id.clone(),
})),
}),
..item.data
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/klarna/transformers.rs" role="context" start="184" end="216">
fn try_from(
item: &KlarnaRouterData<&types::PaymentsSessionRouterData>,
) -> Result<Self, Self::Error> {
let request = &item.router_data.request;
match request.order_details.clone() {
Some(order_details) => Ok(Self {
intent: KlarnaSessionIntent::Buy,
purchase_country: request.country.ok_or(
errors::ConnectorError::MissingRequiredField {
field_name: "billing.address.country",
},
)?,
purchase_currency: request.currency,
order_amount: item.amount,
order_lines: order_details
.iter()
.map(|data| OrderLines {
name: data.product_name.clone(),
quantity: data.quantity,
unit_price: data.amount,
total_amount: data.amount * data.quantity,
total_tax_amount: None,
tax_rate: None,
})
.collect(),
shipping_address: get_address_info(item.router_data.get_optional_shipping())
.transpose()?,
}),
None => Err(report!(errors::ConnectorError::MissingRequiredField {
field_name: "order_details",
})),
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/klarna/transformers.rs" role="context" start="159" end="170">
pub struct KlarnaShippingAddress {
city: String,
country: enums::CountryAlpha2,
email: pii::Email,
given_name: Secret<String>,
family_name: Secret<String>,
phone: Secret<String>,
postal_code: Secret<String>,
region: Secret<String>,
street_address: Secret<String>,
street_address2: 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 -----------------------
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/hyperswitch_connectors/src/connectors/trustpay/transformers.rs<|crate|> hyperswitch_connectors<|connector|> trustpay anchor=handle_bank_redirects_refund_response kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/trustpay/transformers.rs" role="context" start="1651" end="1677">
fn handle_bank_redirects_refund_response(
response: BankRedirectRefundResponse,
status_code: u16,
) -> (Option<ErrorResponse>, RefundsResponseData) {
let (refund_status, msg) = get_refund_status_from_result_info(response.result_info.result_code);
let error = if msg.is_some() {
Some(ErrorResponse {
code: response.result_info.result_code.to_string(),
// message vary for the same code, so relying on code alone as it is unique
message: response.result_info.result_code.to_string(),
reason: msg.map(|message| message.to_string()),
status_code,
attempt_status: None,
connector_transaction_id: None,
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
})
} else {
None
};
let refund_response_data = RefundsResponseData {
connector_refund_id: response.payment_request_id.to_string(),
refund_status,
};
(error, refund_response_data)
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/trustpay/transformers.rs" role="context" start="1650" end="1650">
use hyperswitch_domain_models::{
payment_method_data::{BankRedirectData, BankTransferData, Card, PaymentMethodData},
router_data::{AccessToken, ConnectorAuthType, ErrorResponse, RouterData},
router_request_types::{BrowserInformation, PaymentsPreProcessingData, ResponseId},
router_response_types::{
PaymentsResponseData, PreprocessingResponseId, RedirectForm, RefundsResponseData,
},
types::{
PaymentsAuthorizeRouterData, PaymentsPreProcessingRouterData, RefreshTokenRouterData,
RefundsRouterData,
},
};
use crate::{
types::{RefundsResponseRouterData, ResponseRouterData},
utils::{
self, AddressDetailsData, BrowserInformationData, CardData, PaymentsAuthorizeRequestData,
PaymentsPreProcessingRequestData, RouterData as OtherRouterData,
},
};
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/trustpay/transformers.rs" role="context" start="1718" end="1740">
fn handle_bank_redirects_refund_sync_error_response(
response: ErrorResponseBankRedirect,
status_code: u16,
) -> (Option<ErrorResponse>, RefundsResponseData) {
let error = Some(ErrorResponse {
code: response.payment_result_info.result_code.to_string(),
// message vary for the same code, so relying on code alone as it is unique
message: response.payment_result_info.result_code.to_string(),
reason: response.payment_result_info.additional_info,
status_code,
attempt_status: None,
connector_transaction_id: None,
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
});
//unreachable case as we are sending error as Some()
let refund_response_data = RefundsResponseData {
connector_refund_id: "".to_string(),
refund_status: enums::RefundStatus::Failure,
};
(error, refund_response_data)
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/trustpay/transformers.rs" role="context" start="1679" end="1716">
fn handle_bank_redirects_refund_sync_response(
response: SyncResponseBankRedirect,
status_code: u16,
) -> (Option<ErrorResponse>, RefundsResponseData) {
let refund_status = enums::RefundStatus::from(response.payment_information.status);
let error = if utils::is_refund_failure(refund_status) {
let reason_info = response
.payment_information
.status_reason_information
.unwrap_or_default();
Some(ErrorResponse {
code: reason_info
.reason
.code
.clone()
.unwrap_or(consts::NO_ERROR_CODE.to_string()),
// message vary for the same code, so relying on code alone as it is unique
message: reason_info
.reason
.code
.unwrap_or(consts::NO_ERROR_MESSAGE.to_string()),
reason: reason_info.reason.reject_reason,
status_code,
attempt_status: None,
connector_transaction_id: None,
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
})
} else {
None
};
let refund_response_data = RefundsResponseData {
connector_refund_id: response.payment_information.references.payment_request_id,
refund_status,
};
(error, refund_response_data)
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/trustpay/transformers.rs" role="context" start="1612" end="1649">
fn handle_webhooks_refund_response(
response: WebhookPaymentInformation,
status_code: u16,
) -> CustomResult<(Option<ErrorResponse>, RefundsResponseData), errors::ConnectorError> {
let refund_status = enums::RefundStatus::try_from(response.status)?;
let error = if utils::is_refund_failure(refund_status) {
let reason_info = response.status_reason_information.unwrap_or_default();
Some(ErrorResponse {
code: reason_info
.reason
.code
.clone()
.unwrap_or(consts::NO_ERROR_CODE.to_string()),
// message vary for the same code, so relying on code alone as it is unique
message: reason_info
.reason
.code
.unwrap_or(consts::NO_ERROR_MESSAGE.to_string()),
reason: reason_info.reason.reject_reason,
status_code,
attempt_status: None,
connector_transaction_id: response.references.payment_request_id.clone(),
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
})
} else {
None
};
let refund_response_data = RefundsResponseData {
connector_refund_id: response
.references
.payment_request_id
.ok_or(errors::ConnectorError::MissingConnectorRefundID)?,
refund_status,
};
Ok((error, refund_response_data))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/trustpay/transformers.rs" role="context" start="1583" end="1610">
fn handle_cards_refund_response(
response: CardsRefundResponse,
status_code: u16,
) -> CustomResult<(Option<ErrorResponse>, RefundsResponseData), errors::ConnectorError> {
let (refund_status, msg) = get_refund_status(&response.payment_status)?;
let error = if msg.is_some() {
Some(ErrorResponse {
code: response.payment_status,
message: msg
.clone()
.unwrap_or_else(|| consts::NO_ERROR_MESSAGE.to_string()),
reason: msg,
status_code,
attempt_status: None,
connector_transaction_id: None,
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
})
} else {
None
};
let refund_response_data = RefundsResponseData {
connector_refund_id: response.instance_id,
refund_status,
};
Ok((error, refund_response_data))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/trustpay/transformers.rs" role="context" start="1744" end="1766">
fn try_from(item: RefundsResponseRouterData<F, RefundResponse>) -> Result<Self, Self::Error> {
let (error, response) = match item.response {
RefundResponse::CardsRefund(response) => {
handle_cards_refund_response(*response, item.http_code)?
}
RefundResponse::WebhookRefund(response) => {
handle_webhooks_refund_response(*response, item.http_code)?
}
RefundResponse::BankRedirectRefund(response) => {
handle_bank_redirects_refund_response(*response, item.http_code)
}
RefundResponse::BankRedirectRefundSyncResponse(response) => {
handle_bank_redirects_refund_sync_response(*response, item.http_code)
}
RefundResponse::BankRedirectError(response) => {
handle_bank_redirects_refund_sync_error_response(*response, item.http_code)
}
};
Ok(Self {
response: error.map_or_else(|| Ok(response), Err),
..item.data
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/trustpay/transformers.rs" role="context" start="1787" end="1833">
fn get_refund_status_from_result_info(
result_code: i64,
) -> (enums::RefundStatus, Option<&'static str>) {
match result_code {
1001000 => (enums::RefundStatus::Success, None),
1130001 => (enums::RefundStatus::Pending, Some("MapiPending")),
1130000 => (enums::RefundStatus::Pending, Some("MapiSuccess")),
1130004 => (enums::RefundStatus::Pending, Some("MapiProcessing")),
1130002 => (enums::RefundStatus::Pending, Some("MapiAnnounced")),
1130003 => (enums::RefundStatus::Pending, Some("MapiAuthorized")),
1130005 => (enums::RefundStatus::Pending, Some("MapiAuthorizedOnly")),
1112008 => (enums::RefundStatus::Failure, Some("InvalidPaymentState")),
1112009 => (enums::RefundStatus::Failure, Some("RefundRejected")),
1122006 => (
enums::RefundStatus::Failure,
Some("AccountCurrencyNotAllowed"),
),
1132000 => (enums::RefundStatus::Failure, Some("InvalidMapiRequest")),
1132001 => (enums::RefundStatus::Failure, Some("UnknownAccount")),
1132002 => (
enums::RefundStatus::Failure,
Some("MerchantAccountDisabled"),
),
1132003 => (enums::RefundStatus::Failure, Some("InvalidSign")),
1132004 => (enums::RefundStatus::Failure, Some("DisposableBalance")),
1132005 => (enums::RefundStatus::Failure, Some("TransactionNotFound")),
1132006 => (enums::RefundStatus::Failure, Some("UnsupportedTransaction")),
1132007 => (enums::RefundStatus::Failure, Some("GeneralMapiError")),
1132008 => (
enums::RefundStatus::Failure,
Some("UnsupportedCurrencyConversion"),
),
1132009 => (enums::RefundStatus::Failure, Some("UnknownMandate")),
1132010 => (enums::RefundStatus::Failure, Some("CanceledMandate")),
1132011 => (enums::RefundStatus::Failure, Some("MissingCid")),
1132012 => (enums::RefundStatus::Failure, Some("MandateAlreadyPaid")),
1132013 => (enums::RefundStatus::Failure, Some("AccountIsTesting")),
1132014 => (enums::RefundStatus::Failure, Some("RequestThrottled")),
1133000 => (enums::RefundStatus::Failure, Some("InvalidAuthentication")),
1133001 => (enums::RefundStatus::Failure, Some("ServiceNotAllowed")),
1133002 => (enums::RefundStatus::Failure, Some("PaymentRequestNotFound")),
1133003 => (enums::RefundStatus::Failure, Some("UnexpectedGateway")),
1133004 => (enums::RefundStatus::Failure, Some("MissingExternalId")),
1152000 => (enums::RefundStatus::Failure, Some("RiskDecline")),
_ => (enums::RefundStatus::Pending, None),
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/trustpay/transformers.rs" role="context" start="1568" end="1571">
pub struct BankRedirectRefundResponse {
pub payment_request_id: i64,
pub result_info: ResultInfo,
}
<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/globalpay/transformers.rs<|crate|> hyperswitch_connectors<|connector|> globalpay 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/globalpay/transformers.rs" role="context" start="319" end="345">
fn try_from(
item: ResponseRouterData<F, GlobalpayPaymentsResponse, T, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
let status = common_enums::AttemptStatus::from(item.response.status);
let redirect_url = item
.response
.payment_method
.as_ref()
.and_then(|payment_method| {
payment_method
.apm
.as_ref()
.and_then(|apm| apm.redirect_url.as_ref())
})
.filter(|redirect_str| !redirect_str.is_empty())
.map(|url| {
Url::parse(url).change_context(errors::ConnectorError::FailedToObtainIntegrationUrl)
})
.transpose()?;
let redirection_data = redirect_url.map(|url| RedirectForm::from((url, Method::Get)));
Ok(Self {
status,
response: get_payment_response(status, item.response, redirection_data)
.map_err(|err| *err),
..item.data
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/globalpay/transformers.rs" role="context" start="318" end="318">
use common_utils::{
crypto::{self, GenerateDigest},
errors::ParsingError,
pii,
request::Method,
types::{AmountConvertor, MinorUnit, StringMinorUnit, StringMinorUnitForConnector},
};
use hyperswitch_domain_models::{
payment_method_data,
router_data::{AccessToken, ConnectorAuthType, ErrorResponse, RouterData},
router_flow_types::{Execute, RSync},
router_request_types::ResponseId,
router_response_types::{
MandateReference, PaymentsResponseData, RedirectForm, RefundsResponseData,
},
types::{
PaymentsAuthorizeRouterData, PaymentsCancelRouterData, PaymentsCaptureRouterData,
PaymentsSyncRouterData, RefreshTokenRouterData, RefundExecuteRouterData, RefundsRouterData,
},
};
use url::Url;
use super::{
requests::{
self, ApmProvider, GlobalPayRouterData, GlobalpayCancelRouterData,
GlobalpayPaymentsRequest, GlobalpayRefreshTokenRequest, Initiator, PaymentMethodData,
Sequence, StoredCredential,
},
response::{GlobalpayPaymentStatus, GlobalpayPaymentsResponse, GlobalpayRefreshTokenResponse},
};
use crate::{
types::{PaymentsSyncResponseRouterData, RefundsResponseRouterData, ResponseRouterData},
utils::{
self, construct_captures_response_hashmap, CardData, ForeignTryFrom,
MultipleCaptureSyncResponse, PaymentsAuthorizeRequestData, RouterData as _, WalletData,
},
};
type Error = error_stack::Report<errors::ConnectorError>;
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/globalpay/transformers.rs" role="context" start="381" end="391">
fn try_from(
item: ResponseRouterData<F, GlobalpayRefreshTokenResponse, T, AccessToken>,
) -> Result<Self, Self::Error> {
Ok(Self {
response: Ok(AccessToken {
token: item.response.token,
expires: item.response.seconds_to_expire,
}),
..item.data
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/globalpay/transformers.rs" role="context" start="356" end="374">
fn foreign_try_from(
(value, is_multiple_capture_sync): (
PaymentsSyncResponseRouterData<GlobalpayPaymentsResponse>,
bool,
),
) -> Result<Self, Self::Error> {
if is_multiple_capture_sync {
let capture_sync_response_list =
construct_captures_response_hashmap(vec![value.response])?;
Ok(Self {
response: Ok(PaymentsResponseData::MultipleCaptureResponse {
capture_sync_response_list,
}),
..value.data
})
} else {
Self::try_from(value)
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/globalpay/transformers.rs" role="context" start="278" end="313">
fn get_payment_response(
status: common_enums::AttemptStatus,
response: GlobalpayPaymentsResponse,
redirection_data: Option<RedirectForm>,
) -> Result<PaymentsResponseData, Box<ErrorResponse>> {
let mandate_reference = response.payment_method.as_ref().and_then(|pm| {
pm.card
.as_ref()
.and_then(|card| card.brand_reference.to_owned())
.map(|id| MandateReference {
connector_mandate_id: Some(id.expose()),
payment_method_id: None,
mandate_metadata: None,
connector_mandate_request_reference_id: None,
})
});
match status {
common_enums::AttemptStatus::Failure => Err(Box::new(ErrorResponse {
message: response
.payment_method
.and_then(|pm| pm.message)
.unwrap_or_else(|| NO_ERROR_MESSAGE.to_string()),
..Default::default()
})),
_ => Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(response.id),
redirection_data: Box::new(redirection_data),
mandate_reference: Box::new(mandate_reference),
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: response.reference,
incremental_authorization_allowed: None,
charges: None,
}),
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/globalpay/transformers.rs" role="context" start="269" end="275">
fn from(capture_method: Option<common_enums::CaptureMethod>) -> Self {
match capture_method {
Some(common_enums::CaptureMethod::Manual) => Self::Later,
Some(common_enums::CaptureMethod::ManualMultiple) => Self::Multiple,
_ => Self::Auto,
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/globalpay/transformers.rs" role="context" start="62" end="62">
type Error = error_stack::Report<errors::ConnectorError>;
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/globalpay/requests.rs" role="context" start="685" end="688">
pub enum Method {
Ksn,
Ktb,
}
<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=paypal_threeds_link 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="2172" end="2198">
fn paypal_threeds_link(
(redirect_url, complete_auth_url): (Option<Url>, Option<String>),
) -> CustomResult<RedirectForm, errors::ConnectorError> {
let mut redirect_url =
redirect_url.ok_or(errors::ConnectorError::ResponseDeserializationFailed)?;
let complete_auth_url =
complete_auth_url.ok_or(errors::ConnectorError::MissingRequiredField {
field_name: "complete_authorize_url",
})?;
let mut form_fields = std::collections::HashMap::from_iter(
redirect_url
.query_pairs()
.map(|(key, value)| (key.to_string(), value.to_string())),
);
// paypal requires return url to be passed as a field along with payer_action_url
form_fields.insert(String::from("redirect_uri"), complete_auth_url);
// Do not include query params in the endpoint
redirect_url.set_query(None);
Ok(RedirectForm::Form {
endpoint: redirect_url.to_string(),
method: Method::Get,
form_fields,
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/paypal/transformers.rs" role="context" start="2171" end="2171">
use common_enums::enums as storage_enums;
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,
},
};
use url::Url;
use crate::{
types::{PaymentsCaptureResponseRouterData, RefundsResponseRouterData, ResponseRouterData},
utils::{
self, missing_field_err, to_connector_meta, AccessTokenRequestInfo, AddressDetailsData,
CardData, PaymentsAuthorizeRequestData, PaymentsPostSessionTokensRequestData,
RouterData as OtherRouterData,
},
};
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/paypal/transformers.rs" role="context" start="2300" end="2310">
fn try_from(
item: &PaypalRouterData<&PayoutsRouterData<PoFulfill>>,
) -> Result<Self, Self::Error> {
let item_data = PaypalPayoutItem::try_from(item)?;
Ok(Self {
sender_batch_header: PayoutBatchHeader {
sender_batch_id: item.router_data.request.payout_id.to_owned(),
},
items: vec![item_data],
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/paypal/transformers.rs" role="context" start="2204" end="2231">
fn try_from(
item: ResponseRouterData<F, PaypalPaymentsSyncResponse, T, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
Ok(Self {
status: storage_enums::AttemptStatus::from(item.response.status),
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(
item.response
.supplementary_data
.related_ids
.order_id
.clone(),
),
redirection_data: Box::new(None),
mandate_reference: Box::new(None),
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: item
.response
.invoice_id
.clone()
.or(Some(item.response.supplementary_data.related_ids.order_id)),
incremental_authorization_allowed: None,
charges: None,
}),
..item.data
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/paypal/transformers.rs" role="context" start="2130" end="2169">
fn try_from(
item: ResponseRouterData<
F,
PaypalThreeDsResponse,
PaymentsAuthorizeData,
PaymentsResponseData,
>,
) -> Result<Self, Self::Error> {
let connector_meta = serde_json::json!(PaypalMeta {
authorize_id: None,
capture_id: None,
psync_flow: PaypalPaymentIntent::Authenticate, // when there is no capture or auth id present
next_action: None,
order_id: None,
});
let status = get_order_status(
item.response.clone().status,
PaypalPaymentIntent::Authenticate,
);
let link = get_redirect_url(item.response.links.clone())?;
Ok(Self {
status,
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(item.response.id),
redirection_data: Box::new(Some(paypal_threeds_link((
link,
item.data.request.complete_authorize_url.clone(),
))?)),
mandate_reference: Box::new(None),
connector_metadata: Some(connector_meta),
network_txn_id: None,
connector_response_reference_id: None,
incremental_authorization_allowed: None,
charges: None,
}),
..item.data
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/paypal/transformers.rs" role="context" start="2097" end="2121">
fn try_from(
item: ResponseRouterData<
F,
PaypalThreeDsSyncResponse,
PaymentsSyncData,
PaymentsResponseData,
>,
) -> Result<Self, Self::Error> {
Ok(Self {
// status is hardcoded because this try_from will only be reached in card 3ds before the completion of complete authorize flow.
// also force sync won't be hit in terminal status thus leaving us with only one status to get here.
status: storage_enums::AttemptStatus::AuthenticationPending,
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(item.response.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
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/paypal/transformers.rs" role="context" start="3166" end="3171">
fn from(error: ErrorDetails) -> Self {
Self {
error_code: error.issue.to_string(),
error_message: error.issue.to_string(),
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/globalpay/requests.rs" role="context" start="685" end="688">
pub enum Method {
Ksn,
Ktb,
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/hyperswitch_connectors/src/connectors/nexinets/transformers.rs<|crate|> hyperswitch_connectors<|connector|> nexinets anchor=get_card_data kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/nexinets/transformers.rs" role="context" start="636" end="662">
fn get_card_data(
item: &PaymentsAuthorizeRouterData,
card: &Card,
) -> Result<NexinetsPaymentDetails, errors::ConnectorError> {
let (card_data, cof_contract) = match item.request.is_mandate_payment() {
true => {
let card_data = match item.request.off_session {
Some(true) => CardDataDetails::PaymentInstrument(Box::new(PaymentInstrument {
payment_instrument_id: item.request.connector_mandate_id().map(Secret::new),
})),
_ => CardDataDetails::CardDetails(Box::new(get_card_details(card)?)),
};
let cof_contract = Some(CofContract {
recurring_type: RecurringType::Unscheduled,
});
(card_data, cof_contract)
}
false => (
CardDataDetails::CardDetails(Box::new(get_card_details(card)?)),
None,
),
};
Ok(NexinetsPaymentDetails::Card(Box::new(NexiCardDetails {
card_data,
cof_contract,
})))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/nexinets/transformers.rs" role="context" start="635" end="635">
use common_utils::{consts, errors::CustomResult, request::Method};
use hyperswitch_domain_models::{
payment_method_data::{
ApplePayWalletData, BankRedirectData, Card, PaymentMethodData, WalletData,
},
router_data::{ConnectorAuthType, RouterData},
router_flow_types::{Execute, RSync},
router_request_types::ResponseId,
router_response_types::{
MandateReference, PaymentsResponseData, RedirectForm, RefundsResponseData,
},
types::{
PaymentsAuthorizeRouterData, PaymentsCancelRouterData, PaymentsCaptureRouterData,
RefundsRouterData,
},
};
use masking::{ExposeInterface, PeekInterface, Secret};
use crate::{
types::{RefundsResponseRouterData, ResponseRouterData},
utils::{
self, CardData, PaymentsAuthorizeRequestData, PaymentsCancelRequestData, WalletData as _,
},
};
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/nexinets/transformers.rs" role="context" start="680" end="687">
fn get_card_details(req_card: &Card) -> Result<CardDetails, errors::ConnectorError> {
Ok(CardDetails {
card_number: req_card.card_number.clone(),
expiry_month: req_card.card_exp_month.clone(),
expiry_year: req_card.get_card_expiry_year_2_digit()?,
verification: req_card.card_cvc.clone(),
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/nexinets/transformers.rs" role="context" start="664" end="678">
fn get_applepay_details(
wallet_data: &WalletData,
applepay_data: &ApplePayWalletData,
) -> CustomResult<ApplePayDetails, errors::ConnectorError> {
let payment_data = WalletData::get_wallet_token_as_json(wallet_data, "Apple Pay".to_string())?;
Ok(ApplePayDetails {
payment_data,
payment_method: ApplepayPaymentMethod {
display_name: applepay_data.payment_method.display_name.to_owned(),
network: applepay_data.payment_method.network.to_owned(),
token_type: applepay_data.payment_method.pm_type.to_owned(),
},
transaction_identifier: applepay_data.transaction_identifier.to_owned(),
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/nexinets/transformers.rs" role="context" start="567" end="634">
fn get_payment_details_and_product(
item: &PaymentsAuthorizeRouterData,
) -> Result<
(Option<NexinetsPaymentDetails>, NexinetsProduct),
error_stack::Report<errors::ConnectorError>,
> {
match &item.request.payment_method_data {
PaymentMethodData::Card(card) => Ok((
Some(get_card_data(item, card)?),
NexinetsProduct::Creditcard,
)),
PaymentMethodData::Wallet(wallet) => Ok(get_wallet_details(wallet)?),
PaymentMethodData::BankRedirect(bank_redirect) => match bank_redirect {
BankRedirectData::Eps { .. } => Ok((None, NexinetsProduct::Eps)),
BankRedirectData::Giropay { .. } => Ok((None, NexinetsProduct::Giropay)),
BankRedirectData::Ideal { bank_name, .. } => Ok((
Some(NexinetsPaymentDetails::BankRedirects(Box::new(
NexinetsBankRedirects {
bic: bank_name
.map(|bank_name| NexinetsBIC::try_from(&bank_name))
.transpose()?,
},
))),
NexinetsProduct::Ideal,
)),
BankRedirectData::Sofort { .. } => Ok((None, NexinetsProduct::Sofort)),
BankRedirectData::BancontactCard { .. }
| BankRedirectData::Blik { .. }
| BankRedirectData::Bizum { .. }
| BankRedirectData::Eft { .. }
| BankRedirectData::Interac { .. }
| BankRedirectData::OnlineBankingCzechRepublic { .. }
| BankRedirectData::OnlineBankingFinland { .. }
| BankRedirectData::OnlineBankingPoland { .. }
| BankRedirectData::OnlineBankingSlovakia { .. }
| BankRedirectData::OpenBankingUk { .. }
| BankRedirectData::Przelewy24 { .. }
| BankRedirectData::Trustly { .. }
| BankRedirectData::OnlineBankingFpx { .. }
| BankRedirectData::OnlineBankingThailand { .. }
| BankRedirectData::LocalBankRedirect {} => {
Err(errors::ConnectorError::NotImplemented(
utils::get_unimplemented_payment_method_error_message("nexinets"),
))?
}
},
PaymentMethodData::CardRedirect(_)
| PaymentMethodData::PayLater(_)
| 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("nexinets"),
))?
}
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/nexinets/transformers.rs" role="context" start="539" end="549">
fn try_from(
item: RefundsResponseRouterData<RSync, NexinetsRefundResponse>,
) -> Result<Self, Self::Error> {
Ok(Self {
response: Ok(RefundsResponseData {
connector_refund_id: item.response.transaction_id,
refund_status: enums::RefundStatus::from(item.response.status),
}),
..item.data
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/nexinets/transformers.rs" role="context" start="113" end="115">
pub enum RecurringType {
Unscheduled,
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/nexinets/transformers.rs" role="context" start="106" end="109">
pub struct CofContract {
#[serde(rename = "type")]
recurring_type: RecurringType,
}
<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>>,
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/hyperswitch_connectors/src/connectors/braintree/transformers.rs<|crate|> hyperswitch_connectors<|connector|> braintree 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/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="1117" end="1117">
use common_enums::enums;
use hyperswitch_domain_models::{
payment_method_data::PaymentMethodData,
router_data::{ConnectorAuthType, PaymentMethodToken, RouterData},
router_flow_types::refunds::{Execute, RSync},
router_request_types::{
CompleteAuthorizeData, MandateRevokeRequestData, PaymentsAuthorizeData, ResponseId,
},
router_response_types::{
MandateReference, MandateRevokeResponseData, PaymentsResponseData, RedirectForm,
RefundsResponseData,
},
types::{self, RefundsRouterData},
};
use crate::{
types::{PaymentsCaptureResponseRouterData, RefundsResponseRouterData, ResponseRouterData},
unimplemented_payment_method,
utils::{
self, PaymentsAuthorizeRequestData, PaymentsCompleteAuthorizeRequestData,
RefundsRequestData, RouterData as _,
},
};
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/braintree/transformers.rs" role="context" start="1279" end="1303">
fn try_from(
item: ResponseRouterData<F, BraintreeTokenResponse, T, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
Ok(Self {
response: match item.response {
BraintreeTokenResponse::ErrorResponse(error_response) => {
build_error_response(error_response.errors.as_ref(), item.http_code)
.map_err(|err| *err)
}
BraintreeTokenResponse::TokenResponse(token_response) => {
Ok(PaymentsResponseData::TokenizationResponse {
token: token_response
.data
.tokenize_credit_card
.payment_method
.id
.expose()
.clone(),
})
}
},
..item.data
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/braintree/transformers.rs" role="context" start="1179" end="1221">
fn try_from(item: &types::TokenizationRouterData) -> Result<Self, Self::Error> {
match item.request.payment_method_data.clone() {
PaymentMethodData::Card(card_data) => Ok(Self {
query: TOKENIZE_CREDIT_CARD.to_string(),
variables: VariableInput {
input: InputData {
credit_card: CreditCardData {
number: card_data.card_number,
expiration_year: card_data.card_exp_year,
expiration_month: card_data.card_exp_month,
cvv: card_data.card_cvc,
cardholder_name: item
.get_optional_billing_full_name()
.unwrap_or(Secret::new("".to_string())),
},
},
},
}),
PaymentMethodData::CardRedirect(_)
| PaymentMethodData::Wallet(_)
| PaymentMethodData::PayLater(_)
| PaymentMethodData::BankRedirect(_)
| PaymentMethodData::BankDebit(_)
| PaymentMethodData::BankTransfer(_)
| PaymentMethodData::Crypto(_)
| PaymentMethodData::MandatePayment
| PaymentMethodData::OpenBanking(_)
| PaymentMethodData::Reward
| PaymentMethodData::RealTimePayment(_)
| PaymentMethodData::MobilePayment(_)
| PaymentMethodData::Upi(_)
| PaymentMethodData::Voucher(_)
| PaymentMethodData::GiftCard(_)
| PaymentMethodData::CardToken(_)
| PaymentMethodData::NetworkToken(_)
| PaymentMethodData::CardDetailsForNetworkTransactionId(_) => {
Err(errors::ConnectorError::NotImplemented(
utils::get_unimplemented_payment_method_error_message("braintree"),
)
.into())
}
}
}
<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="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="531" end="556">
fn build_error_response<T>(
response: &[ErrorDetails],
http_code: u16,
) -> Result<T, Box<hyperswitch_domain_models::router_data::ErrorResponse>> {
let error_messages = response
.iter()
.map(|error| error.message.to_string())
.collect::<Vec<String>>();
let reason = match !error_messages.is_empty() {
true => Some(error_messages.join(" ")),
false => None,
};
get_error_response(
response
.first()
.and_then(|err_details| err_details.extensions.as_ref())
.and_then(|extensions| extensions.legacy_code.clone()),
response
.first()
.map(|err_details| err_details.message.clone()),
reason,
http_code,
)
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/braintree/transformers.rs" role="context" start="116" end="116">
type Error = error_stack::Report<errors::ConnectorError>;
<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/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/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="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="578" end="578">
use common_utils::{
consts::{PROPHETPAY_REDIRECT_URL, PROPHETPAY_TOKEN},
errors::CustomResult,
request::Method,
};
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="552" end="562">
fn try_from(item: &types::PaymentsCancelRouterData) -> Result<Self, Self::Error> {
let auth_data = ProphetpayAuthType::try_from(&item.connector_auth_type)?;
let transaction_id = item.request.connector_transaction_id.to_owned();
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="502" end="537">
fn try_from(
item: ResponseRouterData<F, ProphetpayVoidResponse, T, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
if item.response.success {
Ok(Self {
status: enums::AttemptStatus::Voided,
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(item.response.transaction_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: enums::AttemptStatus::VoidFailed,
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="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="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="375" end="377">
pub struct ProphetpayCardTokenData {
card_token: Secret<String>,
}
<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);
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/hyperswitch_connectors/src/connectors/zen/transformers.rs<|crate|> hyperswitch_connectors<|connector|> zen anchor=get_zen_refund_response kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/zen/transformers.rs" role="context" start="1074" end="1104">
fn get_zen_refund_response(
response: RefundResponse,
status_code: u16,
) -> CustomResult<(Option<ErrorResponse>, RefundsResponseData), errors::ConnectorError> {
let refund_status = enums::RefundStatus::from(response.status);
let error = if utils::is_refund_failure(refund_status) {
Some(ErrorResponse {
code: response
.reject_code
.unwrap_or_else(|| NO_ERROR_CODE.to_string()),
message: response
.reject_reason
.clone()
.unwrap_or_else(|| NO_ERROR_MESSAGE.to_string()),
reason: response.reject_reason,
status_code,
attempt_status: None,
connector_transaction_id: Some(response.id.clone()),
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
})
} else {
None
};
let refund_response_data = RefundsResponseData {
connector_refund_id: response.id,
refund_status,
};
Ok((error, refund_response_data))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/zen/transformers.rs" role="context" start="1073" end="1073">
use common_enums::enums;
use common_utils::{
errors::CustomResult,
ext_traits::{OptionExt, ValueExt},
pii::{self},
request::Method,
};
use hyperswitch_domain_models::{
payment_method_data::{
BankDebitData, BankRedirectData, BankTransferData, Card, CardRedirectData, GiftCardData,
PayLaterData, PaymentMethodData, VoucherData, WalletData,
},
router_data::{ConnectorAuthType, ErrorResponse, RouterData},
router_flow_types::refunds::{Execute, RSync},
router_request_types::{BrowserInformation, ResponseId},
router_response_types::{PaymentsResponseData, RedirectForm, RefundsResponseData},
types,
};
use hyperswitch_interfaces::{
api,
consts::{NO_ERROR_CODE, NO_ERROR_MESSAGE},
errors,
};
use crate::{
types::{RefundsResponseRouterData, ResponseRouterData},
utils::{
self, BrowserInformationData, CardData, ForeignTryFrom, PaymentsAuthorizeRequestData,
RouterData as _,
},
};
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/zen/transformers.rs" role="context" start="1108" end="1119">
fn try_from(
item: RefundsResponseRouterData<RSync, RefundResponse>,
) -> Result<Self, Self::Error> {
let refund_status = enums::RefundStatus::from(item.response.status);
Ok(Self {
response: Ok(RefundsResponseData {
connector_refund_id: item.response.id,
refund_status,
}),
..item.data
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/zen/transformers.rs" role="context" start="1063" end="1071">
fn try_from(
item: RefundsResponseRouterData<Execute, RefundResponse>,
) -> Result<Self, Self::Error> {
let (error, refund_response_data) = get_zen_refund_response(item.response, item.http_code)?;
Ok(Self {
response: error.map_or_else(|| Ok(refund_response_data), Err),
..item.data
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/zen/transformers.rs" role="context" start="1041" end="1047">
fn from(item: RefundStatus) -> Self {
match item {
RefundStatus::Accepted => Self::Success,
RefundStatus::Pending | RefundStatus::Authorized => Self::Pending,
RefundStatus::Rejected => Self::Failure,
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/zen/transformers.rs" role="context" start="1052" end="1057">
pub struct RefundResponse {
id: String,
status: RefundStatus,
reject_code: Option<String>,
reject_reason: Option<String>,
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/zen/transformers.rs" role="context" start="1032" end="1038">
pub enum RefundStatus {
Authorized,
Accepted,
#[default]
Pending,
Rejected,
}
<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/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/trustpay/transformers.rs<|crate|> hyperswitch_connectors<|connector|> trustpay 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/trustpay/transformers.rs" role="context" start="1290" end="1314">
fn try_from(
item: ResponseRouterData<
F,
TrustpayCreateIntentResponse,
PaymentsPreProcessingData,
PaymentsResponseData,
>,
) -> Result<Self, Self::Error> {
let create_intent_response = item.response.init_result_data.to_owned();
let secrets = item.response.secrets.to_owned();
let instance_id = item.response.instance_id.to_owned();
let pmt = PaymentsPreProcessingData::get_payment_method_type(&item.data.request)?;
match (pmt, create_intent_response) {
(
enums::PaymentMethodType::ApplePay,
InitResultData::AppleInitResultData(apple_pay_response),
) => get_apple_pay_session(instance_id, &secrets, apple_pay_response, item),
(
enums::PaymentMethodType::GooglePay,
InitResultData::GoogleInitResultData(google_pay_response),
) => get_google_pay_session(instance_id, &secrets, google_pay_response, item),
_ => Err(report!(errors::ConnectorError::InvalidWallet)),
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/trustpay/transformers.rs" role="context" start="1289" end="1289">
use common_enums::enums;
use common_utils::{
errors::CustomResult,
pii::{self, Email},
request::Method,
types::StringMajorUnit,
};
use error_stack::{report, ResultExt};
use hyperswitch_domain_models::{
payment_method_data::{BankRedirectData, BankTransferData, Card, PaymentMethodData},
router_data::{AccessToken, ConnectorAuthType, ErrorResponse, RouterData},
router_request_types::{BrowserInformation, PaymentsPreProcessingData, ResponseId},
router_response_types::{
PaymentsResponseData, PreprocessingResponseId, RedirectForm, RefundsResponseData,
},
types::{
PaymentsAuthorizeRouterData, PaymentsPreProcessingRouterData, RefreshTokenRouterData,
RefundsRouterData,
},
};
use crate::{
types::{RefundsResponseRouterData, ResponseRouterData},
utils::{
self, AddressDetailsData, BrowserInformationData, CardData, PaymentsAuthorizeRequestData,
PaymentsPreProcessingRequestData, RouterData as OtherRouterData,
},
};
type Error = error_stack::Report<errors::ConnectorError>;
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/trustpay/transformers.rs" role="context" start="1369" end="1412">
pub fn get_google_pay_session<F, T>(
instance_id: String,
secrets: &SdkSecretInfo,
google_pay_init_result: TrustpayGooglePayResponse,
item: ResponseRouterData<F, TrustpayCreateIntentResponse, T, PaymentsResponseData>,
) -> Result<RouterData<F, T, PaymentsResponseData>, error_stack::Report<errors::ConnectorError>> {
Ok(RouterData {
response: Ok(PaymentsResponseData::PreProcessingResponse {
connector_metadata: None,
pre_processing_id: PreprocessingResponseId::ConnectorTransactionId(instance_id),
session_token: Some(SessionToken::GooglePay(Box::new(
api_models::payments::GpaySessionTokenResponse::GooglePaySession(
api_models::payments::GooglePaySessionResponse {
connector: "trustpay".to_string(),
delayed_session_token: true,
sdk_next_action: {
api_models::payments::SdkNextAction {
next_action: api_models::payments::NextActionCall::Sync,
}
},
merchant_info: google_pay_init_result.merchant_info.into(),
allowed_payment_methods: google_pay_init_result
.allowed_payment_methods
.into_iter()
.map(Into::into)
.collect(),
transaction_info: google_pay_init_result.transaction_info.into(),
secrets: Some((*secrets).clone().into()),
shipping_address_required: false,
email_required: false,
shipping_address_parameters:
api_models::payments::GpayShippingAddressParameters {
phone_number_required: false,
},
},
),
))),
connector_response_reference_id: None,
}),
// We don't get status from TrustPay but status should be AuthenticationPending by default for session response
status: enums::AttemptStatus::AuthenticationPending,
..item.data
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/trustpay/transformers.rs" role="context" start="1317" end="1367">
pub fn get_apple_pay_session<F, T>(
instance_id: String,
secrets: &SdkSecretInfo,
apple_pay_init_result: TrustpayApplePayResponse,
item: ResponseRouterData<F, TrustpayCreateIntentResponse, T, PaymentsResponseData>,
) -> Result<RouterData<F, T, PaymentsResponseData>, error_stack::Report<errors::ConnectorError>> {
Ok(RouterData {
response: Ok(PaymentsResponseData::PreProcessingResponse {
connector_metadata: None,
pre_processing_id: PreprocessingResponseId::ConnectorTransactionId(instance_id),
session_token: Some(SessionToken::ApplePay(Box::new(
api_models::payments::ApplepaySessionTokenResponse {
session_token_data: Some(
api_models::payments::ApplePaySessionResponse::ThirdPartySdk(
api_models::payments::ThirdPartySdkSessionResponse {
secrets: secrets.to_owned().into(),
},
),
),
payment_request_data: Some(api_models::payments::ApplePayPaymentRequest {
country_code: apple_pay_init_result.country_code,
currency_code: apple_pay_init_result.currency_code,
supported_networks: Some(apple_pay_init_result.supported_networks.clone()),
merchant_capabilities: Some(
apple_pay_init_result.merchant_capabilities.clone(),
),
total: apple_pay_init_result.total.into(),
merchant_identifier: None,
required_billing_contact_fields: None,
required_shipping_contact_fields: None,
recurring_payment_request: None,
}),
connector: "trustpay".to_string(),
delayed_session_token: true,
sdk_next_action: {
api_models::payments::SdkNextAction {
next_action: api_models::payments::NextActionCall::Sync,
}
},
connector_reference_id: None,
connector_sdk_public_key: None,
connector_merchant_id: None,
},
))),
connector_response_reference_id: None,
}),
// We don't get status from TrustPay but status should be AuthenticationPending by default for session response
status: enums::AttemptStatus::AuthenticationPending,
..item.data
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/trustpay/transformers.rs" role="context" start="1150" end="1177">
fn try_from(
item: &TrustpayRouterData<&PaymentsPreProcessingRouterData>,
) -> Result<Self, Self::Error> {
let is_apple_pay = item
.router_data
.request
.payment_method_type
.as_ref()
.map(|pmt| matches!(pmt, enums::PaymentMethodType::ApplePay));
let is_google_pay = item
.router_data
.request
.payment_method_type
.as_ref()
.map(|pmt| matches!(pmt, enums::PaymentMethodType::GooglePay));
let currency = item.router_data.request.get_currency()?;
let amount = item.amount.to_owned();
Ok(Self {
amount,
currency: currency.to_string(),
init_apple_pay: is_apple_pay,
init_google_pay: is_google_pay,
reference: item.router_data.connector_request_reference_id.clone(),
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/trustpay/transformers.rs" role="context" start="1104" end="1131">
fn try_from(
item: ResponseRouterData<F, TrustpayAuthUpdateResponse, T, AccessToken>,
) -> Result<Self, Self::Error> {
match (item.response.access_token, item.response.expires_in) {
(Some(access_token), Some(expires_in)) => Ok(Self {
response: Ok(AccessToken {
token: access_token,
expires: expires_in,
}),
..item.data
}),
_ => Ok(Self {
response: Err(ErrorResponse {
code: item.response.result_info.result_code.to_string(),
// message vary for the same code, so relying on code alone as it is unique
message: item.response.result_info.result_code.to_string(),
reason: item.response.result_info.additional_info,
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/trustpay/transformers.rs" role="context" start="37" end="37">
type Error = error_stack::Report<errors::ConnectorError>;
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/trustpay/transformers.rs" role="context" start="1194" end="1197">
pub enum InitResultData {
AppleInitResultData(TrustpayApplePayResponse),
GoogleInitResultData(TrustpayGooglePayResponse),
}
<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/redsys/transformers.rs<|crate|> hyperswitch_connectors<|connector|> redsys 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/redsys/transformers.rs" role="context" start="601" end="635">
fn try_from(
item: ResponseRouterData<
F,
RedsysResponse,
PaymentsPreProcessingData,
PaymentsResponseData,
>,
) -> Result<Self, Self::Error> {
match item.response.clone() {
RedsysResponse::RedsysResponse(response) => {
let response_data: RedsysPaymentsResponse =
to_connector_response_data(&response.ds_merchant_parameters.clone().expose())?;
handle_redsys_preprocessing_response(item, &response_data)
}
RedsysResponse::RedsysErrorResponse(response) => {
let response = Err(ErrorResponse {
code: response.error_code.clone(),
message: response.error_code.clone(),
reason: Some(response.error_code.clone()),
status_code: item.http_code,
attempt_status: None,
connector_transaction_id: None,
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
});
Ok(Self {
status: enums::AttemptStatus::Failure,
response,
..item.data
})
}
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/redsys/transformers.rs" role="context" start="600" end="600">
use common_enums::enums;
use hyperswitch_domain_models::{
address::Address,
payment_method_data::PaymentMethodData,
router_data::{ConnectorAuthType, ErrorResponse, RouterData},
router_flow_types::refunds::{Execute, RSync},
router_request_types::{
BrowserInformation, CompleteAuthorizeData, PaymentsAuthorizeData, PaymentsCancelData,
PaymentsCaptureData, PaymentsPreProcessingData, PaymentsSyncData, ResponseId,
},
router_response_types::{PaymentsResponseData, RedirectForm, RefundsResponseData},
types::{
PaymentsAuthorizeRouterData, PaymentsCancelRouterData, PaymentsCaptureRouterData,
PaymentsCompleteAuthorizeRouterData, PaymentsPreProcessingRouterData,
PaymentsSyncRouterData, RefundSyncRouterData, RefundsRouterData,
},
};
use crate::{
types::{RefundsResponseRouterData, ResponseRouterData},
utils::{
self as connector_utils, AddressDetailsData, BrowserInformationData, CardData,
PaymentsAuthorizeRequestData, PaymentsCompleteAuthorizeRequestData,
PaymentsPreProcessingRequestData, RouterData as _,
},
};
type Error = error_stack::Report<errors::ConnectorError>;
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/redsys/transformers.rs" role="context" start="686" end="737">
fn handle_threeds_invoke<F>(
item: ResponseRouterData<F, RedsysResponse, PaymentsPreProcessingData, PaymentsResponseData>,
response_data: &RedsysPaymentsResponse,
three_d_s_method_u_r_l: String,
three_d_s_server_trans_i_d: String,
protocol_version: String,
) -> Result<
RouterData<F, PaymentsPreProcessingData, PaymentsResponseData>,
error_stack::Report<errors::ConnectorError>,
> {
let three_d_s_method_notification_u_r_l = item.data.request.get_webhook_url()?;
let threeds_invoke_data = ThreedsInvokeRequest {
three_d_s_server_trans_i_d: three_d_s_method_u_r_l.clone(),
three_d_s_method_notification_u_r_l,
};
let three_ds_data_string = threeds_invoke_data
.encode_to_string_of_json()
.change_context(errors::ConnectorError::RequestEncodingFailed)?;
let three_ds_method_data = BASE64_ENGINE.encode(&three_ds_data_string);
let three_ds_data = RedsysThreeDsInvokeData {
three_ds_method_url: three_d_s_method_u_r_l,
three_ds_method_data,
message_version: protocol_version.clone(),
directory_server_id: three_d_s_server_trans_i_d,
three_ds_method_data_submission: true,
};
let connector_metadata = Some(
serde_json::to_value(&three_ds_data)
.change_context(errors::ConnectorError::RequestEncodingFailed)
.attach_printable("Failed to serialize ThreeDsData")?,
);
Ok(RouterData {
status: enums::AttemptStatus::AuthenticationPending,
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(response_data.ds_order.clone()),
redirection_data: Box::new(None),
mandate_reference: Box::new(None),
connector_metadata,
network_txn_id: None,
connector_response_reference_id: Some(response_data.ds_order.clone()),
incremental_authorization_allowed: None,
charges: None,
}),
..item.data
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/redsys/transformers.rs" role="context" start="638" end="684">
fn handle_redsys_preprocessing_response<F>(
item: ResponseRouterData<F, RedsysResponse, PaymentsPreProcessingData, PaymentsResponseData>,
response_data: &RedsysPaymentsResponse,
) -> Result<
RouterData<F, PaymentsPreProcessingData, PaymentsResponseData>,
error_stack::Report<errors::ConnectorError>,
> {
match (
response_data
.ds_emv3ds
.as_ref()
.and_then(|emv3ds_data| emv3ds_data.three_d_s_method_u_r_l.clone()),
response_data
.ds_emv3ds
.as_ref()
.and_then(|emv3ds_data| emv3ds_data.three_d_s_server_trans_i_d.clone()),
response_data
.ds_emv3ds
.as_ref()
.map(|emv3ds_data| emv3ds_data.protocol_version.clone()),
) {
(
Some(three_d_s_method_u_r_l),
Some(three_d_s_server_trans_i_d),
Some(protocol_version),
) => handle_threeds_invoke(
item,
response_data,
three_d_s_method_u_r_l,
three_d_s_server_trans_i_d,
protocol_version,
),
(None, Some(three_d_s_server_trans_i_d), Some(protocol_version)) => {
handle_threeds_invoke_exempt(
item,
response_data,
three_d_s_server_trans_i_d,
protocol_version,
)
}
_ => Err(errors::ConnectorError::NotSupported {
message: "3DS payment with a non-3DS card".to_owned(),
connector: "redsys",
}
.into()),
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/redsys/transformers.rs" role="context" start="580" end="593">
fn to_connector_response_data<T>(connector_response: &str) -> Result<T, Error>
where
T: serde::de::DeserializeOwned,
{
let decoded_bytes = BASE64_ENGINE
.decode(connector_response)
.change_context(errors::ConnectorError::ResponseDeserializationFailed)
.attach_printable("Failed to decode Base64")?;
let response_data: T = serde_json::from_slice(&decoded_bytes)
.change_context(errors::ConnectorError::ResponseHandlingFailed)?;
Ok(response_data)
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/redsys/transformers.rs" role="context" start="449" end="490">
fn try_from(
item: &RedsysRouterData<&PaymentsPreProcessingRouterData>,
) -> Result<Self, Self::Error> {
let auth = RedsysAuthType::try_from(&item.router_data.connector_auth_type)?;
if !item.router_data.is_three_ds() {
Err(errors::ConnectorError::NotSupported {
message: "PreProcessing flow for no-3ds cards".to_string(),
connector: "redsys",
})?
};
let redsys_preprocessing_request =
if item.router_data.auth_type == enums::AuthenticationType::ThreeDs {
let ds_merchant_emv3ds = Some(EmvThreedsData::new(RedsysThreeDsInfo::CardData));
let ds_merchant_transactiontype = if item.router_data.request.is_auto_capture()? {
RedsysTransactionType::Payment
} else {
RedsysTransactionType::Preauthorization
};
let ds_merchant_order = connector_utils::generate_12_digit_number().to_string();
let card_data =
RedsysCardData::try_from(&item.router_data.request.payment_method_data)?;
Ok(PaymentsRequest {
ds_merchant_emv3ds,
ds_merchant_transactiontype,
ds_merchant_currency: item.currency.iso_4217().to_owned(),
ds_merchant_pan: card_data.card_number,
ds_merchant_merchantcode: auth.merchant_id.clone(),
ds_merchant_terminal: auth.terminal_id.clone(),
ds_merchant_order,
ds_merchant_amount: item.amount.clone(),
ds_merchant_expirydate: card_data.expiry_date,
ds_merchant_cvv2: card_data.cvv2,
})
} else {
Err(errors::ConnectorError::FlowNotSupported {
flow: "PreProcessing".to_string(),
connector: "redsys".to_string(),
})
}?;
Self::try_from((&redsys_preprocessing_request, &auth))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/redsys/transformers.rs" role="context" start="38" end="38">
type Error = error_stack::Report<errors::ConnectorError>;
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/redsys/transformers.rs" role="context" start="521" end="532">
pub struct RedsysPaymentsResponse {
#[serde(rename = "Ds_Order")]
ds_order: String,
#[serde(rename = "Ds_EMV3DS")]
ds_emv3ds: Option<RedsysEmv3DSData>,
#[serde(rename = "Ds_Card_PSD2")]
ds_card_psd2: Option<CardPSD2>,
#[serde(rename = "Ds_Response")]
ds_response: Option<DsResponse>,
#[serde(rename = "Ds_AuthorisationCode")]
ds_authorisation_code: Option<String>,
}
<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/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/deutschebank/transformers.rs<|crate|> hyperswitch_connectors<|connector|> deutschebank 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/deutschebank/transformers.rs" role="context" start="972" end="1007">
fn try_from(
item: ResponseRouterData<
Capture,
DeutschebankPaymentsResponse,
PaymentsCaptureData,
PaymentsResponseData,
>,
) -> Result<Self, Self::Error> {
let response_code = item.response.rc.clone();
if is_response_success(&response_code) {
Ok(Self {
status: common_enums::AttemptStatus::Charged,
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/deutschebank/transformers.rs" role="context" start="971" end="971">
use common_enums::{enums, PaymentMethod};
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,
},
};
use crate::{
types::{PaymentsCancelResponseRouterData, RefundsResponseRouterData, ResponseRouterData},
utils::{
self, AddressDetailsData, CardData, PaymentsAuthorizeRequestData,
PaymentsCompleteAuthorizeRequestData, RefundsRequestData, RouterData as OtherRouterData,
},
};
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/deutschebank/transformers.rs" role="context" start="1077" end="1092">
fn try_from(item: &PaymentsCancelRouterData) -> Result<Self, Self::Error> {
if matches!(item.payment_method, PaymentMethod::BankDebit) {
Ok(Self {
kind: DeutschebankTransactionKind::Directdebit,
})
} else if item.is_three_ds() && matches!(item.payment_method, PaymentMethod::Card) {
Ok(Self {
kind: DeutschebankTransactionKind::Creditcard3ds20,
})
} else {
Err(errors::ConnectorError::NotImplemented(
utils::get_unimplemented_payment_method_error_message("deutschebank"),
)
.into())
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/deutschebank/transformers.rs" role="context" start="1021" end="1067">
fn try_from(
item: ResponseRouterData<
PSync,
DeutschebankPaymentsResponse,
PaymentsSyncData,
PaymentsResponseData,
>,
) -> Result<Self, Self::Error> {
let response_code = item.response.rc.clone();
let status = if is_response_success(&response_code) {
item.response
.tx_action
.and_then(|tx_action| match tx_action {
DeutschebankTXAction::Preauthorization => {
Some(common_enums::AttemptStatus::Authorized)
}
DeutschebankTXAction::Authorization | DeutschebankTXAction::Capture => {
Some(common_enums::AttemptStatus::Charged)
}
DeutschebankTXAction::Credit
| DeutschebankTXAction::Refund
| DeutschebankTXAction::Reversal
| DeutschebankTXAction::RiskCheck
| DeutschebankTXAction::VerifyMop
| DeutschebankTXAction::Payment
| DeutschebankTXAction::AccountInformation => None,
})
} else {
Some(common_enums::AttemptStatus::Failure)
};
match status {
Some(common_enums::AttemptStatus::Failure) => Ok(Self {
status: common_enums::AttemptStatus::Failure,
response: Err(get_error_response(
response_code.clone(),
item.response.message.clone(),
item.http_code,
)),
..item.data
}),
Some(status) => Ok(Self {
status,
..item.data
}),
None => Ok(Self { ..item.data }),
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/deutschebank/transformers.rs" role="context" start="937" end="958">
fn try_from(
item: &DeutschebankRouterData<&PaymentsCaptureRouterData>,
) -> Result<Self, Self::Error> {
if matches!(item.router_data.payment_method, PaymentMethod::BankDebit) {
Ok(Self {
changed_amount: item.amount,
kind: DeutschebankTransactionKind::Directdebit,
})
} else if item.router_data.is_three_ds()
&& matches!(item.router_data.payment_method, PaymentMethod::Card)
{
Ok(Self {
changed_amount: item.amount,
kind: DeutschebankTransactionKind::Creditcard3ds20,
})
} else {
Err(errors::ConnectorError::NotImplemented(
utils::get_unimplemented_payment_method_error_message("deutschebank"),
)
.into())
}
}
<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/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="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="59" end="59">
type Error = error_stack::Report<errors::ConnectorError>;
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/deutschebank/transformers.rs" role="context" start="855" end="867">
pub struct DeutschebankPaymentsResponse {
rc: String,
message: String,
timestamp: String,
back_ext_id: Option<String>,
back_rc: Option<String>,
event_id: Option<String>,
kind: Option<String>,
tx_action: Option<DeutschebankTXAction>,
tx_id: String,
amount_total: Option<DeutschebankAmount>,
transaction_info: Option<DeutschebankTransactionInfo>,
}
<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/migrations/2023-07-07-091223_create_captures_table/up.sql" role="context" start="1" end="17">
CREATE TYPE "CaptureStatus" AS ENUM (
'started',
'charged',
'pending',
'failed'
);
ALTER TYPE "IntentStatus" ADD VALUE If NOT EXISTS 'partially_captured' AFTER 'requires_capture';
CREATE TABLE captures(
capture_id VARCHAR(64) NOT NULL PRIMARY KEY,
payment_id VARCHAR(64) NOT NULL,
merchant_id VARCHAR(64) NOT NULL,
status "CaptureStatus" NOT NULL,
amount BIGINT NOT NULL,
currency "Currency",
connector VARCHAR(255),
error_message VARCHAR(255),
<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/shift4/transformers.rs<|crate|> hyperswitch_connectors<|connector|> shift4 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/shift4/transformers.rs" role="context" start="785" end="816">
fn try_from(
item: ResponseRouterData<F, Shift4NonThreeDsResponse, T, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
let connector_id = ResponseId::ConnectorTransactionId(item.response.id.clone());
Ok(Self {
status: get_status(
item.response.captured,
item.response
.flow
.as_ref()
.and_then(|flow| flow.next_action.as_ref()),
item.response.status,
),
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: connector_id,
redirection_data: Box::new(
item.response
.flow
.and_then(|flow| flow.redirect)
.and_then(|redirect| redirect.redirect_url)
.map(|url| RedirectForm::from((url, Method::Get))),
),
mandate_reference: Box::new(None),
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: Some(item.response.id),
incremental_authorization_allowed: None,
charges: None,
}),
..item.data
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/shift4/transformers.rs" role="context" start="784" end="784">
use common_utils::{
pii::{self, SecretSerdeValue},
request::Method,
types::MinorUnit,
};
use hyperswitch_domain_models::{
payment_method_data::{
BankRedirectData, BankTransferData, Card as CardData, GiftCardData, PaymentMethodData,
VoucherData, WalletData,
},
router_data::{ConnectorAuthType, RouterData},
router_flow_types::refunds::{Execute, RSync},
router_request_types::{
CompleteAuthorizeData, PaymentsAuthorizeData, PaymentsPreProcessingData, ResponseId,
},
router_response_types::{PaymentsResponseData, RedirectForm, RefundsResponseData},
types::{PaymentsPreProcessingRouterData, RefundsRouterData},
};
use crate::{
types::{
PaymentsPreprocessingResponseRouterData, RefundsResponseRouterData, ResponseRouterData,
},
utils::{
self, to_connector_meta, PaymentsAuthorizeRequestData,
PaymentsCompleteAuthorizeRequestData, PaymentsPreProcessingRequestData, RouterData as _,
},
};
type Error = error_stack::Report<errors::ConnectorError>;
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/shift4/transformers.rs" role="context" start="839" end="845">
fn from(item: Shift4RefundStatus) -> Self {
match item {
Shift4RefundStatus::Successful => Self::Success,
Shift4RefundStatus::Failed => Self::Failure,
Shift4RefundStatus::Processing => Self::Pending,
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/shift4/transformers.rs" role="context" start="830" end="835">
fn try_from(item: &Shift4RouterData<&RefundsRouterData<F>>) -> Result<Self, Self::Error> {
Ok(Self {
charge_id: item.router_data.request.connector_transaction_id.clone(),
amount: item.amount.to_owned(),
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/shift4/transformers.rs" role="context" start="744" end="778">
fn try_from(
item: PaymentsPreprocessingResponseRouterData<Shift4ThreeDsResponse>,
) -> Result<Self, Self::Error> {
let redirection_data = item
.response
.redirect_url
.map(|url| RedirectForm::from((url, Method::Get)));
Ok(Self {
status: if redirection_data.is_some() {
enums::AttemptStatus::AuthenticationPending
} else {
enums::AttemptStatus::Pending
},
request: PaymentsPreProcessingData {
enrolled_for_3ds: item.response.enrolled,
..item.data.request
},
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::NoResponseId,
redirection_data: Box::new(redirection_data),
mandate_reference: Box::new(None),
connector_metadata: Some(
serde_json::to_value(Shift4CardToken {
id: item.response.token.id,
})
.change_context(errors::ConnectorError::ResponseDeserializationFailed)?,
),
network_txn_id: None,
connector_response_reference_id: None,
incremental_authorization_allowed: None,
charges: None,
}),
..item.data
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/shift4/transformers.rs" role="context" start="601" end="620">
fn get_status(
captured: bool,
next_action: Option<&NextAction>,
payment_status: Shift4PaymentStatus,
) -> enums::AttemptStatus {
match payment_status {
Shift4PaymentStatus::Successful => {
if captured {
enums::AttemptStatus::Charged
} else {
enums::AttemptStatus::Authorized
}
}
Shift4PaymentStatus::Failed => enums::AttemptStatus::Failure,
Shift4PaymentStatus::Pending => match next_action {
Some(NextAction::Redirect) => enums::AttemptStatus::AuthenticationPending,
Some(NextAction::Wait) | Some(NextAction::None) | None => enums::AttemptStatus::Pending,
},
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/shift4/transformers.rs" role="context" start="924" end="935">
fn from(event: Shift4WebhookEvent) -> Self {
match event {
Shift4WebhookEvent::ChargeSucceeded | Shift4WebhookEvent::ChargeUpdated => {
//reference : https://dev.shift4.com/docs/api#event-types
Self::PaymentIntentProcessing
}
Shift4WebhookEvent::ChargeCaptured => Self::PaymentIntentSuccess,
Shift4WebhookEvent::ChargeFailed => Self::PaymentIntentFailure,
Shift4WebhookEvent::ChargeRefunded => Self::RefundSuccess,
Shift4WebhookEvent::Unknown => Self::EventNotSupported,
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/shift4/transformers.rs" role="context" start="38" end="38">
type Error = error_stack::Report<errors::ConnectorError>;
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/shift4/transformers.rs" role="context" start="664" end="672">
pub struct Shift4NonThreeDsResponse {
pub id: String,
pub currency: String,
pub amount: u32,
pub status: Shift4PaymentStatus,
pub captured: bool,
pub refunded: bool,
pub flow: Option<FlowResponse>,
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/globalpay/requests.rs" role="context" start="685" end="688">
pub enum Method {
Ksn,
Ktb,
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/hyperswitch_connectors/src/connectors/taxjar.rs<|crate|> hyperswitch_connectors<|connector|> taxjar 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/taxjar.rs" role="context" start="186" end="217">
fn get_request_body(
&self,
req: &PaymentsTaxCalculationRouterData,
_connectors: &Connectors,
) -> CustomResult<RequestContent, errors::ConnectorError> {
let amount = utils::convert_amount(
self.amount_converter,
req.request.amount,
req.request.currency,
)?;
let shipping = utils::convert_amount(
self.amount_converter,
req.request.shipping_cost.unwrap_or(MinorUnit::zero()),
req.request.currency,
)?;
let order_amount = utils::convert_amount(
self.amount_converter,
req.request
.order_details
.as_ref()
.map(|details| details.iter().map(|item| item.amount).sum())
.unwrap_or(MinorUnit::zero()),
req.request.currency,
)?;
let connector_router_data =
taxjar::TaxjarRouterData::from((amount, order_amount, shipping, req));
let connector_req = taxjar::TaxjarPaymentsRequest::try_from(&connector_router_data)?;
Ok(RequestContent::Json(Box::new(connector_req)))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/taxjar.rs" role="context" start="185" end="185">
use common_utils::{
errors::CustomResult,
ext_traits::BytesExt,
request::{Method, Request, RequestBuilder, RequestContent},
types::{AmountConvertor, FloatMajorUnit, FloatMajorUnitForConnector, MinorUnit},
};
use hyperswitch_domain_models::{
router_data::{AccessToken, ConnectorAuthType, ErrorResponse, RouterData},
router_flow_types::{
access_token_auth::AccessTokenAuth,
payments::{
Authorize, CalculateTax, Capture, PSync, PaymentMethodToken, Session, SetupMandate,
Void,
},
refunds::{Execute, RSync},
},
router_request_types::{
AccessTokenRequestData, PaymentMethodTokenizationData, PaymentsAuthorizeData,
PaymentsCancelData, PaymentsCaptureData, PaymentsSessionData, PaymentsSyncData,
PaymentsTaxCalculationData, RefundsData, SetupMandateRequestData,
},
router_response_types::{
PaymentsResponseData, RefundsResponseData, TaxCalculationResponseData,
},
types::PaymentsTaxCalculationRouterData,
};
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 taxjar;
use crate::{constants::headers, types::ResponseRouterData, utils};
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/taxjar.rs" role="context" start="240" end="257">
fn handle_response(
&self,
data: &PaymentsTaxCalculationRouterData,
event_builder: Option<&mut ConnectorEvent>,
res: Response,
) -> CustomResult<PaymentsTaxCalculationRouterData, errors::ConnectorError> {
let response: taxjar::TaxjarPaymentsResponse = res
.response
.parse_struct("Taxjar PaymentsResponse")
.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/taxjar.rs" role="context" start="218" end="238">
fn build_request(
&self,
req: &PaymentsTaxCalculationRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Ok(Some(
RequestBuilder::new()
.method(Method::Post)
.url(&types::PaymentsTaxCalculationType::get_url(
self, req, connectors,
)?)
.attach_default_headers()
.headers(types::PaymentsTaxCalculationType::get_headers(
self, req, connectors,
)?)
.set_body(types::PaymentsTaxCalculationType::get_request_body(
self, req, connectors,
)?)
.build(),
))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/taxjar.rs" role="context" start="179" end="185">
fn get_url(
&self,
_req: &PaymentsTaxCalculationRouterData,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
Ok(format!("{}taxes", self.base_url(connectors)))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/taxjar.rs" role="context" start="175" end="177">
fn get_content_type(&self) -> &'static str {
self.common_get_content_type()
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/taxjar.rs" role="context" start="52" end="56">
pub fn new() -> &'static Self {
&Self {
amount_converter: &FloatMajorUnitForConnector,
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/taxjar/transformers.rs" role="context" start="19" end="24">
pub struct TaxjarRouterData<T> {
pub amount: FloatMajorUnit, // The type of amount that a connector accepts, for example, String, i64, f64, etc.
pub order_amount: FloatMajorUnit,
pub shipping: FloatMajorUnit,
pub router_data: T,
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/hyperswitch_connectors/src/connectors/trustpay/transformers.rs<|crate|> hyperswitch_connectors<|connector|> trustpay anchor=is_payment_successful kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=1<|meta_end|>
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/trustpay/transformers.rs" role="context" start="634" end="658">
fn is_payment_successful(payment_status: &str) -> CustomResult<bool, errors::ConnectorError> {
match payment_status {
"000.400.100" => Ok(true),
_ => {
let allowed_prefixes = [
"000.000.",
"000.100.1",
"000.3",
"000.6",
"000.400.01",
"000.400.02",
"000.400.04",
"000.400.05",
"000.400.06",
"000.400.07",
"000.400.08",
"000.400.09",
];
let is_valid = allowed_prefixes
.iter()
.any(|&prefix| payment_status.starts_with(prefix));
Ok(is_valid)
}
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/trustpay/transformers.rs" role="context" start="633" end="633">
use common_utils::{
errors::CustomResult,
pii::{self, Email},
request::Method,
types::StringMajorUnit,
};
type Error = error_stack::Report<errors::ConnectorError>;
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/trustpay/transformers.rs" role="context" start="667" end="692">
fn get_transaction_status(
payment_status: Option<String>,
redirect_url: Option<Url>,
) -> CustomResult<(enums::AttemptStatus, Option<String>), errors::ConnectorError> {
// We don't get payment_status only in case, when the user doesn't complete the authentication step.
// If we receive status, then return the proper status based on the connector response
if let Some(payment_status) = payment_status {
let (is_failed, failure_message) = is_payment_failed(&payment_status);
if is_failed {
return Ok((
enums::AttemptStatus::Failure,
Some(failure_message.to_string()),
));
}
if is_payment_successful(&payment_status)? {
return Ok((enums::AttemptStatus::Charged, None));
}
let pending_status = get_pending_status_based_on_redirect_url(redirect_url);
Ok((pending_status, None))
} else {
Ok((enums::AttemptStatus::AuthenticationPending, None))
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/trustpay/transformers.rs" role="context" start="660" end="665">
fn get_pending_status_based_on_redirect_url(redirect_url: Option<Url>) -> enums::AttemptStatus {
match redirect_url {
Some(_url) => enums::AttemptStatus::AuthenticationPending,
None => enums::AttemptStatus::Pending,
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/trustpay/transformers.rs" role="context" start="560" end="632">
fn is_payment_failed(payment_status: &str) -> (bool, &'static str) {
match payment_status {
"100.100.600" => (true, "Empty CVV for VISA, MASTER not allowed"),
"100.350.100" => (true, "Referenced session is rejected (no action possible)"),
"100.380.401" => (true, "User authentication failed"),
"100.380.501" => (true, "Risk management transaction timeout"),
"100.390.103" => (true, "PARes validation failed - problem with signature"),
"100.390.105" => (
true,
"Transaction rejected because of technical error in 3DSecure system",
),
"100.390.111" => (
true,
"Communication error to VISA/Mastercard Directory Server",
),
"100.390.112" => (true, "Technical error in 3D system"),
"100.390.115" => (true, "Authentication failed due to invalid message format"),
"100.390.118" => (true, "Authentication failed due to suspected fraud"),
"100.400.304" => (true, "Invalid input data"),
"100.550.312" => (true, "Amount is outside allowed ticket size boundaries"),
"200.300.404" => (true, "Invalid or missing parameter"),
"300.100.100" => (
true,
"Transaction declined (additional customer authentication required)",
),
"400.001.301" => (true, "Card not enrolled in 3DS"),
"400.001.600" => (true, "Authentication error"),
"400.001.601" => (true, "Transaction declined (auth. declined)"),
"400.001.602" => (true, "Invalid transaction"),
"400.001.603" => (true, "Invalid transaction"),
"400.003.600" => (true, "No description available."),
"700.400.200" => (
true,
"Cannot refund (refund volume exceeded or tx reversed or invalid workflow)",
),
"700.500.001" => (true, "Referenced session contains too many transactions"),
"700.500.003" => (true, "Test accounts not allowed in production"),
"800.100.100" => (true, "Transaction declined for unknown reason"),
"800.100.151" => (true, "Transaction declined (invalid card)"),
"800.100.152" => (true, "Transaction declined by authorization system"),
"800.100.153" => (true, "Transaction declined (invalid CVV)"),
"800.100.155" => (true, "Transaction declined (amount exceeds credit)"),
"800.100.157" => (true, "Transaction declined (wrong expiry date)"),
"800.100.158" => (true, "transaction declined (suspecting manipulation)"),
"800.100.160" => (true, "transaction declined (card blocked)"),
"800.100.162" => (true, "Transaction declined (limit exceeded)"),
"800.100.163" => (
true,
"Transaction declined (maximum transaction frequency exceeded)",
),
"800.100.165" => (true, "Transaction declined (card lost)"),
"800.100.168" => (true, "Transaction declined (restricted card)"),
"800.100.170" => (true, "Transaction declined (transaction not permitted)"),
"800.100.171" => (true, "transaction declined (pick up card)"),
"800.100.172" => (true, "Transaction declined (account blocked)"),
"800.100.190" => (true, "Transaction declined (invalid configuration data)"),
"800.100.202" => (true, "Account Closed"),
"800.100.203" => (true, "Insufficient Funds"),
"800.120.100" => (true, "Rejected by throttling"),
"800.300.102" => (true, "Country blacklisted"),
"800.300.401" => (true, "Bin blacklisted"),
"800.700.100" => (
true,
"Transaction for the same session is currently being processed, please try again later",
),
"900.100.100" => (
true,
"Unexpected communication error with connector/acquirer",
),
"900.100.300" => (true, "Timeout, uncertain result"),
_ => (false, ""),
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/trustpay/transformers.rs" role="context" start="479" end="557">
fn try_from(
item: &TrustpayRouterData<&PaymentsAuthorizeRouterData>,
) -> Result<Self, Self::Error> {
let browser_info = item
.router_data
.request
.browser_info
.clone()
.unwrap_or_default();
let default_browser_info = BrowserInformation {
color_depth: Some(browser_info.color_depth.unwrap_or(24)),
java_enabled: Some(browser_info.java_enabled.unwrap_or(false)),
java_script_enabled: Some(browser_info.java_enabled.unwrap_or(true)),
language: Some(browser_info.language.unwrap_or("en-US".to_string())),
screen_height: Some(browser_info.screen_height.unwrap_or(1080)),
screen_width: Some(browser_info.screen_width.unwrap_or(1920)),
time_zone: Some(browser_info.time_zone.unwrap_or(3600)),
accept_header: Some(browser_info.accept_header.unwrap_or("*".to_string())),
user_agent: browser_info.user_agent,
ip_address: browser_info.ip_address,
os_type: None,
os_version: None,
device_model: None,
accept_language: Some(browser_info.accept_language.unwrap_or("en".to_string())),
};
let params = get_mandatory_fields(item.router_data)?;
let amount = item.amount.to_owned();
let auth = TrustpayAuthType::try_from(&item.router_data.connector_auth_type)
.change_context(errors::ConnectorError::FailedToObtainAuthType)?;
match item.router_data.request.payment_method_data {
PaymentMethodData::Card(ref ccard) => Ok(get_card_request_data(
item.router_data,
&default_browser_info,
params,
amount,
ccard,
item.router_data.request.get_router_return_url()?,
)?),
PaymentMethodData::BankRedirect(ref bank_redirection_data) => {
get_bank_redirection_request_data(
item.router_data,
bank_redirection_data,
params,
amount,
auth,
)
}
PaymentMethodData::BankTransfer(ref bank_transfer_data) => {
get_bank_transfer_request_data(
item.router_data,
bank_transfer_data,
params,
amount,
auth,
)
}
PaymentMethodData::CardRedirect(_)
| PaymentMethodData::Wallet(_)
| PaymentMethodData::PayLater(_)
| PaymentMethodData::BankDebit(_)
| 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("trustpay"),
)
.into())
}
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/trustpay/transformers.rs" role="context" start="1769" end="1785">
fn get_refund_status(
payment_status: &str,
) -> CustomResult<(enums::RefundStatus, Option<String>), errors::ConnectorError> {
let (is_failed, failure_message) = is_payment_failed(payment_status);
if payment_status == "000.200.000" {
Ok((enums::RefundStatus::Pending, None))
} else if is_failed {
Ok((
enums::RefundStatus::Failure,
Some(failure_message.to_string()),
))
} else if is_payment_successful(payment_status)? {
Ok((enums::RefundStatus::Success, None))
} else {
Ok((enums::RefundStatus::Pending, None))
}
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/hyperswitch_connectors/src/connectors/novalnet/transformers.rs<|crate|> hyperswitch_connectors<|connector|> novalnet 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/novalnet/transformers.rs" role="context" start="932" end="966">
fn try_from(
item: RefundsResponseRouterData<Execute, NovalnetRefundResponse>,
) -> Result<Self, Self::Error> {
match item.response.result.status {
NovalnetAPIStatus::Success => {
let refund_id = item
.response
.transaction
.clone()
.and_then(|data| data.refund.tid.map(|tid| tid.expose().to_string()))
.ok_or(errors::ConnectorError::ResponseHandlingFailed)?;
let transaction_status = item
.response
.transaction
.map(|transaction| transaction.status)
.unwrap_or(NovalnetTransactionStatus::Pending);
Ok(Self {
response: Ok(RefundsResponseData {
connector_refund_id: refund_id,
refund_status: enums::RefundStatus::from(transaction_status),
}),
..item.data
})
}
NovalnetAPIStatus::Failure => {
let response = Err(get_error_response(item.response.result, item.http_code));
Ok(Self {
response,
..item.data
})
}
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/novalnet/transformers.rs" role="context" start="931" end="931">
use common_enums::{enums, enums as api_enums};
use hyperswitch_domain_models::{
payment_method_data::{PaymentMethodData, WalletData as WalletDataPaymentMethod},
router_data::{ConnectorAuthType, ErrorResponse, RouterData},
router_flow_types::refunds::{Execute, RSync},
router_request_types::{PaymentsCancelData, PaymentsCaptureData, PaymentsSyncData, ResponseId},
router_response_types::{
MandateReference, PaymentsResponseData, RedirectForm, RefundsResponseData,
},
types::{
PaymentsAuthorizeRouterData, PaymentsCancelRouterData, PaymentsCaptureRouterData,
PaymentsSyncRouterData, RefundSyncRouterData, RefundsRouterData, SetupMandateRouterData,
},
};
use crate::{
types::{RefundsResponseRouterData, ResponseRouterData},
utils::{
self, AddressData, AddressDetailsData, ApplePay, PaymentsAuthorizeRequestData,
PaymentsCancelRequestData, PaymentsCaptureRequestData, PaymentsSetupMandateRequestData,
PaymentsSyncRequestData, RefundsRequestData, RouterData as _,
},
};
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/novalnet/transformers.rs" role="context" start="1017" end="1031">
pub fn get_token(transaction_data: Option<&Self>) -> Option<String> {
if let Some(data) = transaction_data {
match &data.payment_data {
Some(NovalnetResponsePaymentData::Card(card_data)) => {
card_data.token.clone().map(|token| token.expose())
}
Some(NovalnetResponsePaymentData::Paypal(paypal_data)) => {
paypal_data.token.clone().map(|token| token.expose())
}
None => None,
}
} else {
None
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/novalnet/transformers.rs" role="context" start="977" end="1013">
fn try_from(item: &PaymentsSyncRouterData) -> Result<Self, Self::Error> {
let transaction = if item
.request
.encoded_data
.clone()
.get_required_value("encoded_data")
.is_ok()
{
let encoded_data = item
.request
.encoded_data
.clone()
.get_required_value("encoded_data")
.change_context(errors::ConnectorError::RequestEncodingFailed)?;
let novalnet_redirection_response =
serde_urlencoded::from_str::<NovolnetRedirectionResponse>(encoded_data.as_str())
.change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
NovalnetSyncTransaction {
tid: novalnet_redirection_response.tid.expose(),
}
} else {
NovalnetSyncTransaction {
tid: item
.request
.get_connector_transaction_id()
.change_context(errors::ConnectorError::MissingConnectorTransactionID)?,
}
};
let custom = NovalnetCustom {
lang: consts::DEFAULT_LOCALE.to_string().to_string(),
};
Ok(Self {
transaction,
custom,
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/novalnet/transformers.rs" role="context" start="877" end="888">
fn from(item: NovalnetTransactionStatus) -> Self {
match item {
NovalnetTransactionStatus::Success | NovalnetTransactionStatus::Confirmed => {
Self::Success
}
NovalnetTransactionStatus::Pending => Self::Pending,
NovalnetTransactionStatus::Failure
| NovalnetTransactionStatus::OnHold
| NovalnetTransactionStatus::Deactivated
| NovalnetTransactionStatus::Progress => Self::Failure,
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/novalnet/transformers.rs" role="context" start="856" end="873">
fn try_from(item: &NovalnetRouterData<&RefundsRouterData<F>>) -> Result<Self, Self::Error> {
let transaction = NovalnetRefundTransaction {
tid: item.router_data.request.connector_transaction_id.clone(),
amount: Some(item.amount.to_owned()),
};
let custom = NovalnetCustom {
lang: item
.router_data
.request
.get_optional_language_from_browser_info()
.unwrap_or(consts::DEFAULT_LOCALE.to_string().to_string()),
};
Ok(Self {
transaction,
custom,
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/novalnet/transformers.rs" role="context" start="581" end="596">
pub fn get_error_response(result: ResultData, status_code: u16) -> ErrorResponse {
let error_code = result.status;
let error_reason = result.status_text.clone();
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/novalnet/transformers.rs" role="context" start="174" end="174">
type Error = error_stack::Report<errors::ConnectorError>;
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/novalnet/transformers.rs" role="context" start="921" end="926">
pub struct NovalnetRefundResponse {
pub customer: Option<NovalnetResponseCustomer>,
pub merchant: Option<NovalnetResponseMerchant>,
pub result: ResultData,
pub transaction: Option<NovalnetRefundsTransactionData>,
}
<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/braintree.rs<|crate|> hyperswitch_connectors<|connector|> braintree anchor=get_webhook_source_verification_signature kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/braintree.rs" role="context" start="910" end="934">
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 signature_pairs: Vec<(&str, &str)> = notif_item
.bt_signature
.split('&')
.collect::<Vec<&str>>()
.into_iter()
.map(|pair| pair.split_once('|').unwrap_or(("", "")))
.collect::<Vec<(_, _)>>();
let merchant_secret = connector_webhook_secrets
.additional_secret //public key
.clone()
.ok_or(errors::ConnectorError::WebhookVerificationSecretNotFound)?;
let signature = get_matching_webhook_signature(signature_pairs, merchant_secret.expose())
.ok_or(errors::ConnectorError::WebhookSignatureNotFound)?;
Ok(signature.as_bytes().to_vec())
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/braintree.rs" role="context" start="909" end="909">
use api_models::webhooks::IncomingWebhookEvent;
use common_utils::{
consts::BASE64_ENGINE,
crypto,
errors::{CustomResult, ParsingError},
ext_traits::{BytesExt, XmlExt},
request::{Method, Request, RequestBuilder, RequestContent},
types::{AmountConvertor, StringMajorUnit, StringMajorUnitForConnector},
};
use hyperswitch_interfaces::{
api::{
self, ConnectorCommon, ConnectorCommonExt, ConnectorIntegration, ConnectorRedirectResponse,
ConnectorSpecifications, ConnectorValidation,
},
configs::Connectors,
consts::{NO_ERROR_CODE, NO_ERROR_MESSAGE},
disputes::DisputePayload,
errors,
events::connector_api_logs::ConnectorEvent,
types::{
MandateRevokeType, PaymentsAuthorizeType, PaymentsCaptureType,
PaymentsCompleteAuthorizeType, PaymentsSyncType, PaymentsVoidType, RefundExecuteType,
RefundSyncType, Response, TokenizationType,
},
webhooks::{IncomingWebhook, IncomingWebhookFlowError, IncomingWebhookRequestDetails},
};
use transformers::{self as braintree, get_status};
use crate::{
constants::headers,
types::ResponseRouterData,
utils::{
self, convert_amount, is_mandate_supported, to_currency_lower_unit, PaymentMethodDataType,
PaymentsAuthorizeRequestData, PaymentsCompleteAuthorizeRequestData,
},
};
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/braintree.rs" role="context" start="950" end="988">
async fn verify_webhook_source(
&self,
request: &IncomingWebhookRequestDetails<'_>,
merchant_id: &common_utils::id_type::MerchantId,
connector_webhook_details: Option<common_utils::pii::SecretSerdeValue>,
_connector_account_details: crypto::Encryptable<Secret<serde_json::Value>>,
connector_label: &str,
) -> CustomResult<bool, errors::ConnectorError> {
let connector_webhook_secrets = self
.get_webhook_source_verification_merchant_secret(
merchant_id,
connector_label,
connector_webhook_details,
)
.await
.change_context(errors::ConnectorError::WebhookSourceVerificationFailed)?;
let signature = self
.get_webhook_source_verification_signature(request, &connector_webhook_secrets)
.change_context(errors::ConnectorError::WebhookSignatureNotFound)?;
let message = self
.get_webhook_source_verification_message(
request,
merchant_id,
&connector_webhook_secrets,
)
.change_context(errors::ConnectorError::WebhookSourceVerificationFailed)?;
let sha1_hash_key = Sha1::digest(&connector_webhook_secrets.secret);
let signing_key = hmac::Key::new(
hmac::HMAC_SHA1_FOR_LEGACY_USE_ONLY,
sha1_hash_key.as_slice(),
);
let signed_messaged = hmac::sign(&signing_key, &message);
let payload_sign: String = hex::encode(signed_messaged);
Ok(payload_sign.as_bytes().eq(&signature))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/braintree.rs" role="context" start="936" end="948">
fn get_webhook_source_verification_message(
&self,
request: &IncomingWebhookRequestDetails<'_>,
_merchant_id: &common_utils::id_type::MerchantId,
_connector_webhook_secrets: &api_models::webhooks::ConnectorWebhookSecrets,
) -> CustomResult<Vec<u8>, errors::ConnectorError> {
let notify = get_webhook_object_from_body(request.body)
.change_context(errors::ConnectorError::WebhookSourceVerificationFailed)?;
let message = notify.bt_payload.to_string();
Ok(message.into_bytes())
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/braintree.rs" role="context" start="903" end="908">
fn get_webhook_source_verification_algorithm(
&self,
_request: &IncomingWebhookRequestDetails<'_>,
) -> CustomResult<Box<dyn crypto::VerifySignature + Send>, errors::ConnectorError> {
Ok(Box::new(crypto::HmacSha1))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/braintree.rs" role="context" start="892" end="898">
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/braintree.rs" role="context" start="1083" end="1088">
fn get_webhook_object_from_body(
body: &[u8],
) -> CustomResult<transformers::BraintreeWebhookResponse, ParsingError> {
serde_urlencoded::from_bytes::<transformers::BraintreeWebhookResponse>(body)
.change_context(ParsingError::StructParseFailure("BraintreeWebhookResponse"))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/braintree.rs" role="context" start="1071" end="1081">
fn get_matching_webhook_signature(
signature_pairs: Vec<(&str, &str)>,
secret: String,
) -> Option<String> {
for (public_key, signature) in signature_pairs {
if *public_key == secret {
return Some(signature.to_string());
}
}
None
}
<file_sep path="hyperswitch/crates/api_models/src/webhooks.rs" role="context" start="369" end="372">
pub struct ConnectorWebhookSecrets {
pub secret: Vec<u8>,
pub additional_secret: Option<masking::Secret<String>>,
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/hyperswitch_connectors/src/connectors/airwallex/transformers.rs<|crate|> hyperswitch_connectors<|connector|> airwallex anchor=get_payment_status kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=1<|meta_end|>
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/airwallex/transformers.rs" role="context" start="492" end="515">
fn get_payment_status(
status: &AirwallexPaymentStatus,
next_action: &Option<AirwallexPaymentsNextAction>,
) -> enums::AttemptStatus {
match status.clone() {
AirwallexPaymentStatus::Succeeded => enums::AttemptStatus::Charged,
AirwallexPaymentStatus::Failed => enums::AttemptStatus::Failure,
AirwallexPaymentStatus::Pending => enums::AttemptStatus::Pending,
AirwallexPaymentStatus::RequiresPaymentMethod => enums::AttemptStatus::PaymentMethodAwaited,
AirwallexPaymentStatus::RequiresCustomerAction => next_action.as_ref().map_or(
enums::AttemptStatus::AuthenticationPending,
|next_action| match next_action.stage {
AirwallexNextActionStage::WaitingDeviceDataCollection => {
enums::AttemptStatus::DeviceDataCollectionPending
}
AirwallexNextActionStage::WaitingUserInfoInput => {
enums::AttemptStatus::AuthenticationPending
}
},
),
AirwallexPaymentStatus::RequiresCapture => enums::AttemptStatus::Authorized,
AirwallexPaymentStatus::Cancelled => enums::AttemptStatus::Voided,
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/airwallex/transformers.rs" role="context" start="491" end="491">
use common_enums::enums;
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/airwallex/transformers.rs" role="context" start="611" end="672">
fn try_from(
item: ResponseRouterData<F, AirwallexPaymentsResponse, T, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
let (status, redirection_data) = item.response.next_action.clone().map_or(
// If no next action is there, map the status and set redirection form as None
(
get_payment_status(&item.response.status, &item.response.next_action),
None,
),
|response_url_data| {
// If the connector sends a customer action response that is already under
// process from our end it can cause an infinite loop to break this this check
// is added and fail the payment
if matches!(
(
response_url_data.stage.clone(),
item.data.status,
item.response.status.clone(),
),
// If the connector sends waiting for DDC and our status is already DDC Pending
// that means we initiated the call to collect the data and now we expect a different response
(
AirwallexNextActionStage::WaitingDeviceDataCollection,
enums::AttemptStatus::DeviceDataCollectionPending,
_
)
// If the connector sends waiting for Customer Action and our status is already Authenticaition Pending
// that means we initiated the call to authenticate and now we do not expect a requires_customer action
// it will start a loop
| (
_,
enums::AttemptStatus::AuthenticationPending,
AirwallexPaymentStatus::RequiresCustomerAction,
)
) {
// Fail the payment for above conditions
(enums::AttemptStatus::AuthenticationFailed, None)
} else {
(
//Build the redirect form and update the payment status
get_payment_status(&item.response.status, &item.response.next_action),
get_redirection_form(response_url_data),
)
}
},
);
Ok(Self {
status,
reference_id: Some(item.response.id.clone()),
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(item.response.id.clone()),
redirection_data: Box::new(redirection_data),
mandate_reference: Box::new(None),
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: Some(item.response.id),
incremental_authorization_allowed: None,
charges: None,
}),
..item.data
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/airwallex/transformers.rs" role="context" start="565" end="605">
fn get_redirection_form(response_url_data: AirwallexPaymentsNextAction) -> Option<RedirectForm> {
Some(RedirectForm::Form {
endpoint: response_url_data.url.to_string(),
method: response_url_data.method,
form_fields: std::collections::HashMap::from([
//Some form fields might be empty based on the authentication type by the connector
(
"JWT".to_string(),
response_url_data
.data
.jwt
.map(|jwt| jwt.expose())
.unwrap_or_default(),
),
(
"threeDSMethodData".to_string(),
response_url_data
.data
.three_ds_method_data
.map(|three_ds_method_data| three_ds_method_data.expose())
.unwrap_or_default(),
),
(
"token".to_string(),
response_url_data
.data
.token
.map(|token: Secret<String>| token.expose())
.unwrap_or_default(),
),
(
"provider".to_string(),
response_url_data.data.provider.unwrap_or_default(),
),
(
"version".to_string(),
response_url_data.data.version.unwrap_or_default(),
),
]),
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/airwallex/transformers.rs" role="context" start="470" end="475">
fn try_from(item: &types::PaymentsCancelRouterData) -> Result<Self, Self::Error> {
Ok(Self {
request_id: Uuid::new_v4().to_string(),
cancellation_reason: item.request.cancellation_reason.clone(),
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/airwallex/transformers.rs" role="context" start="450" end="458">
fn try_from(item: &types::PaymentsCaptureRouterData) -> Result<Self, Self::Error> {
Ok(Self {
request_id: Uuid::new_v4().to_string(),
amount: Some(utils::to_currency_base_unit(
item.request.amount_to_capture,
item.request.currency,
)?),
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/airwallex/transformers.rs" role="context" start="686" end="715">
fn try_from(
item: ResponseRouterData<
PSync,
AirwallexPaymentsSyncResponse,
PaymentsSyncData,
PaymentsResponseData,
>,
) -> Result<Self, Self::Error> {
let status = get_payment_status(&item.response.status, &item.response.next_action);
let redirection_data = if let Some(redirect_url_data) = item.response.next_action {
get_redirection_form(redirect_url_data)
} else {
None
};
Ok(Self {
status,
reference_id: Some(item.response.id.clone()),
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(item.response.id.clone()),
redirection_data: Box::new(redirection_data),
mandate_reference: Box::new(None),
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: Some(item.response.id),
incremental_authorization_allowed: None,
charges: None,
}),
..item.data
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/airwallex/transformers.rs" role="context" start="536" end="541">
pub struct AirwallexPaymentsNextAction {
url: Url,
method: Method,
data: AirwallexRedirectFormData,
stage: AirwallexNextActionStage,
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/airwallex/transformers.rs" role="context" start="519" end="522">
pub enum AirwallexNextActionStage {
WaitingDeviceDataCollection,
WaitingUserInfoInput,
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/airwallex/transformers.rs" role="context" start="481" end="490">
pub enum AirwallexPaymentStatus {
Succeeded,
Failed,
#[default]
Pending,
RequiresPaymentMethod,
RequiresCustomerAction,
RequiresCapture,
Cancelled,
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/hyperswitch_connectors/src/connectors/paypal/transformers.rs<|crate|> hyperswitch_connectors<|connector|> paypal anchor=foreign_try_from kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=1<|meta_end|>
<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="1895" end="1895">
use common_enums::enums as storage_enums;
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,
},
};
use crate::{
types::{PaymentsCaptureResponseRouterData, RefundsResponseRouterData, ResponseRouterData},
utils::{
self, missing_field_err, to_connector_meta, AccessTokenRequestInfo, AddressDetailsData,
CardData, PaymentsAuthorizeRequestData, PaymentsPostSessionTokensRequestData,
RouterData as OtherRouterData,
},
};
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/paypal/transformers.rs" role="context" start="2000" end="2038">
fn try_from(
item: ResponseRouterData<
Authorize,
PaypalRedirectResponse,
PaymentsAuthorizeData,
PaymentsResponseData,
>,
) -> Result<Self, Self::Error> {
let status = get_order_status(item.response.clone().status, item.response.intent.clone());
let link = get_redirect_url(item.response.links.clone())?;
let connector_meta = serde_json::json!(PaypalMeta {
authorize_id: None,
capture_id: None,
psync_flow: item.response.intent,
next_action: None,
order_id: None,
});
let purchase_units = item.response.purchase_units.first();
Ok(Self {
status,
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(item.response.id.clone()),
redirection_data: Box::new(Some(RedirectForm::from((
link.ok_or(errors::ConnectorError::ResponseDeserializationFailed)?,
Method::Get,
)))),
mandate_reference: Box::new(None),
connector_metadata: Some(connector_meta),
network_txn_id: None,
connector_response_reference_id: Some(
purchase_units.map_or(item.response.id, |item| item.invoice_id.clone()),
),
incremental_authorization_allowed: None,
charges: None,
}),
..item.data
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/paypal/transformers.rs" role="context" start="1943" end="1986">
fn foreign_try_from(
(item, payment_experience): (
ResponseRouterData<F, PaypalRedirectResponse, T, PaymentsResponseData>,
Option<common_enums::PaymentExperience>,
),
) -> Result<Self, Self::Error> {
let status = get_order_status(item.response.clone().status, item.response.intent.clone());
let link = get_redirect_url(item.response.links.clone())?;
// For Paypal SDK flow, we need to trigger SDK client and then complete authorize
let next_action =
if let Some(common_enums::PaymentExperience::InvokeSdkClient) = payment_experience {
Some(api_models::payments::NextActionCall::CompleteAuthorize)
} else {
None
};
let connector_meta = serde_json::json!(PaypalMeta {
authorize_id: None,
capture_id: None,
psync_flow: item.response.intent,
next_action,
order_id: None,
});
let purchase_units = item.response.purchase_units.first();
Ok(Self {
status,
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(item.response.id.clone()),
redirection_data: Box::new(Some(RedirectForm::from((
link.ok_or(errors::ConnectorError::ResponseDeserializationFailed)?,
Method::Get,
)))),
mandate_reference: Box::new(None),
connector_metadata: Some(connector_meta),
network_txn_id: None,
connector_response_reference_id: Some(
purchase_units.map_or(item.response.id, |item| item.invoice_id.clone()),
),
incremental_authorization_allowed: None,
charges: None,
}),
..item.data
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/paypal/transformers.rs" role="context" start="1877" end="1887">
fn get_redirect_url(
link_vec: Vec<PaypalLinks>,
) -> CustomResult<Option<Url>, errors::ConnectorError> {
let mut link: Option<Url> = None;
for item2 in link_vec.iter() {
if item2.rel == "payer-action" {
link.clone_from(&item2.href)
}
}
Ok(link)
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/paypal/transformers.rs" role="context" start="1783" end="1874">
fn try_from(
item: ResponseRouterData<F, PaypalOrdersResponse, T, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
let purchase_units = item
.response
.purchase_units
.first()
.ok_or(errors::ConnectorError::MissingConnectorTransactionID)?;
let id = get_id_based_on_intent(&item.response.intent, purchase_units)?;
let (connector_meta, order_id) = match item.response.intent.clone() {
PaypalPaymentIntent::Capture => (
serde_json::json!(PaypalMeta {
authorize_id: None,
capture_id: Some(id),
psync_flow: item.response.intent.clone(),
next_action: None,
order_id: None,
}),
ResponseId::ConnectorTransactionId(item.response.id.clone()),
),
PaypalPaymentIntent::Authorize => (
serde_json::json!(PaypalMeta {
authorize_id: Some(id),
capture_id: None,
psync_flow: item.response.intent.clone(),
next_action: None,
order_id: None,
}),
ResponseId::ConnectorTransactionId(item.response.id.clone()),
),
PaypalPaymentIntent::Authenticate => {
Err(errors::ConnectorError::ResponseDeserializationFailed)?
}
};
//payment collection will always have only one element as we only make one transaction per order.
let payment_collection = &item
.response
.purchase_units
.first()
.ok_or(errors::ConnectorError::ResponseDeserializationFailed)?
.payments;
//payment collection item will either have "authorizations" field or "capture" field, not both at a time.
let payment_collection_item = match (
&payment_collection.authorizations,
&payment_collection.captures,
) {
(Some(authorizations), None) => authorizations.first(),
(None, Some(captures)) => captures.first(),
(Some(_), Some(captures)) => captures.first(),
_ => None,
}
.ok_or(errors::ConnectorError::ResponseDeserializationFailed)?;
let status = payment_collection_item.status.clone();
let status = storage_enums::AttemptStatus::from(status);
Ok(Self {
status,
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: order_id,
redirection_data: Box::new(None),
mandate_reference: Box::new(Some(MandateReference {
connector_mandate_id: match item.response.payment_source.clone() {
Some(paypal_source) => match paypal_source {
PaymentSourceItemResponse::Paypal(paypal_source) => {
paypal_source.attributes.map(|attr| attr.vault.id)
}
PaymentSourceItemResponse::Card(card) => {
card.attributes.map(|attr| attr.vault.id)
}
PaymentSourceItemResponse::Eps(_)
| PaymentSourceItemResponse::Ideal(_) => None,
},
None => None,
},
payment_method_id: None,
mandate_metadata: None,
connector_mandate_request_reference_id: None,
})),
connector_metadata: Some(connector_meta),
network_txn_id: None,
connector_response_reference_id: purchase_units
.invoice_id
.clone()
.or(Some(item.response.id)),
incremental_authorization_allowed: None,
charges: None,
}),
..item.data
})
}
<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="76" end="76">
type Error = error_stack::Report<errors::ConnectorError>;
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/paypal/transformers.rs" role="context" start="1723" end="1728">
pub struct PaypalThreeDsSyncResponse {
id: String,
status: PaypalOrderStatus,
// provided to separated response of card's 3DS from other
payment_source: CardsData,
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/paypal/transformers.rs" role="context" start="1706" end="1711">
pub enum PaypalSyncResponse {
PaypalOrdersSyncResponse(PaypalOrdersResponse),
PaypalThreeDsSyncResponse(PaypalThreeDsSyncResponse),
PaypalRedirectSyncResponse(PaypalRedirectResponse),
PaypalPaymentsSyncResponse(PaypalPaymentsSyncResponse),
}
|
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="1032" end="1055">
fn try_from(item: &FiuuRouterData<&RefundsRouterData<Execute>>) -> Result<Self, Self::Error> {
let auth: FiuuAuthType = FiuuAuthType::try_from(&item.router_data.connector_auth_type)?;
let merchant_id = auth.merchant_id.peek().to_string();
let txn_amount = item.amount.clone();
let reference_no = item.router_data.connector_request_reference_id.clone();
let txn_id = item.router_data.request.connector_transaction_id.clone();
let secret_key = auth.secret_key.peek().to_string();
Ok(Self {
refund_type: RefundType::Partial,
merchant_id: auth.merchant_id,
ref_id: reference_no.clone(),
txn_id: txn_id.clone(),
amount: txn_amount.clone(),
signature: calculate_signature(format!(
"{}{merchant_id}{reference_no}{txn_id}{}{secret_key}",
RefundType::Partial,
txn_amount.get_amount_as_string()
))?,
notify_url: Some(
Url::parse(&item.router_data.request.get_webhook_url()?)
.change_context(errors::ConnectorError::RequestEncodingFailed)?,
),
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/fiuu/transformers.rs" role="context" start="1031" end="1031">
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,
},
};
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/fiuu/transformers.rs" role="context" start="1207" end="1228">
fn try_from(item: &PaymentsSyncRouterData) -> Result<Self, Self::Error> {
let auth = FiuuAuthType::try_from(&item.connector_auth_type)?;
let txn_id = item
.request
.connector_transaction_id
.get_connector_transaction_id()
.change_context(errors::ConnectorError::MissingConnectorTransactionID)?;
let merchant_id = auth.merchant_id.peek().to_string();
let verify_key = auth.verify_key.peek().to_string();
let amount = StringMajorUnitForConnector
.convert(item.request.amount, item.request.currency)
.change_context(errors::ConnectorError::AmountConversionFailed)?;
Ok(Self {
amount: amount.clone(),
tx_id: txn_id.clone(),
domain: merchant_id.clone(),
skey: calculate_signature(format!(
"{txn_id}{merchant_id}{verify_key}{}",
amount.get_amount_as_string()
))?,
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/fiuu/transformers.rs" role="context" start="1077" end="1133">
fn try_from(
item: RefundsResponseRouterData<Execute, FiuuRefundResponse>,
) -> Result<Self, Self::Error> {
match item.response {
FiuuRefundResponse::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
}),
FiuuRefundResponse::Success(refund_data) => {
let refund_status = match refund_data.status.as_str() {
"00" => Ok(enums::RefundStatus::Success),
"11" => Ok(enums::RefundStatus::Failure),
"22" => Ok(enums::RefundStatus::Pending),
other => Err(errors::ConnectorError::UnexpectedResponseError(
bytes::Bytes::from(other.to_owned()),
)),
}?;
if refund_status == enums::RefundStatus::Failure {
Ok(Self {
response: Err(ErrorResponse {
code: refund_data.status.clone(),
message: refund_data
.reason
.clone()
.unwrap_or(consts::NO_ERROR_MESSAGE.to_string()),
reason: refund_data.reason.clone(),
status_code: item.http_code,
attempt_status: None,
connector_transaction_id: Some(refund_data.refund_id.to_string()),
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
}),
..item.data
})
} else {
Ok(Self {
response: Ok(RefundsResponseData {
connector_refund_id: refund_data.refund_id.clone().to_string(),
refund_status,
}),
..item.data
})
}
}
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/fiuu/transformers.rs" role="context" start="1000" end="1005">
fn from(status: FiuuRecurringStautus) -> Self {
match status {
FiuuRecurringStautus::Accepted => Self::Charged,
FiuuRecurringStautus::Failed => Self::Failure,
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/fiuu/transformers.rs" role="context" start="800" end="996">
fn try_from(
item: ResponseRouterData<
F,
FiuuPaymentsResponse,
PaymentsAuthorizeData,
PaymentsResponseData,
>,
) -> Result<Self, Self::Error> {
match item.response {
FiuuPaymentsResponse::QRPaymentResponse(ref response) => Ok(Self {
status: enums::AttemptStatus::AuthenticationPending,
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(response.txn_id.clone()),
redirection_data: Box::new(None),
mandate_reference: Box::new(None),
connector_metadata: get_qr_metadata(response)?,
network_txn_id: None,
connector_response_reference_id: None,
incremental_authorization_allowed: None,
charges: None,
}),
..item.data
}),
FiuuPaymentsResponse::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
}),
FiuuPaymentsResponse::PaymentResponse(data) => match data.txn_data.request_data {
RequestData::RedirectData(redirection_data) => {
let redirection_data = Some(RedirectForm::Form {
endpoint: data.txn_data.request_url.to_string(),
method: if data.txn_data.request_method.as_str() == "POST" {
Method::Post
} else {
Method::Get
},
form_fields: redirection_data.unwrap_or_default(),
});
Ok(Self {
status: enums::AttemptStatus::AuthenticationPending,
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(data.txn_id),
redirection_data: Box::new(redirection_data),
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
})
}
RequestData::NonThreeDS(non_threeds_data) => {
let mandate_reference =
non_threeds_data
.extra_parameters
.as_ref()
.and_then(|extra_p| {
extra_p.token.as_ref().map(|token| MandateReference {
connector_mandate_id: Some(token.clone().expose()),
payment_method_id: None,
mandate_metadata: None,
connector_mandate_request_reference_id: None,
})
});
let status = match non_threeds_data.status.as_str() {
"00" => {
if item.data.request.is_auto_capture()? {
Ok(enums::AttemptStatus::Charged)
} else {
Ok(enums::AttemptStatus::Authorized)
}
}
"11" => Ok(enums::AttemptStatus::Failure),
"22" => Ok(enums::AttemptStatus::Pending),
other => Err(errors::ConnectorError::UnexpectedResponseError(
bytes::Bytes::from(other.to_owned()),
)),
}?;
let response = if status == enums::AttemptStatus::Failure {
Err(ErrorResponse {
code: non_threeds_data
.error_code
.clone()
.unwrap_or_else(|| "NO_ERROR_CODE".to_string()),
message: non_threeds_data
.error_desc
.clone()
.unwrap_or_else(|| "NO_ERROR_MESSAGE".to_string()),
reason: non_threeds_data.error_desc.clone(),
status_code: item.http_code,
attempt_status: None,
connector_transaction_id: Some(data.txn_id),
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
})
} else {
Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(data.txn_id.clone()),
redirection_data: Box::new(None),
mandate_reference: Box::new(mandate_reference),
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: None,
incremental_authorization_allowed: None,
charges: None,
})
};
Ok(Self {
status,
response,
..item.data
})
}
},
FiuuPaymentsResponse::RecurringResponse(ref recurring_response_vec) => {
let recurring_response_item = recurring_response_vec.first();
let router_data_response = match recurring_response_item {
Some(recurring_response) => {
let status =
common_enums::AttemptStatus::from(recurring_response.status.clone());
let connector_transaction_id = recurring_response
.tran_id
.as_ref()
.map_or(ResponseId::NoResponseId, |tran_id| {
ResponseId::ConnectorTransactionId(tran_id.clone())
});
let response = if status == common_enums::AttemptStatus::Failure {
Err(ErrorResponse {
code: recurring_response
.reason
.clone()
.unwrap_or_else(|| "NO_ERROR_CODE".to_string()),
message: recurring_response
.reason
.clone()
.unwrap_or_else(|| "NO_ERROR_MESSAGE".to_string()),
reason: recurring_response.reason.clone(),
status_code: item.http_code,
attempt_status: None,
connector_transaction_id: recurring_response.tran_id.clone(),
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
})
} else {
Ok(PaymentsResponseData::TransactionResponse {
resource_id: connector_transaction_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,
})
};
Self {
status,
response,
..item.data
}
}
None => {
// It is not expected to get empty response from the connnector, if we get we are not updating the payment response since we don't have any info in the authorize response.
let response = 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,
});
Self {
response,
..item.data
}
}
};
Ok(router_data_response)
}
}
}
<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="391" end="401">
pub fn calculate_signature(
signature_data: String,
) -> Result<Secret<String>, Report<errors::ConnectorError>> {
let message = signature_data.as_bytes();
let encoded_data = hex::encode(
crypto::Md5
.generate_digest(message)
.change_context(errors::ConnectorError::RequestEncodingFailed)?,
);
Ok(Secret::new(encoded_data))
}
<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="1024" end="1028">
pub enum RefundType {
#[serde(rename = "P")]
#[strum(serialize = "P")]
Partial,
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/fiuu/transformers.rs" role="context" start="70" end="74">
pub struct FiuuAuthType {
pub(super) merchant_id: Secret<String>,
pub(super) verify_key: Secret<String>,
pub(super) secret_key: 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/redsys/transformers.rs<|crate|> hyperswitch_connectors<|connector|> redsys 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/redsys/transformers.rs" role="context" start="1138" end="1175">
fn try_from(
item: ResponseRouterData<F, RedsysResponse, CompleteAuthorizeData, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
let (response, status) = match item.response.clone() {
RedsysResponse::RedsysResponse(transaction_response) => {
let response_data: RedsysPaymentsResponse = to_connector_response_data(
&transaction_response.ds_merchant_parameters.clone().expose(),
)?;
get_payments_response(
response_data,
item.data.request.capture_method,
None,
item.http_code,
)?
}
RedsysResponse::RedsysErrorResponse(response) => {
let response = Err(ErrorResponse {
code: response.error_code.clone(),
message: response.error_code.clone(),
reason: Some(response.error_code.clone()),
status_code: item.http_code,
attempt_status: None,
connector_transaction_id: None,
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
});
(response, enums::AttemptStatus::Failure)
}
};
Ok(Self {
status,
response,
..item.data
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/redsys/transformers.rs" role="context" start="1137" end="1137">
use common_enums::enums;
use hyperswitch_domain_models::{
address::Address,
payment_method_data::PaymentMethodData,
router_data::{ConnectorAuthType, ErrorResponse, RouterData},
router_flow_types::refunds::{Execute, RSync},
router_request_types::{
BrowserInformation, CompleteAuthorizeData, PaymentsAuthorizeData, PaymentsCancelData,
PaymentsCaptureData, PaymentsPreProcessingData, PaymentsSyncData, ResponseId,
},
router_response_types::{PaymentsResponseData, RedirectForm, RefundsResponseData},
types::{
PaymentsAuthorizeRouterData, PaymentsCancelRouterData, PaymentsCaptureRouterData,
PaymentsCompleteAuthorizeRouterData, PaymentsPreProcessingRouterData,
PaymentsSyncRouterData, RefundSyncRouterData, RefundsRouterData,
},
};
use crate::{
types::{RefundsResponseRouterData, ResponseRouterData},
utils::{
self as connector_utils, AddressDetailsData, BrowserInformationData, CardData,
PaymentsAuthorizeRequestData, PaymentsCompleteAuthorizeRequestData,
PaymentsPreProcessingRequestData, RouterData as _,
},
};
type Error = error_stack::Report<errors::ConnectorError>;
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/redsys/transformers.rs" role="context" start="1218" end="1229">
fn try_from(item: &RedsysRouterData<&PaymentsCaptureRouterData>) -> Result<Self, Self::Error> {
let auth = RedsysAuthType::try_from(&item.router_data.connector_auth_type)?;
let redys_capture_request = RedsysOperationRequest {
ds_merchant_order: item.router_data.request.connector_transaction_id.clone(),
ds_merchant_merchantcode: auth.merchant_id.clone(),
ds_merchant_terminal: auth.terminal_id.clone(),
ds_merchant_currency: item.router_data.request.currency.iso_4217().to_owned(),
ds_merchant_transactiontype: RedsysTransactionType::Confirmation,
ds_merchant_amount: item.amount.clone(),
};
Self::try_from((&redys_capture_request, &auth))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/redsys/transformers.rs" role="context" start="1179" end="1185">
fn from(threeds_compl_flag: api_models::payments::ThreeDsCompletionIndicator) -> Self {
match threeds_compl_flag {
api_models::payments::ThreeDsCompletionIndicator::Success => Self::Y,
api_models::payments::ThreeDsCompletionIndicator::Failure
| api_models::payments::ThreeDsCompletionIndicator::NotAvailable => Self::N,
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/redsys/transformers.rs" role="context" start="1024" end="1131">
fn try_from(
item: &RedsysRouterData<&PaymentsCompleteAuthorizeRouterData>,
) -> Result<Self, Self::Error> {
if !item.router_data.is_three_ds() {
Err(errors::ConnectorError::NotSupported {
message: "PaymentsComplete flow for no-3ds cards".to_string(),
connector: "redsys",
})?
};
let card_data =
RedsysCardData::try_from(&item.router_data.request.payment_method_data.clone())?;
let auth = RedsysAuthType::try_from(&item.router_data.connector_auth_type)?;
let redirect_response = item
.router_data
.request
.get_redirect_response_payload()
.ok()
.clone()
.map(|payload_data| {
payload_data
.parse_value::<ThreedsChallengeResponse>("Redsys ThreedsChallengeResponse")
.change_context(errors::ConnectorError::ResponseDeserializationFailed)
})
.transpose()?;
let billing_data = item.router_data.get_optional_billing();
let shipping_data = item.router_data.get_optional_shipping();
let emv3ds_data = match redirect_response {
Some(payload) => {
if let Ok(threeds_invoke_meta_data) =
connector_utils::to_connector_meta::<RedsysThreeDsInvokeData>(
item.router_data.request.connector_meta.clone(),
)
{
EmvThreedsData::new(RedsysThreeDsInfo::ChallengeResponse)
.set_protocol_version(threeds_invoke_meta_data.message_version)
.set_three_d_s_cres(payload.cres)
.set_billing_data(billing_data)?
.set_shipping_data(shipping_data)?
} else if let Ok(threeds_meta_data) =
connector_utils::to_connector_meta::<ThreeDsInvokeExempt>(
item.router_data.request.connector_meta.clone(),
)
{
EmvThreedsData::new(RedsysThreeDsInfo::ChallengeResponse)
.set_protocol_version(threeds_meta_data.message_version)
.set_three_d_s_cres(payload.cres)
.set_billing_data(billing_data)?
.set_shipping_data(shipping_data)?
} else {
Err(errors::ConnectorError::RequestEncodingFailed)?
}
}
None => {
if let Ok(threeds_invoke_meta_data) =
connector_utils::to_connector_meta::<RedsysThreeDsInvokeData>(
item.router_data.request.connector_meta.clone(),
)
{
let three_d_s_comp_ind = ThreeDSCompInd::from(
item.router_data.request.get_threeds_method_comp_ind()?,
);
let browser_info = item.router_data.request.get_browser_info()?;
let complete_authorize_url =
item.router_data.request.get_complete_authorize_url()?;
EmvThreedsData::new(RedsysThreeDsInfo::AuthenticationData)
.set_three_d_s_server_trans_i_d(
threeds_invoke_meta_data.directory_server_id,
)
.set_protocol_version(threeds_invoke_meta_data.message_version)
.set_three_d_s_comp_ind(three_d_s_comp_ind)
.add_browser_data(browser_info)?
.set_notification_u_r_l(complete_authorize_url)
.set_billing_data(billing_data)?
.set_shipping_data(shipping_data)?
} else {
Err(errors::ConnectorError::NoConnectorMetaData)?
}
}
};
let ds_merchant_transactiontype = if item.router_data.request.is_auto_capture()? {
RedsysTransactionType::Payment
} else {
RedsysTransactionType::Preauthorization
};
let ds_merchant_order = item
.router_data
.request
.connector_transaction_id
.clone()
.ok_or(errors::ConnectorError::RequestEncodingFailed)
.attach_printable("Missing connector_transaction_id")?;
let complete_authorize_response = PaymentsRequest {
ds_merchant_emv3ds: Some(emv3ds_data),
ds_merchant_transactiontype,
ds_merchant_currency: item.currency.iso_4217().to_owned(),
ds_merchant_pan: card_data.card_number,
ds_merchant_merchantcode: auth.merchant_id.clone(),
ds_merchant_terminal: auth.terminal_id.clone(),
ds_merchant_order,
ds_merchant_amount: item.amount.clone(),
ds_merchant_expirydate: card_data.expiry_date,
ds_merchant_cvv2: card_data.cvv2,
};
Self::try_from((&complete_authorize_response, &auth))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/redsys/transformers.rs" role="context" start="973" end="1015">
fn try_from(
item: ResponseRouterData<F, RedsysResponse, PaymentsAuthorizeData, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
let (response, status) = match item.response.clone() {
RedsysResponse::RedsysResponse(transaction_response) => {
let connector_metadata = match item.data.response {
Ok(PaymentsResponseData::TransactionResponse {
connector_metadata, ..
}) => connector_metadata,
_ => None,
};
let response_data: RedsysPaymentsResponse = to_connector_response_data(
&transaction_response.ds_merchant_parameters.clone().expose(),
)?;
get_payments_response(
response_data,
item.data.request.capture_method,
connector_metadata,
item.http_code,
)?
}
RedsysResponse::RedsysErrorResponse(response) => {
let response = Err(ErrorResponse {
code: response.error_code.clone(),
message: response.error_code.clone(),
reason: Some(response.error_code.clone()),
status_code: item.http_code,
attempt_status: None,
connector_transaction_id: None,
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
});
(response, enums::AttemptStatus::Failure)
}
};
Ok(Self {
status,
response,
..item.data
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/redsys/transformers.rs" role="context" start="580" end="593">
fn to_connector_response_data<T>(connector_response: &str) -> Result<T, Error>
where
T: serde::de::DeserializeOwned,
{
let decoded_bytes = BASE64_ENGINE
.decode(connector_response)
.change_context(errors::ConnectorError::ResponseDeserializationFailed)
.attach_printable("Failed to decode Base64")?;
let response_data: T = serde_json::from_slice(&decoded_bytes)
.change_context(errors::ConnectorError::ResponseHandlingFailed)?;
Ok(response_data)
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/redsys/transformers.rs" role="context" start="1468" end="1530">
fn get_payments_response(
redsys_payments_response: RedsysPaymentsResponse,
capture_method: Option<enums::CaptureMethod>,
connector_metadata: Option<josekit::Value>,
http_code: u16,
) -> Result<
(
Result<PaymentsResponseData, ErrorResponse>,
enums::AttemptStatus,
),
Error,
> {
if let Some(ds_response) = redsys_payments_response.ds_response {
let status = get_redsys_attempt_status(ds_response.clone(), capture_method)?;
let response = if connector_utils::is_payment_failure(status) {
Err(ErrorResponse {
code: ds_response.0.clone(),
message: ds_response.0.clone(),
reason: Some(ds_response.0.clone()),
status_code: http_code,
attempt_status: None,
connector_transaction_id: Some(redsys_payments_response.ds_order.clone()),
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
})
} else {
Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(
redsys_payments_response.ds_order.clone(),
),
redirection_data: Box::new(None),
mandate_reference: Box::new(None),
connector_metadata,
network_txn_id: None,
connector_response_reference_id: Some(redsys_payments_response.ds_order.clone()),
incremental_authorization_allowed: None,
charges: None,
})
};
Ok((response, status))
} else {
let redirection_form = redsys_payments_response
.ds_emv3ds
.map(|ds_emv3ds| build_threeds_form(&ds_emv3ds))
.transpose()?;
let response = Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(
redsys_payments_response.ds_order.clone(),
),
redirection_data: Box::new(redirection_form),
mandate_reference: Box::new(None),
connector_metadata,
network_txn_id: None,
connector_response_reference_id: Some(redsys_payments_response.ds_order.clone()),
incremental_authorization_allowed: None,
charges: None,
});
Ok((response, enums::AttemptStatus::AuthenticationPending))
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/redsys/transformers.rs" role="context" start="38" end="38">
type Error = error_stack::Report<errors::ConnectorError>;
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/redsys/transformers.rs" role="context" start="521" end="532">
pub struct RedsysPaymentsResponse {
#[serde(rename = "Ds_Order")]
ds_order: String,
#[serde(rename = "Ds_EMV3DS")]
ds_emv3ds: Option<RedsysEmv3DSData>,
#[serde(rename = "Ds_Card_PSD2")]
ds_card_psd2: Option<CardPSD2>,
#[serde(rename = "Ds_Response")]
ds_response: Option<DsResponse>,
#[serde(rename = "Ds_AuthorisationCode")]
ds_authorisation_code: Option<String>,
}
<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/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/braintree.rs<|crate|> hyperswitch_connectors<|connector|> braintree anchor=get_dispute_details kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/braintree.rs" role="context" start="1041" end="1068">
fn get_dispute_details(
&self,
request: &IncomingWebhookRequestDetails<'_>,
) -> CustomResult<DisputePayload, errors::ConnectorError> {
let notif = get_webhook_object_from_body(request.body)
.change_context(errors::ConnectorError::WebhookBodyDecodingFailed)?;
let response = decode_webhook_payload(notif.bt_payload.replace('\n', "").as_bytes())?;
match response.dispute {
Some(dispute_data) => Ok(DisputePayload {
amount: to_currency_lower_unit(
dispute_data.amount_disputed.to_string(),
dispute_data.currency_iso_code,
)?,
currency: dispute_data.currency_iso_code,
dispute_stage: transformers::get_dispute_stage(dispute_data.kind.as_str())?,
connector_dispute_id: dispute_data.id,
connector_reason: dispute_data.reason,
connector_reason_code: dispute_data.reason_code,
challenge_required_by: dispute_data.reply_by_date,
connector_status: dispute_data.status,
created_at: dispute_data.created_at,
updated_at: dispute_data.updated_at,
}),
None => Err(errors::ConnectorError::WebhookResourceObjectNotFound)?,
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/braintree.rs" role="context" start="1040" end="1040">
use common_utils::{
consts::BASE64_ENGINE,
crypto,
errors::{CustomResult, ParsingError},
ext_traits::{BytesExt, XmlExt},
request::{Method, Request, RequestBuilder, RequestContent},
types::{AmountConvertor, StringMajorUnit, StringMajorUnitForConnector},
};
use hyperswitch_interfaces::{
api::{
self, ConnectorCommon, ConnectorCommonExt, ConnectorIntegration, ConnectorRedirectResponse,
ConnectorSpecifications, ConnectorValidation,
},
configs::Connectors,
consts::{NO_ERROR_CODE, NO_ERROR_MESSAGE},
disputes::DisputePayload,
errors,
events::connector_api_logs::ConnectorEvent,
types::{
MandateRevokeType, PaymentsAuthorizeType, PaymentsCaptureType,
PaymentsCompleteAuthorizeType, PaymentsSyncType, PaymentsVoidType, RefundExecuteType,
RefundSyncType, Response, TokenizationType,
},
webhooks::{IncomingWebhook, IncomingWebhookFlowError, IncomingWebhookRequestDetails},
};
use transformers::{self as braintree, get_status};
use crate::{
constants::headers,
types::ResponseRouterData,
utils::{
self, convert_amount, is_mandate_supported, to_currency_lower_unit, PaymentMethodDataType,
PaymentsAuthorizeRequestData, PaymentsCompleteAuthorizeRequestData,
},
};
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/braintree.rs" role="context" start="1083" end="1088">
fn get_webhook_object_from_body(
body: &[u8],
) -> CustomResult<transformers::BraintreeWebhookResponse, ParsingError> {
serde_urlencoded::from_bytes::<transformers::BraintreeWebhookResponse>(body)
.change_context(ParsingError::StructParseFailure("BraintreeWebhookResponse"))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/braintree.rs" role="context" start="1071" end="1081">
fn get_matching_webhook_signature(
signature_pairs: Vec<(&str, &str)>,
secret: String,
) -> Option<String> {
for (public_key, signature) in signature_pairs {
if *public_key == secret {
return Some(signature.to_string());
}
}
None
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/braintree.rs" role="context" start="1033" end="1039">
fn get_webhook_api_response(
&self,
_request: &IncomingWebhookRequestDetails<'_>,
_error_kind: Option<IncomingWebhookFlowError>,
) -> CustomResult<ApplicationResponse<serde_json::Value>, errors::ConnectorError> {
Ok(ApplicationResponse::TextPlain("[accepted]".to_string()))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/braintree.rs" role="context" start="1021" end="1031">
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::WebhookBodyDecodingFailed)?;
let response = decode_webhook_payload(notif.bt_payload.replace('\n', "").as_bytes())?;
Ok(Box::new(response))
}
<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/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/novalnet/transformers.rs<|crate|> hyperswitch_connectors<|connector|> novalnet 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/novalnet/transformers.rs" role="context" start="1215" end="1251">
fn try_from(
item: RefundsResponseRouterData<RSync, NovalnetRefundSyncResponse>,
) -> Result<Self, Self::Error> {
match item.response.result.status {
NovalnetAPIStatus::Success => {
let refund_id = item
.response
.transaction
.clone()
.and_then(|data| data.tid)
.map(|tid| tid.expose().to_string())
.unwrap_or("".to_string());
//NOTE: Mapping refund_id with "" incase we dont get any tid
let transaction_status = item
.response
.transaction
.map(|transaction_data| transaction_data.status)
.unwrap_or(NovalnetTransactionStatus::Pending);
Ok(Self {
response: Ok(RefundsResponseData {
connector_refund_id: refund_id,
refund_status: enums::RefundStatus::from(transaction_status),
}),
..item.data
})
}
NovalnetAPIStatus::Failure => {
let response = Err(get_error_response(item.response.result, item.http_code));
Ok(Self {
response,
..item.data
})
}
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/novalnet/transformers.rs" role="context" start="1214" end="1214">
use common_enums::{enums, enums as api_enums};
use hyperswitch_domain_models::{
payment_method_data::{PaymentMethodData, WalletData as WalletDataPaymentMethod},
router_data::{ConnectorAuthType, ErrorResponse, RouterData},
router_flow_types::refunds::{Execute, RSync},
router_request_types::{PaymentsCancelData, PaymentsCaptureData, PaymentsSyncData, ResponseId},
router_response_types::{
MandateReference, PaymentsResponseData, RedirectForm, RefundsResponseData,
},
types::{
PaymentsAuthorizeRouterData, PaymentsCancelRouterData, PaymentsCaptureRouterData,
PaymentsSyncRouterData, RefundSyncRouterData, RefundsRouterData, SetupMandateRouterData,
},
};
use crate::{
types::{RefundsResponseRouterData, ResponseRouterData},
utils::{
self, AddressData, AddressDetailsData, ApplePay, PaymentsAuthorizeRequestData,
PaymentsCancelRequestData, PaymentsCaptureRequestData, PaymentsSetupMandateRequestData,
PaymentsSyncRequestData, RefundsRequestData, RouterData as _,
},
};
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/novalnet/transformers.rs" role="context" start="1296" end="1346">
fn try_from(
item: ResponseRouterData<
F,
NovalnetCancelResponse,
PaymentsCancelData,
PaymentsResponseData,
>,
) -> Result<Self, Self::Error> {
match item.response.result.status {
NovalnetAPIStatus::Success => {
let transaction_id = item
.response
.transaction
.clone()
.and_then(|data| data.tid.map(|tid| tid.expose().to_string()));
let transaction_status = item
.response
.transaction
.and_then(|transaction_data| transaction_data.status)
.unwrap_or(NovalnetTransactionStatus::Pending);
Ok(Self {
status: if transaction_status == NovalnetTransactionStatus::Deactivated {
enums::AttemptStatus::Voided
} else {
enums::AttemptStatus::VoidFailed
},
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: transaction_id
.clone()
.map(ResponseId::ConnectorTransactionId)
.unwrap_or(ResponseId::NoResponseId),
redirection_data: Box::new(None),
mandate_reference: Box::new(None),
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: transaction_id.clone(),
incremental_authorization_allowed: None,
charges: None,
}),
..item.data
})
}
NovalnetAPIStatus::Failure => {
let response = Err(get_error_response(item.response.result, item.http_code));
Ok(Self {
response,
..item.data
})
}
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/novalnet/transformers.rs" role="context" start="1267" end="1282">
fn try_from(item: &PaymentsCancelRouterData) -> Result<Self, Self::Error> {
let transaction = NovalnetCancelTransaction {
tid: item.request.connector_transaction_id.clone(),
};
let custom = NovalnetCustom {
lang: item
.request
.get_optional_language_from_browser_info()
.unwrap_or(consts::DEFAULT_LOCALE.to_string().to_string()),
};
Ok(Self {
transaction,
custom,
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/novalnet/transformers.rs" role="context" start="1193" end="1208">
fn try_from(item: &RefundSyncRouterData) -> Result<Self, Self::Error> {
let transaction = NovalnetSyncTransaction {
tid: item.request.connector_transaction_id.clone(),
};
let custom = NovalnetCustom {
lang: item
.request
.get_optional_language_from_browser_info()
.unwrap_or(consts::DEFAULT_LOCALE.to_string().to_string()),
};
Ok(Self {
transaction,
custom,
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/novalnet/transformers.rs" role="context" start="1130" end="1177">
fn try_from(
item: ResponseRouterData<
F,
NovalnetCaptureResponse,
PaymentsCaptureData,
PaymentsResponseData,
>,
) -> Result<Self, Self::Error> {
match item.response.result.status {
NovalnetAPIStatus::Success => {
let transaction_id = item
.response
.transaction
.clone()
.map(|data| data.tid.expose().to_string());
let transaction_status = item
.response
.transaction
.map(|transaction_data| transaction_data.status)
.unwrap_or(NovalnetTransactionStatus::Pending);
Ok(Self {
status: common_enums::AttemptStatus::from(transaction_status),
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: transaction_id
.clone()
.map(ResponseId::ConnectorTransactionId)
.unwrap_or(ResponseId::NoResponseId),
redirection_data: Box::new(None),
mandate_reference: Box::new(None),
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: transaction_id.clone(),
incremental_authorization_allowed: None,
charges: None,
}),
..item.data
})
}
NovalnetAPIStatus::Failure => {
let response = Err(get_error_response(item.response.result, item.http_code));
Ok(Self {
response,
..item.data
})
}
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/novalnet/transformers.rs" role="context" start="877" end="888">
fn from(item: NovalnetTransactionStatus) -> Self {
match item {
NovalnetTransactionStatus::Success | NovalnetTransactionStatus::Confirmed => {
Self::Success
}
NovalnetTransactionStatus::Pending => Self::Pending,
NovalnetTransactionStatus::Failure
| NovalnetTransactionStatus::OnHold
| NovalnetTransactionStatus::Deactivated
| NovalnetTransactionStatus::Progress => Self::Failure,
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/novalnet/transformers.rs" role="context" start="581" end="596">
pub fn get_error_response(result: ResultData, status_code: u16) -> ErrorResponse {
let error_code = result.status;
let error_reason = result.status_text.clone();
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/novalnet/transformers.rs" role="context" start="174" end="174">
type Error = error_stack::Report<errors::ConnectorError>;
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/novalnet/transformers.rs" role="context" start="892" end="895">
pub struct NovalnetRefundSyncResponse {
result: ResultData,
transaction: Option<NovalnetSyncResponseTransactionData>,
}
<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/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/deutschebank/transformers.rs<|crate|> hyperswitch_connectors<|connector|> deutschebank 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/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/deutschebank/transformers.rs" role="context" start="879" end="879">
use common_enums::{enums, PaymentMethod};
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,
},
};
use crate::{
types::{PaymentsCancelResponseRouterData, RefundsResponseRouterData, ResponseRouterData},
utils::{
self, AddressDetailsData, CardData, PaymentsAuthorizeRequestData,
PaymentsCompleteAuthorizeRequestData, RefundsRequestData, RouterData as OtherRouterData,
},
};
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/deutschebank/transformers.rs" role="context" start="972" end="1007">
fn try_from(
item: ResponseRouterData<
Capture,
DeutschebankPaymentsResponse,
PaymentsCaptureData,
PaymentsResponseData,
>,
) -> Result<Self, Self::Error> {
let response_code = item.response.rc.clone();
if is_response_success(&response_code) {
Ok(Self {
status: common_enums::AttemptStatus::Charged,
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/deutschebank/transformers.rs" role="context" start="937" end="958">
fn try_from(
item: &DeutschebankRouterData<&PaymentsCaptureRouterData>,
) -> Result<Self, Self::Error> {
if matches!(item.router_data.payment_method, PaymentMethod::BankDebit) {
Ok(Self {
changed_amount: item.amount,
kind: DeutschebankTransactionKind::Directdebit,
})
} else if item.router_data.is_three_ds()
&& matches!(item.router_data.payment_method, PaymentMethod::Card)
{
Ok(Self {
changed_amount: item.amount,
kind: DeutschebankTransactionKind::Creditcard3ds20,
})
} else {
Err(errors::ConnectorError::NotImplemented(
utils::get_unimplemented_payment_method_error_message("deutschebank"),
)
.into())
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/deutschebank/transformers.rs" role="context" start="717" end="813">
fn try_from(
item: &DeutschebankRouterData<&PaymentsCompleteAuthorizeRouterData>,
) -> Result<Self, Self::Error> {
if matches!(item.router_data.payment_method, PaymentMethod::Card) {
let redirect_response_payload = item
.router_data
.request
.get_redirect_response_payload()?
.expose();
let cres = redirect_response_payload
.get("cres")
.and_then(|v| v.as_str())
.map(String::from)
.ok_or(errors::ConnectorError::MissingRequiredField { field_name: "cres" })?;
Ok(Self::DeutschebankThreeDSCompleteAuthorizeRequest(
DeutschebankThreeDSCompleteAuthorizeRequest { cres },
))
} else {
match item.router_data.request.payment_method_data.clone() {
Some(PaymentMethodData::BankDebit(BankDebitData::SepaBankDebit {
iban, ..
})) => {
let account_holder = item.router_data.get_billing_address()?.get_full_name()?;
let redirect_response =
item.router_data.request.redirect_response.clone().ok_or(
errors::ConnectorError::MissingRequiredField {
field_name: "redirect_response",
},
)?;
let queries_params = redirect_response
.params
.map(|param| {
let mut queries = HashMap::<String, String>::new();
let values = param.peek().split('&').collect::<Vec<&str>>();
for value in values {
let pair = value.split('=').collect::<Vec<&str>>();
queries.insert(
pair.first()
.ok_or(
errors::ConnectorError::ResponseDeserializationFailed,
)?
.to_string(),
pair.get(1)
.ok_or(
errors::ConnectorError::ResponseDeserializationFailed,
)?
.to_string(),
);
}
Ok::<_, errors::ConnectorError>(queries)
})
.transpose()?
.ok_or(errors::ConnectorError::ResponseDeserializationFailed)?;
let reference = Secret::from(
queries_params
.get("reference")
.ok_or(errors::ConnectorError::MissingRequiredField {
field_name: "reference",
})?
.to_owned(),
);
let signed_on = queries_params
.get("signed_on")
.ok_or(errors::ConnectorError::MissingRequiredField {
field_name: "signed_on",
})?
.to_owned();
Ok(Self::DeutschebankDirectDebitRequest(
DeutschebankDirectDebitRequest {
amount_total: DeutschebankAmount {
amount: item.amount,
currency: item.router_data.request.currency,
},
means_of_payment: DeutschebankMeansOfPayment {
bank_account: DeutschebankBankAccount {
account_holder,
iban: Secret::from(iban.peek().replace(" ", "")),
},
},
mandate: {
DeutschebankMandate {
reference,
signed_on,
}
},
},
))
}
_ => Err(errors::ConnectorError::NotImplemented(
utils::get_unimplemented_payment_method_error_message("deutschebank"),
)
.into()),
}
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/deutschebank/transformers.rs" role="context" start="630" end="668">
fn try_from(
item: ResponseRouterData<
Authorize,
DeutschebankPaymentsResponse,
PaymentsAuthorizeData,
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/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="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="59" end="59">
type Error = error_stack::Report<errors::ConnectorError>;
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/deutschebank/transformers.rs" role="context" start="855" end="867">
pub struct DeutschebankPaymentsResponse {
rc: String,
message: String,
timestamp: String,
back_ext_id: Option<String>,
back_rc: Option<String>,
event_id: Option<String>,
kind: Option<String>,
tx_action: Option<DeutschebankTXAction>,
tx_id: String,
amount_total: Option<DeutschebankAmount>,
transaction_info: Option<DeutschebankTransactionInfo>,
}
<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/deutschebank/transformers.rs<|crate|> hyperswitch_connectors<|connector|> deutschebank 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/deutschebank/transformers.rs" role="context" start="630" end="668">
fn try_from(
item: ResponseRouterData<
Authorize,
DeutschebankPaymentsResponse,
PaymentsAuthorizeData,
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/deutschebank/transformers.rs" role="context" start="629" end="629">
use common_enums::{enums, PaymentMethod};
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,
},
};
use crate::{
types::{PaymentsCancelResponseRouterData, RefundsResponseRouterData, ResponseRouterData},
utils::{
self, AddressDetailsData, CardData, PaymentsAuthorizeRequestData,
PaymentsCompleteAuthorizeRequestData, RefundsRequestData, RouterData as OtherRouterData,
},
};
<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/deutschebank/transformers.rs" role="context" start="717" end="813">
fn try_from(
item: &DeutschebankRouterData<&PaymentsCompleteAuthorizeRouterData>,
) -> Result<Self, Self::Error> {
if matches!(item.router_data.payment_method, PaymentMethod::Card) {
let redirect_response_payload = item
.router_data
.request
.get_redirect_response_payload()?
.expose();
let cres = redirect_response_payload
.get("cres")
.and_then(|v| v.as_str())
.map(String::from)
.ok_or(errors::ConnectorError::MissingRequiredField { field_name: "cres" })?;
Ok(Self::DeutschebankThreeDSCompleteAuthorizeRequest(
DeutschebankThreeDSCompleteAuthorizeRequest { cres },
))
} else {
match item.router_data.request.payment_method_data.clone() {
Some(PaymentMethodData::BankDebit(BankDebitData::SepaBankDebit {
iban, ..
})) => {
let account_holder = item.router_data.get_billing_address()?.get_full_name()?;
let redirect_response =
item.router_data.request.redirect_response.clone().ok_or(
errors::ConnectorError::MissingRequiredField {
field_name: "redirect_response",
},
)?;
let queries_params = redirect_response
.params
.map(|param| {
let mut queries = HashMap::<String, String>::new();
let values = param.peek().split('&').collect::<Vec<&str>>();
for value in values {
let pair = value.split('=').collect::<Vec<&str>>();
queries.insert(
pair.first()
.ok_or(
errors::ConnectorError::ResponseDeserializationFailed,
)?
.to_string(),
pair.get(1)
.ok_or(
errors::ConnectorError::ResponseDeserializationFailed,
)?
.to_string(),
);
}
Ok::<_, errors::ConnectorError>(queries)
})
.transpose()?
.ok_or(errors::ConnectorError::ResponseDeserializationFailed)?;
let reference = Secret::from(
queries_params
.get("reference")
.ok_or(errors::ConnectorError::MissingRequiredField {
field_name: "reference",
})?
.to_owned(),
);
let signed_on = queries_params
.get("signed_on")
.ok_or(errors::ConnectorError::MissingRequiredField {
field_name: "signed_on",
})?
.to_owned();
Ok(Self::DeutschebankDirectDebitRequest(
DeutschebankDirectDebitRequest {
amount_total: DeutschebankAmount {
amount: item.amount,
currency: item.router_data.request.currency,
},
means_of_payment: DeutschebankMeansOfPayment {
bank_account: DeutschebankBankAccount {
account_holder,
iban: Secret::from(iban.peek().replace(" ", "")),
},
},
mandate: {
DeutschebankMandate {
reference,
signed_on,
}
},
},
))
}
_ => Err(errors::ConnectorError::NotImplemented(
utils::get_unimplemented_payment_method_error_message("deutschebank"),
)
.into()),
}
}
}
<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="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="59" end="59">
type Error = error_stack::Report<errors::ConnectorError>;
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/deutschebank/transformers.rs" role="context" start="855" end="867">
pub struct DeutschebankPaymentsResponse {
rc: String,
message: String,
timestamp: String,
back_ext_id: Option<String>,
back_rc: Option<String>,
event_id: Option<String>,
kind: Option<String>,
tx_action: Option<DeutschebankTXAction>,
tx_id: String,
amount_total: Option<DeutschebankAmount>,
transaction_info: Option<DeutschebankTransactionInfo>,
}
<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/paybox/transformers.rs<|crate|> hyperswitch_connectors<|connector|> paybox anchor=try_from 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="315" end="340">
fn try_from(item: &types::PaymentsSyncRouterData) -> Result<Self, Self::Error> {
let auth_data: PayboxAuthType = PayboxAuthType::try_from(&item.connector_auth_type)
.change_context(errors::ConnectorError::FailedToObtainAuthType)?;
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.request.connector_meta.clone())?;
Ok(Self {
date: format_time.clone(),
transaction_type: SYNC_REQUEST.to_string(),
paybox_request_number: get_paybox_request_number()?,
version: VERSION_PAYBOX.to_string(),
site: auth_data.site,
rank: auth_data.rang,
key: auth_data.cle,
transaction_number: paybox_meta_data.connector_request_id,
paybox_order_id: item
.request
.connector_transaction_id
.get_connector_transaction_id()
.change_context(errors::ConnectorError::MissingConnectorTransactionID)?,
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/paybox/transformers.rs" role="context" start="314" end="314">
use common_utils::{
date_time::DateFormat, errors::CustomResult, ext_traits::ValueExt, types::MinorUnit,
};
use hyperswitch_domain_models::{
payment_method_data::PaymentMethodData,
router_data::{ConnectorAuthType, ErrorResponse, RouterData},
router_flow_types::refunds::{Execute, RSync},
router_request_types::{CompleteAuthorizeData, PaymentsAuthorizeData, ResponseId},
router_response_types::{
MandateReference, PaymentsResponseData, RedirectForm, RefundsResponseData,
},
types,
};
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="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="258" end="281">
fn try_from(item: &types::RefundSyncRouterData) -> Result<Self, Self::Error> {
let auth_data: PayboxAuthType = PayboxAuthType::try_from(&item.connector_auth_type)
.change_context(errors::ConnectorError::FailedToObtainAuthType)?;
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: SYNC_REQUEST.to_string(),
paybox_request_number: get_paybox_request_number()?,
version: VERSION_PAYBOX.to_string(),
site: auth_data.site,
rank: auth_data.rang,
key: auth_data.cle,
transaction_number: item
.request
.connector_refund_id
.clone()
.ok_or(errors::ConnectorError::RequestEncodingFailed)?,
paybox_order_id: item.request.connector_transaction_id.clone(),
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/paybox/transformers.rs" role="context" start="195" end="223">
fn try_from(
item: &PayboxRouterData<&types::PaymentsCaptureRouterData>,
) -> 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 paybox_meta_data: PayboxMeta =
utils::to_connector_meta(item.router_data.request.connector_meta.clone())?;
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: CAPTURE_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,
reference: item.router_data.connector_request_reference_id.to_string(),
})
}
<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="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="60" end="60">
type Error = error_stack::Report<errors::ConnectorError>;
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/paybox/transformers.rs" role="context" start="549" end="554">
pub struct PayboxAuthType {
pub(super) site: Secret<String>,
pub(super) rang: Secret<String>,
pub(super) cle: Secret<String>,
pub(super) merchant_id: Secret<String>,
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/paybox/transformers.rs" role="context" start="344" end="346">
pub struct PayboxMeta {
pub connector_request_id: String,
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/hyperswitch_connectors/src/connectors/bankofamerica/transformers.rs<|crate|> hyperswitch_connectors<|connector|> bankofamerica anchor=convert_to_error_response_from_error_info 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="2625" end="2666">
fn convert_to_error_response_from_error_info(
error_response: &BankOfAmericaErrorInformationResponse,
status_code: u16,
) -> ErrorResponse {
let detailed_error_info =
error_response
.error_information
.to_owned()
.details
.map(|error_details| {
error_details
.iter()
.map(|details| format!("{} : {}", details.field, details.reason))
.collect::<Vec<_>>()
.join(", ")
});
let reason = get_error_reason(
error_response.error_information.message.to_owned(),
detailed_error_info,
None,
);
ErrorResponse {
code: error_response
.error_information
.reason
.clone()
.unwrap_or(hyperswitch_interfaces::consts::NO_ERROR_CODE.to_string()),
message: error_response
.error_information
.reason
.clone()
.unwrap_or(hyperswitch_interfaces::consts::NO_ERROR_MESSAGE.to_string()),
reason,
status_code,
attempt_status: None,
connector_transaction_id: Some(error_response.id.clone()),
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/bankofamerica/transformers.rs" role="context" start="2624" end="2624">
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,
},
};
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/bankofamerica/transformers.rs" role="context" start="2690" end="2702">
fn get_commerce_indicator(network: Option<String>) -> String {
match network {
Some(card_network) => match card_network.to_lowercase().as_str() {
"amex" => "aesk",
"discover" => "dipb",
"mastercard" => "spa",
"visa" => "internet",
_ => "internet",
},
None => "internet",
}
.to_string()
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/bankofamerica/transformers.rs" role="context" start="2668" end="2688">
fn get_boa_mandate_action_details() -> (
Option<Vec<BankOfAmericaActionsList>>,
Option<Vec<BankOfAmericaActionsTokenType>>,
Option<BankOfAmericaAuthorizationOptions>,
) {
(
Some(vec![BankOfAmericaActionsList::TokenCreate]),
Some(vec![
BankOfAmericaActionsTokenType::PaymentInstrument,
BankOfAmericaActionsTokenType::Customer,
]),
Some(BankOfAmericaAuthorizationOptions {
initiator: Some(BankOfAmericaPaymentInitiator {
initiator_type: Some(BankOfAmericaPaymentInitiatorTypes::Customer),
credential_stored_on_file: Some(true),
stored_credential_used: None,
}),
merchant_intitiated_transaction: None,
}),
)
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/bankofamerica/transformers.rs" role="context" start="2613" end="2622">
fn from(google_pay_data: &GooglePayWalletData) -> Self {
Self::GooglePay(Box::new(GooglePayPaymentInformation {
fluid_data: FluidData {
value: Secret::from(
consts::BASE64_ENGINE.encode(google_pay_data.tokenization_data.token.clone()),
),
descriptor: None,
},
}))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/bankofamerica/transformers.rs" role="context" start="2599" end="2609">
fn from(apple_pay_data: &ApplePayWalletData) -> Self {
Self::ApplePayToken(Box::new(ApplePayTokenPaymentInformation {
fluid_data: FluidData {
value: Secret::from(apple_pay_data.payment_data.clone()),
descriptor: None,
},
tokenized_card: ApplePayTokenizedCard {
transaction_type: TransactionType::ApplePay,
},
}))
}
<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="2704" end="2729">
pub fn get_error_reason(
error_info: Option<String>,
detailed_error_info: Option<String>,
avs_error_info: Option<String>,
) -> Option<String> {
match (error_info, detailed_error_info, avs_error_info) {
(Some(message), Some(details), Some(avs_message)) => Some(format!(
"{}, detailed_error_information: {}, avs_message: {}",
message, details, avs_message
)),
(Some(message), Some(details), None) => Some(format!(
"{}, detailed_error_information: {}",
message, details
)),
(Some(message), None, Some(avs_message)) => {
Some(format!("{}, avs_message: {}", message, avs_message))
}
(None, Some(details), Some(avs_message)) => {
Some(format!("{}, avs_message: {}", details, avs_message))
}
(Some(message), None, None) => Some(message),
(None, Some(details), None) => Some(details),
(None, None, Some(avs_message)) => Some(avs_message),
(None, None, None) => None,
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/bankofamerica/transformers.rs" role="context" start="1524" end="1527">
pub struct BankOfAmericaErrorInformationResponse {
id: String,
error_information: BankOfAmericaErrorInformation,
}
<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/prophetpay/transformers.rs<|crate|> hyperswitch_connectors<|connector|> prophetpay anchor=get_card_token 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="279" end="316">
fn get_card_token(
response: Option<CompleteAuthorizeRedirectResponse>,
) -> CustomResult<String, errors::ConnectorError> {
let res = response.ok_or(errors::ConnectorError::MissingRequiredField {
field_name: "redirect_response",
})?;
let queries_params = res
.params
.map(|param| {
let mut queries = HashMap::<String, String>::new();
let values = param.peek().split('&').collect::<Vec<&str>>();
for value in values {
let pair = value.split('=').collect::<Vec<&str>>();
queries.insert(
pair.first()
.ok_or(errors::ConnectorError::ResponseDeserializationFailed)?
.to_string(),
pair.get(1)
.ok_or(errors::ConnectorError::ResponseDeserializationFailed)?
.to_string(),
);
}
Ok::<_, errors::ConnectorError>(queries)
})
.transpose()?
.ok_or(errors::ConnectorError::ResponseDeserializationFailed)?;
for (key, val) in queries_params {
if key.as_str() == PROPHETPAY_TOKEN {
return Ok(val);
}
}
Err(errors::ConnectorError::MissingRequiredField {
field_name: "card_token",
}
.into())
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/prophetpay/transformers.rs" role="context" start="278" end="278">
use common_utils::{
consts::{PROPHETPAY_REDIRECT_URL, PROPHETPAY_TOKEN},
errors::CustomResult,
request::Method,
};
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,
};
<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="261" end="276">
fn try_from(
item: &ProphetpayRouterData<&types::PaymentsCompleteAuthorizeRouterData>,
) -> Result<Self, Self::Error> {
let auth_data = ProphetpayAuthType::try_from(&item.router_data.connector_auth_type)?;
let card_token = Secret::new(get_card_token(
item.router_data.request.redirect_response.clone(),
)?);
Ok(Self {
amount: item.amount.to_owned(),
ref_info: item.router_data.connector_request_reference_id.to_owned(),
inquiry_reference: item.router_data.connector_request_reference_id.clone(),
profile: auth_data.profile_id,
action_type: ProphetpayActionType::get_action_type(&ProphetpayActionType::Charge),
card_token,
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/prophetpay/transformers.rs" role="context" start="223" end="244">
fn get_redirect_url_form(
mut redirect_url: Url,
complete_auth_url: Option<String>,
) -> CustomResult<RedirectForm, errors::ConnectorError> {
let mut form_fields = HashMap::<String, String>::new();
form_fields.insert(
String::from("redirectUrl"),
complete_auth_url.ok_or(errors::ConnectorError::MissingRequiredField {
field_name: "complete_auth_url",
})?,
);
// Do not include query params in the endpoint
redirect_url.set_query(None);
Ok(RedirectForm::Form {
endpoint: redirect_url.to_string(),
method: Method::Get,
form_fields,
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/prophetpay/transformers.rs" role="context" start="390" end="435">
fn try_from(
item: ResponseRouterData<
F,
ProphetpayCompleteAuthResponse,
CompleteAuthorizeData,
PaymentsResponseData,
>,
) -> Result<Self, Self::Error> {
if item.response.success {
let card_token = get_card_token(item.data.request.redirect_response.clone())?;
let card_token_data = ProphetpayCardTokenData {
card_token: Secret::from(card_token),
};
let connector_metadata = serde_json::to_value(card_token_data).ok();
Ok(Self {
status: enums::AttemptStatus::Charged,
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(item.response.transaction_id),
redirection_data: Box::new(None),
mandate_reference: Box::new(None),
connector_metadata,
network_txn_id: None,
connector_response_reference_id: None,
incremental_authorization_allowed: None,
charges: None,
}),
..item.data
})
} else {
Ok(Self {
status: enums::AttemptStatus::Failure,
response: Err(ErrorResponse {
code: item.response.response_code,
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/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/nexinets/transformers.rs<|crate|> hyperswitch_connectors<|connector|> nexinets anchor=get_status kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/nexinets/transformers.rs" role="context" start="239" end="265">
fn get_status(status: NexinetsPaymentStatus, method: NexinetsTransactionType) -> AttemptStatus {
match status {
NexinetsPaymentStatus::Success => match method {
NexinetsTransactionType::Preauth => AttemptStatus::Authorized,
NexinetsTransactionType::Debit | NexinetsTransactionType::Capture => {
AttemptStatus::Charged
}
NexinetsTransactionType::Cancel => AttemptStatus::Voided,
},
NexinetsPaymentStatus::Declined
| NexinetsPaymentStatus::Failure
| NexinetsPaymentStatus::Expired
| NexinetsPaymentStatus::Aborted => match method {
NexinetsTransactionType::Preauth => AttemptStatus::AuthorizationFailed,
NexinetsTransactionType::Debit | NexinetsTransactionType::Capture => {
AttemptStatus::CaptureFailed
}
NexinetsTransactionType::Cancel => AttemptStatus::VoidFailed,
},
NexinetsPaymentStatus::Ok => match method {
NexinetsTransactionType::Preauth => AttemptStatus::Authorized,
_ => AttemptStatus::Pending,
},
NexinetsPaymentStatus::Pending => AttemptStatus::AuthenticationPending,
NexinetsPaymentStatus::InProgress => AttemptStatus::Pending,
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/nexinets/transformers.rs" role="context" start="238" end="238">
use common_enums::{enums, AttemptStatus};
use crate::{
types::{RefundsResponseRouterData, ResponseRouterData},
utils::{
self, CardData, PaymentsAuthorizeRequestData, PaymentsCancelRequestData, WalletData as _,
},
};
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/nexinets/transformers.rs" role="context" start="330" end="378">
fn try_from(
item: ResponseRouterData<F, NexinetsPreAuthOrDebitResponse, T, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
let transaction = match item.response.transactions.first() {
Some(order) => order,
_ => Err(errors::ConnectorError::ResponseHandlingFailed)?,
};
let connector_metadata = serde_json::to_value(NexinetsPaymentsMetadata {
transaction_id: Some(transaction.transaction_id.clone()),
order_id: Some(item.response.order_id.clone()),
psync_flow: item.response.transaction_type.clone(),
})
.change_context(errors::ConnectorError::ResponseHandlingFailed)?;
let redirection_data = item
.response
.redirect_url
.map(|url| RedirectForm::from((url, Method::Get)));
let resource_id = match item.response.transaction_type.clone() {
NexinetsTransactionType::Preauth => ResponseId::NoResponseId,
NexinetsTransactionType::Debit => {
ResponseId::ConnectorTransactionId(transaction.transaction_id.clone())
}
_ => Err(errors::ConnectorError::ResponseHandlingFailed)?,
};
let mandate_reference = item
.response
.payment_instrument
.payment_instrument_id
.map(|id| MandateReference {
connector_mandate_id: Some(id.expose()),
payment_method_id: None,
mandate_metadata: None,
connector_mandate_request_reference_id: None,
});
Ok(Self {
status: get_status(transaction.status.clone(), item.response.transaction_type),
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id,
redirection_data: Box::new(redirection_data),
mandate_reference: Box::new(mandate_reference),
connector_metadata: Some(connector_metadata),
network_txn_id: None,
connector_response_reference_id: Some(item.response.order_id),
incremental_authorization_allowed: None,
charges: None,
}),
..item.data
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/nexinets/transformers.rs" role="context" start="269" end="287">
fn try_from(bank: &enums::BankNames) -> Result<Self, Self::Error> {
match bank {
enums::BankNames::AbnAmro => Ok(Self::AbnAmro),
enums::BankNames::AsnBank => Ok(Self::AsnBank),
enums::BankNames::Bunq => Ok(Self::Bunq),
enums::BankNames::Ing => Ok(Self::Ing),
enums::BankNames::Knab => Ok(Self::Knab),
enums::BankNames::Rabobank => Ok(Self::Rabobank),
enums::BankNames::Regiobank => Ok(Self::Regiobank),
enums::BankNames::SnsBank => Ok(Self::SnsBank),
enums::BankNames::TriodosBank => Ok(Self::TriodosBank),
enums::BankNames::VanLanschot => Ok(Self::VanLanschot),
_ => Err(errors::ConnectorError::FlowNotSupported {
flow: bank.to_string(),
connector: "Nexinets".to_string(),
}
.into()),
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/nexinets/transformers.rs" role="context" start="212" end="223">
fn try_from(auth_type: &ConnectorAuthType) -> Result<Self, Self::Error> {
match auth_type {
ConnectorAuthType::BodyKey { api_key, key1 } => {
let auth_key = format!("{}:{}", key1.peek(), api_key.peek());
let auth_header = format!("Basic {}", consts::BASE64_ENGINE.encode(auth_key));
Ok(Self {
api_key: Secret::new(auth_header),
})
}
_ => Err(errors::ConnectorError::FailedToObtainAuthType)?,
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/nexinets/transformers.rs" role="context" start="180" end="202">
fn try_from(item: &PaymentsAuthorizeRouterData) -> Result<Self, Self::Error> {
let return_url = item.request.router_return_url.clone();
let nexinets_async = NexinetsAsyncDetails {
success_url: return_url.clone(),
cancel_url: return_url.clone(),
failure_url: return_url,
};
let (payment, product) = get_payment_details_and_product(item)?;
let merchant_order_id = match item.payment_method {
// Merchant order id is sent only in case of card payment
enums::PaymentMethod::Card => Some(item.connector_request_reference_id.clone()),
_ => None,
};
Ok(Self {
initial_amount: item.request.amount,
currency: item.request.currency,
channel: NexinetsChannel::Ecom,
product,
payment,
nexinets_async,
merchant_order_id,
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/nexinets/transformers.rs" role="context" start="428" end="458">
fn try_from(
item: ResponseRouterData<F, NexinetsPaymentResponse, T, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
let transaction_id = Some(item.response.transaction_id.clone());
let connector_metadata = serde_json::to_value(NexinetsPaymentsMetadata {
transaction_id,
order_id: Some(item.response.order.order_id.clone()),
psync_flow: item.response.transaction_type.clone(),
})
.change_context(errors::ConnectorError::ResponseHandlingFailed)?;
let resource_id = match item.response.transaction_type.clone() {
NexinetsTransactionType::Debit | NexinetsTransactionType::Capture => {
ResponseId::ConnectorTransactionId(item.response.transaction_id)
}
_ => ResponseId::NoResponseId,
};
Ok(Self {
status: get_status(item.response.status, item.response.transaction_type),
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id,
redirection_data: Box::new(None),
mandate_reference: Box::new(None),
connector_metadata: Some(connector_metadata),
network_txn_id: None,
connector_response_reference_id: Some(item.response.order.order_id),
incremental_authorization_allowed: None,
charges: None,
}),
..item.data
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/nexinets/transformers.rs" role="context" start="312" end="317">
pub enum NexinetsTransactionType {
Preauth,
Debit,
Capture,
Cancel,
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/nexinets/transformers.rs" role="context" start="228" end="237">
pub enum NexinetsPaymentStatus {
Success,
Pending,
Ok,
Failure,
Declined,
InProgress,
Expired,
Aborted,
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/novalnet/transformers.rs" role="context" start="791" end="795">
pub struct Capture {
#[serde(rename = "type")]
cap_type: CaptureType,
reference: String,
}
<file_sep path="hyperswitch/migrations/2023-07-07-091223_create_captures_table/up.sql" role="context" start="1" end="17">
CREATE TYPE "CaptureStatus" AS ENUM (
'started',
'charged',
'pending',
'failed'
);
ALTER TYPE "IntentStatus" ADD VALUE If NOT EXISTS 'partially_captured' AFTER 'requires_capture';
CREATE TABLE captures(
capture_id VARCHAR(64) NOT NULL PRIMARY KEY,
payment_id VARCHAR(64) NOT NULL,
merchant_id VARCHAR(64) NOT NULL,
status "CaptureStatus" NOT NULL,
amount BIGINT NOT NULL,
currency "Currency",
connector VARCHAR(255),
error_message VARCHAR(255),
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/hyperswitch_connectors/src/connectors/cybersource/transformers.rs<|crate|> hyperswitch_connectors<|connector|> cybersource anchor=try_from kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=1<|meta_end|>
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/cybersource/transformers.rs" role="context" start="2440" end="2476">
fn try_from(
item: &CybersourceRouterData<&PaymentsIncrementalAuthorizationRouterData>,
) -> Result<Self, Self::Error> {
let connector_merchant_config =
CybersourceConnectorMetadataObject::try_from(&item.router_data.connector_meta_data)?;
Ok(Self {
processing_information: ProcessingInformation {
action_list: None,
action_token_types: None,
authorization_options: Some(CybersourceAuthorizationOptions {
initiator: Some(CybersourcePaymentInitiator {
initiator_type: None,
credential_stored_on_file: None,
stored_credential_used: Some(true),
}),
merchant_intitiated_transaction: Some(MerchantInitiatedTransaction {
reason: Some("5".to_owned()),
previous_transaction_id: None,
original_authorized_amount: None,
}),
ignore_avs_result: connector_merchant_config.disable_avs,
ignore_cv_result: connector_merchant_config.disable_cvn,
}),
commerce_indicator: String::from("internet"),
capture: None,
capture_options: None,
payment_solution: None,
},
order_information: OrderInformationIncrementalAuthorization {
amount_details: AdditionalAmount {
additional_amount: item.amount.clone(),
currency: item.router_data.request.currency.to_string(),
},
},
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/cybersource/transformers.rs" role="context" start="2439" end="2439">
use hyperswitch_domain_models::{
network_tokenization::NetworkTokenNumber,
payment_method_data::{
ApplePayWalletData, GooglePayWalletData, NetworkTokenData, PaymentMethodData,
SamsungPayWalletData, WalletData,
},
router_data::{
AdditionalPaymentMethodConnectorResponse, ApplePayPredecryptData, ConnectorAuthType,
ConnectorResponseData, ErrorResponse, GooglePayDecryptedData, PaymentMethodToken,
RouterData,
},
router_flow_types::{
payments::Authorize,
refunds::{Execute, RSync},
SetupMandate,
},
router_request_types::{
CompleteAuthorizeData, PaymentsAuthorizeData, PaymentsCancelData, PaymentsCaptureData,
PaymentsPreProcessingData, PaymentsSyncData, ResponseId, SetupMandateRequestData,
},
router_response_types::{
MandateReference, PaymentsResponseData, RedirectForm, RefundsResponseData,
},
types::{
PaymentsAuthorizeRouterData, PaymentsCancelRouterData, PaymentsCaptureRouterData,
PaymentsCompleteAuthorizeRouterData, PaymentsIncrementalAuthorizationRouterData,
PaymentsPreProcessingRouterData, RefundsRouterData, SetupMandateRouterData,
},
};
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/cybersource/transformers.rs" role="context" start="2543" end="2558">
fn try_from(auth_type: &ConnectorAuthType) -> Result<Self, Self::Error> {
if let ConnectorAuthType::SignatureKey {
api_key,
key1,
api_secret,
} = auth_type
{
Ok(Self {
api_key: api_key.to_owned(),
merchant_account: key1.to_owned(),
api_secret: api_secret.to_owned(),
})
} else {
Err(errors::ConnectorError::FailedToObtainAuthType)?
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/cybersource/transformers.rs" role="context" start="2498" end="2532">
fn try_from(
value: &CybersourceRouterData<&PaymentsCancelRouterData>,
) -> Result<Self, Self::Error> {
let merchant_defined_information = value
.router_data
.request
.metadata
.clone()
.map(convert_metadata_to_merchant_defined_info);
Ok(Self {
client_reference_information: ClientReferenceInformation {
code: Some(value.router_data.connector_request_reference_id.clone()),
},
reversal_information: ReversalInformation {
amount_details: Amount {
total_amount: value.amount.to_owned(),
currency: value.router_data.request.currency.ok_or(
errors::ConnectorError::MissingRequiredField {
field_name: "Currency",
},
)?,
},
reason: value
.router_data
.request
.cancellation_reason
.clone()
.ok_or(errors::ConnectorError::MissingRequiredField {
field_name: "Cancellation Reason",
})?,
},
merchant_defined_information,
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/cybersource/transformers.rs" role="context" start="2391" end="2433">
fn try_from(
item: &CybersourceRouterData<&PaymentsCaptureRouterData>,
) -> Result<Self, Self::Error> {
let merchant_defined_information = item
.router_data
.request
.metadata
.clone()
.map(convert_metadata_to_merchant_defined_info);
let is_final = matches!(
item.router_data.request.capture_method,
Some(enums::CaptureMethod::Manual)
)
.then_some(true);
Ok(Self {
processing_information: ProcessingInformation {
capture_options: Some(CaptureOptions {
capture_sequence_number: 1,
total_capture_count: 1,
is_final,
}),
action_list: None,
action_token_types: None,
authorization_options: None,
capture: None,
commerce_indicator: String::from("internet"),
payment_solution: None,
},
order_information: OrderInformationWithBill {
amount_details: Amount {
total_amount: item.amount.clone(),
currency: item.router_data.request.currency,
},
bill_to: None,
},
client_reference_information: ClientReferenceInformation {
code: Some(item.router_data.connector_request_reference_id.clone()),
},
merchant_defined_information,
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/cybersource/transformers.rs" role="context" start="2300" end="2367">
fn try_from(
item: &CybersourceRouterData<&PaymentsAuthorizeRouterData>,
) -> Result<Self, Self::Error> {
match item.router_data.request.payment_method_data.clone() {
PaymentMethodData::Card(ccard) => {
let card_type = match ccard
.card_network
.clone()
.and_then(get_cybersource_card_type)
{
Some(card_network) => Some(card_network.to_string()),
None => ccard.get_card_issuer().ok().map(String::from),
};
let is_cobadged_card = ccard
.card_number
.clone()
.is_cobadged_card()
.change_context(errors::ConnectorError::RequestEncodingFailed)
.attach_printable("error while checking is_cobadged_card")?;
let type_selection_indicator = if is_cobadged_card {
Some("1".to_owned())
} else {
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,
type_selection_indicator,
},
}));
let client_reference_information = ClientReferenceInformation::from(item);
Ok(Self {
payment_information,
client_reference_information,
})
}
PaymentMethodData::Wallet(_)
| 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("Cybersource"),
)
.into())
}
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/cybersource/transformers.rs" role="context" start="4091" end="4105">
fn try_from(
item: PayoutsResponseRouterData<F, CybersourceFulfillResponse>,
) -> Result<Self, Self::Error> {
Ok(Self {
response: Ok(PayoutsResponseData {
status: Some(map_payout_status(item.response.status)),
connector_payout_id: Some(item.response.id),
payout_eligible: None,
should_add_next_step_to_process_tracker: false,
error_code: None,
error_message: None,
}),
..item.data
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/cybersource/transformers.rs" role="context" start="3742" end="3752">
fn from(item: CybersourceRefundStatus) -> Self {
match item {
CybersourceRefundStatus::Succeeded | CybersourceRefundStatus::Transmitted => {
Self::Success
}
CybersourceRefundStatus::Cancelled
| CybersourceRefundStatus::Failed
| CybersourceRefundStatus::Voided => Self::Failure,
CybersourceRefundStatus::Pending => Self::Pending,
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/cybersource/transformers.rs" role="context" start="109" end="109">
type Error = error_stack::Report<errors::ConnectorError>;
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/cybersource/transformers.rs" role="context" start="608" end="611">
pub struct AdditionalAmount {
additional_amount: StringMajorUnit,
currency: String,
}
<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/redsys/transformers.rs<|crate|> hyperswitch_connectors<|connector|> redsys anchor=handle_threeds_invoke_exempt kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/redsys/transformers.rs" role="context" start="739" end="773">
fn handle_threeds_invoke_exempt<F>(
item: ResponseRouterData<F, RedsysResponse, PaymentsPreProcessingData, PaymentsResponseData>,
response_data: &RedsysPaymentsResponse,
three_d_s_server_trans_i_d: String,
protocol_version: String,
) -> Result<
RouterData<F, PaymentsPreProcessingData, PaymentsResponseData>,
error_stack::Report<errors::ConnectorError>,
> {
let three_ds_data = ThreeDsInvokeExempt {
message_version: protocol_version.clone(),
three_d_s_server_trans_i_d,
};
let connector_metadata = Some(
serde_json::to_value(&three_ds_data)
.change_context(errors::ConnectorError::RequestEncodingFailed)
.attach_printable("Failed to serialize ThreeDsData")?,
);
Ok(RouterData {
status: enums::AttemptStatus::AuthenticationPending,
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(response_data.ds_order.clone()),
redirection_data: Box::new(None),
mandate_reference: Box::new(None),
connector_metadata,
network_txn_id: None,
connector_response_reference_id: Some(response_data.ds_order.clone()),
incremental_authorization_allowed: None,
charges: None,
}),
..item.data
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/redsys/transformers.rs" role="context" start="738" end="738">
use common_enums::enums;
use error_stack::ResultExt;
use hyperswitch_domain_models::{
address::Address,
payment_method_data::PaymentMethodData,
router_data::{ConnectorAuthType, ErrorResponse, RouterData},
router_flow_types::refunds::{Execute, RSync},
router_request_types::{
BrowserInformation, CompleteAuthorizeData, PaymentsAuthorizeData, PaymentsCancelData,
PaymentsCaptureData, PaymentsPreProcessingData, PaymentsSyncData, ResponseId,
},
router_response_types::{PaymentsResponseData, RedirectForm, RefundsResponseData},
types::{
PaymentsAuthorizeRouterData, PaymentsCancelRouterData, PaymentsCaptureRouterData,
PaymentsCompleteAuthorizeRouterData, PaymentsPreProcessingRouterData,
PaymentsSyncRouterData, RefundSyncRouterData, RefundsRouterData,
},
};
use crate::{
types::{RefundsResponseRouterData, ResponseRouterData},
utils::{
self as connector_utils, AddressDetailsData, BrowserInformationData, CardData,
PaymentsAuthorizeRequestData, PaymentsCompleteAuthorizeRequestData,
PaymentsPreProcessingRequestData, RouterData as _,
},
};
type Error = error_stack::Report<errors::ConnectorError>;
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/redsys/transformers.rs" role="context" start="803" end="817">
fn get_signature(
order_id: &str,
params: &str,
key: &str,
) -> Result<String, error_stack::Report<errors::ConnectorError>> {
let secret_ko = des_encrypt(order_id, key)?;
let result = common_utils::crypto::HmacSha256::sign_message(
&common_utils::crypto::HmacSha256,
&secret_ko,
params.as_bytes(),
)
.map_err(|_| errors::ConnectorError::RequestEncodingFailed)?;
let encoded = BASE64_ENGINE.encode(result);
Ok(encoded)
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/redsys/transformers.rs" role="context" start="775" end="801">
fn des_encrypt(
message: &str,
key: &str,
) -> Result<Vec<u8>, error_stack::Report<errors::ConnectorError>> {
// Connector decrypts the signature using an initialization vector (IV) set to all zeros
let iv_array = [0u8; common_utils::crypto::TripleDesEde3CBC::TRIPLE_DES_IV_LENGTH];
let iv = iv_array.to_vec();
let key_bytes = BASE64_ENGINE
.decode(key)
.change_context(errors::ConnectorError::RequestEncodingFailed)
.attach_printable("Base64 decoding failed")?;
let triple_des =
common_utils::crypto::TripleDesEde3CBC::new(Some(enums::CryptoPadding::ZeroPadding), iv)
.change_context(errors::ConnectorError::RequestEncodingFailed)
.attach_printable("Triple DES encryption failed")?;
let encrypted = triple_des
.encode_message(&key_bytes, message.as_bytes())
.change_context(errors::ConnectorError::RequestEncodingFailed)
.attach_printable("Triple DES encryption failed")?;
let expected_len =
encrypted.len() - common_utils::crypto::TripleDesEde3CBC::TRIPLE_DES_IV_LENGTH;
let encrypted_trimmed = encrypted
.get(..expected_len)
.ok_or(errors::ConnectorError::RequestEncodingFailed)
.attach_printable("Failed to trim encrypted data to the expected length")?;
Ok(encrypted_trimmed.to_vec())
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/redsys/transformers.rs" role="context" start="686" end="737">
fn handle_threeds_invoke<F>(
item: ResponseRouterData<F, RedsysResponse, PaymentsPreProcessingData, PaymentsResponseData>,
response_data: &RedsysPaymentsResponse,
three_d_s_method_u_r_l: String,
three_d_s_server_trans_i_d: String,
protocol_version: String,
) -> Result<
RouterData<F, PaymentsPreProcessingData, PaymentsResponseData>,
error_stack::Report<errors::ConnectorError>,
> {
let three_d_s_method_notification_u_r_l = item.data.request.get_webhook_url()?;
let threeds_invoke_data = ThreedsInvokeRequest {
three_d_s_server_trans_i_d: three_d_s_method_u_r_l.clone(),
three_d_s_method_notification_u_r_l,
};
let three_ds_data_string = threeds_invoke_data
.encode_to_string_of_json()
.change_context(errors::ConnectorError::RequestEncodingFailed)?;
let three_ds_method_data = BASE64_ENGINE.encode(&three_ds_data_string);
let three_ds_data = RedsysThreeDsInvokeData {
three_ds_method_url: three_d_s_method_u_r_l,
three_ds_method_data,
message_version: protocol_version.clone(),
directory_server_id: three_d_s_server_trans_i_d,
three_ds_method_data_submission: true,
};
let connector_metadata = Some(
serde_json::to_value(&three_ds_data)
.change_context(errors::ConnectorError::RequestEncodingFailed)
.attach_printable("Failed to serialize ThreeDsData")?,
);
Ok(RouterData {
status: enums::AttemptStatus::AuthenticationPending,
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(response_data.ds_order.clone()),
redirection_data: Box::new(None),
mandate_reference: Box::new(None),
connector_metadata,
network_txn_id: None,
connector_response_reference_id: Some(response_data.ds_order.clone()),
incremental_authorization_allowed: None,
charges: None,
}),
..item.data
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/redsys/transformers.rs" role="context" start="638" end="684">
fn handle_redsys_preprocessing_response<F>(
item: ResponseRouterData<F, RedsysResponse, PaymentsPreProcessingData, PaymentsResponseData>,
response_data: &RedsysPaymentsResponse,
) -> Result<
RouterData<F, PaymentsPreProcessingData, PaymentsResponseData>,
error_stack::Report<errors::ConnectorError>,
> {
match (
response_data
.ds_emv3ds
.as_ref()
.and_then(|emv3ds_data| emv3ds_data.three_d_s_method_u_r_l.clone()),
response_data
.ds_emv3ds
.as_ref()
.and_then(|emv3ds_data| emv3ds_data.three_d_s_server_trans_i_d.clone()),
response_data
.ds_emv3ds
.as_ref()
.map(|emv3ds_data| emv3ds_data.protocol_version.clone()),
) {
(
Some(three_d_s_method_u_r_l),
Some(three_d_s_server_trans_i_d),
Some(protocol_version),
) => handle_threeds_invoke(
item,
response_data,
three_d_s_method_u_r_l,
three_d_s_server_trans_i_d,
protocol_version,
),
(None, Some(three_d_s_server_trans_i_d), Some(protocol_version)) => {
handle_threeds_invoke_exempt(
item,
response_data,
three_d_s_server_trans_i_d,
protocol_version,
)
}
_ => Err(errors::ConnectorError::NotSupported {
message: "3DS payment with a non-3DS card".to_owned(),
connector: "redsys",
}
.into()),
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/redsys/transformers.rs" role="context" start="135" end="156">
pub fn new(three_d_s_info: RedsysThreeDsInfo) -> Self {
Self {
three_d_s_info,
protocol_version: None,
browser_accept_header: None,
browser_user_agent: None,
browser_java_enabled: None,
browser_java_script_enabled: None,
browser_language: None,
browser_color_depth: None,
browser_screen_height: None,
browser_screen_width: None,
browser_t_z: None,
browser_i_p: None,
three_d_s_server_trans_i_d: None,
notification_u_r_l: None,
three_d_s_comp_ind: None,
cres: None,
billing_data: None,
shipping_data: None,
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/redsys/transformers.rs" role="context" start="565" end="568">
pub struct ThreeDsInvokeExempt {
pub three_d_s_server_trans_i_d: String,
pub message_version: String,
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/redsys/transformers.rs" role="context" start="521" end="532">
pub struct RedsysPaymentsResponse {
#[serde(rename = "Ds_Order")]
ds_order: String,
#[serde(rename = "Ds_EMV3DS")]
ds_emv3ds: Option<RedsysEmv3DSData>,
#[serde(rename = "Ds_Card_PSD2")]
ds_card_psd2: Option<CardPSD2>,
#[serde(rename = "Ds_Response")]
ds_response: Option<DsResponse>,
#[serde(rename = "Ds_AuthorisationCode")]
ds_authorisation_code: Option<String>,
}
<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/trustpay/transformers.rs<|crate|> hyperswitch_connectors<|connector|> trustpay anchor=handle_bank_redirects_refund_sync_response kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/trustpay/transformers.rs" role="context" start="1679" end="1716">
fn handle_bank_redirects_refund_sync_response(
response: SyncResponseBankRedirect,
status_code: u16,
) -> (Option<ErrorResponse>, RefundsResponseData) {
let refund_status = enums::RefundStatus::from(response.payment_information.status);
let error = if utils::is_refund_failure(refund_status) {
let reason_info = response
.payment_information
.status_reason_information
.unwrap_or_default();
Some(ErrorResponse {
code: reason_info
.reason
.code
.clone()
.unwrap_or(consts::NO_ERROR_CODE.to_string()),
// message vary for the same code, so relying on code alone as it is unique
message: reason_info
.reason
.code
.unwrap_or(consts::NO_ERROR_MESSAGE.to_string()),
reason: reason_info.reason.reject_reason,
status_code,
attempt_status: None,
connector_transaction_id: None,
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
})
} else {
None
};
let refund_response_data = RefundsResponseData {
connector_refund_id: response.payment_information.references.payment_request_id,
refund_status,
};
(error, refund_response_data)
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/trustpay/transformers.rs" role="context" start="1678" end="1678">
use common_enums::enums;
use hyperswitch_domain_models::{
payment_method_data::{BankRedirectData, BankTransferData, Card, PaymentMethodData},
router_data::{AccessToken, ConnectorAuthType, ErrorResponse, RouterData},
router_request_types::{BrowserInformation, PaymentsPreProcessingData, ResponseId},
router_response_types::{
PaymentsResponseData, PreprocessingResponseId, RedirectForm, RefundsResponseData,
},
types::{
PaymentsAuthorizeRouterData, PaymentsPreProcessingRouterData, RefreshTokenRouterData,
RefundsRouterData,
},
};
use crate::{
types::{RefundsResponseRouterData, ResponseRouterData},
utils::{
self, AddressDetailsData, BrowserInformationData, CardData, PaymentsAuthorizeRequestData,
PaymentsPreProcessingRequestData, RouterData as OtherRouterData,
},
};
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/trustpay/transformers.rs" role="context" start="1744" end="1766">
fn try_from(item: RefundsResponseRouterData<F, RefundResponse>) -> Result<Self, Self::Error> {
let (error, response) = match item.response {
RefundResponse::CardsRefund(response) => {
handle_cards_refund_response(*response, item.http_code)?
}
RefundResponse::WebhookRefund(response) => {
handle_webhooks_refund_response(*response, item.http_code)?
}
RefundResponse::BankRedirectRefund(response) => {
handle_bank_redirects_refund_response(*response, item.http_code)
}
RefundResponse::BankRedirectRefundSyncResponse(response) => {
handle_bank_redirects_refund_sync_response(*response, item.http_code)
}
RefundResponse::BankRedirectError(response) => {
handle_bank_redirects_refund_sync_error_response(*response, item.http_code)
}
};
Ok(Self {
response: error.map_or_else(|| Ok(response), Err),
..item.data
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/trustpay/transformers.rs" role="context" start="1718" end="1740">
fn handle_bank_redirects_refund_sync_error_response(
response: ErrorResponseBankRedirect,
status_code: u16,
) -> (Option<ErrorResponse>, RefundsResponseData) {
let error = Some(ErrorResponse {
code: response.payment_result_info.result_code.to_string(),
// message vary for the same code, so relying on code alone as it is unique
message: response.payment_result_info.result_code.to_string(),
reason: response.payment_result_info.additional_info,
status_code,
attempt_status: None,
connector_transaction_id: None,
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
});
//unreachable case as we are sending error as Some()
let refund_response_data = RefundsResponseData {
connector_refund_id: "".to_string(),
refund_status: enums::RefundStatus::Failure,
};
(error, refund_response_data)
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/trustpay/transformers.rs" role="context" start="1651" end="1677">
fn handle_bank_redirects_refund_response(
response: BankRedirectRefundResponse,
status_code: u16,
) -> (Option<ErrorResponse>, RefundsResponseData) {
let (refund_status, msg) = get_refund_status_from_result_info(response.result_info.result_code);
let error = if msg.is_some() {
Some(ErrorResponse {
code: response.result_info.result_code.to_string(),
// message vary for the same code, so relying on code alone as it is unique
message: response.result_info.result_code.to_string(),
reason: msg.map(|message| message.to_string()),
status_code,
attempt_status: None,
connector_transaction_id: None,
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
})
} else {
None
};
let refund_response_data = RefundsResponseData {
connector_refund_id: response.payment_request_id.to_string(),
refund_status,
};
(error, refund_response_data)
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/trustpay/transformers.rs" role="context" start="1612" end="1649">
fn handle_webhooks_refund_response(
response: WebhookPaymentInformation,
status_code: u16,
) -> CustomResult<(Option<ErrorResponse>, RefundsResponseData), errors::ConnectorError> {
let refund_status = enums::RefundStatus::try_from(response.status)?;
let error = if utils::is_refund_failure(refund_status) {
let reason_info = response.status_reason_information.unwrap_or_default();
Some(ErrorResponse {
code: reason_info
.reason
.code
.clone()
.unwrap_or(consts::NO_ERROR_CODE.to_string()),
// message vary for the same code, so relying on code alone as it is unique
message: reason_info
.reason
.code
.unwrap_or(consts::NO_ERROR_MESSAGE.to_string()),
reason: reason_info.reason.reject_reason,
status_code,
attempt_status: None,
connector_transaction_id: response.references.payment_request_id.clone(),
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
})
} else {
None
};
let refund_response_data = RefundsResponseData {
connector_refund_id: response
.references
.payment_request_id
.ok_or(errors::ConnectorError::MissingConnectorRefundID)?,
refund_status,
};
Ok((error, refund_response_data))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/trustpay/transformers.rs" role="context" start="1929" end="1934">
fn from(error: Errors) -> Self {
Self {
error_code: error.code.to_string(),
error_message: error.description,
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/trustpay/transformers.rs" role="context" start="762" end="764">
pub struct SyncResponseBankRedirect {
pub payment_information: BankPaymentInformationResponse,
}
<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/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/nexixpay/transformers.rs<|crate|> hyperswitch_connectors<|connector|> nexixpay 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/nexixpay/transformers.rs" role="context" start="1236" end="1279">
fn try_from(
item: ResponseRouterData<
F,
NexixpayTransactionResponse,
PaymentsSyncData,
PaymentsResponseData,
>,
) -> Result<Self, Self::Error> {
let status = AttemptStatus::from(item.response.operation_result.clone());
match status {
AttemptStatus::Failure => {
let response = Err(get_error_response(
item.response.operation_result.clone(),
item.http_code,
));
Ok(Self {
response,
..item.data
})
}
_ => Ok(Self {
status,
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(item.response.order_id.clone()),
redirection_data: Box::new(None),
mandate_reference: Box::new(Some(MandateReference {
connector_mandate_id: item
.data
.connector_mandate_request_reference_id
.clone(),
payment_method_id: None,
mandate_metadata: None,
connector_mandate_request_reference_id: None,
})),
connector_metadata: item.data.request.connector_meta.clone(),
network_txn_id: None,
connector_response_reference_id: Some(item.response.order_id.clone()),
incremental_authorization_allowed: None,
charges: None,
}),
..item.data
}),
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/nexixpay/transformers.rs" role="context" start="1235" end="1235">
use common_enums::{enums, AttemptStatus, CaptureMethod, Currency, RefundStatus};
use common_utils::{
errors::CustomResult, ext_traits::ValueExt, request::Method, types::StringMinorUnit,
};
use hyperswitch_domain_models::{
payment_method_data::PaymentMethodData,
router_data::{ConnectorAuthType, ErrorResponse, RouterData},
router_flow_types::{
refunds::{Execute, RSync},
SetupMandate,
},
router_request_types::{
CompleteAuthorizeData, PaymentsAuthorizeData, PaymentsCancelData, PaymentsCaptureData,
PaymentsPreProcessingData, PaymentsSyncData, ResponseId, SetupMandateRequestData,
},
router_response_types::{
MandateReference, PaymentsResponseData, RedirectForm, RefundsResponseData,
},
types::{
PaymentsAuthorizeRouterData, PaymentsCancelRouterData, PaymentsCaptureRouterData,
PaymentsCompleteAuthorizeRouterData, PaymentsPreProcessingRouterData, RefundsRouterData,
},
};
use crate::{
types::{RefundsResponseRouterData, ResponseRouterData},
utils::{
get_unimplemented_payment_method_error_message, to_connector_meta,
to_connector_meta_from_secret, CardData, PaymentsAuthorizeRequestData,
PaymentsCompleteAuthorizeRequestData, PaymentsPreProcessingRequestData,
PaymentsSetupMandateRequestData, RouterData as _,
},
};
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/nexixpay/transformers.rs" role="context" start="1300" end="1337">
fn try_from(
item: ResponseRouterData<
F,
NexixpayOperationResponse,
PaymentsCaptureData,
PaymentsResponseData,
>,
) -> Result<Self, Self::Error> {
let meta_data = to_connector_meta(item.data.request.connector_meta.clone())?;
let connector_metadata = Some(update_nexi_meta_data(UpdateNexixpayConnectorMetaData {
three_d_s_auth_result: None,
three_d_s_auth_response: None,
authorization_operation_id: None,
capture_operation_id: Some(item.response.operation_id.clone()),
cancel_operation_id: None,
psync_flow: Some(NexixpayPaymentIntent::Capture),
meta_data,
is_auto_capture: false,
})?);
Ok(Self {
status: AttemptStatus::Pending, // Capture call do not return status in their response.
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(
item.data.request.connector_transaction_id.clone(),
),
redirection_data: Box::new(None),
mandate_reference: Box::new(None),
connector_metadata,
network_txn_id: None,
connector_response_reference_id: Some(
item.data.request.connector_transaction_id.clone(),
),
incremental_authorization_allowed: None,
charges: None,
}),
..item.data
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/nexixpay/transformers.rs" role="context" start="1284" end="1291">
fn try_from(
item: &NexixpayRouterData<&PaymentsCaptureRouterData>,
) -> Result<Self, Self::Error> {
Ok(Self {
amount: item.amount.clone(),
currency: item.router_data.request.currency,
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/nexixpay/transformers.rs" role="context" start="1081" end="1227">
fn try_from(
item: &NexixpayRouterData<&PaymentsCompleteAuthorizeRouterData>,
) -> Result<Self, Self::Error> {
let payment_method_data: PaymentMethodData =
item.router_data.request.payment_method_data.clone().ok_or(
errors::ConnectorError::MissingRequiredField {
field_name: "payment_method_data",
},
)?;
let capture_type = get_nexixpay_capture_type(item.router_data.request.capture_method)?;
let order_id = item.router_data.connector_request_reference_id.clone();
let amount = item.amount.clone();
let billing_address_street = match (
item.router_data.get_optional_billing_line1(),
item.router_data.get_optional_billing_line2(),
) {
(Some(line1), Some(line2)) => Some(Secret::new(format!(
"{}, {}",
line1.expose(),
line2.expose()
))),
(Some(line1), None) => Some(line1),
(None, Some(line2)) => Some(line2),
(None, None) => None,
};
let billing_address = item
.router_data
.get_optional_billing()
.map(|_| BillingAddress {
name: item.router_data.get_optional_billing_full_name(),
street: billing_address_street,
city: item.router_data.get_optional_billing_city(),
post_code: item.router_data.get_optional_billing_zip(),
country: item.router_data.get_optional_billing_country(),
});
let shipping_address_street = match (
item.router_data.get_optional_shipping_line1(),
item.router_data.get_optional_shipping_line2(),
) {
(Some(line1), Some(line2)) => Some(Secret::new(format!(
"{}, {}",
line1.expose(),
line2.expose()
))),
(Some(line1), None) => Some(Secret::new(line1.expose())),
(None, Some(line2)) => Some(Secret::new(line2.expose())),
(None, None) => None,
};
let shipping_address = item
.router_data
.get_optional_shipping()
.map(|_| ShippingAddress {
name: item.router_data.get_optional_shipping_full_name(),
street: shipping_address_street,
city: item.router_data.get_optional_shipping_city(),
post_code: item.router_data.get_optional_shipping_zip(),
country: item.router_data.get_optional_shipping_country(),
});
let customer_info = CustomerInfo {
card_holder_name: item.router_data.get_billing_full_name()?,
billing_address: billing_address.clone(),
shipping_address: shipping_address.clone(),
};
let order_data = Order {
order_id,
amount,
currency: item.router_data.request.currency,
description: item.router_data.description.clone(),
customer_info,
};
let connector_metadata =
to_connector_meta(item.router_data.request.connector_meta.clone())?;
let nexixpay_meta_data =
serde_json::from_value::<NexixpayConnectorMetaData>(connector_metadata)
.change_context(errors::ConnectorError::ParsingFailed)?;
let operation_id = nexixpay_meta_data.authorization_operation_id.ok_or(
errors::ConnectorError::MissingRequiredField {
field_name: "authorization_operation_id",
},
)?;
let authentication_value = nexixpay_meta_data
.three_d_s_auth_result
.and_then(|data| data.authentication_value);
let three_d_s_auth_data = ThreeDSAuthData {
three_d_s_auth_response: nexixpay_meta_data.three_d_s_auth_response,
authentication_value,
};
let card: Result<NexixpayCard, error_stack::Report<errors::ConnectorError>> =
match payment_method_data {
PaymentMethodData::Card(req_card) => Ok(NexixpayCard {
pan: req_card.card_number.clone(),
expiry_date: req_card.get_expiry_date_as_mmyy()?,
}),
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::CardDetailsForNetworkTransactionId(_) => {
Err(errors::ConnectorError::NotImplemented(
get_unimplemented_payment_method_error_message("nexixpay"),
)
.into())
}
};
let recurrence_request_obj = if item.router_data.request.is_mandate_payment() {
let contract_id = Secret::new(
item.router_data
.connector_mandate_request_reference_id
.clone()
.ok_or_else(|| errors::ConnectorError::MissingRequiredField {
field_name: "connector_mandate_request_reference_id",
})?,
);
Some(RecurrenceRequest {
action: NexixpayRecurringAction::ContractCreation,
contract_id,
contract_type: ContractType::MitUnscheduled,
})
} else {
None
};
Ok(Self {
order: order_data,
card: card?,
operation_id,
capture_type,
three_d_s_auth_data,
recurrence: recurrence_request_obj,
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/nexixpay/transformers.rs" role="context" start="1011" end="1074">
fn try_from(
item: ResponseRouterData<
F,
NexixpayCompleteAuthorizeResponse,
CompleteAuthorizeData,
PaymentsResponseData,
>,
) -> Result<Self, Self::Error> {
let is_auto_capture = item.data.request.is_auto_capture()?;
let meta_data = to_connector_meta(item.data.request.connector_meta.clone())?;
let connector_metadata = Some(update_nexi_meta_data(UpdateNexixpayConnectorMetaData {
three_d_s_auth_result: None,
three_d_s_auth_response: None,
authorization_operation_id: Some(item.response.operation.operation_id.clone()),
capture_operation_id: None,
cancel_operation_id: None,
psync_flow: Some(NexixpayPaymentIntent::Authorize),
meta_data,
is_auto_capture,
})?);
let status = if item.data.request.amount == 0
&& item.response.operation.operation_result == NexixpayPaymentStatus::Authorized
{
AttemptStatus::Charged
} else {
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(Some(MandateReference {
connector_mandate_id: item
.data
.connector_mandate_request_reference_id
.clone(),
payment_method_id: None,
mandate_metadata: None,
connector_mandate_request_reference_id: 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="309" end="324">
pub fn get_error_response(
operation_result: NexixpayPaymentStatus,
status_code: u16,
) -> ErrorResponse {
ErrorResponse {
status_code,
code: NO_ERROR_CODE.to_string(),
message: operation_result.to_string(),
reason: Some(operation_result.to_string()),
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/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="375" end="375">
type Error = error_stack::Report<errors::ConnectorError>;
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/nexixpay/transformers.rs" role="context" start="713" end="718">
pub struct NexixpayTransactionResponse {
order_id: String,
operation_id: String,
operation_result: NexixpayPaymentStatus,
operation_type: NexixpayOperationType,
}
<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/paystack/transformers.rs<|crate|> hyperswitch_connectors<|connector|> paystack 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/paystack/transformers.rs" role="context" start="329" end="365">
fn try_from(
item: RefundsResponseRouterData<Execute, PaystackRefundsResponse>,
) -> Result<Self, Self::Error> {
match item.response {
PaystackRefundsResponse::PaystackRefundsData(resp) => Ok(Self {
response: Ok(RefundsResponseData {
connector_refund_id: resp.data.id.to_string(),
refund_status: enums::RefundStatus::from(resp.data.status),
}),
..item.data
}),
PaystackRefundsResponse::PaystackRSyncWebhook(resp) => Ok(Self {
response: Ok(RefundsResponseData {
connector_refund_id: resp.id,
refund_status: enums::RefundStatus::from(resp.status),
}),
..item.data
}),
PaystackRefundsResponse::PaystackRefundsError(err) => {
let err_msg = get_error_message(err.clone());
Ok(Self {
response: Err(ErrorResponse {
code: err.code,
message: err_msg.clone(),
reason: Some(err_msg.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,
}),
..item.data
})
}
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/paystack/transformers.rs" role="context" start="328" end="328">
use common_enums::{enums, Currency};
use hyperswitch_domain_models::{
payment_method_data::{BankRedirectData, PaymentMethodData},
router_data::{ConnectorAuthType, ErrorResponse, RouterData},
router_flow_types::refunds::{Execute, RSync},
router_request_types::ResponseId,
router_response_types::{PaymentsResponseData, RedirectForm, RefundsResponseData},
types::{PaymentsAuthorizeRouterData, RefundsRouterData},
};
use crate::{
types::{RefundsResponseRouterData, ResponseRouterData},
utils::PaymentsAuthorizeRequestData,
};
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/paystack/transformers.rs" role="context" start="420" end="427">
pub fn get_error_message(response: PaystackErrorResponse) -> String {
if let Some(serde_json::Value::Object(err_map)) = response.data {
err_map.get("message").map(|msg| msg.clone().to_string())
} else {
None
}
.unwrap_or(response.message)
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/paystack/transformers.rs" role="context" start="372" end="408">
fn try_from(
item: RefundsResponseRouterData<RSync, PaystackRefundsResponse>,
) -> Result<Self, Self::Error> {
match item.response {
PaystackRefundsResponse::PaystackRefundsData(resp) => Ok(Self {
response: Ok(RefundsResponseData {
connector_refund_id: resp.data.id.to_string(),
refund_status: enums::RefundStatus::from(resp.data.status),
}),
..item.data
}),
PaystackRefundsResponse::PaystackRSyncWebhook(resp) => Ok(Self {
response: Ok(RefundsResponseData {
connector_refund_id: resp.id,
refund_status: enums::RefundStatus::from(resp.status),
}),
..item.data
}),
PaystackRefundsResponse::PaystackRefundsError(err) => {
let err_msg = get_error_message(err.clone());
Ok(Self {
response: Err(ErrorResponse {
code: err.code,
message: err_msg.clone(),
reason: Some(err_msg.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,
}),
..item.data
})
}
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/paystack/transformers.rs" role="context" start="295" end="301">
fn from(item: PaystackRefundStatus) -> Self {
match item {
PaystackRefundStatus::Processed => Self::Success,
PaystackRefundStatus::Failed => Self::Failure,
PaystackRefundStatus::Processing | PaystackRefundStatus::Pending => Self::Pending,
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/paystack/transformers.rs" role="context" start="276" end="281">
fn try_from(item: &PaystackRouterData<&RefundsRouterData<F>>) -> Result<Self, Self::Error> {
Ok(Self {
transaction: item.router_data.request.connector_transaction_id.clone(),
amount: item.amount.to_owned(),
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/paystack/transformers.rs" role="context" start="456" end="476">
fn from(item: PaystackWebhookEventData) -> Self {
match item {
PaystackWebhookEventData::Payment(payment_data) => match payment_data.status {
PaystackPSyncStatus::Success => Self::PaymentIntentSuccess,
PaystackPSyncStatus::Failed => Self::PaymentIntentFailure,
PaystackPSyncStatus::Abandoned
| PaystackPSyncStatus::Ongoing
| PaystackPSyncStatus::Pending
| PaystackPSyncStatus::Processing
| PaystackPSyncStatus::Queued => Self::PaymentIntentProcessing,
PaystackPSyncStatus::Reversed => Self::EventNotSupported,
},
PaystackWebhookEventData::Refund(refund_data) => match refund_data.status {
PaystackRefundStatus::Processed => Self::RefundSuccess,
PaystackRefundStatus::Failed => Self::RefundFailure,
PaystackRefundStatus::Processing | PaystackRefundStatus::Pending => {
Self::EventNotSupported
}
},
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/paystack/transformers.rs" role="context" start="51" end="51">
type Error = error_stack::Report<errors::ConnectorError>;
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/paystack/transformers.rs" role="context" start="319" end="323">
pub enum PaystackRefundsResponse {
PaystackRefundsData(PaystackRefundsResponseData),
PaystackRSyncWebhook(PaystackRefundWebhookData),
PaystackRefundsError(PaystackErrorResponse),
}
<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/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/braintree/transformers.rs<|crate|> hyperswitch_connectors<|connector|> braintree 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/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="996" end="996">
use common_enums::enums;
use hyperswitch_domain_models::{
payment_method_data::PaymentMethodData,
router_data::{ConnectorAuthType, PaymentMethodToken, RouterData},
router_flow_types::refunds::{Execute, RSync},
router_request_types::{
CompleteAuthorizeData, MandateRevokeRequestData, PaymentsAuthorizeData, ResponseId,
},
router_response_types::{
MandateReference, MandateRevokeResponseData, PaymentsResponseData, RedirectForm,
RefundsResponseData,
},
types::{self, RefundsRouterData},
};
use crate::{
types::{PaymentsCaptureResponseRouterData, RefundsResponseRouterData, ResponseRouterData},
unimplemented_payment_method,
utils::{
self, PaymentsAuthorizeRequestData, PaymentsCompleteAuthorizeRequestData,
RefundsRequestData, RouterData as _,
},
};
<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="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="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="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="531" end="556">
fn build_error_response<T>(
response: &[ErrorDetails],
http_code: u16,
) -> Result<T, Box<hyperswitch_domain_models::router_data::ErrorResponse>> {
let error_messages = response
.iter()
.map(|error| error.message.to_string())
.collect::<Vec<String>>();
let reason = match !error_messages.is_empty() {
true => Some(error_messages.join(" ")),
false => None,
};
get_error_response(
response
.first()
.and_then(|err_details| err_details.extensions.as_ref())
.and_then(|extensions| extensions.legacy_code.clone()),
response
.first()
.map(|err_details| err_details.message.clone()),
reason,
http_code,
)
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/braintree/transformers.rs" role="context" start="116" end="116">
type Error = error_stack::Report<errors::ConnectorError>;
<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/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/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/payme/transformers.rs<|crate|> hyperswitch_connectors<|connector|> payme 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/payme/transformers.rs" role="context" start="359" end="391">
fn try_from(
item: &PaymeRouterData<&PaymentsPreProcessingRouterData>,
) -> Result<Self, Self::Error> {
let sale_type = SaleType::try_from(item.router_data)?;
let seller_payme_id =
PaymeAuthType::try_from(&item.router_data.connector_auth_type)?.seller_payme_id;
let order_details = item.router_data.request.get_order_details()?;
let services = get_services(item.router_data);
let product_name = order_details
.first()
.ok_or_else(utils::missing_field_err("order_details"))?
.product_name
.clone();
let pmd = item
.router_data
.request
.payment_method_data
.to_owned()
.ok_or_else(utils::missing_field_err("payment_method_data"))?;
Ok(Self {
seller_payme_id,
sale_price: item.amount.to_owned(),
currency: item.router_data.request.get_currency()?,
product_name,
sale_payment_method: SalePaymentMethod::try_from(&pmd)?,
sale_type,
transaction_id: item.router_data.payment_id.clone(),
sale_return_url: item.router_data.request.get_router_return_url()?,
sale_callback_url: item.router_data.request.get_webhook_url()?,
language: LANGUAGE.to_string(),
services,
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/payme/transformers.rs" role="context" start="358" end="358">
use hyperswitch_domain_models::{
payment_method_data::{PaymentMethodData, WalletData},
router_data::{ConnectorAuthType, ErrorResponse, PaymentMethodToken, RouterData},
router_flow_types::{Execute, Void},
router_request_types::{PaymentsCancelData, PaymentsPreProcessingData, ResponseId},
router_response_types::{
MandateReference, PaymentsResponseData, PreprocessingResponseId, RedirectForm,
RefundsResponseData,
},
types::{
PaymentsAuthorizeRouterData, PaymentsCancelRouterData, PaymentsCaptureRouterData,
PaymentsCompleteAuthorizeRouterData, PaymentsPreProcessingRouterData,
PaymentsSyncRouterData, RefundSyncRouterData, RefundsRouterData, TokenizationRouterData,
},
};
use crate::{
types::{PaymentsCancelResponseRouterData, RefundsResponseRouterData, ResponseRouterData},
unimplemented_payment_method,
utils::{
self, AddressDetailsData, CardData, PaymentsAuthorizeRequestData,
PaymentsCancelRequestData, PaymentsCompleteAuthorizeRequestData,
PaymentsPreProcessingRequestData, PaymentsSyncRequestData, RouterData as OtherRouterData,
},
};
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/payme/transformers.rs" role="context" start="459" end="468">
fn try_from(
value: &PaymeRouterData<&PaymentsAuthorizeRouterData>,
) -> Result<Self, Self::Error> {
let payme_request = if value.router_data.request.mandate_id.is_some() {
Self::MandateRequest(MandateRequest::try_from(value)?)
} else {
Self::PayRequest(PayRequest::try_from(value.router_data)?)
};
Ok(payme_request)
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/payme/transformers.rs" role="context" start="396" end="454">
fn try_from(item: &PaymentMethodData) -> Result<Self, Self::Error> {
match item {
PaymentMethodData::Card(_) => Ok(Self::CreditCard),
PaymentMethodData::Wallet(wallet_data) => match wallet_data {
WalletData::ApplePayThirdPartySdk(_) => Ok(Self::ApplePay),
WalletData::AliPayQr(_)
| WalletData::AliPayRedirect(_)
| WalletData::AliPayHkRedirect(_)
| WalletData::AmazonPayRedirect(_)
| WalletData::MomoRedirect(_)
| WalletData::KakaoPayRedirect(_)
| WalletData::GoPayRedirect(_)
| WalletData::GcashRedirect(_)
| WalletData::ApplePayRedirect(_)
| WalletData::DanaRedirect {}
| WalletData::GooglePay(_)
| 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::ApplePay(_)
| WalletData::SwishQr(_)
| WalletData::Mifinity(_) => Err(errors::ConnectorError::NotSupported {
message: "Wallet".to_string(),
connector: "payme",
}
.into()),
},
PaymentMethodData::PayLater(_)
| PaymentMethodData::BankRedirect(_)
| PaymentMethodData::BankDebit(_)
| PaymentMethodData::BankTransfer(_)
| PaymentMethodData::Crypto(_)
| PaymentMethodData::MandatePayment
| PaymentMethodData::Reward
| PaymentMethodData::RealTimePayment(_)
| PaymentMethodData::MobilePayment(_)
| PaymentMethodData::GiftCard(_)
| PaymentMethodData::CardRedirect(_)
| PaymentMethodData::Upi(_)
| PaymentMethodData::Voucher(_)
| PaymentMethodData::OpenBanking(_)
| PaymentMethodData::CardToken(_)
| PaymentMethodData::NetworkToken(_)
| PaymentMethodData::CardDetailsForNetworkTransactionId(_) => {
Err(errors::ConnectorError::NotImplemented("Payment methods".to_string()).into())
}
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/payme/transformers.rs" role="context" start="327" end="339">
fn from(value: &SaleQuery) -> Self {
Self::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(value.sale_payme_id.clone()),
redirection_data: Box::new(None),
// mandate reference will be updated with webhooks only. That has been handled with PaymePaySaleResponse struct
mandate_reference: Box::new(None),
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: None,
incremental_authorization_allowed: None,
charges: None,
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/payme/transformers.rs" role="context" start="304" end="324">
fn get_sale_query_error_response(
(sale_query_response, http_code): (&SaleQuery, u16),
) -> ErrorResponse {
ErrorResponse {
code: sale_query_response
.sale_error_code
.clone()
.unwrap_or(consts::NO_ERROR_CODE.to_string()),
message: sale_query_response
.sale_error_text
.clone()
.unwrap_or(consts::NO_ERROR_MESSAGE.to_string()),
reason: sale_query_response.sale_error_text.clone(),
status_code: http_code,
attempt_status: None,
connector_transaction_id: Some(sale_query_response.sale_payme_id.clone()),
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/payme/transformers.rs" role="context" start="1156" end="1187">
fn try_from(
item: ResponseRouterData<F, PaymeQueryTransactionResponse, T, RefundsResponseData>,
) -> Result<Self, Self::Error> {
let pay_sale_response = item
.response
.items
.first()
.ok_or(errors::ConnectorError::ResponseHandlingFailed)?;
let refund_status = enums::RefundStatus::try_from(pay_sale_response.sale_status.clone())?;
let response = if utils::is_refund_failure(refund_status) {
Err(ErrorResponse {
code: consts::NO_ERROR_CODE.to_string(),
message: consts::NO_ERROR_CODE.to_string(),
reason: None,
status_code: item.http_code,
attempt_status: None,
connector_transaction_id: Some(pay_sale_response.payme_transaction_id.clone()),
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
})
} else {
Ok(RefundsResponseData {
refund_status,
connector_refund_id: pay_sale_response.payme_transaction_id.clone(),
})
};
Ok(Self {
response,
..item.data
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/payme/transformers.rs" role="context" start="1190" end="1201">
fn get_services(item: &PaymentsPreProcessingRouterData) -> Option<ThreeDs> {
match item.auth_type {
AuthenticationType::ThreeDs => {
let settings = ThreeDsSettings { active: true };
Some(ThreeDs {
name: ThreeDsType::ThreeDs,
settings,
})
}
AuthenticationType::NoThreeDs => None,
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/payme/transformers.rs" role="context" start="49" end="49">
type Error = error_stack::Report<errors::ConnectorError>;
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/payme/transformers.rs" role="context" start="819" end="824">
pub struct PaymeAuthType {
#[allow(dead_code)]
pub(super) payme_public_key: Secret<String>,
pub(super) seller_payme_id: Secret<String>,
pub(super) payme_merchant_id: Option<Secret<String>>,
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/payme/transformers.rs" role="context" start="344" end="348">
pub enum SaleType {
Sale,
Authorize,
Token,
}
<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/nomupay.rs<|crate|> hyperswitch_connectors<|connector|> nomupay anchor=build_headers kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/nomupay.rs" role="context" start="186" end="218">
fn build_headers(
&self,
req: &RouterData<Flow, Request, Response>,
connectors: &Connectors,
) -> CustomResult<Vec<(String, masking::Maskable<String>)>, errors::ConnectorError> {
let is_post_req = matches!(self.get_http_method(), Method::Post);
let body = self.get_request_body(req, connectors)?;
let auth = nomupay::NomupayAuthType::try_from(&req.connector_auth_type)
.change_context(errors::ConnectorError::FailedToObtainAuthType)?;
let base_url = connectors.nomupay.base_url.as_str();
let path: String = self
.get_url(req, connectors)?
.chars()
.skip(base_url.len())
.collect();
let req_method = if is_post_req { "POST" } else { "GET" };
let sign = get_signature(&req.connector_meta_data, auth, body, req_method, path)?;
let mut header = vec![(
headers::CONTENT_TYPE.to_string(),
self.get_content_type().to_string().into(),
)];
header.push((
headers::X_SIGNATURE.to_string(),
masking::Maskable::Normal(sign),
));
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/nomupay.rs" role="context" start="185" end="185">
use common_utils::{
errors::CustomResult,
ext_traits::BytesExt,
pii,
request::{Method, RequestContent},
};
use common_utils::{
request::{Request, RequestBuilder},
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},
};
use hyperswitch_interfaces::{
api::{
self, ConnectorCommon, ConnectorCommonExt, ConnectorIntegration, ConnectorRedirectResponse,
ConnectorSpecifications, ConnectorValidation,
},
configs::Connectors,
consts::{NO_ERROR_CODE, NO_ERROR_MESSAGE},
errors,
events::connector_api_logs::ConnectorEvent,
types::Response,
webhooks,
};
use masking::{ExposeInterface, Mask};
use transformers as nomupay;
use crate::{types::ResponseRouterData, utils::RouterData as RouterDataTrait};
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/nomupay.rs" role="context" start="233" end="235">
fn id(&self) -> &'static str {
"nomupay"
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/nomupay.rs" role="context" start="223" end="229">
fn try_from(meta_data: Option<&pii::SecretSerdeValue>) -> Result<Self, Self::Error> {
let metadata: Self = utils::to_connector_meta_from_secret::<Self>(meta_data.cloned())
.change_context(errors::ConnectorError::InvalidConnectorConfig {
config: "metadata",
})?;
Ok(metadata)
}
<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()),
}
}
<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/shift4/transformers.rs" role="context" start="167" end="169">
pub struct Flow {
pub return_url: String,
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/hyperswitch_connectors/src/connectors/redsys/transformers.rs<|crate|> hyperswitch_connectors<|connector|> redsys 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/redsys/transformers.rs" role="context" start="973" end="1015">
fn try_from(
item: ResponseRouterData<F, RedsysResponse, PaymentsAuthorizeData, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
let (response, status) = match item.response.clone() {
RedsysResponse::RedsysResponse(transaction_response) => {
let connector_metadata = match item.data.response {
Ok(PaymentsResponseData::TransactionResponse {
connector_metadata, ..
}) => connector_metadata,
_ => None,
};
let response_data: RedsysPaymentsResponse = to_connector_response_data(
&transaction_response.ds_merchant_parameters.clone().expose(),
)?;
get_payments_response(
response_data,
item.data.request.capture_method,
connector_metadata,
item.http_code,
)?
}
RedsysResponse::RedsysErrorResponse(response) => {
let response = Err(ErrorResponse {
code: response.error_code.clone(),
message: response.error_code.clone(),
reason: Some(response.error_code.clone()),
status_code: item.http_code,
attempt_status: None,
connector_transaction_id: None,
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
});
(response, enums::AttemptStatus::Failure)
}
};
Ok(Self {
status,
response,
..item.data
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/redsys/transformers.rs" role="context" start="972" end="972">
use common_enums::enums;
use hyperswitch_domain_models::{
address::Address,
payment_method_data::PaymentMethodData,
router_data::{ConnectorAuthType, ErrorResponse, RouterData},
router_flow_types::refunds::{Execute, RSync},
router_request_types::{
BrowserInformation, CompleteAuthorizeData, PaymentsAuthorizeData, PaymentsCancelData,
PaymentsCaptureData, PaymentsPreProcessingData, PaymentsSyncData, ResponseId,
},
router_response_types::{PaymentsResponseData, RedirectForm, RefundsResponseData},
types::{
PaymentsAuthorizeRouterData, PaymentsCancelRouterData, PaymentsCaptureRouterData,
PaymentsCompleteAuthorizeRouterData, PaymentsPreProcessingRouterData,
PaymentsSyncRouterData, RefundSyncRouterData, RefundsRouterData,
},
};
use crate::{
types::{RefundsResponseRouterData, ResponseRouterData},
utils::{
self as connector_utils, AddressDetailsData, BrowserInformationData, CardData,
PaymentsAuthorizeRequestData, PaymentsCompleteAuthorizeRequestData,
PaymentsPreProcessingRequestData, RouterData as _,
},
};
type Error = error_stack::Report<errors::ConnectorError>;
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/redsys/transformers.rs" role="context" start="1138" end="1175">
fn try_from(
item: ResponseRouterData<F, RedsysResponse, CompleteAuthorizeData, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
let (response, status) = match item.response.clone() {
RedsysResponse::RedsysResponse(transaction_response) => {
let response_data: RedsysPaymentsResponse = to_connector_response_data(
&transaction_response.ds_merchant_parameters.clone().expose(),
)?;
get_payments_response(
response_data,
item.data.request.capture_method,
None,
item.http_code,
)?
}
RedsysResponse::RedsysErrorResponse(response) => {
let response = Err(ErrorResponse {
code: response.error_code.clone(),
message: response.error_code.clone(),
reason: Some(response.error_code.clone()),
status_code: item.http_code,
attempt_status: None,
connector_transaction_id: None,
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
});
(response, enums::AttemptStatus::Failure)
}
};
Ok(Self {
status,
response,
..item.data
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/redsys/transformers.rs" role="context" start="1024" end="1131">
fn try_from(
item: &RedsysRouterData<&PaymentsCompleteAuthorizeRouterData>,
) -> Result<Self, Self::Error> {
if !item.router_data.is_three_ds() {
Err(errors::ConnectorError::NotSupported {
message: "PaymentsComplete flow for no-3ds cards".to_string(),
connector: "redsys",
})?
};
let card_data =
RedsysCardData::try_from(&item.router_data.request.payment_method_data.clone())?;
let auth = RedsysAuthType::try_from(&item.router_data.connector_auth_type)?;
let redirect_response = item
.router_data
.request
.get_redirect_response_payload()
.ok()
.clone()
.map(|payload_data| {
payload_data
.parse_value::<ThreedsChallengeResponse>("Redsys ThreedsChallengeResponse")
.change_context(errors::ConnectorError::ResponseDeserializationFailed)
})
.transpose()?;
let billing_data = item.router_data.get_optional_billing();
let shipping_data = item.router_data.get_optional_shipping();
let emv3ds_data = match redirect_response {
Some(payload) => {
if let Ok(threeds_invoke_meta_data) =
connector_utils::to_connector_meta::<RedsysThreeDsInvokeData>(
item.router_data.request.connector_meta.clone(),
)
{
EmvThreedsData::new(RedsysThreeDsInfo::ChallengeResponse)
.set_protocol_version(threeds_invoke_meta_data.message_version)
.set_three_d_s_cres(payload.cres)
.set_billing_data(billing_data)?
.set_shipping_data(shipping_data)?
} else if let Ok(threeds_meta_data) =
connector_utils::to_connector_meta::<ThreeDsInvokeExempt>(
item.router_data.request.connector_meta.clone(),
)
{
EmvThreedsData::new(RedsysThreeDsInfo::ChallengeResponse)
.set_protocol_version(threeds_meta_data.message_version)
.set_three_d_s_cres(payload.cres)
.set_billing_data(billing_data)?
.set_shipping_data(shipping_data)?
} else {
Err(errors::ConnectorError::RequestEncodingFailed)?
}
}
None => {
if let Ok(threeds_invoke_meta_data) =
connector_utils::to_connector_meta::<RedsysThreeDsInvokeData>(
item.router_data.request.connector_meta.clone(),
)
{
let three_d_s_comp_ind = ThreeDSCompInd::from(
item.router_data.request.get_threeds_method_comp_ind()?,
);
let browser_info = item.router_data.request.get_browser_info()?;
let complete_authorize_url =
item.router_data.request.get_complete_authorize_url()?;
EmvThreedsData::new(RedsysThreeDsInfo::AuthenticationData)
.set_three_d_s_server_trans_i_d(
threeds_invoke_meta_data.directory_server_id,
)
.set_protocol_version(threeds_invoke_meta_data.message_version)
.set_three_d_s_comp_ind(three_d_s_comp_ind)
.add_browser_data(browser_info)?
.set_notification_u_r_l(complete_authorize_url)
.set_billing_data(billing_data)?
.set_shipping_data(shipping_data)?
} else {
Err(errors::ConnectorError::NoConnectorMetaData)?
}
}
};
let ds_merchant_transactiontype = if item.router_data.request.is_auto_capture()? {
RedsysTransactionType::Payment
} else {
RedsysTransactionType::Preauthorization
};
let ds_merchant_order = item
.router_data
.request
.connector_transaction_id
.clone()
.ok_or(errors::ConnectorError::RequestEncodingFailed)
.attach_printable("Missing connector_transaction_id")?;
let complete_authorize_response = PaymentsRequest {
ds_merchant_emv3ds: Some(emv3ds_data),
ds_merchant_transactiontype,
ds_merchant_currency: item.currency.iso_4217().to_owned(),
ds_merchant_pan: card_data.card_number,
ds_merchant_merchantcode: auth.merchant_id.clone(),
ds_merchant_terminal: auth.terminal_id.clone(),
ds_merchant_order,
ds_merchant_amount: item.amount.clone(),
ds_merchant_expirydate: card_data.expiry_date,
ds_merchant_cvv2: card_data.cvv2,
};
Self::try_from((&complete_authorize_response, &auth))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/redsys/transformers.rs" role="context" start="948" end="967">
fn build_threeds_form(ds_emv3ds: &RedsysEmv3DSData) -> Result<RedirectForm, Error> {
let creq = ds_emv3ds
.creq
.clone()
.ok_or(errors::ConnectorError::ResponseDeserializationFailed)?;
let endpoint = ds_emv3ds
.acs_u_r_l
.clone()
.ok_or(errors::ConnectorError::ResponseDeserializationFailed)?;
let mut form_fields = std::collections::HashMap::new();
form_fields.insert("creq".to_string(), creq);
Ok(RedirectForm::Form {
endpoint,
method: common_utils::request::Method::Post,
form_fields,
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/redsys/transformers.rs" role="context" start="896" end="945">
fn try_from(
item: &RedsysRouterData<&PaymentsAuthorizeRouterData>,
) -> Result<Self, Self::Error> {
if !item.router_data.is_three_ds() {
Err(errors::ConnectorError::NotSupported {
message: "No-3DS cards".to_string(),
connector: "redsys",
})?
};
let auth = RedsysAuthType::try_from(&item.router_data.connector_auth_type)?;
let ds_merchant_transactiontype = if item.router_data.request.is_auto_capture()? {
RedsysTransactionType::Payment
} else {
RedsysTransactionType::Preauthorization
};
let card_data =
RedsysCardData::try_from(&Some(item.router_data.request.payment_method_data.clone()))?;
let (connector_meta_data, ds_merchant_order) = match &item.router_data.response {
Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(order_id),
connector_metadata,
..
}) => (connector_metadata.clone(), order_id.clone()),
_ => Err(errors::ConnectorError::ResponseHandlingFailed)?,
};
let threeds_meta_data =
connector_utils::to_connector_meta::<ThreeDsInvokeExempt>(connector_meta_data.clone())?;
let emv3ds_data = EmvThreedsData::new(RedsysThreeDsInfo::AuthenticationData)
.set_three_d_s_server_trans_i_d(threeds_meta_data.three_d_s_server_trans_i_d)
.set_protocol_version(threeds_meta_data.message_version)
.set_notification_u_r_l(item.router_data.request.get_complete_authorize_url()?)
.add_browser_data(item.router_data.request.get_browser_info()?)?
.set_three_d_s_comp_ind(ThreeDSCompInd::N)
.set_billing_data(item.router_data.get_optional_billing())?
.set_shipping_data(item.router_data.get_optional_shipping())?;
let payment_authorize_request = PaymentsRequest {
ds_merchant_emv3ds: Some(emv3ds_data),
ds_merchant_transactiontype,
ds_merchant_currency: item.currency.iso_4217().to_owned(),
ds_merchant_pan: card_data.card_number,
ds_merchant_merchantcode: auth.merchant_id.clone(),
ds_merchant_terminal: auth.terminal_id.clone(),
ds_merchant_order,
ds_merchant_amount: item.amount.clone(),
ds_merchant_expirydate: card_data.expiry_date,
ds_merchant_cvv2: card_data.cvv2,
};
Self::try_from((&payment_authorize_request, &auth))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/redsys/transformers.rs" role="context" start="1468" end="1530">
fn get_payments_response(
redsys_payments_response: RedsysPaymentsResponse,
capture_method: Option<enums::CaptureMethod>,
connector_metadata: Option<josekit::Value>,
http_code: u16,
) -> Result<
(
Result<PaymentsResponseData, ErrorResponse>,
enums::AttemptStatus,
),
Error,
> {
if let Some(ds_response) = redsys_payments_response.ds_response {
let status = get_redsys_attempt_status(ds_response.clone(), capture_method)?;
let response = if connector_utils::is_payment_failure(status) {
Err(ErrorResponse {
code: ds_response.0.clone(),
message: ds_response.0.clone(),
reason: Some(ds_response.0.clone()),
status_code: http_code,
attempt_status: None,
connector_transaction_id: Some(redsys_payments_response.ds_order.clone()),
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
})
} else {
Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(
redsys_payments_response.ds_order.clone(),
),
redirection_data: Box::new(None),
mandate_reference: Box::new(None),
connector_metadata,
network_txn_id: None,
connector_response_reference_id: Some(redsys_payments_response.ds_order.clone()),
incremental_authorization_allowed: None,
charges: None,
})
};
Ok((response, status))
} else {
let redirection_form = redsys_payments_response
.ds_emv3ds
.map(|ds_emv3ds| build_threeds_form(&ds_emv3ds))
.transpose()?;
let response = Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(
redsys_payments_response.ds_order.clone(),
),
redirection_data: Box::new(redirection_form),
mandate_reference: Box::new(None),
connector_metadata,
network_txn_id: None,
connector_response_reference_id: Some(redsys_payments_response.ds_order.clone()),
incremental_authorization_allowed: None,
charges: None,
});
Ok((response, enums::AttemptStatus::AuthenticationPending))
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/redsys/transformers.rs" role="context" start="580" end="593">
fn to_connector_response_data<T>(connector_response: &str) -> Result<T, Error>
where
T: serde::de::DeserializeOwned,
{
let decoded_bytes = BASE64_ENGINE
.decode(connector_response)
.change_context(errors::ConnectorError::ResponseDeserializationFailed)
.attach_printable("Failed to decode Base64")?;
let response_data: T = serde_json::from_slice(&decoded_bytes)
.change_context(errors::ConnectorError::ResponseHandlingFailed)?;
Ok(response_data)
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/redsys/transformers.rs" role="context" start="38" end="38">
type Error = error_stack::Report<errors::ConnectorError>;
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/redsys/transformers.rs" role="context" start="521" end="532">
pub struct RedsysPaymentsResponse {
#[serde(rename = "Ds_Order")]
ds_order: String,
#[serde(rename = "Ds_EMV3DS")]
ds_emv3ds: Option<RedsysEmv3DSData>,
#[serde(rename = "Ds_Card_PSD2")]
ds_card_psd2: Option<CardPSD2>,
#[serde(rename = "Ds_Response")]
ds_response: Option<DsResponse>,
#[serde(rename = "Ds_AuthorisationCode")]
ds_authorisation_code: Option<String>,
}
<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/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/paybox/transformers.rs<|crate|> hyperswitch_connectors<|connector|> paybox anchor=try_from 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="195" end="223">
fn try_from(
item: &PayboxRouterData<&types::PaymentsCaptureRouterData>,
) -> 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 paybox_meta_data: PayboxMeta =
utils::to_connector_meta(item.router_data.request.connector_meta.clone())?;
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: CAPTURE_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,
reference: item.router_data.connector_request_reference_id.to_string(),
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/paybox/transformers.rs" role="context" start="194" end="194">
use common_enums::enums;
use common_utils::{
date_time::DateFormat, errors::CustomResult, ext_traits::ValueExt, types::MinorUnit,
};
use hyperswitch_domain_models::{
payment_method_data::PaymentMethodData,
router_data::{ConnectorAuthType, ErrorResponse, RouterData},
router_flow_types::refunds::{Execute, RSync},
router_request_types::{CompleteAuthorizeData, PaymentsAuthorizeData, ResponseId},
router_response_types::{
MandateReference, PaymentsResponseData, RedirectForm, RefundsResponseData,
},
types,
};
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="315" end="340">
fn try_from(item: &types::PaymentsSyncRouterData) -> Result<Self, Self::Error> {
let auth_data: PayboxAuthType = PayboxAuthType::try_from(&item.connector_auth_type)
.change_context(errors::ConnectorError::FailedToObtainAuthType)?;
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.request.connector_meta.clone())?;
Ok(Self {
date: format_time.clone(),
transaction_type: SYNC_REQUEST.to_string(),
paybox_request_number: get_paybox_request_number()?,
version: VERSION_PAYBOX.to_string(),
site: auth_data.site,
rank: auth_data.rang,
key: auth_data.cle,
transaction_number: paybox_meta_data.connector_request_id,
paybox_order_id: item
.request
.connector_transaction_id
.get_connector_transaction_id()
.change_context(errors::ConnectorError::MissingConnectorTransactionID)?,
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/paybox/transformers.rs" role="context" start="258" end="281">
fn try_from(item: &types::RefundSyncRouterData) -> Result<Self, Self::Error> {
let auth_data: PayboxAuthType = PayboxAuthType::try_from(&item.connector_auth_type)
.change_context(errors::ConnectorError::FailedToObtainAuthType)?;
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: SYNC_REQUEST.to_string(),
paybox_request_number: get_paybox_request_number()?,
version: VERSION_PAYBOX.to_string(),
site: auth_data.site,
rank: auth_data.rang,
key: auth_data.cle,
transaction_number: item
.request
.connector_refund_id
.clone()
.ok_or(errors::ConnectorError::RequestEncodingFailed)?,
paybox_order_id: item.request.connector_transaction_id.clone(),
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/paybox/transformers.rs" role="context" start="38" end="43">
fn from((amount, item): (MinorUnit, T)) -> Self {
Self {
amount,
router_data: item,
}
}
<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="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="60" end="60">
type Error = error_stack::Report<errors::ConnectorError>;
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/paybox/transformers.rs" role="context" start="549" end="554">
pub struct PayboxAuthType {
pub(super) site: Secret<String>,
pub(super) rang: Secret<String>,
pub(super) cle: Secret<String>,
pub(super) merchant_id: Secret<String>,
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/paybox/transformers.rs" role="context" start="344" end="346">
pub struct PayboxMeta {
pub connector_request_id: String,
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/hyperswitch_connectors/src/connectors/trustpay/transformers.rs<|crate|> hyperswitch_connectors<|connector|> trustpay anchor=handle_webhooks_refund_response kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/trustpay/transformers.rs" role="context" start="1612" end="1649">
fn handle_webhooks_refund_response(
response: WebhookPaymentInformation,
status_code: u16,
) -> CustomResult<(Option<ErrorResponse>, RefundsResponseData), errors::ConnectorError> {
let refund_status = enums::RefundStatus::try_from(response.status)?;
let error = if utils::is_refund_failure(refund_status) {
let reason_info = response.status_reason_information.unwrap_or_default();
Some(ErrorResponse {
code: reason_info
.reason
.code
.clone()
.unwrap_or(consts::NO_ERROR_CODE.to_string()),
// message vary for the same code, so relying on code alone as it is unique
message: reason_info
.reason
.code
.unwrap_or(consts::NO_ERROR_MESSAGE.to_string()),
reason: reason_info.reason.reject_reason,
status_code,
attempt_status: None,
connector_transaction_id: response.references.payment_request_id.clone(),
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
})
} else {
None
};
let refund_response_data = RefundsResponseData {
connector_refund_id: response
.references
.payment_request_id
.ok_or(errors::ConnectorError::MissingConnectorRefundID)?,
refund_status,
};
Ok((error, refund_response_data))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/trustpay/transformers.rs" role="context" start="1611" end="1611">
use common_enums::enums;
use common_utils::{
errors::CustomResult,
pii::{self, Email},
request::Method,
types::StringMajorUnit,
};
use hyperswitch_domain_models::{
payment_method_data::{BankRedirectData, BankTransferData, Card, PaymentMethodData},
router_data::{AccessToken, ConnectorAuthType, ErrorResponse, RouterData},
router_request_types::{BrowserInformation, PaymentsPreProcessingData, ResponseId},
router_response_types::{
PaymentsResponseData, PreprocessingResponseId, RedirectForm, RefundsResponseData,
},
types::{
PaymentsAuthorizeRouterData, PaymentsPreProcessingRouterData, RefreshTokenRouterData,
RefundsRouterData,
},
};
use hyperswitch_interfaces::{consts, errors};
use crate::{
types::{RefundsResponseRouterData, ResponseRouterData},
utils::{
self, AddressDetailsData, BrowserInformationData, CardData, PaymentsAuthorizeRequestData,
PaymentsPreProcessingRequestData, RouterData as OtherRouterData,
},
};
type Error = error_stack::Report<errors::ConnectorError>;
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/trustpay/transformers.rs" role="context" start="1679" end="1716">
fn handle_bank_redirects_refund_sync_response(
response: SyncResponseBankRedirect,
status_code: u16,
) -> (Option<ErrorResponse>, RefundsResponseData) {
let refund_status = enums::RefundStatus::from(response.payment_information.status);
let error = if utils::is_refund_failure(refund_status) {
let reason_info = response
.payment_information
.status_reason_information
.unwrap_or_default();
Some(ErrorResponse {
code: reason_info
.reason
.code
.clone()
.unwrap_or(consts::NO_ERROR_CODE.to_string()),
// message vary for the same code, so relying on code alone as it is unique
message: reason_info
.reason
.code
.unwrap_or(consts::NO_ERROR_MESSAGE.to_string()),
reason: reason_info.reason.reject_reason,
status_code,
attempt_status: None,
connector_transaction_id: None,
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
})
} else {
None
};
let refund_response_data = RefundsResponseData {
connector_refund_id: response.payment_information.references.payment_request_id,
refund_status,
};
(error, refund_response_data)
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/trustpay/transformers.rs" role="context" start="1651" end="1677">
fn handle_bank_redirects_refund_response(
response: BankRedirectRefundResponse,
status_code: u16,
) -> (Option<ErrorResponse>, RefundsResponseData) {
let (refund_status, msg) = get_refund_status_from_result_info(response.result_info.result_code);
let error = if msg.is_some() {
Some(ErrorResponse {
code: response.result_info.result_code.to_string(),
// message vary for the same code, so relying on code alone as it is unique
message: response.result_info.result_code.to_string(),
reason: msg.map(|message| message.to_string()),
status_code,
attempt_status: None,
connector_transaction_id: None,
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
})
} else {
None
};
let refund_response_data = RefundsResponseData {
connector_refund_id: response.payment_request_id.to_string(),
refund_status,
};
(error, refund_response_data)
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/trustpay/transformers.rs" role="context" start="1583" end="1610">
fn handle_cards_refund_response(
response: CardsRefundResponse,
status_code: u16,
) -> CustomResult<(Option<ErrorResponse>, RefundsResponseData), errors::ConnectorError> {
let (refund_status, msg) = get_refund_status(&response.payment_status)?;
let error = if msg.is_some() {
Some(ErrorResponse {
code: response.payment_status,
message: msg
.clone()
.unwrap_or_else(|| consts::NO_ERROR_MESSAGE.to_string()),
reason: msg,
status_code,
attempt_status: None,
connector_transaction_id: None,
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
})
} else {
None
};
let refund_response_data = RefundsResponseData {
connector_refund_id: response.instance_id,
refund_status,
};
Ok((error, refund_response_data))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/trustpay/transformers.rs" role="context" start="1522" end="1553">
fn try_from(item: &TrustpayRouterData<&RefundsRouterData<F>>) -> Result<Self, Self::Error> {
let amount = item.amount.to_owned();
match item.router_data.payment_method {
enums::PaymentMethod::BankRedirect => {
let auth = TrustpayAuthType::try_from(&item.router_data.connector_auth_type)
.change_context(errors::ConnectorError::FailedToObtainAuthType)?;
Ok(Self::BankRedirectRefund(Box::new(
TrustpayRefundRequestBankRedirect {
merchant_identification: MerchantIdentification {
project_id: auth.project_id,
},
payment_information: BankPaymentInformation {
amount: Amount {
amount,
currency: item.router_data.request.currency.to_string(),
},
references: References {
merchant_reference: item.router_data.request.refund_id.clone(),
},
debtor: None,
},
},
)))
}
_ => Ok(Self::CardsRefund(Box::new(TrustpayRefundRequestCards {
instance_id: item.router_data.request.connector_transaction_id.clone(),
amount,
currency: item.router_data.request.currency.to_string(),
reference: item.router_data.request.refund_id.clone(),
}))),
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/trustpay/transformers.rs" role="context" start="1744" end="1766">
fn try_from(item: RefundsResponseRouterData<F, RefundResponse>) -> Result<Self, Self::Error> {
let (error, response) = match item.response {
RefundResponse::CardsRefund(response) => {
handle_cards_refund_response(*response, item.http_code)?
}
RefundResponse::WebhookRefund(response) => {
handle_webhooks_refund_response(*response, item.http_code)?
}
RefundResponse::BankRedirectRefund(response) => {
handle_bank_redirects_refund_response(*response, item.http_code)
}
RefundResponse::BankRedirectRefundSyncResponse(response) => {
handle_bank_redirects_refund_sync_response(*response, item.http_code)
}
RefundResponse::BankRedirectError(response) => {
handle_bank_redirects_refund_sync_error_response(*response, item.http_code)
}
};
Ok(Self {
response: error.map_or_else(|| Ok(response), Err),
..item.data
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/trustpay/transformers.rs" role="context" start="1886" end="1893">
fn try_from(item: WebhookStatus) -> Result<Self, Self::Error> {
match item {
WebhookStatus::Paid => Ok(Self::Success),
WebhookStatus::Refunded => Ok(Self::Success),
WebhookStatus::Rejected => Ok(Self::Failure),
_ => Err(errors::ConnectorError::WebhookEventTypeNotFound),
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/trustpay/transformers.rs" role="context" start="1913" end="1919">
pub struct WebhookPaymentInformation {
pub credit_debit_indicator: CreditDebitIndicator,
pub references: WebhookReferences,
pub status: WebhookStatus,
pub amount: WebhookAmount,
pub status_reason_information: Option<StatusReasonInformation>,
}
<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/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/cashtocode.rs<|crate|> hyperswitch_connectors<|connector|> cashtocode anchor=get_b64_auth_cashtocode kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/cashtocode.rs" role="context" start="69" end="103">
fn get_b64_auth_cashtocode(
payment_method_type: Option<enums::PaymentMethodType>,
auth_type: &transformers::CashtocodeAuth,
) -> CustomResult<Vec<(String, masking::Maskable<String>)>, errors::ConnectorError> {
fn construct_basic_auth(
username: Option<Secret<String>>,
password: Option<Secret<String>>,
) -> Result<masking::Maskable<String>, errors::ConnectorError> {
let username = username.ok_or(errors::ConnectorError::FailedToObtainAuthType)?;
let password = password.ok_or(errors::ConnectorError::FailedToObtainAuthType)?;
Ok(format!(
"Basic {}",
base64::engine::general_purpose::STANDARD.encode(format!(
"{}:{}",
username.peek(),
password.peek()
))
)
.into_masked())
}
let auth_header = match payment_method_type {
Some(enums::PaymentMethodType::ClassicReward) => construct_basic_auth(
auth_type.username_classic.to_owned(),
auth_type.password_classic.to_owned(),
),
Some(enums::PaymentMethodType::Evoucher) => construct_basic_auth(
auth_type.username_evoucher.to_owned(),
auth_type.password_evoucher.to_owned(),
),
_ => return Err(errors::ConnectorError::MissingPaymentMethodType)?,
}?;
Ok(vec![(headers::AUTHORIZATION.to_string(), auth_header)])
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/cashtocode.rs" role="context" start="68" end="68">
use common_enums::enums;
use common_utils::{
errors::CustomResult,
ext_traits::ByteSliceExt,
request::{Method, Request, RequestBuilder, RequestContent},
types::{AmountConvertor, FloatMajorUnit, FloatMajorUnitForConnector},
};
use hyperswitch_interfaces::{
api::{
self, ConnectorCommon, ConnectorCommonExt, ConnectorIntegration, ConnectorSpecifications,
ConnectorValidation,
},
configs::Connectors,
errors,
events::connector_api_logs::ConnectorEvent,
types::{PaymentsAuthorizeType, Response},
webhooks::{self, IncomingWebhookFlowError},
};
use masking::{Mask, PeekInterface, Secret};
use transformers as cashtocode;
use crate::{constants::headers, types::ResponseRouterData, utils};
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/cashtocode.rs" role="context" start="121" end="123">
fn common_get_content_type(&self) -> &'static str {
"application/json"
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/cashtocode.rs" role="context" start="117" end="119">
fn id(&self) -> &'static str {
"cashtocode"
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/cashtocode.rs" role="context" start="73" end="88">
fn construct_basic_auth(
username: Option<Secret<String>>,
password: Option<Secret<String>>,
) -> Result<masking::Maskable<String>, errors::ConnectorError> {
let username = username.ok_or(errors::ConnectorError::FailedToObtainAuthType)?;
let password = password.ok_or(errors::ConnectorError::FailedToObtainAuthType)?;
Ok(format!(
"Basic {}",
base64::engine::general_purpose::STANDARD.encode(format!(
"{}:{}",
username.peek(),
password.peek()
))
)
.into_masked())
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/cashtocode.rs" role="context" start="49" end="53">
pub fn new() -> &'static Self {
&Self {
amount_converter: &FloatMajorUnitForConnector,
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/cashtocode.rs" role="context" start="197" end="218">
fn get_headers(
&self,
req: &PaymentsAuthorizeRouterData,
_connectors: &Connectors,
) -> CustomResult<Vec<(String, masking::Maskable<String>)>, errors::ConnectorError> {
let mut header = vec![(
headers::CONTENT_TYPE.to_string(),
PaymentsAuthorizeType::get_content_type(self)
.to_owned()
.into(),
)];
let auth_type = transformers::CashtocodeAuth::try_from((
&req.connector_auth_type,
&req.request.currency,
))?;
let mut api_key = get_b64_auth_cashtocode(req.request.payment_method_type, &auth_type)?;
header.append(&mut api_key);
Ok(header)
}
<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/klarna/transformers.rs<|crate|> hyperswitch_connectors<|connector|> klarna 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/klarna/transformers.rs" role="context" start="563" end="598">
fn try_from(
item: ResponseRouterData<F, KlarnaPsyncResponse, T, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
match item.response {
KlarnaPsyncResponse::KlarnaSDKPsyncResponse(response) => Ok(Self {
status: enums::AttemptStatus::from(response.status),
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(response.order_id.clone()),
redirection_data: Box::new(None),
mandate_reference: Box::new(None),
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: response
.klarna_reference
.or(Some(response.order_id.clone())),
incremental_authorization_allowed: None,
charges: None,
}),
..item.data
}),
KlarnaPsyncResponse::KlarnaCheckoutPSyncResponse(response) => Ok(Self {
status: get_checkout_status(response.status.clone(), response.options.auto_capture),
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(response.order_id.clone()),
redirection_data: Box::new(None),
mandate_reference: Box::new(None),
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: Some(response.order_id.clone()),
incremental_authorization_allowed: None,
charges: None,
}),
..item.data
}),
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/klarna/transformers.rs" role="context" start="562" end="562">
use common_enums::enums;
use hyperswitch_domain_models::{
payment_method_data::{PayLaterData, PaymentMethodData},
router_data::{
AdditionalPaymentMethodConnectorResponse, ConnectorAuthType, ConnectorResponseData,
KlarnaSdkResponse, RouterData,
},
router_flow_types::refunds::{Execute, RSync},
router_request_types::{PaymentsCaptureData, ResponseId},
router_response_types::{PaymentsResponseData, RedirectForm, RefundsResponseData},
types,
};
use crate::{
types::{
PaymentsResponseRouterData, PaymentsSessionResponseRouterData, RefundsResponseRouterData,
ResponseRouterData,
},
utils::{self, AddressData, AddressDetailsData, PaymentsAuthorizeRequestData, RouterData as _},
};
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/klarna/transformers.rs" role="context" start="635" end="670">
fn try_from(
item: ResponseRouterData<
F,
KlarnaCaptureResponse,
PaymentsCaptureData,
PaymentsResponseData,
>,
) -> Result<Self, Self::Error> {
let connector_meta = serde_json::json!(KlarnaMeta {
capture_id: item.response.capture_id,
});
// https://docs.klarna.com/api/ordermanagement/#operation/captureOrder
// If 201 status code, then order is captured, other status codes are handled by the error handler
let status = if item.http_code == 201 {
enums::AttemptStatus::Charged
} else {
item.data.status
};
let resource_id = item.data.request.connector_transaction_id.clone();
Ok(Self {
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(resource_id),
redirection_data: Box::new(None),
mandate_reference: Box::new(None),
connector_metadata: Some(connector_meta),
network_txn_id: None,
connector_response_reference_id: None,
incremental_authorization_allowed: None,
charges: None,
}),
status,
..item.data
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/klarna/transformers.rs" role="context" start="609" end="617">
fn try_from(
item: &KlarnaRouterData<&types::PaymentsCaptureRouterData>,
) -> Result<Self, Self::Error> {
let reference = Some(item.router_data.connector_request_reference_id.clone());
Ok(Self {
reference,
captured_amount: item.amount.to_owned(),
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/klarna/transformers.rs" role="context" start="548" end="556">
fn from(item: KlarnaPaymentStatus) -> Self {
match item {
KlarnaPaymentStatus::Authorized => Self::Authorized,
KlarnaPaymentStatus::PartCaptured => Self::PartialCharged,
KlarnaPaymentStatus::Captured => Self::Charged,
KlarnaPaymentStatus::Cancelled => Self::Voided,
KlarnaPaymentStatus::Expired | KlarnaPaymentStatus::Closed => Self::Failure,
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/klarna/transformers.rs" role="context" start="499" end="513">
fn get_checkout_status(
klarna_status: KlarnaCheckoutStatus,
is_auto_capture: bool,
) -> common_enums::AttemptStatus {
match klarna_status {
KlarnaCheckoutStatus::CheckoutIncomplete => {
if is_auto_capture {
common_enums::AttemptStatus::AuthenticationPending
} else {
common_enums::AttemptStatus::Authorized
}
}
KlarnaCheckoutStatus::CheckoutComplete => common_enums::AttemptStatus::Charged,
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/klarna/transformers.rs" role="context" start="66" end="66">
type Error = error_stack::Report<errors::ConnectorError>;
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/klarna/transformers.rs" role="context" start="517" end="520">
pub enum KlarnaPsyncResponse {
KlarnaSDKPsyncResponse(KlarnaSDKSyncResponse),
KlarnaCheckoutPSyncResponse(KlarnaCheckoutSyncResponse),
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/types.rs" role="context" start="53" end="57">
pub struct ResponseRouterData<Flow, R, Request, Response> {
pub response: R,
pub data: RouterData<Flow, Request, Response>,
pub http_code: u16,
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/hyperswitch_connectors/src/connectors/novalnet/transformers.rs<|crate|> hyperswitch_connectors<|connector|> novalnet 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/novalnet/transformers.rs" role="context" start="1130" end="1177">
fn try_from(
item: ResponseRouterData<
F,
NovalnetCaptureResponse,
PaymentsCaptureData,
PaymentsResponseData,
>,
) -> Result<Self, Self::Error> {
match item.response.result.status {
NovalnetAPIStatus::Success => {
let transaction_id = item
.response
.transaction
.clone()
.map(|data| data.tid.expose().to_string());
let transaction_status = item
.response
.transaction
.map(|transaction_data| transaction_data.status)
.unwrap_or(NovalnetTransactionStatus::Pending);
Ok(Self {
status: common_enums::AttemptStatus::from(transaction_status),
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: transaction_id
.clone()
.map(ResponseId::ConnectorTransactionId)
.unwrap_or(ResponseId::NoResponseId),
redirection_data: Box::new(None),
mandate_reference: Box::new(None),
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: transaction_id.clone(),
incremental_authorization_allowed: None,
charges: None,
}),
..item.data
})
}
NovalnetAPIStatus::Failure => {
let response = Err(get_error_response(item.response.result, item.http_code));
Ok(Self {
response,
..item.data
})
}
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/novalnet/transformers.rs" role="context" start="1129" end="1129">
use common_enums::{enums, enums as api_enums};
use hyperswitch_domain_models::{
payment_method_data::{PaymentMethodData, WalletData as WalletDataPaymentMethod},
router_data::{ConnectorAuthType, ErrorResponse, RouterData},
router_flow_types::refunds::{Execute, RSync},
router_request_types::{PaymentsCancelData, PaymentsCaptureData, PaymentsSyncData, ResponseId},
router_response_types::{
MandateReference, PaymentsResponseData, RedirectForm, RefundsResponseData,
},
types::{
PaymentsAuthorizeRouterData, PaymentsCancelRouterData, PaymentsCaptureRouterData,
PaymentsSyncRouterData, RefundSyncRouterData, RefundsRouterData, SetupMandateRouterData,
},
};
use crate::{
types::{RefundsResponseRouterData, ResponseRouterData},
utils::{
self, AddressData, AddressDetailsData, ApplePay, PaymentsAuthorizeRequestData,
PaymentsCancelRequestData, PaymentsCaptureRequestData, PaymentsSetupMandateRequestData,
PaymentsSyncRequestData, RefundsRequestData, RouterData as _,
},
};
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/novalnet/transformers.rs" role="context" start="1215" end="1251">
fn try_from(
item: RefundsResponseRouterData<RSync, NovalnetRefundSyncResponse>,
) -> Result<Self, Self::Error> {
match item.response.result.status {
NovalnetAPIStatus::Success => {
let refund_id = item
.response
.transaction
.clone()
.and_then(|data| data.tid)
.map(|tid| tid.expose().to_string())
.unwrap_or("".to_string());
//NOTE: Mapping refund_id with "" incase we dont get any tid
let transaction_status = item
.response
.transaction
.map(|transaction_data| transaction_data.status)
.unwrap_or(NovalnetTransactionStatus::Pending);
Ok(Self {
response: Ok(RefundsResponseData {
connector_refund_id: refund_id,
refund_status: enums::RefundStatus::from(transaction_status),
}),
..item.data
})
}
NovalnetAPIStatus::Failure => {
let response = Err(get_error_response(item.response.result, item.http_code));
Ok(Self {
response,
..item.data
})
}
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/novalnet/transformers.rs" role="context" start="1193" end="1208">
fn try_from(item: &RefundSyncRouterData) -> Result<Self, Self::Error> {
let transaction = NovalnetSyncTransaction {
tid: item.request.connector_transaction_id.clone(),
};
let custom = NovalnetCustom {
lang: item
.request
.get_optional_language_from_browser_info()
.unwrap_or(consts::DEFAULT_LOCALE.to_string().to_string()),
};
Ok(Self {
transaction,
custom,
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/novalnet/transformers.rs" role="context" start="1039" end="1093">
fn try_from(
item: ResponseRouterData<F, NovalnetPSyncResponse, PaymentsSyncData, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
match item.response.result.status {
NovalnetAPIStatus::Success => {
let transaction_id = item
.response
.transaction
.clone()
.and_then(|data| data.tid)
.map(|tid| tid.expose().to_string());
let transaction_status = item
.response
.transaction
.clone()
.map(|transaction_data| transaction_data.status)
.unwrap_or(NovalnetTransactionStatus::Pending);
let mandate_reference_id = NovalnetSyncResponseTransactionData::get_token(
item.response.transaction.as_ref(),
);
Ok(Self {
status: common_enums::AttemptStatus::from(transaction_status),
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: transaction_id
.clone()
.map(ResponseId::ConnectorTransactionId)
.unwrap_or(ResponseId::NoResponseId),
redirection_data: Box::new(None),
mandate_reference: Box::new(mandate_reference_id.as_ref().map(|id| {
MandateReference {
connector_mandate_id: Some(id.clone()),
payment_method_id: None,
mandate_metadata: None,
connector_mandate_request_reference_id: None,
}
})),
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: transaction_id.clone(),
incremental_authorization_allowed: None,
charges: None,
}),
..item.data
})
}
NovalnetAPIStatus::Failure => {
let response = Err(get_error_response(item.response.result, item.http_code));
Ok(Self {
response,
..item.data
})
}
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/novalnet/transformers.rs" role="context" start="1017" end="1031">
pub fn get_token(transaction_data: Option<&Self>) -> Option<String> {
if let Some(data) = transaction_data {
match &data.payment_data {
Some(NovalnetResponsePaymentData::Card(card_data)) => {
card_data.token.clone().map(|token| token.expose())
}
Some(NovalnetResponsePaymentData::Paypal(paypal_data)) => {
paypal_data.token.clone().map(|token| token.expose())
}
None => None,
}
} else {
None
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/novalnet/transformers.rs" role="context" start="877" end="888">
fn from(item: NovalnetTransactionStatus) -> Self {
match item {
NovalnetTransactionStatus::Success | NovalnetTransactionStatus::Confirmed => {
Self::Success
}
NovalnetTransactionStatus::Pending => Self::Pending,
NovalnetTransactionStatus::Failure
| NovalnetTransactionStatus::OnHold
| NovalnetTransactionStatus::Deactivated
| NovalnetTransactionStatus::Progress => Self::Failure,
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/novalnet/transformers.rs" role="context" start="581" end="596">
pub fn get_error_response(result: ResultData, status_code: u16) -> ErrorResponse {
let error_code = result.status;
let error_reason = result.status_text.clone();
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/novalnet/transformers.rs" role="context" start="174" end="174">
type Error = error_stack::Report<errors::ConnectorError>;
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/novalnet/transformers.rs" role="context" start="1119" end="1122">
pub struct NovalnetCaptureResponse {
pub result: ResultData,
pub transaction: Option<NovalnetCaptureTransactionData>,
}
<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/payeezy/transformers.rs<|crate|> hyperswitch_connectors<|connector|> payeezy 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/payeezy/transformers.rs" role="context" start="409" end="454">
fn try_from(
item: ResponseRouterData<F, PayeezyPaymentsResponse, T, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
let metadata = item
.response
.transaction_tag
.map(|txn_tag| construct_payeezy_payments_metadata(txn_tag).encode_to_value())
.transpose()
.change_context(ConnectorError::ResponseHandlingFailed)?;
let mandate_reference = item
.response
.stored_credentials
.map(|credentials| credentials.cardbrand_original_transaction_id)
.map(|id| MandateReference {
connector_mandate_id: Some(id.expose()),
payment_method_id: None,
mandate_metadata: None,
connector_mandate_request_reference_id: None,
});
let status = get_status(
item.response.transaction_status,
item.response.transaction_type,
);
Ok(Self {
status,
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(
item.response.transaction_id.clone(),
),
redirection_data: Box::new(None),
mandate_reference: Box::new(mandate_reference),
connector_metadata: metadata,
network_txn_id: None,
connector_response_reference_id: Some(
item.response
.reference
.unwrap_or(item.response.transaction_id),
),
incremental_authorization_allowed: None,
charges: None,
}),
..item.data
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/payeezy/transformers.rs" role="context" start="408" end="408">
use hyperswitch_domain_models::{
payment_method_data::PaymentMethodData,
router_data::{ConnectorAuthType, RouterData},
router_flow_types::Execute,
router_request_types::ResponseId,
router_response_types::{MandateReference, PaymentsResponseData, RefundsResponseData},
types::{
PaymentsAuthorizeRouterData, PaymentsCancelRouterData, PaymentsCaptureRouterData,
RefundsRouterData,
},
};
use crate::{
types::{RefundsResponseRouterData, ResponseRouterData},
utils::{
get_amount_as_string, get_unimplemented_payment_method_error_message, to_connector_meta,
CardData, CardIssuer, RouterData as _,
},
};
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/payeezy/transformers.rs" role="context" start="494" end="504">
fn try_from(item: &PayeezyRouterData<&RefundsRouterData<F>>) -> Result<Self, Self::Error> {
let metadata: PayeezyPaymentsMetadata =
to_connector_meta(item.router_data.request.connector_metadata.clone())
.change_context(ConnectorError::RequestEncodingFailed)?;
Ok(Self {
transaction_type: PayeezyTransactionType::Refund,
amount: item.amount.clone(),
currency_code: item.router_data.request.currency.to_string(),
transaction_tag: metadata.transaction_tag,
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/payeezy/transformers.rs" role="context" start="457" end="480">
fn get_status(status: PayeezyPaymentStatus, method: PayeezyTransactionType) -> AttemptStatus {
match status {
PayeezyPaymentStatus::Approved => match method {
PayeezyTransactionType::Authorize => AttemptStatus::Authorized,
PayeezyTransactionType::Capture
| PayeezyTransactionType::Purchase
| PayeezyTransactionType::Recurring => AttemptStatus::Charged,
PayeezyTransactionType::Void => AttemptStatus::Voided,
PayeezyTransactionType::Refund | PayeezyTransactionType::Pending => {
AttemptStatus::Pending
}
},
PayeezyPaymentStatus::Declined | PayeezyPaymentStatus::NotProcessed => match method {
PayeezyTransactionType::Capture => AttemptStatus::CaptureFailed,
PayeezyTransactionType::Authorize
| PayeezyTransactionType::Purchase
| PayeezyTransactionType::Recurring => AttemptStatus::AuthorizationFailed,
PayeezyTransactionType::Void => AttemptStatus::VoidFailed,
PayeezyTransactionType::Refund | PayeezyTransactionType::Pending => {
AttemptStatus::Pending
}
},
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/payeezy/transformers.rs" role="context" start="370" end="384">
fn try_from(item: &PaymentsCancelRouterData) -> Result<Self, Self::Error> {
let metadata: PayeezyPaymentsMetadata =
to_connector_meta(item.request.connector_meta.clone())
.change_context(ConnectorError::RequestEncodingFailed)?;
Ok(Self {
transaction_type: PayeezyTransactionType::Void,
amount: item
.request
.amount
.ok_or(ConnectorError::RequestEncodingFailed)?
.to_string(),
currency_code: item.request.currency.unwrap_or_default().to_string(),
transaction_tag: metadata.transaction_tag,
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/payeezy/transformers.rs" role="context" start="355" end="365">
fn try_from(item: &PayeezyRouterData<&PaymentsCaptureRouterData>) -> Result<Self, Self::Error> {
let metadata: PayeezyPaymentsMetadata =
to_connector_meta(item.router_data.request.connector_meta.clone())
.change_context(ConnectorError::RequestEncodingFailed)?;
Ok(Self {
transaction_type: PayeezyTransactionType::Capture,
amount: item.amount.clone(),
currency_code: item.router_data.request.currency.to_string(),
transaction_tag: metadata.transaction_tag,
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/payeezy/transformers.rs" role="context" start="579" end="581">
fn construct_payeezy_payments_metadata(transaction_tag: String) -> PayeezyPaymentsMetadata {
PayeezyPaymentsMetadata { transaction_tag }
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/payeezy/transformers.rs" role="context" start="35" end="35">
type Error = error_stack::Report<ConnectorError>;
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/payeezy/transformers.rs" role="context" start="322" end="338">
pub struct PayeezyPaymentsResponse {
pub correlation_id: String,
pub transaction_status: PayeezyPaymentStatus,
pub validation_status: String,
pub transaction_type: PayeezyTransactionType,
pub transaction_id: String,
pub transaction_tag: Option<String>,
pub method: Option<String>,
pub amount: String,
pub currency: String,
pub bank_resp_code: String,
pub bank_message: String,
pub gateway_resp_code: String,
pub gateway_message: String,
pub stored_credentials: Option<PaymentsStoredCredentials>,
pub reference: Option<String>,
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/types.rs" role="context" start="53" end="57">
pub struct ResponseRouterData<Flow, R, Request, Response> {
pub response: R,
pub data: RouterData<Flow, Request, Response>,
pub http_code: u16,
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/hyperswitch_connectors/src/connectors/redsys/transformers.rs<|crate|> hyperswitch_connectors<|connector|> redsys anchor=des_encrypt kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=1<|meta_end|>
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/redsys/transformers.rs" role="context" start="775" end="801">
fn des_encrypt(
message: &str,
key: &str,
) -> Result<Vec<u8>, error_stack::Report<errors::ConnectorError>> {
// Connector decrypts the signature using an initialization vector (IV) set to all zeros
let iv_array = [0u8; common_utils::crypto::TripleDesEde3CBC::TRIPLE_DES_IV_LENGTH];
let iv = iv_array.to_vec();
let key_bytes = BASE64_ENGINE
.decode(key)
.change_context(errors::ConnectorError::RequestEncodingFailed)
.attach_printable("Base64 decoding failed")?;
let triple_des =
common_utils::crypto::TripleDesEde3CBC::new(Some(enums::CryptoPadding::ZeroPadding), iv)
.change_context(errors::ConnectorError::RequestEncodingFailed)
.attach_printable("Triple DES encryption failed")?;
let encrypted = triple_des
.encode_message(&key_bytes, message.as_bytes())
.change_context(errors::ConnectorError::RequestEncodingFailed)
.attach_printable("Triple DES encryption failed")?;
let expected_len =
encrypted.len() - common_utils::crypto::TripleDesEde3CBC::TRIPLE_DES_IV_LENGTH;
let encrypted_trimmed = encrypted
.get(..expected_len)
.ok_or(errors::ConnectorError::RequestEncodingFailed)
.attach_printable("Failed to trim encrypted data to the expected length")?;
Ok(encrypted_trimmed.to_vec())
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/redsys/transformers.rs" role="context" start="774" end="774">
use common_enums::enums;
use common_utils::{
consts::BASE64_ENGINE,
crypto::{EncodeMessage, SignMessage},
ext_traits::{Encode, ValueExt},
types::StringMinorUnit,
};
use error_stack::ResultExt;
type Error = error_stack::Report<errors::ConnectorError>;
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/redsys/transformers.rs" role="context" start="825" end="828">
fn get_merchant_parameters(&self) -> Result<String, Error> {
self.encode_to_string_of_json()
.change_context(errors::ConnectorError::RequestEncodingFailed)
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/redsys/transformers.rs" role="context" start="803" end="817">
fn get_signature(
order_id: &str,
params: &str,
key: &str,
) -> Result<String, error_stack::Report<errors::ConnectorError>> {
let secret_ko = des_encrypt(order_id, key)?;
let result = common_utils::crypto::HmacSha256::sign_message(
&common_utils::crypto::HmacSha256,
&secret_ko,
params.as_bytes(),
)
.map_err(|_| errors::ConnectorError::RequestEncodingFailed)?;
let encoded = BASE64_ENGINE.encode(result);
Ok(encoded)
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/redsys/transformers.rs" role="context" start="739" end="773">
fn handle_threeds_invoke_exempt<F>(
item: ResponseRouterData<F, RedsysResponse, PaymentsPreProcessingData, PaymentsResponseData>,
response_data: &RedsysPaymentsResponse,
three_d_s_server_trans_i_d: String,
protocol_version: String,
) -> Result<
RouterData<F, PaymentsPreProcessingData, PaymentsResponseData>,
error_stack::Report<errors::ConnectorError>,
> {
let three_ds_data = ThreeDsInvokeExempt {
message_version: protocol_version.clone(),
three_d_s_server_trans_i_d,
};
let connector_metadata = Some(
serde_json::to_value(&three_ds_data)
.change_context(errors::ConnectorError::RequestEncodingFailed)
.attach_printable("Failed to serialize ThreeDsData")?,
);
Ok(RouterData {
status: enums::AttemptStatus::AuthenticationPending,
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(response_data.ds_order.clone()),
redirection_data: Box::new(None),
mandate_reference: Box::new(None),
connector_metadata,
network_txn_id: None,
connector_response_reference_id: Some(response_data.ds_order.clone()),
incremental_authorization_allowed: None,
charges: None,
}),
..item.data
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/redsys/transformers.rs" role="context" start="686" end="737">
fn handle_threeds_invoke<F>(
item: ResponseRouterData<F, RedsysResponse, PaymentsPreProcessingData, PaymentsResponseData>,
response_data: &RedsysPaymentsResponse,
three_d_s_method_u_r_l: String,
three_d_s_server_trans_i_d: String,
protocol_version: String,
) -> Result<
RouterData<F, PaymentsPreProcessingData, PaymentsResponseData>,
error_stack::Report<errors::ConnectorError>,
> {
let three_d_s_method_notification_u_r_l = item.data.request.get_webhook_url()?;
let threeds_invoke_data = ThreedsInvokeRequest {
three_d_s_server_trans_i_d: three_d_s_method_u_r_l.clone(),
three_d_s_method_notification_u_r_l,
};
let three_ds_data_string = threeds_invoke_data
.encode_to_string_of_json()
.change_context(errors::ConnectorError::RequestEncodingFailed)?;
let three_ds_method_data = BASE64_ENGINE.encode(&three_ds_data_string);
let three_ds_data = RedsysThreeDsInvokeData {
three_ds_method_url: three_d_s_method_u_r_l,
three_ds_method_data,
message_version: protocol_version.clone(),
directory_server_id: three_d_s_server_trans_i_d,
three_ds_method_data_submission: true,
};
let connector_metadata = Some(
serde_json::to_value(&three_ds_data)
.change_context(errors::ConnectorError::RequestEncodingFailed)
.attach_printable("Failed to serialize ThreeDsData")?,
);
Ok(RouterData {
status: enums::AttemptStatus::AuthenticationPending,
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(response_data.ds_order.clone()),
redirection_data: Box::new(None),
mandate_reference: Box::new(None),
connector_metadata,
network_txn_id: None,
connector_response_reference_id: Some(response_data.ds_order.clone()),
incremental_authorization_allowed: None,
charges: None,
}),
..item.data
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/redsys/transformers.rs" role="context" start="135" end="156">
pub fn new(three_d_s_info: RedsysThreeDsInfo) -> Self {
Self {
three_d_s_info,
protocol_version: None,
browser_accept_header: None,
browser_user_agent: None,
browser_java_enabled: None,
browser_java_script_enabled: None,
browser_language: None,
browser_color_depth: None,
browser_screen_height: None,
browser_screen_width: None,
browser_t_z: None,
browser_i_p: None,
three_d_s_server_trans_i_d: None,
notification_u_r_l: None,
three_d_s_comp_ind: None,
cres: None,
billing_data: None,
shipping_data: None,
}
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/hyperswitch_connectors/src/connectors/globepay/transformers.rs<|crate|> hyperswitch_connectors<|connector|> globepay 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/globepay/transformers.rs" role="context" start="276" end="313">
fn try_from(
item: ResponseRouterData<F, GlobepaySyncResponse, T, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
if item.response.return_code == GlobepayReturnCode::Success {
let globepay_status = item
.response
.result_code
.ok_or(errors::ConnectorError::ResponseHandlingFailed)?;
let globepay_id = item
.response
.order_id
.ok_or(errors::ConnectorError::ResponseHandlingFailed)?;
Ok(Self {
status: enums::AttemptStatus::from(globepay_status),
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(globepay_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: enums::AttemptStatus::Failure, //As this connector gives 200 in failed scenarios . if return_code is not success status is mapped to failure. ref = "https://pay.globepay.co/docs/en/#api-QRCode-NewQRCode"
response: Err(get_error_response(
item.response.return_code,
item.response.return_msg,
item.http_code,
)),
..item.data
})
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/globepay/transformers.rs" role="context" start="275" end="275">
use common_enums::enums;
use hyperswitch_domain_models::{
payment_method_data::{PaymentMethodData, WalletData},
router_data::{ConnectorAuthType, ErrorResponse, RouterData},
router_request_types::ResponseId,
router_response_types::{PaymentsResponseData, RefundsResponseData},
types::{self, RefundsRouterData},
};
use crate::{
types::{RefundsResponseRouterData, ResponseRouterData},
utils::{get_unimplemented_payment_method_error_message, RouterData as _},
};
type Error = error_stack::Report<errors::ConnectorError>;
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/globepay/transformers.rs" role="context" start="341" end="343">
fn try_from(item: &GlobepayRouterData<&RefundsRouterData<F>>) -> Result<Self, Self::Error> {
Ok(Self { fee: item.amount })
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/globepay/transformers.rs" role="context" start="316" end="332">
fn get_error_response(
return_code: GlobepayReturnCode,
return_msg: Option<String>,
status_code: u16,
) -> ErrorResponse {
ErrorResponse {
code: return_code.to_string(),
message: consts::NO_ERROR_MESSAGE.to_string(),
reason: return_msg,
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/globepay/transformers.rs" role="context" start="261" end="269">
fn from(item: GlobepayPaymentPsyncStatus) -> Self {
match item {
GlobepayPaymentPsyncStatus::PaySuccess => Self::Charged,
GlobepayPaymentPsyncStatus::PayFail
| GlobepayPaymentPsyncStatus::CreateFail
| GlobepayPaymentPsyncStatus::Closed => Self::Failure,
GlobepayPaymentPsyncStatus::Paying => Self::AuthenticationPending,
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/globepay/transformers.rs" role="context" start="192" end="239">
fn try_from(
item: ResponseRouterData<F, GlobepayPaymentsResponse, T, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
if item.response.return_code == GlobepayReturnCode::Success {
let globepay_metadata = GlobepayConnectorMetadata {
image_data_url: item
.response
.qrcode_img
.ok_or(errors::ConnectorError::ResponseHandlingFailed)?,
};
let connector_metadata = Some(globepay_metadata.encode_to_value())
.transpose()
.change_context(errors::ConnectorError::ResponseHandlingFailed)?;
let globepay_status = item
.response
.result_code
.ok_or(errors::ConnectorError::ResponseHandlingFailed)?;
Ok(Self {
status: enums::AttemptStatus::from(globepay_status),
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(
item.response
.order_id
.ok_or(errors::ConnectorError::ResponseHandlingFailed)?,
),
redirection_data: Box::new(None),
mandate_reference: Box::new(None),
connector_metadata,
network_txn_id: None,
connector_response_reference_id: None,
incremental_authorization_allowed: None,
charges: None,
}),
..item.data
})
} else {
Ok(Self {
status: enums::AttemptStatus::Failure, //As this connector gives 200 in failed scenarios . if return_code is not success status is mapped to failure. ref = "https://pay.globepay.co/docs/en/#api-QRCode-NewQRCode"
response: Err(get_error_response(
item.response.return_code,
item.response.return_msg,
item.http_code,
)),
..item.data
})
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/globepay/transformers.rs" role="context" start="357" end="365">
fn from(item: GlobepayRefundStatus) -> Self {
match item {
GlobepayRefundStatus::Finished => Self::Success, //FINISHED: Refund success(funds has already been returned to user's account)
GlobepayRefundStatus::Failed
| GlobepayRefundStatus::CreateFailed
| GlobepayRefundStatus::Change => Self::Failure, //CHANGE: Refund can not return to user's account. Manual operation is required
GlobepayRefundStatus::Waiting | GlobepayRefundStatus::Success => Self::Pending, // SUCCESS: Submission succeeded, but refund is not yet complete. Waiting = Submission succeeded, but refund is not yet complete.
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/globepay/transformers.rs" role="context" start="19" end="19">
type Error = error_stack::Report<errors::ConnectorError>;
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/globepay/transformers.rs" role="context" start="243" end="248">
pub struct GlobepaySyncResponse {
pub result_code: Option<GlobepayPaymentPsyncStatus>,
pub order_id: Option<String>,
pub return_code: GlobepayReturnCode,
pub return_msg: Option<String>,
}
<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/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="1257" end="1293">
fn try_from(request: NuveiPaymentRequestData) -> Result<Self, Self::Error> {
let session_token = request.session_token;
fp_utils::when(session_token.clone().expose().is_empty(), || {
Err(errors::ConnectorError::FailedToObtainAuthType)
})?;
let connector_meta: NuveiAuthType = NuveiAuthType::try_from(&request.connector_auth_type)?;
let merchant_id = connector_meta.merchant_id;
let merchant_site_id = connector_meta.merchant_site_id;
let client_request_id = request.client_request_id;
let time_stamp =
date_time::format_date(date_time::now(), date_time::DateFormat::YYYYMMDDHHmmss)
.change_context(errors::ConnectorError::RequestEncodingFailed)?;
let merchant_secret = connector_meta.merchant_secret;
Ok(Self {
merchant_id: merchant_id.clone(),
merchant_site_id: merchant_site_id.clone(),
client_request_id: Secret::new(client_request_id.clone()),
time_stamp: time_stamp.clone(),
session_token,
transaction_type: request
.capture_method
.map(TransactionType::from)
.unwrap_or_default(),
checksum: Secret::new(encode_payload(&[
merchant_id.peek(),
merchant_site_id.peek(),
&client_request_id,
&request.amount.clone(),
&request.currency.to_string(),
&time_stamp,
merchant_secret.peek(),
])?),
amount: request.amount,
currency: request.currency,
..Default::default()
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/nuvei/transformers.rs" role="context" start="1256" end="1256">
use common_utils::{
crypto::{self, GenerateDigest},
date_time,
ext_traits::{Encode, OptionExt},
fp_utils,
pii::{Email, IpAddress},
request::Method,
};
use masking::{ExposeInterface, PeekInterface, Secret};
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/nuvei/transformers.rs" role="context" start="1342" end="1354">
fn try_from(item: &types::PaymentsCaptureRouterData) -> 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.amount_to_capture,
item.request.currency,
)?,
currency: item.request.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="1298" end="1326">
fn try_from(request: NuveiPaymentRequestData) -> Result<Self, Self::Error> {
let connector_meta: NuveiAuthType = NuveiAuthType::try_from(&request.connector_auth_type)?;
let merchant_id = connector_meta.merchant_id;
let merchant_site_id = connector_meta.merchant_site_id;
let client_request_id = request.client_request_id;
let time_stamp =
date_time::format_date(date_time::now(), date_time::DateFormat::YYYYMMDDHHmmss)
.change_context(errors::ConnectorError::RequestEncodingFailed)?;
let merchant_secret = connector_meta.merchant_secret;
Ok(Self {
merchant_id: merchant_id.to_owned(),
merchant_site_id: merchant_site_id.to_owned(),
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,
&request.amount.clone(),
&request.currency.to_string(),
&request.related_transaction_id.clone().unwrap_or_default(),
&time_stamp,
merchant_secret.peek(),
])?),
amount: request.amount,
currency: request.currency,
related_transaction_id: request.related_transaction_id,
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/nuvei/transformers.rs" role="context" start="1203" end="1252">
fn try_from(
data: (&types::PaymentsCompleteAuthorizeRouterData, Secret<String>),
) -> Result<Self, Self::Error> {
let item = data.0;
let request_data = match item.request.payment_method_data.clone() {
Some(PaymentMethodData::Card(card)) => Ok(Self {
payment_option: PaymentOption::from(NuveiCardDetails {
card,
three_d: None,
card_holder_name: item.get_optional_billing_full_name(),
}),
..Default::default()
}),
Some(PaymentMethodData::Wallet(..))
| Some(PaymentMethodData::PayLater(..))
| Some(PaymentMethodData::BankDebit(..))
| Some(PaymentMethodData::BankRedirect(..))
| Some(PaymentMethodData::BankTransfer(..))
| Some(PaymentMethodData::Crypto(..))
| Some(PaymentMethodData::MandatePayment)
| Some(PaymentMethodData::GiftCard(..))
| Some(PaymentMethodData::Voucher(..))
| Some(PaymentMethodData::CardRedirect(..))
| Some(PaymentMethodData::Reward)
| Some(PaymentMethodData::RealTimePayment(..))
| Some(PaymentMethodData::MobilePayment(..))
| Some(PaymentMethodData::Upi(..))
| Some(PaymentMethodData::OpenBanking(_))
| Some(PaymentMethodData::CardToken(..))
| Some(PaymentMethodData::NetworkToken(..))
| Some(PaymentMethodData::CardDetailsForNetworkTransactionId(_))
| None => Err(errors::ConnectorError::NotImplemented(
utils::get_unimplemented_payment_method_error_message("nuvei"),
)),
}?;
let request = Self::try_from(NuveiPaymentRequestData {
amount: utils::to_currency_base_unit(item.request.amount, item.request.currency)?,
currency: item.request.currency,
connector_auth_type: item.connector_auth_type.clone(),
client_request_id: item.connector_request_reference_id.clone(),
session_token: data.1,
capture_method: item.request.capture_method,
..Default::default()
})?;
Ok(Self {
related_transaction_id: request_data.related_transaction_id,
payment_option: request_data.payment_option,
..request
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/nuvei/transformers.rs" role="context" start="1182" end="1196">
fn from(card_details: NuveiCardDetails) -> Self {
let card = card_details.card;
Self {
card: Some(Card {
card_number: Some(card.card_number),
card_holder_name: card_details.card_holder_name,
expiration_month: Some(card.card_exp_month),
expiration_year: Some(card.card_exp_year),
three_d: card_details.three_d,
cvv: Some(card.card_cvc),
..Default::default()
}),
..Default::default()
}
}
<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="532" end="539">
fn encode_payload(payload: &[&str]) -> Result<String, error_stack::Report<errors::ConnectorError>> {
let data = payload.join("");
let digest = crypto::Sha256
.generate_digest(data.as_bytes())
.change_context(errors::ConnectorError::RequestEncodingFailed)
.attach_printable("error encoding the payload")?;
Ok(hex::encode(digest))
}
<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="1401" end="1405">
pub struct NuveiAuthType {
pub(super) merchant_id: Secret<String>,
pub(super) merchant_site_id: Secret<String>,
pub(super) merchant_secret: Secret<String>,
}
<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/zsl/transformers.rs<|crate|> hyperswitch_connectors<|connector|> zsl anchor=calculate_signature kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=1<|meta_end|>
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/zsl/transformers.rs" role="context" start="895" end="941">
pub fn calculate_signature(
enctype: EncodingType,
signature_data: ZslSignatureType,
) -> Result<Secret<String>, error_stack::Report<errors::ConnectorError>> {
let signature_data = match signature_data {
ZslSignatureType::RequestSignature {
txn_amt,
ccy,
mer_ref,
mer_id,
mer_txn_date,
key,
} => format!("{txn_amt}{ccy}{mer_ref}{mer_id}{mer_txn_date}{key}"),
ZslSignatureType::ResponseSignature {
status,
txn_url,
mer_ref,
mer_id,
key,
} => {
format!("{status}{txn_url}{mer_ref}{mer_id}{key}")
}
ZslSignatureType::WebhookSignature {
status,
txn_id,
txn_date,
paid_ccy,
paid_amt,
mer_ref,
mer_id,
key,
} => format!("{status}{txn_id}{txn_date}{paid_ccy}{paid_amt}{mer_ref}{mer_id}{key}"),
};
let message = signature_data.as_bytes();
let encoded_data = match enctype {
EncodingType::MD5 => hex::encode(
common_utils::crypto::Md5
.generate_digest(message)
.change_context(errors::ConnectorError::RequestEncodingFailed)?,
),
EncodingType::Sha1 => {
hex::encode(digest::digest(&digest::SHA1_FOR_LEGACY_USE_ONLY, message))
}
};
Ok(Secret::new(encoded_data))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/zsl/transformers.rs" role="context" start="894" end="894">
use common_utils::{crypto::GenerateDigest, date_time, pii::Email, request::Method};
use error_stack::ResultExt;
use masking::{ExposeInterface, Secret};
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/zsl/transformers.rs" role="context" start="467" end="663">
fn try_from(status: String) -> Result<Self, Self::Error> {
match status.as_str() {
"0" => Ok(Self::Normal),
"1000" => Ok(Self::InternalError),
"1001" => Ok(Self::BreakDownMessageError),
"1002" => Ok(Self::FormatError),
"1004" => Ok(Self::InvalidTransaction),
"1005" => Ok(Self::TransactionCountryNotFound),
"1006" => Ok(Self::MerchantIdNotFound),
"1007" => Ok(Self::AccountDisabled),
"1008" => Ok(Self::DuplicateMerchantReference),
"1009" => Ok(Self::InvalidPayAmount),
"1010" => Ok(Self::PayAmountNotFound),
"1011" => Ok(Self::InvalidCurrencyCode),
"1012" => Ok(Self::CurrencyCodeNotFound),
"1013" => Ok(Self::ReferenceNotFound),
"1014" => Ok(Self::TransmissionTimeNotFound),
"1015" => Ok(Self::PayMethodNotFound),
"1016" => Ok(Self::BankCodeNotFound),
"1017" => Ok(Self::InvalidShowPayPage),
"1018" => Ok(Self::ShowPayPageNotFound),
"1019" => Ok(Self::SuccessUrlNotFound),
"1020" => Ok(Self::SuccessCallbackUrlNotFound),
"1021" => Ok(Self::FailUrlNotFound),
"1022" => Ok(Self::FailCallbackUrlNotFound),
"1023" => Ok(Self::MacNotFound),
"1025" => Ok(Self::OriginalTransactionNotFound),
"1026" => Ok(Self::DeblockDataError),
"1028" => Ok(Self::PspAckNotYetReturn),
"1029" => Ok(Self::BankBranchNameNotFound),
"1030" => Ok(Self::BankAccountIDNotFound),
"1031" => Ok(Self::BankAccountNameNotFound),
"1032" => Ok(Self::IdentityIDNotFound),
"1033" => Ok(Self::ErrorConnectingToPsp),
"1034" => Ok(Self::CountryPspNotAvailable),
"1035" => Ok(Self::UnsupportedPayAmount),
"1036" => Ok(Self::RecordMismatch),
"1037" => Ok(Self::NoRecord),
"1038" => Ok(Self::PspError),
"1039" => Ok(Self::UnsupportedEncryptionType),
"1040" => Ok(Self::ExceedTransactionLimitCount),
"1041" => Ok(Self::ExceedTransactionLimitAmount),
"1042" => Ok(Self::ExceedTransactionAccountLimitCount),
"1043" => Ok(Self::ExceedTransactionAccountLimitAmount),
"1044" => Ok(Self::ExchangeRateError),
"1045" => Ok(Self::InvalidEncoding),
"1046" => Ok(Self::CustomerNameNotFound),
"1047" => Ok(Self::CustomerFamilyNameNotFound),
"1048" => Ok(Self::CustomerTelPhoneNotFound),
"1049" => Ok(Self::InsufficientFund),
"1050" => Ok(Self::ServiceCodeIsMissing),
"1051" => Ok(Self::CurrencyIdNotMatch),
"1052" => Ok(Self::NoPendingRecord),
"1053" => Ok(Self::NoLoadBalancerRuleDefineForTransaction),
"1054" => Ok(Self::NoPaymentProviderAvailable),
"1055" => Ok(Self::UnsupportedPayMethod),
"1056" => Ok(Self::PendingTransaction),
"1057" => Ok(Self::OtherError1059),
"1058" => Ok(Self::OtherError1058),
"1059" => Ok(Self::OtherError1059),
"1084" => Ok(Self::InvalidRequestId),
"5043" => Ok(Self::BeneficiaryBankAccountIsNotAvailable),
"5053" => Ok(Self::BaidNotFound),
"5057" => Ok(Self::InvalidBaid),
"5059" => Ok(Self::InvalidBaidStatus),
"5107" => Ok(Self::AutoUploadBankDisabled),
"5108" => Ok(Self::InvalidNature),
"5109" => Ok(Self::SmsCreateDateNotFound),
"5110" => Ok(Self::InvalidSmsCreateDate),
"5111" => Ok(Self::RecordNotFound),
"5112" => Ok(Self::InsufficientBaidAvailableBalance),
"5113" => Ok(Self::ExceedTxnAmountLimit),
"5114" => Ok(Self::BaidBalanceNotFound),
"5115" => Ok(Self::AutoUploadIndicatorNotFound),
"5116" => Ok(Self::InvalidBankAcctStatus),
"5117" => Ok(Self::InvalidAutoUploadIndicator),
"5118" => Ok(Self::InvalidPidStatus),
"5119" => Ok(Self::InvalidProviderStatus),
"5120" => Ok(Self::InvalidBankAccountSystemSwitchEnabled),
"5121" => Ok(Self::AutoUploadProviderDisabled),
"5122" => Ok(Self::AutoUploadBankNotFound),
"5123" => Ok(Self::AutoUploadBankAcctNotFound),
"5124" => Ok(Self::AutoUploadProviderNotFound),
"5125" => Ok(Self::UnsupportedBankCode),
"5126" => Ok(Self::BalanceOverrideIndicatorNotFound),
"5127" => Ok(Self::InvalidBalanceOverrideIndicator),
"10000" => Ok(Self::VernoInvalid),
"10001" => Ok(Self::ServiceCodeInvalid),
"10002" => Ok(Self::PspResponseSignatureIsNotValid),
"10003" => Ok(Self::ProcessTypeNotFound),
"10004" => Ok(Self::ProcessCodeNotFound),
"10005" => Ok(Self::EnctypeNotFound),
"10006" => Ok(Self::VernoNotFound),
"10007" => Ok(Self::DepositBankNotFound),
"10008" => Ok(Self::DepositFlowNotFound),
"10009" => Ok(Self::CustDepositDateNotFound),
"10010" => Ok(Self::CustTagNotFound),
"10011" => Ok(Self::CountryValueInvalid),
"10012" => Ok(Self::CurrencyCodeValueInvalid),
"10013" => Ok(Self::MerTxnDateInvalid),
"10014" => Ok(Self::CustDepositDateInvalid),
"10015" => Ok(Self::TxnAmtInvalid),
"10016" => Ok(Self::SuccessCallbackUrlInvalid),
"10017" => Ok(Self::DepositFlowInvalid),
"10018" => Ok(Self::ProcessTypeInvalid),
"10019" => Ok(Self::ProcessCodeInvalid),
"10020" => Ok(Self::UnsupportedMerRefLength),
"10021" => Ok(Self::DepositBankLengthOverLimit),
"10022" => Ok(Self::CustTagLengthOverLimit),
"10023" => Ok(Self::SignatureLengthOverLimit),
"10024" => Ok(Self::RequestContainInvalidTag),
"10025" => Ok(Self::RequestSignatureNotMatch),
"10026" => Ok(Self::InvalidCustomer),
"10027" => Ok(Self::SchemeNotFound),
"10028" => Ok(Self::PspResponseFieldsMissing),
"10029" => Ok(Self::PspResponseMerRefNotMatchWithRequestMerRef),
"10030" => Ok(Self::PspResponseMerIdNotMatchWithRequestMerId),
"10031" => Ok(Self::UpdateDepositFailAfterResponse),
"10032" => Ok(Self::UpdateUsedLimitTransactionCountFailAfterSuccessResponse),
"10033" => Ok(Self::UpdateCustomerLastDepositRecordAfterSuccessResponse),
"10034" => Ok(Self::CreateDepositFail),
"10035" => Ok(Self::CreateDepositMsgFail),
"10036" => Ok(Self::UpdateStatusSubStatusFail),
"10037" => Ok(Self::AddDepositRecordToSchemeAccount),
"10038" => Ok(Self::EmptyResponse),
"10039" => Ok(Self::AubConfirmErrorFromPh),
"10040" => Ok(Self::ProviderEmailAddressNotFound),
"10041" => Ok(Self::AubConnectionTimeout),
"10042" => Ok(Self::AubConnectionIssue),
"10043" => Ok(Self::AubMsgTypeMissing),
"10044" => Ok(Self::AubMsgCodeMissing),
"10045" => Ok(Self::AubVersionMissing),
"10046" => Ok(Self::AubEncTypeMissing),
"10047" => Ok(Self::AubSignMissing),
"10048" => Ok(Self::AubInfoMissing),
"10049" => Ok(Self::AubErrorCodeMissing),
"10050" => Ok(Self::AubMsgTypeInvalid),
"10051" => Ok(Self::AubMsgCodeInvalid),
"10052" => Ok(Self::AubBaidMissing),
"10053" => Ok(Self::AubResponseSignNotMatch),
"10054" => Ok(Self::SmsConnectionTimeout),
"10055" => Ok(Self::SmsConnectionIssue),
"10056" => Ok(Self::SmsConfirmErrorFromPh),
"10057" => Ok(Self::SmsMsgTypeMissing),
"10058" => Ok(Self::SmsMsgCodeMissing),
"10059" => Ok(Self::SmsVersionMissing),
"10060" => Ok(Self::SmsEncTypeMissing),
"10061" => Ok(Self::SmsSignMissing),
"10062" => Ok(Self::SmsInfoMissing),
"10063" => Ok(Self::SmsErrorCodeMissing),
"10064" => Ok(Self::SmsMsgTypeInvalid),
"10065" => Ok(Self::SmsMsgCodeInvalid),
"10066" => Ok(Self::SmsResponseSignNotMatch),
"10067" => Ok(Self::SmsRequestReachMaximumLimit),
"10068" => Ok(Self::SyncConnectionTimeout),
"10069" => Ok(Self::SyncConnectionIssue),
"10070" => Ok(Self::SyncConfirmErrorFromPh),
"10071" => Ok(Self::SyncMsgTypeMissing),
"10072" => Ok(Self::SyncMsgCodeMissing),
"10073" => Ok(Self::SyncVersionMissing),
"10074" => Ok(Self::SyncEncTypeMissing),
"10075" => Ok(Self::SyncSignMissing),
"10076" => Ok(Self::SyncInfoMissing),
"10077" => Ok(Self::SyncErrorCodeMissing),
"10078" => Ok(Self::SyncMsgTypeInvalid),
"10079" => Ok(Self::SyncMsgCodeInvalid),
"10080" => Ok(Self::SyncResponseSignNotMatch),
"10081" => Ok(Self::AccountExpired),
"10082" => Ok(Self::ExceedMaxMinAmount),
"10083" => Ok(Self::WholeNumberAmountLessThanOne),
"10084" => Ok(Self::AddDepositRecordToSchemeChannel),
"10085" => Ok(Self::UpdateUtilizedAmountFailAfterSuccessResponse),
"10086" => Ok(Self::PidResponseInvalidFormat),
"10087" => Ok(Self::PspNameNotFound),
"10088" => Ok(Self::LangIsMissing),
"10089" => Ok(Self::FailureCallbackUrlInvalid),
"10090" => Ok(Self::SuccessRedirectUrlInvalid),
"10091" => Ok(Self::FailureRedirectUrlInvalid),
"10092" => Ok(Self::LangValueInvalid),
"10093" => Ok(Self::OnlineDepositSessionTimeout),
"10094" => Ok(Self::AccessPaymentPageRouteFieldMissing),
"10095" => Ok(Self::AmountNotMatch),
"10096" => Ok(Self::PidCallbackFieldsMissing),
"10097" => Ok(Self::TokenNotMatch),
"10098" => Ok(Self::OperationDuplicated),
"10099" => Ok(Self::PayPageDomainNotAvailable),
"10100" => Ok(Self::PayPageConfirmSignatureNotMatch),
"10101" => Ok(Self::PaymentPageConfirmationFieldMissing),
"10102" => Ok(Self::MultipleCallbackFromPsp),
"10103" => Ok(Self::PidNotAvailable),
"10104" => Ok(Self::PidDepositUrlNotValidOrEmp),
"10105" => Ok(Self::PspSelfRedirectTagNotValid),
"20000" => Ok(Self::InternalError20000),
"20001" => Ok(Self::DepositTimeout),
_ => Err(errors::ConnectorError::ResponseHandlingFailed.into()),
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/zsl/transformers.rs" role="context" start="418" end="462">
fn try_from(
item: ResponseRouterData<F, ZslWebhookResponse, PaymentsSyncData, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
let paid_amount = item
.response
.consr_paid_amt
.parse::<i64>()
.change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
if item.response.status == "0" {
Ok(Self {
status: enums::AttemptStatus::Charged,
amount_captured: Some(paid_amount),
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(item.response.txn_id.clone()),
redirection_data: Box::new(None),
mandate_reference: Box::new(None),
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: Some(item.response.mer_ref.clone()),
incremental_authorization_allowed: None,
charges: None,
}),
..item.data
})
} else {
let error_reason =
ZslResponseStatus::try_from(item.response.status.clone())?.to_string();
Ok(Self {
status: enums::AttemptStatus::Failure,
response: Err(ErrorResponse {
code: item.response.status.clone(),
message: error_reason.clone(),
reason: Some(error_reason.clone()),
status_code: item.http_code,
attempt_status: Some(enums::AttemptStatus::Failure),
connector_transaction_id: Some(item.response.mer_ref.clone()),
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
}),
..item.data
})
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/zsl/transformers.rs" role="context" start="300" end="381">
fn try_from(
item: ResponseRouterData<F, ZslPaymentsResponse, T, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
if item.response.status.eq("0") && !item.response.txn_url.is_empty() {
let auth_type = ZslAuthType::try_from(&item.data.connector_auth_type)?;
let key: Secret<String> = auth_type.api_key;
let mer_id = auth_type.merchant_id;
let calculated_signature = calculate_signature(
item.response.enctype,
ZslSignatureType::ResponseSignature {
status: item.response.status.clone(),
txn_url: item.response.txn_url.clone(),
mer_ref: item.response.mer_ref.clone(),
mer_id: mer_id.clone().expose(),
key: key.expose(),
},
)?;
if calculated_signature.clone().eq(&item.response.signature) {
let decoded_redirect_url_bytes: Vec<u8> = base64::engine::general_purpose::STANDARD
.decode(item.response.txn_url.clone())
.change_context(errors::ConnectorError::RequestEncodingFailed)?;
let redirect_url = String::from_utf8(decoded_redirect_url_bytes)
.change_context(errors::ConnectorError::RequestEncodingFailed)?;
Ok(Self {
status: enums::AttemptStatus::AuthenticationPending, // Redirect is always expected after success response
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::NoResponseId,
redirection_data: Box::new(Some(RedirectForm::Form {
endpoint: redirect_url,
method: Method::Get,
form_fields: HashMap::new(),
})),
mandate_reference: Box::new(None),
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: Some(item.response.mer_ref.clone()),
incremental_authorization_allowed: None,
charges: None,
}),
..item.data
})
} else {
// When the signature check fails
Ok(Self {
status: enums::AttemptStatus::Failure,
response: Err(ErrorResponse {
code: NO_ERROR_CODE.to_string(),
message: auth_error::INVALID_SIGNATURE.to_string(),
reason: Some(auth_error::INVALID_SIGNATURE.to_string()),
status_code: item.http_code,
attempt_status: Some(enums::AttemptStatus::Failure),
connector_transaction_id: Some(item.response.mer_ref.clone()),
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
}),
..item.data
})
}
} else {
let error_reason =
ZslResponseStatus::try_from(item.response.status.clone())?.to_string();
Ok(Self {
status: enums::AttemptStatus::Failure,
response: Err(ErrorResponse {
code: item.response.status.clone(),
message: error_reason.clone(),
reason: Some(error_reason.clone()),
status_code: item.http_code,
attempt_status: Some(enums::AttemptStatus::Failure),
connector_transaction_id: Some(item.response.mer_ref.clone()),
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
}),
..item.data
})
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/zsl/transformers.rs" role="context" start="142" end="281">
fn try_from(
item: &ZslRouterData<&types::PaymentsAuthorizeRouterData>,
) -> Result<Self, Self::Error> {
let payment_method = match item.router_data.request.payment_method_data.clone() {
PaymentMethodData::BankTransfer(bank_transfer_data) => match *bank_transfer_data {
BankTransferData::LocalBankTransfer { bank_code } => Ok(
ZslPaymentMethods::LocalBankTransfer(LocalBankTransaferRequest {
bank_code,
pay_method: None,
}),
),
BankTransferData::AchBankTransfer { .. }
| BankTransferData::SepaBankTransfer { .. }
| BankTransferData::BacsBankTransfer { .. }
| BankTransferData::MultibancoBankTransfer { .. }
| BankTransferData::PermataBankTransfer { .. }
| BankTransferData::BcaBankTransfer { .. }
| BankTransferData::BniVaBankTransfer { .. }
| BankTransferData::BriVaBankTransfer { .. }
| BankTransferData::CimbVaBankTransfer { .. }
| BankTransferData::DanamonVaBankTransfer { .. }
| BankTransferData::MandiriVaBankTransfer { .. }
| BankTransferData::Pix { .. }
| BankTransferData::Pse {}
| BankTransferData::InstantBankTransfer {} => {
Err(errors::ConnectorError::NotImplemented(
get_unimplemented_payment_method_error_message(
item.router_data.connector.as_str(),
),
))
}
},
PaymentMethodData::Card(_)
| PaymentMethodData::CardRedirect(_)
| PaymentMethodData::Wallet(_)
| PaymentMethodData::PayLater(_)
| PaymentMethodData::BankRedirect(_)
| PaymentMethodData::BankDebit(_)
| PaymentMethodData::Crypto(_)
| PaymentMethodData::MandatePayment
| PaymentMethodData::Reward
| PaymentMethodData::RealTimePayment(_)
| PaymentMethodData::MobilePayment(_)
| PaymentMethodData::Upi(_)
| PaymentMethodData::Voucher(_)
| PaymentMethodData::GiftCard(_)
| PaymentMethodData::CardToken(_)
| PaymentMethodData::NetworkToken(_)
| PaymentMethodData::CardDetailsForNetworkTransactionId(_)
| PaymentMethodData::OpenBanking(_) => Err(errors::ConnectorError::NotImplemented(
get_unimplemented_payment_method_error_message(item.router_data.connector.as_str()),
)),
}?;
let auth_type = ZslAuthType::try_from(&item.router_data.connector_auth_type)?;
let key: Secret<String> = auth_type.api_key;
let mer_id = auth_type.merchant_id;
let mer_txn_date =
date_time::format_date(date_time::now(), date_time::DateFormat::YYYYMMDDHHmmss)
.change_context(errors::ConnectorError::RequestEncodingFailed)?;
let txn_amt = item.amount.clone();
let ccy = item.router_data.request.currency;
let mer_ref = item.router_data.connector_request_reference_id.clone();
let signature = calculate_signature(
EncodingType::MD5,
ZslSignatureType::RequestSignature {
txn_amt: txn_amt.clone(),
ccy: ccy.to_string(),
mer_ref: mer_ref.clone(),
mer_id: mer_id.clone().expose(),
mer_txn_date: mer_txn_date.clone(),
key: key.expose(),
},
)?;
let tel_phone = item.router_data.get_optional_billing_phone_number();
let email = item.router_data.get_optional_billing_email();
let name = item.router_data.get_optional_billing_first_name();
let family_name = item.router_data.get_optional_billing_last_name();
let router_url = item.router_data.request.get_router_return_url()?;
let webhook_url = item.router_data.request.get_webhook_url()?;
let billing_country = item.router_data.get_billing_country()?;
let lang = item
.router_data
.request
.browser_info
.as_ref()
.and_then(|browser_data| {
browser_data.language.as_ref().map(|language| {
language
.split_once('-')
.map_or(language.to_uppercase(), |(lang, _)| lang.to_uppercase())
})
})
.ok_or(errors::ConnectorError::MissingRequiredField {
field_name: "browser_info.language",
})?;
let cust_tag = item
.router_data
.customer_id
.clone()
.and_then(|customer_id| {
let cust_id = customer_id.get_string_repr().replace(['_', '-'], "");
let id_len = cust_id.len();
if id_len > 10 {
cust_id.get(id_len - 10..id_len).map(|id| id.to_string())
} else {
Some(cust_id)
}
})
.ok_or(errors::ConnectorError::MissingRequiredField {
field_name: "customer_id",
})?;
Ok(Self {
process_type: ProcessType::PaymentRequest,
process_code: ProcessCode::API,
txn_amt,
ccy,
mer_ref,
mer_txn_date,
mer_id,
lang,
success_url: router_url.clone(),
failure_url: router_url.clone(),
success_s2s_url: webhook_url.clone(),
failure_s2s_url: webhook_url.clone(),
enctype: EncodingType::MD5,
signature,
verno: zsl_version::VERSION_1.to_owned(),
service_code: ServiceCode::MPG,
country: billing_country,
payment_method,
name,
family_name,
tel_phone,
email,
cust_tag,
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/zsl/transformers.rs" role="context" start="867" end="893">
pub enum ZslSignatureType {
RequestSignature {
txn_amt: String,
ccy: String,
mer_ref: String,
mer_id: String,
mer_txn_date: String,
key: String,
},
ResponseSignature {
status: String,
txn_url: String,
mer_ref: String,
mer_id: String,
key: String,
},
WebhookSignature {
status: String,
txn_id: String,
txn_date: String,
paid_ccy: String,
paid_amt: String,
mer_ref: String,
mer_id: String,
key: String,
},
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/zsl/transformers.rs" role="context" start="127" end="132">
pub enum EncodingType {
#[serde(rename = "1")]
MD5,
#[serde(rename = "2")]
Sha1,
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/hyperswitch_connectors/src/connectors/nuvei/transformers.rs<|crate|> hyperswitch_connectors<|connector|> nuvei anchor=get_payment_status 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="1508" end="1539">
fn get_payment_status(response: &NuveiPaymentsResponse) -> enums::AttemptStatus {
match response.transaction_status.clone() {
Some(status) => match status {
NuveiTransactionStatus::Approved => match response.transaction_type {
Some(NuveiTransactionType::Auth) => enums::AttemptStatus::Authorized,
Some(NuveiTransactionType::Sale) | Some(NuveiTransactionType::Settle) => {
enums::AttemptStatus::Charged
}
Some(NuveiTransactionType::Void) => enums::AttemptStatus::Voided,
_ => enums::AttemptStatus::Pending,
},
NuveiTransactionStatus::Declined | NuveiTransactionStatus::Error => {
match response.transaction_type {
Some(NuveiTransactionType::Auth) => enums::AttemptStatus::AuthorizationFailed,
Some(NuveiTransactionType::Void) => enums::AttemptStatus::VoidFailed,
Some(NuveiTransactionType::Auth3D) => {
enums::AttemptStatus::AuthenticationFailed
}
_ => enums::AttemptStatus::Failure,
}
}
NuveiTransactionStatus::Processing | NuveiTransactionStatus::Pending => {
enums::AttemptStatus::Pending
}
NuveiTransactionStatus::Redirect => enums::AttemptStatus::AuthenticationPending,
},
None => match response.status {
NuveiPaymentStatus::Failed | NuveiPaymentStatus::Error => enums::AttemptStatus::Failure,
_ => enums::AttemptStatus::Pending,
},
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/nuvei/transformers.rs" role="context" start="1507" end="1507">
use common_enums::enums;
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="1583" end="1653">
fn try_from(
item: ResponseRouterData<F, NuveiPaymentsResponse, T, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
let redirection_data = match item.data.payment_method {
enums::PaymentMethod::Wallet | enums::PaymentMethod::BankRedirect => item
.response
.payment_option
.as_ref()
.and_then(|po| po.redirect_url.clone())
.map(|base_url| RedirectForm::from((base_url, Method::Get))),
_ => item
.response
.payment_option
.as_ref()
.and_then(|o| o.card.clone())
.and_then(|card| card.three_d)
.and_then(|three_ds| three_ds.acs_url.zip(three_ds.c_req))
.map(|(base_url, creq)| RedirectForm::Form {
endpoint: base_url,
method: Method::Post,
form_fields: std::collections::HashMap::from([(
"creq".to_string(),
creq.expose(),
)]),
}),
};
let response = item.response;
Ok(Self {
status: get_payment_status(&response),
response: if let Some(err) = build_error_response(&response, item.http_code) {
err
} else {
Ok(PaymentsResponseData::TransactionResponse {
resource_id: response
.transaction_id
.map_or(response.order_id.clone(), Some) // For paypal there will be no transaction_id, only order_id will be present
.map(ResponseId::ConnectorTransactionId)
.ok_or(errors::ConnectorError::MissingConnectorTransactionID)?,
redirection_data: Box::new(redirection_data),
mandate_reference: Box::new(
response
.payment_option
.and_then(|po| po.user_payment_option_id)
.map(|id| MandateReference {
connector_mandate_id: Some(id),
payment_method_id: None,
mandate_metadata: None,
connector_mandate_request_reference_id: None,
}),
),
// we don't need to save session token for capture, void flow so ignoring if it is not present
connector_metadata: if let Some(token) = response.session_token {
Some(
serde_json::to_value(NuveiMeta {
session_token: token,
})
.change_context(errors::ConnectorError::ResponseHandlingFailed)?,
)
} else {
None
},
network_txn_id: None,
connector_response_reference_id: response.order_id,
incremental_authorization_allowed: None,
charges: None,
})
},
..item.data
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/nuvei/transformers.rs" role="context" start="1541" end="1567">
fn build_error_response<T>(
response: &NuveiPaymentsResponse,
http_code: u16,
) -> Option<Result<T, ErrorResponse>> {
match response.status {
NuveiPaymentStatus::Error => Some(
get_error_response(response.err_code, &response.reason, http_code).map_err(|err| *err),
),
_ => {
let err = Some(
get_error_response(response.gw_error_code, &response.gw_error_reason, http_code)
.map_err(|err| *err),
);
match response.transaction_status {
Some(NuveiTransactionStatus::Error) | Some(NuveiTransactionStatus::Declined) => err,
_ => match response
.gw_error_reason
.as_ref()
.map(|r| r.eq("Missing argument"))
{
Some(true) => err,
_ => None,
},
}
}
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/nuvei/transformers.rs" role="context" start="1450" end="1456">
fn from(item: NuveiTransactionStatus) -> Self {
match item {
NuveiTransactionStatus::Approved => Self::Charged,
NuveiTransactionStatus::Declined | NuveiTransactionStatus::Error => Self::Failure,
_ => Self::Pending,
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/nuvei/transformers.rs" role="context" start="1409" end="1424">
fn try_from(auth_type: &ConnectorAuthType) -> Result<Self, Self::Error> {
if let ConnectorAuthType::SignatureKey {
api_key,
key1,
api_secret,
} = auth_type
{
Ok(Self {
merchant_id: api_key.to_owned(),
merchant_site_id: key1.to_owned(),
merchant_secret: api_secret.to_owned(),
})
} else {
Err(errors::ConnectorError::FailedToObtainAuthType)?
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/nuvei/transformers.rs" role="context" start="1660" end="1680">
fn try_from(
item: PaymentsPreprocessingResponseRouterData<NuveiPaymentsResponse>,
) -> Result<Self, Self::Error> {
let response = item.response;
let is_enrolled_for_3ds = response
.clone()
.payment_option
.and_then(|po| po.card)
.and_then(|c| c.three_d)
.and_then(|t| t.v2supported)
.map(to_boolean)
.unwrap_or_default();
Ok(Self {
status: get_payment_status(&response),
response: Ok(PaymentsResponseData::ThreeDSEnrollmentResponse {
enrolled_v2: is_enrolled_for_3ds,
related_transaction_id: response.transaction_id,
}),
..item.data
})
}
<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="1492" end="1500">
pub enum NuveiTransactionType {
Auth,
Sale,
Credit,
Auth3D,
InitAuth3D,
Settle,
Void,
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/shift4/transformers.rs" role="context" start="723" end="725">
pub struct Redirect {
pub redirect_url: Option<Url>,
}
<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/cybersource/transformers.rs<|crate|> hyperswitch_connectors<|connector|> cybersource 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/cybersource/transformers.rs" role="context" start="3822" end="3875">
fn try_from(
item: RefundsResponseRouterData<RSync, CybersourceRsyncResponse>,
) -> Result<Self, Self::Error> {
let response = match item
.response
.application_information
.and_then(|application_information| application_information.status)
{
Some(status) => {
let refund_status = enums::RefundStatus::from(status.clone());
if utils::is_refund_failure(refund_status) {
if status == CybersourceRefundStatus::Voided {
Err(get_error_response(
&Some(CybersourceErrorInformation {
message: Some(constants::REFUND_VOIDED.to_string()),
reason: Some(constants::REFUND_VOIDED.to_string()),
details: None,
}),
&None,
None,
item.http_code,
item.response.id.clone(),
))
} else {
Err(get_error_response(
&item.response.error_information,
&None,
None,
item.http_code,
item.response.id.clone(),
))
}
} else {
Ok(RefundsResponseData {
connector_refund_id: item.response.id,
refund_status,
})
}
}
None => Ok(RefundsResponseData {
connector_refund_id: item.response.id.clone(),
refund_status: match item.data.response {
Ok(response) => response.refund_status,
Err(_) => common_enums::RefundStatus::Pending,
},
}),
};
Ok(Self {
response,
..item.data
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/cybersource/transformers.rs" role="context" start="3821" end="3821">
#[derive(Debug, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct CybersourceRsyncResponse {
id: String,
application_information: Option<RsyncApplicationInformation>,
error_information: Option<CybersourceErrorInformation>,
}
impl TryFrom<RefundsResponseRouterData<RSync, CybersourceRsyncResponse>>
for RefundsRouterData<RSync>
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: RefundsResponseRouterData<RSync, CybersourceRsyncResponse>,
) -> Result<Self, Self::Error> {
let response = match item
.response
.application_information
.and_then(|application_information| application_information.status)
{
Some(status) => {
let refund_status = enums::RefundStatus::from(status.clone());
if utils::is_refund_failure(refund_status) {
if status == CybersourceRefundStatus::Voided {
Err(get_error_response(
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/cybersource/transformers.rs" role="context" start="4005" end="4030">
fn try_from(item: (&AddressDetails, &PhoneDetails)) -> Result<Self, Self::Error> {
let (billing_address, phone_address) = item;
Ok(Self {
first_name: billing_address.get_first_name()?.to_owned(),
last_name: billing_address.get_last_name()?.to_owned(),
address1: billing_address.get_line1()?.to_owned(),
locality: billing_address.get_city()?.to_owned(),
administrative_area: {
billing_address
.to_state_code_as_optional()
.unwrap_or_else(|_| {
billing_address
.state
.remove_new_line()
.as_ref()
.map(|state| truncate_string(state, 20)) //NOTE: Cybersource connector throws error if billing state exceeds 20 characters, so truncation is done to avoid payment failure
})
.ok_or_else(|| errors::ConnectorError::MissingRequiredField {
field_name: "billing_address.state",
})?
},
postal_code: billing_address.get_zip()?.to_owned(),
country: billing_address.get_country()?.to_owned(),
phone_number: phone_address.number.clone(),
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/cybersource/transformers.rs" role="context" start="3947" end="3999">
fn try_from(
item: &CybersourceRouterData<&PayoutsRouterData<PoFulfill>>,
) -> Result<Self, Self::Error> {
let payout_type = item.router_data.request.get_payout_type()?;
match payout_type {
enums::PayoutType::Card => {
let client_reference_information = ClientReferenceInformation {
code: Some(item.router_data.request.payout_id.clone()),
};
let order_information = OrderInformation {
amount_details: Amount {
total_amount: item.amount.to_owned(),
currency: item.router_data.request.destination_currency,
},
};
let billing_address = item.router_data.get_billing_address()?;
let phone_address = item.router_data.get_billing_phone()?;
let recipient_information =
CybersourceRecipientInfo::try_from((billing_address, phone_address))?;
let sender_information = CybersourceSenderInfo {
reference_number: item.router_data.request.payout_id.clone(),
account: CybersourceAccountInfo {
funds_source: CybersourcePayoutFundSourceType::Disbursement,
},
};
let processing_information = CybersourceProcessingInfo {
business_application_id: CybersourcePayoutBusinessType::PersonToPerson, // this means sender and receiver are different
};
let payout_method_data = item.router_data.get_payout_method_data()?;
let payment_information = PaymentInformation::try_from(payout_method_data)?;
Ok(Self {
client_reference_information,
order_information,
recipient_information,
sender_information,
processing_information,
payment_information,
})
}
enums::PayoutType::Bank | enums::PayoutType::Wallet => {
Err(errors::ConnectorError::NotSupported {
message: "PayoutType is not supported".to_string(),
connector: "Cybersource",
})?
}
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/cybersource/transformers.rs" role="context" start="3778" end="3801">
fn try_from(
item: RefundsResponseRouterData<Execute, CybersourceRefundResponse>,
) -> Result<Self, Self::Error> {
let refund_status = enums::RefundStatus::from(item.response.status.clone());
let response = if utils::is_refund_failure(refund_status) {
Err(get_error_response(
&item.response.error_information,
&None,
None,
item.http_code,
item.response.id.clone(),
))
} else {
Ok(RefundsResponseData {
connector_refund_id: item.response.id,
refund_status: enums::RefundStatus::from(item.response.status),
})
};
Ok(Self {
response,
..item.data
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/cybersource/transformers.rs" role="context" start="3742" end="3752">
fn from(item: CybersourceRefundStatus) -> Self {
match item {
CybersourceRefundStatus::Succeeded | CybersourceRefundStatus::Transmitted => {
Self::Success
}
CybersourceRefundStatus::Cancelled
| CybersourceRefundStatus::Failed
| CybersourceRefundStatus::Voided => Self::Failure,
CybersourceRefundStatus::Pending => Self::Pending,
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/cybersource/transformers.rs" role="context" start="4181" end="4241">
pub fn get_error_response(
error_data: &Option<CybersourceErrorInformation>,
risk_information: &Option<ClientRiskInformation>,
attempt_status: Option<enums::AttemptStatus>,
status_code: u16,
transaction_id: String,
) -> ErrorResponse {
let avs_message = risk_information
.clone()
.map(|client_risk_information| {
client_risk_information.rules.map(|rules| {
rules
.iter()
.map(|risk_info| {
risk_info.name.clone().map_or("".to_string(), |name| {
format!(" , {}", name.clone().expose())
})
})
.collect::<Vec<String>>()
.join("")
})
})
.unwrap_or(Some("".to_string()));
let detailed_error_info = error_data.as_ref().and_then(|error_data| {
error_data.details.as_ref().map(|details| {
details
.iter()
.map(|detail| format!("{} : {}", detail.field, detail.reason))
.collect::<Vec<_>>()
.join(", ")
})
});
let reason = get_error_reason(
error_data
.as_ref()
.and_then(|error_info| error_info.message.clone()),
detailed_error_info,
avs_message,
);
let error_message = error_data
.as_ref()
.and_then(|error_info| error_info.reason.clone());
ErrorResponse {
code: error_message
.clone()
.unwrap_or_else(|| hyperswitch_interfaces::consts::NO_ERROR_CODE.to_string()),
message: error_message
.unwrap_or_else(|| hyperswitch_interfaces::consts::NO_ERROR_MESSAGE.to_string()),
reason,
status_code,
attempt_status,
connector_transaction_id: Some(transaction_id),
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/cybersource/transformers.rs" role="context" start="109" end="109">
type Error = error_stack::Report<errors::ConnectorError>;
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/cybersource/transformers.rs" role="context" start="3812" end="3816">
pub struct CybersourceRsyncResponse {
id: String,
application_information: Option<RsyncApplicationInformation>,
error_information: Option<CybersourceErrorInformation>,
}
<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/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/deutschebank/transformers.rs<|crate|> hyperswitch_connectors<|connector|> deutschebank 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/deutschebank/transformers.rs" role="context" start="1021" end="1067">
fn try_from(
item: ResponseRouterData<
PSync,
DeutschebankPaymentsResponse,
PaymentsSyncData,
PaymentsResponseData,
>,
) -> Result<Self, Self::Error> {
let response_code = item.response.rc.clone();
let status = if is_response_success(&response_code) {
item.response
.tx_action
.and_then(|tx_action| match tx_action {
DeutschebankTXAction::Preauthorization => {
Some(common_enums::AttemptStatus::Authorized)
}
DeutschebankTXAction::Authorization | DeutschebankTXAction::Capture => {
Some(common_enums::AttemptStatus::Charged)
}
DeutschebankTXAction::Credit
| DeutschebankTXAction::Refund
| DeutschebankTXAction::Reversal
| DeutschebankTXAction::RiskCheck
| DeutschebankTXAction::VerifyMop
| DeutschebankTXAction::Payment
| DeutschebankTXAction::AccountInformation => None,
})
} else {
Some(common_enums::AttemptStatus::Failure)
};
match status {
Some(common_enums::AttemptStatus::Failure) => Ok(Self {
status: common_enums::AttemptStatus::Failure,
response: Err(get_error_response(
response_code.clone(),
item.response.message.clone(),
item.http_code,
)),
..item.data
}),
Some(status) => Ok(Self {
status,
..item.data
}),
None => Ok(Self { ..item.data }),
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/deutschebank/transformers.rs" role="context" start="1020" end="1020">
use common_enums::{enums, PaymentMethod};
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,
},
};
use crate::{
types::{PaymentsCancelResponseRouterData, RefundsResponseRouterData, ResponseRouterData},
utils::{
self, AddressDetailsData, CardData, PaymentsAuthorizeRequestData,
PaymentsCompleteAuthorizeRequestData, RefundsRequestData, RouterData as OtherRouterData,
},
};
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/deutschebank/transformers.rs" role="context" start="1099" end="1119">
fn try_from(
item: PaymentsCancelResponseRouterData<DeutschebankPaymentsResponse>,
) -> Result<Self, Self::Error> {
let response_code = item.response.rc.clone();
if is_response_success(&response_code) {
Ok(Self {
status: common_enums::AttemptStatus::Voided,
..item.data
})
} else {
Ok(Self {
status: common_enums::AttemptStatus::VoidFailed,
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="1077" end="1092">
fn try_from(item: &PaymentsCancelRouterData) -> Result<Self, Self::Error> {
if matches!(item.payment_method, PaymentMethod::BankDebit) {
Ok(Self {
kind: DeutschebankTransactionKind::Directdebit,
})
} else if item.is_three_ds() && matches!(item.payment_method, PaymentMethod::Card) {
Ok(Self {
kind: DeutschebankTransactionKind::Creditcard3ds20,
})
} else {
Err(errors::ConnectorError::NotImplemented(
utils::get_unimplemented_payment_method_error_message("deutschebank"),
)
.into())
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/deutschebank/transformers.rs" role="context" start="972" end="1007">
fn try_from(
item: ResponseRouterData<
Capture,
DeutschebankPaymentsResponse,
PaymentsCaptureData,
PaymentsResponseData,
>,
) -> Result<Self, Self::Error> {
let response_code = item.response.rc.clone();
if is_response_success(&response_code) {
Ok(Self {
status: common_enums::AttemptStatus::Charged,
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/deutschebank/transformers.rs" role="context" start="937" end="958">
fn try_from(
item: &DeutschebankRouterData<&PaymentsCaptureRouterData>,
) -> Result<Self, Self::Error> {
if matches!(item.router_data.payment_method, PaymentMethod::BankDebit) {
Ok(Self {
changed_amount: item.amount,
kind: DeutschebankTransactionKind::Directdebit,
})
} else if item.router_data.is_three_ds()
&& matches!(item.router_data.payment_method, PaymentMethod::Card)
{
Ok(Self {
changed_amount: item.amount,
kind: DeutschebankTransactionKind::Creditcard3ds20,
})
} else {
Err(errors::ConnectorError::NotImplemented(
utils::get_unimplemented_payment_method_error_message("deutschebank"),
)
.into())
}
}
<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="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="59" end="59">
type Error = error_stack::Report<errors::ConnectorError>;
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/deutschebank/transformers.rs" role="context" start="855" end="867">
pub struct DeutschebankPaymentsResponse {
rc: String,
message: String,
timestamp: String,
back_ext_id: Option<String>,
back_rc: Option<String>,
event_id: Option<String>,
kind: Option<String>,
tx_action: Option<DeutschebankTXAction>,
tx_id: String,
amount_total: Option<DeutschebankAmount>,
transaction_info: Option<DeutschebankTransactionInfo>,
}
<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);
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/hyperswitch_connectors/src/connectors/deutschebank/transformers.rs<|crate|> hyperswitch_connectors<|connector|> deutschebank 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/deutschebank/transformers.rs" role="context" start="1186" end="1229">
fn try_from(
item: RefundsResponseRouterData<RSync, DeutschebankPaymentsResponse>,
) -> Result<Self, Self::Error> {
let response_code = item.response.rc.clone();
let status = if is_response_success(&response_code) {
item.response
.tx_action
.and_then(|tx_action| match tx_action {
DeutschebankTXAction::Credit | DeutschebankTXAction::Refund => {
Some(enums::RefundStatus::Success)
}
DeutschebankTXAction::Preauthorization
| DeutschebankTXAction::Authorization
| DeutschebankTXAction::Capture
| DeutschebankTXAction::Reversal
| DeutschebankTXAction::RiskCheck
| DeutschebankTXAction::VerifyMop
| DeutschebankTXAction::Payment
| DeutschebankTXAction::AccountInformation => None,
})
} else {
Some(enums::RefundStatus::Failure)
};
match status {
Some(enums::RefundStatus::Failure) => Ok(Self {
status: common_enums::AttemptStatus::Failure,
response: Err(get_error_response(
response_code.clone(),
item.response.message.clone(),
item.http_code,
)),
..item.data
}),
Some(refund_status) => Ok(Self {
response: Ok(RefundsResponseData {
refund_status,
connector_refund_id: item.data.request.get_connector_refund_id()?,
}),
..item.data
}),
None => Ok(Self { ..item.data }),
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/deutschebank/transformers.rs" role="context" start="1185" end="1185">
use common_enums::{enums, PaymentMethod};
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,
},
};
use crate::{
types::{PaymentsCancelResponseRouterData, RefundsResponseRouterData, ResponseRouterData},
utils::{
self, AddressDetailsData, CardData, PaymentsAuthorizeRequestData,
PaymentsCompleteAuthorizeRequestData, RefundsRequestData, RouterData as OtherRouterData,
},
};
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/deutschebank/transformers.rs" role="context" start="1156" end="1179">
fn try_from(
item: RefundsResponseRouterData<Execute, DeutschebankPaymentsResponse>,
) -> Result<Self, Self::Error> {
let response_code = item.response.rc.clone();
if is_response_success(&response_code) {
Ok(Self {
response: Ok(RefundsResponseData {
connector_refund_id: item.response.tx_id,
refund_status: enums::RefundStatus::Success,
}),
..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/deutschebank/transformers.rs" role="context" start="1130" end="1149">
fn try_from(item: &DeutschebankRouterData<&RefundsRouterData<F>>) -> Result<Self, Self::Error> {
if matches!(item.router_data.payment_method, PaymentMethod::BankDebit) {
Ok(Self {
changed_amount: item.amount,
kind: DeutschebankTransactionKind::Directdebit,
})
} else if item.router_data.is_three_ds()
&& matches!(item.router_data.payment_method, PaymentMethod::Card)
{
Ok(Self {
changed_amount: item.amount,
kind: DeutschebankTransactionKind::Creditcard3ds20,
})
} else {
Err(errors::ConnectorError::NotImplemented(
utils::get_unimplemented_payment_method_error_message("deutschebank"),
)
.into())
}
}
<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="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="59" end="59">
type Error = error_stack::Report<errors::ConnectorError>;
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/deutschebank/transformers.rs" role="context" start="855" end="867">
pub struct DeutschebankPaymentsResponse {
rc: String,
message: String,
timestamp: String,
back_ext_id: Option<String>,
back_rc: Option<String>,
event_id: Option<String>,
kind: Option<String>,
tx_action: Option<DeutschebankTXAction>,
tx_id: String,
amount_total: Option<DeutschebankAmount>,
transaction_info: Option<DeutschebankTransactionInfo>,
}
<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="378" end="384">
pub enum RefundStatus {
Succeeded,
Failed,
#[default]
Pending,
Review,
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/hyperswitch_connectors/src/connectors/getnet/transformers.rs<|crate|> hyperswitch_connectors<|connector|> getnet 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/getnet/transformers.rs" role="context" start="466" end="513">
fn try_from(
item: PaymentsSyncResponseRouterData<GetnetPaymentsResponse>,
) -> Result<Self, Self::Error> {
match item.response {
GetnetPaymentsResponse::PaymentsResponse(ref payment_response) => Ok(Self {
status: authorization_attempt_status_from_transaction_state(
payment_response.payment.transaction_state.clone(),
item.data.request.is_auto_capture()?,
),
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(
payment_response.payment.transaction_id.clone(),
),
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
}),
GetnetPaymentsResponse::GetnetWebhookNotificationResponse(ref webhook_response) => {
Ok(Self {
status: psync_attempt_status_from_transaction_state(
webhook_response.payment.transaction_state.clone(),
item.data.request.is_auto_capture()?,
webhook_response.payment.transaction_type.clone(),
),
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(
webhook_response.payment.transaction_id.clone(),
),
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
})
}
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/getnet/transformers.rs" role="context" start="465" end="465">
use hyperswitch_domain_models::{
payment_method_data::PaymentMethodData,
router_data::{ConnectorAuthType, RouterData},
router_flow_types::refunds::{Execute, RSync},
router_request_types::{
PaymentsAuthorizeData, PaymentsCancelData, PaymentsCaptureData, ResponseId,
},
router_response_types::{PaymentsResponseData, RefundsResponseData},
types::{
PaymentsAuthorizeRouterData, PaymentsCancelRouterData, PaymentsCaptureRouterData,
PaymentsSyncRouterData, RefundsRouterData,
},
};
use crate::{
connectors::paybox::transformers::parse_url_encoded_to_struct,
types::{PaymentsSyncResponseRouterData, RefundsResponseRouterData, ResponseRouterData},
utils::{
BrowserInformationData, PaymentsAuthorizeRequestData, PaymentsSyncRequestData,
RouterData as _,
},
};
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/getnet/transformers.rs" role="context" start="628" end="634">
pub fn capture_status_from_transaction_state(getnet_status: GetnetPaymentStatus) -> AttemptStatus {
match getnet_status {
GetnetPaymentStatus::Success => AttemptStatus::Charged,
GetnetPaymentStatus::InProgress => AttemptStatus::Pending,
GetnetPaymentStatus::Failed => AttemptStatus::Authorized,
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/getnet/transformers.rs" role="context" start="539" end="581">
fn try_from(item: &GetnetRouterData<&PaymentsCaptureRouterData>) -> Result<Self, Self::Error> {
let request = &item.router_data.request;
let auth_type = GetnetAuthType::try_from(&item.router_data.connector_auth_type)
.change_context(errors::ConnectorError::FailedToObtainAuthType)?;
let merchant_account_id = MerchantAccountId {
value: auth_type.merchant_id,
};
let requested_amount = Amount {
value: item.amount,
currency: request.currency,
};
let req = &item.router_data.request;
let webhook_url = &req.webhook_url;
let notifications = NotificationContainer {
format: NotificationFormat::JsonSigned,
notification: vec![Notification {
url: webhook_url.clone(),
}],
};
let transaction_type = GetnetTransactionType::CaptureAuthorization;
let ip_address = req
.browser_info
.as_ref()
.and_then(|info| info.ip_address.as_ref())
.map(|ip| Secret::new(ip.to_string()));
let request_id = item.router_data.connector_request_reference_id.clone();
let parent_transaction_id = item.router_data.request.connector_transaction_id.clone();
let capture_payment_data = CapturePaymentData {
merchant_account_id,
request_id,
transaction_type,
parent_transaction_id,
requested_amount,
notifications,
ip_address,
};
Ok(Self {
payment: capture_payment_data,
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/getnet/transformers.rs" role="context" start="446" end="462">
pub fn psync_attempt_status_from_transaction_state(
getnet_status: GetnetPaymentStatus,
is_auto_capture: bool,
transaction_type: GetnetTransactionType,
) -> AttemptStatus {
match getnet_status {
GetnetPaymentStatus::Success => {
if is_auto_capture && transaction_type == GetnetTransactionType::CaptureAuthorization {
AttemptStatus::Charged
} else {
AttemptStatus::Authorized
}
}
GetnetPaymentStatus::InProgress => AttemptStatus::Pending,
GetnetPaymentStatus::Failed => AttemptStatus::Failure,
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/getnet/transformers.rs" role="context" start="410" end="443">
fn try_from(
item: ResponseRouterData<
F,
GetnetPaymentsResponse,
PaymentsAuthorizeData,
PaymentsResponseData,
>,
) -> Result<Self, Self::Error> {
match item.response {
GetnetPaymentsResponse::PaymentsResponse(ref payment_response) => Ok(Self {
status: authorization_attempt_status_from_transaction_state(
payment_response.payment.transaction_state.clone(),
item.data.request.is_auto_capture()?,
),
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(
payment_response.payment.transaction_id.clone(),
),
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
}),
_ => Err(error_stack::Report::new(
errors::ConnectorError::ResponseHandlingFailed,
)),
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/getnet/transformers.rs" role="context" start="387" end="402">
pub fn authorization_attempt_status_from_transaction_state(
getnet_status: GetnetPaymentStatus,
is_auto_capture: bool,
) -> AttemptStatus {
match getnet_status {
GetnetPaymentStatus::Success => {
if is_auto_capture {
AttemptStatus::Charged
} else {
AttemptStatus::Authorized
}
}
GetnetPaymentStatus::InProgress => AttemptStatus::Pending,
GetnetPaymentStatus::Failed => AttemptStatus::Failure,
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/getnet/transformers.rs" role="context" start="1010" end="1017">
pub struct GetnetWebhookNotificationResponse {
#[serde(rename = "response-signature-base64")]
pub response_signature_base64: Secret<String>,
#[serde(rename = "response-signature-algorithm")]
pub response_signature_algorithm: Secret<String>,
#[serde(rename = "response-base64")]
pub response_base64: Secret<String>,
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/getnet/transformers.rs" role="context" start="174" end="174">
type Error = error_stack::Report<errors::ConnectorError>;
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/klarna/transformers.rs" role="context" start="120" end="124">
pub struct PaymentsResponse {
order_id: String,
fraud_status: KlarnaFraudStatus,
authorized_payment_method: Option<AuthorizedPaymentMethod>,
}
<file_sep path="hyperswitch/crates/api_models/src/payments.rs" role="context" start="4748" end="5106">
pub struct PaymentsResponse {
/// Unique identifier for the payment. This ensures idempotency for multiple payments
/// that have been done by a single merchant.
#[schema(
min_length = 30,
max_length = 30,
example = "pay_mbabizu24mvu3mela5njyhpit4",
value_type = String,
)]
pub payment_id: id_type::PaymentId,
/// 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 = String)]
pub merchant_id: id_type::MerchantId,
#[schema(value_type = IntentStatus, example = "failed", default = "requires_confirmation")]
pub status: api_enums::IntentStatus,
/// The 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, example = 6540)]
pub amount: MinorUnit,
/// The payment net amount. net_amount = amount + surcharge_details.surcharge_amount + surcharge_details.tax_amount + shipping_cost + order_tax_amount,
/// If no surcharge_details, shipping_cost, order_tax_amount, net_amount = amount
#[schema(value_type = i64, example = 6540)]
pub net_amount: MinorUnit,
/// The shipping cost for the payment.
#[schema(value_type = Option<i64>, example = 6540)]
pub shipping_cost: Option<MinorUnit>,
/// The maximum amount that could be captured from the payment
#[schema(value_type = i64, minimum = 100, example = 6540)]
pub amount_capturable: MinorUnit,
/// The amount which is already captured from the payment, this helps in the cases where merchants can't capture all capturable amount at once.
#[schema(value_type = Option<i64>, example = 6540)]
pub amount_received: Option<MinorUnit>,
/// The connector used for the payment
#[schema(example = "stripe")]
pub connector: Option<String>,
/// It's a token used for client side verification.
#[schema(value_type = Option<String>, example = "pay_U42c409qyHwOkWo3vK60_secret_el9ksDkiB8hi6j9N78yo")]
pub client_secret: Option<Secret<String>>,
/// Time when the payment was created
#[schema(example = "2022-09-10T10:11:12Z")]
#[serde(with = "common_utils::custom_serde::iso8601::option")]
pub created: Option<PrimitiveDateTime>,
/// The currency of the amount of the payment
#[schema(value_type = Currency, example = "USD")]
pub currency: String,
/// The identifier for the customer object. If not provided the customer ID will be autogenerated.
/// This field will be deprecated soon. Please refer to `customer.id`
#[schema(
max_length = 64,
min_length = 1,
example = "cus_y3oqhf46pyzuxjbcn2giaqnb44",
deprecated,
value_type = Option<String>,
)]
pub customer_id: Option<id_type::CustomerId>,
pub customer: Option<CustomerDetailsResponse>,
/// A description of the payment
#[schema(example = "It's my first payment request")]
pub description: Option<String>,
/// List of refunds that happened on this intent, as same payment intent can have multiple refund requests depending on the nature of order
#[schema(value_type = Option<Vec<RefundResponse>>)]
pub refunds: Option<Vec<refunds::RefundResponse>>,
/// List of disputes that happened on this intent
#[schema(value_type = Option<Vec<DisputeResponsePaymentsRetrieve>>)]
pub disputes: Option<Vec<disputes::DisputeResponsePaymentsRetrieve>>,
/// List of attempts that happened on this intent
#[schema(value_type = Option<Vec<PaymentAttemptResponse>>)]
#[serde(skip_serializing_if = "Option::is_none")]
pub attempts: Option<Vec<PaymentAttemptResponse>>,
/// List of captures done on latest attempt
#[schema(value_type = Option<Vec<CaptureResponse>>)]
#[serde(skip_serializing_if = "Option::is_none")]
pub captures: Option<Vec<CaptureResponse>>,
/// A unique identifier to link the payment to a mandate, can be used instead of payment_method_data, in case of setting up recurring payments
#[schema(max_length = 255, example = "mandate_iwer89rnjef349dni3")]
pub mandate_id: Option<String>,
/// Provided mandate information for creating a mandate
pub mandate_data: Option<MandateData>,
/// Indicates that you intend to make future payments with this Payment’s payment method. Providing this parameter will attach the payment method to the Customer, if present, after the Payment is confirmed and any required actions from the user are complete.
#[schema(value_type = Option<FutureUsage>, example = "off_session")]
pub setup_future_usage: Option<api_enums::FutureUsage>,
/// 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. This parameter can only be used with confirm=true.
#[schema(example = true)]
pub off_session: Option<bool>,
/// 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(with = "common_utils::custom_serde::iso8601::option")]
#[remove_in(PaymentsCreateResponseOpenApi)]
pub capture_on: Option<PrimitiveDateTime>,
/// This is the instruction for capture/ debit the money from the users' card. On the other hand authorization refers to blocking the amount on the users' payment method.
#[schema(value_type = Option<CaptureMethod>, example = "automatic")]
pub capture_method: Option<api_enums::CaptureMethod>,
/// The payment method that is to be used
#[schema(value_type = PaymentMethod, example = "bank_transfer")]
pub payment_method: Option<api_enums::PaymentMethod>,
/// The payment method information provided for making a payment
#[schema(value_type = Option<PaymentMethodDataResponseWithBilling>, example = "bank_transfer")]
#[serde(serialize_with = "serialize_payment_method_data_response")]
pub payment_method_data: Option<PaymentMethodDataResponseWithBilling>,
/// Provide a reference to a stored payment method
#[schema(example = "187282ab-40ef-47a9-9206-5099ba31e432")]
pub payment_token: Option<String>,
/// The shipping address for the payment
pub shipping: Option<Address>,
/// The billing address for the payment
pub billing: Option<Address>,
/// Information about the product , quantity and amount for connectors. (e.g. Klarna)
#[schema(value_type = Option<Vec<OrderDetailsWithAmount>>, example = r#"[{
"product_name": "gillete creme",
"quantity": 15,
"amount" : 900
}]"#)]
pub order_details: Option<Vec<pii::SecretSerdeValue>>,
/// description: The customer's email address
/// This field will be deprecated soon. Please refer to `customer.email` object
#[schema(max_length = 255, value_type = Option<String>, example = "johntest@test.com", deprecated)]
pub email: crypto::OptionalEncryptableEmail,
/// description: The customer's name
/// This field will be deprecated soon. Please refer to `customer.name` object
#[schema(value_type = Option<String>, max_length = 255, example = "John Test", deprecated)]
pub name: crypto::OptionalEncryptableName,
/// The customer's phone number
/// This field will be deprecated soon. Please refer to `customer.phone` object
#[schema(value_type = Option<String>, max_length = 255, example = "9123456789", deprecated)]
pub phone: crypto::OptionalEncryptablePhone,
/// The URL to redirect after the completion of the operation
#[schema(example = "https://hyperswitch.io")]
pub return_url: Option<String>,
/// The transaction authentication can be set to undergo payer authentication. By default, the authentication will be marked as NO_THREE_DS, as the 3DS method helps with more robust payer authentication
#[schema(value_type = Option<AuthenticationType>, example = "no_three_ds", default = "three_ds")]
pub authentication_type: Option<api_enums::AuthenticationType>,
/// 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 255 characters for the concatenated descriptor.
#[schema(max_length = 255, example = "Payment for shoes purchase")]
pub statement_descriptor_suffix: Option<String>,
/// Additional information required for redirection
pub next_action: Option<NextActionData>,
/// If the payment was cancelled the reason will be provided here
pub cancellation_reason: Option<String>,
/// If there was an error while calling the connectors the code is received here
#[schema(example = "E0001")]
pub error_code: Option<String>,
/// If there was an error while calling the connector the error message is received here
#[schema(example = "Failed while verifying the card")]
pub error_message: Option<String>,
/// error code unified across the connectors is received here if there was an error while calling connector
#[remove_in(PaymentsCreateResponseOpenApi)]
pub unified_code: Option<String>,
/// error message unified across the connectors is received here if there was an error while calling connector
#[remove_in(PaymentsCreateResponseOpenApi)]
pub unified_message: Option<String>,
/// Payment Experience for the current payment
#[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 = "gpay")]
pub payment_method_type: Option<api_enums::PaymentMethodType>,
/// The connector used for this payment along with the country and business details
#[schema(example = "stripe_US_food")]
pub connector_label: Option<String>,
/// The business country of merchant for this payment
#[schema(value_type = Option<CountryAlpha2>, example = "US")]
pub business_country: Option<api_enums::CountryAlpha2>,
/// The business label of merchant for this payment
pub business_label: Option<String>,
/// The business_sub_label for this payment
pub business_sub_label: Option<String>,
/// Allowed Payment Method Types for a given PaymentIntent
#[schema(value_type = Option<Vec<PaymentMethodType>>)]
pub allowed_payment_method_types: Option<serde_json::Value>,
/// ephemeral_key for the customer_id mentioned
pub ephemeral_key: Option<EphemeralKeyCreateResponse>,
/// If true the payment can be retried with same or different payment method which means the confirm call can be made again.
pub manual_retry_allowed: Option<bool>,
/// A unique identifier for a payment provided by the connector
#[schema(value_type = Option<String>, example = "993672945374576J")]
pub connector_transaction_id: Option<String>,
/// Frm message contains information about the frm response
pub frm_message: Option<FrmMessage>,
/// 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>,
/// Additional data related to some connectors
#[schema(value_type = Option<ConnectorMetadata>)]
pub connector_metadata: Option<serde_json::Value>, // This is Value because it is fetched from DB and before putting in DB the type is validated
/// Additional data that might be required by hyperswitch, to enable some specific features.
#[schema(value_type = Option<FeatureMetadata>)]
pub feature_metadata: Option<serde_json::Value>, // This is Value because it is fetched from DB and before putting in DB the type is validated
/// reference(Identifier) to the payment at connector side
#[schema(value_type = Option<String>, example = "993672945374576J")]
pub reference_id: Option<String>,
/// Details for Payment link
pub payment_link: Option<PaymentLinkResponse>,
/// The business profile that is associated with this payment
#[schema(value_type = Option<String>)]
pub profile_id: Option<id_type::ProfileId>,
/// Details of surcharge applied on this payment
pub surcharge_details: Option<RequestSurchargeDetails>,
/// Total number of attempts associated with this payment
pub attempt_count: i16,
/// Denotes the action(approve or reject) taken by merchant in case of manual review. Manual review can occur when the transaction is marked as risky by the frm_processor, payment processor or when there is underpayment/over payment incase of crypto payment
pub merchant_decision: Option<String>,
/// Identifier of the connector ( merchant connector account ) which was chosen to make the payment
#[schema(value_type = Option<String>)]
pub merchant_connector_id: Option<id_type::MerchantConnectorAccountId>,
/// If true, incremental authorization can be performed on this payment, in case the funds authorized initially fall short.
pub incremental_authorization_allowed: Option<bool>,
/// Total number of authorizations happened in an incremental_authorization payment
pub authorization_count: Option<i32>,
/// List of incremental authorizations happened to the payment
pub incremental_authorizations: Option<Vec<IncrementalAuthorizationResponse>>,
/// Details of external authentication
pub external_authentication_details: Option<ExternalAuthenticationDetailsResponse>,
/// Flag indicating if external 3ds authentication is made or not
pub external_3ds_authentication_attempted: Option<bool>,
/// Date Time for expiry of the payment
#[schema(example = "2022-09-10T10:11:12Z")]
#[serde(default, with = "common_utils::custom_serde::iso8601::option")]
pub expires_on: Option<PrimitiveDateTime>,
/// Payment Fingerprint, to identify a particular card.
/// It is a 20 character long alphanumeric code.
pub fingerprint: Option<String>,
#[schema(value_type = Option<BrowserInformation>)]
/// The browser information used for this payment
pub browser_info: Option<serde_json::Value>,
/// Identifier for Payment Method used for the payment
pub payment_method_id: Option<String>,
/// Payment Method Status, refers to the status of the payment method used for this payment.
#[schema(value_type = Option<PaymentMethodStatus>)]
pub payment_method_status: Option<common_enums::PaymentMethodStatus>,
/// Date time at which payment was updated
#[schema(example = "2022-09-10T10:11:12Z")]
#[serde(default, with = "common_utils::custom_serde::iso8601::option")]
pub updated: Option<PrimitiveDateTime>,
/// Fee information to be charged on the payment being collected
#[schema(value_type = Option<ConnectorChargeResponseData>)]
pub split_payments: Option<common_types::payments::ConnectorChargeResponseData>,
/// You can specify up to 50 keys, with key names up to 40 characters long and values up to 500 characters long. FRM Metadata is useful for storing additional, structured information on an object related to FRM.
#[schema(value_type = Option<Object>, example = r#"{ "fulfillment_method" : "deliver", "coverage_request" : "fraud" }"#)]
pub frm_metadata: Option<pii::SecretSerdeValue>,
/// flag that indicates if extended authorization is applied on this payment or not
#[schema(value_type = Option<bool>)]
pub extended_authorization_applied: Option<ExtendedAuthorizationAppliedBool>,
/// date and time after which this payment cannot be captured
#[serde(default, with = "common_utils::custom_serde::iso8601::option")]
pub capture_before: Option<PrimitiveDateTime>,
/// 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>,
/// order tax amount calculated by tax connectors
pub order_tax_amount: Option<MinorUnit>,
/// Connector Identifier for the payment method
pub connector_mandate_id: Option<String>,
/// Method through which card was discovered
#[schema(value_type = Option<CardDiscovery>, example = "manual")]
pub card_discovery: Option<enums::CardDiscovery>,
/// Indicates if 3ds challenge is forced
pub force_3ds_challenge: Option<bool>,
/// Indicates if 3ds challenge is triggered
pub force_3ds_challenge_trigger: Option<bool>,
/// Error code received from the issuer in case of failed payments
pub issuer_error_code: Option<String>,
/// Error message received from the issuer in case of failed payments
pub issuer_error_message: Option<String>,
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/hyperswitch_connectors/src/connectors/getnet/transformers.rs<|crate|> hyperswitch_connectors<|connector|> getnet 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/getnet/transformers.rs" role="context" start="466" end="513">
fn try_from(
item: PaymentsSyncResponseRouterData<GetnetPaymentsResponse>,
) -> Result<Self, Self::Error> {
match item.response {
GetnetPaymentsResponse::PaymentsResponse(ref payment_response) => Ok(Self {
status: authorization_attempt_status_from_transaction_state(
payment_response.payment.transaction_state.clone(),
item.data.request.is_auto_capture()?,
),
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(
payment_response.payment.transaction_id.clone(),
),
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
}),
GetnetPaymentsResponse::GetnetWebhookNotificationResponse(ref webhook_response) => {
Ok(Self {
status: psync_attempt_status_from_transaction_state(
webhook_response.payment.transaction_state.clone(),
item.data.request.is_auto_capture()?,
webhook_response.payment.transaction_type.clone(),
),
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(
webhook_response.payment.transaction_id.clone(),
),
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
})
}
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/getnet/transformers.rs" role="context" start="465" end="465">
use hyperswitch_domain_models::{
payment_method_data::PaymentMethodData,
router_data::{ConnectorAuthType, RouterData},
router_flow_types::refunds::{Execute, RSync},
router_request_types::{
PaymentsAuthorizeData, PaymentsCancelData, PaymentsCaptureData, ResponseId,
},
router_response_types::{PaymentsResponseData, RefundsResponseData},
types::{
PaymentsAuthorizeRouterData, PaymentsCancelRouterData, PaymentsCaptureRouterData,
PaymentsSyncRouterData, RefundsRouterData,
},
};
use crate::{
connectors::paybox::transformers::parse_url_encoded_to_struct,
types::{PaymentsSyncResponseRouterData, RefundsResponseRouterData, ResponseRouterData},
utils::{
BrowserInformationData, PaymentsAuthorizeRequestData, PaymentsSyncRequestData,
RouterData as _,
},
};
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/getnet/transformers.rs" role="context" start="628" end="634">
pub fn capture_status_from_transaction_state(getnet_status: GetnetPaymentStatus) -> AttemptStatus {
match getnet_status {
GetnetPaymentStatus::Success => AttemptStatus::Charged,
GetnetPaymentStatus::InProgress => AttemptStatus::Pending,
GetnetPaymentStatus::Failed => AttemptStatus::Authorized,
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/getnet/transformers.rs" role="context" start="539" end="581">
fn try_from(item: &GetnetRouterData<&PaymentsCaptureRouterData>) -> Result<Self, Self::Error> {
let request = &item.router_data.request;
let auth_type = GetnetAuthType::try_from(&item.router_data.connector_auth_type)
.change_context(errors::ConnectorError::FailedToObtainAuthType)?;
let merchant_account_id = MerchantAccountId {
value: auth_type.merchant_id,
};
let requested_amount = Amount {
value: item.amount,
currency: request.currency,
};
let req = &item.router_data.request;
let webhook_url = &req.webhook_url;
let notifications = NotificationContainer {
format: NotificationFormat::JsonSigned,
notification: vec![Notification {
url: webhook_url.clone(),
}],
};
let transaction_type = GetnetTransactionType::CaptureAuthorization;
let ip_address = req
.browser_info
.as_ref()
.and_then(|info| info.ip_address.as_ref())
.map(|ip| Secret::new(ip.to_string()));
let request_id = item.router_data.connector_request_reference_id.clone();
let parent_transaction_id = item.router_data.request.connector_transaction_id.clone();
let capture_payment_data = CapturePaymentData {
merchant_account_id,
request_id,
transaction_type,
parent_transaction_id,
requested_amount,
notifications,
ip_address,
};
Ok(Self {
payment: capture_payment_data,
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/getnet/transformers.rs" role="context" start="446" end="462">
pub fn psync_attempt_status_from_transaction_state(
getnet_status: GetnetPaymentStatus,
is_auto_capture: bool,
transaction_type: GetnetTransactionType,
) -> AttemptStatus {
match getnet_status {
GetnetPaymentStatus::Success => {
if is_auto_capture && transaction_type == GetnetTransactionType::CaptureAuthorization {
AttemptStatus::Charged
} else {
AttemptStatus::Authorized
}
}
GetnetPaymentStatus::InProgress => AttemptStatus::Pending,
GetnetPaymentStatus::Failed => AttemptStatus::Failure,
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/getnet/transformers.rs" role="context" start="410" end="443">
fn try_from(
item: ResponseRouterData<
F,
GetnetPaymentsResponse,
PaymentsAuthorizeData,
PaymentsResponseData,
>,
) -> Result<Self, Self::Error> {
match item.response {
GetnetPaymentsResponse::PaymentsResponse(ref payment_response) => Ok(Self {
status: authorization_attempt_status_from_transaction_state(
payment_response.payment.transaction_state.clone(),
item.data.request.is_auto_capture()?,
),
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(
payment_response.payment.transaction_id.clone(),
),
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
}),
_ => Err(error_stack::Report::new(
errors::ConnectorError::ResponseHandlingFailed,
)),
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/getnet/transformers.rs" role="context" start="387" end="402">
pub fn authorization_attempt_status_from_transaction_state(
getnet_status: GetnetPaymentStatus,
is_auto_capture: bool,
) -> AttemptStatus {
match getnet_status {
GetnetPaymentStatus::Success => {
if is_auto_capture {
AttemptStatus::Charged
} else {
AttemptStatus::Authorized
}
}
GetnetPaymentStatus::InProgress => AttemptStatus::Pending,
GetnetPaymentStatus::Failed => AttemptStatus::Failure,
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/getnet/transformers.rs" role="context" start="1010" end="1017">
pub struct GetnetWebhookNotificationResponse {
#[serde(rename = "response-signature-base64")]
pub response_signature_base64: Secret<String>,
#[serde(rename = "response-signature-algorithm")]
pub response_signature_algorithm: Secret<String>,
#[serde(rename = "response-base64")]
pub response_base64: Secret<String>,
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/getnet/transformers.rs" role="context" start="174" end="174">
type Error = error_stack::Report<errors::ConnectorError>;
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/klarna/transformers.rs" role="context" start="120" end="124">
pub struct PaymentsResponse {
order_id: String,
fraud_status: KlarnaFraudStatus,
authorized_payment_method: Option<AuthorizedPaymentMethod>,
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/hyperswitch_connectors/src/connectors/braintree/transformers.rs<|crate|> hyperswitch_connectors<|connector|> braintree 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/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="1560" end="1560">
use common_enums::enums;
use hyperswitch_domain_models::{
payment_method_data::PaymentMethodData,
router_data::{ConnectorAuthType, PaymentMethodToken, RouterData},
router_flow_types::refunds::{Execute, RSync},
router_request_types::{
CompleteAuthorizeData, MandateRevokeRequestData, PaymentsAuthorizeData, ResponseId,
},
router_response_types::{
MandateReference, MandateRevokeResponseData, PaymentsResponseData, RedirectForm,
RefundsResponseData,
},
types::{self, RefundsRouterData},
};
use crate::{
types::{PaymentsCaptureResponseRouterData, RefundsResponseRouterData, ResponseRouterData},
unimplemented_payment_method,
utils::{
self, PaymentsAuthorizeRequestData, PaymentsCompleteAuthorizeRequestData,
RefundsRequestData, RouterData as _,
},
};
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/braintree/transformers.rs" role="context" start="1661" end="1710">
fn try_from(
item: ResponseRouterData<F, BraintreePSyncResponse, T, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
match item.response {
BraintreePSyncResponse::ErrorResponse(error_response) => Ok(Self {
response: build_error_response(&error_response.errors, item.http_code)
.map_err(|err| *err),
..item.data
}),
BraintreePSyncResponse::SuccessResponse(psync_response) => {
let edge_data = psync_response
.data
.search
.transactions
.edges
.first()
.ok_or(errors::ConnectorError::MissingConnectorTransactionID)?;
let status = enums::AttemptStatus::from(edge_data.node.status.clone());
let response = if utils::is_payment_failure(status) {
Err(hyperswitch_domain_models::router_data::ErrorResponse {
code: edge_data.node.status.to_string().clone(),
message: edge_data.node.status.to_string().clone(),
reason: Some(edge_data.node.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::ConnectorTransactionId(edge_data.node.id.clone()),
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="1609" end="1623">
fn try_from(item: &types::PaymentsSyncRouterData) -> Result<Self, Self::Error> {
let transaction_id = item
.request
.connector_transaction_id
.get_connector_transaction_id()
.change_context(errors::ConnectorError::MissingConnectorTransactionID)?;
Ok(Self {
query: TRANSACTION_QUERY.to_string(),
variables: PSyncInput {
input: TransactionSearchInput {
id: IdFilter { is: transaction_id },
},
},
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/braintree/transformers.rs" role="context" start="1517" end="1525">
fn try_from(item: &types::PaymentsCancelRouterData) -> Result<Self, Self::Error> {
let query = VOID_TRANSACTION_MUTATION.to_string();
let variables = VariableCancelInput {
input: CancelInputData {
transaction_id: item.request.connector_transaction_id.clone(),
},
};
Ok(Self { query, variables })
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/braintree/transformers.rs" role="context" start="1455" end="1477">
fn try_from(
item: ResponseRouterData<
F,
BraintreeRevokeMandateResponse,
MandateRevokeRequestData,
MandateRevokeResponseData,
>,
) -> Result<Self, Self::Error> {
Ok(Self {
response: match item.response {
BraintreeRevokeMandateResponse::ErrorResponse(error_response) => {
build_error_response(error_response.errors.as_ref(), item.http_code)
.map_err(|err| *err)
}
BraintreeRevokeMandateResponse::RevokeMandateResponse(..) => {
Ok(MandateRevokeResponseData {
mandate_status: common_enums::MandateStatus::Revoked,
})
}
},
..item.data
})
}
<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="531" end="556">
fn build_error_response<T>(
response: &[ErrorDetails],
http_code: u16,
) -> Result<T, Box<hyperswitch_domain_models::router_data::ErrorResponse>> {
let error_messages = response
.iter()
.map(|error| error.message.to_string())
.collect::<Vec<String>>();
let reason = match !error_messages.is_empty() {
true => Some(error_messages.join(" ")),
false => None,
};
get_error_response(
response
.first()
.and_then(|err_details| err_details.extensions.as_ref())
.and_then(|extensions| extensions.legacy_code.clone()),
response
.first()
.map(|err_details| err_details.message.clone()),
reason,
http_code,
)
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/braintree/transformers.rs" role="context" start="116" end="116">
type Error = error_stack::Report<errors::ConnectorError>;
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/braintree/transformers.rs" role="context" start="1552" end="1555">
pub enum BraintreeCancelResponse {
CancelResponse(Box<CancelResponse>),
ErrorResponse(Box<ErrorResponse>),
}
<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
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.