text stringlengths 70 351k | source stringclasses 4 values |
|---|---|
<|meta_start|><|file|> hyperswitch/crates/hyperswitch_connectors/src/connectors/braintree/transformers.rs<|crate|> hyperswitch_connectors<|connector|> braintree anchor=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="1363" end="1406">
fn try_from(
item: PaymentsCaptureResponseRouterData<BraintreeCaptureResponse>,
) -> Result<Self, Self::Error> {
match item.response {
BraintreeCaptureResponse::SuccessResponse(capture_data) => {
let transaction_data = capture_data.data.capture_transaction.transaction;
let status = enums::AttemptStatus::from(transaction_data.status.clone());
let response = if utils::is_payment_failure(status) {
Err(hyperswitch_domain_models::router_data::ErrorResponse {
code: transaction_data.status.to_string().clone(),
message: transaction_data.status.to_string().clone(),
reason: Some(transaction_data.status.to_string().clone()),
attempt_status: None,
connector_transaction_id: Some(transaction_data.id),
status_code: item.http_code,
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
})
} else {
Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(transaction_data.id),
redirection_data: Box::new(None),
mandate_reference: Box::new(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
})
}
BraintreeCaptureResponse::ErrorResponse(error_data) => Ok(Self {
response: build_error_response(&error_data.errors, item.http_code)
.map_err(|err| *err),
..item.data
}),
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/braintree/transformers.rs" role="context" start="1362" end="1362">
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="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="1428" end="1441">
fn try_from(item: &types::MandateRevokeRouterData) -> Result<Self, Self::Error> {
let query = DELETE_PAYMENT_METHOD_FROM_VAULT_MUTATION.to_string();
let variables = VariableDeletePaymentMethodFromVaultInput {
input: DeletePaymentMethodFromVaultInputData {
payment_method_id: Secret::new(
item.request
.connector_mandate_id
.clone()
.ok_or(errors::ConnectorError::MissingConnectorMandateID)?,
),
},
};
Ok(Self { query, variables })
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/braintree/transformers.rs" role="context" start="1321" end="1334">
fn try_from(
item: &BraintreeRouterData<&types::PaymentsCaptureRouterData>,
) -> Result<Self, Self::Error> {
let query = CAPTURE_TRANSACTION_MUTATION.to_string();
let variables = VariableCaptureInput {
input: CaptureInputData {
transaction_id: item.router_data.request.connector_transaction_id.clone(),
transaction: CaptureTransactionBody {
amount: item.amount.to_owned(),
},
},
};
Ok(Self { query, variables })
}
<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="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/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/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="112" end="159">
fn try_from(
item: ResponseRouterData<F, PaystackPaymentsResponse, T, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
let (status, response) = match item.response {
PaystackPaymentsResponse::PaystackPaymentsData(resp) => {
let redirection_url = Url::parse(resp.data.url.as_str())
.change_context(errors::ConnectorError::ParsingFailed)?;
let redirection_data = RedirectForm::from((redirection_url, Method::Get));
(
common_enums::AttemptStatus::AuthenticationPending,
Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(
resp.data.reference.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,
}),
)
}
PaystackPaymentsResponse::PaystackPaymentsError(err) => {
let err_msg = get_error_message(err.clone());
(
common_enums::AttemptStatus::Failure,
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,
}),
)
}
};
Ok(Self {
status,
response,
..item.data
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/paystack/transformers.rs" role="context" start="111" end="111">
use common_enums::{enums, Currency};
use common_utils::{pii::Email, request::Method, types::MinorUnit};
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 url::Url;
use crate::{
types::{RefundsResponseRouterData, ResponseRouterData},
utils::PaymentsAuthorizeRequestData,
};
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/paystack/transformers.rs" role="context" start="215" end="265">
fn try_from(
item: ResponseRouterData<F, PaystackPSyncResponse, T, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
match item.response {
PaystackPSyncResponse::PaystackPSyncData(resp) => Ok(Self {
status: common_enums::AttemptStatus::from(resp.data.status),
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(resp.data.reference.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
}),
PaystackPSyncResponse::PaystackPSyncWebhook(resp) => Ok(Self {
status: common_enums::AttemptStatus::from(resp.status),
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(resp.reference.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
}),
PaystackPSyncResponse::PaystackPSyncError(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="176" end="187">
fn from(item: PaystackPSyncStatus) -> Self {
match item {
PaystackPSyncStatus::Success => Self::Charged,
PaystackPSyncStatus::Abandoned => Self::AuthenticationPending,
PaystackPSyncStatus::Ongoing
| PaystackPSyncStatus::Pending
| PaystackPSyncStatus::Processing
| PaystackPSyncStatus::Queued => Self::Pending,
PaystackPSyncStatus::Failed => Self::Failure,
PaystackPSyncStatus::Reversed => Self::Voided,
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/paystack/transformers.rs" role="context" start="77" end="84">
fn try_from(auth_type: &ConnectorAuthType) -> Result<Self, Self::Error> {
match auth_type {
ConnectorAuthType::HeaderKey { api_key } => Ok(Self {
api_key: api_key.to_owned(),
}),
_ => Err(errors::ConnectorError::FailedToObtainAuthType.into()),
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/paystack/transformers.rs" role="context" start="52" end="68">
fn try_from(
item: &PaystackRouterData<&PaymentsAuthorizeRouterData>,
) -> Result<Self, Self::Error> {
match item.router_data.request.payment_method_data.clone() {
PaymentMethodData::BankRedirect(BankRedirectData::Eft { provider }) => {
let email = item.router_data.request.get_email()?;
let eft = PaystackEftProvider { provider };
Ok(Self {
amount: item.amount,
currency: item.router_data.request.currency,
email,
eft,
})
}
_ => Err(errors::ConnectorError::NotImplemented("Payment method".to_string()).into()),
}
}
<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="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="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="103" end="106">
pub enum PaystackPaymentsResponse {
PaystackPaymentsData(PaystackPaymentsResponseData),
PaystackPaymentsError(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/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_webhook_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="981" end="1030">
pub fn handle_webhook_response(
payment_information: WebhookPaymentInformation,
status_code: u16,
) -> CustomResult<
(
enums::AttemptStatus,
Option<ErrorResponse>,
PaymentsResponseData,
),
errors::ConnectorError,
> {
let status = enums::AttemptStatus::try_from(payment_information.status)?;
let error = if utils::is_payment_failure(status) {
let reason_info = 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: 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::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="980" end="980">
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="1070" end="1074">
fn try_from(_item: &RefreshTokenRouterData) -> Result<Self, Self::Error> {
Ok(Self {
grant_type: "client_credentials".to_string(),
})
}
<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="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="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/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/fiuu/transformers.rs<|crate|> hyperswitch_connectors<|connector|> fiuu 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/fiuu/transformers.rs" role="context" start="204" end="245">
fn try_from(item: &FiuuRouterData<&PaymentsAuthorizeRouterData>) -> Result<Self, Self::Error> {
let auth: FiuuAuthType = FiuuAuthType::try_from(&item.router_data.connector_auth_type)?;
let record_type = FiuuRecordType::T;
let merchant_id = auth.merchant_id;
let order_id = item.router_data.connector_request_reference_id.clone();
let currency = item.router_data.request.currency;
let amount = item.amount.clone();
let billing_name = item
.router_data
.request
.get_card_holder_name_from_additional_payment_method_data()?;
let email = item.router_data.get_billing_email()?;
let token = Secret::new(item.router_data.request.get_connector_mandate_id()?);
let verify_key = auth.verify_key;
let recurring_request = FiuuRecurringRequest {
record_type: record_type.clone(),
merchant_id: merchant_id.clone(),
token: token.clone(),
order_id: order_id.clone(),
currency,
amount: amount.clone(),
billing_name: billing_name.clone(),
email: email.clone(),
verify_key: verify_key.clone(),
};
let check_sum = calculate_check_sum(recurring_request)?;
let mandate_request = format!(
"{}|{}||{}|{}|{}|{}|{}|{}|||{}",
record_type,
merchant_id.peek(),
token.peek(),
order_id,
currency,
amount.get_amount_as_string(),
billing_name.peek(),
email.peek(),
check_sum.peek()
);
Ok(Self {
mandate_request: mandate_request.into(),
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/fiuu/transformers.rs" role="context" start="203" end="203">
use common_utils::{
crypto::{self, GenerateDigest},
errors::CustomResult,
ext_traits::Encode,
pii::Email,
request::Method,
types::{AmountConvertor, StringMajorUnit, StringMajorUnitForConnector},
};
use hyperswitch_domain_models::{
payment_method_data::{
BankRedirectData, Card, CardDetailsForNetworkTransactionId, GooglePayWalletData,
PaymentMethodData, RealTimePaymentData, WalletData,
},
router_data::{
ApplePayPredecryptData, ConnectorAuthType, ErrorResponse, PaymentMethodToken, RouterData,
},
router_flow_types::refunds::{Execute, RSync},
router_request_types::{PaymentsAuthorizeData, ResponseId},
router_response_types::{
MandateReference, PaymentsResponseData, RedirectForm, RefundsResponseData,
},
types::{
PaymentsAuthorizeRouterData, PaymentsCancelRouterData, PaymentsCaptureRouterData,
PaymentsSyncRouterData, RefundSyncRouterData, RefundsRouterData,
},
};
use masking::{ExposeInterface, PeekInterface, Secret};
<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="248" end="266">
pub fn calculate_check_sum(
req: FiuuRecurringRequest,
) -> CustomResult<Secret<String>, errors::ConnectorError> {
let formatted_string = format!(
"{}{}{}{}{}{}{}",
req.record_type,
req.merchant_id.peek(),
req.token.peek(),
req.order_id,
req.currency,
req.amount.get_amount_as_string(),
req.verify_key.peek()
);
Ok(Secret::new(hex::encode(
crypto::Md5
.generate_digest(formatted_string.as_bytes())
.change_context(errors::ConnectorError::RequestEncodingFailed)?,
)))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/fiuu/transformers.rs" role="context" start="150" end="175">
fn try_from(bank_names: BankNames) -> Result<Self, Self::Error> {
match bank_names {
BankNames::AffinBank => Ok(Self::FpxAbb),
BankNames::AgroBank => Ok(Self::FpxAgrobank),
BankNames::AllianceBank => Ok(Self::FpxAbmb),
BankNames::AmBank => Ok(Self::FpxAmb),
BankNames::BankOfChina => Ok(Self::FpxBocm),
BankNames::BankIslam => Ok(Self::FpxBimb),
BankNames::BankMuamalat => Ok(Self::FpxBmmb),
BankNames::BankRakyat => Ok(Self::FpxBkrm),
BankNames::BankSimpananNasional => Ok(Self::FpxBsn),
BankNames::CimbBank => Ok(Self::FpxCimbclicks),
BankNames::HongLeongBank => Ok(Self::FpxHlb),
BankNames::HsbcBank => Ok(Self::FpxHsbc),
BankNames::KuwaitFinanceHouse => Ok(Self::FpxKfh),
BankNames::Maybank => Ok(Self::FpxMb2u),
BankNames::PublicBank => Ok(Self::FpxPbb),
BankNames::RhbBank => Ok(Self::FpxRhb),
BankNames::StandardCharteredBank => Ok(Self::FpxScb),
BankNames::UobBank => Ok(Self::FpxUob),
BankNames::OcbcBank => Ok(Self::FpxOcbc),
_ => Err(errors::ConnectorError::NotImplemented(
utils::get_unimplemented_payment_method_error_message("Fiuu"),
))?,
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/fiuu/transformers.rs" role="context" start="103" end="111">
fn try_from(capture_method: Option<CaptureMethod>) -> Result<Self, Self::Error> {
match capture_method {
Some(CaptureMethod::Automatic) | Some(CaptureMethod::SequentialAutomatic) | None => {
Ok(Self::Sals)
}
Some(CaptureMethod::Manual) => Ok(Self::Auts),
_ => Err(errors::ConnectorError::CaptureMethodNotSupported.into()),
}
}
<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="77" end="77">
type Error = Report<errors::ConnectorError>;
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/fiuu/transformers.rs" role="context" start="198" end="200">
pub enum FiuuRecordType {
T,
}
<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>,
}
| symbol_neighborhood |
<|meta_start|><|file|> hyperswitch/crates/hyperswitch_connectors/src/connectors/powertranz/transformers.rs<|crate|> hyperswitch_connectors<|connector|> powertranz 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/powertranz/transformers.rs" role="context" start="441" end="484">
fn build_error_response(item: &PowertranzBaseResponse, status_code: u16) -> Option<ErrorResponse> {
// errors object has highest precedence to get error message and code
let error_response = if item.errors.is_some() {
item.errors.as_ref().map(|errors| {
let first_error = errors.first();
let code = first_error.map(|error| error.code.clone());
let message = first_error.map(|error| error.message.clone());
ErrorResponse {
status_code,
code: code.unwrap_or_else(|| consts::NO_ERROR_CODE.to_string()),
message: message.unwrap_or_else(|| consts::NO_ERROR_MESSAGE.to_string()),
reason: Some(
errors
.iter()
.map(|error| format!("{} : {}", error.code, error.message))
.collect::<Vec<_>>()
.join(", "),
),
attempt_status: None,
connector_transaction_id: None,
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
}
})
} else if !ISO_SUCCESS_CODES.contains(&item.iso_response_code.as_str()) {
// Incase error object is not present the error message and code should be propagated based on iso_response_code
Some(ErrorResponse {
status_code,
code: item.iso_response_code.clone(),
message: item.response_message.clone(),
reason: Some(item.response_message.clone()),
attempt_status: None,
connector_transaction_id: None,
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
})
} else {
None
};
error_response
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/powertranz/transformers.rs" role="context" start="440" end="440">
use hyperswitch_domain_models::{
payment_method_data::{Card, PaymentMethodData},
router_data::{ConnectorAuthType, ErrorResponse, RouterData},
router_flow_types::refunds::Execute,
router_request_types::{
BrowserInformation, PaymentsCancelData, PaymentsCaptureData, ResponseId,
},
router_response_types::{PaymentsResponseData, RefundsResponseData},
types::{PaymentsAuthorizeRouterData, RefundsRouterData},
};
use hyperswitch_interfaces::{consts, errors};
use crate::{
types::{RefundsResponseRouterData, ResponseRouterData},
utils::{self, CardData, PaymentsAuthorizeRequestData, RouterData as _},
};
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/powertranz/transformers.rs" role="context" start="420" end="438">
fn try_from(
item: RefundsResponseRouterData<Execute, PowertranzBaseResponse>,
) -> Result<Self, Self::Error> {
let error_response = build_error_response(&item.response, item.http_code);
let response = error_response.map_or(
Ok(RefundsResponseData {
connector_refund_id: item.response.transaction_identifier.to_string(),
refund_status: match item.response.approved {
true => enums::RefundStatus::Success,
false => enums::RefundStatus::Failure,
},
}),
Err,
);
Ok(Self {
response,
..item.data
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/powertranz/transformers.rs" role="context" start="403" end="413">
fn try_from(item: &RefundsRouterData<F>) -> Result<Self, Self::Error> {
let total_amount = Some(utils::to_currency_base_unit_asf64(
item.request.refund_amount,
item.request.currency,
)?);
Ok(Self {
transaction_identifier: item.request.connector_transaction_id.clone(),
total_amount,
refund: Some(true),
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/powertranz/transformers.rs" role="context" start="323" end="359">
fn try_from(
item: ResponseRouterData<F, PowertranzBaseResponse, T, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
let error_response = build_error_response(&item.response, item.http_code);
// original_trxn_identifier will be present only in capture and void
let connector_transaction_id = item
.response
.original_trxn_identifier
.unwrap_or(item.response.transaction_identifier.clone());
let redirection_data = item.response.redirect_data.map(|redirect_data| {
hyperswitch_domain_models::router_response_types::RedirectForm::Html {
html_data: redirect_data.expose(),
}
});
let response = error_response.map_or(
Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(connector_transaction_id),
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.order_identifier),
incremental_authorization_allowed: None,
charges: None,
}),
Err,
);
Ok(Self {
status: get_status((
item.response.transaction_type,
item.response.approved,
is_3ds_payment(item.response.iso_response_code),
)),
response,
..item.data
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/powertranz/transformers.rs" role="context" start="266" end="276">
pub struct PowertranzBaseResponse {
transaction_type: u8,
approved: bool,
transaction_identifier: String,
original_trxn_identifier: Option<String>,
errors: Option<Vec<Error>>,
iso_response_code: String,
redirect_data: Option<Secret<String>>,
response_message: String,
order_identifier: 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/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="1417" end="1465">
fn try_from(
item: RefundsResponseRouterData<Execute, RedsysResponse>,
) -> Result<Self, Self::Error> {
let response = match item.response {
RedsysResponse::RedsysResponse(redsys_transaction) => {
let response_data: RedsysOperationsResponse = to_connector_response_data(
&redsys_transaction.ds_merchant_parameters.clone().expose(),
)?;
let refund_status =
enums::RefundStatus::try_from(response_data.ds_response.clone())?;
if connector_utils::is_refund_failure(refund_status) {
Err(ErrorResponse {
code: response_data.ds_response.0.clone(),
message: response_data.ds_response.0.clone(),
reason: Some(response_data.ds_response.0.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,
})
} else {
Ok(RefundsResponseData {
connector_refund_id: response_data.ds_order,
refund_status,
})
}
}
RedsysResponse::RedsysErrorResponse(redsys_error_response) => Err(ErrorResponse {
code: redsys_error_response.error_code.clone(),
message: redsys_error_response.error_code.clone(),
reason: Some(redsys_error_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 {
response,
..item.data
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/redsys/transformers.rs" role="context" start="1416" end="1416">
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="1570" end="1611">
fn get_transaction_type(
status: enums::AttemptStatus,
capture_method: Option<enums::CaptureMethod>,
) -> Result<String, errors::ConnectorError> {
match status {
enums::AttemptStatus::AuthenticationPending
| enums::AttemptStatus::AuthenticationSuccessful
| enums::AttemptStatus::Started
| enums::AttemptStatus::Authorizing
| enums::AttemptStatus::Authorized
| enums::AttemptStatus::DeviceDataCollectionPending => match capture_method {
Some(enums::CaptureMethod::Automatic) | None => {
Ok(transaction_type::PAYMENT.to_owned())
}
Some(enums::CaptureMethod::Manual) => Ok(transaction_type::PREAUTHORIZATION.to_owned()),
Some(capture_method) => Err(errors::ConnectorError::NotSupported {
message: capture_method.to_string(),
connector: "redsys",
}),
},
enums::AttemptStatus::VoidInitiated => Ok(transaction_type::CANCELLATION.to_owned()),
enums::AttemptStatus::PartialChargedAndChargeable
| enums::AttemptStatus::CaptureInitiated => Ok(transaction_type::CONFIRMATION.to_owned()),
enums::AttemptStatus::Pending => match capture_method {
Some(enums::CaptureMethod::Automatic) | None => {
Ok(transaction_type::PAYMENT.to_owned())
}
Some(enums::CaptureMethod::Manual) => Ok(transaction_type::CONFIRMATION.to_owned()),
Some(capture_method) => Err(errors::ConnectorError::NotSupported {
message: capture_method.to_string(),
connector: "redsys",
}),
},
other_attempt_status => Err(errors::ConnectorError::NotSupported {
message: format!(
"Payment sync after terminal status: {} payment",
other_attempt_status
),
connector: "redsys",
}),
}
}
<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="1404" end="1412">
fn try_from(ds_response: DsResponse) -> Result<Self, Self::Error> {
match ds_response.0.as_str() {
"0900" => Ok(Self::Success),
"9999" => Ok(Self::Pending),
"0950" | "0172" | "174" => Ok(Self::Failure),
unknown_status => Err(errors::ConnectorError::ResponseHandlingFailed)
.attach_printable(format!("Received unknown status:{}", unknown_status))?,
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/redsys/transformers.rs" role="context" start="1336" end="1399">
fn try_from(
item: ResponseRouterData<F, RedsysResponse, PaymentsCancelData, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
let (response, status) = match item.response {
RedsysResponse::RedsysResponse(redsys_transaction_response) => {
let response_data: RedsysOperationsResponse = to_connector_response_data(
&redsys_transaction_response
.ds_merchant_parameters
.clone()
.expose(),
)?;
let status = get_redsys_attempt_status(response_data.ds_response.clone(), None)?;
let response = if connector_utils::is_payment_failure(status) {
Err(ErrorResponse {
code: response_data.ds_response.0.clone(),
message: response_data.ds_response.0.clone(),
reason: Some(response_data.ds_response.0.clone()),
status_code: item.http_code,
attempt_status: None,
connector_transaction_id: Some(response_data.ds_order.clone()),
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
})
} else {
Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(
response_data.ds_order.clone(),
),
redirection_data: Box::new(None),
mandate_reference: Box::new(None),
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: Some(response_data.ds_order.clone()),
incremental_authorization_allowed: None,
charges: None,
})
};
(response, status)
}
RedsysResponse::RedsysErrorResponse(error_response) => {
let response = Err(ErrorResponse {
code: error_response.error_code.clone(),
message: error_response.error_code.clone(),
reason: Some(error_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::VoidFailed)
}
};
Ok(Self {
status,
response,
..item.data
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/redsys/transformers.rs" role="context" start="1850" end="1915">
fn try_from(
item: RefundsResponseRouterData<RSync, RedsysSyncResponse>,
) -> Result<Self, Self::Error> {
let message_data = item
.response
.body
.consultaoperacionesresponse
.consultaoperacionesreturn
.messages
.version
.message;
let response = match (message_data.response, message_data.errormsg) {
(None, Some(errormsg)) => {
let error_code = errormsg.ds_errorcode.clone();
Err(ErrorResponse {
code: error_code.clone(),
message: error_code.clone(),
reason: Some(error_code),
status_code: item.http_code,
attempt_status: None,
connector_transaction_id: None,
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
})
}
(Some(response), None) => {
if let Some(ds_response) = response.ds_response {
let refund_status = enums::RefundStatus::try_from(ds_response.clone())?;
if connector_utils::is_refund_failure(refund_status) {
Err(ErrorResponse {
status_code: item.http_code,
code: ds_response.0.clone(),
message: ds_response.0.clone(),
reason: Some(ds_response.0.clone()),
attempt_status: None,
connector_transaction_id: None,
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
})
} else {
Ok(RefundsResponseData {
connector_refund_id: response.ds_order,
refund_status,
})
}
} else {
// When the refund is pending
Ok(RefundsResponseData {
connector_refund_id: response.ds_order,
refund_status: enums::RefundStatus::Pending,
})
}
}
(Some(_), Some(_)) | (None, None) => {
Err(errors::ConnectorError::ResponseHandlingFailed)?
}
};
Ok(Self {
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="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="1200" end="1207">
pub struct RedsysOperationsResponse {
#[serde(rename = "Ds_Order")]
ds_order: String,
#[serde(rename = "Ds_Response")]
ds_response: 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/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="1029" end="1078">
fn try_from(
(item, solution, three_ds_data): (
&CybersourceRouterData<&PaymentsCompleteAuthorizeRouterData>,
Option<PaymentSolution>,
&CybersourceConsumerAuthValidateResponse,
),
) -> Result<Self, Self::Error> {
let connector_merchant_config =
CybersourceConnectorMetadataObject::try_from(&item.router_data.connector_meta_data)?;
let (action_list, action_token_types, authorization_options) =
if item.router_data.request.setup_future_usage == Some(FutureUsage::OffSession)
//TODO check for customer acceptance also
{
(
Some(vec![CybersourceActionsList::TokenCreate]),
Some(vec![
CybersourceActionsTokenType::PaymentInstrument,
CybersourceActionsTokenType::Customer,
]),
Some(CybersourceAuthorizationOptions {
initiator: Some(CybersourcePaymentInitiator {
initiator_type: Some(CybersourcePaymentInitiatorTypes::Customer),
credential_stored_on_file: Some(true),
stored_credential_used: None,
}),
merchant_intitiated_transaction: None,
ignore_avs_result: connector_merchant_config.disable_avs,
ignore_cv_result: connector_merchant_config.disable_cvn,
}),
)
} else {
(None, None, None)
};
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: three_ds_data
.indicator
.to_owned()
.unwrap_or(String::from("internet")),
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/cybersource/transformers.rs" role="context" start="1028" end="1028">
use common_enums::{enums, FutureUsage};
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="1109" end="1122">
fn from(
(item, bill_to): (
&CybersourceRouterData<&PaymentsCompleteAuthorizeRouterData>,
BillTo,
),
) -> Self {
Self {
amount_details: Amount {
total_amount: item.amount.to_owned(),
currency: item.router_data.request.currency,
},
bill_to: Some(bill_to),
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/cybersource/transformers.rs" role="context" start="1087" end="1100">
fn from(
(item, bill_to): (
&CybersourceRouterData<&PaymentsAuthorizeRouterData>,
Option<BillTo>,
),
) -> Self {
Self {
amount_details: Amount {
total_amount: item.amount.to_owned(),
currency: item.router_data.request.currency,
},
bill_to,
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/cybersource/transformers.rs" role="context" start="971" end="1019">
fn get_commerce_indicator_for_external_authentication(
card_network: Option<String>,
eci: String,
) -> String {
let card_network_lower_case = card_network
.as_ref()
.map(|card_network| card_network.to_lowercase());
match eci.as_str() {
"00" | "01" | "02" => {
if matches!(
card_network_lower_case.as_deref(),
Some("mastercard") | Some("maestro")
) {
"spa"
} else {
"internet"
}
}
"05" => match card_network_lower_case.as_deref() {
Some("amex") => "aesk",
Some("discover") => "dipb",
Some("mastercard") => "spa",
Some("visa") => "vbv",
Some("diners") => "pb",
Some("upi") => "up3ds",
_ => "internet",
},
"06" => match card_network_lower_case.as_deref() {
Some("amex") => "aesk_attempted",
Some("discover") => "dipb_attempted",
Some("mastercard") => "spa",
Some("visa") => "vbv_attempted",
Some("diners") => "pb_attempted",
Some("upi") => "up3ds_attempted",
_ => "internet",
},
"07" => match card_network_lower_case.as_deref() {
Some("amex") => "internet",
Some("discover") => "internet",
Some("mastercard") => "spa",
Some("visa") => "vbv_failure",
Some("diners") => "internet",
Some("upi") => "up3ds_failure",
_ => "internet",
},
_ => "vbv_failure",
}
.to_string()
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/cybersource/transformers.rs" role="context" start="682" end="968">
fn try_from(
(item, solution, network): (
&CybersourceRouterData<&PaymentsAuthorizeRouterData>,
Option<PaymentSolution>,
Option<String>,
),
) -> Result<Self, Self::Error> {
let mut commerce_indicator = solution
.as_ref()
.map(|pm_solution| match pm_solution {
PaymentSolution::ApplePay | PaymentSolution::SamsungPay => network
.as_ref()
.map(|card_network| match card_network.to_lowercase().as_str() {
"amex" => "internet",
"discover" => "internet",
"mastercard" => "spa",
"visa" => "internet",
_ => "internet",
})
.unwrap_or("internet"),
PaymentSolution::GooglePay => "internet",
})
.unwrap_or("internet")
.to_string();
let connector_merchant_config =
CybersourceConnectorMetadataObject::try_from(&item.router_data.connector_meta_data)?;
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()))
{
(
Some(vec![CybersourceActionsList::TokenCreate]),
Some(vec![
CybersourceActionsTokenType::PaymentInstrument,
CybersourceActionsTokenType::Customer,
]),
Some(CybersourceAuthorizationOptions {
initiator: Some(CybersourcePaymentInitiator {
initiator_type: Some(CybersourcePaymentInitiatorTypes::Customer),
credential_stored_on_file: Some(true),
stored_credential_used: None,
}),
ignore_avs_result: connector_merchant_config.disable_avs,
ignore_cv_result: connector_merchant_config.disable_cvn,
merchant_intitiated_transaction: None,
}),
)
} else if item.router_data.request.mandate_id.is_some() {
match item
.router_data
.request
.mandate_id
.clone()
.and_then(|mandate_id| mandate_id.mandate_reference_id)
{
Some(payments::MandateReferenceId::ConnectorMandateId(_)) => {
let original_amount = item
.router_data
.recurring_mandate_payment_data
.as_ref()
.and_then(|recurring_mandate_payment_data| {
recurring_mandate_payment_data.original_payment_authorized_amount
});
let original_currency = item
.router_data
.recurring_mandate_payment_data
.as_ref()
.and_then(|recurring_mandate_payment_data| {
recurring_mandate_payment_data.original_payment_authorized_currency
});
let original_authorized_amount = match original_amount.zip(original_currency) {
Some((original_amount, original_currency)) => {
Some(utils::get_amount_as_string(
&api::CurrencyUnit::Base,
original_amount,
original_currency,
)?)
}
None => None,
};
(
None,
None,
Some(CybersourceAuthorizationOptions {
initiator: None,
merchant_intitiated_transaction: Some(MerchantInitiatedTransaction {
reason: None,
original_authorized_amount,
previous_transaction_id: None,
}),
ignore_avs_result: connector_merchant_config.disable_avs,
ignore_cv_result: connector_merchant_config.disable_cvn,
}),
)
}
Some(payments::MandateReferenceId::NetworkMandateId(network_transaction_id)) => {
let (original_amount, original_currency) = match network
.clone()
.map(|network| network.to_lowercase())
.as_deref()
{
//This is to make original_authorized_amount mandatory for discover card networks in NetworkMandateId flow
Some("004") => {
let original_amount = Some(
item.router_data
.get_recurring_mandate_payment_data()?
.get_original_payment_amount()?,
);
let original_currency = Some(
item.router_data
.get_recurring_mandate_payment_data()?
.get_original_payment_currency()?,
);
(original_amount, original_currency)
}
_ => {
let original_amount = item
.router_data
.recurring_mandate_payment_data
.as_ref()
.and_then(|recurring_mandate_payment_data| {
recurring_mandate_payment_data
.original_payment_authorized_amount
});
let original_currency = item
.router_data
.recurring_mandate_payment_data
.as_ref()
.and_then(|recurring_mandate_payment_data| {
recurring_mandate_payment_data
.original_payment_authorized_currency
});
(original_amount, original_currency)
}
};
let original_authorized_amount = match original_amount.zip(original_currency) {
Some((original_amount, original_currency)) => Some(
utils::to_currency_base_unit(original_amount, original_currency)?,
),
None => None,
};
commerce_indicator = "recurring".to_string();
(
None,
None,
Some(CybersourceAuthorizationOptions {
initiator: Some(CybersourcePaymentInitiator {
initiator_type: Some(CybersourcePaymentInitiatorTypes::Merchant),
credential_stored_on_file: None,
stored_credential_used: Some(true),
}),
merchant_intitiated_transaction: Some(MerchantInitiatedTransaction {
reason: Some("7".to_string()),
original_authorized_amount,
previous_transaction_id: Some(Secret::new(network_transaction_id)),
}),
ignore_avs_result: connector_merchant_config.disable_avs,
ignore_cv_result: connector_merchant_config.disable_cvn,
}),
)
}
Some(payments::MandateReferenceId::NetworkTokenWithNTI(mandate_data)) => {
let (original_amount, original_currency) = match network
.clone()
.map(|network| network.to_lowercase())
.as_deref()
{
//This is to make original_authorized_amount mandatory for discover card networks in NetworkMandateId flow
Some("004") => {
let original_amount = Some(
item.router_data
.get_recurring_mandate_payment_data()?
.get_original_payment_amount()?,
);
let original_currency = Some(
item.router_data
.get_recurring_mandate_payment_data()?
.get_original_payment_currency()?,
);
(original_amount, original_currency)
}
_ => {
let original_amount = item
.router_data
.recurring_mandate_payment_data
.as_ref()
.and_then(|recurring_mandate_payment_data| {
recurring_mandate_payment_data
.original_payment_authorized_amount
});
let original_currency = item
.router_data
.recurring_mandate_payment_data
.as_ref()
.and_then(|recurring_mandate_payment_data| {
recurring_mandate_payment_data
.original_payment_authorized_currency
});
(original_amount, original_currency)
}
};
let original_authorized_amount = match original_amount.zip(original_currency) {
Some((original_amount, original_currency)) => Some(
utils::to_currency_base_unit(original_amount, original_currency)?,
),
None => None,
};
commerce_indicator = "recurring".to_string(); //
(
None,
None,
Some(CybersourceAuthorizationOptions {
initiator: Some(CybersourcePaymentInitiator {
initiator_type: Some(CybersourcePaymentInitiatorTypes::Merchant),
credential_stored_on_file: None,
stored_credential_used: Some(true),
}),
merchant_intitiated_transaction: Some(MerchantInitiatedTransaction {
reason: Some("7".to_string()), // 7 is for MIT using NTI
original_authorized_amount,
previous_transaction_id: Some(Secret::new(
mandate_data.network_transaction_id,
)),
}),
ignore_avs_result: connector_merchant_config.disable_avs,
ignore_cv_result: connector_merchant_config.disable_cvn,
}),
)
}
None => (None, None, None),
}
} else {
(
None,
None,
Some(CybersourceAuthorizationOptions {
initiator: None,
merchant_intitiated_transaction: None,
ignore_avs_result: connector_merchant_config.disable_avs,
ignore_cv_result: connector_merchant_config.disable_cvn,
}),
)
};
// this logic is for external authenticated card
let commerce_indicator_for_external_authentication = item
.router_data
.request
.authentication_data
.as_ref()
.and_then(|authn_data| {
authn_data
.eci
.clone()
.map(|eci| get_commerce_indicator_for_external_authentication(network, eci))
});
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: commerce_indicator_for_external_authentication
.unwrap_or(commerce_indicator),
})
}
<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="3183" end="3191">
pub struct CybersourceConsumerAuthValidateResponse {
ucaf_collection_indicator: Option<String>,
cavv: Option<String>,
ucaf_authentication_data: Option<Secret<String>>,
xid: Option<String>,
specification_version: Option<String>,
directory_server_transaction_id: Option<Secret<String>>,
indicator: Option<String>,
}
<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/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="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="1660" end="1660">
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="1756" end="1821">
fn try_from(
(item, metadata): (
&BraintreeRouterData<&types::PaymentsAuthorizeRouterData>,
BraintreeMeta,
),
) -> Result<Self, Self::Error> {
let (query, transaction_body) = if item.router_data.request.is_mandate_payment() {
(
match item.router_data.request.is_auto_capture()? {
true => CHARGE_AND_VAULT_TRANSACTION_MUTATION.to_string(),
false => AUTHORIZE_AND_VAULT_CREDIT_CARD_MUTATION.to_string(),
},
TransactionBody::Vault(VaultTransactionBody {
amount: item.amount.to_owned(),
merchant_account_id: metadata.merchant_account_id,
vault_payment_method_after_transacting: TransactionTiming {
when: "ALWAYS".to_string(),
},
customer_details: item
.router_data
.get_billing_email()
.ok()
.map(|email| CustomerBody { email }),
order_id: item.router_data.connector_request_reference_id.clone(),
}),
)
} else {
(
match item.router_data.request.is_auto_capture()? {
true => CHARGE_CREDIT_CARD_MUTATION.to_string(),
false => AUTHORIZE_CREDIT_CARD_MUTATION.to_string(),
},
TransactionBody::Regular(RegularTransactionBody {
amount: item.amount.to_owned(),
merchant_account_id: metadata.merchant_account_id,
channel: CHANNEL_CODE.to_string(),
customer_details: item
.router_data
.get_billing_email()
.ok()
.map(|email| CustomerBody { email }),
order_id: item.router_data.connector_request_reference_id.clone(),
}),
)
};
Ok(Self {
query,
variables: VariablePaymentInput {
input: PaymentInput {
payment_method_id: match item.router_data.get_payment_method_token()? {
PaymentMethodToken::Token(token) => token,
PaymentMethodToken::ApplePayDecrypt(_) => Err(
unimplemented_payment_method!("Apple Pay", "Simplified", "Braintree"),
)?,
PaymentMethodToken::PazeDecrypt(_) => {
Err(unimplemented_payment_method!("Paze", "Braintree"))?
}
PaymentMethodToken::GooglePayDecrypt(_) => {
Err(unimplemented_payment_method!("Google Pay", "Braintree"))?
}
},
transaction: transaction_body,
},
},
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/braintree/transformers.rs" role="context" start="1735" end="1746">
fn try_from(metadata: BraintreeMeta) -> Result<Self, Self::Error> {
Ok(Self {
query: CLIENT_TOKEN_MUTATION.to_owned(),
variables: VariableClientTokenInput {
input: InputClientTokenData {
client_token: ClientTokenInput {
merchant_account_id: metadata.merchant_account_id,
},
},
},
})
}
<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="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="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/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/iatapay/transformers.rs<|crate|> hyperswitch_connectors<|connector|> iatapay 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/iatapay/transformers.rs" role="context" start="637" end="663">
fn try_from(payload: IatapayWebhookResponse) -> CustomResult<Self, errors::ConnectorError> {
match payload {
IatapayWebhookResponse::IatapayPaymentWebhookBody(wh_body) => match wh_body.status {
IatapayWebhookStatus::Authorized | IatapayWebhookStatus::Settled => {
Ok(Self::PaymentIntentSuccess)
}
IatapayWebhookStatus::Initiated => Ok(Self::PaymentIntentProcessing),
IatapayWebhookStatus::Failed => Ok(Self::PaymentIntentFailure),
IatapayWebhookStatus::Created
| IatapayWebhookStatus::Cleared
| IatapayWebhookStatus::Tobeinvestigated
| IatapayWebhookStatus::Blocked
| IatapayWebhookStatus::UnexpectedSettled
| IatapayWebhookStatus::Unknown => Ok(Self::EventNotSupported),
},
IatapayWebhookResponse::IatapayRefundWebhookBody(wh_body) => match wh_body.status {
IatapayRefundWebhookStatus::Cleared
| IatapayRefundWebhookStatus::Authorized
| IatapayRefundWebhookStatus::Settled => Ok(Self::RefundSuccess),
IatapayRefundWebhookStatus::Failed => Ok(Self::RefundFailure),
IatapayRefundWebhookStatus::Created
| IatapayRefundWebhookStatus::Locked
| IatapayRefundWebhookStatus::Initiated
| IatapayRefundWebhookStatus::Unknown => Ok(Self::EventNotSupported),
},
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/iatapay/transformers.rs" role="context" start="636" end="636">
use common_utils::{
errors::CustomResult, ext_traits::Encode, request::Method, types::FloatMajorUnit,
};
type Error = error_stack::Report<errors::ConnectorError>;
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/iatapay/transformers.rs" role="context" start="553" end="586">
fn try_from(
item: RefundsResponseRouterData<RSync, RefundResponse>,
) -> Result<Self, Self::Error> {
let refund_status = enums::RefundStatus::from(item.response.status);
let response = if is_refund_failure(refund_status) {
Err(ErrorResponse {
code: item
.response
.failure_code
.unwrap_or_else(|| NO_ERROR_CODE.to_string()),
message: item
.response
.failure_details
.clone()
.unwrap_or_else(|| NO_ERROR_MESSAGE.to_string()),
reason: item.response.failure_details,
status_code: item.http_code,
attempt_status: None,
connector_transaction_id: Some(item.response.iata_refund_id.clone()),
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
})
} else {
Ok(RefundsResponseData {
connector_refund_id: item.response.iata_refund_id.to_string(),
refund_status,
})
};
Ok(Self {
response,
..item.data
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/iatapay/transformers.rs" role="context" start="514" end="548">
fn try_from(
item: RefundsResponseRouterData<Execute, RefundResponse>,
) -> Result<Self, Self::Error> {
let refund_status = enums::RefundStatus::from(item.response.status);
let response = if is_refund_failure(refund_status) {
Err(ErrorResponse {
code: item
.response
.failure_code
.unwrap_or_else(|| NO_ERROR_CODE.to_string()),
message: item
.response
.failure_details
.clone()
.unwrap_or_else(|| NO_ERROR_MESSAGE.to_string()),
reason: item.response.failure_details,
status_code: item.http_code,
attempt_status: None,
connector_transaction_id: Some(item.response.iata_refund_id.clone()),
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
})
} else {
Ok(RefundsResponseData {
connector_refund_id: item.response.iata_refund_id.to_string(),
refund_status,
})
};
Ok(Self {
response,
..item.data
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/iatapay/transformers.rs" role="context" start="132" end="233">
fn try_from(
item: &IatapayRouterData<
&RouterData<Authorize, PaymentsAuthorizeData, PaymentsResponseData>,
>,
) -> Result<Self, Self::Error> {
let return_url = item.router_data.request.get_router_return_url()?;
// Iatapay processes transactions through the payment method selected based on the country
let (country, payer_info, preferred_checkout_method) = match item
.router_data
.request
.payment_method_data
.clone()
{
PaymentMethodData::Upi(upi_type) => match upi_type {
UpiData::UpiCollect(upi_data) => (
common_enums::CountryAlpha2::IN,
upi_data.vpa_id.map(|id| PayerInfo {
token_id: id.switch_strategy(),
}),
None,
),
UpiData::UpiIntent(_) => (
common_enums::CountryAlpha2::IN,
None,
Some(PreferredCheckoutMethod::Qr),
),
},
PaymentMethodData::BankRedirect(bank_redirect_data) => match bank_redirect_data {
BankRedirectData::Ideal { .. } => (common_enums::CountryAlpha2::NL, None, None),
BankRedirectData::LocalBankRedirect {} => {
(common_enums::CountryAlpha2::AT, None, None)
}
BankRedirectData::BancontactCard { .. }
| BankRedirectData::Bizum {}
| BankRedirectData::Blik { .. }
| BankRedirectData::Eft { .. }
| BankRedirectData::Eps { .. }
| BankRedirectData::Giropay { .. }
| BankRedirectData::Interac { .. }
| BankRedirectData::OnlineBankingCzechRepublic { .. }
| BankRedirectData::OnlineBankingFinland { .. }
| BankRedirectData::OnlineBankingPoland { .. }
| BankRedirectData::OnlineBankingSlovakia { .. }
| BankRedirectData::OpenBankingUk { .. }
| BankRedirectData::Przelewy24 { .. }
| BankRedirectData::Sofort { .. }
| BankRedirectData::Trustly { .. }
| BankRedirectData::OnlineBankingFpx { .. }
| BankRedirectData::OnlineBankingThailand { .. } => {
Err(errors::ConnectorError::NotImplemented(
get_unimplemented_payment_method_error_message("iatapay"),
))?
}
},
PaymentMethodData::RealTimePayment(real_time_payment_data) => {
match *real_time_payment_data {
RealTimePaymentData::DuitNow {} => {
(common_enums::CountryAlpha2::MY, None, None)
}
RealTimePaymentData::Fps {} => (common_enums::CountryAlpha2::HK, None, None),
RealTimePaymentData::PromptPay {} => {
(common_enums::CountryAlpha2::TH, None, None)
}
RealTimePaymentData::VietQr {} => (common_enums::CountryAlpha2::VN, None, None),
}
}
PaymentMethodData::Card(_)
| PaymentMethodData::CardRedirect(_)
| PaymentMethodData::Wallet(_)
| PaymentMethodData::PayLater(_)
| PaymentMethodData::BankDebit(_)
| PaymentMethodData::BankTransfer(_)
| PaymentMethodData::Crypto(_)
| PaymentMethodData::MandatePayment
| PaymentMethodData::Reward
| PaymentMethodData::MobilePayment(_)
| PaymentMethodData::Voucher(_)
| PaymentMethodData::GiftCard(_)
| PaymentMethodData::CardToken(_)
| PaymentMethodData::OpenBanking(_)
| PaymentMethodData::NetworkToken(_)
| PaymentMethodData::CardDetailsForNetworkTransactionId(_) => {
Err(errors::ConnectorError::NotImplemented(
get_unimplemented_payment_method_error_message("iatapay"),
))?
}
};
let payload = Self {
merchant_id: IatapayAuthType::try_from(&item.router_data.connector_auth_type)?
.merchant_id,
merchant_payment_id: Some(item.router_data.connector_request_reference_id.clone()),
amount: item.amount,
currency: item.router_data.request.currency,
country,
locale: format!("en-{}", country),
redirect_urls: get_redirect_url(return_url),
payer_info,
notification_url: item.router_data.request.get_webhook_url()?,
preferred_checkout_method,
};
Ok(payload)
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/iatapay/transformers.rs" role="context" start="446" end="456">
fn try_from(item: &IatapayRouterData<&RefundsRouterData<F>>) -> Result<Self, Self::Error> {
Ok(Self {
amount: item.amount,
merchant_id: IatapayAuthType::try_from(&item.router_data.connector_auth_type)?
.merchant_id,
merchant_refund_id: Some(item.router_data.request.refund_id.clone()),
currency: item.router_data.request.currency.to_string(),
bank_transfer_description: item.router_data.request.reason.clone(),
notification_url: item.router_data.request.get_webhook_url()?,
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/iatapay/transformers.rs" role="context" start="685" end="695">
pub enum IatapayRefundWebhookStatus {
Created,
Initiated,
Authorized,
Settled,
Failed,
Cleared,
Locked,
#[serde(other)]
Unknown,
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/iatapay/transformers.rs" role="context" start="668" end="681">
pub enum IatapayWebhookStatus {
Created,
Initiated,
Authorized,
Settled,
Cleared,
Failed,
Tobeinvestigated,
Blocked,
#[serde(rename = "UNEXPECTED SETTLED")]
UnexpectedSettled,
#[serde(other)]
Unknown,
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/iatapay/transformers.rs" role="context" start="630" end="633">
pub enum IatapayWebhookResponse {
IatapayPaymentWebhookBody(IatapayPaymentWebhookBody),
IatapayRefundWebhookBody(IatapayRefundWebhookBody),
}
| 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="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="191" end="191">
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="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="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="149" end="154">
fn from(item: GlobepayPaymentStatus) -> Self {
match item {
GlobepayPaymentStatus::Success => Self::AuthenticationPending, // this connector only have redirection flows so "Success" is mapped to authenticatoin pending ,ref = "https://pay.globepay.co/docs/en/#api-QRCode-NewQRCode"
GlobepayPaymentStatus::Exists => Self::Failure,
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/globepay/transformers.rs" role="context" start="130" end="138">
fn try_from(auth_type: &ConnectorAuthType) -> Result<Self, Self::Error> {
match auth_type {
ConnectorAuthType::BodyKey { api_key, key1 } => Ok(Self {
partner_code: api_key.to_owned(),
credential_code: key1.to_owned(),
}),
_ => Err(errors::ConnectorError::FailedToObtainAuthType.into()),
}
}
<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="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="173" end="186">
pub enum GlobepayReturnCode {
Success,
OrderNotExist,
OrderMismatch,
Systemerror,
InvalidShortId,
SignTimeout,
InvalidSign,
ParamInvalid,
NotPermitted,
InvalidChannel,
DuplicateOrderId,
OrderNotPaid,
}
<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/trustpay/transformers.rs<|crate|> hyperswitch_connectors<|connector|> trustpay anchor=handle_bank_redirects_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="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="916" end="916">
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="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="981" end="1030">
pub fn handle_webhook_response(
payment_information: WebhookPaymentInformation,
status_code: u16,
) -> CustomResult<
(
enums::AttemptStatus,
Option<ErrorResponse>,
PaymentsResponseData,
),
errors::ConnectorError,
> {
let status = enums::AttemptStatus::try_from(payment_information.status)?;
let error = if utils::is_payment_failure(status) {
let reason_info = 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: 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::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="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="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="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/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/adyen/transformers.rs<|crate|> hyperswitch_connectors<|connector|> adyen anchor=get_redirection_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/adyen/transformers.rs" role="context" start="4090" end="4143">
pub fn get_redirection_error_response(
response: RedirectionErrorResponse,
is_manual_capture: bool,
status_code: u16,
pmt: Option<storage_enums::PaymentMethodType>,
) -> CustomResult<
(
storage_enums::AttemptStatus,
Option<ErrorResponse>,
PaymentsResponseData,
),
errors::ConnectorError,
> {
let status = get_adyen_payment_status(is_manual_capture, response.result_code, pmt);
let error = Some(ErrorResponse {
code: status.to_string(),
message: response
.refusal_reason
.clone()
.unwrap_or_else(|| NO_ERROR_MESSAGE.to_string()),
reason: response.refusal_reason,
status_code,
attempt_status: None,
connector_transaction_id: response.psp_reference.clone(),
network_advice_code: response
.additional_data
.as_ref()
.and_then(|data| data.extract_network_advice_code()),
network_decline_code: response
.additional_data
.as_ref()
.and_then(|data| data.refusal_code_raw.clone()),
network_error_message: response
.additional_data
.as_ref()
.and_then(|data| data.refusal_reason_raw.clone()),
});
// We don't get connector transaction id for redirections in Adyen.
let payments_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: response
.merchant_reference
.clone()
.or(response.psp_reference),
incremental_authorization_allowed: None,
charges: None,
};
Ok((status, error, payments_response_data))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/adyen/transformers.rs" role="context" start="4089" end="4089">
connector_metadata,
network_txn_id: None,
connector_response_reference_id: response
.merchant_reference
.clone()
.or(response.psp_reference),
incremental_authorization_allowed: None,
charges,
};
Ok((status, error, payments_response_data))
}
pub fn get_redirection_error_response(
response: RedirectionErrorResponse,
is_manual_capture: bool,
status_code: u16,
pmt: Option<storage_enums::PaymentMethodType>,
) -> CustomResult<
(
storage_enums::AttemptStatus,
Option<ErrorResponse>,
PaymentsResponseData,
),
errors::ConnectorError,
> {
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/adyen/transformers.rs" role="context" start="4197" end="4280">
pub fn get_wait_screen_metadata(
next_action: &RedirectionResponse,
) -> CustomResult<Option<serde_json::Value>, errors::ConnectorError> {
match next_action.action.payment_method_type {
PaymentType::Blik => {
let current_time = OffsetDateTime::now_utc().unix_timestamp_nanos();
Ok(Some(serde_json::json!(WaitScreenData {
display_from_timestamp: current_time,
display_to_timestamp: Some(current_time + Duration::minutes(1).whole_nanoseconds())
})))
}
PaymentType::Mbway => {
let current_time = OffsetDateTime::now_utc().unix_timestamp_nanos();
Ok(Some(serde_json::json!(WaitScreenData {
display_from_timestamp: current_time,
display_to_timestamp: None
})))
}
PaymentType::Affirm
| PaymentType::Oxxo
| PaymentType::Afterpaytouch
| PaymentType::Alipay
| PaymentType::AlipayHk
| PaymentType::Alfamart
| PaymentType::Alma
| PaymentType::Applepay
| PaymentType::Bizum
| PaymentType::Atome
| PaymentType::BoletoBancario
| PaymentType::ClearPay
| PaymentType::Dana
| PaymentType::Eps
| PaymentType::Gcash
| PaymentType::Googlepay
| PaymentType::GoPay
| PaymentType::Ideal
| PaymentType::Indomaret
| PaymentType::Klarna
| PaymentType::Kakaopay
| PaymentType::MobilePay
| PaymentType::Momo
| PaymentType::MomoAtm
| PaymentType::OnlineBankingCzechRepublic
| PaymentType::OnlineBankingFinland
| PaymentType::OnlineBankingPoland
| PaymentType::OnlineBankingSlovakia
| PaymentType::OnlineBankingFpx
| PaymentType::OnlineBankingThailand
| PaymentType::OpenBankingUK
| PaymentType::PayBright
| PaymentType::Paypal
| PaymentType::Scheme
| PaymentType::NetworkToken
| PaymentType::Trustly
| PaymentType::TouchNGo
| PaymentType::Walley
| PaymentType::WeChatPayWeb
| PaymentType::AchDirectDebit
| PaymentType::SepaDirectDebit
| PaymentType::BacsDirectDebit
| PaymentType::Samsungpay
| PaymentType::Twint
| PaymentType::Vipps
| PaymentType::Swish
| PaymentType::Knet
| PaymentType::Benefit
| PaymentType::PermataBankTransfer
| PaymentType::BcaBankTransfer
| PaymentType::BniVa
| PaymentType::BriVa
| PaymentType::CimbVa
| PaymentType::DanamonVa
| PaymentType::Giftcard
| PaymentType::MandiriVa
| PaymentType::PaySafeCard
| PaymentType::SevenEleven
| PaymentType::Lawson
| PaymentType::MiniStop
| PaymentType::FamilyMart
| PaymentType::Seicomart
| PaymentType::PayEasy
| PaymentType::Pix => Ok(None),
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/adyen/transformers.rs" role="context" start="4145" end="4189">
pub fn get_qr_metadata(
response: &QrCodeResponseResponse,
) -> CustomResult<Option<serde_json::Value>, errors::ConnectorError> {
let image_data = utils::QrImage::new_from_data(response.action.qr_code_data.clone())
.change_context(errors::ConnectorError::ResponseHandlingFailed)?;
let image_data_url = Url::parse(image_data.data.clone().as_str()).ok();
let qr_code_url = response.action.qr_code_url.clone();
let display_to_timestamp = response
.additional_data
.clone()
.and_then(|additional_data| additional_data.pix_expiration_date)
.map(|time| utils::get_timestamp_in_milliseconds(&time));
if let (Some(image_data_url), Some(qr_code_url)) = (image_data_url.clone(), qr_code_url.clone())
{
let qr_code_info = QrCodeInformation::QrCodeUrl {
image_data_url,
qr_code_url,
display_to_timestamp,
};
Some(qr_code_info.encode_to_value())
.transpose()
.change_context(errors::ConnectorError::ResponseHandlingFailed)
} else if let (None, Some(qr_code_url)) = (image_data_url.clone(), qr_code_url.clone()) {
let qr_code_info = QrCodeInformation::QrCodeImageUrl {
qr_code_url,
display_to_timestamp,
};
Some(qr_code_info.encode_to_value())
.transpose()
.change_context(errors::ConnectorError::ResponseHandlingFailed)
} else if let (Some(image_data_url), None) = (image_data_url, qr_code_url) {
let qr_code_info = QrCodeInformation::QrDataUrl {
image_data_url,
display_to_timestamp,
};
Some(qr_code_info.encode_to_value())
.transpose()
.change_context(errors::ConnectorError::ResponseHandlingFailed)
} else {
Ok(None)
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/adyen/transformers.rs" role="context" start="4023" end="4088">
pub fn get_qr_code_response(
response: QrCodeResponseResponse,
is_manual_capture: bool,
status_code: u16,
pmt: Option<storage_enums::PaymentMethodType>,
) -> CustomResult<
(
storage_enums::AttemptStatus,
Option<ErrorResponse>,
PaymentsResponseData,
),
errors::ConnectorError,
> {
let status = get_adyen_payment_status(is_manual_capture, response.result_code.clone(), pmt);
let error = if response.refusal_reason.is_some()
|| response.refusal_reason_code.is_some()
|| status == storage_enums::AttemptStatus::Failure
{
Some(ErrorResponse {
code: response
.refusal_reason_code
.clone()
.unwrap_or_else(|| NO_ERROR_CODE.to_string()),
message: response
.refusal_reason
.clone()
.unwrap_or_else(|| NO_ERROR_MESSAGE.to_string()),
reason: response.refusal_reason.to_owned(),
status_code,
attempt_status: None,
connector_transaction_id: response.psp_reference.clone(),
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
})
} else {
None
};
let charges = match &response.splits {
Some(split_items) => Some(construct_charge_response(
response.store.clone(),
split_items,
)),
None => None,
};
let connector_metadata = get_qr_metadata(&response)?;
let payments_response_data = PaymentsResponseData::TransactionResponse {
resource_id: match response.psp_reference.as_ref() {
Some(psp) => ResponseId::ConnectorTransactionId(psp.to_string()),
None => ResponseId::NoResponseId,
},
redirection_data: Box::new(None),
mandate_reference: Box::new(None),
connector_metadata,
network_txn_id: None,
connector_response_reference_id: response
.merchant_reference
.clone()
.or(response.psp_reference),
incremental_authorization_allowed: None,
charges,
};
Ok((status, error, payments_response_data))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/adyen/transformers.rs" role="context" start="3955" end="4021">
pub fn get_present_to_shopper_response(
response: PresentToShopperResponse,
is_manual_capture: bool,
status_code: u16,
pmt: Option<storage_enums::PaymentMethodType>,
) -> CustomResult<
(
storage_enums::AttemptStatus,
Option<ErrorResponse>,
PaymentsResponseData,
),
errors::ConnectorError,
> {
let status = get_adyen_payment_status(is_manual_capture, response.result_code.clone(), pmt);
let error = if response.refusal_reason.is_some()
|| response.refusal_reason_code.is_some()
|| status == storage_enums::AttemptStatus::Failure
{
Some(ErrorResponse {
code: response
.refusal_reason_code
.clone()
.unwrap_or_else(|| NO_ERROR_CODE.to_string()),
message: response
.refusal_reason
.clone()
.unwrap_or_else(|| NO_ERROR_MESSAGE.to_string()),
reason: response.refusal_reason.to_owned(),
status_code,
attempt_status: None,
connector_transaction_id: response.psp_reference.clone(),
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
})
} else {
None
};
let charges = match &response.splits {
Some(split_items) => Some(construct_charge_response(
response.store.clone(),
split_items,
)),
None => None,
};
let connector_metadata = get_present_to_shopper_metadata(&response)?;
// We don't get connector transaction id for redirections in Adyen.
let payments_response_data = PaymentsResponseData::TransactionResponse {
resource_id: match response.psp_reference.as_ref() {
Some(psp) => ResponseId::ConnectorTransactionId(psp.to_string()),
None => ResponseId::NoResponseId,
},
redirection_data: Box::new(None),
mandate_reference: Box::new(None),
connector_metadata,
network_txn_id: None,
connector_response_reference_id: response
.merchant_reference
.clone()
.or(response.psp_reference),
incremental_authorization_allowed: None,
charges,
};
Ok((status, error, payments_response_data))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/adyen/transformers.rs" role="context" start="4393" end="4431">
fn foreign_try_from(
(item, capture_method, is_multiple_capture_psync_flow, pmt): (
ResponseRouterData<F, AdyenPaymentResponse, Req, PaymentsResponseData>,
Option<storage_enums::CaptureMethod>,
bool,
Option<storage_enums::PaymentMethodType>,
),
) -> Result<Self, Self::Error> {
let is_manual_capture = is_manual_capture(capture_method);
let (status, error, payment_response_data) = match item.response {
AdyenPaymentResponse::Response(response) => {
get_adyen_response(*response, is_manual_capture, item.http_code, pmt)?
}
AdyenPaymentResponse::PresentToShopper(response) => {
get_present_to_shopper_response(*response, is_manual_capture, item.http_code, pmt)?
}
AdyenPaymentResponse::QrCodeResponse(response) => {
get_qr_code_response(*response, is_manual_capture, item.http_code, pmt)?
}
AdyenPaymentResponse::RedirectionResponse(response) => {
get_redirection_response(*response, is_manual_capture, item.http_code, pmt)?
}
AdyenPaymentResponse::RedirectionErrorResponse(response) => {
get_redirection_error_response(*response, is_manual_capture, item.http_code, pmt)?
}
AdyenPaymentResponse::WebhookResponse(response) => get_webhook_response(
*response,
is_manual_capture,
is_multiple_capture_psync_flow,
item.http_code,
)?,
};
Ok(Self {
status,
response: error.map_or_else(|| Ok(payment_response_data), Err),
..item.data
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/adyen/transformers.rs" role="context" start="372" end="407">
fn get_adyen_payment_status(
is_manual_capture: bool,
adyen_status: AdyenStatus,
pmt: Option<common_enums::PaymentMethodType>,
) -> storage_enums::AttemptStatus {
match adyen_status {
AdyenStatus::AuthenticationFinished => {
storage_enums::AttemptStatus::AuthenticationSuccessful
}
AdyenStatus::AuthenticationNotRequired | AdyenStatus::Received => {
storage_enums::AttemptStatus::Pending
}
AdyenStatus::Authorised => match is_manual_capture {
true => storage_enums::AttemptStatus::Authorized,
// In case of Automatic capture Authorized is the final status of the payment
false => storage_enums::AttemptStatus::Charged,
},
AdyenStatus::Cancelled => storage_enums::AttemptStatus::Voided,
AdyenStatus::ChallengeShopper
| AdyenStatus::RedirectShopper
| AdyenStatus::PresentToShopper => storage_enums::AttemptStatus::AuthenticationPending,
AdyenStatus::Error | AdyenStatus::Refused => storage_enums::AttemptStatus::Failure,
AdyenStatus::Pending => match pmt {
Some(common_enums::PaymentMethodType::Pix) => {
storage_enums::AttemptStatus::AuthenticationPending
}
_ => storage_enums::AttemptStatus::Pending,
},
#[cfg(feature = "payouts")]
AdyenStatus::PayoutConfirmReceived => storage_enums::AttemptStatus::Started,
#[cfg(feature = "payouts")]
AdyenStatus::PayoutSubmitReceived => storage_enums::AttemptStatus::Pending,
#[cfg(feature = "payouts")]
AdyenStatus::PayoutDeclineReceived => storage_enums::AttemptStatus::Voided,
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/adyen/transformers.rs" role="context" start="532" end="538">
pub struct RedirectionErrorResponse {
result_code: AdyenStatus,
refusal_reason: Option<String>,
psp_reference: Option<String>,
merchant_reference: Option<String>,
additional_data: Option<AdditionalData>,
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/adyen.rs" role="context" start="95" end="97">
pub struct Adyen {
amount_converter: &'static (dyn AmountConvertor<Output = MinorUnit> + Sync),
}
<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/masking/src/maskable.rs<|crate|> masking anchor=new_normal kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=1<|meta_end|>
<file_sep path="hyperswitch/crates/masking/src/maskable.rs" role="context" start="48" end="50">
pub fn new_normal(item: T) -> Self {
Self::Normal(item)
}
<file_sep path="hyperswitch/crates/masking/src/maskable.rs" role="context" start="62" end="64">
pub fn is_normal(&self) -> bool {
matches!(self, Self::Normal(_))
}
<file_sep path="hyperswitch/crates/masking/src/maskable.rs" role="context" start="55" end="57">
pub fn is_masked(&self) -> bool {
matches!(self, Self::Masked(_))
}
<file_sep path="hyperswitch/crates/masking/src/maskable.rs" role="context" start="43" end="45">
pub fn new_masked(item: Secret<T>) -> Self {
Self::Masked(item)
}
<file_sep path="hyperswitch/crates/masking/src/maskable.rs" role="context" start="35" end="40">
pub fn into_inner(self) -> T {
match self {
Self::Masked(inner_secret) => inner_secret.expose(),
Self::Normal(inner) => inner,
}
}
<file_sep path="hyperswitch/crates/masking/src/maskable.rs" role="context" start="97" end="99">
fn from(value: &str) -> Self {
Self::new_normal(value.to_string())
}
<file_sep path="hyperswitch/crates/masking/src/maskable.rs" role="context" start="91" end="93">
fn from(value: T) -> Self {
Self::new_normal(value)
}
| symbol_neighborhood |
<|meta_start|><|file|> hyperswitch/crates/masking/src/maskable.rs<|crate|> masking anchor=new_masked kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=1<|meta_end|>
<file_sep path="hyperswitch/crates/masking/src/maskable.rs" role="context" start="43" end="45">
pub fn new_masked(item: Secret<T>) -> Self {
Self::Masked(item)
}
<file_sep path="hyperswitch/crates/masking/src/maskable.rs" role="context" start="42" end="42">
use crate::{ExposeInterface, Secret};
<file_sep path="hyperswitch/crates/masking/src/maskable.rs" role="context" start="55" end="57">
pub fn is_masked(&self) -> bool {
matches!(self, Self::Masked(_))
}
<file_sep path="hyperswitch/crates/masking/src/maskable.rs" role="context" start="48" end="50">
pub fn new_normal(item: T) -> Self {
Self::Normal(item)
}
<file_sep path="hyperswitch/crates/masking/src/maskable.rs" role="context" start="35" end="40">
pub fn into_inner(self) -> T {
match self {
Self::Masked(inner_secret) => inner_secret.expose(),
Self::Normal(inner) => inner,
}
}
<file_sep path="hyperswitch/crates/masking/src/maskable.rs" role="context" start="25" end="30">
fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
match self {
Self::Masked(value) => crate::PeekInterface::peek(value).hash(state),
Self::Normal(value) => value.hash(state),
}
}
<file_sep path="hyperswitch/crates/masking/src/maskable.rs" role="context" start="78" end="80">
fn into_masked(self) -> Maskable<Self::Output> {
Maskable::new_masked(self.into())
}
<file_sep path="hyperswitch/crates/masking/src/maskable.rs" role="context" start="85" end="87">
fn into_masked(self) -> Maskable<Self::Output> {
Maskable::new_masked(self)
}
| symbol_neighborhood |
<|meta_start|><|file|> hyperswitch/crates/common_utils/src/id_type.rs<|crate|> common_utils anchor=new kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=1<|meta_end|>
<file_sep path="hyperswitch/crates/common_utils/src/id_type.rs" role="context" start="165" end="167">
pub fn new(prefix: &str) -> Self {
Self(AlphaNumericId::new(prefix))
}
<file_sep path="hyperswitch/crates/common_utils/src/id_type.rs" role="context" start="164" end="164">
pub use self::global_id::{
customer::GlobalCustomerId,
payment::{GlobalAttemptId, GlobalPaymentId},
payment_methods::{GlobalPaymentMethodId, GlobalPaymentMethodSessionId},
refunds::GlobalRefundId,
CellId,
};
pub use self::{
api_key::ApiKeyId,
client_secret::ClientSecretId,
customer::CustomerId,
merchant::MerchantId,
merchant_connector_account::MerchantConnectorAccountId,
organization::OrganizationId,
payment::{PaymentId, PaymentReferenceId},
profile::ProfileId,
refunds::RefundReferenceId,
relay::RelayId,
routing::RoutingId,
tenant::TenantId,
};
<file_sep path="hyperswitch/crates/common_utils/src/id_type.rs" role="context" start="176" end="192">
pub(crate) fn from_alphanumeric_id(
alphanumeric_id: AlphaNumericId,
) -> Result<Self, LengthIdError> {
let length_of_input_string = alphanumeric_id.0.len();
let length_of_input_string = u8::try_from(length_of_input_string)
.map_err(|_| LengthIdError::MaxLengthViolated(MAX_LENGTH))?;
when(length_of_input_string > MAX_LENGTH, || {
Err(LengthIdError::MaxLengthViolated(MAX_LENGTH))
})?;
when(length_of_input_string < MIN_LENGTH, || {
Err(LengthIdError::MinLengthViolated(MIN_LENGTH))
})?;
Ok(Self(alphanumeric_id))
}
<file_sep path="hyperswitch/crates/common_utils/src/id_type.rs" role="context" start="170" end="172">
pub(crate) fn new_unchecked(alphanumeric_id: AlphaNumericId) -> Self {
Self(alphanumeric_id)
}
<file_sep path="hyperswitch/crates/common_utils/src/id_type.rs" role="context" start="143" end="162">
pub fn from(input_string: Cow<'static, str>) -> Result<Self, LengthIdError> {
let trimmed_input_string = input_string.trim().to_string();
let length_of_input_string = u8::try_from(trimmed_input_string.len())
.map_err(|_| LengthIdError::MaxLengthViolated(MAX_LENGTH))?;
when(length_of_input_string > MAX_LENGTH, || {
Err(LengthIdError::MaxLengthViolated(MAX_LENGTH))
})?;
when(length_of_input_string < MIN_LENGTH, || {
Err(LengthIdError::MinLengthViolated(MIN_LENGTH))
})?;
let alphanumeric_id = match AlphaNumericId::from(trimmed_input_string.into()) {
Ok(valid_alphanumeric_id) => valid_alphanumeric_id,
Err(error) => Err(LengthIdError::AlphanumericIdError(error))?,
};
Ok(Self(alphanumeric_id))
}
<file_sep path="hyperswitch/crates/common_utils/src/id_type.rs" role="context" start="136" end="138">
fn from(alphanumeric_id_error: AlphaNumericIdError) -> Self {
Self::AlphanumericIdError(alphanumeric_id_error)
}
<file_sep path="hyperswitch/crates/common_utils/src/id_type.rs" role="context" start="71" end="71">
pub(crate) struct AlphaNumericId(String);
| symbol_neighborhood |
<|meta_start|><|file|> hyperswitch/crates/masking/src/serde.rs<|crate|> masking anchor=masked_serialize kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/masking/src/serde.rs" role="context" start="111" end="113">
fn masked_serialize(&self) -> Result<Value, serde_json::Error> {
masked_serialize(self)
}
<file_sep path="hyperswitch/crates/masking/src/serde.rs" role="context" start="110" end="110">
use serde_json::{value::Serializer as JsonValueSerializer, Value};
<file_sep path="hyperswitch/crates/masking/src/serde.rs" role="context" start="126" end="131">
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: Serializer,
{
erased_serde::serialize(self, serializer)
}
<file_sep path="hyperswitch/crates/masking/src/serde.rs" role="context" start="117" end="122">
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: Serializer,
{
erased_serde::serialize(self, serializer)
}
<file_sep path="hyperswitch/crates/masking/src/serde.rs" role="context" start="92" end="96">
pub fn masked_serialize<T: Serialize>(value: &T) -> Result<Value, serde_json::Error> {
value.serialize(PIISerializer {
inner: JsonValueSerializer,
})
}
<file_sep path="hyperswitch/crates/masking/src/serde.rs" role="context" start="79" end="84">
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: Serializer,
{
pii_serializer::pii_serialize(self, serializer)
}
<file_sep path="hyperswitch/crates/masking/src/serde.rs" role="context" start="181" end="181">
type Error = serde_json::Error;
<file_sep path="hyperswitch/crates/masking/src/bytes.rs" role="context" start="63" end="63">
type Value = SecretBytesMut;
<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-card-vault/src/config.rs<|crate|> src anchor=new kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=1<|meta_end|>
<file_sep path="hyperswitch-card-vault/src/config.rs" role="context" start="180" end="182">
pub fn new() -> Result<Self, config::ConfigError> {
Self::new_with_config_path(None)
}
<file_sep path="hyperswitch-card-vault/src/config.rs" role="context" start="179" end="179">
use crate::{
api_client::ApiClientConfig,
crypto::secrets_manager::{
secrets_interface::SecretManager, secrets_management::SecretsManagementConfig,
},
error,
logger::config::Log,
};
<file_sep path="hyperswitch-card-vault/src/config.rs" role="context" start="202" end="210">
pub fn builder(
environment: &Env,
) -> Result<config::ConfigBuilder<config::builder::DefaultState>, config::ConfigError> {
config::Config::builder()
// Here, it should be `set_override()` not `set_default()`.
// "env" can't be altered by config field.
// Should be single source of truth.
.set_override("env", environment.to_string())
}
<file_sep path="hyperswitch-card-vault/src/config.rs" role="context" start="185" end="200">
pub fn new_with_config_path(
explicit_config_path: Option<PathBuf>,
) -> Result<Self, config::ConfigError> {
let env = Env::current_env();
let config_path = Self::config_path(&env, explicit_config_path);
let config = Self::builder(&env)?
.add_source(config::File::from(config_path).required(false))
.add_source(config::Environment::with_prefix("LOCKER").separator("__"))
.build()?;
serde_path_to_error::deserialize(config).map_err(|error| {
eprintln!("Unable to deserialize application configuration: {error}");
error.into_inner()
})
}
<file_sep path="hyperswitch-card-vault/src/config.rs" role="context" start="170" end="176">
pub fn workspace_path() -> PathBuf {
if let Ok(manifest_dir) = std::env::var("CARGO_MANIFEST_DIR") {
PathBuf::from(manifest_dir)
} else {
PathBuf::from(".")
}
}
<file_sep path="hyperswitch-card-vault/src/config.rs" role="context" start="159" end="166">
fn default() -> Self {
Self {
client_idle_timeout: 90,
pool_max_idle_per_host: 5,
#[cfg(feature = "external_key_manager_mtls")]
identity: masking::Secret::default(),
}
}
<file_sep path="hyperswitch-card-vault/src/config.rs" role="context" start="213" end="226">
pub fn config_path(environment: &Env, explicit_config_path: Option<PathBuf>) -> PathBuf {
let mut config_path = PathBuf::new();
if let Some(explicit_config_path_val) = explicit_config_path {
config_path.push(explicit_config_path_val);
} else {
let config_directory: String = "config".into();
let config_file_name = environment.config_path();
config_path.push(workspace_path());
config_path.push(config_directory);
config_path.push(config_file_name);
}
config_path
}
| symbol_neighborhood |
<|meta_start|><|file|> hyperswitch/crates/common_utils/src/lib.rs<|crate|> common_utils anchor=now kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=1<|meta_end|>
<file_sep path="hyperswitch/crates/common_utils/src/lib.rs" role="context" start="69" end="72">
pub fn now() -> PrimitiveDateTime {
let utc_date_time = OffsetDateTime::now_utc();
PrimitiveDateTime::new(utc_date_time.date(), utc_date_time.time())
}
<file_sep path="hyperswitch/crates/common_utils/src/lib.rs" role="context" start="68" end="68">
pub use base64_serializer::Base64Serializer;
<file_sep path="hyperswitch/crates/common_utils/src/lib.rs" role="context" start="80" end="82">
pub fn now_unix_timestamp() -> i64 {
OffsetDateTime::now_utc().unix_timestamp()
}
<file_sep path="hyperswitch/crates/common_utils/src/lib.rs" role="context" start="75" end="77">
pub fn convert_to_pdt(offset_time: OffsetDateTime) -> PrimitiveDateTime {
PrimitiveDateTime::new(offset_time.date(), offset_time.time())
}
<file_sep path="hyperswitch/crates/common_utils/src/lib.rs" role="context" start="104" end="111">
pub fn date_as_yyyymmddthhmmssmmmz() -> Result<String, time::error::Format> {
const ISO_CONFIG: EncodedConfig = Config::DEFAULT
.set_time_precision(TimePrecision::Second {
decimal_digits: NonZeroU8::new(3),
})
.encode();
now().assume_utc().format(&Iso8601::<ISO_CONFIG>)
}
<file_sep path="hyperswitch/crates/common_utils/src/lib.rs" role="context" start="86" end="92">
pub async fn time_it<T, Fut: futures::Future<Output = T>, F: FnOnce() -> Fut>(
block: F,
) -> (T, f64) {
let start = Instant::now();
let result = block().await;
(result, start.elapsed().as_secs_f64() * 1000f64)
}
| symbol_neighborhood |
<|meta_start|><|file|> hyperswitch/crates/common_utils/src/new_type.rs<|crate|> common_utils anchor=from kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=1<|meta_end|>
<file_sep path="hyperswitch/crates/common_utils/src/new_type.rs" role="context" start="127" end="130">
fn from(src: String) -> Self {
let masked_value = apply_mask(src.as_ref(), 5, 5);
Self(Secret::from(masked_value))
}
<file_sep path="hyperswitch/crates/common_utils/src/new_type.rs" role="context" start="126" end="126">
use masking::{ExposeInterface, PeekInterface, Secret};
<file_sep path="hyperswitch/crates/common_utils/src/new_type.rs" role="context" start="142" end="145">
fn from(src: String) -> Self {
let masked_value = apply_mask(src.as_ref(), 3, 2);
Self(Secret::from(masked_value))
}
<file_sep path="hyperswitch/crates/common_utils/src/new_type.rs" role="context" start="133" end="135">
fn from(secret: Secret<String>) -> Self {
Self::from(secret.expose())
}
<file_sep path="hyperswitch/crates/common_utils/src/new_type.rs" role="context" start="118" end="120">
fn from(secret: Secret<String>) -> Self {
Self::from(secret.expose())
}
<file_sep path="hyperswitch/crates/common_utils/src/new_type.rs" role="context" start="112" end="115">
fn from(src: String) -> Self {
let masked_value = apply_mask(src.as_ref(), 4, 4);
Self(Secret::from(masked_value))
}
<file_sep path="hyperswitch/crates/common_utils/src/new_type.rs" role="context" start="234" end="236">
fn from(secret: Secret<String>) -> Self {
Self::from(secret.expose())
}
<file_sep path="hyperswitch/crates/common_utils/src/new_type.rs" role="context" start="49" end="76">
fn apply_mask(val: &str, unmasked_char_count: usize, min_masked_char_count: usize) -> String {
let len = val.len();
if len <= unmasked_char_count {
return val.to_string();
}
let mask_start_index =
// For showing only last `unmasked_char_count` characters
if len < (unmasked_char_count * 2 + min_masked_char_count) {
0
// For showing first and last `unmasked_char_count` characters
} else {
unmasked_char_count
};
let mask_end_index = len - unmasked_char_count - 1;
let range = mask_start_index..=mask_end_index;
val.chars()
.enumerate()
.fold(String::new(), |mut acc, (index, ch)| {
if ch.is_alphanumeric() && range.contains(&index) {
acc.push('*');
} else {
acc.push(ch);
}
acc
})
}
| symbol_neighborhood |
<|meta_start|><|file|> hyperswitch/crates/common_utils/src/new_type.rs<|crate|> common_utils anchor=from kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=1<|meta_end|>
<file_sep path="hyperswitch/crates/common_utils/src/new_type.rs" role="context" start="82" end="85">
fn from(src: String) -> Self {
let masked_value = apply_mask(src.as_ref(), 2, 2);
Self(Secret::from(masked_value))
}
<file_sep path="hyperswitch/crates/common_utils/src/new_type.rs" role="context" start="81" end="81">
use masking::{ExposeInterface, PeekInterface, Secret};
<file_sep path="hyperswitch/crates/common_utils/src/new_type.rs" role="context" start="97" end="100">
fn from(src: String) -> Self {
let masked_value = apply_mask(src.as_ref(), 3, 3);
Self(Secret::from(masked_value))
}
<file_sep path="hyperswitch/crates/common_utils/src/new_type.rs" role="context" start="88" end="90">
fn from(secret: Secret<String>) -> Self {
Self::from(secret.expose())
}
<file_sep path="hyperswitch/crates/common_utils/src/new_type.rs" role="context" start="49" end="76">
fn apply_mask(val: &str, unmasked_char_count: usize, min_masked_char_count: usize) -> String {
let len = val.len();
if len <= unmasked_char_count {
return val.to_string();
}
let mask_start_index =
// For showing only last `unmasked_char_count` characters
if len < (unmasked_char_count * 2 + min_masked_char_count) {
0
// For showing first and last `unmasked_char_count` characters
} else {
unmasked_char_count
};
let mask_end_index = len - unmasked_char_count - 1;
let range = mask_start_index..=mask_end_index;
val.chars()
.enumerate()
.fold(String::new(), |mut acc, (index, ch)| {
if ch.is_alphanumeric() && range.contains(&index) {
acc.push('*');
} else {
acc.push(ch);
}
acc
})
}
<file_sep path="hyperswitch/crates/common_utils/src/new_type.rs" role="context" start="234" end="236">
fn from(secret: Secret<String>) -> Self {
Self::from(secret.expose())
}
| symbol_neighborhood |
<|meta_start|><|file|> hyperswitch/crates/common_utils/src/id_type.rs<|crate|> common_utils anchor=get_invalid_input_character kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=1<|meta_end|>
<file_sep path="hyperswitch/crates/common_utils/src/id_type.rs" role="context" start="62" end="67">
fn get_invalid_input_character(input_string: Cow<'static, str>) -> Option<char> {
input_string
.trim()
.chars()
.find(|&char| !is_valid_id_character(char))
}
<file_sep path="hyperswitch/crates/common_utils/src/id_type.rs" role="context" start="61" end="61">
use std::{borrow::Cow, fmt::Debug};
<file_sep path="hyperswitch/crates/common_utils/src/id_type.rs" role="context" start="90" end="101">
pub fn from(input_string: Cow<'static, str>) -> Result<Self, AlphaNumericIdError> {
let invalid_character = get_invalid_input_character(input_string.clone());
if let Some(invalid_character) = invalid_character {
Err(AlphaNumericIdError(
input_string.to_string(),
invalid_character,
))?
}
Ok(Self(input_string.to_string()))
}
<file_sep path="hyperswitch/crates/common_utils/src/id_type.rs" role="context" start="79" end="85">
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
let deserialized_string = String::deserialize(deserializer)?;
Self::from(deserialized_string.into()).map_err(serde::de::Error::custom)
}
<file_sep path="hyperswitch/crates/common_utils/src/id_type.rs" role="context" start="56" end="58">
fn is_valid_id_character(input_char: char) -> bool {
input_char.is_ascii_alphanumeric() || matches!(input_char, '_' | '-')
}
| symbol_neighborhood |
<|meta_start|><|file|> hyperswitch-encryption-service/src/storage.rs<|crate|> src anchor=get_conn kind=fn pack=symbol_neighborhood lang=rust role_window=k1 hops=2<|meta_end|>
<file_sep path="hyperswitch-encryption-service/src/storage.rs" role="context" start="36" end="40">
pub async fn get_conn(
&self,
) -> CustomResult<<Self as DbAdapter>::Conn<'_>, errors::ConnectionError> {
<Self as DbAdapter>::get_conn(self).await
}
<file_sep path="hyperswitch-encryption-service/src/storage.rs" role="context" start="35" end="35">
use crate::{
config::Config,
errors::{self, CustomResult},
};
use self::adapter::{DbAdapter, DbAdapterType};
<file_sep path="hyperswitch-encryption-service/src/storage.rs" role="context" start="29" end="34">
pub async fn from_config(
config: &Config,
schema: &str,
) -> DbState<<Self as DbAdapter>::Pool, <Self as DbAdapter>::AdapterType> {
<Self as DbAdapter>::from_config(config, schema).await
}
<file_sep path="hyperswitch-encryption-service/src/storage/adapter/cassandra.rs" role="context" start="7" end="7">
type Conn<'a> = &'a scylla::CachingSession;
| symbol_neighborhood |
<|meta_start|><|file|> hyperswitch/crates/common_utils/src/id_type/global_id/customer.rs<|crate|> common_utils anchor=generate kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/common_utils/src/id_type/global_id/customer.rs" role="context" start="25" end="28">
pub fn generate(cell_id: &crate::id_type::CellId) -> Self {
let global_id = super::GlobalId::generate(cell_id, super::GlobalEntity::Customer);
Self(global_id)
}
<file_sep path="hyperswitch/crates/common_utils/src/id_type/global_id/customer.rs" role="context" start="24" end="24">
use crate::{errors, generate_id_with_default_len, generate_time_ordered_id_without_prefix, types};
<file_sep path="hyperswitch/crates/common_utils/src/id_type/global_id/customer.rs" role="context" start="40" end="44">
fn get_api_event_type(&self) -> Option<crate::events::ApiEventsType> {
Some(crate::events::ApiEventsType::Customer {
customer_id: Some(self.clone()),
})
}
<file_sep path="hyperswitch/crates/common_utils/src/id_type/global_id/customer.rs" role="context" start="34" end="36">
fn try_from(value: GlobalCustomerId) -> Result<Self, Self::Error> {
Self::try_from(std::borrow::Cow::from(value.get_string_repr().to_owned()))
}
<file_sep path="hyperswitch/crates/common_utils/src/id_type/global_id/customer.rs" role="context" start="20" end="22">
pub fn get_string_repr(&self) -> &str {
self.0.get_string_repr()
}
<file_sep path="hyperswitch/crates/common_utils/src/id_type/global_id.rs" role="context" start="47" end="47">
pub struct CellId(LengthId<CELL_IDENTIFIER_LENGTH, CELL_IDENTIFIER_LENGTH>);
<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
<file_sep path="hyperswitch/postman/collection-dir/airwallex/Flow Testcases/Variation Cases/Scenario6-Create 3DS payment with greater capture/Payments - Retrieve/event.test.js" role="context" start="62" end="74">
// Response body should have value "requires_customer_action" for "status"
if (jsonData?.status) {
pm.test(
"[POST]::/payments - Content check if value for 'status' matches 'requires_customer_action'",
function () {
pm.expect(jsonData.status).to.eql("requires_customer_action");
},
);
}
| symbol_neighborhood |
<|meta_start|><|file|> hyperswitch/crates/common_utils/src/types.rs<|crate|> common_utils anchor=get_invalid_percentage_error_message kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=1<|meta_end|>
<file_sep path="hyperswitch/crates/common_utils/src/types.rs" role="context" start="62" end="67">
fn get_invalid_percentage_error_message(precision: u8) -> String {
format!(
"value should be a float between 0 to 100 and precise to only upto {} decimal digits",
precision
)
}
<file_sep path="hyperswitch/crates/common_utils/src/types.rs" role="context" start="84" end="86">
pub fn get_percentage(&self) -> f32 {
self.percentage
}
<file_sep path="hyperswitch/crates/common_utils/src/types.rs" role="context" start="71" end="82">
pub fn from_string(value: String) -> CustomResult<Self, PercentageError> {
if Self::is_valid_string_value(&value)? {
Ok(Self {
percentage: value
.parse::<f32>()
.change_context(PercentageError::InvalidPercentageValue)?,
})
} else {
Err(report!(PercentageError::InvalidPercentageValue))
.attach_printable(get_invalid_percentage_error_message(PRECISION))
}
}
<file_sep path="hyperswitch/crates/common_utils/src/types.rs" role="context" start="150" end="177">
fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error>
where
A: serde::de::MapAccess<'de>,
{
let mut percentage_value = None;
while let Some(key) = map.next_key::<String>()? {
if key.eq("percentage") {
if percentage_value.is_some() {
return Err(serde::de::Error::duplicate_field("percentage"));
}
percentage_value = Some(map.next_value::<serde_json::Value>()?);
} else {
// Ignore unknown fields
let _: serde::de::IgnoredAny = map.next_value()?;
}
}
if let Some(value) = percentage_value {
let string_value = value.to_string();
Ok(Percentage::from_string(string_value.clone()).map_err(|_| {
serde::de::Error::invalid_value(
serde::de::Unexpected::Other(&format!("percentage value {}", string_value)),
&&*get_invalid_percentage_error_message(PRECISION),
)
})?)
} else {
Err(serde::de::Error::missing_field("percentage"))
}
}
| symbol_neighborhood |
<|meta_start|><|file|> hyperswitch/crates/common_utils/src/id_type/global_id/refunds.rs<|crate|> common_utils anchor=generate kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/common_utils/src/id_type/global_id/refunds.rs" role="context" start="29" end="32">
pub fn generate(cell_id: &crate::id_type::CellId) -> Self {
let global_id = super::GlobalId::generate(cell_id, super::GlobalEntity::Refund);
Self(global_id)
}
<file_sep path="hyperswitch/crates/common_utils/src/id_type/global_id/refunds.rs" role="context" start="28" end="28">
use crate::{errors, generate_id_with_default_len, generate_time_ordered_id_without_prefix, types};
<file_sep path="hyperswitch/crates/common_utils/src/id_type/global_id/refunds.rs" role="context" start="55" end="60">
fn to_sql<'b>(
&'b self,
out: &mut diesel::serialize::Output<'b, '_, DB>,
) -> diesel::serialize::Result {
self.0.to_sql(out)
}
<file_sep path="hyperswitch/crates/common_utils/src/id_type/global_id/refunds.rs" role="context" start="38" end="46">
fn try_from(value: std::borrow::Cow<'static, str>) -> Result<Self, Self::Error> {
use error_stack::ResultExt;
let merchant_ref_id = super::GlobalId::from_string(value).change_context(
errors::ValidationError::IncorrectValueProvided {
field_name: "refund_id",
},
)?;
Ok(Self(merchant_ref_id))
}
<file_sep path="hyperswitch/crates/common_utils/src/id_type/global_id/refunds.rs" role="context" start="24" end="26">
pub fn get_string_repr(&self) -> &str {
self.0.get_string_repr()
}
<file_sep path="hyperswitch/crates/common_utils/src/id_type/global_id.rs" role="context" start="47" end="47">
pub struct CellId(LengthId<CELL_IDENTIFIER_LENGTH, CELL_IDENTIFIER_LENGTH>);
<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/postman/collection-dir/powertranz/Flow Testcases/Happy Cases/Scenario1-Create payment with confirm true/Payments - Create/event.test.js" role="context" start="61" end="78">
"INFO - Unable to assign variable {{client_secret}}, as jsonData.client_secret is undefined.",
);
}
// Response body should have value "succeeded" for "status"
if (jsonData?.status) {
pm.test(
"[POST]::/payments - Content check if value for 'status' matches 'succeeded'",
function () {
pm.expect(jsonData.status).to.eql("succeeded");
},
);
}
| symbol_neighborhood |
<|meta_start|><|file|> hyperswitch-encryption-service/src/storage.rs<|crate|> src anchor=from_config kind=fn pack=symbol_neighborhood lang=rust role_window=k1 hops=2<|meta_end|>
<file_sep path="hyperswitch-encryption-service/src/storage.rs" role="context" start="29" end="34">
pub async fn from_config(
config: &Config,
schema: &str,
) -> DbState<<Self as DbAdapter>::Pool, <Self as DbAdapter>::AdapterType> {
<Self as DbAdapter>::from_config(config, schema).await
}
<file_sep path="hyperswitch-encryption-service/src/storage.rs" role="context" start="28" end="28">
use crate::{
config::Config,
errors::{self, CustomResult},
};
use self::adapter::{DbAdapter, DbAdapterType};
<file_sep path="hyperswitch-encryption-service/src/storage.rs" role="context" start="36" end="40">
pub async fn get_conn(
&self,
) -> CustomResult<<Self as DbAdapter>::Conn<'_>, errors::ConnectionError> {
<Self as DbAdapter>::get_conn(self).await
}
<file_sep path="hyperswitch-encryption-service/src/storage.rs" role="context" start="15" end="18">
pub struct DbState<C, T: DbAdapterType> {
pub pool: C,
_adapter: std::marker::PhantomData<T>,
}
<file_sep path="hyperswitch-encryption-service/src/storage/adapter/cassandra.rs" role="context" start="9" end="9">
type Pool = scylla::CachingSession;
<file_sep path="hyperswitch/migrations/2022-09-29-084920_create_initial_tables/up.sql" role="context" start="257" end="273">
first_name VARCHAR(255),
last_name VARCHAR(255),
phone_number VARCHAR(255),
country_code VARCHAR(255),
created_at TIMESTAMP NOT NULL DEFAULT now()::TIMESTAMP,
modified_at TIMESTAMP NOT NULL DEFAULT now()::TIMESTAMP
);
CREATE TABLE configs (
id SERIAL,
key VARCHAR(255) NOT NULL,
config TEXT NOT NULL,
PRIMARY KEY (key)
);
CREATE TABLE customers (
id SERIAL,
| symbol_neighborhood |
<|meta_start|><|file|> hyperswitch/crates/hyperswitch_interfaces/src/secrets_interface/secret_state.rs<|crate|> hyperswitch_interfaces anchor=deserialize kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/hyperswitch_interfaces/src/secrets_interface/secret_state.rs" role="context" start="43" end="52">
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: Deserializer<'de>,
{
let val = Deserialize::deserialize(deserializer)?;
Ok(Self {
inner: val,
marker: PhantomData,
})
}
<file_sep path="hyperswitch/crates/hyperswitch_interfaces/src/secrets_interface/secret_state.rs" role="context" start="42" end="42">
use std::marker::PhantomData;
use serde::{Deserialize, Deserializer};
<file_sep path="hyperswitch/crates/hyperswitch_interfaces/src/secrets_interface/secret_state.rs" role="context" start="57" end="66">
pub fn transition_state(
mut self,
decryptor_fn: impl FnOnce(T) -> T,
) -> SecretStateContainer<T, RawSecret> {
self.inner = decryptor_fn(self.inner);
SecretStateContainer {
inner: self.inner,
marker: PhantomData,
}
}
<file_sep path="hyperswitch/crates/hyperswitch_interfaces/src/secrets_interface/secret_state.rs" role="context" start="37" end="39">
pub fn get_inner(&self) -> &T {
&self.inner
}
<file_sep path="hyperswitch/crates/hyperswitch_interfaces/src/secrets_interface/secret_state.rs" role="context" start="31" end="33">
pub fn into_inner(self) -> T {
self.inner
}
<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/router_derive/src/lib.rs<|crate|> router_derive anchor=validate_config kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=1<|meta_end|>
<file_sep path="hyperswitch/crates/router_derive/src/lib.rs" role="context" start="551" end="557">
pub fn validate_config(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
let input = syn::parse_macro_input!(input as syn::DeriveInput);
macros::misc::validate_config(input)
.unwrap_or_else(|error| error.into_compile_error())
.into()
}
<file_sep path="hyperswitch/crates/router_derive/src/lib.rs" role="context" start="550" end="550">
use syn::parse_macro_input;
use crate::macros::diesel::DieselEnumMeta;
<file_sep path="hyperswitch/crates/router_derive/src/lib.rs" role="context" start="648" end="696">
pub fn flat_struct_derive(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
let input = parse_macro_input!(input as syn::DeriveInput);
let name = &input.ident;
let expanded = quote::quote! {
impl #name {
pub fn flat_struct(&self) -> std::collections::HashMap<String, String> {
use serde_json::Value;
use std::collections::HashMap;
fn flatten_value(
value: &Value,
prefix: &str,
result: &mut HashMap<String, String>
) {
match value {
Value::Object(map) => {
for (key, val) in map {
let new_key = if prefix.is_empty() {
key.to_string()
} else {
format!("{}.{}", prefix, key)
};
flatten_value(val, &new_key, result);
}
}
Value::String(s) => {
result.insert(prefix.to_string(), s.clone());
}
Value::Number(n) => {
result.insert(prefix.to_string(), n.to_string());
}
Value::Bool(b) => {
result.insert(prefix.to_string(), b.to_string());
}
_ => {}
}
}
let mut result = HashMap::new();
let value = serde_json::to_value(self).unwrap();
flatten_value(&value, "", &mut result);
result
}
}
};
proc_macro::TokenStream::from(expanded)
}
<file_sep path="hyperswitch/crates/router_derive/src/lib.rs" role="context" start="607" end="613">
pub fn try_get_enum_variant(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
let input = syn::parse_macro_input!(input as syn::DeriveInput);
macros::try_get_enum::try_get_enum_variant(input)
.unwrap_or_else(|error| error.into_compile_error())
.into()
}
<file_sep path="hyperswitch/crates/router_derive/src/lib.rs" role="context" start="511" end="517">
pub fn polymorphic_schema(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
let input = syn::parse_macro_input!(input as syn::DeriveInput);
macros::polymorphic_macro_derive_inner(input)
.unwrap_or_else(|error| error.into_compile_error())
.into()
}
<file_sep path="hyperswitch/crates/router_derive/src/lib.rs" role="context" start="462" end="466">
pub fn operation_derive(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
let input = syn::parse_macro_input!(input as syn::DeriveInput);
macros::operation::operation_derive_inner(input)
.unwrap_or_else(|err| err.to_compile_error().into())
}
| symbol_neighborhood |
<|meta_start|><|file|> hyperswitch/crates/router_derive/src/macros/to_encryptable.rs<|crate|> router_derive anchor=get_field_and_inner_types kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=1<|meta_end|>
<file_sep path="hyperswitch/crates/router_derive/src/macros/to_encryptable.rs" role="context" start="105" end="112">
fn get_field_and_inner_types(fields: &[Field]) -> Vec<(Field, Ident)> {
fields
.iter()
.flat_map(|field| {
get_inner_most_type(field.ty.clone()).map(|field_name| (field.to_owned(), field_name))
})
.collect()
}
<file_sep path="hyperswitch/crates/router_derive/src/macros/to_encryptable.rs" role="context" start="104" end="104">
use std::iter::Iterator;
use syn::{parse::Parse, punctuated::Punctuated, token::Comma, Field, Ident, Type as SynType};
<file_sep path="hyperswitch/crates/router_derive/src/macros/to_encryptable.rs" role="context" start="164" end="225">
fn generate_impls(
self,
gen1: proc_macro2::TokenStream,
gen2: proc_macro2::TokenStream,
gen3: proc_macro2::TokenStream,
impl_st: proc_macro2::TokenStream,
inner: &[Field],
) -> proc_macro2::TokenStream {
let map_length = inner.len();
let to_encryptable_impl = inner.iter().flat_map(|field| {
get_field_type(field.ty.clone()).map(|field_ty| {
let is_option = field_ty.eq("Option");
let field_ident = &field.ident;
let field_ident_string = field_ident.as_ref().map(|s| s.to_string());
if is_option || self == Self::Updated {
quote! { self.#field_ident.map(|s| map.insert(#field_ident_string.to_string(), s)) }
} else {
quote! { map.insert(#field_ident_string.to_string(), self.#field_ident) }
}
})
});
let from_encryptable_impl = inner.iter().flat_map(|field| {
get_field_type(field.ty.clone()).map(|field_ty| {
let is_option = field_ty.eq("Option");
let field_ident = &field.ident;
let field_ident_string = field_ident.as_ref().map(|s| s.to_string());
if is_option || self == Self::Updated {
quote! { #field_ident: map.remove(#field_ident_string) }
} else {
quote! {
#field_ident: map.remove(#field_ident_string).ok_or(
error_stack::report!(common_utils::errors::ParsingError::EncodeError(
"Unable to convert from HashMap",
))
)?
}
}
})
});
quote! {
impl ToEncryptable<#gen1, #gen2, #gen3> for #impl_st {
fn to_encryptable(self) -> FxHashMap<String, #gen3> {
let mut map = FxHashMap::with_capacity_and_hasher(#map_length, Default::default());
#(#to_encryptable_impl;)*
map
}
fn from_encryptable(
mut map: FxHashMap<String, Encryptable<#gen2>>,
) -> CustomResult<#gen1, common_utils::errors::ParsingError> {
Ok(#gen1 {
#(#from_encryptable_impl,)*
})
}
}
}
}
<file_sep path="hyperswitch/crates/router_derive/src/macros/to_encryptable.rs" role="context" start="127" end="161">
fn generate_struct_fields(self, fields: &[(Field, Ident)]) -> Vec<proc_macro2::TokenStream> {
fields
.iter()
.map(|(field, inner_ty)| {
let provided_ty = get_encryption_ty_meta(field);
let is_option = get_field_type(field.ty.clone())
.map(|f| f.eq("Option"))
.unwrap_or_default();
let ident = &field.ident;
let inner_ty = if let Some(ref ty) = provided_ty {
&ty.value
} else {
inner_ty
};
match (self, is_option) {
(Self::Encrypted, true) => quote! { pub #ident: Option<Encryption> },
(Self::Encrypted, false) => quote! { pub #ident: Encryption },
(Self::Decrypted, true) => {
quote! { pub #ident: Option<Encryptable<Secret<#inner_ty>>> }
}
(Self::Decrypted, false) => {
quote! { pub #ident: Encryptable<Secret<#inner_ty>> }
}
(Self::DecryptedUpdate, _) => {
quote! { pub #ident: Option<Encryptable<Secret<#inner_ty>>> }
}
(Self::FromRequest, true) => {
quote! { pub #ident: Option<Secret<#inner_ty>> }
}
(Self::FromRequest, false) => quote! { pub #ident: Secret<#inner_ty> },
(Self::Updated, _) => quote! { pub #ident: Option<Secret<#inner_ty>> },
}
})
.collect()
}
<file_sep path="hyperswitch/crates/router_derive/src/macros/to_encryptable.rs" role="context" start="92" end="102">
fn get_encryptable_fields(fields: Punctuated<Field, Comma>) -> Vec<Field> {
fields
.into_iter()
.filter(|field| {
field
.attrs
.iter()
.any(|attr| attr.path().is_ident("encrypt"))
})
.collect()
}
<file_sep path="hyperswitch/crates/router_derive/src/macros/to_encryptable.rs" role="context" start="61" end="89">
fn get_inner_most_type(ty: SynType) -> syn::Result<Ident> {
fn get_inner_type_recursive(path: syn::TypePath) -> syn::Result<syn::TypePath> {
match get_inner_type(&path) {
Ok(inner_path) => get_inner_type_recursive(inner_path),
Err(_) => Ok(path),
}
}
match ty {
SynType::Path(path) => {
let inner_path = get_inner_type_recursive(path)?;
inner_path
.path
.segments
.last()
.map(|last_segment| last_segment.ident.to_owned())
.ok_or_else(|| {
syn::Error::new(
proc_macro2::Span::call_site(),
"At least one ident must be specified",
)
})
}
_ => Err(syn::Error::new(
proc_macro2::Span::call_site(),
"Only path fields are supported",
)),
}
}
<file_sep path="hyperswitch/crates/router_derive/src/macros/to_encryptable.rs" role="context" start="229" end="321">
fn generate_to_encryptable(
struct_name: Ident,
fields: Vec<Field>,
) -> syn::Result<proc_macro2::TokenStream> {
let struct_types = [
// The first two are to be used as return types we do not need to implement ToEncryptable
// on it
("Decrypted", StructType::Decrypted),
("DecryptedUpdate", StructType::DecryptedUpdate),
("FromRequestEncryptable", StructType::FromRequest),
("Encrypted", StructType::Encrypted),
("UpdateEncryptable", StructType::Updated),
];
let inner_types = get_field_and_inner_types(&fields);
let inner_type = inner_types.first().ok_or_else(|| {
syn::Error::new(
proc_macro2::Span::call_site(),
"Please use the macro with attribute #[encrypt] on the fields you want to encrypt",
)
})?;
let provided_ty = get_encryption_ty_meta(&inner_type.0)
.map(|ty| ty.value.clone())
.unwrap_or(inner_type.1.clone());
let structs = struct_types.iter().map(|(prefix, struct_type)| {
let name = format_ident!("{}{}", prefix, struct_name);
let temp_fields = struct_type.generate_struct_fields(&inner_types);
quote! {
pub struct #name {
#(#temp_fields,)*
}
}
});
// These implementations shouldn't be implemented Decrypted and DecryptedUpdate temp structs
// So skip the first two entries in the list
let impls = struct_types
.iter()
.skip(2)
.map(|(prefix, struct_type)| {
let name = format_ident!("{}{}", prefix, struct_name);
let impl_block = if *struct_type != StructType::DecryptedUpdate
|| *struct_type != StructType::Decrypted
{
let (gen1, gen2, gen3) = match struct_type {
StructType::FromRequest => {
let decrypted_name = format_ident!("Decrypted{}", struct_name);
(
quote! { #decrypted_name },
quote! { Secret<#provided_ty> },
quote! { Secret<#provided_ty> },
)
}
StructType::Encrypted => {
let decrypted_name = format_ident!("Decrypted{}", struct_name);
(
quote! { #decrypted_name },
quote! { Secret<#provided_ty> },
quote! { Encryption },
)
}
StructType::Updated => {
let decrypted_update_name = format_ident!("DecryptedUpdate{}", struct_name);
(
quote! { #decrypted_update_name },
quote! { Secret<#provided_ty> },
quote! { Secret<#provided_ty> },
)
}
//Unreachable statement
_ => (quote! {}, quote! {}, quote! {}),
};
struct_type.generate_impls(gen1, gen2, gen3, quote! { #name }, &fields)
} else {
quote! {}
};
Ok(quote! {
#impl_block
})
})
.collect::<syn::Result<Vec<_>>>()?;
Ok(quote! {
#(#structs)*
#(#impls)*
})
}
| symbol_neighborhood |
<|meta_start|><|file|> hyperswitch/crates/common_utils/src/id_type.rs<|crate|> common_utils anchor=deserialize kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/common_utils/src/id_type.rs" role="context" start="79" end="85">
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
let deserialized_string = String::deserialize(deserializer)?;
Self::from(deserialized_string.into()).map_err(serde::de::Error::custom)
}
<file_sep path="hyperswitch/crates/common_utils/src/id_type.rs" role="context" start="78" end="78">
use diesel::{
backend::Backend,
deserialize::FromSql,
expression::AsExpression,
serialize::{Output, ToSql},
sql_types,
};
use serde::{Deserialize, Serialize};
use thiserror::Error;
<file_sep path="hyperswitch/crates/common_utils/src/id_type.rs" role="context" start="104" end="106">
pub(crate) fn new_unchecked(input_string: String) -> Self {
Self(input_string)
}
<file_sep path="hyperswitch/crates/common_utils/src/id_type.rs" role="context" start="90" end="101">
pub fn from(input_string: Cow<'static, str>) -> Result<Self, AlphaNumericIdError> {
let invalid_character = get_invalid_input_character(input_string.clone());
if let Some(invalid_character) = invalid_character {
Err(AlphaNumericIdError(
input_string.to_string(),
invalid_character,
))?
}
Ok(Self(input_string.to_string()))
}
<file_sep path="hyperswitch/crates/common_utils/src/id_type.rs" role="context" start="62" end="67">
fn get_invalid_input_character(input_string: Cow<'static, str>) -> Option<char> {
input_string
.trim()
.chars()
.find(|&char| !is_valid_id_character(char))
}
<file_sep path="hyperswitch/crates/common_utils/src/id_type.rs" role="context" start="56" end="58">
fn is_valid_id_character(input_char: char) -> bool {
input_char.is_ascii_alphanumeric() || matches!(input_char, '_' | '-')
}
<file_sep path="hyperswitch/crates/common_utils/src/id_type.rs" role="context" start="143" end="162">
pub fn from(input_string: Cow<'static, str>) -> Result<Self, LengthIdError> {
let trimmed_input_string = input_string.trim().to_string();
let length_of_input_string = u8::try_from(trimmed_input_string.len())
.map_err(|_| LengthIdError::MaxLengthViolated(MAX_LENGTH))?;
when(length_of_input_string > MAX_LENGTH, || {
Err(LengthIdError::MaxLengthViolated(MAX_LENGTH))
})?;
when(length_of_input_string < MIN_LENGTH, || {
Err(LengthIdError::MinLengthViolated(MIN_LENGTH))
})?;
let alphanumeric_id = match AlphaNumericId::from(trimmed_input_string.into()) {
Ok(valid_alphanumeric_id) => valid_alphanumeric_id,
Err(error) => Err(LengthIdError::AlphanumericIdError(error))?,
};
Ok(Self(alphanumeric_id))
}
<file_sep path="hyperswitch/crates/common_utils/src/id_type.rs" role="context" start="198" end="204">
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
let deserialized_string = String::deserialize(deserializer)?;
Self::from(deserialized_string.into()).map_err(serde::de::Error::custom)
}
<file_sep path="hyperswitch/crates/common_utils/src/types.rs" role="context" start="1270" end="1270">
type Error = error_stack::Report<ValidationError>;
<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/common_utils/src/id_type/global_id.rs<|crate|> common_utils anchor=deserialize kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/common_utils/src/id_type/global_id.rs" role="context" start="97" end="103">
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
let deserialized_string = String::deserialize(deserializer)?;
Self::from_str(deserialized_string.as_str()).map_err(serde::de::Error::custom)
}
<file_sep path="hyperswitch/crates/common_utils/src/id_type/global_id.rs" role="context" start="96" end="96">
use diesel::{backend::Backend, deserialize::FromSql, serialize::ToSql, sql_types};
use thiserror::Error;
<file_sep path="hyperswitch/crates/common_utils/src/id_type/global_id.rs" role="context" start="132" end="144">
pub(crate) fn from_string(
input_string: std::borrow::Cow<'static, str>,
) -> Result<Self, GlobalIdError> {
let length_id = LengthId::from(input_string)?;
let input_string = &length_id.0 .0;
let (cell_id, remaining) = input_string
.split_once("_")
.ok_or(GlobalIdError::InvalidIdFormat)?;
CellId::from_str(cell_id)?;
Ok(Self(length_id))
}
<file_sep path="hyperswitch/crates/common_utils/src/id_type/global_id.rs" role="context" start="125" end="130">
pub fn generate(cell_id: &CellId, entity: GlobalEntity) -> Self {
let prefix = format!("{}_{}", cell_id.get_string_repr(), entity.prefix());
let id = generate_time_ordered_id(&prefix);
let alphanumeric_id = AlphaNumericId::new_unchecked(id);
Self(LengthId::new_unchecked(alphanumeric_id))
}
<file_sep path="hyperswitch/crates/common_utils/src/id_type/global_id.rs" role="context" start="91" end="93">
fn get_string_repr(&self) -> &str {
&self.0 .0 .0
}
<file_sep path="hyperswitch/crates/common_utils/src/id_type/global_id.rs" role="context" start="80" end="88">
pub fn from_string(
input_string: impl AsRef<str>,
) -> error_stack::Result<Self, errors::ValidationError> {
Self::from_str(input_string).change_context(
errors::ValidationError::IncorrectValueProvided {
field_name: "cell_id",
},
)
}
<file_sep path="hyperswitch/crates/common_utils/src/id_type/global_id.rs" role="context" start="72" end="77">
fn from_str(cell_id_string: impl AsRef<str>) -> Result<Self, CellIdError> {
let trimmed_input_string = cell_id_string.as_ref().trim().to_string();
let alphanumeric_id = AlphaNumericId::from(trimmed_input_string.into())?;
let length_id = LengthId::from_alphanumeric_id(alphanumeric_id)?;
Ok(Self(length_id))
}
<file_sep path="hyperswitch/crates/common_utils/src/id_type/global_id.rs" role="context" start="180" end="186">
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
let deserialized_string = String::deserialize(deserializer)?;
Self::from_string(deserialized_string.into()).map_err(serde::de::Error::custom)
}
<file_sep path="hyperswitch/crates/common_utils/src/types.rs" role="context" start="1270" end="1270">
type Error = error_stack::Report<ValidationError>;
| symbol_neighborhood |
<|meta_start|><|file|> hyperswitch/crates/router_derive/src/lib.rs<|crate|> router_derive anchor=try_get_enum_variant kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=1<|meta_end|>
<file_sep path="hyperswitch/crates/router_derive/src/lib.rs" role="context" start="607" end="613">
pub fn try_get_enum_variant(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
let input = syn::parse_macro_input!(input as syn::DeriveInput);
macros::try_get_enum::try_get_enum_variant(input)
.unwrap_or_else(|error| error.into_compile_error())
.into()
}
<file_sep path="hyperswitch/crates/router_derive/src/lib.rs" role="context" start="606" end="606">
use syn::parse_macro_input;
use crate::macros::diesel::DieselEnumMeta;
<file_sep path="hyperswitch/crates/router_derive/src/lib.rs" role="context" start="749" end="751">
pub fn generate_permissions(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
macros::generate_permissions_inner(input)
}
<file_sep path="hyperswitch/crates/router_derive/src/lib.rs" role="context" start="648" end="696">
pub fn flat_struct_derive(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
let input = parse_macro_input!(input as syn::DeriveInput);
let name = &input.ident;
let expanded = quote::quote! {
impl #name {
pub fn flat_struct(&self) -> std::collections::HashMap<String, String> {
use serde_json::Value;
use std::collections::HashMap;
fn flatten_value(
value: &Value,
prefix: &str,
result: &mut HashMap<String, String>
) {
match value {
Value::Object(map) => {
for (key, val) in map {
let new_key = if prefix.is_empty() {
key.to_string()
} else {
format!("{}.{}", prefix, key)
};
flatten_value(val, &new_key, result);
}
}
Value::String(s) => {
result.insert(prefix.to_string(), s.clone());
}
Value::Number(n) => {
result.insert(prefix.to_string(), n.to_string());
}
Value::Bool(b) => {
result.insert(prefix.to_string(), b.to_string());
}
_ => {}
}
}
let mut result = HashMap::new();
let value = serde_json::to_value(self).unwrap();
flatten_value(&value, "", &mut result);
result
}
}
};
proc_macro::TokenStream::from(expanded)
}
<file_sep path="hyperswitch/crates/router_derive/src/lib.rs" role="context" start="551" end="557">
pub fn validate_config(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
let input = syn::parse_macro_input!(input as syn::DeriveInput);
macros::misc::validate_config(input)
.unwrap_or_else(|error| error.into_compile_error())
.into()
}
<file_sep path="hyperswitch/crates/router_derive/src/lib.rs" role="context" start="511" end="517">
pub fn polymorphic_schema(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
let input = syn::parse_macro_input!(input as syn::DeriveInput);
macros::polymorphic_macro_derive_inner(input)
.unwrap_or_else(|error| error.into_compile_error())
.into()
}
| symbol_neighborhood |
<|meta_start|><|file|> hyperswitch/crates/masking/src/maskable.rs<|crate|> masking anchor=fmt kind=fn pack=symbol_neighborhood lang=rust role_window=k2 hops=1<|meta_end|>
<file_sep path="hyperswitch/crates/masking/src/maskable.rs" role="context" start="16" end="21">
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self {
Self::Masked(secret_value) => std::fmt::Debug::fmt(secret_value, f),
Self::Normal(value) => std::fmt::Debug::fmt(value, f),
}
}
<file_sep path="hyperswitch/crates/masking/src/maskable.rs" role="context" start="35" end="40">
pub fn into_inner(self) -> T {
match self {
Self::Masked(inner_secret) => inner_secret.expose(),
Self::Normal(inner) => inner,
}
}
<file_sep path="hyperswitch/crates/masking/src/maskable.rs" role="context" start="25" end="30">
fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
match self {
Self::Masked(value) => crate::PeekInterface::peek(value).hash(state),
Self::Normal(value) => value.hash(state),
}
}
| symbol_neighborhood |
<|meta_start|><|file|> hyperswitch/crates/router_env/src/logger/config.rs<|crate|> router_env anchor=get_config_directory kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=1<|meta_end|>
<file_sep path="hyperswitch/crates/router_env/src/logger/config.rs" role="context" start="193" end="202">
pub fn get_config_directory() -> PathBuf {
let mut config_path = PathBuf::new();
let config_directory =
std::env::var(crate::env::vars::CONFIG_DIR).unwrap_or_else(|_| "config".into());
config_path.push(crate::env::workspace_path());
config_path.push(config_directory);
config_path
}
<file_sep path="hyperswitch/crates/router_env/src/logger/config.rs" role="context" start="192" end="192">
use std::path::PathBuf;
<file_sep path="hyperswitch/crates/router_env/src/logger/config.rs" role="context" start="173" end="189">
pub fn config_path(environment: &str, explicit_config_path: Option<PathBuf>) -> PathBuf {
let mut config_path = PathBuf::new();
if let Some(explicit_config_path_val) = explicit_config_path {
config_path.push(explicit_config_path_val);
} else {
let config_file_name = match environment {
"production" => "production.toml",
"sandbox" => "sandbox.toml",
_ => "development.toml",
};
let config_directory = Self::get_config_directory();
config_path.push(config_directory);
config_path.push(config_file_name);
}
config_path
}
<file_sep path="hyperswitch/crates/router_env/src/logger/config.rs" role="context" start="162" end="170">
pub fn builder(
environment: &str,
) -> Result<config::ConfigBuilder<config::builder::DefaultState>, config::ConfigError> {
config::Config::builder()
// Here, it should be `set_override()` not `set_default()`.
// "env" can't be altered by config field.
// Should be single source of truth.
.set_override("env", environment)
}
<file_sep path="hyperswitch/crates/router_env/src/logger/config.rs" role="context" start="123" end="125">
pub fn new() -> Result<Self, config::ConfigError> {
Self::new_with_config_path(None)
}
| symbol_neighborhood |
<|meta_start|><|file|> hyperswitch/crates/external_services/src/file_storage/aws_s3.rs<|crate|> external_services anchor=new kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/external_services/src/file_storage/aws_s3.rs" role="context" start="53" end="60">
pub(super) async fn new(config: &AwsFileStorageConfig) -> Self {
let region_provider = RegionProviderChain::first_try(Region::new(config.region.clone()));
let sdk_config = aws_config::from_env().region(region_provider).load().await;
Self {
inner_client: Client::new(&sdk_config),
bucket_name: config.bucket_name.clone(),
}
}
<file_sep path="hyperswitch/crates/external_services/src/file_storage/aws_s3.rs" role="context" start="52" end="52">
use aws_config::meta::region::RegionProviderChain;
use aws_sdk_s3::{
operation::{
delete_object::DeleteObjectError, get_object::GetObjectError, put_object::PutObjectError,
},
Client,
};
use aws_sdk_sts::config::Region;
use super::InvalidFileStorageConfig;
<file_sep path="hyperswitch/crates/external_services/src/file_storage/aws_s3.rs" role="context" start="80" end="89">
async fn delete_file(&self, file_key: &str) -> CustomResult<(), AwsS3StorageError> {
self.inner_client
.delete_object()
.bucket(&self.bucket_name)
.key(file_key)
.send()
.await
.map_err(AwsS3StorageError::DeleteFailure)?;
Ok(())
}
<file_sep path="hyperswitch/crates/external_services/src/file_storage/aws_s3.rs" role="context" start="63" end="77">
async fn upload_file(
&self,
file_key: &str,
file: Vec<u8>,
) -> CustomResult<(), AwsS3StorageError> {
self.inner_client
.put_object()
.bucket(&self.bucket_name)
.key(file_key)
.body(file.into())
.send()
.await
.map_err(AwsS3StorageError::UploadFailure)?;
Ok(())
}
<file_sep path="hyperswitch/crates/external_services/src/file_storage/aws_s3.rs" role="context" start="27" end="39">
pub(super) fn validate(&self) -> Result<(), InvalidFileStorageConfig> {
use common_utils::fp_utils::when;
when(self.region.is_default_or_empty(), || {
Err(InvalidFileStorageConfig("aws s3 region must not be empty"))
})?;
when(self.bucket_name.is_default_or_empty(), || {
Err(InvalidFileStorageConfig(
"aws s3 bucket name must not be empty",
))
})
}
<file_sep path="hyperswitch/crates/external_services/src/file_storage/aws_s3.rs" role="context" start="18" end="23">
pub struct AwsFileStorageConfig {
/// The AWS region to send file uploads
region: String,
/// The AWS s3 bucket to send file uploads
bucket_name: String,
}
<file_sep path="hyperswitch/crates/external_services/src/grpc_client.rs" role="context" start="29" end="29">
pub type Client = hyper_util::client::legacy::Client<HttpConnector, UnsyncBoxBody<Bytes, Status>>;
| symbol_neighborhood |
<|meta_start|><|file|> hyperswitch-card-vault/src/logger/config.rs<|crate|> src anchor=deserialize kind=fn pack=symbol_neighborhood lang=rust role_window=k1 hops=2<|meta_end|>
<file_sep path="hyperswitch-card-vault/src/logger/config.rs" role="context" start="39" end="49">
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
use std::str::FromStr as _;
let s = String::deserialize(deserializer)?;
tracing::Level::from_str(&s)
.map(Level)
.map_err(serde::de::Error::custom)
}
<file_sep path="hyperswitch-card-vault/src/logger/config.rs" role="context" start="38" end="38">
use serde::Deserialize;
<file_sep path="hyperswitch-card-vault/src/logger/config.rs" role="context" start="33" end="35">
pub fn into_level(&self) -> tracing::Level {
self.0
}
<file_sep path="hyperswitch-card-vault/src/logger/config.rs" role="context" start="29" end="29">
pub struct Level(pub(super) tracing::Level);
<file_sep path="hyperswitch-encryption-service/src/types/core/identifier.rs" role="context" start="40" end="40">
type Error = error_stack::Report<errors::ParsingError>;
<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-encryption-service/src/services/aws/config.rs<|crate|> src anchor=new kind=fn pack=symbol_neighborhood lang=rust role_window=k2 hops=1<|meta_end|>
<file_sep path="hyperswitch-encryption-service/src/services/aws/config.rs" role="context" start="23" end="34">
pub async fn new(config: &AwsKmsConfig) -> Self {
let region_provider = RegionProviderChain::first_try(Region::new(config.region.clone()));
let sdk_config = aws_config::defaults(BehaviorVersion::v2024_03_28())
.region(region_provider)
.load()
.await;
Self {
inner_client: Client::new(&sdk_config),
key_id: config.key_id.clone(),
}
}
<file_sep path="hyperswitch-encryption-service/src/services/aws/config.rs" role="context" start="22" end="22">
use aws_config::{meta::region::RegionProviderChain, BehaviorVersion};
use aws_sdk_kms::{config::Region, Client};
<file_sep path="hyperswitch-encryption-service/src/services/aws/config.rs" role="context" start="40" end="42">
pub fn key_id(&self) -> &str {
&self.key_id
}
<file_sep path="hyperswitch-encryption-service/src/services/aws/config.rs" role="context" start="36" end="38">
pub fn inner_client(&self) -> &Client {
&self.inner_client
}
<file_sep path="hyperswitch-encryption-service/src/services/aws/config.rs" role="context" start="7" end="13">
pub struct AwsKmsConfig {
/// The AWS key identifier of the KMS key used to encrypt or decrypt data.
pub key_id: String,
/// The AWS region to send KMS requests to.
pub region: String,
}
| symbol_neighborhood |
<|meta_start|><|file|> hyperswitch/crates/router_derive/src/macros/diesel.rs<|crate|> router_derive anchor=diesel_enum_derive_inner kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=1<|meta_end|>
<file_sep path="hyperswitch/crates/router_derive/src/macros/diesel.rs" role="context" start="172" end="186">
pub(crate) fn diesel_enum_derive_inner(ast: &DeriveInput) -> syn::Result<TokenStream> {
let storage_type = ast.get_metadata()?;
match storage_type
.first()
.ok_or(syn::Error::new(
Span::call_site(),
"Storage type must be specified",
))?
.get_storage_type()
{
StorageType::Text => diesel_enum_text_derive_inner(ast),
StorageType::DbEnum => diesel_enum_db_enum_derive_inner(ast),
}
}
<file_sep path="hyperswitch/crates/router_derive/src/macros/diesel.rs" role="context" start="171" end="171">
use proc_macro2::{Span, TokenStream};
use syn::{parse::Parse, Data, DeriveInput, ItemEnum};
use crate::macros::helpers;
<file_sep path="hyperswitch/crates/router_derive/src/macros/diesel.rs" role="context" start="192" end="222">
pub(crate) fn diesel_enum_attribute_macro(
diesel_enum_meta: DieselEnumMeta,
item: &ItemEnum,
) -> syn::Result<TokenStream> {
let diesel_derives =
quote!(#[derive(diesel::AsExpression, diesel::FromSqlRow, router_derive::DieselEnum) ]);
match diesel_enum_meta {
DieselEnumMeta::StorageTypeEnum {
value: storage_type,
..
} => match storage_type {
StorageType::Text => Ok(quote! {
#diesel_derives
#[diesel(sql_type = ::diesel::sql_types::Text)]
#[storage_type(storage_type = "text")]
#item
}),
StorageType::DbEnum => {
let name = &item.ident;
let type_name = format_ident!("Db{name}");
Ok(quote! {
#diesel_derives
#[diesel(sql_type = #type_name)]
#[storage_type(storage_type= "db_enum")]
#item
})
}
},
}
}
<file_sep path="hyperswitch/crates/router_derive/src/macros/diesel.rs" role="context" start="167" end="169">
fn get_metadata(&self) -> syn::Result<Vec<DieselEnumMeta>> {
helpers::get_metadata_inner("storage_type", &self.attrs)
}
<file_sep path="hyperswitch/crates/router_derive/src/macros/diesel.rs" role="context" start="154" end="158">
fn to_tokens(&self, tokens: &mut TokenStream) {
match self {
Self::StorageTypeEnum { keyword, .. } => keyword.to_tokens(tokens),
}
}
<file_sep path="hyperswitch/crates/router_derive/src/macros/diesel.rs" role="context" start="7" end="42">
pub(crate) fn diesel_enum_text_derive_inner(ast: &DeriveInput) -> syn::Result<TokenStream> {
let name = &ast.ident;
let (impl_generics, ty_generics, where_clause) = ast.generics.split_for_impl();
match &ast.data {
Data::Enum(_) => (),
_ => return Err(helpers::non_enum_error()),
};
Ok(quote! {
#[automatically_derived]
impl #impl_generics ::diesel::serialize::ToSql<::diesel::sql_types::Text, ::diesel::pg::Pg> for #name #ty_generics
#where_clause
{
fn to_sql<'b>(&'b self, out: &mut ::diesel::serialize::Output<'b, '_, ::diesel::pg::Pg>) -> ::diesel::serialize::Result {
use ::std::io::Write;
out.write_all(self.to_string().as_bytes())?;
Ok(::diesel::serialize::IsNull::No)
}
}
#[automatically_derived]
impl #impl_generics ::diesel::deserialize::FromSql<::diesel::sql_types::Text, ::diesel::pg::Pg> for #name #ty_generics
#where_clause
{
fn from_sql(value: ::diesel::pg::PgValue) -> diesel::deserialize::Result<Self> {
use ::core::str::FromStr;
Self::from_str(::core::str::from_utf8(value.as_bytes())?)
.map_err(|_| "Unrecognized enum variant".into())
}
}
})
}
<file_sep path="hyperswitch/crates/router_derive/src/macros/diesel.rs" role="context" start="44" end="86">
pub(crate) fn diesel_enum_db_enum_derive_inner(ast: &DeriveInput) -> syn::Result<TokenStream> {
let name = &ast.ident;
let (impl_generics, ty_generics, where_clause) = ast.generics.split_for_impl();
match &ast.data {
Data::Enum(_) => (),
_ => return Err(helpers::non_enum_error()),
};
let struct_name = format_ident!("Db{name}");
let type_name = format!("{name}");
Ok(quote! {
#[derive(::core::clone::Clone, ::core::marker::Copy, ::core::fmt::Debug, ::diesel::QueryId, ::diesel::SqlType)]
#[diesel(postgres_type(name = #type_name))]
pub struct #struct_name;
#[automatically_derived]
impl #impl_generics ::diesel::serialize::ToSql<#struct_name, ::diesel::pg::Pg> for #name #ty_generics
#where_clause
{
fn to_sql<'b>(&'b self, out: &mut ::diesel::serialize::Output<'b, '_, ::diesel::pg::Pg>) -> ::diesel::serialize::Result {
use ::std::io::Write;
out.write_all(self.to_string().as_bytes())?;
Ok(::diesel::serialize::IsNull::No)
}
}
#[automatically_derived]
impl #impl_generics ::diesel::deserialize::FromSql<#struct_name, ::diesel::pg::Pg> for #name #ty_generics
#where_clause
{
fn from_sql(value: ::diesel::pg::PgValue) -> diesel::deserialize::Result<Self> {
use ::core::str::FromStr;
Self::from_str(::core::str::from_utf8(value.as_bytes())?)
.map_err(|_| "Unrecognized enum variant".into())
}
}
})
}
<file_sep path="hyperswitch/crates/router_derive/src/macros/diesel.rs" role="context" start="98" end="104">
pub enum StorageType {
/// Store the Enum as Text value in the database
Text,
/// Store the Enum as Enum in the database. This requires a corresponding enum to be created
/// in the database with the same name
DbEnum,
}
| symbol_neighborhood |
<|meta_start|><|file|> hyperswitch-card-vault/src/config.rs<|crate|> src anchor=config_path kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=1<|meta_end|>
<file_sep path="hyperswitch-card-vault/src/config.rs" role="context" start="213" end="226">
pub fn config_path(environment: &Env, explicit_config_path: Option<PathBuf>) -> PathBuf {
let mut config_path = PathBuf::new();
if let Some(explicit_config_path_val) = explicit_config_path {
config_path.push(explicit_config_path_val);
} else {
let config_directory: String = "config".into();
let config_file_name = environment.config_path();
config_path.push(workspace_path());
config_path.push(config_directory);
config_path.push(config_file_name);
}
config_path
}
<file_sep path="hyperswitch-card-vault/src/config.rs" role="context" start="212" end="212">
use crate::{
api_client::ApiClientConfig,
crypto::secrets_manager::{
secrets_interface::SecretManager, secrets_management::SecretsManagementConfig,
},
error,
logger::config::Log,
};
use std::{
collections::HashMap,
ops::{Deref, DerefMut},
path::PathBuf,
};
<file_sep path="hyperswitch-card-vault/src/config.rs" role="context" start="303" end="306">
pub fn validate(&self) -> error_stack::Result<(), error::ConfigurationError> {
self.secrets_management.validate()?;
Ok(())
}
<file_sep path="hyperswitch-card-vault/src/config.rs" role="context" start="235" end="301">
pub async fn fetch_raw_secrets(
&mut self,
) -> error_stack::Result<(), error::ConfigurationError> {
let secret_management_client = self
.secrets_management
.get_secret_management_client()
.await
.expect("Failed to create secret management client");
self.database.password = secret_management_client
.get_secret(self.database.password.clone())
.await
.change_context(error::ConfigurationError::KmsDecryptError(
"database_password",
))?;
for tenant_secrets in self.tenant_secrets.values_mut() {
tenant_secrets.master_key = hex::decode(
secret_management_client
.get_secret(
String::from_utf8(tenant_secrets.master_key.clone())
.expect("Failed while converting master key to `String`")
.into(),
)
.await
.change_context(error::ConfigurationError::KmsDecryptError("master_key"))?
.expose(),
)
.expect("Failed to hex decode master key")
}
#[cfg(feature = "middleware")]
{
for tenant_secrets in self.tenant_secrets.values_mut() {
tenant_secrets.public_key = secret_management_client
.get_secret(tenant_secrets.public_key.clone())
.await
.change_context(error::ConfigurationError::KmsDecryptError("public_key"))?;
}
self.secrets.locker_private_key = secret_management_client
.get_secret(self.secrets.locker_private_key.clone())
.await
.change_context(error::ConfigurationError::KmsDecryptError(
"locker_private_key",
))?;
}
#[cfg(feature = "external_key_manager_mtls")]
{
self.external_key_manager.cert = secret_management_client
.get_secret(self.external_key_manager.cert.clone())
.await
.change_context(error::ConfigurationError::KmsDecryptError(
"external_key_manager-cert",
))?;
self.api_client.identity = secret_management_client
.get_secret(self.api_client.identity.clone())
.await
.change_context(error::ConfigurationError::KmsDecryptError(
"api_client-identity",
))?;
}
Ok(())
}
<file_sep path="hyperswitch-card-vault/src/config.rs" role="context" start="202" end="210">
pub fn builder(
environment: &Env,
) -> Result<config::ConfigBuilder<config::builder::DefaultState>, config::ConfigError> {
config::Config::builder()
// Here, it should be `set_override()` not `set_default()`.
// "env" can't be altered by config field.
// Should be single source of truth.
.set_override("env", environment.to_string())
}
<file_sep path="hyperswitch-card-vault/src/config.rs" role="context" start="185" end="200">
pub fn new_with_config_path(
explicit_config_path: Option<PathBuf>,
) -> Result<Self, config::ConfigError> {
let env = Env::current_env();
let config_path = Self::config_path(&env, explicit_config_path);
let config = Self::builder(&env)?
.add_source(config::File::from(config_path).required(false))
.add_source(config::Environment::with_prefix("LOCKER").separator("__"))
.build()?;
serde_path_to_error::deserialize(config).map_err(|error| {
eprintln!("Unable to deserialize application configuration: {error}");
error.into_inner()
})
}
<file_sep path="hyperswitch-card-vault/src/config.rs" role="context" start="180" end="182">
pub fn new() -> Result<Self, config::ConfigError> {
Self::new_with_config_path(None)
}
<file_sep path="hyperswitch-card-vault/src/config.rs" role="context" start="170" end="176">
pub fn workspace_path() -> PathBuf {
if let Ok(manifest_dir) = std::env::var("CARGO_MANIFEST_DIR") {
PathBuf::from(manifest_dir)
} else {
PathBuf::from(".")
}
}
<file_sep path="hyperswitch-card-vault/src/config.rs" role="context" start="310" end="313">
pub enum Env {
Development,
Release,
}
| symbol_neighborhood |
<|meta_start|><|file|> hyperswitch/crates/common_utils/src/types.rs<|crate|> common_utils anchor=to_minor_unit_as_i64 kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/common_utils/src/types.rs" role="context" start="527" end="538">
fn to_minor_unit_as_i64(&self) -> Result<MinorUnit, error_stack::Report<ParsingError>> {
let amount_string = &self.0;
let amount_decimal = Decimal::from_str(amount_string).map_err(|e| {
ParsingError::StringToDecimalConversionFailure {
error: e.to_string(),
}
})?;
let amount_i64 = amount_decimal
.to_i64()
.ok_or(ParsingError::DecimalToI64ConversionFailure)?;
Ok(MinorUnit::new(amount_i64))
}
<file_sep path="hyperswitch/crates/common_utils/src/types.rs" role="context" start="526" end="526">
use error_stack::{report, ResultExt};
use rust_decimal::{
prelude::{FromPrimitive, ToPrimitive},
Decimal,
};
use crate::{
consts::{
self, MAX_DESCRIPTION_LENGTH, MAX_STATEMENT_DESCRIPTOR_LENGTH, PUBLISHABLE_KEY_LENGTH,
},
errors::{CustomResult, ParsingError, PercentageError, ValidationError},
fp_utils::when,
};
<file_sep path="hyperswitch/crates/common_utils/src/types.rs" role="context" start="552" end="554">
pub fn zero() -> Self {
Self(0.0)
}
<file_sep path="hyperswitch/crates/common_utils/src/types.rs" role="context" start="547" end="549">
fn new(value: f64) -> Self {
Self(value)
}
<file_sep path="hyperswitch/crates/common_utils/src/types.rs" role="context" start="522" end="524">
fn new(value: String) -> Self {
Self(value)
}
<file_sep path="hyperswitch/crates/common_utils/src/types.rs" role="context" start="511" end="513">
fn sum<I: Iterator<Item = Self>>(iter: I) -> Self {
iter.fold(Self(0), |a, b| a + b)
}
<file_sep path="hyperswitch/crates/common_utils/src/types.rs" role="context" start="722" end="727">
pub(crate) fn new(payment_id: id_type::GlobalPaymentId, secret: String) -> Self {
Self {
payment_id,
secret: masking::Secret::new(secret),
}
}
<file_sep path="hyperswitch/crates/common_utils/src/types.rs" role="context" start="733" end="751">
fn from_str(str_value: &str) -> Result<Self, Self::Err> {
let (payment_id, secret) =
str_value
.rsplit_once("_secret_")
.ok_or(ParsingError::EncodeError(
"Expected a string in the format '{payment_id}_secret_{secret}'",
))?;
let payment_id = id_type::GlobalPaymentId::try_from(Cow::Owned(payment_id.to_owned()))
.map_err(|err| {
logger::error!(global_payment_id_error=?err);
ParsingError::EncodeError("Error while constructing GlobalPaymentId")
})?;
Ok(Self {
payment_id,
secret: masking::Secret::new(secret.to_owned()),
})
}
<file_sep path="hyperswitch/crates/common_utils/src/types.rs" role="context" start="386" end="386">
pub struct MinorUnit(i64);
<file_sep path="hyperswitch/crates/common_utils/src/errors.rs" role="context" start="15" end="55">
pub enum ParsingError {
///Failed to parse enum
#[error("Failed to parse enum: {0}")]
EnumParseFailure(&'static str),
///Failed to parse struct
#[error("Failed to parse struct: {0}")]
StructParseFailure(&'static str),
/// Failed to encode data to given format
#[error("Failed to serialize to {0} format")]
EncodeError(&'static str),
/// Failed to parse data
#[error("Unknown error while parsing")]
UnknownError,
/// Failed to parse datetime
#[error("Failed to parse datetime")]
DateTimeParsingError,
/// Failed to parse email
#[error("Failed to parse email")]
EmailParsingError,
/// Failed to parse phone number
#[error("Failed to parse phone number")]
PhoneNumberParsingError,
/// Failed to parse Float value for converting to decimal points
#[error("Failed to parse Float value for converting to decimal points")]
FloatToDecimalConversionFailure,
/// Failed to parse Decimal value for i64 value conversion
#[error("Failed to parse Decimal value for i64 value conversion")]
DecimalToI64ConversionFailure,
/// Failed to parse string value for f64 value conversion
#[error("Failed to parse string value for f64 value conversion")]
StringToFloatConversionFailure,
/// Failed to parse i64 value for f64 value conversion
#[error("Failed to parse i64 value for f64 value conversion")]
I64ToDecimalConversionFailure,
/// Failed to parse String value to Decimal value conversion because `error`
#[error("Failed to parse String value to Decimal value conversion because {error}")]
StringToDecimalConversionFailure { error: String },
/// Failed to convert the given integer because of integer overflow error
#[error("Integer Overflow error")]
IntegerOverflow,
}
| symbol_neighborhood |
<|meta_start|><|file|> hyperswitch-card-vault/src/crypto/secrets_manager/managers/hcvault/core.rs<|crate|> src anchor=new kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=1<|meta_end|>
<file_sep path="hyperswitch-card-vault/src/crypto/secrets_manager/managers/hcvault/core.rs" role="context" start="99" end="112">
pub fn new(config: &HashiCorpVaultConfig) -> error_stack::Result<Self, HashiCorpError> {
VaultClient::new(
VaultClientSettingsBuilder::default()
.address(&config.url)
.token(config.token.peek())
.build()
.map_err(Into::<Report<_>>::into)
.change_context(HashiCorpError::ClientCreationFailed)
.attach_printable("Failed while building vault settings")?,
)
.map_err(Into::<Report<_>>::into)
.change_context(HashiCorpError::ClientCreationFailed)
.map(|client| Self { client })
}
<file_sep path="hyperswitch-card-vault/src/crypto/secrets_manager/managers/hcvault/core.rs" role="context" start="98" end="98">
use error_stack::{Report, ResultExt};
use vaultrs::client::{VaultClient, VaultClientSettingsBuilder};
<file_sep path="hyperswitch-card-vault/src/crypto/secrets_manager/managers/hcvault/core.rs" role="context" start="149" end="151">
fn from_encoded(input: String) -> Option<Self> {
Some(input.into())
}
<file_sep path="hyperswitch-card-vault/src/crypto/secrets_manager/managers/hcvault/core.rs" role="context" start="125" end="140">
pub async fn fetch<En, I>(&self, data: String) -> error_stack::Result<I, HashiCorpError>
where
for<'a> En: Engine<
ReturnType<'a, String> = Pin<
Box<
dyn Future<Output = error_stack::Result<String, HashiCorpError>>
+ Send
+ 'a,
>,
>,
> + 'a,
I: FromEncoded,
{
let output = En::read(self, data).await?;
I::from_encoded(output).ok_or(error_stack::report!(HashiCorpError::HexDecodingFailed))
}
<file_sep path="hyperswitch-card-vault/src/crypto/secrets_manager/managers/hcvault/core.rs" role="context" start="74" end="89">
fn read(client: &HashiCorpVault, location: String) -> Self::ReturnType<'_, String> {
Box::pin(async move {
let mut split = location.split(':');
let mount = split.next().ok_or(HashiCorpError::IncompleteData)?;
let path = split.next().ok_or(HashiCorpError::IncompleteData)?;
let key = split.next().unwrap_or("value");
let mut output =
vaultrs::kv2::read::<HashMap<String, String>>(&client.client, mount, path)
.await
.map_err(Into::<Report<_>>::into)
.change_context(HashiCorpError::FetchFailed)?;
Ok(output.remove(key).ok_or(HashiCorpError::ParseError)?)
})
}
<file_sep path="hyperswitch-card-vault/src/crypto/secrets_manager/managers/hcvault/core.rs" role="context" start="30" end="44">
pub fn validate(&self) -> Result<(), ConfigurationError> {
if self.url.trim().is_empty() {
return Err(ConfigurationError::InvalidConfigurationValueError(
"HashiCorp vault url must not be empty".into(),
));
}
if self.token.peek().trim().is_empty() {
return Err(ConfigurationError::InvalidConfigurationValueError(
"HashiCorp vault token must not be empty".into(),
));
}
Ok(())
}
<file_sep path="hyperswitch-card-vault/src/crypto/secrets_manager/managers/hcvault/core.rs" role="context" start="162" end="202">
pub enum HashiCorpError {
/// Failed while creating hashicorp client
#[error("Failed while creating a new client")]
ClientCreationFailed,
/// Failed while building configurations for hashicorp client
#[error("Failed while building configuration")]
ConfigurationBuildFailed,
/// Failed while decoding data to hex format
#[error("Failed while decoding hex data")]
HexDecodingFailed,
/// An error occurred when base64 decoding input data.
#[error("Failed to base64 decode input data")]
Base64DecodingFailed,
/// An error occurred when KMS decrypting input data.
#[error("Failed to KMS decrypt input data")]
DecryptionFailed,
/// The KMS decrypted output does not include a plaintext output.
#[error("Missing plaintext KMS decryption output")]
MissingPlaintextDecryptionOutput,
/// An error occurred UTF-8 decoding KMS decrypted output.
#[error("Failed to UTF-8 decode decryption output")]
Utf8DecodingFailed,
/// Incomplete data provided to fetch data from hasicorp
#[error("Provided information about the value is incomplete")]
IncompleteData,
/// Failed while fetching data from vault
#[error("Failed while fetching data from the server")]
FetchFailed,
/// Failed while parsing received data
#[error("Failed while parsing the response")]
ParseError,
}
<file_sep path="hyperswitch-card-vault/src/crypto/secrets_manager/managers/hcvault/core.rs" role="context" start="21" end="26">
pub struct HashiCorpVaultConfig {
/// The URL of the HashiCorp Vault server.
pub url: String,
/// The authentication token used to access HashiCorp Vault.
pub token: Secret<String>,
}
| symbol_neighborhood |
<|meta_start|><|file|> hyperswitch/crates/external_services/src/hashicorp_vault/core.rs<|crate|> external_services anchor=fetch kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=1<|meta_end|>
<file_sep path="hyperswitch/crates/external_services/src/hashicorp_vault/core.rs" role="context" start="131" end="146">
pub async fn fetch<En, I>(&self, data: String) -> error_stack::Result<I, HashiCorpError>
where
for<'a> En: Engine<
ReturnType<'a, String> = Pin<
Box<
dyn Future<Output = error_stack::Result<String, HashiCorpError>>
+ Send
+ 'a,
>,
>,
> + 'a,
I: FromEncoded,
{
let output = En::read(self, data).await?;
I::from_encoded(output).ok_or(error_stack::report!(HashiCorpError::HexDecodingFailed))
}
<file_sep path="hyperswitch/crates/external_services/src/hashicorp_vault/core.rs" role="context" start="130" end="130">
use std::{collections::HashMap, future::Future, pin::Pin};
use error_stack::{Report, ResultExt};
<file_sep path="hyperswitch/crates/external_services/src/hashicorp_vault/core.rs" role="context" start="179" end="181">
fn from_encoded(input: String) -> Option<Self> {
hex::decode(input).ok()
}
<file_sep path="hyperswitch/crates/external_services/src/hashicorp_vault/core.rs" role="context" start="173" end="175">
fn from_encoded(input: String) -> Option<Self> {
Some(input.into())
}
<file_sep path="hyperswitch/crates/external_services/src/hashicorp_vault/core.rs" role="context" start="106" end="119">
pub fn new(config: &HashiCorpVaultConfig) -> error_stack::Result<Self, HashiCorpError> {
VaultClient::new(
VaultClientSettingsBuilder::default()
.address(&config.url)
.token(config.token.peek())
.build()
.map_err(Into::<Report<_>>::into)
.change_context(HashiCorpError::ClientCreationFailed)
.attach_printable("Failed while building vault settings")?,
)
.map_err(Into::<Report<_>>::into)
.change_context(HashiCorpError::ClientCreationFailed)
.map(|client| Self { client })
}
<file_sep path="hyperswitch/crates/external_services/src/hashicorp_vault/core.rs" role="context" start="82" end="97">
fn read(client: &HashiCorpVault, location: String) -> Self::ReturnType<'_, String> {
Box::pin(async move {
let mut split = location.split(':');
let mount = split.next().ok_or(HashiCorpError::IncompleteData)?;
let path = split.next().ok_or(HashiCorpError::IncompleteData)?;
let key = split.next().unwrap_or("value");
let mut output =
vaultrs::kv2::read::<HashMap<String, String>>(&client.client, mount, path)
.await
.map_err(Into::<Report<_>>::into)
.change_context(HashiCorpError::FetchFailed)?;
Ok(output.remove(key).ok_or(HashiCorpError::ParseError)?)
})
}
<file_sep path="hyperswitch/crates/external_services/src/hashicorp_vault/core.rs" role="context" start="186" end="226">
pub enum HashiCorpError {
/// Failed while creating hashicorp client
#[error("Failed while creating a new client")]
ClientCreationFailed,
/// Failed while building configurations for hashicorp client
#[error("Failed while building configuration")]
ConfigurationBuildFailed,
/// Failed while decoding data to hex format
#[error("Failed while decoding hex data")]
HexDecodingFailed,
/// An error occurred when base64 decoding input data.
#[error("Failed to base64 decode input data")]
Base64DecodingFailed,
/// An error occurred when KMS decrypting input data.
#[error("Failed to KMS decrypt input data")]
DecryptionFailed,
/// The KMS decrypted output does not include a plaintext output.
#[error("Missing plaintext KMS decryption output")]
MissingPlaintextDecryptionOutput,
/// An error occurred UTF-8 decoding KMS decrypted output.
#[error("Failed to UTF-8 decode decryption output")]
Utf8DecodingFailed,
/// Incomplete data provided to fetch data from hasicorp
#[error("Provided information about the value is incomplete")]
IncompleteData,
/// Failed while fetching data from vault
#[error("Failed while fetching data from the server")]
FetchFailed,
/// Failed while parsing received data
#[error("Failed while parsing the response")]
ParseError,
}
<file_sep path="hyperswitch/crates/external_services/src/hashicorp_vault/core.rs" role="context" start="150" end="170">
pub trait FromEncoded: Sized {
/// Constructs an instance of the type from the provided encoded input.
///
/// # Parameters
///
/// - `input`: A String containing the encoded data.
///
/// # Returns
///
/// An `Option<Self>` representing the constructed instance if successful, or `None` otherwise.
///
/// # Example
///
/// ```rust
/// use external_services::hashicorp_vault::core::FromEncoded;
/// use masking::Secret;
/// let secret_instance = Secret::<String>::from_encoded("encoded_secret_string".to_string());
/// let vec_instance = Vec::<u8>::from_encoded("68656c6c6f".to_string());
/// ```
fn from_encoded(input: String) -> Option<Self>;
}
<file_sep path="hyperswitch/crates/external_services/src/hashicorp_vault/core.rs" role="context" start="56" end="73">
pub trait Engine: Sized {
/// The associated type representing the return type of the engine's operations.
type ReturnType<'b, T>
where
T: 'b,
Self: 'b;
/// Reads data from HashiCorp Vault at the specified location.
///
/// # Parameters
///
/// - `client`: A reference to the HashiCorpVault client.
/// - `location`: The location in HashiCorp Vault to read data from.
///
/// # Returns
///
/// A future representing the result of the read operation.
fn read(client: &HashiCorpVault, location: String) -> Self::ReturnType<'_, String>;
}
| symbol_neighborhood |
<|meta_start|><|file|> hyperswitch-card-vault/src/crypto/secrets_manager/managers/hcvault/core.rs<|crate|> src anchor=fetch kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=1<|meta_end|>
<file_sep path="hyperswitch-card-vault/src/crypto/secrets_manager/managers/hcvault/core.rs" role="context" start="125" end="140">
pub async fn fetch<En, I>(&self, data: String) -> error_stack::Result<I, HashiCorpError>
where
for<'a> En: Engine<
ReturnType<'a, String> = Pin<
Box<
dyn Future<Output = error_stack::Result<String, HashiCorpError>>
+ Send
+ 'a,
>,
>,
> + 'a,
I: FromEncoded,
{
let output = En::read(self, data).await?;
I::from_encoded(output).ok_or(error_stack::report!(HashiCorpError::HexDecodingFailed))
}
<file_sep path="hyperswitch-card-vault/src/crypto/secrets_manager/managers/hcvault/core.rs" role="context" start="124" end="124">
use std::{collections::HashMap, future::Future, pin::Pin};
use error_stack::{Report, ResultExt};
<file_sep path="hyperswitch-card-vault/src/crypto/secrets_manager/managers/hcvault/core.rs" role="context" start="155" end="157">
fn from_encoded(input: String) -> Option<Self> {
hex::decode(input).ok()
}
<file_sep path="hyperswitch-card-vault/src/crypto/secrets_manager/managers/hcvault/core.rs" role="context" start="149" end="151">
fn from_encoded(input: String) -> Option<Self> {
Some(input.into())
}
<file_sep path="hyperswitch-card-vault/src/crypto/secrets_manager/managers/hcvault/core.rs" role="context" start="99" end="112">
pub fn new(config: &HashiCorpVaultConfig) -> error_stack::Result<Self, HashiCorpError> {
VaultClient::new(
VaultClientSettingsBuilder::default()
.address(&config.url)
.token(config.token.peek())
.build()
.map_err(Into::<Report<_>>::into)
.change_context(HashiCorpError::ClientCreationFailed)
.attach_printable("Failed while building vault settings")?,
)
.map_err(Into::<Report<_>>::into)
.change_context(HashiCorpError::ClientCreationFailed)
.map(|client| Self { client })
}
<file_sep path="hyperswitch-card-vault/src/crypto/secrets_manager/managers/hcvault/core.rs" role="context" start="74" end="89">
fn read(client: &HashiCorpVault, location: String) -> Self::ReturnType<'_, String> {
Box::pin(async move {
let mut split = location.split(':');
let mount = split.next().ok_or(HashiCorpError::IncompleteData)?;
let path = split.next().ok_or(HashiCorpError::IncompleteData)?;
let key = split.next().unwrap_or("value");
let mut output =
vaultrs::kv2::read::<HashMap<String, String>>(&client.client, mount, path)
.await
.map_err(Into::<Report<_>>::into)
.change_context(HashiCorpError::FetchFailed)?;
Ok(output.remove(key).ok_or(HashiCorpError::ParseError)?)
})
}
<file_sep path="hyperswitch-card-vault/src/crypto/secrets_manager/managers/hcvault/core.rs" role="context" start="162" end="202">
pub enum HashiCorpError {
/// Failed while creating hashicorp client
#[error("Failed while creating a new client")]
ClientCreationFailed,
/// Failed while building configurations for hashicorp client
#[error("Failed while building configuration")]
ConfigurationBuildFailed,
/// Failed while decoding data to hex format
#[error("Failed while decoding hex data")]
HexDecodingFailed,
/// An error occurred when base64 decoding input data.
#[error("Failed to base64 decode input data")]
Base64DecodingFailed,
/// An error occurred when KMS decrypting input data.
#[error("Failed to KMS decrypt input data")]
DecryptionFailed,
/// The KMS decrypted output does not include a plaintext output.
#[error("Missing plaintext KMS decryption output")]
MissingPlaintextDecryptionOutput,
/// An error occurred UTF-8 decoding KMS decrypted output.
#[error("Failed to UTF-8 decode decryption output")]
Utf8DecodingFailed,
/// Incomplete data provided to fetch data from hasicorp
#[error("Provided information about the value is incomplete")]
IncompleteData,
/// Failed while fetching data from vault
#[error("Failed while fetching data from the server")]
FetchFailed,
/// Failed while parsing received data
#[error("Failed while parsing the response")]
ParseError,
}
<file_sep path="hyperswitch-card-vault/src/crypto/secrets_manager/managers/hcvault/core.rs" role="context" start="144" end="146">
pub trait FromEncoded: Sized {
fn from_encoded(input: String) -> Option<Self>;
}
<file_sep path="hyperswitch-card-vault/src/crypto/secrets_manager/managers/hcvault/core.rs" role="context" start="48" end="65">
pub trait Engine: Sized {
/// The associated type representing the return type of the engine's operations.
type ReturnType<'b, T>
where
T: 'b,
Self: 'b;
/// Reads data from HashiCorp Vault at the specified location.
///
/// # Parameters
///
/// - `client`: A reference to the HashiCorpVault client.
/// - `location`: The location in HashiCorp Vault to read data from.
///
/// # Returns
///
/// A future representing the result of the read operation.
fn read(client: &HashiCorpVault, location: String) -> Self::ReturnType<'_, String>;
}
| symbol_neighborhood |
<|meta_start|><|file|> hyperswitch/crates/cards/src/validate.rs<|crate|> cards anchor=fmt kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=1<|meta_end|>
<file_sep path="hyperswitch/crates/cards/src/validate.rs" role="context" start="299" end="313">
fn fmt(val: &T, f: &mut fmt::Formatter<'_>) -> fmt::Result {
let val_str: &str = val.as_ref();
if val_str.len() < 15 || val_str.len() > 19 {
return WithType::fmt(val, f);
}
if let Some(value) = val_str.get(..6) {
write!(f, "{}{}", value, "*".repeat(val_str.len() - 6))
} else {
#[cfg(not(target_arch = "wasm32"))]
logger::error!("Invalid card number {val_str}");
WithType::fmt(val, f)
}
}
<file_sep path="hyperswitch/crates/cards/src/validate.rs" role="context" start="298" end="298">
use std::{collections::HashMap, fmt, ops::Deref, str::FromStr};
use masking::{PeekInterface, Strategy, StrongSecret, WithType};
use router_env::{logger, which as router_env_which, Env};
<file_sep path="hyperswitch/crates/cards/src/validate.rs" role="context" start="334" end="340">
fn invalid_card_number_length() {
let s = "371446";
assert_eq!(
CardNumber::from_str(s).unwrap_err().to_string(),
"invalid card number length".to_string()
);
}
<file_sep path="hyperswitch/crates/cards/src/validate.rs" role="context" start="325" end="331">
fn valid_card_number() {
let s = "371449635398431";
assert_eq!(
CardNumber::from_str(s).unwrap(),
CardNumber(StrongSecret::from_str(s).unwrap())
);
}
<file_sep path="hyperswitch/crates/cards/src/validate.rs" role="context" start="287" end="290">
fn deserialize<D: Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
let s = String::deserialize(d)?;
Self::from_str(&s).map_err(serde::de::Error::custom)
}
<file_sep path="hyperswitch/crates/cards/src/validate.rs" role="context" start="280" end="283">
fn deserialize<D: Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
let s = String::deserialize(d)?;
Self::from_str(&s).map_err(serde::de::Error::custom)
}
| symbol_neighborhood |
<|meta_start|><|file|> hyperswitch/crates/drainer/src/services.rs<|crate|> drainer anchor=new kind=fn pack=symbol_neighborhood lang=rust role_window=k2 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/drainer/src/services.rs" role="context" start="32" end="51">
pub async fn new(config: &crate::Settings, test_transaction: bool, tenant: &Tenant) -> Self {
let redis_conn = crate::connection::redis_connection(config).await;
Self {
master_pool: diesel_make_pg_pool(
config.master_database.get_inner(),
test_transaction,
&tenant.schema,
)
.await,
redis_conn: Arc::new(RedisConnectionPool::clone(
&redis_conn,
&tenant.redis_key_prefix,
)),
config: StoreConfig {
drainer_stream_name: config.drainer.stream_name.clone(),
drainer_num_partitions: config.drainer.num_partitions,
},
request_id: None,
}
}
<file_sep path="hyperswitch/crates/drainer/src/services.rs" role="context" start="31" end="31">
use std::sync::Arc;
use redis_interface::RedisConnectionPool;
use crate::{
connection::{diesel_make_pg_pool, PgPool},
logger,
settings::Tenant,
};
<file_sep path="hyperswitch/crates/drainer/src/services.rs" role="context" start="68" end="72">
pub fn http_response_json<T: body::MessageBody + 'static>(response: T) -> HttpResponse {
HttpResponse::Ok()
.content_type(mime::APPLICATION_JSON)
.body(response)
}
<file_sep path="hyperswitch/crates/drainer/src/services.rs" role="context" start="54" end="66">
pub fn log_and_return_error_response<T>(error: Report<T>) -> HttpResponse
where
T: error_stack::Context + ResponseError + Clone,
{
logger::error!(?error);
let body = serde_json::json!({
"message": error.to_string()
})
.to_string();
HttpResponse::InternalServerError()
.content_type(mime::APPLICATION_JSON)
.body(body)
}
<file_sep path="hyperswitch/crates/drainer/src/services.rs" role="context" start="22" end="25">
pub struct StoreConfig {
pub drainer_stream_name: String,
pub drainer_num_partitions: u8,
}
<file_sep path="hyperswitch/crates/drainer/src/settings.rs" role="context" start="178" end="185">
pub struct Tenant {
pub tenant_id: id_type::TenantId,
pub base_url: String,
pub schema: String,
pub accounts_schema: String,
pub redis_key_prefix: String,
pub clickhouse_database: String,
}
<file_sep path="hyperswitch/crates/api_models/src/user/theme.rs" role="context" start="63" end="70">
struct Settings {
colors: Colors,
sidebar: Option<Sidebar>,
typography: Option<Typography>,
buttons: Buttons,
borders: Option<Borders>,
spacing: Option<Spacing>,
}
| symbol_neighborhood |
<|meta_start|><|file|> hyperswitch/crates/common_types/src/payment_methods.rs<|crate|> common_types anchor=to_sql kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/common_types/src/payment_methods.rs" role="context" start="43" end="52">
fn to_sql<'b>(
&'b self,
out: &mut diesel::serialize::Output<'b, '_, diesel::pg::Pg>,
) -> diesel::serialize::Result {
let value = serde_json::to_value(self)?;
// the function `reborrow` only works in case of `Pg` backend. But, in case of other backends
// please refer to the diesel migration blog:
// https://github.com/Diesel-rs/Diesel/blob/master/guide_drafts/migration_guide.md#changed-tosql-implementations
<serde_json::Value as ToSql<Json, diesel::pg::Pg>>::to_sql(&value, &mut out.reborrow())
}
<file_sep path="hyperswitch/crates/common_types/src/payment_methods.rs" role="context" start="42" end="42">
use diesel::{
backend::Backend,
deserialize,
deserialize::FromSql,
serialize::ToSql,
sql_types::{Json, Jsonb},
AsExpression, Queryable,
};
<file_sep path="hyperswitch/crates/common_types/src/payment_methods.rs" role="context" start="98" end="100">
pub fn get_payment_method(&self) -> Option<common_enums::PaymentMethod> {
Some(self.payment_method_type)
}
<file_sep path="hyperswitch/crates/common_types/src/payment_methods.rs" role="context" start="70" end="92">
fn from(helper: PaymentMethodsEnabledHelper) -> Self {
match helper {
PaymentMethodsEnabledHelper::V2 {
payment_method_type,
payment_method_subtypes,
} => Self {
payment_method_type,
payment_method_subtypes,
},
PaymentMethodsEnabledHelper::V1 {
payment_method,
payment_method_types,
} => Self {
payment_method_type: payment_method,
payment_method_subtypes: payment_method_types.map(|subtypes| {
subtypes
.into_iter()
.map(RequestPaymentMethodTypes::from)
.collect()
}),
},
}
}
<file_sep path="hyperswitch/crates/common_types/src/payment_methods.rs" role="context" start="34" end="38">
fn from_sql(bytes: <diesel::pg::Pg as Backend>::RawValue<'_>) -> deserialize::Result<Self> {
let helper: PaymentMethodsEnabledHelper = serde_json::from_slice(bytes.as_bytes())
.map_err(|e| Box::new(diesel::result::Error::DeserializationError(Box::new(e))))?;
Ok(helper.into())
}
<file_sep path="hyperswitch/crates/api_models/src/payment_methods.rs" role="context" start="1670" end="1670">
type Value = PaymentMethodListRequest;
| symbol_neighborhood |
<|meta_start|><|file|> hyperswitch-card-vault/src/logger/formatter.rs<|crate|> src anchor=span_serialize kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch-card-vault/src/logger/formatter.rs" role="context" start="217" end="242">
fn span_serialize<S>(
&self,
span: &SpanRef<'_, S>,
ty: RecordType,
) -> Result<Vec<u8>, std::io::Error>
where
S: Subscriber + for<'a> LookupSpan<'a>,
{
let mut buffer = Vec::new();
let mut serializer = serde_json::Serializer::new(&mut buffer);
let mut map_serializer = serializer.serialize_map(None)?;
let message = Self::span_message(span, ty);
let mut storage = Storage::default();
storage.record_value(MESSAGE, message.into());
self.common_serialize(
&mut map_serializer,
span.metadata(),
Some(span),
&storage,
span.name(),
)?;
map_serializer.end()?;
Ok(buffer)
}
<file_sep path="hyperswitch-card-vault/src/logger/formatter.rs" role="context" start="216" end="216">
use std::{
collections::{HashMap, HashSet},
fmt,
io::Write,
};
use serde::ser::{SerializeMap, Serializer};
use serde_json::Value;
use super::storage::Storage;
use tracing::{Event, Metadata, Subscriber};
use tracing_subscriber::{
fmt::MakeWriter,
layer::Context,
registry::{LookupSpan, SpanRef},
Layer,
};
<file_sep path="hyperswitch-card-vault/src/logger/formatter.rs" role="context" start="274" end="279">
fn span_message<S>(span: &SpanRef<'_, S>, ty: RecordType) -> String
where
S: Subscriber + for<'a> LookupSpan<'a>,
{
format!("[{} - {}]", span.metadata().name().to_uppercase(), ty)
}
<file_sep path="hyperswitch-card-vault/src/logger/formatter.rs" role="context" start="245" end="267">
pub fn event_serialize<S>(
&self,
span: &Option<&SpanRef<'_, S>>,
event: &Event<'_>,
) -> std::io::Result<Vec<u8>>
where
S: Subscriber + for<'a> LookupSpan<'a>,
{
let mut buffer = Vec::new();
let mut serializer = serde_json::Serializer::new(&mut buffer);
let mut map_serializer = serializer.serialize_map(None)?;
let mut storage = Storage::default();
event.record(&mut storage);
let name = span.map_or("?", SpanRef::name);
Self::event_message(span, event, &mut storage);
self.common_serialize(&mut map_serializer, event.metadata(), *span, &storage, name)?;
map_serializer.end()?;
Ok(buffer)
}
<file_sep path="hyperswitch-card-vault/src/logger/formatter.rs" role="context" start="211" end="214">
fn flush(&self, mut buffer: Vec<u8>) -> Result<(), std::io::Error> {
buffer.write_all(b"\n")?;
self.dst_writer.make_writer().write_all(&buffer)
}
<file_sep path="hyperswitch-card-vault/src/logger/formatter.rs" role="context" start="147" end="204">
fn common_serialize<S>(
&self,
map_serializer: &mut impl SerializeMap<Error = serde_json::Error>,
metadata: &Metadata<'_>,
span: Option<&SpanRef<'_, S>>,
storage: &Storage<'_>,
name: &str,
) -> Result<(), std::io::Error>
where
S: Subscriber + for<'a> LookupSpan<'a>,
{
let is_extra = |s: &str| !IMPLICIT_KEYS.contains(s);
map_serializer.serialize_entry(HOSTNAME, &self.hostname)?;
map_serializer.serialize_entry(PID, &self.pid)?;
map_serializer.serialize_entry(LEVEL, &format_args!("{}", metadata.level()))?;
map_serializer.serialize_entry(TARGET, metadata.target())?;
map_serializer.serialize_entry(SERVICE, &self.service)?;
map_serializer.serialize_entry(LINE, &metadata.line())?;
map_serializer.serialize_entry(FILE, &metadata.file())?;
map_serializer.serialize_entry(FN, name)?;
map_serializer
.serialize_entry(FULL_NAME, &format_args!("{}::{}", metadata.target(), name))?;
if let Ok(time) = &time::OffsetDateTime::now_utc().format(&Iso8601::DEFAULT) {
map_serializer.serialize_entry(TIME, time)?;
}
// Write down implicit default entries.
for (key, value) in self.default_fields.iter() {
map_serializer.serialize_entry(key, value)?;
}
let mut explicit_entries_set: HashSet<&str> = HashSet::default();
// Write down explicit event's entries.
for (key, value) in storage.values.iter() {
map_serializer.serialize_entry(key, value)?;
explicit_entries_set.insert(key);
}
// Write down entries from the span, if it exists.
if let Some(span) = &span {
let extensions = span.extensions();
if let Some(visitor) = extensions.get::<Storage<'_>>() {
for (key, value) in &visitor.values {
if is_extra(key) && !explicit_entries_set.contains(key) {
map_serializer.serialize_entry(key, value)?;
} else {
eprintln!(
"Attempting to log a reserved entry. It won't be added to the logs. key: {key:?}, value: {value:?}"
);
}
}
}
}
Ok(())
}
<file_sep path="hyperswitch-card-vault/src/logger/formatter.rs" role="context" start="112" end="114">
pub fn new(service: &str, dst_writer: W) -> Self {
Self::new_with_implicit_entries(service, dst_writer, HashMap::new())
}
<file_sep path="hyperswitch-card-vault/src/logger/formatter.rs" role="context" start="61" end="68">
pub enum RecordType {
/// Entering a span.
EnterSpan,
/// Exiting a span.
ExitSpan,
/// Event.
Event,
}
<file_sep path="hyperswitch-encryption-service/src/types/core/identifier.rs" role="context" start="40" end="40">
type Error = error_stack::Report<errors::ParsingError>;
| symbol_neighborhood |
<|meta_start|><|file|> hyperswitch/crates/storage_impl/src/lib.rs<|crate|> storage_impl anchor=test_store kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/storage_impl/src/lib.rs" role="context" start="222" end="240">
pub async fn test_store(
db_conf: T::Config,
tenant_config: &dyn config::TenantConfig,
cache_conf: &redis_interface::RedisSettings,
encryption_key: StrongSecret<Vec<u8>>,
) -> error_stack::Result<Self, StorageError> {
// TODO: create an error enum and return proper error here
let db_store = T::new(db_conf, tenant_config, true).await?;
let cache_store = RedisStore::new(cache_conf)
.await
.change_context(StorageError::InitializationError)
.attach_printable("failed to create redis cache")?;
Ok(Self {
db_store,
cache_store: Arc::new(cache_store),
master_encryption_key: encryption_key,
request_id: None,
})
}
<file_sep path="hyperswitch/crates/storage_impl/src/lib.rs" role="context" start="221" end="221">
use std::{fmt::Debug, sync::Arc};
use error_stack::ResultExt;
use masking::StrongSecret;
use redis::{kv_store::RedisConnInterface, pub_sub::PubSubInterface, RedisStore};
pub use mock_db::MockDb;
use redis_interface::{errors::RedisError, RedisConnectionPool, SaddReply};
pub use crate::database::store::Store;
pub use crate::{database::store::DatabaseStore, errors::StorageError};
<file_sep path="hyperswitch/crates/storage_impl/src/lib.rs" role="context" start="273" end="289">
async fn check_for_constraints(
&self,
redis_conn: &Arc<RedisConnectionPool>,
) -> CustomResult<(), RedisError> {
let constraints = self.unique_constraints();
let sadd_result = redis_conn
.sadd(
&format!("unique_constraint:{}", self.table_name()).into(),
constraints,
)
.await?;
match sadd_result {
SaddReply::KeyNotSet => Err(error_stack::report!(RedisError::SetAddMembersFailed)),
SaddReply::KeySet => Ok(()),
}
}
<file_sep path="hyperswitch/crates/storage_impl/src/lib.rs" role="context" start="251" end="267">
pub(crate) fn diesel_error_to_data_error(
diesel_error: diesel_models::errors::DatabaseError,
) -> StorageError {
match diesel_error {
diesel_models::errors::DatabaseError::DatabaseConnectionError => {
StorageError::DatabaseConnectionError
}
diesel_models::errors::DatabaseError::NotFound => {
StorageError::ValueNotFound("Value not found".to_string())
}
diesel_models::errors::DatabaseError::UniqueViolation => StorageError::DuplicateValue {
entity: "entity ",
key: None,
},
_ => StorageError::DatabaseError(error_stack::report!(diesel_error)),
}
}
<file_sep path="hyperswitch/crates/storage_impl/src/lib.rs" role="context" start="182" end="217">
pub async fn find_resources<D, R, M>(
&self,
state: &KeyManagerState,
key_store: &MerchantKeyStore,
execute_query: R,
) -> error_stack::Result<Vec<D>, StorageError>
where
D: Debug + Sync + Conversion,
R: futures::Future<
Output = error_stack::Result<Vec<M>, diesel_models::errors::DatabaseError>,
> + Send,
M: ReverseConversion<D>,
{
let resource_futures = execute_query
.await
.map_err(|error| {
let new_err = diesel_error_to_data_error(*error.current_context());
error.change_context(new_err)
})?
.into_iter()
.map(|resource| async {
resource
.convert(
state,
key_store.key.get_inner(),
key_store.merchant_id.clone().into(),
)
.await
.change_context(StorageError::DecryptionError)
})
.collect::<Vec<_>>();
let resources = futures::future::try_join_all(resource_futures).await?;
Ok(resources)
}
<file_sep path="hyperswitch/crates/storage_impl/src/lib.rs" role="context" start="155" end="180">
pub async fn call_database<D, R, M>(
&self,
state: &KeyManagerState,
key_store: &MerchantKeyStore,
execute_query: R,
) -> error_stack::Result<D, StorageError>
where
D: Debug + Sync + Conversion,
R: futures::Future<Output = error_stack::Result<M, diesel_models::errors::DatabaseError>>
+ Send,
M: ReverseConversion<D>,
{
execute_query
.await
.map_err(|error| {
let new_err = diesel_error_to_data_error(*error.current_context());
error.change_context(new_err)
})?
.convert(
state,
key_store.key.get_inner(),
key_store.merchant_id.clone().into(),
)
.await
.change_context(StorageError::DecryptionError)
}
<file_sep path="hyperswitch/crates/storage_impl/src/lib.rs" role="context" start="63" end="85">
async fn new(
config: Self::Config,
tenant_config: &dyn config::TenantConfig,
test_transaction: bool,
) -> error_stack::Result<Self, StorageError> {
let (db_conf, cache_conf, encryption_key, cache_error_signal, inmemory_cache_stream) =
config;
if test_transaction {
Self::test_store(db_conf, tenant_config, &cache_conf, encryption_key)
.await
.attach_printable("failed to create test router store")
} else {
Self::from_config(
db_conf,
tenant_config,
encryption_key,
Self::cache_store(&cache_conf, cache_error_signal).await?,
inmemory_cache_stream,
)
.await
.attach_printable("failed to create store")
}
}
<file_sep path="hyperswitch/crates/storage_impl/src/lib.rs" role="context" start="56" end="62">
type Config = (
T::Config,
redis_interface::RedisSettings,
StrongSecret<Vec<u8>>,
tokio::sync::oneshot::Sender<()>,
&'static str,
);
<file_sep path="hyperswitch/crates/storage_impl/src/redis.rs" role="context" start="12" end="15">
pub struct RedisStore {
// Maybe expose the redis_conn via traits instead of the making the field public
pub(crate) redis_conn: Arc<redis_interface::RedisConnectionPool>,
}
<file_sep path="hyperswitch/migrations/2022-09-29-084920_create_initial_tables/up.sql" role="context" start="257" end="273">
first_name VARCHAR(255),
last_name VARCHAR(255),
phone_number VARCHAR(255),
country_code VARCHAR(255),
created_at TIMESTAMP NOT NULL DEFAULT now()::TIMESTAMP,
modified_at TIMESTAMP NOT NULL DEFAULT now()::TIMESTAMP
);
CREATE TABLE configs (
id SERIAL,
key VARCHAR(255) NOT NULL,
config TEXT NOT NULL,
PRIMARY KEY (key)
);
CREATE TABLE customers (
id SERIAL,
| symbol_neighborhood |
<|meta_start|><|file|> hyperswitch-card-vault/src/logger/formatter.rs<|crate|> src anchor=event_serialize kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch-card-vault/src/logger/formatter.rs" role="context" start="245" end="267">
pub fn event_serialize<S>(
&self,
span: &Option<&SpanRef<'_, S>>,
event: &Event<'_>,
) -> std::io::Result<Vec<u8>>
where
S: Subscriber + for<'a> LookupSpan<'a>,
{
let mut buffer = Vec::new();
let mut serializer = serde_json::Serializer::new(&mut buffer);
let mut map_serializer = serializer.serialize_map(None)?;
let mut storage = Storage::default();
event.record(&mut storage);
let name = span.map_or("?", SpanRef::name);
Self::event_message(span, event, &mut storage);
self.common_serialize(&mut map_serializer, event.metadata(), *span, &storage, name)?;
map_serializer.end()?;
Ok(buffer)
}
<file_sep path="hyperswitch-card-vault/src/logger/formatter.rs" role="context" start="244" end="244">
use std::{
collections::{HashMap, HashSet},
fmt,
io::Write,
};
use serde::ser::{SerializeMap, Serializer};
use serde_json::Value;
use super::storage::Storage;
use tracing::{Event, Metadata, Subscriber};
use tracing_subscriber::{
fmt::MakeWriter,
layer::Context,
registry::{LookupSpan, SpanRef},
Layer,
};
<file_sep path="hyperswitch-card-vault/src/logger/formatter.rs" role="context" start="286" end="302">
fn event_message<S>(
span: &Option<&SpanRef<'_, S>>,
event: &Event<'_>,
storage: &mut Storage<'_>,
) where
S: Subscriber + for<'a> LookupSpan<'a>,
{
let message = storage
.values
.entry(MESSAGE)
.or_insert_with(|| event.metadata().target().into());
// Prepend the span name to the message if span exists.
if let (Some(span), Value::String(a)) = (span, message) {
*a = format!("{} {}", Self::span_message(span, RecordType::Event), a,);
}
}
<file_sep path="hyperswitch-card-vault/src/logger/formatter.rs" role="context" start="274" end="279">
fn span_message<S>(span: &SpanRef<'_, S>, ty: RecordType) -> String
where
S: Subscriber + for<'a> LookupSpan<'a>,
{
format!("[{} - {}]", span.metadata().name().to_uppercase(), ty)
}
<file_sep path="hyperswitch-card-vault/src/logger/formatter.rs" role="context" start="217" end="242">
fn span_serialize<S>(
&self,
span: &SpanRef<'_, S>,
ty: RecordType,
) -> Result<Vec<u8>, std::io::Error>
where
S: Subscriber + for<'a> LookupSpan<'a>,
{
let mut buffer = Vec::new();
let mut serializer = serde_json::Serializer::new(&mut buffer);
let mut map_serializer = serializer.serialize_map(None)?;
let message = Self::span_message(span, ty);
let mut storage = Storage::default();
storage.record_value(MESSAGE, message.into());
self.common_serialize(
&mut map_serializer,
span.metadata(),
Some(span),
&storage,
span.name(),
)?;
map_serializer.end()?;
Ok(buffer)
}
<file_sep path="hyperswitch-card-vault/src/logger/formatter.rs" role="context" start="211" end="214">
fn flush(&self, mut buffer: Vec<u8>) -> Result<(), std::io::Error> {
buffer.write_all(b"\n")?;
self.dst_writer.make_writer().write_all(&buffer)
}
<file_sep path="hyperswitch-card-vault/src/logger/formatter.rs" role="context" start="112" end="114">
pub fn new(service: &str, dst_writer: W) -> Self {
Self::new_with_implicit_entries(service, dst_writer, HashMap::new())
}
<file_sep path="hyperswitch-card-vault/src/storage.rs" role="context" start="33" end="35">
pub struct Storage {
pg_pool: Arc<Pool<AsyncPgConnection>>,
}
<file_sep path="hyperswitch/migrations/2022-09-29-084920_create_initial_tables/up.sql" role="context" start="279" end="295">
phone_country_code VARCHAR(255),
description VARCHAR(255),
address JSON,
created_at TIMESTAMP NOT NULL DEFAULT now()::TIMESTAMP,
metadata JSON,
PRIMARY KEY (customer_id, merchant_id)
);
CREATE TABLE events (
id SERIAL PRIMARY KEY,
event_id VARCHAR(255) NOT NULL,
event_type "EventType" NOT NULL,
event_class "EventClass" NOT NULL,
is_webhook_notified BOOLEAN NOT NULL DEFAULT FALSE,
intent_reference_id VARCHAR(255),
primary_object_id VARCHAR(255) NOT NULL,
primary_object_type "EventObjectType" NOT NULL,
| symbol_neighborhood |
<|meta_start|><|file|> hyperswitch/crates/router_env/src/logger/formatter.rs<|crate|> router_env anchor=span_serialize kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/router_env/src/logger/formatter.rs" role="context" start="302" end="328">
fn span_serialize<S>(
&self,
span: &SpanRef<'_, S>,
ty: RecordType,
) -> Result<Vec<u8>, std::io::Error>
where
S: Subscriber + for<'a> LookupSpan<'a>,
{
let mut buffer = Vec::new();
let mut serializer =
serde_json::Serializer::with_formatter(&mut buffer, self.formatter.clone());
let mut map_serializer = serializer.serialize_map(None)?;
let message = Self::span_message(span, ty);
let mut storage = Storage::default();
storage.record_value("message", message.into());
self.common_serialize(
&mut map_serializer,
span.metadata(),
Some(span),
&storage,
span.name(),
)?;
map_serializer.end()?;
Ok(buffer)
}
<file_sep path="hyperswitch/crates/router_env/src/logger/formatter.rs" role="context" start="301" end="301">
use std::{
collections::{HashMap, HashSet},
fmt,
io::Write,
};
use serde::ser::{SerializeMap, Serializer};
use serde_json::{ser::Formatter, Value};
use tracing::{Event, Metadata, Subscriber};
use tracing_subscriber::{
fmt::MakeWriter,
layer::Context,
registry::{LookupSpan, SpanRef},
Layer,
};
use crate::Storage;
<file_sep path="hyperswitch/crates/router_env/src/logger/formatter.rs" role="context" start="359" end="364">
fn span_message<S>(span: &SpanRef<'_, S>, ty: RecordType) -> String
where
S: Subscriber + for<'a> LookupSpan<'a>,
{
format!("[{} - {}]", span.metadata().name().to_uppercase(), ty)
}
<file_sep path="hyperswitch/crates/router_env/src/logger/formatter.rs" role="context" start="331" end="354">
pub fn event_serialize<S>(
&self,
span: Option<&SpanRef<'_, S>>,
event: &Event<'_>,
) -> std::io::Result<Vec<u8>>
where
S: Subscriber + for<'a> LookupSpan<'a>,
{
let mut buffer = Vec::new();
let mut serializer =
serde_json::Serializer::with_formatter(&mut buffer, self.formatter.clone());
let mut map_serializer = serializer.serialize_map(None)?;
let mut storage = Storage::default();
event.record(&mut storage);
let name = span.map_or("?", SpanRef::name);
Self::event_message(span, event, &mut storage);
self.common_serialize(&mut map_serializer, event.metadata(), span, &storage, name)?;
map_serializer.end()?;
Ok(buffer)
}
<file_sep path="hyperswitch/crates/router_env/src/logger/formatter.rs" role="context" start="296" end="299">
fn flush(&self, mut buffer: Vec<u8>) -> Result<(), std::io::Error> {
buffer.write_all(b"\n")?;
self.dst_writer.make_writer().write_all(&buffer)
}
<file_sep path="hyperswitch/crates/router_env/src/logger/formatter.rs" role="context" start="201" end="291">
fn common_serialize<S>(
&self,
map_serializer: &mut impl SerializeMap<Error = serde_json::Error>,
metadata: &Metadata<'_>,
span: Option<&SpanRef<'_, S>>,
storage: &Storage<'_>,
name: &str,
) -> Result<(), std::io::Error>
where
S: Subscriber + for<'a> LookupSpan<'a>,
{
let is_extra = |s: &str| !IMPLICIT_KEYS.contains(s);
let is_extra_implicit = |s: &str| is_extra(s) && EXTRA_IMPLICIT_KEYS.contains(s);
map_serializer.serialize_entry(HOSTNAME, &self.hostname)?;
map_serializer.serialize_entry(PID, &self.pid)?;
map_serializer.serialize_entry(ENV, &self.env)?;
#[cfg(feature = "vergen")]
map_serializer.serialize_entry(VERSION, &self.version)?;
#[cfg(feature = "vergen")]
map_serializer.serialize_entry(BUILD, &self.build)?;
map_serializer.serialize_entry(LEVEL, &format_args!("{}", metadata.level()))?;
map_serializer.serialize_entry(TARGET, metadata.target())?;
map_serializer.serialize_entry(SERVICE, &self.service)?;
map_serializer.serialize_entry(LINE, &metadata.line())?;
map_serializer.serialize_entry(FILE, &metadata.file())?;
map_serializer.serialize_entry(FN, name)?;
map_serializer
.serialize_entry(FULL_NAME, &format_args!("{}::{}", metadata.target(), name))?;
if let Ok(time) = &time::OffsetDateTime::now_utc().format(&Iso8601::DEFAULT) {
map_serializer.serialize_entry(TIME, time)?;
}
// Write down implicit default entries.
for (key, value) in self.default_fields.iter() {
map_serializer.serialize_entry(key, value)?;
}
#[cfg(feature = "log_custom_entries_to_extra")]
let mut extra = serde_json::Map::default();
let mut explicit_entries_set: HashSet<&str> = HashSet::default();
// Write down explicit event's entries.
for (key, value) in storage.values.iter() {
if is_extra_implicit(key) {
#[cfg(feature = "log_extra_implicit_fields")]
map_serializer.serialize_entry(key, value)?;
explicit_entries_set.insert(key);
} else if is_extra(key) {
#[cfg(feature = "log_custom_entries_to_extra")]
extra.insert(key.to_string(), value.clone());
#[cfg(not(feature = "log_custom_entries_to_extra"))]
map_serializer.serialize_entry(key, value)?;
explicit_entries_set.insert(key);
} else {
tracing::warn!(
?key,
?value,
"Attempting to log a reserved entry. It won't be added to the logs"
);
}
}
// Write down entries from the span, if it exists.
if let Some(span) = &span {
let extensions = span.extensions();
if let Some(visitor) = extensions.get::<Storage<'_>>() {
for (key, value) in &visitor.values {
if is_extra_implicit(key) && !explicit_entries_set.contains(key) {
#[cfg(feature = "log_extra_implicit_fields")]
map_serializer.serialize_entry(key, value)?;
} else if is_extra(key) && !explicit_entries_set.contains(key) {
#[cfg(feature = "log_custom_entries_to_extra")]
extra.insert(key.to_string(), value.clone());
#[cfg(not(feature = "log_custom_entries_to_extra"))]
map_serializer.serialize_entry(key, value)?;
} else {
tracing::warn!(
?key,
?value,
"Attempting to log a reserved entry. It won't be added to the logs"
);
}
}
}
}
#[cfg(feature = "log_custom_entries_to_extra")]
map_serializer.serialize_entry("extra", &extra)?;
Ok(())
}
<file_sep path="hyperswitch/crates/router_env/src/logger/formatter.rs" role="context" start="153" end="159">
pub fn new(
service: &str,
dst_writer: W,
formatter: F,
) -> error_stack::Result<Self, ConfigError> {
Self::new_with_implicit_entries(service, dst_writer, HashMap::new(), formatter)
}
<file_sep path="hyperswitch/crates/router_env/src/logger/formatter.rs" role="context" start="98" end="105">
pub enum RecordType {
/// Entering a span.
EnterSpan,
/// Exiting a span.
ExitSpan,
/// Event.
Event,
}
<file_sep path="hyperswitch/crates/router_env/src/logger/storage.rs" role="context" start="19" end="22">
pub struct Storage<'a> {
/// Hash map to store values.
pub values: HashMap<&'a str, serde_json::Value>,
}
<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/router_env/src/logger/formatter.rs<|crate|> router_env anchor=event_serialize kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/router_env/src/logger/formatter.rs" role="context" start="331" end="354">
pub fn event_serialize<S>(
&self,
span: Option<&SpanRef<'_, S>>,
event: &Event<'_>,
) -> std::io::Result<Vec<u8>>
where
S: Subscriber + for<'a> LookupSpan<'a>,
{
let mut buffer = Vec::new();
let mut serializer =
serde_json::Serializer::with_formatter(&mut buffer, self.formatter.clone());
let mut map_serializer = serializer.serialize_map(None)?;
let mut storage = Storage::default();
event.record(&mut storage);
let name = span.map_or("?", SpanRef::name);
Self::event_message(span, event, &mut storage);
self.common_serialize(&mut map_serializer, event.metadata(), span, &storage, name)?;
map_serializer.end()?;
Ok(buffer)
}
<file_sep path="hyperswitch/crates/router_env/src/logger/formatter.rs" role="context" start="330" end="330">
use std::{
collections::{HashMap, HashSet},
fmt,
io::Write,
};
use serde::ser::{SerializeMap, Serializer};
use serde_json::{ser::Formatter, Value};
use tracing::{Event, Metadata, Subscriber};
use tracing_subscriber::{
fmt::MakeWriter,
layer::Context,
registry::{LookupSpan, SpanRef},
Layer,
};
use crate::Storage;
<file_sep path="hyperswitch/crates/router_env/src/logger/formatter.rs" role="context" start="369" end="383">
fn event_message<S>(span: Option<&SpanRef<'_, S>>, event: &Event<'_>, storage: &mut Storage<'_>)
where
S: Subscriber + for<'a> LookupSpan<'a>,
{
// Get value of kept "message" or "target" if does not exist.
let message = storage
.values
.entry("message")
.or_insert_with(|| event.metadata().target().into());
// Prepend the span name to the message if span exists.
if let (Some(span), Value::String(a)) = (span, message) {
*a = format!("{} {}", Self::span_message(span, RecordType::Event), a,);
}
}
<file_sep path="hyperswitch/crates/router_env/src/logger/formatter.rs" role="context" start="359" end="364">
fn span_message<S>(span: &SpanRef<'_, S>, ty: RecordType) -> String
where
S: Subscriber + for<'a> LookupSpan<'a>,
{
format!("[{} - {}]", span.metadata().name().to_uppercase(), ty)
}
<file_sep path="hyperswitch/crates/router_env/src/logger/formatter.rs" role="context" start="302" end="328">
fn span_serialize<S>(
&self,
span: &SpanRef<'_, S>,
ty: RecordType,
) -> Result<Vec<u8>, std::io::Error>
where
S: Subscriber + for<'a> LookupSpan<'a>,
{
let mut buffer = Vec::new();
let mut serializer =
serde_json::Serializer::with_formatter(&mut buffer, self.formatter.clone());
let mut map_serializer = serializer.serialize_map(None)?;
let message = Self::span_message(span, ty);
let mut storage = Storage::default();
storage.record_value("message", message.into());
self.common_serialize(
&mut map_serializer,
span.metadata(),
Some(span),
&storage,
span.name(),
)?;
map_serializer.end()?;
Ok(buffer)
}
<file_sep path="hyperswitch/crates/router_env/src/logger/formatter.rs" role="context" start="296" end="299">
fn flush(&self, mut buffer: Vec<u8>) -> Result<(), std::io::Error> {
buffer.write_all(b"\n")?;
self.dst_writer.make_writer().write_all(&buffer)
}
<file_sep path="hyperswitch/crates/router_env/src/logger/formatter.rs" role="context" start="153" end="159">
pub fn new(
service: &str,
dst_writer: W,
formatter: F,
) -> error_stack::Result<Self, ConfigError> {
Self::new_with_implicit_entries(service, dst_writer, HashMap::new(), formatter)
}
<file_sep path="hyperswitch/crates/router_env/src/logger/storage.rs" role="context" start="19" end="22">
pub struct Storage<'a> {
/// Hash map to store values.
pub values: HashMap<&'a str, serde_json::Value>,
}
<file_sep path="hyperswitch/migrations/2022-09-29-084920_create_initial_tables/up.sql" role="context" start="279" end="295">
phone_country_code VARCHAR(255),
description VARCHAR(255),
address JSON,
created_at TIMESTAMP NOT NULL DEFAULT now()::TIMESTAMP,
metadata JSON,
PRIMARY KEY (customer_id, merchant_id)
);
CREATE TABLE events (
id SERIAL PRIMARY KEY,
event_id VARCHAR(255) NOT NULL,
event_type "EventType" NOT NULL,
event_class "EventClass" NOT NULL,
is_webhook_notified BOOLEAN NOT NULL DEFAULT FALSE,
intent_reference_id VARCHAR(255),
primary_object_id VARCHAR(255) NOT NULL,
primary_object_type "EventObjectType" NOT NULL,
| symbol_neighborhood |
<|meta_start|><|file|> hyperswitch-card-vault/src/storage.rs<|crate|> src anchor=new kind=fn pack=symbol_neighborhood lang=rust role_window=k1 hops=2<|meta_end|>
<file_sep path="hyperswitch-card-vault/src/storage.rs" role="context" start="41" end="71">
pub async fn new(
database: &Database,
schema: &str,
) -> error_stack::Result<Self, error::StorageError> {
let database_url = format!(
"postgres://{}:{}@{}:{}/{}?application_name={}&options=-c search_path%3D{}",
database.username,
database.password.peek(),
database.host,
database.port,
database.dbname,
schema,
schema
);
let config =
pooled_connection::AsyncDieselConnectionManager::<AsyncPgConnection>::new(database_url);
let pool = Pool::builder(config);
let pool = match database.pool_size {
Some(value) => pool.max_size(value),
None => pool,
};
let pool = pool
.build()
.change_context(error::StorageError::DBPoolError)?;
Ok(Self {
pg_pool: Arc::new(pool),
})
}
<file_sep path="hyperswitch-card-vault/src/storage.rs" role="context" start="40" end="40">
use crate::{
config::Database,
crypto::encryption_manager::encryption_interface::Encryption,
error::{self, ContainerError},
};
use std::sync::Arc;
use diesel_async::{
pooled_connection::{
self,
deadpool::{Object, Pool},
},
AsyncPgConnection,
};
use error_stack::ResultExt;
type DeadPoolConnType = Object<AsyncPgConnection>;
<file_sep path="hyperswitch-card-vault/src/storage.rs" role="context" start="74" end="80">
pub async fn get_conn(&self) -> Result<DeadPoolConnType, ContainerError<error::StorageError>> {
Ok(self
.pg_pool
.get()
.await
.change_context(error::StorageError::PoolClientFailure)?)
}
<file_sep path="hyperswitch-encryption-service/src/storage/adapter/cassandra.rs" role="context" start="9" end="9">
type Pool = scylla::CachingSession;
| symbol_neighborhood |
<|meta_start|><|file|> hyperswitch/crates/common_utils/src/types.rs<|crate|> common_utils anchor=apply_and_ceil_result kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/common_utils/src/types.rs" role="context" start="90" end="111">
pub fn apply_and_ceil_result(
&self,
amount: MinorUnit,
) -> CustomResult<MinorUnit, PercentageError> {
let max_amount = i64::MAX / 10000;
let amount = amount.0;
if amount > max_amount {
// value gets rounded off after i64::MAX/10000
Err(report!(PercentageError::UnableToApplyPercentage {
percentage: self.percentage,
amount: MinorUnit::new(amount),
}))
.attach_printable(format!(
"Cannot calculate percentage for amount greater than {}",
max_amount
))
} else {
let percentage_f64 = f64::from(self.percentage);
let result = (amount as f64 * (percentage_f64 / 100.0)).ceil() as i64;
Ok(MinorUnit::new(result))
}
}
<file_sep path="hyperswitch/crates/common_utils/src/types.rs" role="context" start="89" end="89">
use std::{
borrow::Cow,
fmt::Display,
iter::Sum,
ops::{Add, Mul, Sub},
primitive::i64,
str::FromStr,
};
use error_stack::{report, ResultExt};
pub use primitive_wrappers::bool_wrappers::{
AlwaysRequestExtendedAuthorization, ExtendedAuthorizationAppliedBool,
RequestExtendedAuthorizationBool,
};
use crate::{
consts::{
self, MAX_DESCRIPTION_LENGTH, MAX_STATEMENT_DESCRIPTOR_LENGTH, PUBLISHABLE_KEY_LENGTH,
},
errors::{CustomResult, ParsingError, PercentageError, ValidationError},
fp_utils::when,
};
pub use client_secret_type::ClientSecret;
<file_sep path="hyperswitch/crates/common_utils/src/types.rs" role="context" start="117" end="121">
fn is_valid_float_string(value: &str) -> CustomResult<f32, PercentageError> {
value
.parse::<f32>()
.change_context(PercentageError::InvalidPercentageValue)
}
<file_sep path="hyperswitch/crates/common_utils/src/types.rs" role="context" start="113" end="116">
fn is_valid_string_value(value: &str) -> CustomResult<bool, PercentageError> {
let float_value = Self::is_valid_float_string(value)?;
Ok(Self::is_valid_range(float_value) && Self::is_valid_precision_length(value))
}
<file_sep path="hyperswitch/crates/common_utils/src/types.rs" role="context" start="84" end="86">
pub fn get_percentage(&self) -> f32 {
self.percentage
}
<file_sep path="hyperswitch/crates/common_utils/src/types.rs" role="context" start="71" end="82">
pub fn from_string(value: String) -> CustomResult<Self, PercentageError> {
if Self::is_valid_string_value(&value)? {
Ok(Self {
percentage: value
.parse::<f32>()
.change_context(PercentageError::InvalidPercentageValue)?,
})
} else {
Err(report!(PercentageError::InvalidPercentageValue))
.attach_printable(get_invalid_percentage_error_message(PRECISION))
}
}
<file_sep path="hyperswitch/crates/common_utils/src/types.rs" role="context" start="722" end="727">
pub(crate) fn new(payment_id: id_type::GlobalPaymentId, secret: String) -> Self {
Self {
payment_id,
secret: masking::Secret::new(secret),
}
}
<file_sep path="hyperswitch/crates/common_utils/src/types.rs" role="context" start="1482" end="1498">
fn from(src: String) -> Self {
// ID already hashed
if src.starts_with("hs_hash_") {
Self::HashedData(src)
// Hash connector's transaction ID
} else if src.len() > 128 {
let mut hasher = blake3::Hasher::new();
let mut output = [0u8; consts::CONNECTOR_TRANSACTION_ID_HASH_BYTES];
hasher.update(src.as_bytes());
hasher.finalize_xof().fill(&mut output);
let hash = hex::encode(output);
Self::HashedData(format!("hs_hash_{}", hash))
// Default
} else {
Self::TxnId(src)
}
}
<file_sep path="hyperswitch/crates/common_utils/src/types.rs" role="context" start="228" end="228">
type Err = error_stack::Report<ParsingError>;
<file_sep path="hyperswitch/crates/common_utils/src/types.rs" role="context" start="386" end="386">
pub struct MinorUnit(i64);
<file_sep path="hyperswitch/crates/common_utils/src/errors.rs" role="context" start="10" end="10">
pub type CustomResult<T, E> = error_stack::Result<T, E>;
| symbol_neighborhood |
<|meta_start|><|file|> hyperswitch/crates/storage_impl/src/mock_db.rs<|crate|> storage_impl anchor=new kind=fn pack=symbol_neighborhood lang=rust role_window=k2 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/storage_impl/src/mock_db.rs" role="context" start="69" end="113">
pub async fn new(redis: &RedisSettings) -> error_stack::Result<Self, StorageError> {
Ok(Self {
addresses: Default::default(),
configs: Default::default(),
merchant_accounts: Default::default(),
merchant_connector_accounts: Default::default(),
payment_attempts: Default::default(),
payment_intents: Default::default(),
payment_methods: Default::default(),
customers: Default::default(),
refunds: Default::default(),
processes: Default::default(),
redis: Arc::new(
RedisStore::new(redis)
.await
.change_context(StorageError::InitializationError)?,
),
api_keys: Default::default(),
ephemeral_keys: Default::default(),
cards_info: Default::default(),
events: Default::default(),
disputes: Default::default(),
lockers: Default::default(),
mandates: Default::default(),
captures: Default::default(),
merchant_key_store: Default::default(),
business_profiles: Default::default(),
reverse_lookups: Default::default(),
payment_link: Default::default(),
organizations: Default::default(),
users: Default::default(),
user_roles: Default::default(),
authorizations: Default::default(),
dashboard_metadata: Default::default(),
#[cfg(feature = "payouts")]
payout_attempt: Default::default(),
#[cfg(feature = "payouts")]
payouts: Default::default(),
authentications: Default::default(),
roles: Default::default(),
user_key_store: Default::default(),
user_authentication_methods: Default::default(),
themes: Default::default(),
})
}
<file_sep path="hyperswitch/crates/storage_impl/src/mock_db.rs" role="context" start="68" end="68">
use std::sync::Arc;
use error_stack::ResultExt;
use hyperswitch_domain_models::{
behaviour::{Conversion, ReverseConversion},
merchant_key_store::MerchantKeyStore,
payments::{payment_attempt::PaymentAttempt, PaymentIntent},
};
use redis_interface::RedisSettings;
use crate::{errors::StorageError, redis::RedisStore};
<file_sep path="hyperswitch/crates/storage_impl/src/mock_db.rs" role="context" start="141" end="174">
pub async fn find_resources<D, R>(
&self,
state: &KeyManagerState,
key_store: &MerchantKeyStore,
resources: MutexGuard<'_, Vec<D>>,
filter_fn: impl Fn(&&D) -> bool,
error_message: String,
) -> CustomResult<Vec<R>, StorageError>
where
D: Sync + ReverseConversion<R> + Clone,
R: Conversion,
{
let resources: Vec<_> = resources.iter().filter(filter_fn).cloned().collect();
if resources.is_empty() {
Err(StorageError::ValueNotFound(error_message).into())
} else {
let pm_futures = resources
.into_iter()
.map(|pm| async {
pm.convert(
state,
key_store.key.get_inner(),
key_store.merchant_id.clone().into(),
)
.await
.change_context(StorageError::DecryptionError)
})
.collect::<Vec<_>>();
let domain_resources = futures::future::try_join_all(pm_futures).await?;
Ok(domain_resources)
}
}
<file_sep path="hyperswitch/crates/storage_impl/src/mock_db.rs" role="context" start="115" end="139">
pub async fn find_resource<D, R>(
&self,
state: &KeyManagerState,
key_store: &MerchantKeyStore,
resources: MutexGuard<'_, Vec<D>>,
filter_fn: impl Fn(&&D) -> bool,
error_message: String,
) -> CustomResult<R, StorageError>
where
D: Sync + ReverseConversion<R> + Clone,
R: Conversion,
{
let resource = resources.iter().find(filter_fn).cloned();
match resource {
Some(res) => Ok(res
.convert(
state,
key_store.key.get_inner(),
key_store.merchant_id.clone().into(),
)
.await
.change_context(StorageError::DecryptionError)?),
None => Err(StorageError::ValueNotFound(error_message).into()),
}
}
<file_sep path="hyperswitch/crates/storage_impl/src/redis.rs" role="context" start="12" end="15">
pub struct RedisStore {
// Maybe expose the redis_conn via traits instead of the making the field public
pub(crate) redis_conn: Arc<redis_interface::RedisConnectionPool>,
}
| symbol_neighborhood |
<|meta_start|><|file|> hyperswitch/crates/router_derive/src/macros/try_get_enum.rs<|crate|> router_derive anchor=try_get_enum_variant kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/router_derive/src/macros/try_get_enum.rs" role="context" start="46" end="91">
pub fn try_get_enum_variant(
input: syn::DeriveInput,
) -> Result<proc_macro2::TokenStream, syn::Error> {
let name = &input.ident;
let parsed_error_type = input.get_metadata()?;
let (error_type, error_variant) = parsed_error_type
.first()
.ok_or(syn::Error::new(
Span::call_site(),
"One error should be specified",
))
.map(|error_struct| (&error_struct.error_type, &error_struct.variant))?;
let (impl_generics, generics, where_clause) = input.generics.split_for_impl();
let variants = get_enum_variants(&input.data)?;
let try_into_fns = variants.iter().map(|variant| {
let variant_name = &variant.ident;
let variant_field = get_enum_variant_field(variant)?;
let variant_types = variant_field.iter().map(|f|f.ty.clone());
let try_into_fn = syn::Ident::new(
&format!("try_into_{}", variant_name.to_string().to_lowercase()),
Span::call_site(),
);
Ok(quote::quote! {
pub fn #try_into_fn(self)->Result<(#(#variant_types),*),error_stack::Report<#error_type>> {
match self {
Self::#variant_name(inner) => Ok(inner),
_=> Err(error_stack::report!(#error_type::#error_variant)),
}
}
})
}).collect::<Result<Vec<proc_macro2::TokenStream>,syn::Error>>()?;
let expanded = quote::quote! {
impl #impl_generics #name #generics #where_clause {
#(#try_into_fns)*
}
};
Ok(expanded)
}
<file_sep path="hyperswitch/crates/router_derive/src/macros/try_get_enum.rs" role="context" start="45" end="45">
use proc_macro2::Span;
use quote::ToTokens;
use syn::{parse::Parse, punctuated::Punctuated};
<file_sep path="hyperswitch/crates/router_derive/src/macros/try_get_enum.rs" role="context" start="103" end="117">
fn get_enum_variant_field(
variant: &syn::Variant,
) -> syn::Result<Punctuated<syn::Field, syn::token::Comma>> {
let field = match variant.fields.clone() {
syn::Fields::Unnamed(un) => un.unnamed,
syn::Fields::Named(n) => n.named,
syn::Fields::Unit => {
return Err(super::helpers::syn_error(
Span::call_site(),
"The enum is a unit variant it's not supported",
))
}
};
Ok(field)
}
<file_sep path="hyperswitch/crates/router_derive/src/macros/try_get_enum.rs" role="context" start="94" end="100">
fn get_enum_variants(data: &syn::Data) -> syn::Result<Punctuated<syn::Variant, syn::token::Comma>> {
if let syn::Data::Enum(syn::DataEnum { variants, .. }) = data {
Ok(variants.clone())
} else {
Err(super::helpers::non_enum_error())
}
}
<file_sep path="hyperswitch/crates/router_derive/src/macros/try_get_enum.rs" role="context" start="42" end="42">
fn to_tokens(&self, _: &mut proc_macro2::TokenStream) {}
<file_sep path="hyperswitch/crates/router_derive/src/macros/try_get_enum.rs" role="context" start="36" end="38">
fn get_metadata(&self) -> syn::Result<Vec<TryGetEnumMeta>> {
super::helpers::get_metadata_inner("error", &self.attrs)
}
<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/aci/transformers.rs<|crate|> hyperswitch_connectors<|connector|> aci anchor=try_from kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/aci/transformers.rs" role="context" start="714" end="764">
fn try_from(
item: ResponseRouterData<F, AciPaymentsResponse, T, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
let redirection_data = item.response.redirect.map(|data| {
let form_fields = std::collections::HashMap::<_, _>::from_iter(
data.parameters
.iter()
.map(|parameter| (parameter.name.clone(), parameter.value.clone())),
);
// If method is Get, parameters are appended to URL
// If method is post, we http Post the method to URL
RedirectForm::Form {
endpoint: data.url.to_string(),
// Handles method for Bank redirects currently.
// 3DS response have method within preconditions. That would require replacing below line with a function.
method: data.method.unwrap_or(Method::Post),
form_fields,
}
});
let mandate_reference = item.response.registration_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: {
if redirection_data.is_some() {
enums::AttemptStatus::from(AciPaymentStatus::RedirectShopper)
} else {
enums::AttemptStatus::from(AciPaymentStatus::from_str(
&item.response.result.code,
)?)
}
},
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(item.response.id.clone()),
redirection_data: Box::new(redirection_data),
mandate_reference: Box::new(mandate_reference),
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/aci/transformers.rs" role="context" start="713" end="713">
use common_enums::enums;
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},
};
use crate::{
types::{RefundsResponseRouterData, ResponseRouterData},
utils::{self, PhoneDetailsData, RouterData as _},
};
type Error = error_stack::Report<errors::ConnectorError>;
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/aci/transformers.rs" role="context" start="803" end="815">
fn from_str(s: &str) -> Result<Self, Self::Err> {
if FAILURE_CODES.contains(&s) {
Ok(Self::Failed)
} else if PENDING_CODES.contains(&s) {
Ok(Self::Pending)
} else if SUCCESSFUL_CODES.contains(&s) {
Ok(Self::Succeeded)
} else {
Err(report!(errors::ConnectorError::UnexpectedResponseError(
bytes::Bytes::from(s.to_owned())
)))
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/aci/transformers.rs" role="context" start="778" end="790">
fn try_from(item: &AciRouterData<&RefundsRouterData<F>>) -> Result<Self, Self::Error> {
let amount = item.amount.to_owned();
let currency = item.router_data.request.currency;
let payment_type = AciPaymentType::Refund;
let auth = AciAuthType::try_from(&item.router_data.connector_auth_type)?;
Ok(Self {
amount,
currency: currency.to_string(),
payment_type,
entity_id: auth.entity_id,
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/aci/transformers.rs" role="context" start="643" end="655">
fn from_str(s: &str) -> Result<Self, Self::Err> {
if FAILURE_CODES.contains(&s) {
Ok(Self::Failed)
} else if PENDING_CODES.contains(&s) {
Ok(Self::Pending)
} else if SUCCESSFUL_CODES.contains(&s) {
Ok(Self::Succeeded)
} else {
Err(report!(errors::ConnectorError::UnexpectedResponseError(
bytes::Bytes::from(s.to_owned())
)))
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/aci/transformers.rs" role="context" start="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="819" end="825">
fn from(item: AciRefundStatus) -> Self {
match item {
AciRefundStatus::Succeeded => Self::Success,
AciRefundStatus::Failed => Self::Failure,
AciRefundStatus::Pending => Self::Pending,
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/aci/transformers.rs" role="context" start="26" end="26">
type Error = error_stack::Report<errors::ConnectorError>;
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/aci/transformers.rs" role="context" start="660" end="670">
pub struct AciPaymentsResponse {
id: String,
registration_id: Option<Secret<String>>,
// ndc is an internal unique identifier for the request.
ndc: String,
timestamp: String,
// Number useful for support purposes.
build_number: String,
pub(super) result: ResultCode,
pub(super) redirect: Option<AciRedirectionData>,
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/globalpay/response.rs" role="context" start="172" end="183">
pub struct Bank {
/// The local identifier of the bank account.
pub account_number: Option<Secret<String>>,
/// The local identifier of the bank.
pub code: Option<Secret<String>>,
/// The international identifier of the bank account.
pub iban: Option<Secret<String>>,
/// The international identifier code for the bank.
pub identifier_code: Option<Secret<String>>,
/// The name associated with the bank account
pub name: Option<Secret<String>>,
}
<file_sep path="hyperswitch-encryption-service/migrations/2024-05-28-075150_create_dek_table/up.sql" role="context" start="1" end="9">
CREATE TABLE IF NOT EXISTS data_key_store (
id SERIAL PRIMARY KEY,
key_identifier VARCHAR(255) NOT NULL,
data_identifier VARCHAR(20) NOT NULL,
encryption_key bytea NOT NULL,
version VARCHAR(30) NOT NULL,
created_at TIMESTAMP NOT NULL
);
<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/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="215" end="265">
fn try_from(
item: ResponseRouterData<F, PaystackPSyncResponse, T, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
match item.response {
PaystackPSyncResponse::PaystackPSyncData(resp) => Ok(Self {
status: common_enums::AttemptStatus::from(resp.data.status),
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(resp.data.reference.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
}),
PaystackPSyncResponse::PaystackPSyncWebhook(resp) => Ok(Self {
status: common_enums::AttemptStatus::from(resp.status),
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(resp.reference.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
}),
PaystackPSyncResponse::PaystackPSyncError(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="214" end="214">
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="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="176" end="187">
fn from(item: PaystackPSyncStatus) -> Self {
match item {
PaystackPSyncStatus::Success => Self::Charged,
PaystackPSyncStatus::Abandoned => Self::AuthenticationPending,
PaystackPSyncStatus::Ongoing
| PaystackPSyncStatus::Pending
| PaystackPSyncStatus::Processing
| PaystackPSyncStatus::Queued => Self::Pending,
PaystackPSyncStatus::Failed => Self::Failure,
PaystackPSyncStatus::Reversed => Self::Voided,
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/paystack/transformers.rs" role="context" start="112" end="159">
fn try_from(
item: ResponseRouterData<F, PaystackPaymentsResponse, T, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
let (status, response) = match item.response {
PaystackPaymentsResponse::PaystackPaymentsData(resp) => {
let redirection_url = Url::parse(resp.data.url.as_str())
.change_context(errors::ConnectorError::ParsingFailed)?;
let redirection_data = RedirectForm::from((redirection_url, Method::Get));
(
common_enums::AttemptStatus::AuthenticationPending,
Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(
resp.data.reference.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,
}),
)
}
PaystackPaymentsResponse::PaystackPaymentsError(err) => {
let err_msg = get_error_message(err.clone());
(
common_enums::AttemptStatus::Failure,
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,
}),
)
}
};
Ok(Self {
status,
response,
..item.data
})
}
<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="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="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="205" end="209">
pub enum PaystackPSyncResponse {
PaystackPSyncData(PaystackPSyncResponseData),
PaystackPSyncWebhook(PaystackPaymentWebhookData),
PaystackPSyncError(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/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/noon/transformers.rs<|crate|> hyperswitch_connectors<|connector|> noon 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/noon/transformers.rs" role="context" start="565" end="620">
fn try_from(
item: ResponseRouterData<F, NoonPaymentsResponse, T, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
let order = item.response.result.order;
let status = get_payment_status((order.status, item.data.status));
let redirection_data =
item.response
.result
.checkout_data
.map(|redirection_data| RedirectForm::Form {
endpoint: redirection_data.post_url.to_string(),
method: Method::Post,
form_fields: std::collections::HashMap::new(),
});
let mandate_reference =
item.response
.result
.subscription
.map(|subscription_data| MandateReference {
connector_mandate_id: Some(subscription_data.identifier.expose()),
payment_method_id: None,
mandate_metadata: None,
connector_mandate_request_reference_id: None,
});
Ok(Self {
status,
response: match order.error_message {
Some(error_message) => Err(ErrorResponse {
code: order.error_code.to_string(),
message: error_message.clone(),
reason: Some(error_message),
status_code: item.http_code,
attempt_status: Some(status),
connector_transaction_id: Some(order.id.to_string()),
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
}),
_ => {
let connector_response_reference_id =
order.reference.or(Some(order.id.to_string()));
Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(order.id.to_string()),
redirection_data: Box::new(redirection_data),
mandate_reference: Box::new(mandate_reference),
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id,
incremental_authorization_allowed: None,
charges: None,
})
}
},
..item.data
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/noon/transformers.rs" role="context" start="564" end="564">
use common_utils::{ext_traits::Encode, pii, request::Method, types::StringMajorUnit};
use hyperswitch_domain_models::{
payment_method_data::{PaymentMethodData, WalletData},
router_data::{ConnectorAuthType, ErrorResponse, RouterData},
router_flow_types::{Execute, RSync},
router_request_types::{MandateRevokeRequestData, ResponseId},
router_response_types::{
MandateReference, MandateRevokeResponseData, PaymentsResponseData, RedirectForm,
RefundsResponseData,
},
types::{
MandateRevokeRouterData, PaymentsAuthorizeRouterData, PaymentsCancelRouterData,
PaymentsCaptureRouterData, RefundsRouterData,
},
};
use crate::{
types::{RefundsResponseRouterData, ResponseRouterData},
utils::{
self, CardData, GooglePayWalletData, PaymentsAuthorizeRequestData,
RevokeMandateRequestData, RouterData as OtherRouterData, WalletData as OtherWalletData,
},
};
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/noon/transformers.rs" role="context" start="675" end="683">
fn try_from(item: &PaymentsCancelRouterData) -> Result<Self, Self::Error> {
let order = NoonActionOrder {
id: item.request.connector_transaction_id.clone(),
};
Ok(Self {
api_operation: NoonApiOperations::Reverse,
order,
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/noon/transformers.rs" role="context" start="647" end="663">
fn try_from(data: &NoonRouterData<&PaymentsCaptureRouterData>) -> Result<Self, Self::Error> {
let item = data.router_data;
let amount = &data.amount;
let order = NoonActionOrder {
id: item.request.connector_transaction_id.clone(),
};
let transaction = NoonActionTransaction {
amount: amount.to_owned(),
currency: item.request.currency,
transaction_reference: None,
};
Ok(Self {
api_operation: NoonApiOperations::Capture,
order,
transaction,
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/noon/transformers.rs" role="context" start="502" end="525">
fn get_payment_status(data: (NoonPaymentStatus, AttemptStatus)) -> AttemptStatus {
let (item, current_status) = data;
match item {
NoonPaymentStatus::Authorized => AttemptStatus::Authorized,
NoonPaymentStatus::Captured
| NoonPaymentStatus::PartiallyCaptured
| NoonPaymentStatus::PartiallyRefunded
| NoonPaymentStatus::Refunded => AttemptStatus::Charged,
NoonPaymentStatus::Reversed | NoonPaymentStatus::PartiallyReversed => AttemptStatus::Voided,
NoonPaymentStatus::Cancelled | NoonPaymentStatus::Expired => {
AttemptStatus::AuthenticationFailed
}
NoonPaymentStatus::ThreeDsEnrollInitiated | NoonPaymentStatus::ThreeDsEnrollChecked => {
AttemptStatus::AuthenticationPending
}
NoonPaymentStatus::ThreeDsResultVerified => AttemptStatus::AuthenticationSuccessful,
NoonPaymentStatus::Failed | NoonPaymentStatus::Rejected => AttemptStatus::Failure,
NoonPaymentStatus::Pending | NoonPaymentStatus::MarkedForReview => AttemptStatus::Pending,
NoonPaymentStatus::Initiated
| NoonPaymentStatus::PaymentInfoAdded
| NoonPaymentStatus::Authenticated => AttemptStatus::Started,
NoonPaymentStatus::Locked => current_status,
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/noon/transformers.rs" role="context" start="457" end="470">
fn try_from(auth_type: &ConnectorAuthType) -> Result<Self, Self::Error> {
match auth_type {
ConnectorAuthType::SignatureKey {
api_key,
key1,
api_secret,
} => Ok(Self {
api_key: api_key.to_owned(),
application_identifier: api_secret.to_owned(),
business_identifier: key1.to_owned(),
}),
_ => Err(errors::ConnectorError::FailedToObtainAuthType.into()),
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/noon/transformers.rs" role="context" start="124" end="139">
pub fn new(metadata: &serde_json::Value) -> Self {
let metadata_as_string = metadata.to_string();
let hash_map: std::collections::BTreeMap<String, serde_json::Value> =
serde_json::from_str(&metadata_as_string).unwrap_or(std::collections::BTreeMap::new());
let inner = hash_map
.into_iter()
.enumerate()
.map(|(index, (hs_key, hs_value))| {
let noon_key = format!("{}", index + 1);
// to_string() function on serde_json::Value returns a string with "" quotes. Noon doesn't allow this. Hence get_value_as_string function
let noon_value = format!("{hs_key}={}", get_value_as_string(&hs_value));
(noon_key, Secret::new(noon_value))
})
.collect();
Self { inner }
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/noon/transformers.rs" role="context" start="263" end="263">
type Error = error_stack::Report<errors::ConnectorError>;
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/noon/transformers.rs" role="context" start="557" end="559">
pub struct NoonPaymentsResponse {
result: NoonPaymentsResponseResult,
}
<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.rs<|crate|> hyperswitch_connectors<|connector|> deutschebank 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/deutschebank.rs" role="context" start="218" end="267">
fn build_request(
&self,
req: &RefreshTokenRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
let auth = deutschebank::DeutschebankAuthType::try_from(&req.connector_auth_type)?;
let client_id = auth.client_id.expose();
let date = Date(SystemTime::now().into()).to_string();
let random_string = Alphanumeric.sample_string(&mut rand::thread_rng(), 50);
let string_to_sign = client_id.clone() + &date + &random_string;
let key = hmac::Key::new(hmac::HMAC_SHA256, auth.client_key.expose().as_bytes());
let client_secret = format!(
"V1:{}",
common_utils::consts::BASE64_ENGINE
.encode(hmac::sign(&key, string_to_sign.as_bytes()).as_ref())
);
let headers = vec![
(
headers::X_RANDOM_VALUE.to_string(),
random_string.into_masked(),
),
(headers::X_REQUEST_DATE.to_string(), date.into_masked()),
(
headers::CONTENT_TYPE.to_string(),
types::RefreshTokenType::get_content_type(self)
.to_string()
.into(),
),
];
let connector_req = deutschebank::DeutschebankAccessTokenRequest {
client_id: Secret::from(client_id),
client_secret: Secret::from(client_secret),
grant_type: "client_credentials".to_string(),
scope: "ftx".to_string(),
};
let body = RequestContent::FormUrlEncoded(Box::new(connector_req));
let req = Some(
RequestBuilder::new()
.method(Method::Post)
.headers(headers)
.url(&types::RefreshTokenType::get_url(self, req, connectors)?)
.set_body(body)
.build(),
);
Ok(req)
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/deutschebank.rs" role="context" start="217" end="217">
fn get_url(
&self,
_req: &RefreshTokenRouterData,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
Ok(format!("{}/security/v1/token", self.base_url(connectors)))
}
fn get_content_type(&self) -> &'static str {
"application/x-www-form-urlencoded"
}
fn build_request(
&self,
req: &RefreshTokenRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
let auth = deutschebank::DeutschebankAuthType::try_from(&req.connector_auth_type)?;
let client_id = auth.client_id.expose();
let date = Date(SystemTime::now().into()).to_string();
let random_string = Alphanumeric.sample_string(&mut rand::thread_rng(), 50);
let string_to_sign = client_id.clone() + &date + &random_string;
let key = hmac::Key::new(hmac::HMAC_SHA256, auth.client_key.expose().as_bytes());
let client_secret = format!(
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/deutschebank.rs" role="context" start="290" end="328">
fn get_error_response(
&self,
res: Response,
event_builder: Option<&mut ConnectorEvent>,
) -> CustomResult<ErrorResponse, errors::ConnectorError> {
let response: deutschebank::DeutschebankError = res
.response
.parse_struct("DeutschebankError")
.change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
event_builder.map(|i| i.set_response_body(&response));
router_env::logger::info!(connector_response=?response);
match response {
deutschebank::DeutschebankError::PaymentsErrorResponse(response) => Ok(ErrorResponse {
status_code: res.status_code,
code: response.rc,
message: response.message.clone(),
reason: Some(response.message),
attempt_status: None,
connector_transaction_id: None,
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
}),
deutschebank::DeutschebankError::AccessTokenErrorResponse(response) => {
Ok(ErrorResponse {
status_code: res.status_code,
code: response.cause.clone(),
message: response.cause.clone(),
reason: Some(response.description),
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.rs" role="context" start="269" end="288">
fn handle_response(
&self,
data: &RefreshTokenRouterData,
event_builder: Option<&mut ConnectorEvent>,
res: Response,
) -> CustomResult<RefreshTokenRouterData, errors::ConnectorError> {
let response: deutschebank::DeutschebankAccessTokenResponse = res
.response
.parse_struct("Paypal PaypalAuthUpdateResponse")
.change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
event_builder.map(|i| i.set_response_body(&response));
router_env::logger::info!(connector_response=?response);
RouterData::try_from(ResponseRouterData {
response,
data: data.clone(),
http_code: res.status_code,
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/deutschebank.rs" role="context" start="214" end="216">
fn get_content_type(&self) -> &'static str {
"application/x-www-form-urlencoded"
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/deutschebank.rs" role="context" start="206" end="212">
fn get_url(
&self,
_req: &RefreshTokenRouterData,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
Ok(format!("{}/security/v1/token", self.base_url(connectors)))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/deutschebank.rs" role="context" start="72" end="76">
pub fn new() -> &'static Self {
&Self {
amount_converter: &MinorUnitForConnector,
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/deutschebank.rs" role="context" start="927" end="937">
fn get_url(
&self,
req: &RefundSyncRouterData,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
let tx_id = req.request.get_connector_refund_id()?;
Ok(format!(
"{}/services/v2.1/payment/tx/{tx_id}",
self.base_url(connectors)
))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/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/payeezy/transformers.rs<|crate|> hyperswitch_connectors<|connector|> payeezy anchor=get_payment_method_data 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="239" end="281">
fn get_payment_method_data(
item: &PayeezyRouterData<&PaymentsAuthorizeRouterData>,
) -> Result<PayeezyPaymentMethod, error_stack::Report<ConnectorError>> {
match item.router_data.request.payment_method_data {
PaymentMethodData::Card(ref card) => {
let card_type = PayeezyCardType::try_from(card.get_card_issuer()?)?;
let payeezy_card = PayeezyCard {
card_type,
cardholder_name: item
.router_data
.get_optional_billing_full_name()
.unwrap_or(Secret::new("".to_string())),
card_number: card.card_number.clone(),
exp_date: card.get_card_expiry_month_year_2_digit_with_delimiter("".to_string())?,
cvv: card.card_cvc.clone(),
};
Ok(PayeezyPaymentMethod::PayeezyCard(payeezy_card))
}
PaymentMethodData::CardRedirect(_)
| PaymentMethodData::Wallet(_)
| PaymentMethodData::PayLater(_)
| PaymentMethodData::BankRedirect(_)
| PaymentMethodData::BankDebit(_)
| PaymentMethodData::BankTransfer(_)
| PaymentMethodData::Crypto(_)
| PaymentMethodData::MandatePayment
| PaymentMethodData::Reward
| PaymentMethodData::RealTimePayment(_)
| PaymentMethodData::MobilePayment(_)
| PaymentMethodData::Upi(_)
| PaymentMethodData::Voucher(_)
| PaymentMethodData::GiftCard(_)
| PaymentMethodData::OpenBanking(_)
| PaymentMethodData::CardToken(_)
| PaymentMethodData::NetworkToken(_)
| PaymentMethodData::CardDetailsForNetworkTransactionId(_) => {
Err(ConnectorError::NotImplemented(
get_unimplemented_payment_method_error_message("Payeezy"),
))?
}
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/payeezy/transformers.rs" role="context" start="238" end="238">
use error_stack::ResultExt;
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 masking::{ExposeInterface, Secret};
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="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="292" end="307">
fn try_from(item: &ConnectorAuthType) -> Result<Self, Self::Error> {
if let ConnectorAuthType::SignatureKey {
api_key,
key1,
api_secret,
} = item
{
Ok(Self {
api_key: api_key.to_owned(),
api_secret: api_secret.to_owned(),
merchant_token: key1.to_owned(),
})
} else {
Err(ConnectorError::FailedToObtainAuthType.into())
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/payeezy/transformers.rs" role="context" start="232" end="237">
fn is_mandate_payment(
item: &PaymentsAuthorizeRouterData,
connector_mandate_id: Option<&String>,
) -> bool {
item.request.setup_mandate_details.is_some() || connector_mandate_id.is_some()
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/payeezy/transformers.rs" role="context" start="181" end="230">
fn get_transaction_type_and_stored_creds(
item: &PaymentsAuthorizeRouterData,
) -> Result<(PayeezyTransactionType, Option<StoredCredentials>), error_stack::Report<ConnectorError>>
{
let connector_mandate_id = item.request.mandate_id.as_ref().and_then(|mandate_ids| {
match mandate_ids.mandate_reference_id.clone() {
Some(api_models::payments::MandateReferenceId::ConnectorMandateId(
connector_mandate_ids,
)) => connector_mandate_ids.get_connector_mandate_id(),
_ => None,
}
});
let (transaction_type, stored_credentials) =
if is_mandate_payment(item, connector_mandate_id.as_ref()) {
// Mandate payment
(
PayeezyTransactionType::Recurring,
Some(StoredCredentials {
// connector_mandate_id is not present then it is a First payment, else it is a Subsequent mandate payment
sequence: match connector_mandate_id.is_some() {
true => Sequence::Subsequent,
false => Sequence::First,
},
// off_session true denotes the customer not present during the checkout process. In other cases customer present at the checkout.
initiator: match item.request.off_session {
Some(true) => Initiator::Merchant,
_ => Initiator::CardHolder,
},
is_scheduled: true,
// In case of first mandate payment connector_mandate_id would be None, otherwise holds some value
cardbrand_original_transaction_id: connector_mandate_id.map(Secret::new),
}),
)
} else {
match item.request.capture_method {
Some(CaptureMethod::Manual) => Ok((PayeezyTransactionType::Authorize, None)),
Some(CaptureMethod::SequentialAutomatic) | Some(CaptureMethod::Automatic) => {
Ok((PayeezyTransactionType::Purchase, None))
}
Some(CaptureMethod::ManualMultiple) | Some(CaptureMethod::Scheduled) | None => {
Err(ConnectorError::FlowNotSupported {
flow: item.request.capture_method.unwrap_or_default().to_string(),
connector: "Payeezy".to_string(),
})
}
}?
};
Ok((transaction_type, stored_credentials))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/payeezy/transformers.rs" role="context" start="160" end="180">
fn get_card_specific_payment_data(
item: &PayeezyRouterData<&PaymentsAuthorizeRouterData>,
) -> Result<PayeezyPaymentsRequest, error_stack::Report<ConnectorError>> {
let merchant_ref = item.router_data.attempt_id.to_string();
let method = PayeezyPaymentMethodType::CreditCard;
let amount = item.amount.clone();
let currency_code = item.router_data.request.currency.to_string();
let credit_card = get_payment_method_data(item)?;
let (transaction_type, stored_credentials) =
get_transaction_type_and_stored_creds(item.router_data)?;
Ok(PayeezyPaymentsRequest {
merchant_ref,
transaction_type,
method,
amount,
currency_code,
credit_card,
stored_credentials,
reference: item.router_data.connector_request_reference_id.clone(),
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/payeezy/transformers.rs" role="context" start="548" end="558">
fn try_from(
item: RefundsResponseRouterData<Execute, RefundResponse>,
) -> Result<Self, Self::Error> {
Ok(Self {
response: Ok(RefundsResponseData {
connector_refund_id: item.response.transaction_id,
refund_status: enums::RefundStatus::from(item.response.transaction_status),
}),
..item.data
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/payeezy/transformers.rs" role="context" start="88" end="90">
pub enum PayeezyPaymentMethod {
PayeezyCard(PayeezyCard),
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/payeezy/transformers.rs" role="context" start="59" end="65">
pub enum PayeezyCardType {
#[serde(rename = "American Express")]
AmericanExpress,
Visa,
Mastercard,
Discover,
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/globalpay/requests.rs" role="context" start="203" end="208">
pub enum PaymentMethodData {
Card(Card),
Apm(Apm),
BankTransfer(BankTransfer),
DigitalWallet(DigitalWallet),
}
| symbol_neighborhood |
<|meta_start|><|file|> hyperswitch/crates/hyperswitch_connectors/src/connectors/tsys/transformers.rs<|crate|> hyperswitch_connectors<|connector|> tsys anchor=try_from kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/tsys/transformers.rs" role="context" start="289" end="339">
fn try_from(
item: ResponseRouterData<F, TsysPaymentsResponse, T, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
let (response, status) = match item.response {
TsysPaymentsResponse::AuthResponse(resp) => match resp {
TsysResponseTypes::SuccessResponse(auth_response) => (
Ok(get_payments_response(auth_response)),
enums::AttemptStatus::Authorized,
),
TsysResponseTypes::ErrorResponse(connector_response) => (
Err(get_error_response(connector_response, item.http_code)),
enums::AttemptStatus::AuthorizationFailed,
),
},
TsysPaymentsResponse::SaleResponse(resp) => match resp {
TsysResponseTypes::SuccessResponse(sale_response) => (
Ok(get_payments_response(sale_response)),
enums::AttemptStatus::Charged,
),
TsysResponseTypes::ErrorResponse(connector_response) => (
Err(get_error_response(connector_response, item.http_code)),
enums::AttemptStatus::Failure,
),
},
TsysPaymentsResponse::CaptureResponse(resp) => match resp {
TsysResponseTypes::SuccessResponse(capture_response) => (
Ok(get_payments_response(capture_response)),
enums::AttemptStatus::Charged,
),
TsysResponseTypes::ErrorResponse(connector_response) => (
Err(get_error_response(connector_response, item.http_code)),
enums::AttemptStatus::CaptureFailed,
),
},
TsysPaymentsResponse::VoidResponse(resp) => match resp {
TsysResponseTypes::SuccessResponse(void_response) => (
Ok(get_payments_response(void_response)),
enums::AttemptStatus::Voided,
),
TsysResponseTypes::ErrorResponse(connector_response) => (
Err(get_error_response(connector_response, item.http_code)),
enums::AttemptStatus::VoidFailed,
),
},
};
Ok(Self {
status,
response,
..item.data
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/tsys/transformers.rs" role="context" start="288" end="288">
use common_enums::enums;
use hyperswitch_domain_models::{
payment_method_data::PaymentMethodData,
router_data::{self, ConnectorAuthType, RouterData},
router_flow_types::refunds::{Execute, RSync},
router_request_types::ResponseId,
router_response_types::{PaymentsResponseData, RefundsResponseData},
types::{
self, PaymentsCancelRouterData, PaymentsSyncRouterData, RefundSyncRouterData,
RefundsRouterData,
},
};
use crate::{
types::{RefundsResponseRouterData, ResponseRouterData},
utils::{self, CardData as _, PaymentsAuthorizeRequestData, RefundsRequestData as _},
};
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/tsys/transformers.rs" role="context" start="395" end="414">
fn try_from(
item: ResponseRouterData<F, TsysSyncResponse, T, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
let tsys_search_response = item.response.search_transaction_response;
let (response, status) = match tsys_search_response {
SearchResponseTypes::SuccessResponse(search_response) => (
Ok(get_payments_sync_response(&search_response)),
enums::AttemptStatus::from(search_response.transaction_details),
),
SearchResponseTypes::ErrorResponse(connector_response) => (
Err(get_error_response(connector_response, item.http_code)),
item.data.status,
),
};
Ok(Self {
status,
response,
..item.data
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/tsys/transformers.rs" role="context" start="362" end="375">
fn try_from(item: &PaymentsSyncRouterData) -> Result<Self, Self::Error> {
let connector_auth: TsysAuthType = TsysAuthType::try_from(&item.connector_auth_type)?;
let search_transaction = TsysSearchTransactionRequest {
device_id: connector_auth.device_id,
transaction_key: connector_auth.transaction_key,
transaction_id: item
.request
.connector_transaction_id
.get_connector_transaction_id()
.change_context(errors::ConnectorError::MissingConnectorTransactionID)?,
developer_id: connector_auth.developer_id,
};
Ok(Self { search_transaction })
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/tsys/transformers.rs" role="context" start="260" end="283">
fn get_payments_sync_response(
connector_response: &TsysPaymentsSyncResponse,
) -> PaymentsResponseData {
PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(
connector_response
.transaction_details
.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(
connector_response
.transaction_details
.transaction_id
.clone(),
),
incremental_authorization_allowed: None,
charges: None,
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/tsys/transformers.rs" role="context" start="247" end="258">
fn get_payments_response(connector_response: TsysResponse) -> PaymentsResponseData {
PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(connector_response.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(connector_response.transaction_id),
incremental_authorization_allowed: None,
charges: None,
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/tsys/transformers.rs" role="context" start="230" end="245">
fn get_error_response(
connector_response: TsysErrorResponse,
status_code: u16,
) -> router_data::ErrorResponse {
router_data::ErrorResponse {
code: connector_response.response_code,
message: connector_response.response_message.clone(),
reason: Some(connector_response.response_message),
status_code,
attempt_status: None,
connector_transaction_id: None,
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/tsys/transformers.rs" role="context" start="64" end="64">
type Error = error_stack::Report<errors::ConnectorError>;
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/tsys/transformers.rs" role="context" start="223" end="228">
pub enum TsysPaymentsResponse {
AuthResponse(TsysResponseTypes),
SaleResponse(TsysResponseTypes),
CaptureResponse(TsysResponseTypes),
VoidResponse(TsysResponseTypes),
}
<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/bankofamerica/transformers.rs<|crate|> hyperswitch_connectors<|connector|> bankofamerica 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/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="619" end="619">
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="694" end="698">
fn from(item: &SetupMandateRouterData) -> Self {
Self {
code: Some(item.connector_request_reference_id.clone()),
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/bankofamerica/transformers.rs" role="context" start="686" end="690">
fn from(item: &BankOfAmericaRouterData<&PaymentsAuthorizeRouterData>) -> Self {
Self {
code: Some(item.router_data.connector_request_reference_id.clone()),
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/bankofamerica/transformers.rs" role="context" start="595" end="608">
fn from(
(item, bill_to): (
&BankOfAmericaRouterData<&PaymentsAuthorizeRouterData>,
Option<BillTo>,
),
) -> Self {
Self {
amount_details: Amount {
total_amount: item.amount.to_owned(),
currency: item.router_data.request.currency,
},
bill_to,
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/bankofamerica/transformers.rs" role="context" start="571" end="578">
fn from(solution: PaymentSolution) -> Self {
let payment_solution = match solution {
PaymentSolution::ApplePay => "001",
PaymentSolution::GooglePay => "012",
PaymentSolution::SamsungPay => "008",
};
payment_solution.to_string()
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/bankofamerica/transformers.rs" role="context" start="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="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="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="564" end="568">
pub enum PaymentSolution {
ApplePay,
GooglePay,
SamsungPay,
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/bankofamerica/transformers.rs" role="context" start="65" end="68">
pub struct BankOfAmericaRouterData<T> {
pub amount: String,
pub router_data: T,
}
| 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="797" end="852">
fn try_from(
item: ResponseRouterData<
F,
BraintreeCompleteAuthResponse,
CompleteAuthorizeData,
PaymentsResponseData,
>,
) -> Result<Self, Self::Error> {
match item.response {
BraintreeCompleteAuthResponse::ErrorResponse(error_response) => Ok(Self {
response: build_error_response(&error_response.errors, item.http_code)
.map_err(|err| *err),
..item.data
}),
BraintreeCompleteAuthResponse::AuthResponse(auth_response) => {
let transaction_data = auth_response.data.authorize_credit_card.transaction;
let status = enums::AttemptStatus::from(transaction_data.status.clone());
let response = if utils::is_payment_failure(status) {
Err(hyperswitch_domain_models::router_data::ErrorResponse {
code: transaction_data.status.to_string().clone(),
message: transaction_data.status.to_string().clone(),
reason: Some(transaction_data.status.to_string().clone()),
attempt_status: None,
connector_transaction_id: Some(transaction_data.id),
status_code: item.http_code,
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
})
} else {
Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(transaction_data.id),
redirection_data: Box::new(None),
mandate_reference: Box::new(transaction_data.payment_method.as_ref().map(
|pm| MandateReference {
connector_mandate_id: Some(pm.id.clone().expose()),
payment_method_id: None,
mandate_metadata: None,
connector_mandate_request_reference_id: None,
},
)),
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: None,
incremental_authorization_allowed: None,
charges: None,
})
};
Ok(Self {
status,
response,
..item.data
})
}
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/braintree/transformers.rs" role="context" start="796" end="796">
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="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="728" end="783">
fn try_from(
item: ResponseRouterData<
F,
BraintreeCompleteChargeResponse,
CompleteAuthorizeData,
PaymentsResponseData,
>,
) -> Result<Self, Self::Error> {
match item.response {
BraintreeCompleteChargeResponse::ErrorResponse(error_response) => Ok(Self {
response: build_error_response(&error_response.errors.clone(), item.http_code)
.map_err(|err| *err),
..item.data
}),
BraintreeCompleteChargeResponse::PaymentsResponse(payment_response) => {
let transaction_data = payment_response.data.charge_credit_card.transaction;
let status = enums::AttemptStatus::from(transaction_data.status.clone());
let response = if utils::is_payment_failure(status) {
Err(hyperswitch_domain_models::router_data::ErrorResponse {
code: transaction_data.status.to_string().clone(),
message: transaction_data.status.to_string().clone(),
reason: Some(transaction_data.status.to_string().clone()),
attempt_status: None,
connector_transaction_id: Some(transaction_data.id),
status_code: item.http_code,
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
})
} else {
Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(transaction_data.id),
redirection_data: Box::new(None),
mandate_reference: Box::new(transaction_data.payment_method.as_ref().map(
|pm| MandateReference {
connector_mandate_id: Some(pm.id.clone().expose()),
payment_method_id: None,
mandate_metadata: None,
connector_mandate_request_reference_id: None,
},
)),
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: None,
incremental_authorization_allowed: None,
charges: None,
})
};
Ok(Self {
status,
response,
..item.data
})
}
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/braintree/transformers.rs" role="context" start="640" end="714">
fn try_from(
item: ResponseRouterData<
F,
BraintreePaymentsResponse,
PaymentsAuthorizeData,
PaymentsResponseData,
>,
) -> Result<Self, Self::Error> {
match item.response {
BraintreePaymentsResponse::ErrorResponse(error_response) => Ok(Self {
response: build_error_response(&error_response.errors.clone(), item.http_code)
.map_err(|err| *err),
..item.data
}),
BraintreePaymentsResponse::PaymentsResponse(payment_response) => {
let transaction_data = payment_response.data.charge_credit_card.transaction;
let status = enums::AttemptStatus::from(transaction_data.status.clone());
let response = if utils::is_payment_failure(status) {
Err(hyperswitch_domain_models::router_data::ErrorResponse {
code: transaction_data.status.to_string().clone(),
message: transaction_data.status.to_string().clone(),
reason: Some(transaction_data.status.to_string().clone()),
attempt_status: None,
connector_transaction_id: Some(transaction_data.id),
status_code: item.http_code,
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
})
} else {
Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(transaction_data.id),
redirection_data: Box::new(None),
mandate_reference: Box::new(transaction_data.payment_method.as_ref().map(
|pm| MandateReference {
connector_mandate_id: Some(pm.id.clone().expose()),
payment_method_id: None,
mandate_metadata: None,
connector_mandate_request_reference_id: None,
},
)),
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: None,
incremental_authorization_allowed: None,
charges: None,
})
};
Ok(Self {
status,
response,
..item.data
})
}
BraintreePaymentsResponse::ClientTokenResponse(client_token_data) => Ok(Self {
status: enums::AttemptStatus::AuthenticationPending,
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::NoResponseId,
redirection_data: Box::new(Some(get_braintree_redirect_form(
*client_token_data,
item.data.get_payment_method_token()?,
item.data.request.payment_method_data.clone(),
item.data.request.get_complete_authorize_url()?,
)?)),
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/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/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/nexinets/transformers.rs<|crate|> hyperswitch_connectors<|connector|> nexinets 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/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="329" end="329">
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 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="406" end="411">
fn try_from(item: &PaymentsCancelRouterData) -> Result<Self, Self::Error> {
Ok(Self {
initial_amount: item.request.get_amount()?,
currency: item.request.get_currency()?,
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/nexinets/transformers.rs" role="context" start="396" end="401">
fn try_from(item: &PaymentsCaptureRouterData) -> Result<Self, Self::Error> {
Ok(Self {
initial_amount: item.request.amount_to_capture,
currency: item.request.currency,
})
}
<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="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="509" end="515">
fn from(item: RefundStatus) -> Self {
match item {
RefundStatus::Success => Self::Success,
RefundStatus::Failure | RefundStatus::Declined => Self::Failure,
RefundStatus::InProgress | RefundStatus::Ok => Self::Pending,
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/nexinets/transformers.rs" role="context" start="179" end="179">
type Error = error_stack::Report<errors::ConnectorError>;
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/nexinets/transformers.rs" role="context" start="320" end="324">
pub struct NexinetsPaymentsMetadata {
pub transaction_id: Option<String>,
pub order_id: Option<String>,
pub psync_flow: NexinetsTransactionType,
}
<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="3649" end="3714">
fn try_from(
item: ResponseRouterData<
F,
CybersourceTransactionResponse,
PaymentsSyncData,
PaymentsResponseData,
>,
) -> Result<Self, Self::Error> {
match item.response.application_information.status {
Some(status) => {
let status =
map_cybersource_attempt_status(status, item.data.request.is_auto_capture()?);
let incremental_authorization_allowed =
Some(status == enums::AttemptStatus::Authorized);
let risk_info: Option<ClientRiskInformation> = None;
if utils::is_payment_failure(status) {
Ok(Self {
response: Err(get_error_response(
&item.response.error_information,
&risk_info,
Some(status),
item.http_code,
item.response.id.clone(),
)),
status: enums::AttemptStatus::Failure,
..item.data
})
} else {
Ok(Self {
status,
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: item
.response
.client_reference_information
.map(|cref| cref.code)
.unwrap_or(Some(item.response.id)),
incremental_authorization_allowed,
charges: None,
}),
..item.data
})
}
}
None => Ok(Self {
status: item.data.status,
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/cybersource/transformers.rs" role="context" start="3648" end="3648">
impl<F>
TryFrom<
ResponseRouterData<
F,
CybersourceTransactionResponse,
PaymentsSyncData,
PaymentsResponseData,
>,
> for RouterData<F, PaymentsSyncData, PaymentsResponseData>
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: ResponseRouterData<
F,
CybersourceTransactionResponse,
PaymentsSyncData,
PaymentsResponseData,
>,
) -> Result<Self, Self::Error> {
match item.response.application_information.status {
Some(status) => {
let status =
map_cybersource_attempt_status(status, item.data.request.is_auto_capture()?);
let incremental_authorization_allowed =
<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="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="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="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="3625" end="3630">
pub struct CybersourceTransactionResponse {
id: String,
application_information: ApplicationInformation,
client_reference_information: Option<ClientReferenceInformation>,
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>;
| symbol_neighborhood |
<|meta_start|><|file|> hyperswitch/crates/hyperswitch_connectors/src/connectors/redsys/transformers.rs<|crate|> hyperswitch_connectors<|connector|> redsys anchor=handle_threeds_invoke 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="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="685" end="685">
use common_enums::enums;
use common_utils::{
consts::BASE64_ENGINE,
crypto::{EncodeMessage, SignMessage},
ext_traits::{Encode, ValueExt},
types::StringMinorUnit,
};
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="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="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="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="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="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="556" end="562">
pub struct RedsysThreeDsInvokeData {
pub three_ds_method_url: String,
pub three_ds_method_data: String,
pub message_version: String,
pub directory_server_id: String,
pub three_ds_method_data_submission: bool,
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/redsys/transformers.rs" role="context" start="550" end="553">
pub struct ThreedsInvokeRequest {
three_d_s_server_trans_i_d: String,
three_d_s_method_notification_u_r_l: 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=get_card_request_data 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="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="309" end="309">
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="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="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="293" end="308">
fn get_mandatory_fields(
item: &PaymentsAuthorizeRouterData,
) -> Result<TrustpayMandatoryParams, Error> {
let billing_address = item
.get_billing()?
.address
.as_ref()
.ok_or_else(utils::missing_field_err("billing.address"))?;
Ok(TrustpayMandatoryParams {
billing_city: billing_address.get_city()?.to_owned(),
billing_country: billing_address.get_country()?.to_owned(),
billing_street1: billing_address.get_line1()?.to_owned(),
billing_postcode: billing_address.get_zip()?.to_owned(),
billing_first_name: billing_address.get_first_name()?.to_owned(),
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/trustpay/transformers.rs" role="context" start="281" end="290">
fn try_from(value: &BankTransferData) -> Result<Self, Self::Error> {
match value {
BankTransferData::SepaBankTransfer { .. } => Ok(Self::SepaCreditTransfer),
BankTransferData::InstantBankTransfer {} => Ok(Self::InstantBankTransfer),
_ => 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="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="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="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/globalpay/response.rs" role="context" start="216" end="241">
pub struct Card {
/// Code generated when the card is successfully authorized.
pub authcode: Option<Secret<String>>,
/// The recommended AVS action to be taken by the agent processing the card transaction.
pub avs_action: Option<String>,
/// The result of the AVS address check.
pub avs_address_result: Option<String>,
/// The result of the AVS postal code check.
pub avs_postal_code_result: Option<String>,
/// Indicates the card brand that issued the card.
pub brand: Option<Brand>,
/// The unique reference created by the brands/schemes to uniquely identify the transaction.
pub brand_reference: Option<Secret<String>>,
/// The time returned by the card brand indicating when the transaction was processed on
/// their system.
pub brand_time_reference: Option<String>,
/// The result of the CVV check.
pub cvv_result: Option<String>,
/// Masked card number with last 4 digits showing.
pub masked_number_last4: Option<String>,
/// The result codes directly from the card issuer.
pub provider: Option<ProviderClass>,
/// The card EMV tag response data from the card issuer for a contactless or chip card
/// transaction.
pub tag_response: Option<Secret<String>>,
}
<file_sep path="hyperswitch/crates/api_models/src/payments.rs" role="context" start="1398" end="1441">
pub struct BrowserInformation {
/// Color depth supported by the browser
pub color_depth: Option<u8>,
/// Whether java is enabled in the browser
pub java_enabled: Option<bool>,
/// Whether javascript is enabled in the browser
pub java_script_enabled: Option<bool>,
/// Language supported
pub language: Option<String>,
/// The screen height in pixels
pub screen_height: Option<u32>,
/// The screen width in pixels
pub screen_width: Option<u32>,
/// Time zone of the client
pub time_zone: Option<i32>,
/// Ip address of the client
#[schema(value_type = Option<String>)]
pub ip_address: Option<std::net::IpAddr>,
/// List of headers that are accepted
#[schema(
example = "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8"
)]
pub accept_header: Option<String>,
/// User-agent of the browser
pub user_agent: Option<String>,
/// The os type of the client device
pub os_type: Option<String>,
/// The os version of the client device
pub os_version: Option<String>,
/// The device model of the client
pub device_model: Option<String>,
}
| symbol_neighborhood |
<|meta_start|><|file|> hyperswitch/crates/hyperswitch_connectors/src/connectors/trustpay/transformers.rs<|crate|> hyperswitch_connectors<|connector|> trustpay anchor=get_card_request_data 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="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="309" end="309">
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="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="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="293" end="308">
fn get_mandatory_fields(
item: &PaymentsAuthorizeRouterData,
) -> Result<TrustpayMandatoryParams, Error> {
let billing_address = item
.get_billing()?
.address
.as_ref()
.ok_or_else(utils::missing_field_err("billing.address"))?;
Ok(TrustpayMandatoryParams {
billing_city: billing_address.get_city()?.to_owned(),
billing_country: billing_address.get_country()?.to_owned(),
billing_street1: billing_address.get_line1()?.to_owned(),
billing_postcode: billing_address.get_zip()?.to_owned(),
billing_first_name: billing_address.get_first_name()?.to_owned(),
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/trustpay/transformers.rs" role="context" start="281" end="290">
fn try_from(value: &BankTransferData) -> Result<Self, Self::Error> {
match value {
BankTransferData::SepaBankTransfer { .. } => Ok(Self::SepaCreditTransfer),
BankTransferData::InstantBankTransfer {} => Ok(Self::InstantBankTransfer),
_ => 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="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="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="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/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/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="1584" end="1638">
fn try_from(
item: PaymentsCancelResponseRouterData<FiuuPaymentCancelResponse>,
) -> Result<Self, Self::Error> {
let status_code = item.response.stat_code;
let status = match status_code.as_str() {
"00" => Ok(enums::AttemptStatus::Voided),
"11" | "12" | "13" | "14" | "15" | "16" | "17" | "18" | "19" | "20" | "21" => {
Ok(enums::AttemptStatus::VoidFailed)
}
other => Err(errors::ConnectorError::UnexpectedResponseError(
bytes::Bytes::from(other.to_owned()),
)),
}?;
let void_message_status = void_status_codes();
let error_response = if status == enums::AttemptStatus::VoidFailed {
Some(ErrorResponse {
status_code: item.http_code,
code: status_code.to_owned(),
message: void_message_status
.get(status_code.as_str())
.unwrap_or(&"NO_ERROR_MESSAGE")
.to_string(),
reason: Some(
void_message_status
.get(status_code.as_str())
.unwrap_or(&"NO_ERROR_REASON")
.to_string(),
),
attempt_status: None,
connector_transaction_id: Some(item.response.tran_id.clone()),
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
})
} else {
None
};
let payments_response_data = PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(
item.response.tran_id.clone().to_string(),
),
redirection_data: Box::new(None),
mandate_reference: Box::new(None),
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: None,
incremental_authorization_allowed: None,
charges: None,
};
Ok(Self {
status,
response: error_response.map_or_else(|| Ok(payments_response_data), Err),
..item.data
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/fiuu/transformers.rs" role="context" start="1583" end="1583">
use common_enums::{enums, BankNames, CaptureMethod, Currency};
use common_utils::{
crypto::{self, GenerateDigest},
errors::CustomResult,
ext_traits::Encode,
pii::Email,
request::Method,
types::{AmountConvertor, StringMajorUnit, StringMajorUnitForConnector},
};
use hyperswitch_domain_models::{
payment_method_data::{
BankRedirectData, Card, CardDetailsForNetworkTransactionId, GooglePayWalletData,
PaymentMethodData, RealTimePaymentData, WalletData,
},
router_data::{
ApplePayPredecryptData, ConnectorAuthType, ErrorResponse, PaymentMethodToken, RouterData,
},
router_flow_types::refunds::{Execute, RSync},
router_request_types::{PaymentsAuthorizeData, ResponseId},
router_response_types::{
MandateReference, PaymentsResponseData, RedirectForm, RefundsResponseData,
},
types::{
PaymentsAuthorizeRouterData, PaymentsCancelRouterData, PaymentsCaptureRouterData,
PaymentsSyncRouterData, RefundSyncRouterData, RefundsRouterData,
},
};
use crate::{
constants,
types::{
PaymentsCancelResponseRouterData, PaymentsCaptureResponseRouterData,
PaymentsSyncResponseRouterData, RefundsResponseRouterData, ResponseRouterData,
},
unimplemented_payment_method,
utils::{
self, ApplePayDecrypt, PaymentsAuthorizeRequestData, QrImage, RefundsRequestData,
RouterData as _,
},
};
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/fiuu/transformers.rs" role="context" start="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="1654" end="1667">
fn try_from(item: &RefundSyncRouterData) -> Result<Self, Self::Error> {
let auth = FiuuAuthType::try_from(&item.connector_auth_type)?;
let (txn_id, merchant_id, verify_key) = (
item.request.connector_transaction_id.clone(),
auth.merchant_id.peek().to_string(),
auth.verify_key.peek().to_string(),
);
let signature = calculate_signature(format!("{txn_id}{merchant_id}{verify_key}"))?;
Ok(Self {
txn_id,
merchant_id: auth.merchant_id,
signature,
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/fiuu/transformers.rs" role="context" start="1559" end="1579">
fn void_status_codes() -> HashMap<&'static str, &'static str> {
[
("00", "Success (will proceed the request)"),
("11", "Failure"),
("12", "Invalid or unmatched security hash string"),
("13", "Not a refundable transaction"),
("14", "Transaction date more than 180 days"),
("15", "Requested day is on settlement day"),
("16", "Forbidden transaction"),
("17", "Transaction not found"),
("18", "Duplicate partial refund request"),
("19", "Merchant not found"),
("20", "Missing required parameter"),
(
"21",
"Transaction must be in authorized/captured/settled status",
),
]
.into_iter()
.collect()
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/fiuu/transformers.rs" role="context" start="1546" end="1556">
fn try_from(item: &PaymentsCancelRouterData) -> Result<Self, Self::Error> {
let auth = FiuuAuthType::try_from(&item.connector_auth_type)?;
let txn_id = item.request.connector_transaction_id.clone();
let merchant_id = auth.merchant_id.peek().to_string();
let secret_key = auth.secret_key.peek().to_string();
Ok(Self {
txn_id: txn_id.clone(),
domain: merchant_id.clone(),
skey: calculate_signature(format!("{txn_id}{merchant_id}{secret_key}"))?,
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/fiuu/transformers.rs" role="context" start="1907" end="1913">
fn from(value: FiuuRefundsWebhookStatus) -> Self {
match value {
FiuuRefundsWebhookStatus::RefundFailure => Self::Failure,
FiuuRefundsWebhookStatus::RefundSuccess => Self::Success,
FiuuRefundsWebhookStatus::RefundPending => Self::Pending,
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/fiuu/transformers.rs" role="context" start="77" end="77">
type Error = Report<errors::ConnectorError>;
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/fiuu/transformers.rs" role="context" start="1535" end="1541">
pub struct FiuuPaymentCancelResponse {
#[serde(rename = "TranID")]
tran_id: String,
stat_code: String,
#[serde(rename = "miscellaneous")]
miscellaneous: Option<HashMap<String, 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/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/nexinets/transformers.rs<|crate|> hyperswitch_connectors<|connector|> nexinets anchor=get_wallet_details 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="689" end="736">
fn get_wallet_details(
wallet: &WalletData,
) -> Result<
(Option<NexinetsPaymentDetails>, NexinetsProduct),
error_stack::Report<errors::ConnectorError>,
> {
match wallet {
WalletData::PaypalRedirect(_) => Ok((None, NexinetsProduct::Paypal)),
WalletData::ApplePay(applepay_data) => Ok((
Some(NexinetsPaymentDetails::Wallet(Box::new(
NexinetsWalletDetails::ApplePayToken(Box::new(get_applepay_details(
wallet,
applepay_data,
)?)),
))),
NexinetsProduct::Applepay,
)),
WalletData::AliPayQr(_)
| WalletData::AliPayRedirect(_)
| WalletData::AliPayHkRedirect(_)
| WalletData::AmazonPayRedirect(_)
| WalletData::MomoRedirect(_)
| WalletData::KakaoPayRedirect(_)
| WalletData::GoPayRedirect(_)
| WalletData::GcashRedirect(_)
| WalletData::ApplePayRedirect(_)
| WalletData::ApplePayThirdPartySdk(_)
| WalletData::DanaRedirect { .. }
| WalletData::GooglePay(_)
| WalletData::GooglePayRedirect(_)
| WalletData::GooglePayThirdPartySdk(_)
| WalletData::MbWayRedirect(_)
| WalletData::MobilePayRedirect(_)
| WalletData::PaypalSdk(_)
| WalletData::Paze(_)
| WalletData::SamsungPay(_)
| WalletData::TwintRedirect { .. }
| WalletData::VippsRedirect { .. }
| WalletData::TouchNGoRedirect(_)
| WalletData::WeChatPayRedirect(_)
| WalletData::WeChatPayQr(_)
| WalletData::CashappQr(_)
| WalletData::SwishQr(_)
| WalletData::Mifinity(_) => Err(errors::ConnectorError::NotImplemented(
utils::get_unimplemented_payment_method_error_message("nexinets"),
))?,
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/nexinets/transformers.rs" role="context" start="688" end="688">
use error_stack::ResultExt;
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 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="749" end="758">
pub fn get_transaction_id(
meta: &NexinetsPaymentsMetadata,
) -> Result<String, error_stack::Report<errors::ConnectorError>> {
let transaction_id = meta.transaction_id.clone().ok_or(
errors::ConnectorError::MissingConnectorRelatedTransactionID {
id: "transaction_id".to_string(),
},
)?;
Ok(transaction_id)
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/nexinets/transformers.rs" role="context" start="738" end="747">
pub fn get_order_id(
meta: &NexinetsPaymentsMetadata,
) -> Result<String, error_stack::Report<errors::ConnectorError>> {
let order_id = meta.order_id.clone().ok_or(
errors::ConnectorError::MissingConnectorRelatedTransactionID {
id: "order_id".to_string(),
},
)?;
Ok(order_id)
}
<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="157" end="159">
pub enum NexinetsWalletDetails {
ApplePayToken(Box<ApplePayDetails>),
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/nexinets/transformers.rs" role="context" start="69" end="73">
pub enum NexinetsPaymentDetails {
Card(Box<NexiCardDetails>),
Wallet(Box<NexinetsWalletDetails>),
BankRedirects(Box<NexinetsBankRedirects>),
}
<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="370" end="382">
pub struct Paypal {
/// Email linked with paypal account
#[schema(value_type = String, example = "john.doe@example.com")]
pub email: Option<Email>,
/// mobile number linked to paypal account
#[schema(value_type = String, example = "16608213349")]
pub telephone_number: Option<Secret<String>>,
/// id of the paypal account
#[schema(value_type = String, example = "G83KXTJ5EHCQ2")]
pub paypal_id: Option<Secret<String>>,
}
| symbol_neighborhood |
<|meta_start|><|file|> hyperswitch/crates/hyperswitch_connectors/src/connectors/braintree/transformers.rs<|crate|> hyperswitch_connectors<|connector|> braintree anchor=get_braintree_redirect_form 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="1924" end="1975">
fn get_braintree_redirect_form(
client_token_data: ClientTokenResponse,
payment_method_token: PaymentMethodToken,
card_details: PaymentMethodData,
complete_authorize_url: String,
) -> Result<RedirectForm, error_stack::Report<errors::ConnectorError>> {
Ok(RedirectForm::Braintree {
client_token: client_token_data
.data
.create_client_token
.client_token
.expose(),
card_token: match payment_method_token {
PaymentMethodToken::Token(token) => token.expose(),
PaymentMethodToken::ApplePayDecrypt(_) => Err(unimplemented_payment_method!(
"Apple Pay",
"Simplified",
"Braintree"
))?,
PaymentMethodToken::PazeDecrypt(_) => {
Err(unimplemented_payment_method!("Paze", "Braintree"))?
}
PaymentMethodToken::GooglePayDecrypt(_) => {
Err(unimplemented_payment_method!("Google Pay", "Braintree"))?
}
},
bin: match card_details {
PaymentMethodData::Card(card_details) => card_details.card_number.get_card_isin(),
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("given payment method".to_owned()),
)?,
},
acs_url: complete_authorize_url,
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/braintree/transformers.rs" role="context" start="1923" end="1923">
use error_stack::ResultExt;
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="2038" end="2045">
pub(crate) fn get_dispute_stage(code: &str) -> Result<enums::DisputeStage, errors::ConnectorError> {
match code {
"CHARGEBACK" => Ok(enums::DisputeStage::Dispute),
"PRE_ARBITATION" => Ok(enums::DisputeStage::PreArbitration),
"RETRIEVAL" => Ok(enums::DisputeStage::PreDispute),
_ => Err(errors::ConnectorError::WebhookBodyDecodingFailed),
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/braintree/transformers.rs" role="context" start="1991" end="2001">
pub(crate) fn get_status(status: &str) -> IncomingWebhookEvent {
match status {
"dispute_opened" => IncomingWebhookEvent::DisputeOpened,
"dispute_lost" => IncomingWebhookEvent::DisputeLost,
"dispute_won" => IncomingWebhookEvent::DisputeWon,
"dispute_accepted" | "dispute_auto_accepted" => IncomingWebhookEvent::DisputeAccepted,
"dispute_expired" => IncomingWebhookEvent::DisputeExpired,
"dispute_disputed" => IncomingWebhookEvent::DisputeChallenged,
_ => IncomingWebhookEvent::EventNotSupported,
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/braintree/transformers.rs" role="context" start="1828" end="1921">
fn try_from(
item: &BraintreeRouterData<&types::PaymentsCompleteAuthorizeRouterData>,
) -> 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 payload_data = PaymentsCompleteAuthorizeRequestData::get_redirect_response_payload(
&item.router_data.request,
)?
.expose();
let redirection_response: BraintreeRedirectionResponse = serde_json::from_value(
payload_data,
)
.change_context(errors::ConnectorError::MissingConnectorRedirectionPayload {
field_name: "redirection_response",
})?;
let three_ds_data = serde_json::from_str::<BraintreeThreeDsResponse>(
&redirection_response.authentication_response,
)
.change_context(errors::ConnectorError::MissingConnectorRedirectionPayload {
field_name: "three_ds_data",
})?;
let (query, transaction_body) = if item.router_data.request.is_mandate_payment() {
(
match item.router_data.request.is_auto_capture()? {
true => CHARGE_AND_VAULT_TRANSACTION_MUTATION.to_string(),
false => AUTHORIZE_AND_VAULT_CREDIT_CARD_MUTATION.to_string(),
},
TransactionBody::Vault(VaultTransactionBody {
amount: item.amount.to_owned(),
merchant_account_id: metadata.merchant_account_id,
vault_payment_method_after_transacting: TransactionTiming {
when: "ALWAYS".to_string(),
},
customer_details: item
.router_data
.get_billing_email()
.ok()
.map(|email| CustomerBody { email }),
order_id: item.router_data.connector_request_reference_id.clone(),
}),
)
} else {
(
match item.router_data.request.is_auto_capture()? {
true => CHARGE_CREDIT_CARD_MUTATION.to_string(),
false => AUTHORIZE_CREDIT_CARD_MUTATION.to_string(),
},
TransactionBody::Regular(RegularTransactionBody {
amount: item.amount.to_owned(),
merchant_account_id: metadata.merchant_account_id,
channel: CHANNEL_CODE.to_string(),
customer_details: item
.router_data
.get_billing_email()
.ok()
.map(|email| CustomerBody { email }),
order_id: item.router_data.connector_request_reference_id.clone(),
}),
)
};
Ok(Self {
query,
variables: VariablePaymentInput {
input: PaymentInput {
payment_method_id: three_ds_data.nonce,
transaction: transaction_body,
},
},
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/braintree/transformers.rs" role="context" start="1756" end="1821">
fn try_from(
(item, metadata): (
&BraintreeRouterData<&types::PaymentsAuthorizeRouterData>,
BraintreeMeta,
),
) -> Result<Self, Self::Error> {
let (query, transaction_body) = if item.router_data.request.is_mandate_payment() {
(
match item.router_data.request.is_auto_capture()? {
true => CHARGE_AND_VAULT_TRANSACTION_MUTATION.to_string(),
false => AUTHORIZE_AND_VAULT_CREDIT_CARD_MUTATION.to_string(),
},
TransactionBody::Vault(VaultTransactionBody {
amount: item.amount.to_owned(),
merchant_account_id: metadata.merchant_account_id,
vault_payment_method_after_transacting: TransactionTiming {
when: "ALWAYS".to_string(),
},
customer_details: item
.router_data
.get_billing_email()
.ok()
.map(|email| CustomerBody { email }),
order_id: item.router_data.connector_request_reference_id.clone(),
}),
)
} else {
(
match item.router_data.request.is_auto_capture()? {
true => CHARGE_CREDIT_CARD_MUTATION.to_string(),
false => AUTHORIZE_CREDIT_CARD_MUTATION.to_string(),
},
TransactionBody::Regular(RegularTransactionBody {
amount: item.amount.to_owned(),
merchant_account_id: metadata.merchant_account_id,
channel: CHANNEL_CODE.to_string(),
customer_details: item
.router_data
.get_billing_email()
.ok()
.map(|email| CustomerBody { email }),
order_id: item.router_data.connector_request_reference_id.clone(),
}),
)
};
Ok(Self {
query,
variables: VariablePaymentInput {
input: PaymentInput {
payment_method_id: match item.router_data.get_payment_method_token()? {
PaymentMethodToken::Token(token) => token,
PaymentMethodToken::ApplePayDecrypt(_) => Err(
unimplemented_payment_method!("Apple Pay", "Simplified", "Braintree"),
)?,
PaymentMethodToken::PazeDecrypt(_) => {
Err(unimplemented_payment_method!("Paze", "Braintree"))?
}
PaymentMethodToken::GooglePayDecrypt(_) => {
Err(unimplemented_payment_method!("Google Pay", "Braintree"))?
}
},
transaction: transaction_body,
},
},
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/braintree/transformers.rs" role="context" start="454" end="528">
fn try_from(
item: ResponseRouterData<
F,
BraintreeAuthResponse,
PaymentsAuthorizeData,
PaymentsResponseData,
>,
) -> Result<Self, Self::Error> {
match item.response {
BraintreeAuthResponse::ErrorResponse(error_response) => Ok(Self {
response: build_error_response(&error_response.errors, item.http_code)
.map_err(|err| *err),
..item.data
}),
BraintreeAuthResponse::AuthResponse(auth_response) => {
let transaction_data = auth_response.data.authorize_credit_card.transaction;
let status = enums::AttemptStatus::from(transaction_data.status.clone());
let response = if utils::is_payment_failure(status) {
Err(hyperswitch_domain_models::router_data::ErrorResponse {
code: transaction_data.status.to_string().clone(),
message: transaction_data.status.to_string().clone(),
reason: Some(transaction_data.status.to_string().clone()),
attempt_status: None,
connector_transaction_id: Some(transaction_data.id),
status_code: item.http_code,
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
})
} else {
Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(transaction_data.id),
redirection_data: Box::new(None),
mandate_reference: Box::new(transaction_data.payment_method.as_ref().map(
|pm| MandateReference {
connector_mandate_id: Some(pm.id.clone().expose()),
payment_method_id: None,
mandate_metadata: None,
connector_mandate_request_reference_id: None,
},
)),
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: None,
incremental_authorization_allowed: None,
charges: None,
})
};
Ok(Self {
status,
response,
..item.data
})
}
BraintreeAuthResponse::ClientTokenResponse(client_token_data) => Ok(Self {
status: enums::AttemptStatus::AuthenticationPending,
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::NoResponseId,
redirection_data: Box::new(Some(get_braintree_redirect_form(
*client_token_data,
item.data.get_payment_method_token()?,
item.data.request.payment_method_data.clone(),
item.data.request.get_complete_authorize_url()?,
)?)),
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/braintree/transformers.rs" role="context" start="640" end="714">
fn try_from(
item: ResponseRouterData<
F,
BraintreePaymentsResponse,
PaymentsAuthorizeData,
PaymentsResponseData,
>,
) -> Result<Self, Self::Error> {
match item.response {
BraintreePaymentsResponse::ErrorResponse(error_response) => Ok(Self {
response: build_error_response(&error_response.errors.clone(), item.http_code)
.map_err(|err| *err),
..item.data
}),
BraintreePaymentsResponse::PaymentsResponse(payment_response) => {
let transaction_data = payment_response.data.charge_credit_card.transaction;
let status = enums::AttemptStatus::from(transaction_data.status.clone());
let response = if utils::is_payment_failure(status) {
Err(hyperswitch_domain_models::router_data::ErrorResponse {
code: transaction_data.status.to_string().clone(),
message: transaction_data.status.to_string().clone(),
reason: Some(transaction_data.status.to_string().clone()),
attempt_status: None,
connector_transaction_id: Some(transaction_data.id),
status_code: item.http_code,
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
})
} else {
Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(transaction_data.id),
redirection_data: Box::new(None),
mandate_reference: Box::new(transaction_data.payment_method.as_ref().map(
|pm| MandateReference {
connector_mandate_id: Some(pm.id.clone().expose()),
payment_method_id: None,
mandate_metadata: None,
connector_mandate_request_reference_id: None,
},
)),
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: None,
incremental_authorization_allowed: None,
charges: None,
})
};
Ok(Self {
status,
response,
..item.data
})
}
BraintreePaymentsResponse::ClientTokenResponse(client_token_data) => Ok(Self {
status: enums::AttemptStatus::AuthenticationPending,
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::NoResponseId,
redirection_data: Box::new(Some(get_braintree_redirect_form(
*client_token_data,
item.data.get_payment_method_token()?,
item.data.request.payment_method_data.clone(),
item.data.request.get_complete_authorize_url()?,
)?)),
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/braintree/transformers.rs" role="context" start="1254" end="1256">
pub struct ClientTokenResponse {
data: ClientTokenData,
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/globalpay/requests.rs" role="context" start="203" end="208">
pub enum PaymentMethodData {
Card(Card),
Apm(Apm),
BankTransfer(BankTransfer),
DigitalWallet(DigitalWallet),
}
| 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="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="1466" end="1466">
use common_enums::{enums, BankNames, CaptureMethod, Currency};
use common_utils::{
crypto::{self, GenerateDigest},
errors::CustomResult,
ext_traits::Encode,
pii::Email,
request::Method,
types::{AmountConvertor, StringMajorUnit, StringMajorUnitForConnector},
};
use hyperswitch_domain_models::{
payment_method_data::{
BankRedirectData, Card, CardDetailsForNetworkTransactionId, GooglePayWalletData,
PaymentMethodData, RealTimePaymentData, WalletData,
},
router_data::{
ApplePayPredecryptData, ConnectorAuthType, ErrorResponse, PaymentMethodToken, RouterData,
},
router_flow_types::refunds::{Execute, RSync},
router_request_types::{PaymentsAuthorizeData, ResponseId},
router_response_types::{
MandateReference, PaymentsResponseData, RedirectForm, RefundsResponseData,
},
types::{
PaymentsAuthorizeRouterData, PaymentsCancelRouterData, PaymentsCaptureRouterData,
PaymentsSyncRouterData, RefundSyncRouterData, RefundsRouterData,
},
};
use crate::{
constants,
types::{
PaymentsCancelResponseRouterData, PaymentsCaptureResponseRouterData,
PaymentsSyncResponseRouterData, RefundsResponseRouterData, ResponseRouterData,
},
unimplemented_payment_method,
utils::{
self, ApplePayDecrypt, PaymentsAuthorizeRequestData, QrImage, RefundsRequestData,
RouterData as _,
},
};
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/fiuu/transformers.rs" role="context" start="1559" end="1579">
fn void_status_codes() -> HashMap<&'static str, &'static str> {
[
("00", "Success (will proceed the request)"),
("11", "Failure"),
("12", "Invalid or unmatched security hash string"),
("13", "Not a refundable transaction"),
("14", "Transaction date more than 180 days"),
("15", "Requested day is on settlement day"),
("16", "Forbidden transaction"),
("17", "Transaction not found"),
("18", "Duplicate partial refund request"),
("19", "Merchant not found"),
("20", "Missing required parameter"),
(
"21",
"Transaction must be in authorized/captured/settled status",
),
]
.into_iter()
.collect()
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/fiuu/transformers.rs" role="context" start="1546" end="1556">
fn try_from(item: &PaymentsCancelRouterData) -> Result<Self, Self::Error> {
let auth = FiuuAuthType::try_from(&item.connector_auth_type)?;
let txn_id = item.request.connector_transaction_id.clone();
let merchant_id = auth.merchant_id.peek().to_string();
let secret_key = auth.secret_key.peek().to_string();
Ok(Self {
txn_id: txn_id.clone(),
domain: merchant_id.clone(),
skey: calculate_signature(format!("{txn_id}{merchant_id}{secret_key}"))?,
})
}
<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="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="1907" end="1913">
fn from(value: FiuuRefundsWebhookStatus) -> Self {
match value {
FiuuRefundsWebhookStatus::RefundFailure => Self::Failure,
FiuuRefundsWebhookStatus::RefundSuccess => Self::Success,
FiuuRefundsWebhookStatus::RefundPending => Self::Pending,
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/fiuu/transformers.rs" role="context" start="77" end="77">
type Error = Report<errors::ConnectorError>;
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/fiuu/transformers.rs" role="context" start="1390" end="1394">
pub struct PaymentCaptureResponse {
#[serde(rename = "TranID")]
tran_id: String,
stat_code: 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/gocardless/transformers.rs<|crate|> hyperswitch_connectors<|connector|> gocardless 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/gocardless/transformers.rs" role="context" start="405" end="460">
fn try_from(item: &types::SetupMandateRouterData) -> Result<Self, Self::Error> {
let (scheme, payer_ip_address) = match &item.request.payment_method_data {
PaymentMethodData::BankDebit(bank_debit_data) => {
let payer_ip_address = get_ip_if_required(bank_debit_data, item)?;
Ok((
GocardlessScheme::try_from(bank_debit_data)?,
payer_ip_address,
))
}
PaymentMethodData::Card(_)
| PaymentMethodData::CardRedirect(_)
| PaymentMethodData::Wallet(_)
| PaymentMethodData::PayLater(_)
| PaymentMethodData::BankRedirect(_)
| 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(
"Setup Mandate flow for selected payment method through Gocardless".to_string(),
))
}
}?;
let payment_method_token = item.get_payment_method_token()?;
let customer_bank_account = match payment_method_token {
PaymentMethodToken::Token(token) => Ok(token),
PaymentMethodToken::ApplePayDecrypt(_)
| PaymentMethodToken::PazeDecrypt(_)
| PaymentMethodToken::GooglePayDecrypt(_) => {
Err(errors::ConnectorError::NotImplemented(
"Setup Mandate flow for selected payment method through Gocardless".to_string(),
))
}
}?;
Ok(Self {
mandates: Mandate {
scheme,
metadata: MandateMetaData {
payment_reference: item.connector_request_reference_id.clone(),
},
payer_ip_address,
links: MandateLink {
customer_bank_account,
},
},
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/gocardless/transformers.rs" role="context" start="404" end="404">
use hyperswitch_domain_models::{
address::AddressDetails,
payment_method_data::{BankDebitData, PaymentMethodData},
router_data::{ConnectorAuthType, PaymentMethodToken, RouterData},
router_flow_types::refunds::Execute,
router_request_types::{
ConnectorCustomerData, PaymentMethodTokenizationData, PaymentsAuthorizeData,
PaymentsSyncData, ResponseId, SetupMandateRequestData,
},
router_response_types::{MandateReference, PaymentsResponseData, RefundsResponseData},
types,
};
use crate::{
types::{RefundsResponseRouterData, ResponseRouterData},
utils::{
self, AddressDetailsData, BrowserInformationData, CustomerData, ForeignTryFrom,
PaymentsAuthorizeRequestData, PaymentsSetupMandateRequestData, RouterData as _,
},
};
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/gocardless/transformers.rs" role="context" start="478" end="488">
fn try_from(item: &BankDebitData) -> Result<Self, Self::Error> {
match item {
BankDebitData::AchBankDebit { .. } => Ok(Self::Ach),
BankDebitData::SepaBankDebit { .. } => Ok(Self::SepaCore),
BankDebitData::BecsBankDebit { .. } => Ok(Self::Becs),
BankDebitData::BacsBankDebit { .. } => Err(errors::ConnectorError::NotImplemented(
"Setup Mandate flow for selected payment method through Gocardless".to_string(),
)
.into()),
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/gocardless/transformers.rs" role="context" start="463" end="474">
fn get_ip_if_required(
bank_debit_data: &BankDebitData,
item: &types::SetupMandateRouterData,
) -> Result<Option<Secret<String, IpAddress>>, error_stack::Report<errors::ConnectorError>> {
let ip_address = item.request.get_browser_info()?.get_ip_address()?;
match bank_debit_data {
BankDebitData::AchBankDebit { .. } => Ok(Some(ip_address)),
BankDebitData::SepaBankDebit { .. }
| BankDebitData::BecsBankDebit { .. }
| BankDebitData::BacsBankDebit { .. } => Ok(None),
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/gocardless/transformers.rs" role="context" start="354" end="368">
fn try_from(
item: ResponseRouterData<
F,
GocardlessBankAccountResponse,
PaymentMethodTokenizationData,
PaymentsResponseData,
>,
) -> Result<Self, Self::Error> {
Ok(Self {
response: Ok(PaymentsResponseData::TokenizationResponse {
token: item.response.customer_bank_accounts.id.expose(),
}),
..item.data
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/gocardless/transformers.rs" role="context" start="325" end="330">
fn from(item: common_enums::BankType) -> Self {
match item {
common_enums::BankType::Checking => Self::Checking,
common_enums::BankType::Savings => Self::Savings,
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/gocardless/transformers.rs" role="context" start="929" end="949">
fn try_from(item: &WebhookAction) -> Result<Self, Self::Error> {
match item {
WebhookAction::PaymentsAction(action) => match action {
PaymentsAction::CustomerApprovalGranted | PaymentsAction::Submitted => {
Ok(Self::Submitted)
}
PaymentsAction::CustomerApprovalDenied => Ok(Self::CustomerApprovalDenied),
PaymentsAction::LateFailureSettled => Ok(Self::Failed),
PaymentsAction::Failed => Ok(Self::Failed),
PaymentsAction::Cancelled => Ok(Self::Cancelled),
PaymentsAction::Confirmed => Ok(Self::Confirmed),
PaymentsAction::PaidOut => Ok(Self::PaidOut),
PaymentsAction::SurchargeFeeDebited
| PaymentsAction::ResubmissionRequired
| PaymentsAction::Created => Err(errors::ConnectorError::WebhookEventTypeNotFound)?,
},
WebhookAction::RefundsAction(_) | WebhookAction::MandatesAction(_) => {
Err(errors::ConnectorError::WebhookEventTypeNotFound)?
}
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/gocardless/transformers.rs" role="context" start="36" end="36">
type Error = error_stack::Report<errors::ConnectorError>;
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/gocardless/transformers.rs" role="context" start="399" end="401">
pub struct MandateLink {
customer_bank_account: Secret<String>,
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/globalpay/response.rs" role="context" start="186" end="189">
pub struct Mandate {
/// The reference to identify the mandate.
pub code: Option<Secret<String>>,
}
<file_sep path="hyperswitch/migrations/2022-12-05-090521_single_use_mandate_fields/up.sql" role="context" start="1" end="4">
-- Your SQL goes here
ALTER TABLE mandate
ADD IF NOT EXISTS single_use_amount INTEGER DEFAULT NULL,
ADD IF NOT EXISTS single_use_currency "Currency" DEFAULT NULL;
| symbol_neighborhood |
<|meta_start|><|file|> hyperswitch/crates/hyperswitch_connectors/src/connectors/zen/transformers.rs<|crate|> hyperswitch_connectors<|connector|> zen 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/zen/transformers.rs" role="context" start="263" end="307">
fn try_from(
value: (
&ZenRouterData<&types::PaymentsAuthorizeRouterData>,
&VoucherData,
),
) -> Result<Self, Self::Error> {
let (item, voucher_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 voucher_data {
VoucherData::Boleto { .. } => ZenPaymentChannels::PclBoacompraBoleto,
VoucherData::Efecty => ZenPaymentChannels::PclBoacompraEfecty,
VoucherData::PagoEfectivo => ZenPaymentChannels::PclBoacompraPagoefectivo,
VoucherData::RedCompra => ZenPaymentChannels::PclBoacompraRedcompra,
VoucherData::RedPagos => ZenPaymentChannels::PclBoacompraRedpagos,
VoucherData::Oxxo
| VoucherData::Alfamart { .. }
| VoucherData::Indomaret { .. }
| VoucherData::SevenEleven { .. }
| VoucherData::Lawson { .. }
| VoucherData::MiniStop { .. }
| VoucherData::FamilyMart { .. }
| VoucherData::Seicomart { .. }
| VoucherData::PayEasy { .. } => 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="262" end="262">
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 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="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="215" end="253">
fn try_from(
value: (&ZenRouterData<&types::PaymentsAuthorizeRouterData>, &Card),
) -> Result<Self, Self::Error> {
let (item, ccard) = value;
let browser_info = item.router_data.request.get_browser_info()?;
let ip = browser_info.get_ip_address()?;
let browser_details = get_browser_details(&browser_info)?;
let amount = item.amount.to_owned();
let payment_specific_data =
ZenPaymentSpecificData::ZenOnetimePayment(Box::new(ZenPaymentData {
browser_details,
//Connector Specific for cards
payment_type: ZenPaymentTypes::Onetime,
token: None,
card: Some(ZenCardDetails {
number: ccard.card_number.clone(),
expiry_date: ccard
.get_card_expiry_month_year_2_digit_with_delimiter("".to_owned())?,
cvv: ccard.card_cvc.clone(),
}),
descriptor: item
.router_data
.get_description()?
.chars()
.take(24)
.collect(),
return_verify_url: item.router_data.request.router_return_url.clone(),
}));
Ok(Self::ApiRequest(Box::new(ApiRequest {
merchant_transaction_id: item.router_data.connector_request_reference_id.clone(),
payment_channel: ZenPaymentChannels::PclCard,
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="65" end="73">
fn try_from(auth_type: &ConnectorAuthType) -> Result<Self, Self::Error> {
if let ConnectorAuthType::HeaderKey { api_key } = auth_type {
Ok(Self {
api_key: api_key.to_owned(),
})
} else {
Err(errors::ConnectorError::FailedToObtainAuthType.into())
}
}
<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="617" end="641">
fn get_item_object(
item: &types::PaymentsAuthorizeRouterData,
) -> Result<Vec<ZenItemObject>, error_stack::Report<errors::ConnectorError>> {
let order_details = item.request.get_order_details()?;
order_details
.iter()
.map(|data| {
Ok(ZenItemObject {
name: data.product_name.clone(),
quantity: data.quantity,
price: utils::to_currency_base_unit_with_zero_decimal_check(
data.amount.get_amount_as_i64(), // This should be changed to MinorUnit when we implement amount conversion for this connector. Additionally, the function get_amount_as_i64() should be avoided in the future.
item.request.currency,
)?,
line_amount_total: (f64::from(data.quantity)
* utils::to_currency_base_unit_asf64(
data.amount.get_amount_as_i64(), // This should be changed to MinorUnit when we implement amount conversion for this connector. Additionally, the function get_amount_as_i64() should be avoided in the future.
item.request.currency,
)?)
.to_string(),
})
})
.collect::<Result<_, _>>()
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/zen/transformers.rs" role="context" start="46" end="46">
type Error = error_stack::Report<errors::ConnectorError>;
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/zen/transformers.rs" role="context" start="179" end="182">
pub enum ZenPaymentTypes {
Onetime,
General,
}
<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/payeezy/transformers.rs<|crate|> hyperswitch_connectors<|connector|> payeezy anchor=get_transaction_type_and_stored_creds 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="181" end="230">
fn get_transaction_type_and_stored_creds(
item: &PaymentsAuthorizeRouterData,
) -> Result<(PayeezyTransactionType, Option<StoredCredentials>), error_stack::Report<ConnectorError>>
{
let connector_mandate_id = item.request.mandate_id.as_ref().and_then(|mandate_ids| {
match mandate_ids.mandate_reference_id.clone() {
Some(api_models::payments::MandateReferenceId::ConnectorMandateId(
connector_mandate_ids,
)) => connector_mandate_ids.get_connector_mandate_id(),
_ => None,
}
});
let (transaction_type, stored_credentials) =
if is_mandate_payment(item, connector_mandate_id.as_ref()) {
// Mandate payment
(
PayeezyTransactionType::Recurring,
Some(StoredCredentials {
// connector_mandate_id is not present then it is a First payment, else it is a Subsequent mandate payment
sequence: match connector_mandate_id.is_some() {
true => Sequence::Subsequent,
false => Sequence::First,
},
// off_session true denotes the customer not present during the checkout process. In other cases customer present at the checkout.
initiator: match item.request.off_session {
Some(true) => Initiator::Merchant,
_ => Initiator::CardHolder,
},
is_scheduled: true,
// In case of first mandate payment connector_mandate_id would be None, otherwise holds some value
cardbrand_original_transaction_id: connector_mandate_id.map(Secret::new),
}),
)
} else {
match item.request.capture_method {
Some(CaptureMethod::Manual) => Ok((PayeezyTransactionType::Authorize, None)),
Some(CaptureMethod::SequentialAutomatic) | Some(CaptureMethod::Automatic) => {
Ok((PayeezyTransactionType::Purchase, None))
}
Some(CaptureMethod::ManualMultiple) | Some(CaptureMethod::Scheduled) | None => {
Err(ConnectorError::FlowNotSupported {
flow: item.request.capture_method.unwrap_or_default().to_string(),
connector: "Payeezy".to_string(),
})
}
}?
};
Ok((transaction_type, stored_credentials))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/payeezy/transformers.rs" role="context" start="180" end="180">
use common_enums::{enums, AttemptStatus, CaptureMethod, Currency, PaymentMethod};
use error_stack::ResultExt;
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 masking::{ExposeInterface, Secret};
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="239" end="281">
fn get_payment_method_data(
item: &PayeezyRouterData<&PaymentsAuthorizeRouterData>,
) -> Result<PayeezyPaymentMethod, error_stack::Report<ConnectorError>> {
match item.router_data.request.payment_method_data {
PaymentMethodData::Card(ref card) => {
let card_type = PayeezyCardType::try_from(card.get_card_issuer()?)?;
let payeezy_card = PayeezyCard {
card_type,
cardholder_name: item
.router_data
.get_optional_billing_full_name()
.unwrap_or(Secret::new("".to_string())),
card_number: card.card_number.clone(),
exp_date: card.get_card_expiry_month_year_2_digit_with_delimiter("".to_string())?,
cvv: card.card_cvc.clone(),
};
Ok(PayeezyPaymentMethod::PayeezyCard(payeezy_card))
}
PaymentMethodData::CardRedirect(_)
| PaymentMethodData::Wallet(_)
| PaymentMethodData::PayLater(_)
| PaymentMethodData::BankRedirect(_)
| PaymentMethodData::BankDebit(_)
| PaymentMethodData::BankTransfer(_)
| PaymentMethodData::Crypto(_)
| PaymentMethodData::MandatePayment
| PaymentMethodData::Reward
| PaymentMethodData::RealTimePayment(_)
| PaymentMethodData::MobilePayment(_)
| PaymentMethodData::Upi(_)
| PaymentMethodData::Voucher(_)
| PaymentMethodData::GiftCard(_)
| PaymentMethodData::OpenBanking(_)
| PaymentMethodData::CardToken(_)
| PaymentMethodData::NetworkToken(_)
| PaymentMethodData::CardDetailsForNetworkTransactionId(_) => {
Err(ConnectorError::NotImplemented(
get_unimplemented_payment_method_error_message("Payeezy"),
))?
}
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/payeezy/transformers.rs" role="context" start="232" end="237">
fn is_mandate_payment(
item: &PaymentsAuthorizeRouterData,
connector_mandate_id: Option<&String>,
) -> bool {
item.request.setup_mandate_details.is_some() || connector_mandate_id.is_some()
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/payeezy/transformers.rs" role="context" start="160" end="180">
fn get_card_specific_payment_data(
item: &PayeezyRouterData<&PaymentsAuthorizeRouterData>,
) -> Result<PayeezyPaymentsRequest, error_stack::Report<ConnectorError>> {
let merchant_ref = item.router_data.attempt_id.to_string();
let method = PayeezyPaymentMethodType::CreditCard;
let amount = item.amount.clone();
let currency_code = item.router_data.request.currency.to_string();
let credit_card = get_payment_method_data(item)?;
let (transaction_type, stored_credentials) =
get_transaction_type_and_stored_creds(item.router_data)?;
Ok(PayeezyPaymentsRequest {
merchant_ref,
transaction_type,
method,
amount,
currency_code,
credit_card,
stored_credentials,
reference: item.router_data.connector_request_reference_id.clone(),
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/payeezy/transformers.rs" role="context" start="134" end="157">
fn try_from(
item: &PayeezyRouterData<&PaymentsAuthorizeRouterData>,
) -> Result<Self, Self::Error> {
match item.router_data.payment_method {
PaymentMethod::Card => get_card_specific_payment_data(item),
PaymentMethod::CardRedirect
| PaymentMethod::PayLater
| PaymentMethod::Wallet
| PaymentMethod::BankRedirect
| PaymentMethod::BankTransfer
| PaymentMethod::Crypto
| PaymentMethod::BankDebit
| PaymentMethod::Reward
| PaymentMethod::RealTimePayment
| PaymentMethod::MobilePayment
| PaymentMethod::Upi
| PaymentMethod::Voucher
| PaymentMethod::OpenBanking
| PaymentMethod::GiftCard => {
Err(ConnectorError::NotImplemented("Payment methods".to_string()).into())
}
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/payeezy/transformers.rs" role="context" start="389" end="398">
pub enum PayeezyTransactionType {
Authorize,
Capture,
Purchase,
Recurring,
Void,
Refund,
#[default]
Pending,
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/payeezy/transformers.rs" role="context" start="127" end="130">
pub enum Initiator {
Merchant,
CardHolder,
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/globalpay/response.rs" role="context" start="186" end="189">
pub struct Mandate {
/// The reference to identify the mandate.
pub code: Option<Secret<String>>,
}
<file_sep path="hyperswitch/migrations/2022-12-05-090521_single_use_mandate_fields/up.sql" role="context" start="1" end="4">
-- Your SQL goes here
ALTER TABLE mandate
ADD IF NOT EXISTS single_use_amount INTEGER DEFAULT NULL,
ADD IF NOT EXISTS single_use_currency "Currency" DEFAULT NULL;
| 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="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="1202" end="1202">
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 masking::{ExposeInterface, PeekInterface, Secret};
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="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="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="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="1063" end="1180">
fn get_card_info<F, Req>(
item: &RouterData<F, Req, PaymentsResponseData>,
card_details: &payment_method_data::Card,
) -> Result<NuveiPaymentsRequest, error_stack::Report<errors::ConnectorError>>
where
Req: NuveiAuthorizePreprocessingCommon,
{
let browser_information = item.request.get_browser_info().clone();
let related_transaction_id = if item.is_three_ds() {
item.request.get_related_transaction_id().clone()
} else {
None
};
let address = item
.get_optional_billing()
.and_then(|billing_details| billing_details.address.as_ref());
let billing_address = match address {
Some(address) => {
let first_name = address.get_first_name()?.clone();
Some(BillingAddress {
first_name: Some(first_name.clone()),
last_name: Some(address.get_last_name().ok().unwrap_or(&first_name).clone()),
email: item.request.get_email_required()?,
country: item.get_billing_country()?,
})
}
None => None,
};
let (is_rebilling, additional_params, user_token_id) =
match item.request.get_setup_mandate_details().clone() {
Some(mandate_data) => {
let details = match mandate_data
.mandate_type
.get_required_value("mandate_type")
.change_context(errors::ConnectorError::MissingRequiredField {
field_name: "mandate_type",
})? {
MandateDataType::SingleUse(details) => details,
MandateDataType::MultiUse(details) => {
details.ok_or(errors::ConnectorError::MissingRequiredField {
field_name: "mandate_data.mandate_type.multi_use",
})?
}
};
let mandate_meta: NuveiMandateMeta = utils::to_connector_meta_from_secret(Some(
details.get_metadata().ok_or_else(utils::missing_field_err(
"mandate_data.mandate_type.{multi_use|single_use}.metadata",
))?,
))?;
(
Some("0".to_string()), // In case of first installment, rebilling should be 0
Some(V2AdditionalParams {
rebill_expiry: Some(
details
.get_end_date(date_time::DateFormat::YYYYMMDD)
.change_context(errors::ConnectorError::DateFormattingFailed)?
.ok_or_else(utils::missing_field_err(
"mandate_data.mandate_type.{multi_use|single_use}.end_date",
))?,
),
rebill_frequency: Some(mandate_meta.frequency),
challenge_window_size: None,
}),
Some(item.request.get_email_required()?),
)
}
_ => (None, None, None),
};
let three_d = if item.is_three_ds() {
let browser_details = match &browser_information {
Some(browser_info) => Some(BrowserDetails {
accept_header: browser_info.get_accept_header()?,
ip: browser_info.get_ip_address()?,
java_enabled: browser_info.get_java_enabled()?.to_string().to_uppercase(),
java_script_enabled: browser_info
.get_java_script_enabled()?
.to_string()
.to_uppercase(),
language: browser_info.get_language()?,
screen_height: browser_info.get_screen_height()?,
screen_width: browser_info.get_screen_width()?,
color_depth: browser_info.get_color_depth()?,
user_agent: browser_info.get_user_agent()?,
time_zone: browser_info.get_time_zone()?,
}),
None => None,
};
Some(ThreeD {
browser_details,
v2_additional_params: additional_params,
notification_url: item.request.get_complete_authorize_url().clone(),
merchant_url: Some(item.request.get_return_url_required()?),
platform_type: Some(PlatformType::Browser),
method_completion_ind: Some(MethodCompletion::Unavailable),
..Default::default()
})
} else {
None
};
Ok(NuveiPaymentsRequest {
related_transaction_id,
is_rebilling,
user_token_id,
device_details: Option::<DeviceDetails>::foreign_try_from(
&item.request.get_browser_info().clone(),
)?,
payment_option: PaymentOption::from(NuveiCardDetails {
card: card_details.clone(),
three_d,
card_holder_name: item.get_optional_billing_full_name(),
}),
billing_address,
..Default::default()
})
}
<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="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="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="1330" end="1338">
pub struct NuveiPaymentRequestData {
pub amount: String,
pub currency: enums::Currency,
pub related_transaction_id: Option<String>,
pub client_request_id: String,
pub connector_auth_type: ConnectorAuthType,
pub session_token: Secret<String>,
pub capture_method: Option<enums::CaptureMethod>,
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/globalpay/requests.rs" role="context" start="203" end="208">
pub enum PaymentMethodData {
Card(Card),
Apm(Apm),
BankTransfer(BankTransfer),
DigitalWallet(DigitalWallet),
}
| symbol_neighborhood |
<|meta_start|><|file|> hyperswitch/crates/hyperswitch_connectors/src/connectors/multisafepay/transformers.rs<|crate|> hyperswitch_connectors<|connector|> multisafepay 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/multisafepay/transformers.rs" role="context" start="955" end="1031">
fn try_from(
item: ResponseRouterData<F, MultisafepayAuthResponse, T, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
match item.response {
MultisafepayAuthResponse::PaymentResponse(payment_response) => {
let redirection_data = payment_response
.data
.payment_url
.clone()
.map(|url| RedirectForm::from((url, Method::Get)));
let default_status = if payment_response.success {
MultisafepayPaymentStatus::Initialized
} else {
MultisafepayPaymentStatus::Declined
};
let status =
AttemptStatus::from(payment_response.data.status.unwrap_or(default_status));
Ok(Self {
status,
response: if utils::is_payment_failure(status) {
Err(populate_error_reason(
payment_response.data.reason_code,
payment_response.data.reason.clone(),
payment_response.data.reason,
item.http_code,
Some(status),
Some(payment_response.data.order_id),
))
} else {
Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(
payment_response.data.order_id.clone(),
),
redirection_data: Box::new(redirection_data),
mandate_reference: Box::new(
payment_response
.data
.payment_details
.and_then(|payment_details| payment_details.recurring_id)
.map(|id| MandateReference {
connector_mandate_id: Some(id.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: Some(
payment_response.data.order_id.clone(),
),
incremental_authorization_allowed: None,
charges: None,
})
},
..item.data
})
}
MultisafepayAuthResponse::ErrorResponse(error_response) => {
let attempt_status = Option::<AttemptStatus>::from(error_response.clone());
Ok(Self {
response: Err(populate_error_reason(
Some(error_response.error_code.to_string()),
Some(error_response.error_info.clone()),
Some(error_response.error_info),
item.http_code,
attempt_status,
None,
)),
..item.data
})
}
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/multisafepay/transformers.rs" role="context" start="954" end="954">
use common_enums::{enums, AttemptStatus, BankNames};
use common_utils::{
errors::ParsingError,
pii::{Email, IpAddress},
request::Method,
types::{FloatMajorUnit, MinorUnit},
};
use hyperswitch_domain_models::{
payment_method_data::{BankRedirectData, PayLaterData, PaymentMethodData, WalletData},
router_data::{ConnectorAuthType, ErrorResponse, RouterData},
router_flow_types::refunds::{Execute, RSync},
router_request_types::ResponseId,
router_response_types::{
MandateReference, PaymentsResponseData, RedirectForm, RefundsResponseData,
},
types::{self},
};
use crate::{
types::{RefundsResponseRouterData, ResponseRouterData},
utils::{
self, AddressDetailsData, CardData as _, PaymentsAuthorizeRequestData, RouterData as _,
},
};
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/multisafepay/transformers.rs" role="context" start="1068" end="1078">
fn try_from(
item: &MultisafepayRouterData<&types::RefundsRouterData<F>>,
) -> Result<Self, Self::Error> {
Ok(Self {
currency: item.router_data.request.currency,
amount: item.amount,
description: item.router_data.description.clone(),
refund_order_id: Some(item.router_data.request.refund_id.clone()),
checkout_data: None,
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/multisafepay/transformers.rs" role="context" start="1033" end="1052">
pub fn populate_error_reason(
code: Option<String>,
message: Option<String>,
reason: Option<String>,
http_code: u16,
attempt_status: Option<AttemptStatus>,
connector_transaction_id: Option<String>,
) -> ErrorResponse {
ErrorResponse {
code: code.unwrap_or(NO_ERROR_CODE.to_string()),
message: message.clone().unwrap_or(NO_ERROR_MESSAGE.to_string()),
reason,
status_code: http_code,
attempt_status,
connector_transaction_id,
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/multisafepay/transformers.rs" role="context" start="897" end="905">
fn from(item: MultisafepayPaymentStatus) -> Self {
match item {
MultisafepayPaymentStatus::Completed => Self::Charged,
MultisafepayPaymentStatus::Declined => Self::Failure,
MultisafepayPaymentStatus::Initialized => Self::AuthenticationPending,
MultisafepayPaymentStatus::Uncleared => Self::Pending,
MultisafepayPaymentStatus::Void => Self::Voided,
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/multisafepay/transformers.rs" role="context" start="868" end="876">
fn try_from(auth_type: &ConnectorAuthType) -> Result<Self, Self::Error> {
if let ConnectorAuthType::HeaderKey { api_key } = auth_type {
Ok(Self {
api_key: api_key.to_owned(),
})
} else {
Err(errors::ConnectorError::FailedToObtainAuthType.into())
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/multisafepay/transformers.rs" role="context" start="1212" end="1252">
fn from(error_data: MultisafepayErrorResponse) -> Self {
match error_data.error_code {
10001 // InvalidAmount
| 1002 // InvalidCurrency
| 1003 // InvalidAccountID
| 1004 // InvalidSiteID
| 1005 // InvalidSecurityCode
| 1006 // InvalidTransactionID
| 1007 // InvalidIPAddress
| 1008 // InvalidDescription
| 1010 // InvalidVariable
| 1011 // InvalidCustomerAccountID
| 1012 // InvalidCustomerSecurityCode
| 1013 // InvalidSignature
| 1015 //UnknownAccountID
| 1016 // MissingData
| 1018 // InvalidCountryCode
| 1025 // MultisafepayErrorCodes::IncorrectCustomerIPAddress
| 1026 // MultisafepayErrorCodes::MultipleCurrenciesInCart
| 1027 // MultisafepayErrorCodes::CartCurrencyDifferentToOrderCurrency
| 1028 // IncorrectCustomTaxRate
| 1029 // IncorrectItemTaxRate
| 1030 // IncorrectItemCurrency
| 1031 // IncorrectItemPrice
| 1035 // InvalidSignatureRefund
| 1036 // InvalidIdealIssuerID
| 5001 // CartDataNotValidated
| 1032 // InvalidAPIKey
=> {
Some(AttemptStatus::AuthenticationFailed)
}
1034 // CannotRefundTransaction
| 1022 // CannotInitiateTransaction
| 1024 //TransactionDeclined
=> Some(AttemptStatus::Failure),
1017 // InsufficientFunds
=> Some(AttemptStatus::AuthorizationFailed),
_ => None,
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/multisafepay/transformers.rs" role="context" start="234" end="234">
type Error = error_stack::Report<errors::ConnectorError>;
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/multisafepay/transformers.rs" role="context" start="946" end="949">
pub enum MultisafepayAuthResponse {
ErrorResponse(MultisafepayErrorResponse),
PaymentResponse(Box<MultisafepayPaymentsResponse>),
}
<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/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="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="610" end="610">
use common_enums::enums;
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="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="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="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="544" end="552">
pub struct AirwallexPaymentsResponse {
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/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
<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/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="224" end="282">
fn try_from(
item: &AirwallexRouterData<&types::PaymentsAuthorizeRouterData>,
) -> Result<Self, Self::Error> {
let mut payment_method_options = None;
let request = &item.router_data.request;
let payment_method = match request.payment_method_data.clone() {
PaymentMethodData::Card(ccard) => {
payment_method_options =
Some(AirwallexPaymentOptions::Card(AirwallexCardPaymentOptions {
auto_capture: matches!(
request.capture_method,
Some(enums::CaptureMethod::Automatic)
| Some(enums::CaptureMethod::SequentialAutomatic)
| None
),
}));
Ok(AirwallexPaymentMethod::Card(AirwallexCard {
card: AirwallexCardDetails {
number: ccard.card_number.clone(),
expiry_month: ccard.card_exp_month.clone(),
expiry_year: ccard.get_expiry_year_4_digit(),
cvc: ccard.card_cvc,
},
payment_method_type: AirwallexPaymentType::Card,
}))
}
PaymentMethodData::Wallet(ref wallet_data) => get_wallet_details(wallet_data),
PaymentMethodData::PayLater(_)
| PaymentMethodData::BankRedirect(_)
| PaymentMethodData::BankDebit(_)
| PaymentMethodData::BankTransfer(_)
| PaymentMethodData::CardRedirect(_)
| 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("airwallex"),
))
}
}?;
let device_data = get_device_data(item.router_data)?;
Ok(Self {
request_id: Uuid::new_v4().to_string(),
payment_method,
payment_method_options,
return_url: request.complete_authorize_url.clone(),
device_data,
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/airwallex/transformers.rs" role="context" start="223" end="223">
use common_enums::enums;
use common_utils::{errors::ParsingError, pii::IpAddress, request::Method};
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="322" end="369">
fn get_wallet_details(
wallet_data: &WalletData,
) -> Result<AirwallexPaymentMethod, errors::ConnectorError> {
let wallet_details: AirwallexPaymentMethod = match wallet_data {
WalletData::GooglePay(gpay_details) => {
AirwallexPaymentMethod::Wallets(AirwallexWalletData::GooglePay(GooglePayData {
googlepay: GooglePayDetails {
encrypted_payment_token: Secret::new(
gpay_details.tokenization_data.token.clone(),
),
payment_data_type: GpayPaymentDataType::EncryptedPaymentToken,
},
payment_method_type: AirwallexPaymentType::Googlepay,
}))
}
WalletData::AliPayQr(_)
| WalletData::AliPayRedirect(_)
| WalletData::AliPayHkRedirect(_)
| WalletData::AmazonPayRedirect(_)
| WalletData::MomoRedirect(_)
| WalletData::KakaoPayRedirect(_)
| WalletData::GoPayRedirect(_)
| WalletData::GcashRedirect(_)
| WalletData::ApplePay(_)
| WalletData::ApplePayRedirect(_)
| WalletData::ApplePayThirdPartySdk(_)
| WalletData::DanaRedirect {}
| WalletData::GooglePayRedirect(_)
| WalletData::GooglePayThirdPartySdk(_)
| WalletData::MbWayRedirect(_)
| WalletData::MobilePayRedirect(_)
| WalletData::PaypalRedirect(_)
| WalletData::PaypalSdk(_)
| WalletData::Paze(_)
| WalletData::SamsungPay(_)
| WalletData::TwintRedirect {}
| WalletData::VippsRedirect {}
| WalletData::TouchNGoRedirect(_)
| WalletData::WeChatPayRedirect(_)
| WalletData::WeChatPayQr(_)
| WalletData::CashappQr(_)
| WalletData::SwishQr(_)
| WalletData::Mifinity(_) => Err(errors::ConnectorError::NotImplemented(
utils::get_unimplemented_payment_method_error_message("airwallex"),
))?,
};
Ok(wallet_details)
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/airwallex/transformers.rs" role="context" start="285" end="320">
fn get_device_data(
item: &types::PaymentsAuthorizeRouterData,
) -> Result<DeviceData, error_stack::Report<errors::ConnectorError>> {
let info = item.request.get_browser_info()?;
let browser = Browser {
java_enabled: info.get_java_enabled()?,
javascript_enabled: info.get_java_script_enabled()?,
user_agent: info.get_user_agent()?,
};
let mobile = {
let device_model = info.get_device_model().ok();
let os_type = info.get_os_type().ok();
let os_version = info.get_os_version().ok();
if device_model.is_some() || os_type.is_some() || os_version.is_some() {
Some(Mobile {
device_model,
os_type,
os_version,
})
} else {
None
}
};
Ok(DeviceData {
accept_header: info.get_accept_header()?,
browser,
ip_address: info.get_ip_address()?,
mobile,
screen_color_depth: info.get_color_depth()?,
screen_height: info.get_screen_height()?,
screen_width: info.get_screen_width()?,
timezone: info.get_time_zone()?.to_string(),
language: info.get_language()?,
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/airwallex/transformers.rs" role="context" start="104" end="117">
fn try_from(
(currency_unit, currency, amount, router_data): (
&api::CurrencyUnit,
enums::Currency,
i64,
T,
),
) -> Result<Self, Self::Error> {
let amount = utils::get_amount_as_string(currency_unit, amount, currency)?;
Ok(Self {
amount,
router_data,
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/airwallex/transformers.rs" role="context" start="67" end="92">
fn try_from(item: &types::PaymentsPreProcessingRouterData) -> Result<Self, Self::Error> {
let referrer_data = ReferrerData {
r_type: "hyperswitch".to_string(),
version: "1.0.0".to_string(),
};
// amount and currency will always be Some since PaymentsPreProcessingData is constructed using PaymentsAuthorizeData
let amount = item
.request
.amount
.ok_or(errors::ConnectorError::MissingRequiredField {
field_name: "amount",
})?;
let currency =
item.request
.currency
.ok_or(errors::ConnectorError::MissingRequiredField {
field_name: "currency",
})?;
Ok(Self {
request_id: Uuid::new_v4().to_string(),
amount: utils::to_currency_base_unit(amount, currency)?,
currency,
merchant_order_id: item.connector_request_reference_id.clone(),
referrer_data,
})
}
<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="216" end="218">
pub struct AirwallexCardPaymentOptions {
auto_capture: bool,
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/globalpay/requests.rs" role="context" start="203" end="208">
pub enum PaymentMethodData {
Card(Card),
Apm(Apm),
BankTransfer(BankTransfer),
DigitalWallet(DigitalWallet),
}
| symbol_neighborhood |
<|meta_start|><|file|> hyperswitch/crates/hyperswitch_connectors/src/connectors/zen/transformers.rs<|crate|> hyperswitch_connectors<|connector|> zen 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/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="316" end="316">
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 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="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="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="263" end="307">
fn try_from(
value: (
&ZenRouterData<&types::PaymentsAuthorizeRouterData>,
&VoucherData,
),
) -> Result<Self, Self::Error> {
let (item, voucher_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 voucher_data {
VoucherData::Boleto { .. } => ZenPaymentChannels::PclBoacompraBoleto,
VoucherData::Efecty => ZenPaymentChannels::PclBoacompraEfecty,
VoucherData::PagoEfectivo => ZenPaymentChannels::PclBoacompraPagoefectivo,
VoucherData::RedCompra => ZenPaymentChannels::PclBoacompraRedcompra,
VoucherData::RedPagos => ZenPaymentChannels::PclBoacompraRedpagos,
VoucherData::Oxxo
| VoucherData::Alfamart { .. }
| VoucherData::Indomaret { .. }
| VoucherData::SevenEleven { .. }
| VoucherData::Lawson { .. }
| VoucherData::MiniStop { .. }
| VoucherData::FamilyMart { .. }
| VoucherData::Seicomart { .. }
| VoucherData::PayEasy { .. } => 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="215" end="253">
fn try_from(
value: (&ZenRouterData<&types::PaymentsAuthorizeRouterData>, &Card),
) -> Result<Self, Self::Error> {
let (item, ccard) = value;
let browser_info = item.router_data.request.get_browser_info()?;
let ip = browser_info.get_ip_address()?;
let browser_details = get_browser_details(&browser_info)?;
let amount = item.amount.to_owned();
let payment_specific_data =
ZenPaymentSpecificData::ZenOnetimePayment(Box::new(ZenPaymentData {
browser_details,
//Connector Specific for cards
payment_type: ZenPaymentTypes::Onetime,
token: None,
card: Some(ZenCardDetails {
number: ccard.card_number.clone(),
expiry_date: ccard
.get_card_expiry_month_year_2_digit_with_delimiter("".to_owned())?,
cvv: ccard.card_cvc.clone(),
}),
descriptor: item
.router_data
.get_description()?
.chars()
.take(24)
.collect(),
return_verify_url: item.router_data.request.router_return_url.clone(),
}));
Ok(Self::ApiRequest(Box::new(ApiRequest {
merchant_transaction_id: item.router_data.connector_request_reference_id.clone(),
payment_channel: ZenPaymentChannels::PclCard,
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="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="617" end="641">
fn get_item_object(
item: &types::PaymentsAuthorizeRouterData,
) -> Result<Vec<ZenItemObject>, error_stack::Report<errors::ConnectorError>> {
let order_details = item.request.get_order_details()?;
order_details
.iter()
.map(|data| {
Ok(ZenItemObject {
name: data.product_name.clone(),
quantity: data.quantity,
price: utils::to_currency_base_unit_with_zero_decimal_check(
data.amount.get_amount_as_i64(), // This should be changed to MinorUnit when we implement amount conversion for this connector. Additionally, the function get_amount_as_i64() should be avoided in the future.
item.request.currency,
)?,
line_amount_total: (f64::from(data.quantity)
* utils::to_currency_base_unit_asf64(
data.amount.get_amount_as_i64(), // This should be changed to MinorUnit when we implement amount conversion for this connector. Additionally, the function get_amount_as_i64() should be avoided in the future.
item.request.currency,
)?)
.to_string(),
})
})
.collect::<Result<_, _>>()
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/zen/transformers.rs" role="context" start="46" end="46">
type Error = error_stack::Report<errors::ConnectorError>;
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/zen/transformers.rs" role="context" start="179" end="182">
pub enum ZenPaymentTypes {
Onetime,
General,
}
<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="270" end="290">
pub struct AchBankTransfer {
/// Bank name
#[schema(value_type = Option<String>, example = "Deutsche Bank")]
pub bank_name: Option<String>,
/// Bank country code
#[schema(value_type = Option<CountryAlpha2>, example = "US")]
pub bank_country_code: Option<api_enums::CountryAlpha2>,
/// Bank city
#[schema(value_type = Option<String>, example = "California")]
pub bank_city: Option<String>,
/// Bank account number is an unique identifier assigned by a bank to a customer.
#[schema(value_type = String, example = "000123456")]
pub bank_account_number: Secret<String>,
/// [9 digits] Routing number - used in USA for identifying a specific bank.
#[schema(value_type = String, example = "110000000")]
pub bank_routing_number: Secret<String>,
}
| symbol_neighborhood |
<|meta_start|><|file|> hyperswitch/crates/hyperswitch_connectors/src/connectors/jpmorgan/transformers.rs<|crate|> hyperswitch_connectors<|connector|> jpmorgan 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/jpmorgan/transformers.rs" role="context" start="138" end="205">
fn try_from(
item: &JpmorganRouterData<&PaymentsAuthorizeRouterData>,
) -> Result<Self, Self::Error> {
match item.router_data.request.payment_method_data.clone() {
PaymentMethodData::Card(req_card) => {
if item.router_data.is_three_ds() {
return Err(errors::ConnectorError::NotSupported {
message: "3DS payments".to_string(),
connector: "Jpmorgan",
}
.into());
}
let capture_method =
map_capture_method(item.router_data.request.capture_method.unwrap_or_default());
let merchant_software = JpmorganMerchantSoftware {
company_name: String::from("JPMC").into(),
product_name: String::from("Hyperswitch").into(),
};
let merchant = JpmorganMerchant { merchant_software };
let expiry: Expiry = Expiry {
month: req_card.card_exp_month.clone(),
year: req_card.get_expiry_year_4_digit(),
};
let account_number = Secret::new(req_card.card_number.to_string());
let card = JpmorganCard {
account_number,
expiry,
};
let payment_method_type = JpmorganPaymentMethodType { card };
Ok(Self {
capture_method: capture_method?,
currency: item.router_data.request.currency,
amount: item.amount,
merchant,
payment_method_type,
})
}
PaymentMethodData::CardDetailsForNetworkTransactionId(_)
| 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(_) => Err(errors::ConnectorError::NotImplemented(
get_unimplemented_payment_method_error_message("jpmorgan"),
)
.into()),
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/jpmorgan/transformers.rs" role="context" start="137" end="137">
use hyperswitch_domain_models::{
payment_method_data::PaymentMethodData,
router_data::{AccessToken, ConnectorAuthType, RouterData},
router_flow_types::refunds::{Execute, RSync},
router_request_types::{PaymentsCancelData, ResponseId},
router_response_types::{PaymentsResponseData, RefundsResponseData},
types::{
PaymentsAuthorizeRouterData, PaymentsCancelRouterData, PaymentsCaptureRouterData,
RefreshTokenRouterData, RefundsRouterData,
},
};
use masking::Secret;
use crate::{
types::{RefundsResponseRouterData, ResponseRouterData},
utils::{
get_unimplemented_payment_method_error_message, CardData, RouterData as OtherRouterData,
},
};
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/jpmorgan/transformers.rs" role="context" start="317" end="329">
pub fn attempt_status_from_transaction_state(
transaction_state: JpmorganTransactionState,
) -> common_enums::AttemptStatus {
match transaction_state {
JpmorganTransactionState::Authorized => common_enums::AttemptStatus::Authorized,
JpmorganTransactionState::Closed => common_enums::AttemptStatus::Charged,
JpmorganTransactionState::Declined | JpmorganTransactionState::Error => {
common_enums::AttemptStatus::Failure
}
JpmorganTransactionState::Pending => common_enums::AttemptStatus::Pending,
JpmorganTransactionState::Voided => common_enums::AttemptStatus::Voided,
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/jpmorgan/transformers.rs" role="context" start="217" end="225">
fn try_from(auth_type: &ConnectorAuthType) -> Result<Self, Self::Error> {
match auth_type {
ConnectorAuthType::BodyKey { api_key, key1 } => Ok(Self {
_api_key: api_key.to_owned(),
_key1: key1.to_owned(),
}),
_ => Err(errors::ConnectorError::FailedToObtainAuthType.into()),
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/jpmorgan/transformers.rs" role="context" start="122" end="134">
fn map_capture_method(
capture_method: CaptureMethod,
) -> Result<CapMethod, error_stack::Report<errors::ConnectorError>> {
match capture_method {
CaptureMethod::Automatic => Ok(CapMethod::Now),
CaptureMethod::Manual => Ok(CapMethod::Manual),
CaptureMethod::Scheduled
| CaptureMethod::ManualMultiple
| CaptureMethod::SequentialAutomatic => {
Err(errors::ConnectorError::NotImplemented("Capture Method".to_string()).into())
}
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/jpmorgan/transformers.rs" role="context" start="66" end="76">
fn try_from(
item: ResponseRouterData<F, JpmorganAuthUpdateResponse, 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/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="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="285" end="292">
pub struct Card {
expiry: Option<ExpiryResponse>,
card_type: Option<Secret<String>>,
card_type_name: Option<Secret<String>>,
masked_account_number: Option<Secret<String>>,
card_type_indicators: Option<CardTypeIndicators>,
network_response: Option<NetworkResponse>,
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/globalpay/requests.rs" role="context" start="203" end="208">
pub enum PaymentMethodData {
Card(Card),
Apm(Apm),
BankTransfer(BankTransfer),
DigitalWallet(DigitalWallet),
}
| 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="1891" end="1963">
fn try_from(
item: ResponseRouterData<
SetupMandate,
WellsfargoPaymentsResponse,
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_attempt_status(
item.response
.status
.clone()
.unwrap_or(WellsfargoPaymentStatus::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/wellsfargo/transformers.rs" role="context" start="1890" end="1890">
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="2031" end="2095">
fn try_from(
item: ResponseRouterData<
F,
WellsfargoTransactionResponse,
PaymentsSyncData,
PaymentsResponseData,
>,
) -> Result<Self, Self::Error> {
match item.response.application_information.status {
Some(status) => {
let status = map_attempt_status(status, item.data.request.is_auto_capture()?);
let incremental_authorization_allowed =
Some(status == enums::AttemptStatus::Authorized);
let risk_info: Option<ClientRiskInformation> = None;
if utils::is_payment_failure(status) {
Ok(Self {
response: Err(get_error_response(
&item.response.error_information,
&risk_info,
Some(status),
item.http_code,
item.response.id.clone(),
)),
status: enums::AttemptStatus::Failure,
..item.data
})
} else {
Ok(Self {
status,
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: item
.response
.client_reference_information
.map(|cref| cref.code)
.unwrap_or(Some(item.response.id)),
incremental_authorization_allowed,
charges: None,
}),
..item.data
})
}
}
None => Ok(Self {
status: item.data.status,
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/wellsfargo/transformers.rs" role="context" start="1977" end="2002">
fn try_from(
item: ResponseRouterData<
F,
WellsfargoPaymentsIncrementalAuthorizationResponse,
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,
}),
_ => 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/wellsfargo/transformers.rs" role="context" start="1854" end="1876">
fn try_from(
item: ResponseRouterData<
F,
WellsfargoPaymentsResponse,
PaymentsCancelData,
PaymentsResponseData,
>,
) -> Result<Self, Self::Error> {
let status = map_attempt_status(
item.response
.status
.clone()
.unwrap_or(WellsfargoPaymentStatus::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/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="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="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="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/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="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="3508" end="3508">
// zero dollar response
impl
TryFrom<
ResponseRouterData<
SetupMandate,
CybersourcePaymentsResponse,
SetupMandateRequestData,
PaymentsResponseData,
>,
> for RouterData<SetupMandate, SetupMandateRequestData, PaymentsResponseData>
{
type Error = error_stack::Report<errors::ConnectorError>;
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 {
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/cybersource/transformers.rs" role="context" start="3649" end="3714">
fn try_from(
item: ResponseRouterData<
F,
CybersourceTransactionResponse,
PaymentsSyncData,
PaymentsResponseData,
>,
) -> Result<Self, Self::Error> {
match item.response.application_information.status {
Some(status) => {
let status =
map_cybersource_attempt_status(status, item.data.request.is_auto_capture()?);
let incremental_authorization_allowed =
Some(status == enums::AttemptStatus::Authorized);
let risk_info: Option<ClientRiskInformation> = None;
if utils::is_payment_failure(status) {
Ok(Self {
response: Err(get_error_response(
&item.response.error_information,
&risk_info,
Some(status),
item.http_code,
item.response.id.clone(),
)),
status: enums::AttemptStatus::Failure,
..item.data
})
} else {
Ok(Self {
status,
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: item
.response
.client_reference_information
.map(|cref| cref.code)
.unwrap_or(Some(item.response.id)),
incremental_authorization_allowed,
charges: None,
}),
..item.data
})
}
}
None => Ok(Self {
status: item.data.status,
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/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="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="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="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="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="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/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/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="832" end="898">
fn try_from(
(item, ccard): (
&AuthorizedotnetRouterData<&PaymentsAuthorizeRouterData>,
&Card,
),
) -> Result<Self, Self::Error> {
let (profile, customer) = if item.router_data.request.is_mandate_payment() {
(
Some(ProfileDetails::CreateProfileDetails(CreateProfileDetails {
create_profile: true,
})),
Some(CustomerDetails {
//The payment ID is included in the customer details because the connector requires unique customer information with a length of fewer than 20 characters when creating a mandate.
//If the length exceeds 20 characters, a random alphanumeric string is used instead.
id: if item.router_data.payment_id.len() <= 20 {
item.router_data.payment_id.clone()
} else {
Alphanumeric.sample_string(&mut rand::thread_rng(), 20)
},
}),
)
} else {
(None, None)
};
Ok(Self {
transaction_type: TransactionType::try_from(item.router_data.request.capture_method)?,
amount: item.amount,
currency_code: item.router_data.request.currency,
payment: Some(PaymentDetails::CreditCard(CreditCardDetails {
card_number: (*ccard.card_number).clone(),
expiration_date: ccard.get_expiry_date_as_yyyymm("-"),
card_code: Some(ccard.card_cvc.clone()),
})),
profile,
order: Order {
description: item.router_data.connector_request_reference_id.clone(),
},
customer,
bill_to: item
.router_data
.get_optional_billing()
.and_then(|billing_address| billing_address.address.as_ref())
.map(|address| BillTo {
first_name: address.first_name.clone(),
last_name: address.last_name.clone(),
address: address.line1.clone(),
city: address.city.clone(),
state: address.state.clone(),
zip: address.zip.clone(),
country: address.country,
}),
user_fields: match item.router_data.request.metadata.clone() {
Some(metadata) => Some(UserFields {
user_field: Vec::<UserField>::foreign_try_from(metadata)?,
}),
None => None,
},
processing_options: None,
subsequent_auth_information: None,
authorization_indicator_type: match item.router_data.request.capture_method {
Some(capture_method) => Some(AuthorizationIndicator {
authorization_indicator: capture_method.try_into()?,
}),
None => None,
},
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/authorizedotnet/transformers.rs" role="context" start="831" end="831">
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 rand::distributions::{Alphanumeric, DistString};
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/authorizedotnet/transformers.rs" role="context" start="977" end="992">
fn try_from(item: &PaymentsCancelRouterData) -> Result<Self, Self::Error> {
let transaction_request = TransactionVoidOrCaptureRequest {
amount: None, //amount is not required for void
transaction_type: TransactionType::Void,
ref_trans_id: item.request.connector_transaction_id.to_string(),
};
let merchant_authentication = AuthorizedotnetAuthType::try_from(&item.connector_auth_type)?;
Ok(Self {
create_transaction_request: AuthorizedotnetPaymentCancelOrCaptureRequest {
merchant_authentication,
transaction_request,
},
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/authorizedotnet/transformers.rs" role="context" start="908" end="972">
fn try_from(
(item, wallet_data): (
&AuthorizedotnetRouterData<&PaymentsAuthorizeRouterData>,
&WalletData,
),
) -> Result<Self, Self::Error> {
let (profile, customer) = if item.router_data.request.is_mandate_payment() {
(
Some(ProfileDetails::CreateProfileDetails(CreateProfileDetails {
create_profile: true,
})),
Some(CustomerDetails {
id: if item.router_data.payment_id.len() <= 20 {
item.router_data.payment_id.clone()
} else {
Alphanumeric.sample_string(&mut rand::thread_rng(), 20)
},
}),
)
} else {
(None, None)
};
Ok(Self {
transaction_type: TransactionType::try_from(item.router_data.request.capture_method)?,
amount: item.amount,
currency_code: item.router_data.request.currency,
payment: Some(get_wallet_data(
wallet_data,
&item.router_data.request.complete_authorize_url,
)?),
profile,
order: Order {
description: item.router_data.connector_request_reference_id.clone(),
},
customer,
bill_to: item
.router_data
.get_optional_billing()
.and_then(|billing_address| billing_address.address.as_ref())
.map(|address| BillTo {
first_name: address.first_name.clone(),
last_name: address.last_name.clone(),
address: address.line1.clone(),
city: address.city.clone(),
state: address.state.clone(),
zip: address.zip.clone(),
country: address.country,
}),
user_fields: match item.router_data.request.metadata.clone() {
Some(metadata) => Some(UserFields {
user_field: Vec::<UserField>::foreign_try_from(metadata)?,
}),
None => None,
},
processing_options: None,
subsequent_auth_information: None,
authorization_indicator_type: match item.router_data.request.capture_method {
Some(capture_method) => Some(AuthorizationIndicator {
authorization_indicator: capture_method.try_into()?,
}),
None => None,
},
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/authorizedotnet/transformers.rs" role="context" start="776" end="822">
fn try_from(
(item, connector_mandate_id): (
&AuthorizedotnetRouterData<&PaymentsAuthorizeRouterData>,
api_models::payments::ConnectorMandateReferenceId,
),
) -> Result<Self, Self::Error> {
let mandate_id = connector_mandate_id
.get_connector_mandate_id()
.ok_or(errors::ConnectorError::MissingConnectorMandateID)?;
Ok(Self {
transaction_type: TransactionType::try_from(item.router_data.request.capture_method)?,
amount: item.amount,
currency_code: item.router_data.request.currency,
payment: None,
profile: mandate_id
.split_once('-')
.map(|(customer_profile_id, payment_profile_id)| {
ProfileDetails::CustomerProfileDetails(CustomerProfileDetails {
customer_profile_id: Secret::from(customer_profile_id.to_string()),
payment_profile: PaymentProfileDetails {
payment_profile_id: Secret::from(payment_profile_id.to_string()),
},
})
}),
order: Order {
description: item.router_data.connector_request_reference_id.clone(),
},
customer: None,
bill_to: None,
user_fields: match item.router_data.request.metadata.clone() {
Some(metadata) => Some(UserFields {
user_field: Vec::<UserField>::foreign_try_from(metadata)?,
}),
None => None,
},
processing_options: Some(ProcessingOptions {
is_subsequent_auth: true,
}),
subsequent_auth_information: None,
authorization_indicator_type: match item.router_data.request.capture_method {
Some(capture_method) => Some(AuthorizationIndicator {
authorization_indicator: capture_method.try_into()?,
}),
None => None,
},
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/authorizedotnet/transformers.rs" role="context" start="687" end="766">
fn try_from(
(item, network_trans_id): (
&AuthorizedotnetRouterData<&PaymentsAuthorizeRouterData>,
String,
),
) -> Result<Self, Self::Error> {
Ok(Self {
transaction_type: TransactionType::try_from(item.router_data.request.capture_method)?,
amount: item.amount,
currency_code: item.router_data.request.currency,
payment: Some(match item.router_data.request.payment_method_data {
PaymentMethodData::Card(ref ccard) => {
PaymentDetails::CreditCard(CreditCardDetails {
card_number: (*ccard.card_number).clone(),
expiration_date: ccard.get_expiry_date_as_yyyymm("-"),
card_code: None,
})
}
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(
utils::get_unimplemented_payment_method_error_message("authorizedotnet"),
))?
}
}),
profile: None,
order: Order {
description: item.router_data.connector_request_reference_id.clone(),
},
customer: None,
bill_to: item
.router_data
.get_optional_billing()
.and_then(|billing_address| billing_address.address.as_ref())
.map(|address| BillTo {
first_name: address.first_name.clone(),
last_name: address.last_name.clone(),
address: address.line1.clone(),
city: address.city.clone(),
state: address.state.clone(),
zip: address.zip.clone(),
country: address.country,
}),
user_fields: match item.router_data.request.metadata.clone() {
Some(metadata) => Some(UserFields {
user_field: Vec::<UserField>::foreign_try_from(metadata)?,
}),
None => None,
},
processing_options: Some(ProcessingOptions {
is_subsequent_auth: true,
}),
subsequent_auth_information: Some(SubsequentAuthInformation {
original_network_trans_id: Secret::new(network_trans_id),
reason: Reason::Resubmission,
}),
authorization_indicator_type: match item.router_data.request.capture_method {
Some(capture_method) => Some(AuthorizationIndicator {
authorization_indicator: capture_method.try_into()?,
}),
None => None,
},
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/authorizedotnet/transformers.rs" role="context" start="1205" end="1298">
fn foreign_try_from(
(item, is_auto_capture): (
ResponseRouterData<F, AuthorizedotnetPaymentsResponse, T, PaymentsResponseData>,
bool,
),
) -> Result<Self, Self::Error> {
match &item.response.transaction_response {
Some(TransactionResponse::AuthorizedotnetTransactionResponse(transaction_response)) => {
let status = get_payment_status((
transaction_response.response_code.clone(),
is_auto_capture,
));
let error = transaction_response.errors.as_ref().and_then(|errors| {
errors.iter().next().map(|error| ErrorResponse {
code: error.error_code.clone(),
message: error.error_text.clone(),
reason: Some(error.error_text.clone()),
status_code: item.http_code,
attempt_status: None,
connector_transaction_id: Some(transaction_response.transaction_id.clone()),
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
})
});
let metadata = transaction_response
.account_number
.as_ref()
.map(|acc_no| {
construct_refund_payment_details(acc_no.clone().expose()).encode_to_value()
})
.transpose()
.change_context(errors::ConnectorError::MissingRequiredField {
field_name: "connector_metadata",
})?;
let url = transaction_response
.secure_acceptance
.as_ref()
.and_then(|x| x.secure_acceptance_url.to_owned());
let redirection_data = url.map(|url| RedirectForm::from((url, Method::Get)));
let mandate_reference = item.response.profile_response.map(|profile_response| {
let payment_profile_id = profile_response
.customer_payment_profile_id_list
.and_then(|customer_payment_profile_id_list| {
customer_payment_profile_id_list.first().cloned()
});
MandateReference {
connector_mandate_id: profile_response.customer_profile_id.and_then(
|customer_profile_id| {
payment_profile_id.map(|payment_profile_id| {
format!("{customer_profile_id}-{payment_profile_id}")
})
},
),
payment_method_id: None,
mandate_metadata: None,
connector_mandate_request_reference_id: None,
}
});
Ok(Self {
status,
response: match error {
Some(err) => Err(err),
None => Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(
transaction_response.transaction_id.clone(),
),
redirection_data: Box::new(redirection_data),
mandate_reference: Box::new(mandate_reference),
connector_metadata: metadata,
network_txn_id: transaction_response
.network_trans_id
.clone()
.map(|network_trans_id| network_trans_id.expose()),
connector_response_reference_id: Some(
transaction_response.transaction_id.clone(),
),
incremental_authorization_allowed: None,
charges: None,
}),
},
..item.data
})
}
Some(TransactionResponse::AuthorizedotnetTransactionResponseError(_)) | None => {
Ok(Self {
status: enums::AttemptStatus::Failure,
response: Err(get_err_response(item.http_code, item.response.messages)?),
..item.data
})
}
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/authorizedotnet/transformers.rs" role="context" start="1963" end="2013">
fn try_from(
item: &AuthorizedotnetRouterData<&PaymentsCompleteAuthorizeRouterData>,
) -> Result<Self, Self::Error> {
let params = item
.router_data
.request
.redirect_response
.as_ref()
.and_then(|redirect_response| redirect_response.params.as_ref())
.ok_or(errors::ConnectorError::ResponseDeserializationFailed)?;
let query_params: PaypalQueryParams = serde_urlencoded::from_str(params.peek())
.change_context(errors::ConnectorError::ResponseDeserializationFailed)
.attach_printable("Failed to parse connector response")?;
let payer_id = query_params.payer_id;
let transaction_type = match item.router_data.request.capture_method {
Some(enums::CaptureMethod::Manual) => Ok(TransactionType::ContinueAuthorization),
Some(enums::CaptureMethod::SequentialAutomatic)
| Some(enums::CaptureMethod::Automatic)
| None => Ok(TransactionType::ContinueCapture),
Some(enums::CaptureMethod::ManualMultiple) => {
Err(errors::ConnectorError::NotSupported {
message: enums::CaptureMethod::ManualMultiple.to_string(),
connector: "authorizedotnet",
})
}
Some(enums::CaptureMethod::Scheduled) => Err(errors::ConnectorError::NotSupported {
message: enums::CaptureMethod::Scheduled.to_string(),
connector: "authorizedotnet",
}),
}?;
let transaction_request = TransactionConfirmRequest {
transaction_type,
payment: PaypalPaymentConfirm {
pay_pal: Paypal { payer_id },
},
ref_trans_id: item.router_data.request.connector_transaction_id.clone(),
};
let merchant_authentication =
AuthorizedotnetAuthType::try_from(&item.router_data.connector_auth_type)?;
Ok(Self {
create_transaction_request: PaypalConfirmTransactionRequest {
merchant_authentication,
transaction_request,
},
})
}
<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="257" end="259">
struct AuthorizationIndicator {
authorization_indicator: AuthorizationType,
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/globalpay/response.rs" role="context" start="216" end="241">
pub struct Card {
/// Code generated when the card is successfully authorized.
pub authcode: Option<Secret<String>>,
/// The recommended AVS action to be taken by the agent processing the card transaction.
pub avs_action: Option<String>,
/// The result of the AVS address check.
pub avs_address_result: Option<String>,
/// The result of the AVS postal code check.
pub avs_postal_code_result: Option<String>,
/// Indicates the card brand that issued the card.
pub brand: Option<Brand>,
/// The unique reference created by the brands/schemes to uniquely identify the transaction.
pub brand_reference: Option<Secret<String>>,
/// The time returned by the card brand indicating when the transaction was processed on
/// their system.
pub brand_time_reference: Option<String>,
/// The result of the CVV check.
pub cvv_result: Option<String>,
/// Masked card number with last 4 digits showing.
pub masked_number_last4: Option<String>,
/// The result codes directly from the card issuer.
pub provider: Option<ProviderClass>,
/// The card EMV tag response data from the card issuer for a contactless or chip card
/// transaction.
pub tag_response: Option<Secret<String>>,
}
<file_sep path="hyperswitch-encryption-service/migrations/2024-05-28-075150_create_dek_table/up.sql" role="context" start="1" end="9">
CREATE TABLE IF NOT EXISTS data_key_store (
id SERIAL PRIMARY KEY,
key_identifier VARCHAR(255) NOT NULL,
data_identifier VARCHAR(20) NOT NULL,
encryption_key bytea NOT NULL,
version VARCHAR(30) NOT NULL,
created_at TIMESTAMP NOT NULL
);
| symbol_neighborhood |
<|meta_start|><|file|> hyperswitch/crates/hyperswitch_connectors/src/connectors/worldline/transformers.rs<|crate|> hyperswitch_connectors<|connector|> worldline anchor=make_bank_redirect_request 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="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="359" end="359">
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="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="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="330" end="358">
fn make_card_request(
req: &PaymentsAuthorizeData,
ccard: &hyperswitch_domain_models::payment_method_data::Card,
card_holder_name: Option<Secret<String>>,
) -> Result<CardPaymentMethod, error_stack::Report<errors::ConnectorError>> {
let expiry_year = ccard.card_exp_year.peek();
let secret_value = format!(
"{}{}",
ccard.card_exp_month.peek(),
&expiry_year
.get(expiry_year.len() - 2..)
.ok_or(errors::ConnectorError::RequestEncodingFailed)?
);
let expiry_date: Secret<String> = Secret::new(secret_value);
let card = Card {
card_number: ccard.card_number.clone(),
cardholder_name: card_holder_name.unwrap_or(Secret::new("".to_string())),
cvv: ccard.card_cvc.clone(),
expiry_date,
};
#[allow(clippy::as_conversions)]
let payment_product_id = Gateway::try_from(ccard.get_card_issuer()?)? as u16;
let card_payment_method_specific_input = CardPaymentMethod {
card,
requires_approval: matches!(req.capture_method, Some(CaptureMethod::Manual)),
payment_product_id,
};
Ok(card_payment_method_specific_input)
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/worldline/transformers.rs" role="context" start="309" end="327">
fn try_from(bank: &BankNames) -> Result<Self, Self::Error> {
match bank {
BankNames::AbnAmro => Ok(Self::Abnamro),
BankNames::AsnBank => Ok(Self::Asn),
BankNames::Ing => Ok(Self::Ing),
BankNames::Knab => Ok(Self::Knab),
BankNames::Rabobank => Ok(Self::Rabobank),
BankNames::Regiobank => Ok(Self::Regiobank),
BankNames::SnsBank => Ok(Self::Sns),
BankNames::TriodosBank => Ok(Self::Triodos),
BankNames::VanLanschot => Ok(Self::Vanlanschot),
BankNames::FrieslandBank => Ok(Self::Friesland),
_ => Err(errors::ConnectorError::FlowNotSupported {
flow: bank.to_string(),
connector: "Worldline".to_string(),
}
.into()),
}
}
<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="716" end="727">
fn try_from(
item: RefundsResponseRouterData<RSync, RefundResponse>,
) -> Result<Self, Self::Error> {
let refund_status = common_enums::enums::RefundStatus::from(item.response.status);
Ok(Self {
response: Ok(RefundsResponseData {
connector_refund_id: item.response.id.clone(),
refund_status,
}),
..item.data
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/worldline/transformers.rs" role="context" start="177" end="180">
pub struct BankAccountIban {
pub account_holder_name: Secret<String>,
pub iban: Option<Secret<String>>,
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/worldline/transformers.rs" role="context" start="152" end="173">
pub enum WorldlineBic {
#[serde(rename = "ABNANL2A")]
Abnamro,
#[serde(rename = "ASNBNL21")]
Asn,
#[serde(rename = "FRBKNL2L")]
Friesland,
#[serde(rename = "KNABNL2H")]
Knab,
#[serde(rename = "RABONL2U")]
Rabobank,
#[serde(rename = "RBRBNL21")]
Regiobank,
#[serde(rename = "SNSBNL2A")]
Sns,
#[serde(rename = "TRIONL2U")]
Triodos,
#[serde(rename = "FVLBNL22")]
Vanlanschot,
#[serde(rename = "INGBNL2A")]
Ing,
}
<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/rapyd/transformers.rs<|crate|> hyperswitch_connectors<|connector|> rapyd 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/rapyd/transformers.rs" role="context" start="434" end="513">
fn try_from(
item: ResponseRouterData<F, RapydPaymentsResponse, T, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
let (status, response) = match &item.response.data {
Some(data) => {
let attempt_status =
get_status(data.status.to_owned(), data.next_action.to_owned());
match attempt_status {
enums::AttemptStatus::Failure => (
enums::AttemptStatus::Failure,
Err(ErrorResponse {
code: data
.failure_code
.to_owned()
.unwrap_or(item.response.status.error_code),
status_code: item.http_code,
message: item.response.status.status.unwrap_or_default(),
reason: data.failure_message.to_owned(),
attempt_status: None,
connector_transaction_id: None,
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
}),
),
_ => {
let redirection_url = data
.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 =
redirection_url.map(|url| RedirectForm::from((url, Method::Get)));
(
attempt_status,
Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(data.id.to_owned()), //transaction_id is also the field but this id is used to initiate a refund
redirection_data: Box::new(redirection_data),
mandate_reference: Box::new(None),
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: data
.merchant_reference_id
.to_owned(),
incremental_authorization_allowed: None,
charges: None,
}),
)
}
}
}
None => (
enums::AttemptStatus::Failure,
Err(ErrorResponse {
code: item.response.status.error_code,
status_code: item.http_code,
message: item.response.status.status.unwrap_or_default(),
reason: item.response.status.message,
attempt_status: None,
connector_transaction_id: None,
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
}),
),
};
Ok(Self {
status,
response,
..item.data
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/rapyd/transformers.rs" role="context" start="433" end="433">
use common_enums::enums;
use common_utils::{ext_traits::OptionExt, request::Method, types::FloatMajorUnit};
use hyperswitch_domain_models::{
payment_method_data::{PaymentMethodData, WalletData},
router_data::{ConnectorAuthType, ErrorResponse, RouterData},
router_flow_types::refunds::{Execute, RSync},
router_request_types::ResponseId,
router_response_types::{PaymentsResponseData, RedirectForm, RefundsResponseData},
types,
};
use url::Url;
use crate::{
types::{RefundsResponseRouterData, ResponseRouterData},
utils::{PaymentsAuthorizeRequestData, RouterData as _},
};
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/rapyd/transformers.rs" role="context" start="577" end="588">
fn from(value: ResponseData) -> Self {
Self {
status: Status {
error_code: NO_ERROR_CODE.to_owned(),
status: None,
message: None,
response_code: None,
operation_id: None,
},
data: Some(value),
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/rapyd/transformers.rs" role="context" start="557" end="565">
fn from(value: RapydWebhookDisputeStatus) -> Self {
match value {
RapydWebhookDisputeStatus::Active => Self::DisputeOpened,
RapydWebhookDisputeStatus::Review => Self::DisputeChallenged,
RapydWebhookDisputeStatus::Lose => Self::DisputeLost,
RapydWebhookDisputeStatus::Win => Self::DisputeWon,
RapydWebhookDisputeStatus::Unknown => Self::EventNotSupported,
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/rapyd/transformers.rs" role="context" start="419" end="427">
fn try_from(
item: &RapydRouterData<&types::PaymentsCaptureRouterData>,
) -> Result<Self, Self::Error> {
Ok(Self {
amount: Some(item.amount),
receipt_email: None,
statement_descriptor: None,
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/rapyd/transformers.rs" role="context" start="390" end="407">
fn try_from(
item: RefundsResponseRouterData<RSync, RefundResponse>,
) -> Result<Self, Self::Error> {
let (connector_refund_id, refund_status) = match item.response.data {
Some(data) => (data.id, enums::RefundStatus::from(data.status)),
None => (
item.response.status.error_code,
enums::RefundStatus::Failure,
),
};
Ok(Self {
response: Ok(RefundsResponseData {
connector_refund_id,
refund_status,
}),
..item.data
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/rapyd/transformers.rs" role="context" start="220" end="239">
fn get_status(status: RapydPaymentStatus, next_action: NextAction) -> enums::AttemptStatus {
match (status, next_action) {
(RapydPaymentStatus::Closed, _) => enums::AttemptStatus::Charged,
(
RapydPaymentStatus::Active,
NextAction::ThreedsVerification | NextAction::PendingConfirmation,
) => enums::AttemptStatus::AuthenticationPending,
(RapydPaymentStatus::Active, NextAction::PendingCapture | NextAction::NotApplicable) => {
enums::AttemptStatus::Authorized
}
(
RapydPaymentStatus::CanceledByClientOrBank
| RapydPaymentStatus::Expired
| RapydPaymentStatus::ReversedByRapyd,
_,
) => enums::AttemptStatus::Voided,
(RapydPaymentStatus::Error, _) => enums::AttemptStatus::Failure,
(RapydPaymentStatus::New, _) => enums::AttemptStatus::Authorizing,
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/rapyd/transformers.rs" role="context" start="592" end="603">
fn from(value: RefundResponseData) -> Self {
Self {
status: Status {
error_code: NO_ERROR_CODE.to_owned(),
status: None,
message: None,
response_code: None,
operation_id: None,
},
data: Some(value),
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/rapyd/transformers.rs" role="context" start="96" end="96">
type Error = error_stack::Report<errors::ConnectorError>;
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/rapyd/transformers.rs" role="context" start="242" end="245">
pub struct RapydPaymentsResponse {
pub status: Status,
pub data: Option<ResponseData>,
}
<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/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="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="895" end="895">
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="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="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="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="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="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="1850" end="1915">
fn try_from(
item: RefundsResponseRouterData<RSync, RedsysSyncResponse>,
) -> Result<Self, Self::Error> {
let message_data = item
.response
.body
.consultaoperacionesresponse
.consultaoperacionesreturn
.messages
.version
.message;
let response = match (message_data.response, message_data.errormsg) {
(None, Some(errormsg)) => {
let error_code = errormsg.ds_errorcode.clone();
Err(ErrorResponse {
code: error_code.clone(),
message: error_code.clone(),
reason: Some(error_code),
status_code: item.http_code,
attempt_status: None,
connector_transaction_id: None,
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
})
}
(Some(response), None) => {
if let Some(ds_response) = response.ds_response {
let refund_status = enums::RefundStatus::try_from(ds_response.clone())?;
if connector_utils::is_refund_failure(refund_status) {
Err(ErrorResponse {
status_code: item.http_code,
code: ds_response.0.clone(),
message: ds_response.0.clone(),
reason: Some(ds_response.0.clone()),
attempt_status: None,
connector_transaction_id: None,
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
})
} else {
Ok(RefundsResponseData {
connector_refund_id: response.ds_order,
refund_status,
})
}
} else {
// When the refund is pending
Ok(RefundsResponseData {
connector_refund_id: response.ds_order,
refund_status: enums::RefundStatus::Pending,
})
}
}
(Some(_), Some(_)) | (None, None) => {
Err(errors::ConnectorError::ResponseHandlingFailed)?
}
};
Ok(Self {
response,
..item.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="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/worldline/transformers.rs" role="context" start="563" end="568">
pub struct Payment {
pub id: String,
pub status: PaymentStatus,
#[serde(skip_deserializing)]
pub capture_method: CaptureMethod,
}
| 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="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="895" end="895">
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="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="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="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="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="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="1850" end="1915">
fn try_from(
item: RefundsResponseRouterData<RSync, RedsysSyncResponse>,
) -> Result<Self, Self::Error> {
let message_data = item
.response
.body
.consultaoperacionesresponse
.consultaoperacionesreturn
.messages
.version
.message;
let response = match (message_data.response, message_data.errormsg) {
(None, Some(errormsg)) => {
let error_code = errormsg.ds_errorcode.clone();
Err(ErrorResponse {
code: error_code.clone(),
message: error_code.clone(),
reason: Some(error_code),
status_code: item.http_code,
attempt_status: None,
connector_transaction_id: None,
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
})
}
(Some(response), None) => {
if let Some(ds_response) = response.ds_response {
let refund_status = enums::RefundStatus::try_from(ds_response.clone())?;
if connector_utils::is_refund_failure(refund_status) {
Err(ErrorResponse {
status_code: item.http_code,
code: ds_response.0.clone(),
message: ds_response.0.clone(),
reason: Some(ds_response.0.clone()),
attempt_status: None,
connector_transaction_id: None,
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
})
} else {
Ok(RefundsResponseData {
connector_refund_id: response.ds_order,
refund_status,
})
}
} else {
// When the refund is pending
Ok(RefundsResponseData {
connector_refund_id: response.ds_order,
refund_status: enums::RefundStatus::Pending,
})
}
}
(Some(_), Some(_)) | (None, None) => {
Err(errors::ConnectorError::ResponseHandlingFailed)?
}
};
Ok(Self {
response,
..item.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="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/worldline/transformers.rs" role="context" start="563" end="568">
pub struct Payment {
pub id: String,
pub status: PaymentStatus,
#[serde(skip_deserializing)]
pub capture_method: CaptureMethod,
}
<file_sep path="hyperswitch/crates/api_models/src/payments.rs" role="context" start="849" end="1160">
pub struct PaymentsRequest {
/// The payment amount. Amount for the payment in the lowest denomination of the currency, (i.e) in cents for USD denomination, in yen for JPY denomination etc. E.g., Pass 100 to charge $1.00 and 1 for 1¥ since ¥ is a zero-decimal currency. Read more about [the Decimal and Non-Decimal Currencies](https://github.com/juspay/hyperswitch/wiki/Decimal-and-Non%E2%80%90Decimal-Currencies)
#[schema(value_type = Option<u64>, example = 6540)]
#[serde(default, deserialize_with = "amount::deserialize_option")]
#[mandatory_in(PaymentsCreateRequest = u64)]
// Makes the field mandatory in PaymentsCreateRequest
pub amount: Option<Amount>,
/// Total tax amount applicable to the order
#[schema(value_type = Option<i64>, example = 6540)]
pub order_tax_amount: Option<MinorUnit>,
/// The three letter ISO currency code in uppercase. Eg: 'USD' to charge US Dollars
#[schema(example = "USD", value_type = Option<Currency>)]
#[mandatory_in(PaymentsCreateRequest = Currency)]
pub currency: Option<api_enums::Currency>,
/// The Amount to be captured / debited from the users payment method. It shall be in lowest denomination of the currency. (i.e) in cents for USD denomination, in paisa for INR denomination etc., If not provided, the default amount_to_capture will be the payment amount. Also, it must be less than or equal to the original payment account.
#[schema(value_type = Option<i64>, example = 6540)]
pub amount_to_capture: Option<MinorUnit>,
/// The shipping cost for the payment. This is required for tax calculation in some regions.
#[schema(value_type = Option<i64>, example = 6540)]
pub shipping_cost: Option<MinorUnit>,
/// Unique identifier for the payment. This ensures idempotency for multiple payments
/// that have been done by a single merchant. The value for this field can be specified in the request, it will be auto generated otherwise and returned in the API response.
#[schema(
value_type = Option<String>,
min_length = 30,
max_length = 30,
example = "pay_mbabizu24mvu3mela5njyhpit4"
)]
#[serde(default, deserialize_with = "payment_id_type::deserialize_option")]
pub payment_id: Option<PaymentIdType>,
/// This is an identifier for the merchant account. This is inferred from the API key
/// provided during the request
#[schema(max_length = 255, example = "merchant_1668273825", value_type = Option<String>)]
#[remove_in(PaymentsUpdateRequest, PaymentsCreateRequest, PaymentsConfirmRequest)]
pub merchant_id: Option<id_type::MerchantId>,
/// Details of the routing configuration for that payment
#[schema(value_type = Option<StraightThroughAlgorithm>, example = json!({
"type": "single",
"data": {"connector": "stripe", "merchant_connector_id": "mca_123"}
}))]
pub routing: Option<serde_json::Value>,
/// This allows to manually select a connector with which the payment can go through.
#[schema(value_type = Option<Vec<Connector>>, max_length = 255, example = json!(["stripe", "adyen"]))]
pub connector: Option<Vec<api_enums::Connector>>,
#[schema(value_type = Option<CaptureMethod>, example = "automatic")]
pub capture_method: Option<api_enums::CaptureMethod>,
#[schema(value_type = Option<AuthenticationType>, example = "no_three_ds", default = "three_ds")]
pub authentication_type: Option<api_enums::AuthenticationType>,
/// The billing details of the payment. This address will be used for invoicing.
pub billing: Option<Address>,
/// A timestamp (ISO 8601 code) that determines when the payment should be captured.
/// Providing this field will automatically set `capture` to true
#[schema(example = "2022-09-10T10:11:12Z")]
#[serde(default, with = "common_utils::custom_serde::iso8601::option")]
#[remove_in(PaymentsUpdateRequest, PaymentsCreateRequest, PaymentsConfirmRequest)]
pub capture_on: Option<PrimitiveDateTime>,
/// Whether to confirm the payment (if applicable). It can be used to completely process a payment by attaching a payment method, setting `confirm=true` and `capture_method = automatic` in the *Payments/Create API* request itself.
#[schema(default = false, example = true)]
pub confirm: Option<bool>,
/// Passing this object creates a new customer or attaches an existing customer to the payment
pub customer: Option<CustomerDetails>,
/// The identifier for the customer
#[schema(value_type = Option<String>, max_length = 64, min_length = 1, example = "cus_y3oqhf46pyzuxjbcn2giaqnb44")]
pub customer_id: Option<id_type::CustomerId>,
/// The customer's email address.
/// This field will be deprecated soon, use the customer object instead
#[schema(max_length = 255, value_type = Option<String>, example = "johntest@test.com", deprecated)]
#[remove_in(PaymentsUpdateRequest, PaymentsCreateRequest, PaymentsConfirmRequest)]
pub email: Option<Email>,
/// The customer's name.
/// This field will be deprecated soon, use the customer object instead.
#[schema(value_type = Option<String>, max_length = 255, example = "John Test", deprecated)]
#[remove_in(PaymentsUpdateRequest, PaymentsCreateRequest, PaymentsConfirmRequest)]
pub name: Option<Secret<String>>,
/// The customer's phone number
/// This field will be deprecated soon, use the customer object instead
#[schema(value_type = Option<String>, max_length = 255, example = "9123456789", deprecated)]
#[remove_in(PaymentsUpdateRequest, PaymentsCreateRequest, PaymentsConfirmRequest)]
pub phone: Option<Secret<String>>,
/// The country code for the customer phone number
/// This field will be deprecated soon, use the customer object instead
#[schema(max_length = 255, example = "+1", deprecated)]
#[remove_in(PaymentsUpdateRequest, PaymentsCreateRequest, PaymentsConfirmRequest)]
pub phone_country_code: Option<String>,
/// Set to true to indicate that the customer is not in your checkout flow during this payment, and therefore is unable to authenticate. This parameter is intended for scenarios where you collect card details and charge them later. When making a recurring payment by passing a mandate_id, this parameter is mandatory
#[schema(example = true)]
pub off_session: Option<bool>,
/// A description for the payment
#[schema(example = "It's my first payment request")]
pub description: Option<String>,
/// The URL to which you want the user to be redirected after the completion of the payment operation
#[schema(value_type = Option<String>, example = "https://hyperswitch.io")]
pub return_url: Option<Url>,
#[schema(value_type = Option<FutureUsage>, example = "off_session")]
pub setup_future_usage: Option<api_enums::FutureUsage>,
#[schema(example = "bank_transfer")]
#[serde(with = "payment_method_data_serde", default)]
pub payment_method_data: Option<PaymentMethodDataRequest>,
#[schema(value_type = Option<PaymentMethod>, example = "card")]
pub payment_method: Option<api_enums::PaymentMethod>,
/// As Hyperswitch tokenises the sensitive details about the payments method, it provides the payment_token as a reference to a stored payment method, ensuring that the sensitive details are not exposed in any manner.
#[schema(example = "187282ab-40ef-47a9-9206-5099ba31e432")]
pub payment_token: Option<String>,
/// This is used along with the payment_token field while collecting during saved card payments. This field will be deprecated soon, use the payment_method_data.card_token object instead
#[schema(value_type = Option<String>, deprecated)]
#[remove_in(PaymentsUpdateRequest, PaymentsCreateRequest, PaymentsConfirmRequest)]
pub card_cvc: Option<Secret<String>>,
/// The shipping address for the payment
pub shipping: Option<Address>,
/// For non-card charges, you can use this value as the complete description that appears on your customers’ statements. Must contain at least one letter, maximum 22 characters.
#[schema(max_length = 255, example = "Hyperswitch Router")]
pub statement_descriptor_name: Option<String>,
/// Provides information about a card payment that customers see on their statements. Concatenated with the prefix (shortened descriptor) or statement descriptor that’s set on the account to form the complete statement descriptor. Maximum 22 characters for the concatenated descriptor.
#[schema(max_length = 255, example = "Payment for shoes purchase")]
pub statement_descriptor_suffix: Option<String>,
/// Use this object to capture the details about the different products for which the payment is being made. The sum of amount across different products here should be equal to the overall payment amount
#[schema(value_type = Option<Vec<OrderDetailsWithAmount>>, example = r#"[{
"product_name": "Apple iPhone 16",
"quantity": 1,
"amount" : 69000
"product_img_link" : "https://dummy-img-link.com"
}]"#)]
pub order_details: Option<Vec<OrderDetailsWithAmount>>,
/// It's a token used for client side verification.
#[schema(example = "pay_U42c409qyHwOkWo3vK60_secret_el9ksDkiB8hi6j9N78yo")]
#[remove_in(PaymentsUpdateRequest, PaymentsCreateRequest)]
pub client_secret: Option<String>,
/// Passing this object during payments creates a mandate. The mandate_type sub object is passed by the server.
pub mandate_data: Option<MandateData>,
/// This "CustomerAcceptance" object is passed during Payments-Confirm request, it enlists the type, time, and mode of acceptance properties related to an acceptance done by the customer. The customer_acceptance sub object is usually passed by the SDK or client.
#[schema(value_type = Option<CustomerAcceptance>)]
pub customer_acceptance: Option<CustomerAcceptance>,
/// A unique identifier to link the payment to a mandate. To do Recurring payments after a mandate has been created, pass the mandate_id instead of payment_method_data
#[schema(max_length = 255, example = "mandate_iwer89rnjef349dni3")]
#[remove_in(PaymentsUpdateRequest)]
pub mandate_id: Option<String>,
/// Additional details required by 3DS 2.0
#[schema(value_type = Option<BrowserInformation>, example = r#"{
"user_agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/70.0.3538.110 Safari/537.36",
"accept_header": "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8",
"language": "nl-NL",
"color_depth": 24,
"screen_height": 723,
"screen_width": 1536,
"time_zone": 0,
"java_enabled": true,
"java_script_enabled":true
}"#)]
pub browser_info: Option<serde_json::Value>,
/// To indicate the type of payment experience that the payment method would go through
#[schema(value_type = Option<PaymentExperience>, example = "redirect_to_url")]
pub payment_experience: Option<api_enums::PaymentExperience>,
/// Can be used to specify the Payment Method Type
#[schema(value_type = Option<PaymentMethodType>, example = "google_pay")]
pub payment_method_type: Option<api_enums::PaymentMethodType>,
/// Business country of the merchant for this payment.
/// To be deprecated soon. Pass the profile_id instead
#[schema(value_type = Option<CountryAlpha2>, example = "US")]
#[remove_in(PaymentsUpdateRequest, PaymentsConfirmRequest)]
pub business_country: Option<api_enums::CountryAlpha2>,
/// Business label of the merchant for this payment.
/// To be deprecated soon. Pass the profile_id instead
#[schema(example = "food")]
#[remove_in(PaymentsUpdateRequest, PaymentsConfirmRequest)]
pub business_label: Option<String>,
#[schema(value_type = Option<MerchantConnectorDetailsWrap>)]
pub merchant_connector_details: Option<admin::MerchantConnectorDetailsWrap>,
/// Use this parameter to restrict the Payment Method Types to show for a given PaymentIntent
#[schema(value_type = Option<Vec<PaymentMethodType>>)]
pub allowed_payment_method_types: Option<Vec<api_enums::PaymentMethodType>>,
/// Business sub label for the payment
#[remove_in(PaymentsUpdateRequest, PaymentsConfirmRequest, PaymentsCreateRequest)]
pub business_sub_label: Option<String>,
/// Denotes the retry action
#[schema(value_type = Option<RetryAction>)]
#[remove_in(PaymentsCreateRequest)]
pub retry_action: Option<api_enums::RetryAction>,
/// You can specify up to 50 keys, with key names up to 40 characters long and values up to 500 characters long. Metadata is useful for storing additional, structured information on an object.
#[schema(value_type = Option<Object>, example = r#"{ "udf1": "some-value", "udf2": "some-value" }"#)]
pub metadata: Option<serde_json::Value>,
/// Some connectors like Apple pay, Airwallex and Noon might require some additional information, find specific details in the child attributes below.
pub connector_metadata: Option<ConnectorMetadata>,
/// Additional data that might be required by hyperswitch based on the requested features by the merchants.
#[remove_in(PaymentsUpdateRequest, PaymentsCreateRequest, PaymentsConfirmRequest)]
pub feature_metadata: Option<FeatureMetadata>,
/// Whether to generate the payment link for this payment or not (if applicable)
#[schema(default = false, example = true)]
pub payment_link: Option<bool>,
#[schema(value_type = Option<PaymentCreatePaymentLinkConfig>)]
pub payment_link_config: Option<PaymentCreatePaymentLinkConfig>,
/// Custom payment link config id set at business profile, send only if business_specific_configs is configured
pub payment_link_config_id: Option<String>,
/// The business profile to be used for this payment, if not passed the default business profile associated with the merchant account will be used. It is mandatory in case multiple business profiles have been set up.
#[remove_in(PaymentsUpdateRequest, PaymentsConfirmRequest)]
#[schema(value_type = Option<String>)]
pub profile_id: Option<id_type::ProfileId>,
#[remove_in(PaymentsConfirmRequest)]
#[schema(value_type = Option<RequestSurchargeDetails>)]
pub surcharge_details: Option<RequestSurchargeDetails>,
/// The type of the payment that differentiates between normal and various types of mandate payments
#[schema(value_type = Option<PaymentType>)]
pub payment_type: Option<api_enums::PaymentType>,
///Request an incremental authorization, i.e., increase the authorized amount on a confirmed payment before you capture it.
pub request_incremental_authorization: Option<bool>,
///Will be used to expire client secret after certain amount of time to be supplied in seconds
///(900) for 15 mins
#[schema(example = 900)]
pub session_expiry: Option<u32>,
/// Additional data related to some frm(Fraud Risk Management) connectors
#[schema(value_type = Option<Object>, example = r#"{ "coverage_request" : "fraud", "fulfillment_method" : "delivery" }"#)]
pub frm_metadata: Option<pii::SecretSerdeValue>,
/// Whether to perform external authentication (if applicable)
#[schema(example = true)]
pub request_external_three_ds_authentication: Option<bool>,
/// Details required for recurring payment
pub recurring_details: Option<RecurringDetails>,
/// Fee information to be charged on the payment being collected
#[schema(value_type = Option<SplitPaymentsRequest>)]
pub split_payments: Option<common_types::payments::SplitPaymentsRequest>,
/// Optional boolean value to extent authorization period of this payment
///
/// capture method must be manual or manual_multiple
#[schema(value_type = Option<bool>, default = false)]
pub request_extended_authorization: Option<RequestExtendedAuthorizationBool>,
/// Merchant's identifier for the payment/invoice. This will be sent to the connector
/// if the connector provides support to accept multiple reference ids.
/// In case the connector supports only one reference id, Hyperswitch's Payment ID will be sent as reference.
#[schema(
value_type = Option<String>,
max_length = 255,
example = "Custom_Order_id_123"
)]
pub merchant_order_reference_id: Option<String>,
/// Whether to calculate tax for this payment intent
pub skip_external_tax_calculation: Option<bool>,
/// Choose what kind of sca exemption is required for this payment
#[schema(value_type = Option<ScaExemptionType>)]
pub psd2_sca_exemption_type: Option<api_enums::ScaExemptionType>,
/// Service details for click to pay external authentication
#[schema(value_type = Option<CtpServiceDetails>)]
pub ctp_service_details: Option<CtpServiceDetails>,
/// Indicates if 3ds challenge is forced
pub force_3ds_challenge: Option<bool>,
/// Indicates if 3DS method data was successfully completed or not
pub threeds_method_comp_ind: Option<ThreeDsCompletionIndicator>,
}
| symbol_neighborhood |
<|meta_start|><|file|> hyperswitch/crates/hyperswitch_connectors/src/connectors/bluesnap/transformers.rs<|crate|> hyperswitch_connectors<|connector|> bluesnap 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/bluesnap/transformers.rs" role="context" start="596" end="669">
fn try_from(
item: &BluesnapRouterData<&types::PaymentsCompleteAuthorizeRouterData>,
) -> Result<Self, Self::Error> {
let redirection_response: BluesnapRedirectionResponse = item
.router_data
.request
.redirect_response
.as_ref()
.and_then(|res| res.payload.to_owned())
.ok_or(errors::ConnectorError::MissingConnectorRedirectionPayload {
field_name: "request.redirect_response.payload",
})?
.parse_value("BluesnapRedirectionResponse")
.change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
let transaction_meta_data =
item.router_data
.request
.metadata
.as_ref()
.map(|metadata| BluesnapMetadata {
meta_data: convert_metadata_to_request_metadata(metadata.to_owned()),
});
let token = item
.router_data
.request
.redirect_response
.clone()
.and_then(|res| res.params.to_owned())
.ok_or(errors::ConnectorError::MissingConnectorRedirectionPayload {
field_name: "request.redirect_response.params",
})?
.peek()
.split_once('=')
.ok_or(errors::ConnectorError::MissingConnectorRedirectionPayload {
field_name: "request.redirect_response.params.paymentToken",
})?
.1
.to_string();
let redirection_result: BluesnapThreeDsResult = redirection_response
.authentication_response
.parse_struct("BluesnapThreeDsResult")
.change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
let auth_mode = match item.router_data.request.capture_method {
Some(enums::CaptureMethod::Manual) => BluesnapTxnType::AuthOnly,
_ => BluesnapTxnType::AuthCapture,
};
Ok(Self {
amount: item.amount.to_owned(),
currency: item.router_data.request.currency,
card_transaction_type: auth_mode,
three_d_secure: Some(BluesnapThreeDSecureInfo {
three_d_secure_reference_id: redirection_result
.three_d_secure
.ok_or(errors::ConnectorError::MissingConnectorRedirectionPayload {
field_name: "three_d_secure_reference_id",
})?
.three_d_secure_reference_id,
}),
transaction_fraud_info: Some(TransactionFraudInfo {
fraud_session_id: item.router_data.payment_id.clone(),
}),
card_holder_info: get_card_holder_info(
item.router_data.get_billing_address()?,
item.router_data.request.get_email()?,
)?,
merchant_transaction_id: Some(item.router_data.connector_request_reference_id.clone()),
pf_token: Secret::new(token),
transaction_meta_data,
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/bluesnap/transformers.rs" role="context" start="595" end="595">
use common_enums::{enums, CountryAlpha2};
use common_utils::{
consts::{APPLEPAY_VALIDATION_URL, BASE64_ENGINE},
errors::CustomResult,
ext_traits::{ByteSliceExt, Encode, OptionExt, StringExt, ValueExt},
pii::Email,
types::StringMajorUnit,
};
use hyperswitch_domain_models::{
address::AddressDetails,
payment_method_data::{self, PaymentMethodData, WalletData},
router_data::{ConnectorAuthType, RouterData},
router_flow_types::refunds::{Execute, RSync},
router_request_types::ResponseId,
router_response_types::{PaymentsResponseData, RefundsResponseData},
types,
};
use masking::{ExposeInterface, PeekInterface, Secret};
use crate::{
types::{PaymentsSessionResponseRouterData, RefundsResponseRouterData, ResponseRouterData},
utils::{
self, AddressDetailsData, ApplePay, CardData as _, ForeignTryFrom,
PaymentsAuthorizeRequestData, PaymentsCompleteAuthorizeRequestData, RouterData as _,
},
};
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/bluesnap/transformers.rs" role="context" start="727" end="741">
fn try_from(
item: &BluesnapRouterData<&types::PaymentsCaptureRouterData>,
) -> Result<Self, Self::Error> {
let card_transaction_type = BluesnapTxnType::Capture;
let transaction_id = item
.router_data
.request
.connector_transaction_id
.to_string();
Ok(Self {
card_transaction_type,
transaction_id,
amount: Some(item.amount.to_owned()),
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/bluesnap/transformers.rs" role="context" start="707" end="714">
fn try_from(item: &types::PaymentsCancelRouterData) -> Result<Self, Self::Error> {
let card_transaction_type = BluesnapTxnType::AuthReversal;
let transaction_id = item.request.connector_transaction_id.to_string();
Ok(Self {
card_transaction_type,
transaction_id,
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/bluesnap/transformers.rs" role="context" start="496" end="575">
fn foreign_try_from(
(item, apple_pay_amount): (
PaymentsSessionResponseRouterData<BluesnapWalletTokenResponse>,
StringMajorUnit,
),
) -> Result<Self, Self::Error> {
let response = &item.response;
let wallet_token = BASE64_ENGINE
.decode(response.wallet_token.clone().expose())
.change_context(errors::ConnectorError::ResponseHandlingFailed)?;
let session_response: NoThirdPartySdkSessionResponse = wallet_token
.parse_struct("NoThirdPartySdkSessionResponse")
.change_context(errors::ConnectorError::ParsingFailed)?;
let metadata = item.data.get_connector_meta()?.expose();
let applepay_metadata = metadata
.clone()
.parse_value::<ApplepayCombinedSessionTokenData>("ApplepayCombinedSessionTokenData")
.map(|combined_metadata| {
ApplepaySessionTokenMetadata::ApplePayCombined(combined_metadata.apple_pay_combined)
})
.or_else(|_| {
metadata
.parse_value::<ApplepaySessionTokenData>("ApplepaySessionTokenData")
.map(|old_metadata| {
ApplepaySessionTokenMetadata::ApplePay(old_metadata.apple_pay)
})
})
.change_context(errors::ConnectorError::ParsingFailed)?;
let (payment_request_data, session_token_data) = match applepay_metadata {
ApplepaySessionTokenMetadata::ApplePayCombined(_apple_pay_combined) => {
Err(errors::ConnectorError::FlowNotSupported {
flow: "apple pay combined".to_string(),
connector: "bluesnap".to_string(),
})
}
ApplepaySessionTokenMetadata::ApplePay(apple_pay) => {
Ok((apple_pay.payment_request_data, apple_pay.session_token_data))
}
}?;
Ok(Self {
response: Ok(PaymentsResponseData::SessionResponse {
session_token: SessionToken::ApplePay(Box::new(ApplepaySessionTokenResponse {
session_token_data: Some(ApplePaySessionResponse::NoThirdPartySdk(
session_response,
)),
payment_request_data: Some(ApplePayPaymentRequest {
country_code: item.data.get_billing_country()?,
currency_code: item.data.request.currency,
total: AmountInfo {
label: payment_request_data.label,
total_type: Some("final".to_string()),
amount: apple_pay_amount,
},
merchant_capabilities: Some(payment_request_data.merchant_capabilities),
supported_networks: Some(payment_request_data.supported_networks),
merchant_identifier: Some(session_token_data.merchant_identifier),
required_billing_contact_fields: None,
required_shipping_contact_fields: None,
recurring_payment_request: None,
}),
connector: "bluesnap".to_string(),
delayed_session_token: false,
sdk_next_action: {
SdkNextAction {
next_action: NextActionCall::Confirm,
}
},
connector_reference_id: None,
connector_sdk_public_key: None,
connector_merchant_id: None,
})),
}),
..item.data
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/bluesnap/transformers.rs" role="context" start="447" end="486">
fn try_from(item: &types::PaymentsSessionRouterData) -> Result<Self, Self::Error> {
let apple_pay_metadata = item.get_connector_meta()?.expose();
let applepay_metadata = apple_pay_metadata
.clone()
.parse_value::<ApplepayCombinedSessionTokenData>("ApplepayCombinedSessionTokenData")
.map(|combined_metadata| {
ApplepaySessionTokenMetadata::ApplePayCombined(combined_metadata.apple_pay_combined)
})
.or_else(|_| {
apple_pay_metadata
.parse_value::<ApplepaySessionTokenData>("ApplepaySessionTokenData")
.map(|old_metadata| {
ApplepaySessionTokenMetadata::ApplePay(old_metadata.apple_pay)
})
})
.change_context(errors::ConnectorError::ParsingFailed)?;
let session_token_data = match applepay_metadata {
ApplepaySessionTokenMetadata::ApplePay(apple_pay_data) => {
Ok(apple_pay_data.session_token_data)
}
ApplepaySessionTokenMetadata::ApplePayCombined(_apple_pay_combined_data) => {
Err(errors::ConnectorError::FlowNotSupported {
flow: "apple pay combined".to_string(),
connector: "bluesnap".to_string(),
})
}
}?;
let domain_name = session_token_data.initiative_context.ok_or(
errors::ConnectorError::MissingRequiredField {
field_name: "apple pay initiative_context",
},
)?;
Ok(Self {
wallet_type: "APPLE_PAY".to_string(),
validation_url: APPLEPAY_VALIDATION_URL.to_string().into(),
domain_name,
display_name: Some(session_token_data.display_name),
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/bluesnap/transformers.rs" role="context" start="1123" end="1133">
fn get_card_holder_info(
address: &AddressDetails,
email: Email,
) -> CustomResult<Option<BluesnapCardHolderInfo>, errors::ConnectorError> {
let first_name = address.get_first_name()?;
Ok(Some(BluesnapCardHolderInfo {
first_name: first_name.clone(),
last_name: address.get_last_name().unwrap_or(first_name).clone(),
email,
}))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/bluesnap/transformers.rs" role="context" start="1144" end="1156">
fn convert_metadata_to_request_metadata(metadata: Value) -> Vec<RequestMetadata> {
let hashmap: HashMap<Option<String>, Option<Value>> =
serde_json::from_str(&metadata.to_string()).unwrap_or(HashMap::new());
let mut vector = Vec::<RequestMetadata>::new();
for (key, value) in hashmap {
vector.push(RequestMetadata {
meta_key: key,
meta_value: value.map(|field_value| field_value.to_string()),
is_visible: Some(DISPLAY_METADATA.to_string()),
});
}
vector
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/bluesnap/transformers.rs" role="context" start="53" end="53">
type Error = error_stack::Report<errors::ConnectorError>;
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/bluesnap/transformers.rs" role="context" start="767" end="773">
pub enum BluesnapTxnType {
AuthOnly,
AuthCapture,
AuthReversal,
Capture,
Refund,
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/shift4/transformers.rs" role="context" start="684" end="699">
pub struct Token {
pub id: Secret<String>,
pub created: i64,
#[serde(rename = "objectType")]
pub object_type: String,
pub first6: String,
pub last4: String,
pub fingerprint: Secret<String>,
pub brand: String,
#[serde(rename = "type")]
pub token_type: String,
pub country: String,
pub used: bool,
#[serde(rename = "threeDSecureInfo")]
pub three_d_secure_info: ThreeDSecureInfo,
}
<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/utils.rs<|crate|> hyperswitch_connectors anchor=foreign_try_from kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/utils.rs" role="context" start="5080" end="5118">
fn foreign_try_from(value: String) -> Result<Self, Self::Error> {
let state_abbreviation_check =
StringExt::<Self>::parse_enum(value.clone(), "UkraineStatesAbbreviation");
match state_abbreviation_check {
Ok(state_abbreviation) => Ok(state_abbreviation),
Err(_) => match value.as_str() {
"Autonomous Republic of Crimea" => Ok(Self::AutonomousRepublicOfCrimea),
"Cherkasy Oblast" => Ok(Self::CherkasyOblast),
"Chernihiv Oblast" => Ok(Self::ChernihivOblast),
"Chernivtsi Oblast" => Ok(Self::ChernivtsiOblast),
"Dnipropetrovsk Oblast" => Ok(Self::DnipropetrovskOblast),
"Donetsk Oblast" => Ok(Self::DonetskOblast),
"Ivano-Frankivsk Oblast" => Ok(Self::IvanoFrankivskOblast),
"Kharkiv Oblast" => Ok(Self::KharkivOblast),
"Kherson Oblast" => Ok(Self::KhersonOblast),
"Khmelnytsky Oblast" => Ok(Self::KhmelnytskyOblast),
"Kiev" => Ok(Self::Kiev),
"Kirovohrad Oblast" => Ok(Self::KirovohradOblast),
"Kyiv Oblast" => Ok(Self::KyivOblast),
"Luhansk Oblast" => Ok(Self::LuhanskOblast),
"Lviv Oblast" => Ok(Self::LvivOblast),
"Mykolaiv Oblast" => Ok(Self::MykolaivOblast),
"Odessa Oblast" => Ok(Self::OdessaOblast),
"Rivne Oblast" => Ok(Self::RivneOblast),
"Sumy Oblast" => Ok(Self::SumyOblast),
"Ternopil Oblast" => Ok(Self::TernopilOblast),
"Vinnytsia Oblast" => Ok(Self::VinnytsiaOblast),
"Volyn Oblast" => Ok(Self::VolynOblast),
"Zakarpattia Oblast" => Ok(Self::ZakarpattiaOblast),
"Zaporizhzhya Oblast" => Ok(Self::ZaporizhzhyaOblast),
"Zhytomyr Oblast" => Ok(Self::ZhytomyrOblast),
_ => Err(errors::ConnectorError::InvalidDataFormat {
field_name: "address.state",
}
.into()),
},
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/utils.rs" role="context" start="5079" end="5079">
_ => Err(errors::ConnectorError::InvalidDataFormat {
field_name: "address.state",
}
.into()),
},
}
}
}
impl ForeignTryFrom<String> for UkraineStatesAbbreviation {
type Error = error_stack::Report<errors::ConnectorError>;
fn foreign_try_from(value: String) -> Result<Self, Self::Error> {
let state_abbreviation_check =
StringExt::<Self>::parse_enum(value.clone(), "UkraineStatesAbbreviation");
match state_abbreviation_check {
Ok(state_abbreviation) => Ok(state_abbreviation),
Err(_) => match value.as_str() {
"Autonomous Republic of Crimea" => Ok(Self::AutonomousRepublicOfCrimea),
"Cherkasy Oblast" => Ok(Self::CherkasyOblast),
"Chernihiv Oblast" => Ok(Self::ChernihivOblast),
"Chernivtsi Oblast" => Ok(Self::ChernivtsiOblast),
"Dnipropetrovsk Oblast" => Ok(Self::DnipropetrovskOblast),
"Donetsk Oblast" => Ok(Self::DonetskOblast),
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/utils.rs" role="context" start="5161" end="5198">
pub fn new_colored_from_data(
data: String,
hex_color: &str,
) -> Result<Self, error_stack::Report<common_utils::errors::QrCodeError>> {
let qr_code = qrcode::QrCode::new(data.as_bytes())
.change_context(common_utils::errors::QrCodeError::FailedToCreateQrCode)?;
let qrcode_image_buffer = qr_code.render::<Luma<u8>>().build();
let (width, height) = qrcode_image_buffer.dimensions();
let mut colored_image = ImageBuffer::new(width, height);
let rgb = Self::parse_hex_color(hex_color)?;
for (x, y, pixel) in qrcode_image_buffer.enumerate_pixels() {
let luminance = pixel.0[0];
let color = if luminance == 0 {
Rgba([rgb.0, rgb.1, rgb.2, 255])
} else {
Rgba([255, 255, 255, 255])
};
colored_image.put_pixel(x, y, color);
}
let qrcode_dynamic_image = DynamicImage::ImageRgba8(colored_image);
let mut image_bytes = std::io::Cursor::new(Vec::new());
qrcode_dynamic_image
.write_to(&mut image_bytes, ImageFormat::Png)
.change_context(common_utils::errors::QrCodeError::FailedToCreateQrCode)?;
let image_data_source = format!(
"{},{}",
QR_IMAGE_DATA_SOURCE_STRING,
BASE64_ENGINE.encode(image_bytes.get_ref())
);
Ok(Self {
data: image_data_source,
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/utils.rs" role="context" start="5137" end="5159">
pub fn new_from_data(
data: String,
) -> Result<Self, error_stack::Report<common_utils::errors::QrCodeError>> {
let qr_code = qrcode::QrCode::new(data.as_bytes())
.change_context(common_utils::errors::QrCodeError::FailedToCreateQrCode)?;
let qrcode_image_buffer = qr_code.render::<Luma<u8>>().build();
let qrcode_dynamic_image = DynamicImage::ImageLuma8(qrcode_image_buffer);
let mut image_bytes = std::io::BufWriter::new(std::io::Cursor::new(Vec::new()));
// Encodes qrcode_dynamic_image and write it to image_bytes
let _ = qrcode_dynamic_image.write_to(&mut image_bytes, ImageFormat::Png);
let image_data_source = format!(
"{},{}",
QR_IMAGE_DATA_SOURCE_STRING,
BASE64_ENGINE.encode(image_bytes.buffer())
);
Ok(Self {
data: image_data_source,
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/utils.rs" role="context" start="4849" end="5074">
fn foreign_try_from(value: String) -> Result<Self, Self::Error> {
let state_abbreviation_check =
StringExt::<Self>::parse_enum(value.clone(), "SloveniaStatesAbbreviation");
match state_abbreviation_check {
Ok(state_abbreviation) => Ok(state_abbreviation),
Err(_) => match value.as_str() {
"Ajdovščina Municipality" => Ok(Self::Ajdovščina),
"Ankaran Municipality" => Ok(Self::Ankaran),
"Beltinci Municipality" => Ok(Self::Beltinci),
"Benedikt Municipality" => Ok(Self::Benedikt),
"Bistrica ob Sotli Municipality" => Ok(Self::BistricaObSotli),
"Bled Municipality" => Ok(Self::Bled),
"Bloke Municipality" => Ok(Self::Bloke),
"Bohinj Municipality" => Ok(Self::Bohinj),
"Borovnica Municipality" => Ok(Self::Borovnica),
"Bovec Municipality" => Ok(Self::Bovec),
"Braslovče Municipality" => Ok(Self::Braslovče),
"Brda Municipality" => Ok(Self::Brda),
"Brezovica Municipality" => Ok(Self::Brezovica),
"Brežice Municipality" => Ok(Self::Brežice),
"Cankova Municipality" => Ok(Self::Cankova),
"Cerklje na Gorenjskem Municipality" => Ok(Self::CerkljeNaGorenjskem),
"Cerknica Municipality" => Ok(Self::Cerknica),
"Cerkno Municipality" => Ok(Self::Cerkno),
"Cerkvenjak Municipality" => Ok(Self::Cerkvenjak),
"City Municipality of Celje" => Ok(Self::CityMunicipalityOfCelje),
"City Municipality of Novo Mesto" => Ok(Self::CityMunicipalityOfNovoMesto),
"Destrnik Municipality" => Ok(Self::Destrnik),
"Divača Municipality" => Ok(Self::Divača),
"Dobje Municipality" => Ok(Self::Dobje),
"Dobrepolje Municipality" => Ok(Self::Dobrepolje),
"Dobrna Municipality" => Ok(Self::Dobrna),
"Dobrova–Polhov Gradec Municipality" => Ok(Self::DobrovaPolhovGradec),
"Dobrovnik Municipality" => Ok(Self::Dobrovnik),
"Dol pri Ljubljani Municipality" => Ok(Self::DolPriLjubljani),
"Dolenjske Toplice Municipality" => Ok(Self::DolenjskeToplice),
"Domžale Municipality" => Ok(Self::Domžale),
"Dornava Municipality" => Ok(Self::Dornava),
"Dravograd Municipality" => Ok(Self::Dravograd),
"Duplek Municipality" => Ok(Self::Duplek),
"Gorenja Vas–Poljane Municipality" => Ok(Self::GorenjaVasPoljane),
"Gorišnica Municipality" => Ok(Self::Gorišnica),
"Gorje Municipality" => Ok(Self::Gorje),
"Gornja Radgona Municipality" => Ok(Self::GornjaRadgona),
"Gornji Grad Municipality" => Ok(Self::GornjiGrad),
"Gornji Petrovci Municipality" => Ok(Self::GornjiPetrovci),
"Grad Municipality" => Ok(Self::Grad),
"Grosuplje Municipality" => Ok(Self::Grosuplje),
"Hajdina Municipality" => Ok(Self::Hajdina),
"Hodoš Municipality" => Ok(Self::Hodoš),
"Horjul Municipality" => Ok(Self::Horjul),
"Hoče–Slivnica Municipality" => Ok(Self::HočeSlivnica),
"Hrastnik Municipality" => Ok(Self::Hrastnik),
"Hrpelje–Kozina Municipality" => Ok(Self::HrpeljeKozina),
"Idrija Municipality" => Ok(Self::Idrija),
"Ig Municipality" => Ok(Self::Ig),
"Ivančna Gorica Municipality" => Ok(Self::IvančnaGorica),
"Izola Municipality" => Ok(Self::Izola),
"Jesenice Municipality" => Ok(Self::Jesenice),
"Jezersko Municipality" => Ok(Self::Jezersko),
"Juršinci Municipality" => Ok(Self::Jursinci),
"Kamnik Municipality" => Ok(Self::Kamnik),
"Kanal ob Soči Municipality" => Ok(Self::KanalObSoci),
"Kidričevo Municipality" => Ok(Self::Kidricevo),
"Kobarid Municipality" => Ok(Self::Kobarid),
"Kobilje Municipality" => Ok(Self::Kobilje),
"Komen Municipality" => Ok(Self::Komen),
"Komenda Municipality" => Ok(Self::Komenda),
"Koper City Municipality" => Ok(Self::Koper),
"Kostanjevica na Krki Municipality" => Ok(Self::KostanjevicaNaKrki),
"Kostel Municipality" => Ok(Self::Kostel),
"Kozje Municipality" => Ok(Self::Kozje),
"Kočevje Municipality" => Ok(Self::Kocevje),
"Kranj City Municipality" => Ok(Self::Kranj),
"Kranjska Gora Municipality" => Ok(Self::KranjskaGora),
"Križevci Municipality" => Ok(Self::Krizevci),
"Kungota" => Ok(Self::Kungota),
"Kuzma Municipality" => Ok(Self::Kuzma),
"Laško Municipality" => Ok(Self::Lasko),
"Lenart Municipality" => Ok(Self::Lenart),
"Lendava Municipality" => Ok(Self::Lendava),
"Litija Municipality" => Ok(Self::Litija),
"Ljubljana City Municipality" => Ok(Self::Ljubljana),
"Ljubno Municipality" => Ok(Self::Ljubno),
"Ljutomer Municipality" => Ok(Self::Ljutomer),
"Logatec Municipality" => Ok(Self::Logatec),
"Log–Dragomer Municipality" => Ok(Self::LogDragomer),
"Lovrenc na Pohorju Municipality" => Ok(Self::LovrencNaPohorju),
"Loška Dolina Municipality" => Ok(Self::LoskaDolina),
"Loški Potok Municipality" => Ok(Self::LoskiPotok),
"Lukovica Municipality" => Ok(Self::Lukovica),
"Luče Municipality" => Ok(Self::Luče),
"Majšperk Municipality" => Ok(Self::Majsperk),
"Makole Municipality" => Ok(Self::Makole),
"Maribor City Municipality" => Ok(Self::Maribor),
"Markovci Municipality" => Ok(Self::Markovci),
"Medvode Municipality" => Ok(Self::Medvode),
"Mengeš Municipality" => Ok(Self::Menges),
"Metlika Municipality" => Ok(Self::Metlika),
"Mežica Municipality" => Ok(Self::Mezica),
"Miklavž na Dravskem Polju Municipality" => Ok(Self::MiklavzNaDravskemPolju),
"Miren–Kostanjevica Municipality" => Ok(Self::MirenKostanjevica),
"Mirna Municipality" => Ok(Self::Mirna),
"Mirna Peč Municipality" => Ok(Self::MirnaPec),
"Mislinja Municipality" => Ok(Self::Mislinja),
"Mokronog–Trebelno Municipality" => Ok(Self::MokronogTrebelno),
"Moravske Toplice Municipality" => Ok(Self::MoravskeToplice),
"Moravče Municipality" => Ok(Self::Moravce),
"Mozirje Municipality" => Ok(Self::Mozirje),
"Municipality of Apače" => Ok(Self::Apače),
"Municipality of Cirkulane" => Ok(Self::Cirkulane),
"Municipality of Ilirska Bistrica" => Ok(Self::IlirskaBistrica),
"Municipality of Krško" => Ok(Self::Krsko),
"Municipality of Škofljica" => Ok(Self::Skofljica),
"Murska Sobota City Municipality" => Ok(Self::MurskaSobota),
"Muta Municipality" => Ok(Self::Muta),
"Naklo Municipality" => Ok(Self::Naklo),
"Nazarje Municipality" => Ok(Self::Nazarje),
"Nova Gorica City Municipality" => Ok(Self::NovaGorica),
"Odranci Municipality" => Ok(Self::Odranci),
"Oplotnica" => Ok(Self::Oplotnica),
"Ormož Municipality" => Ok(Self::Ormoz),
"Osilnica Municipality" => Ok(Self::Osilnica),
"Pesnica Municipality" => Ok(Self::Pesnica),
"Piran Municipality" => Ok(Self::Piran),
"Pivka Municipality" => Ok(Self::Pivka),
"Podlehnik Municipality" => Ok(Self::Podlehnik),
"Podvelka Municipality" => Ok(Self::Podvelka),
"Podčetrtek Municipality" => Ok(Self::Podcetrtek),
"Poljčane Municipality" => Ok(Self::Poljcane),
"Polzela Municipality" => Ok(Self::Polzela),
"Postojna Municipality" => Ok(Self::Postojna),
"Prebold Municipality" => Ok(Self::Prebold),
"Preddvor Municipality" => Ok(Self::Preddvor),
"Prevalje Municipality" => Ok(Self::Prevalje),
"Ptuj City Municipality" => Ok(Self::Ptuj),
"Puconci Municipality" => Ok(Self::Puconci),
"Radenci Municipality" => Ok(Self::Radenci),
"Radeče Municipality" => Ok(Self::Radece),
"Radlje ob Dravi Municipality" => Ok(Self::RadljeObDravi),
"Radovljica Municipality" => Ok(Self::Radovljica),
"Ravne na Koroškem Municipality" => Ok(Self::RavneNaKoroskem),
"Razkrižje Municipality" => Ok(Self::Razkrizje),
"Rače–Fram Municipality" => Ok(Self::RaceFram),
"Renče–Vogrsko Municipality" => Ok(Self::RenčeVogrsko),
"Rečica ob Savinji Municipality" => Ok(Self::RecicaObSavinji),
"Ribnica Municipality" => Ok(Self::Ribnica),
"Ribnica na Pohorju Municipality" => Ok(Self::RibnicaNaPohorju),
"Rogatec Municipality" => Ok(Self::Rogatec),
"Rogaška Slatina Municipality" => Ok(Self::RogaskaSlatina),
"Rogašovci Municipality" => Ok(Self::Rogasovci),
"Ruše Municipality" => Ok(Self::Ruse),
"Selnica ob Dravi Municipality" => Ok(Self::SelnicaObDravi),
"Semič Municipality" => Ok(Self::Semic),
"Sevnica Municipality" => Ok(Self::Sevnica),
"Sežana Municipality" => Ok(Self::Sezana),
"Slovenj Gradec City Municipality" => Ok(Self::SlovenjGradec),
"Slovenska Bistrica Municipality" => Ok(Self::SlovenskaBistrica),
"Slovenske Konjice Municipality" => Ok(Self::SlovenskeKonjice),
"Sodražica Municipality" => Ok(Self::Sodrazica),
"Solčava Municipality" => Ok(Self::Solcava),
"Središče ob Dravi" => Ok(Self::SredisceObDravi),
"Starše Municipality" => Ok(Self::Starse),
"Straža Municipality" => Ok(Self::Straza),
"Sveta Ana Municipality" => Ok(Self::SvetaAna),
"Sveta Trojica v Slovenskih Goricah Municipality" => Ok(Self::SvetaTrojica),
"Sveti Andraž v Slovenskih Goricah Municipality" => Ok(Self::SvetiAndraz),
"Sveti Jurij ob Ščavnici Municipality" => Ok(Self::SvetiJurijObScavnici),
"Sveti Jurij v Slovenskih Goricah Municipality" => {
Ok(Self::SvetiJurijVSlovenskihGoricah)
}
"Sveti Tomaž Municipality" => Ok(Self::SvetiTomaz),
"Tabor Municipality" => Ok(Self::Tabor),
"Tišina Municipality" => Ok(Self::Tišina),
"Tolmin Municipality" => Ok(Self::Tolmin),
"Trbovlje Municipality" => Ok(Self::Trbovlje),
"Trebnje Municipality" => Ok(Self::Trebnje),
"Trnovska Vas Municipality" => Ok(Self::TrnovskaVas),
"Trzin Municipality" => Ok(Self::Trzin),
"Tržič Municipality" => Ok(Self::Tržič),
"Turnišče Municipality" => Ok(Self::Turnišče),
"Velika Polana Municipality" => Ok(Self::VelikaPolana),
"Velike Lašče Municipality" => Ok(Self::VelikeLašče),
"Veržej Municipality" => Ok(Self::Veržej),
"Videm Municipality" => Ok(Self::Videm),
"Vipava Municipality" => Ok(Self::Vipava),
"Vitanje Municipality" => Ok(Self::Vitanje),
"Vodice Municipality" => Ok(Self::Vodice),
"Vojnik Municipality" => Ok(Self::Vojnik),
"Vransko Municipality" => Ok(Self::Vransko),
"Vrhnika Municipality" => Ok(Self::Vrhnika),
"Vuzenica Municipality" => Ok(Self::Vuzenica),
"Zagorje ob Savi Municipality" => Ok(Self::ZagorjeObSavi),
"Zavrč Municipality" => Ok(Self::Zavrč),
"Zreče Municipality" => Ok(Self::Zreče),
"Črenšovci Municipality" => Ok(Self::Črenšovci),
"Črna na Koroškem Municipality" => Ok(Self::ČrnaNaKoroškem),
"Črnomelj Municipality" => Ok(Self::Črnomelj),
"Šalovci Municipality" => Ok(Self::Šalovci),
"Šempeter–Vrtojba Municipality" => Ok(Self::ŠempeterVrtojba),
"Šentilj Municipality" => Ok(Self::Šentilj),
"Šentjernej Municipality" => Ok(Self::Šentjernej),
"Šentjur Municipality" => Ok(Self::Šentjur),
"Šentrupert Municipality" => Ok(Self::Šentrupert),
"Šenčur Municipality" => Ok(Self::Šenčur),
"Škocjan Municipality" => Ok(Self::Škocjan),
"Škofja Loka Municipality" => Ok(Self::ŠkofjaLoka),
"Šmarje pri Jelšah Municipality" => Ok(Self::ŠmarjePriJelšah),
"Šmarješke Toplice Municipality" => Ok(Self::ŠmarješkeToplice),
"Šmartno ob Paki Municipality" => Ok(Self::ŠmartnoObPaki),
"Šmartno pri Litiji Municipality" => Ok(Self::ŠmartnoPriLitiji),
"Šoštanj Municipality" => Ok(Self::Šoštanj),
"Štore Municipality" => Ok(Self::Štore),
"Žalec Municipality" => Ok(Self::Žalec),
"Železniki Municipality" => Ok(Self::Železniki),
"Žetale Municipality" => Ok(Self::Žetale),
"Žiri Municipality" => Ok(Self::Žiri),
"Žirovnica Municipality" => Ok(Self::Žirovnica),
"Žužemberk Municipality" => Ok(Self::Žužemberk),
_ => Err(errors::ConnectorError::InvalidDataFormat {
field_name: "address.state",
}
.into()),
},
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/utils.rs" role="context" start="4812" end="4844">
fn foreign_try_from(value: String) -> Result<Self, Self::Error> {
let state_abbreviation_check =
StringExt::<Self>::parse_enum(value.clone(), "SwedenStatesAbbreviation");
match state_abbreviation_check {
Ok(state_abbreviation) => Ok(state_abbreviation),
Err(_) => match value.as_str() {
"Blekinge" => Ok(Self::Blekinge),
"Dalarna County" => Ok(Self::DalarnaCounty),
"Gotland County" => Ok(Self::GotlandCounty),
"Gävleborg County" => Ok(Self::GävleborgCounty),
"Halland County" => Ok(Self::HallandCounty),
"Jönköping County" => Ok(Self::JönköpingCounty),
"Kalmar County" => Ok(Self::KalmarCounty),
"Kronoberg County" => Ok(Self::KronobergCounty),
"Norrbotten County" => Ok(Self::NorrbottenCounty),
"Skåne County" => Ok(Self::SkåneCounty),
"Stockholm County" => Ok(Self::StockholmCounty),
"Södermanland County" => Ok(Self::SödermanlandCounty),
"Uppsala County" => Ok(Self::UppsalaCounty),
"Värmland County" => Ok(Self::VärmlandCounty),
"Västerbotten County" => Ok(Self::VästerbottenCounty),
"Västernorrland County" => Ok(Self::VästernorrlandCounty),
"Västmanland County" => Ok(Self::VästmanlandCounty),
"Västra Götaland County" => Ok(Self::VästraGötalandCounty),
"Örebro County" => Ok(Self::ÖrebroCounty),
"Östergötland County" => Ok(Self::ÖstergötlandCounty),
_ => Err(errors::ConnectorError::InvalidDataFormat {
field_name: "address.state",
}
.into()),
},
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/utils.rs" role="context" start="755" end="767">
fn get_billing_state_code(&self) -> Result<Secret<String>, Error> {
let country = self.get_billing_country()?;
let state = self.get_billing_state()?;
match country {
api_models::enums::CountryAlpha2::US => Ok(Secret::new(
UsStatesAbbreviation::foreign_try_from(state.peek().to_string())?.to_string(),
)),
api_models::enums::CountryAlpha2::CA => Ok(Secret::new(
CanadaStatesAbbreviation::foreign_try_from(state.peek().to_string())?.to_string(),
)),
_ => Ok(state.clone()),
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/utils.rs" role="context" start="1398" end="1515">
fn to_state_code(&self) -> Result<Secret<String>, Error> {
let country = self.get_country()?;
let state = self.get_state()?;
match country {
api_models::enums::CountryAlpha2::US => Ok(Secret::new(
UsStatesAbbreviation::foreign_try_from(state.peek().to_string())?.to_string(),
)),
api_models::enums::CountryAlpha2::CA => Ok(Secret::new(
CanadaStatesAbbreviation::foreign_try_from(state.peek().to_string())?.to_string(),
)),
api_models::enums::CountryAlpha2::AL => Ok(Secret::new(
AlbaniaStatesAbbreviation::foreign_try_from(state.peek().to_string())?.to_string(),
)),
api_models::enums::CountryAlpha2::AD => Ok(Secret::new(
AndorraStatesAbbreviation::foreign_try_from(state.peek().to_string())?.to_string(),
)),
api_models::enums::CountryAlpha2::AT => Ok(Secret::new(
AustriaStatesAbbreviation::foreign_try_from(state.peek().to_string())?.to_string(),
)),
api_models::enums::CountryAlpha2::BY => Ok(Secret::new(
BelarusStatesAbbreviation::foreign_try_from(state.peek().to_string())?.to_string(),
)),
api_models::enums::CountryAlpha2::BA => Ok(Secret::new(
BosniaAndHerzegovinaStatesAbbreviation::foreign_try_from(state.peek().to_string())?
.to_string(),
)),
api_models::enums::CountryAlpha2::BG => Ok(Secret::new(
BulgariaStatesAbbreviation::foreign_try_from(state.peek().to_string())?.to_string(),
)),
api_models::enums::CountryAlpha2::HR => Ok(Secret::new(
CroatiaStatesAbbreviation::foreign_try_from(state.peek().to_string())?.to_string(),
)),
api_models::enums::CountryAlpha2::CZ => Ok(Secret::new(
CzechRepublicStatesAbbreviation::foreign_try_from(state.peek().to_string())?
.to_string(),
)),
api_models::enums::CountryAlpha2::DK => Ok(Secret::new(
DenmarkStatesAbbreviation::foreign_try_from(state.peek().to_string())?.to_string(),
)),
api_models::enums::CountryAlpha2::FI => Ok(Secret::new(
FinlandStatesAbbreviation::foreign_try_from(state.peek().to_string())?.to_string(),
)),
api_models::enums::CountryAlpha2::FR => Ok(Secret::new(
FranceStatesAbbreviation::foreign_try_from(state.peek().to_string())?.to_string(),
)),
api_models::enums::CountryAlpha2::DE => Ok(Secret::new(
GermanyStatesAbbreviation::foreign_try_from(state.peek().to_string())?.to_string(),
)),
api_models::enums::CountryAlpha2::GR => Ok(Secret::new(
GreeceStatesAbbreviation::foreign_try_from(state.peek().to_string())?.to_string(),
)),
api_models::enums::CountryAlpha2::HU => Ok(Secret::new(
HungaryStatesAbbreviation::foreign_try_from(state.peek().to_string())?.to_string(),
)),
api_models::enums::CountryAlpha2::IS => Ok(Secret::new(
IcelandStatesAbbreviation::foreign_try_from(state.peek().to_string())?.to_string(),
)),
api_models::enums::CountryAlpha2::IE => Ok(Secret::new(
IrelandStatesAbbreviation::foreign_try_from(state.peek().to_string())?.to_string(),
)),
api_models::enums::CountryAlpha2::LV => Ok(Secret::new(
LatviaStatesAbbreviation::foreign_try_from(state.peek().to_string())?.to_string(),
)),
api_models::enums::CountryAlpha2::IT => Ok(Secret::new(
ItalyStatesAbbreviation::foreign_try_from(state.peek().to_string())?.to_string(),
)),
api_models::enums::CountryAlpha2::LI => Ok(Secret::new(
LiechtensteinStatesAbbreviation::foreign_try_from(state.peek().to_string())?
.to_string(),
)),
api_models::enums::CountryAlpha2::LT => Ok(Secret::new(
LithuaniaStatesAbbreviation::foreign_try_from(state.peek().to_string())?
.to_string(),
)),
api_models::enums::CountryAlpha2::MT => Ok(Secret::new(
MaltaStatesAbbreviation::foreign_try_from(state.peek().to_string())?.to_string(),
)),
api_models::enums::CountryAlpha2::MD => Ok(Secret::new(
MoldovaStatesAbbreviation::foreign_try_from(state.peek().to_string())?.to_string(),
)),
api_models::enums::CountryAlpha2::MC => Ok(Secret::new(
MonacoStatesAbbreviation::foreign_try_from(state.peek().to_string())?.to_string(),
)),
api_models::enums::CountryAlpha2::ME => Ok(Secret::new(
MontenegroStatesAbbreviation::foreign_try_from(state.peek().to_string())?
.to_string(),
)),
api_models::enums::CountryAlpha2::NL => Ok(Secret::new(
NetherlandsStatesAbbreviation::foreign_try_from(state.peek().to_string())?
.to_string(),
)),
api_models::enums::CountryAlpha2::MK => Ok(Secret::new(
NorthMacedoniaStatesAbbreviation::foreign_try_from(state.peek().to_string())?
.to_string(),
)),
api_models::enums::CountryAlpha2::NO => Ok(Secret::new(
NorwayStatesAbbreviation::foreign_try_from(state.peek().to_string())?.to_string(),
)),
api_models::enums::CountryAlpha2::PL => Ok(Secret::new(
PolandStatesAbbreviation::foreign_try_from(state.peek().to_string())?.to_string(),
)),
api_models::enums::CountryAlpha2::PT => Ok(Secret::new(
PortugalStatesAbbreviation::foreign_try_from(state.peek().to_string())?.to_string(),
)),
api_models::enums::CountryAlpha2::ES => Ok(Secret::new(
SpainStatesAbbreviation::foreign_try_from(state.peek().to_string())?.to_string(),
)),
api_models::enums::CountryAlpha2::CH => Ok(Secret::new(
SwitzerlandStatesAbbreviation::foreign_try_from(state.peek().to_string())?
.to_string(),
)),
api_models::enums::CountryAlpha2::GB => Ok(Secret::new(
UnitedKingdomStatesAbbreviation::foreign_try_from(state.peek().to_string())?
.to_string(),
)),
_ => Ok(state.clone()),
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/utils.rs" role="context" start="5128" end="5130">
pub struct QrImage {
pub data: String,
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/utils.rs" role="context" start="5121" end="5125">
pub trait ForeignTryFrom<F>: Sized {
type Error;
fn foreign_try_from(from: F) -> Result<Self, Self::Error>;
}
<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="1549" end="1625">
fn try_from(
(item, paze_data): (
&CybersourceRouterData<&PaymentsAuthorizeRouterData>,
Box<hyperswitch_domain_models::router_data::PazeDecryptedData>,
),
) -> Result<Self, Self::Error> {
let email = item.router_data.request.get_email()?;
let (first_name, last_name) = match paze_data.billing_address.name {
Some(name) => {
let (first_name, last_name) = name
.peek()
.split_once(' ')
.map(|(first, last)| (first.to_string(), last.to_string()))
.ok_or(errors::ConnectorError::MissingRequiredField {
field_name: "billing_address.name",
})?;
(Secret::from(first_name), Secret::from(last_name))
}
None => (
item.router_data.get_billing_first_name()?,
item.router_data.get_billing_last_name()?,
),
};
let bill_to = BillTo {
first_name: Some(first_name),
last_name: Some(last_name),
address1: paze_data.billing_address.line1,
locality: paze_data.billing_address.city.map(|city| city.expose()),
administrative_area: Some(Secret::from(
//Paze wallet is currently supported in US only
common_enums::UsStatesAbbreviation::foreign_try_from(
paze_data
.billing_address
.state
.ok_or(errors::ConnectorError::MissingRequiredField {
field_name: "billing_address.state",
})?
.peek()
.to_owned(),
)?
.to_string(),
)),
postal_code: paze_data.billing_address.zip,
country: paze_data.billing_address.country_code,
email,
};
let order_information = OrderInformationWithBill::from((item, Some(bill_to)));
let payment_information =
PaymentInformation::NetworkToken(Box::new(NetworkTokenPaymentInformation {
tokenized_card: NetworkTokenizedCard {
number: paze_data.token.payment_token,
expiration_month: paze_data.token.token_expiration_month,
expiration_year: paze_data.token.token_expiration_year,
cryptogram: Some(paze_data.token.payment_account_reference),
transaction_type: "1".to_string(),
},
}));
let processing_information = ProcessingInformation::try_from((item, None, None))?;
let client_reference_information = ClientReferenceInformation::from(item);
let merchant_defined_information = item
.router_data
.request
.metadata
.clone()
.map(convert_metadata_to_merchant_defined_info);
Ok(Self {
processing_information,
payment_information,
order_information,
client_reference_information,
consumer_authentication_information: None,
merchant_defined_information,
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/cybersource/transformers.rs" role="context" start="1548" end="1548">
use common_enums::{enums, FutureUsage};
use hyperswitch_domain_models::{
address::{AddressDetails, PhoneDetails},
router_flow_types::PoFulfill,
router_response_types::PayoutsResponseData,
types::PayoutsRouterData,
};
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,
},
};
use masking::{ExposeInterface, PeekInterface, Secret};
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/cybersource/transformers.rs" role="context" start="1738" end="1802">
fn try_from(
(item, apple_pay_data, apple_pay_wallet_data): (
&CybersourceRouterData<&PaymentsAuthorizeRouterData>,
Box<ApplePayPredecryptData>,
ApplePayWalletData,
),
) -> Result<Self, Self::Error> {
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::from((item, Some(bill_to)));
let processing_information = ProcessingInformation::try_from((
item,
Some(PaymentSolution::ApplePay),
Some(apple_pay_wallet_data.payment_method.network.clone()),
))?;
let client_reference_information = ClientReferenceInformation::from(item);
let expiration_month = apple_pay_data.get_expiry_month()?;
let expiration_year = apple_pay_data.get_four_digit_expiry_year()?;
let payment_information =
PaymentInformation::ApplePay(Box::new(ApplePayPaymentInformation {
tokenized_card: TokenizedCard {
number: apple_pay_data.application_primary_account_number,
cryptogram: Some(apple_pay_data.payment_data.online_payment_cryptogram),
transaction_type: TransactionType::ApplePay,
expiration_year,
expiration_month,
},
}));
let merchant_defined_information = item
.router_data
.request
.metadata
.clone()
.map(convert_metadata_to_merchant_defined_info);
let ucaf_collection_indicator = match apple_pay_wallet_data
.payment_method
.network
.to_lowercase()
.as_str()
{
"mastercard" => Some("2".to_string()),
_ => None,
};
Ok(Self {
processing_information,
payment_information,
order_information,
client_reference_information,
consumer_authentication_information: Some(CybersourceConsumerAuthInformation {
ucaf_collection_indicator,
cavv: None,
ucaf_authentication_data: None,
xid: None,
directory_server_transaction_id: None,
specification_version: None,
pa_specification_version: None,
veres_enrolled: None,
eci_raw: None,
}),
merchant_defined_information,
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/cybersource/transformers.rs" role="context" start="1635" end="1727">
fn try_from(
(item, ccard): (
&CybersourceRouterData<&PaymentsCompleteAuthorizeRouterData>,
hyperswitch_domain_models::payment_method_data::Card,
),
) -> Result<Self, Self::Error> {
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::from((item, bill_to));
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);
let three_ds_info: CybersourceThreeDSMetadata = item
.router_data
.request
.connector_meta
.clone()
.ok_or(errors::ConnectorError::MissingRequiredField {
field_name: "connector_meta",
})?
.parse_value("CybersourceThreeDSMetadata")
.change_context(errors::ConnectorError::InvalidConnectorConfig {
config: "metadata",
})?;
let processing_information =
ProcessingInformation::try_from((item, None, &three_ds_info.three_ds_data))?;
let consumer_authentication_information = Some(CybersourceConsumerAuthInformation {
ucaf_collection_indicator: three_ds_info.three_ds_data.ucaf_collection_indicator,
cavv: three_ds_info.three_ds_data.cavv,
ucaf_authentication_data: three_ds_info.three_ds_data.ucaf_authentication_data,
xid: three_ds_info.three_ds_data.xid,
directory_server_transaction_id: three_ds_info
.three_ds_data
.directory_server_transaction_id,
specification_version: three_ds_info.three_ds_data.specification_version,
pa_specification_version: None,
veres_enrolled: None,
eci_raw: None,
});
let merchant_defined_information = item
.router_data
.request
.metadata
.clone()
.map(convert_metadata_to_merchant_defined_info);
Ok(Self {
processing_information,
payment_information,
order_information,
client_reference_information,
consumer_authentication_information,
merchant_defined_information,
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/cybersource/transformers.rs" role="context" start="1463" end="1539">
fn try_from(
(item, token_data): (
&CybersourceRouterData<&PaymentsAuthorizeRouterData>,
NetworkTokenData,
),
) -> Result<Self, Self::Error> {
let email = item.router_data.request.get_email()?;
let bill_to = build_bill_to(item.router_data.get_optional_billing(), email)?;
let order_information = OrderInformationWithBill::from((item, Some(bill_to)));
let card_issuer = token_data.get_card_issuer();
let card_type = match card_issuer {
Ok(issuer) => Some(String::from(issuer)),
Err(_) => None,
};
let payment_information =
PaymentInformation::NetworkToken(Box::new(NetworkTokenPaymentInformation {
tokenized_card: NetworkTokenizedCard {
number: token_data.get_network_token(),
expiration_month: token_data.get_network_token_expiry_month(),
expiration_year: token_data.get_network_token_expiry_year(),
cryptogram: token_data.get_cryptogram().clone(),
transaction_type: "1".to_string(),
},
}));
let processing_information = ProcessingInformation::try_from((item, None, card_type))?;
let client_reference_information = ClientReferenceInformation::from(item);
let merchant_defined_information = item
.router_data
.request
.metadata
.clone()
.map(convert_metadata_to_merchant_defined_info);
let consumer_authentication_information = item
.router_data
.request
.authentication_data
.as_ref()
.map(|authn_data| {
let (ucaf_authentication_data, cavv, ucaf_collection_indicator) =
if token_data.card_network == Some(common_enums::CardNetwork::Mastercard) {
(
Some(Secret::new(authn_data.cavv.clone())),
None,
Some("2".to_string()),
)
} else {
(None, Some(authn_data.cavv.clone()), None)
};
CybersourceConsumerAuthInformation {
ucaf_collection_indicator,
cavv,
ucaf_authentication_data,
xid: None,
directory_server_transaction_id: authn_data
.ds_trans_id
.clone()
.map(Secret::new),
specification_version: None,
pa_specification_version: authn_data.message_version.clone(),
veres_enrolled: Some("Y".to_string()),
eci_raw: authn_data.eci.clone(),
}
});
Ok(Self {
processing_information,
payment_information,
order_information,
client_reference_information,
consumer_authentication_information,
merchant_defined_information,
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/cybersource/transformers.rs" role="context" start="1362" end="1453">
fn try_from(
(item, ccard): (
&CybersourceRouterData<&PaymentsAuthorizeRouterData>,
hyperswitch_domain_models::payment_method_data::CardDetailsForNetworkTransactionId,
),
) -> Result<Self, Self::Error> {
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::from((item, Some(bill_to)));
let card_issuer = ccard.get_card_issuer();
let card_type = match card_issuer {
Ok(issuer) => Some(String::from(issuer)),
Err(_) => None,
};
let 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: None,
card_type: card_type.clone(),
type_selection_indicator,
},
}));
let processing_information = ProcessingInformation::try_from((item, None, card_type))?;
let client_reference_information = ClientReferenceInformation::from(item);
let merchant_defined_information = item
.router_data
.request
.metadata
.clone()
.map(convert_metadata_to_merchant_defined_info);
let consumer_authentication_information = item
.router_data
.request
.authentication_data
.as_ref()
.map(|authn_data| {
let (ucaf_authentication_data, cavv, ucaf_collection_indicator) =
if ccard.card_network == Some(common_enums::CardNetwork::Mastercard) {
(
Some(Secret::new(authn_data.cavv.clone())),
None,
Some("2".to_string()),
)
} else {
(None, Some(authn_data.cavv.clone()), None)
};
CybersourceConsumerAuthInformation {
ucaf_collection_indicator,
cavv,
ucaf_authentication_data,
xid: None,
directory_server_transaction_id: authn_data
.ds_trans_id
.clone()
.map(Secret::new),
specification_version: None,
pa_specification_version: authn_data.message_version.clone(),
veres_enrolled: Some("Y".to_string()),
eci_raw: authn_data.eci.clone(),
}
});
Ok(Self {
processing_information,
payment_information,
order_information,
client_reference_information,
consumer_authentication_information,
merchant_defined_information,
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/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="2691" end="2693">
pub struct ClientReferenceInformation {
code: Option<String>,
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/authorizedotnet/transformers.rs" role="context" start="220" end="228">
pub struct BillTo {
first_name: Option<Secret<String>>,
last_name: Option<Secret<String>>,
address: Option<Secret<String>>,
city: Option<String>,
state: Option<Secret<String>>,
zip: Option<Secret<String>>,
country: Option<enums::CountryAlpha2>,
}
| symbol_neighborhood |
<|meta_start|><|file|> hyperswitch/crates/hyperswitch_connectors/src/connectors/iatapay/transformers.rs<|crate|> hyperswitch_connectors<|connector|> iatapay anchor=get_iatpay_response kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/iatapay/transformers.rs" role="context" start="321" end="412">
fn get_iatpay_response(
response: IatapayPaymentsResponse,
status_code: u16,
) -> CustomResult<
(
enums::AttemptStatus,
Option<ErrorResponse>,
PaymentsResponseData,
),
errors::ConnectorError,
> {
let status = enums::AttemptStatus::from(response.status);
let error = if is_payment_failure(status) {
Some(ErrorResponse {
code: response
.failure_code
.unwrap_or_else(|| NO_ERROR_CODE.to_string()),
message: response
.failure_details
.clone()
.unwrap_or_else(|| NO_ERROR_MESSAGE.to_string()),
reason: response.failure_details,
status_code,
attempt_status: Some(status),
connector_transaction_id: response.iata_payment_id.clone(),
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
})
} else {
None
};
let form_fields = HashMap::new();
let id = match response.iata_payment_id.clone() {
Some(s) => ResponseId::ConnectorTransactionId(s),
None => ResponseId::NoResponseId,
};
let connector_response_reference_id = response.merchant_payment_id.or(response.iata_payment_id);
let payment_response_data = match response.checkout_methods {
Some(checkout_methods) => {
let (connector_metadata, redirection_data) =
match checkout_methods.redirect.redirect_url.ends_with("qr") {
true => {
let qr_code_info = api_models::payments::FetchQrCodeInformation {
qr_code_fetch_url: url::Url::parse(
&checkout_methods.redirect.redirect_url,
)
.change_context(errors::ConnectorError::ResponseHandlingFailed)?,
};
(
Some(qr_code_info.encode_to_value())
.transpose()
.change_context(errors::ConnectorError::ResponseHandlingFailed)?,
None,
)
}
false => (
None,
Some(RedirectForm::Form {
endpoint: checkout_methods.redirect.redirect_url,
method: Method::Get,
form_fields,
}),
),
};
PaymentsResponseData::TransactionResponse {
resource_id: id,
redirection_data: Box::new(redirection_data),
mandate_reference: Box::new(None),
connector_metadata,
network_txn_id: None,
connector_response_reference_id: connector_response_reference_id.clone(),
incremental_authorization_allowed: None,
charges: None,
}
}
None => PaymentsResponseData::TransactionResponse {
resource_id: id.clone(),
redirection_data: Box::new(None),
mandate_reference: Box::new(None),
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: connector_response_reference_id.clone(),
incremental_authorization_allowed: None,
charges: None,
},
};
Ok((status, error, payment_response_data))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/iatapay/transformers.rs" role="context" start="320" end="320">
use common_enums::enums;
use common_utils::{
errors::CustomResult, ext_traits::Encode, request::Method, types::FloatMajorUnit,
};
use hyperswitch_domain_models::{
payment_method_data::{BankRedirectData, PaymentMethodData, RealTimePaymentData, UpiData},
router_data::{AccessToken, ConnectorAuthType, ErrorResponse, RouterData},
router_flow_types::{
refunds::{Execute, RSync},
Authorize,
},
router_request_types::{PaymentsAuthorizeData, ResponseId},
router_response_types::{PaymentsResponseData, RedirectForm, RefundsResponseData},
types::{self, RefundsRouterData},
};
use hyperswitch_interfaces::{
consts::{NO_ERROR_CODE, NO_ERROR_MESSAGE},
errors,
};
use crate::{
types::{RefundsResponseRouterData, ResponseRouterData},
utils::{
get_unimplemented_payment_method_error_message, is_payment_failure, is_refund_failure,
PaymentsAuthorizeRequestData, RefundsRequestData,
},
};
type Error = error_stack::Report<errors::ConnectorError>;
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/iatapay/transformers.rs" role="context" start="446" end="456">
fn try_from(item: &IatapayRouterData<&RefundsRouterData<F>>) -> Result<Self, Self::Error> {
Ok(Self {
amount: item.amount,
merchant_id: IatapayAuthType::try_from(&item.router_data.connector_auth_type)?
.merchant_id,
merchant_refund_id: Some(item.router_data.request.refund_id.clone()),
currency: item.router_data.request.currency.to_string(),
bank_transfer_description: item.router_data.request.reason.clone(),
notification_url: item.router_data.request.get_webhook_url()?,
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/iatapay/transformers.rs" role="context" start="418" end="428">
fn try_from(
item: ResponseRouterData<F, IatapayPaymentsResponse, T, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
let (status, error, payment_response_data) =
get_iatpay_response(item.response, item.http_code)?;
Ok(Self {
status,
response: error.map_or_else(|| Ok(payment_response_data), Err),
..item.data
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/iatapay/transformers.rs" role="context" start="283" end="292">
fn from(item: IatapayPaymentStatus) -> Self {
match item {
IatapayPaymentStatus::Authorized
| IatapayPaymentStatus::Settled
| IatapayPaymentStatus::Cleared => Self::Charged,
IatapayPaymentStatus::Failed | IatapayPaymentStatus::UnexpectedSettled => Self::Failure,
IatapayPaymentStatus::Created => Self::AuthenticationPending,
IatapayPaymentStatus::Initiated => Self::Pending,
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/iatapay/transformers.rs" role="context" start="252" end="265">
fn try_from(auth_type: &ConnectorAuthType) -> Result<Self, Self::Error> {
match auth_type {
ConnectorAuthType::SignatureKey {
api_key,
key1,
api_secret,
} => Ok(Self {
client_id: api_key.to_owned(),
merchant_id: key1.to_owned(),
client_secret: api_secret.to_owned(),
}),
_ => Err(errors::ConnectorError::FailedToObtainAuthType)?,
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/iatapay/transformers.rs" role="context" start="476" end="486">
fn from(item: RefundStatus) -> Self {
match item {
RefundStatus::Created => Self::Pending,
RefundStatus::Failed => Self::Failure,
RefundStatus::Locked => Self::Pending,
RefundStatus::Initiated => Self::Pending,
RefundStatus::Authorized => Self::Pending,
RefundStatus::Settled => Self::Success,
RefundStatus::Cleared => Self::Success,
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/iatapay/transformers.rs" role="context" start="308" end="319">
pub struct IatapayPaymentsResponse {
pub status: IatapayPaymentStatus,
pub iata_payment_id: Option<String>,
pub iata_refund_id: Option<String>,
pub merchant_id: Option<Secret<String>>,
pub merchant_payment_id: Option<String>,
pub amount: FloatMajorUnit,
pub currency: String,
pub checkout_methods: Option<CheckoutMethod>,
pub failure_code: Option<String>,
pub failure_details: Option<String>,
}
<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/volt/transformers.rs<|crate|> hyperswitch_connectors<|connector|> volt 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/volt/transformers.rs" role="context" start="340" end="425">
fn try_from(
item: ResponseRouterData<F, VoltPaymentsResponseData, T, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
match item.response {
VoltPaymentsResponseData::PsyncResponse(payment_response) => {
let status =
get_attempt_status((payment_response.status.clone(), item.data.status));
Ok(Self {
status,
response: if is_payment_failure(status) {
Err(ErrorResponse {
code: payment_response.status.clone().to_string(),
message: payment_response.status.clone().to_string(),
reason: Some(payment_response.status.to_string()),
status_code: item.http_code,
attempt_status: None,
connector_transaction_id: Some(payment_response.id),
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
})
} else {
Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(
payment_response.id.clone(),
),
redirection_data: Box::new(None),
mandate_reference: Box::new(None),
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: payment_response
.merchant_internal_reference
.or(Some(payment_response.id)),
incremental_authorization_allowed: None,
charges: None,
})
},
..item.data
})
}
VoltPaymentsResponseData::WebhookResponse(webhook_response) => {
let detailed_status = webhook_response.detailed_status.clone();
let status = enums::AttemptStatus::from(webhook_response.status);
Ok(Self {
status,
response: if is_payment_failure(status) {
Err(ErrorResponse {
code: detailed_status
.clone()
.map(|volt_status| volt_status.to_string())
.unwrap_or_else(|| consts::NO_ERROR_CODE.to_owned()),
message: detailed_status
.clone()
.map(|volt_status| volt_status.to_string())
.unwrap_or_else(|| consts::NO_ERROR_MESSAGE.to_owned()),
reason: detailed_status
.clone()
.map(|volt_status| volt_status.to_string()),
status_code: item.http_code,
attempt_status: None,
connector_transaction_id: Some(webhook_response.payment.clone()),
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
})
} else {
Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(
webhook_response.payment.clone(),
),
redirection_data: Box::new(None),
mandate_reference: Box::new(None),
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: webhook_response
.merchant_internal_reference
.or(Some(webhook_response.payment)),
incremental_authorization_allowed: None,
charges: None,
})
},
..item.data
})
}
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/volt/transformers.rs" role="context" start="339" end="339">
use common_enums::enums;
use hyperswitch_domain_models::{
payment_method_data::{BankRedirectData, PaymentMethodData},
router_data::{AccessToken, ConnectorAuthType, ErrorResponse, RouterData},
router_flow_types::refunds::Execute,
router_request_types::ResponseId,
router_response_types::{PaymentsResponseData, RedirectForm, RefundsResponseData},
types,
};
use crate::{
types::{RefreshTokenRouterData, RefundsResponseRouterData, ResponseRouterData},
utils::{self, is_payment_failure, AddressDetailsData, RouterData as _},
};
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/volt/transformers.rs" role="context" start="452" end="457">
fn try_from(item: &VoltRouterData<&types::RefundsRouterData<F>>) -> Result<Self, Self::Error> {
Ok(Self {
amount: item.amount,
external_reference: item.router_data.request.refund_id.clone(),
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/volt/transformers.rs" role="context" start="428" end="438">
fn from(status: VoltWebhookPaymentStatus) -> Self {
match status {
VoltWebhookPaymentStatus::Received => Self::Charged,
VoltWebhookPaymentStatus::Failed | VoltWebhookPaymentStatus::NotReceived => {
Self::Failure
}
VoltWebhookPaymentStatus::Completed | VoltWebhookPaymentStatus::Pending => {
Self::Pending
}
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/volt/transformers.rs" role="context" start="274" end="297">
fn try_from(
item: ResponseRouterData<F, VoltPaymentsResponse, T, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
let url = item.response.checkout_url;
let redirection_data = Some(RedirectForm::Form {
endpoint: url,
method: Method::Get,
form_fields: Default::default(),
});
Ok(Self {
status: enums::AttemptStatus::AuthenticationPending,
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/volt/transformers.rs" role="context" start="239" end="261">
fn get_attempt_status(
(item, current_status): (VoltPaymentStatus, enums::AttemptStatus),
) -> enums::AttemptStatus {
match item {
VoltPaymentStatus::Received | VoltPaymentStatus::Settled => enums::AttemptStatus::Charged,
VoltPaymentStatus::Completed | VoltPaymentStatus::DelayedAtBank => {
enums::AttemptStatus::Pending
}
VoltPaymentStatus::NewPayment
| VoltPaymentStatus::BankRedirect
| VoltPaymentStatus::AwaitingCheckoutAuthorisation => {
enums::AttemptStatus::AuthenticationPending
}
VoltPaymentStatus::RefusedByBank
| VoltPaymentStatus::RefusedByRisk
| VoltPaymentStatus::NotReceived
| VoltPaymentStatus::ErrorAtBank
| VoltPaymentStatus::CancelledByUser
| VoltPaymentStatus::AbandonedByUser
| VoltPaymentStatus::Failed => enums::AttemptStatus::Failure,
VoltPaymentStatus::Unknown => current_status,
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/volt/transformers.rs" role="context" start="584" end="600">
fn from(status: VoltWebhookBodyEventType) -> Self {
match status {
VoltWebhookBodyEventType::Payment(payment_data) => match payment_data.status {
VoltWebhookPaymentStatus::Received => Self::PaymentIntentSuccess,
VoltWebhookPaymentStatus::Failed | VoltWebhookPaymentStatus::NotReceived => {
Self::PaymentIntentFailure
}
VoltWebhookPaymentStatus::Completed | VoltWebhookPaymentStatus::Pending => {
Self::PaymentIntentProcessing
}
},
VoltWebhookBodyEventType::Refund(refund_data) => match refund_data.status {
VoltWebhookRefundsStatus::RefundConfirmed => Self::RefundSuccess,
VoltWebhookRefundsStatus::RefundFailed => Self::RefundFailure,
},
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/volt/transformers.rs" role="context" start="499" end="503">
pub enum WebhookResponse {
// the enum order shouldn't be changed as this is being used during serialization and deserialization
Refund(VoltRefundWebhookBodyReference),
Payment(VoltPaymentWebhookBodyReference),
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/volt/transformers.rs" role="context" start="76" end="76">
type Error = error_stack::Report<errors::ConnectorError>;
<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/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="1750" end="1838">
fn try_from(
item: ResponseRouterData<F, RedsysSyncResponse, PaymentsSyncData, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
let message_data = item
.response
.body
.consultaoperacionesresponse
.consultaoperacionesreturn
.messages
.version
.message;
let (status, response) = match (message_data.response, message_data.errormsg) {
(Some(response), None) => {
if let Some(ds_response) = response.ds_response {
let status = get_redsys_attempt_status(
ds_response.clone(),
item.data.request.capture_method,
)?;
if connector_utils::is_payment_failure(status) {
let payment_response = Err(ErrorResponse {
status_code: item.http_code,
code: ds_response.0.clone(),
message: ds_response.0.clone(),
reason: Some(ds_response.0.clone()),
attempt_status: None,
connector_transaction_id: None,
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
});
(status, payment_response)
} else {
let payment_response = Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(
response.ds_order.clone(),
),
redirection_data: Box::new(None),
mandate_reference: Box::new(None),
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: Some(response.ds_order.clone()),
incremental_authorization_allowed: None,
charges: None,
});
(status, payment_response)
}
} else {
// When the payment is in authentication or still processing
let payment_response = Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(response.ds_order.clone()),
redirection_data: Box::new(None),
mandate_reference: Box::new(None),
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: Some(response.ds_order.clone()),
incremental_authorization_allowed: None,
charges: None,
});
(item.data.status, payment_response)
}
}
(None, Some(errormsg)) => {
let error_code = errormsg.ds_errorcode.clone();
let response = Err(ErrorResponse {
code: error_code.clone(),
message: error_code.clone(),
reason: Some(error_code),
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.status, response)
}
(Some(_), Some(_)) | (None, None) => {
Err(errors::ConnectorError::ResponseHandlingFailed)?
}
};
Ok(Self {
status,
response,
..item.data
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/redsys/transformers.rs" role="context" start="1749" end="1749">
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="1850" end="1915">
fn try_from(
item: RefundsResponseRouterData<RSync, RedsysSyncResponse>,
) -> Result<Self, Self::Error> {
let message_data = item
.response
.body
.consultaoperacionesresponse
.consultaoperacionesreturn
.messages
.version
.message;
let response = match (message_data.response, message_data.errormsg) {
(None, Some(errormsg)) => {
let error_code = errormsg.ds_errorcode.clone();
Err(ErrorResponse {
code: error_code.clone(),
message: error_code.clone(),
reason: Some(error_code),
status_code: item.http_code,
attempt_status: None,
connector_transaction_id: None,
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
})
}
(Some(response), None) => {
if let Some(ds_response) = response.ds_response {
let refund_status = enums::RefundStatus::try_from(ds_response.clone())?;
if connector_utils::is_refund_failure(refund_status) {
Err(ErrorResponse {
status_code: item.http_code,
code: ds_response.0.clone(),
message: ds_response.0.clone(),
reason: Some(ds_response.0.clone()),
attempt_status: None,
connector_transaction_id: None,
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
})
} else {
Ok(RefundsResponseData {
connector_refund_id: response.ds_order,
refund_status,
})
}
} else {
// When the refund is pending
Ok(RefundsResponseData {
connector_refund_id: response.ds_order,
refund_status: enums::RefundStatus::Pending,
})
}
}
(Some(_), Some(_)) | (None, None) => {
Err(errors::ConnectorError::ResponseHandlingFailed)?
}
};
Ok(Self {
response,
..item.data
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/redsys/transformers.rs" role="context" start="1841" end="1846">
pub fn build_refund_sync_request(item: &RefundSyncRouterData) -> Result<Vec<u8>, Error> {
let transaction_type = transaction_type::REFUND.to_owned();
let auth = RedsysAuthType::try_from(&item.connector_auth_type)?;
let connector_transaction_id = item.request.connector_transaction_id.clone();
construct_sync_request(connector_transaction_id, transaction_type, auth)
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/redsys/transformers.rs" role="context" start="1654" end="1663">
pub fn build_payment_sync_request(item: &PaymentsSyncRouterData) -> Result<Vec<u8>, Error> {
let transaction_type = get_transaction_type(item.status, item.request.capture_method)?;
let auth = RedsysAuthType::try_from(&item.connector_auth_type)?;
let connector_transaction_id = item
.request
.connector_transaction_id
.get_connector_transaction_id()
.change_context(errors::ConnectorError::MissingConnectorTransactionID)?;
construct_sync_request(connector_transaction_id, transaction_type, auth)
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/redsys/transformers.rs" role="context" start="1613" end="1652">
fn construct_sync_request(
order_id: String,
transaction_type: String,
auth: RedsysAuthType,
) -> Result<Vec<u8>, Error> {
let transaction_data = RedsysSyncRequest {
ds_merchant_code: auth.merchant_id,
ds_terminal: auth.terminal_id,
ds_transaction_type: transaction_type,
ds_order: order_id.clone(),
};
let version = VersionData {
ds_version: DS_VERSION.to_owned(),
message: Message {
transaction: transaction_data,
},
};
let version_data = quick_xml::se::to_string(&version)
.change_context(errors::ConnectorError::RequestEncodingFailed)?;
let signature = get_signature(&order_id, &version_data, auth.sha256_pwd.peek())?;
let messages = Messages {
version,
signature,
signature_version: SIGNATURE_VERSION.to_owned(),
};
let cdata = quick_xml::se::to_string(&messages)
.change_context(errors::ConnectorError::RequestEncodingFailed)?;
let body = format!(
r#"<soapenv:Envelope xmlns:soapenv="{}" xmlns:web="{}"><soapenv:Header/><soapenv:Body><web:consultaOperaciones><cadenaXML><![CDATA[{}]]></cadenaXML></web:consultaOperaciones></soapenv:Body></soapenv:Envelope>"#,
common_utils::consts::SOAP_ENV_NAMESPACE,
XMLNS_WEB_URL,
cdata
);
Ok(body.as_bytes().to_vec())
}
<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="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="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="1667" end="1680">
pub struct RedsysSyncResponse {
#[serde(rename = "@xmlns:soapenv")]
xmlns_soapenv: String,
#[serde(rename = "@xmlns:soapenc")]
xmlns_soapenc: String,
#[serde(rename = "@xmlns:xsd")]
xmlns_xsd: String,
#[serde(rename = "@xmlns:xsi")]
xmlns_xsi: String,
#[serde(rename = "header")]
header: Option<SoapHeader>,
#[serde(rename = "body")]
body: SyncResponseBody,
}
<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/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="687" end="766">
fn try_from(
(item, network_trans_id): (
&AuthorizedotnetRouterData<&PaymentsAuthorizeRouterData>,
String,
),
) -> Result<Self, Self::Error> {
Ok(Self {
transaction_type: TransactionType::try_from(item.router_data.request.capture_method)?,
amount: item.amount,
currency_code: item.router_data.request.currency,
payment: Some(match item.router_data.request.payment_method_data {
PaymentMethodData::Card(ref ccard) => {
PaymentDetails::CreditCard(CreditCardDetails {
card_number: (*ccard.card_number).clone(),
expiration_date: ccard.get_expiry_date_as_yyyymm("-"),
card_code: None,
})
}
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(
utils::get_unimplemented_payment_method_error_message("authorizedotnet"),
))?
}
}),
profile: None,
order: Order {
description: item.router_data.connector_request_reference_id.clone(),
},
customer: None,
bill_to: item
.router_data
.get_optional_billing()
.and_then(|billing_address| billing_address.address.as_ref())
.map(|address| BillTo {
first_name: address.first_name.clone(),
last_name: address.last_name.clone(),
address: address.line1.clone(),
city: address.city.clone(),
state: address.state.clone(),
zip: address.zip.clone(),
country: address.country,
}),
user_fields: match item.router_data.request.metadata.clone() {
Some(metadata) => Some(UserFields {
user_field: Vec::<UserField>::foreign_try_from(metadata)?,
}),
None => None,
},
processing_options: Some(ProcessingOptions {
is_subsequent_auth: true,
}),
subsequent_auth_information: Some(SubsequentAuthInformation {
original_network_trans_id: Secret::new(network_trans_id),
reason: Reason::Resubmission,
}),
authorization_indicator_type: match item.router_data.request.capture_method {
Some(capture_method) => Some(AuthorizationIndicator {
authorization_indicator: capture_method.try_into()?,
}),
None => None,
},
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/authorizedotnet/transformers.rs" role="context" start="686" end="686">
use common_utils::{
errors::CustomResult,
ext_traits::{Encode, OptionExt, ValueExt},
request::Method,
};
use hyperswitch_domain_models::{
payment_method_data::{Card, PaymentMethodData, WalletData},
router_data::{ConnectorAuthType, ErrorResponse, RouterData},
router_flow_types::RSync,
router_request_types::ResponseId,
router_response_types::{
MandateReference, PaymentsResponseData, RedirectForm, RefundsResponseData,
},
types::{
PaymentsAuthorizeRouterData, PaymentsCancelRouterData, PaymentsCaptureRouterData,
PaymentsCompleteAuthorizeRouterData, PaymentsSyncRouterData, RefundsRouterData,
SetupMandateRouterData,
},
};
use masking::{ExposeInterface, PeekInterface, Secret, StrongSecret};
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="832" end="898">
fn try_from(
(item, ccard): (
&AuthorizedotnetRouterData<&PaymentsAuthorizeRouterData>,
&Card,
),
) -> Result<Self, Self::Error> {
let (profile, customer) = if item.router_data.request.is_mandate_payment() {
(
Some(ProfileDetails::CreateProfileDetails(CreateProfileDetails {
create_profile: true,
})),
Some(CustomerDetails {
//The payment ID is included in the customer details because the connector requires unique customer information with a length of fewer than 20 characters when creating a mandate.
//If the length exceeds 20 characters, a random alphanumeric string is used instead.
id: if item.router_data.payment_id.len() <= 20 {
item.router_data.payment_id.clone()
} else {
Alphanumeric.sample_string(&mut rand::thread_rng(), 20)
},
}),
)
} else {
(None, None)
};
Ok(Self {
transaction_type: TransactionType::try_from(item.router_data.request.capture_method)?,
amount: item.amount,
currency_code: item.router_data.request.currency,
payment: Some(PaymentDetails::CreditCard(CreditCardDetails {
card_number: (*ccard.card_number).clone(),
expiration_date: ccard.get_expiry_date_as_yyyymm("-"),
card_code: Some(ccard.card_cvc.clone()),
})),
profile,
order: Order {
description: item.router_data.connector_request_reference_id.clone(),
},
customer,
bill_to: item
.router_data
.get_optional_billing()
.and_then(|billing_address| billing_address.address.as_ref())
.map(|address| BillTo {
first_name: address.first_name.clone(),
last_name: address.last_name.clone(),
address: address.line1.clone(),
city: address.city.clone(),
state: address.state.clone(),
zip: address.zip.clone(),
country: address.country,
}),
user_fields: match item.router_data.request.metadata.clone() {
Some(metadata) => Some(UserFields {
user_field: Vec::<UserField>::foreign_try_from(metadata)?,
}),
None => None,
},
processing_options: None,
subsequent_auth_information: None,
authorization_indicator_type: match item.router_data.request.capture_method {
Some(capture_method) => Some(AuthorizationIndicator {
authorization_indicator: capture_method.try_into()?,
}),
None => None,
},
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/authorizedotnet/transformers.rs" role="context" start="776" end="822">
fn try_from(
(item, connector_mandate_id): (
&AuthorizedotnetRouterData<&PaymentsAuthorizeRouterData>,
api_models::payments::ConnectorMandateReferenceId,
),
) -> Result<Self, Self::Error> {
let mandate_id = connector_mandate_id
.get_connector_mandate_id()
.ok_or(errors::ConnectorError::MissingConnectorMandateID)?;
Ok(Self {
transaction_type: TransactionType::try_from(item.router_data.request.capture_method)?,
amount: item.amount,
currency_code: item.router_data.request.currency,
payment: None,
profile: mandate_id
.split_once('-')
.map(|(customer_profile_id, payment_profile_id)| {
ProfileDetails::CustomerProfileDetails(CustomerProfileDetails {
customer_profile_id: Secret::from(customer_profile_id.to_string()),
payment_profile: PaymentProfileDetails {
payment_profile_id: Secret::from(payment_profile_id.to_string()),
},
})
}),
order: Order {
description: item.router_data.connector_request_reference_id.clone(),
},
customer: None,
bill_to: None,
user_fields: match item.router_data.request.metadata.clone() {
Some(metadata) => Some(UserFields {
user_field: Vec::<UserField>::foreign_try_from(metadata)?,
}),
None => None,
},
processing_options: Some(ProcessingOptions {
is_subsequent_auth: true,
}),
subsequent_auth_information: None,
authorization_indicator_type: match item.router_data.request.capture_method {
Some(capture_method) => Some(AuthorizationIndicator {
authorization_indicator: capture_method.try_into()?,
}),
None => None,
},
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/authorizedotnet/transformers.rs" role="context" start="608" end="677">
fn try_from(
item: &AuthorizedotnetRouterData<&PaymentsAuthorizeRouterData>,
) -> Result<Self, Self::Error> {
let merchant_authentication =
AuthorizedotnetAuthType::try_from(&item.router_data.connector_auth_type)?;
let ref_id = if item.router_data.connector_request_reference_id.len() <= 20 {
Some(item.router_data.connector_request_reference_id.clone())
} else {
None
};
let transaction_request = match item
.router_data
.request
.mandate_id
.clone()
.and_then(|mandate_ids| mandate_ids.mandate_reference_id)
{
Some(api_models::payments::MandateReferenceId::NetworkMandateId(network_trans_id)) => {
TransactionRequest::try_from((item, network_trans_id))?
}
Some(api_models::payments::MandateReferenceId::ConnectorMandateId(
connector_mandate_id,
)) => TransactionRequest::try_from((item, connector_mandate_id))?,
Some(api_models::payments::MandateReferenceId::NetworkTokenWithNTI(_)) => {
Err(errors::ConnectorError::NotImplemented(
utils::get_unimplemented_payment_method_error_message("authorizedotnet"),
))?
}
None => {
match &item.router_data.request.payment_method_data {
PaymentMethodData::Card(ccard) => TransactionRequest::try_from((item, ccard)),
PaymentMethodData::Wallet(wallet_data) => {
TransactionRequest::try_from((item, wallet_data))
}
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(
"authorizedotnet",
),
))?
}
}
}?,
};
Ok(Self {
create_transaction_request: AuthorizedotnetPaymentsRequest {
merchant_authentication,
ref_id,
transaction_request,
},
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/authorizedotnet/transformers.rs" role="context" start="591" end="601">
fn try_from(capture_method: enums::CaptureMethod) -> Result<Self, Self::Error> {
match capture_method {
enums::CaptureMethod::Manual => Ok(Self::Pre),
enums::CaptureMethod::SequentialAutomatic | enums::CaptureMethod::Automatic => {
Ok(Self::Final)
}
enums::CaptureMethod::ManualMultiple | enums::CaptureMethod::Scheduled => Err(
utils::construct_not_supported_error_report(capture_method, "authorizedotnet"),
)?,
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/authorizedotnet/transformers.rs" role="context" start="1963" end="2013">
fn try_from(
item: &AuthorizedotnetRouterData<&PaymentsCompleteAuthorizeRouterData>,
) -> Result<Self, Self::Error> {
let params = item
.router_data
.request
.redirect_response
.as_ref()
.and_then(|redirect_response| redirect_response.params.as_ref())
.ok_or(errors::ConnectorError::ResponseDeserializationFailed)?;
let query_params: PaypalQueryParams = serde_urlencoded::from_str(params.peek())
.change_context(errors::ConnectorError::ResponseDeserializationFailed)
.attach_printable("Failed to parse connector response")?;
let payer_id = query_params.payer_id;
let transaction_type = match item.router_data.request.capture_method {
Some(enums::CaptureMethod::Manual) => Ok(TransactionType::ContinueAuthorization),
Some(enums::CaptureMethod::SequentialAutomatic)
| Some(enums::CaptureMethod::Automatic)
| None => Ok(TransactionType::ContinueCapture),
Some(enums::CaptureMethod::ManualMultiple) => {
Err(errors::ConnectorError::NotSupported {
message: enums::CaptureMethod::ManualMultiple.to_string(),
connector: "authorizedotnet",
})
}
Some(enums::CaptureMethod::Scheduled) => Err(errors::ConnectorError::NotSupported {
message: enums::CaptureMethod::Scheduled.to_string(),
connector: "authorizedotnet",
}),
}?;
let transaction_request = TransactionConfirmRequest {
transaction_type,
payment: PaypalPaymentConfirm {
pay_pal: Paypal { payer_id },
},
ref_trans_id: item.router_data.request.connector_transaction_id.clone(),
};
let merchant_authentication =
AuthorizedotnetAuthType::try_from(&item.router_data.connector_auth_type)?;
Ok(Self {
create_transaction_request: PaypalConfirmTransactionRequest {
merchant_authentication,
transaction_request,
},
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/authorizedotnet/transformers.rs" role="context" start="1205" end="1298">
fn foreign_try_from(
(item, is_auto_capture): (
ResponseRouterData<F, AuthorizedotnetPaymentsResponse, T, PaymentsResponseData>,
bool,
),
) -> Result<Self, Self::Error> {
match &item.response.transaction_response {
Some(TransactionResponse::AuthorizedotnetTransactionResponse(transaction_response)) => {
let status = get_payment_status((
transaction_response.response_code.clone(),
is_auto_capture,
));
let error = transaction_response.errors.as_ref().and_then(|errors| {
errors.iter().next().map(|error| ErrorResponse {
code: error.error_code.clone(),
message: error.error_text.clone(),
reason: Some(error.error_text.clone()),
status_code: item.http_code,
attempt_status: None,
connector_transaction_id: Some(transaction_response.transaction_id.clone()),
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
})
});
let metadata = transaction_response
.account_number
.as_ref()
.map(|acc_no| {
construct_refund_payment_details(acc_no.clone().expose()).encode_to_value()
})
.transpose()
.change_context(errors::ConnectorError::MissingRequiredField {
field_name: "connector_metadata",
})?;
let url = transaction_response
.secure_acceptance
.as_ref()
.and_then(|x| x.secure_acceptance_url.to_owned());
let redirection_data = url.map(|url| RedirectForm::from((url, Method::Get)));
let mandate_reference = item.response.profile_response.map(|profile_response| {
let payment_profile_id = profile_response
.customer_payment_profile_id_list
.and_then(|customer_payment_profile_id_list| {
customer_payment_profile_id_list.first().cloned()
});
MandateReference {
connector_mandate_id: profile_response.customer_profile_id.and_then(
|customer_profile_id| {
payment_profile_id.map(|payment_profile_id| {
format!("{customer_profile_id}-{payment_profile_id}")
})
},
),
payment_method_id: None,
mandate_metadata: None,
connector_mandate_request_reference_id: None,
}
});
Ok(Self {
status,
response: match error {
Some(err) => Err(err),
None => Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(
transaction_response.transaction_id.clone(),
),
redirection_data: Box::new(redirection_data),
mandate_reference: Box::new(mandate_reference),
connector_metadata: metadata,
network_txn_id: transaction_response
.network_trans_id
.clone()
.map(|network_trans_id| network_trans_id.expose()),
connector_response_reference_id: Some(
transaction_response.transaction_id.clone(),
),
incremental_authorization_allowed: None,
charges: None,
}),
},
..item.data
})
}
Some(TransactionResponse::AuthorizedotnetTransactionResponseError(_)) | None => {
Ok(Self {
status: enums::AttemptStatus::Failure,
response: Err(get_err_response(item.http_code, item.response.messages)?),
..item.data
})
}
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/authorizedotnet/transformers.rs" role="context" start="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="257" end="259">
struct AuthorizationIndicator {
authorization_indicator: AuthorizationType,
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/globalpay/requests.rs" role="context" start="203" end="208">
pub enum PaymentMethodData {
Card(Card),
Apm(Apm),
BankTransfer(BankTransfer),
DigitalWallet(DigitalWallet),
}
| 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="362" end="454">
fn try_from(
item: ResponseRouterData<
Authorize,
DeutschebankThreeDSInitializeResponse,
PaymentsAuthorizeData,
PaymentsResponseData,
>,
) -> Result<Self, Self::Error> {
match item.response.outcome {
DeutschebankThreeDSInitializeResponseOutcome::Processed => {
match item.response.processed {
Some(processed) => Ok(Self {
status: if is_response_success(&processed.rc) {
match item.data.request.is_auto_capture()? {
true => common_enums::AttemptStatus::Charged,
false => common_enums::AttemptStatus::Authorized,
}
} else {
common_enums::AttemptStatus::AuthenticationFailed
},
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(
processed.tx_id.clone(),
),
redirection_data: Box::new(None),
mandate_reference: Box::new(None),
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: Some(processed.tx_id.clone()),
incremental_authorization_allowed: None,
charges: None,
}),
..item.data
}),
None => {
let response_string = format!("{:?}", item.response);
Err(
errors::ConnectorError::UnexpectedResponseError(bytes::Bytes::from(
response_string,
))
.into(),
)
}
}
}
DeutschebankThreeDSInitializeResponseOutcome::ChallengeRequired => {
match item.response.challenge_required {
Some(challenge) => Ok(Self {
status: common_enums::AttemptStatus::AuthenticationPending,
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::NoResponseId,
redirection_data: Box::new(Some(
RedirectForm::DeutschebankThreeDSChallengeFlow {
acs_url: challenge.acs_url,
creq: challenge.creq,
},
)),
mandate_reference: Box::new(None),
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: None,
incremental_authorization_allowed: None,
charges: None,
}),
..item.data
}),
None => {
let response_string = format!("{:?}", item.response);
Err(
errors::ConnectorError::UnexpectedResponseError(bytes::Bytes::from(
response_string,
))
.into(),
)
}
}
}
DeutschebankThreeDSInitializeResponseOutcome::MethodRequired => Ok(Self {
status: common_enums::AttemptStatus::Failure,
response: Err(ErrorResponse {
code: consts::NO_ERROR_CODE.to_owned(),
message: "METHOD_REQUIRED Flow not supported for deutschebank 3ds payments".to_owned(),
reason: Some("METHOD_REQUIRED Flow is not currently supported for deutschebank 3ds payments".to_owned()),
status_code: item.http_code,
attempt_status: None,
connector_transaction_id: None,network_advice_code: None,
network_decline_code: None,
network_error_message: None,
}),
..item.data
}),
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/deutschebank/transformers.rs" role="context" start="361" end="361">
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 hyperswitch_interfaces::{consts, errors};
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="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="474" end="488">
fn from(item: DeutschebankSEPAMandateStatus) -> Self {
match item {
DeutschebankSEPAMandateStatus::Active
| DeutschebankSEPAMandateStatus::Created
| DeutschebankSEPAMandateStatus::PendingApproval
| DeutschebankSEPAMandateStatus::PendingSecondaryApproval
| DeutschebankSEPAMandateStatus::PendingReview
| DeutschebankSEPAMandateStatus::PendingSubmission
| DeutschebankSEPAMandateStatus::Submitted => Self::AuthenticationPending,
DeutschebankSEPAMandateStatus::Failed
| DeutschebankSEPAMandateStatus::Discarded
| DeutschebankSEPAMandateStatus::Expired
| DeutschebankSEPAMandateStatus::Replaced => Self::Failure,
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/deutschebank/transformers.rs" role="context" start="208" end="320">
fn try_from(
item: &DeutschebankRouterData<&PaymentsAuthorizeRouterData>,
) -> Result<Self, Self::Error> {
match item
.router_data
.request
.mandate_id
.clone()
.and_then(|mandate_id| mandate_id.mandate_reference_id)
{
None => {
// To facilitate one-off payments via SEPA with Deutsche Bank, we are considering not storing the connector mandate ID in our system if future usage is on-session.
// We will only check for customer acceptance to make a one-off payment. we will be storing the connector mandate details only when setup future usage is off-session.
match item.router_data.request.payment_method_data.clone() {
PaymentMethodData::BankDebit(BankDebitData::SepaBankDebit { iban, .. }) => {
if item.router_data.request.customer_acceptance.is_some() {
let billing_address = item.router_data.get_billing_address()?;
Ok(Self::MandatePost(DeutschebankMandatePostRequest {
approval_by: DeutschebankSEPAApproval::Click,
email_address: item.router_data.request.get_email()?,
iban: Secret::from(iban.peek().replace(" ", "")),
first_name: billing_address.get_first_name()?.clone(),
last_name: billing_address.get_last_name()?.clone(),
}))
} else {
Err(errors::ConnectorError::MissingRequiredField {
field_name: "customer_acceptance",
}
.into())
}
}
PaymentMethodData::Card(ccard) => {
if !item.router_data.clone().is_three_ds() {
Err(errors::ConnectorError::NotSupported {
message: "Non-ThreeDs".to_owned(),
connector: "deutschebank",
}
.into())
} else {
let billing_address = item.router_data.get_billing_address()?;
Ok(Self::CreditCard(Box::new(DeutschebankThreeDSInitializeRequest {
means_of_payment: DeutschebankThreeDSInitializeRequestMeansOfPayment {
credit_card: DeutschebankThreeDSInitializeRequestCreditCard {
number: ccard.clone().card_number,
expiry_date: DeutschebankThreeDSInitializeRequestCreditCardExpiry {
year: ccard.get_expiry_year_4_digit(),
month: ccard.card_exp_month,
},
code: ccard.card_cvc,
cardholder: item.router_data.get_billing_full_name()?,
}},
amount_total: DeutschebankThreeDSInitializeRequestAmountTotal {
amount: item.amount,
currency: item.router_data.request.currency,
},
tds_20_data: DeutschebankThreeDSInitializeRequestTds20Data {
communication_data: DeutschebankThreeDSInitializeRequestCommunicationData {
method_notification_url: item.router_data.request.get_complete_authorize_url()?,
cres_notification_url: item.router_data.request.get_complete_authorize_url()?,
},
customer_data: DeutschebankThreeDSInitializeRequestCustomerData {
billing_address: DeutschebankThreeDSInitializeRequestCustomerBillingData {
street: billing_address.get_line1()?.clone(),
postal_code: billing_address.get_zip()?.clone(),
city: billing_address.get_city()?.to_string(),
state: billing_address.get_state()?.clone(),
country: item.router_data.get_billing_country()?.to_string(),
},
cardholder_email: item.router_data.request.get_email()?,
}
}
})))
}
}
_ => Err(errors::ConnectorError::NotImplemented(
utils::get_unimplemented_payment_method_error_message("deutschebank"),
)
.into()),
}
}
Some(api_models::payments::MandateReferenceId::ConnectorMandateId(mandate_data)) => {
let mandate_metadata: DeutschebankMandateMetadata = mandate_data
.get_mandate_metadata()
.ok_or(errors::ConnectorError::MissingConnectorMandateMetadata)?
.clone()
.parse_value("DeutschebankMandateMetadata")
.change_context(errors::ConnectorError::ParsingFailed)?;
Ok(Self::DirectDebit(DeutschebankDirectDebitRequest {
amount_total: DeutschebankAmount {
amount: item.amount,
currency: item.router_data.request.currency,
},
means_of_payment: DeutschebankMeansOfPayment {
bank_account: DeutschebankBankAccount {
account_holder: mandate_metadata.account_holder,
iban: mandate_metadata.iban,
},
},
mandate: DeutschebankMandate {
reference: mandate_metadata.reference,
signed_on: mandate_metadata.signed_on,
},
}))
}
Some(api_models::payments::MandateReferenceId::NetworkTokenWithNTI(_))
| Some(api_models::payments::MandateReferenceId::NetworkMandateId(_)) => {
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="97" end="107">
fn try_from(
item: ResponseRouterData<F, DeutschebankAccessTokenResponse, 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/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="339" end="343">
pub enum DeutschebankThreeDSInitializeResponseOutcome {
Processed,
ChallengeRequired,
MethodRequired,
}
<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/datatrans/transformers.rs<|crate|> hyperswitch_connectors<|connector|> datatrans 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/datatrans/transformers.rs" role="context" start="335" end="413">
fn try_from(
item: &DatatransRouterData<&types::PaymentsAuthorizeRouterData>,
) -> Result<Self, Self::Error> {
match item.router_data.request.payment_method_data.clone() {
PaymentMethodData::Card(req_card) => {
let is_mandate_payment = item.router_data.request.is_mandate_payment();
let option =
is_mandate_payment.then_some(DataTransCreateAlias { create_alias: true });
// provides return url for only mandate payment(CIT) or 3ds through datatrans
let redirect = if is_mandate_payment
|| (item.router_data.is_three_ds()
&& item.router_data.request.authentication_data.is_none())
{
Some(RedirectUrls {
success_url: item.router_data.request.router_return_url.clone(),
cancel_url: item.router_data.request.router_return_url.clone(),
error_url: item.router_data.request.router_return_url.clone(),
})
} else {
None
};
Ok(Self {
amount: Some(item.amount),
currency: item.router_data.request.currency,
card: create_card_details(item, &req_card)?,
refno: item.router_data.connector_request_reference_id.clone(),
auto_settle: item.router_data.request.is_auto_capture()?,
option,
redirect,
})
}
PaymentMethodData::MandatePayment => {
let additional_payment_data = match item
.router_data
.request
.additional_payment_method_data
.clone()
.ok_or(errors::ConnectorError::MissingRequiredField {
field_name: "additional_payment_method_data",
})? {
AdditionalPaymentData::Card(card) => *card,
_ => Err(errors::ConnectorError::NotSupported {
message: "Payment Method Not Supported".to_string(),
connector: "DataTrans",
})?,
};
Ok(Self {
amount: Some(item.amount),
currency: item.router_data.request.currency,
card: create_mandate_details(item, &additional_payment_data)?,
refno: item.router_data.connector_request_reference_id.clone(),
auto_settle: item.router_data.request.is_auto_capture()?,
option: None,
redirect: None,
})
}
PaymentMethodData::Wallet(_)
| PaymentMethodData::PayLater(_)
| PaymentMethodData::BankRedirect(_)
| PaymentMethodData::BankDebit(_)
| PaymentMethodData::BankTransfer(_)
| PaymentMethodData::Crypto(_)
| PaymentMethodData::Reward
| PaymentMethodData::RealTimePayment(_)
| PaymentMethodData::MobilePayment(_)
| PaymentMethodData::Upi(_)
| PaymentMethodData::CardRedirect(_)
| PaymentMethodData::Voucher(_)
| PaymentMethodData::GiftCard(_)
| PaymentMethodData::OpenBanking(_)
| PaymentMethodData::CardToken(_)
| PaymentMethodData::NetworkToken(_)
| PaymentMethodData::CardDetailsForNetworkTransactionId(_) => {
Err(errors::ConnectorError::NotImplemented(
get_unimplemented_payment_method_error_message("Datatrans"),
))?
}
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/datatrans/transformers.rs" role="context" start="334" end="334">
use common_utils::{pii::Email, request::Method, types::MinorUnit};
use hyperswitch_domain_models::{
payment_method_data::{Card, PaymentMethodData},
router_data::{ConnectorAuthType, ErrorResponse, RouterData},
router_flow_types::refunds::{Execute, RSync},
router_request_types::{PaymentsAuthorizeData, ResponseId, SetupMandateRequestData},
router_response_types::{
MandateReference, PaymentsResponseData, RedirectForm, RefundsResponseData,
},
types,
};
use crate::{
types::{
PaymentsCancelResponseRouterData, PaymentsCaptureResponseRouterData,
PaymentsSyncResponseRouterData, RefundsResponseRouterData, ResponseRouterData,
},
utils::{
get_unimplemented_payment_method_error_message, AdditionalCardInfo, CardData as _,
PaymentsAuthorizeRequestData, RouterData as _,
},
};
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/datatrans/transformers.rs" role="context" start="428" end="440">
fn get_status(item: &DatatransResponse, is_auto_capture: bool) -> enums::AttemptStatus {
match item {
DatatransResponse::ErrorResponse(_) => enums::AttemptStatus::Failure,
DatatransResponse::TransactionResponse(_) => {
if is_auto_capture {
enums::AttemptStatus::Charged
} else {
enums::AttemptStatus::Authorized
}
}
DatatransResponse::ThreeDSResponse(_) => enums::AttemptStatus::AuthenticationPending,
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/datatrans/transformers.rs" role="context" start="417" end="425">
fn try_from(auth_type: &ConnectorAuthType) -> Result<Self, Self::Error> {
match auth_type {
ConnectorAuthType::BodyKey { api_key, key1 } => Ok(Self {
merchant_id: key1.clone(),
passcode: api_key.clone(),
}),
_ => Err(errors::ConnectorError::FailedToObtainAuthType.into()),
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/datatrans/transformers.rs" role="context" start="278" end="328">
fn try_from(item: &types::SetupMandateRouterData) -> Result<Self, Self::Error> {
match item.request.payment_method_data.clone() {
PaymentMethodData::Card(req_card) => Ok(Self {
amount: None,
currency: item.request.currency,
card: DataTransPaymentDetails::Cards(PlainCardDetails {
res_type: "PLAIN".to_string(),
number: req_card.card_number.clone(),
expiry_month: req_card.card_exp_month.clone(),
expiry_year: req_card.get_card_expiry_year_2_digit()?,
cvv: req_card.card_cvc.clone(),
three_ds: Some(ThreeDSecureData::Cardholder(ThreedsInfo {
cardholder: CardHolder {
cardholder_name: item.get_billing_full_name()?,
email: item.get_billing_email()?,
},
})),
}),
refno: item.connector_request_reference_id.clone(),
auto_settle: true, // zero auth doesn't support manual capture
option: Some(DataTransCreateAlias { create_alias: true }),
redirect: Some(RedirectUrls {
success_url: item.request.router_return_url.clone(),
cancel_url: item.request.router_return_url.clone(),
error_url: item.request.router_return_url.clone(),
}),
}),
PaymentMethodData::Wallet(_)
| PaymentMethodData::PayLater(_)
| PaymentMethodData::BankRedirect(_)
| PaymentMethodData::BankDebit(_)
| PaymentMethodData::BankTransfer(_)
| PaymentMethodData::MandatePayment
| PaymentMethodData::Crypto(_)
| PaymentMethodData::Reward
| PaymentMethodData::RealTimePayment(_)
| PaymentMethodData::MobilePayment(_)
| PaymentMethodData::Upi(_)
| PaymentMethodData::CardRedirect(_)
| PaymentMethodData::Voucher(_)
| PaymentMethodData::GiftCard(_)
| PaymentMethodData::OpenBanking(_)
| PaymentMethodData::CardToken(_)
| PaymentMethodData::NetworkToken(_)
| PaymentMethodData::CardDetailsForNetworkTransactionId(_) => {
Err(errors::ConnectorError::NotImplemented(
get_unimplemented_payment_method_error_message("Datatrans"),
))?
}
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/datatrans/transformers.rs" role="context" start="268" end="273">
fn try_from((amount, item): (MinorUnit, T)) -> Result<Self, Self::Error> {
Ok(Self {
amount,
router_data: item,
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/datatrans/transformers.rs" role="context" start="481" end="496">
fn create_mandate_details(
item: &DatatransRouterData<&types::PaymentsAuthorizeRouterData>,
additional_card_details: &payments::AdditionalCardInfo,
) -> Result<DataTransPaymentDetails, error_stack::Report<errors::ConnectorError>> {
let alias = item.router_data.request.get_connector_mandate_id()?;
Ok(DataTransPaymentDetails::Mandate(MandateDetails {
res_type: "ALIAS".to_string(),
alias,
expiry_month: additional_card_details.card_exp_month.clone().ok_or(
errors::ConnectorError::MissingRequiredField {
field_name: "card_exp_month",
},
)?,
expiry_year: additional_card_details.get_card_expiry_year_2_digit()?,
}))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/datatrans/transformers.rs" role="context" start="442" end="479">
fn create_card_details(
item: &DatatransRouterData<&types::PaymentsAuthorizeRouterData>,
card: &Card,
) -> Result<DataTransPaymentDetails, error_stack::Report<errors::ConnectorError>> {
let mut details = PlainCardDetails {
res_type: "PLAIN".to_string(),
number: card.card_number.clone(),
expiry_month: card.card_exp_month.clone(),
expiry_year: card.get_card_expiry_year_2_digit()?,
cvv: card.card_cvc.clone(),
three_ds: None,
};
if let Some(auth_data) = &item.router_data.request.authentication_data {
details.three_ds = Some(ThreeDSecureData::Authentication(ThreeDSData {
three_ds_transaction_id: auth_data
.threeds_server_transaction_id
.clone()
.map(Secret::new),
cavv: Secret::new(auth_data.cavv.clone()),
eci: auth_data.eci.clone(),
xid: auth_data.ds_trans_id.clone().map(Secret::new),
three_ds_version: auth_data
.message_version
.clone()
.map(|version| version.to_string()),
authentication_response: "Y".to_string(),
}));
} else if item.router_data.is_three_ds() {
details.three_ds = Some(ThreeDSecureData::Cardholder(ThreedsInfo {
cardholder: CardHolder {
cardholder_name: item.router_data.get_billing_full_name()?,
email: item.router_data.get_billing_email()?,
},
}));
}
Ok(DataTransPaymentDetails::Cards(details))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/datatrans/transformers.rs" role="context" start="267" end="267">
type Error = error_stack::Report<errors::ConnectorError>;
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/datatrans/transformers.rs" role="context" start="74" end="78">
pub struct RedirectUrls {
pub success_url: Option<String>,
pub cancel_url: Option<String>,
pub error_url: Option<String>,
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/worldline/transformers.rs" role="context" start="563" end="568">
pub struct Payment {
pub id: String,
pub status: PaymentStatus,
#[serde(skip_deserializing)]
pub capture_method: CaptureMethod,
}
| symbol_neighborhood |
<|meta_start|><|file|> hyperswitch/crates/hyperswitch_connectors/src/connectors/adyen/transformers.rs<|crate|> hyperswitch_connectors<|connector|> adyen anchor=get_defence_documents kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=1<|meta_end|>
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/adyen/transformers.rs" role="context" start="5525" end="5604">
fn get_defence_documents(item: SubmitEvidenceRequestData) -> Option<Vec<DefenseDocuments>> {
let mut defense_documents: Vec<DefenseDocuments> = Vec::new();
if let Some(shipping_documentation) = item.shipping_documentation {
defense_documents.push(DefenseDocuments {
content: get_content(shipping_documentation).into(),
content_type: item.receipt_file_type,
defense_document_type_code: "DefenseMaterial".into(),
})
}
if let Some(receipt) = item.receipt {
defense_documents.push(DefenseDocuments {
content: get_content(receipt).into(),
content_type: item.shipping_documentation_file_type,
defense_document_type_code: "DefenseMaterial".into(),
})
}
if let Some(invoice_showing_distinct_transactions) = item.invoice_showing_distinct_transactions
{
defense_documents.push(DefenseDocuments {
content: get_content(invoice_showing_distinct_transactions).into(),
content_type: item.invoice_showing_distinct_transactions_file_type,
defense_document_type_code: "DefenseMaterial".into(),
})
}
if let Some(customer_communication) = item.customer_communication {
defense_documents.push(DefenseDocuments {
content: get_content(customer_communication).into(),
content_type: item.customer_communication_file_type,
defense_document_type_code: "DefenseMaterial".into(),
})
}
if let Some(refund_policy) = item.refund_policy {
defense_documents.push(DefenseDocuments {
content: get_content(refund_policy).into(),
content_type: item.refund_policy_file_type,
defense_document_type_code: "DefenseMaterial".into(),
})
}
if let Some(recurring_transaction_agreement) = item.recurring_transaction_agreement {
defense_documents.push(DefenseDocuments {
content: get_content(recurring_transaction_agreement).into(),
content_type: item.recurring_transaction_agreement_file_type,
defense_document_type_code: "DefenseMaterial".into(),
})
}
if let Some(uncategorized_file) = item.uncategorized_file {
defense_documents.push(DefenseDocuments {
content: get_content(uncategorized_file).into(),
content_type: item.uncategorized_file_type,
defense_document_type_code: "DefenseMaterial".into(),
})
}
if let Some(cancellation_policy) = item.cancellation_policy {
defense_documents.push(DefenseDocuments {
content: get_content(cancellation_policy).into(),
content_type: item.cancellation_policy_file_type,
defense_document_type_code: "DefenseMaterial".into(),
})
}
if let Some(customer_signature) = item.customer_signature {
defense_documents.push(DefenseDocuments {
content: get_content(customer_signature).into(),
content_type: item.customer_signature_file_type,
defense_document_type_code: "DefenseMaterial".into(),
})
}
if let Some(service_documentation) = item.service_documentation {
defense_documents.push(DefenseDocuments {
content: get_content(service_documentation).into(),
content_type: item.service_documentation_file_type,
defense_document_type_code: "DefenseMaterial".into(),
})
}
if defense_documents.is_empty() {
None
} else {
Some(defense_documents)
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/adyen/transformers.rs" role="context" start="5524" end="5524">
use hyperswitch_domain_models::{
network_tokenization::NetworkTokenNumber,
payment_method_data::{
BankDebitData, BankRedirectData, BankTransferData, Card, CardRedirectData, GiftCardData,
NetworkTokenData, PayLaterData, PaymentMethodData, VoucherData, WalletData,
},
router_data::{
ConnectorAuthType, ErrorResponse, PaymentMethodBalance, PaymentMethodToken, RouterData,
},
router_request_types::{PaymentsPreProcessingData, ResponseId, SubmitEvidenceRequestData},
router_response_types::{
AcceptDisputeResponse, DefendDisputeResponse, MandateReference, PaymentsResponseData,
RedirectForm, RefundsResponseData, SubmitEvidenceResponse,
},
types::{
PaymentsAuthorizeRouterData, PaymentsCancelRouterData, PaymentsCaptureRouterData,
PaymentsPreProcessingRouterData, RefundsRouterData,
},
};
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/adyen/transformers.rs" role="context" start="5613" end="5650">
fn foreign_try_from(item: (&Self, AdyenDisputeResponse)) -> Result<Self, Self::Error> {
let (data, response) = item;
if response.success {
Ok(AcceptDisputeRouterData {
response: Ok(AcceptDisputeResponse {
dispute_status: storage_enums::DisputeStatus::DisputeAccepted,
connector_status: None,
}),
..data.clone()
})
} else {
Ok(AcceptDisputeRouterData {
response: Err(ErrorResponse {
code: response
.error_message
.clone()
.unwrap_or_else(|| NO_ERROR_CODE.to_string()),
message: response
.error_message
.clone()
.unwrap_or_else(|| NO_ERROR_MESSAGE.to_string()),
reason: response.error_message,
status_code: data.connector_http_status_code.ok_or(
errors::ConnectorError::MissingRequiredField {
field_name: "http code",
},
)?,
attempt_status: None,
connector_transaction_id: None,
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
}),
..data.clone()
})
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/adyen/transformers.rs" role="context" start="5606" end="5608">
fn get_content(item: Vec<u8>) -> String {
String::from_utf8_lossy(&item).to_string()
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/adyen/transformers.rs" role="context" start="5510" end="5522">
fn try_from(item: &SubmitEvidenceRouterData) -> Result<Self, Self::Error> {
let merchant_account_code = get_merchant_account_code(&item.connector_auth_type)?;
let submit_evidence_request_data = item.request.clone();
Ok(Self {
defense_documents: get_defence_documents(submit_evidence_request_data).ok_or(
errors::ConnectorError::MissingRequiredField {
field_name: "Missing Defence Documents",
},
)?,
merchant_account_code,
dispute_psp_reference: item.request.connector_dispute_id.clone(),
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/adyen/transformers.rs" role="context" start="5482" end="5489">
fn try_from(item: &DefendDisputeRouterData) -> Result<Self, Self::Error> {
let merchant_account_code = get_merchant_account_code(&item.connector_auth_type)?;
Ok(Self {
dispute_psp_reference: item.request.connector_dispute_id.clone(),
merchant_account_code,
defense_reason_code: "SupplyDefenseMaterial".into(),
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/adyen/transformers.rs" role="context" start="5502" end="5506">
pub struct DefenseDocuments {
content: Secret<String>,
content_type: Option<String>,
defense_document_type_code: String,
}
| symbol_neighborhood |
<|meta_start|><|file|> hyperswitch/crates/hyperswitch_connectors/src/connectors/zen/transformers.rs<|crate|> hyperswitch_connectors<|connector|> zen 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/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="455" end="455">
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 masking::{ExposeInterface, PeekInterface, Secret};
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="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="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="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="263" end="307">
fn try_from(
value: (
&ZenRouterData<&types::PaymentsAuthorizeRouterData>,
&VoucherData,
),
) -> Result<Self, Self::Error> {
let (item, voucher_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 voucher_data {
VoucherData::Boleto { .. } => ZenPaymentChannels::PclBoacompraBoleto,
VoucherData::Efecty => ZenPaymentChannels::PclBoacompraEfecty,
VoucherData::PagoEfectivo => ZenPaymentChannels::PclBoacompraPagoefectivo,
VoucherData::RedCompra => ZenPaymentChannels::PclBoacompraRedcompra,
VoucherData::RedPagos => ZenPaymentChannels::PclBoacompraRedpagos,
VoucherData::Oxxo
| VoucherData::Alfamart { .. }
| VoucherData::Indomaret { .. }
| VoucherData::SevenEleven { .. }
| VoucherData::Lawson { .. }
| VoucherData::MiniStop { .. }
| VoucherData::FamilyMart { .. }
| VoucherData::Seicomart { .. }
| VoucherData::PayEasy { .. } => 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="617" end="641">
fn get_item_object(
item: &types::PaymentsAuthorizeRouterData,
) -> Result<Vec<ZenItemObject>, error_stack::Report<errors::ConnectorError>> {
let order_details = item.request.get_order_details()?;
order_details
.iter()
.map(|data| {
Ok(ZenItemObject {
name: data.product_name.clone(),
quantity: data.quantity,
price: utils::to_currency_base_unit_with_zero_decimal_check(
data.amount.get_amount_as_i64(), // This should be changed to MinorUnit when we implement amount conversion for this connector. Additionally, the function get_amount_as_i64() should be avoided in the future.
item.request.currency,
)?,
line_amount_total: (f64::from(data.quantity)
* utils::to_currency_base_unit_asf64(
data.amount.get_amount_as_i64(), // This should be changed to MinorUnit when we implement amount conversion for this connector. Additionally, the function get_amount_as_i64() should be avoided in the future.
item.request.currency,
)?)
.to_string(),
})
})
.collect::<Result<_, _>>()
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/zen/transformers.rs" role="context" start="46" end="46">
type Error = error_stack::Report<errors::ConnectorError>;
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/zen/transformers.rs" role="context" start="202" end="205">
pub struct SessionObject {
pub apple_pay: Option<WalletSessionData>,
pub google_pay: Option<WalletSessionData>,
}
<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/paypal/transformers.rs<|crate|> hyperswitch_connectors<|connector|> paypal anchor=try_from kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/paypal/transformers.rs" role="context" start="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="1782" end="1782">
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 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="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="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="1749" end="1777">
fn get_id_based_on_intent(
intent: &PaypalPaymentIntent,
purchase_unit: &PurchaseUnitItem,
) -> CustomResult<String, errors::ConnectorError> {
|| -> _ {
match intent {
PaypalPaymentIntent::Capture => Some(
purchase_unit
.payments
.captures
.clone()?
.into_iter()
.next()?
.id,
),
PaypalPaymentIntent::Authorize => Some(
purchase_unit
.payments
.authorizations
.clone()?
.into_iter()
.next()?
.id,
),
PaypalPaymentIntent::Authenticate => None,
}
}()
.ok_or_else(|| errors::ConnectorError::MissingConnectorTransactionID.into())
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/paypal/transformers.rs" role="context" start="1532" end="1553">
pub(crate) fn get_order_status(
item: PaypalOrderStatus,
intent: PaypalPaymentIntent,
) -> storage_enums::AttemptStatus {
match item {
PaypalOrderStatus::Completed => {
if intent == PaypalPaymentIntent::Authorize {
storage_enums::AttemptStatus::Authorized
} else {
storage_enums::AttemptStatus::Charged
}
}
PaypalOrderStatus::Voided => storage_enums::AttemptStatus::Voided,
PaypalOrderStatus::Created | PaypalOrderStatus::Saved | PaypalOrderStatus::Pending => {
storage_enums::AttemptStatus::Pending
}
PaypalOrderStatus::Approved => storage_enums::AttemptStatus::AuthenticationSuccessful,
PaypalOrderStatus::PayerActionRequired => {
storage_enums::AttemptStatus::AuthenticationPending
}
}
}
<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/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="1741" end="1747">
pub struct PaypalMeta {
pub authorize_id: Option<String>,
pub capture_id: Option<String>,
pub psync_flow: PaypalPaymentIntent,
pub next_action: Option<api_models::payments::NextActionCall>,
pub order_id: 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/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/payouts.rs" role="context" start="370" end="382">
pub struct Paypal {
/// Email linked with paypal account
#[schema(value_type = String, example = "john.doe@example.com")]
pub email: Option<Email>,
/// mobile number linked to paypal account
#[schema(value_type = String, example = "16608213349")]
pub telephone_number: Option<Secret<String>>,
/// id of the paypal account
#[schema(value_type = String, example = "G83KXTJ5EHCQ2")]
pub paypal_id: Option<Secret<String>>,
}
| symbol_neighborhood |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.