text stringlengths 70 351k | source stringclasses 4 values |
|---|---|
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/bluesnap/transformers.rs | crate: hyperswitch_connectors | connector: bluesnap
use api_models::{
payments::{
AmountInfo, ApplePayPaymentRequest, ApplePaySessionResponse,
ApplepayCombinedSessionTokenData, ApplepaySessionTokenData, ApplepaySessionTokenMetadata,
ApplepaySessionTokenResponse, NextActionCall, NoThirdPartySdkSessionResponse,
SdkNextAction, SessionToken,
},
webhooks::IncomingWebhookEvent,
};
use common_utils::{
consts::{APPLEPAY_VALIDATION_URL, BASE64_ENGINE},
errors::CustomResult,
ext_traits::{ByteSliceExt, Encode, OptionExt, StringExt, ValueExt},
pii::Email,
types::StringMajorUnit,
};
use hyperswitch_domain_models::{
address::AddressDetails,
payment_method_data::{self, PaymentMethodData, WalletData},
router_data::{ConnectorAuthType, RouterData},
router_flow_types::refunds::{Execute, RSync},
router_request_types::ResponseId,
router_response_types::{PaymentsResponseData, RefundsResponseData},
types,
};
use crate::{
types::{PaymentsSessionResponseRouterData, RefundsResponseRouterData, ResponseRouterData},
utils::{
self, AddressDetailsData, ApplePay, CardData as _, ForeignTryFrom,
PaymentsAuthorizeRequestData, PaymentsCompleteAuthorizeRequestData, RouterData as _,
},
};
fn try_from(item: &types::PaymentsSessionRouterData) -> Result<Self, Self::Error> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/bluesnap/transformers.rs | crate: hyperswitch_connectors | connector: bluesnap
use common_utils::{
consts::{APPLEPAY_VALIDATION_URL, BASE64_ENGINE},
errors::CustomResult,
ext_traits::{ByteSliceExt, Encode, OptionExt, StringExt, ValueExt},
pii::Email,
types::StringMajorUnit,
};
use hyperswitch_domain_models::{
address::AddressDetails,
payment_method_data::{self, PaymentMethodData, WalletData},
router_data::{ConnectorAuthType, RouterData},
router_flow_types::refunds::{Execute, RSync},
router_request_types::ResponseId,
router_response_types::{PaymentsResponseData, RefundsResponseData},
types,
};
use crate::{
types::{PaymentsSessionResponseRouterData, RefundsResponseRouterData, ResponseRouterData},
utils::{
self, AddressDetailsData, ApplePay, CardData as _, ForeignTryFrom,
PaymentsAuthorizeRequestData, PaymentsCompleteAuthorizeRequestData, RouterData as _,
},
};
fn try_from(
item: &BluesnapRouterData<&types::PaymentsAuthorizeRouterData>,
) -> Result<Self, Self::Error> {
match item.router_data.request.payment_method_data {
PaymentMethodData::Card(ref ccard) => Ok(Self {
cc_number: ccard.card_number.clone(),
exp_date: ccard.get_expiry_date_as_mmyyyy("/"),
}),
PaymentMethodData::Wallet(_)
| PaymentMethodData::PayLater(_)
| PaymentMethodData::BankRedirect(_)
| PaymentMethodData::BankDebit(_)
| PaymentMethodData::BankTransfer(_)
| PaymentMethodData::Crypto(_)
| PaymentMethodData::MandatePayment
| PaymentMethodData::Reward
| PaymentMethodData::RealTimePayment(_)
| PaymentMethodData::MobilePayment(_)
| PaymentMethodData::Upi(_)
| PaymentMethodData::CardRedirect(_)
| PaymentMethodData::Voucher(_)
| PaymentMethodData::GiftCard(_)
| PaymentMethodData::OpenBanking(_)
| PaymentMethodData::CardToken(_)
| PaymentMethodData::NetworkToken(_)
| PaymentMethodData::CardDetailsForNetworkTransactionId(_) => {
Err(errors::ConnectorError::NotImplemented(
"Selected payment method via Token flow through bluesnap".to_string(),
)
.into())
}
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/bluesnap/transformers.rs | crate: hyperswitch_connectors | connector: bluesnap
use common_utils::{
consts::{APPLEPAY_VALIDATION_URL, BASE64_ENGINE},
errors::CustomResult,
ext_traits::{ByteSliceExt, Encode, OptionExt, StringExt, ValueExt},
pii::Email,
types::StringMajorUnit,
};
use serde_json::Value;
fn try_from(details: BluesnapWebhookObjectResource) -> Result<Self, Self::Error> {
{
BluesnapWebhookEvents::Decline | BluesnapWebhookEvents::CcChargeFailed => Ok((
BluesnapTxnType::Capture,
BluesnapProcessingStatus::Fail,
details.reference_number,
)),<|fim_suffix|>
<|fim_middle|>
BluesnapWebhookEvents::Unknown => {
Err(errors::ConnectorError::WebhookResourceObjectNotFound)
}
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/bluesnap/transformers.rs | crate: hyperswitch_connectors | connector: bluesnap
fn from(item: BluesnapProcessingStatus) -> Self {
{
BluesnapProcessingStatus::Success => Self::Success,<|fim_suffix|>
<|fim_middle|>
BluesnapProcessingStatus::Fail => Self::Failure,
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/bluesnap/transformers.rs | crate: hyperswitch_connectors | connector: bluesnap
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct BluesnapCaptureRequest {
card_transaction_type: BluesnapTxnType,
transaction_id: String,
amount: Option<StringMajorUnit>,
}
impl TryFrom<&BluesnapRouterData<&types::PaymentsCaptureRouterData>> for BluesnapCaptureRequest {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: &BluesnapRouterData<&types::PaymentsCaptureRouterData>,
) -> Result<Self, Self::Error> {
let card_transaction_type = BluesnapTxnType::Capture;
let transaction_id = item
.router_data
.request
.connector_transaction_id
.to_string();
Ok(Self {
card_transaction_type,
transaction_id,
amount: Some(item.amount.to_owned()),
fn try_from(
item: &BluesnapRouterData<&types::PaymentsCaptureRouterData>,
) -> Result<Self, Self::Error> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/bluesnap/transformers.rs | crate: hyperswitch_connectors | connector: bluesnap
pf_token: Secret<String>,
three_d_secure: Option<BluesnapThreeDSecureInfo>,
transaction_fraud_info: Option<TransactionFraudInfo>,
card_holder_info: Option<BluesnapCardHolderInfo>,
merchant_transaction_id: Option<String>,
transaction_meta_data: Option<BluesnapMetadata>,
}
impl TryFrom<&BluesnapRouterData<&types::PaymentsCompleteAuthorizeRouterData>>
for BluesnapCompletePaymentsRequest
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: &BluesnapRouterData<&types::PaymentsCompleteAuthorizeRouterData>,
) -> Result<Self, Self::Error> {
let redirection_response: BluesnapRedirectionResponse = item
.router_data
.request
.redirect_response
.as_ref()
.and_then(|res| res.payload.to_owned())
.ok_or(errors::ConnectorError::MissingConnectorRedirectionPayload {
field_name: "request.redirect_response.payload",
})?
.parse_value("BluesnapRedirectionResponse")
fn try_from(
item: &BluesnapRouterData<&types::PaymentsCompleteAuthorizeRouterData>,
) -> Result<Self, Self::Error> {
{
Some(enums::CaptureMethod::Manual) => BluesnapTxnType::AuthOnly,<|fim_suffix|>
<|fim_middle|>
_ => BluesnapTxnType::AuthCapture,
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/bluesnap/transformers.rs | crate: hyperswitch_connectors | connector: bluesnap
use serde_json::Value;
fn convert_metadata_to_request_metadata(metadata: Value) -> Vec<RequestMetadata> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/bluesnap/transformers.rs | crate: hyperswitch_connectors | connector: bluesnap
fn from(error: ErrorDetails) -> Self {
Self {
error_code: error.code.to_string(),
error_message: error.error_name.unwrap_or(error.code),
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/bluesnap/transformers.rs | crate: hyperswitch_connectors | connector: bluesnap
use common_utils::{
consts::{APPLEPAY_VALIDATION_URL, BASE64_ENGINE},
errors::CustomResult,
ext_traits::{ByteSliceExt, Encode, OptionExt, StringExt, ValueExt},
pii::Email,
types::StringMajorUnit,
};
use hyperswitch_domain_models::{
address::AddressDetails,
payment_method_data::{self, PaymentMethodData, WalletData},
router_data::{ConnectorAuthType, RouterData},
router_flow_types::refunds::{Execute, RSync},
router_request_types::ResponseId,
router_response_types::{PaymentsResponseData, RefundsResponseData},
types,
};
fn get_card_holder_info(
address: &AddressDetails,
email: Email,
) -> CustomResult<Option<BluesnapCardHolderInfo>, errors::ConnectorError> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/bluesnap/transformers.rs | crate: hyperswitch_connectors | connector: bluesnap
use common_utils::{
consts::{APPLEPAY_VALIDATION_URL, BASE64_ENGINE},
errors::CustomResult,
ext_traits::{ByteSliceExt, Encode, OptionExt, StringExt, ValueExt},
pii::Email,
types::StringMajorUnit,
};
fn try_from(details: BluesnapWebhookObjectEventType) -> Result<Self, Self::Error> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/bluesnap/transformers.rs | crate: hyperswitch_connectors | connector: bluesnap
use common_enums::{enums, CountryAlpha2};
use hyperswitch_domain_models::{
address::AddressDetails,
payment_method_data::{self, PaymentMethodData, WalletData},
router_data::{ConnectorAuthType, RouterData},
router_flow_types::refunds::{Execute, RSync},
router_request_types::ResponseId,
router_response_types::{PaymentsResponseData, RefundsResponseData},
types,
};
use crate::{
types::{PaymentsSessionResponseRouterData, RefundsResponseRouterData, ResponseRouterData},
utils::{
self, AddressDetailsData, ApplePay, CardData as _, ForeignTryFrom,
PaymentsAuthorizeRequestData, PaymentsCompleteAuthorizeRequestData, RouterData as _,
},
};
fn try_from(
item: RefundsResponseRouterData<Execute, RefundResponse>,
) -> Result<Self, Self::Error> {
Ok(Self {
response: Ok(RefundsResponseData {
connector_refund_id: item.response.refund_transaction_id.to_string(),
refund_status: enums::RefundStatus::from(item.response.refund_status),
}),
..item.data
})
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/bluesnap/transformers.rs | crate: hyperswitch_connectors | connector: bluesnap
use common_enums::{enums, CountryAlpha2};
use hyperswitch_domain_models::{
address::AddressDetails,
payment_method_data::{self, PaymentMethodData, WalletData},
router_data::{ConnectorAuthType, RouterData},
router_flow_types::refunds::{Execute, RSync},
router_request_types::ResponseId,
router_response_types::{PaymentsResponseData, RefundsResponseData},
types,
};
use crate::{
types::{PaymentsSessionResponseRouterData, RefundsResponseRouterData, ResponseRouterData},
utils::{
self, AddressDetailsData, ApplePay, CardData as _, ForeignTryFrom,
PaymentsAuthorizeRequestData, PaymentsCompleteAuthorizeRequestData, RouterData as _,
},
};
fn try_from(
item: RefundsResponseRouterData<RSync, BluesnapPaymentsResponse>,
) -> Result<Self, Self::Error> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/bluesnap/transformers.rs | crate: hyperswitch_connectors | connector: bluesnap
use common_utils::{
consts::{APPLEPAY_VALIDATION_URL, BASE64_ENGINE},
errors::CustomResult,
ext_traits::{ByteSliceExt, Encode, OptionExt, StringExt, ValueExt},
pii::Email,
types::StringMajorUnit,
};
use hyperswitch_domain_models::{
address::AddressDetails,
payment_method_data::{self, PaymentMethodData, WalletData},
router_data::{ConnectorAuthType, RouterData},
router_flow_types::refunds::{Execute, RSync},
router_request_types::ResponseId,
router_response_types::{PaymentsResponseData, RefundsResponseData},
types,
};
use crate::{
types::{PaymentsSessionResponseRouterData, RefundsResponseRouterData, ResponseRouterData},
utils::{
self, AddressDetailsData, ApplePay, CardData as _, ForeignTryFrom,
PaymentsAuthorizeRequestData, PaymentsCompleteAuthorizeRequestData, RouterData as _,
},
};
fn try_from(
item: &BluesnapRouterData<&types::RefundsRouterData<F>>,
) -> Result<Self, Self::Error> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/bluesnap/transformers.rs | crate: hyperswitch_connectors | connector: bluesnap
use common_enums::{enums, CountryAlpha2};
use hyperswitch_domain_models::{
address::AddressDetails,
payment_method_data::{self, PaymentMethodData, WalletData},
router_data::{ConnectorAuthType, RouterData},
router_flow_types::refunds::{Execute, RSync},
router_request_types::ResponseId,
router_response_types::{PaymentsResponseData, RefundsResponseData},
types,
};
use crate::{
types::{PaymentsSessionResponseRouterData, RefundsResponseRouterData, ResponseRouterData},
utils::{
self, AddressDetailsData, ApplePay, CardData as _, ForeignTryFrom,
PaymentsAuthorizeRequestData, PaymentsCompleteAuthorizeRequestData, RouterData as _,
},
};
fn try_from(
item: ResponseRouterData<F, BluesnapPaymentsResponse, T, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/bluesnap/transformers.rs | crate: hyperswitch_connectors | connector: bluesnap
fn from(item: BluesnapRefundStatus) -> Self {
{
BluesnapRefundStatus::Success => Self::Success,<|fim_suffix|>
<|fim_middle|>
BluesnapRefundStatus::Pending => Self::Pending,
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/bluesnap/transformers.rs | crate: hyperswitch_connectors | connector: bluesnap
fn from(item: BluesnapProcessingStatus) -> Self {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/bluesnap/transformers.rs | crate: hyperswitch_connectors | connector: bluesnap
fn foreign_try_from(
item: (BluesnapTxnType, BluesnapProcessingStatus),
) -> Result<Self, Self::Error> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/bluesnap/transformers.rs | crate: hyperswitch_connectors | connector: bluesnap
use common_utils::{
consts::{APPLEPAY_VALIDATION_URL, BASE64_ENGINE},
errors::CustomResult,
ext_traits::{ByteSliceExt, Encode, OptionExt, StringExt, ValueExt},
pii::Email,
types::StringMajorUnit,
};
use hyperswitch_domain_models::{
address::AddressDetails,
payment_method_data::{self, PaymentMethodData, WalletData},
router_data::{ConnectorAuthType, RouterData},
router_flow_types::refunds::{Execute, RSync},
router_request_types::ResponseId,
router_response_types::{PaymentsResponseData, RefundsResponseData},
types,
};
use crate::{
types::{PaymentsSessionResponseRouterData, RefundsResponseRouterData, ResponseRouterData},
utils::{
self, AddressDetailsData, ApplePay, CardData as _, ForeignTryFrom,
PaymentsAuthorizeRequestData, PaymentsCompleteAuthorizeRequestData, RouterData as _,
},
};
fn try_from(
item: &BluesnapRouterData<&types::PaymentsCaptureRouterData>,
) -> Result<Self, Self::Error> {
let card_transaction_type = BluesnapTxnType::Capture;
let transaction_id = item
.router_data
.request
.connector_transaction_id
.to_string();
Ok(Self {
card_transaction_type,
transaction_id,
amount: Some(item.amount.to_owned()),
})
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/bluesnap/transformers.rs | crate: hyperswitch_connectors | connector: bluesnap
use hyperswitch_domain_models::{
address::AddressDetails,
payment_method_data::{self, PaymentMethodData, WalletData},
router_data::{ConnectorAuthType, RouterData},
router_flow_types::refunds::{Execute, RSync},
router_request_types::ResponseId,
router_response_types::{PaymentsResponseData, RefundsResponseData},
types,
};
fn from(item: payment_method_data::ApplepayPaymentMethod) -> Self {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/bluesnap/transformers.rs | crate: hyperswitch_connectors | connector: bluesnap
use common_enums::{enums, CountryAlpha2};
use common_utils::{
consts::{APPLEPAY_VALIDATION_URL, BASE64_ENGINE},
errors::CustomResult,
ext_traits::{ByteSliceExt, Encode, OptionExt, StringExt, ValueExt},
pii::Email,
types::StringMajorUnit,
};
use hyperswitch_domain_models::{
address::AddressDetails,
payment_method_data::{self, PaymentMethodData, WalletData},
router_data::{ConnectorAuthType, RouterData},
router_flow_types::refunds::{Execute, RSync},
router_request_types::ResponseId,
router_response_types::{PaymentsResponseData, RefundsResponseData},
types,
};
use masking::{ExposeInterface, PeekInterface, Secret};
use crate::{
types::{PaymentsSessionResponseRouterData, RefundsResponseRouterData, ResponseRouterData},
utils::{
self, AddressDetailsData, ApplePay, CardData as _, ForeignTryFrom,
PaymentsAuthorizeRequestData, PaymentsCompleteAuthorizeRequestData, RouterData as _,
},
};
fn try_from(
item: &BluesnapRouterData<&types::PaymentsAuthorizeRouterData>,
) -> Result<Self, Self::Error> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/worldline/transformers.rs | crate: hyperswitch_connectors | connector: worldline
use hyperswitch_domain_models::{
payment_method_data::{BankRedirectData, PaymentMethodData},
router_data::{ConnectorAuthType, RouterData},
router_flow_types::{
payments::Authorize,
refunds::{Execute, RSync},
},
router_request_types::{PaymentsAuthorizeData, ResponseId},
router_response_types::{PaymentsResponseData, RedirectForm, RefundsResponseData},
types::{PaymentsAuthorizeRouterData, PaymentsCaptureRouterData, RefundsRouterData},
};
use crate::{
types::{RefundsResponseRouterData, ResponseRouterData},
utils::{self, CardData, RouterData as RouterDataUtils},
};
fn try_from(
item: ResponseRouterData<F, PaymentResponse, T, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/worldline/transformers.rs | crate: hyperswitch_connectors | connector: worldline
use common_enums::enums::{AttemptStatus, BankNames, CaptureMethod, CountryAlpha2, Currency};
fn get_status(item: (PaymentStatus, CaptureMethod)) -> AttemptStatus {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/worldline/transformers.rs | crate: hyperswitch_connectors | connector: worldline
use hyperswitch_domain_models::{
payment_method_data::{BankRedirectData, PaymentMethodData},
router_data::{ConnectorAuthType, RouterData},
router_flow_types::{
payments::Authorize,
refunds::{Execute, RSync},
},
router_request_types::{PaymentsAuthorizeData, ResponseId},
router_response_types::{PaymentsResponseData, RedirectForm, RefundsResponseData},
types::{PaymentsAuthorizeRouterData, PaymentsCaptureRouterData, RefundsRouterData},
};
use masking::{PeekInterface, Secret};
fn build_customer_info(
billing_address: &hyperswitch_domain_models::address::Address,
email: &Option<Email>,
) -> Result<Customer, error_stack::Report<errors::ConnectorError>> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/worldline/transformers.rs | crate: hyperswitch_connectors | connector: worldline
use hyperswitch_domain_models::{
payment_method_data::{BankRedirectData, PaymentMethodData},
router_data::{ConnectorAuthType, RouterData},
router_flow_types::{
payments::Authorize,
refunds::{Execute, RSync},
},
router_request_types::{PaymentsAuthorizeData, ResponseId},
router_response_types::{PaymentsResponseData, RedirectForm, RefundsResponseData},
types::{PaymentsAuthorizeRouterData, PaymentsCaptureRouterData, RefundsRouterData},
};
use crate::{
types::{RefundsResponseRouterData, ResponseRouterData},
utils::{self, CardData, RouterData as RouterDataUtils},
};
fn make_bank_redirect_request(
req: &PaymentsAuthorizeRouterData,
bank_redirect: &BankRedirectData,
) -> Result<RedirectPaymentMethod, error_stack::Report<errors::ConnectorError>> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/worldline/transformers.rs | crate: hyperswitch_connectors | connector: worldline
use common_enums::enums::{AttemptStatus, BankNames, CaptureMethod, CountryAlpha2, Currency};
use hyperswitch_domain_models::{
payment_method_data::{BankRedirectData, PaymentMethodData},
router_data::{ConnectorAuthType, RouterData},
router_flow_types::{
payments::Authorize,
refunds::{Execute, RSync},
},
router_request_types::{PaymentsAuthorizeData, ResponseId},
router_response_types::{PaymentsResponseData, RedirectForm, RefundsResponseData},
types::{PaymentsAuthorizeRouterData, PaymentsCaptureRouterData, RefundsRouterData},
};
use masking::{PeekInterface, Secret};
use crate::{
types::{RefundsResponseRouterData, ResponseRouterData},
utils::{self, CardData, RouterData as RouterDataUtils},
};
fn make_card_request(
req: &PaymentsAuthorizeData,
ccard: &hyperswitch_domain_models::payment_method_data::Card,
card_holder_name: Option<Secret<String>>,
) -> Result<CardPaymentMethod, error_stack::Report<errors::ConnectorError>> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/worldline/transformers.rs | crate: hyperswitch_connectors | connector: worldline
use hyperswitch_domain_models::{
payment_method_data::{BankRedirectData, PaymentMethodData},
router_data::{ConnectorAuthType, RouterData},
router_flow_types::{
payments::Authorize,
refunds::{Execute, RSync},
},
router_request_types::{PaymentsAuthorizeData, ResponseId},
router_response_types::{PaymentsResponseData, RedirectForm, RefundsResponseData},
types::{PaymentsAuthorizeRouterData, PaymentsCaptureRouterData, RefundsRouterData},
};
use crate::{
types::{RefundsResponseRouterData, ResponseRouterData},
utils::{self, CardData, RouterData as RouterDataUtils},
};
fn try_from(
item: &WorldlineRouterData<
&RouterData<Authorize, PaymentsAuthorizeData, PaymentsResponseData>,
>,
) -> Result<Self, Self::Error> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/worldline/transformers.rs | crate: hyperswitch_connectors | connector: worldline
use common_enums::enums::{AttemptStatus, BankNames, CaptureMethod, CountryAlpha2, Currency};
fn try_from(bank: &BankNames) -> Result<Self, Self::Error> {
{
BankNames::AbnAmro => Ok(Self::Abnamro),<|fim_suffix|>
<|fim_middle|>
_ => Err(errors::ConnectorError::FlowNotSupported {
flow: bank.to_string(),
connector: "Worldline".to_string(),
}
.into()),
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/worldline/transformers.rs | crate: hyperswitch_connectors | connector: worldline
use crate::{
types::{RefundsResponseRouterData, ResponseRouterData},
utils::{self, CardData, RouterData as RouterDataUtils},
};
fn try_from(issuer: utils::CardIssuer) -> Result<Self, Self::Error> {
{
utils::CardIssuer::AmericanExpress => Ok(Self::Amex),<|fim_suffix|>
<|fim_middle|>
_ => Err(errors::ConnectorError::NotImplemented(
utils::get_unimplemented_payment_method_error_message("worldline"),
)
.into()),
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/worldline/transformers.rs | crate: hyperswitch_connectors | connector: worldline
use common_enums::enums::{AttemptStatus, BankNames, CaptureMethod, CountryAlpha2, Currency};
use hyperswitch_domain_models::{
payment_method_data::{BankRedirectData, PaymentMethodData},
router_data::{ConnectorAuthType, RouterData},
router_flow_types::{
payments::Authorize,
refunds::{Execute, RSync},
},
router_request_types::{PaymentsAuthorizeData, ResponseId},
router_response_types::{PaymentsResponseData, RedirectForm, RefundsResponseData},
types::{PaymentsAuthorizeRouterData, PaymentsCaptureRouterData, RefundsRouterData},
};
fn try_from(
(_currency_unit, _currency, amount, item): (&CurrencyUnit, Currency, i64, T),
) -> Result<Self, Self::Error> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/worldline/transformers.rs | crate: hyperswitch_connectors | connector: worldline
fn from(item: RefundStatus) -> Self {
match item {
RefundStatus::Refunded => Self::Success,
RefundStatus::Cancelled | RefundStatus::Rejected => Self::Failure,
RefundStatus::Processing => Self::Pending,
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/worldline/transformers.rs | crate: hyperswitch_connectors | connector: worldline
use hyperswitch_domain_models::{
payment_method_data::{BankRedirectData, PaymentMethodData},
router_data::{ConnectorAuthType, RouterData},
router_flow_types::{
payments::Authorize,
refunds::{Execute, RSync},
},
router_request_types::{PaymentsAuthorizeData, ResponseId},
router_response_types::{PaymentsResponseData, RedirectForm, RefundsResponseData},
types::{PaymentsAuthorizeRouterData, PaymentsCaptureRouterData, RefundsRouterData},
};
fn try_from(item: &RefundsRouterData<F>) -> Result<Self, Self::Error> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/worldline/transformers.rs | crate: hyperswitch_connectors | connector: worldline
use hyperswitch_domain_models::{
payment_method_data::{BankRedirectData, PaymentMethodData},
router_data::{ConnectorAuthType, RouterData},
router_flow_types::{
payments::Authorize,
refunds::{Execute, RSync},
},
router_request_types::{PaymentsAuthorizeData, ResponseId},
router_response_types::{PaymentsResponseData, RedirectForm, RefundsResponseData},
types::{PaymentsAuthorizeRouterData, PaymentsCaptureRouterData, RefundsRouterData},
};
fn try_from(_item: &PaymentsCaptureRouterData) -> Result<Self, Self::Error> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/worldline/transformers.rs | crate: hyperswitch_connectors | connector: worldline
use hyperswitch_domain_models::{
payment_method_data::{BankRedirectData, PaymentMethodData},
router_data::{ConnectorAuthType, RouterData},
router_flow_types::{
payments::Authorize,
refunds::{Execute, RSync},
},
router_request_types::{PaymentsAuthorizeData, ResponseId},
router_response_types::{PaymentsResponseData, RedirectForm, RefundsResponseData},
types::{PaymentsAuthorizeRouterData, PaymentsCaptureRouterData, RefundsRouterData},
};
use crate::{
types::{RefundsResponseRouterData, ResponseRouterData},
utils::{self, CardData, RouterData as RouterDataUtils},
};
fn try_from(
item: ResponseRouterData<F, Payment, T, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/worldline/transformers.rs | crate: hyperswitch_connectors | connector: worldline
use hyperswitch_domain_models::{
payment_method_data::{BankRedirectData, PaymentMethodData},
router_data::{ConnectorAuthType, RouterData},
router_flow_types::{
payments::Authorize,
refunds::{Execute, RSync},
},
router_request_types::{PaymentsAuthorizeData, ResponseId},
router_response_types::{PaymentsResponseData, RedirectForm, RefundsResponseData},
types::{PaymentsAuthorizeRouterData, PaymentsCaptureRouterData, RefundsRouterData},
};
fn from(value: hyperswitch_domain_models::address::AddressDetails) -> Self {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/worldline/transformers.rs | crate: hyperswitch_connectors | connector: worldline
use hyperswitch_domain_models::{
payment_method_data::{BankRedirectData, PaymentMethodData},
router_data::{ConnectorAuthType, RouterData},
router_flow_types::{
payments::Authorize,
refunds::{Execute, RSync},
},
router_request_types::{PaymentsAuthorizeData, ResponseId},
router_response_types::{PaymentsResponseData, RedirectForm, RefundsResponseData},
types::{PaymentsAuthorizeRouterData, PaymentsCaptureRouterData, RefundsRouterData},
};
fn get_address(
billing: &hyperswitch_domain_models::address::Address,
) -> Option<(
&hyperswitch_domain_models::address::Address,
&hyperswitch_domain_models::address::AddressDetails,
)> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/worldline/transformers.rs | crate: hyperswitch_connectors | connector: worldline
use common_enums::enums::{AttemptStatus, BankNames, CaptureMethod, CountryAlpha2, Currency};
fn try_from(bank: &BankNames) -> Result<Self, Self::Error> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/worldline/transformers.rs | crate: hyperswitch_connectors | connector: worldline
use common_enums::enums::{AttemptStatus, BankNames, CaptureMethod, CountryAlpha2, Currency};
use hyperswitch_domain_models::{
payment_method_data::{BankRedirectData, PaymentMethodData},
router_data::{ConnectorAuthType, RouterData},
router_flow_types::{
payments::Authorize,
refunds::{Execute, RSync},
},
router_request_types::{PaymentsAuthorizeData, ResponseId},
router_response_types::{PaymentsResponseData, RedirectForm, RefundsResponseData},
types::{PaymentsAuthorizeRouterData, PaymentsCaptureRouterData, RefundsRouterData},
};
fn try_from(
(_currency_unit, _currency, amount, item): (&CurrencyUnit, Currency, i64, T),
) -> Result<Self, Self::Error> {
Ok(Self {
amount,
router_data: item,
})
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/deutschebank/transformers.rs | crate: hyperswitch_connectors | connector: deutschebank
use common_enums::{enums, PaymentMethod};
use hyperswitch_domain_models::{
payment_method_data::{BankDebitData, PaymentMethodData},
router_data::{AccessToken, ConnectorAuthType, ErrorResponse, RouterData},
router_flow_types::{
payments::{Authorize, Capture, CompleteAuthorize, PSync},
refunds::{Execute, RSync},
},
router_request_types::{
CompleteAuthorizeData, PaymentsAuthorizeData, PaymentsCaptureData, PaymentsSyncData,
ResponseId,
},
router_response_types::{
MandateReference, PaymentsResponseData, RedirectForm, RefundsResponseData,
},
types::{
PaymentsAuthorizeRouterData, PaymentsCancelRouterData, PaymentsCaptureRouterData,
PaymentsCompleteAuthorizeRouterData, RefundsRouterData,
},
};
use crate::{
types::{PaymentsCancelResponseRouterData, RefundsResponseRouterData, ResponseRouterData},
utils::{
self, AddressDetailsData, CardData, PaymentsAuthorizeRequestData,
PaymentsCompleteAuthorizeRequestData, RefundsRequestData, RouterData as OtherRouterData,
},
};
fn try_from(
item: RefundsResponseRouterData<RSync, DeutschebankPaymentsResponse>,
) -> Result<Self, Self::Error> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/deutschebank/transformers.rs | crate: hyperswitch_connectors | connector: deutschebank
use common_enums::{enums, PaymentMethod};
use hyperswitch_domain_models::{
payment_method_data::{BankDebitData, PaymentMethodData},
router_data::{AccessToken, ConnectorAuthType, ErrorResponse, RouterData},
router_flow_types::{
payments::{Authorize, Capture, CompleteAuthorize, PSync},
refunds::{Execute, RSync},
},
router_request_types::{
CompleteAuthorizeData, PaymentsAuthorizeData, PaymentsCaptureData, PaymentsSyncData,
ResponseId,
},
router_response_types::{
MandateReference, PaymentsResponseData, RedirectForm, RefundsResponseData,
},
types::{
PaymentsAuthorizeRouterData, PaymentsCancelRouterData, PaymentsCaptureRouterData,
PaymentsCompleteAuthorizeRouterData, RefundsRouterData,
},
};
use crate::{
types::{PaymentsCancelResponseRouterData, RefundsResponseRouterData, ResponseRouterData},
utils::{
self, AddressDetailsData, CardData, PaymentsAuthorizeRequestData,
PaymentsCompleteAuthorizeRequestData, RefundsRequestData, RouterData as OtherRouterData,
},
};
fn try_from(
item: ResponseRouterData<
PSync,
DeutschebankPaymentsResponse,
PaymentsSyncData,
PaymentsResponseData,
>,
) -> Result<Self, Self::Error> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/deutschebank/transformers.rs | crate: hyperswitch_connectors | connector: deutschebank
use common_enums::{enums, PaymentMethod};
use hyperswitch_domain_models::{
payment_method_data::{BankDebitData, PaymentMethodData},
router_data::{AccessToken, ConnectorAuthType, ErrorResponse, RouterData},
router_flow_types::{
payments::{Authorize, Capture, CompleteAuthorize, PSync},
refunds::{Execute, RSync},
},
router_request_types::{
CompleteAuthorizeData, PaymentsAuthorizeData, PaymentsCaptureData, PaymentsSyncData,
ResponseId,
},
router_response_types::{
MandateReference, PaymentsResponseData, RedirectForm, RefundsResponseData,
},
types::{
PaymentsAuthorizeRouterData, PaymentsCancelRouterData, PaymentsCaptureRouterData,
PaymentsCompleteAuthorizeRouterData, RefundsRouterData,
},
};
use crate::{
types::{PaymentsCancelResponseRouterData, RefundsResponseRouterData, ResponseRouterData},
utils::{
self, AddressDetailsData, CardData, PaymentsAuthorizeRequestData,
PaymentsCompleteAuthorizeRequestData, RefundsRequestData, RouterData as OtherRouterData,
},
};
fn try_from(
item: ResponseRouterData<
Capture,
DeutschebankPaymentsResponse,
PaymentsCaptureData,
PaymentsResponseData,
>,
) -> Result<Self, Self::Error> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/deutschebank/transformers.rs | crate: hyperswitch_connectors | connector: deutschebank
use common_enums::{enums, PaymentMethod};
use hyperswitch_domain_models::{
payment_method_data::{BankDebitData, PaymentMethodData},
router_data::{AccessToken, ConnectorAuthType, ErrorResponse, RouterData},
router_flow_types::{
payments::{Authorize, Capture, CompleteAuthorize, PSync},
refunds::{Execute, RSync},
},
router_request_types::{
CompleteAuthorizeData, PaymentsAuthorizeData, PaymentsCaptureData, PaymentsSyncData,
ResponseId,
},
router_response_types::{
MandateReference, PaymentsResponseData, RedirectForm, RefundsResponseData,
},
types::{
PaymentsAuthorizeRouterData, PaymentsCancelRouterData, PaymentsCaptureRouterData,
PaymentsCompleteAuthorizeRouterData, RefundsRouterData,
},
};
use crate::{
types::{PaymentsCancelResponseRouterData, RefundsResponseRouterData, ResponseRouterData},
utils::{
self, AddressDetailsData, CardData, PaymentsAuthorizeRequestData,
PaymentsCompleteAuthorizeRequestData, RefundsRequestData, RouterData as OtherRouterData,
},
};
fn try_from(
item: ResponseRouterData<
CompleteAuthorize,
DeutschebankPaymentsResponse,
CompleteAuthorizeData,
PaymentsResponseData,
>,
) -> Result<Self, Self::Error> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/deutschebank/transformers.rs | crate: hyperswitch_connectors | connector: deutschebank
use common_enums::{enums, PaymentMethod};
use hyperswitch_domain_models::{
payment_method_data::{BankDebitData, PaymentMethodData},
router_data::{AccessToken, ConnectorAuthType, ErrorResponse, RouterData},
router_flow_types::{
payments::{Authorize, Capture, CompleteAuthorize, PSync},
refunds::{Execute, RSync},
},
router_request_types::{
CompleteAuthorizeData, PaymentsAuthorizeData, PaymentsCaptureData, PaymentsSyncData,
ResponseId,
},
router_response_types::{
MandateReference, PaymentsResponseData, RedirectForm, RefundsResponseData,
},
types::{
PaymentsAuthorizeRouterData, PaymentsCancelRouterData, PaymentsCaptureRouterData,
PaymentsCompleteAuthorizeRouterData, RefundsRouterData,
},
};
use crate::{
types::{PaymentsCancelResponseRouterData, RefundsResponseRouterData, ResponseRouterData},
utils::{
self, AddressDetailsData, CardData, PaymentsAuthorizeRequestData,
PaymentsCompleteAuthorizeRequestData, RefundsRequestData, RouterData as OtherRouterData,
},
};
fn try_from(
item: ResponseRouterData<
Authorize,
DeutschebankPaymentsResponse,
PaymentsAuthorizeData,
PaymentsResponseData,
>,
) -> Result<Self, Self::Error> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/deutschebank/transformers.rs | crate: hyperswitch_connectors | connector: deutschebank
use common_enums::{enums, PaymentMethod};
use common_utils::{ext_traits::ValueExt, pii::Email, types::MinorUnit};
use hyperswitch_domain_models::{
payment_method_data::{BankDebitData, PaymentMethodData},
router_data::{AccessToken, ConnectorAuthType, ErrorResponse, RouterData},
router_flow_types::{
payments::{Authorize, Capture, CompleteAuthorize, PSync},
refunds::{Execute, RSync},
},
router_request_types::{
CompleteAuthorizeData, PaymentsAuthorizeData, PaymentsCaptureData, PaymentsSyncData,
ResponseId,
},
router_response_types::{
MandateReference, PaymentsResponseData, RedirectForm, RefundsResponseData,
},
types::{
PaymentsAuthorizeRouterData, PaymentsCancelRouterData, PaymentsCaptureRouterData,
PaymentsCompleteAuthorizeRouterData, RefundsRouterData,
},
};
use masking::{ExposeInterface, PeekInterface, Secret};
use crate::{
types::{PaymentsCancelResponseRouterData, RefundsResponseRouterData, ResponseRouterData},
utils::{
self, AddressDetailsData, CardData, PaymentsAuthorizeRequestData,
PaymentsCompleteAuthorizeRequestData, RefundsRequestData, RouterData as OtherRouterData,
},
};
fn try_from(
item: ResponseRouterData<
Authorize,
DeutschebankMandatePostResponse,
PaymentsAuthorizeData,
PaymentsResponseData,
>,
) -> Result<Self, Self::Error> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/deutschebank/transformers.rs | crate: hyperswitch_connectors | connector: deutschebank
item.http_code,
)),
..item.data
})
}
}
}
impl TryFrom<RefundsResponseRouterData<RSync, DeutschebankPaymentsResponse>>
for RefundsRouterData<RSync>
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: RefundsResponseRouterData<RSync, DeutschebankPaymentsResponse>,
) -> Result<Self, Self::Error> {
let response_code = item.response.rc.clone();
let status = if is_response_success(&response_code) {
item.response
.tx_action
.and_then(|tx_action| match tx_action {
DeutschebankTXAction::Credit | DeutschebankTXAction::Refund => {
Some(enums::RefundStatus::Success)
}
DeutschebankTXAction::Preauthorization
| DeutschebankTXAction::Authorization
fn try_from(
item: RefundsResponseRouterData<RSync, DeutschebankPaymentsResponse>,
) -> Result<Self, Self::Error> {
{
Some(enums::RefundStatus::Failure) => Ok(Self {
status: common_enums::AttemptStatus::Failure,
response: Err(get_error_response(
response_code.clone(),
item.response.message.clone(),
item.http_code,
)),
..item.data
}),<|fim_suffix|>
<|fim_middle|>
None => Ok(Self { ..item.data }),
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/deutschebank/transformers.rs | crate: hyperswitch_connectors | connector: deutschebank
impl
TryFrom<
ResponseRouterData<
Authorize,
DeutschebankMandatePostResponse,
PaymentsAuthorizeData,
PaymentsResponseData,
>,
> for RouterData<Authorize, PaymentsAuthorizeData, PaymentsResponseData>
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: ResponseRouterData<
Authorize,
DeutschebankMandatePostResponse,
PaymentsAuthorizeData,
PaymentsResponseData,
>,
) -> Result<Self, Self::Error> {
let signed_on = match item.response.approval_date.clone() {
Some(date) => date.chars().take(10).collect(),
None => time::OffsetDateTime::now_utc().date().to_string(),
};
let response_code = item.response.rc.clone();
fn try_from(
item: ResponseRouterData<
Authorize,
DeutschebankMandatePostResponse,
PaymentsAuthorizeData,
PaymentsResponseData,
>,
) -> Result<Self, Self::Error> {
{
Some(date) => date.chars().take(10).collect(),<|fim_suffix|>
<|fim_middle|>
None => time::OffsetDateTime::now_utc().date().to_string(),
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/deutschebank/transformers.rs | crate: hyperswitch_connectors | connector: deutschebank
use common_enums::{enums, PaymentMethod};
use hyperswitch_domain_models::{
payment_method_data::{BankDebitData, PaymentMethodData},
router_data::{AccessToken, ConnectorAuthType, ErrorResponse, RouterData},
router_flow_types::{
payments::{Authorize, Capture, CompleteAuthorize, PSync},
refunds::{Execute, RSync},
},
router_request_types::{
CompleteAuthorizeData, PaymentsAuthorizeData, PaymentsCaptureData, PaymentsSyncData,
ResponseId,
},
router_response_types::{
MandateReference, PaymentsResponseData, RedirectForm, RefundsResponseData,
},
types::{
PaymentsAuthorizeRouterData, PaymentsCancelRouterData, PaymentsCaptureRouterData,
PaymentsCompleteAuthorizeRouterData, RefundsRouterData,
},
};
use crate::{
types::{PaymentsCancelResponseRouterData, RefundsResponseRouterData, ResponseRouterData},
utils::{
self, AddressDetailsData, CardData, PaymentsAuthorizeRequestData,
PaymentsCompleteAuthorizeRequestData, RefundsRequestData, RouterData as OtherRouterData,
},
};
fn try_from(
item: RefundsResponseRouterData<Execute, DeutschebankPaymentsResponse>,
) -> Result<Self, Self::Error> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/deutschebank/transformers.rs | crate: hyperswitch_connectors | connector: deutschebank
use common_enums::{enums, PaymentMethod};
use hyperswitch_domain_models::{
payment_method_data::{BankDebitData, PaymentMethodData},
router_data::{AccessToken, ConnectorAuthType, ErrorResponse, RouterData},
router_flow_types::{
payments::{Authorize, Capture, CompleteAuthorize, PSync},
refunds::{Execute, RSync},
},
router_request_types::{
CompleteAuthorizeData, PaymentsAuthorizeData, PaymentsCaptureData, PaymentsSyncData,
ResponseId,
},
router_response_types::{
MandateReference, PaymentsResponseData, RedirectForm, RefundsResponseData,
},
types::{
PaymentsAuthorizeRouterData, PaymentsCancelRouterData, PaymentsCaptureRouterData,
PaymentsCompleteAuthorizeRouterData, RefundsRouterData,
},
};
use crate::{
types::{PaymentsCancelResponseRouterData, RefundsResponseRouterData, ResponseRouterData},
utils::{
self, AddressDetailsData, CardData, PaymentsAuthorizeRequestData,
PaymentsCompleteAuthorizeRequestData, RefundsRequestData, RouterData as OtherRouterData,
},
};
fn try_from(item: &DeutschebankRouterData<&RefundsRouterData<F>>) -> Result<Self, Self::Error> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/deutschebank/transformers.rs | crate: hyperswitch_connectors | connector: deutschebank
use common_enums::{enums, PaymentMethod};
use crate::{
types::{PaymentsCancelResponseRouterData, RefundsResponseRouterData, ResponseRouterData},
utils::{
self, AddressDetailsData, CardData, PaymentsAuthorizeRequestData,
PaymentsCompleteAuthorizeRequestData, RefundsRequestData, RouterData as OtherRouterData,
},
};
fn try_from(
item: PaymentsCancelResponseRouterData<DeutschebankPaymentsResponse>,
) -> Result<Self, Self::Error> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/deutschebank/transformers.rs | crate: hyperswitch_connectors | connector: deutschebank
use common_enums::{enums, PaymentMethod};
use hyperswitch_domain_models::{
payment_method_data::{BankDebitData, PaymentMethodData},
router_data::{AccessToken, ConnectorAuthType, ErrorResponse, RouterData},
router_flow_types::{
payments::{Authorize, Capture, CompleteAuthorize, PSync},
refunds::{Execute, RSync},
},
router_request_types::{
CompleteAuthorizeData, PaymentsAuthorizeData, PaymentsCaptureData, PaymentsSyncData,
ResponseId,
},
router_response_types::{
MandateReference, PaymentsResponseData, RedirectForm, RefundsResponseData,
},
types::{
PaymentsAuthorizeRouterData, PaymentsCancelRouterData, PaymentsCaptureRouterData,
PaymentsCompleteAuthorizeRouterData, RefundsRouterData,
},
};
use crate::{
types::{PaymentsCancelResponseRouterData, RefundsResponseRouterData, ResponseRouterData},
utils::{
self, AddressDetailsData, CardData, PaymentsAuthorizeRequestData,
PaymentsCompleteAuthorizeRequestData, RefundsRequestData, RouterData as OtherRouterData,
},
};
fn try_from(
item: &DeutschebankRouterData<&PaymentsCaptureRouterData>,
) -> Result<Self, Self::Error> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/deutschebank/transformers.rs | crate: hyperswitch_connectors | connector: deutschebank
fn is_response_success(rc: &String) -> bool {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/deutschebank/transformers.rs | crate: hyperswitch_connectors | connector: deutschebank
use hyperswitch_domain_models::{
payment_method_data::{BankDebitData, PaymentMethodData},
router_data::{AccessToken, ConnectorAuthType, ErrorResponse, RouterData},
router_flow_types::{
payments::{Authorize, Capture, CompleteAuthorize, PSync},
refunds::{Execute, RSync},
},
router_request_types::{
CompleteAuthorizeData, PaymentsAuthorizeData, PaymentsCaptureData, PaymentsSyncData,
ResponseId,
},
router_response_types::{
MandateReference, PaymentsResponseData, RedirectForm, RefundsResponseData,
},
types::{
PaymentsAuthorizeRouterData, PaymentsCancelRouterData, PaymentsCaptureRouterData,
PaymentsCompleteAuthorizeRouterData, RefundsRouterData,
},
};
fn get_error_response(error_code: String, error_reason: String, status_code: u16) -> ErrorResponse {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/deutschebank/transformers.rs | crate: hyperswitch_connectors | connector: deutschebank
fn from(item: DeutschebankSEPAMandateStatus) -> Self {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/deutschebank/transformers.rs | crate: hyperswitch_connectors | connector: deutschebank
use hyperswitch_domain_models::{
payment_method_data::{BankDebitData, PaymentMethodData},
router_data::{AccessToken, ConnectorAuthType, ErrorResponse, RouterData},
router_flow_types::{
payments::{Authorize, Capture, CompleteAuthorize, PSync},
refunds::{Execute, RSync},
},
router_request_types::{
CompleteAuthorizeData, PaymentsAuthorizeData, PaymentsCaptureData, PaymentsSyncData,
ResponseId,
},
router_response_types::{
MandateReference, PaymentsResponseData, RedirectForm, RefundsResponseData,
},
types::{
PaymentsAuthorizeRouterData, PaymentsCancelRouterData, PaymentsCaptureRouterData,
PaymentsCompleteAuthorizeRouterData, RefundsRouterData,
},
};
use crate::{
types::{PaymentsCancelResponseRouterData, RefundsResponseRouterData, ResponseRouterData},
utils::{
self, AddressDetailsData, CardData, PaymentsAuthorizeRequestData,
PaymentsCompleteAuthorizeRequestData, RefundsRequestData, RouterData as OtherRouterData,
},
};
fn try_from(
item: ResponseRouterData<F, DeutschebankAccessTokenResponse, T, AccessToken>,
) -> Result<Self, Self::Error> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/deutschebank/transformers.rs | crate: hyperswitch_connectors | connector: deutschebank
use hyperswitch_domain_models::{
payment_method_data::{BankDebitData, PaymentMethodData},
router_data::{AccessToken, ConnectorAuthType, ErrorResponse, RouterData},
router_flow_types::{
payments::{Authorize, Capture, CompleteAuthorize, PSync},
refunds::{Execute, RSync},
},
router_request_types::{
CompleteAuthorizeData, PaymentsAuthorizeData, PaymentsCaptureData, PaymentsSyncData,
ResponseId,
},
router_response_types::{
MandateReference, PaymentsResponseData, RedirectForm, RefundsResponseData,
},
types::{
PaymentsAuthorizeRouterData, PaymentsCancelRouterData, PaymentsCaptureRouterData,
PaymentsCompleteAuthorizeRouterData, RefundsRouterData,
},
};
fn try_from(auth_type: &ConnectorAuthType) -> Result<Self, Self::Error> {
{
ConnectorAuthType::SignatureKey {
api_key,
key1,
api_secret,
} => Ok(Self {
client_id: api_key.to_owned(),
merchant_id: key1.to_owned(),
client_key: api_secret.to_owned(),
}),<|fim_suffix|>
<|fim_middle|>
_ => Err(errors::ConnectorError::FailedToObtainAuthType.into()),
}
} | ast_fragments |
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/deutschebank/transformers.rs | crate: hyperswitch_connectors | connector: deutschebank
use common_utils::{ext_traits::ValueExt, pii::Email, types::MinorUnit};
use hyperswitch_domain_models::{
payment_method_data::{BankDebitData, PaymentMethodData},
router_data::{AccessToken, ConnectorAuthType, ErrorResponse, RouterData},
router_flow_types::{
payments::{Authorize, Capture, CompleteAuthorize, PSync},
refunds::{Execute, RSync},
},
router_request_types::{
CompleteAuthorizeData, PaymentsAuthorizeData, PaymentsCaptureData, PaymentsSyncData,
ResponseId,
},
router_response_types::{
MandateReference, PaymentsResponseData, RedirectForm, RefundsResponseData,
},
types::{
PaymentsAuthorizeRouterData, PaymentsCancelRouterData, PaymentsCaptureRouterData,
PaymentsCompleteAuthorizeRouterData, RefundsRouterData,
},
};
fn from((amount, item): (MinorUnit, T)) -> Self {
Self {
amount,
router_data: item,
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/deutschebank/transformers.rs | crate: hyperswitch_connectors | connector: deutschebank
use common_enums::{enums, PaymentMethod};
use hyperswitch_domain_models::{
payment_method_data::{BankDebitData, PaymentMethodData},
router_data::{AccessToken, ConnectorAuthType, ErrorResponse, RouterData},
router_flow_types::{
payments::{Authorize, Capture, CompleteAuthorize, PSync},
refunds::{Execute, RSync},
},
router_request_types::{
CompleteAuthorizeData, PaymentsAuthorizeData, PaymentsCaptureData, PaymentsSyncData,
ResponseId,
},
router_response_types::{
MandateReference, PaymentsResponseData, RedirectForm, RefundsResponseData,
},
types::{
PaymentsAuthorizeRouterData, PaymentsCancelRouterData, PaymentsCaptureRouterData,
PaymentsCompleteAuthorizeRouterData, RefundsRouterData,
},
};
use masking::{ExposeInterface, PeekInterface, Secret};
use crate::{
types::{PaymentsCancelResponseRouterData, RefundsResponseRouterData, ResponseRouterData},
utils::{
self, AddressDetailsData, CardData, PaymentsAuthorizeRequestData,
PaymentsCompleteAuthorizeRequestData, RefundsRequestData, RouterData as OtherRouterData,
},
};
fn try_from(
item: &DeutschebankRouterData<&PaymentsCompleteAuthorizeRouterData>,
) -> Result<Self, Self::Error> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/deutschebank/transformers.rs | crate: hyperswitch_connectors | connector: deutschebank
use common_enums::{enums, PaymentMethod};
use hyperswitch_domain_models::{
payment_method_data::{BankDebitData, PaymentMethodData},
router_data::{AccessToken, ConnectorAuthType, ErrorResponse, RouterData},
router_flow_types::{
payments::{Authorize, Capture, CompleteAuthorize, PSync},
refunds::{Execute, RSync},
},
router_request_types::{
CompleteAuthorizeData, PaymentsAuthorizeData, PaymentsCaptureData, PaymentsSyncData,
ResponseId,
},
router_response_types::{
MandateReference, PaymentsResponseData, RedirectForm, RefundsResponseData,
},
types::{
PaymentsAuthorizeRouterData, PaymentsCancelRouterData, PaymentsCaptureRouterData,
PaymentsCompleteAuthorizeRouterData, RefundsRouterData,
},
};
use hyperswitch_interfaces::{consts, errors};
use crate::{
types::{PaymentsCancelResponseRouterData, RefundsResponseRouterData, ResponseRouterData},
utils::{
self, AddressDetailsData, CardData, PaymentsAuthorizeRequestData,
PaymentsCompleteAuthorizeRequestData, RefundsRequestData, RouterData as OtherRouterData,
},
};
fn try_from(
item: ResponseRouterData<
Authorize,
DeutschebankThreeDSInitializeResponse,
PaymentsAuthorizeData,
PaymentsResponseData,
>,
) -> Result<Self, Self::Error> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/deutschebank/transformers.rs | crate: hyperswitch_connectors | connector: deutschebank
use hyperswitch_domain_models::{
payment_method_data::{BankDebitData, PaymentMethodData},
router_data::{AccessToken, ConnectorAuthType, ErrorResponse, RouterData},
router_flow_types::{
payments::{Authorize, Capture, CompleteAuthorize, PSync},
refunds::{Execute, RSync},
},
router_request_types::{
CompleteAuthorizeData, PaymentsAuthorizeData, PaymentsCaptureData, PaymentsSyncData,
ResponseId,
},
router_response_types::{
MandateReference, PaymentsResponseData, RedirectForm, RefundsResponseData,
},
types::{
PaymentsAuthorizeRouterData, PaymentsCancelRouterData, PaymentsCaptureRouterData,
PaymentsCompleteAuthorizeRouterData, RefundsRouterData,
},
};
use masking::{ExposeInterface, PeekInterface, Secret};
use crate::{
types::{PaymentsCancelResponseRouterData, RefundsResponseRouterData, ResponseRouterData},
utils::{
self, AddressDetailsData, CardData, PaymentsAuthorizeRequestData,
PaymentsCompleteAuthorizeRequestData, RefundsRequestData, RouterData as OtherRouterData,
},
};
fn try_from(
item: &DeutschebankRouterData<&PaymentsAuthorizeRouterData>,
) -> Result<Self, Self::Error> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/razorpay/transformers.rs | crate: hyperswitch_connectors | connector: razorpay
use common_enums::enums;
use hyperswitch_domain_models::{
payment_method_data::{PaymentMethodData, UpiCollectData, UpiData},
router_data::{ConnectorAuthType, RouterData},
router_flow_types::refunds::{Execute, RSync},
router_request_types::ResponseId,
router_response_types::{PaymentsResponseData, RefundsResponseData},
types,
};
use crate::{
types::{RefundsResponseRouterData, ResponseRouterData},
utils::generate_12_digit_number,
};
fn try_from(
item: ResponseRouterData<F, RazorpayPaymentsResponse, T, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/razorpay/transformers.rs | crate: hyperswitch_connectors | connector: razorpay
use common_utils::{
pii::{self, Email},
types::FloatMajorUnit,
};
use hyperswitch_domain_models::{
payment_method_data::{PaymentMethodData, UpiCollectData, UpiData},
router_data::{ConnectorAuthType, RouterData},
router_flow_types::refunds::{Execute, RSync},
router_request_types::ResponseId,
router_response_types::{PaymentsResponseData, RefundsResponseData},
types,
};
use hyperswitch_interfaces::{
configs::Connectors,
consts::{NO_ERROR_CODE, NO_ERROR_MESSAGE},
errors,
};
use crate::{
types::{RefundsResponseRouterData, ResponseRouterData},
utils::generate_12_digit_number,
};
fn try_from(
(item, data): (
&RazorpayRouterData<&types::PaymentsAuthorizeRouterData>,
&Connectors,
),
) -> Result<Self, Self::Error> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/razorpay/transformers.rs | crate: hyperswitch_connectors | connector: razorpay
pub struct PaymentGatewayResponse {
id: String,
version: i32,
}
impl<F>
TryFrom<(
&RazorpayRouterData<&types::RefundsRouterData<F>>,
&Connectors,
)> for RazorpayRefundRequest
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
(item, data): (
&RazorpayRouterData<&types::RefundsRouterData<F>>,
&Connectors,
),
) -> Result<Self, Self::Error> {
let ref_id = generate_12_digit_number();
let auth = RazorpayAuthType::try_from(&item.router_data.connector_auth_type)?;
let merchant_data = JuspayAuthData::try_from(data)?;
let connector_transaction_id = item.router_data.request.connector_transaction_id.clone();
let connector_request_reference_id = &item.router_data.connector_request_reference_id;
let order_metadata_v2 = OrderMetadataV2 {
id: ref_id.to_string(),
fn try_from(
(item, data): (
&RazorpayRouterData<&types::RefundsRouterData<F>>,
&Connectors,
),
) -> Result<Self, Self::Error> {
{let ref_id = generate_12_digit_number();<|fim_suffix|>
<|fim_middle|>
Ok(Self {
order_metadata_v2,
second_factor,
order_reference,
txn_detail,
refund,
payment_gateway_response,
txn_card_info,
merchant_gateway_account,
})}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/razorpay/transformers.rs | crate: hyperswitch_connectors | connector: razorpay
fn from(item: PsyncStatus) -> Self {
{
PsyncStatus::Charged => Self::Charged,<|fim_suffix|>
<|fim_middle|>
PsyncStatus::Authorizing => Self::Pending,
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/razorpay/transformers.rs | crate: hyperswitch_connectors | connector: razorpay
fn from(item: TxnStatus) -> Self {
{
TxnStatus::Authorizing => Self::Pending,<|fim_suffix|>
<|fim_middle|>
TxnStatus::Charged => Self::Charged,
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/razorpay/transformers.rs | crate: hyperswitch_connectors | connector: razorpay
use hyperswitch_domain_models::{
payment_method_data::{PaymentMethodData, UpiCollectData, UpiData},
router_data::{ConnectorAuthType, 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 {
razorpay_id: api_key.to_owned(),
razorpay_secret: key1.to_owned(),
}),<|fim_suffix|>
<|fim_middle|>
_ => Err(errors::ConnectorError::FailedToObtainAuthType.into()),
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/razorpay/transformers.rs | crate: hyperswitch_connectors | connector: razorpay
fn try_from(webhook_payload: RazorpayWebhookPayload) -> Result<Self, Self::Error> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/razorpay/transformers.rs | crate: hyperswitch_connectors | connector: razorpay
use common_enums::enums;
use hyperswitch_domain_models::{
payment_method_data::{PaymentMethodData, UpiCollectData, UpiData},
router_data::{ConnectorAuthType, RouterData},
router_flow_types::refunds::{Execute, RSync},
router_request_types::ResponseId,
router_response_types::{PaymentsResponseData, RefundsResponseData},
types,
};
use crate::{
types::{RefundsResponseRouterData, ResponseRouterData},
utils::generate_12_digit_number,
};
fn try_from(
item: ResponseRouterData<F, RazorpaySyncResponse, T, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/razorpay/transformers.rs | crate: hyperswitch_connectors | connector: razorpay
fn from(item: PsyncStatus) -> Self {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/razorpay/transformers.rs | crate: hyperswitch_connectors | connector: razorpay
use common_enums::enums;
fn from(item: enums::AttemptStatus) -> Self {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/razorpay/transformers.rs | crate: hyperswitch_connectors | connector: razorpay
fn from(item: TxnStatus) -> Self {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/razorpay/transformers.rs | crate: hyperswitch_connectors | connector: razorpay
fn try_from(connector_param: &Connectors) -> Result<Self, Self::Error> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/razorpay/transformers.rs | crate: hyperswitch_connectors | connector: razorpay
use common_utils::{
pii::{self, Email},
types::FloatMajorUnit,
};
use hyperswitch_domain_models::{
payment_method_data::{PaymentMethodData, UpiCollectData, UpiData},
router_data::{ConnectorAuthType, RouterData},
router_flow_types::refunds::{Execute, RSync},
router_request_types::ResponseId,
router_response_types::{PaymentsResponseData, RefundsResponseData},
types,
};
use crate::{
types::{RefundsResponseRouterData, ResponseRouterData},
utils::generate_12_digit_number,
};
fn try_from(
_item: &RazorpayRouterData<&types::PaymentsAuthorizeRouterData>,
) -> Result<Self, Self::Error> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/razorpay/transformers.rs | crate: hyperswitch_connectors | connector: razorpay
use common_enums::enums;
use common_utils::{
pii::{self, Email},
types::FloatMajorUnit,
};
use hyperswitch_domain_models::{
payment_method_data::{PaymentMethodData, UpiCollectData, UpiData},
router_data::{ConnectorAuthType, RouterData},
router_flow_types::refunds::{Execute, RSync},
router_request_types::ResponseId,
router_response_types::{PaymentsResponseData, RefundsResponseData},
types,
};
use crate::{
types::{RefundsResponseRouterData, ResponseRouterData},
utils::generate_12_digit_number,
};
fn try_from(
payment_data: (
&RazorpayRouterData<&types::PaymentsAuthorizeRouterData>,
UpiCollectData,
),
) -> Result<Self, Self::Error> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/razorpay/transformers.rs | crate: hyperswitch_connectors | connector: razorpay
use common_utils::{
pii::{self, Email},
types::FloatMajorUnit,
};
use hyperswitch_domain_models::{
payment_method_data::{PaymentMethodData, UpiCollectData, UpiData},
router_data::{ConnectorAuthType, RouterData},
router_flow_types::refunds::{Execute, RSync},
router_request_types::ResponseId,
router_response_types::{PaymentsResponseData, RefundsResponseData},
types,
};
use crate::{
types::{RefundsResponseRouterData, ResponseRouterData},
utils::generate_12_digit_number,
};
fn try_from(
(_item, data): (
&RazorpayRouterData<&types::PaymentsAuthorizeRouterData>,
&Connectors,
),
) -> Result<Self, Self::Error> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/razorpay/transformers.rs | crate: hyperswitch_connectors | connector: razorpay
use common_utils::{
pii::{self, Email},
types::FloatMajorUnit,
};
use hyperswitch_domain_models::{
payment_method_data::{PaymentMethodData, UpiCollectData, UpiData},
router_data::{ConnectorAuthType, RouterData},
router_flow_types::refunds::{Execute, RSync},
router_request_types::ResponseId,
router_response_types::{PaymentsResponseData, RefundsResponseData},
types,
};
use crate::{
types::{RefundsResponseRouterData, ResponseRouterData},
utils::generate_12_digit_number,
};
fn try_from(
item: &RazorpayRouterData<&types::PaymentsAuthorizeRouterData>,
) -> Result<Self, Self::Error> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/razorpay/transformers.rs | crate: hyperswitch_connectors | connector: razorpay
use common_enums::enums;
use common_utils::{
pii::{self, Email},
types::FloatMajorUnit,
};
use hyperswitch_domain_models::{
payment_method_data::{PaymentMethodData, UpiCollectData, UpiData},
router_data::{ConnectorAuthType, RouterData},
router_flow_types::refunds::{Execute, RSync},
router_request_types::ResponseId,
router_response_types::{PaymentsResponseData, RefundsResponseData},
types,
};
use hyperswitch_interfaces::{
configs::Connectors,
consts::{NO_ERROR_CODE, NO_ERROR_MESSAGE},
errors,
};
use masking::Secret;
use crate::{
types::{RefundsResponseRouterData, ResponseRouterData},
utils::generate_12_digit_number,
};
fn try_from(
(item, data): (
&RazorpayRouterData<&types::RefundsRouterData<F>>,
&Connectors,
),
) -> Result<Self, Self::Error> {
let ref_id = generate_12_digit_number();
let auth = RazorpayAuthType::try_from(&item.router_data.connector_auth_type)?;
let merchant_data = JuspayAuthData::try_from(data)?;
let connector_transaction_id = item.router_data.request.connector_transaction_id.clone();
let connector_request_reference_id = &item.router_data.connector_request_reference_id;
let order_metadata_v2 = OrderMetadataV2 {
id: ref_id.to_string(),
order_reference_id: ref_id.to_string(),
date_created: Some(common_utils::date_time::now()),
last_updated: Some(common_utils::date_time::now()),
..Default::default()
};
let second_factor = SecondFactor {
txn_id: connector_request_reference_id.clone(),
id: ref_id.to_string(),
status: SecondFactorStatus::Pending,
version: VERSION,
sf_type: SecondFactorType::Vbv,
date_created: Some(common_utils::date_time::now()),
last_updated: Some(common_utils::date_time::now()),
epg_txn_id: Some(connector_transaction_id.clone()),
..Default::default()
};
let order_reference = OrderReference {
id: ref_id.to_string(),
amount: item.amount,
currency: item.router_data.request.currency.to_string(),
status: OrderStatus::Success,
merchant_id: merchant_data.merchant_id.clone(),
order_id: connector_request_reference_id.clone(),
version: VERSION,
order_type: OrderType::OrderPayment,
order_uuid: uuid::Uuid::new_v4().to_string(),
date_created: Some(common_utils::date_time::now()),
last_modified: Some(common_utils::date_time::now()),
..Default::default()
};
let txn_mode: TxnMode = match item.router_data.test_mode {
Some(true) | None => TxnMode::Test,
Some(false) => TxnMode::Prod,
};
let txn_detail = TxnDetail {
order_id: connector_request_reference_id.clone(),
express_checkout: false,
txn_mode,
merchant_id: merchant_data.merchant_id.clone(),
status: TxnStatus::from(item.router_data.status),
net_amount: item.amount,
txn_id: connector_request_reference_id.clone(),
txn_amount: item.amount,
emi_tenure: 0,
txn_uuid: uuid::Uuid::new_v4().to_string(),
id: ref_id.to_string(),
merchant_gateway_account_id: 11476,
txn_type: TxnType::AuthAndSettle,
redirect: true,
version: VERSION,
add_to_locker: false,
currency: item.router_data.request.currency.to_string(),
is_emi: false,
gateway: Gateway::Razorpay,
date_created: Some(common_utils::date_time::now()),
last_modified: Some(common_utils::date_time::now()),
..Default::default()
};
let refund = Refund {
id: ref_id,
status: RefundStatus::Pending,
amount: item.amount,
merchant_id: Some(merchant_data.merchant_id.clone()),
gateway: Gateway::Razorpay,
txn_detail_id: ref_id,
unique_request_id: item.router_data.request.refund_id.clone(),
processed: false,
date_created: Some(common_utils::date_time::now()),
};
let payment_gateway_response = PaymentGatewayResponse {
id: ref_id.to_string(),
version: VERSION,
};
let payment_source: Secret<String, pii::UpiVpaMaskingStrategy> =
Secret::new("".to_string());
let pm = enums::PaymentMethod::Upi;
let txn_card_info = TxnCardInfo {
txn_detail_id: ref_id.to_string(),
txn_id: item.router_data.connector_request_reference_id.clone(),
payment_method_type: pm.to_string().to_uppercase(),
id: ref_id.to_string(),
payment_method: pm.to_string().to_uppercase(),
payment_source,
date_created: Some(common_utils::date_time::now()),
..Default::default()
};
let account_details = AccountDetails {
razorpay_id: auth.razorpay_id.clone(),
razorpay_secret: auth.razorpay_secret,
};
let merchant_gateway_account = MerchantGatewayAccount {
gateway: Gateway::Razorpay,
disabled: false,
id: ref_id,
account_details: serde_json::to_string(&account_details)
.change_context(errors::ConnectorError::ParsingFailed)?,
test_mode: false,
merchant_id: merchant_data.merchant_id,
..Default::default()
};
Ok(Self {
order_metadata_v2,
second_factor,
order_reference,
txn_detail,
refund,
payment_gateway_response,
txn_card_info,
merchant_gateway_account,
})
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/razorpay/transformers.rs | crate: hyperswitch_connectors | connector: razorpay
use common_utils::{
pii::{self, Email},
types::FloatMajorUnit,
};
use hyperswitch_domain_models::{
payment_method_data::{PaymentMethodData, UpiCollectData, UpiData},
router_data::{ConnectorAuthType, RouterData},
router_flow_types::refunds::{Execute, RSync},
router_request_types::ResponseId,
router_response_types::{PaymentsResponseData, RefundsResponseData},
types,
};
use hyperswitch_interfaces::{
configs::Connectors,
consts::{NO_ERROR_CODE, NO_ERROR_MESSAGE},
errors,
};
use crate::{
types::{RefundsResponseRouterData, ResponseRouterData},
utils::generate_12_digit_number,
};
fn try_from(
(item, data): (
RazorpayRouterData<&types::PaymentsSyncRouterData>,
&Connectors,
),
) -> Result<Self, Self::Error> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/nexinets/transformers.rs | crate: hyperswitch_connectors | connector: nexinets
use error_stack::ResultExt;
use hyperswitch_domain_models::{
payment_method_data::{
ApplePayWalletData, BankRedirectData, Card, PaymentMethodData, WalletData,
},
router_data::{ConnectorAuthType, RouterData},
router_flow_types::{Execute, RSync},
router_request_types::ResponseId,
router_response_types::{
MandateReference, PaymentsResponseData, RedirectForm, RefundsResponseData,
},
types::{
PaymentsAuthorizeRouterData, PaymentsCancelRouterData, PaymentsCaptureRouterData,
RefundsRouterData,
},
};
use crate::{
types::{RefundsResponseRouterData, ResponseRouterData},
utils::{
self, CardData, PaymentsAuthorizeRequestData, PaymentsCancelRequestData, WalletData as _,
},
};
fn get_wallet_details(
wallet: &WalletData,
) -> Result<
(Option<NexinetsPaymentDetails>, NexinetsProduct),
error_stack::Report<errors::ConnectorError>,
> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/nexinets/transformers.rs | crate: hyperswitch_connectors | connector: nexinets
use common_utils::{consts, errors::CustomResult, request::Method};
use hyperswitch_domain_models::{
payment_method_data::{
ApplePayWalletData, BankRedirectData, Card, PaymentMethodData, WalletData,
},
router_data::{ConnectorAuthType, RouterData},
router_flow_types::{Execute, RSync},
router_request_types::ResponseId,
router_response_types::{
MandateReference, PaymentsResponseData, RedirectForm, RefundsResponseData,
},
types::{
PaymentsAuthorizeRouterData, PaymentsCancelRouterData, PaymentsCaptureRouterData,
RefundsRouterData,
},
};
use masking::{ExposeInterface, PeekInterface, Secret};
use crate::{
types::{RefundsResponseRouterData, ResponseRouterData},
utils::{
self, CardData, PaymentsAuthorizeRequestData, PaymentsCancelRequestData, WalletData as _,
},
};
fn get_card_data(
item: &PaymentsAuthorizeRouterData,
card: &Card,
) -> Result<NexinetsPaymentDetails, errors::ConnectorError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/nexinets/transformers.rs | crate: hyperswitch_connectors | connector: nexinets
use common_utils::{consts, errors::CustomResult, request::Method};
use error_stack::ResultExt;
use hyperswitch_domain_models::{
payment_method_data::{
ApplePayWalletData, BankRedirectData, Card, PaymentMethodData, WalletData,
},
router_data::{ConnectorAuthType, RouterData},
router_flow_types::{Execute, RSync},
router_request_types::ResponseId,
router_response_types::{
MandateReference, PaymentsResponseData, RedirectForm, RefundsResponseData,
},
types::{
PaymentsAuthorizeRouterData, PaymentsCancelRouterData, PaymentsCaptureRouterData,
RefundsRouterData,
},
};
use crate::{
types::{RefundsResponseRouterData, ResponseRouterData},
utils::{
self, CardData, PaymentsAuthorizeRequestData, PaymentsCancelRequestData, WalletData as _,
},
};
fn get_payment_details_and_product(
item: &PaymentsAuthorizeRouterData,
) -> Result<
(Option<NexinetsPaymentDetails>, NexinetsProduct),
error_stack::Report<errors::ConnectorError>,
> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/nexinets/transformers.rs | crate: hyperswitch_connectors | connector: nexinets
use hyperswitch_domain_models::{
payment_method_data::{
ApplePayWalletData, BankRedirectData, Card, PaymentMethodData, WalletData,
},
router_data::{ConnectorAuthType, RouterData},
router_flow_types::{Execute, RSync},
router_request_types::ResponseId,
router_response_types::{
MandateReference, PaymentsResponseData, RedirectForm, RefundsResponseData,
},
types::{
PaymentsAuthorizeRouterData, PaymentsCancelRouterData, PaymentsCaptureRouterData,
RefundsRouterData,
},
};
use crate::{
types::{RefundsResponseRouterData, ResponseRouterData},
utils::{
self, CardData, PaymentsAuthorizeRequestData, PaymentsCancelRequestData, WalletData as _,
},
};
fn try_from(
item: ResponseRouterData<F, NexinetsPaymentResponse, T, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/nexinets/transformers.rs | crate: hyperswitch_connectors | connector: nexinets
use common_utils::{consts, errors::CustomResult, request::Method};
use hyperswitch_domain_models::{
payment_method_data::{
ApplePayWalletData, BankRedirectData, Card, PaymentMethodData, WalletData,
},
router_data::{ConnectorAuthType, RouterData},
router_flow_types::{Execute, RSync},
router_request_types::ResponseId,
router_response_types::{
MandateReference, PaymentsResponseData, RedirectForm, RefundsResponseData,
},
types::{
PaymentsAuthorizeRouterData, PaymentsCancelRouterData, PaymentsCaptureRouterData,
RefundsRouterData,
},
};
use crate::{
types::{RefundsResponseRouterData, ResponseRouterData},
utils::{
self, CardData, PaymentsAuthorizeRequestData, PaymentsCancelRequestData, WalletData as _,
},
};
fn try_from(
item: ResponseRouterData<F, NexinetsPreAuthOrDebitResponse, T, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/nexinets/transformers.rs | crate: hyperswitch_connectors | connector: nexinets
use common_enums::{enums, AttemptStatus};
use crate::{
types::{RefundsResponseRouterData, ResponseRouterData},
utils::{
self, CardData, PaymentsAuthorizeRequestData, PaymentsCancelRequestData, WalletData as _,
},
};
fn get_status(status: NexinetsPaymentStatus, method: NexinetsTransactionType) -> AttemptStatus {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/nexinets/transformers.rs | crate: hyperswitch_connectors | connector: nexinets
use error_stack::ResultExt;
pub fn get_order_id(
meta: &NexinetsPaymentsMetadata,
) -> Result<String, error_stack::Report<errors::ConnectorError>> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/nexinets/transformers.rs | crate: hyperswitch_connectors | connector: nexinets
use common_enums::{enums, AttemptStatus};
use crate::{
types::{RefundsResponseRouterData, ResponseRouterData},
utils::{
self, CardData, PaymentsAuthorizeRequestData, PaymentsCancelRequestData, WalletData as _,
},
};
fn try_from(bank: &enums::BankNames) -> Result<Self, Self::Error> {
{
enums::BankNames::AbnAmro => Ok(Self::AbnAmro),<|fim_suffix|>
<|fim_middle|>
_ => Err(errors::ConnectorError::FlowNotSupported {
flow: bank.to_string(),
connector: "Nexinets".to_string(),
}
.into()),
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/nexinets/transformers.rs | crate: hyperswitch_connectors | connector: nexinets
use error_stack::ResultExt;
pub fn get_transaction_id(
meta: &NexinetsPaymentsMetadata,
) -> Result<String, error_stack::Report<errors::ConnectorError>> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/nexinets/transformers.rs | crate: hyperswitch_connectors | connector: nexinets
use error_stack::ResultExt;
pub fn get_order_id(
meta: &NexinetsPaymentsMetadata,
) -> Result<String, error_stack::Report<errors::ConnectorError>> {
let order_id = meta.order_id.clone().ok_or(
errors::ConnectorError::MissingConnectorRelatedTransactionID {
id: "order_id".to_string(),
},
)?;
Ok(order_id)
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/nexinets/transformers.rs | crate: hyperswitch_connectors | connector: nexinets
use hyperswitch_domain_models::{
payment_method_data::{
ApplePayWalletData, BankRedirectData, Card, PaymentMethodData, WalletData,
},
router_data::{ConnectorAuthType, RouterData},
router_flow_types::{Execute, RSync},
router_request_types::ResponseId,
router_response_types::{
MandateReference, PaymentsResponseData, RedirectForm, RefundsResponseData,
},
types::{
PaymentsAuthorizeRouterData, PaymentsCancelRouterData, PaymentsCaptureRouterData,
RefundsRouterData,
},
};
fn get_card_details(req_card: &Card) -> Result<CardDetails, errors::ConnectorError> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/nexinets/transformers.rs | crate: hyperswitch_connectors | connector: nexinets
use common_utils::{consts, errors::CustomResult, request::Method};
use hyperswitch_domain_models::{
payment_method_data::{
ApplePayWalletData, BankRedirectData, Card, PaymentMethodData, WalletData,
},
router_data::{ConnectorAuthType, RouterData},
router_flow_types::{Execute, RSync},
router_request_types::ResponseId,
router_response_types::{
MandateReference, PaymentsResponseData, RedirectForm, RefundsResponseData,
},
types::{
PaymentsAuthorizeRouterData, PaymentsCancelRouterData, PaymentsCaptureRouterData,
RefundsRouterData,
},
};
use crate::{
types::{RefundsResponseRouterData, ResponseRouterData},
utils::{
self, CardData, PaymentsAuthorizeRequestData, PaymentsCancelRequestData, WalletData as _,
},
};
fn get_applepay_details(
wallet_data: &WalletData,
applepay_data: &ApplePayWalletData,
) -> CustomResult<ApplePayDetails, errors::ConnectorError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/nexinets/transformers.rs | crate: hyperswitch_connectors | connector: nexinets
use common_enums::{enums, AttemptStatus};
use hyperswitch_domain_models::{
payment_method_data::{
ApplePayWalletData, BankRedirectData, Card, PaymentMethodData, WalletData,
},
router_data::{ConnectorAuthType, RouterData},
router_flow_types::{Execute, RSync},
router_request_types::ResponseId,
router_response_types::{
MandateReference, PaymentsResponseData, RedirectForm, RefundsResponseData,
},
types::{
PaymentsAuthorizeRouterData, PaymentsCancelRouterData, PaymentsCaptureRouterData,
RefundsRouterData,
},
};
use crate::{
types::{RefundsResponseRouterData, ResponseRouterData},
utils::{
self, CardData, PaymentsAuthorizeRequestData, PaymentsCancelRequestData, WalletData as _,
},
};
fn try_from(
item: RefundsResponseRouterData<RSync, NexinetsRefundResponse>,
) -> Result<Self, Self::Error> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/nexinets/transformers.rs | crate: hyperswitch_connectors | connector: nexinets
use common_enums::{enums, AttemptStatus};
use hyperswitch_domain_models::{
payment_method_data::{
ApplePayWalletData, BankRedirectData, Card, PaymentMethodData, WalletData,
},
router_data::{ConnectorAuthType, RouterData},
router_flow_types::{Execute, RSync},
router_request_types::ResponseId,
router_response_types::{
MandateReference, PaymentsResponseData, RedirectForm, RefundsResponseData,
},
types::{
PaymentsAuthorizeRouterData, PaymentsCancelRouterData, PaymentsCaptureRouterData,
RefundsRouterData,
},
};
use crate::{
types::{RefundsResponseRouterData, ResponseRouterData},
utils::{
self, CardData, PaymentsAuthorizeRequestData, PaymentsCancelRequestData, WalletData as _,
},
};
fn try_from(
item: RefundsResponseRouterData<Execute, NexinetsRefundResponse>,
) -> Result<Self, Self::Error> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/nexinets/transformers.rs | crate: hyperswitch_connectors | connector: nexinets
use hyperswitch_domain_models::{
payment_method_data::{
ApplePayWalletData, BankRedirectData, Card, PaymentMethodData, WalletData,
},
router_data::{ConnectorAuthType, RouterData},
router_flow_types::{Execute, RSync},
router_request_types::ResponseId,
router_response_types::{
MandateReference, PaymentsResponseData, RedirectForm, RefundsResponseData,
},
types::{
PaymentsAuthorizeRouterData, PaymentsCancelRouterData, PaymentsCaptureRouterData,
RefundsRouterData,
},
};
fn try_from(item: &PaymentsCaptureRouterData) -> Result<Self, Self::Error> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/nuvei/transformers.rs | crate: hyperswitch_connectors | connector: nuvei
use common_enums::enums;
use hyperswitch_domain_models::{
mandates::{MandateData, MandateDataType},
payment_method_data::{
self, ApplePayWalletData, BankRedirectData, GooglePayWalletData, PayLaterData,
PaymentMethodData, WalletData,
},
router_data::{ConnectorAuthType, ErrorResponse, RouterData},
router_flow_types::{
refunds::{Execute, RSync},
Authorize, Capture, CompleteAuthorize, PSync, Void,
},
router_request_types::{
BrowserInformation, PaymentsAuthorizeData, PaymentsPreProcessingData, ResponseId,
},
router_response_types::{
MandateReference, PaymentsResponseData, RedirectForm, RefundsResponseData,
},
types,
};
use crate::{
types::{
PaymentsPreprocessingResponseRouterData, RefundsResponseRouterData, ResponseRouterData,
},
utils::{
self, AddressDetailsData, BrowserInformationData, ForeignTryFrom,
PaymentsAuthorizeRequestData, PaymentsCancelRequestData, PaymentsPreProcessingRequestData,
RouterData as _,
},
};
fn try_from(
item: ResponseRouterData<F, NuveiPaymentsResponse, T, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/nuvei/transformers.rs | crate: hyperswitch_connectors | connector: nuvei
use hyperswitch_domain_models::{
mandates::{MandateData, MandateDataType},
payment_method_data::{
self, ApplePayWalletData, BankRedirectData, GooglePayWalletData, PayLaterData,
PaymentMethodData, WalletData,
},
router_data::{ConnectorAuthType, ErrorResponse, RouterData},
router_flow_types::{
refunds::{Execute, RSync},
Authorize, Capture, CompleteAuthorize, PSync, Void,
},
router_request_types::{
BrowserInformation, PaymentsAuthorizeData, PaymentsPreProcessingData, ResponseId,
},
router_response_types::{
MandateReference, PaymentsResponseData, RedirectForm, RefundsResponseData,
},
types,
};
use crate::{
types::{
PaymentsPreprocessingResponseRouterData, RefundsResponseRouterData, ResponseRouterData,
},
utils::{
self, AddressDetailsData, BrowserInformationData, ForeignTryFrom,
PaymentsAuthorizeRequestData, PaymentsCancelRequestData, PaymentsPreProcessingRequestData,
RouterData as _,
},
};
fn build_error_response<T>(
response: &NuveiPaymentsResponse,
http_code: u16,
) -> Option<Result<T, ErrorResponse>> {
match response.status {
NuveiPaymentStatus::Error => Some(
get_error_response(response.err_code, &response.reason, http_code).map_err(|err| *err),
),
_ => {
let err = Some(
get_error_response(response.gw_error_code, &response.gw_error_reason, http_code)
.map_err(|err| *err),
);
match response.transaction_status {
Some(NuveiTransactionStatus::Error) | Some(NuveiTransactionStatus::Declined) => err,
_ => match response
.gw_error_reason
.as_ref()
.map(|r| r.eq("Missing argument"))
{
Some(true) => err,
_ => None,
},
}
}
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/nuvei/transformers.rs | crate: hyperswitch_connectors | connector: nuvei
use common_enums::enums;
use hyperswitch_domain_models::{
mandates::{MandateData, MandateDataType},
payment_method_data::{
self, ApplePayWalletData, BankRedirectData, GooglePayWalletData, PayLaterData,
PaymentMethodData, WalletData,
},
router_data::{ConnectorAuthType, ErrorResponse, RouterData},
router_flow_types::{
refunds::{Execute, RSync},
Authorize, Capture, CompleteAuthorize, PSync, Void,
},
router_request_types::{
BrowserInformation, PaymentsAuthorizeData, PaymentsPreProcessingData, ResponseId,
},
router_response_types::{
MandateReference, PaymentsResponseData, RedirectForm, RefundsResponseData,
},
types,
};
use crate::{
types::{
PaymentsPreprocessingResponseRouterData, RefundsResponseRouterData, ResponseRouterData,
},
utils::{
self, AddressDetailsData, BrowserInformationData, ForeignTryFrom,
PaymentsAuthorizeRequestData, PaymentsCancelRequestData, PaymentsPreProcessingRequestData,
RouterData as _,
},
};
fn get_payment_status(response: &NuveiPaymentsResponse) -> enums::AttemptStatus {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/nuvei/transformers.rs | crate: hyperswitch_connectors | connector: nuvei
use common_utils::{
crypto::{self, GenerateDigest},
date_time,
ext_traits::{Encode, OptionExt},
fp_utils,
pii::{Email, IpAddress},
request::Method,
};
use masking::{ExposeInterface, PeekInterface, Secret};
fn try_from(request: NuveiPaymentRequestData) -> Result<Self, Self::Error> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/nuvei/transformers.rs | crate: hyperswitch_connectors | connector: nuvei
use hyperswitch_domain_models::{
mandates::{MandateData, MandateDataType},
payment_method_data::{
self, ApplePayWalletData, BankRedirectData, GooglePayWalletData, PayLaterData,
PaymentMethodData, WalletData,
},
router_data::{ConnectorAuthType, ErrorResponse, RouterData},
router_flow_types::{
refunds::{Execute, RSync},
Authorize, Capture, CompleteAuthorize, PSync, Void,
},
router_request_types::{
BrowserInformation, PaymentsAuthorizeData, PaymentsPreProcessingData, ResponseId,
},
router_response_types::{
MandateReference, PaymentsResponseData, RedirectForm, RefundsResponseData,
},
types,
};
use masking::{ExposeInterface, PeekInterface, Secret};
use crate::{
types::{
PaymentsPreprocessingResponseRouterData, RefundsResponseRouterData, ResponseRouterData,
},
utils::{
self, AddressDetailsData, BrowserInformationData, ForeignTryFrom,
PaymentsAuthorizeRequestData, PaymentsCancelRequestData, PaymentsPreProcessingRequestData,
RouterData as _,
},
};
fn try_from(
data: (&types::PaymentsCompleteAuthorizeRouterData, Secret<String>),
) -> Result<Self, Self::Error> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/nuvei/transformers.rs | crate: hyperswitch_connectors | connector: nuvei
use error_stack::ResultExt;
use hyperswitch_domain_models::{
mandates::{MandateData, MandateDataType},
payment_method_data::{
self, ApplePayWalletData, BankRedirectData, GooglePayWalletData, PayLaterData,
PaymentMethodData, WalletData,
},
router_data::{ConnectorAuthType, ErrorResponse, RouterData},
router_flow_types::{
refunds::{Execute, RSync},
Authorize, Capture, CompleteAuthorize, PSync, Void,
},
router_request_types::{
BrowserInformation, PaymentsAuthorizeData, PaymentsPreProcessingData, ResponseId,
},
router_response_types::{
MandateReference, PaymentsResponseData, RedirectForm, RefundsResponseData,
},
types,
};
use crate::{
types::{
PaymentsPreprocessingResponseRouterData, RefundsResponseRouterData, ResponseRouterData,
},
utils::{
self, AddressDetailsData, BrowserInformationData, ForeignTryFrom,
PaymentsAuthorizeRequestData, PaymentsCancelRequestData, PaymentsPreProcessingRequestData,
RouterData as _,
},
};
fn get_pay_later_info<F, Req>(
payment_method_type: AlternativePaymentMethodType,
item: &RouterData<F, Req, PaymentsResponseData>,
) -> Result<NuveiPaymentsRequest, error_stack::Report<errors::ConnectorError>>
where
Req: NuveiAuthorizePreprocessingCommon,
{
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/nuvei/transformers.rs | crate: hyperswitch_connectors | connector: nuvei
use hyperswitch_domain_models::{
mandates::{MandateData, MandateDataType},
payment_method_data::{
self, ApplePayWalletData, BankRedirectData, GooglePayWalletData, PayLaterData,
PaymentMethodData, WalletData,
},
router_data::{ConnectorAuthType, ErrorResponse, RouterData},
router_flow_types::{
refunds::{Execute, RSync},
Authorize, Capture, CompleteAuthorize, PSync, Void,
},
router_request_types::{
BrowserInformation, PaymentsAuthorizeData, PaymentsPreProcessingData, ResponseId,
},
router_response_types::{
MandateReference, PaymentsResponseData, RedirectForm, RefundsResponseData,
},
types,
};
use crate::{
types::{
PaymentsPreprocessingResponseRouterData, RefundsResponseRouterData, ResponseRouterData,
},
utils::{
self, AddressDetailsData, BrowserInformationData, ForeignTryFrom,
PaymentsAuthorizeRequestData, PaymentsCancelRequestData, PaymentsPreProcessingRequestData,
RouterData as _,
},
};
fn foreign_try_from(
data: (
AlternativePaymentMethodType,
Option<BankRedirectData>,
&RouterData<F, Req, PaymentsResponseData>,
),
) -> Result<Self, Self::Error> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/nuvei/transformers.rs | crate: hyperswitch_connectors | connector: nuvei
use crate::{
types::{
PaymentsPreprocessingResponseRouterData, RefundsResponseRouterData, ResponseRouterData,
},
utils::{
self, AddressDetailsData, BrowserInformationData, ForeignTryFrom,
PaymentsAuthorizeRequestData, PaymentsCancelRequestData, PaymentsPreProcessingRequestData,
RouterData as _,
},
};
fn from(status: NuveiWebhookStatus) -> Self {
{
NuveiWebhookStatus::Approved => Self::Approved,<|fim_suffix|>
<|fim_middle|>
_ => Self::Processing,
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/nuvei/transformers.rs | crate: hyperswitch_connectors | connector: nuvei | op: refund
type Error = error_stack::Report<errors::ConnectorError>;
fn foreign_try_from(browser_info: &Option<BrowserInformation>) -> Result<Self, Self::Error> {
let device_details = match browser_info {
Some(browser_info) => Some(DeviceDetails {
ip_address: browser_info.get_ip_address()?,
}),
None => None,
};
Ok(device_details)
}
}
fn get_refund_response(
response: NuveiPaymentsResponse,
http_code: u16,
txn_id: String,
) -> Result<RefundsResponseData, Box<ErrorResponse>> {
let refund_status = response
.transaction_status
.clone()
.map(enums::RefundStatus::from)
.unwrap_or(enums::RefundStatus::Failure);
match response.status {
NuveiPaymentStatus::Error => {
get_error_response(response.err_code, &response.reason, http_code)
fn get_refund_response(
response: NuveiPaymentsResponse,
http_code: u16,
txn_id: String,
) -> Result<RefundsResponseData, Box<ErrorResponse>> {
{
Some(NuveiTransactionStatus::Error) => {
get_error_response(response.gw_error_code, &response.gw_error_reason, http_code)
}<|fim_suffix|>
<|fim_middle|>
_ => Ok(RefundsResponseData {
connector_refund_id: txn_id,
refund_status,
}),
}
} | ast_fragments |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.