text stringlengths 70 351k | source stringclasses 4 values |
|---|---|
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/forte/transformers.rs | crate: hyperswitch_connectors | connector: forte
use common_enums::enums;
use crate::{
types::{PaymentsCaptureResponseRouterData, RefundsResponseRouterData, ResponseRouterData},
utils::{
self, AddressDetailsData, CardData as _PaymentsAuthorizeRequestData,
PaymentsAuthorizeRequestData, RouterData as _,
},
};
fn get_status(response_code: ForteResponseCode, action: ForteAction) -> enums::AttemptStatus {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/forte/transformers.rs | crate: hyperswitch_connectors | connector: forte
fn from(item: FortePaymentStatus) -> Self {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/forte/transformers.rs | crate: hyperswitch_connectors | connector: forte
use crate::{
types::{PaymentsCaptureResponseRouterData, RefundsResponseRouterData, ResponseRouterData},
utils::{
self, AddressDetailsData, CardData as _PaymentsAuthorizeRequestData,
PaymentsAuthorizeRequestData, RouterData as _,
},
};
fn try_from(issuer: utils::CardIssuer) -> Result<Self, Self::Error> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/aci/transformers.rs | crate: hyperswitch_connectors | connector: aci
use common_enums::enums;
use common_utils::{id_type, pii::Email, request::Method, types::StringMajorUnit};
use hyperswitch_domain_models::{
payment_method_data::{BankRedirectData, Card, PayLaterData, PaymentMethodData, WalletData},
router_data::{ConnectorAuthType, RouterData},
router_request_types::ResponseId,
router_response_types::{
MandateReference, PaymentsResponseData, RedirectForm, RefundsResponseData,
},
types::{PaymentsAuthorizeRouterData, PaymentsCancelRouterData, RefundsRouterData},
};
use crate::{
types::{RefundsResponseRouterData, ResponseRouterData},
utils::{self, PhoneDetailsData, RouterData as _},
};
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: ResponseRouterData<F, AciPaymentsResponse, T, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/aci/transformers.rs | crate: hyperswitch_connectors | connector: aci
use common_utils::{id_type, pii::Email, request::Method, types::StringMajorUnit};
use hyperswitch_domain_models::{
payment_method_data::{BankRedirectData, Card, PayLaterData, PaymentMethodData, WalletData},
router_data::{ConnectorAuthType, RouterData},
router_request_types::ResponseId,
router_response_types::{
MandateReference, PaymentsResponseData, RedirectForm, RefundsResponseData,
},
types::{PaymentsAuthorizeRouterData, PaymentsCancelRouterData, RefundsRouterData},
};
use crate::{
types::{RefundsResponseRouterData, ResponseRouterData},
utils::{self, PhoneDetailsData, RouterData as _},
};
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(item: &AciRouterData<&PaymentsAuthorizeRouterData>) -> Result<Self, Self::Error> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/aci/transformers.rs | crate: hyperswitch_connectors | connector: aci
fn from(item: AciRefundStatus) -> Self {
{
AciRefundStatus::Succeeded => Self::Success,<|fim_suffix|>
<|fim_middle|>
AciRefundStatus::Pending => Self::Pending,
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/aci/transformers.rs | crate: hyperswitch_connectors | connector: aci
use common_utils::{id_type, pii::Email, request::Method, types::StringMajorUnit};
use hyperswitch_domain_models::{
payment_method_data::{BankRedirectData, Card, PayLaterData, PaymentMethodData, WalletData},
router_data::{ConnectorAuthType, RouterData},
router_request_types::ResponseId,
router_response_types::{
MandateReference, PaymentsResponseData, RedirectForm, RefundsResponseData,
},
types::{PaymentsAuthorizeRouterData, PaymentsCancelRouterData, RefundsRouterData},
};
fn get_instruction_details(
item: &AciRouterData<&PaymentsAuthorizeRouterData>,
) -> Option<Instruction> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/aci/transformers.rs | crate: hyperswitch_connectors | connector: aci
use common_enums::enums;
use hyperswitch_domain_models::{
payment_method_data::{BankRedirectData, Card, PayLaterData, PaymentMethodData, WalletData},
router_data::{ConnectorAuthType, RouterData},
router_request_types::ResponseId,
router_response_types::{
MandateReference, PaymentsResponseData, RedirectForm, RefundsResponseData,
},
types::{PaymentsAuthorizeRouterData, PaymentsCancelRouterData, RefundsRouterData},
};
use crate::{
types::{RefundsResponseRouterData, ResponseRouterData},
utils::{self, PhoneDetailsData, RouterData as _},
};
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: RefundsResponseRouterData<F, AciRefundResponse>,
) -> Result<Self, Self::Error> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/aci/transformers.rs | crate: hyperswitch_connectors | connector: aci
fn from(item: AciRefundStatus) -> Self {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/aci/transformers.rs | crate: hyperswitch_connectors | connector: aci
use common_utils::{id_type, pii::Email, request::Method, types::StringMajorUnit};
use hyperswitch_domain_models::{
payment_method_data::{BankRedirectData, Card, PayLaterData, PaymentMethodData, WalletData},
router_data::{ConnectorAuthType, RouterData},
router_request_types::ResponseId,
router_response_types::{
MandateReference, PaymentsResponseData, RedirectForm, RefundsResponseData,
},
types::{PaymentsAuthorizeRouterData, PaymentsCancelRouterData, RefundsRouterData},
};
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(item: &AciRouterData<&RefundsRouterData<F>>) -> Result<Self, Self::Error> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/aci/transformers.rs | crate: hyperswitch_connectors | connector: aci
fn from(item: AciPaymentStatus) -> Self {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/aci/transformers.rs | crate: hyperswitch_connectors | connector: aci
use common_utils::{id_type, pii::Email, request::Method, types::StringMajorUnit};
use hyperswitch_domain_models::{
payment_method_data::{BankRedirectData, Card, PayLaterData, PaymentMethodData, WalletData},
router_data::{ConnectorAuthType, RouterData},
router_request_types::ResponseId,
router_response_types::{
MandateReference, PaymentsResponseData, RedirectForm, RefundsResponseData,
},
types::{PaymentsAuthorizeRouterData, PaymentsCancelRouterData, RefundsRouterData},
};
fn get_instruction_details(
item: &AciRouterData<&PaymentsAuthorizeRouterData>,
) -> Option<Instruction> {
if item.router_data.request.setup_mandate_details.is_some() {
return Some(Instruction {
mode: InstructionMode::Initial,
transaction_type: InstructionType::Unscheduled,
source: InstructionSource::CardholderInitiatedTransaction,
create_registration: Some(true),
});
} else if item.router_data.request.mandate_id.is_some() {
return Some(Instruction {
mode: InstructionMode::Repeated,
transaction_type: InstructionType::Unscheduled,
source: InstructionSource::MerchantInitiatedTransaction,
create_registration: None,
});
}
None
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/aci/transformers.rs | crate: hyperswitch_connectors | connector: aci
use common_utils::{id_type, pii::Email, request::Method, types::StringMajorUnit};
use error_stack::report;
use hyperswitch_domain_models::{
payment_method_data::{BankRedirectData, Card, PayLaterData, PaymentMethodData, WalletData},
router_data::{ConnectorAuthType, RouterData},
router_request_types::ResponseId,
router_response_types::{
MandateReference, PaymentsResponseData, RedirectForm, RefundsResponseData,
},
types::{PaymentsAuthorizeRouterData, PaymentsCancelRouterData, RefundsRouterData},
};
type Error = error_stack::Report<errors::ConnectorError>;
fn get_transaction_details(
item: &AciRouterData<&PaymentsAuthorizeRouterData>,
) -> Result<TransactionDetails, error_stack::Report<errors::ConnectorError>> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/aci/transformers.rs | crate: hyperswitch_connectors | connector: aci
use common_utils::{id_type, pii::Email, request::Method, types::StringMajorUnit};
use hyperswitch_domain_models::{
payment_method_data::{BankRedirectData, Card, PayLaterData, PaymentMethodData, WalletData},
router_data::{ConnectorAuthType, RouterData},
router_request_types::ResponseId,
router_response_types::{
MandateReference, PaymentsResponseData, RedirectForm, RefundsResponseData,
},
types::{PaymentsAuthorizeRouterData, PaymentsCancelRouterData, RefundsRouterData},
};
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
value: (
&AciRouterData<&PaymentsAuthorizeRouterData>,
api_models::payments::MandateIds,
),
) -> Result<Self, Self::Error> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/aci/transformers.rs | crate: hyperswitch_connectors | connector: aci
use hyperswitch_domain_models::{
payment_method_data::{BankRedirectData, Card, PayLaterData, PaymentMethodData, WalletData},
router_data::{ConnectorAuthType, RouterData},
router_request_types::ResponseId,
router_response_types::{
MandateReference, PaymentsResponseData, RedirectForm, RefundsResponseData,
},
types::{PaymentsAuthorizeRouterData, PaymentsCancelRouterData, RefundsRouterData},
};
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
value: (&AciRouterData<&PaymentsAuthorizeRouterData>, &Card),
) -> Result<Self, Self::Error> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/aci/transformers.rs | crate: hyperswitch_connectors | connector: aci
use common_utils::{id_type, pii::Email, request::Method, types::StringMajorUnit};
use hyperswitch_domain_models::{
payment_method_data::{BankRedirectData, Card, PayLaterData, PaymentMethodData, WalletData},
router_data::{ConnectorAuthType, RouterData},
router_request_types::ResponseId,
router_response_types::{
MandateReference, PaymentsResponseData, RedirectForm, RefundsResponseData,
},
types::{PaymentsAuthorizeRouterData, PaymentsCancelRouterData, RefundsRouterData},
};
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
value: (&AciRouterData<&PaymentsAuthorizeRouterData>, &PayLaterData),
) -> Result<Self, Self::Error> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/aci/transformers.rs | crate: hyperswitch_connectors | connector: aci
use common_utils::{id_type, pii::Email, request::Method, types::StringMajorUnit};
use hyperswitch_domain_models::{
payment_method_data::{BankRedirectData, Card, PayLaterData, PaymentMethodData, WalletData},
router_data::{ConnectorAuthType, RouterData},
router_request_types::ResponseId,
router_response_types::{
MandateReference, PaymentsResponseData, RedirectForm, RefundsResponseData,
},
types::{PaymentsAuthorizeRouterData, PaymentsCancelRouterData, RefundsRouterData},
};
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
value: (
&AciRouterData<&PaymentsAuthorizeRouterData>,
&BankRedirectData,
),
) -> Result<Self, Self::Error> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/aci/transformers.rs | crate: hyperswitch_connectors | connector: aci
use common_utils::{id_type, pii::Email, request::Method, types::StringMajorUnit};
use hyperswitch_domain_models::{
payment_method_data::{BankRedirectData, Card, PayLaterData, PaymentMethodData, WalletData},
router_data::{ConnectorAuthType, RouterData},
router_request_types::ResponseId,
router_response_types::{
MandateReference, PaymentsResponseData, RedirectForm, RefundsResponseData,
},
types::{PaymentsAuthorizeRouterData, PaymentsCancelRouterData, RefundsRouterData},
};
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
value: (&AciRouterData<&PaymentsAuthorizeRouterData>, &WalletData),
) -> Result<Self, Self::Error> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/aci/transformers.rs | crate: hyperswitch_connectors | connector: aci
use hyperswitch_domain_models::{
payment_method_data::{BankRedirectData, Card, PayLaterData, PaymentMethodData, WalletData},
router_data::{ConnectorAuthType, RouterData},
router_request_types::ResponseId,
router_response_types::{
MandateReference, PaymentsResponseData, RedirectForm, RefundsResponseData,
},
types::{PaymentsAuthorizeRouterData, PaymentsCancelRouterData, RefundsRouterData},
};
use masking::{ExposeInterface, Secret};
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
(card_data, card_holder_name): (Card, Option<Secret<String>>),
) -> Result<Self, Self::Error> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/fiserv/transformers.rs | crate: hyperswitch_connectors | connector: fiserv
use common_utils::{ext_traits::ValueExt, pii, types::FloatMajorUnit};
use hyperswitch_domain_models::{
payment_method_data::PaymentMethodData,
router_data::{ConnectorAuthType, RouterData},
router_flow_types::refunds::{Execute, RSync},
router_request_types::ResponseId,
router_response_types::{PaymentsResponseData, RefundsResponseData},
types,
};
use crate::{
types::{RefundsResponseRouterData, ResponseRouterData},
utils::{
self, CardData as CardDataUtil, PaymentsCancelRequestData, PaymentsSyncRequestData,
RouterData as _,
},
};
fn try_from(
item: &FiservRouterData<&types::RefundsRouterData<F>>,
) -> Result<Self, Self::Error> {
let auth: FiservAuthType = FiservAuthType::try_from(&item.router_data.connector_auth_type)?;
let metadata = item
.router_data
.connector_meta_data
.clone()
.ok_or(errors::ConnectorError::RequestEncodingFailed)?;
let session: FiservSessionObject = metadata
.parse_value("FiservSessionObject")
.change_context(errors::ConnectorError::InvalidConnectorConfig {
config: "Merchant connector account metadata",
})?;
Ok(Self {
amount: Amount {
total: item.amount,
currency: item.router_data.request.currency.to_string(),
},
merchant_details: MerchantDetails {
merchant_id: auth.merchant_account,
terminal_id: Some(session.terminal_id),
},
reference_transaction_details: ReferenceTransactionDetails {
reference_transaction_id: item
.router_data
.request
.connector_transaction_id
.to_string(),
},
})
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/fiserv/transformers.rs | crate: hyperswitch_connectors | connector: fiserv
use common_utils::{ext_traits::ValueExt, pii, types::FloatMajorUnit};
use hyperswitch_domain_models::{
payment_method_data::PaymentMethodData,
router_data::{ConnectorAuthType, RouterData},
router_flow_types::refunds::{Execute, RSync},
router_request_types::ResponseId,
router_response_types::{PaymentsResponseData, RefundsResponseData},
types,
};
use crate::{
types::{RefundsResponseRouterData, ResponseRouterData},
utils::{
self, CardData as CardDataUtil, PaymentsCancelRequestData, PaymentsSyncRequestData,
RouterData as _,
},
};
fn try_from(
item: &FiservRouterData<&types::PaymentsCaptureRouterData>,
) -> Result<Self, Self::Error> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/fiserv/transformers.rs | crate: hyperswitch_connectors | connector: fiserv
use common_enums::enums;
use hyperswitch_domain_models::{
payment_method_data::PaymentMethodData,
router_data::{ConnectorAuthType, RouterData},
router_flow_types::refunds::{Execute, RSync},
router_request_types::ResponseId,
router_response_types::{PaymentsResponseData, RefundsResponseData},
types,
};
use crate::{
types::{RefundsResponseRouterData, ResponseRouterData},
utils::{
self, CardData as CardDataUtil, PaymentsCancelRequestData, PaymentsSyncRequestData,
RouterData as _,
},
};
fn try_from(
item: ResponseRouterData<F, FiservSyncResponse, T, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/fiserv/transformers.rs | crate: hyperswitch_connectors | connector: fiserv
use common_enums::enums;
use common_utils::{ext_traits::ValueExt, pii, types::FloatMajorUnit};
use hyperswitch_domain_models::{
payment_method_data::PaymentMethodData,
router_data::{ConnectorAuthType, RouterData},
router_flow_types::refunds::{Execute, RSync},
router_request_types::ResponseId,
router_response_types::{PaymentsResponseData, RefundsResponseData},
types,
};
use crate::{
types::{RefundsResponseRouterData, ResponseRouterData},
utils::{
self, CardData as CardDataUtil, PaymentsCancelRequestData, PaymentsSyncRequestData,
RouterData as _,
},
};
fn try_from(
item: &FiservRouterData<&types::PaymentsAuthorizeRouterData>,
) -> Result<Self, Self::Error> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/fiserv/transformers.rs | crate: hyperswitch_connectors | connector: fiserv
use common_utils::{ext_traits::ValueExt, pii, types::FloatMajorUnit};
use hyperswitch_domain_models::{
payment_method_data::PaymentMethodData,
router_data::{ConnectorAuthType, RouterData},
router_flow_types::refunds::{Execute, RSync},
router_request_types::ResponseId,
router_response_types::{PaymentsResponseData, RefundsResponseData},
types,
};
use crate::{
types::{RefundsResponseRouterData, ResponseRouterData},
utils::{
self, CardData as CardDataUtil, PaymentsCancelRequestData, PaymentsSyncRequestData,
RouterData as _,
},
};
fn try_from(
item: &FiservRouterData<&types::RefundsRouterData<F>>,
) -> Result<Self, Self::Error> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/fiserv/transformers.rs | crate: hyperswitch_connectors | connector: fiserv
fn from(item: FiservPaymentStatus) -> Self {
{
FiservPaymentStatus::Succeeded
| FiservPaymentStatus::Authorized
| FiservPaymentStatus::Captured => Self::Success,<|fim_suffix|>
<|fim_middle|>
FiservPaymentStatus::Voided | FiservPaymentStatus::Processing => Self::Pending,
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/fiserv/transformers.rs | crate: hyperswitch_connectors | connector: fiserv
fn from(item: FiservPaymentStatus) -> Self {
{
FiservPaymentStatus::Captured | FiservPaymentStatus::Succeeded => Self::Charged,<|fim_suffix|>
<|fim_middle|>
FiservPaymentStatus::Authorized => Self::Authorized,
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/fiserv/transformers.rs | crate: hyperswitch_connectors | connector: fiserv
use common_enums::enums;
use hyperswitch_domain_models::{
payment_method_data::PaymentMethodData,
router_data::{ConnectorAuthType, RouterData},
router_flow_types::refunds::{Execute, RSync},
router_request_types::ResponseId,
router_response_types::{PaymentsResponseData, RefundsResponseData},
types,
};
use crate::{
types::{RefundsResponseRouterData, ResponseRouterData},
utils::{
self, CardData as CardDataUtil, PaymentsCancelRequestData, PaymentsSyncRequestData,
RouterData as _,
},
};
fn try_from(
item: RefundsResponseRouterData<RSync, FiservSyncResponse>,
) -> Result<Self, Self::Error> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/fiserv/transformers.rs | crate: hyperswitch_connectors | connector: fiserv
use common_enums::enums;
use hyperswitch_domain_models::{
payment_method_data::PaymentMethodData,
router_data::{ConnectorAuthType, RouterData},
router_flow_types::refunds::{Execute, RSync},
router_request_types::ResponseId,
router_response_types::{PaymentsResponseData, RefundsResponseData},
types,
};
use crate::{
types::{RefundsResponseRouterData, ResponseRouterData},
utils::{
self, CardData as CardDataUtil, PaymentsCancelRequestData, PaymentsSyncRequestData,
RouterData as _,
},
};
fn try_from(
item: ResponseRouterData<F, FiservPaymentsResponse, T, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/fiserv/transformers.rs | crate: hyperswitch_connectors | connector: fiserv
fn from(item: FiservPaymentStatus) -> Self {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/fiserv/transformers.rs | crate: hyperswitch_connectors | connector: fiserv
fn from(item: FiservPaymentStatus) -> Self {
match item {
FiservPaymentStatus::Captured | FiservPaymentStatus::Succeeded => Self::Charged,
FiservPaymentStatus::Declined | FiservPaymentStatus::Failed => Self::Failure,
FiservPaymentStatus::Processing => Self::Authorizing,
FiservPaymentStatus::Voided => Self::Voided,
FiservPaymentStatus::Authorized => Self::Authorized,
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/fiserv/transformers.rs | crate: hyperswitch_connectors | connector: fiserv
use common_utils::{ext_traits::ValueExt, pii, types::FloatMajorUnit};
use hyperswitch_domain_models::{
payment_method_data::PaymentMethodData,
router_data::{ConnectorAuthType, RouterData},
router_flow_types::refunds::{Execute, RSync},
router_request_types::ResponseId,
router_response_types::{PaymentsResponseData, RefundsResponseData},
types,
};
fn try_from((amount, router_data): (FloatMajorUnit, T)) -> Result<Self, Self::Error> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/shift4/transformers.rs | crate: hyperswitch_connectors | connector: shift4
use common_utils::{
pii::{self, SecretSerdeValue},
request::Method,
types::MinorUnit,
};
use hyperswitch_domain_models::{
payment_method_data::{
BankRedirectData, BankTransferData, Card as CardData, GiftCardData, PaymentMethodData,
VoucherData, WalletData,
},
router_data::{ConnectorAuthType, RouterData},
router_flow_types::refunds::{Execute, RSync},
router_request_types::{
CompleteAuthorizeData, PaymentsAuthorizeData, PaymentsPreProcessingData, ResponseId,
},
router_response_types::{PaymentsResponseData, RedirectForm, RefundsResponseData},
types::{PaymentsPreProcessingRouterData, RefundsRouterData},
};
use crate::{
types::{
PaymentsPreprocessingResponseRouterData, RefundsResponseRouterData, ResponseRouterData,
},
utils::{
self, to_connector_meta, PaymentsAuthorizeRequestData,
PaymentsCompleteAuthorizeRequestData, PaymentsPreProcessingRequestData, RouterData as _,
},
};
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: ResponseRouterData<F, Shift4NonThreeDsResponse, T, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/shift4/transformers.rs | crate: hyperswitch_connectors | connector: shift4
use common_enums::enums;
use common_utils::{
pii::{self, SecretSerdeValue},
request::Method,
types::MinorUnit,
};
use hyperswitch_domain_models::{
payment_method_data::{
BankRedirectData, BankTransferData, Card as CardData, GiftCardData, PaymentMethodData,
VoucherData, WalletData,
},
router_data::{ConnectorAuthType, RouterData},
router_flow_types::refunds::{Execute, RSync},
router_request_types::{
CompleteAuthorizeData, PaymentsAuthorizeData, PaymentsPreProcessingData, ResponseId,
},
router_response_types::{PaymentsResponseData, RedirectForm, RefundsResponseData},
types::{PaymentsPreProcessingRouterData, RefundsRouterData},
};
use crate::{
types::{
PaymentsPreprocessingResponseRouterData, RefundsResponseRouterData, ResponseRouterData,
},
utils::{
self, to_connector_meta, PaymentsAuthorizeRequestData,
PaymentsCompleteAuthorizeRequestData, PaymentsPreProcessingRequestData, RouterData as _,
},
};
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: PaymentsPreprocessingResponseRouterData<Shift4ThreeDsResponse>,
) -> Result<Self, Self::Error> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/shift4/transformers.rs | crate: hyperswitch_connectors | connector: shift4
use hyperswitch_domain_models::{
payment_method_data::{
BankRedirectData, BankTransferData, Card as CardData, GiftCardData, PaymentMethodData,
VoucherData, WalletData,
},
router_data::{ConnectorAuthType, RouterData},
router_flow_types::refunds::{Execute, RSync},
router_request_types::{
CompleteAuthorizeData, PaymentsAuthorizeData, PaymentsPreProcessingData, ResponseId,
},
router_response_types::{PaymentsResponseData, RedirectForm, RefundsResponseData},
types::{PaymentsPreProcessingRouterData, RefundsRouterData},
};
use crate::{
types::{
PaymentsPreprocessingResponseRouterData, RefundsResponseRouterData, ResponseRouterData,
},
utils::{
self, to_connector_meta, PaymentsAuthorizeRequestData,
PaymentsCompleteAuthorizeRequestData, PaymentsPreProcessingRequestData, RouterData as _,
},
};
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(value: &BankRedirectData) -> Result<Self, Self::Error> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/shift4/transformers.rs | crate: hyperswitch_connectors | connector: shift4
use common_utils::{
pii::{self, SecretSerdeValue},
request::Method,
types::MinorUnit,
};
use hyperswitch_domain_models::{
payment_method_data::{
BankRedirectData, BankTransferData, Card as CardData, GiftCardData, PaymentMethodData,
VoucherData, WalletData,
},
router_data::{ConnectorAuthType, RouterData},
router_flow_types::refunds::{Execute, RSync},
router_request_types::{
CompleteAuthorizeData, PaymentsAuthorizeData, PaymentsPreProcessingData, ResponseId,
},
router_response_types::{PaymentsResponseData, RedirectForm, RefundsResponseData},
types::{PaymentsPreProcessingRouterData, RefundsRouterData},
};
use crate::{
types::{
PaymentsPreprocessingResponseRouterData, RefundsResponseRouterData, ResponseRouterData,
},
utils::{
self, to_connector_meta, PaymentsAuthorizeRequestData,
PaymentsCompleteAuthorizeRequestData, PaymentsPreProcessingRequestData, RouterData as _,
},
};
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: &Shift4RouterData<&RouterData<T, CompleteAuthorizeData, PaymentsResponseData>>,
) -> Result<Self, Self::Error> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/shift4/transformers.rs | crate: hyperswitch_connectors | connector: shift4
use common_utils::{
pii::{self, SecretSerdeValue},
request::Method,
types::MinorUnit,
};
use hyperswitch_domain_models::{
payment_method_data::{
BankRedirectData, BankTransferData, Card as CardData, GiftCardData, PaymentMethodData,
VoucherData, WalletData,
},
router_data::{ConnectorAuthType, RouterData},
router_flow_types::refunds::{Execute, RSync},
router_request_types::{
CompleteAuthorizeData, PaymentsAuthorizeData, PaymentsPreProcessingData, ResponseId,
},
router_response_types::{PaymentsResponseData, RedirectForm, RefundsResponseData},
types::{PaymentsPreProcessingRouterData, RefundsRouterData},
};
use masking::Secret;
use crate::{
types::{
PaymentsPreprocessingResponseRouterData, RefundsResponseRouterData, ResponseRouterData,
},
utils::{
self, to_connector_meta, PaymentsAuthorizeRequestData,
PaymentsCompleteAuthorizeRequestData, PaymentsPreProcessingRequestData, RouterData as _,
},
};
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
(item, card): (&RouterData<T, Req, PaymentsResponseData>, &CardData),
) -> Result<Self, Self::Error> {
let card_object = Card {
number: card.card_number.clone(),
exp_month: card.card_exp_month.clone(),
exp_year: card.card_exp_year.clone(),
cardholder_name: item
.get_optional_billing_full_name()
.unwrap_or(Secret::new("".to_string())),
};
if item.is_three_ds() {
Ok(Self::Cards3DSRequest(Box::new(Cards3DSRequest {
card_number: card_object.number,
card_exp_month: card_object.exp_month,
card_exp_year: card_object.exp_year,
return_url: item
.request
.get_complete_authorize_url()
.clone()
.ok_or_else(|| errors::ConnectorError::RequestEncodingFailed)?,
})))
} else {
Ok(Self::CardsNon3DSRequest(Box::new(CardsNon3DSRequest {
card: CardPayment::RawCard(Box::new(card_object)),
description: item.description.clone(),
})))
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/shift4/transformers.rs | crate: hyperswitch_connectors | connector: shift4
use hyperswitch_domain_models::{
payment_method_data::{
BankRedirectData, BankTransferData, Card as CardData, GiftCardData, PaymentMethodData,
VoucherData, WalletData,
},
router_data::{ConnectorAuthType, RouterData},
router_flow_types::refunds::{Execute, RSync},
router_request_types::{
CompleteAuthorizeData, PaymentsAuthorizeData, PaymentsPreProcessingData, ResponseId,
},
router_response_types::{PaymentsResponseData, RedirectForm, RefundsResponseData},
types::{PaymentsPreProcessingRouterData, RefundsRouterData},
};
use crate::{
types::{
PaymentsPreprocessingResponseRouterData, RefundsResponseRouterData, ResponseRouterData,
},
utils::{
self, to_connector_meta, PaymentsAuthorizeRequestData,
PaymentsCompleteAuthorizeRequestData, PaymentsPreProcessingRequestData, RouterData as _,
},
};
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(wallet_data: &WalletData) -> Result<Self, Self::Error> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/shift4/transformers.rs | crate: hyperswitch_connectors | connector: shift4
fn from(item: Shift4RefundStatus) -> Self {
{
Shift4RefundStatus::Successful => Self::Success,<|fim_suffix|>
<|fim_middle|>
Shift4RefundStatus::Processing => Self::Pending,
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/shift4/transformers.rs | crate: hyperswitch_connectors | connector: shift4
use common_enums::enums;
fn get_status(
captured: bool,
next_action: Option<&NextAction>,
payment_status: Shift4PaymentStatus,
) -> enums::AttemptStatus {
{
Some(NextAction::Redirect) => enums::AttemptStatus::AuthenticationPending,<|fim_suffix|>
<|fim_middle|>
Some(NextAction::Wait) | Some(NextAction::None) | None => enums::AttemptStatus::Pending,
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/shift4/transformers.rs | crate: hyperswitch_connectors | connector: shift4
)
.into())
}
}
}
}
impl<T, Req> TryFrom<(&RouterData<T, Req, PaymentsResponseData>, &CardData)> for Shift4PaymentMethod
where
Req: Shift4AuthorizePreprocessingCommon,
{
type Error = Error;
fn try_from(
(item, card): (&RouterData<T, Req, PaymentsResponseData>, &CardData),
) -> Result<Self, Self::Error> {
let card_object = Card {
number: card.card_number.clone(),
exp_month: card.card_exp_month.clone(),
exp_year: card.card_exp_year.clone(),
cardholder_name: item
.get_optional_billing_full_name()
.unwrap_or(Secret::new("".to_string())),
};
if item.is_three_ds() {
Ok(Self::Cards3DSRequest(Box::new(Cards3DSRequest {
fn try_from(
(item, card): (&RouterData<T, Req, PaymentsResponseData>, &CardData),
) -> Result<Self, Self::Error> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/shift4/transformers.rs | crate: hyperswitch_connectors | connector: shift4
use common_utils::{
pii::{self, SecretSerdeValue},
request::Method,
types::MinorUnit,
};
use hyperswitch_domain_models::{
payment_method_data::{
BankRedirectData, BankTransferData, Card as CardData, GiftCardData, PaymentMethodData,
VoucherData, WalletData,
},
router_data::{ConnectorAuthType, RouterData},
router_flow_types::refunds::{Execute, RSync},
router_request_types::{
CompleteAuthorizeData, PaymentsAuthorizeData, PaymentsPreProcessingData, ResponseId,
},
router_response_types::{PaymentsResponseData, RedirectForm, RefundsResponseData},
types::{PaymentsPreProcessingRouterData, RefundsRouterData},
};
use crate::{
types::{
PaymentsPreprocessingResponseRouterData, RefundsResponseRouterData, ResponseRouterData,
},
utils::{
self, to_connector_meta, PaymentsAuthorizeRequestData,
PaymentsCompleteAuthorizeRequestData, PaymentsPreProcessingRequestData, RouterData as _,
},
};
fn from(event: Shift4WebhookEvent) -> Self {
{
Shift4WebhookEvent::ChargeSucceeded | Shift4WebhookEvent::ChargeUpdated => {
//reference : https://dev.shift4.com/docs/api#event-types
Self::PaymentIntentProcessing
}<|fim_suffix|>
<|fim_middle|>
Shift4WebhookEvent::Unknown => Self::EventNotSupported,
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/shift4/transformers.rs | crate: hyperswitch_connectors | connector: shift4 | op: refund
pub fn is_refund_event(event: &Shift4WebhookEvent) -> bool {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/shift4/transformers.rs | crate: hyperswitch_connectors | connector: shift4
pub fn is_transaction_event(event: &Shift4WebhookEvent) -> bool {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/shift4/transformers.rs | crate: hyperswitch_connectors | connector: shift4
fn from(item: Shift4RefundStatus) -> Self {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/shift4/transformers.rs | crate: hyperswitch_connectors | connector: shift4
use common_utils::{
pii::{self, SecretSerdeValue},
request::Method,
types::MinorUnit,
};
use hyperswitch_domain_models::{
payment_method_data::{
BankRedirectData, BankTransferData, Card as CardData, GiftCardData, PaymentMethodData,
VoucherData, WalletData,
},
router_data::{ConnectorAuthType, RouterData},
router_flow_types::refunds::{Execute, RSync},
router_request_types::{
CompleteAuthorizeData, PaymentsAuthorizeData, PaymentsPreProcessingData, ResponseId,
},
router_response_types::{PaymentsResponseData, RedirectForm, RefundsResponseData},
types::{PaymentsPreProcessingRouterData, RefundsRouterData},
};
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(item: &Shift4RouterData<&RefundsRouterData<F>>) -> Result<Self, Self::Error> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/shift4/transformers.rs | crate: hyperswitch_connectors | connector: shift4
use common_enums::enums;
fn get_status(
captured: bool,
next_action: Option<&NextAction>,
payment_status: Shift4PaymentStatus,
) -> enums::AttemptStatus {
{
Shift4PaymentStatus::Successful => {
if captured {
enums::AttemptStatus::Charged
} else {
enums::AttemptStatus::Authorized
}
}<|fim_suffix|>
<|fim_middle|>
Shift4PaymentStatus::Pending => match next_action {
Some(NextAction::Redirect) => enums::AttemptStatus::AuthenticationPending,
Some(NextAction::Wait) | Some(NextAction::None) | None => enums::AttemptStatus::Pending,
},
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/shift4/transformers.rs | crate: hyperswitch_connectors | connector: shift4
use hyperswitch_domain_models::{
payment_method_data::{
BankRedirectData, BankTransferData, Card as CardData, GiftCardData, PaymentMethodData,
VoucherData, WalletData,
},
router_data::{ConnectorAuthType, RouterData},
router_flow_types::refunds::{Execute, RSync},
router_request_types::{
CompleteAuthorizeData, PaymentsAuthorizeData, PaymentsPreProcessingData, ResponseId,
},
router_response_types::{PaymentsResponseData, RedirectForm, RefundsResponseData},
types::{PaymentsPreProcessingRouterData, RefundsRouterData},
};
fn get_address_details(
address_details: Option<&hyperswitch_domain_models::address::AddressDetails>,
) -> Option<Address> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/shift4/transformers.rs | crate: hyperswitch_connectors | connector: shift4
use common_utils::{
pii::{self, SecretSerdeValue},
request::Method,
types::MinorUnit,
};
use hyperswitch_domain_models::{
payment_method_data::{
BankRedirectData, BankTransferData, Card as CardData, GiftCardData, PaymentMethodData,
VoucherData, WalletData,
},
router_data::{ConnectorAuthType, RouterData},
router_flow_types::refunds::{Execute, RSync},
router_request_types::{
CompleteAuthorizeData, PaymentsAuthorizeData, PaymentsPreProcessingData, ResponseId,
},
router_response_types::{PaymentsResponseData, RedirectForm, RefundsResponseData},
types::{PaymentsPreProcessingRouterData, RefundsRouterData},
};
use masking::Secret;
use crate::{
types::{
PaymentsPreprocessingResponseRouterData, RefundsResponseRouterData, ResponseRouterData,
},
utils::{
self, to_connector_meta, PaymentsAuthorizeRequestData,
PaymentsCompleteAuthorizeRequestData, PaymentsPreProcessingRequestData, RouterData as _,
},
};
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(item: &RouterData<T, Req, PaymentsResponseData>) -> Result<Self, Self::Error> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/shift4/transformers.rs | crate: hyperswitch_connectors | connector: shift4
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(router_return_url: Option<String>) -> Result<Self, Self::Error> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/shift4/transformers.rs | crate: hyperswitch_connectors | connector: shift4
use common_utils::{
pii::{self, SecretSerdeValue},
request::Method,
types::MinorUnit,
};
use hyperswitch_domain_models::{
payment_method_data::{
BankRedirectData, BankTransferData, Card as CardData, GiftCardData, PaymentMethodData,
VoucherData, WalletData,
},
router_data::{ConnectorAuthType, RouterData},
router_flow_types::refunds::{Execute, RSync},
router_request_types::{
CompleteAuthorizeData, PaymentsAuthorizeData, PaymentsPreProcessingData, ResponseId,
},
router_response_types::{PaymentsResponseData, RedirectForm, RefundsResponseData},
types::{PaymentsPreProcessingRouterData, RefundsRouterData},
};
use crate::{
types::{
PaymentsPreprocessingResponseRouterData, RefundsResponseRouterData, ResponseRouterData,
},
utils::{
self, to_connector_meta, PaymentsAuthorizeRequestData,
PaymentsCompleteAuthorizeRequestData, PaymentsPreProcessingRequestData, RouterData as _,
},
};
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
(item, redirect_data): (&RouterData<T, Req, PaymentsResponseData>, &BankRedirectData),
) -> Result<Self, Self::Error> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/shift4/transformers.rs | crate: hyperswitch_connectors | connector: shift4
use hyperswitch_domain_models::{
payment_method_data::{
BankRedirectData, BankTransferData, Card as CardData, GiftCardData, PaymentMethodData,
VoucherData, WalletData,
},
router_data::{ConnectorAuthType, RouterData},
router_flow_types::refunds::{Execute, RSync},
router_request_types::{
CompleteAuthorizeData, PaymentsAuthorizeData, PaymentsPreProcessingData, ResponseId,
},
router_response_types::{PaymentsResponseData, RedirectForm, RefundsResponseData},
types::{PaymentsPreProcessingRouterData, RefundsRouterData},
};
use crate::{
types::{
PaymentsPreprocessingResponseRouterData, RefundsResponseRouterData, ResponseRouterData,
},
utils::{
self, to_connector_meta, PaymentsAuthorizeRequestData,
PaymentsCompleteAuthorizeRequestData, PaymentsPreProcessingRequestData, RouterData as _,
},
};
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(voucher_data: &VoucherData) -> Result<Self, Self::Error> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/shift4/transformers.rs | crate: hyperswitch_connectors | connector: shift4
use hyperswitch_domain_models::{
payment_method_data::{
BankRedirectData, BankTransferData, Card as CardData, GiftCardData, PaymentMethodData,
VoucherData, WalletData,
},
router_data::{ConnectorAuthType, RouterData},
router_flow_types::refunds::{Execute, RSync},
router_request_types::{
CompleteAuthorizeData, PaymentsAuthorizeData, PaymentsPreProcessingData, ResponseId,
},
router_response_types::{PaymentsResponseData, RedirectForm, RefundsResponseData},
types::{PaymentsPreProcessingRouterData, RefundsRouterData},
};
use crate::{
types::{
PaymentsPreprocessingResponseRouterData, RefundsResponseRouterData, ResponseRouterData,
},
utils::{
self, to_connector_meta, PaymentsAuthorizeRequestData,
PaymentsCompleteAuthorizeRequestData, PaymentsPreProcessingRequestData, RouterData as _,
},
};
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(bank_transfer_data: &BankTransferData) -> Result<Self, Self::Error> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/shift4/transformers.rs | crate: hyperswitch_connectors | connector: shift4
use common_utils::{
pii::{self, SecretSerdeValue},
request::Method,
types::MinorUnit,
};
use hyperswitch_domain_models::{
payment_method_data::{
BankRedirectData, BankTransferData, Card as CardData, GiftCardData, PaymentMethodData,
VoucherData, WalletData,
},
router_data::{ConnectorAuthType, RouterData},
router_flow_types::refunds::{Execute, RSync},
router_request_types::{
CompleteAuthorizeData, PaymentsAuthorizeData, PaymentsPreProcessingData, ResponseId,
},
router_response_types::{PaymentsResponseData, RedirectForm, RefundsResponseData},
types::{PaymentsPreProcessingRouterData, RefundsRouterData},
};
use crate::{
types::{
PaymentsPreprocessingResponseRouterData, RefundsResponseRouterData, ResponseRouterData,
},
utils::{
self, to_connector_meta, PaymentsAuthorizeRequestData,
PaymentsCompleteAuthorizeRequestData, PaymentsPreProcessingRequestData, RouterData as _,
},
};
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: &Shift4RouterData<&RouterData<T, Req, PaymentsResponseData>>,
) -> Result<Self, Self::Error> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/shift4/transformers.rs | crate: hyperswitch_connectors | connector: shift4
use common_utils::{
pii::{self, SecretSerdeValue},
request::Method,
types::MinorUnit,
};
use crate::{
types::{
PaymentsPreprocessingResponseRouterData, RefundsResponseRouterData, ResponseRouterData,
},
utils::{
self, to_connector_meta, PaymentsAuthorizeRequestData,
PaymentsCompleteAuthorizeRequestData, PaymentsPreProcessingRequestData, RouterData as _,
},
};
fn get_router_return_url(&self) -> Option<String> {
self.router_return_url.clone()
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/shift4/transformers.rs | crate: hyperswitch_connectors | connector: shift4
use common_utils::{
pii::{self, SecretSerdeValue},
request::Method,
types::MinorUnit,
};
use hyperswitch_domain_models::{
payment_method_data::{
BankRedirectData, BankTransferData, Card as CardData, GiftCardData, PaymentMethodData,
VoucherData, WalletData,
},
router_data::{ConnectorAuthType, RouterData},
router_flow_types::refunds::{Execute, RSync},
router_request_types::{
CompleteAuthorizeData, PaymentsAuthorizeData, PaymentsPreProcessingData, ResponseId,
},
router_response_types::{PaymentsResponseData, RedirectForm, RefundsResponseData},
types::{PaymentsPreProcessingRouterData, RefundsRouterData},
};
use crate::{
types::{
PaymentsPreprocessingResponseRouterData, RefundsResponseRouterData, ResponseRouterData,
},
utils::{
self, to_connector_meta, PaymentsAuthorizeRequestData,
PaymentsCompleteAuthorizeRequestData, PaymentsPreProcessingRequestData, RouterData as _,
},
};
type Error = error_stack::Report<errors::ConnectorError>;
fn get_payment_method_data_required(&self) -> Result<PaymentMethodData, Error> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/shift4/transformers.rs | crate: hyperswitch_connectors | connector: shift4
use common_enums::enums;
use common_utils::{
pii::{self, SecretSerdeValue},
request::Method,
types::MinorUnit,
};
use crate::{
types::{
PaymentsPreprocessingResponseRouterData, RefundsResponseRouterData, ResponseRouterData,
},
utils::{
self, to_connector_meta, PaymentsAuthorizeRequestData,
PaymentsCompleteAuthorizeRequestData, PaymentsPreProcessingRequestData, RouterData as _,
},
};
type Error = error_stack::Report<errors::ConnectorError>;
fn get_currency_required(&self) -> Result<enums::Currency, Error> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/shift4/transformers.rs | crate: hyperswitch_connectors | connector: shift4 | op: authorize
use common_utils::{
pii::{self, SecretSerdeValue},
request::Method,
types::MinorUnit,
};
use crate::{
types::{
PaymentsPreprocessingResponseRouterData, RefundsResponseRouterData, ResponseRouterData,
},
utils::{
self, to_connector_meta, PaymentsAuthorizeRequestData,
PaymentsCompleteAuthorizeRequestData, PaymentsPreProcessingRequestData, RouterData as _,
},
};
fn get_complete_authorize_url(&self) -> Option<String> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/shift4/transformers.rs | crate: hyperswitch_connectors | connector: shift4
use common_utils::{
pii::{self, SecretSerdeValue},
request::Method,
types::MinorUnit,
};
use crate::{
types::{
PaymentsPreprocessingResponseRouterData, RefundsResponseRouterData, ResponseRouterData,
},
utils::{
self, to_connector_meta, PaymentsAuthorizeRequestData,
PaymentsCompleteAuthorizeRequestData, PaymentsPreProcessingRequestData, RouterData as _,
},
};
fn get_email_optional(&self) -> Option<pii::Email> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/shift4/transformers.rs | crate: hyperswitch_connectors | connector: shift4
use common_utils::{
pii::{self, SecretSerdeValue},
request::Method,
types::MinorUnit,
};
use crate::{
types::{
PaymentsPreprocessingResponseRouterData, RefundsResponseRouterData, ResponseRouterData,
},
utils::{
self, to_connector_meta, PaymentsAuthorizeRequestData,
PaymentsCompleteAuthorizeRequestData, PaymentsPreProcessingRequestData, RouterData as _,
},
};
fn get_router_return_url(&self) -> Option<String> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/shift4/transformers.rs | crate: hyperswitch_connectors | connector: shift4 | op: capture
use common_utils::{
pii::{self, SecretSerdeValue},
request::Method,
types::MinorUnit,
};
use crate::{
types::{
PaymentsPreprocessingResponseRouterData, RefundsResponseRouterData, ResponseRouterData,
},
utils::{
self, to_connector_meta, PaymentsAuthorizeRequestData,
PaymentsCompleteAuthorizeRequestData, PaymentsPreProcessingRequestData, RouterData as _,
},
};
type Error = error_stack::Report<errors::ConnectorError>;
fn is_automatic_capture(&self) -> Result<bool, Error> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/shift4/transformers.rs | crate: hyperswitch_connectors | connector: shift4
use common_utils::{
pii::{self, SecretSerdeValue},
request::Method,
types::MinorUnit,
};
use error_stack::ResultExt;
use hyperswitch_domain_models::{
payment_method_data::{
BankRedirectData, BankTransferData, Card as CardData, GiftCardData, PaymentMethodData,
VoucherData, WalletData,
},
router_data::{ConnectorAuthType, RouterData},
router_flow_types::refunds::{Execute, RSync},
router_request_types::{
CompleteAuthorizeData, PaymentsAuthorizeData, PaymentsPreProcessingData, ResponseId,
},
router_response_types::{PaymentsResponseData, RedirectForm, RefundsResponseData},
types::{PaymentsPreProcessingRouterData, RefundsRouterData},
};
use crate::{
types::{
PaymentsPreprocessingResponseRouterData, RefundsResponseRouterData, ResponseRouterData,
},
utils::{
self, to_connector_meta, PaymentsAuthorizeRequestData,
PaymentsCompleteAuthorizeRequestData, PaymentsPreProcessingRequestData, RouterData as _,
},
};
type Error = error_stack::Report<errors::ConnectorError>;
fn get_payment_method_data_required(
&self,
) -> Result<PaymentMethodData, error_stack::Report<errors::ConnectorError>> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/zen/transformers.rs | crate: hyperswitch_connectors | connector: zen | op: refund
use common_enums::enums;
use common_utils::{
errors::CustomResult,
ext_traits::{OptionExt, ValueExt},
pii::{self},
request::Method,
};
use hyperswitch_domain_models::{
payment_method_data::{
BankDebitData, BankRedirectData, BankTransferData, Card, CardRedirectData, GiftCardData,
PayLaterData, PaymentMethodData, VoucherData, WalletData,
},
router_data::{ConnectorAuthType, ErrorResponse, RouterData},
router_flow_types::refunds::{Execute, RSync},
router_request_types::{BrowserInformation, ResponseId},
router_response_types::{PaymentsResponseData, RedirectForm, RefundsResponseData},
types,
};
use hyperswitch_interfaces::{
api,
consts::{NO_ERROR_CODE, NO_ERROR_MESSAGE},
errors,
};
use crate::{
types::{RefundsResponseRouterData, ResponseRouterData},
utils::{
self, BrowserInformationData, CardData, ForeignTryFrom, PaymentsAuthorizeRequestData,
RouterData as _,
},
};
fn get_zen_refund_response(
response: RefundResponse,
status_code: u16,
) -> CustomResult<(Option<ErrorResponse>, RefundsResponseData), errors::ConnectorError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/zen/transformers.rs | crate: hyperswitch_connectors | connector: zen
use common_enums::enums;
use common_utils::{
errors::CustomResult,
ext_traits::{OptionExt, ValueExt},
pii::{self},
request::Method,
};
use hyperswitch_domain_models::{
payment_method_data::{
BankDebitData, BankRedirectData, BankTransferData, Card, CardRedirectData, GiftCardData,
PayLaterData, PaymentMethodData, VoucherData, WalletData,
},
router_data::{ConnectorAuthType, ErrorResponse, RouterData},
router_flow_types::refunds::{Execute, RSync},
router_request_types::{BrowserInformation, ResponseId},
router_response_types::{PaymentsResponseData, RedirectForm, RefundsResponseData},
types,
};
use hyperswitch_interfaces::{
api,
consts::{NO_ERROR_CODE, NO_ERROR_MESSAGE},
errors,
};
use crate::{
types::{RefundsResponseRouterData, ResponseRouterData},
utils::{
self, BrowserInformationData, CardData, ForeignTryFrom, PaymentsAuthorizeRequestData,
RouterData as _,
},
};
fn get_zen_response(
response: ApiResponse,
status_code: u16,
) -> CustomResult<
(
enums::AttemptStatus,
Option<ErrorResponse>,
PaymentsResponseData,
),
errors::ConnectorError,
> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/zen/transformers.rs | crate: hyperswitch_connectors | connector: zen
use common_utils::{
errors::CustomResult,
ext_traits::{OptionExt, ValueExt},
pii::{self},
request::Method,
};
use hyperswitch_domain_models::{
payment_method_data::{
BankDebitData, BankRedirectData, BankTransferData, Card, CardRedirectData, GiftCardData,
PayLaterData, PaymentMethodData, VoucherData, WalletData,
},
router_data::{ConnectorAuthType, ErrorResponse, RouterData},
router_flow_types::refunds::{Execute, RSync},
router_request_types::{BrowserInformation, ResponseId},
router_response_types::{PaymentsResponseData, RedirectForm, RefundsResponseData},
types,
};
use crate::{
types::{RefundsResponseRouterData, ResponseRouterData},
utils::{
self, BrowserInformationData, CardData, ForeignTryFrom, PaymentsAuthorizeRequestData,
RouterData as _,
},
};
fn try_from(
item: &ZenRouterData<&types::PaymentsAuthorizeRouterData>,
) -> Result<Self, Self::Error> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/zen/transformers.rs | crate: hyperswitch_connectors | connector: zen
use common_utils::{
errors::CustomResult,
ext_traits::{OptionExt, ValueExt},
pii::{self},
request::Method,
};
use hyperswitch_domain_models::{
payment_method_data::{
BankDebitData, BankRedirectData, BankTransferData, Card, CardRedirectData, GiftCardData,
PayLaterData, PaymentMethodData, VoucherData, WalletData,
},
router_data::{ConnectorAuthType, ErrorResponse, RouterData},
router_flow_types::refunds::{Execute, RSync},
router_request_types::{BrowserInformation, ResponseId},
router_response_types::{PaymentsResponseData, RedirectForm, RefundsResponseData},
types,
};
use crate::{
types::{RefundsResponseRouterData, ResponseRouterData},
utils::{
self, BrowserInformationData, CardData, ForeignTryFrom, PaymentsAuthorizeRequestData,
RouterData as _,
},
};
fn get_browser_details(
browser_info: &BrowserInformation,
) -> CustomResult<ZenBrowserDetails, errors::ConnectorError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/zen/transformers.rs | crate: hyperswitch_connectors | connector: zen
/// Fields should be in alphabetical order
fn get_signature_data(
checkout_request: &CheckoutRequest,
) -> Result<String, errors::ConnectorError> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/zen/transformers.rs | crate: hyperswitch_connectors | connector: zen
use common_utils::{
errors::CustomResult,
ext_traits::{OptionExt, ValueExt},
pii::{self},
request::Method,
};
use hyperswitch_domain_models::{
payment_method_data::{
BankDebitData, BankRedirectData, BankTransferData, Card, CardRedirectData, GiftCardData,
PayLaterData, PaymentMethodData, VoucherData, WalletData,
},
router_data::{ConnectorAuthType, ErrorResponse, RouterData},
router_flow_types::refunds::{Execute, RSync},
router_request_types::{BrowserInformation, ResponseId},
router_response_types::{PaymentsResponseData, RedirectForm, RefundsResponseData},
types,
};
use masking::{ExposeInterface, PeekInterface, Secret};
use crate::{
types::{RefundsResponseRouterData, ResponseRouterData},
utils::{
self, BrowserInformationData, CardData, ForeignTryFrom, PaymentsAuthorizeRequestData,
RouterData as _,
},
};
fn try_from(
(item, wallet_data): (
&ZenRouterData<&types::PaymentsAuthorizeRouterData>,
&WalletData,
),
) -> Result<Self, Self::Error> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/zen/transformers.rs | crate: hyperswitch_connectors | connector: zen
use common_utils::{
errors::CustomResult,
ext_traits::{OptionExt, ValueExt},
pii::{self},
request::Method,
};
use hyperswitch_domain_models::{
payment_method_data::{
BankDebitData, BankRedirectData, BankTransferData, Card, CardRedirectData, GiftCardData,
PayLaterData, PaymentMethodData, VoucherData, WalletData,
},
router_data::{ConnectorAuthType, ErrorResponse, RouterData},
router_flow_types::refunds::{Execute, RSync},
router_request_types::{BrowserInformation, ResponseId},
router_response_types::{PaymentsResponseData, RedirectForm, RefundsResponseData},
types,
};
use crate::{
types::{RefundsResponseRouterData, ResponseRouterData},
utils::{
self, BrowserInformationData, CardData, ForeignTryFrom, PaymentsAuthorizeRequestData,
RouterData as _,
},
};
fn try_from(
value: (
&ZenRouterData<&types::PaymentsAuthorizeRouterData>,
&Box<BankTransferData>,
),
) -> Result<Self, Self::Error> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/zen/transformers.rs | crate: hyperswitch_connectors | connector: zen
use common_utils::{
errors::CustomResult,
ext_traits::{OptionExt, ValueExt},
pii::{self},
request::Method,
};
use hyperswitch_domain_models::{
payment_method_data::{
BankDebitData, BankRedirectData, BankTransferData, Card, CardRedirectData, GiftCardData,
PayLaterData, PaymentMethodData, VoucherData, WalletData,
},
router_data::{ConnectorAuthType, ErrorResponse, RouterData},
router_flow_types::refunds::{Execute, RSync},
router_request_types::{BrowserInformation, ResponseId},
router_response_types::{PaymentsResponseData, RedirectForm, RefundsResponseData},
types,
};
use crate::{
types::{RefundsResponseRouterData, ResponseRouterData},
utils::{
self, BrowserInformationData, CardData, ForeignTryFrom, PaymentsAuthorizeRequestData,
RouterData as _,
},
};
fn try_from(
value: (
&ZenRouterData<&types::PaymentsAuthorizeRouterData>,
&VoucherData,
),
) -> Result<Self, Self::Error> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/zen/transformers.rs | crate: hyperswitch_connectors | connector: zen
use hyperswitch_domain_models::{
payment_method_data::{
BankDebitData, BankRedirectData, BankTransferData, Card, CardRedirectData, GiftCardData,
PayLaterData, PaymentMethodData, VoucherData, WalletData,
},
router_data::{ConnectorAuthType, ErrorResponse, RouterData},
router_flow_types::refunds::{Execute, RSync},
router_request_types::{BrowserInformation, ResponseId},
router_response_types::{PaymentsResponseData, RedirectForm, RefundsResponseData},
types,
};
use crate::{
types::{RefundsResponseRouterData, ResponseRouterData},
utils::{
self, BrowserInformationData, CardData, ForeignTryFrom, PaymentsAuthorizeRequestData,
RouterData as _,
},
};
fn try_from(
value: (&ZenRouterData<&types::PaymentsAuthorizeRouterData>, &Card),
) -> Result<Self, Self::Error> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/zen/transformers.rs | crate: hyperswitch_connectors | connector: zen
use hyperswitch_domain_models::{
payment_method_data::{
BankDebitData, BankRedirectData, BankTransferData, Card, CardRedirectData, GiftCardData,
PayLaterData, PaymentMethodData, VoucherData, WalletData,
},
router_data::{ConnectorAuthType, ErrorResponse, RouterData},
router_flow_types::refunds::{Execute, RSync},
router_request_types::{BrowserInformation, ResponseId},
router_response_types::{PaymentsResponseData, RedirectForm, RefundsResponseData},
types,
};
use crate::{
types::{RefundsResponseRouterData, ResponseRouterData},
utils::{
self, BrowserInformationData, CardData, ForeignTryFrom, PaymentsAuthorizeRequestData,
RouterData as _,
},
};
fn try_from(item: &ZenRouterData<&types::RefundsRouterData<F>>) -> Result<Self, Self::Error> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/zen/transformers.rs | crate: hyperswitch_connectors | connector: zen
fn foreign_try_from(item: (ZenPaymentStatus, Option<ZenActions>)) -> Result<Self, Self::Error> {
{
ZenPaymentStatus::Authorized => Self::Pending,<|fim_suffix|>
<|fim_middle|>
ZenPaymentStatus::Canceled => Self::Voided,
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/zen/transformers.rs | crate: hyperswitch_connectors | connector: zen
lang: browser_info.get_language()?,
screen_height: screen_height.to_string(),
screen_width: screen_width.to_string(),
timezone: browser_info.get_time_zone()?.to_string(),
accept_header: browser_info.get_accept_header()?,
user_agent: browser_info.get_user_agent()?,
window_size,
})
}
impl TryFrom<&ZenRouterData<&types::PaymentsAuthorizeRouterData>> for ZenPaymentsRequest {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: &ZenRouterData<&types::PaymentsAuthorizeRouterData>,
) -> Result<Self, Self::Error> {
match &item.router_data.request.payment_method_data {
PaymentMethodData::Card(card) => Self::try_from((item, card)),
PaymentMethodData::Wallet(wallet_data) => Self::try_from((item, wallet_data)),
PaymentMethodData::Voucher(voucher_data) => Self::try_from((item, voucher_data)),
PaymentMethodData::BankTransfer(bank_transfer_data) => {
Self::try_from((item, bank_transfer_data))
}
PaymentMethodData::BankRedirect(bank_redirect_data) => {
Self::try_from(bank_redirect_data)
}
fn try_from(
item: &ZenRouterData<&types::PaymentsAuthorizeRouterData>,
) -> Result<Self, Self::Error> {
{
PaymentMethodData::Card(card) => Self::try_from((item, card)),<|fim_suffix|>
<|fim_middle|>
PaymentMethodData::Crypto(_)
| PaymentMethodData::MandatePayment
| PaymentMethodData::Reward
| PaymentMethodData::RealTimePayment(_)
| PaymentMethodData::MobilePayment(_)
| PaymentMethodData::Upi(_)
| PaymentMethodData::OpenBanking(_)
| PaymentMethodData::CardToken(_)
| PaymentMethodData::NetworkToken(_)
| PaymentMethodData::CardDetailsForNetworkTransactionId(_) => {
Err(errors::ConnectorError::NotImplemented(
utils::get_unimplemented_payment_method_error_message("Zen"),
))?
}
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/zen/transformers.rs | crate: hyperswitch_connectors | connector: zen
)?,
line_amount_total: (f64::from(data.quantity)
* utils::to_currency_base_unit_asf64(
data.amount.get_amount_as_i64(), // This should be changed to MinorUnit when we implement amount conversion for this connector. Additionally, the function get_amount_as_i64() should be avoided in the future.
item.request.currency,
)?)
.to_string(),
})
})
.collect::<Result<_, _>>()
}
fn get_browser_details(
browser_info: &BrowserInformation,
) -> CustomResult<ZenBrowserDetails, errors::ConnectorError> {
let screen_height = browser_info
.screen_height
.get_required_value("screen_height")
.change_context(errors::ConnectorError::MissingRequiredField {
field_name: "screen_height",
})?;
let screen_width = browser_info
.screen_width
.get_required_value("screen_width")
fn get_browser_details(
browser_info: &BrowserInformation,
) -> CustomResult<ZenBrowserDetails, errors::ConnectorError> {
{
(250, 400) => "01",<|fim_suffix|>
<|fim_middle|>
_ => "05",
}
} | ast_fragments |
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/zen/transformers.rs | crate: hyperswitch_connectors | connector: zen
use hyperswitch_domain_models::{
payment_method_data::{
BankDebitData, BankRedirectData, BankTransferData, Card, CardRedirectData, GiftCardData,
PayLaterData, PaymentMethodData, VoucherData, WalletData,
},
router_data::{ConnectorAuthType, ErrorResponse, RouterData},
router_flow_types::refunds::{Execute, RSync},
router_request_types::{BrowserInformation, ResponseId},
router_response_types::{PaymentsResponseData, RedirectForm, RefundsResponseData},
types,
};
use crate::{
types::{RefundsResponseRouterData, ResponseRouterData},
utils::{
self, BrowserInformationData, CardData, ForeignTryFrom, PaymentsAuthorizeRequestData,
RouterData as _,
},
};
fn try_from(item: &ZenRouterData<&types::RefundsRouterData<F>>) -> Result<Self, Self::Error> {
Ok(Self {
amount: item.amount.to_owned(),
transaction_id: item.router_data.request.connector_transaction_id.clone(),
currency: item.router_data.request.currency,
merchant_transaction_id: item.router_data.request.refund_id.clone(),
})
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/zen/transformers.rs | crate: hyperswitch_connectors | connector: zen
use common_enums::enums;
use hyperswitch_domain_models::{
payment_method_data::{
BankDebitData, BankRedirectData, BankTransferData, Card, CardRedirectData, GiftCardData,
PayLaterData, PaymentMethodData, VoucherData, WalletData,
},
router_data::{ConnectorAuthType, ErrorResponse, RouterData},
router_flow_types::refunds::{Execute, RSync},
router_request_types::{BrowserInformation, ResponseId},
router_response_types::{PaymentsResponseData, RedirectForm, RefundsResponseData},
types,
};
use crate::{
types::{RefundsResponseRouterData, ResponseRouterData},
utils::{
self, BrowserInformationData, CardData, ForeignTryFrom, PaymentsAuthorizeRequestData,
RouterData as _,
},
};
fn try_from(
value: ResponseRouterData<F, CheckoutResponse, T, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/zen/transformers.rs | crate: hyperswitch_connectors | connector: zen
use hyperswitch_domain_models::{
payment_method_data::{
BankDebitData, BankRedirectData, BankTransferData, Card, CardRedirectData, GiftCardData,
PayLaterData, PaymentMethodData, VoucherData, WalletData,
},
router_data::{ConnectorAuthType, ErrorResponse, RouterData},
router_flow_types::refunds::{Execute, RSync},
router_request_types::{BrowserInformation, ResponseId},
router_response_types::{PaymentsResponseData, RedirectForm, RefundsResponseData},
types,
};
use crate::{
types::{RefundsResponseRouterData, ResponseRouterData},
utils::{
self, BrowserInformationData, CardData, ForeignTryFrom, PaymentsAuthorizeRequestData,
RouterData as _,
},
};
fn try_from(
value: ResponseRouterData<F, ApiResponse, T, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/zen/transformers.rs | crate: hyperswitch_connectors | connector: zen
use hyperswitch_domain_models::{
payment_method_data::{
BankDebitData, BankRedirectData, BankTransferData, Card, CardRedirectData, GiftCardData,
PayLaterData, PaymentMethodData, VoucherData, WalletData,
},
router_data::{ConnectorAuthType, ErrorResponse, RouterData},
router_flow_types::refunds::{Execute, RSync},
router_request_types::{BrowserInformation, ResponseId},
router_response_types::{PaymentsResponseData, RedirectForm, RefundsResponseData},
types,
};
use crate::{
types::{RefundsResponseRouterData, ResponseRouterData},
utils::{
self, BrowserInformationData, CardData, ForeignTryFrom, PaymentsAuthorizeRequestData,
RouterData as _,
},
};
fn try_from(
item: ResponseRouterData<F, ZenPaymentsResponse, T, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/zen/transformers.rs | crate: hyperswitch_connectors | connector: zen
fn foreign_try_from(item: (ZenPaymentStatus, Option<ZenActions>)) -> Result<Self, Self::Error> {
let (item_txn_status, item_action_status) = item;
Ok(match item_txn_status {
// Payment has been authorized at connector end, They will send webhook when it gets accepted
ZenPaymentStatus::Authorized => Self::Pending,
ZenPaymentStatus::Accepted => Self::Charged,
ZenPaymentStatus::Pending => {
item_action_status.map_or(Self::Pending, |action| match action {
ZenActions::Redirect => Self::AuthenticationPending,
})
}
ZenPaymentStatus::Rejected => Self::Failure,
ZenPaymentStatus::Canceled => Self::Voided,
})
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/zen/transformers.rs | crate: hyperswitch_connectors | connector: zen
use hyperswitch_domain_models::{
payment_method_data::{
BankDebitData, BankRedirectData, BankTransferData, Card, CardRedirectData, GiftCardData,
PayLaterData, PaymentMethodData, VoucherData, WalletData,
},
router_data::{ConnectorAuthType, ErrorResponse, RouterData},
router_flow_types::refunds::{Execute, RSync},
router_request_types::{BrowserInformation, ResponseId},
router_response_types::{PaymentsResponseData, RedirectForm, RefundsResponseData},
types,
};
use crate::{
types::{RefundsResponseRouterData, ResponseRouterData},
utils::{
self, BrowserInformationData, CardData, ForeignTryFrom, PaymentsAuthorizeRequestData,
RouterData as _,
},
};
fn try_from(value: &GiftCardData) -> Result<Self, Self::Error> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/zen/transformers.rs | crate: hyperswitch_connectors | connector: zen
use hyperswitch_domain_models::{
payment_method_data::{
BankDebitData, BankRedirectData, BankTransferData, Card, CardRedirectData, GiftCardData,
PayLaterData, PaymentMethodData, VoucherData, WalletData,
},
router_data::{ConnectorAuthType, ErrorResponse, RouterData},
router_flow_types::refunds::{Execute, RSync},
router_request_types::{BrowserInformation, ResponseId},
router_response_types::{PaymentsResponseData, RedirectForm, RefundsResponseData},
types,
};
use crate::{
types::{RefundsResponseRouterData, ResponseRouterData},
utils::{
self, BrowserInformationData, CardData, ForeignTryFrom, PaymentsAuthorizeRequestData,
RouterData as _,
},
};
fn try_from(value: &CardRedirectData) -> Result<Self, Self::Error> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/zen/transformers.rs | crate: hyperswitch_connectors | connector: zen
use hyperswitch_domain_models::{
payment_method_data::{
BankDebitData, BankRedirectData, BankTransferData, Card, CardRedirectData, GiftCardData,
PayLaterData, PaymentMethodData, VoucherData, WalletData,
},
router_data::{ConnectorAuthType, ErrorResponse, RouterData},
router_flow_types::refunds::{Execute, RSync},
router_request_types::{BrowserInformation, ResponseId},
router_response_types::{PaymentsResponseData, RedirectForm, RefundsResponseData},
types,
};
use crate::{
types::{RefundsResponseRouterData, ResponseRouterData},
utils::{
self, BrowserInformationData, CardData, ForeignTryFrom, PaymentsAuthorizeRequestData,
RouterData as _,
},
};
fn try_from(value: &BankDebitData) -> Result<Self, Self::Error> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/zen/transformers.rs | crate: hyperswitch_connectors | connector: zen
use hyperswitch_domain_models::{
payment_method_data::{
BankDebitData, BankRedirectData, BankTransferData, Card, CardRedirectData, GiftCardData,
PayLaterData, PaymentMethodData, VoucherData, WalletData,
},
router_data::{ConnectorAuthType, ErrorResponse, RouterData},
router_flow_types::refunds::{Execute, RSync},
router_request_types::{BrowserInformation, ResponseId},
router_response_types::{PaymentsResponseData, RedirectForm, RefundsResponseData},
types,
};
use crate::{
types::{RefundsResponseRouterData, ResponseRouterData},
utils::{
self, BrowserInformationData, CardData, ForeignTryFrom, PaymentsAuthorizeRequestData,
RouterData as _,
},
};
fn try_from(value: &PayLaterData) -> Result<Self, Self::Error> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/zen/transformers.rs | crate: hyperswitch_connectors | connector: zen
use common_utils::{
errors::CustomResult,
ext_traits::{OptionExt, ValueExt},
pii::{self},
request::Method,
};
use error_stack::ResultExt;
use hyperswitch_domain_models::{
payment_method_data::{
BankDebitData, BankRedirectData, BankTransferData, Card, CardRedirectData, GiftCardData,
PayLaterData, PaymentMethodData, VoucherData, WalletData,
},
router_data::{ConnectorAuthType, ErrorResponse, RouterData},
router_flow_types::refunds::{Execute, RSync},
router_request_types::{BrowserInformation, ResponseId},
router_response_types::{PaymentsResponseData, RedirectForm, RefundsResponseData},
types,
};
use crate::{
types::{RefundsResponseRouterData, ResponseRouterData},
utils::{
self, BrowserInformationData, CardData, ForeignTryFrom, PaymentsAuthorizeRequestData,
RouterData as _,
},
};
fn get_item_object(
item: &types::PaymentsAuthorizeRouterData,
) -> Result<Vec<ZenItemObject>, error_stack::Report<errors::ConnectorError>> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/zen/transformers.rs | crate: hyperswitch_connectors | connector: zen
use common_utils::{
errors::CustomResult,
ext_traits::{OptionExt, ValueExt},
pii::{self},
request::Method,
};
use error_stack::ResultExt;
use hyperswitch_domain_models::{
payment_method_data::{
BankDebitData, BankRedirectData, BankTransferData, Card, CardRedirectData, GiftCardData,
PayLaterData, PaymentMethodData, VoucherData, WalletData,
},
router_data::{ConnectorAuthType, ErrorResponse, RouterData},
router_flow_types::refunds::{Execute, RSync},
router_request_types::{BrowserInformation, ResponseId},
router_response_types::{PaymentsResponseData, RedirectForm, RefundsResponseData},
types,
};
use masking::{ExposeInterface, PeekInterface, Secret};
use crate::{
types::{RefundsResponseRouterData, ResponseRouterData},
utils::{
self, BrowserInformationData, CardData, ForeignTryFrom, PaymentsAuthorizeRequestData,
RouterData as _,
},
};
fn get_customer(
item: &types::PaymentsAuthorizeRouterData,
ip: Secret<String, pii::IpAddress>,
) -> Result<ZenCustomerDetails, error_stack::Report<errors::ConnectorError>> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/zen/transformers.rs | crate: hyperswitch_connectors | connector: zen
use error_stack::ResultExt;
use masking::{ExposeInterface, PeekInterface, Secret};
fn get_checkout_signature(
checkout_request: &CheckoutRequest,
session: &WalletSessionData,
) -> Result<Secret<String>, error_stack::Report<errors::ConnectorError>> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/redsys/transformers.rs | crate: hyperswitch_connectors | connector: redsys
use common_enums::enums;
use hyperswitch_domain_models::{
address::Address,
payment_method_data::PaymentMethodData,
router_data::{ConnectorAuthType, ErrorResponse, RouterData},
router_flow_types::refunds::{Execute, RSync},
router_request_types::{
BrowserInformation, CompleteAuthorizeData, PaymentsAuthorizeData, PaymentsCancelData,
PaymentsCaptureData, PaymentsPreProcessingData, PaymentsSyncData, ResponseId,
},
router_response_types::{PaymentsResponseData, RedirectForm, RefundsResponseData},
types::{
PaymentsAuthorizeRouterData, PaymentsCancelRouterData, PaymentsCaptureRouterData,
PaymentsCompleteAuthorizeRouterData, PaymentsPreProcessingRouterData,
PaymentsSyncRouterData, RefundSyncRouterData, RefundsRouterData,
},
};
use crate::{
types::{RefundsResponseRouterData, ResponseRouterData},
utils::{
self as connector_utils, AddressDetailsData, BrowserInformationData, CardData,
PaymentsAuthorizeRequestData, PaymentsCompleteAuthorizeRequestData,
PaymentsPreProcessingRequestData, RouterData as _,
},
};
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: RefundsResponseRouterData<RSync, RedsysSyncResponse>,
) -> Result<Self, Self::Error> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/redsys/transformers.rs | crate: hyperswitch_connectors | connector: redsys | op: sync
use common_utils::{
consts::BASE64_ENGINE,
crypto::{EncodeMessage, SignMessage},
ext_traits::{Encode, ValueExt},
types::StringMinorUnit,
};
type Error = error_stack::Report<errors::ConnectorError>;
fn construct_sync_request(
order_id: String,
transaction_type: String,
auth: RedsysAuthType,
) -> Result<Vec<u8>, Error> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/redsys/transformers.rs | crate: hyperswitch_connectors | connector: redsys
use common_enums::enums;
type Error = error_stack::Report<errors::ConnectorError>;
fn get_transaction_type(
status: enums::AttemptStatus,
capture_method: Option<enums::CaptureMethod>,
) -> Result<String, errors::ConnectorError> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/redsys/transformers.rs | crate: hyperswitch_connectors | connector: redsys
use common_enums::enums;
use hyperswitch_domain_models::{
address::Address,
payment_method_data::PaymentMethodData,
router_data::{ConnectorAuthType, ErrorResponse, RouterData},
router_flow_types::refunds::{Execute, RSync},
router_request_types::{
BrowserInformation, CompleteAuthorizeData, PaymentsAuthorizeData, PaymentsCancelData,
PaymentsCaptureData, PaymentsPreProcessingData, PaymentsSyncData, ResponseId,
},
router_response_types::{PaymentsResponseData, RedirectForm, RefundsResponseData},
types::{
PaymentsAuthorizeRouterData, PaymentsCancelRouterData, PaymentsCaptureRouterData,
PaymentsCompleteAuthorizeRouterData, PaymentsPreProcessingRouterData,
PaymentsSyncRouterData, RefundSyncRouterData, RefundsRouterData,
},
};
use crate::{
types::{RefundsResponseRouterData, ResponseRouterData},
utils::{
self as connector_utils, AddressDetailsData, BrowserInformationData, CardData,
PaymentsAuthorizeRequestData, PaymentsCompleteAuthorizeRequestData,
PaymentsPreProcessingRequestData, RouterData as _,
},
};
type Error = error_stack::Report<errors::ConnectorError>;
fn get_payments_response(
redsys_payments_response: RedsysPaymentsResponse,
capture_method: Option<enums::CaptureMethod>,
connector_metadata: Option<josekit::Value>,
http_code: u16,
) -> Result<
(
Result<PaymentsResponseData, ErrorResponse>,
enums::AttemptStatus,
),
Error,
> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/redsys/transformers.rs | crate: hyperswitch_connectors | connector: redsys
use common_enums::enums;
use hyperswitch_domain_models::{
address::Address,
payment_method_data::PaymentMethodData,
router_data::{ConnectorAuthType, ErrorResponse, RouterData},
router_flow_types::refunds::{Execute, RSync},
router_request_types::{
BrowserInformation, CompleteAuthorizeData, PaymentsAuthorizeData, PaymentsCancelData,
PaymentsCaptureData, PaymentsPreProcessingData, PaymentsSyncData, ResponseId,
},
router_response_types::{PaymentsResponseData, RedirectForm, RefundsResponseData},
types::{
PaymentsAuthorizeRouterData, PaymentsCancelRouterData, PaymentsCaptureRouterData,
PaymentsCompleteAuthorizeRouterData, PaymentsPreProcessingRouterData,
PaymentsSyncRouterData, RefundSyncRouterData, RefundsRouterData,
},
};
use crate::{
types::{RefundsResponseRouterData, ResponseRouterData},
utils::{
self as connector_utils, AddressDetailsData, BrowserInformationData, CardData,
PaymentsAuthorizeRequestData, PaymentsCompleteAuthorizeRequestData,
PaymentsPreProcessingRequestData, RouterData as _,
},
};
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: RefundsResponseRouterData<Execute, RedsysResponse>,
) -> Result<Self, Self::Error> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/redsys/transformers.rs | crate: hyperswitch_connectors | connector: redsys
use common_enums::enums;
use hyperswitch_domain_models::{
address::Address,
payment_method_data::PaymentMethodData,
router_data::{ConnectorAuthType, ErrorResponse, RouterData},
router_flow_types::refunds::{Execute, RSync},
router_request_types::{
BrowserInformation, CompleteAuthorizeData, PaymentsAuthorizeData, PaymentsCancelData,
PaymentsCaptureData, PaymentsPreProcessingData, PaymentsSyncData, ResponseId,
},
router_response_types::{PaymentsResponseData, RedirectForm, RefundsResponseData},
types::{
PaymentsAuthorizeRouterData, PaymentsCancelRouterData, PaymentsCaptureRouterData,
PaymentsCompleteAuthorizeRouterData, PaymentsPreProcessingRouterData,
PaymentsSyncRouterData, RefundSyncRouterData, RefundsRouterData,
},
};
use crate::{
types::{RefundsResponseRouterData, ResponseRouterData},
utils::{
self as connector_utils, AddressDetailsData, BrowserInformationData, CardData,
PaymentsAuthorizeRequestData, PaymentsCompleteAuthorizeRequestData,
PaymentsPreProcessingRequestData, RouterData as _,
},
};
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: ResponseRouterData<F, RedsysResponse, PaymentsCancelData, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/redsys/transformers.rs | crate: hyperswitch_connectors | connector: redsys
use common_enums::enums;
use hyperswitch_domain_models::{
address::Address,
payment_method_data::PaymentMethodData,
router_data::{ConnectorAuthType, ErrorResponse, RouterData},
router_flow_types::refunds::{Execute, RSync},
router_request_types::{
BrowserInformation, CompleteAuthorizeData, PaymentsAuthorizeData, PaymentsCancelData,
PaymentsCaptureData, PaymentsPreProcessingData, PaymentsSyncData, ResponseId,
},
router_response_types::{PaymentsResponseData, RedirectForm, RefundsResponseData},
types::{
PaymentsAuthorizeRouterData, PaymentsCancelRouterData, PaymentsCaptureRouterData,
PaymentsCompleteAuthorizeRouterData, PaymentsPreProcessingRouterData,
PaymentsSyncRouterData, RefundSyncRouterData, RefundsRouterData,
},
};
use crate::{
types::{RefundsResponseRouterData, ResponseRouterData},
utils::{
self as connector_utils, AddressDetailsData, BrowserInformationData, CardData,
PaymentsAuthorizeRequestData, PaymentsCompleteAuthorizeRequestData,
PaymentsPreProcessingRequestData, RouterData as _,
},
};
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: ResponseRouterData<F, RedsysResponse, PaymentsCaptureData, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
let (response, status) = match item.response {
RedsysResponse::RedsysResponse(redsys_transaction_response) => {
let response_data: RedsysOperationsResponse = to_connector_response_data(
&redsys_transaction_response
.ds_merchant_parameters
.clone()
.expose(),
)?;
let status = get_redsys_attempt_status(response_data.ds_response.clone(), None)?;
let response = if connector_utils::is_payment_failure(status) {
Err(ErrorResponse {
code: response_data.ds_response.0.clone(),
message: response_data.ds_response.0.clone(),
reason: Some(response_data.ds_response.0.clone()),
status_code: item.http_code,
attempt_status: None,
connector_transaction_id: Some(response_data.ds_order.clone()),
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
})
} else {
Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(
response_data.ds_order.clone(),
),
redirection_data: Box::new(None),
mandate_reference: Box::new(None),
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: Some(response_data.ds_order.clone()),
incremental_authorization_allowed: None,
charges: None,
})
};
(response, status)
}
RedsysResponse::RedsysErrorResponse(error_response) => {
let response = Err(ErrorResponse {
code: error_response.error_code.clone(),
message: error_response.error_code.clone(),
reason: Some(error_response.error_code.clone()),
status_code: item.http_code,
attempt_status: None,
connector_transaction_id: None,
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
});
(response, enums::AttemptStatus::Failure)
}
};
Ok(Self {
status,
response,
..item.data
})
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/redsys/transformers.rs | crate: hyperswitch_connectors | connector: redsys
use common_enums::enums;
use hyperswitch_domain_models::{
address::Address,
payment_method_data::PaymentMethodData,
router_data::{ConnectorAuthType, ErrorResponse, RouterData},
router_flow_types::refunds::{Execute, RSync},
router_request_types::{
BrowserInformation, CompleteAuthorizeData, PaymentsAuthorizeData, PaymentsCancelData,
PaymentsCaptureData, PaymentsPreProcessingData, PaymentsSyncData, ResponseId,
},
router_response_types::{PaymentsResponseData, RedirectForm, RefundsResponseData},
types::{
PaymentsAuthorizeRouterData, PaymentsCancelRouterData, PaymentsCaptureRouterData,
PaymentsCompleteAuthorizeRouterData, PaymentsPreProcessingRouterData,
PaymentsSyncRouterData, RefundSyncRouterData, RefundsRouterData,
},
};
use crate::{
types::{RefundsResponseRouterData, ResponseRouterData},
utils::{
self as connector_utils, AddressDetailsData, BrowserInformationData, CardData,
PaymentsAuthorizeRequestData, PaymentsCompleteAuthorizeRequestData,
PaymentsPreProcessingRequestData, RouterData as _,
},
};
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: ResponseRouterData<F, RedsysResponse, CompleteAuthorizeData, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/redsys/transformers.rs | crate: hyperswitch_connectors | connector: redsys
use common_enums::enums;
use hyperswitch_domain_models::{
address::Address,
payment_method_data::PaymentMethodData,
router_data::{ConnectorAuthType, ErrorResponse, RouterData},
router_flow_types::refunds::{Execute, RSync},
router_request_types::{
BrowserInformation, CompleteAuthorizeData, PaymentsAuthorizeData, PaymentsCancelData,
PaymentsCaptureData, PaymentsPreProcessingData, PaymentsSyncData, ResponseId,
},
router_response_types::{PaymentsResponseData, RedirectForm, RefundsResponseData},
types::{
PaymentsAuthorizeRouterData, PaymentsCancelRouterData, PaymentsCaptureRouterData,
PaymentsCompleteAuthorizeRouterData, PaymentsPreProcessingRouterData,
PaymentsSyncRouterData, RefundSyncRouterData, RefundsRouterData,
},
};
use crate::{
types::{RefundsResponseRouterData, ResponseRouterData},
utils::{
self as connector_utils, AddressDetailsData, BrowserInformationData, CardData,
PaymentsAuthorizeRequestData, PaymentsCompleteAuthorizeRequestData,
PaymentsPreProcessingRequestData, RouterData as _,
},
};
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: ResponseRouterData<F, RedsysResponse, PaymentsAuthorizeData, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/redsys/transformers.rs | crate: hyperswitch_connectors | connector: redsys
use hyperswitch_domain_models::{
address::Address,
payment_method_data::PaymentMethodData,
router_data::{ConnectorAuthType, ErrorResponse, RouterData},
router_flow_types::refunds::{Execute, RSync},
router_request_types::{
BrowserInformation, CompleteAuthorizeData, PaymentsAuthorizeData, PaymentsCancelData,
PaymentsCaptureData, PaymentsPreProcessingData, PaymentsSyncData, ResponseId,
},
router_response_types::{PaymentsResponseData, RedirectForm, RefundsResponseData},
types::{
PaymentsAuthorizeRouterData, PaymentsCancelRouterData, PaymentsCaptureRouterData,
PaymentsCompleteAuthorizeRouterData, PaymentsPreProcessingRouterData,
PaymentsSyncRouterData, RefundSyncRouterData, RefundsRouterData,
},
};
use crate::{
types::{RefundsResponseRouterData, ResponseRouterData},
utils::{
self as connector_utils, AddressDetailsData, BrowserInformationData, CardData,
PaymentsAuthorizeRequestData, PaymentsCompleteAuthorizeRequestData,
PaymentsPreProcessingRequestData, RouterData as _,
},
};
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: &RedsysRouterData<&PaymentsAuthorizeRouterData>,
) -> Result<Self, Self::Error> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/redsys/transformers.rs | crate: hyperswitch_connectors | connector: redsys
use common_enums::enums;
use error_stack::ResultExt;
use crate::{
types::{RefundsResponseRouterData, ResponseRouterData},
utils::{
self as connector_utils, AddressDetailsData, BrowserInformationData, CardData,
PaymentsAuthorizeRequestData, PaymentsCompleteAuthorizeRequestData,
PaymentsPreProcessingRequestData, RouterData as _,
},
};
type Error = error_stack::Report<errors::ConnectorError>;
fn get_redsys_attempt_status(
ds_response: DsResponse,
capture_method: Option<enums::CaptureMethod>,
) -> Result<enums::AttemptStatus, error_stack::Report<errors::ConnectorError>> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/redsys/transformers.rs | crate: hyperswitch_connectors | connector: redsys
use common_enums::enums;
use common_utils::{
consts::BASE64_ENGINE,
crypto::{EncodeMessage, SignMessage},
ext_traits::{Encode, ValueExt},
types::StringMinorUnit,
};
use error_stack::ResultExt;
type Error = error_stack::Report<errors::ConnectorError>;
fn des_encrypt(
message: &str,
key: &str,
) -> Result<Vec<u8>, error_stack::Report<errors::ConnectorError>> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/redsys/transformers.rs | crate: hyperswitch_connectors | connector: redsys
use common_enums::enums;
use error_stack::ResultExt;
use hyperswitch_domain_models::{
address::Address,
payment_method_data::PaymentMethodData,
router_data::{ConnectorAuthType, ErrorResponse, RouterData},
router_flow_types::refunds::{Execute, RSync},
router_request_types::{
BrowserInformation, CompleteAuthorizeData, PaymentsAuthorizeData, PaymentsCancelData,
PaymentsCaptureData, PaymentsPreProcessingData, PaymentsSyncData, ResponseId,
},
router_response_types::{PaymentsResponseData, RedirectForm, RefundsResponseData},
types::{
PaymentsAuthorizeRouterData, PaymentsCancelRouterData, PaymentsCaptureRouterData,
PaymentsCompleteAuthorizeRouterData, PaymentsPreProcessingRouterData,
PaymentsSyncRouterData, RefundSyncRouterData, RefundsRouterData,
},
};
use crate::{
types::{RefundsResponseRouterData, ResponseRouterData},
utils::{
self as connector_utils, AddressDetailsData, BrowserInformationData, CardData,
PaymentsAuthorizeRequestData, PaymentsCompleteAuthorizeRequestData,
PaymentsPreProcessingRequestData, RouterData as _,
},
};
type Error = error_stack::Report<errors::ConnectorError>;
fn handle_threeds_invoke_exempt<F>(
item: ResponseRouterData<F, RedsysResponse, PaymentsPreProcessingData, PaymentsResponseData>,
response_data: &RedsysPaymentsResponse,
three_d_s_server_trans_i_d: String,
protocol_version: String,
) -> Result<
RouterData<F, PaymentsPreProcessingData, PaymentsResponseData>,
error_stack::Report<errors::ConnectorError>,
> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/redsys/transformers.rs | crate: hyperswitch_connectors | connector: redsys
use common_enums::enums;
use common_utils::{
consts::BASE64_ENGINE,
crypto::{EncodeMessage, SignMessage},
ext_traits::{Encode, ValueExt},
types::StringMinorUnit,
};
use error_stack::ResultExt;
use hyperswitch_domain_models::{
address::Address,
payment_method_data::PaymentMethodData,
router_data::{ConnectorAuthType, ErrorResponse, RouterData},
router_flow_types::refunds::{Execute, RSync},
router_request_types::{
BrowserInformation, CompleteAuthorizeData, PaymentsAuthorizeData, PaymentsCancelData,
PaymentsCaptureData, PaymentsPreProcessingData, PaymentsSyncData, ResponseId,
},
router_response_types::{PaymentsResponseData, RedirectForm, RefundsResponseData},
types::{
PaymentsAuthorizeRouterData, PaymentsCancelRouterData, PaymentsCaptureRouterData,
PaymentsCompleteAuthorizeRouterData, PaymentsPreProcessingRouterData,
PaymentsSyncRouterData, RefundSyncRouterData, RefundsRouterData,
},
};
use crate::{
types::{RefundsResponseRouterData, ResponseRouterData},
utils::{
self as connector_utils, AddressDetailsData, BrowserInformationData, CardData,
PaymentsAuthorizeRequestData, PaymentsCompleteAuthorizeRequestData,
PaymentsPreProcessingRequestData, RouterData as _,
},
};
type Error = error_stack::Report<errors::ConnectorError>;
fn handle_threeds_invoke<F>(
item: ResponseRouterData<F, RedsysResponse, PaymentsPreProcessingData, PaymentsResponseData>,
response_data: &RedsysPaymentsResponse,
three_d_s_method_u_r_l: String,
three_d_s_server_trans_i_d: String,
protocol_version: String,
) -> Result<
RouterData<F, PaymentsPreProcessingData, PaymentsResponseData>,
error_stack::Report<errors::ConnectorError>,
> {
<|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.