text stringlengths 70 351k | source stringclasses 4
values |
|---|---|
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/nmi/transformers.rs | crate: router
use common_utils::{errors::CustomResult, ext_traits::XmlExt, pii::Email, types::FloatMajorUnit};
use crate::{
connector::utils::{
self, AddressDetailsData, PaymentsAuthorizeRequestData,
PaymentsCompleteAuthorizeRequestData, RouterData,
},
core::errors,
services,
types::{self, api, domain, storage::enums, transformers::ForeignFrom, ConnectorAuthType},
};
type Error = Report<errors::ConnectorError>;
fn try_from(
item: types::ResponseRouterData<
api::SetupMandate,
StandardResponse,
T,
types::PaymentsResponseData,
>,
) -> Result<Self, Self::Error> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/nmi/transformers.rs | crate: router
use common_utils::{errors::CustomResult, ext_traits::XmlExt, pii::Email, types::FloatMajorUnit};
use crate::{
connector::utils::{
self, AddressDetailsData, PaymentsAuthorizeRequestData,
PaymentsCompleteAuthorizeRequestData, RouterData,
},
core::errors,
services,
types::{self, api, domain, storage::enums, transformers::ForeignFrom, ConnectorAuthType},
};
type Error = Report<errors::ConnectorError>;
fn try_from(
item: types::ResponseRouterData<
api::Capture,
StandardResponse,
types::PaymentsCaptureData,
types::PaymentsResponseData,
>,
) -> Result<Self, Self::Error> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
// file: hyperswitch/crates/router/src/connector/nmi/transformers.rs | crate: router
use common_utils::{errors::CustomResult, ext_traits::XmlExt, pii::Email, types::FloatMajorUnit};
use masking::{ExposeInterface, PeekInterface, Secret};
use crate::{
connector::utils::{
self, AddressDetailsData, PaymentsAuthorizeRequestData,
PaymentsCompleteAuthorizeRequestData, RouterData,
},
core::errors,
services,
types::{self, api, domain, storage::enums, transformers::ForeignFrom, ConnectorAuthType},
};
type Error = Report<errors::ConnectorError>;
fn try_from(
val: (&domain::payments::Card, &types::PaymentsAuthorizeData),
) -> Result<Self, Self::Error> {
let (card_data, item) = val;
let auth_data = &item.get_authentication_data()?;
let ccexp = utils::CardData::get_card_expiry_month_year_2_digit_with_delimiter(
card_data,
"".to_string(),
)?;
let card_3ds_details = CardThreeDsData {
ccnumber: card_data.card_number.clone(),
ccexp,
cvv: card_data.card_cvc.clone(),
email: item.email.clone(),
cavv: Some(auth_data.cavv.clone()),
eci: auth_data.eci.clone(),
cardholder_auth: None,
three_ds_version: auth_data
.message_version
.clone()
.map(|version| version.to_string()),
directory_server_id: auth_data
.threeds_server_transaction_id
.clone()
.map(Secret::new),
};
Ok(Self::CardThreeDs(Box::new(card_3ds_details)))
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/nmi/transformers.rs | crate: router
use common_enums::CountryAlpha2;
use common_utils::{errors::CustomResult, ext_traits::XmlExt, pii::Email, types::FloatMajorUnit};
use error_stack::{report, Report, ResultExt};
use crate::{
connector::utils::{
self, AddressDetailsData, PaymentsAuthorizeRequestData,
PaymentsCompleteAuthorizeRequestData, RouterData,
},
core::errors,
services,
types::{self, api, domain, storage::enums, transformers::ForeignFrom, ConnectorAuthType},
};
type Error = Report<errors::ConnectorError>;
fn try_from(
item: (
&domain::PaymentMethodData,
Option<&types::PaymentsAuthorizeRouterData>,
),
) -> Result<Self, Self::Error> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/nmi/transformers.rs | crate: router
use common_utils::{errors::CustomResult, ext_traits::XmlExt, pii::Email, types::FloatMajorUnit};
use crate::{
connector::utils::{
self, AddressDetailsData, PaymentsAuthorizeRequestData,
PaymentsCompleteAuthorizeRequestData, RouterData,
},
core::errors,
services,
types::{self, api, domain, storage::enums, transformers::ForeignFrom, ConnectorAuthType},
};
type Error = Report<errors::ConnectorError>;
fn try_from(
item: &NmiRouterData<&types::PaymentsAuthorizeRouterData>,
) -> Result<Self, Self::Error> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/nmi/transformers.rs | crate: router
use common_utils::{errors::CustomResult, ext_traits::XmlExt, pii::Email, types::FloatMajorUnit};
use crate::{
connector::utils::{
self, AddressDetailsData, PaymentsAuthorizeRequestData,
PaymentsCompleteAuthorizeRequestData, RouterData,
},
core::errors,
services,
types::{self, api, domain, storage::enums, transformers::ForeignFrom, ConnectorAuthType},
};
type Error = Report<errors::ConnectorError>;
fn try_from(
item: types::ResponseRouterData<
api::CompleteAuthorize,
NmiCompleteResponse,
types::CompleteAuthorizeData,
types::PaymentsResponseData,
>,
) -> Result<Self, Self::Error> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/nmi/transformers.rs | crate: router
use common_utils::{errors::CustomResult, ext_traits::XmlExt, pii::Email, types::FloatMajorUnit};
use crate::{
connector::utils::{
self, AddressDetailsData, PaymentsAuthorizeRequestData,
PaymentsCompleteAuthorizeRequestData, RouterData,
},
core::errors,
services,
types::{self, api, domain, storage::enums, transformers::ForeignFrom, ConnectorAuthType},
};
type Error = Report<errors::ConnectorError>;
fn try_from(
item: &NmiRouterData<&types::PaymentsCompleteAuthorizeRouterData>,
) -> Result<Self, Self::Error> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/nmi/transformers.rs | crate: router
use common_utils::{errors::CustomResult, ext_traits::XmlExt, pii::Email, types::FloatMajorUnit};
use crate::{
connector::utils::{
self, AddressDetailsData, PaymentsAuthorizeRequestData,
PaymentsCompleteAuthorizeRequestData, RouterData,
},
core::errors,
services,
types::{self, api, domain, storage::enums, transformers::ForeignFrom, ConnectorAuthType},
};
type Error = Report<errors::ConnectorError>;
fn try_from(
item: types::ResponseRouterData<
api::PreProcessing,
NmiVaultResponse,
types::PaymentsPreProcessingData,
types::PaymentsResponseData,
>,
) -> Result<Self, Self::Error> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/nmi/transformers.rs | crate: router
fn foreign_from(status: NmiWebhookEventType) -> Self {
{
NmiWebhookEventType::SaleSuccess => Self::PaymentIntentSuccess,<|fim_suffix|>
<|fim_middle|>
NmiWebhookEventType::SaleUnknown
| NmiWebhookEventType::RefundUnknown
| NmiWebhookEventType::AuthUnknown
| NmiWebhookEventType::VoidUnknown
| NmiWebhookEventType::CaptureUnknown => Self::EventNotSupported,
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/nmi/transformers.rs | crate: router
type Error = Report<errors::ConnectorError>;
fn from(item: Response) -> Self {
{
Response::Approved => Self::Pending,<|fim_suffix|>
<|fim_middle|>
Response::Declined | Response::Error => Self::Failure,
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/nmi/transformers.rs | crate: router
type Error = Report<errors::ConnectorError>;
fn try_from(item: &NmiWebhookBody) -> Result<Self, Self::Error> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/nmi/transformers.rs | crate: router
fn foreign_from(status: NmiWebhookEventType) -> Self {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/nmi/transformers.rs | crate: router
fn from(item: NmiStatus) -> Self {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/nmi/transformers.rs | crate: router
use common_utils::{errors::CustomResult, ext_traits::XmlExt, pii::Email, types::FloatMajorUnit};
use crate::{
connector::utils::{
self, AddressDetailsData, PaymentsAuthorizeRequestData,
PaymentsCompleteAuthorizeRequestData, RouterData,
},
core::errors,
services,
types::{self, api, domain, storage::enums, transformers::ForeignFrom, ConnectorAuthType},
};
type Error = Report<errors::ConnectorError>;
fn try_from(
item: types::RefundsResponseRouterData<api::RSync, NmiRefundSyncResponse>,
) -> Result<Self, Self::Error> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/nmi/transformers.rs | crate: router
type Error = Report<errors::ConnectorError>;
fn from(item: Response) -> Self {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/nmi/transformers.rs | crate: router
use common_utils::{errors::CustomResult, ext_traits::XmlExt, pii::Email, types::FloatMajorUnit};
use crate::{
connector::utils::{
self, AddressDetailsData, PaymentsAuthorizeRequestData,
PaymentsCompleteAuthorizeRequestData, RouterData,
},
core::errors,
services,
types::{self, api, domain, storage::enums, transformers::ForeignFrom, ConnectorAuthType},
};
type Error = Report<errors::ConnectorError>;
fn try_from(
item: types::RefundsResponseRouterData<api::Capture, StandardResponse>,
) -> Result<Self, Self::Error> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
// file: hyperswitch/crates/router/src/connector/nmi/transformers.rs | crate: router
use common_utils::{errors::CustomResult, ext_traits::XmlExt, pii::Email, types::FloatMajorUnit};
use crate::{
connector::utils::{
self, AddressDetailsData, PaymentsAuthorizeRequestData,
PaymentsCompleteAuthorizeRequestData, RouterData,
},
core::errors,
services,
types::{self, api, domain, storage::enums, transformers::ForeignFrom, ConnectorAuthType},
};
type Error = Report<errors::ConnectorError>;
fn try_from(
item: types::RefundsResponseRouterData<api::Execute, StandardResponse>,
) -> Result<Self, Self::Error> {
let refund_status = enums::RefundStatus::from(item.response.response);
Ok(Self {
response: Ok(types::RefundsResponseData {
connector_refund_id: item.response.orderid,
refund_status,
}),
..item.data
})
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/nmi/transformers.rs | crate: router
use common_utils::{errors::CustomResult, ext_traits::XmlExt, pii::Email, types::FloatMajorUnit};
use crate::{
connector::utils::{
self, AddressDetailsData, PaymentsAuthorizeRequestData,
PaymentsCompleteAuthorizeRequestData, RouterData,
},
core::errors,
services,
types::{self, api, domain, storage::enums, transformers::ForeignFrom, ConnectorAuthType},
};
type Error = Report<errors::ConnectorError>;
fn try_from(item: &NmiRouterData<&types::RefundsRouterData<F>>) -> Result<Self, Self::Error> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/nmi/transformers.rs | crate: router
fn from(item: NmiStatus) -> Self {
{
NmiStatus::Abandoned => Self::AuthenticationFailed,<|fim_suffix|>
<|fim_middle|>
NmiStatus::Failed | NmiStatus::Unknown => Self::Failure,
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/nmi/transformers.rs | crate: router
use common_utils::{errors::CustomResult, ext_traits::XmlExt, pii::Email, types::FloatMajorUnit};
use crate::{
connector::utils::{
self, AddressDetailsData, PaymentsAuthorizeRequestData,
PaymentsCompleteAuthorizeRequestData, RouterData,
},
core::errors,
services,
types::{self, api, domain, storage::enums, transformers::ForeignFrom, ConnectorAuthType},
};
type Error = Report<errors::ConnectorError>;
fn try_from(bytes: Vec<u8>) -> Result<Self, Self::Error> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/nmi/transformers.rs | crate: router
use common_utils::{errors::CustomResult, ext_traits::XmlExt, pii::Email, types::FloatMajorUnit};
use crate::{
connector::utils::{
self, AddressDetailsData, PaymentsAuthorizeRequestData,
PaymentsCompleteAuthorizeRequestData, RouterData,
},
core::errors,
services,
types::{self, api, domain, storage::enums, transformers::ForeignFrom, ConnectorAuthType},
};
type Error = Report<errors::ConnectorError>;
fn try_from(
item: types::ResponseRouterData<F, SyncResponse, T, types::PaymentsResponseData>,
) -> Result<Self, Self::Error> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/nmi/transformers.rs | crate: router
fn foreign_from((response, http_code): (StandardResponse, u16)) -> Self {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/nmi/transformers.rs | crate: router
use common_utils::{errors::CustomResult, ext_traits::XmlExt, pii::Email, types::FloatMajorUnit};
use crate::{
connector::utils::{
self, AddressDetailsData, PaymentsAuthorizeRequestData,
PaymentsCompleteAuthorizeRequestData, RouterData,
},
core::errors,
services,
types::{self, api, domain, storage::enums, transformers::ForeignFrom, ConnectorAuthType},
};
type Error = Report<errors::ConnectorError>;
fn try_from(
item: &NmiRouterData<&types::PaymentsCaptureRouterData>,
) -> Result<Self, Self::Error> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/nmi/transformers.rs | crate: router
use masking::{ExposeInterface, PeekInterface, Secret};
use crate::{
connector::utils::{
self, AddressDetailsData, PaymentsAuthorizeRequestData,
PaymentsCompleteAuthorizeRequestData, RouterData,
},
core::errors,
services,
types::{self, api, domain, storage::enums, transformers::ForeignFrom, ConnectorAuthType},
};
fn from(wallet_data: &domain::ApplePayWalletData) -> Self {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/nmi/transformers.rs | crate: router
use masking::{ExposeInterface, PeekInterface, Secret};
use crate::{
connector::utils::{
self, AddressDetailsData, PaymentsAuthorizeRequestData,
PaymentsCompleteAuthorizeRequestData, RouterData,
},
core::errors,
services,
types::{self, api, domain, storage::enums, transformers::ForeignFrom, ConnectorAuthType},
};
fn from(wallet_data: &domain::GooglePayWalletData) -> Self {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/nmi/transformers.rs | crate: router
use crate::{
connector::utils::{
self, AddressDetailsData, PaymentsAuthorizeRequestData,
PaymentsCompleteAuthorizeRequestData, RouterData,
},
core::errors,
services,
types::{self, api, domain, storage::enums, transformers::ForeignFrom, ConnectorAuthType},
};
type Error = Report<errors::ConnectorError>;
fn try_from(card: &domain::payments::Card) -> Result<Self, Self::Error> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/nmi/transformers.rs | crate: router
use masking::{ExposeInterface, PeekInterface, Secret};
pub fn new(metadata: &serde_json::Value) -> Self {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/nmi/transformers.rs | crate: router
fn foreign_from((response, http_code): (NmiCompleteResponse, u16)) -> Self {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/nmi/transformers.rs | crate: router
use cards::CardNumber;
use common_utils::{errors::CustomResult, ext_traits::XmlExt, pii::Email, types::FloatMajorUnit};
use masking::{ExposeInterface, PeekInterface, Secret};
use crate::{
connector::utils::{
self, AddressDetailsData, PaymentsAuthorizeRequestData,
PaymentsCompleteAuthorizeRequestData, RouterData,
},
core::errors,
services,
types::{self, api, domain, storage::enums, transformers::ForeignFrom, ConnectorAuthType},
};
type Error = Report<errors::ConnectorError>;
fn get_card_details(
payment_method_data: Option<domain::PaymentMethodData>,
) -> CustomResult<(CardNumber, Secret<String>, Secret<String>), errors::ConnectorError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/netcetera/netcetera_types.rs | crate: router
use std::collections::HashMap;
use common_utils::{pii::Email, types::SemanticVersion};
pub fn new(
app_ip: Option<std::net::IpAddr>,
psd2_sca_exemption_type: Option<common_enums::ScaExemptionType>,
force_3ds_challenge: bool,
message_version: SemanticVersion,
) -> Self {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/netcetera/netcetera_types.rs | crate: router
fn from(sdk_type: api_models::payments::SdkType) -> Self {
{
api_models::payments::SdkType::DefaultSdk => Self::DefaultSdk,<|fim_suffix|>
<|fim_middle|>
api_models::payments::SdkType::ShellSdk => Self::ShellSdk,
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/netcetera/netcetera_types.rs | crate: router
fn from(sdk_info: api_models::payments::SdkInformation) -> Self {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/netcetera/netcetera_types.rs | crate: router
fn from(sdk_type: api_models::payments::SdkType) -> Self {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
// file: hyperswitch/crates/router/src/connector/netcetera/netcetera_types.rs | crate: router
fn from(sdk_info: api_models::payments::SdkInformation) -> Self {
Self {
sdk_app_id: Some(sdk_info.sdk_app_id),
sdk_enc_data: Some(sdk_info.sdk_enc_data),
sdk_ephem_pub_key: Some(sdk_info.sdk_ephem_pub_key),
sdk_max_timeout: Some(sdk_info.sdk_max_timeout),
sdk_reference_number: Some(sdk_info.sdk_reference_number),
sdk_trans_id: Some(sdk_info.sdk_trans_id),
sdk_server_signed_content: None,
sdk_type: sdk_info
.sdk_type
.map(SdkType::from)
.or(Some(SdkType::DefaultSdk)),
default_sdk_type: Some(DefaultSdkType {
// hardcoding this value because, it's the only value that is accepted
sdk_variant: "01".to_string(),
wrapped_ind: None,
}),
split_sdk_type: None,
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/netcetera/netcetera_types.rs | crate: router
use common_utils::{pii::Email, types::SemanticVersion};
use masking::ExposeInterface;
use crate::{connector::utils::PhoneDetailsData, errors, types::api::MessageCategory};
fn from(value: crate::types::BrowserInformation) -> Self {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/netcetera/netcetera_types.rs | crate: router
pub fn get_list_of_accept_languages(accept_language: String) -> Vec<String> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/netcetera/netcetera_types.rs | crate: router
fn try_from(
value: hyperswitch_domain_models::address::PhoneDetails,
) -> Result<Self, Self::Error> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/netcetera/netcetera_types.rs | crate: router
use crate::{connector::utils::PhoneDetailsData, errors, types::api::MessageCategory};
fn try_from(network: common_enums::CardNetwork) -> Result<Self, Self::Error> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/netcetera/netcetera_types.rs | crate: router
fn from(value: api_models::payments::ThreeDsCompletionIndicator) -> Self {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/netcetera/netcetera_types.rs | crate: router
use crate::{connector::utils::PhoneDetailsData, errors, types::api::MessageCategory};
fn from(value: MessageCategory) -> Self {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/netcetera/netcetera_types.rs | crate: router
fn from(value: api_models::payments::DeviceChannel) -> Self {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/netcetera/netcetera_types.rs | crate: router
pub fn new_list(value: Vec<T>) -> Self {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/netcetera/netcetera_types.rs | crate: router
pub fn new_single(value: T) -> Self {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/netcetera/netcetera_types.rs | crate: router
use common_utils::{pii::Email, types::SemanticVersion};
fn get_version_checked(message_version: SemanticVersion, value: T) -> Self {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/netcetera/netcetera_types.rs | crate: router
use masking::ExposeInterface;
use unidecode::unidecode;
fn try_from(
(billing_address, shipping_address): (
hyperswitch_domain_models::address::Address,
Option<hyperswitch_domain_models::address::Address>,
),
) -> Result<Self, Self::Error> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/ebanx/transformers.rs | crate: router
use api_models::payouts::{Bank, PayoutMethodData};
use common_utils::types::FloatMajorUnit;
use crate::{
connector::utils::{AddressDetailsData, RouterData},
connector::utils::{CustomerDetails, PayoutsData},
types::{api, storage::enums as storage_enums},
};
use crate::{core::errors, types};
fn try_from(
item: &EbanxRouterData<&types::PayoutsRouterData<api::PoCreate>>,
) -> Result<Self, Self::Error> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/ebanx/transformers.rs | crate: router
fn from(item: EbanxFulfillStatus) -> Self {
{
EbanxFulfillStatus::Success => Self::Success,<|fim_suffix|>
<|fim_middle|>
EbanxFulfillStatus::ApiError
| EbanxFulfillStatus::AuthenticationError
| EbanxFulfillStatus::InvalidRequestError
| EbanxFulfillStatus::RequestError => Self::Failed,
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/ebanx/transformers.rs | crate: router
use common_utils::types::FloatMajorUnit;
use crate::{
connector::utils::{AddressDetailsData, RouterData},
connector::utils::{CustomerDetails, PayoutsData},
types::{api, storage::enums as storage_enums},
};
use crate::{core::errors, types};
fn try_from(auth_type: &types::ConnectorAuthType) -> Result<Self, Self::Error> {
{
types::ConnectorAuthType::HeaderKey { api_key } => Ok(Self {
integration_key: api_key.to_owned(),
}),<|fim_suffix|>
<|fim_middle|>
_ => Err(errors::ConnectorError::FailedToObtainAuthType.into()),
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/ebanx/transformers.rs | crate: router
use common_utils::types::FloatMajorUnit;
use crate::{
connector::utils::{AddressDetailsData, RouterData},
connector::utils::{CustomerDetails, PayoutsData},
types::{api, storage::enums as storage_enums},
};
use crate::{core::errors, types};
fn try_from(
item: types::PayoutsResponseRouterData<F, EbanxCancelResponse>,
) -> Result<Self, Self::Error> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/ebanx/transformers.rs | crate: router
fn from(item: EbanxCancelStatus) -> Self {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/ebanx/transformers.rs | crate: router
use common_utils::types::FloatMajorUnit;
use crate::{
connector::utils::{AddressDetailsData, RouterData},
connector::utils::{CustomerDetails, PayoutsData},
types::{api, storage::enums as storage_enums},
};
use crate::{core::errors, types};
fn try_from(
item: types::PayoutsResponseRouterData<F, EbanxFulfillResponse>,
) -> Result<Self, Self::Error> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/ebanx/transformers.rs | crate: router
fn from(item: EbanxFulfillStatus) -> Self {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/ebanx/transformers.rs | crate: router
use api_models::payouts::{Bank, PayoutMethodData};
use common_utils::types::FloatMajorUnit;
use crate::{
connector::utils::{AddressDetailsData, RouterData},
connector::utils::{CustomerDetails, PayoutsData},
types::{api, storage::enums as storage_enums},
};
use crate::{core::errors, types};
fn try_from(item: &EbanxRouterData<&types::PayoutsRouterData<F>>) -> Result<Self, Self::Error> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/ebanx/transformers.rs | crate: router
use common_utils::types::FloatMajorUnit;
use crate::{
connector::utils::{AddressDetailsData, RouterData},
connector::utils::{CustomerDetails, PayoutsData},
types::{api, storage::enums as storage_enums},
};
use crate::{core::errors, types};
fn try_from(
item: types::PayoutsResponseRouterData<F, EbanxPayoutResponse>,
) -> Result<Self, Self::Error> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/ebanx/transformers.rs | crate: router
fn from(item: EbanxPayoutStatus) -> Self {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/signifyd/transformers/api.rs | crate: router
use common_utils::{ext_traits::ValueExt, pii::Email};
use crate::{
connector::utils::{
AddressDetailsData, FraudCheckCheckoutRequest, FraudCheckRecordReturnRequest,
FraudCheckSaleRequest, FraudCheckTransactionRequest, RouterData,
},
core::{errors, fraud_check::types as core_types},
types::{
self, api, api::Fulfillment, fraud_check as frm_types, storage::enums as storage_enums,
transformers::ForeignFrom, ResponseId, ResponseRouterData,
},
};
fn try_from(item: &frm_types::FrmCheckoutRouterData) -> Result<Self, Self::Error> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/signifyd/transformers/api.rs | crate: router
use common_utils::{ext_traits::ValueExt, pii::Email};
use crate::{
connector::utils::{
AddressDetailsData, FraudCheckCheckoutRequest, FraudCheckRecordReturnRequest,
FraudCheckSaleRequest, FraudCheckTransactionRequest, RouterData,
},
core::{errors, fraud_check::types as core_types},
types::{
self, api, api::Fulfillment, fraud_check as frm_types, storage::enums as storage_enums,
transformers::ForeignFrom, ResponseId, ResponseRouterData,
},
};
fn try_from(item: &frm_types::FrmSaleRouterData) -> Result<Self, Self::Error> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/signifyd/transformers/api.rs | crate: router
use crate::{
connector::utils::{
AddressDetailsData, FraudCheckCheckoutRequest, FraudCheckRecordReturnRequest,
FraudCheckSaleRequest, FraudCheckTransactionRequest, RouterData,
},
core::{errors, fraud_check::types as core_types},
types::{
self, api, api::Fulfillment, fraud_check as frm_types, storage::enums as storage_enums,
transformers::ForeignFrom, ResponseId, ResponseRouterData,
},
};
fn try_from(item: &frm_types::FrmRecordReturnRouterData) -> Result<Self, Self::Error> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/signifyd/transformers/api.rs | crate: router
fn from(item: SignifydPaymentStatus) -> Self {
{
SignifydPaymentStatus::Accept => Self::Legit,<|fim_suffix|>
<|fim_middle|>
SignifydPaymentStatus::Challenge | SignifydPaymentStatus::Credit => Self::Pending,
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/signifyd/transformers/api.rs | crate: router
fn from(value: ReviewDisposition) -> Self {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
// file: hyperswitch/crates/router/src/connector/signifyd/transformers/api.rs | crate: router
use crate::{
connector::utils::{
AddressDetailsData, FraudCheckCheckoutRequest, FraudCheckRecordReturnRequest,
FraudCheckSaleRequest, FraudCheckTransactionRequest, RouterData,
},
core::{errors, fraud_check::types as core_types},
types::{
self, api, api::Fulfillment, fraud_check as frm_types, storage::enums as storage_enums,
transformers::ForeignFrom, ResponseId, ResponseRouterData,
},
};
fn try_from(item: &frm_types::FrmRecordReturnRouterData) -> Result<Self, Self::Error> {
let currency = item.request.get_currency()?;
let refund = SignifydRefund {
method: item.request.refund_method.clone(),
amount: item.request.amount.to_string(),
currency,
};
Ok(Self {
return_id: uuid::Uuid::new_v4().to_string(),
refund_transaction_id: item.request.refund_transaction_id.clone(),
refund,
order_id: item.attempt_id.clone(),
})
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/signifyd/transformers/api.rs | crate: router
use crate::{
connector::utils::{
AddressDetailsData, FraudCheckCheckoutRequest, FraudCheckRecordReturnRequest,
FraudCheckSaleRequest, FraudCheckTransactionRequest, RouterData,
},
core::{errors, fraud_check::types as core_types},
types::{
self, api, api::Fulfillment, fraud_check as frm_types, storage::enums as storage_enums,
transformers::ForeignFrom, ResponseId, ResponseRouterData,
},
};
fn try_from(
item: ResponseRouterData<
F,
SignifydPaymentsRecordReturnResponse,
T,
frm_types::FraudCheckResponseData,
>,
) -> Result<Self, Self::Error> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/signifyd/transformers/api.rs | crate: router
use crate::{
connector::utils::{
AddressDetailsData, FraudCheckCheckoutRequest, FraudCheckRecordReturnRequest,
FraudCheckSaleRequest, FraudCheckTransactionRequest, RouterData,
},
core::{errors, fraud_check::types as core_types},
types::{
self, api, api::Fulfillment, fraud_check as frm_types, storage::enums as storage_enums,
transformers::ForeignFrom, ResponseId, ResponseRouterData,
},
};
fn try_from(
item: ResponseRouterData<
Fulfillment,
FrmFulfillmentSignifydApiResponse,
frm_types::FraudCheckFulfillmentData,
frm_types::FraudCheckResponseData,
>,
) -> Result<Self, Self::Error> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/signifyd/transformers/api.rs | crate: router
use crate::{
connector::utils::{
AddressDetailsData, FraudCheckCheckoutRequest, FraudCheckRecordReturnRequest,
FraudCheckSaleRequest, FraudCheckTransactionRequest, RouterData,
},
core::{errors, fraud_check::types as core_types},
types::{
self, api, api::Fulfillment, fraud_check as frm_types, storage::enums as storage_enums,
transformers::ForeignFrom, ResponseId, ResponseRouterData,
},
};
fn from(address: core_types::Address) -> Self {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/signifyd/transformers/api.rs | crate: router
use crate::{
connector::utils::{
AddressDetailsData, FraudCheckCheckoutRequest, FraudCheckRecordReturnRequest,
FraudCheckSaleRequest, FraudCheckTransactionRequest, RouterData,
},
core::{errors, fraud_check::types as core_types},
types::{
self, api, api::Fulfillment, fraud_check as frm_types, storage::enums as storage_enums,
transformers::ForeignFrom, ResponseId, ResponseRouterData,
},
};
fn from(destination: core_types::Destination) -> Self {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/signifyd/transformers/api.rs | crate: router
use crate::{
connector::utils::{
AddressDetailsData, FraudCheckCheckoutRequest, FraudCheckRecordReturnRequest,
FraudCheckSaleRequest, FraudCheckTransactionRequest, RouterData,
},
core::{errors, fraud_check::types as core_types},
types::{
self, api, api::Fulfillment, fraud_check as frm_types, storage::enums as storage_enums,
transformers::ForeignFrom, ResponseId, ResponseRouterData,
},
};
fn from(product: core_types::Product) -> Self {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/signifyd/transformers/api.rs | crate: router
use crate::{
connector::utils::{
AddressDetailsData, FraudCheckCheckoutRequest, FraudCheckRecordReturnRequest,
FraudCheckSaleRequest, FraudCheckTransactionRequest, RouterData,
},
core::{errors, fraud_check::types as core_types},
types::{
self, api, api::Fulfillment, fraud_check as frm_types, storage::enums as storage_enums,
transformers::ForeignFrom, ResponseId, ResponseRouterData,
},
};
fn foreign_from(fulfillment_req: &core_types::FrmFulfillmentRequest) -> Self {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/signifyd/transformers/api.rs | crate: router
use crate::{
connector::utils::{
AddressDetailsData, FraudCheckCheckoutRequest, FraudCheckRecordReturnRequest,
FraudCheckSaleRequest, FraudCheckTransactionRequest, RouterData,
},
core::{errors, fraud_check::types as core_types},
types::{
self, api, api::Fulfillment, fraud_check as frm_types, storage::enums as storage_enums,
transformers::ForeignFrom, ResponseId, ResponseRouterData,
},
};
fn from(status: &core_types::FulfillmentStatus) -> Self {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/signifyd/transformers/api.rs | crate: router
use crate::{
connector::utils::{
AddressDetailsData, FraudCheckCheckoutRequest, FraudCheckRecordReturnRequest,
FraudCheckSaleRequest, FraudCheckTransactionRequest, RouterData,
},
core::{errors, fraud_check::types as core_types},
types::{
self, api, api::Fulfillment, fraud_check as frm_types, storage::enums as storage_enums,
transformers::ForeignFrom, ResponseId, ResponseRouterData,
},
};
fn from(item: storage_enums::AttemptStatus) -> Self {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/signifyd/transformers/api.rs | crate: router
use crate::{
connector::utils::{
AddressDetailsData, FraudCheckCheckoutRequest, FraudCheckRecordReturnRequest,
FraudCheckSaleRequest, FraudCheckTransactionRequest, RouterData,
},
core::{errors, fraud_check::types as core_types},
types::{
self, api, api::Fulfillment, fraud_check as frm_types, storage::enums as storage_enums,
transformers::ForeignFrom, ResponseId, ResponseRouterData,
},
};
fn try_from(
item: ResponseRouterData<F, SignifydPaymentsResponse, T, frm_types::FraudCheckResponseData>,
) -> Result<Self, Self::Error> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/signifyd/transformers/api.rs | crate: router
fn from(item: SignifydPaymentStatus) -> Self {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/stripe/transformers.rs | crate: router
use api_models::{self, enums as api_enums, payments};
use common_utils::{
errors::CustomResult,
ext_traits::{ByteSliceExt, Encode},
pii::{self, Email},
request::RequestContent,
types::MinorUnit,
};
pub use self::connect::*;
use crate::{
collect_missing_value_keys,
connector::utils::{self as connector_util, ApplePay, ApplePayDecrypt, RouterData},
consts,
core::errors,
headers, services,
types::{
self, api, domain,
storage::enums,
transformers::{ForeignFrom, ForeignTryFrom},
},
utils::OptionExt,
};
pub fn construct_charge_response<T>(
charge_id: String,
request: &T,
) -> Option<common_types::payments::ConnectorChargeResponseData>
where
T: connector_util::SplitPaymentData,
{
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/stripe/transformers.rs | crate: router
use common_utils::{
errors::CustomResult,
ext_traits::{ByteSliceExt, Encode},
pii::{self, Email},
request::RequestContent,
types::MinorUnit,
};
use crate::{
collect_missing_value_keys,
connector::utils::{self as connector_util, ApplePay, ApplePayDecrypt, RouterData},
consts,
core::errors,
headers, services,
types::{
self, api, domain,
storage::enums,
transformers::{ForeignFrom, ForeignTryFrom},
},
utils::OptionExt,
};
fn foreign_try_from(
(response, http_code, response_id): (&Option<ErrorDetails>, u16, String),
) -> Result<Self, Self::Error> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/stripe/transformers.rs | crate: router
use common_utils::{
errors::CustomResult,
ext_traits::{ByteSliceExt, Encode},
pii::{self, Email},
request::RequestContent,
types::MinorUnit,
};
use masking::{ExposeInterface, ExposeOptionInterface, Mask, PeekInterface, Secret};
use crate::{
collect_missing_value_keys,
connector::utils::{self as connector_util, ApplePay, ApplePayDecrypt, RouterData},
consts,
core::errors,
headers, services,
types::{
self, api, domain,
storage::enums,
transformers::{ForeignFrom, ForeignTryFrom},
},
utils::OptionExt,
};
fn try_from(item: &types::SubmitEvidenceRouterData) -> Result<Self, Self::Error> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/stripe/transformers.rs | crate: router
use common_utils::{
errors::CustomResult,
ext_traits::{ByteSliceExt, Encode},
pii::{self, Email},
request::RequestContent,
types::MinorUnit,
};
use crate::{
collect_missing_value_keys,
connector::utils::{self as connector_util, ApplePay, ApplePayDecrypt, RouterData},
consts,
core::errors,
headers, services,
types::{
self, api, domain,
storage::enums,
transformers::{ForeignFrom, ForeignTryFrom},
},
utils::OptionExt,
};
fn mandatory_parameters_for_sepa_bank_debit_mandates(
billing_details: &Option<StripeBillingAddress>,
is_customer_initiated_mandate_payment: Option<bool>,
) -> Result<StripeBillingAddress, errors::ConnectorError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/stripe/transformers.rs | crate: router
use api_models::{self, enums as api_enums, payments};
use common_utils::{
errors::CustomResult,
ext_traits::{ByteSliceExt, Encode},
pii::{self, Email},
request::RequestContent,
types::MinorUnit,
};
use crate::{
collect_missing_value_keys,
connector::utils::{self as connector_util, ApplePay, ApplePayDecrypt, RouterData},
consts,
core::errors,
headers, services,
types::{
self, api, domain,
storage::enums,
transformers::{ForeignFrom, ForeignTryFrom},
},
utils::OptionExt,
};
fn try_from(
item: types::ResponseRouterData<F, ChargesResponse, T, types::PaymentsResponseData>,
) -> Result<Self, Self::Error> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/stripe/transformers.rs | crate: router
use api_models::{self, enums as api_enums, payments};
use common_utils::{
errors::CustomResult,
ext_traits::{ByteSliceExt, Encode},
pii::{self, Email},
request::RequestContent,
types::MinorUnit,
};
use crate::{
collect_missing_value_keys,
connector::utils::{self as connector_util, ApplePay, ApplePayDecrypt, RouterData},
consts,
core::errors,
headers, services,
types::{
self, api, domain,
storage::enums,
transformers::{ForeignFrom, ForeignTryFrom},
},
utils::OptionExt,
};
fn try_from(
item: types::ResponseRouterData<F, StripeSourceResponse, T, types::PaymentsResponseData>,
) -> Result<Self, Self::Error> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/stripe/transformers.rs | crate: router
use api_models::{self, enums as api_enums, payments};
use common_utils::{
errors::CustomResult,
ext_traits::{ByteSliceExt, Encode},
pii::{self, Email},
request::RequestContent,
types::MinorUnit,
};
use crate::{
collect_missing_value_keys,
connector::utils::{self as connector_util, ApplePay, ApplePayDecrypt, RouterData},
consts,
core::errors,
headers, services,
types::{
self, api, domain,
storage::enums,
transformers::{ForeignFrom, ForeignTryFrom},
},
utils::OptionExt,
};
fn try_from(
item: types::RefundsResponseRouterData<api::RSync, RefundResponse>,
) -> Result<Self, Self::Error> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/stripe/transformers.rs | crate: router
use api_models::{self, enums as api_enums, payments};
use common_utils::{
errors::CustomResult,
ext_traits::{ByteSliceExt, Encode},
pii::{self, Email},
request::RequestContent,
types::MinorUnit,
};
use crate::{
collect_missing_value_keys,
connector::utils::{self as connector_util, ApplePay, ApplePayDecrypt, RouterData},
consts,
core::errors,
headers, services,
types::{
self, api, domain,
storage::enums,
transformers::{ForeignFrom, ForeignTryFrom},
},
utils::OptionExt,
};
fn try_from(
item: types::RefundsResponseRouterData<api::Execute, RefundResponse>,
) -> Result<Self, Self::Error> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/stripe/transformers.rs | crate: router
use common_utils::{
errors::CustomResult,
ext_traits::{ByteSliceExt, Encode},
pii::{self, Email},
request::RequestContent,
types::MinorUnit,
};
use crate::{
collect_missing_value_keys,
connector::utils::{self as connector_util, ApplePay, ApplePayDecrypt, RouterData},
consts,
core::errors,
headers, services,
types::{
self, api, domain,
storage::enums,
transformers::{ForeignFrom, ForeignTryFrom},
},
utils::OptionExt,
};
fn try_from(item: &types::RefundsRouterData<F>) -> Result<Self, Self::Error> {
{
None => Err(errors::ConnectorError::MissingRequiredField {
field_name: "split_refunds",
}
.into()),<|fim_suffix|>
<|fim_middle|>
Some(split_refunds) => match split_refunds {
types::SplitRefundsRequest::StripeSplitRefund(stripe_refund) => {
let (refund_application_fee, reverse_transfer) = match &stripe_refund.options {
types::ChargeRefundsOptions::Direct(types::DirectChargeRefund {
revert_platform_fee,
}) => (Some(*revert_platform_fee), None),
types::ChargeRefundsOptions::Destination(
types::DestinationChargeRefund {
revert_platform_fee,
revert_transfer,
},
) => (Some(*revert_platform_fee), Some(*revert_transfer)),
};
Ok(Self {
charge: stripe_refund.charge_id.clone(),
refund_application_fee,
reverse_transfer,
amount: Some(amount),
meta_data: StripeMetadata {
order_id: Some(item.request.refund_id.clone()),
is_refund_id_as_reference: Some("true".to_string()),
},
})
}
_ => Err(errors::ConnectorError::MissingRequiredField {
field_name: "stripe_split_refund",
})?,
},
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/stripe/transformers.rs | crate: router
use std::{collections::HashMap, ops::Deref};
use api_models::{self, enums as api_enums, payments};
use common_utils::{
errors::CustomResult,
ext_traits::{ByteSliceExt, Encode},
pii::{self, Email},
request::RequestContent,
types::MinorUnit,
};
use error_stack::ResultExt;
use hyperswitch_domain_models::mandates::AcceptanceType;
use masking::{ExposeInterface, ExposeOptionInterface, Mask, PeekInterface, Secret};
use serde::{Deserialize, Serialize};
use serde_json::Value;
use time::PrimitiveDateTime;
use url::Url;
pub use self::connect::*;
use crate::{
collect_missing_value_keys,
connector::utils::{self as connector_util, ApplePay, ApplePayDecrypt, RouterData},
consts,
core::errors,
headers, services,
types::{
self, api, domain,
storage::enums,
transformers::{ForeignFrom, ForeignTryFrom},
},
utils::OptionExt,
};
fn try_from(
item: types::ResponseRouterData<F, SetupIntentResponse, T, types::PaymentsResponseData>,
) -> Result<Self, Self::Error> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/stripe/transformers.rs | crate: router
use api_models::{self, enums as api_enums, payments};
use common_utils::{
errors::CustomResult,
ext_traits::{ByteSliceExt, Encode},
pii::{self, Email},
request::RequestContent,
types::MinorUnit,
};
pub use self::connect::*;
use crate::{
collect_missing_value_keys,
connector::utils::{self as connector_util, ApplePay, ApplePayDecrypt, RouterData},
consts,
core::errors,
headers, services,
types::{
self, api, domain,
storage::enums,
transformers::{ForeignFrom, ForeignTryFrom},
},
utils::OptionExt,
};
pub fn get_additional_payment_method_data(&self) -> Option<AdditionalPaymentMethodDetails> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/stripe/transformers.rs | crate: router
use api_models::{self, enums as api_enums, payments};
use common_utils::{
errors::CustomResult,
ext_traits::{ByteSliceExt, Encode},
pii::{self, Email},
request::RequestContent,
types::MinorUnit,
};
use error_stack::ResultExt;
use crate::{
collect_missing_value_keys,
connector::utils::{self as connector_util, ApplePay, ApplePayDecrypt, RouterData},
consts,
core::errors,
headers, services,
types::{
self, api, domain,
storage::enums,
transformers::{ForeignFrom, ForeignTryFrom},
},
utils::OptionExt,
};
fn get_payment_method_type_for_saved_payment_method_payment(
item: &types::PaymentsAuthorizeRouterData,
) -> Result<Option<StripePaymentMethodType>, error_stack::Report<errors::ConnectorError>> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/stripe/transformers.rs | crate: router
use masking::{ExposeInterface, ExposeOptionInterface, Mask, PeekInterface, Secret};
use crate::{
collect_missing_value_keys,
connector::utils::{self as connector_util, ApplePay, ApplePayDecrypt, RouterData},
consts,
core::errors,
headers, services,
types::{
self, api, domain,
storage::enums,
transformers::{ForeignFrom, ForeignTryFrom},
},
utils::OptionExt,
};
fn get_bank_debit_data(
bank_debit_data: &domain::BankDebitData,
) -> (StripePaymentMethodType, BankDebitData) {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/stripe/transformers.rs | crate: router
use common_utils::{
errors::CustomResult,
ext_traits::{ByteSliceExt, Encode},
pii::{self, Email},
request::RequestContent,
types::MinorUnit,
};
use crate::{
collect_missing_value_keys,
connector::utils::{self as connector_util, ApplePay, ApplePayDecrypt, RouterData},
consts,
core::errors,
headers, services,
types::{
self, api, domain,
storage::enums,
transformers::{ForeignFrom, ForeignTryFrom},
},
utils::OptionExt,
};
fn foreign_try_from(wallet_data: &domain::WalletData) -> Result<Self, Self::Error> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/stripe/transformers.rs | crate: router
use common_utils::{
errors::CustomResult,
ext_traits::{ByteSliceExt, Encode},
pii::{self, Email},
request::RequestContent,
types::MinorUnit,
};
use crate::{
collect_missing_value_keys,
connector::utils::{self as connector_util, ApplePay, ApplePayDecrypt, RouterData},
consts,
core::errors,
headers, services,
types::{
self, api, domain,
storage::enums,
transformers::{ForeignFrom, ForeignTryFrom},
},
utils::OptionExt,
};
fn try_from(bank_redirect_data: &domain::BankRedirectData) -> Result<Self, Self::Error> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/stripe/transformers.rs | crate: router
use common_utils::{
errors::CustomResult,
ext_traits::{ByteSliceExt, Encode},
pii::{self, Email},
request::RequestContent,
types::MinorUnit,
};
use error_stack::ResultExt;
use crate::{
collect_missing_value_keys,
connector::utils::{self as connector_util, ApplePay, ApplePayDecrypt, RouterData},
consts,
core::errors,
headers, services,
types::{
self, api, domain,
storage::enums,
transformers::{ForeignFrom, ForeignTryFrom},
},
utils::OptionExt,
};
fn validate_shipping_address_against_payment_method(
shipping_address: &Option<StripeShippingAddress>,
payment_method: Option<&StripePaymentMethodType>,
) -> Result<(), error_stack::Report<errors::ConnectorError>> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/stripe/transformers.rs | crate: router
fn should_return_error_when_missing_multiple_fields() {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/stripe/transformers.rs | crate: router
fn from(item: RefundStatus) -> Self {
{
RefundStatus::Succeeded => Self::Success,<|fim_suffix|>
<|fim_middle|>
RefundStatus::RequiresAction => Self::ManualReview,
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/stripe/transformers.rs | crate: router
use masking::{ExposeInterface, ExposeOptionInterface, Mask, PeekInterface, Secret};
fn create_stripe_shipping_address(
name: String,
line1: Option<String>,
country: Option<CountryAlpha2>,
zip: Option<String>,
) -> StripeShippingAddress {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/stripe/transformers.rs | crate: router
use common_utils::{
errors::CustomResult,
ext_traits::{ByteSliceExt, Encode},
pii::{self, Email},
request::RequestContent,
types::MinorUnit,
};
use crate::{
collect_missing_value_keys,
connector::utils::{self as connector_util, ApplePay, ApplePayDecrypt, RouterData},
consts,
core::errors,
headers, services,
types::{
self, api, domain,
storage::enums,
transformers::{ForeignFrom, ForeignTryFrom},
},
utils::OptionExt,
};
fn get_missing_fields(connector_error: &errors::ConnectorError) -> Vec<&'static str> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
// file: hyperswitch/crates/router/src/connector/stripe/transformers.rs | crate: router
fn should_return_error_when_missing_multiple_fields() {
// Arrange
let expected_missing_field_names: Vec<&'static str> =
vec!["shipping.address.zip", "shipping.address.country"];
let stripe_shipping_address = create_stripe_shipping_address(
"name".to_string(),
Some("line1".to_string()),
None,
None,
);
let payment_method = &StripePaymentMethodType::AfterpayClearpay;
//Act
let result = validate_shipping_address_against_payment_method(
&Some(stripe_shipping_address),
Some(payment_method),
);
// Assert
assert!(result.is_err());
let missing_fields = get_missing_fields(result.unwrap_err().current_context()).to_owned();
for field in missing_fields {
assert!(expected_missing_field_names.contains(&field));
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/stripe/transformers.rs | crate: router
fn should_return_err_for_empty_zip() {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/stripe/transformers.rs | crate: router
fn should_return_err_for_empty_country() {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/stripe/transformers.rs | crate: router
fn should_return_err_for_empty_line1() {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/stripe/transformers.rs | crate: router
fn should_return_ok() {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/stripe/transformers.rs | crate: router
use api_models::{self, enums as api_enums, payments};
use common_utils::{
errors::CustomResult,
ext_traits::{ByteSliceExt, Encode},
pii::{self, Email},
request::RequestContent,
types::MinorUnit,
};
pub use self::connect::*;
use crate::{
collect_missing_value_keys,
connector::utils::{self as connector_util, ApplePay, ApplePayDecrypt, RouterData},
consts,
core::errors,
headers, services,
types::{
self, api, domain,
storage::enums,
transformers::{ForeignFrom, ForeignTryFrom},
},
utils::OptionExt,
};
pub(super) fn transform_headers_for_connect_platform(
charge_type: api::enums::PaymentChargeType,
transfer_account_id: String,
header: &mut Vec<(String, services::request::Maskable<String>)>,
) {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/stripe/transformers.rs | crate: router
use std::{collections::HashMap, ops::Deref};
use masking::{ExposeInterface, ExposeOptionInterface, Mask, PeekInterface, Secret};
use serde_json::Value;
fn get_transaction_metadata(
merchant_metadata: Option<Secret<Value>>,
order_id: String,
) -> HashMap<String, String> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/stripe/transformers.rs | crate: router
use common_utils::{
errors::CustomResult,
ext_traits::{ByteSliceExt, Encode},
pii::{self, Email},
request::RequestContent,
types::MinorUnit,
};
pub use self::connect::*;
use crate::{
collect_missing_value_keys,
connector::utils::{self as connector_util, ApplePay, ApplePayDecrypt, RouterData},
consts,
core::errors,
headers, services,
types::{
self, api, domain,
storage::enums,
transformers::{ForeignFrom, ForeignTryFrom},
},
utils::OptionExt,
};
pub fn construct_file_upload_request(
file_upload_router_data: types::UploadFileRouterData,
) -> CustomResult<reqwest::multipart::Form, errors::ConnectorError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/stripe/transformers.rs | crate: router
use common_utils::{
errors::CustomResult,
ext_traits::{ByteSliceExt, Encode},
pii::{self, Email},
request::RequestContent,
types::MinorUnit,
};
pub use self::connect::*;
use crate::{
collect_missing_value_keys,
connector::utils::{self as connector_util, ApplePay, ApplePayDecrypt, RouterData},
consts,
core::errors,
headers, services,
types::{
self, api, domain,
storage::enums,
transformers::{ForeignFrom, ForeignTryFrom},
},
utils::OptionExt,
};
pub fn get_bank_transfer_request_data(
req: &types::PaymentsAuthorizeRouterData,
bank_transfer_data: &domain::BankTransferData,
amount: MinorUnit,
) -> CustomResult<RequestContent, errors::ConnectorError> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.