text stringlengths 70 351k | source stringclasses 4 values |
|---|---|
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/adyen/transformers.rs | crate: hyperswitch_connectors | connector: adyen
use api_models::{
enums,
payments::{self, QrCodeInformation, VoucherNextStepData},
};
use common_utils::{
errors::{CustomResult, ParsingError},
ext_traits::Encode,
pii::Email,
request::Method,
types::MinorUnit,
};
use hyperswitch_domain_models::{
network_tokenization::NetworkTokenNumber,
payment_method_data::{
BankDebitData, BankRedirectData, BankTransferData, Card, CardRedirectData, GiftCardData,
NetworkTokenData, PayLaterData, PaymentMethodData, VoucherData, WalletData,
},
router_data::{
ConnectorAuthType, ErrorResponse, PaymentMethodBalance, PaymentMethodToken, RouterData,
},
router_request_types::{PaymentsPreProcessingData, ResponseId, SubmitEvidenceRequestData},
router_response_types::{
AcceptDisputeResponse, DefendDisputeResponse, MandateReference, PaymentsResponseData,
RedirectForm, RefundsResponseData, SubmitEvidenceResponse,
},
types::{
PaymentsAuthorizeRouterData, PaymentsCancelRouterData, PaymentsCaptureRouterData,
PaymentsPreProcessingRouterData, RefundsRouterData,
},
};
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
value: (
&AdyenRouterData<&PaymentsAuthorizeRouterData>,
&PayLaterData,
),
) -> Result<Self, Self::Error> {
{let (item, paylater_data) = value;<|fim_suffix|>
<|fim_middle|>
Ok(AdyenPaymentRequest {
amount,
merchant_account: auth_type.merchant_account,
payment_method,
reference: item.router_data.connector_request_reference_id.clone(),
return_url,
shopper_interaction,
recurring_processing_model,
browser_info,
additional_data,
telephone_number,
shopper_name,
shopper_email,
mpi_data: None,
shopper_locale: None,
social_security_number: None,
billing_address,
delivery_address,
country_code,
line_items,
shopper_reference,
store_payment_method,
channel: None,
shopper_statement: item.router_data.request.statement_descriptor.clone(),
shopper_ip: item.router_data.request.get_ip_address_as_optional(),
merchant_order_reference: item.router_data.request.merchant_order_reference_id.clone(),
store,
splits,
device_fingerprint,
})}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/adyen/transformers.rs | crate: hyperswitch_connectors | connector: adyen
use api_models::{
enums,
payments::{self, QrCodeInformation, VoucherNextStepData},
};
use common_utils::{
errors::{CustomResult, ParsingError},
ext_traits::Encode,
pii::Email,
request::Method,
types::MinorUnit,
};
use hyperswitch_domain_models::{
network_tokenization::NetworkTokenNumber,
payment_method_data::{
BankDebitData, BankRedirectData, BankTransferData, Card, CardRedirectData, GiftCardData,
NetworkTokenData, PayLaterData, PaymentMethodData, VoucherData, WalletData,
},
router_data::{
ConnectorAuthType, ErrorResponse, PaymentMethodBalance, PaymentMethodToken, RouterData,
},
router_request_types::{PaymentsPreProcessingData, ResponseId, SubmitEvidenceRequestData},
router_response_types::{
AcceptDisputeResponse, DefendDisputeResponse, MandateReference, PaymentsResponseData,
RedirectForm, RefundsResponseData, SubmitEvidenceResponse,
},
types::{
PaymentsAuthorizeRouterData, PaymentsCancelRouterData, PaymentsCaptureRouterData,
PaymentsPreProcessingRouterData, RefundsRouterData,
},
};
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
value: (&AdyenRouterData<&PaymentsAuthorizeRouterData>, &WalletData),
) -> Result<Self, Self::Error> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/opennode/transformers.rs | crate: hyperswitch_connectors | connector: opennode
use common_enums::{enums, AttemptStatus};
use hyperswitch_domain_models::{
router_data::{ConnectorAuthType, 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, RouterData as OtherRouterData},
};
fn try_from(
item: ResponseRouterData<F, OpennodePaymentsResponse, T, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/opennode/transformers.rs | crate: hyperswitch_connectors | connector: opennode
use hyperswitch_domain_models::{
router_data::{ConnectorAuthType, RouterData},
router_flow_types::refunds::{Execute, RSync},
router_request_types::ResponseId,
router_response_types::{PaymentsResponseData, RedirectForm, RefundsResponseData},
types::{PaymentsAuthorizeRouterData, RefundsRouterData},
};
fn try_from(item: &OpennodeRouterData<&RefundsRouterData<F>>) -> Result<Self, Self::Error> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/opennode/transformers.rs | crate: hyperswitch_connectors | connector: opennode
use hyperswitch_domain_models::{
router_data::{ConnectorAuthType, RouterData},
router_flow_types::refunds::{Execute, RSync},
router_request_types::ResponseId,
router_response_types::{PaymentsResponseData, RedirectForm, RefundsResponseData},
types::{PaymentsAuthorizeRouterData, RefundsRouterData},
};
fn get_crypto_specific_payment_data(
item: &OpennodeRouterData<&PaymentsAuthorizeRouterData>,
) -> Result<OpennodePaymentsRequest, error_stack::Report<errors::ConnectorError>> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/opennode/transformers.rs | crate: hyperswitch_connectors | connector: opennode
use common_enums::{enums, AttemptStatus};
use hyperswitch_domain_models::{
router_data::{ConnectorAuthType, 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, RouterData as OtherRouterData},
};
fn try_from(
item: RefundsResponseRouterData<Execute, RefundResponse>,
) -> Result<Self, Self::Error> {
Ok(Self {
response: Ok(RefundsResponseData {
connector_refund_id: item.response.id.to_string(),
refund_status: enums::RefundStatus::from(item.response.status),
}),
..item.data
})
} | ast_fragments |
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/opennode/transformers.rs | crate: hyperswitch_connectors | connector: opennode
use hyperswitch_domain_models::{
router_data::{ConnectorAuthType, RouterData},
router_flow_types::refunds::{Execute, RSync},
router_request_types::ResponseId,
router_response_types::{PaymentsResponseData, RedirectForm, RefundsResponseData},
types::{PaymentsAuthorizeRouterData, RefundsRouterData},
};
fn try_from(item: &OpennodeRouterData<&RefundsRouterData<F>>) -> Result<Self, Self::Error> {
Ok(Self {
amount: item.router_data.request.refund_amount,
})
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/opennode/transformers.rs | crate: hyperswitch_connectors | connector: opennode
fn from(item: OpennodePaymentStatus) -> Self {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/opennode/transformers.rs | crate: hyperswitch_connectors | connector: opennode
use hyperswitch_domain_models::{
router_data::{ConnectorAuthType, RouterData},
router_flow_types::refunds::{Execute, RSync},
router_request_types::ResponseId,
router_response_types::{PaymentsResponseData, RedirectForm, RefundsResponseData},
types::{PaymentsAuthorizeRouterData, RefundsRouterData},
};
fn try_from(
item: &OpennodeRouterData<&PaymentsAuthorizeRouterData>,
) -> Result<Self, Self::Error> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/opennode/transformers.rs | crate: hyperswitch_connectors | connector: opennode
use common_enums::{enums, AttemptStatus};
use hyperswitch_domain_models::{
router_data::{ConnectorAuthType, RouterData},
router_flow_types::refunds::{Execute, RSync},
router_request_types::ResponseId,
router_response_types::{PaymentsResponseData, RedirectForm, RefundsResponseData},
types::{PaymentsAuthorizeRouterData, RefundsRouterData},
};
fn try_from(
(_currency_unit, _currency, amount, router_data): (&CurrencyUnit, enums::Currency, i64, T),
) -> Result<Self, Self::Error> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/fiservemea/transformers.rs | crate: hyperswitch_connectors | connector: fiservemea | op: refund
use common_enums::enums;
fn map_refund_status(
fiservemea_status: Option<FiservemeaPaymentStatus>,
fiservemea_result: Option<FiservemeaPaymentResult>,
) -> Result<enums::RefundStatus, errors::ConnectorError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/fiservemea/transformers.rs | crate: hyperswitch_connectors | connector: fiservemea
use common_enums::enums;
fn map_status(
fiservemea_status: Option<FiservemeaPaymentStatus>,
fiservemea_result: Option<FiservemeaPaymentResult>,
transaction_type: FiservemeaTransactionType,
) -> common_enums::AttemptStatus {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/fiservemea/transformers.rs | crate: hyperswitch_connectors | connector: fiservemea
use common_enums::enums;
use hyperswitch_domain_models::{
payment_method_data::PaymentMethodData,
router_data::{ConnectorAuthType, RouterData},
router_flow_types::refunds::{Execute, RSync},
router_request_types::ResponseId,
router_response_types::{PaymentsResponseData, RefundsResponseData},
types::{
PaymentsAuthorizeRouterData, PaymentsCancelRouterData, PaymentsCaptureRouterData,
RefundsRouterData,
},
};
use crate::{
types::{RefundsResponseRouterData, ResponseRouterData},
utils::CardData as _,
};
fn try_from(
item: &FiservemeaRouterData<&PaymentsAuthorizeRouterData>,
) -> Result<Self, Self::Error> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/fiservemea/transformers.rs | crate: hyperswitch_connectors | connector: fiservemea
use common_enums::enums;
fn map_status(
fiservemea_status: Option<FiservemeaPaymentStatus>,
fiservemea_result: Option<FiservemeaPaymentResult>,
transaction_type: FiservemeaTransactionType,
) -> common_enums::AttemptStatus {
{
FiservemeaTransactionType::Preauth => common_enums::AttemptStatus::Authorized,<|fim_suffix|>
<|fim_middle|>
FiservemeaTransactionType::Credit
| FiservemeaTransactionType::ForcedTicket
| FiservemeaTransactionType::Return
| FiservemeaTransactionType::PayerAuth
| FiservemeaTransactionType::Disbursement => common_enums::AttemptStatus::Failure,
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/fiservemea/transformers.rs | crate: hyperswitch_connectors | connector: fiservemea
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, PaymentsCancelRouterData, PaymentsCaptureRouterData,
RefundsRouterData,
},
};
use crate::{
types::{RefundsResponseRouterData, ResponseRouterData},
utils::CardData as _,
};
fn try_from(auth_type: &ConnectorAuthType) -> Result<Self, Self::Error> {
{
ConnectorAuthType::BodyKey { api_key, key1 } => Ok(Self {
api_key: api_key.to_owned(),
secret_key: key1.to_owned(),
}),<|fim_suffix|>
<|fim_middle|>
_ => Err(errors::ConnectorError::FailedToObtainAuthType.into()),
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/fiservemea/transformers.rs | crate: hyperswitch_connectors | connector: fiservemea
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, PaymentsCancelRouterData, PaymentsCaptureRouterData,
RefundsRouterData,
},
};
use crate::{
types::{RefundsResponseRouterData, ResponseRouterData},
utils::CardData as _,
};
fn try_from(
item: RefundsResponseRouterData<RSync, FiservemeaPaymentsResponse>,
) -> Result<Self, Self::Error> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/fiservemea/transformers.rs | crate: hyperswitch_connectors | connector: fiservemea
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, PaymentsCancelRouterData, PaymentsCaptureRouterData,
RefundsRouterData,
},
};
use crate::{
types::{RefundsResponseRouterData, ResponseRouterData},
utils::CardData as _,
};
fn try_from(
item: RefundsResponseRouterData<Execute, FiservemeaPaymentsResponse>,
) -> Result<Self, Self::Error> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/fiservemea/transformers.rs | crate: hyperswitch_connectors | connector: fiservemea
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, PaymentsCancelRouterData, PaymentsCaptureRouterData,
RefundsRouterData,
},
};
fn try_from(item: &FiservemeaRouterData<&RefundsRouterData<F>>) -> Result<Self, Self::Error> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/fiservemea/transformers.rs | crate: hyperswitch_connectors | connector: fiservemea
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, PaymentsCancelRouterData, PaymentsCaptureRouterData,
RefundsRouterData,
},
};
fn try_from(_item: &PaymentsCancelRouterData) -> Result<Self, Self::Error> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/fiservemea/transformers.rs | crate: hyperswitch_connectors | connector: fiservemea
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, PaymentsCancelRouterData, PaymentsCaptureRouterData,
RefundsRouterData,
},
};
fn try_from(
item: &FiservemeaRouterData<&PaymentsCaptureRouterData>,
) -> Result<Self, Self::Error> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/fiservemea/transformers.rs | crate: hyperswitch_connectors | connector: fiservemea
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, PaymentsCancelRouterData, PaymentsCaptureRouterData,
RefundsRouterData,
},
};
use crate::{
types::{RefundsResponseRouterData, ResponseRouterData},
utils::CardData as _,
};
fn try_from(
item: ResponseRouterData<F, FiservemeaPaymentsResponse, T, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/boku/transformers.rs | crate: hyperswitch_connectors | connector: boku
use hyperswitch_domain_models::{
payment_method_data::{PaymentMethodData, WalletData},
router_data::{ConnectorAuthType, RouterData},
router_flow_types::refunds::{Execute, RSync},
router_request_types::ResponseId,
router_response_types::{PaymentsResponseData, RedirectForm, RefundsResponseData},
types::{self, RefundsRouterData},
};
use crate::{
types::{RefundsResponseRouterData, ResponseRouterData},
utils::{self, AddressDetailsData, RouterData as _},
};
fn get_wallet_type(wallet_data: &WalletData) -> Result<String, errors::ConnectorError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/boku/transformers.rs | crate: hyperswitch_connectors | connector: boku
use common_utils::{request::Method, types::MinorUnit};
use hyperswitch_domain_models::{
payment_method_data::{PaymentMethodData, WalletData},
router_data::{ConnectorAuthType, RouterData},
router_flow_types::refunds::{Execute, RSync},
router_request_types::ResponseId,
router_response_types::{PaymentsResponseData, RedirectForm, RefundsResponseData},
types::{self, RefundsRouterData},
};
use masking::Secret;
use crate::{
types::{RefundsResponseRouterData, ResponseRouterData},
utils::{self, AddressDetailsData, RouterData as _},
};
fn try_from(
value: (
&BokuRouterData<&types::PaymentsAuthorizeRouterData>,
&WalletData,
),
) -> Result<Self, Self::Error> {
let (item_router_data, wallet_data) = value;
let item = item_router_data.router_data;
let address = item.get_billing_address()?;
let country = address.get_country()?.to_string();
let payment_method = get_wallet_type(wallet_data)?;
let hosted = get_hosted_data(item);
let auth_type = BokuAuthType::try_from(&item.connector_auth_type)?;
let merchant_item_description = item.get_description()?;
let payment_data = SingleChargeData {
total_amount: item_router_data.amount,
currency: item.request.currency.to_string(),
country,
merchant_id: auth_type.merchant_id,
merchant_transaction_id: Secret::new(item.payment_id.to_string()),
merchant_request_id: Uuid::new_v4().to_string(),
merchant_item_description,
notification_url: item.request.webhook_url.clone(),
payment_method,
charge_type: BokuChargeType::Hosted.to_string(),
hosted,
};
Ok(Self::BeginSingleCharge(payment_data))
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/boku/transformers.rs | crate: hyperswitch_connectors | connector: boku
use common_utils::{request::Method, types::MinorUnit};
use hyperswitch_domain_models::{
payment_method_data::{PaymentMethodData, WalletData},
router_data::{ConnectorAuthType, RouterData},
router_flow_types::refunds::{Execute, RSync},
router_request_types::ResponseId,
router_response_types::{PaymentsResponseData, RedirectForm, RefundsResponseData},
types::{self, RefundsRouterData},
};
use crate::{
types::{RefundsResponseRouterData, ResponseRouterData},
utils::{self, AddressDetailsData, RouterData as _},
};
fn try_from(
item: &BokuRouterData<&types::PaymentsAuthorizeRouterData>,
) -> Result<Self, Self::Error> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/boku/transformers.rs | crate: hyperswitch_connectors | connector: boku
use hyperswitch_domain_models::{
payment_method_data::{PaymentMethodData, WalletData},
router_data::{ConnectorAuthType, RouterData},
router_flow_types::refunds::{Execute, RSync},
router_request_types::ResponseId,
router_response_types::{PaymentsResponseData, RedirectForm, RefundsResponseData},
types::{self, RefundsRouterData},
};
use crate::{
types::{RefundsResponseRouterData, ResponseRouterData},
utils::{self, AddressDetailsData, RouterData as _},
};
fn try_from(
item: RefundsResponseRouterData<RSync, BokuRsyncResponse>,
) -> Result<Self, Self::Error> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/boku/transformers.rs | crate: hyperswitch_connectors | connector: boku | op: refund
use common_enums::enums;
use crate::{
types::{RefundsResponseRouterData, ResponseRouterData},
utils::{self, AddressDetailsData, RouterData as _},
};
fn get_refund_status(status: String) -> enums::RefundStatus {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/boku/transformers.rs | crate: hyperswitch_connectors | connector: boku | op: authorize
use common_enums::enums;
use common_utils::{request::Method, types::MinorUnit};
use hyperswitch_domain_models::{
payment_method_data::{PaymentMethodData, WalletData},
router_data::{ConnectorAuthType, RouterData},
router_flow_types::refunds::{Execute, RSync},
router_request_types::ResponseId,
router_response_types::{PaymentsResponseData, RedirectForm, RefundsResponseData},
types::{self, RefundsRouterData},
};
fn get_authorize_response(
response: BokuPaymentsResponse,
) -> Result<(enums::AttemptStatus, String, Option<RedirectForm>), errors::ConnectorError> {
{
Some(hosted_value) => Ok(hosted_value
.redirect_url
.map(|url| RedirectForm::from((url, Method::Get)))),<|fim_suffix|>
<|fim_middle|>
None => Err(errors::ConnectorError::MissingConnectorRedirectionPayload {
field_name: "redirect_url",
}),
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/boku/transformers.rs | crate: hyperswitch_connectors | connector: boku
use hyperswitch_domain_models::{
payment_method_data::{PaymentMethodData, WalletData},
router_data::{ConnectorAuthType, RouterData},
router_flow_types::refunds::{Execute, RSync},
router_request_types::ResponseId,
router_response_types::{PaymentsResponseData, RedirectForm, RefundsResponseData},
types::{self, RefundsRouterData},
};
use crate::{
types::{RefundsResponseRouterData, ResponseRouterData},
utils::{self, AddressDetailsData, RouterData as _},
};
fn try_from(auth_type: &ConnectorAuthType) -> Result<Self, Self::Error> {
{
ConnectorAuthType::BodyKey { api_key, key1 } => Ok(Self {
merchant_id: key1.to_owned(),
key_id: api_key.to_owned(),
}),<|fim_suffix|>
<|fim_middle|>
_ => Err(errors::ConnectorError::FailedToObtainAuthType.into()),
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/boku/transformers.rs | crate: hyperswitch_connectors | connector: boku
use common_utils::{request::Method, types::MinorUnit};
use hyperswitch_domain_models::{
payment_method_data::{PaymentMethodData, WalletData},
router_data::{ConnectorAuthType, RouterData},
router_flow_types::refunds::{Execute, RSync},
router_request_types::ResponseId,
router_response_types::{PaymentsResponseData, RedirectForm, RefundsResponseData},
types::{self, RefundsRouterData},
};
use crate::{
types::{RefundsResponseRouterData, ResponseRouterData},
utils::{self, AddressDetailsData, RouterData as _},
};
fn get_hosted_data(item: &types::PaymentsAuthorizeRouterData) -> Option<BokuHostedData> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/boku/transformers.rs | crate: hyperswitch_connectors | connector: boku
use hyperswitch_domain_models::{
payment_method_data::{PaymentMethodData, WalletData},
router_data::{ConnectorAuthType, RouterData},
router_flow_types::refunds::{Execute, RSync},
router_request_types::ResponseId,
router_response_types::{PaymentsResponseData, RedirectForm, RefundsResponseData},
types::{self, RefundsRouterData},
};
use crate::{
types::{RefundsResponseRouterData, ResponseRouterData},
utils::{self, AddressDetailsData, RouterData as _},
};
fn try_from(
item: RefundsResponseRouterData<RSync, BokuRsyncResponse>,
) -> Result<Self, Self::Error> {
Ok(Self {
response: Ok(RefundsResponseData {
connector_refund_id: item.response.refunds.refund.refund_id,
refund_status: get_refund_status(item.response.refunds.refund.refund_status),
}),
..item.data
})
} | ast_fragments |
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/boku/transformers.rs | crate: hyperswitch_connectors | connector: boku | op: refund
use common_enums::enums;
use crate::{
types::{RefundsResponseRouterData, ResponseRouterData},
utils::{self, AddressDetailsData, RouterData as _},
};
fn get_refund_status(status: String) -> enums::RefundStatus {
match status.as_str() {
"Success" => enums::RefundStatus::Success,
"Failure" => enums::RefundStatus::Failure,
_ => enums::RefundStatus::Pending,
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/boku/transformers.rs | crate: hyperswitch_connectors | connector: boku
use common_utils::{request::Method, types::MinorUnit};
use hyperswitch_domain_models::{
payment_method_data::{PaymentMethodData, WalletData},
router_data::{ConnectorAuthType, RouterData},
router_flow_types::refunds::{Execute, RSync},
router_request_types::ResponseId,
router_response_types::{PaymentsResponseData, RedirectForm, RefundsResponseData},
types::{self, RefundsRouterData},
};
use masking::Secret;
fn try_from(item: &BokuRouterData<&RefundsRouterData<F>>) -> Result<Self, Self::Error> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/boku/transformers.rs | crate: hyperswitch_connectors | connector: boku
use hyperswitch_domain_models::{
payment_method_data::{PaymentMethodData, WalletData},
router_data::{ConnectorAuthType, RouterData},
router_flow_types::refunds::{Execute, RSync},
router_request_types::ResponseId,
router_response_types::{PaymentsResponseData, RedirectForm, RefundsResponseData},
types::{self, RefundsRouterData},
};
use crate::{
types::{RefundsResponseRouterData, ResponseRouterData},
utils::{self, AddressDetailsData, RouterData as _},
};
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
Self::NonFulfillment => write!(f, "8"),
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/boku/transformers.rs | crate: hyperswitch_connectors | connector: boku | op: sync
use common_enums::enums;
use hyperswitch_domain_models::{
payment_method_data::{PaymentMethodData, WalletData},
router_data::{ConnectorAuthType, RouterData},
router_flow_types::refunds::{Execute, RSync},
router_request_types::ResponseId,
router_response_types::{PaymentsResponseData, RedirectForm, RefundsResponseData},
types::{self, RefundsRouterData},
};
fn get_psync_response(
response: BokuPsyncResponse,
) -> Result<(enums::AttemptStatus, String, Option<RedirectForm>), errors::ConnectorError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/boku/transformers.rs | crate: hyperswitch_connectors | connector: boku | op: authorize
use common_enums::enums;
use common_utils::{request::Method, types::MinorUnit};
use hyperswitch_domain_models::{
payment_method_data::{PaymentMethodData, WalletData},
router_data::{ConnectorAuthType, RouterData},
router_flow_types::refunds::{Execute, RSync},
router_request_types::ResponseId,
router_response_types::{PaymentsResponseData, RedirectForm, RefundsResponseData},
types::{self, RefundsRouterData},
};
fn get_authorize_response(
response: BokuPaymentsResponse,
) -> Result<(enums::AttemptStatus, String, Option<RedirectForm>), errors::ConnectorError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/boku/transformers.rs | crate: hyperswitch_connectors | connector: boku
use common_enums::enums;
use crate::{
types::{RefundsResponseRouterData, ResponseRouterData},
utils::{self, AddressDetailsData, RouterData as _},
};
fn get_response_status(status: String) -> enums::AttemptStatus {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/boku/transformers.rs | crate: hyperswitch_connectors | connector: boku
use hyperswitch_domain_models::{
payment_method_data::{PaymentMethodData, WalletData},
router_data::{ConnectorAuthType, RouterData},
router_flow_types::refunds::{Execute, RSync},
router_request_types::ResponseId,
router_response_types::{PaymentsResponseData, RedirectForm, RefundsResponseData},
types::{self, RefundsRouterData},
};
use crate::{
types::{RefundsResponseRouterData, ResponseRouterData},
utils::{self, AddressDetailsData, RouterData as _},
};
fn try_from(
item: ResponseRouterData<F, BokuResponse, T, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/boku/transformers.rs | crate: hyperswitch_connectors | connector: boku
use hyperswitch_domain_models::{
payment_method_data::{PaymentMethodData, WalletData},
router_data::{ConnectorAuthType, RouterData},
router_flow_types::refunds::{Execute, RSync},
router_request_types::ResponseId,
router_response_types::{PaymentsResponseData, RedirectForm, RefundsResponseData},
types::{self, RefundsRouterData},
};
use crate::{
types::{RefundsResponseRouterData, ResponseRouterData},
utils::{self, AddressDetailsData, RouterData as _},
};
fn try_from(auth_type: &ConnectorAuthType) -> Result<Self, Self::Error> {
match auth_type {
ConnectorAuthType::BodyKey { api_key, key1 } => Ok(Self {
merchant_id: key1.to_owned(),
key_id: api_key.to_owned(),
}),
_ => Err(errors::ConnectorError::FailedToObtainAuthType.into()),
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/coinbase/transformers.rs | crate: hyperswitch_connectors | connector: coinbase
use error_stack::ResultExt;
use hyperswitch_domain_models::{
router_data::{ConnectorAuthType, RouterData},
router_flow_types::refunds::{Execute, RSync},
router_request_types::ResponseId,
router_response_types::{PaymentsResponseData, RedirectForm},
types,
};
use crate::{
types::{RefundsResponseRouterData, ResponseRouterData},
utils::{
self, AddressDetailsData, PaymentsAuthorizeRequestData, RouterData as OtherRouterData,
},
};
fn get_crypto_specific_payment_data(
item: &types::PaymentsAuthorizeRouterData,
) -> Result<CoinbasePaymentsRequest, error_stack::Report<errors::ConnectorError>> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/coinbase/transformers.rs | crate: hyperswitch_connectors | connector: coinbase
use common_enums::enums;
use hyperswitch_domain_models::{
router_data::{ConnectorAuthType, RouterData},
router_flow_types::refunds::{Execute, RSync},
router_request_types::ResponseId,
router_response_types::{PaymentsResponseData, RedirectForm},
types,
};
use crate::{
types::{RefundsResponseRouterData, ResponseRouterData},
utils::{
self, AddressDetailsData, PaymentsAuthorizeRequestData, RouterData as OtherRouterData,
},
};
fn try_from(
item: ResponseRouterData<F, CoinbasePaymentsResponse, T, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/coinbase/transformers.rs | crate: hyperswitch_connectors | connector: coinbase
use hyperswitch_domain_models::{
router_data::{ConnectorAuthType, RouterData},
router_flow_types::refunds::{Execute, RSync},
router_request_types::ResponseId,
router_response_types::{PaymentsResponseData, RedirectForm},
types,
};
use crate::{
types::{RefundsResponseRouterData, ResponseRouterData},
utils::{
self, AddressDetailsData, PaymentsAuthorizeRequestData, RouterData as OtherRouterData,
},
};
fn try_from(_item: &types::RefundsRouterData<F>) -> Result<Self, Self::Error> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/coinbase/transformers.rs | crate: hyperswitch_connectors | connector: coinbase
fn from(item: CoinbasePaymentStatus) -> Self {
{
CoinbasePaymentStatus::Completed | CoinbasePaymentStatus::Resolved => Self::Charged,<|fim_suffix|>
<|fim_middle|>
_ => Self::Pending,
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/coinbase/transformers.rs | crate: hyperswitch_connectors | connector: coinbase
use hyperswitch_domain_models::{
router_data::{ConnectorAuthType, RouterData},
router_flow_types::refunds::{Execute, RSync},
router_request_types::ResponseId,
router_response_types::{PaymentsResponseData, RedirectForm},
types,
};
use crate::{
types::{RefundsResponseRouterData, ResponseRouterData},
utils::{
self, AddressDetailsData, PaymentsAuthorizeRequestData, RouterData as OtherRouterData,
},
};
fn get_local_price(item: &types::PaymentsAuthorizeRouterData) -> LocalPrice {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/coinbase/transformers.rs | crate: hyperswitch_connectors | connector: coinbase
use hyperswitch_domain_models::{
router_data::{ConnectorAuthType, RouterData},
router_flow_types::refunds::{Execute, RSync},
router_request_types::ResponseId,
router_response_types::{PaymentsResponseData, RedirectForm},
types,
};
use crate::{
types::{RefundsResponseRouterData, ResponseRouterData},
utils::{
self, AddressDetailsData, PaymentsAuthorizeRequestData, RouterData as OtherRouterData,
},
};
fn try_from(
_item: RefundsResponseRouterData<RSync, RefundResponse>,
) -> Result<Self, Self::Error> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/coinbase/transformers.rs | crate: hyperswitch_connectors | connector: coinbase
use hyperswitch_domain_models::{
router_data::{ConnectorAuthType, RouterData},
router_flow_types::refunds::{Execute, RSync},
router_request_types::ResponseId,
router_response_types::{PaymentsResponseData, RedirectForm},
types,
};
use crate::{
types::{RefundsResponseRouterData, ResponseRouterData},
utils::{
self, AddressDetailsData, PaymentsAuthorizeRequestData, RouterData as OtherRouterData,
},
};
fn try_from(
_item: RefundsResponseRouterData<Execute, RefundResponse>,
) -> Result<Self, Self::Error> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/coinbase/transformers.rs | crate: hyperswitch_connectors | connector: coinbase
use hyperswitch_domain_models::{
router_data::{ConnectorAuthType, RouterData},
router_flow_types::refunds::{Execute, RSync},
router_request_types::ResponseId,
router_response_types::{PaymentsResponseData, RedirectForm},
types,
};
use crate::{
types::{RefundsResponseRouterData, ResponseRouterData},
utils::{
self, AddressDetailsData, PaymentsAuthorizeRequestData, RouterData as OtherRouterData,
},
};
fn try_from(_item: &types::RefundsRouterData<F>) -> Result<Self, Self::Error> {
Err(errors::ConnectorError::NotImplemented("try_from RefundsRouterData".to_string()).into())
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/coinbase/transformers.rs | crate: hyperswitch_connectors | connector: coinbase
fn from(item: CoinbasePaymentStatus) -> Self {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/coinbase/transformers.rs | crate: hyperswitch_connectors | connector: coinbase
use hyperswitch_domain_models::{
router_data::{ConnectorAuthType, RouterData},
router_flow_types::refunds::{Execute, RSync},
router_request_types::ResponseId,
router_response_types::{PaymentsResponseData, RedirectForm},
types,
};
fn try_from(_auth_type: &ConnectorAuthType) -> Result<Self, Self::Error> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/coinbase/transformers.rs | crate: hyperswitch_connectors | connector: coinbase
use hyperswitch_domain_models::{
router_data::{ConnectorAuthType, RouterData},
router_flow_types::refunds::{Execute, RSync},
router_request_types::ResponseId,
router_response_types::{PaymentsResponseData, RedirectForm},
types,
};
use crate::{
types::{RefundsResponseRouterData, ResponseRouterData},
utils::{
self, AddressDetailsData, PaymentsAuthorizeRequestData, RouterData as OtherRouterData,
},
};
fn try_from(item: &types::PaymentsAuthorizeRouterData) -> Result<Self, Self::Error> {
get_crypto_specific_payment_data(item)
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/zsl/transformers.rs | crate: hyperswitch_connectors | connector: zsl
use common_utils::{crypto::GenerateDigest, date_time, pii::Email, request::Method};
use error_stack::ResultExt;
use masking::{ExposeInterface, Secret};
pub fn calculate_signature(
enctype: EncodingType,
signature_data: ZslSignatureType,
) -> Result<Secret<String>, error_stack::Report<errors::ConnectorError>> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/zsl/transformers.rs | crate: hyperswitch_connectors | connector: zsl
use common_enums::enums;
use hyperswitch_domain_models::{
payment_method_data::{BankTransferData, PaymentMethodData},
router_data::{ConnectorAuthType, ErrorResponse, RouterData},
router_request_types::{PaymentsSyncData, ResponseId},
router_response_types::{PaymentsResponseData, RedirectForm},
types,
};
use crate::{
types::ResponseRouterData,
utils::{
get_amount_as_string, get_unimplemented_payment_method_error_message,
PaymentsAuthorizeRequestData, RouterData as _,
},
};
fn try_from(
item: ResponseRouterData<F, ZslWebhookResponse, PaymentsSyncData, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/zsl/transformers.rs | crate: hyperswitch_connectors | connector: zsl
use crate::{
types::ResponseRouterData,
utils::{
get_amount_as_string, get_unimplemented_payment_method_error_message,
PaymentsAuthorizeRequestData, RouterData as _,
},
};
fn try_from(status: String) -> Result<Self, Self::Error> {
{
"0" => Ok(Self::Normal),<|fim_suffix|>
<|fim_middle|>
_ => Err(errors::ConnectorError::ResponseHandlingFailed.into()),
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/zsl/transformers.rs | crate: hyperswitch_connectors | connector: zsl
use hyperswitch_domain_models::{
payment_method_data::{BankTransferData, PaymentMethodData},
router_data::{ConnectorAuthType, ErrorResponse, RouterData},
router_request_types::{PaymentsSyncData, ResponseId},
router_response_types::{PaymentsResponseData, RedirectForm},
types,
};
use crate::{
types::ResponseRouterData,
utils::{
get_amount_as_string, get_unimplemented_payment_method_error_message,
PaymentsAuthorizeRequestData, RouterData as _,
},
};
fn try_from(auth_type: &ConnectorAuthType) -> Result<Self, Self::Error> {
{
ConnectorAuthType::BodyKey { api_key, key1 } => Ok(Self {
api_key: api_key.to_owned(),
merchant_id: key1.clone(),
}),<|fim_suffix|>
<|fim_middle|>
_ => Err(errors::ConnectorError::FailedToObtainAuthType.into()),
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/zsl/transformers.rs | crate: hyperswitch_connectors | connector: zsl
use crate::{
types::ResponseRouterData,
utils::{
get_amount_as_string, get_unimplemented_payment_method_error_message,
PaymentsAuthorizeRequestData, RouterData as _,
},
};
pub(crate) fn get_status(status: String) -> api_models::webhooks::IncomingWebhookEvent {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/zsl/transformers.rs | crate: hyperswitch_connectors | connector: zsl
use common_enums::enums;
use hyperswitch_domain_models::{
payment_method_data::{BankTransferData, PaymentMethodData},
router_data::{ConnectorAuthType, ErrorResponse, RouterData},
router_request_types::{PaymentsSyncData, ResponseId},
router_response_types::{PaymentsResponseData, RedirectForm},
types,
};
use crate::{
types::ResponseRouterData,
utils::{
get_amount_as_string, get_unimplemented_payment_method_error_message,
PaymentsAuthorizeRequestData, RouterData as _,
},
};
fn try_from(
(currency_unit, currency, txn_amount, item): (&api::CurrencyUnit, enums::Currency, i64, T),
) -> Result<Self, Self::Error> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/zsl/transformers.rs | crate: hyperswitch_connectors | connector: zsl
use common_enums::enums;
use hyperswitch_domain_models::{
payment_method_data::{BankTransferData, PaymentMethodData},
router_data::{ConnectorAuthType, ErrorResponse, RouterData},
router_request_types::{PaymentsSyncData, ResponseId},
router_response_types::{PaymentsResponseData, RedirectForm},
types,
};
use hyperswitch_interfaces::{api, consts::NO_ERROR_CODE, errors};
use masking::{ExposeInterface, Secret};
use crate::{
types::ResponseRouterData,
utils::{
get_amount_as_string, get_unimplemented_payment_method_error_message,
PaymentsAuthorizeRequestData, RouterData as _,
},
};
fn try_from(
item: ResponseRouterData<F, ZslPaymentsResponse, T, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/zsl/transformers.rs | crate: hyperswitch_connectors | connector: zsl
use common_utils::{crypto::GenerateDigest, date_time, pii::Email, request::Method};
use hyperswitch_domain_models::{
payment_method_data::{BankTransferData, PaymentMethodData},
router_data::{ConnectorAuthType, ErrorResponse, RouterData},
router_request_types::{PaymentsSyncData, ResponseId},
router_response_types::{PaymentsResponseData, RedirectForm},
types,
};
use masking::{ExposeInterface, Secret};
use crate::{
types::ResponseRouterData,
utils::{
get_amount_as_string, get_unimplemented_payment_method_error_message,
PaymentsAuthorizeRequestData, RouterData as _,
},
};
fn try_from(
item: &ZslRouterData<&types::PaymentsAuthorizeRouterData>,
) -> Result<Self, Self::Error> {
{let payment_method = match item.router_data.request.payment_method_data.clone() {
PaymentMethodData::BankTransfer(bank_transfer_data) => match *bank_transfer_data {
BankTransferData::LocalBankTransfer { bank_code } => Ok(
ZslPaymentMethods::LocalBankTransfer(LocalBankTransaferRequest {
bank_code,
pay_method: None,
}),
),
BankTransferData::AchBankTransfer { .. }
| BankTransferData::SepaBankTransfer { .. }
| BankTransferData::BacsBankTransfer { .. }
| BankTransferData::MultibancoBankTransfer { .. }
| BankTransferData::PermataBankTransfer { .. }
| BankTransferData::BcaBankTransfer { .. }
| BankTransferData::BniVaBankTransfer { .. }
| BankTransferData::BriVaBankTransfer { .. }
| BankTransferData::CimbVaBankTransfer { .. }
| BankTransferData::DanamonVaBankTransfer { .. }
| BankTransferData::MandiriVaBankTransfer { .. }
| BankTransferData::Pix { .. }
| BankTransferData::Pse {}
| BankTransferData::InstantBankTransfer {} => {
Err(errors::ConnectorError::NotImplemented(
get_unimplemented_payment_method_error_message(
item.router_data.connector.as_str(),
),
))
}
},
PaymentMethodData::Card(_)
| PaymentMethodData::CardRedirect(_)
| PaymentMethodData::Wallet(_)
| PaymentMethodData::PayLater(_)
| PaymentMethodData::BankRedirect(_)
| PaymentMethodData::BankDebit(_)
| PaymentMethodData::Crypto(_)
| PaymentMethodData::MandatePayment
| PaymentMethodData::Reward
| PaymentMethodData::RealTimePayment(_)
| PaymentMethodData::MobilePayment(_)
| PaymentMethodData::Upi(_)
| PaymentMethodData::Voucher(_)
| PaymentMethodData::GiftCard(_)
| PaymentMethodData::CardToken(_)
| PaymentMethodData::NetworkToken(_)
| PaymentMethodData::CardDetailsForNetworkTransactionId(_)
| PaymentMethodData::OpenBanking(_) => Err(errors::ConnectorError::NotImplemented(
get_unimplemented_payment_method_error_message(item.router_data.connector.as_str()),
)),
}?;<|fim_suffix|>
<|fim_middle|>
Ok(Self {
process_type: ProcessType::PaymentRequest,
process_code: ProcessCode::API,
txn_amt,
ccy,
mer_ref,
mer_txn_date,
mer_id,
lang,
success_url: router_url.clone(),
failure_url: router_url.clone(),
success_s2s_url: webhook_url.clone(),
failure_s2s_url: webhook_url.clone(),
enctype: EncodingType::MD5,
signature,
verno: zsl_version::VERSION_1.to_owned(),
service_code: ServiceCode::MPG,
country: billing_country,
payment_method,
name,
family_name,
tel_phone,
email,
cust_tag,
})}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/zsl/transformers.rs | crate: hyperswitch_connectors | connector: zsl
use crate::{
types::ResponseRouterData,
utils::{
get_amount_as_string, get_unimplemented_payment_method_error_message,
PaymentsAuthorizeRequestData, RouterData as _,
},
};
fn try_from(status: String) -> Result<Self, Self::Error> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/iatapay/transformers.rs | crate: hyperswitch_connectors | connector: iatapay
use common_utils::{
errors::CustomResult, ext_traits::Encode, request::Method, types::FloatMajorUnit,
};
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(payload: IatapayWebhookResponse) -> CustomResult<Self, errors::ConnectorError> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/iatapay/transformers.rs | crate: hyperswitch_connectors | connector: iatapay
use common_utils::{
errors::CustomResult, ext_traits::Encode, request::Method, types::FloatMajorUnit,
};
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(payload: IatapayWebhookResponse) -> CustomResult<Self, errors::ConnectorError> {
{
IatapayRefundWebhookStatus::Cleared
| IatapayRefundWebhookStatus::Authorized
| IatapayRefundWebhookStatus::Settled => Ok(Self::RefundSuccess),<|fim_suffix|>
<|fim_middle|>
IatapayRefundWebhookStatus::Created
| IatapayRefundWebhookStatus::Locked
| IatapayRefundWebhookStatus::Initiated
| IatapayRefundWebhookStatus::Unknown => Ok(Self::EventNotSupported),
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/iatapay/transformers.rs | crate: hyperswitch_connectors | connector: iatapay
fn from(item: RefundStatus) -> Self {
{
RefundStatus::Created => Self::Pending,<|fim_suffix|>
<|fim_middle|>
RefundStatus::Cleared => Self::Success,
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/iatapay/transformers.rs | crate: hyperswitch_connectors | connector: iatapay
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},
};
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(item: &IatapayRouterData<&RefundsRouterData<F>>) -> Result<Self, Self::Error> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/iatapay/transformers.rs | crate: hyperswitch_connectors | connector: iatapay
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 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>;
fn try_from(
item: ResponseRouterData<F, IatapayPaymentsResponse, T, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/iatapay/transformers.rs | crate: hyperswitch_connectors | connector: iatapay
fn from(item: IatapayPaymentStatus) -> Self {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/iatapay/transformers.rs | crate: hyperswitch_connectors | connector: iatapay
fn get_redirect_url(return_url: String) -> RedirectUrls {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/iatapay/transformers.rs | crate: hyperswitch_connectors | connector: iatapay
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 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>;
fn try_from(
item: ResponseRouterData<F, IatapayAuthUpdateResponse, T, AccessToken>,
) -> Result<Self, Self::Error> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/iatapay/transformers.rs | crate: hyperswitch_connectors | connector: iatapay
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},
};
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from((amount, item): (FloatMajorUnit, T)) -> Result<Self, Self::Error> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/iatapay/transformers.rs | crate: hyperswitch_connectors | connector: iatapay
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 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>;
fn try_from(_item: &types::RefreshTokenRouterData) -> Result<Self, Self::Error> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/iatapay/transformers.rs | crate: hyperswitch_connectors | connector: iatapay
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>;
fn get_iatpay_response(
response: IatapayPaymentsResponse,
status_code: u16,
) -> CustomResult<
(
enums::AttemptStatus,
Option<ErrorResponse>,
PaymentsResponseData,
),
errors::ConnectorError,
> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/iatapay/transformers.rs | crate: hyperswitch_connectors | connector: iatapay
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 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>;
fn try_from(
item: &IatapayRouterData<
&RouterData<Authorize, PaymentsAuthorizeData, PaymentsResponseData>,
>,
) -> Result<Self, Self::Error> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/square/transformers.rs | crate: hyperswitch_connectors | connector: square
use hyperswitch_domain_models::{
payment_method_data::{BankDebitData, Card, PayLaterData, PaymentMethodData, WalletData},
router_data::{ConnectorAuthType, PaymentMethodToken, 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::{RefundsResponseRouterData, ResponseRouterData},
unimplemented_payment_method,
utils::{self, CardData, PaymentsAuthorizeRequestData, RouterData as _},
};
fn try_from(item: &types::PaymentsAuthorizeRouterData) -> Result<Self, Self::Error> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/square/transformers.rs | crate: hyperswitch_connectors | connector: square
use hyperswitch_domain_models::{
payment_method_data::{BankDebitData, Card, PayLaterData, PaymentMethodData, WalletData},
router_data::{ConnectorAuthType, PaymentMethodToken, RouterData},
router_flow_types::{refunds::Execute, RSync},
router_request_types::ResponseId,
router_response_types::{PaymentsResponseData, RefundsResponseData},
types,
};
use crate::{
types::{RefundsResponseRouterData, ResponseRouterData},
unimplemented_payment_method,
utils::{self, CardData, PaymentsAuthorizeRequestData, RouterData as _},
};
fn try_from(value: (&types::TokenizationRouterData, WalletData)) -> Result<Self, Self::Error> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/square/transformers.rs | crate: hyperswitch_connectors | connector: square
use hyperswitch_domain_models::{
payment_method_data::{BankDebitData, Card, PayLaterData, PaymentMethodData, WalletData},
router_data::{ConnectorAuthType, PaymentMethodToken, 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::{RefundsResponseRouterData, ResponseRouterData},
unimplemented_payment_method,
utils::{self, CardData, PaymentsAuthorizeRequestData, RouterData as _},
};
fn try_from(value: (&types::TokenizationRouterData, Card)) -> Result<Self, Self::Error> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/square/transformers.rs | crate: hyperswitch_connectors | connector: square
fn from(item: SquareWebhookObject) -> Self {
{
SquarePaymentStatus::Completed => Self::PaymentIntentSuccess,<|fim_suffix|>
<|fim_middle|>
SquarePaymentStatus::Approved | SquarePaymentStatus::Canceled => {
Self::EventNotSupported
}
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/square/transformers.rs | crate: hyperswitch_connectors | connector: square
fn from(item: RefundStatus) -> Self {
{
RefundStatus::Completed => Self::Success,<|fim_suffix|>
<|fim_middle|>
RefundStatus::Pending => Self::Pending,
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/square/transformers.rs | crate: hyperswitch_connectors | connector: square
use hyperswitch_domain_models::{
payment_method_data::{BankDebitData, Card, PayLaterData, PaymentMethodData, WalletData},
router_data::{ConnectorAuthType, PaymentMethodToken, RouterData},
router_flow_types::{refunds::Execute, RSync},
router_request_types::ResponseId,
router_response_types::{PaymentsResponseData, RefundsResponseData},
types,
};
fn try_from(auth_type: &ConnectorAuthType) -> Result<Self, Self::Error> {
{
ConnectorAuthType::BodyKey { api_key, key1, .. } => Ok(Self {
api_key: api_key.to_owned(),
key1: key1.to_owned(),
}),<|fim_suffix|>
<|fim_middle|>
ConnectorAuthType::HeaderKey { .. }
| ConnectorAuthType::SignatureKey { .. }
| ConnectorAuthType::MultiAuthKey { .. }
| ConnectorAuthType::CurrencyAuthKey { .. }
| ConnectorAuthType::TemporaryAuth
| ConnectorAuthType::NoKey
| ConnectorAuthType::CertificateAuth { .. } => {
Err(errors::ConnectorError::FailedToObtainAuthType.into())
}
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/square/transformers.rs | crate: hyperswitch_connectors | connector: square
fn from(item: SquareWebhookObject) -> Self {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/square/transformers.rs | crate: hyperswitch_connectors | connector: square
use common_enums::enums;
use hyperswitch_domain_models::{
payment_method_data::{BankDebitData, Card, PayLaterData, PaymentMethodData, WalletData},
router_data::{ConnectorAuthType, PaymentMethodToken, RouterData},
router_flow_types::{refunds::Execute, RSync},
router_request_types::ResponseId,
router_response_types::{PaymentsResponseData, RefundsResponseData},
types,
};
use crate::{
types::{RefundsResponseRouterData, ResponseRouterData},
unimplemented_payment_method,
utils::{self, CardData, PaymentsAuthorizeRequestData, RouterData as _},
};
fn try_from(
item: ResponseRouterData<F, SquarePaymentsResponse, T, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/square/transformers.rs | crate: hyperswitch_connectors | connector: square
fn from(item: SquarePaymentStatus) -> Self {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/square/transformers.rs | crate: hyperswitch_connectors | connector: square
use hyperswitch_domain_models::{
payment_method_data::{BankDebitData, Card, PayLaterData, PaymentMethodData, WalletData},
router_data::{ConnectorAuthType, PaymentMethodToken, RouterData},
router_flow_types::{refunds::Execute, RSync},
router_request_types::ResponseId,
router_response_types::{PaymentsResponseData, RefundsResponseData},
types,
};
use crate::{
types::{RefundsResponseRouterData, ResponseRouterData},
unimplemented_payment_method,
utils::{self, CardData, PaymentsAuthorizeRequestData, RouterData as _},
};
fn try_from(
item: ResponseRouterData<F, SquareTokenResponse, T, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/square/transformers.rs | crate: hyperswitch_connectors | connector: square
use common_enums::enums;
use hyperswitch_domain_models::{
payment_method_data::{BankDebitData, Card, PayLaterData, PaymentMethodData, WalletData},
router_data::{ConnectorAuthType, PaymentMethodToken, RouterData},
router_flow_types::{refunds::Execute, RSync},
router_request_types::ResponseId,
router_response_types::{PaymentsResponseData, RefundsResponseData},
types,
};
use crate::{
types::{RefundsResponseRouterData, ResponseRouterData},
unimplemented_payment_method,
utils::{self, CardData, PaymentsAuthorizeRequestData, RouterData as _},
};
fn try_from(
item: ResponseRouterData<F, SquareSessionResponse, T, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/square/transformers.rs | crate: hyperswitch_connectors | connector: square
use hyperswitch_domain_models::{
payment_method_data::{BankDebitData, Card, PayLaterData, PaymentMethodData, WalletData},
router_data::{ConnectorAuthType, PaymentMethodToken, RouterData},
router_flow_types::{refunds::Execute, RSync},
router_request_types::ResponseId,
router_response_types::{PaymentsResponseData, RefundsResponseData},
types,
};
use crate::{
types::{RefundsResponseRouterData, ResponseRouterData},
unimplemented_payment_method,
utils::{self, CardData, PaymentsAuthorizeRequestData, RouterData as _},
};
fn try_from(
value: (&types::TokenizationRouterData, PayLaterData),
) -> Result<Self, Self::Error> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/square/transformers.rs | crate: hyperswitch_connectors | connector: square
use hyperswitch_domain_models::{
payment_method_data::{BankDebitData, Card, PayLaterData, PaymentMethodData, WalletData},
router_data::{ConnectorAuthType, PaymentMethodToken, RouterData},
router_flow_types::{refunds::Execute, RSync},
router_request_types::ResponseId,
router_response_types::{PaymentsResponseData, RefundsResponseData},
types,
};
use crate::{
types::{RefundsResponseRouterData, ResponseRouterData},
unimplemented_payment_method,
utils::{self, CardData, PaymentsAuthorizeRequestData, RouterData as _},
};
fn try_from(
value: (&types::TokenizationRouterData, BankDebitData),
) -> Result<Self, Self::Error> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/opayo/transformers.rs | crate: hyperswitch_connectors | connector: opayo
use hyperswitch_domain_models::{
payment_method_data::PaymentMethodData,
router_data::{ConnectorAuthType, RouterData},
router_flow_types::{Execute, RSync},
router_request_types::ResponseId,
router_response_types::{PaymentsResponseData, RefundsResponseData},
types::{PaymentsAuthorizeRouterData, RefundsRouterData},
};
use masking::Secret;
use crate::{
types::{RefundsResponseRouterData, ResponseRouterData},
utils::{PaymentsAuthorizeRequestData, RouterData as OtherRouterData},
};
fn try_from(
item_data: &OpayoRouterData<&PaymentsAuthorizeRouterData>,
) -> Result<Self, Self::Error> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/opayo/transformers.rs | crate: hyperswitch_connectors | connector: opayo
fn from(item: OpayoPaymentStatus) -> Self {
{
OpayoPaymentStatus::Succeeded => Self::Charged,<|fim_suffix|>
<|fim_middle|>
OpayoPaymentStatus::Processing => Self::Authorizing,
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/opayo/transformers.rs | crate: hyperswitch_connectors | connector: opayo
use hyperswitch_domain_models::{
payment_method_data::PaymentMethodData,
router_data::{ConnectorAuthType, RouterData},
router_flow_types::{Execute, RSync},
router_request_types::ResponseId,
router_response_types::{PaymentsResponseData, RefundsResponseData},
types::{PaymentsAuthorizeRouterData, RefundsRouterData},
};
fn try_from(item: &OpayoRouterData<&RefundsRouterData<F>>) -> Result<Self, Self::Error> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/opayo/transformers.rs | crate: hyperswitch_connectors | connector: opayo
use common_enums::enums;
use hyperswitch_domain_models::{
payment_method_data::PaymentMethodData,
router_data::{ConnectorAuthType, RouterData},
router_flow_types::{Execute, RSync},
router_request_types::ResponseId,
router_response_types::{PaymentsResponseData, RefundsResponseData},
types::{PaymentsAuthorizeRouterData, RefundsRouterData},
};
use crate::{
types::{RefundsResponseRouterData, ResponseRouterData},
utils::{PaymentsAuthorizeRequestData, RouterData as OtherRouterData},
};
fn try_from(
item: ResponseRouterData<F, OpayoPaymentsResponse, T, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/opayo/transformers.rs | crate: hyperswitch_connectors | connector: opayo
fn from(item: OpayoPaymentStatus) -> Self {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/forte/transformers.rs | crate: hyperswitch_connectors | connector: forte
use common_enums::enums;
use common_utils::types::FloatMajorUnit;
use hyperswitch_domain_models::{
payment_method_data::PaymentMethodData,
router_data::{ConnectorAuthType, RouterData},
router_flow_types::refunds::{Execute, RSync},
router_request_types::ResponseId,
router_response_types::{PaymentsResponseData, RefundsResponseData},
types,
};
use masking::{PeekInterface, Secret};
use crate::{
types::{PaymentsCaptureResponseRouterData, RefundsResponseRouterData, ResponseRouterData},
utils::{
self, AddressDetailsData, CardData as _PaymentsAuthorizeRequestData,
PaymentsAuthorizeRequestData, RouterData as _,
},
};
fn try_from(
item_data: &ForteRouterData<&types::PaymentsAuthorizeRouterData>,
) -> Result<Self, Self::Error> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/forte/transformers.rs | crate: hyperswitch_connectors | connector: forte
use common_enums::enums;
use hyperswitch_domain_models::{
payment_method_data::PaymentMethodData,
router_data::{ConnectorAuthType, RouterData},
router_flow_types::refunds::{Execute, RSync},
router_request_types::ResponseId,
router_response_types::{PaymentsResponseData, RefundsResponseData},
types,
};
use crate::{
types::{PaymentsCaptureResponseRouterData, RefundsResponseRouterData, ResponseRouterData},
utils::{
self, AddressDetailsData, CardData as _PaymentsAuthorizeRequestData,
PaymentsAuthorizeRequestData, RouterData as _,
},
};
fn try_from(
item: ResponseRouterData<F, FortePaymentsSyncResponse, T, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/forte/transformers.rs | crate: hyperswitch_connectors | connector: forte
use crate::{
types::{PaymentsCaptureResponseRouterData, RefundsResponseRouterData, ResponseRouterData},
utils::{
self, AddressDetailsData, CardData as _PaymentsAuthorizeRequestData,
PaymentsAuthorizeRequestData, RouterData as _,
},
};
fn from(item: ForteResponseCode) -> Self {
{
ForteResponseCode::A01 | ForteResponseCode::A05 | ForteResponseCode::A06 => {
Self::Pending
}<|fim_suffix|>
<|fim_middle|>
_ => Self::Failure,
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/forte/transformers.rs | crate: hyperswitch_connectors | connector: forte
use common_enums::enums;
use crate::{
types::{PaymentsCaptureResponseRouterData, RefundsResponseRouterData, ResponseRouterData},
utils::{
self, AddressDetailsData, CardData as _PaymentsAuthorizeRequestData,
PaymentsAuthorizeRequestData, RouterData as _,
},
};
fn get_status(response_code: ForteResponseCode, action: ForteAction) -> enums::AttemptStatus {
{
ForteResponseCode::A01 => match action {
ForteAction::Authorize => enums::AttemptStatus::Authorized,
ForteAction::Sale => enums::AttemptStatus::Pending,
ForteAction::Verify => enums::AttemptStatus::Charged,
},<|fim_suffix|>
<|fim_middle|>
_ => enums::AttemptStatus::Failure,
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/forte/transformers.rs | crate: hyperswitch_connectors | connector: forte
fn from(item: FortePaymentStatus) -> Self {
{
FortePaymentStatus::Complete | FortePaymentStatus::Settled => Self::Charged,<|fim_suffix|>
<|fim_middle|>
FortePaymentStatus::Voided => Self::Voided,
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/forte/transformers.rs | crate: hyperswitch_connectors | connector: forte
use crate::{
types::{PaymentsCaptureResponseRouterData, RefundsResponseRouterData, ResponseRouterData},
utils::{
self, AddressDetailsData, CardData as _PaymentsAuthorizeRequestData,
PaymentsAuthorizeRequestData, RouterData as _,
},
};
fn from(item: ForteResponseCode) -> Self {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/forte/transformers.rs | crate: hyperswitch_connectors | connector: forte
fn from(item: RefundStatus) -> Self {
{
RefundStatus::Complete => Self::Success,<|fim_suffix|>
<|fim_middle|>
RefundStatus::Failed => Self::Failure,
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/forte/transformers.rs | crate: hyperswitch_connectors | connector: forte
use common_utils::types::FloatMajorUnit;
use hyperswitch_domain_models::{
payment_method_data::PaymentMethodData,
router_data::{ConnectorAuthType, RouterData},
router_flow_types::refunds::{Execute, RSync},
router_request_types::ResponseId,
router_response_types::{PaymentsResponseData, RefundsResponseData},
types,
};
use crate::{
types::{PaymentsCaptureResponseRouterData, RefundsResponseRouterData, ResponseRouterData},
utils::{
self, AddressDetailsData, CardData as _PaymentsAuthorizeRequestData,
PaymentsAuthorizeRequestData, RouterData as _,
},
};
fn try_from(
item_data: &ForteRouterData<&types::RefundsRouterData<F>>,
) -> Result<Self, Self::Error> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/forte/transformers.rs | crate: hyperswitch_connectors | connector: forte
use common_enums::enums;
use hyperswitch_domain_models::{
payment_method_data::PaymentMethodData,
router_data::{ConnectorAuthType, RouterData},
router_flow_types::refunds::{Execute, RSync},
router_request_types::ResponseId,
router_response_types::{PaymentsResponseData, RefundsResponseData},
types,
};
use crate::{
types::{PaymentsCaptureResponseRouterData, RefundsResponseRouterData, ResponseRouterData},
utils::{
self, AddressDetailsData, CardData as _PaymentsAuthorizeRequestData,
PaymentsAuthorizeRequestData, RouterData as _,
},
};
fn try_from(
item: ResponseRouterData<F, ForteCancelResponse, T, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/forte/transformers.rs | crate: hyperswitch_connectors | connector: forte
use common_enums::enums;
use hyperswitch_domain_models::{
payment_method_data::PaymentMethodData,
router_data::{ConnectorAuthType, RouterData},
router_flow_types::refunds::{Execute, RSync},
router_request_types::ResponseId,
router_response_types::{PaymentsResponseData, RefundsResponseData},
types,
};
use crate::{
types::{PaymentsCaptureResponseRouterData, RefundsResponseRouterData, ResponseRouterData},
utils::{
self, AddressDetailsData, CardData as _PaymentsAuthorizeRequestData,
PaymentsAuthorizeRequestData, RouterData as _,
},
};
fn try_from(
item: PaymentsCaptureResponseRouterData<ForteCaptureResponse>,
) -> Result<Self, Self::Error> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/forte/transformers.rs | crate: hyperswitch_connectors | connector: forte
use common_enums::enums;
use hyperswitch_domain_models::{
payment_method_data::PaymentMethodData,
router_data::{ConnectorAuthType, RouterData},
router_flow_types::refunds::{Execute, RSync},
router_request_types::ResponseId,
router_response_types::{PaymentsResponseData, RefundsResponseData},
types,
};
use crate::{
types::{PaymentsCaptureResponseRouterData, RefundsResponseRouterData, ResponseRouterData},
utils::{
self, AddressDetailsData, CardData as _PaymentsAuthorizeRequestData,
PaymentsAuthorizeRequestData, RouterData as _,
},
};
fn try_from(
item: ResponseRouterData<F, FortePaymentsSyncResponse, T, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
let transaction_id = &item.response.transaction_id;
Ok(Self {
status: enums::AttemptStatus::from(item.response.status),
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(transaction_id.to_string()),
redirection_data: Box::new(None),
mandate_reference: Box::new(None),
connector_metadata: Some(serde_json::json!(ForteMeta {
auth_id: item.response.authorization_code,
})),
network_txn_id: None,
connector_response_reference_id: Some(transaction_id.to_string()),
incremental_authorization_allowed: None,
charges: None,
}),
..item.data
})
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/forte/transformers.rs | crate: hyperswitch_connectors | connector: forte
use hyperswitch_domain_models::{
payment_method_data::PaymentMethodData,
router_data::{ConnectorAuthType, RouterData},
router_flow_types::refunds::{Execute, RSync},
router_request_types::ResponseId,
router_response_types::{PaymentsResponseData, RefundsResponseData},
types,
};
use crate::{
types::{PaymentsCaptureResponseRouterData, RefundsResponseRouterData, ResponseRouterData},
utils::{
self, AddressDetailsData, CardData as _PaymentsAuthorizeRequestData,
PaymentsAuthorizeRequestData, RouterData as _,
},
};
fn try_from(
item: ResponseRouterData<F, FortePaymentsResponse, T, PaymentsResponseData>,
) -> 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.