text stringlengths 70 351k | source stringclasses 4 values |
|---|---|
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/cybersource/transformers.rs | crate: hyperswitch_connectors | connector: cybersource
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,
},
};
fn try_from(
(item, ccard): (
&CybersourceRouterData<&PaymentsCompleteAuthorizeRouterData>,
hyperswitch_domain_models::payment_method_data::Card,
),
) -> Result<Self, Self::Error> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/cybersource/transformers.rs | crate: hyperswitch_connectors | connector: cybersource
merchant_defined_information,
})
}
}
impl
TryFrom<(
&CybersourceRouterData<&PaymentsAuthorizeRouterData>,
hyperswitch_domain_models::payment_method_data::CardDetailsForNetworkTransactionId,
)> for CybersourcePaymentsRequest
{
type Error = error_stack::Report<errors::ConnectorError>;
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)));
fn try_from(
(item, ccard): (
&CybersourceRouterData<&PaymentsAuthorizeRouterData>,
hyperswitch_domain_models::payment_method_data::CardDetailsForNetworkTransactionId,
),
) -> Result<Self, Self::Error> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/cybersource/transformers.rs | crate: hyperswitch_connectors | connector: cybersource
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};
fn try_from(
(item, ccard): (
&CybersourceRouterData<&PaymentsAuthorizeRouterData>,
hyperswitch_domain_models::payment_method_data::Card,
),
) -> Result<Self, Self::Error> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/cybersource/transformers.rs | crate: hyperswitch_connectors | connector: cybersource
.get_required_value("samsung pay public_key_hash")
.change_context(errors::ConnectorError::RequestEncodingFailed)?
.to_string(),
),
version: samsung_pay_token_data.version.clone(),
data: Secret::new(consts::BASE64_ENGINE.encode(samsung_pay_token_data.data.peek())),
};
Ok(samsung_pay_fluid_data_value)
}
impl TryFrom<&CybersourceRouterData<&PaymentsAuthorizeRouterData>> for CybersourcePaymentsRequest {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: &CybersourceRouterData<&PaymentsAuthorizeRouterData>,
) -> Result<Self, Self::Error> {
match item.router_data.request.connector_mandate_id() {
Some(connector_mandate_id) => Self::try_from((item, connector_mandate_id)),
None => {
match item.router_data.request.payment_method_data.clone() {
PaymentMethodData::Card(ccard) => Self::try_from((item, ccard)),
PaymentMethodData::Wallet(wallet_data) => match wallet_data {
WalletData::ApplePay(apple_pay_data) => {
match item.router_data.payment_method_token.clone() {
Some(payment_method_token) => match payment_method_token {
PaymentMethodToken::ApplePayDecrypt(decrypt_data) => {
fn try_from(
item: &CybersourceRouterData<&PaymentsAuthorizeRouterData>,
) -> Result<Self, Self::Error> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/cybersource/transformers.rs | crate: hyperswitch_connectors | connector: cybersource
}
}
}
impl
TryFrom<(
&CybersourceRouterData<&PaymentsAuthorizeRouterData>,
Option<PaymentSolution>,
Option<String>,
)> for ProcessingInformation
{
type Error = error_stack::Report<errors::ConnectorError>;
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() {
fn try_from(
(item, solution, network): (
&CybersourceRouterData<&PaymentsAuthorizeRouterData>,
Option<PaymentSolution>,
Option<String>,
),
) -> Result<Self, Self::Error> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/cryptopay/transformers.rs | crate: hyperswitch_connectors | connector: cryptopay
use common_enums::enums;
use common_utils::{
pii,
types::{MinorUnit, StringMajorUnit},
};
use hyperswitch_domain_models::{
payment_method_data::PaymentMethodData,
router_data::{ConnectorAuthType, ErrorResponse, RouterData},
router_request_types::ResponseId,
router_response_types::{PaymentsResponseData, RedirectForm},
types,
};
use crate::{
types::ResponseRouterData,
utils::{self, CryptoData, ForeignTryFrom, PaymentsAuthorizeRequestData},
};
fn foreign_try_from(
(item, amount_captured_in_minor_units): (
ResponseRouterData<F, CryptopayPaymentsResponse, T, PaymentsResponseData>,
Option<MinorUnit>,
),
) -> Result<Self, Self::Error> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/cryptopay/transformers.rs | crate: hyperswitch_connectors | connector: cryptopay
use common_utils::{
pii,
types::{MinorUnit, StringMajorUnit},
};
use hyperswitch_domain_models::{
payment_method_data::PaymentMethodData,
router_data::{ConnectorAuthType, ErrorResponse, RouterData},
router_request_types::ResponseId,
router_response_types::{PaymentsResponseData, RedirectForm},
types,
};
use crate::{
types::ResponseRouterData,
utils::{self, CryptoData, ForeignTryFrom, PaymentsAuthorizeRequestData},
};
fn try_from(
item: &CryptopayRouterData<&types::PaymentsAuthorizeRouterData>,
) -> Result<Self, Self::Error> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/cryptopay/transformers.rs | crate: hyperswitch_connectors | connector: cryptopay
fn from(item: CryptopayPaymentStatus) -> Self {
{
CryptopayPaymentStatus::New => Self::AuthenticationPending,<|fim_suffix|>
<|fim_middle|>
CryptopayPaymentStatus::Unresolved | CryptopayPaymentStatus::Refunded => {
Self::Unresolved
}
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/cryptopay/transformers.rs | crate: hyperswitch_connectors | connector: cryptopay
fn from(item: CryptopayPaymentStatus) -> Self {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/paystack/transformers.rs | crate: hyperswitch_connectors | connector: paystack
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,
};
fn try_from(
item: RefundsResponseRouterData<RSync, PaystackRefundsResponse>,
) -> Result<Self, Self::Error> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/paystack/transformers.rs | crate: hyperswitch_connectors | connector: paystack
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,
};
fn try_from(
item: RefundsResponseRouterData<Execute, PaystackRefundsResponse>,
) -> Result<Self, Self::Error> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/paystack/transformers.rs | crate: hyperswitch_connectors | connector: paystack
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,
};
fn try_from(
item: ResponseRouterData<F, PaystackPSyncResponse, T, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/paystack/transformers.rs | crate: hyperswitch_connectors | connector: paystack
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,
};
fn try_from(
item: ResponseRouterData<F, PaystackPaymentsResponse, T, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/paystack/transformers.rs | crate: hyperswitch_connectors | connector: paystack
fn from(item: PaystackWebhookEventData) -> Self {
{
PaystackPSyncStatus::Success => Self::PaymentIntentSuccess,<|fim_suffix|>
<|fim_middle|>
PaystackPSyncStatus::Reversed => Self::EventNotSupported,
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/paystack/transformers.rs | crate: hyperswitch_connectors | connector: paystack
fn from(item: PaystackPSyncStatus) -> Self {
{
PaystackPSyncStatus::Success => Self::Charged,<|fim_suffix|>
<|fim_middle|>
PaystackPSyncStatus::Reversed => Self::Voided,
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/paystack/transformers.rs | crate: hyperswitch_connectors | connector: paystack
fn from(item: PaystackWebhookEventData) -> Self {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/paystack/transformers.rs | crate: hyperswitch_connectors | connector: paystack
pub fn get_error_message(response: PaystackErrorResponse) -> String {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/paystack/transformers.rs | crate: hyperswitch_connectors | connector: paystack
fn from(item: PaystackRefundStatus) -> Self {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/paystack/transformers.rs | crate: hyperswitch_connectors | connector: paystack
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},
};
fn try_from(item: &PaystackRouterData<&RefundsRouterData<F>>) -> Result<Self, Self::Error> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/paystack/transformers.rs | crate: hyperswitch_connectors | connector: paystack
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,
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/paystack/transformers.rs | crate: hyperswitch_connectors | connector: paystack
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},
};
fn try_from(
item: &PaystackRouterData<&PaymentsAuthorizeRouterData>,
) -> Result<Self, Self::Error> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/recurly/transformers.rs | crate: hyperswitch_connectors | connector: recurly
use common_enums::enums;
use common_utils::{
errors::CustomResult,
ext_traits::ByteSliceExt,
id_type,
types::{FloatMajorUnit, StringMinorUnit},
};
fn try_from(status: enums::AttemptStatus) -> Result<Self, Self::Error> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/recurly/transformers.rs | crate: hyperswitch_connectors | connector: recurly
use common_enums::enums;
use common_utils::types::{ConnectorTransactionId, FloatMajorUnitForConnector};
use common_utils::{
errors::CustomResult,
ext_traits::ByteSliceExt,
id_type,
types::{FloatMajorUnit, StringMinorUnit},
};
use hyperswitch_domain_models::{
router_flow_types::revenue_recovery as recovery_router_flows,
router_request_types::revenue_recovery as recovery_request_types,
router_response_types::revenue_recovery as recovery_response_types,
types as recovery_router_data_types,
};
use crate::{
types::{RefundsResponseRouterData, ResponseRouterData},
utils::PaymentsAuthorizeRequestData,
};
fn try_from(
item: ResponseRouterData<
recovery_router_flows::BillingConnectorPaymentsSync,
RecurlyRecoveryDetailsData,
recovery_request_types::BillingConnectorPaymentsSyncRequest,
recovery_response_types::BillingConnectorPaymentsSyncResponse,
>,
) -> Result<Self, Self::Error> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/recurly/transformers.rs | crate: hyperswitch_connectors | connector: recurly
fn from(funding: RecurlyFundingTypes) -> Self {
{
RecurlyFundingTypes::Credit => Self::Credit,<|fim_suffix|>
<|fim_middle|>
RecurlyFundingTypes::Debit => Self::Debit,
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/recurly/transformers.rs | crate: hyperswitch_connectors | connector: recurly
fn from(status: RecurlyChargeStatus) -> Self {
{
RecurlyChargeStatus::Succeeded => Self::Charged,<|fim_suffix|>
<|fim_middle|>
RecurlyChargeStatus::Failed => Self::Failure,
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/recurly/transformers.rs | crate: hyperswitch_connectors | connector: recurly
use common_utils::{
errors::CustomResult,
ext_traits::ByteSliceExt,
id_type,
types::{FloatMajorUnit, StringMinorUnit},
};
use hyperswitch_domain_models::{
payment_method_data::PaymentMethodData,
router_data::{ConnectorAuthType, RouterData},
router_flow_types::refunds::{Execute, RSync},
router_request_types::ResponseId,
router_response_types::{PaymentsResponseData, RefundsResponseData},
types::{PaymentsAuthorizeRouterData, RefundsRouterData},
};
fn try_from(
item: &RecurlyRouterData<&PaymentsAuthorizeRouterData>,
) -> Result<Self, Self::Error> {
{
PaymentMethodData::Card(req_card) => {
let card = RecurlyCard {
number: req_card.card_number,
expiry_month: req_card.card_exp_month,
expiry_year: req_card.card_exp_year,
cvc: req_card.card_cvc,
complete: item.router_data.request.is_auto_capture()?,
};
Ok(Self {
amount: item.amount.clone(),
card,
})
}<|fim_suffix|>
<|fim_middle|>
_ => Err(errors::ConnectorError::NotImplemented("Payment method".to_string()).into()),
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/recurly/transformers.rs | crate: hyperswitch_connectors | connector: recurly
use hyperswitch_domain_models::{
router_flow_types::revenue_recovery as recovery_router_flows,
router_request_types::revenue_recovery as recovery_request_types,
router_response_types::revenue_recovery as recovery_response_types,
types as recovery_router_data_types,
};
use crate::{
types::{RefundsResponseRouterData, ResponseRouterData},
utils::PaymentsAuthorizeRequestData,
};
fn try_from(
item: ResponseRouterData<
recovery_router_flows::RecoveryRecordBack,
RecurlyRecordBackResponse,
recovery_request_types::RevenueRecoveryRecordBackRequest,
recovery_response_types::RevenueRecoveryRecordBackResponse,
>,
) -> Result<Self, Self::Error> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/recurly/transformers.rs | crate: hyperswitch_connectors | connector: recurly
fn from(funding: RecurlyPaymentObject) -> Self {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/recurly/transformers.rs | crate: hyperswitch_connectors | connector: recurly
fn from(funding: RecurlyFundingTypes) -> Self {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/recurly/transformers.rs | crate: hyperswitch_connectors | connector: recurly
fn from(status: RecurlyChargeStatus) -> Self {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/recurly/transformers.rs | crate: hyperswitch_connectors | connector: recurly
use hyperswitch_domain_models::{
payment_method_data::PaymentMethodData,
router_data::{ConnectorAuthType, RouterData},
router_flow_types::refunds::{Execute, RSync},
router_request_types::ResponseId,
router_response_types::{PaymentsResponseData, RefundsResponseData},
types::{PaymentsAuthorizeRouterData, RefundsRouterData},
};
fn try_from(item: &RecurlyRouterData<&RefundsRouterData<F>>) -> Result<Self, Self::Error> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/recurly/transformers.rs | crate: hyperswitch_connectors | connector: recurly
use common_enums::enums;
use common_utils::types::{ConnectorTransactionId, FloatMajorUnitForConnector};
use hyperswitch_domain_models::{
payment_method_data::PaymentMethodData,
router_data::{ConnectorAuthType, RouterData},
router_flow_types::refunds::{Execute, RSync},
router_request_types::ResponseId,
router_response_types::{PaymentsResponseData, RefundsResponseData},
types::{PaymentsAuthorizeRouterData, RefundsRouterData},
};
use crate::{
types::{RefundsResponseRouterData, ResponseRouterData},
utils::PaymentsAuthorizeRequestData,
};
fn try_from(
item: ResponseRouterData<F, RecurlyPaymentsResponse, T, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/recurly/transformers.rs | crate: hyperswitch_connectors | connector: recurly
fn from(item: RecurlyPaymentStatus) -> Self {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/recurly/transformers.rs | crate: hyperswitch_connectors | connector: recurly
use common_utils::{
errors::CustomResult,
ext_traits::ByteSliceExt,
id_type,
types::{FloatMajorUnit, StringMinorUnit},
};
use hyperswitch_domain_models::{
payment_method_data::PaymentMethodData,
router_data::{ConnectorAuthType, RouterData},
router_flow_types::refunds::{Execute, RSync},
router_request_types::ResponseId,
router_response_types::{PaymentsResponseData, RefundsResponseData},
types::{PaymentsAuthorizeRouterData, RefundsRouterData},
};
fn try_from(
item: &RecurlyRouterData<&PaymentsAuthorizeRouterData>,
) -> Result<Self, Self::Error> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/prophetpay/transformers.rs | crate: hyperswitch_connectors | connector: prophetpay
use common_enums::enums;
use hyperswitch_domain_models::{
payment_method_data::{CardRedirectData, PaymentMethodData},
router_data::{ConnectorAuthType, ErrorResponse, RouterData},
router_flow_types::refunds::Execute,
router_request_types::{
CompleteAuthorizeData, CompleteAuthorizeRedirectResponse, PaymentsAuthorizeData, ResponseId,
},
router_response_types::{PaymentsResponseData, RedirectForm, RefundsResponseData},
types,
};
use crate::{
types::{RefundsResponseRouterData, ResponseRouterData},
utils::{self, to_connector_meta},
};
fn try_from(
item: RefundsResponseRouterData<T, ProphetpayRefundSyncResponse>,
) -> Result<Self, Self::Error> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/prophetpay/transformers.rs | crate: hyperswitch_connectors | connector: prophetpay
use common_enums::enums;
use hyperswitch_domain_models::{
payment_method_data::{CardRedirectData, PaymentMethodData},
router_data::{ConnectorAuthType, ErrorResponse, RouterData},
router_flow_types::refunds::Execute,
router_request_types::{
CompleteAuthorizeData, CompleteAuthorizeRedirectResponse, PaymentsAuthorizeData, ResponseId,
},
router_response_types::{PaymentsResponseData, RedirectForm, RefundsResponseData},
types,
};
use hyperswitch_interfaces::{api, consts::NO_ERROR_CODE, errors};
use crate::{
types::{RefundsResponseRouterData, ResponseRouterData},
utils::{self, to_connector_meta},
};
fn try_from(
item: RefundsResponseRouterData<Execute, ProphetpayRefundResponse>,
) -> Result<Self, Self::Error> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/prophetpay/transformers.rs | crate: hyperswitch_connectors | connector: prophetpay
use common_enums::enums;
use hyperswitch_domain_models::{
payment_method_data::{CardRedirectData, PaymentMethodData},
router_data::{ConnectorAuthType, ErrorResponse, RouterData},
router_flow_types::refunds::Execute,
router_request_types::{
CompleteAuthorizeData, CompleteAuthorizeRedirectResponse, PaymentsAuthorizeData, ResponseId,
},
router_response_types::{PaymentsResponseData, RedirectForm, RefundsResponseData},
types,
};
use crate::{
types::{RefundsResponseRouterData, ResponseRouterData},
utils::{self, to_connector_meta},
};
fn try_from(
item: ResponseRouterData<F, ProphetpayVoidResponse, T, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/prophetpay/transformers.rs | crate: hyperswitch_connectors | connector: prophetpay
use common_enums::enums;
use hyperswitch_domain_models::{
payment_method_data::{CardRedirectData, PaymentMethodData},
router_data::{ConnectorAuthType, ErrorResponse, RouterData},
router_flow_types::refunds::Execute,
router_request_types::{
CompleteAuthorizeData, CompleteAuthorizeRedirectResponse, PaymentsAuthorizeData, ResponseId,
},
router_response_types::{PaymentsResponseData, RedirectForm, RefundsResponseData},
types,
};
use crate::{
types::{RefundsResponseRouterData, ResponseRouterData},
utils::{self, to_connector_meta},
};
fn try_from(
item: ResponseRouterData<F, ProphetpaySyncResponse, T, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/prophetpay/transformers.rs | crate: hyperswitch_connectors | connector: prophetpay
use common_enums::enums;
use hyperswitch_domain_models::{
payment_method_data::{CardRedirectData, PaymentMethodData},
router_data::{ConnectorAuthType, ErrorResponse, RouterData},
router_flow_types::refunds::Execute,
router_request_types::{
CompleteAuthorizeData, CompleteAuthorizeRedirectResponse, PaymentsAuthorizeData, ResponseId,
},
router_response_types::{PaymentsResponseData, RedirectForm, RefundsResponseData},
types,
};
use masking::{ExposeInterface, PeekInterface, Secret};
use crate::{
types::{RefundsResponseRouterData, ResponseRouterData},
utils::{self, to_connector_meta},
};
fn try_from(
item: ResponseRouterData<
F,
ProphetpayCompleteAuthResponse,
CompleteAuthorizeData,
PaymentsResponseData,
>,
) -> Result<Self, Self::Error> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/prophetpay/transformers.rs | crate: hyperswitch_connectors | connector: prophetpay
use common_utils::{
consts::{PROPHETPAY_REDIRECT_URL, PROPHETPAY_TOKEN},
errors::CustomResult,
request::Method,
};
use hyperswitch_domain_models::{
payment_method_data::{CardRedirectData, PaymentMethodData},
router_data::{ConnectorAuthType, ErrorResponse, RouterData},
router_flow_types::refunds::Execute,
router_request_types::{
CompleteAuthorizeData, CompleteAuthorizeRedirectResponse, PaymentsAuthorizeData, ResponseId,
},
router_response_types::{PaymentsResponseData, RedirectForm, RefundsResponseData},
types,
};
fn get_card_token(
response: Option<CompleteAuthorizeRedirectResponse>,
) -> CustomResult<String, errors::ConnectorError> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/prophetpay/transformers.rs | crate: hyperswitch_connectors | connector: prophetpay
use common_enums::enums;
use common_utils::{
consts::{PROPHETPAY_REDIRECT_URL, PROPHETPAY_TOKEN},
errors::CustomResult,
request::Method,
};
use hyperswitch_domain_models::{
payment_method_data::{CardRedirectData, PaymentMethodData},
router_data::{ConnectorAuthType, ErrorResponse, RouterData},
router_flow_types::refunds::Execute,
router_request_types::{
CompleteAuthorizeData, CompleteAuthorizeRedirectResponse, PaymentsAuthorizeData, ResponseId,
},
router_response_types::{PaymentsResponseData, RedirectForm, RefundsResponseData},
types,
};
use crate::{
types::{RefundsResponseRouterData, ResponseRouterData},
utils::{self, to_connector_meta},
};
fn try_from(
item: ResponseRouterData<
F,
ProphetpayTokenResponse,
PaymentsAuthorizeData,
PaymentsResponseData,
>,
) -> Result<Self, Self::Error> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/prophetpay/transformers.rs | crate: hyperswitch_connectors | connector: prophetpay
use common_enums::enums;
use common_utils::{
consts::{PROPHETPAY_REDIRECT_URL, PROPHETPAY_TOKEN},
errors::CustomResult,
request::Method,
};
use hyperswitch_domain_models::{
payment_method_data::{CardRedirectData, PaymentMethodData},
router_data::{ConnectorAuthType, ErrorResponse, RouterData},
router_flow_types::refunds::Execute,
router_request_types::{
CompleteAuthorizeData, CompleteAuthorizeRedirectResponse, PaymentsAuthorizeData, ResponseId,
},
router_response_types::{PaymentsResponseData, RedirectForm, RefundsResponseData},
types,
};
use crate::{
types::{RefundsResponseRouterData, ResponseRouterData},
utils::{self, to_connector_meta},
};
fn try_from(
item: &ProphetpayRouterData<&types::PaymentsAuthorizeRouterData>,
) -> Result<Self, Self::Error> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/prophetpay/transformers.rs | crate: hyperswitch_connectors | connector: prophetpay
use crate::{
types::{RefundsResponseRouterData, ResponseRouterData},
utils::{self, to_connector_meta},
};
fn get_action_type(&self) -> i8 {
{
Self::Charge => 1,<|fim_suffix|>
<|fim_middle|>
Self::Inquiry => 7,
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/prophetpay/transformers.rs | crate: hyperswitch_connectors | connector: prophetpay
use crate::{
types::{RefundsResponseRouterData, ResponseRouterData},
utils::{self, to_connector_meta},
};
fn get_card_context(&self) -> i8 {
{
Self::NotApplicable => 0,<|fim_suffix|>
<|fim_middle|>
Self::WebConsumerInitiated => 5,
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/prophetpay/transformers.rs | crate: hyperswitch_connectors | connector: prophetpay
use crate::{
types::{RefundsResponseRouterData, ResponseRouterData},
utils::{self, to_connector_meta},
};
fn get_entry_method(&self) -> i8 {
{
Self::ManualEntry => 1,<|fim_suffix|>
<|fim_middle|>
Self::CardSwipe => 2,
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/prophetpay/transformers.rs | crate: hyperswitch_connectors | connector: prophetpay
use hyperswitch_domain_models::{
payment_method_data::{CardRedirectData, PaymentMethodData},
router_data::{ConnectorAuthType, ErrorResponse, RouterData},
router_flow_types::refunds::Execute,
router_request_types::{
CompleteAuthorizeData, CompleteAuthorizeRedirectResponse, PaymentsAuthorizeData, ResponseId,
},
router_response_types::{PaymentsResponseData, RedirectForm, RefundsResponseData},
types,
};
fn try_from(auth_type: &ConnectorAuthType) -> Result<Self, Self::Error> {
{
ConnectorAuthType::SignatureKey {
api_key,
key1,
api_secret,
} => Ok(Self {
user_name: api_key.to_owned(),
password: key1.to_owned(),
profile_id: api_secret.to_owned(),
}),<|fim_suffix|>
<|fim_middle|>
_ => Err(errors::ConnectorError::FailedToObtainAuthType.into()),
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/prophetpay/transformers.rs | crate: hyperswitch_connectors | connector: prophetpay
use common_utils::{
consts::{PROPHETPAY_REDIRECT_URL, PROPHETPAY_TOKEN},
errors::CustomResult,
request::Method,
};
use hyperswitch_domain_models::{
payment_method_data::{CardRedirectData, PaymentMethodData},
router_data::{ConnectorAuthType, ErrorResponse, RouterData},
router_flow_types::refunds::Execute,
router_request_types::{
CompleteAuthorizeData, CompleteAuthorizeRedirectResponse, PaymentsAuthorizeData, ResponseId,
},
router_response_types::{PaymentsResponseData, RedirectForm, RefundsResponseData},
types,
};
use crate::{
types::{RefundsResponseRouterData, ResponseRouterData},
utils::{self, to_connector_meta},
};
fn try_from(
item: &ProphetpayRouterData<&types::RefundsRouterData<F>>,
) -> Result<Self, Self::Error> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/prophetpay/transformers.rs | crate: hyperswitch_connectors | connector: prophetpay
use crate::{
types::{RefundsResponseRouterData, ResponseRouterData},
utils::{self, to_connector_meta},
};
fn get_action_type(&self) -> i8 {
match self {
Self::Charge => 1,
Self::Refund => 3,
Self::Inquiry => 7,
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/prophetpay/transformers.rs | crate: hyperswitch_connectors | connector: prophetpay
use hyperswitch_domain_models::{
payment_method_data::{CardRedirectData, PaymentMethodData},
router_data::{ConnectorAuthType, ErrorResponse, RouterData},
router_flow_types::refunds::Execute,
router_request_types::{
CompleteAuthorizeData, CompleteAuthorizeRedirectResponse, PaymentsAuthorizeData, ResponseId,
},
router_response_types::{PaymentsResponseData, RedirectForm, RefundsResponseData},
types,
};
use masking::{ExposeInterface, PeekInterface, Secret};
use crate::{
types::{RefundsResponseRouterData, ResponseRouterData},
utils::{self, to_connector_meta},
};
fn try_from(
item: &ProphetpayRouterData<&types::PaymentsCompleteAuthorizeRouterData>,
) -> Result<Self, Self::Error> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/prophetpay/transformers.rs | crate: hyperswitch_connectors | connector: prophetpay
use common_utils::{
consts::{PROPHETPAY_REDIRECT_URL, PROPHETPAY_TOKEN},
errors::CustomResult,
request::Method,
};
use hyperswitch_domain_models::{
payment_method_data::{CardRedirectData, PaymentMethodData},
router_data::{ConnectorAuthType, ErrorResponse, RouterData},
router_flow_types::refunds::Execute,
router_request_types::{
CompleteAuthorizeData, CompleteAuthorizeRedirectResponse, PaymentsAuthorizeData, ResponseId,
},
router_response_types::{PaymentsResponseData, RedirectForm, RefundsResponseData},
types,
};
fn get_redirect_url_form(
mut redirect_url: Url,
complete_auth_url: Option<String>,
) -> CustomResult<RedirectForm, errors::ConnectorError> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/prophetpay/transformers.rs | crate: hyperswitch_connectors | connector: prophetpay
use crate::{
types::{RefundsResponseRouterData, ResponseRouterData},
utils::{self, to_connector_meta},
};
fn get_card_context(&self) -> i8 {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/prophetpay/transformers.rs | crate: hyperswitch_connectors | connector: prophetpay
use crate::{
types::{RefundsResponseRouterData, ResponseRouterData},
utils::{self, to_connector_meta},
};
fn get_token_type(&self) -> i8 {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/prophetpay/transformers.rs | crate: hyperswitch_connectors | connector: prophetpay
use crate::{
types::{RefundsResponseRouterData, ResponseRouterData},
utils::{self, to_connector_meta},
};
fn get_entry_method(&self) -> i8 {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/getnet/transformers.rs | crate: hyperswitch_connectors | connector: getnet
pub fn get_incoming_webhook_event(
transaction_type: GetnetTransactionType,
transaction_status: GetnetPaymentStatus,
) -> IncomingWebhookEvent {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/getnet/transformers.rs | crate: hyperswitch_connectors | connector: getnet
use common_enums::{enums, AttemptStatus, CaptureMethod, CountryAlpha2};
use common_utils::{
consts::BASE64_ENGINE,
errors::CustomResult,
pii::{Email, IpAddress},
types::FloatMajorUnit,
};
use hyperswitch_domain_models::{
payment_method_data::PaymentMethodData,
router_data::{ConnectorAuthType, RouterData},
router_flow_types::refunds::{Execute, RSync},
router_request_types::{
PaymentsAuthorizeData, PaymentsCancelData, PaymentsCaptureData, ResponseId,
},
router_response_types::{PaymentsResponseData, RefundsResponseData},
types::{
PaymentsAuthorizeRouterData, PaymentsCancelRouterData, PaymentsCaptureRouterData,
PaymentsSyncRouterData, RefundsRouterData,
},
};
use masking::{PeekInterface, Secret};
fn try_from(item: &GetnetRouterData<&RefundsRouterData<F>>) -> Result<Self, Self::Error> {
let request = &item.router_data.request;
let auth_type = GetnetAuthType::try_from(&item.router_data.connector_auth_type)
.change_context(errors::ConnectorError::FailedToObtainAuthType)?;
let url = request.webhook_url.clone();
let merchant_account_id = MerchantAccountId {
value: auth_type.merchant_id,
};
let notifications = NotificationContainer {
format: NotificationFormat::JsonSigned,
notification: vec![Notification { url }],
};
let capture_method = request.capture_method;
let transaction_type = match capture_method {
Some(CaptureMethod::Automatic) => GetnetTransactionType::RefundPurchase,
Some(CaptureMethod::Manual) => GetnetTransactionType::RefundCapture,
Some(CaptureMethod::ManualMultiple)
| Some(CaptureMethod::Scheduled)
| Some(CaptureMethod::SequentialAutomatic)
| None => {
return Err(errors::ConnectorError::CaptureMethodNotSupported {}.into());
}
};
let ip_address = request
.browser_info
.as_ref()
.and_then(|browser_info| browser_info.ip_address.as_ref())
.map(|ip| Secret::new(ip.to_string()));
let request_id = item
.router_data
.refund_id
.clone()
.ok_or(errors::ConnectorError::MissingConnectorRefundID)?;
let parent_transaction_id = item.router_data.request.connector_transaction_id.clone();
let refund_payment_data = RefundPaymentData {
merchant_account_id,
request_id,
transaction_type,
parent_transaction_id,
notifications,
ip_address,
};
Ok(Self {
payment: refund_payment_data,
})
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/getnet/transformers.rs | crate: hyperswitch_connectors | connector: getnet
use common_utils::{
consts::BASE64_ENGINE,
errors::CustomResult,
pii::{Email, IpAddress},
types::FloatMajorUnit,
};
use hyperswitch_domain_models::{
payment_method_data::PaymentMethodData,
router_data::{ConnectorAuthType, RouterData},
router_flow_types::refunds::{Execute, RSync},
router_request_types::{
PaymentsAuthorizeData, PaymentsCancelData, PaymentsCaptureData, ResponseId,
},
router_response_types::{PaymentsResponseData, RefundsResponseData},
types::{
PaymentsAuthorizeRouterData, PaymentsCancelRouterData, PaymentsCaptureRouterData,
PaymentsSyncRouterData, RefundsRouterData,
},
};
use masking::{PeekInterface, Secret};
fn try_from(item: &GetnetRouterData<&PaymentsCaptureRouterData>) -> Result<Self, Self::Error> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/getnet/transformers.rs | crate: hyperswitch_connectors | connector: getnet
use hyperswitch_domain_models::{
payment_method_data::PaymentMethodData,
router_data::{ConnectorAuthType, RouterData},
router_flow_types::refunds::{Execute, RSync},
router_request_types::{
PaymentsAuthorizeData, PaymentsCancelData, PaymentsCaptureData, ResponseId,
},
router_response_types::{PaymentsResponseData, RefundsResponseData},
types::{
PaymentsAuthorizeRouterData, PaymentsCancelRouterData, PaymentsCaptureRouterData,
PaymentsSyncRouterData, RefundsRouterData,
},
};
use crate::{
connectors::paybox::transformers::parse_url_encoded_to_struct,
types::{PaymentsSyncResponseRouterData, RefundsResponseRouterData, ResponseRouterData},
utils::{
BrowserInformationData, PaymentsAuthorizeRequestData, PaymentsSyncRequestData,
RouterData as _,
},
};
fn try_from(
item: PaymentsSyncResponseRouterData<GetnetPaymentsResponse>,
) -> Result<Self, Self::Error> {
{
GetnetPaymentsResponse::PaymentsResponse(ref payment_response) => Ok(Self {
status: authorization_attempt_status_from_transaction_state(
payment_response.payment.transaction_state.clone(),
item.data.request.is_auto_capture()?,
),
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(
payment_response.payment.transaction_id.clone(),
),
redirection_data: Box::new(None),
mandate_reference: Box::new(None),
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: None,
incremental_authorization_allowed: None,
charges: None,
}),
..item.data
}),<|fim_suffix|>
<|fim_middle|>
GetnetPaymentsResponse::GetnetWebhookNotificationResponse(ref webhook_response) => {
Ok(Self {
status: psync_attempt_status_from_transaction_state(
webhook_response.payment.transaction_state.clone(),
item.data.request.is_auto_capture()?,
webhook_response.payment.transaction_type.clone(),
),
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(
webhook_response.payment.transaction_id.clone(),
),
redirection_data: Box::new(None),
mandate_reference: Box::new(None),
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: None,
incremental_authorization_allowed: None,
charges: None,
}),
..item.data
})
}
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/getnet/transformers.rs | crate: hyperswitch_connectors | connector: getnet
use common_utils::{
consts::BASE64_ENGINE,
errors::CustomResult,
pii::{Email, IpAddress},
types::FloatMajorUnit,
};
use error_stack::ResultExt;
use hyperswitch_domain_models::{
payment_method_data::PaymentMethodData,
router_data::{ConnectorAuthType, RouterData},
router_flow_types::refunds::{Execute, RSync},
router_request_types::{
PaymentsAuthorizeData, PaymentsCancelData, PaymentsCaptureData, ResponseId,
},
router_response_types::{PaymentsResponseData, RefundsResponseData},
types::{
PaymentsAuthorizeRouterData, PaymentsCancelRouterData, PaymentsCaptureRouterData,
PaymentsSyncRouterData, RefundsRouterData,
},
};
use crate::{
connectors::paybox::transformers::parse_url_encoded_to_struct,
types::{PaymentsSyncResponseRouterData, RefundsResponseRouterData, ResponseRouterData},
utils::{
BrowserInformationData, PaymentsAuthorizeRequestData, PaymentsSyncRequestData,
RouterData as _,
},
};
fn try_from(
item: ResponseRouterData<
F,
GetnetPaymentsResponse,
PaymentsAuthorizeData,
PaymentsResponseData,
>,
) -> Result<Self, Self::Error> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/getnet/transformers.rs | crate: hyperswitch_connectors | connector: getnet | op: refund
pub fn is_refund_event(transaction_type: &GetnetTransactionType) -> bool {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/getnet/transformers.rs | crate: hyperswitch_connectors | connector: getnet
pub notifications: NotificationContainer,
#[serde(rename = "ip-address")]
pub ip_address: Option<Secret<String, IpAddress>>,
}
#[derive(Debug, Serialize)]
pub struct GetnetCancelRequest {
pub payment: CancelPaymentData,
}
impl TryFrom<&PaymentsCancelRouterData> for GetnetCancelRequest {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(item: &PaymentsCancelRouterData) -> Result<Self, Self::Error> {
let request = &item.request;
let auth_type = GetnetAuthType::try_from(&item.connector_auth_type)
.change_context(errors::ConnectorError::FailedToObtainAuthType)?;
let merchant_account_id = MerchantAccountId {
value: auth_type.merchant_id,
};
let webhook_url = &item.request.webhook_url;
let notifications = NotificationContainer {
format: NotificationFormat::JsonSigned,
notification: vec![Notification {
fn try_from(item: &PaymentsCancelRouterData) -> Result<Self, Self::Error> {
{
Some(CaptureMethod::Automatic) => GetnetTransactionType::VoidPurchase,<|fim_suffix|>
<|fim_middle|>
None => {
return Err(errors::ConnectorError::CaptureMethodNotSupported {}.into());
}
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/getnet/transformers.rs | crate: hyperswitch_connectors | connector: getnet
fn from(item: RefundStatus) -> Self {
{
RefundStatus::Success => Self::Success,<|fim_suffix|>
<|fim_middle|>
RefundStatus::InProgress => Self::Pending,
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/getnet/transformers.rs | crate: hyperswitch_connectors | connector: getnet
pub parent_transaction_id: String,
pub notifications: NotificationContainer,
#[serde(rename = "ip-address")]
pub ip_address: Option<Secret<String, IpAddress>>,
}
#[derive(Debug, Serialize)]
pub struct GetnetRefundRequest {
pub payment: RefundPaymentData,
}
impl<F> TryFrom<&GetnetRouterData<&RefundsRouterData<F>>> for GetnetRefundRequest {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(item: &GetnetRouterData<&RefundsRouterData<F>>) -> Result<Self, Self::Error> {
let request = &item.router_data.request;
let auth_type = GetnetAuthType::try_from(&item.router_data.connector_auth_type)
.change_context(errors::ConnectorError::FailedToObtainAuthType)?;
let url = request.webhook_url.clone();
let merchant_account_id = MerchantAccountId {
value: auth_type.merchant_id,
};
let notifications = NotificationContainer {
format: NotificationFormat::JsonSigned,
notification: vec![Notification { url }],
};
fn try_from(item: &GetnetRouterData<&RefundsRouterData<F>>) -> Result<Self, Self::Error> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/getnet/transformers.rs | crate: hyperswitch_connectors | connector: getnet
use common_utils::{
consts::BASE64_ENGINE,
errors::CustomResult,
pii::{Email, IpAddress},
types::FloatMajorUnit,
};
use crate::{
connectors::paybox::transformers::parse_url_encoded_to_struct,
types::{PaymentsSyncResponseRouterData, RefundsResponseRouterData, ResponseRouterData},
utils::{
BrowserInformationData, PaymentsAuthorizeRequestData, PaymentsSyncRequestData,
RouterData as _,
},
};
pub fn get_webhook_response(
body: &[u8],
) -> CustomResult<GetnetWebhookNotificationResponse, errors::ConnectorError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/getnet/transformers.rs | crate: hyperswitch_connectors | connector: getnet
use common_utils::{
consts::BASE64_ENGINE,
errors::CustomResult,
pii::{Email, IpAddress},
types::FloatMajorUnit,
};
use crate::{
connectors::paybox::transformers::parse_url_encoded_to_struct,
types::{PaymentsSyncResponseRouterData, RefundsResponseRouterData, ResponseRouterData},
utils::{
BrowserInformationData, PaymentsAuthorizeRequestData, PaymentsSyncRequestData,
RouterData as _,
},
};
pub fn get_webhook_object_from_body(
body: &[u8],
) -> CustomResult<GetnetWebhookNotificationResponseBody, errors::ConnectorError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/getnet/transformers.rs | crate: hyperswitch_connectors | connector: getnet | op: refund
pub fn is_refund_event(transaction_type: &GetnetTransactionType) -> bool {
matches!(
transaction_type,
GetnetTransactionType::RefundPurchase | GetnetTransactionType::RefundCapture
)
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/getnet/transformers.rs | crate: hyperswitch_connectors | connector: getnet
use hyperswitch_domain_models::{
payment_method_data::PaymentMethodData,
router_data::{ConnectorAuthType, RouterData},
router_flow_types::refunds::{Execute, RSync},
router_request_types::{
PaymentsAuthorizeData, PaymentsCancelData, PaymentsCaptureData, ResponseId,
},
router_response_types::{PaymentsResponseData, RefundsResponseData},
types::{
PaymentsAuthorizeRouterData, PaymentsCancelRouterData, PaymentsCaptureRouterData,
PaymentsSyncRouterData, RefundsRouterData,
},
};
use crate::{
connectors::paybox::transformers::parse_url_encoded_to_struct,
types::{PaymentsSyncResponseRouterData, RefundsResponseRouterData, ResponseRouterData},
utils::{
BrowserInformationData, PaymentsAuthorizeRequestData, PaymentsSyncRequestData,
RouterData as _,
},
};
fn try_from(
item: ResponseRouterData<F, GetnetCancelResponse, PaymentsCancelData, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/getnet/transformers.rs | crate: hyperswitch_connectors | connector: getnet | op: cancel
use common_enums::{enums, AttemptStatus, CaptureMethod, CountryAlpha2};
pub fn cancel_status_from_transaction_state(getnet_status: GetnetPaymentStatus) -> AttemptStatus {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/getnet/transformers.rs | crate: hyperswitch_connectors | connector: getnet
use hyperswitch_domain_models::{
payment_method_data::PaymentMethodData,
router_data::{ConnectorAuthType, RouterData},
router_flow_types::refunds::{Execute, RSync},
router_request_types::{
PaymentsAuthorizeData, PaymentsCancelData, PaymentsCaptureData, ResponseId,
},
router_response_types::{PaymentsResponseData, RefundsResponseData},
types::{
PaymentsAuthorizeRouterData, PaymentsCancelRouterData, PaymentsCaptureRouterData,
PaymentsSyncRouterData, RefundsRouterData,
},
};
use crate::{
connectors::paybox::transformers::parse_url_encoded_to_struct,
types::{PaymentsSyncResponseRouterData, RefundsResponseRouterData, ResponseRouterData},
utils::{
BrowserInformationData, PaymentsAuthorizeRequestData, PaymentsSyncRequestData,
RouterData as _,
},
};
fn try_from(
item: ResponseRouterData<
F,
GetnetCaptureResponse,
PaymentsCaptureData,
PaymentsResponseData,
>,
) -> Result<Self, Self::Error> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/getnet/transformers.rs | crate: hyperswitch_connectors | connector: getnet | op: capture
use common_enums::{enums, AttemptStatus, CaptureMethod, CountryAlpha2};
pub fn capture_status_from_transaction_state(getnet_status: GetnetPaymentStatus) -> AttemptStatus {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/getnet/transformers.rs | crate: hyperswitch_connectors | connector: getnet | op: sync
use common_enums::{enums, AttemptStatus, CaptureMethod, CountryAlpha2};
pub fn psync_attempt_status_from_transaction_state(
getnet_status: GetnetPaymentStatus,
is_auto_capture: bool,
transaction_type: GetnetTransactionType,
) -> AttemptStatus {
{
GetnetPaymentStatus::Success => {
if is_auto_capture && transaction_type == GetnetTransactionType::CaptureAuthorization {
AttemptStatus::Charged
} else {
AttemptStatus::Authorized
}
}<|fim_suffix|>
<|fim_middle|>
GetnetPaymentStatus::Failed => AttemptStatus::Failure,
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/getnet/transformers.rs | crate: hyperswitch_connectors | connector: getnet
use common_enums::{enums, AttemptStatus, CaptureMethod, CountryAlpha2};
pub fn authorization_attempt_status_from_transaction_state(
getnet_status: GetnetPaymentStatus,
is_auto_capture: bool,
) -> AttemptStatus {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/getnet/transformers.rs | crate: hyperswitch_connectors | connector: getnet
fn from(item: GetnetPaymentStatus) -> Self {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/getnet/transformers.rs | crate: hyperswitch_connectors | connector: getnet
use common_enums::{enums, AttemptStatus, CaptureMethod, CountryAlpha2};
use common_utils::{
consts::BASE64_ENGINE,
errors::CustomResult,
pii::{Email, IpAddress},
types::FloatMajorUnit,
};
use crate::{
connectors::paybox::transformers::parse_url_encoded_to_struct,
types::{PaymentsSyncResponseRouterData, RefundsResponseRouterData, ResponseRouterData},
utils::{
BrowserInformationData, PaymentsAuthorizeRequestData, PaymentsSyncRequestData,
RouterData as _,
},
};
fn try_from(payment_method_type: enums::PaymentMethodType) -> Result<Self, Self::Error> {
match payment_method_type {
enums::PaymentMethodType::Credit => Ok(Self {
payment_method: vec![PaymentMethod {
name: GetnetPaymentMethods::CreditCard,
}],
}),
_ => Err(errors::ConnectorError::NotSupported {
message: "Payment method type not supported".to_string(),
connector: "Getnet",
}
.into()),
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/getnet/transformers.rs | crate: hyperswitch_connectors | connector: getnet
use common_utils::{
consts::BASE64_ENGINE,
errors::CustomResult,
pii::{Email, IpAddress},
types::FloatMajorUnit,
};
use hyperswitch_domain_models::{
payment_method_data::PaymentMethodData,
router_data::{ConnectorAuthType, RouterData},
router_flow_types::refunds::{Execute, RSync},
router_request_types::{
PaymentsAuthorizeData, PaymentsCancelData, PaymentsCaptureData, ResponseId,
},
router_response_types::{PaymentsResponseData, RefundsResponseData},
types::{
PaymentsAuthorizeRouterData, PaymentsCancelRouterData, PaymentsCaptureRouterData,
PaymentsSyncRouterData, RefundsRouterData,
},
};
use crate::{
connectors::paybox::transformers::parse_url_encoded_to_struct,
types::{PaymentsSyncResponseRouterData, RefundsResponseRouterData, ResponseRouterData},
utils::{
BrowserInformationData, PaymentsAuthorizeRequestData, PaymentsSyncRequestData,
RouterData as _,
},
};
fn try_from(
item: &GetnetRouterData<&PaymentsAuthorizeRouterData>,
) -> Result<Self, Self::Error> {
{
PaymentMethodData::Card(ref req_card) => {
if item.router_data.is_three_ds() {
return Err(errors::ConnectorError::NotSupported {
message: "3DS payments".to_string(),
connector: "Getnet",
}
.into());
}
let request = &item.router_data.request;
let auth_type = GetnetAuthType::try_from(&item.router_data.connector_auth_type)
.change_context(errors::ConnectorError::FailedToObtainAuthType)?;
let merchant_account_id = MerchantAccountId {
value: auth_type.merchant_id,
};
let requested_amount = Amount {
value: item.amount,
currency: request.currency,
};
let account_holder = AccountHolder {
first_name: item.router_data.get_optional_billing_first_name(),
last_name: item.router_data.get_optional_billing_last_name(),
email: item.router_data.request.get_optional_email(),
phone: item.router_data.get_optional_billing_phone_number(),
address: Some(Address {
street1: item.router_data.get_optional_billing_line2(),
city: item.router_data.get_optional_billing_city(),
state: item.router_data.get_optional_billing_state(),
country: item.router_data.get_optional_billing_country(),
}),
};
let card = Card {
account_number: req_card.card_number.clone(),
expiration_month: req_card.card_exp_month.clone(),
expiration_year: req_card.card_exp_year.clone(),
card_security_code: req_card.card_cvc.clone(),
card_type: req_card
.card_network
.as_ref()
.map(|network| network.to_string().to_lowercase())
.unwrap_or_default(),
};
let pmt = item.router_data.request.get_payment_method_type()?;
let payment_method = PaymentMethodContainer::try_from(pmt)?;
let notifications: NotificationContainer = NotificationContainer {
format: NotificationFormat::JsonSigned,
notification: vec![Notification {
url: Some(item.router_data.request.get_webhook_url()?),
}],
};
let transaction_type = if request.is_auto_capture()? {
GetnetTransactionType::Purchase
} else {
GetnetTransactionType::Authorization
};
let payment_data = PaymentData {
merchant_account_id,
request_id: item.router_data.payment_id.clone(),
transaction_type,
requested_amount,
account_holder: Some(account_holder),
card,
ip_address: Some(request.get_browser_info()?.get_ip_address()?),
payment_methods: payment_method,
notifications: Some(notifications),
};
Ok(Self {
payment: payment_data,
})
}<|fim_suffix|>
<|fim_middle|>
_ => Err(errors::ConnectorError::NotImplemented("Payment method".to_string()).into()),
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/paypal/transformers.rs | crate: hyperswitch_connectors | connector: paypal
use api_models::{enums, webhooks::IncomingWebhookEvent};
use crate::{constants, types::PayoutsResponseRouterData};
use crate::{
types::{PaymentsCaptureResponseRouterData, RefundsResponseRouterData, ResponseRouterData},
utils::{
self, missing_field_err, to_connector_meta, AccessTokenRequestInfo, AddressDetailsData,
CardData, PaymentsAuthorizeRequestData, PaymentsPostSessionTokensRequestData,
RouterData as OtherRouterData,
},
};
pub(crate) fn get_payapl_webhooks_event(
event: PaypalWebhookEventType,
outcome: Option<OutcomeCode>,
) -> IncomingWebhookEvent {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/paypal/transformers.rs | crate: hyperswitch_connectors | connector: paypal
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,
},
};
fn try_from(
item: PaymentsCaptureResponseRouterData<PaypalCaptureResponse>,
) -> Result<Self, Self::Error> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/paypal/transformers.rs | crate: hyperswitch_connectors | connector: paypal
use common_enums::enums as storage_enums;
use hyperswitch_domain_models::{
payment_method_data::{
BankDebitData, BankRedirectData, BankTransferData, CardRedirectData, GiftCardData,
PayLaterData, PaymentMethodData, VoucherData, WalletData,
},
router_data::{AccessToken, ConnectorAuthType, RouterData},
router_flow_types::{
payments::{Authorize, PostSessionTokens},
refunds::{Execute, RSync},
VerifyWebhookSource,
},
router_request_types::{
PaymentsAuthorizeData, PaymentsPostSessionTokensData, PaymentsSyncData, ResponseId,
VerifyWebhookSourceRequestData,
},
router_response_types::{
MandateReference, PaymentsResponseData, RedirectForm, RefundsResponseData,
VerifyWebhookSourceResponseData, VerifyWebhookStatus,
},
types::{
PaymentsAuthorizeRouterData, PaymentsCaptureRouterData,
PaymentsPostSessionTokensRouterData, RefreshTokenRouterData, RefundsRouterData,
SdkSessionUpdateRouterData, SetupMandateRouterData, VerifyWebhookSourceRouterData,
},
};
use crate::{
types::{PaymentsCaptureResponseRouterData, RefundsResponseRouterData, ResponseRouterData},
utils::{
self, missing_field_err, to_connector_meta, AccessTokenRequestInfo, AddressDetailsData,
CardData, PaymentsAuthorizeRequestData, PaymentsPostSessionTokensRequestData,
RouterData as OtherRouterData,
},
};
fn try_from(
item: ResponseRouterData<F, PaypalPaymentsSyncResponse, T, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/paypal/transformers.rs | crate: hyperswitch_connectors | connector: paypal
use common_enums::enums as storage_enums;
use common_utils::{consts, errors::CustomResult, request::Method, types::StringMajorUnit};
use hyperswitch_domain_models::{
payment_method_data::{
BankDebitData, BankRedirectData, BankTransferData, CardRedirectData, GiftCardData,
PayLaterData, PaymentMethodData, VoucherData, WalletData,
},
router_data::{AccessToken, ConnectorAuthType, RouterData},
router_flow_types::{
payments::{Authorize, PostSessionTokens},
refunds::{Execute, RSync},
VerifyWebhookSource,
},
router_request_types::{
PaymentsAuthorizeData, PaymentsPostSessionTokensData, PaymentsSyncData, ResponseId,
VerifyWebhookSourceRequestData,
},
router_response_types::{
MandateReference, PaymentsResponseData, RedirectForm, RefundsResponseData,
VerifyWebhookSourceResponseData, VerifyWebhookStatus,
},
types::{
PaymentsAuthorizeRouterData, PaymentsCaptureRouterData,
PaymentsPostSessionTokensRouterData, RefreshTokenRouterData, RefundsRouterData,
SdkSessionUpdateRouterData, SetupMandateRouterData, VerifyWebhookSourceRouterData,
},
};
use url::Url;
use crate::{
types::{PaymentsCaptureResponseRouterData, RefundsResponseRouterData, ResponseRouterData},
utils::{
self, missing_field_err, to_connector_meta, AccessTokenRequestInfo, AddressDetailsData,
CardData, PaymentsAuthorizeRequestData, PaymentsPostSessionTokensRequestData,
RouterData as OtherRouterData,
},
};
fn paypal_threeds_link(
(redirect_url, complete_auth_url): (Option<Url>, Option<String>),
) -> CustomResult<RedirectForm, errors::ConnectorError> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/paypal/transformers.rs | crate: hyperswitch_connectors | connector: paypal
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,
},
};
fn try_from(
item: ResponseRouterData<
F,
PaypalThreeDsResponse,
PaymentsAuthorizeData,
PaymentsResponseData,
>,
) -> Result<Self, Self::Error> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/paypal/transformers.rs | crate: hyperswitch_connectors | connector: paypal
use api_models::{enums, webhooks::IncomingWebhookEvent};
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,
},
};
fn try_from(
item: ResponseRouterData<
PostSessionTokens,
PaypalRedirectResponse,
PaymentsPostSessionTokensData,
PaymentsResponseData,
>,
) -> Result<Self, Self::Error> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/paypal/transformers.rs | crate: hyperswitch_connectors | connector: paypal
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,
},
};
fn try_from(
item: ResponseRouterData<
Authorize,
PaypalRedirectResponse,
PaymentsAuthorizeData,
PaymentsResponseData,
>,
) -> Result<Self, Self::Error> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/paypal/transformers.rs | crate: hyperswitch_connectors | connector: paypal
use api_models::{enums, webhooks::IncomingWebhookEvent};
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,
},
};
fn foreign_try_from(
(item, payment_experience): (
ResponseRouterData<F, PaypalRedirectResponse, T, PaymentsResponseData>,
Option<common_enums::PaymentExperience>,
),
) -> Result<Self, Self::Error> {
let status = get_order_status(item.response.clone().status, item.response.intent.clone());
let link = get_redirect_url(item.response.links.clone())?;
// For Paypal SDK flow, we need to trigger SDK client and then complete authorize
let next_action =
if let Some(common_enums::PaymentExperience::InvokeSdkClient) = payment_experience {
Some(api_models::payments::NextActionCall::CompleteAuthorize)
} else {
None
};
let connector_meta = serde_json::json!(PaypalMeta {
authorize_id: None,
capture_id: None,
psync_flow: item.response.intent,
next_action,
order_id: None,
});
let purchase_units = item.response.purchase_units.first();
Ok(Self {
status,
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(item.response.id.clone()),
redirection_data: Box::new(Some(RedirectForm::from((
link.ok_or(errors::ConnectorError::ResponseDeserializationFailed)?,
Method::Get,
)))),
mandate_reference: Box::new(None),
connector_metadata: Some(connector_meta),
network_txn_id: None,
connector_response_reference_id: Some(
purchase_units.map_or(item.response.id, |item| item.invoice_id.clone()),
),
incremental_authorization_allowed: None,
charges: None,
}),
..item.data
})
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/paypal/transformers.rs | crate: hyperswitch_connectors | connector: paypal
use common_enums::enums as storage_enums;
use hyperswitch_domain_models::{
payment_method_data::{
BankDebitData, BankRedirectData, BankTransferData, CardRedirectData, GiftCardData,
PayLaterData, PaymentMethodData, VoucherData, WalletData,
},
router_data::{AccessToken, ConnectorAuthType, RouterData},
router_flow_types::{
payments::{Authorize, PostSessionTokens},
refunds::{Execute, RSync},
VerifyWebhookSource,
},
router_request_types::{
PaymentsAuthorizeData, PaymentsPostSessionTokensData, PaymentsSyncData, ResponseId,
VerifyWebhookSourceRequestData,
},
router_response_types::{
MandateReference, PaymentsResponseData, RedirectForm, RefundsResponseData,
VerifyWebhookSourceResponseData, VerifyWebhookStatus,
},
types::{
PaymentsAuthorizeRouterData, PaymentsCaptureRouterData,
PaymentsPostSessionTokensRouterData, RefreshTokenRouterData, RefundsRouterData,
SdkSessionUpdateRouterData, SetupMandateRouterData, VerifyWebhookSourceRouterData,
},
};
use crate::{
types::{PaymentsCaptureResponseRouterData, RefundsResponseRouterData, ResponseRouterData},
utils::{
self, missing_field_err, to_connector_meta, AccessTokenRequestInfo, AddressDetailsData,
CardData, PaymentsAuthorizeRequestData, PaymentsPostSessionTokensRequestData,
RouterData as OtherRouterData,
},
};
fn foreign_try_from(
(item, payment_experience): (
ResponseRouterData<F, PaypalSyncResponse, PaymentsSyncData, PaymentsResponseData>,
Option<common_enums::PaymentExperience>,
),
) -> Result<Self, Self::Error> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/paypal/transformers.rs | crate: hyperswitch_connectors | connector: paypal
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,
},
};
fn get_id_based_on_intent(
intent: &PaypalPaymentIntent,
purchase_unit: &PurchaseUnitItem,
) -> CustomResult<String, errors::ConnectorError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/paypal/transformers.rs | crate: hyperswitch_connectors | connector: paypal
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,
},
};
fn try_from(item: &SetupMandateRouterData) -> Result<Self, Self::Error> {
let payment_source = match item.request.payment_method_data.clone() {
PaymentMethodData::Card(ccard) => ZeroMandateSourceItem::Card(CardMandateRequest {
billing_address: get_address_info(item.get_optional_billing()),
expiry: Some(ccard.get_expiry_date_as_yyyymm("-")),
name: item.get_optional_billing_full_name(),
number: Some(ccard.card_number),
}),
PaymentMethodData::Wallet(_)
| PaymentMethodData::CardRedirect(_)
| PaymentMethodData::PayLater(_)
| PaymentMethodData::BankRedirect(_)
| PaymentMethodData::BankDebit(_)
| PaymentMethodData::BankTransfer(_)
| PaymentMethodData::Crypto(_)
| PaymentMethodData::MandatePayment
| PaymentMethodData::Reward
| PaymentMethodData::RealTimePayment(_)
| PaymentMethodData::Upi(_)
| PaymentMethodData::Voucher(_)
| PaymentMethodData::GiftCard(_)
| PaymentMethodData::CardToken(_)
| PaymentMethodData::CardDetailsForNetworkTransactionId(_)
| PaymentMethodData::NetworkToken(_)
| PaymentMethodData::OpenBanking(_)
| PaymentMethodData::MobilePayment(_) => Err(errors::ConnectorError::NotImplemented(
utils::get_unimplemented_payment_method_error_message("Paypal"),
))?,
};
Ok(Self { payment_source })
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/paypal/transformers.rs | crate: hyperswitch_connectors | connector: paypal
use api_models::{enums, webhooks::IncomingWebhookEvent};
use common_enums::enums as storage_enums;
use hyperswitch_domain_models::{
payment_method_data::{
BankDebitData, BankRedirectData, BankTransferData, CardRedirectData, GiftCardData,
PayLaterData, PaymentMethodData, VoucherData, WalletData,
},
router_data::{AccessToken, ConnectorAuthType, RouterData},
router_flow_types::{
payments::{Authorize, PostSessionTokens},
refunds::{Execute, RSync},
VerifyWebhookSource,
},
router_request_types::{
PaymentsAuthorizeData, PaymentsPostSessionTokensData, PaymentsSyncData, ResponseId,
VerifyWebhookSourceRequestData,
},
router_response_types::{
MandateReference, PaymentsResponseData, RedirectForm, RefundsResponseData,
VerifyWebhookSourceResponseData, VerifyWebhookStatus,
},
types::{
PaymentsAuthorizeRouterData, PaymentsCaptureRouterData,
PaymentsPostSessionTokensRouterData, RefreshTokenRouterData, RefundsRouterData,
SdkSessionUpdateRouterData, SetupMandateRouterData, VerifyWebhookSourceRouterData,
},
};
use crate::{
types::{PaymentsCaptureResponseRouterData, RefundsResponseRouterData, ResponseRouterData},
utils::{
self, missing_field_err, to_connector_meta, AccessTokenRequestInfo, AddressDetailsData,
CardData, PaymentsAuthorizeRequestData, PaymentsPostSessionTokensRequestData,
RouterData as OtherRouterData,
},
};
fn try_from(
item: ResponseRouterData<F, PaypalSetupMandatesResponse, T, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/paypal/transformers.rs | crate: hyperswitch_connectors | connector: paypal
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,
},
};
fn try_from(item: &PaypalRouterData<&SdkSessionUpdateRouterData>) -> Result<Self, Self::Error> {
Ok(Self {
currency_code: item.router_data.request.currency,
value: item.amount.clone(),
breakdown: AmountBreakdown {
item_total: OrderAmount {
currency_code: item.router_data.request.currency,
value: item.order_amount.clone().ok_or(
errors::ConnectorError::MissingRequiredField {
field_name: "order_amount",
},
)?,
},
tax_total: Some(OrderAmount {
currency_code: item.router_data.request.currency,
value: item.order_tax_amount.clone().ok_or(
errors::ConnectorError::MissingRequiredField {
field_name: "order_tax_amount",
},
)?,
}),
shipping: Some(OrderAmount {
currency_code: item.router_data.request.currency,
value: item
.shipping_cost
.clone()
.unwrap_or(StringMajorUnit::zero()),
}),
},
})
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/paypal/transformers.rs | crate: hyperswitch_connectors | connector: paypal
fn from(item: PaypalSourceVerificationStatus) -> Self {
{
PaypalSourceVerificationStatus::Success => Self::SourceVerified,<|fim_suffix|>
<|fim_middle|>
PaypalSourceVerificationStatus::Failure => Self::SourceNotVerified,
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/paypal/transformers.rs | crate: hyperswitch_connectors | connector: paypal
fn from(dispute_life_cycle_stage: DisputeLifeCycleStage) -> Self {
{
DisputeLifeCycleStage::Inquiry => Self::PreDispute,<|fim_suffix|>
<|fim_middle|>
DisputeLifeCycleStage::Arbitration => Self::PreArbitration,
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/paypal/transformers.rs | crate: hyperswitch_connectors | connector: paypal
fn from(outcome_code: OutcomeCode) -> Self {
{
OutcomeCode::ResolvedBuyerFavour => Self::DisputeLost,<|fim_suffix|>
<|fim_middle|>
OutcomeCode::ResolvedWithPayout => Self::EventNotSupported,
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/paypal/transformers.rs | crate: hyperswitch_connectors | connector: paypal
use api_models::{enums, webhooks::IncomingWebhookEvent};
use crate::{constants, types::PayoutsResponseRouterData};
use crate::{
types::{PaymentsCaptureResponseRouterData, RefundsResponseRouterData, ResponseRouterData},
utils::{
self, missing_field_err, to_connector_meta, AccessTokenRequestInfo, AddressDetailsData,
CardData, PaymentsAuthorizeRequestData, PaymentsPostSessionTokensRequestData,
RouterData as OtherRouterData,
},
};
pub(crate) fn get_payapl_webhooks_event(
event: PaypalWebhookEventType,
outcome: Option<OutcomeCode>,
) -> IncomingWebhookEvent {
{
PaypalWebhookEventType::PaymentCaptureCompleted
| PaypalWebhookEventType::CheckoutOrderCompleted => {
IncomingWebhookEvent::PaymentIntentSuccess
}<|fim_suffix|>
<|fim_middle|>
PaypalWebhookEventType::PaymentAuthorizationCreated
| PaypalWebhookEventType::PaymentAuthorizationVoided
| PaypalWebhookEventType::CheckoutOrderApproved
| PaypalWebhookEventType::CustomerDisputedUpdated
| PaypalWebhookEventType::Unknown => IncomingWebhookEvent::EventNotSupported,
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/paypal/transformers.rs | crate: hyperswitch_connectors | connector: paypal
fn from(error: ErrorDetails) -> Self {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/paypal/transformers.rs | crate: hyperswitch_connectors | connector: paypal
fn from(error: OrderErrorDetails) -> Self {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/paypal/transformers.rs | crate: hyperswitch_connectors | connector: paypal
use common_utils::{consts, errors::CustomResult, request::Method, types::StringMajorUnit};
fn get_headers(
header: &actix_web::http::header::HeaderMap,
key: &'static str,
) -> CustomResult<String, errors::ConnectorError> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/paypal/transformers.rs | crate: hyperswitch_connectors | connector: paypal
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,
},
};
fn try_from(req: &VerifyWebhookSourceRequestData) -> Result<Self, Self::Error> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/paypal/transformers.rs | crate: hyperswitch_connectors | connector: paypal
use common_utils::{consts, errors::CustomResult, request::Method, types::StringMajorUnit};
fn try_from(event: PaypalWebhookEventType) -> Result<Self, Self::Error> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/paypal/transformers.rs | crate: hyperswitch_connectors | connector: paypal
use common_utils::{consts, errors::CustomResult, request::Method, types::StringMajorUnit};
fn try_from(event: PaypalWebhookEventType) -> Result<Self, Self::Error> {
match event {
PaypalWebhookEventType::PaymentCaptureCompleted
| PaypalWebhookEventType::CheckoutOrderCompleted => Ok(Self::Completed),
PaypalWebhookEventType::PaymentAuthorizationVoided => Ok(Self::Voided),
PaypalWebhookEventType::PaymentCaptureDeclined => Ok(Self::Declined),
PaypalWebhookEventType::PaymentCapturePending
| PaypalWebhookEventType::CheckoutOrderApproved
| PaypalWebhookEventType::CheckoutOrderProcessed => Ok(Self::Pending),
PaypalWebhookEventType::PaymentAuthorizationCreated => Ok(Self::Created),
PaypalWebhookEventType::PaymentCaptureRefunded => Ok(Self::Refunded),
PaypalWebhookEventType::CustomerDisputeCreated
| PaypalWebhookEventType::CustomerDisputeResolved
| PaypalWebhookEventType::CustomerDisputedUpdated
| PaypalWebhookEventType::RiskDisputeCreated
| PaypalWebhookEventType::Unknown => {
Err(errors::ConnectorError::WebhookEventTypeNotFound.into())
}
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/paypal/transformers.rs | crate: hyperswitch_connectors | connector: paypal
fn try_from(
(webhook_body, webhook_event): (PaypalRefundWebhooks, PaypalWebhookEventType),
) -> Result<Self, Self::Error> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/paypal/transformers.rs | crate: hyperswitch_connectors | connector: paypal
fn try_from(
(webhook_body, webhook_event): (PaypalRedirectsWebhooks, PaypalWebhookEventType),
) -> Result<Self, Self::Error> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/paypal/transformers.rs | crate: hyperswitch_connectors | connector: paypal
fn try_from(
(webhook_body, webhook_event): (PaypalCardWebhooks, PaypalWebhookEventType),
) -> Result<Self, Self::Error> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.