id stringlengths 20 153 | type stringclasses 1
value | granularity stringclasses 14
values | content stringlengths 16 84.3k | metadata dict |
|---|---|---|---|---|
connector-service_mini_connector-integration_2054780185909450401_2 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/worldpayvantiv/transformers.rs
enhanced_data: None,
processing_instructions: None,
cardholder_authentication: None,
};
(Some(authorization), None)
};
let cnp_request = CnpOnlineRequest {
version: worldpayvantiv_constants::WORLDPAYVANTIV_VERSION.to_string(),
xmlns: worldpayvantiv_constants::XMLNS.to_string(),
merchant_id: auth.merchant_id,
authentication,
authorization,
sale,
capture: None,
auth_reversal: None,
void: None,
credit: None,
};
Ok(WorldpayvantivPaymentsRequest { cnp_request })
}
}
pub(super) mod worldpayvantiv_constants {
pub const WORLDPAYVANTIV_VERSION: &str = "12.23";
#[allow(dead_code)]
pub const XML_VERSION: &str = "1.0";
#[allow(dead_code)]
pub const XML_ENCODING: &str = "UTF-8";
#[allow(dead_code)]
pub const XML_STANDALONE: &str = "yes";
pub const XMLNS: &str = "http://www.vantivcnp.com/schema";
pub const MAX_PAYMENT_REFERENCE_ID_LENGTH: usize = 28;
#[allow(dead_code)]
pub const XML_CHARGEBACK: &str = "http://www.vantivcnp.com/chargebacks";
#[allow(dead_code)]
pub const MAC_FIELD_NUMBER: &str = "39";
#[allow(dead_code)]
pub const CUSTOMER_ID_MAX_LENGTH: usize = 50;
#[allow(dead_code)]
pub const CUSTOMER_REFERENCE_MAX_LENGTH: usize = 17;
}
#[derive(Debug, Clone)]
pub struct WorldpayvantivAuthType {
pub user: Secret<String>,
pub password: Secret<String>,
pub merchant_id: Secret<String>,
}
impl TryFrom<&ConnectorAuthType> for WorldpayvantivAuthType {
type Error = error_stack::Report<ConnectorError>;
fn try_from(auth_type: &ConnectorAuthType) -> Result<Self, Self::Error> {
match auth_type {
ConnectorAuthType::SignatureKey {
api_key,
api_secret,
key1,
} => Ok(Self {
user: api_key.to_owned(),
password: api_secret.to_owned(),
merchant_id: key1.to_owned(),
}),
_ => Err(ConnectorError::FailedToObtainAuthType.into()),
}
}
}
#[derive(Debug, Serialize)]
#[serde(rename = "cnpOnlineRequest", rename_all = "camelCase")]
pub struct CnpOnlineRequest<T: PaymentMethodDataTypes> {
#[serde(rename = "@version")]
pub version: String,
#[serde(rename = "@xmlns")]
pub xmlns: String,
#[serde(rename = "@merchantId")]
pub merchant_id: Secret<String>,
pub authentication: Authentication,
#[serde(skip_serializing_if = "Option::is_none")]
pub authorization: Option<Authorization<T>>,
#[serde(skip_serializing_if = "Option::is_none")]
pub sale: Option<Sale<T>>,
#[serde(skip_serializing_if = "Option::is_none")]
pub capture: Option<CaptureRequest>,
#[serde(skip_serializing_if = "Option::is_none")]
pub auth_reversal: Option<AuthReversal>,
#[serde(skip_serializing_if = "Option::is_none")]
pub void: Option<VoidRequest>,
#[serde(skip_serializing_if = "Option::is_none")]
pub credit: Option<RefundRequest>,
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct Authentication {
pub user: Secret<String>,
pub password: Secret<String>,
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct Authorization<T: PaymentMethodDataTypes> {
#[serde(rename = "@id")]
pub id: String,
#[serde(rename = "@reportGroup")]
pub report_group: String,
#[serde(rename = "@customerId", skip_serializing_if = "Option::is_none")]
pub customer_id: Option<Secret<String>>,
pub order_id: String,
pub amount: MinorUnit,
pub order_source: OrderSource,
#[serde(skip_serializing_if = "Option::is_none")]
pub bill_to_address: Option<BillToAddress>,
#[serde(skip_serializing_if = "Option::is_none")]
pub ship_to_address: Option<ShipToAddress>,
#[serde(flatten)]
pub payment_info: PaymentInfo<T>,
#[serde(skip_serializing_if = "Option::is_none")]
pub enhanced_data: Option<EnhancedData>,
#[serde(skip_serializing_if = "Option::is_none")]
pub processing_instructions: Option<ProcessingInstructions>,
#[serde(skip_serializing_if = "Option::is_none")]
| {
"chunk": 2,
"crate": "connector-integration",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_mini_connector-integration_2054780185909450401_3 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/worldpayvantiv/transformers.rs
pub cardholder_authentication: Option<CardholderAuthentication>,
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct Sale<T: PaymentMethodDataTypes> {
#[serde(rename = "@id")]
pub id: String,
#[serde(rename = "@reportGroup")]
pub report_group: String,
#[serde(rename = "@customerId", skip_serializing_if = "Option::is_none")]
pub customer_id: Option<Secret<String>>,
pub order_id: String,
pub amount: MinorUnit,
pub order_source: OrderSource,
#[serde(skip_serializing_if = "Option::is_none")]
pub bill_to_address: Option<BillToAddress>,
#[serde(skip_serializing_if = "Option::is_none")]
pub ship_to_address: Option<ShipToAddress>,
#[serde(flatten)]
pub payment_info: PaymentInfo<T>,
#[serde(skip_serializing_if = "Option::is_none")]
pub enhanced_data: Option<EnhancedData>,
#[serde(skip_serializing_if = "Option::is_none")]
pub processing_instructions: Option<ProcessingInstructions>,
#[serde(skip_serializing_if = "Option::is_none")]
pub cardholder_authentication: Option<CardholderAuthentication>,
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct CaptureRequest {
#[serde(rename = "@id")]
pub id: String,
#[serde(rename = "@reportGroup")]
pub report_group: String,
pub cnp_txn_id: String,
pub amount: MinorUnit,
#[serde(skip_serializing_if = "Option::is_none")]
pub enhanced_data: Option<EnhancedData>,
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct AuthReversal {
#[serde(rename = "@id")]
pub id: String,
#[serde(rename = "@reportGroup")]
pub report_group: String,
pub cnp_txn_id: String,
#[serde(skip_serializing_if = "Option::is_none")]
pub amount: Option<MinorUnit>,
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct VoidRequest {
#[serde(rename = "@id")]
pub id: String,
#[serde(rename = "@reportGroup")]
pub report_group: String,
pub cnp_txn_id: String,
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct RefundRequest {
#[serde(rename = "@id")]
pub id: String,
#[serde(rename = "@reportGroup")]
pub report_group: String,
pub cnp_txn_id: String,
pub amount: MinorUnit,
}
#[derive(Debug, Serialize)]
#[serde(untagged)]
pub enum PaymentInfo<T: PaymentMethodDataTypes> {
Card(CardData<T>),
Token(TokenData),
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct CardData<T: PaymentMethodDataTypes> {
pub card: WorldpayvantivCardData<T>,
#[serde(skip_serializing_if = "Option::is_none")]
pub processing_type: Option<VantivProcessingType>,
#[serde(skip_serializing_if = "Option::is_none")]
pub network_transaction_id: Option<Secret<String>>,
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct TokenData {
pub token: TokenizationData,
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct WorldpayvantivCardData<T: PaymentMethodDataTypes> {
#[serde(rename = "type")]
pub card_type: WorldpayvativCardType,
pub number: RawCardNumber<T>,
pub exp_date: Secret<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub card_validation_num: Option<Secret<String>>,
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct TokenizationData {
pub cnp_token: Secret<String>,
pub exp_date: Secret<String>,
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "PascalCase")]
pub enum VantivProcessingType {
InitialCOF,
MerchantInitiatedCOF,
}
#[derive(Debug, Serialize, Deserialize, PartialEq, Clone)]
pub enum WorldpayvativCardType {
#[serde(rename = "VI")]
Visa,
#[serde(rename = "MC")]
MasterCard,
#[serde(rename = "AX")]
AmericanExpress,
#[serde(rename = "DI")]
Discover,
#[serde(rename = "DC")]
DinersClub,
#[serde(rename = "JC")]
JCB,
#[serde(rename = "UP")]
UnionPay,
}
impl TryFrom<common_enums::CardNetwork> for WorldpayvativCardType {
type Error = error_stack::Report<ConnectorError>;
fn try_from(card_network: common_enums::CardNetwork) -> Result<Self, Self::Error> {
match card_network {
common_enums::CardNetwork::Visa => Ok(Self::Visa),
common_enums::CardNetwork::Mastercard => Ok(Self::MasterCard),
| {
"chunk": 3,
"crate": "connector-integration",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_mini_connector-integration_2054780185909450401_4 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/worldpayvantiv/transformers.rs
common_enums::CardNetwork::AmericanExpress => Ok(Self::AmericanExpress),
common_enums::CardNetwork::Discover => Ok(Self::Discover),
common_enums::CardNetwork::DinersClub => Ok(Self::DinersClub),
common_enums::CardNetwork::JCB => Ok(Self::JCB),
common_enums::CardNetwork::UnionPay => Ok(Self::UnionPay),
_ => Err(ConnectorError::NotSupported {
message: "Card network".to_string(),
connector: "worldpayvantiv",
}
.into()),
}
}
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub enum OrderSource {
#[serde(rename = "ecommerce")]
Ecommerce,
#[serde(rename = "installment")]
Installment,
#[serde(rename = "mailorder")]
MailOrder,
#[serde(rename = "recurring")]
Recurring,
#[serde(rename = "telephone")]
Telephone,
#[serde(rename = "applepay")]
ApplePay,
#[serde(rename = "androidpay")]
AndroidPay,
}
impl<T: PaymentMethodDataTypes> From<PaymentMethodData<T>> for OrderSource {
fn from(payment_method_data: PaymentMethodData<T>) -> Self {
match payment_method_data {
PaymentMethodData::Wallet(WalletData::ApplePay(_)) => Self::ApplePay,
PaymentMethodData::Wallet(WalletData::GooglePay(_)) => Self::AndroidPay,
_ => Self::Ecommerce,
}
}
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct BillToAddress {
pub name: Option<Secret<String>>,
#[serde(rename = "companyName")]
pub company: Option<String>,
pub address_line1: Option<Secret<String>>,
pub address_line2: Option<Secret<String>>,
pub city: Option<String>,
pub state: Option<Secret<String>>,
pub zip: Option<Secret<String>>,
pub country: Option<CountryAlpha2>,
pub email: Option<common_utils::pii::Email>,
pub phone: Option<Secret<String>>,
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ShipToAddress {
pub name: Option<Secret<String>>,
#[serde(rename = "companyName")]
pub company: Option<String>,
pub address_line1: Option<Secret<String>>,
pub address_line2: Option<Secret<String>>,
pub city: Option<String>,
pub state: Option<Secret<String>>,
pub zip: Option<Secret<String>>,
pub country: Option<CountryAlpha2>,
pub email: Option<common_utils::pii::Email>,
pub phone: Option<Secret<String>>,
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct EnhancedData {
#[serde(skip_serializing_if = "Option::is_none")]
pub customer_reference: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub sales_tax: Option<MinorUnit>,
#[serde(skip_serializing_if = "Option::is_none")]
pub tax_exempt: Option<bool>,
#[serde(skip_serializing_if = "Option::is_none")]
pub discount_amount: Option<MinorUnit>,
#[serde(skip_serializing_if = "Option::is_none")]
pub shipping_amount: Option<MinorUnit>,
#[serde(skip_serializing_if = "Option::is_none")]
pub duty_amount: Option<MinorUnit>,
#[serde(skip_serializing_if = "Option::is_none")]
pub line_item_data: Option<Vec<LineItemData>>,
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct LineItemData {
#[serde(skip_serializing_if = "Option::is_none")]
pub item_sequence_number: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub item_description: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub product_code: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub quantity: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub unit_of_measure: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub unit_cost: Option<MinorUnit>,
#[serde(skip_serializing_if = "Option::is_none")]
pub item_total: Option<MinorUnit>,
#[serde(skip_serializing_if = "Option::is_none")]
pub item_discount_amount: Option<MinorUnit>,
#[serde(skip_serializing_if = "Option::is_none")]
pub commodity_code: Option<String>,
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ProcessingInstructions {
#[serde(skip_serializing_if = "Option::is_none")]
pub bypass_velocity_check: Option<bool>,
}
| {
"chunk": 4,
"crate": "connector-integration",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_mini_connector-integration_2054780185909450401_5 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/worldpayvantiv/transformers.rs
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct CardholderAuthentication {
pub authentication_value: Secret<String>,
}
// Response structures
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename = "cnpOnlineResponse", rename_all = "camelCase")]
pub struct CnpOnlineResponse {
#[serde(rename = "@version")]
pub version: String,
#[serde(rename = "@response")]
pub response_code: String,
#[serde(rename = "@message")]
pub message: String,
#[serde(skip_serializing_if = "Option::is_none")]
pub authorization_response: Option<PaymentResponse>,
#[serde(skip_serializing_if = "Option::is_none")]
pub sale_response: Option<PaymentResponse>,
#[serde(skip_serializing_if = "Option::is_none")]
pub capture_response: Option<CaptureResponse>,
#[serde(skip_serializing_if = "Option::is_none")]
pub auth_reversal_response: Option<AuthReversalResponse>,
#[serde(skip_serializing_if = "Option::is_none")]
pub void_response: Option<VoidResponse>,
#[serde(skip_serializing_if = "Option::is_none")]
pub credit_response: Option<CreditResponse>,
}
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
#[serde(rename_all = "camelCase")]
pub struct PaymentResponse {
#[serde(rename = "@id")]
pub id: String,
#[serde(rename = "@reportGroup")]
pub report_group: String,
#[serde(rename = "@customerId", skip_serializing_if = "Option::is_none")]
pub customer_id: Option<Secret<String>>,
pub cnp_txn_id: String,
pub order_id: String,
pub response: WorldpayvantivResponseCode,
pub message: String,
pub response_time: String,
#[serde(skip_serializing_if = "Option::is_none")]
pub post_date: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub location: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub auth_code: Option<Secret<String>>,
#[serde(skip_serializing_if = "Option::is_none")]
pub fraud_result: Option<FraudResult>,
#[serde(skip_serializing_if = "Option::is_none")]
pub token_response: Option<TokenResponse>,
#[serde(skip_serializing_if = "Option::is_none")]
pub network_transaction_id: Option<Secret<String>>,
#[serde(skip_serializing_if = "Option::is_none")]
pub approved_amount: Option<MinorUnit>,
#[serde(skip_serializing_if = "Option::is_none")]
pub enhanced_auth_response: Option<EnhancedAuthResponse>,
#[serde(skip_serializing_if = "Option::is_none")]
pub card_suffix: Option<String>,
}
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
#[serde(rename_all = "camelCase")]
pub struct CaptureResponse {
#[serde(rename = "@id")]
pub id: String,
#[serde(rename = "@reportGroup")]
pub report_group: String,
pub cnp_txn_id: String,
pub response: WorldpayvantivResponseCode,
pub message: String,
pub response_time: String,
}
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
#[serde(rename_all = "camelCase")]
pub struct AuthReversalResponse {
#[serde(rename = "@id")]
pub id: String,
#[serde(rename = "@reportGroup")]
pub report_group: String,
pub cnp_txn_id: String,
pub response: WorldpayvantivResponseCode,
pub message: String,
pub response_time: String,
}
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
#[serde(rename_all = "camelCase")]
pub struct VoidResponse {
#[serde(rename = "@id")]
pub id: String,
#[serde(rename = "@reportGroup")]
pub report_group: String,
pub cnp_txn_id: String,
pub response: WorldpayvantivResponseCode,
pub message: String,
pub response_time: String,
}
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
#[serde(rename_all = "camelCase")]
pub struct CreditResponse {
#[serde(rename = "@id")]
pub id: String,
#[serde(rename = "@reportGroup")]
pub report_group: String,
pub cnp_txn_id: String,
pub response: WorldpayvantivResponseCode,
pub message: String,
pub response_time: String,
}
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
#[serde(rename_all = "camelCase")]
pub struct FraudResult {
#[serde(skip_serializing_if = "Option::is_none")]
pub avs_result: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub card_validation_result: Option<String>,
| {
"chunk": 5,
"crate": "connector-integration",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_mini_connector-integration_2054780185909450401_6 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/worldpayvantiv/transformers.rs
#[serde(skip_serializing_if = "Option::is_none")]
pub authentication_result: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub advanced_a_v_s_result: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub advanced_fraud_results: Option<AdvancedFraudResults>,
}
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
#[serde(rename_all = "camelCase")]
pub struct AdvancedFraudResults {
#[serde(skip_serializing_if = "Option::is_none")]
pub device_review_status: Option<String>,
}
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
#[serde(rename_all = "camelCase")]
pub struct TokenResponse {
pub cnp_token: Secret<String>,
pub token_response_code: String,
pub token_message: String,
#[serde(rename = "type")]
pub token_type: String,
pub bin: String,
}
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
#[serde(rename_all = "camelCase")]
pub struct EnhancedAuthResponse {
#[serde(skip_serializing_if = "Option::is_none")]
pub funding_source: Option<FundingSource>,
#[serde(skip_serializing_if = "Option::is_none")]
pub virtual_account_number: Option<bool>,
#[serde(skip_serializing_if = "Option::is_none")]
pub network_response: Option<NetworkResponse>,
}
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
#[serde(rename_all = "camelCase")]
pub struct NetworkResponse {
#[serde(skip_serializing_if = "Option::is_none")]
pub endpoint: Option<String>,
#[serde(
rename = "networkField",
default,
skip_serializing_if = "Vec::is_empty"
)]
pub network_field: Vec<NetworkField>,
}
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
#[serde(rename_all = "camelCase")]
pub struct NetworkField {
#[serde(rename = "@fieldNumber")]
pub field_number: String,
#[serde(rename = "@fieldName", skip_serializing_if = "Option::is_none")]
pub field_name: Option<String>,
#[serde(rename = "fieldValue", skip_serializing_if = "Option::is_none")]
pub field_value: Option<String>,
#[serde(
rename = "networkSubField",
default,
skip_serializing_if = "Vec::is_empty"
)]
pub network_sub_field: Vec<NetworkSubField>,
}
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
#[serde(rename_all = "camelCase")]
pub struct NetworkSubField {
#[serde(rename = "@fieldNumber")]
pub field_number: String,
#[serde(rename = "fieldValue", skip_serializing_if = "Option::is_none")]
pub field_value: Option<String>,
}
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
#[serde(rename_all = "camelCase")]
pub struct FundingSource {
#[serde(rename = "type", skip_serializing_if = "Option::is_none")]
pub funding_type: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub available_balance: Option<String>,
}
// Response codes (comprehensive list)
#[derive(Debug, strum::Display, Serialize, Deserialize, PartialEq, Clone, Copy)]
pub enum WorldpayvantivResponseCode {
#[serde(rename = "000")]
Approved,
#[serde(rename = "001")]
TransactionReceived,
#[serde(rename = "010")]
PartiallyApproved,
#[serde(rename = "110")]
InsufficientFunds,
#[serde(rename = "120")]
CallIssuer,
#[serde(rename = "121")]
ExceedsApprovalAmountLimit,
#[serde(rename = "123")]
ExceedsActivityAmountLimit,
#[serde(rename = "125")]
InvalidEffectiveDate,
#[serde(rename = "301")]
InvalidAccountNumber,
#[serde(rename = "302")]
AccountNumberDoesNotMatchPaymentType,
#[serde(rename = "303")]
InvalidExpirationDate,
#[serde(rename = "304")]
InvalidCVV,
#[serde(rename = "305")]
InvalidCardValidationNum,
#[serde(rename = "306")]
ExpiredCard,
#[serde(rename = "307")]
InvalidPin,
#[serde(rename = "308")]
InvalidTransactionType,
#[serde(rename = "310")]
AccountNumberNotOnFile,
#[serde(rename = "311")]
AccountNumberLocked,
#[serde(rename = "320")]
InvalidLocation,
#[serde(rename = "321")]
InvalidMerchantId,
#[serde(rename = "322")]
InvalidLocation2,
#[serde(rename = "323")]
InvalidMerchantClassCode,
#[serde(rename = "324")]
InvalidExpirationDate2,
#[serde(rename = "325")]
InvalidData,
#[serde(rename = "326")]
| {
"chunk": 6,
"crate": "connector-integration",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_mini_connector-integration_2054780185909450401_7 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/worldpayvantiv/transformers.rs
InvalidPin2,
#[serde(rename = "327")]
ExceedsNumberofPINEntryTries,
#[serde(rename = "328")]
InvalidCryptoBox,
#[serde(rename = "329")]
InvalidRequestFormat,
#[serde(rename = "330")]
InvalidApplicationData,
#[serde(rename = "340")]
InvalidMerchantCategoryCode,
#[serde(rename = "346")]
TransactionCannotBeCompleted,
#[serde(rename = "347")]
TransactionTypeNotSupportedForCard,
#[serde(rename = "349")]
TransactionTypeNotAllowedAtTerminal,
#[serde(rename = "350")]
GenericDecline,
#[serde(rename = "351")]
DeclineByCard,
#[serde(rename = "352")]
DoNotHonor,
#[serde(rename = "353")]
InvalidMerchant,
#[serde(rename = "354")]
PickUpCard,
#[serde(rename = "355")]
CardOk,
#[serde(rename = "356")]
CallVoiceOperator,
#[serde(rename = "357")]
StopRecurring,
#[serde(rename = "358")]
NoChecking,
#[serde(rename = "359")]
NoCreditAccount,
#[serde(rename = "360")]
NoCreditAccountType,
#[serde(rename = "361")]
InvalidCreditPlan,
#[serde(rename = "362")]
InvalidTransactionCode,
#[serde(rename = "363")]
TransactionNotPermittedToCardholderAccount,
#[serde(rename = "364")]
TransactionNotPermittedToMerchant,
#[serde(rename = "365")]
PINTryExceeded,
#[serde(rename = "366")]
SecurityViolation,
#[serde(rename = "367")]
HardCapturePickUpCard,
#[serde(rename = "368")]
ResponseReceivedTooLate,
#[serde(rename = "370")]
SoftDecline,
#[serde(rename = "400")]
ContactCardIssuer,
#[serde(rename = "401")]
CallVoiceCenter,
#[serde(rename = "402")]
InvalidMerchantTerminal,
#[serde(rename = "410")]
InvalidAmount,
#[serde(rename = "411")]
ResubmitTransaction,
#[serde(rename = "412")]
InvalidTransaction,
#[serde(rename = "413")]
MerchantNotFound,
#[serde(rename = "501")]
PickUpCard2,
#[serde(rename = "502")]
ExpiredCard2,
#[serde(rename = "503")]
SuspectedFraud,
#[serde(rename = "504")]
ContactCardIssuer2,
#[serde(rename = "505")]
DoNotHonor2,
#[serde(rename = "506")]
InvalidMerchant2,
#[serde(rename = "507")]
InsufficientFunds2,
#[serde(rename = "508")]
AccountNumberNotOnFile2,
#[serde(rename = "509")]
InvalidAmount2,
#[serde(rename = "510")]
InvalidCardNumber,
#[serde(rename = "511")]
InvalidExpirationDate3,
#[serde(rename = "512")]
InvalidCVV2,
#[serde(rename = "513")]
InvalidCardValidationNum2,
#[serde(rename = "514")]
InvalidPin3,
#[serde(rename = "515")]
CardRestricted,
#[serde(rename = "516")]
OverCreditLimit,
#[serde(rename = "517")]
AccountClosed,
#[serde(rename = "518")]
AccountFrozen,
#[serde(rename = "519")]
InvalidTransactionType2,
#[serde(rename = "520")]
InvalidMerchantId2,
#[serde(rename = "521")]
ProcessorNotAvailable,
#[serde(rename = "522")]
NetworkTimeOut,
#[serde(rename = "523")]
SystemError,
#[serde(rename = "524")]
DuplicateTransaction,
#[serde(rename = "601")]
OfflineApproval,
#[serde(rename = "602")]
VoiceAuthRequired,
#[serde(rename = "603")]
AuthenticationRequired,
#[serde(rename = "604")]
SecurityCodeRequired,
#[serde(rename = "605")]
SecurityCodeNotMatch,
#[serde(rename = "606")]
ZipCodeNotMatch,
#[serde(rename = "607")]
AddressNotMatch,
#[serde(rename = "608")]
AVSFailure,
#[serde(rename = "609")]
CVVFailure,
#[serde(rename = "610")]
ServiceNotAllowed,
#[serde(rename = "820")]
CreditNotSupported,
#[serde(rename = "821")]
InvalidCreditAmount,
#[serde(rename = "822")]
CreditAmountExceedsDebitAmount,
#[serde(rename = "823")]
RefundNotSupported,
#[serde(rename = "824")]
InvalidRefundAmount,
#[serde(rename = "825")]
RefundAmountExceedsOriginalAmount,
#[serde(rename = "826")]
VoidNotSupported,
#[serde(rename = "827")]
VoidNotAllowed,
#[serde(rename = "828")]
CaptureNotSupported,
#[serde(rename = "829")]
CaptureNotAllowed,
#[serde(rename = "830")]
InvalidCaptureAmount,
#[serde(rename = "831")]
CaptureAmountExceedsAuthAmount,
#[serde(rename = "832")]
TransactionAlreadySettled,
| {
"chunk": 7,
"crate": "connector-integration",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_mini_connector-integration_2054780185909450401_8 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/worldpayvantiv/transformers.rs
#[serde(rename = "833")]
TransactionAlreadyVoided,
#[serde(rename = "834")]
TransactionAlreadyCaptured,
#[serde(rename = "835")]
TransactionNotFound,
}
// Sync structures
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct VantivSyncResponse {
#[serde(rename = "paymentId", skip_serializing_if = "Option::is_none")]
pub payment_id: Option<u64>,
#[serde(skip_serializing_if = "Option::is_none")]
pub request_uuid: Option<String>,
pub payment_status: PaymentStatus,
#[serde(skip_serializing_if = "Option::is_none")]
pub payment_detail: Option<PaymentDetail>,
}
#[derive(Debug, strum::Display, Serialize, Deserialize, PartialEq, Eq)]
#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
pub enum PaymentStatus {
NotYetProcessed,
ProcessedSuccessfully,
TransactionDeclined,
StatusUnavailable,
PaymentStatusNotFound,
}
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct PaymentDetail {
#[serde(rename = "paymentId", skip_serializing_if = "Option::is_none")]
pub payment_id: Option<u64>,
#[serde(skip_serializing_if = "Option::is_none")]
pub batch_id: Option<u64>,
#[serde(skip_serializing_if = "Option::is_none")]
pub session_id: Option<u64>,
#[serde(skip_serializing_if = "Option::is_none")]
pub response_reason_code: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub response_reason_message: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub reject_type: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub dupe_txn_id: Option<u64>,
#[serde(skip_serializing_if = "Option::is_none")]
pub amount: Option<StringMajorUnit>,
#[serde(skip_serializing_if = "Option::is_none")]
pub purchase_currency: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub post_day: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub reported_timestamp: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub payment_type: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub merchant_order_number: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub merchant_txn_id: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub parent_id: Option<u64>,
#[serde(skip_serializing_if = "Option::is_none")]
pub reporting_group: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub txn_type: Option<String>,
#[serde(rename = "eCommMerchantId", skip_serializing_if = "Option::is_none")]
pub e_comm_merchant_id: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub organization_name: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub merchant_category_code: Option<String>,
}
// Sync error response
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct VantivSyncErrorResponse {
pub error_messages: Vec<String>,
}
// Dispute structures
#[derive(Debug, Deserialize, Serialize)]
#[serde(rename = "chargebackRetrievalResponse", rename_all = "camelCase")]
pub struct ChargebackRetrievalResponse {
#[serde(rename = "@xmlns")]
pub xmlns: String,
pub transaction_id: String,
#[serde(skip_serializing_if = "Option::is_none")]
pub chargeback_case: Option<Vec<ChargebackCase>>,
}
#[derive(Debug, Deserialize, Serialize, Clone)]
#[serde(rename_all = "camelCase")]
pub struct ChargebackCase {
pub case_id: String,
pub merchant_id: String,
#[serde(skip_serializing_if = "Option::is_none")]
pub day_issued_by_bank: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub date_received_by_vantiv_cnp: Option<String>,
pub vantiv_cnp_txn_id: String,
pub cycle: String,
pub order_id: String,
#[serde(skip_serializing_if = "Option::is_none")]
pub card_number_last4: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub card_type: Option<String>,
pub chargeback_amount: MinorUnit,
pub chargeback_currency_type: Currency,
#[serde(skip_serializing_if = "Option::is_none")]
pub original_txn_day: Option<String>,
| {
"chunk": 8,
"crate": "connector-integration",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_mini_connector-integration_2054780185909450401_9 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/worldpayvantiv/transformers.rs
#[serde(skip_serializing_if = "Option::is_none")]
pub chargeback_type: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub reason_code: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub reason_code_description: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub current_queue: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub acquirer_reference_number: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub chargeback_reference_number: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub bin: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub payment_amount: Option<MinorUnit>,
#[serde(skip_serializing_if = "Option::is_none")]
pub reply_by_day: Option<String>,
pub activity: Vec<Activity>,
}
#[derive(Debug, Deserialize, Serialize, Clone)]
#[serde(rename_all = "camelCase")]
pub struct Activity {
pub activity_date: String,
pub activity_type: String,
#[serde(skip_serializing_if = "Option::is_none")]
pub from_queue: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub to_queue: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub settlement_amount: Option<MinorUnit>,
#[serde(skip_serializing_if = "Option::is_none")]
pub notes: Option<String>,
}
#[derive(Debug, Serialize)]
#[serde(rename = "chargebackUpdateRequest", rename_all = "camelCase")]
pub struct ChargebackUpdateRequest {
#[serde(rename = "@xmlns")]
pub xmlns: String,
pub activity_type: String,
#[serde(skip_serializing_if = "Option::is_none")]
pub notes: Option<String>,
}
#[derive(Debug, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ChargebackDocumentUploadResponse {
pub response_message: String,
pub response_code: String,
#[serde(skip_serializing_if = "Option::is_none")]
pub document_id: Option<String>,
}
#[derive(Debug, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct VantivDisputeErrorResponse {
pub errors: Vec<ErrorInfo>,
}
#[derive(Debug, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ErrorInfo {
pub error: String,
}
// Payment flow types
#[derive(Debug, Serialize, Deserialize, PartialEq, Clone, Copy)]
#[serde(rename_all = "lowercase")]
pub enum WorldpayvantivPaymentFlow {
Sale,
Auth,
Capture,
Void,
VoidPC, // VoidPostCapture
}
// Helper function to determine payment flow type from merchant transaction ID
fn get_payment_flow_type(
merchant_txn_id: &str,
) -> Result<WorldpayvantivPaymentFlow, ConnectorError> {
let merchant_txn_id_lower = merchant_txn_id.to_lowercase();
if merchant_txn_id_lower.contains("auth") {
Ok(WorldpayvantivPaymentFlow::Auth)
} else if merchant_txn_id_lower.contains("sale") {
Ok(WorldpayvantivPaymentFlow::Sale)
} else if merchant_txn_id_lower.contains("voidpc") {
Ok(WorldpayvantivPaymentFlow::VoidPC)
} else if merchant_txn_id_lower.contains("void") {
Ok(WorldpayvantivPaymentFlow::Void)
} else if merchant_txn_id_lower.contains("capture") {
Ok(WorldpayvantivPaymentFlow::Capture)
} else {
Err(ConnectorError::NotSupported {
message: format!(
"Unable to determine payment flow type from merchant transaction ID: {}",
merchant_txn_id
),
connector: "worldpayvantiv",
})
}
}
// Helper function to determine attempt status based on payment flow and Vantiv response status
fn determine_attempt_status_for_psync(
payment_status: PaymentStatus,
merchant_txn_id: &str,
current_status: common_enums::AttemptStatus,
) -> Result<common_enums::AttemptStatus, ConnectorError> {
let flow_type = get_payment_flow_type(merchant_txn_id)?;
match payment_status {
PaymentStatus::ProcessedSuccessfully => match flow_type {
WorldpayvantivPaymentFlow::Sale | WorldpayvantivPaymentFlow::Capture => {
Ok(common_enums::AttemptStatus::Charged)
}
WorldpayvantivPaymentFlow::Auth => Ok(common_enums::AttemptStatus::Authorized),
| {
"chunk": 9,
"crate": "connector-integration",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_mini_connector-integration_2054780185909450401_10 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/worldpayvantiv/transformers.rs
WorldpayvantivPaymentFlow::Void => Ok(common_enums::AttemptStatus::Voided),
WorldpayvantivPaymentFlow::VoidPC => Ok(common_enums::AttemptStatus::VoidedPostCapture),
},
PaymentStatus::TransactionDeclined => match flow_type {
WorldpayvantivPaymentFlow::Sale | WorldpayvantivPaymentFlow::Capture => {
Ok(common_enums::AttemptStatus::Failure)
}
WorldpayvantivPaymentFlow::Auth => Ok(common_enums::AttemptStatus::AuthorizationFailed),
WorldpayvantivPaymentFlow::Void | WorldpayvantivPaymentFlow::VoidPC => {
Ok(common_enums::AttemptStatus::VoidFailed)
}
},
PaymentStatus::PaymentStatusNotFound
| PaymentStatus::NotYetProcessed
| PaymentStatus::StatusUnavailable => Ok(current_status),
}
}
#[derive(Debug, strum::Display, Serialize, Deserialize, PartialEq, Clone, Copy)]
#[strum(serialize_all = "lowercase")]
#[serde(rename_all = "lowercase")]
pub enum OperationId {
Sale,
Auth,
Capture,
Void,
#[strum(serialize = "voidPC")]
VoidPC,
Refund,
}
// Step 90-93: TryFrom for Authorize response
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
TryFrom<
ResponseRouterData<
CnpOnlineResponse,
RouterDataV2<
Authorize,
PaymentFlowData,
PaymentsAuthorizeData<T>,
PaymentsResponseData,
>,
>,
> for RouterDataV2<Authorize, PaymentFlowData, PaymentsAuthorizeData<T>, PaymentsResponseData>
{
type Error = error_stack::Report<ConnectorError>;
fn try_from(
item: ResponseRouterData<
CnpOnlineResponse,
RouterDataV2<
Authorize,
PaymentFlowData,
PaymentsAuthorizeData<T>,
PaymentsResponseData,
>,
>,
) -> Result<Self, Self::Error> {
match (
item.response.sale_response.as_ref(),
item.response.authorization_response.as_ref(),
) {
(Some(sale_response), None) => {
let status =
get_attempt_status(WorldpayvantivPaymentFlow::Sale, sale_response.response)?;
if is_payment_failure(status) {
let error_response = ErrorResponse {
code: sale_response.response.to_string(),
message: sale_response.message.clone(),
reason: Some(sale_response.message.clone()),
status_code: item.http_code,
attempt_status: Some(status),
connector_transaction_id: Some(sale_response.cnp_txn_id.clone()),
network_decline_code: None,
network_advice_code: None,
network_error_message: None,
};
Ok(Self {
resource_common_data: PaymentFlowData {
status,
..item.router_data.resource_common_data
},
response: Err(error_response),
..item.router_data
})
} else {
let payments_response = PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(
sale_response.cnp_txn_id.clone(),
),
redirection_data: None,
mandate_reference: None,
connector_metadata: None,
network_txn_id: sale_response
.network_transaction_id
.clone()
.map(|id| id.expose()),
connector_response_reference_id: Some(sale_response.order_id.clone()),
incremental_authorization_allowed: None,
status_code: item.http_code,
};
Ok(Self {
| {
"chunk": 10,
"crate": "connector-integration",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_mini_connector-integration_2054780185909450401_11 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/worldpayvantiv/transformers.rs
resource_common_data: PaymentFlowData {
status,
..item.router_data.resource_common_data
},
response: Ok(payments_response),
..item.router_data
})
}
}
(None, Some(auth_response)) => {
let status =
get_attempt_status(WorldpayvantivPaymentFlow::Auth, auth_response.response)?;
if is_payment_failure(status) {
let error_response = ErrorResponse {
code: auth_response.response.to_string(),
message: auth_response.message.clone(),
reason: Some(auth_response.message.clone()),
status_code: item.http_code,
attempt_status: Some(status),
connector_transaction_id: Some(auth_response.cnp_txn_id.clone()),
network_decline_code: None,
network_advice_code: None,
network_error_message: None,
};
Ok(Self {
resource_common_data: PaymentFlowData {
status,
..item.router_data.resource_common_data
},
response: Err(error_response),
..item.router_data
})
} else {
let payments_response = PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(
auth_response.cnp_txn_id.clone(),
),
redirection_data: None,
mandate_reference: None,
connector_metadata: None,
network_txn_id: auth_response
.network_transaction_id
.clone()
.map(|id| id.expose()),
connector_response_reference_id: Some(auth_response.order_id.clone()),
incremental_authorization_allowed: None,
status_code: item.http_code,
};
Ok(Self {
resource_common_data: PaymentFlowData {
status,
..item.router_data.resource_common_data
},
response: Ok(payments_response),
..item.router_data
})
}
}
(None, None) => {
let error_response = ErrorResponse {
code: item.response.response_code,
message: item.response.message.clone(),
reason: Some(item.response.message.clone()),
status_code: item.http_code,
attempt_status: Some(common_enums::AttemptStatus::Failure),
connector_transaction_id: None,
network_decline_code: None,
network_advice_code: None,
network_error_message: None,
};
Ok(Self {
resource_common_data: PaymentFlowData {
status: common_enums::AttemptStatus::Failure,
..item.router_data.resource_common_data
},
response: Err(error_response),
..item.router_data
})
}
(_, _) => Err(ConnectorError::UnexpectedResponseError(
"Only one of 'sale_response' or 'authorization_response' is expected"
.to_string()
.into(),
)
.into()),
}
}
}
// Helper functions for creating RawCardNumber from different sources
#[allow(dead_code)]
fn create_raw_card_number_from_string<T: PaymentMethodDataTypes>(
card_string: String,
) -> Result<RawCardNumber<T>, error_stack::Report<ConnectorError>>
where
T::Inner: From<String>,
{
| {
"chunk": 11,
"crate": "connector-integration",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_mini_connector-integration_2054780185909450401_12 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/worldpayvantiv/transformers.rs
Ok(RawCardNumber(T::Inner::from(card_string)))
}
#[allow(dead_code)]
fn get_payment_info<T: PaymentMethodDataTypes>(
payment_method_data: &PaymentMethodData<T>,
payment_method_token: Option<PaymentMethodToken>,
) -> Result<PaymentInfo<T>, error_stack::Report<ConnectorError>>
where
T::Inner: From<String> + Clone,
{
match payment_method_data {
PaymentMethodData::Card(card_data) => {
let card_type = match card_data.card_network.clone() {
Some(network) => WorldpayvativCardType::try_from(network)?,
None => {
// Determine from card number if network not provided
return Err(ConnectorError::MissingRequiredField {
field_name: "card_network",
}
.into());
}
};
let year_str = card_data.card_exp_year.peek();
let formatted_year = if year_str.len() == 4 {
&year_str[2..]
} else {
year_str
};
let exp_date = format!("{}{}", card_data.card_exp_month.peek(), formatted_year);
let worldpay_card = WorldpayvantivCardData {
card_type,
number: card_data.card_number.clone(),
exp_date: exp_date.into(),
card_validation_num: Some(card_data.card_cvc.clone()),
};
Ok(PaymentInfo::Card(CardData {
card: worldpay_card,
processing_type: None,
network_transaction_id: None,
}))
}
PaymentMethodData::Wallet(wallet_data) => {
match wallet_data {
WalletData::ApplePay(apple_pay_data) => {
match payment_method_token {
Some(PaymentMethodToken::ApplePayDecrypt(apple_pay_decrypted_data)) => {
let card_type = determine_apple_pay_card_type(
&apple_pay_data.payment_method.network,
)?;
// Extract expiry date from Apple Pay decrypted data
let expiry_month: Secret<String> =
apple_pay_decrypted_data.get_expiry_month()?;
let expiry_year =
apple_pay_decrypted_data.get_four_digit_expiry_year()?;
let formatted_year = &expiry_year.expose()[2..]; // Convert to 2-digit year
let exp_date = format!("{}{}", expiry_month.expose(), formatted_year);
let card_number_string = apple_pay_decrypted_data
.application_primary_account_number
.expose();
let raw_card_number =
create_raw_card_number_from_string::<T>(card_number_string)?;
let worldpay_card = WorldpayvantivCardData {
card_type,
number: raw_card_number,
exp_date: exp_date.into(),
card_validation_num: None, // Apple Pay doesn't provide CVV
};
Ok(PaymentInfo::Card(CardData {
card: worldpay_card,
processing_type: None,
network_transaction_id: None,
}))
}
_ => Err(ConnectorError::MissingRequiredField {
field_name: "apple_pay_decrypted_data",
}
.into()),
}
}
WalletData::GooglePay(google_pay_data) => {
match payment_method_token {
Some(PaymentMethodToken::GooglePayDecrypt(google_pay_decrypted_data)) => {
let card_type =
determine_google_pay_card_type(&google_pay_data.info.card_network)?;
// Extract expiry date from Google Pay decrypted data
| {
"chunk": 12,
"crate": "connector-integration",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_mini_connector-integration_2054780185909450401_13 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/worldpayvantiv/transformers.rs
let expiry_month = google_pay_decrypted_data
.payment_method_details
.expiration_month
.two_digits();
// Since CardExpirationYear doesn't have a public accessor, we need to deserialize it
// This follows the pattern where year is extracted from the validated data
let expiry_year_bytes = serde_json::to_vec(
&google_pay_decrypted_data
.payment_method_details
.expiration_year,
)
.change_context(ConnectorError::RequestEncodingFailed)?;
let expiry_year: u16 = serde_json::from_slice(&expiry_year_bytes)
.change_context(ConnectorError::RequestEncodingFailed)?;
let formatted_year = format!("{:02}", expiry_year % 100); // Convert to 2-digit year
let exp_date = format!("{}{}", expiry_month, formatted_year);
let card_number_string = google_pay_decrypted_data
.payment_method_details
.pan
.peek()
.to_string();
let raw_card_number =
create_raw_card_number_from_string::<T>(card_number_string)?;
let worldpay_card = WorldpayvantivCardData {
card_type,
number: raw_card_number,
exp_date: exp_date.into(),
card_validation_num: None, // Google Pay doesn't provide CVV
};
Ok(PaymentInfo::Card(CardData {
card: worldpay_card,
processing_type: None,
network_transaction_id: None,
}))
}
_ => Err(ConnectorError::MissingRequiredField {
field_name: "google_pay_decrypted_data",
}
.into()),
}
}
_ => Err(ConnectorError::NotSupported {
message: "Wallet type".to_string(),
connector: "worldpayvantiv",
}
.into()),
}
}
_ => Err(ConnectorError::NotSupported {
message: "Payment method".to_string(),
connector: "worldpayvantiv",
}
.into()),
}
}
#[allow(dead_code)]
fn determine_apple_pay_card_type(
network: &str,
) -> Result<WorldpayvativCardType, error_stack::Report<ConnectorError>> {
match network.to_lowercase().as_str() {
"visa" => Ok(WorldpayvativCardType::Visa),
"mastercard" => Ok(WorldpayvativCardType::MasterCard),
"amex" => Ok(WorldpayvativCardType::AmericanExpress),
"discover" => Ok(WorldpayvativCardType::Discover),
_ => Err(ConnectorError::NotSupported {
message: format!("Apple Pay network: {}", network),
connector: "worldpayvantiv",
}
.into()),
}
}
#[allow(dead_code)]
fn determine_google_pay_card_type(
network: &str,
) -> Result<WorldpayvativCardType, error_stack::Report<ConnectorError>> {
match network.to_lowercase().as_str() {
"visa" => Ok(WorldpayvativCardType::Visa),
"mastercard" => Ok(WorldpayvativCardType::MasterCard),
"amex" => Ok(WorldpayvativCardType::AmericanExpress),
"discover" => Ok(WorldpayvativCardType::Discover),
_ => Err(ConnectorError::NotSupported {
message: format!("Google Pay network: {}", network),
connector: "worldpayvantiv",
}
.into()),
}
}
fn get_billing_address(
billing_address: &Option<domain_types::payment_address::Address>,
) -> Option<BillToAddress> {
billing_address.as_ref().map(|addr| BillToAddress {
| {
"chunk": 13,
"crate": "connector-integration",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_mini_connector-integration_2054780185909450401_14 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/worldpayvantiv/transformers.rs
name: addr.get_optional_full_name(),
company: addr
.address
.as_ref()
.and_then(|a| a.first_name.as_ref().map(|f| f.peek().to_string())),
address_line1: addr
.address
.as_ref()
.and_then(|a| a.line1.as_ref().map(|l| Secret::new(l.peek().to_string()))),
address_line2: addr
.address
.as_ref()
.and_then(|a| a.line2.as_ref().map(|l| Secret::new(l.peek().to_string()))),
city: addr.address.as_ref().and_then(|a| a.city.clone()),
state: addr
.address
.as_ref()
.and_then(|a| a.state.as_ref().map(|s| Secret::new(s.peek().to_string()))),
zip: addr
.address
.as_ref()
.and_then(|a| a.zip.as_ref().map(|z| Secret::new(z.peek().to_string()))),
country: addr.address.as_ref().and_then(|a| a.country),
email: addr.email.clone(),
phone: addr
.phone
.as_ref()
.and_then(|p| p.number.as_ref().map(|n| Secret::new(n.peek().to_string()))),
})
}
fn get_shipping_address(
shipping_address: &Option<domain_types::payment_address::Address>,
) -> Option<ShipToAddress> {
shipping_address.as_ref().map(|addr| ShipToAddress {
name: addr.get_optional_full_name(),
company: addr
.address
.as_ref()
.and_then(|a| a.first_name.as_ref().map(|f| f.peek().to_string())),
address_line1: addr
.address
.as_ref()
.and_then(|a| a.line1.as_ref().map(|l| Secret::new(l.peek().to_string()))),
address_line2: addr
.address
.as_ref()
.and_then(|a| a.line2.as_ref().map(|l| Secret::new(l.peek().to_string()))),
city: addr.address.as_ref().and_then(|a| a.city.clone()),
state: addr
.address
.as_ref()
.and_then(|a| a.state.as_ref().map(|s| Secret::new(s.peek().to_string()))),
zip: addr
.address
.as_ref()
.and_then(|a| a.zip.as_ref().map(|z| Secret::new(z.peek().to_string()))),
country: addr.address.as_ref().and_then(|a| a.country),
email: addr.email.clone(),
phone: addr
.phone
.as_ref()
.and_then(|p| p.number.as_ref().map(|n| Secret::new(n.peek().to_string()))),
})
}
fn get_valid_transaction_id(
id: String,
_error_field_name: &str,
) -> Result<String, error_stack::Report<ConnectorError>> {
if id.len() <= worldpayvantiv_constants::MAX_PAYMENT_REFERENCE_ID_LENGTH {
Ok(id)
} else {
Err(ConnectorError::InvalidConnectorConfig {
config: "Transaction ID length exceeds maximum limit",
}
.into())
}
}
// Step 94-98: TryFrom for PSync response
impl
TryFrom<
ResponseRouterData<
VantivSyncResponse,
RouterDataV2<PSync, PaymentFlowData, PaymentsSyncData, PaymentsResponseData>,
>,
> for RouterDataV2<PSync, PaymentFlowData, PaymentsSyncData, PaymentsResponseData>
{
type Error = error_stack::Report<ConnectorError>;
fn try_from(
item: ResponseRouterData<
VantivSyncResponse,
RouterDataV2<PSync, PaymentFlowData, PaymentsSyncData, PaymentsResponseData>,
>,
) -> Result<Self, Self::Error> {
let status = if let Some(merchant_txn_id) = item
.response
.payment_detail
.as_ref()
.and_then(|detail| detail.merchant_txn_id.as_ref())
{
determine_attempt_status_for_psync(
item.response.payment_status,
merchant_txn_id,
item.router_data.resource_common_data.status,
)?
} else {
// Fallback to simple status mapping if no merchant_txn_id available
match item.response.payment_status {
PaymentStatus::ProcessedSuccessfully => common_enums::AttemptStatus::Charged,
PaymentStatus::TransactionDeclined => common_enums::AttemptStatus::Failure,
_ => item.router_data.resource_common_data.status,
}
};
let payments_response = PaymentsResponseData::TransactionResponse {
| {
"chunk": 14,
"crate": "connector-integration",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_mini_connector-integration_2054780185909450401_15 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/worldpayvantiv/transformers.rs
resource_id: ResponseId::ConnectorTransactionId(
item.response
.payment_id
.map(|id| id.to_string())
.unwrap_or_else(|| "unknown".to_string()),
),
redirection_data: None,
mandate_reference: None,
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: item
.response
.payment_detail
.as_ref()
.and_then(|detail| detail.merchant_txn_id.clone()),
incremental_authorization_allowed: None,
status_code: item.http_code,
};
Ok(Self {
resource_common_data: PaymentFlowData {
status,
..item.router_data.resource_common_data
},
response: Ok(payments_response),
..item.router_data
})
}
}
// TryFrom for Capture request
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
TryFrom<
WorldpayvantivRouterData<
RouterDataV2<Capture, PaymentFlowData, PaymentsCaptureData, PaymentsResponseData>,
T,
>,
> for WorldpayvantivPaymentsRequest<T>
{
type Error = error_stack::Report<ConnectorError>;
fn try_from(
item: WorldpayvantivRouterData<
RouterDataV2<Capture, PaymentFlowData, PaymentsCaptureData, PaymentsResponseData>,
T,
>,
) -> Result<Self, Self::Error> {
let auth = WorldpayvantivAuthType::try_from(&item.router_data.connector_auth_type)?;
let authentication = Authentication {
user: auth.user,
password: auth.password,
};
let cnp_txn_id = item
.router_data
.request
.get_connector_transaction_id()
.change_context(ConnectorError::MissingConnectorTransactionID)?;
let merchant_txn_id = item
.router_data
.resource_common_data
.connector_request_reference_id
.clone();
let capture = CaptureRequest {
id: format!("{}_{}", OperationId::Capture, merchant_txn_id),
report_group: "Default".to_string(),
cnp_txn_id,
amount: item.router_data.request.minor_amount_to_capture,
enhanced_data: None,
};
let cnp_request = CnpOnlineRequest {
version: worldpayvantiv_constants::WORLDPAYVANTIV_VERSION.to_string(),
xmlns: worldpayvantiv_constants::XMLNS.to_string(),
merchant_id: auth.merchant_id,
authentication,
authorization: None,
sale: None,
capture: Some(capture),
auth_reversal: None,
void: None,
credit: None,
};
Ok(WorldpayvantivPaymentsRequest { cnp_request })
}
}
// TryFrom for Void request (pre-capture void using AuthReversal)
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
TryFrom<
WorldpayvantivRouterData<
RouterDataV2<Void, PaymentFlowData, PaymentVoidData, PaymentsResponseData>,
T,
>,
> for WorldpayvantivPaymentsRequest<T>
{
type Error = error_stack::Report<ConnectorError>;
fn try_from(
item: WorldpayvantivRouterData<
RouterDataV2<Void, PaymentFlowData, PaymentVoidData, PaymentsResponseData>,
T,
>,
) -> Result<Self, Self::Error> {
let auth = WorldpayvantivAuthType::try_from(&item.router_data.connector_auth_type)?;
let authentication = Authentication {
user: auth.user,
password: auth.password,
};
let cnp_txn_id = item.router_data.request.connector_transaction_id.clone();
let merchant_txn_id = item
.router_data
.resource_common_data
.connector_request_reference_id
.clone();
// Extract report group from metadata or use default
let report_group =
| {
"chunk": 15,
"crate": "connector-integration",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_mini_connector-integration_2054780185909450401_16 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/worldpayvantiv/transformers.rs
extract_report_group(&item.router_data.resource_common_data.connector_meta_data)
.unwrap_or_else(|| "rtpGrp".to_string());
// For pre-capture void, use AuthReversal
let auth_reversal = AuthReversal {
id: format!("{}_{}", OperationId::Void, merchant_txn_id),
report_group,
cnp_txn_id,
amount: None, // Amount is optional for AuthReversal
};
let cnp_request = CnpOnlineRequest {
version: worldpayvantiv_constants::WORLDPAYVANTIV_VERSION.to_string(),
xmlns: worldpayvantiv_constants::XMLNS.to_string(),
merchant_id: auth.merchant_id,
authentication,
authorization: None,
sale: None,
capture: None,
auth_reversal: Some(auth_reversal),
void: None,
credit: None,
};
Ok(WorldpayvantivPaymentsRequest { cnp_request })
}
}
// TryFrom for Refund request
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
TryFrom<
WorldpayvantivRouterData<
RouterDataV2<Refund, RefundFlowData, RefundsData, RefundsResponseData>,
T,
>,
> for WorldpayvantivPaymentsRequest<T>
{
type Error = error_stack::Report<ConnectorError>;
fn try_from(
item: WorldpayvantivRouterData<
RouterDataV2<Refund, RefundFlowData, RefundsData, RefundsResponseData>,
T,
>,
) -> Result<Self, Self::Error> {
let auth = WorldpayvantivAuthType::try_from(&item.router_data.connector_auth_type)?;
let authentication = Authentication {
user: auth.user,
password: auth.password,
};
let cnp_txn_id = item.router_data.request.connector_transaction_id.clone();
let merchant_txn_id = item
.router_data
.resource_common_data
.connector_request_reference_id
.clone();
let credit = RefundRequest {
id: format!("{}_{}", OperationId::Refund, merchant_txn_id),
report_group: "Default".to_string(),
cnp_txn_id,
amount: item.router_data.request.minor_refund_amount,
};
let cnp_request = CnpOnlineRequest {
version: worldpayvantiv_constants::WORLDPAYVANTIV_VERSION.to_string(),
xmlns: worldpayvantiv_constants::XMLNS.to_string(),
merchant_id: auth.merchant_id,
authentication,
authorization: None,
sale: None,
capture: None,
auth_reversal: None,
void: None,
credit: Some(credit),
};
Ok(WorldpayvantivPaymentsRequest { cnp_request })
}
}
// TryFrom for RSync request
// TryFrom for VoidPC (VoidPostCapture) request
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
TryFrom<
WorldpayvantivRouterData<
RouterDataV2<
VoidPC,
PaymentFlowData,
PaymentsCancelPostCaptureData,
PaymentsResponseData,
>,
T,
>,
> for WorldpayvantivPaymentsRequest<T>
{
type Error = error_stack::Report<ConnectorError>;
fn try_from(
item: WorldpayvantivRouterData<
RouterDataV2<
VoidPC,
PaymentFlowData,
PaymentsCancelPostCaptureData,
PaymentsResponseData,
>,
T,
>,
) -> Result<Self, Self::Error> {
let auth = WorldpayvantivAuthType::try_from(&item.router_data.connector_auth_type)?;
let authentication = Authentication {
user: auth.user,
password: auth.password,
};
let cnp_txn_id = item.router_data.request.connector_transaction_id.clone();
let merchant_txn_id = item
.router_data
.resource_common_data
.connector_request_reference_id
.clone();
// Extract report group from metadata or use default
let report_group =
| {
"chunk": 16,
"crate": "connector-integration",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_mini_connector-integration_2054780185909450401_17 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/worldpayvantiv/transformers.rs
extract_report_group(&item.router_data.resource_common_data.connector_meta_data)
.unwrap_or_else(|| "rtpGrp".to_string());
let void = VoidRequest {
id: format!("{}_{}", OperationId::VoidPC, merchant_txn_id),
report_group,
cnp_txn_id,
};
let cnp_request = CnpOnlineRequest {
version: worldpayvantiv_constants::WORLDPAYVANTIV_VERSION.to_string(),
xmlns: worldpayvantiv_constants::XMLNS.to_string(),
merchant_id: auth.merchant_id,
authentication,
authorization: None,
sale: None,
capture: None,
auth_reversal: None,
void: Some(void),
credit: None,
};
Ok(WorldpayvantivPaymentsRequest { cnp_request })
}
}
impl
TryFrom<
ResponseRouterData<
CnpOnlineResponse,
RouterDataV2<Refund, RefundFlowData, RefundsData, RefundsResponseData>,
>,
> for RouterDataV2<Refund, RefundFlowData, RefundsData, RefundsResponseData>
{
type Error = error_stack::Report<ConnectorError>;
fn try_from(
item: ResponseRouterData<
CnpOnlineResponse,
RouterDataV2<Refund, RefundFlowData, RefundsData, RefundsResponseData>,
>,
) -> Result<Self, Self::Error> {
if let Some(credit_response) = item.response.credit_response {
let status = match credit_response.response {
WorldpayvantivResponseCode::Approved
| WorldpayvantivResponseCode::TransactionReceived => {
common_enums::RefundStatus::Pending
}
_ => common_enums::RefundStatus::Failure,
};
let refunds_response = RefundsResponseData {
connector_refund_id: credit_response.cnp_txn_id.clone(),
refund_status: status,
status_code: item.http_code,
};
Ok(Self {
resource_common_data: RefundFlowData {
status,
..item.router_data.resource_common_data
},
response: Ok(refunds_response),
..item.router_data
})
} else {
let error_response = ErrorResponse {
code: item.response.response_code,
message: item.response.message.clone(),
reason: Some(item.response.message.clone()),
status_code: item.http_code,
attempt_status: Some(common_enums::AttemptStatus::Failure),
connector_transaction_id: None,
network_decline_code: None,
network_advice_code: None,
network_error_message: None,
};
Ok(Self {
resource_common_data: RefundFlowData {
status: common_enums::RefundStatus::Failure,
..item.router_data.resource_common_data
},
response: Err(error_response),
..item.router_data
})
}
}
}
// Step 109-113: TryFrom for RSync response
impl
TryFrom<
ResponseRouterData<
VantivSyncResponse,
RouterDataV2<RSync, RefundFlowData, RefundSyncData, RefundsResponseData>,
>,
> for RouterDataV2<RSync, RefundFlowData, RefundSyncData, RefundsResponseData>
{
type Error = error_stack::Report<ConnectorError>;
fn try_from(
item: ResponseRouterData<
VantivSyncResponse,
RouterDataV2<RSync, RefundFlowData, RefundSyncData, RefundsResponseData>,
>,
) -> Result<Self, Self::Error> {
let status = match item.response.payment_status {
PaymentStatus::ProcessedSuccessfully => common_enums::RefundStatus::Success,
PaymentStatus::TransactionDeclined => common_enums::RefundStatus::Failure,
_ => item.router_data.resource_common_data.status,
};
let refunds_response = RefundsResponseData {
connector_refund_id: item
.response
.payment_id
.map(|id| id.to_string())
.unwrap_or_else(|| "unknown".to_string()),
refund_status: status,
status_code: item.http_code,
};
| {
"chunk": 17,
"crate": "connector-integration",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_mini_connector-integration_2054780185909450401_18 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/worldpayvantiv/transformers.rs
Ok(Self {
resource_common_data: RefundFlowData {
status,
..item.router_data.resource_common_data
},
response: Ok(refunds_response),
..item.router_data
})
}
}
// Step 114-123: TryFrom for Capture request and response
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
TryFrom<
WorldpayvantivRouterData<
RouterDataV2<Capture, PaymentFlowData, PaymentsCaptureData, PaymentsResponseData>,
T,
>,
> for CnpOnlineRequest<T>
{
type Error = error_stack::Report<ConnectorError>;
fn try_from(
item: WorldpayvantivRouterData<
RouterDataV2<Capture, PaymentFlowData, PaymentsCaptureData, PaymentsResponseData>,
T,
>,
) -> Result<Self, Self::Error> {
let auth = WorldpayvantivAuthType::try_from(&item.router_data.connector_auth_type)?;
let authentication = Authentication {
user: auth.user,
password: auth.password,
};
let cnp_txn_id = item
.router_data
.request
.get_connector_transaction_id()
.change_context(ConnectorError::MissingConnectorTransactionID)?;
let merchant_txn_id = item
.router_data
.resource_common_data
.connector_request_reference_id
.clone();
let capture = CaptureRequest {
id: format!("{}_{}", OperationId::Capture, merchant_txn_id),
report_group: "Default".to_string(),
cnp_txn_id,
amount: item.router_data.request.minor_amount_to_capture,
enhanced_data: None,
};
Ok(Self {
version: worldpayvantiv_constants::WORLDPAYVANTIV_VERSION.to_string(),
xmlns: worldpayvantiv_constants::XMLNS.to_string(),
merchant_id: auth.merchant_id,
authentication,
authorization: None,
sale: None,
capture: Some(capture),
auth_reversal: None,
void: None,
credit: None,
})
}
}
impl
TryFrom<
ResponseRouterData<
CnpOnlineResponse,
RouterDataV2<Capture, PaymentFlowData, PaymentsCaptureData, PaymentsResponseData>,
>,
> for RouterDataV2<Capture, PaymentFlowData, PaymentsCaptureData, PaymentsResponseData>
{
type Error = error_stack::Report<ConnectorError>;
fn try_from(
item: ResponseRouterData<
CnpOnlineResponse,
RouterDataV2<Capture, PaymentFlowData, PaymentsCaptureData, PaymentsResponseData>,
>,
) -> Result<Self, Self::Error> {
if let Some(capture_response) = item.response.capture_response {
let status = get_attempt_status(
WorldpayvantivPaymentFlow::Capture,
capture_response.response,
)?;
if is_payment_failure(status) {
let error_response = ErrorResponse {
code: capture_response.response.to_string(),
message: capture_response.message.clone(),
reason: Some(capture_response.message.clone()),
status_code: item.http_code,
attempt_status: Some(status),
connector_transaction_id: Some(capture_response.cnp_txn_id.clone()),
network_decline_code: None,
network_advice_code: None,
network_error_message: None,
};
Ok(Self {
resource_common_data: PaymentFlowData {
status,
..item.router_data.resource_common_data
},
response: Err(error_response),
..item.router_data
})
} else {
let payments_response = PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(
capture_response.cnp_txn_id.clone(),
),
redirection_data: None,
mandate_reference: None,
| {
"chunk": 18,
"crate": "connector-integration",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_mini_connector-integration_2054780185909450401_19 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/worldpayvantiv/transformers.rs
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: Some(capture_response.id.clone()),
incremental_authorization_allowed: None,
status_code: item.http_code,
};
Ok(Self {
resource_common_data: PaymentFlowData {
status,
..item.router_data.resource_common_data
},
response: Ok(payments_response),
..item.router_data
})
}
} else {
let error_response = ErrorResponse {
code: item.response.response_code,
message: item.response.message.clone(),
reason: Some(item.response.message.clone()),
status_code: item.http_code,
attempt_status: Some(common_enums::AttemptStatus::CaptureFailed),
connector_transaction_id: None,
network_decline_code: None,
network_advice_code: None,
network_error_message: None,
};
Ok(Self {
resource_common_data: PaymentFlowData {
status: common_enums::AttemptStatus::CaptureFailed,
..item.router_data.resource_common_data
},
response: Err(error_response),
..item.router_data
})
}
}
}
// Step 124-133: TryFrom for Void request and response
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
TryFrom<
WorldpayvantivRouterData<
RouterDataV2<Void, PaymentFlowData, PaymentVoidData, PaymentsResponseData>,
T,
>,
> for CnpOnlineRequest<T>
{
type Error = error_stack::Report<ConnectorError>;
fn try_from(
item: WorldpayvantivRouterData<
RouterDataV2<Void, PaymentFlowData, PaymentVoidData, PaymentsResponseData>,
T,
>,
) -> Result<Self, Self::Error> {
let auth = WorldpayvantivAuthType::try_from(&item.router_data.connector_auth_type)?;
let authentication = Authentication {
user: auth.user,
password: auth.password,
};
let cnp_txn_id = item.router_data.request.connector_transaction_id.clone();
let merchant_txn_id = item
.router_data
.resource_common_data
.connector_request_reference_id
.clone();
let void = VoidRequest {
id: format!("{}_{}", OperationId::Void, merchant_txn_id),
report_group: "Default".to_string(),
cnp_txn_id,
};
Ok(Self {
version: worldpayvantiv_constants::WORLDPAYVANTIV_VERSION.to_string(),
xmlns: worldpayvantiv_constants::XMLNS.to_string(),
merchant_id: auth.merchant_id,
authentication,
authorization: None,
sale: None,
capture: None,
auth_reversal: None,
void: Some(void),
credit: None,
})
}
}
impl
TryFrom<
ResponseRouterData<
CnpOnlineResponse,
RouterDataV2<Void, PaymentFlowData, PaymentVoidData, PaymentsResponseData>,
>,
> for RouterDataV2<Void, PaymentFlowData, PaymentVoidData, PaymentsResponseData>
{
type Error = error_stack::Report<ConnectorError>;
fn try_from(
item: ResponseRouterData<
CnpOnlineResponse,
RouterDataV2<Void, PaymentFlowData, PaymentVoidData, PaymentsResponseData>,
>,
) -> Result<Self, Self::Error> {
// Check for AuthReversal response first (pre-capture void)
if let Some(auth_reversal_response) = item.response.auth_reversal_response {
let status = get_attempt_status(
WorldpayvantivPaymentFlow::Void,
auth_reversal_response.response,
)?;
if is_payment_failure(status) {
let error_response = ErrorResponse {
code: auth_reversal_response.response.to_string(),
| {
"chunk": 19,
"crate": "connector-integration",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_mini_connector-integration_2054780185909450401_20 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/worldpayvantiv/transformers.rs
message: auth_reversal_response.message.clone(),
reason: Some(auth_reversal_response.message.clone()),
status_code: item.http_code,
attempt_status: Some(status),
connector_transaction_id: Some(auth_reversal_response.cnp_txn_id.clone()),
network_decline_code: None,
network_advice_code: None,
network_error_message: None,
};
Ok(Self {
resource_common_data: PaymentFlowData {
status,
..item.router_data.resource_common_data
},
response: Err(error_response),
..item.router_data
})
} else {
let payments_response = PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(
auth_reversal_response.cnp_txn_id.clone(),
),
redirection_data: None,
mandate_reference: None,
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: Some(auth_reversal_response.id.clone()),
incremental_authorization_allowed: None,
status_code: item.http_code,
};
Ok(Self {
resource_common_data: PaymentFlowData {
status,
..item.router_data.resource_common_data
},
response: Ok(payments_response),
..item.router_data
})
}
} else if let Some(void_response) = item.response.void_response {
// Fallback to void_response for compatibility
let status =
get_attempt_status(WorldpayvantivPaymentFlow::Void, void_response.response)?;
if is_payment_failure(status) {
let error_response = ErrorResponse {
code: void_response.response.to_string(),
message: void_response.message.clone(),
reason: Some(void_response.message.clone()),
status_code: item.http_code,
attempt_status: Some(status),
connector_transaction_id: Some(void_response.cnp_txn_id.clone()),
network_decline_code: None,
network_advice_code: None,
network_error_message: None,
};
Ok(Self {
resource_common_data: PaymentFlowData {
status,
..item.router_data.resource_common_data
},
response: Err(error_response),
..item.router_data
})
} else {
let payments_response = PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(
void_response.cnp_txn_id.clone(),
),
redirection_data: None,
mandate_reference: None,
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: Some(void_response.id.clone()),
incremental_authorization_allowed: None,
status_code: item.http_code,
};
Ok(Self {
resource_common_data: PaymentFlowData {
status,
..item.router_data.resource_common_data
},
response: Ok(payments_response),
..item.router_data
})
}
} else {
let error_response = ErrorResponse {
code: item.response.response_code,
message: item.response.message.clone(),
reason: Some(item.response.message.clone()),
status_code: item.http_code,
| {
"chunk": 20,
"crate": "connector-integration",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_mini_connector-integration_2054780185909450401_21 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/worldpayvantiv/transformers.rs
attempt_status: Some(common_enums::AttemptStatus::VoidFailed),
connector_transaction_id: None,
network_decline_code: None,
network_advice_code: None,
network_error_message: None,
};
Ok(Self {
resource_common_data: PaymentFlowData {
status: common_enums::AttemptStatus::VoidFailed,
..item.router_data.resource_common_data
},
response: Err(error_response),
..item.router_data
})
}
}
}
// TryFrom for VoidPC (VoidPostCapture) response
impl
TryFrom<
ResponseRouterData<
CnpOnlineResponse,
RouterDataV2<
VoidPC,
PaymentFlowData,
PaymentsCancelPostCaptureData,
PaymentsResponseData,
>,
>,
>
for RouterDataV2<VoidPC, PaymentFlowData, PaymentsCancelPostCaptureData, PaymentsResponseData>
{
type Error = error_stack::Report<ConnectorError>;
fn try_from(
item: ResponseRouterData<
CnpOnlineResponse,
RouterDataV2<
VoidPC,
PaymentFlowData,
PaymentsCancelPostCaptureData,
PaymentsResponseData,
>,
>,
) -> Result<Self, Self::Error> {
if let Some(void_response) = item.response.void_response {
let status =
get_attempt_status(WorldpayvantivPaymentFlow::VoidPC, void_response.response)?;
if is_payment_failure(status) {
let error_response = ErrorResponse {
code: void_response.response.to_string(),
message: void_response.message.clone(),
reason: Some(void_response.message.clone()),
status_code: item.http_code,
attempt_status: Some(status),
connector_transaction_id: Some(void_response.cnp_txn_id.clone()),
network_decline_code: None,
network_advice_code: None,
network_error_message: None,
};
Ok(Self {
resource_common_data: PaymentFlowData {
status,
..item.router_data.resource_common_data
},
response: Err(error_response),
..item.router_data
})
} else {
let payments_response = PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(
void_response.cnp_txn_id.clone(),
),
redirection_data: None,
mandate_reference: None,
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: Some(void_response.id.clone()),
incremental_authorization_allowed: None,
status_code: item.http_code,
};
Ok(Self {
resource_common_data: PaymentFlowData {
status,
..item.router_data.resource_common_data
},
response: Ok(payments_response),
..item.router_data
})
}
} else {
let error_response = ErrorResponse {
code: item.response.response_code,
message: item.response.message.clone(),
reason: Some(item.response.message.clone()),
status_code: item.http_code,
attempt_status: Some(common_enums::AttemptStatus::VoidFailed),
connector_transaction_id: None,
network_decline_code: None,
network_advice_code: None,
network_error_message: None,
};
Ok(Self {
resource_common_data: PaymentFlowData {
status: common_enums::AttemptStatus::VoidFailed,
..item.router_data.resource_common_data
},
response: Err(error_response),
| {
"chunk": 21,
"crate": "connector-integration",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_mini_connector-integration_2054780185909450401_22 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/worldpayvantiv/transformers.rs
..item.router_data
})
}
}
}
// Status mapping functions
fn get_attempt_status(
flow: WorldpayvantivPaymentFlow,
response: WorldpayvantivResponseCode,
) -> Result<common_enums::AttemptStatus, ConnectorError> {
match response {
WorldpayvantivResponseCode::Approved
| WorldpayvantivResponseCode::PartiallyApproved
| WorldpayvantivResponseCode::OfflineApproval
| WorldpayvantivResponseCode::TransactionReceived => match flow {
WorldpayvantivPaymentFlow::Sale => Ok(common_enums::AttemptStatus::Pending),
WorldpayvantivPaymentFlow::Auth => Ok(common_enums::AttemptStatus::Authorizing),
WorldpayvantivPaymentFlow::Capture => Ok(common_enums::AttemptStatus::CaptureInitiated),
WorldpayvantivPaymentFlow::Void => Ok(common_enums::AttemptStatus::VoidInitiated),
WorldpayvantivPaymentFlow::VoidPC => {
Ok(common_enums::AttemptStatus::VoidPostCaptureInitiated)
}
},
// Decline codes - all other response codes not listed above
WorldpayvantivResponseCode::InsufficientFunds
| WorldpayvantivResponseCode::CallIssuer
| WorldpayvantivResponseCode::ExceedsApprovalAmountLimit
| WorldpayvantivResponseCode::ExceedsActivityAmountLimit
| WorldpayvantivResponseCode::InvalidEffectiveDate
| WorldpayvantivResponseCode::InvalidAccountNumber
| WorldpayvantivResponseCode::AccountNumberDoesNotMatchPaymentType
| WorldpayvantivResponseCode::InvalidExpirationDate
| WorldpayvantivResponseCode::InvalidCVV
| WorldpayvantivResponseCode::InvalidCardValidationNum
| WorldpayvantivResponseCode::ExpiredCard
| WorldpayvantivResponseCode::InvalidPin
| WorldpayvantivResponseCode::InvalidTransactionType
| WorldpayvantivResponseCode::AccountNumberNotOnFile
| WorldpayvantivResponseCode::AccountNumberLocked
| WorldpayvantivResponseCode::InvalidLocation
| WorldpayvantivResponseCode::InvalidMerchantId
| WorldpayvantivResponseCode::InvalidLocation2
| WorldpayvantivResponseCode::InvalidMerchantClassCode
| WorldpayvantivResponseCode::InvalidExpirationDate2
| WorldpayvantivResponseCode::InvalidData
| WorldpayvantivResponseCode::InvalidPin2
| WorldpayvantivResponseCode::ExceedsNumberofPINEntryTries
| WorldpayvantivResponseCode::InvalidCryptoBox
| WorldpayvantivResponseCode::InvalidRequestFormat
| WorldpayvantivResponseCode::InvalidApplicationData
| WorldpayvantivResponseCode::InvalidMerchantCategoryCode
| WorldpayvantivResponseCode::TransactionCannotBeCompleted
| WorldpayvantivResponseCode::TransactionTypeNotSupportedForCard
| WorldpayvantivResponseCode::TransactionTypeNotAllowedAtTerminal
| WorldpayvantivResponseCode::GenericDecline
| WorldpayvantivResponseCode::DeclineByCard
| WorldpayvantivResponseCode::DoNotHonor
| WorldpayvantivResponseCode::InvalidMerchant
| WorldpayvantivResponseCode::PickUpCard
| WorldpayvantivResponseCode::CardOk
| WorldpayvantivResponseCode::CallVoiceOperator
| WorldpayvantivResponseCode::StopRecurring
| WorldpayvantivResponseCode::NoChecking
| WorldpayvantivResponseCode::NoCreditAccount
| WorldpayvantivResponseCode::NoCreditAccountType
| WorldpayvantivResponseCode::InvalidCreditPlan
| WorldpayvantivResponseCode::InvalidTransactionCode
| WorldpayvantivResponseCode::TransactionNotPermittedToCardholderAccount
| WorldpayvantivResponseCode::TransactionNotPermittedToMerchant
| WorldpayvantivResponseCode::PINTryExceeded
| WorldpayvantivResponseCode::SecurityViolation
| WorldpayvantivResponseCode::HardCapturePickUpCard
| WorldpayvantivResponseCode::ResponseReceivedTooLate
| WorldpayvantivResponseCode::SoftDecline
| WorldpayvantivResponseCode::ContactCardIssuer
| WorldpayvantivResponseCode::CallVoiceCenter
| WorldpayvantivResponseCode::InvalidMerchantTerminal
| WorldpayvantivResponseCode::InvalidAmount
| {
"chunk": 22,
"crate": "connector-integration",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_mini_connector-integration_2054780185909450401_23 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/worldpayvantiv/transformers.rs
| WorldpayvantivResponseCode::ResubmitTransaction
| WorldpayvantivResponseCode::InvalidTransaction
| WorldpayvantivResponseCode::MerchantNotFound
| WorldpayvantivResponseCode::PickUpCard2
| WorldpayvantivResponseCode::ExpiredCard2
| WorldpayvantivResponseCode::SuspectedFraud
| WorldpayvantivResponseCode::ContactCardIssuer2
| WorldpayvantivResponseCode::DoNotHonor2
| WorldpayvantivResponseCode::InvalidMerchant2
| WorldpayvantivResponseCode::InsufficientFunds2
| WorldpayvantivResponseCode::AccountNumberNotOnFile2
| WorldpayvantivResponseCode::InvalidAmount2
| WorldpayvantivResponseCode::InvalidCardNumber
| WorldpayvantivResponseCode::InvalidExpirationDate3
| WorldpayvantivResponseCode::InvalidCVV2
| WorldpayvantivResponseCode::InvalidCardValidationNum2
| WorldpayvantivResponseCode::InvalidPin3
| WorldpayvantivResponseCode::CardRestricted
| WorldpayvantivResponseCode::OverCreditLimit
| WorldpayvantivResponseCode::AccountClosed
| WorldpayvantivResponseCode::AccountFrozen
| WorldpayvantivResponseCode::InvalidTransactionType2
| WorldpayvantivResponseCode::InvalidMerchantId2
| WorldpayvantivResponseCode::ProcessorNotAvailable
| WorldpayvantivResponseCode::NetworkTimeOut
| WorldpayvantivResponseCode::SystemError
| WorldpayvantivResponseCode::DuplicateTransaction
| WorldpayvantivResponseCode::VoiceAuthRequired
| WorldpayvantivResponseCode::AuthenticationRequired
| WorldpayvantivResponseCode::SecurityCodeRequired
| WorldpayvantivResponseCode::SecurityCodeNotMatch
| WorldpayvantivResponseCode::ZipCodeNotMatch
| WorldpayvantivResponseCode::AddressNotMatch
| WorldpayvantivResponseCode::AVSFailure
| WorldpayvantivResponseCode::CVVFailure
| WorldpayvantivResponseCode::ServiceNotAllowed
| WorldpayvantivResponseCode::CreditNotSupported
| WorldpayvantivResponseCode::InvalidCreditAmount
| WorldpayvantivResponseCode::CreditAmountExceedsDebitAmount
| WorldpayvantivResponseCode::RefundNotSupported
| WorldpayvantivResponseCode::InvalidRefundAmount
| WorldpayvantivResponseCode::RefundAmountExceedsOriginalAmount
| WorldpayvantivResponseCode::VoidNotSupported
| WorldpayvantivResponseCode::VoidNotAllowed
| WorldpayvantivResponseCode::CaptureNotSupported
| WorldpayvantivResponseCode::CaptureNotAllowed
| WorldpayvantivResponseCode::InvalidCaptureAmount
| WorldpayvantivResponseCode::CaptureAmountExceedsAuthAmount
| WorldpayvantivResponseCode::TransactionAlreadySettled
| WorldpayvantivResponseCode::TransactionAlreadyVoided
| WorldpayvantivResponseCode::TransactionAlreadyCaptured
| WorldpayvantivResponseCode::TransactionNotFound => match flow {
WorldpayvantivPaymentFlow::Sale => Ok(common_enums::AttemptStatus::Failure),
WorldpayvantivPaymentFlow::Auth => Ok(common_enums::AttemptStatus::AuthorizationFailed),
WorldpayvantivPaymentFlow::Capture => Ok(common_enums::AttemptStatus::CaptureFailed),
WorldpayvantivPaymentFlow::Void | WorldpayvantivPaymentFlow::VoidPC => {
Ok(common_enums::AttemptStatus::VoidFailed)
}
},
}
}
fn is_payment_failure(status: common_enums::AttemptStatus) -> bool {
matches!(
status,
common_enums::AttemptStatus::Failure
| common_enums::AttemptStatus::AuthorizationFailed
| common_enums::AttemptStatus::CaptureFailed
| common_enums::AttemptStatus::VoidFailed
)
}
| {
"chunk": 23,
"crate": "connector-integration",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_mini_connector-integration_8396971848464489452_0 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/authorizedotnet/transformers.rs
use common_enums::{self, enums, AttemptStatus, RefundStatus};
use common_utils::{consts, ext_traits::OptionExt, pii::Email, types::FloatMajorUnit};
use domain_types::{
connector_flow::{
Authorize, CreateConnectorCustomer, PSync, RSync, Refund, RepeatPayment, SetupMandate,
},
connector_types::{
ConnectorCustomerData, ConnectorCustomerResponse, MandateReference, MandateReferenceId,
PaymentFlowData, PaymentVoidData, PaymentsAuthorizeData, PaymentsCaptureData,
PaymentsResponseData, PaymentsSyncData, RefundFlowData, RefundSyncData, RefundsData,
RefundsResponseData, RepeatPaymentData, ResponseId, SetupMandateRequestData,
},
errors::ConnectorError,
payment_method_data::{
DefaultPCIHolder, PaymentMethodData, PaymentMethodDataTypes, RawCardNumber,
VaultTokenHolder,
},
router_data::{ConnectorAuthType, ErrorResponse},
router_data_v2::RouterDataV2,
};
use crate::types::ResponseRouterData;
// Alias to make the transition easier
type HsInterfacesConnectorError = ConnectorError;
use std::str::FromStr;
use error_stack::ResultExt;
use hyperswitch_masking::{ExposeInterface, PeekInterface, Secret};
use rand::distributions::{Alphanumeric, DistString};
use serde::{Deserialize, Serialize};
use serde_with::skip_serializing_none;
use super::AuthorizedotnetRouterData;
type Error = error_stack::Report<domain_types::errors::ConnectorError>;
// Constants
const MAX_ID_LENGTH: usize = 20;
// Helper functions for creating RawCardNumber from string
fn create_raw_card_number_for_default_pci(
card_string: String,
) -> Result<RawCardNumber<DefaultPCIHolder>, Error> {
let card_number = cards::CardNumber::from_str(&card_string)
.change_context(ConnectorError::RequestEncodingFailed)?;
Ok(RawCardNumber(card_number))
}
fn create_raw_card_number_for_vault_token(card_string: String) -> RawCardNumber<VaultTokenHolder> {
RawCardNumber(card_string)
}
fn get_random_string() -> String {
Alphanumeric.sample_string(&mut rand::thread_rng(), MAX_ID_LENGTH)
}
/// Returns invoice number if length <= MAX_ID_LENGTH, otherwise random string
fn get_invoice_number_or_random(merchant_order_reference_id: Option<String>) -> String {
match merchant_order_reference_id {
Some(num) if num.len() <= MAX_ID_LENGTH => num,
None | Some(_) => get_random_string(),
}
}
/// Returns customer ID only if length <= MAX_ID_LENGTH
fn validate_customer_id_length(customer_id: Option<String>) -> Option<String> {
customer_id.filter(|id| id.len() <= MAX_ID_LENGTH)
}
/// Convert metadata to UserFields with optional serialization
fn metadata_to_user_fields(
metadata: Option<serde_json::Value>,
needs_serialization: bool,
) -> Result<Option<UserFields>, Error> {
let meta = match metadata {
Some(m) => m,
None => return Ok(None),
};
let value = if needs_serialization {
serde_json::to_value(meta).change_context(ConnectorError::RequestEncodingFailed)?
} else {
meta
};
Ok(Some(UserFields {
user_field: Vec::<UserField>::foreign_try_from(value)?,
}))
}
// // Helper traits for working with generic types
// trait RawCardNumberExt<T: PaymentMethodDataTypes> {
// fn peek(&self) -> &str;
// }
// trait CardExt<T: PaymentMethodDataTypes> {
// fn get_expiry_date_as_yyyymm(&self, separator: &str) -> Secret<String>;
// }
// // Implementations for DefaultPCIHolder
// impl RawCardNumberExt<DefaultPCIHolder> for RawCardNumber<DefaultPCIHolder> {
// fn peek(&self) -> &str {
// self.0.peek()
// }
// }
// impl CardExt<DefaultPCIHolder> for domain_types::payment_method_data::Card<DefaultPCIHolder> {
// fn get_expiry_date_as_yyyymm(&self, separator: &str) -> Secret<String> {
// Secret::new(format!("{}{}{}",
// self.card_exp_year.peek(),
// separator,
// self.card_exp_month.peek()
// ))
// }
// }
// // Implementations for VaultTokenHolder
// impl RawCardNumberExt<VaultTokenHolder> for RawCardNumber<VaultTokenHolder> {
// fn peek(&self) -> &str {
// &self.0
// }
// }
// impl CardExt<VaultTokenHolder> for domain_types::payment_method_data::Card<VaultTokenHolder> {
// fn get_expiry_date_as_yyyymm(&self, separator: &str) -> Secret<String> {
| {
"chunk": 0,
"crate": "connector-integration",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_mini_connector-integration_8396971848464489452_1 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/authorizedotnet/transformers.rs
// Secret::new(format!("{}{}{}",
// self.card_exp_year.peek(),
// separator,
// self.card_exp_month.peek()
// ))
// }
// }
// Wrapper for RawCardNumber to provide construction methods
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
pub struct AuthorizedotnetRawCardNumber<T: PaymentMethodDataTypes>(pub RawCardNumber<T>);
impl AuthorizedotnetRawCardNumber<DefaultPCIHolder> {
pub fn from_card_number_string(card_number: String) -> Result<Self, Error> {
let card_number = cards::CardNumber::from_str(&card_number)
.change_context(ConnectorError::RequestEncodingFailed)?;
Ok(AuthorizedotnetRawCardNumber(RawCardNumber(card_number)))
}
}
impl AuthorizedotnetRawCardNumber<VaultTokenHolder> {
pub fn from_token_string(token: String) -> Self {
AuthorizedotnetRawCardNumber(RawCardNumber(token))
}
}
// Implement From to convert back to RawCardNumber
impl<T: PaymentMethodDataTypes> From<AuthorizedotnetRawCardNumber<T>> for RawCardNumber<T> {
fn from(wrapper: AuthorizedotnetRawCardNumber<T>) -> Self {
wrapper.0
}
}
// Re-export common enums for use in this file
pub mod api_enums {
pub use common_enums::Currency;
}
pub trait ForeignTryFrom<F>: Sized {
type Error;
fn foreign_try_from(from: F) -> Result<Self, Self::Error>;
}
#[skip_serializing_none]
#[derive(Debug, Serialize, Clone)]
#[serde(rename_all = "camelCase")]
pub struct MerchantAuthentication {
name: Secret<String>,
transaction_key: Secret<String>,
}
impl TryFrom<&ConnectorAuthType> for MerchantAuthentication {
type Error = Error;
fn try_from(auth_type: &ConnectorAuthType) -> Result<Self, Self::Error> {
match auth_type {
ConnectorAuthType::BodyKey { api_key, key1 } => Ok(Self {
name: api_key.clone(),
transaction_key: key1.clone(),
}),
_ => Err(error_stack::report!(ConnectorError::FailedToObtainAuthType)),
}
}
}
impl ForeignTryFrom<serde_json::Value> for Vec<UserField> {
type Error = Error;
fn foreign_try_from(metadata: serde_json::Value) -> Result<Self, Self::Error> {
let mut vector = Self::new();
if let serde_json::Value::Object(obj) = metadata {
for (key, value) in obj {
vector.push(UserField {
name: key,
value: match value {
serde_json::Value::String(s) => s,
_ => value.to_string(),
},
});
}
}
Ok(vector)
}
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "lowercase")]
pub enum AuthorizationType {
Final,
Pre,
}
impl TryFrom<enums::CaptureMethod> for AuthorizationType {
type Error = error_stack::Report<domain_types::errors::ConnectorError>;
fn try_from(capture_method: enums::CaptureMethod) -> Result<Self, Self::Error> {
match capture_method {
enums::CaptureMethod::Manual => Ok(Self::Pre),
enums::CaptureMethod::SequentialAutomatic | enums::CaptureMethod::Automatic => {
Ok(Self::Final)
}
enums::CaptureMethod::ManualMultiple | enums::CaptureMethod::Scheduled => {
Err(error_stack::report!(ConnectorError::NotSupported {
message: "Capture method not supported".to_string(),
connector: "authorizedotnet",
}))?
}
}
}
}
#[skip_serializing_none]
#[derive(Debug, Serialize, Deserialize, Clone)]
#[serde(rename_all = "camelCase")]
pub struct CreditCardDetails<T: PaymentMethodDataTypes> {
card_number: RawCardNumber<T>,
expiration_date: Secret<String>, // YYYY-MM
card_code: Option<Secret<String>>,
}
#[derive(Debug, Serialize, Deserialize, Clone)]
#[serde(rename_all = "camelCase")]
pub enum PaymentDetails<T: PaymentMethodDataTypes> {
CreditCard(CreditCardDetails<T>),
}
#[skip_serializing_none]
#[derive(Debug, Serialize, Deserialize, Clone, PartialEq, Eq)]
#[serde(rename_all = "camelCase")]
pub enum TransactionType {
AuthOnlyTransaction,
AuthCaptureTransaction,
PriorAuthCaptureTransaction,
VoidTransaction,
RefundTransaction,
}
#[skip_serializing_none]
#[derive(Debug, Default, Serialize, Deserialize, Clone)]
| {
"chunk": 1,
"crate": "connector-integration",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_mini_connector-integration_8396971848464489452_2 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/authorizedotnet/transformers.rs
#[serde(rename_all = "camelCase")]
pub struct Order {
invoice_number: String,
description: String,
}
#[skip_serializing_none]
#[derive(Debug, Default, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct BillTo {
first_name: Option<Secret<String>>,
last_name: Option<Secret<String>>,
address: Option<Secret<String>>,
city: Option<String>,
state: Option<Secret<String>>,
zip: Option<Secret<String>>,
country: Option<enums::CountryAlpha2>,
}
#[skip_serializing_none]
#[derive(Debug, Default, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ShipTo {
first_name: Option<Secret<String>>,
last_name: Option<Secret<String>>,
company: Option<String>,
address: Option<Secret<String>>,
city: Option<String>,
state: Option<String>,
zip: Option<Secret<String>>,
country: Option<enums::CountryAlpha2>,
}
#[skip_serializing_none]
#[derive(Debug, Default, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct CustomerDetails {
id: String,
email: Option<Email>,
}
#[skip_serializing_none]
#[derive(Debug, Default, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct UserField {
name: String,
value: String,
}
#[skip_serializing_none]
#[derive(Debug, Default, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct UserFields {
user_field: Vec<UserField>,
}
#[skip_serializing_none]
#[derive(Debug, Default, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ProcessingOptions {
is_subsequent_auth: bool,
}
#[skip_serializing_none]
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct SubsequentAuthInformation {
original_network_trans_id: Secret<String>,
reason: Reason,
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "lowercase")]
pub enum Reason {
Resubmission,
#[serde(rename = "delayedCharge")]
DelayedCharge,
Reauthorization,
#[serde(rename = "noShow")]
NoShow,
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
struct AuthorizationIndicator {
authorization_indicator: AuthorizationType,
}
#[derive(Debug, Serialize)]
#[serde(untagged)]
pub enum ProfileDetails {
CreateProfileDetails(CreateProfileDetails),
CustomerProfileDetails(CustomerProfileDetails),
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct CreateProfileDetails {
create_profile: bool,
customer_profile_id: Option<Secret<String>>,
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct CustomerProfileDetails {
customer_profile_id: Secret<String>,
payment_profile: PaymentProfileDetails,
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct PaymentProfileDetails {
payment_profile_id: Secret<String>,
}
#[skip_serializing_none]
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct AuthorizedotnetTransactionRequest<T: PaymentMethodDataTypes> {
// General structure for transaction details in Authorize
transaction_type: TransactionType,
amount: Option<FloatMajorUnit>,
currency_code: Option<api_enums::Currency>,
payment: Option<PaymentDetails<T>>,
profile: Option<ProfileDetails>,
order: Option<Order>,
customer: Option<CustomerDetails>,
bill_to: Option<BillTo>,
user_fields: Option<UserFields>,
processing_options: Option<ProcessingOptions>,
subsequent_auth_information: Option<SubsequentAuthInformation>,
authorization_indicator_type: Option<AuthorizationIndicator>,
ref_trans_id: Option<String>,
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct TransactionSettings {
setting: Vec<TransactionSetting>,
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct TransactionSetting {
setting_name: String,
setting_value: String,
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct CreateTransactionRequest<T: PaymentMethodDataTypes> {
// Used by Authorize Flow, wraps the general transaction request
merchant_authentication: AuthorizedotnetAuthType,
ref_id: Option<String>,
transaction_request: AuthorizedotnetTransactionRequest<T>,
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct AuthorizedotnetPaymentsRequest<T: PaymentMethodDataTypes> {
// Top-level wrapper for Authorize Flow
create_transaction_request: CreateTransactionRequest<T>,
}
| {
"chunk": 2,
"crate": "connector-integration",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_mini_connector-integration_8396971848464489452_3 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/authorizedotnet/transformers.rs
// Implementation for owned RouterData that doesn't depend on reference version
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
TryFrom<
AuthorizedotnetRouterData<
RouterDataV2<
Authorize,
PaymentFlowData,
PaymentsAuthorizeData<T>,
PaymentsResponseData,
>,
T,
>,
> for AuthorizedotnetPaymentsRequest<T>
{
type Error = Error;
fn try_from(
item: AuthorizedotnetRouterData<
RouterDataV2<
Authorize,
PaymentFlowData,
PaymentsAuthorizeData<T>,
PaymentsResponseData,
>,
T,
>,
) -> Result<Self, Self::Error> {
let merchant_authentication =
AuthorizedotnetAuthType::try_from(&item.router_data.connector_auth_type)?;
let currency_str = item.router_data.request.currency.to_string();
let currency = api_enums::Currency::from_str(¤cy_str)
.map_err(|_| error_stack::report!(ConnectorError::RequestEncodingFailed))?;
// Always create regular transaction request (mandate logic moved to RepeatPayment flow)
let transaction_request = create_regular_transaction_request(&item, currency)?;
let ref_id = Some(
item.router_data
.resource_common_data
.connector_request_reference_id
.clone(),
)
.filter(|id| id.len() <= MAX_ID_LENGTH);
let create_transaction_request = CreateTransactionRequest {
merchant_authentication,
ref_id,
transaction_request,
};
Ok(AuthorizedotnetPaymentsRequest {
create_transaction_request,
})
}
}
// Helper function to create regular transaction request (non-mandate)
fn create_regular_transaction_request<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>(
item: &AuthorizedotnetRouterData<
RouterDataV2<Authorize, PaymentFlowData, PaymentsAuthorizeData<T>, PaymentsResponseData>,
T,
>,
currency: api_enums::Currency,
) -> Result<AuthorizedotnetTransactionRequest<T>, Error> {
let card_data = match &item.router_data.request.payment_method_data {
PaymentMethodData::Card(card) => Ok(card),
_ => Err(ConnectorError::RequestEncodingFailed),
}?;
let expiry_month = card_data.card_exp_month.peek().clone();
let year = card_data.card_exp_year.peek().clone();
let expiry_year = if year.len() == 2 {
format!("20{year}")
} else {
year
};
let expiration_date = format!("{expiry_year}-{expiry_month}");
let credit_card_details = CreditCardDetails {
card_number: card_data.card_number.clone(),
expiration_date: Secret::new(expiration_date),
card_code: Some(card_data.card_cvc.clone()),
};
let payment_details = PaymentDetails::CreditCard(credit_card_details);
let transaction_type = match item.router_data.request.capture_method {
Some(enums::CaptureMethod::Manual) => TransactionType::AuthOnlyTransaction,
Some(enums::CaptureMethod::Automatic)
| None
| Some(enums::CaptureMethod::SequentialAutomatic) => {
TransactionType::AuthCaptureTransaction
}
Some(_) => {
return Err(error_stack::report!(ConnectorError::NotSupported {
message: "Capture method not supported".to_string(),
connector: "authorizedotnet",
}))
}
};
let order_description = item
.router_data
.resource_common_data
.connector_request_reference_id
.clone();
// Get invoice number (random string if > MAX_ID_LENGTH or None)
let invoice_number =
get_invoice_number_or_random(item.router_data.request.merchant_order_reference_id.clone());
let order = Order {
invoice_number,
description: order_description,
};
// Extract user fields from metadata
let user_fields = metadata_to_user_fields(item.router_data.request.metadata.clone(), false)?;
| {
"chunk": 3,
"crate": "connector-integration",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_mini_connector-integration_8396971848464489452_4 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/authorizedotnet/transformers.rs
// Process billing address
let billing_address = item
.router_data
.resource_common_data
.address
.get_payment_billing();
let bill_to = billing_address.as_ref().map(|billing| {
let first_name = billing.address.as_ref().and_then(|a| a.first_name.clone());
let last_name = billing.address.as_ref().and_then(|a| a.last_name.clone());
BillTo {
first_name,
last_name,
address: billing.address.as_ref().and_then(|a| a.line1.clone()),
city: billing.address.as_ref().and_then(|a| a.city.clone()),
state: billing.address.as_ref().and_then(|a| a.state.clone()),
zip: billing.address.as_ref().and_then(|a| a.zip.clone()),
country: billing
.address
.as_ref()
.and_then(|a| a.country)
.and_then(|api_country| {
enums::CountryAlpha2::from_str(&api_country.to_string()).ok()
}),
}
});
let customer_details = item
.router_data
.request
.customer_id
.as_ref()
.filter(|_| {
!item
.router_data
.request
.is_customer_initiated_mandate_payment()
})
.and_then(|customer| {
let customer_id = customer.get_string_repr();
(customer_id.len() <= MAX_ID_LENGTH).then_some(CustomerDetails {
id: customer_id.to_string(),
email: item.router_data.request.get_optional_email(),
})
});
// Check if we should create a profile for future mandate usage
let profile = item
.router_data
.request
.is_customer_initiated_mandate_payment()
.then(|| {
ProfileDetails::CreateProfileDetails(CreateProfileDetails {
create_profile: true,
customer_profile_id: item
.router_data
.resource_common_data
.connector_customer
.as_ref()
.map(|cid| Secret::new(cid.to_string())),
})
});
Ok(AuthorizedotnetTransactionRequest {
transaction_type,
amount: Some(
item.connector
.amount_converter
.convert(
item.router_data.request.minor_amount,
item.router_data.request.currency,
)
.change_context(ConnectorError::AmountConversionFailed)
.attach_printable("Failed to convert payment amount for authorize transaction")?,
),
currency_code: Some(currency),
payment: Some(payment_details),
profile,
order: Some(order),
customer: customer_details,
bill_to,
user_fields,
processing_options: None,
subsequent_auth_information: None,
authorization_indicator_type: match item.router_data.request.capture_method {
Some(capture_method) => Some(AuthorizationIndicator {
authorization_indicator: capture_method.try_into()?,
}),
None => None,
},
ref_trans_id: None,
})
}
// RepeatPayment request structures
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct AuthorizedotnetRepeatPaymentRequest {
create_transaction_request: CreateRepeatPaymentRequest,
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct CreateRepeatPaymentRequest {
merchant_authentication: AuthorizedotnetAuthType,
ref_id: Option<String>,
transaction_request: AuthorizedotnetRepeatPaymentTransactionRequest,
}
#[skip_serializing_none]
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct AuthorizedotnetRepeatPaymentTransactionRequest {
transaction_type: TransactionType,
amount: FloatMajorUnit,
currency_code: api_enums::Currency,
profile: Option<ProfileDetails>,
order: Option<Order>,
customer: Option<CustomerDetails>,
user_fields: Option<UserFields>,
processing_options: Option<ProcessingOptions>,
subsequent_auth_information: Option<SubsequentAuthInformation>,
authorization_indicator_type: Option<AuthorizationIndicator>,
}
// Implementation for RepeatPayment request conversion
impl<
| {
"chunk": 4,
"crate": "connector-integration",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_mini_connector-integration_8396971848464489452_5 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/authorizedotnet/transformers.rs
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
TryFrom<
AuthorizedotnetRouterData<
RouterDataV2<RepeatPayment, PaymentFlowData, RepeatPaymentData, PaymentsResponseData>,
T,
>,
> for AuthorizedotnetRepeatPaymentRequest
{
type Error = Error;
fn try_from(
item: AuthorizedotnetRouterData<
RouterDataV2<RepeatPayment, PaymentFlowData, RepeatPaymentData, PaymentsResponseData>,
T,
>,
) -> Result<Self, Self::Error> {
let merchant_authentication =
AuthorizedotnetAuthType::try_from(&item.router_data.connector_auth_type)?;
let currency_str = item.router_data.request.currency.to_string();
let currency = api_enums::Currency::from_str(¤cy_str)
.map_err(|_| error_stack::report!(ConnectorError::RequestEncodingFailed))?;
// Handle different mandate reference types with appropriate MIT structures
let (profile, processing_options, subsequent_auth_information) =
match &item.router_data.request.mandate_reference {
// Case 1: Mandate-based MIT (using stored customer profile)
MandateReferenceId::ConnectorMandateId(connector_mandate_ref) => {
let mandate_id = connector_mandate_ref
.get_connector_mandate_id()
.ok_or_else(|| {
error_stack::report!(ConnectorError::MissingRequiredField {
field_name: "connector_mandate_id"
})
})?;
// Parse mandate_id to extract customer_profile_id and payment_profile_id
let profile = mandate_id
.split_once('-')
.map(|(customer_profile_id, payment_profile_id)| {
ProfileDetails::CustomerProfileDetails(CustomerProfileDetails {
customer_profile_id: Secret::from(customer_profile_id.to_string()),
payment_profile: PaymentProfileDetails {
payment_profile_id: Secret::from(
payment_profile_id.to_string(),
),
},
})
})
.ok_or_else(|| {
error_stack::report!(ConnectorError::MissingRequiredField {
field_name: "valid mandate_id format (should contain '-')"
})
})?;
(
Some(profile),
Some(ProcessingOptions {
is_subsequent_auth: true,
}),
None, // No network transaction ID for mandate-based flow
)
}
// Case 2: Network mandate ID flow (PG agnostic with network trans ID)
MandateReferenceId::NetworkMandateId(network_trans_id) => (
None, // No customer profile for network transaction flow
Some(ProcessingOptions {
is_subsequent_auth: true,
}),
Some(SubsequentAuthInformation {
original_network_trans_id: Secret::new(network_trans_id.clone()),
reason: Reason::Resubmission,
}),
),
// Case 3: Network token with NTI - NOT SUPPORTED (same as Hyperswitch)
MandateReferenceId::NetworkTokenWithNTI(_) => {
return Err(error_stack::report!(ConnectorError::NotImplemented(
"Network token with NTI not supported for authorizedotnet".to_string(),
)))
}
};
// Order description should be connector_request_reference_id (same as Hyperswitch)
let order_description = item
.router_data
.resource_common_data
| {
"chunk": 5,
"crate": "connector-integration",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_mini_connector-integration_8396971848464489452_6 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/authorizedotnet/transformers.rs
.connector_request_reference_id
.clone();
// Get invoice number (random string if > MAX_ID_LENGTH or None)
let invoice_number = get_invoice_number_or_random(
item.router_data.request.merchant_order_reference_id.clone(),
);
let order = Order {
invoice_number,
description: order_description,
};
// Extract user fields from metadata (RepeatPayment metadata is HashMap, needs conversion to Value)
let user_fields = metadata_to_user_fields(
item.router_data
.request
.metadata
.clone()
.map(serde_json::to_value)
.transpose()
.change_context(ConnectorError::RequestEncodingFailed)?,
false, // Already serialized above
)?;
// ref_id should be connector_request_reference_id with MAX_ID_LENGTH check (same as Authorize flow)
let ref_id = Some(
item.router_data
.resource_common_data
.connector_request_reference_id
.clone(),
)
.filter(|id| id.len() <= MAX_ID_LENGTH);
let customer_id_string = validate_customer_id_length(
item.router_data
.resource_common_data
.customer_id
.as_ref()
.map(|cid| cid.get_string_repr().to_owned()),
);
let customer_details = customer_id_string.map(|cid| CustomerDetails {
id: cid,
email: item.router_data.request.email.clone(),
});
let transaction_request = AuthorizedotnetRepeatPaymentTransactionRequest {
transaction_type: TransactionType::AuthCaptureTransaction, // Repeat payments are typically captured immediately
amount: item
.connector
.amount_converter
.convert(
item.router_data.request.minor_amount,
item.router_data.request.currency,
)
.change_context(ConnectorError::AmountConversionFailed)
.attach_printable(
"Failed to convert payment amount for repeat payment transaction",
)?,
currency_code: currency,
profile,
order: Some(order),
customer: customer_details,
user_fields,
processing_options,
subsequent_auth_information,
authorization_indicator_type: match item.router_data.request.capture_method {
Some(capture_method) => Some(AuthorizationIndicator {
authorization_indicator: capture_method.try_into()?,
}),
None => None,
},
};
Ok(Self {
create_transaction_request: CreateRepeatPaymentRequest {
merchant_authentication,
ref_id,
transaction_request,
},
})
}
}
#[skip_serializing_none]
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct AuthorizedotnetCaptureTransactionInternal {
// Specific transaction details for Capture
transaction_type: TransactionType,
amount: FloatMajorUnit,
ref_trans_id: String,
}
#[skip_serializing_none]
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct CreateCaptureTransactionRequest {
// Used by Capture Flow, wraps specific capture transaction details
merchant_authentication: AuthorizedotnetAuthType,
transaction_request: AuthorizedotnetCaptureTransactionInternal,
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct AuthorizedotnetCaptureRequest {
// Top-level wrapper for Capture Flow
create_transaction_request: CreateCaptureTransactionRequest,
}
// New direct implementation for capture without relying on the reference version
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
TryFrom<
AuthorizedotnetRouterData<
RouterDataV2<
domain_types::connector_flow::Capture,
PaymentFlowData,
PaymentsCaptureData,
| {
"chunk": 6,
"crate": "connector-integration",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_mini_connector-integration_8396971848464489452_7 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/authorizedotnet/transformers.rs
PaymentsResponseData,
>,
T,
>,
> for AuthorizedotnetCaptureRequest
{
type Error = Error;
fn try_from(
item: AuthorizedotnetRouterData<
RouterDataV2<
domain_types::connector_flow::Capture,
PaymentFlowData,
PaymentsCaptureData,
PaymentsResponseData,
>,
T,
>,
) -> Result<Self, Self::Error> {
let router_data = &item.router_data;
let original_connector_txn_id = match &router_data.request.connector_transaction_id {
ResponseId::ConnectorTransactionId(id) => id.clone(),
_ => {
return Err(error_stack::report!(
HsInterfacesConnectorError::MissingRequiredField {
field_name: "connector_transaction_id"
}
));
}
};
let transaction_request_payload = AuthorizedotnetCaptureTransactionInternal {
transaction_type: TransactionType::PriorAuthCaptureTransaction,
amount: item
.connector
.amount_converter
.convert(
item.router_data.request.minor_amount_to_capture,
item.router_data.request.currency,
)
.change_context(ConnectorError::AmountConversionFailed)
.attach_printable("Failed to convert capture amount for capture transaction")?,
ref_trans_id: original_connector_txn_id,
};
let merchant_authentication =
AuthorizedotnetAuthType::try_from(&item.router_data.connector_auth_type)?;
let create_transaction_request_payload = CreateCaptureTransactionRequest {
merchant_authentication,
transaction_request: transaction_request_payload,
};
Ok(Self {
create_transaction_request: create_transaction_request_payload,
})
}
}
#[skip_serializing_none]
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct AuthorizedotnetTransactionVoidDetails {
// Specific transaction details for Void
transaction_type: TransactionType,
ref_trans_id: String,
amount: Option<f64>,
}
#[skip_serializing_none]
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct CreateTransactionVoidRequest {
// Used by Void Flow, wraps specific void transaction details
merchant_authentication: AuthorizedotnetAuthType,
ref_id: Option<String>,
transaction_request: AuthorizedotnetTransactionVoidDetails,
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct AuthorizedotnetVoidRequest {
// Top-level wrapper for Void Flow
create_transaction_request: CreateTransactionVoidRequest,
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct AuthorizedotnetAuthType {
name: Secret<String>,
transaction_key: Secret<String>,
}
impl TryFrom<&ConnectorAuthType> for AuthorizedotnetAuthType {
type Error = error_stack::Report<ConnectorError>;
fn try_from(auth_type: &ConnectorAuthType) -> Result<Self, Self::Error> {
if let ConnectorAuthType::BodyKey { api_key, key1 } = auth_type {
Ok(Self {
name: api_key.to_owned(),
transaction_key: key1.to_owned(),
})
} else {
Err(ConnectorError::FailedToObtainAuthType)?
}
}
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
TryFrom<
AuthorizedotnetRouterData<
RouterDataV2<
domain_types::connector_flow::Void,
PaymentFlowData,
domain_types::connector_types::PaymentVoidData,
PaymentsResponseData,
>,
T,
>,
> for AuthorizedotnetVoidRequest
{
type Error = Error;
fn try_from(
item: AuthorizedotnetRouterData<
RouterDataV2<
domain_types::connector_flow::Void,
PaymentFlowData,
domain_types::connector_types::PaymentVoidData,
PaymentsResponseData,
>,
T,
>,
| {
"chunk": 7,
"crate": "connector-integration",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_mini_connector-integration_8396971848464489452_8 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/authorizedotnet/transformers.rs
) -> Result<Self, Self::Error> {
let router_data = &item.router_data;
// Extract transaction ID from the connector_transaction_id string
// This transaction ID comes from the authorization response
let transaction_id = match router_data.request.connector_transaction_id.as_str() {
"" => {
return Err(error_stack::report!(
HsInterfacesConnectorError::MissingRequiredField {
field_name: "connector_transaction_id"
}
));
}
id => id.to_string(),
};
let ref_id = Some(
&item
.router_data
.resource_common_data
.connector_request_reference_id,
)
.filter(|id| !id.is_empty())
.cloned();
let ref_id = get_the_truncate_id(ref_id, MAX_ID_LENGTH);
let transaction_void_details = AuthorizedotnetTransactionVoidDetails {
transaction_type: TransactionType::VoidTransaction,
ref_trans_id: transaction_id,
amount: None,
};
let merchant_authentication =
AuthorizedotnetAuthType::try_from(&router_data.connector_auth_type)?;
let create_transaction_void_request = CreateTransactionVoidRequest {
merchant_authentication,
ref_id,
transaction_request: transaction_void_details,
};
Ok(Self {
create_transaction_request: create_transaction_void_request,
})
}
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct TransactionDetails {
pub merchant_authentication: MerchantAuthentication,
#[serde(rename = "transId")]
pub transaction_id: Option<String>,
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct AuthorizedotnetCreateSyncRequest {
pub get_transaction_details_request: TransactionDetails,
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct AuthorizedotnetRSyncRequest {
pub get_transaction_details_request: TransactionDetails,
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
TryFrom<
AuthorizedotnetRouterData<
RouterDataV2<PSync, PaymentFlowData, PaymentsSyncData, PaymentsResponseData>,
T,
>,
> for AuthorizedotnetCreateSyncRequest
{
type Error = Error;
fn try_from(
item: AuthorizedotnetRouterData<
RouterDataV2<PSync, PaymentFlowData, PaymentsSyncData, PaymentsResponseData>,
T,
>,
) -> Result<Self, Self::Error> {
// Extract connector_transaction_id from the request
let connector_transaction_id = match &item.router_data.request.connector_transaction_id {
ResponseId::ConnectorTransactionId(id) => id.clone(),
_ => {
return Err(error_stack::report!(
HsInterfacesConnectorError::MissingRequiredField {
field_name: "connector_transaction_id"
}
))
}
};
let merchant_authentication =
MerchantAuthentication::try_from(&item.router_data.connector_auth_type)?;
let payload = Self {
get_transaction_details_request: TransactionDetails {
merchant_authentication,
transaction_id: Some(connector_transaction_id),
},
};
Ok(payload)
}
}
// Implementation for the RSync flow to support refund synchronization
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
TryFrom<
AuthorizedotnetRouterData<
RouterDataV2<RSync, RefundFlowData, RefundSyncData, RefundsResponseData>,
T,
>,
> for AuthorizedotnetRSyncRequest
{
type Error = Error;
fn try_from(
item: AuthorizedotnetRouterData<
RouterDataV2<RSync, RefundFlowData, RefundSyncData, RefundsResponseData>,
T,
>,
) -> Result<Self, Self::Error> {
// Extract connector_refund_id from the request
| {
"chunk": 8,
"crate": "connector-integration",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_mini_connector-integration_8396971848464489452_9 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/authorizedotnet/transformers.rs
let connector_refund_id = if !item.router_data.request.connector_refund_id.is_empty() {
item.router_data.request.connector_refund_id.clone()
} else {
return Err(error_stack::report!(
HsInterfacesConnectorError::MissingRequiredField {
field_name: "connector_refund_id"
}
));
};
let merchant_authentication =
MerchantAuthentication::try_from(&item.router_data.connector_auth_type)?;
let payload = Self {
get_transaction_details_request: TransactionDetails {
merchant_authentication,
transaction_id: Some(connector_refund_id),
},
};
Ok(payload)
}
}
// Refund-related structs and implementations
#[skip_serializing_none]
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct AuthorizedotnetRefundCardDetails {
card_number: Secret<String>,
expiration_date: Secret<String>,
}
#[derive(Serialize, Deserialize, Debug, Clone)]
#[serde(rename_all = "camelCase")]
#[allow(dead_code)]
enum AuthorizedotnetRefundPaymentDetails<T: PaymentMethodDataTypes> {
CreditCard(CreditCardDetails<T>),
}
#[skip_serializing_none]
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct AuthorizedotnetRefundTransactionDetails<T: PaymentMethodDataTypes> {
transaction_type: TransactionType,
amount: FloatMajorUnit,
payment: PaymentDetails<T>,
ref_trans_id: String,
}
#[skip_serializing_none]
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct AuthorizedotnetRefundRequest<T: PaymentMethodDataTypes> {
create_transaction_request: CreateTransactionRefundRequest<T>,
}
#[skip_serializing_none]
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct CreateTransactionRefundRequest<T: PaymentMethodDataTypes> {
merchant_authentication: AuthorizedotnetAuthType,
ref_id: Option<String>,
transaction_request: AuthorizedotnetRefundTransactionDetails<T>,
}
#[skip_serializing_none]
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct CreditCardPayment {
credit_card: CreditCardInfo,
}
#[skip_serializing_none]
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct CreditCardInfo {
card_number: String,
expiration_date: String,
}
// Specific implementation for DefaultPCIHolder
impl
TryFrom<
AuthorizedotnetRouterData<
RouterDataV2<Refund, RefundFlowData, RefundsData, RefundsResponseData>,
DefaultPCIHolder,
>,
> for AuthorizedotnetRefundRequest<DefaultPCIHolder>
{
type Error = Error;
fn try_from(
item: AuthorizedotnetRouterData<
RouterDataV2<Refund, RefundFlowData, RefundsData, RefundsResponseData>,
DefaultPCIHolder,
>,
) -> Result<Self, Self::Error> {
// Get connector metadata which contains payment details
let payment_details = item
.router_data
.request
.refund_connector_metadata
.as_ref()
.get_required_value("refund_connector_metadata")
.change_context(HsInterfacesConnectorError::MissingRequiredField {
field_name: "refund_connector_metadata",
})?
.clone();
let merchant_authentication =
AuthorizedotnetAuthType::try_from(&item.router_data.connector_auth_type)?;
// Handle the payment details which might be a JSON string or a serde_json::Value
let payment_details_inner = payment_details.peek();
let payment_details_value = match payment_details_inner {
serde_json::Value::String(s) => {
serde_json::from_str::<serde_json::Value>(s.as_str())
.change_context(HsInterfacesConnectorError::RequestEncodingFailed)?
}
_ => payment_details_inner.clone(),
};
// For refunds, we need to reconstruct the payment details from the metadata
let payment_details = match payment_details_value.get("payment") {
Some(payment_obj) => {
if let Some(credit_card) = payment_obj.get("creditCard") {
let card_number = credit_card
.get("cardNumber")
| {
"chunk": 9,
"crate": "connector-integration",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_mini_connector-integration_8396971848464489452_10 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/authorizedotnet/transformers.rs
.and_then(|v| v.as_str())
.unwrap_or("****")
.to_string();
let expiration_date = credit_card
.get("expirationDate")
.and_then(|v| v.as_str())
.unwrap_or("YYYY-MM")
.to_string();
// For DefaultPCIHolder, create a proper CardNumber
let raw_card_number = create_raw_card_number_for_default_pci(card_number)?;
let credit_card_details = CreditCardDetails {
card_number: raw_card_number,
expiration_date: Secret::new(expiration_date),
card_code: None, // Not needed for refunds
};
PaymentDetails::CreditCard(credit_card_details)
} else {
return Err(error_stack::report!(
HsInterfacesConnectorError::MissingRequiredField {
field_name: "credit_card_details",
}
));
}
}
None => {
return Err(error_stack::report!(
HsInterfacesConnectorError::MissingRequiredField {
field_name: "payment_details",
}
));
}
};
// Build the refund transaction request with parsed payment details
let transaction_request = AuthorizedotnetRefundTransactionDetails {
transaction_type: TransactionType::RefundTransaction,
amount: item
.connector
.amount_converter
.convert(
item.router_data.request.minor_refund_amount,
item.router_data.request.currency,
)
.change_context(ConnectorError::AmountConversionFailed)
.attach_printable(
"Failed to convert refund amount for refund transaction (DefaultPCIHolder)",
)?,
payment: payment_details,
ref_trans_id: item.router_data.request.connector_transaction_id.clone(),
};
Ok(Self {
create_transaction_request: CreateTransactionRefundRequest {
merchant_authentication,
ref_id: Some(format!(
"refund_{}",
std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.unwrap()
.as_secs()
)),
transaction_request,
},
})
}
}
// Specific implementation for VaultTokenHolder
impl
TryFrom<
AuthorizedotnetRouterData<
RouterDataV2<Refund, RefundFlowData, RefundsData, RefundsResponseData>,
VaultTokenHolder,
>,
> for AuthorizedotnetRefundRequest<VaultTokenHolder>
{
type Error = Error;
fn try_from(
item: AuthorizedotnetRouterData<
RouterDataV2<Refund, RefundFlowData, RefundsData, RefundsResponseData>,
VaultTokenHolder,
>,
) -> Result<Self, Self::Error> {
// Get connector metadata which contains payment details
let payment_details = item
.router_data
.request
.refund_connector_metadata
.as_ref()
.get_required_value("refund_connector_metadata")
.change_context(HsInterfacesConnectorError::MissingRequiredField {
field_name: "refund_connector_metadata",
})?
.clone();
let merchant_authentication =
AuthorizedotnetAuthType::try_from(&item.router_data.connector_auth_type)?;
// Handle the payment details which might be a JSON string or a serde_json::Value
let payment_details_inner = payment_details.peek();
let payment_details_value = match payment_details_inner {
serde_json::Value::String(s) => {
serde_json::from_str::<serde_json::Value>(s.as_str())
.change_context(HsInterfacesConnectorError::RequestEncodingFailed)?
}
_ => payment_details_inner.clone(),
};
| {
"chunk": 10,
"crate": "connector-integration",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_mini_connector-integration_8396971848464489452_11 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/authorizedotnet/transformers.rs
// For refunds, we need to reconstruct the payment details from the metadata
let payment_details = match payment_details_value.get("payment") {
Some(payment_obj) => {
if let Some(credit_card) = payment_obj.get("creditCard") {
let card_number = credit_card
.get("cardNumber")
.and_then(|v| v.as_str())
.unwrap_or("****")
.to_string();
let expiration_date = credit_card
.get("expirationDate")
.and_then(|v| v.as_str())
.unwrap_or("YYYY-MM")
.to_string();
// For VaultTokenHolder, use the string directly as a token
let raw_card_number = create_raw_card_number_for_vault_token(card_number);
let credit_card_details = CreditCardDetails {
card_number: raw_card_number,
expiration_date: Secret::new(expiration_date),
card_code: None, // Not needed for refunds
};
PaymentDetails::CreditCard(credit_card_details)
} else {
return Err(error_stack::report!(
HsInterfacesConnectorError::MissingRequiredField {
field_name: "credit_card_details",
}
));
}
}
None => {
return Err(error_stack::report!(
HsInterfacesConnectorError::MissingRequiredField {
field_name: "payment_details",
}
));
}
};
// Build the refund transaction request with parsed payment details
let transaction_request = AuthorizedotnetRefundTransactionDetails {
transaction_type: TransactionType::RefundTransaction,
amount: item
.connector
.amount_converter
.convert(
item.router_data.request.minor_refund_amount,
item.router_data.request.currency,
)
.change_context(ConnectorError::AmountConversionFailed)
.attach_printable(
"Failed to convert refund amount for refund transaction (VaultTokenHolder)",
)?,
payment: payment_details,
ref_trans_id: item.router_data.request.connector_transaction_id.clone(),
};
let ref_id = Some(&item.router_data.request.refund_id)
.filter(|id| !id.is_empty())
.cloned();
let ref_id = get_the_truncate_id(ref_id, MAX_ID_LENGTH);
Ok(Self {
create_transaction_request: CreateTransactionRefundRequest {
merchant_authentication,
ref_id,
transaction_request,
},
})
}
}
// Refund request struct is fully implemented above
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(untagged)]
pub enum TransactionResponse {
AuthorizedotnetTransactionResponse(Box<AuthorizedotnetTransactionResponse>),
AuthorizedotnetTransactionResponseError(Box<AuthorizedotnetTransactionResponseError>),
}
// Base transaction response - used internally
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct TransactionProfileInfo {
customer_profile_id: String,
customer_payment_profile_id: String,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct AuthorizedotnetTransactionResponse {
response_code: AuthorizedotnetPaymentStatus,
#[serde(rename = "transId")]
transaction_id: String,
#[serde(default)]
transaction_status: Option<String>,
#[serde(default)]
network_trans_id: Option<Secret<String>>,
#[serde(default)]
pub(super) account_number: Option<Secret<String>>,
#[serde(default)]
pub(super) account_type: Option<Secret<String>>,
#[serde(default)]
pub(super) errors: Option<Vec<ErrorMessage>>,
#[serde(default)]
secure_acceptance: Option<SecureAcceptance>,
#[serde(default)]
| {
"chunk": 11,
"crate": "connector-integration",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_mini_connector-integration_8396971848464489452_12 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/authorizedotnet/transformers.rs
profile: Option<TransactionProfileInfo>,
#[serde(default, rename = "avsResultCode")]
avs_result_code: Option<String>,
}
// Create flow-specific response types
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct AuthorizedotnetAuthorizeResponse(pub AuthorizedotnetPaymentsResponse);
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct AuthorizedotnetCaptureResponse(pub AuthorizedotnetPaymentsResponse);
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct AuthorizedotnetVoidResponse(pub AuthorizedotnetPaymentsResponse);
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct AuthorizedotnetRepeatPaymentResponse(pub AuthorizedotnetPaymentsResponse);
// Helper function to get AVS response description based on the code
fn get_avs_response_description(code: &str) -> Option<&'static str> {
match code {
"A" => Some("The street address matched, but the postal code did not."),
"B" => Some("No address information was provided."),
"E" => Some("The AVS check returned an error."),
"G" => Some("The card was issued by a bank outside the U.S. and does not support AVS."),
"N" => Some("Neither the street address nor postal code matched."),
"P" => Some("AVS is not applicable for this transaction."),
"R" => Some("Retry — AVS was unavailable or timed out."),
"S" => Some("AVS is not supported by card issuer."),
"U" => Some("Address information is unavailable."),
"W" => Some("The US ZIP+4 code matches, but the street address does not."),
"X" => Some("Both the street address and the US ZIP+4 code matched."),
"Y" => Some("The street address and postal code matched."),
"Z" => Some("The postal code matched, but the street address did not."),
_ => None,
}
}
// Convert transaction response to additional payment method connector response
fn convert_to_additional_payment_method_connector_response(
transaction_response: &AuthorizedotnetTransactionResponse,
) -> Option<domain_types::router_data::AdditionalPaymentMethodConnectorResponse> {
match transaction_response.avs_result_code.as_deref() {
Some("P") | None => None,
Some(code) => {
let description = get_avs_response_description(code);
let payment_checks = serde_json::json!({
"avs_result_code": code,
"description": description
});
Some(
domain_types::router_data::AdditionalPaymentMethodConnectorResponse::Card {
authentication_data: None,
payment_checks: Some(payment_checks),
card_network: None,
domestic_network: None,
},
)
}
}
}
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct RefundResponse {
response_code: AuthorizedotnetRefundStatus,
#[serde(rename = "transId")]
transaction_id: String,
network_trans_id: Option<Secret<String>>,
pub account_number: Option<Secret<String>>,
pub errors: Option<Vec<ErrorMessage>>,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct AuthorizedotnetRefundResponse {
pub transaction_response: RefundResponse,
pub messages: ResponseMessages,
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct AuthorizedotnetCreateConnectorCustomerRequest<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> {
create_customer_profile_request: AuthorizedotnetZeroMandateRequest<T>,
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct AuthorizedotnetZeroMandateRequest<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> {
merchant_authentication: AuthorizedotnetAuthType,
profile: Profile<T>,
#[serde(skip_serializing_if = "Option::is_none")]
validation_mode: Option<ValidationMode>,
}
// ShipToList for customer shipping address
#[skip_serializing_none]
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
struct ShipToList {
first_name: Option<Secret<String>>,
last_name: Option<Secret<String>>,
| {
"chunk": 12,
"crate": "connector-integration",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_mini_connector-integration_8396971848464489452_13 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/authorizedotnet/transformers.rs
address: Option<Secret<String>>,
city: Option<String>,
state: Option<Secret<String>>,
zip: Option<Secret<String>>,
country: Option<common_enums::CountryAlpha2>,
phone_number: Option<Secret<String>>,
}
#[skip_serializing_none]
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
struct Profile<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> {
merchant_customer_id: Option<String>,
description: Option<String>,
email: Option<String>,
payment_profiles: Option<Vec<PaymentProfiles<T>>>,
ship_to_list: Option<Vec<ShipToList>>,
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
struct PaymentProfiles<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> {
customer_type: CustomerType,
payment: PaymentDetails<T>,
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "lowercase")]
pub enum CustomerType {
Individual,
Business,
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub enum ValidationMode {
// testMode performs a Luhn mod-10 check on the card number, without further validation at connector.
TestMode,
// liveMode submits a zero-dollar or one-cent transaction (depending on card type and processor support) to confirm that the card number belongs to an active credit or debit account.
LiveMode,
}
// SetupMandate request structures - adds payment profile to existing customer
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct AuthorizedotnetSetupMandateRequest<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> {
create_customer_payment_profile_request: AuthorizedotnetPaymentProfileRequest<T>,
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct AuthorizedotnetPaymentProfileRequest<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> {
merchant_authentication: AuthorizedotnetAuthType,
customer_profile_id: Secret<String>,
payment_profile: PaymentProfile<T>,
validation_mode: ValidationMode,
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct PaymentProfile<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> {
#[serde(skip_serializing_if = "Option::is_none")]
bill_to: Option<BillTo>,
payment: PaymentDetails<T>,
}
// SetupMandate response structure
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct AuthorizedotnetSetupMandateResponse {
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub customer_payment_profile_id_list: Vec<String>,
pub customer_profile_id: Option<String>,
#[serde(rename = "customerPaymentProfileId")]
pub customer_payment_profile_id: Option<String>,
pub validation_direct_response_list: Option<Vec<Secret<String>>>,
pub messages: ResponseMessages,
}
// PSync response wrapper - Using direct structure instead of wrapping AuthorizedotnetPaymentsResponse
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct AuthorizedotnetPSyncResponse {
pub transaction: Option<SyncTransactionResponse>,
pub messages: ResponseMessages,
}
// Implement From/TryFrom for the response types
impl From<AuthorizedotnetPaymentsResponse> for AuthorizedotnetAuthorizeResponse {
fn from(response: AuthorizedotnetPaymentsResponse) -> Self {
Self(response)
}
}
impl From<AuthorizedotnetPaymentsResponse> for AuthorizedotnetCaptureResponse {
fn from(response: AuthorizedotnetPaymentsResponse) -> Self {
Self(response)
}
}
impl From<AuthorizedotnetPaymentsResponse> for AuthorizedotnetVoidResponse {
fn from(response: AuthorizedotnetPaymentsResponse) -> Self {
Self(response)
}
}
impl From<AuthorizedotnetPaymentsResponse> for AuthorizedotnetRepeatPaymentResponse {
fn from(response: AuthorizedotnetPaymentsResponse) -> Self {
Self(response)
}
}
| {
"chunk": 13,
"crate": "connector-integration",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_mini_connector-integration_8396971848464489452_14 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/authorizedotnet/transformers.rs
// We no longer need the From implementation for AuthorizedotnetPSyncResponse since we're using the direct structure
// TryFrom implementations for the router data conversions
impl<
F,
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize
+ Serialize,
> TryFrom<ResponseRouterData<AuthorizedotnetAuthorizeResponse, Self>>
for RouterDataV2<F, PaymentFlowData, PaymentsAuthorizeData<T>, PaymentsResponseData>
{
type Error = error_stack::Report<HsInterfacesConnectorError>;
fn try_from(
value: ResponseRouterData<AuthorizedotnetAuthorizeResponse, Self>,
) -> Result<Self, Self::Error> {
let ResponseRouterData {
response,
router_data,
http_code,
} = value;
// Use our helper function to convert the response
let (status, response_result, connector_response_data) =
convert_to_payments_response_data_or_error(
&response.0,
http_code,
Operation::Authorize,
router_data.request.capture_method,
router_data
.resource_common_data
.raw_connector_response
.clone(),
)
.change_context(HsInterfacesConnectorError::ResponseHandlingFailed)?;
// Create a new RouterDataV2 with updated fields
let mut new_router_data = router_data;
// Update the status and connector_response in resource_common_data
let mut resource_common_data = new_router_data.resource_common_data.clone();
resource_common_data.status = status;
resource_common_data.connector_response = connector_response_data;
new_router_data.resource_common_data = resource_common_data;
// Set the response
new_router_data.response = response_result;
Ok(new_router_data)
}
}
impl<F> TryFrom<ResponseRouterData<AuthorizedotnetCaptureResponse, Self>>
for RouterDataV2<F, PaymentFlowData, PaymentsCaptureData, PaymentsResponseData>
{
type Error = error_stack::Report<HsInterfacesConnectorError>;
fn try_from(
value: ResponseRouterData<AuthorizedotnetCaptureResponse, Self>,
) -> Result<Self, Self::Error> {
let ResponseRouterData {
response,
router_data,
http_code,
} = value;
// Use our helper function to convert the response
let (status, response_result, connector_response_data) =
convert_to_payments_response_data_or_error(
&response.0,
http_code,
Operation::Capture,
None,
router_data
.resource_common_data
.raw_connector_response
.clone(),
)
.change_context(HsInterfacesConnectorError::ResponseHandlingFailed)?;
// Create a new RouterDataV2 with updated fields
let mut new_router_data = router_data;
// Update the status and connector_response in resource_common_data
let mut resource_common_data = new_router_data.resource_common_data.clone();
resource_common_data.status = status;
resource_common_data.connector_response = connector_response_data;
new_router_data.resource_common_data = resource_common_data;
// Set the response
new_router_data.response = response_result;
Ok(new_router_data)
}
}
impl<F> TryFrom<ResponseRouterData<AuthorizedotnetVoidResponse, Self>>
for RouterDataV2<F, PaymentFlowData, PaymentVoidData, PaymentsResponseData>
{
type Error = error_stack::Report<HsInterfacesConnectorError>;
fn try_from(
value: ResponseRouterData<AuthorizedotnetVoidResponse, Self>,
) -> Result<Self, Self::Error> {
let ResponseRouterData {
response,
router_data,
http_code,
} = value;
// Use our helper function to convert the response
let (status, response_result, connector_response_data) =
convert_to_payments_response_data_or_error(
&response.0,
http_code,
Operation::Void,
| {
"chunk": 14,
"crate": "connector-integration",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_mini_connector-integration_8396971848464489452_15 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/authorizedotnet/transformers.rs
None,
router_data
.resource_common_data
.raw_connector_response
.clone(),
)
.change_context(HsInterfacesConnectorError::ResponseHandlingFailed)?;
// Create a new RouterDataV2 with updated fields
let mut new_router_data = router_data;
// Update the status and connector_response in resource_common_data
let mut resource_common_data = new_router_data.resource_common_data.clone();
resource_common_data.status = status;
resource_common_data.connector_response = connector_response_data;
new_router_data.resource_common_data = resource_common_data;
// Set the response
new_router_data.response = response_result;
Ok(new_router_data)
}
}
impl<F> TryFrom<ResponseRouterData<AuthorizedotnetRepeatPaymentResponse, Self>>
for RouterDataV2<F, PaymentFlowData, RepeatPaymentData, PaymentsResponseData>
{
type Error = error_stack::Report<HsInterfacesConnectorError>;
fn try_from(
value: ResponseRouterData<AuthorizedotnetRepeatPaymentResponse, Self>,
) -> Result<Self, Self::Error> {
let ResponseRouterData {
response,
router_data,
http_code,
} = value;
// Dedicated RepeatPayment response handling (matching Hyperswitch)
let status = get_hs_status(
&response.0,
http_code,
Operation::Authorize,
Some(enums::CaptureMethod::Automatic),
);
// Extract connector response data
let connector_response_data = match &response.0.transaction_response {
Some(TransactionResponse::AuthorizedotnetTransactionResponse(trans_res)) => {
convert_to_additional_payment_method_connector_response(trans_res)
.map(domain_types::router_data::ConnectorResponseData::with_additional_payment_method_data)
}
_ => None,
};
let response_result = match &response.0.transaction_response {
Some(TransactionResponse::AuthorizedotnetTransactionResponse(transaction_response)) => {
// Check for errors in the response
let error = transaction_response.errors.as_ref().and_then(|errors| {
errors.first().map(|error| ErrorResponse {
code: error.error_code.clone(),
message: error.error_text.clone(),
reason: Some(error.error_text.clone()),
status_code: http_code,
attempt_status: Some(status),
connector_transaction_id: Some(transaction_response.transaction_id.clone()),
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
})
});
// Build connector_metadata from account_number
let connector_metadata = build_connector_metadata(transaction_response);
// Extract mandate_reference from transaction_response.profile (RepeatPayment returns profile info)
let mandate_reference = transaction_response.profile.as_ref().map(|profile| {
domain_types::connector_types::MandateReference {
connector_mandate_id: Some(format!(
"{}-{}",
profile.customer_profile_id, profile.customer_payment_profile_id
)),
payment_method_id: None,
}
});
match error {
Some(err) => Err(err),
None => Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(
transaction_response.transaction_id.clone(),
),
redirection_data: None,
mandate_reference: mandate_reference.map(Box::new),
connector_metadata,
network_txn_id: transaction_response
| {
"chunk": 15,
"crate": "connector-integration",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_mini_connector-integration_8396971848464489452_16 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/authorizedotnet/transformers.rs
.network_trans_id
.as_ref()
.map(|s| s.peek().clone()),
connector_response_reference_id: Some(
transaction_response.transaction_id.clone(),
),
incremental_authorization_allowed: None,
status_code: http_code,
}),
}
}
Some(TransactionResponse::AuthorizedotnetTransactionResponseError(_)) | None => {
let (error_code, error_message) = extract_error_details(&response.0, None);
Err(create_error_response(
http_code,
error_code,
error_message,
status,
None,
router_data
.resource_common_data
.raw_connector_response
.clone(),
))
}
};
// Create a new RouterDataV2 with updated fields
let mut new_router_data = router_data;
// Update the status and connector_response in resource_common_data
let mut resource_common_data = new_router_data.resource_common_data.clone();
resource_common_data.status = status;
resource_common_data.connector_response = connector_response_data;
new_router_data.resource_common_data = resource_common_data;
// Set the response
new_router_data.response = response_result;
Ok(new_router_data)
}
}
impl TryFrom<ResponseRouterData<AuthorizedotnetRefundResponse, Self>>
for RouterDataV2<Refund, RefundFlowData, RefundsData, RefundsResponseData>
{
type Error = error_stack::Report<HsInterfacesConnectorError>;
fn try_from(
value: ResponseRouterData<AuthorizedotnetRefundResponse, Self>,
) -> Result<Self, Self::Error> {
let ResponseRouterData {
response,
router_data,
http_code,
} = value;
let transaction_response = &response.transaction_response;
let refund_status = enums::RefundStatus::from(transaction_response.response_code.clone());
let error = transaction_response.errors.clone().and_then(|errors| {
errors.first().map(|error| ErrorResponse {
code: error.error_code.clone(),
message: error.error_text.clone(),
reason: Some(error.error_text.clone()),
status_code: http_code,
attempt_status: Some(AttemptStatus::Failure),
connector_transaction_id: Some(transaction_response.transaction_id.clone()),
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
})
});
// Create a new RouterDataV2 with updated fields
let mut new_router_data = router_data;
// Update the status in resource_common_data
let mut resource_common_data = new_router_data.resource_common_data.clone();
resource_common_data.status = refund_status;
new_router_data.resource_common_data = resource_common_data;
// Set the response based on whether there was an error
new_router_data.response = match error {
Some(err) => Err(err),
None => Ok(RefundsResponseData {
connector_refund_id: transaction_response.transaction_id.clone(),
refund_status,
status_code: http_code,
}),
};
Ok(new_router_data)
}
}
// Implementation for PSync flow
impl<F> TryFrom<ResponseRouterData<AuthorizedotnetPSyncResponse, Self>>
for RouterDataV2<F, PaymentFlowData, PaymentsSyncData, PaymentsResponseData>
{
type Error = error_stack::Report<HsInterfacesConnectorError>;
fn try_from(
value: ResponseRouterData<AuthorizedotnetPSyncResponse, Self>,
) -> Result<Self, Self::Error> {
let ResponseRouterData {
response,
router_data,
http_code,
} = value;
// No need to transform the response since we're using the direct structure
// Use the clean approach with the From trait implementation
| {
"chunk": 16,
"crate": "connector-integration",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_mini_connector-integration_8396971848464489452_17 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/authorizedotnet/transformers.rs
match response.transaction {
Some(transaction) => {
let payment_status = AttemptStatus::from(transaction.transaction_status);
// Create a new RouterDataV2 with updated fields
let mut new_router_data = router_data;
// Update the status in resource_common_data
let mut resource_common_data = new_router_data.resource_common_data.clone();
resource_common_data.status = payment_status;
new_router_data.resource_common_data = resource_common_data;
// Set the response
new_router_data.response = Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(
transaction.transaction_id.clone(),
),
redirection_data: None,
mandate_reference: None,
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: Some(transaction.transaction_id.clone()),
incremental_authorization_allowed: None,
status_code: http_code,
});
Ok(new_router_data)
}
None => {
// Handle missing transaction response
let status = match response.messages.result_code {
ResultCode::Error => AttemptStatus::Failure,
ResultCode::Ok => AttemptStatus::Pending,
};
let error_response = ErrorResponse {
status_code: http_code,
code: response
.messages
.message
.first()
.map(|m| m.code.clone())
.unwrap_or_else(|| consts::NO_ERROR_CODE.to_string()),
message: response
.messages
.message
.first()
.map(|m| m.text.clone())
.unwrap_or_else(|| consts::NO_ERROR_MESSAGE.to_string()),
reason: None,
attempt_status: Some(status),
connector_transaction_id: None,
network_decline_code: None,
network_advice_code: None,
network_error_message: None,
};
// Update router data with status and error response
let mut new_router_data = router_data;
let mut resource_common_data = new_router_data.resource_common_data.clone();
resource_common_data.status = status;
new_router_data.resource_common_data = resource_common_data;
new_router_data.response = Err(error_response);
Ok(new_router_data)
}
}
}
}
#[derive(Debug, Clone, Default, serde::Deserialize, serde::Serialize)]
pub enum AuthorizedotnetPaymentStatus {
#[serde(rename = "1")]
Approved,
#[serde(rename = "2")]
Declined,
#[serde(rename = "3")]
Error,
#[serde(rename = "4")]
#[default]
HeldForReview,
#[serde(rename = "5")]
RequiresAction, // Maps to hyperswitch_common_enums::enums::AttemptStatus::AuthenticationPending
}
#[derive(Debug, Clone, Default, serde::Deserialize, serde::Serialize)]
pub enum AuthorizedotnetRefundStatus {
#[serde(rename = "1")]
Approved,
#[serde(rename = "2")]
Declined,
#[serde(rename = "3")]
Error,
#[serde(rename = "4")]
#[default]
HeldForReview,
}
/// Helper function to extract error code and message from response
fn extract_error_details(
response: &AuthorizedotnetPaymentsResponse,
trans_res: Option<&AuthorizedotnetTransactionResponse>,
) -> (String, String) {
let error_code = trans_res
.and_then(|tr| {
tr.errors
.as_ref()
.and_then(|e| e.first().map(|e| e.error_code.clone()))
})
.or_else(|| response.messages.message.first().map(|m| m.code.clone()))
.unwrap_or_else(|| consts::NO_ERROR_CODE.to_string());
let error_message = trans_res
.and_then(|tr| {
tr.errors
| {
"chunk": 17,
"crate": "connector-integration",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_mini_connector-integration_8396971848464489452_18 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/authorizedotnet/transformers.rs
.as_ref()
.and_then(|e| e.first().map(|e| e.error_text.clone()))
})
.or_else(|| response.messages.message.first().map(|m| m.text.clone()))
.unwrap_or_else(|| consts::NO_ERROR_MESSAGE.to_string());
(error_code, error_message)
}
/// Helper function to create error response
fn create_error_response(
http_status_code: u16,
error_code: String,
error_message: String,
status: AttemptStatus,
connector_transaction_id: Option<String>,
_raw_connector_response: Option<Secret<String>>,
) -> ErrorResponse {
ErrorResponse {
status_code: http_status_code,
code: error_code,
message: error_message,
reason: None,
attempt_status: Some(status),
connector_transaction_id,
network_decline_code: None,
network_advice_code: None,
network_error_message: None,
}
}
impl From<AuthorizedotnetRefundStatus> for enums::RefundStatus {
fn from(item: AuthorizedotnetRefundStatus) -> Self {
match item {
AuthorizedotnetRefundStatus::Declined | AuthorizedotnetRefundStatus::Error => {
Self::Failure
}
AuthorizedotnetRefundStatus::Approved | AuthorizedotnetRefundStatus::HeldForReview => {
Self::Pending
}
}
}
}
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ErrorMessage {
pub error_code: String,
pub error_text: String,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(rename_all = "PascalCase")]
pub struct AuthorizedotnetTransactionResponseError {
_supplemental_data_qualification_indicator: i64,
}
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[serde(rename_all = "camelCase")]
pub struct SecureAcceptance {
// Define fields for SecureAcceptance if it's actually used and its structure is known
}
#[derive(Debug, Default, Clone, Deserialize, PartialEq, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ResponseMessage {
pub code: String,
pub text: String,
}
#[derive(Debug, Default, Clone, Deserialize, PartialEq, Serialize)]
#[serde(rename_all = "PascalCase")]
pub enum ResultCode {
#[default]
Ok,
Error,
}
#[derive(Debug, Default, Clone, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ResponseMessages {
result_code: ResultCode,
pub message: Vec<ResponseMessage>,
}
#[skip_serializing_none]
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct AuthorizedotnetPaymentsResponse {
pub transaction_response: Option<TransactionResponse>,
pub profile_response: Option<AuthorizedotnetNonZeroMandateResponse>,
pub messages: ResponseMessages,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct AuthorizedotnetNonZeroMandateResponse {
customer_profile_id: Option<String>,
customer_payment_profile_id_list: Option<Vec<String>>,
pub messages: ResponseMessages,
}
#[derive(Debug, PartialEq, Eq, Clone, Copy)]
pub enum Operation {
Authorize,
Capture,
Void,
Refund,
}
fn get_hs_status(
response: &AuthorizedotnetPaymentsResponse,
_http_status_code: u16,
operation: Operation,
capture_method: Option<enums::CaptureMethod>,
) -> AttemptStatus {
// Return failure immediately if result code is Error
if response.messages.result_code == ResultCode::Error {
return AttemptStatus::Failure;
}
// Handle case when transaction_response is None
if response.transaction_response.is_none() {
return match operation {
Operation::Void => AttemptStatus::Voided,
Operation::Authorize | Operation::Capture => AttemptStatus::Pending,
Operation::Refund => AttemptStatus::Failure,
};
}
// Now handle transaction_response cases
match response.transaction_response.as_ref().unwrap() {
TransactionResponse::AuthorizedotnetTransactionResponseError(_) => AttemptStatus::Failure,
TransactionResponse::AuthorizedotnetTransactionResponse(trans_res) => {
match trans_res.response_code {
AuthorizedotnetPaymentStatus::Declined | AuthorizedotnetPaymentStatus::Error => {
AttemptStatus::Failure
}
| {
"chunk": 18,
"crate": "connector-integration",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_mini_connector-integration_8396971848464489452_19 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/authorizedotnet/transformers.rs
AuthorizedotnetPaymentStatus::HeldForReview => AttemptStatus::Pending,
AuthorizedotnetPaymentStatus::RequiresAction => {
AttemptStatus::AuthenticationPending
}
AuthorizedotnetPaymentStatus::Approved => {
// For Approved status, determine specific status based on operation and capture method
match operation {
Operation::Authorize => match capture_method {
Some(enums::CaptureMethod::Manual) => AttemptStatus::Authorized,
_ => AttemptStatus::Charged, // Automatic or None defaults to Charged
},
Operation::Capture | Operation::Refund => AttemptStatus::Charged,
Operation::Void => AttemptStatus::Voided,
}
}
}
}
}
}
fn build_connector_metadata(
transaction_response: &AuthorizedotnetTransactionResponse,
) -> Option<serde_json::Value> {
// Check if accountNumber is available
// Note: accountType contains card brand (e.g., "MasterCard"), not expiration date
// Authorize.net does not return the expiration date in authorization response
// Debug logging to understand what we're receiving
tracing::info!(
"build_connector_metadata: account_number={:?}, account_type={:?}",
transaction_response
.account_number
.as_ref()
.map(|n| n.peek()),
transaction_response.account_type.as_ref().map(|t| t.peek())
);
if let Some(card_number) = &transaction_response.account_number {
let card_number_value = card_number.peek();
// Create nested credit card structure
let credit_card_data = serde_json::json!({
"cardNumber": card_number_value,
"expirationDate": "XXXX" // Hardcoded since Auth.net doesn't return it
});
// Serialize to JSON string for proto compatibility (proto expects map<string, string>)
let credit_card_json =
serde_json::to_string(&credit_card_data).unwrap_or_else(|_| "{}".to_string());
// Create flat metadata map with JSON string value
let metadata = serde_json::json!({
"creditCard": credit_card_json
});
tracing::info!(
"build_connector_metadata: Successfully built metadata: {:?}",
metadata
);
return Some(metadata);
}
tracing::warn!("build_connector_metadata: account_number is None, returning empty metadata");
None
}
type PaymentConversionResult = Result<
(
AttemptStatus,
Result<PaymentsResponseData, ErrorResponse>,
Option<domain_types::router_data::ConnectorResponseData>,
),
HsInterfacesConnectorError,
>;
pub fn convert_to_payments_response_data_or_error(
response: &AuthorizedotnetPaymentsResponse,
http_status_code: u16,
operation: Operation,
capture_method: Option<enums::CaptureMethod>,
raw_connector_response: Option<Secret<String>>,
) -> PaymentConversionResult {
let status = get_hs_status(response, http_status_code, operation, capture_method);
let is_successful_status = matches!(
status,
AttemptStatus::Authorized
| AttemptStatus::Pending
| AttemptStatus::AuthenticationPending
| AttemptStatus::Charged
| AttemptStatus::Voided
);
// Extract connector response data from transaction response if available
let connector_response_data = match &response.transaction_response {
Some(TransactionResponse::AuthorizedotnetTransactionResponse(trans_res)) => {
convert_to_additional_payment_method_connector_response(trans_res)
.map(domain_types::router_data::ConnectorResponseData::with_additional_payment_method_data)
}
_ => None,
};
let response_payload_result = match &response.transaction_response {
Some(TransactionResponse::AuthorizedotnetTransactionResponse(trans_res))
if is_successful_status =>
{
let connector_metadata = build_connector_metadata(trans_res);
// Extract mandate_reference from profile_response if available
| {
"chunk": 19,
"crate": "connector-integration",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_mini_connector-integration_8396971848464489452_20 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/authorizedotnet/transformers.rs
let mandate_reference = response.profile_response.as_ref().map(|profile_response| {
let payment_profile_id = profile_response
.customer_payment_profile_id_list
.as_ref()
.and_then(|list| list.first().cloned());
domain_types::connector_types::MandateReference {
connector_mandate_id: profile_response.customer_profile_id.as_ref().and_then(
|customer_profile_id| {
payment_profile_id.map(|payment_profile_id| {
format!("{customer_profile_id}-{payment_profile_id}")
})
},
),
payment_method_id: None,
}
});
Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(trans_res.transaction_id.clone()),
redirection_data: None,
connector_metadata,
mandate_reference: mandate_reference.map(Box::new),
network_txn_id: trans_res
.network_trans_id
.as_ref()
.map(|s| s.peek().clone()),
connector_response_reference_id: Some(trans_res.transaction_id.clone()),
incremental_authorization_allowed: None,
status_code: http_status_code,
})
}
Some(TransactionResponse::AuthorizedotnetTransactionResponse(trans_res)) => {
// Failure status or other non-successful statuses
let (error_code, error_message) = extract_error_details(response, Some(trans_res));
Err(create_error_response(
http_status_code,
error_code,
error_message,
status,
Some(trans_res.transaction_id.clone()),
raw_connector_response.clone(),
))
}
Some(TransactionResponse::AuthorizedotnetTransactionResponseError(_)) => {
let (error_code, error_message) = extract_error_details(response, None);
Err(create_error_response(
http_status_code,
error_code,
error_message,
status,
None,
raw_connector_response.clone(),
))
}
None if status == AttemptStatus::Voided && operation == Operation::Void => {
Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::NoResponseId,
redirection_data: None,
connector_metadata: None,
mandate_reference: None,
network_txn_id: None,
connector_response_reference_id: None,
incremental_authorization_allowed: None,
status_code: http_status_code,
})
}
None => {
let (error_code, error_message) = extract_error_details(response, None);
Err(create_error_response(
http_status_code,
error_code,
error_message,
status,
None,
raw_connector_response.clone(),
))
}
};
Ok((status, response_payload_result, connector_response_data))
}
// Transaction details for sync response used in PSync implementation
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub enum SyncStatus {
CapturedPendingSettlement,
SettledSuccessfully,
AuthorizedPendingCapture,
Declined,
Voided,
CouldNotVoid,
GeneralError,
RefundSettledSuccessfully,
RefundPendingSettlement,
#[serde(rename = "FDSPendingReview")]
FDSPendingReview,
#[serde(rename = "FDSAuthorizedPendingReview")]
FDSAuthorizedPendingReview,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct SyncTransactionResponse {
#[serde(rename = "transId")]
pub transaction_id: String,
#[serde(rename = "transactionStatus")]
pub transaction_status: SyncStatus,
pub response_code: Option<u8>,
pub response_reason_code: Option<u8>,
pub response_reason_description: Option<String>,
| {
"chunk": 20,
"crate": "connector-integration",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_mini_connector-integration_8396971848464489452_21 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/authorizedotnet/transformers.rs
pub network_trans_id: Option<String>,
// Additional fields available but not needed for our implementation
}
impl From<SyncStatus> for enums::AttemptStatus {
fn from(transaction_status: SyncStatus) -> Self {
match transaction_status {
SyncStatus::SettledSuccessfully | SyncStatus::CapturedPendingSettlement => {
Self::Charged
}
SyncStatus::AuthorizedPendingCapture => Self::Authorized,
SyncStatus::Declined => Self::AuthenticationFailed,
SyncStatus::Voided => Self::Voided,
SyncStatus::CouldNotVoid => Self::VoidFailed,
SyncStatus::GeneralError => Self::Failure,
SyncStatus::RefundSettledSuccessfully
| SyncStatus::RefundPendingSettlement
| SyncStatus::FDSPendingReview
| SyncStatus::FDSAuthorizedPendingReview => Self::Pending,
}
}
}
// Removing duplicate implementation
// RSync related types for Refund Sync
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub enum RSyncStatus {
RefundSettledSuccessfully,
RefundPendingSettlement,
Declined,
GeneralError,
Voided,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct RSyncTransactionResponse {
#[serde(rename = "transId")]
transaction_id: String,
transaction_status: RSyncStatus,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct AuthorizedotnetRSyncResponse {
transaction: Option<RSyncTransactionResponse>,
messages: ResponseMessages,
}
impl From<RSyncStatus> for enums::RefundStatus {
fn from(transaction_status: RSyncStatus) -> Self {
match transaction_status {
RSyncStatus::RefundSettledSuccessfully => Self::Success,
RSyncStatus::RefundPendingSettlement => Self::Pending,
RSyncStatus::Declined | RSyncStatus::GeneralError | RSyncStatus::Voided => {
Self::Failure
}
}
}
}
impl TryFrom<ResponseRouterData<AuthorizedotnetRSyncResponse, Self>>
for RouterDataV2<RSync, RefundFlowData, RefundSyncData, RefundsResponseData>
{
type Error = error_stack::Report<HsInterfacesConnectorError>;
fn try_from(
value: ResponseRouterData<AuthorizedotnetRSyncResponse, Self>,
) -> Result<Self, Self::Error> {
let ResponseRouterData {
response,
router_data,
http_code,
} = value;
match response.transaction {
Some(transaction) => {
let refund_status = enums::RefundStatus::from(transaction.transaction_status);
// Create a new RouterDataV2 with updated fields
let mut new_router_data = router_data;
// Update the status in resource_common_data
let mut resource_common_data = new_router_data.resource_common_data.clone();
resource_common_data.status = refund_status;
new_router_data.resource_common_data = resource_common_data;
// Set the response
new_router_data.response = Ok(RefundsResponseData {
connector_refund_id: transaction.transaction_id,
refund_status,
status_code: http_code,
});
Ok(new_router_data)
}
None => {
// Handle error response
let error_response = ErrorResponse {
status_code: http_code,
code: response
.messages
.message
.first()
.map(|m| m.code.clone())
.unwrap_or_else(|| consts::NO_ERROR_CODE.to_string()),
message: response
.messages
.message
.first()
.map(|m| m.text.clone())
.unwrap_or_else(|| consts::NO_ERROR_MESSAGE.to_string()),
reason: None,
attempt_status: Some(AttemptStatus::Failure),
connector_transaction_id: None,
network_decline_code: None,
network_advice_code: None,
| {
"chunk": 21,
"crate": "connector-integration",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_mini_connector-integration_8396971848464489452_22 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/authorizedotnet/transformers.rs
network_error_message: None,
};
// Update router data with error response
let mut new_router_data = router_data;
let mut resource_common_data = new_router_data.resource_common_data.clone();
resource_common_data.status = RefundStatus::Failure;
new_router_data.resource_common_data = resource_common_data;
new_router_data.response = Err(error_response);
Ok(new_router_data)
}
}
}
}
// SetupMandate (Zero Mandate) implementation
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
TryFrom<
AuthorizedotnetRouterData<
RouterDataV2<
SetupMandate,
PaymentFlowData,
SetupMandateRequestData<T>,
PaymentsResponseData,
>,
T,
>,
> for AuthorizedotnetSetupMandateRequest<T>
{
type Error = error_stack::Report<ConnectorError>;
fn try_from(
item: AuthorizedotnetRouterData<
RouterDataV2<
SetupMandate,
PaymentFlowData,
SetupMandateRequestData<T>,
PaymentsResponseData,
>,
T,
>,
) -> Result<Self, error_stack::Report<ConnectorError>> {
let ccard = match &item.router_data.request.payment_method_data {
PaymentMethodData::Card(card) => card,
_ => return Err(error_stack::report!(ConnectorError::RequestEncodingFailed)),
};
let merchant_authentication =
AuthorizedotnetAuthType::try_from(&item.router_data.connector_auth_type)?;
let validation_mode = match item.router_data.resource_common_data.test_mode {
Some(true) | None => ValidationMode::TestMode,
Some(false) => ValidationMode::LiveMode,
};
let customer_profile_id = item
.router_data
.resource_common_data
.connector_customer
.as_ref()
.ok_or(ConnectorError::MissingRequiredField {
field_name: "connector_customer_id is missing",
})?
.clone();
// Build billing address if present - use get_optional_billing() method
let bill_to = item
.router_data
.resource_common_data
.get_optional_billing()
.and_then(|billing| billing.address.as_ref())
.map(|address| BillTo {
first_name: address.first_name.clone(),
last_name: address.last_name.clone(),
address: address.line1.clone(),
city: address.city.clone(),
state: address.state.clone(),
zip: address.zip.clone(),
country: address.country,
});
// Create expiry date manually since we can't use the trait method generically
let expiry_month = ccard.card_exp_month.peek().clone();
let year = ccard.card_exp_year.peek().clone();
let expiry_year = if year.len() == 2 {
format!("20{year}")
} else {
year
};
let expiration_date = format!("{expiry_year}-{expiry_month}");
let payment_profile = PaymentProfile {
bill_to,
payment: PaymentDetails::CreditCard(CreditCardDetails {
card_number: ccard.card_number.clone(),
expiration_date: Secret::new(expiration_date),
card_code: Some(ccard.card_cvc.clone()),
}),
};
Ok(Self {
create_customer_payment_profile_request: AuthorizedotnetPaymentProfileRequest {
merchant_authentication,
customer_profile_id: Secret::new(customer_profile_id),
payment_profile,
validation_mode,
},
})
}
}
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct AuthorizedotnetCreateConnectorCustomerResponse {
pub customer_profile_id: Option<String>,
pub customer_payment_profile_id_list: Vec<String>,
pub validation_direct_response_list: Option<Vec<Secret<String>>>,
| {
"chunk": 22,
"crate": "connector-integration",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_mini_connector-integration_8396971848464489452_23 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/authorizedotnet/transformers.rs
pub messages: ResponseMessages,
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> TryFrom<ResponseRouterData<AuthorizedotnetSetupMandateResponse, Self>>
for RouterDataV2<
SetupMandate,
PaymentFlowData,
SetupMandateRequestData<T>,
PaymentsResponseData,
>
{
type Error = error_stack::Report<ConnectorError>;
fn try_from(
value: ResponseRouterData<AuthorizedotnetSetupMandateResponse, Self>,
) -> Result<Self, error_stack::Report<ConnectorError>> {
let ResponseRouterData {
response,
router_data,
http_code,
} = value;
// Get connector customer ID from resource_common_data - we need it to build mandate reference
let connector_customer_id = router_data
.resource_common_data
.connector_customer
.as_ref()
.ok_or(ConnectorError::MissingRequiredField {
field_name: "connector_customer_id",
})?
.clone();
// Check if we have a successful response:
// 1. resultCode == "Ok" (normal success)
// 2. OR we have customer profile ID AND payment profile ID (E00039 duplicate case)
// E00039 = "A duplicate customer payment profile already exists"
// This is acceptable for idempotent SetupMandate - profile is available for use
let is_success = response.messages.result_code == ResultCode::Ok
|| (response.customer_profile_id.is_some()
&& (response.customer_payment_profile_id.is_some()
|| !response.customer_payment_profile_id_list.is_empty()));
let status = if is_success {
AttemptStatus::Charged
} else {
AttemptStatus::Failure
};
let mut new_router_data = router_data;
let mut resource_common_data = new_router_data.resource_common_data.clone();
resource_common_data.status = status;
new_router_data.resource_common_data = resource_common_data;
if response.customer_profile_id.is_some() {
// Extract payment profile ID from response
let payment_profile_id = response
.customer_payment_profile_id_list
.first()
.or(response.customer_payment_profile_id.as_ref())
.ok_or(ConnectorError::ResponseDeserializationFailed)?;
// Create composite mandate ID: {customer_profile_id}-{payment_profile_id}
let connector_mandate_id = format!("{connector_customer_id}-{payment_profile_id}");
new_router_data.response = Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::NoResponseId,
redirection_data: None,
connector_metadata: None,
mandate_reference: Some(Box::new(MandateReference {
connector_mandate_id: Some(connector_mandate_id),
payment_method_id: None,
})),
network_txn_id: None,
connector_response_reference_id: None,
incremental_authorization_allowed: None,
status_code: http_code,
});
} else {
let error_response = ErrorResponse {
status_code: http_code,
code: response
.messages
.message
.first()
.map(|m| m.code.clone())
.unwrap_or_else(|| consts::NO_ERROR_CODE.to_string()),
message: response
.messages
.message
.first()
.map(|m| m.text.clone())
.unwrap_or_else(|| consts::NO_ERROR_MESSAGE.to_string()),
reason: None,
attempt_status: Some(AttemptStatus::Failure),
connector_transaction_id: None,
network_decline_code: None,
network_advice_code: None,
network_error_message: None,
};
new_router_data.response = Err(error_response);
}
| {
"chunk": 23,
"crate": "connector-integration",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_mini_connector-integration_8396971848464489452_24 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/authorizedotnet/transformers.rs
Ok(new_router_data)
}
}
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct AuthorizedotnetErrorResponse {
pub messages: ResponseMessages,
}
fn get_the_truncate_id(id: Option<String>, max_length: usize) -> Option<String> {
id.map(|s| {
if s.len() > max_length {
s[..max_length].to_string()
} else {
s
}
})
}
// Webhook-related structures
#[derive(Debug, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct AuthorizedotnetWebhookObjectId {
pub webhook_id: String,
pub event_type: AuthorizedotnetWebhookEvent,
pub payload: AuthorizedotnetWebhookPayload,
}
#[derive(Debug, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct AuthorizedotnetWebhookPayload {
pub id: Option<String>,
// Fields specific to customer creation webhooks
pub payment_profiles: Option<Vec<PaymentProfileInfo>>,
pub merchant_customer_id: Option<String>,
pub description: Option<String>,
pub entity_name: Option<String>,
// Fields specific to customer payment profile creation webhooks
pub customer_profile_id: Option<u64>,
pub customer_type: Option<String>,
}
#[derive(Debug, Clone, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct PaymentProfileInfo {
pub id: String,
pub customer_type: String,
}
#[derive(Debug, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct AuthorizedotnetWebhookEventType {
pub event_type: AuthorizedotnetIncomingWebhookEventType,
}
#[derive(Debug, Clone, Deserialize)]
pub enum AuthorizedotnetWebhookEvent {
#[serde(rename = "net.authorize.payment.authorization.created")]
AuthorizationCreated,
#[serde(rename = "net.authorize.payment.priorAuthCapture.created")]
PriorAuthCapture,
#[serde(rename = "net.authorize.payment.authcapture.created")]
AuthCapCreated,
#[serde(rename = "net.authorize.payment.capture.created")]
CaptureCreated,
#[serde(rename = "net.authorize.payment.void.created")]
VoidCreated,
#[serde(rename = "net.authorize.payment.refund.created")]
RefundCreated,
#[serde(rename = "net.authorize.customer.created")]
CustomerCreated,
#[serde(rename = "net.authorize.customer.paymentProfile.created")]
CustomerPaymentProfileCreated,
}
/// Including Unknown to map unknown webhook events
#[derive(Debug, Clone, Deserialize)]
pub enum AuthorizedotnetIncomingWebhookEventType {
#[serde(rename = "net.authorize.payment.authorization.created")]
AuthorizationCreated,
#[serde(rename = "net.authorize.payment.priorAuthCapture.created")]
PriorAuthCapture,
#[serde(rename = "net.authorize.payment.authcapture.created")]
AuthCapCreated,
#[serde(rename = "net.authorize.payment.capture.created")]
CaptureCreated,
#[serde(rename = "net.authorize.payment.void.created")]
VoidCreated,
#[serde(rename = "net.authorize.payment.refund.created")]
RefundCreated,
#[serde(rename = "net.authorize.customer.created")]
CustomerCreated,
#[serde(rename = "net.authorize.customer.paymentProfile.created")]
CustomerPaymentProfileCreated,
#[serde(other)]
Unknown,
}
impl From<AuthorizedotnetIncomingWebhookEventType> for interfaces::webhooks::IncomingWebhookEvent {
fn from(event_type: AuthorizedotnetIncomingWebhookEventType) -> Self {
match event_type {
AuthorizedotnetIncomingWebhookEventType::AuthorizationCreated
| AuthorizedotnetIncomingWebhookEventType::PriorAuthCapture
| AuthorizedotnetIncomingWebhookEventType::AuthCapCreated
| AuthorizedotnetIncomingWebhookEventType::CaptureCreated
| AuthorizedotnetIncomingWebhookEventType::VoidCreated
| AuthorizedotnetIncomingWebhookEventType::CustomerCreated
| AuthorizedotnetIncomingWebhookEventType::CustomerPaymentProfileCreated => {
Self::PaymentIntentSuccess
}
AuthorizedotnetIncomingWebhookEventType::RefundCreated => Self::RefundSuccess,
AuthorizedotnetIncomingWebhookEventType::Unknown => Self::EventNotSupported,
}
}
}
impl From<AuthorizedotnetWebhookEvent> for enums::AttemptStatus {
// status mapping reference https://developer.authorize.net/api/reference/features/webhooks.html#Event_Types_and_Payloads
| {
"chunk": 24,
"crate": "connector-integration",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_mini_connector-integration_8396971848464489452_25 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/authorizedotnet/transformers.rs
fn from(event_type: AuthorizedotnetWebhookEvent) -> Self {
match event_type {
AuthorizedotnetWebhookEvent::AuthorizationCreated => Self::Authorized,
AuthorizedotnetWebhookEvent::CaptureCreated
| AuthorizedotnetWebhookEvent::AuthCapCreated
| AuthorizedotnetWebhookEvent::PriorAuthCapture => Self::Charged,
AuthorizedotnetWebhookEvent::VoidCreated => Self::Voided,
AuthorizedotnetWebhookEvent::RefundCreated => Self::PartialCharged, // This will be used for refund status
AuthorizedotnetWebhookEvent::CustomerCreated => Self::Charged, // Customer profile creation indicates successful setup mandate
AuthorizedotnetWebhookEvent::CustomerPaymentProfileCreated => Self::Charged, // Payment profile creation indicates successful setup mandate
}
}
}
impl From<AuthorizedotnetWebhookEvent> for SyncStatus {
// status mapping reference https://developer.authorize.net/api/reference/features/webhooks.html#Event_Types_and_Payloads
fn from(event_type: AuthorizedotnetWebhookEvent) -> Self {
match event_type {
AuthorizedotnetWebhookEvent::AuthorizationCreated => Self::AuthorizedPendingCapture,
AuthorizedotnetWebhookEvent::CaptureCreated
| AuthorizedotnetWebhookEvent::AuthCapCreated => Self::CapturedPendingSettlement,
AuthorizedotnetWebhookEvent::PriorAuthCapture => Self::SettledSuccessfully,
AuthorizedotnetWebhookEvent::VoidCreated => Self::Voided,
AuthorizedotnetWebhookEvent::RefundCreated => Self::RefundSettledSuccessfully,
AuthorizedotnetWebhookEvent::CustomerCreated => Self::SettledSuccessfully, // Customer profile successfully created and settled
AuthorizedotnetWebhookEvent::CustomerPaymentProfileCreated => Self::SettledSuccessfully, // Payment profile successfully created and settled
}
}
}
pub fn get_trans_id(details: &AuthorizedotnetWebhookObjectId) -> Result<String, ConnectorError> {
match details.event_type {
AuthorizedotnetWebhookEvent::CustomerPaymentProfileCreated => {
// For payment profile creation, use the customer_profile_id as the primary identifier
if let Some(customer_profile_id) = details.payload.customer_profile_id {
tracing::debug!(
target: "authorizedotnet_webhook",
"Extracted customer profile ID {} for payment profile creation webhook",
customer_profile_id
);
Ok(customer_profile_id.to_string())
} else {
match details.payload.id.clone() {
Some(id) => {
tracing::debug!(
target: "authorizedotnet_webhook",
"Extracted transaction ID {} from payment profile webhook payload",
id
);
Ok(id)
}
None => {
tracing::error!(
target: "authorizedotnet_webhook",
"No customer_profile_id or id found in CustomerPaymentProfileCreated webhook payload"
);
Err(ConnectorError::WebhookReferenceIdNotFound)
}
}
}
}
_ => {
// For all other events, use the standard id field
match details.payload.id.clone() {
Some(id) => {
tracing::debug!(
target: "authorizedotnet_webhook",
"Extracted transaction ID {} for webhook event type: {:?}",
id,
details.event_type
);
Ok(id)
}
None => {
tracing::error!(
target: "authorizedotnet_webhook",
"No transaction ID found in webhook payload for event type: {:?}",
details.event_type
);
Err(ConnectorError::WebhookReferenceIdNotFound)
}
}
| {
"chunk": 25,
"crate": "connector-integration",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_mini_connector-integration_8396971848464489452_26 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/authorizedotnet/transformers.rs
}
}
}
impl TryFrom<AuthorizedotnetWebhookObjectId> for AuthorizedotnetPSyncResponse {
type Error = error_stack::Report<ConnectorError>;
fn try_from(item: AuthorizedotnetWebhookObjectId) -> Result<Self, Self::Error> {
Ok(Self {
transaction: Some(SyncTransactionResponse {
transaction_id: get_trans_id(&item)?,
transaction_status: SyncStatus::from(item.event_type),
response_code: Some(1),
response_reason_code: Some(1),
response_reason_description: Some("Approved".to_string()),
network_trans_id: None,
}),
messages: ResponseMessages {
result_code: ResultCode::Ok,
message: vec![ResponseMessage {
code: "I00001".to_string(),
text: "Successful.".to_string(),
}],
},
})
}
}
// Helper function to extract customer profile ID from error message
// Message format: "A duplicate record with ID 933042598 already exists."
fn extract_customer_id_from_error(error_text: &str) -> Option<String> {
// Look for pattern "ID <numbers>"
error_text
.split_whitespace()
.skip_while(|&word| word != "ID")
.nth(1) // Get the word after "ID"
.and_then(|id_str| {
// Remove any trailing punctuation and validate it's numeric
let cleaned = id_str.trim_end_matches(|c: char| !c.is_numeric());
if cleaned.chars().all(char::is_numeric) && !cleaned.is_empty() {
Some(cleaned.to_string())
} else {
None
}
})
}
// TryFrom implementations for CreateConnectorCustomer flow
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
TryFrom<
AuthorizedotnetRouterData<
RouterDataV2<
CreateConnectorCustomer,
PaymentFlowData,
ConnectorCustomerData,
ConnectorCustomerResponse,
>,
T,
>,
> for AuthorizedotnetCreateConnectorCustomerRequest<T>
{
type Error = Error;
fn try_from(
item: AuthorizedotnetRouterData<
RouterDataV2<
CreateConnectorCustomer,
PaymentFlowData,
ConnectorCustomerData,
ConnectorCustomerResponse,
>,
T,
>,
) -> Result<Self, Self::Error> {
let merchant_authentication =
AuthorizedotnetAuthType::try_from(&item.router_data.connector_auth_type)?;
// Build ship_to_list from shipping address if available
let ship_to_list = item
.router_data
.resource_common_data
.address
.get_shipping()
.and_then(|shipping| {
shipping.address.as_ref().map(|address| {
vec![ShipToList {
first_name: address.first_name.clone(),
last_name: address.last_name.clone(),
address: address.line1.clone(),
city: address.city.clone(),
state: address.state.clone(),
zip: address.zip.clone(),
country: address.country,
phone_number: shipping
.phone
.as_ref()
.and_then(|phone| phone.number.clone()),
}]
})
});
// Conditionally send merchant_customer_id (matching Hyperswitch parity)
// Only send if customer_id exists and length <= MAX_ID_LENGTH (20 chars)
let merchant_customer_id = validate_customer_id_length(
item.router_data
.request
.customer_id
.as_ref()
.map(|id| id.peek().clone()),
);
// Create a customer profile without payment method (zero mandate)
Ok(Self {
create_customer_profile_request: AuthorizedotnetZeroMandateRequest {
merchant_authentication,
profile: Profile {
| {
"chunk": 26,
"crate": "connector-integration",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_mini_connector-integration_8396971848464489452_27 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/authorizedotnet/transformers.rs
merchant_customer_id,
description: None,
email: item
.router_data
.request
.email
.as_ref()
.map(|e| e.peek().clone().expose().expose()),
payment_profiles: None,
ship_to_list,
},
validation_mode: None,
},
})
}
}
impl
TryFrom<
ResponseRouterData<
AuthorizedotnetCreateConnectorCustomerResponse,
RouterDataV2<
CreateConnectorCustomer,
PaymentFlowData,
ConnectorCustomerData,
ConnectorCustomerResponse,
>,
>,
>
for RouterDataV2<
CreateConnectorCustomer,
PaymentFlowData,
ConnectorCustomerData,
ConnectorCustomerResponse,
>
{
type Error = Error;
fn try_from(
value: ResponseRouterData<
AuthorizedotnetCreateConnectorCustomerResponse,
RouterDataV2<
CreateConnectorCustomer,
PaymentFlowData,
ConnectorCustomerData,
ConnectorCustomerResponse,
>,
>,
) -> Result<Self, Self::Error> {
let ResponseRouterData {
response,
router_data,
http_code,
} = value;
let mut new_router_data = router_data;
if let Some(profile_id) = response.customer_profile_id {
// Success - return the connector customer ID
new_router_data.response = Ok(ConnectorCustomerResponse {
connector_customer_id: profile_id,
});
} else {
// Check if this is a "duplicate customer" error (E00039)
let first_error = response.messages.message.first();
let error_code = first_error.map(|m| m.code.as_str()).unwrap_or("");
let error_text = first_error.map(|m| m.text.as_str()).unwrap_or("");
if error_code == "E00039" {
// Extract customer profile ID from error message
// Message format: "A duplicate record with ID 933042598 already exists."
if let Some(existing_profile_id) = extract_customer_id_from_error(error_text) {
tracing::info!(
"Customer profile already exists with ID: {}, treating as success",
existing_profile_id
);
new_router_data.response = Ok(ConnectorCustomerResponse {
connector_customer_id: existing_profile_id,
});
} else {
// Couldn't extract ID, return error
new_router_data.response = Err(ErrorResponse {
status_code: http_code,
code: error_code.to_string(),
message: error_text.to_string(),
reason: None,
attempt_status: None,
connector_transaction_id: None,
network_decline_code: None,
network_advice_code: None,
network_error_message: None,
});
}
} else {
// Other error - return error response
new_router_data.response = Err(ErrorResponse {
status_code: http_code,
code: error_code.to_string(),
message: error_text.to_string(),
reason: None,
attempt_status: None,
connector_transaction_id: None,
network_decline_code: None,
network_advice_code: None,
network_error_message: None,
});
}
}
Ok(new_router_data)
}
}
| {
"chunk": 27,
"crate": "connector-integration",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_mini_connector-integration_-6055618699977151850_0 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/payload/transformers.rs
use std::collections::HashMap;
use common_enums::enums;
use common_utils::{
consts::{NO_ERROR_CODE, NO_ERROR_MESSAGE},
ext_traits::ValueExt,
types::FloatMajorUnit,
};
use domain_types::{
connector_flow::{Authorize, Capture, RSync, Refund, SetupMandate, Void},
connector_types::{
MandateReference, PaymentFlowData, PaymentVoidData, PaymentsAuthorizeData,
PaymentsCaptureData, PaymentsResponseData, RefundFlowData, RefundSyncData, RefundsData,
RefundsResponseData, ResponseId, SetupMandateRequestData,
},
errors,
payment_method_data::{PaymentMethodData, PaymentMethodDataTypes},
router_data::{
AdditionalPaymentMethodConnectorResponse, ConnectorAuthType, ConnectorResponseData,
ErrorResponse,
},
router_data_v2::RouterDataV2,
};
use error_stack::ResultExt;
use hyperswitch_masking::{ExposeOptionInterface, Secret};
use serde::{Deserialize, Serialize};
use super::{requests, responses};
use crate::connectors::payload::{PayloadAmountConvertor, PayloadRouterData};
use crate::types::ResponseRouterData;
pub use super::requests::{
PayloadCaptureRequest, PayloadCardsRequestData, PayloadPaymentsRequest, PayloadRefundRequest,
PayloadRepeatPaymentRequest, PayloadVoidRequest,
};
pub use super::responses::{
PayloadAuthorizeResponse, PayloadCaptureResponse, PayloadErrorResponse, PayloadEventDetails,
PayloadPSyncResponse, PayloadPaymentsResponse, PayloadRSyncResponse, PayloadRefundResponse,
PayloadRepeatPaymentResponse, PayloadSetupMandateResponse, PayloadVoidResponse,
PayloadWebhookEvent, PayloadWebhooksTrigger,
};
type Error = error_stack::Report<errors::ConnectorError>;
// Constants
const PAYMENT_METHOD_TYPE_CARD: &str = "card";
// Helper function to check if capture method is manual
fn is_manual_capture(capture_method: Option<enums::CaptureMethod>) -> bool {
matches!(capture_method, Some(enums::CaptureMethod::Manual))
}
// Auth Struct
#[derive(Debug, Clone, Deserialize)]
pub struct PayloadAuth {
pub api_key: Secret<String>,
pub processing_account_id: Option<Secret<String>>,
}
#[derive(Debug, Clone)]
pub struct PayloadAuthType {
pub auths: HashMap<enums::Currency, PayloadAuth>,
}
impl TryFrom<(&ConnectorAuthType, enums::Currency)> for PayloadAuth {
type Error = Error;
fn try_from(value: (&ConnectorAuthType, enums::Currency)) -> Result<Self, Self::Error> {
let (auth_type, currency) = value;
match auth_type {
ConnectorAuthType::CurrencyAuthKey { auth_key_map } => {
let auth_key = auth_key_map.get(¤cy).ok_or(
errors::ConnectorError::CurrencyNotSupported {
message: currency.to_string(),
connector: "Payload",
},
)?;
auth_key
.to_owned()
.parse_value("PayloadAuth")
.change_context(errors::ConnectorError::FailedToObtainAuthType)
}
_ => Err(errors::ConnectorError::FailedToObtainAuthType.into()),
}
}
}
impl TryFrom<&ConnectorAuthType> for PayloadAuthType {
type Error = Error;
fn try_from(auth_type: &ConnectorAuthType) -> Result<Self, Self::Error> {
match auth_type {
ConnectorAuthType::CurrencyAuthKey { auth_key_map } => {
let auths = auth_key_map
.iter()
.map(|(currency, auth_key)| {
let auth: PayloadAuth = auth_key
.to_owned()
.parse_value("PayloadAuth")
.change_context(errors::ConnectorError::InvalidDataFormat {
field_name: "auth_key_map",
})?;
Ok((*currency, auth))
})
.collect::<Result<_, Self::Error>>()?;
Ok(Self { auths })
}
_ => Err(errors::ConnectorError::FailedToObtainAuthType.into()),
}
}
}
// Helper function to build card request data
fn build_payload_cards_request_data<T: PaymentMethodDataTypes>(
payment_method_data: &PaymentMethodData<T>,
connector_auth_type: &ConnectorAuthType,
currency: enums::Currency,
amount: FloatMajorUnit,
| {
"chunk": 0,
"crate": "connector-integration",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_mini_connector-integration_-6055618699977151850_1 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/payload/transformers.rs
resource_common_data: &PaymentFlowData,
capture_method: Option<enums::CaptureMethod>,
is_mandate: bool,
) -> Result<requests::PayloadCardsRequestData<T>, Error> {
if let PaymentMethodData::Card(req_card) = payment_method_data {
let payload_auth = PayloadAuth::try_from((connector_auth_type, currency))?;
let card = requests::PayloadCard {
number: req_card.card_number.clone(),
expiry: req_card.get_card_expiry_month_year_2_digit_with_delimiter("/".to_string())?,
cvc: req_card.card_cvc.clone(),
};
// Get billing address to access zip and state
let billing_addr = resource_common_data.get_billing_address()?;
let billing_address = requests::BillingAddress {
city: resource_common_data.get_billing_city()?,
country: resource_common_data.get_billing_country()?,
postal_code: billing_addr.zip.clone().ok_or(
errors::ConnectorError::MissingRequiredField {
field_name: "billing.address.zip",
},
)?,
state_province: billing_addr.state.clone().ok_or(
errors::ConnectorError::MissingRequiredField {
field_name: "billing.address.state",
},
)?,
street_address: resource_common_data.get_billing_line1()?,
};
// For manual capture, set status to "authorized"
let status = if is_manual_capture(capture_method) {
Some(responses::PayloadPaymentStatus::Authorized)
} else {
None
};
Ok(requests::PayloadCardsRequestData {
amount,
card,
transaction_types: requests::TransactionTypes::Payment,
payment_method_type: PAYMENT_METHOD_TYPE_CARD.to_string(),
status,
billing_address,
processing_id: payload_auth.processing_account_id,
keep_active: is_mandate,
})
} else {
Err(errors::ConnectorError::NotSupported {
message: "Payment method".to_string(),
connector: "Payload",
}
.into())
}
}
// TryFrom implementations for request bodies
// SetupMandate request
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
TryFrom<
PayloadRouterData<
RouterDataV2<
SetupMandate,
PaymentFlowData,
SetupMandateRequestData<T>,
PaymentsResponseData,
>,
T,
>,
> for requests::PayloadCardsRequestData<T>
{
type Error = Error;
fn try_from(
item: PayloadRouterData<
RouterDataV2<
SetupMandate,
PaymentFlowData,
SetupMandateRequestData<T>,
PaymentsResponseData,
>,
T,
>,
) -> Result<Self, Self::Error> {
let router_data = &item.router_data;
match router_data.request.amount {
Some(amount) if amount > 0 => Err(errors::ConnectorError::FlowNotSupported {
flow: "Setup mandate with non zero amount".to_string(),
connector: "Payload".to_string(),
}
.into()),
_ => {
// For SetupMandate, is_mandate is always true
build_payload_cards_request_data(
&router_data.request.payment_method_data,
&router_data.connector_auth_type,
router_data.request.currency,
FloatMajorUnit::zero(),
&router_data.resource_common_data,
None, // No capture_method for SetupMandate
true,
)
}
}
}
}
// Authorize request
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
TryFrom<
PayloadRouterData<
RouterDataV2<
Authorize,
PaymentFlowData,
PaymentsAuthorizeData<T>,
PaymentsResponseData,
>,
T,
>,
| {
"chunk": 1,
"crate": "connector-integration",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_mini_connector-integration_-6055618699977151850_2 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/payload/transformers.rs
> for requests::PayloadPaymentsRequest<T>
{
type Error = Error;
fn try_from(
item: PayloadRouterData<
RouterDataV2<
Authorize,
PaymentFlowData,
PaymentsAuthorizeData<T>,
PaymentsResponseData,
>,
T,
>,
) -> Result<Self, Self::Error> {
let router_data = &item.router_data;
// Convert amount using PayloadAmountConvertor
let amount = PayloadAmountConvertor::convert(
router_data.request.minor_amount,
router_data.request.currency,
)?;
match &router_data.request.payment_method_data {
PaymentMethodData::Card(_) => {
let is_mandate = router_data.request.is_mandate_payment();
let cards_data = build_payload_cards_request_data(
&router_data.request.payment_method_data,
&router_data.connector_auth_type,
router_data.request.currency,
amount,
&router_data.resource_common_data,
router_data.request.capture_method,
is_mandate,
)?;
Ok(Self::PayloadCardsRequest(Box::new(cards_data)))
}
// Payload connector supports GooglePay and ApplePay wallets, but not yet integrated
PaymentMethodData::Wallet(wallet_data) => match wallet_data {
domain_types::payment_method_data::WalletData::GooglePay(_)
| domain_types::payment_method_data::WalletData::ApplePay(_) => {
Err(errors::ConnectorError::NotImplemented("Payment method".to_string()).into())
}
_ => Err(errors::ConnectorError::NotSupported {
message: "Wallet".to_string(),
connector: "Payload",
}
.into()),
},
_ => Err(errors::ConnectorError::NotSupported {
message: "Payment method".to_string(),
connector: "Payload",
}
.into()),
}
}
}
// Capture request
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
TryFrom<
PayloadRouterData<
RouterDataV2<Capture, PaymentFlowData, PaymentsCaptureData, PaymentsResponseData>,
T,
>,
> for requests::PayloadCaptureRequest
{
type Error = Error;
fn try_from(
_item: PayloadRouterData<
RouterDataV2<Capture, PaymentFlowData, PaymentsCaptureData, PaymentsResponseData>,
T,
>,
) -> Result<Self, Self::Error> {
Ok(Self {
status: responses::PayloadPaymentStatus::Processed,
})
}
}
// Void request
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
TryFrom<
PayloadRouterData<
RouterDataV2<Void, PaymentFlowData, PaymentVoidData, PaymentsResponseData>,
T,
>,
> for requests::PayloadVoidRequest
{
type Error = Error;
fn try_from(
_item: PayloadRouterData<
RouterDataV2<Void, PaymentFlowData, PaymentVoidData, PaymentsResponseData>,
T,
>,
) -> Result<Self, Self::Error> {
Ok(Self {
status: responses::PayloadPaymentStatus::Voided,
})
}
}
// RepeatPayment request - for recurring/mandate payments
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
TryFrom<
PayloadRouterData<
RouterDataV2<
domain_types::connector_flow::RepeatPayment,
PaymentFlowData,
domain_types::connector_types::RepeatPaymentData,
PaymentsResponseData,
>,
T,
>,
> for requests::PayloadRepeatPaymentRequest<T>
{
type Error = Error;
fn try_from(
item: PayloadRouterData<
RouterDataV2<
domain_types::connector_flow::RepeatPayment,
| {
"chunk": 2,
"crate": "connector-integration",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_mini_connector-integration_-6055618699977151850_3 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/payload/transformers.rs
PaymentFlowData,
domain_types::connector_types::RepeatPaymentData,
PaymentsResponseData,
>,
T,
>,
) -> Result<Self, Self::Error> {
let router_data = &item.router_data;
// Convert amount using PayloadAmountConvertor
let amount = PayloadAmountConvertor::convert(
router_data.request.minor_amount,
router_data.request.currency,
)?;
// For manual capture, set status to "authorized"
let status = if is_manual_capture(router_data.request.capture_method) {
Some(responses::PayloadPaymentStatus::Authorized)
} else {
None
};
// RepeatPayment flow requires a mandate reference
let mandate_id = match &router_data.request.mandate_reference {
domain_types::connector_types::MandateReferenceId::ConnectorMandateId(
connector_mandate_ref,
) => connector_mandate_ref.get_connector_mandate_id().ok_or(
errors::ConnectorError::MissingRequiredField {
field_name: "connector_mandate_id",
},
)?,
_ => {
return Err(errors::ConnectorError::MissingRequiredField {
field_name: "connector_mandate_id for RepeatPayment",
}
.into())
}
};
Ok(Self::PayloadMandateRequest(Box::new(
requests::PayloadMandateRequestData {
amount,
transaction_types: requests::TransactionTypes::Payment,
payment_method_id: Secret::new(mandate_id),
status,
},
)))
}
}
// Refund request
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
TryFrom<
PayloadRouterData<
RouterDataV2<Refund, RefundFlowData, RefundsData, RefundsResponseData>,
T,
>,
> for requests::PayloadRefundRequest
{
type Error = Error;
fn try_from(
item: PayloadRouterData<
RouterDataV2<Refund, RefundFlowData, RefundsData, RefundsResponseData>,
T,
>,
) -> Result<Self, Self::Error> {
let router_data = &item.router_data;
let connector_transaction_id = router_data.request.connector_transaction_id.clone();
// Convert amount using PayloadAmountConvertor
let amount = PayloadAmountConvertor::convert(
router_data.request.minor_refund_amount,
router_data.request.currency,
)?;
Ok(Self {
transaction_type: requests::TransactionTypes::Refund,
amount,
ledger_assoc_transaction_id: connector_transaction_id,
})
}
}
// TryFrom implementations for response bodies
impl From<responses::PayloadPaymentStatus> for common_enums::AttemptStatus {
fn from(item: responses::PayloadPaymentStatus) -> Self {
match item {
responses::PayloadPaymentStatus::Authorized => Self::Authorized,
responses::PayloadPaymentStatus::Processed => Self::Charged,
responses::PayloadPaymentStatus::Processing => Self::Pending,
responses::PayloadPaymentStatus::Rejected
| responses::PayloadPaymentStatus::Declined => Self::Failure,
responses::PayloadPaymentStatus::Voided => Self::Voided,
}
}
}
// Common function to handle PayloadPaymentsResponse
fn handle_payment_response<F, T>(
response: responses::PayloadPaymentsResponse,
router_data: RouterDataV2<F, PaymentFlowData, T, PaymentsResponseData>,
http_code: u16,
is_mandate_payment: bool,
) -> Result<RouterDataV2<F, PaymentFlowData, T, PaymentsResponseData>, Error> {
match response {
responses::PayloadPaymentsResponse::PayloadCardsResponse(card_response) => {
let status = common_enums::AttemptStatus::from(card_response.status);
let mandate_reference = if is_mandate_payment {
let connector_payment_method_id = card_response
.connector_payment_method_id
.clone()
.expose_option();
| {
"chunk": 3,
"crate": "connector-integration",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_mini_connector-integration_-6055618699977151850_4 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/payload/transformers.rs
connector_payment_method_id.map(|id| MandateReference {
connector_mandate_id: Some(id),
payment_method_id: None,
})
} else {
None
};
let connector_response = card_response
.avs
.map(|avs_response| {
let payment_checks = serde_json::json!({
"avs_result": avs_response
});
AdditionalPaymentMethodConnectorResponse::Card {
authentication_data: None,
payment_checks: Some(payment_checks),
card_network: None,
domestic_network: None,
}
})
.map(ConnectorResponseData::with_additional_payment_method_data);
let response_result = if status == common_enums::AttemptStatus::Failure {
Err(ErrorResponse {
attempt_status: None,
code: card_response
.status_code
.clone()
.unwrap_or_else(|| NO_ERROR_CODE.to_string()),
message: card_response
.status_message
.clone()
.unwrap_or_else(|| NO_ERROR_MESSAGE.to_string()),
reason: card_response.status_message,
status_code: http_code,
connector_transaction_id: Some(card_response.transaction_id.clone()),
network_decline_code: None,
network_advice_code: None,
network_error_message: None,
})
} else {
Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(card_response.transaction_id),
redirection_data: None,
mandate_reference: mandate_reference.map(Box::new),
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: card_response.ref_number,
incremental_authorization_allowed: None,
status_code: http_code,
})
};
// Create a mutable copy to set the status
let mut router_data_with_status = router_data;
router_data_with_status
.resource_common_data
.set_status(status);
Ok(RouterDataV2 {
resource_common_data: PaymentFlowData {
connector_response,
..router_data_with_status.resource_common_data
},
response: response_result,
..router_data_with_status
})
}
}
}
// Authorize response
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
TryFrom<
ResponseRouterData<
responses::PayloadPaymentsResponse,
RouterDataV2<
Authorize,
PaymentFlowData,
PaymentsAuthorizeData<T>,
PaymentsResponseData,
>,
>,
> for RouterDataV2<Authorize, PaymentFlowData, PaymentsAuthorizeData<T>, PaymentsResponseData>
{
type Error = Error;
fn try_from(
item: ResponseRouterData<
responses::PayloadPaymentsResponse,
RouterDataV2<
Authorize,
PaymentFlowData,
PaymentsAuthorizeData<T>,
PaymentsResponseData,
>,
>,
) -> Result<Self, Self::Error> {
let is_mandate_payment = item.router_data.request.is_mandate_payment();
handle_payment_response(
item.response,
item.router_data,
item.http_code,
is_mandate_payment,
)
}
}
// SetupMandate response
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
TryFrom<
ResponseRouterData<
| {
"chunk": 4,
"crate": "connector-integration",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_mini_connector-integration_-6055618699977151850_5 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/payload/transformers.rs
responses::PayloadPaymentsResponse,
RouterDataV2<
SetupMandate,
PaymentFlowData,
SetupMandateRequestData<T>,
PaymentsResponseData,
>,
>,
>
for RouterDataV2<
SetupMandate,
PaymentFlowData,
SetupMandateRequestData<T>,
PaymentsResponseData,
>
{
type Error = Error;
fn try_from(
item: ResponseRouterData<
responses::PayloadPaymentsResponse,
RouterDataV2<
SetupMandate,
PaymentFlowData,
SetupMandateRequestData<T>,
PaymentsResponseData,
>,
>,
) -> Result<Self, Self::Error> {
// SetupMandate is always a mandate payment
handle_payment_response(item.response, item.router_data, item.http_code, true)
}
}
// RepeatPayment response - for recurring/mandate payments
impl
TryFrom<
ResponseRouterData<
responses::PayloadPaymentsResponse,
RouterDataV2<
domain_types::connector_flow::RepeatPayment,
PaymentFlowData,
domain_types::connector_types::RepeatPaymentData,
PaymentsResponseData,
>,
>,
>
for RouterDataV2<
domain_types::connector_flow::RepeatPayment,
PaymentFlowData,
domain_types::connector_types::RepeatPaymentData,
PaymentsResponseData,
>
{
type Error = Error;
fn try_from(
item: ResponseRouterData<
responses::PayloadPaymentsResponse,
RouterDataV2<
domain_types::connector_flow::RepeatPayment,
PaymentFlowData,
domain_types::connector_types::RepeatPaymentData,
PaymentsResponseData,
>,
>,
) -> Result<Self, Self::Error> {
// RepeatPayment should not return mandate_reference as the mandate already exists
handle_payment_response(item.response, item.router_data, item.http_code, false)
}
}
// PSync response
impl
TryFrom<
ResponseRouterData<
responses::PayloadPaymentsResponse,
RouterDataV2<
domain_types::connector_flow::PSync,
PaymentFlowData,
domain_types::connector_types::PaymentsSyncData,
PaymentsResponseData,
>,
>,
>
for RouterDataV2<
domain_types::connector_flow::PSync,
PaymentFlowData,
domain_types::connector_types::PaymentsSyncData,
PaymentsResponseData,
>
{
type Error = Error;
fn try_from(
item: ResponseRouterData<
responses::PayloadPaymentsResponse,
RouterDataV2<
domain_types::connector_flow::PSync,
PaymentFlowData,
domain_types::connector_types::PaymentsSyncData,
PaymentsResponseData,
>,
>,
) -> Result<Self, Self::Error> {
handle_payment_response(item.response, item.router_data, item.http_code, false)
}
}
// Capture response
impl
TryFrom<
ResponseRouterData<
responses::PayloadPaymentsResponse,
RouterDataV2<Capture, PaymentFlowData, PaymentsCaptureData, PaymentsResponseData>,
>,
> for RouterDataV2<Capture, PaymentFlowData, PaymentsCaptureData, PaymentsResponseData>
{
type Error = Error;
fn try_from(
item: ResponseRouterData<
responses::PayloadPaymentsResponse,
RouterDataV2<Capture, PaymentFlowData, PaymentsCaptureData, PaymentsResponseData>,
>,
) -> Result<Self, Self::Error> {
handle_payment_response(item.response, item.router_data, item.http_code, false)
}
}
// Void response
impl
TryFrom<
ResponseRouterData<
responses::PayloadPaymentsResponse,
RouterDataV2<Void, PaymentFlowData, PaymentVoidData, PaymentsResponseData>,
>,
> for RouterDataV2<Void, PaymentFlowData, PaymentVoidData, PaymentsResponseData>
{
type Error = Error;
fn try_from(
item: ResponseRouterData<
responses::PayloadPaymentsResponse,
RouterDataV2<Void, PaymentFlowData, PaymentVoidData, PaymentsResponseData>,
>,
) -> Result<Self, Self::Error> {
| {
"chunk": 5,
"crate": "connector-integration",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_mini_connector-integration_-6055618699977151850_6 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/payload/transformers.rs
handle_payment_response(item.response, item.router_data, item.http_code, false)
}
}
// Refund status conversion
impl From<responses::RefundStatus> for enums::RefundStatus {
fn from(item: responses::RefundStatus) -> Self {
match item {
responses::RefundStatus::Processed => Self::Success,
responses::RefundStatus::Processing => Self::Pending,
responses::RefundStatus::Declined | responses::RefundStatus::Rejected => Self::Failure,
}
}
}
// Refund response
impl
TryFrom<
ResponseRouterData<
responses::PayloadRefundResponse,
RouterDataV2<Refund, RefundFlowData, RefundsData, RefundsResponseData>,
>,
> for RouterDataV2<Refund, RefundFlowData, RefundsData, RefundsResponseData>
{
type Error = Error;
fn try_from(
item: ResponseRouterData<
responses::PayloadRefundResponse,
RouterDataV2<Refund, RefundFlowData, RefundsData, RefundsResponseData>,
>,
) -> Result<Self, Self::Error> {
Ok(Self {
response: Ok(RefundsResponseData {
connector_refund_id: item.response.transaction_id.to_string(),
refund_status: enums::RefundStatus::from(item.response.status),
status_code: item.http_code,
}),
..item.router_data
})
}
}
// Webhook helper function to parse incoming webhook events
pub fn parse_webhook_event(
body: &[u8],
) -> Result<PayloadWebhookEvent, error_stack::Report<errors::ConnectorError>> {
serde_json::from_slice::<PayloadWebhookEvent>(body)
.change_context(errors::ConnectorError::WebhookBodyDecodingFailed)
}
// RSync response
impl
TryFrom<
ResponseRouterData<
responses::PayloadRefundResponse,
RouterDataV2<RSync, RefundFlowData, RefundSyncData, RefundsResponseData>,
>,
> for RouterDataV2<RSync, RefundFlowData, RefundSyncData, RefundsResponseData>
{
type Error = Error;
fn try_from(
item: ResponseRouterData<
responses::PayloadRefundResponse,
RouterDataV2<RSync, RefundFlowData, RefundSyncData, RefundsResponseData>,
>,
) -> Result<Self, Self::Error> {
Ok(Self {
response: Ok(RefundsResponseData {
connector_refund_id: item.response.transaction_id.to_string(),
refund_status: enums::RefundStatus::from(item.response.status),
status_code: item.http_code,
}),
..item.router_data
})
}
}
// Webhook event transformation
pub fn get_event_type_from_trigger(
trigger: responses::PayloadWebhooksTrigger,
) -> domain_types::connector_types::EventType {
match trigger {
// Payment Success Events
responses::PayloadWebhooksTrigger::Processed => {
domain_types::connector_types::EventType::PaymentIntentSuccess
}
responses::PayloadWebhooksTrigger::Authorized => {
domain_types::connector_types::EventType::PaymentIntentAuthorizationSuccess
}
// Payment Processing Events
responses::PayloadWebhooksTrigger::Payment
| responses::PayloadWebhooksTrigger::AutomaticPayment => {
domain_types::connector_types::EventType::PaymentIntentProcessing
}
// Payment Failure Events
responses::PayloadWebhooksTrigger::Decline
| responses::PayloadWebhooksTrigger::Reject
| responses::PayloadWebhooksTrigger::BankAccountReject => {
domain_types::connector_types::EventType::PaymentIntentFailure
}
responses::PayloadWebhooksTrigger::Void | responses::PayloadWebhooksTrigger::Reversal => {
domain_types::connector_types::EventType::PaymentIntentCancelled
}
// Refund Events
responses::PayloadWebhooksTrigger::Refund => {
domain_types::connector_types::EventType::RefundSuccess
}
// Dispute Events
responses::PayloadWebhooksTrigger::Chargeback => {
domain_types::connector_types::EventType::DisputeOpened
}
responses::PayloadWebhooksTrigger::ChargebackReversal => {
domain_types::connector_types::EventType::DisputeWon
}
// Other payment-related events - treat as generic payment processing
| {
"chunk": 6,
"crate": "connector-integration",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_mini_connector-integration_-6055618699977151850_7 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/payload/transformers.rs
responses::PayloadWebhooksTrigger::PaymentActivationStatus
| responses::PayloadWebhooksTrigger::Credit
| responses::PayloadWebhooksTrigger::Deposit
| responses::PayloadWebhooksTrigger::PaymentLinkStatus
| responses::PayloadWebhooksTrigger::ProcessingStatus
| responses::PayloadWebhooksTrigger::TransactionOperation
| responses::PayloadWebhooksTrigger::TransactionOperationClear => {
domain_types::connector_types::EventType::PaymentIntentProcessing
}
}
}
| {
"chunk": 7,
"crate": "connector-integration",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_mini_connector-integration_-7174082965644870196_0 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/payload/responses.rs
use common_utils::FloatMajorUnit;
use hyperswitch_masking::Secret;
use serde::{Deserialize, Serialize};
// PaymentsResponse
#[derive(Default, Debug, Clone, Copy, Serialize, Deserialize, PartialEq)]
#[serde(rename_all = "lowercase")]
pub enum PayloadPaymentStatus {
Authorized,
Declined,
Processed,
#[default]
Processing,
Rejected,
Voided,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum PayloadPaymentsResponse {
PayloadCardsResponse(PayloadCardsResponseData),
}
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum AvsResponse {
Unknown,
NoMatch,
Zip,
Street,
StreetAndZip,
}
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct PayloadCardsResponseData {
pub amount: FloatMajorUnit,
pub avs: Option<AvsResponse>,
pub customer_id: Option<Secret<String>>,
#[serde(rename = "id")]
pub transaction_id: String,
#[serde(rename = "payment_method_id")]
pub connector_payment_method_id: Option<Secret<String>>,
pub processing_id: Option<Secret<String>>,
pub processing_method_id: Option<String>,
pub ref_number: Option<String>,
pub status: PayloadPaymentStatus,
pub status_code: Option<String>,
pub status_message: Option<String>,
#[serde(rename = "type")]
pub response_type: Option<String>,
}
// Type definition for Refund Response
// Added based on assumptions since this is not provided in the documentation
#[derive(Debug, Copy, Serialize, Default, Deserialize, Clone)]
#[serde(rename_all = "snake_case")]
pub enum RefundStatus {
Declined,
Processed,
#[default]
Processing,
Rejected,
}
#[derive(Default, Debug, Clone, Serialize, Deserialize)]
pub struct RefundsLedger {
pub amount: FloatMajorUnit,
#[serde(rename = "assoc_transaction_id")]
pub associated_transaction_id: String, // Connector transaction id
#[serde(rename = "id")]
pub ledger_id: Secret<String>,
}
#[derive(Default, Debug, Clone, Serialize, Deserialize)]
pub struct PayloadRefundResponse {
pub amount: FloatMajorUnit,
#[serde(rename = "id")]
pub transaction_id: String,
pub ledger: Vec<RefundsLedger>,
#[serde(rename = "payment_method_id")]
pub connector_payment_method_id: Option<Secret<String>>,
pub processing_id: Option<Secret<String>>,
pub ref_number: Option<String>,
pub status: RefundStatus,
pub status_code: Option<String>,
pub status_message: Option<String>,
}
#[derive(Default, Debug, Serialize, Deserialize, PartialEq)]
pub struct PayloadErrorResponse {
pub error_type: String,
pub error_description: String,
pub object: String,
/// Payload returns arbitrary details in JSON format
pub details: Option<serde_json::Value>,
}
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum PayloadWebhooksTrigger {
Payment,
Processed,
Authorized,
Credit,
Refund,
Reversal,
Void,
AutomaticPayment,
Decline,
Deposit,
Reject,
#[serde(rename = "payment_activation:status")]
PaymentActivationStatus,
#[serde(rename = "payment_link:status")]
PaymentLinkStatus,
ProcessingStatus,
BankAccountReject,
Chargeback,
ChargebackReversal,
#[serde(rename = "transaction:operation")]
TransactionOperation,
#[serde(rename = "transaction:operation:clear")]
TransactionOperationClear,
}
// Webhook response structures
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct PayloadWebhookEvent {
pub object: String, // Added to match actual webhook structure
pub trigger: PayloadWebhooksTrigger,
pub webhook_id: String,
pub triggered_at: String, // Added to match actual webhook structure
// Webhooks Payload
pub triggered_on: PayloadEventDetails,
pub url: String,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct PayloadEventDetails {
#[serde(rename = "id")]
pub transaction_id: Option<String>,
pub object: String,
pub value: Option<serde_json::Value>, // Changed to handle any value type including null
}
// Type aliases to avoid duplicate templating types in macro
pub type PayloadAuthorizeResponse = PayloadPaymentsResponse;
pub type PayloadPSyncResponse = PayloadPaymentsResponse;
pub type PayloadCaptureResponse = PayloadPaymentsResponse;
pub type PayloadVoidResponse = PayloadPaymentsResponse;
| {
"chunk": 0,
"crate": "connector-integration",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_mini_connector-integration_-6316223293833694220_0 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/payload/requests.rs
use common_utils::types::FloatMajorUnit;
use domain_types::payment_method_data::{PaymentMethodDataTypes, RawCardNumber};
use hyperswitch_masking::Secret;
use serde::{Deserialize, Serialize};
use crate::connectors::payload::responses;
#[derive(Debug, Serialize, PartialEq)]
#[serde(untagged)]
pub enum PayloadPaymentsRequest<T: PaymentMethodDataTypes> {
PayloadCardsRequest(Box<PayloadCardsRequestData<T>>),
PayloadMandateRequest(Box<PayloadMandateRequestData>),
}
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum TransactionTypes {
Credit,
Chargeback,
ChargebackReversal,
Deposit,
Payment,
Refund,
Reversal,
}
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct BillingAddress {
#[serde(rename = "payment_method[billing_address][city]")]
pub city: String,
#[serde(rename = "payment_method[billing_address][country_code]")]
pub country: common_enums::CountryAlpha2,
#[serde(rename = "payment_method[billing_address][postal_code]")]
pub postal_code: Secret<String>,
#[serde(rename = "payment_method[billing_address][state_province]")]
pub state_province: Secret<String>,
#[serde(rename = "payment_method[billing_address][street_address]")]
pub street_address: Secret<String>,
}
#[derive(Debug, Clone, Serialize, PartialEq)]
pub struct PayloadCardsRequestData<T: PaymentMethodDataTypes> {
pub amount: FloatMajorUnit,
#[serde(flatten)]
pub card: PayloadCard<T>,
#[serde(rename = "type")]
pub transaction_types: TransactionTypes,
// For manual capture, set status to "authorized", otherwise omit
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<responses::PayloadPaymentStatus>,
#[serde(rename = "payment_method[type]")]
pub payment_method_type: String,
// Billing address fields are for AVS validation
#[serde(flatten)]
pub billing_address: BillingAddress,
pub processing_id: Option<Secret<String>>,
/// Allows one-time payment by customer without saving their payment method
/// This is true by default
#[serde(rename = "payment_method[keep_active]")]
pub keep_active: bool,
}
#[derive(Debug, Clone, Serialize, PartialEq)]
pub struct PayloadMandateRequestData {
pub amount: FloatMajorUnit,
#[serde(rename = "type")]
pub transaction_types: TransactionTypes,
// Based on the connectors' response, we can do recurring payment either based on a default payment method id saved in the customer profile or a specific payment method id
// Connector by default, saves every payment method
pub payment_method_id: Secret<String>,
// For manual capture, set status to "authorized", otherwise omit
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<responses::PayloadPaymentStatus>,
}
#[derive(Default, Clone, Debug, Serialize, Eq, PartialEq)]
pub struct PayloadCard<T: PaymentMethodDataTypes> {
#[serde(rename = "payment_method[card][card_number]")]
pub number: RawCardNumber<T>,
#[serde(rename = "payment_method[card][expiry]")]
pub expiry: Secret<String>,
#[serde(rename = "payment_method[card][card_code]")]
pub cvc: Secret<String>,
}
#[derive(Clone, Debug, Serialize, PartialEq)]
pub struct PayloadVoidRequest {
pub status: responses::PayloadPaymentStatus,
}
// Type definition for CaptureRequest
#[derive(Clone, Debug, Serialize, PartialEq)]
pub struct PayloadCaptureRequest {
pub status: responses::PayloadPaymentStatus,
}
// Type definition for RefundRequest
#[derive(Debug, Serialize)]
pub struct PayloadRefundRequest {
#[serde(rename = "type")]
pub transaction_type: TransactionTypes,
pub amount: FloatMajorUnit,
#[serde(rename = "ledger[0][assoc_transaction_id]")]
pub ledger_assoc_transaction_id: String,
}
// Type alias for RepeatPayment request (same structure as PayloadPaymentsRequest)
pub type PayloadRepeatPaymentRequest<T> = PayloadPaymentsRequest<T>;
| {
"chunk": 0,
"crate": "connector-integration",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_mini_connector-integration_-3671819979525078476_0 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/bluecode/test.rs
#[cfg(test)]
mod tests {
pub mod authorize {
use std::{borrow::Cow, marker::PhantomData};
use common_utils::{
pii::{self, Email},
request::RequestContent,
types::MinorUnit,
};
use domain_types::{
self,
connector_flow::Authorize,
connector_types::{
ConnectorEnum, PaymentFlowData, PaymentsAuthorizeData, PaymentsResponseData,
},
payment_method_data::{DefaultPCIHolder, PaymentMethodData, WalletData},
router_data::{ConnectorAuthType, ErrorResponse},
router_data_v2::RouterDataV2,
types::{ConnectorParams, Connectors},
};
use hyperswitch_masking::Secret;
use interfaces::{
connector_integration_v2::BoxedConnectorIntegrationV2, connector_types::BoxedConnector,
};
use serde_json::json;
use crate::{connectors::Bluecode, types::ConnectorData};
#[test]
fn test_build_request_valid() {
let api_key = "test_bluecode_api_key".to_string();
let req: RouterDataV2<
Authorize,
PaymentFlowData,
PaymentsAuthorizeData<DefaultPCIHolder>,
PaymentsResponseData,
> = RouterDataV2 {
flow: PhantomData::<domain_types::connector_flow::Authorize>,
resource_common_data: PaymentFlowData {
vault_headers: None,
merchant_id: common_utils::id_type::MerchantId::default(),
customer_id: None,
connector_customer: Some("conn_cust_987654".to_string()),
payment_id: "pay_abcdef123456".to_string(),
attempt_id: "attempt_123456abcdef".to_string(),
status: common_enums::AttemptStatus::Pending,
payment_method: common_enums::PaymentMethod::Wallet,
description: Some("Payment for order #12345".to_string()),
return_url: Some("https://www.google.com".to_string()),
address: domain_types::payment_address::PaymentAddress::new(
None,
Some(domain_types::payment_address::Address {
address: Some(domain_types::payment_address::AddressDetails {
first_name: Some(Secret::new("John".to_string())),
last_name: Some(Secret::new("Doe".to_string())),
line1: Some(Secret::new("123 Main St".to_string())),
city: Some("Anytown".to_string()),
zip: Some(Secret::new("12345".to_string())),
country: Some(common_enums::CountryAlpha2::US),
..Default::default()
}),
phone: None,
email: None,
}),
None,
None,
),
auth_type: common_enums::AuthenticationType::NoThreeDs,
connector_meta_data: Some(pii::SecretSerdeValue::new(
serde_json::json!({ "shop_name": "test_shop" }),
)),
amount_captured: None,
minor_amount_captured: None,
access_token: None,
session_token: None,
reference_id: None,
payment_method_token: None,
preprocessing_id: None,
connector_api_version: None,
connector_request_reference_id: "conn_ref_123456789".to_string(),
test_mode: None,
connector_http_status_code: None,
connectors: Connectors {
bluecode: ConnectorParams {
base_url: "https://api.bluecode.com/".to_string(),
dispute_base_url: None,
..Default::default()
},
..Default::default()
},
| {
"chunk": 0,
"crate": "connector-integration",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_mini_connector-integration_-3671819979525078476_1 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/bluecode/test.rs
external_latency: None,
connector_response_headers: None,
raw_connector_response: None,
raw_connector_request: None,
minor_amount_capturable: None,
connector_response: None,
recurring_mandate_payment_data: None,
},
connector_auth_type: ConnectorAuthType::HeaderKey {
api_key: Secret::new(api_key),
},
request: PaymentsAuthorizeData {
authentication_data: None,
access_token: None,
payment_method_data: PaymentMethodData::Wallet(WalletData::BluecodeRedirect {}),
amount: 1000,
order_tax_amount: None,
email: Some(
Email::try_from("test@example.com".to_string())
.expect("Failed to parse email"),
),
customer_name: None,
currency: common_enums::Currency::USD,
confirm: true,
statement_descriptor_suffix: None,
statement_descriptor: None,
capture_method: None,
integrity_object: None,
router_return_url: Some("https://www.google.com".to_string()),
webhook_url: Some("https://webhook.site/".to_string()),
complete_authorize_url: None,
mandate_id: None,
setup_future_usage: None,
off_session: None,
browser_info: None,
order_category: None,
session_token: None,
enrolled_for_3ds: false,
related_transaction_id: None,
payment_experience: None,
payment_method_type: None,
customer_id: Some(
common_utils::id_type::CustomerId::try_from(Cow::from(
"cus_123456789".to_string(),
))
.unwrap(),
),
request_incremental_authorization: false,
metadata: None,
minor_amount: MinorUnit::new(1000),
merchant_order_reference_id: None,
shipping_cost: None,
merchant_account_id: None,
merchant_config_currency: None,
all_keys_required: None,
customer_acceptance: None,
split_payments: None,
request_extended_authorization: None,
setup_mandate_details: None,
enable_overcapture: None,
merchant_account_metadata: None,
},
response: Err(ErrorResponse::default()),
};
let connector: BoxedConnector<DefaultPCIHolder> = Box::new(Bluecode::new());
let connector_data = ConnectorData {
connector,
connector_name: ConnectorEnum::Bluecode,
};
let connector_integration: BoxedConnectorIntegrationV2<
'_,
Authorize,
PaymentFlowData,
PaymentsAuthorizeData<DefaultPCIHolder>,
PaymentsResponseData,
> = connector_data.connector.get_connector_integration_v2();
let request = connector_integration.build_request_v2(&req).unwrap();
let req_body = request.as_ref().map(|request_val| {
let masked_request = match request_val.body.as_ref() {
Some(request_content) => match request_content {
RequestContent::Json(i)
| RequestContent::FormUrlEncoded(i)
| RequestContent::Xml(i) => i.masked_serialize().unwrap_or(
json!({ "error": "failed to mask serialize connector request"}),
),
RequestContent::FormData(_) => json!({"request_type": "FORM_DATA"}),
| {
"chunk": 1,
"crate": "connector-integration",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_mini_connector-integration_-3671819979525078476_2 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/bluecode/test.rs
RequestContent::RawBytes(_) => json!({"request_type": "RAW_BYTES"}),
},
None => serde_json::Value::Null,
};
masked_request
});
println!("request: {req_body:?}");
assert_eq!(
req_body.as_ref().unwrap()["reference"],
"conn_ref_123456789"
);
}
#[test]
fn test_build_request_missing_fields() {
let api_key = "test_bluecode_api_key_missing".to_string();
let req: RouterDataV2<
Authorize,
PaymentFlowData,
PaymentsAuthorizeData<DefaultPCIHolder>,
PaymentsResponseData,
> = RouterDataV2 {
flow: PhantomData::<Authorize>,
resource_common_data: PaymentFlowData {
vault_headers: None,
merchant_id: common_utils::id_type::MerchantId::default(),
customer_id: None,
connector_customer: None,
payment_id: "".to_string(),
attempt_id: "".to_string(),
status: common_enums::AttemptStatus::Pending,
payment_method: common_enums::PaymentMethod::Wallet,
description: None,
return_url: None,
address: domain_types::payment_address::PaymentAddress::new(
None, None, None, None,
),
auth_type: common_enums::AuthenticationType::NoThreeDs,
connector_meta_data: None,
amount_captured: None,
minor_amount_captured: None,
access_token: None,
session_token: None,
reference_id: None,
payment_method_token: None,
preprocessing_id: None,
connector_api_version: None,
connector_request_reference_id: "".to_string(),
test_mode: None,
connector_http_status_code: None,
connectors: Connectors {
bluecode: ConnectorParams {
base_url: "https://api.bluecode.com/".to_string(),
dispute_base_url: None,
..Default::default()
},
..Default::default()
},
external_latency: None,
connector_response_headers: None,
raw_connector_response: None,
raw_connector_request: None,
minor_amount_capturable: None,
connector_response: None,
recurring_mandate_payment_data: None,
},
connector_auth_type: ConnectorAuthType::HeaderKey {
api_key: Secret::new(api_key),
},
request: PaymentsAuthorizeData {
authentication_data: None,
access_token: None,
payment_method_data: PaymentMethodData::Wallet(WalletData::BluecodeRedirect {}),
amount: 0,
order_tax_amount: None,
email: None,
customer_name: None,
currency: common_enums::Currency::USD,
confirm: true,
statement_descriptor_suffix: None,
statement_descriptor: None,
capture_method: None,
router_return_url: None,
webhook_url: None,
complete_authorize_url: None,
mandate_id: None,
setup_future_usage: None,
off_session: None,
browser_info: None,
integrity_object: None,
order_category: None,
session_token: None,
enrolled_for_3ds: false,
related_transaction_id: None,
payment_experience: None,
payment_method_type: None,
| {
"chunk": 2,
"crate": "connector-integration",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_mini_connector-integration_-3671819979525078476_3 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/bluecode/test.rs
customer_id: None,
request_incremental_authorization: false,
metadata: None,
minor_amount: MinorUnit::new(0),
merchant_order_reference_id: None,
shipping_cost: None,
merchant_account_id: None,
merchant_config_currency: None,
all_keys_required: None,
customer_acceptance: None,
split_payments: None,
request_extended_authorization: None,
setup_mandate_details: None,
enable_overcapture: None,
merchant_account_metadata: None,
},
response: Err(ErrorResponse::default()),
};
let connector: BoxedConnector<DefaultPCIHolder> = Box::new(Bluecode::new());
let connector_data = ConnectorData {
connector,
connector_name: ConnectorEnum::Bluecode,
};
let connector_integration: BoxedConnectorIntegrationV2<
'_,
Authorize,
PaymentFlowData,
PaymentsAuthorizeData<DefaultPCIHolder>,
PaymentsResponseData,
> = connector_data.connector.get_connector_integration_v2();
let result = connector_integration.build_request_v2(&req);
assert!(result.is_err(), "Expected error for missing fields");
}
}
}
| {
"chunk": 3,
"crate": "connector-integration",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_mini_connector-integration_306050111147943451_0 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/bluecode/transformers.rs
use common_enums::{self, enums, AttemptStatus};
use common_utils::{
consts::{NO_ERROR_CODE, NO_ERROR_MESSAGE},
pii,
request::Method,
types::FloatMajorUnit,
};
use domain_types::{
connector_flow::Authorize,
connector_types::{
PaymentFlowData, PaymentsAuthorizeData, PaymentsResponseData, PaymentsSyncData, ResponseId,
},
errors::{self},
payment_method_data::{PaymentMethodData, PaymentMethodDataTypes, WalletData},
router_data::{ConnectorAuthType, ErrorResponse},
router_data_v2::RouterDataV2,
};
use error_stack::ResultExt;
use hyperswitch_masking::{PeekInterface, Secret};
use serde::{Deserialize, Serialize};
use serde_json::{Map, Value};
use crate::types::ResponseRouterData;
// Auth
pub struct BluecodeAuthType {
pub(super) api_key: Secret<String>,
}
impl TryFrom<&ConnectorAuthType> for BluecodeAuthType {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(auth_type: &ConnectorAuthType) -> Result<Self, Self::Error> {
match auth_type {
ConnectorAuthType::HeaderKey { api_key } => Ok(Self {
api_key: api_key.to_owned(),
}),
_ => Err(errors::ConnectorError::FailedToObtainAuthType.into()),
}
}
}
// Requests
#[derive(Debug, Serialize)]
pub struct BluecodePaymentsRequest {
pub amount: FloatMajorUnit,
pub currency: enums::Currency,
pub payment_provider: String,
pub shop_name: String,
pub reference: String,
pub ip_address: Option<Secret<String, pii::IpAddress>>,
pub first_name: Secret<String>,
pub last_name: Secret<String>,
pub billing_address_country_code_iso: enums::CountryAlpha2,
pub billing_address_city: String,
pub billing_address_line1: Secret<String>,
pub billing_address_postal_code: Option<Secret<String>>,
pub webhook_url: url::Url,
pub success_url: url::Url,
pub failure_url: url::Url,
}
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct BluecodeWebhookResponse {
pub id: Option<i64>,
pub order_id: String,
pub user_id: Option<i64>,
pub customer_id: Option<String>,
pub customer_email: Option<common_utils::Email>,
pub customer_phone: Option<Secret<String>>,
pub status: BluecodePaymentStatus,
pub payment_provider: Option<String>,
pub payment_connector: Option<String>,
pub payment_method: Option<String>,
pub payment_method_type: Option<String>,
pub shop_name: Option<String>,
pub sender_name: Option<String>,
pub sender_email: Option<String>,
pub description: Option<String>,
pub amount: FloatMajorUnit,
pub currency: enums::Currency,
pub charged_amount: Option<FloatMajorUnit>,
pub charged_amount_currency: Option<String>,
pub charged_fx_amount: Option<FloatMajorUnit>,
pub charged_fx_amount_currency: Option<enums::Currency>,
pub is_underpaid: Option<bool>,
pub billing_amount: Option<FloatMajorUnit>,
pub billing_currency: Option<String>,
pub language: Option<String>,
pub ip_address: Option<Secret<String, common_utils::pii::IpAddress>>,
pub first_name: Option<Secret<String>>,
pub last_name: Option<Secret<String>>,
pub billing_address_line1: Option<Secret<String>>,
pub billing_address_city: Option<Secret<String>>,
pub billing_address_postal_code: Option<Secret<String>>,
pub billing_address_country: Option<String>,
pub billing_address_country_code_iso: Option<enums::CountryAlpha2>,
pub shipping_address_country_code_iso: Option<enums::CountryAlpha2>,
pub success_url: Option<url::Url>,
pub failure_url: Option<url::Url>,
pub source: Option<String>,
pub bonus_code: Option<String>,
pub dob: Option<String>,
pub fees_amount: Option<f64>,
pub fx_margin_amount: Option<f64>,
pub fx_margin_percent: Option<f64>,
pub fees_percent: Option<f64>,
pub reseller_id: Option<String>,
}
#[derive(Debug, Serialize)]
pub struct BluecodeCaptureRequest;
#[derive(Debug, Serialize)]
pub struct BluecodeVoidRequest;
#[derive(Debug, Serialize)]
pub struct BluecodeRefundRequest {
pub amount: FloatMajorUnit,
}
impl TryFrom<&pii::SecretSerdeValue> for BluecodeMetadataObject {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(secret_value: &pii::SecretSerdeValue) -> Result<Self, Self::Error> {
match secret_value.peek() {
| {
"chunk": 0,
"crate": "connector-integration",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_mini_connector-integration_306050111147943451_1 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/bluecode/transformers.rs
serde_json::Value::String(s) => serde_json::from_str(s).change_context(
errors::ConnectorError::InvalidConnectorConfig {
config: "Deserializing BluecodeMetadataObject from connector_meta_data string",
},
),
value => serde_json::from_value(value.clone()).change_context(
errors::ConnectorError::InvalidConnectorConfig {
config: "Deserializing BluecodeMetadataObject from connector_meta_data value",
},
),
}
}
}
// Request TryFrom implementations
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
TryFrom<
super::BluecodeRouterData<
RouterDataV2<
Authorize,
PaymentFlowData,
PaymentsAuthorizeData<T>,
PaymentsResponseData,
>,
T,
>,
> for BluecodePaymentsRequest
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: super::BluecodeRouterData<
RouterDataV2<
Authorize,
PaymentFlowData,
PaymentsAuthorizeData<T>,
PaymentsResponseData,
>,
T,
>,
) -> Result<Self, Self::Error> {
if item.router_data.request.capture_method == Some(enums::CaptureMethod::Manual) {
return Err(errors::ConnectorError::CaptureMethodNotSupported.into());
}
match item.router_data.request.payment_method_data.clone() {
PaymentMethodData::Wallet(WalletData::BluecodeRedirect {}) => {
let amount = item
.connector
.amount_converter
.convert(
item.router_data.request.minor_amount,
item.router_data.request.currency,
)
.change_context(errors::ConnectorError::RequestEncodingFailed)?;
let bluecode_mca_metadata = BluecodeMetadataObject::try_from(
&item.router_data.resource_common_data.get_connector_meta()?,
)?;
Ok(Self {
amount,
currency: item.router_data.request.currency,
payment_provider: "bluecode_payment".to_string(),
shop_name: bluecode_mca_metadata.shop_name.clone(),
reference: item
.router_data
.resource_common_data
.connector_request_reference_id
.clone(),
ip_address: item.router_data.request.get_ip_address_as_optional(),
first_name: item
.router_data
.resource_common_data
.get_billing_first_name()?,
last_name: item
.router_data
.resource_common_data
.get_billing_last_name()?,
billing_address_country_code_iso: item
.router_data
.resource_common_data
.get_billing_country()?,
billing_address_city: item
.router_data
.resource_common_data
.get_billing_city()?,
billing_address_line1: item
.router_data
.resource_common_data
.get_billing_line1()?,
billing_address_postal_code: item
.router_data
.resource_common_data
.get_optional_billing_zip(),
webhook_url: url::Url::parse(&item.router_data.request.get_webhook_url()?)
.change_context(errors::ConnectorError::ParsingFailed)?,
success_url: url::Url::parse(
&item.router_data.request.get_router_return_url()?,
)
| {
"chunk": 1,
"crate": "connector-integration",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_mini_connector-integration_306050111147943451_2 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/bluecode/transformers.rs
.change_context(errors::ConnectorError::ParsingFailed)?,
failure_url: url::Url::parse(
&item.router_data.request.get_router_return_url()?,
)
.change_context(errors::ConnectorError::ParsingFailed)?,
})
}
_ => Err(errors::ConnectorError::NotImplemented("Payment method".to_string()).into()),
}
}
}
// Responses
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct BluecodePaymentsResponse {
pub id: i64,
pub order_id: String,
pub amount: FloatMajorUnit,
pub currency: enums::Currency,
pub charged_amount: FloatMajorUnit,
pub charged_currency: enums::Currency,
pub status: BluecodePaymentStatus,
pub payment_link: url::Url,
pub etoken: Secret<String>,
pub payment_request_id: String,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct BluecodeSyncResponse {
pub id: Option<i64>,
pub order_id: String,
pub status: BluecodePaymentStatus,
pub amount: FloatMajorUnit,
pub currency: enums::Currency,
}
#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq)]
#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
pub enum BluecodePaymentStatus {
Pending,
PaymentInitiated,
ManualProcessing,
Failed,
Completed,
}
impl From<BluecodePaymentStatus> for AttemptStatus {
fn from(item: BluecodePaymentStatus) -> Self {
match item {
BluecodePaymentStatus::ManualProcessing => Self::Pending,
BluecodePaymentStatus::Pending | BluecodePaymentStatus::PaymentInitiated => {
Self::AuthenticationPending
}
BluecodePaymentStatus::Failed => Self::Failure,
BluecodePaymentStatus::Completed => Self::Charged,
}
}
}
// Response TryFrom implementations
impl<F, T>
TryFrom<
ResponseRouterData<
BluecodePaymentsResponse,
RouterDataV2<F, PaymentFlowData, T, PaymentsResponseData>,
>,
> for RouterDataV2<F, PaymentFlowData, T, PaymentsResponseData>
where
T: Clone,
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: ResponseRouterData<
BluecodePaymentsResponse,
RouterDataV2<F, PaymentFlowData, T, PaymentsResponseData>,
>,
) -> Result<Self, Self::Error> {
let redirection_data = Some(domain_types::router_response_types::RedirectForm::Form {
endpoint: item.response.payment_link.to_string(),
method: Method::Get,
form_fields: Default::default(),
});
let response = Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(item.response.order_id),
redirection_data: redirection_data.map(Box::new),
mandate_reference: None,
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: Some(item.response.payment_request_id),
incremental_authorization_allowed: None,
status_code: item.http_code,
});
Ok(Self {
response,
resource_common_data: PaymentFlowData {
status: AttemptStatus::from(item.response.status),
..item.router_data.resource_common_data
},
..item.router_data
})
}
}
impl<F> TryFrom<ResponseRouterData<BluecodeSyncResponse, Self>>
for RouterDataV2<F, PaymentFlowData, PaymentsSyncData, PaymentsResponseData>
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(item: ResponseRouterData<BluecodeSyncResponse, Self>) -> Result<Self, Self::Error> {
let ResponseRouterData {
response,
router_data,
http_code,
} = item;
let status = AttemptStatus::from(response.status);
let response = if status == common_enums::AttemptStatus::Failure {
Err(ErrorResponse {
code: NO_ERROR_CODE.to_string(),
message: NO_ERROR_MESSAGE.to_string(),
reason: Some(NO_ERROR_MESSAGE.to_string()),
attempt_status: Some(status),
connector_transaction_id: Some(response.order_id.clone()),
status_code: http_code,
| {
"chunk": 2,
"crate": "connector-integration",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_mini_connector-integration_306050111147943451_3 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/bluecode/transformers.rs
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
})
} else {
Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(response.order_id.clone()),
redirection_data: None,
mandate_reference: None,
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: None,
incremental_authorization_allowed: None,
status_code: http_code,
})
};
Ok(Self {
response,
resource_common_data: PaymentFlowData {
status,
..router_data.resource_common_data
},
..router_data
})
}
}
// Error
#[derive(Debug, Serialize, Deserialize)]
pub struct BluecodeErrorResponse {
pub message: String,
pub context_data: std::collections::HashMap<String, Value>,
}
// Webhooks, metadata etc.
#[derive(Debug, Default, Serialize, Deserialize)]
pub struct BluecodeMetadataObject {
pub shop_name: String,
}
pub fn sort_and_minify_json(value: &Value) -> Result<String, errors::ConnectorError> {
fn sort_value(val: &Value) -> Value {
match val {
Value::Object(map) => {
let mut entries: Vec<_> = map.iter().collect();
entries.sort_by_key(|(k, _)| k.to_owned());
let sorted_map: Map<String, Value> = entries
.into_iter()
.map(|(k, v)| (k.clone(), sort_value(v)))
.collect();
Value::Object(sorted_map)
}
Value::Array(arr) => Value::Array(arr.iter().map(sort_value).collect()),
_ => val.clone(),
}
}
let sorted_value = sort_value(value);
serde_json::to_string(&sorted_value)
.map_err(|_| errors::ConnectorError::WebhookBodyDecodingFailed)
}
| {
"chunk": 3,
"crate": "connector-integration",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_mini_connector-integration_2738435745298344692_0 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/fiuu/transformers.rs
use std::collections::HashMap;
use cards::CardNumber;
use common_enums::{BankNames, CaptureMethod, Currency};
use common_utils::{
consts,
crypto::{self, GenerateDigest},
errors::CustomResult,
ext_traits::Encode,
pii::Email,
request::Method,
types::{AmountConvertor, StringMajorUnit, StringMajorUnitForConnector},
};
use domain_types::{
connector_flow::{Authorize, Capture, PSync, RSync, Refund, Void},
connector_types::{
EventType, MandateReference, MandateReferenceId, PaymentFlowData, PaymentVoidData,
PaymentsAuthorizeData, PaymentsCaptureData, PaymentsResponseData, PaymentsSyncData,
RefundFlowData, RefundSyncData, RefundWebhookDetailsResponse, RefundsData,
RefundsResponseData, ResponseId,
},
errors::{self, ConnectorError},
payment_method_data::{
BankRedirectData, Card, CardDetailsForNetworkTransactionId, GooglePayWalletData,
PaymentMethodData, PaymentMethodDataTypes, RawCardNumber, RealTimePaymentData, WalletData,
},
router_data::{ApplePayPredecryptData, ConnectorAuthType, ErrorResponse, PaymentMethodToken},
router_data_v2::RouterDataV2,
router_response_types::RedirectForm,
utils,
};
use error_stack::ResultExt;
use hyperswitch_masking::{ExposeInterface, PeekInterface, Secret};
use serde::{Deserialize, Serialize};
use serde_json::Value;
use strum::Display;
use url::Url;
use crate::{
connectors::{fiuu::FiuuRouterData, macros::GetFormData},
types::ResponseRouterData,
};
// These needs to be accepted from SDK, need to be done after 1.0.0 stability as API contract will change
const GOOGLEPAY_API_VERSION_MINOR: u8 = 0;
const GOOGLEPAY_API_VERSION: u8 = 2;
pub struct FiuuAuthType {
pub(super) merchant_id: Secret<String>,
pub(super) verify_key: Secret<String>,
pub(super) secret_key: Secret<String>,
}
impl TryFrom<&ConnectorAuthType> for FiuuAuthType {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(auth_type: &ConnectorAuthType) -> Result<Self, Self::Error> {
match auth_type {
ConnectorAuthType::SignatureKey {
api_key,
key1,
api_secret,
} => Ok(Self {
merchant_id: key1.to_owned(),
verify_key: api_key.to_owned(),
secret_key: api_secret.to_owned(),
}),
_ => Err(errors::ConnectorError::FailedToObtainAuthType.into()),
}
}
}
#[derive(Serialize, Deserialize, Debug, Clone)]
#[serde(rename_all = "UPPERCASE")]
pub enum TxnType {
Sals,
Auts,
}
impl TryFrom<Option<CaptureMethod>> for TxnType {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(capture_method: Option<CaptureMethod>) -> Result<Self, Self::Error> {
match capture_method {
Some(CaptureMethod::Automatic) | Some(CaptureMethod::SequentialAutomatic) | None => {
Ok(Self::Sals)
}
Some(CaptureMethod::Manual) => Ok(Self::Auts),
_ => Err(errors::ConnectorError::CaptureMethodNotSupported.into()),
}
}
}
#[derive(Serialize, Deserialize, Display, Debug, Clone)]
enum TxnChannel {
#[serde(rename = "CREDITAN")]
#[strum(serialize = "CREDITAN")]
Creditan,
#[serde(rename = "RPP_DUITNOWQR")]
#[strum(serialize = "RPP_DUITNOWQR")]
RppDuitNowQr,
}
#[derive(Serialize, Deserialize, Display, Debug, Clone)]
#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
#[strum(serialize_all = "SCREAMING_SNAKE_CASE")]
pub enum FPXTxnChannel {
FpxAbb,
FpxUob,
FpxAbmb,
FpxScb,
FpxBsn,
FpxKfh,
FpxBmmb,
FpxBkrm,
FpxHsbc,
FpxAgrobank,
FpxBocm,
FpxMb2u,
FpxCimbclicks,
FpxAmb,
FpxHlb,
FpxPbb,
FpxRhb,
FpxBimb,
FpxOcbc,
}
#[derive(Debug, Clone, Serialize)]
pub enum BankCode {
PHBMMYKL,
AGOBMYK1,
MFBBMYKL,
ARBKMYKL,
BKCHMYKL,
BIMBMYKL,
BMMBMYKL,
BKRMMYK1,
BSNAMYK1,
CIBBMYKL,
HLBBMYKL,
HBMBMYKL,
KFHOMYKL,
MBBEMYKL,
PBBEMYKL,
RHBBMYKL,
SCBLMYKX,
UOVBMYKL,
OCBCMYKL,
}
impl TryFrom<BankNames> for BankCode {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(bank: BankNames) -> Result<Self, Self::Error> {
match bank {
BankNames::AffinBank => Ok(Self::PHBMMYKL),
BankNames::AgroBank => Ok(Self::AGOBMYK1),
| {
"chunk": 0,
"crate": "connector-integration",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_mini_connector-integration_2738435745298344692_1 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/fiuu/transformers.rs
BankNames::AllianceBank => Ok(Self::MFBBMYKL),
BankNames::AmBank => Ok(Self::ARBKMYKL),
BankNames::BankOfChina => Ok(Self::BKCHMYKL),
BankNames::BankIslam => Ok(Self::BIMBMYKL),
BankNames::BankMuamalat => Ok(Self::BMMBMYKL),
BankNames::BankRakyat => Ok(Self::BKRMMYK1),
BankNames::BankSimpananNasional => Ok(Self::BSNAMYK1),
BankNames::CimbBank => Ok(Self::CIBBMYKL),
BankNames::HongLeongBank => Ok(Self::HLBBMYKL),
BankNames::HsbcBank => Ok(Self::HBMBMYKL),
BankNames::KuwaitFinanceHouse => Ok(Self::KFHOMYKL),
BankNames::Maybank => Ok(Self::MBBEMYKL),
BankNames::PublicBank => Ok(Self::PBBEMYKL),
BankNames::RhbBank => Ok(Self::RHBBMYKL),
BankNames::StandardCharteredBank => Ok(Self::SCBLMYKX),
BankNames::UobBank => Ok(Self::UOVBMYKL),
BankNames::OcbcBank => Ok(Self::OCBCMYKL),
bank => Err(errors::ConnectorError::NotSupported {
message: format!("Invalid BankName for FPX Refund: {bank:?}"),
connector: "Fiuu",
})?,
}
}
}
impl TryFrom<BankNames> for FPXTxnChannel {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(bank_names: BankNames) -> Result<Self, Self::Error> {
match bank_names {
BankNames::AffinBank => Ok(Self::FpxAbb),
BankNames::AgroBank => Ok(Self::FpxAgrobank),
BankNames::AllianceBank => Ok(Self::FpxAbmb),
BankNames::AmBank => Ok(Self::FpxAmb),
BankNames::BankOfChina => Ok(Self::FpxBocm),
BankNames::BankIslam => Ok(Self::FpxBimb),
BankNames::BankMuamalat => Ok(Self::FpxBmmb),
BankNames::BankRakyat => Ok(Self::FpxBkrm),
BankNames::BankSimpananNasional => Ok(Self::FpxBsn),
BankNames::CimbBank => Ok(Self::FpxCimbclicks),
BankNames::HongLeongBank => Ok(Self::FpxHlb),
BankNames::HsbcBank => Ok(Self::FpxHsbc),
BankNames::KuwaitFinanceHouse => Ok(Self::FpxKfh),
BankNames::Maybank => Ok(Self::FpxMb2u),
BankNames::PublicBank => Ok(Self::FpxPbb),
BankNames::RhbBank => Ok(Self::FpxRhb),
BankNames::StandardCharteredBank => Ok(Self::FpxScb),
BankNames::UobBank => Ok(Self::FpxUob),
BankNames::OcbcBank => Ok(Self::FpxOcbc),
_ => Err(errors::ConnectorError::NotImplemented(
utils::get_unimplemented_payment_method_error_message("Fiuu"),
))?,
}
}
}
#[derive(Serialize, Debug, Clone)]
pub struct FiuuMandateRequest {
#[serde(rename = "0")]
mandate_request: Secret<String>,
}
#[derive(Serialize, Debug, Clone)]
pub struct FiuuRecurringRequest {
record_type: FiuuRecordType,
merchant_id: Secret<String>,
token: Secret<String>,
order_id: String,
currency: Currency,
amount: StringMajorUnit,
billing_name: Secret<String>,
email: Email,
verify_key: Secret<String>,
}
#[derive(Serialize, Debug, Clone, strum::Display)]
pub enum FiuuRecordType {
T,
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
TryFrom<
&FiuuRouterData<
RouterDataV2<
Authorize,
PaymentFlowData,
PaymentsAuthorizeData<T>,
PaymentsResponseData,
>,
T,
>,
> for FiuuMandateRequest
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: &FiuuRouterData<
RouterDataV2<
Authorize,
PaymentFlowData,
PaymentsAuthorizeData<T>,
PaymentsResponseData,
>,
T,
>,
) -> Result<Self, Self::Error> {
let auth: FiuuAuthType = FiuuAuthType::try_from(&item.router_data.connector_auth_type)?;
let record_type = FiuuRecordType::T;
let merchant_id = auth.merchant_id;
let order_id = item
.router_data
.resource_common_data
.connector_request_reference_id
.clone();
| {
"chunk": 1,
"crate": "connector-integration",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_mini_connector-integration_2738435745298344692_2 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/fiuu/transformers.rs
let currency = item.router_data.request.currency;
let converter = StringMajorUnitForConnector;
let amount = converter
.convert(
item.router_data.request.minor_amount,
item.router_data.request.currency,
)
.change_context(ConnectorError::RequestEncodingFailed)?;
let billing_name = item
.router_data
.resource_common_data
.get_billing_full_name()?;
let email = item.router_data.resource_common_data.get_billing_email()?;
let token = Secret::new(item.router_data.request.get_connector_mandate_id()?);
let verify_key = auth.verify_key;
let recurring_request = FiuuRecurringRequest {
record_type: record_type.clone(),
merchant_id: merchant_id.clone(),
token: token.clone(),
order_id: order_id.clone(),
currency,
amount: amount.clone(),
billing_name: billing_name.clone(),
email: email.clone(),
verify_key: verify_key.clone(),
};
let check_sum = calculate_check_sum(recurring_request)?;
let mandate_request = format!(
"{}|{}||{}|{}|{}|{}|{}|{}|||{}",
record_type,
merchant_id.peek(),
token.peek(),
order_id,
currency,
amount.get_amount_as_string(),
billing_name.peek(),
email.peek(),
check_sum.peek()
);
Ok(Self {
mandate_request: mandate_request.into(),
})
}
}
pub fn calculate_check_sum(
req: FiuuRecurringRequest,
) -> CustomResult<Secret<String>, errors::ConnectorError> {
let formatted_string = format!(
"{}{}{}{}{}{}{}",
req.record_type,
req.merchant_id.peek(),
req.token.peek(),
req.order_id,
req.currency,
req.amount.get_amount_as_string(),
req.verify_key.peek()
);
Ok(Secret::new(hex::encode(
crypto::Md5
.generate_digest(formatted_string.as_bytes())
.change_context(errors::ConnectorError::RequestEncodingFailed)?,
)))
}
#[derive(Serialize, Debug, Clone)]
#[serde(rename_all = "PascalCase")]
pub struct FiuuPaymentRequest<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> {
#[serde(rename = "MerchantID")]
merchant_id: Secret<String>,
reference_no: String,
txn_type: TxnType,
txn_currency: Currency,
txn_amount: StringMajorUnit,
signature: Secret<String>,
#[serde(rename = "ReturnURL")]
return_url: Option<String>,
#[serde(rename = "NotificationURL")]
notification_url: Option<Url>,
#[serde(flatten)]
payment_method_data: FiuuPaymentMethodData<T>,
}
#[derive(Serialize, Debug, Clone)]
#[serde(untagged)]
pub enum FiuuPaymentMethodData<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> {
FiuuQRData(Box<FiuuQRData>),
FiuuCardData(Box<FiuuCardData<T>>),
FiuuCardWithNTI(Box<FiuuCardWithNTI>),
FiuuFpxData(Box<FiuuFPXData>),
FiuuGooglePayData(Box<FiuuGooglePayData>),
FiuuApplePayData(Box<FiuuApplePayData>),
}
#[derive(Serialize, Debug, Clone)]
#[serde(rename_all = "PascalCase")]
pub struct FiuuFPXData {
#[serde(rename = "non_3DS")]
non_3ds: i32,
txn_channel: FPXTxnChannel,
}
#[derive(Serialize, Debug, Clone)]
#[serde(rename_all = "PascalCase")]
pub struct FiuuQRData {
txn_channel: TxnChannel,
}
#[derive(Serialize, Debug, Clone)]
#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
pub struct FiuuCardData<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> {
#[serde(rename = "non_3DS")]
non_3ds: i32,
#[serde(rename = "TxnChannel")]
txn_channel: TxnChannel,
cc_pan: RawCardNumber<T>,
cc_cvv2: Secret<String>,
cc_month: Secret<String>,
cc_year: Secret<String>,
#[serde(rename = "mpstokenstatus")]
mps_token_status: Option<i32>,
#[serde(rename = "CustEmail")]
customer_email: Option<Email>,
}
#[derive(Serialize, Debug, Clone)]
#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
pub struct FiuuCardWithNTI {
| {
"chunk": 2,
"crate": "connector-integration",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_mini_connector-integration_2738435745298344692_3 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/fiuu/transformers.rs
#[serde(rename = "TxnChannel")]
txn_channel: TxnChannel,
cc_pan: CardNumber,
cc_month: Secret<String>,
cc_year: Secret<String>,
#[serde(rename = "OriginalSchemeID")]
original_scheme_id: Secret<String>,
}
#[derive(Serialize, Debug, Clone)]
#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
pub struct FiuuApplePayData {
#[serde(rename = "TxnChannel")]
txn_channel: TxnChannel,
cc_month: Secret<String>,
cc_year: Secret<String>,
cc_token: Secret<String>,
eci: Option<String>,
token_cryptogram: Secret<String>,
token_type: FiuuTokenType,
#[serde(rename = "non_3DS")]
non_3ds: i32,
}
#[derive(Serialize, Debug, Clone)]
#[serde(rename_all = "PascalCase")]
pub enum FiuuTokenType {
ApplePay,
GooglePay,
}
#[derive(Serialize, Debug, Clone)]
#[serde(rename_all = "PascalCase")]
pub struct FiuuGooglePayData {
txn_channel: TxnChannel,
#[serde(rename = "GooglePay[apiVersion]")]
api_version: u8,
#[serde(rename = "GooglePay[apiVersionMinor]")]
api_version_minor: u8,
#[serde(rename = "GooglePay[paymentMethodData][info][assuranceDetails][accountVerified]")]
account_verified: Option<bool>,
#[serde(
rename = "GooglePay[paymentMethodData][info][assuranceDetails][cardHolderAuthenticated]"
)]
card_holder_authenticated: Option<bool>,
#[serde(rename = "GooglePay[paymentMethodData][info][cardDetails]")]
card_details: String,
#[serde(rename = "GooglePay[paymentMethodData][info][cardNetwork]")]
card_network: String,
#[serde(rename = "GooglePay[paymentMethodData][tokenizationData][token]")]
token: Secret<String>,
#[serde(rename = "GooglePay[paymentMethodData][tokenizationData][type]")]
tokenization_data_type: Secret<String>,
#[serde(rename = "GooglePay[paymentMethodData][type]")]
pm_type: String,
#[serde(rename = "SCREAMING_SNAKE_CASE")]
token_type: FiuuTokenType,
#[serde(rename = "non_3DS")]
non_3ds: i32,
}
pub fn calculate_signature(
signature_data: String,
) -> Result<Secret<String>, error_stack::Report<errors::ConnectorError>> {
let message = signature_data.as_bytes();
let encoded_data = hex::encode(
crypto::Md5
.generate_digest(message)
.change_context(errors::ConnectorError::RequestEncodingFailed)?,
);
Ok(Secret::new(encoded_data))
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
TryFrom<
&FiuuRouterData<
RouterDataV2<
Authorize,
PaymentFlowData,
PaymentsAuthorizeData<T>,
PaymentsResponseData,
>,
T,
>,
> for FiuuPaymentRequest<T>
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: &FiuuRouterData<
RouterDataV2<
Authorize,
PaymentFlowData,
PaymentsAuthorizeData<T>,
PaymentsResponseData,
>,
T,
>,
) -> Result<Self, Self::Error> {
let auth = FiuuAuthType::try_from(&item.router_data.connector_auth_type)?;
let merchant_id = auth.merchant_id.peek().to_string();
let txn_currency = item.router_data.request.currency;
let converter = StringMajorUnitForConnector;
let amount = converter
.convert(
item.router_data.request.minor_amount,
item.router_data.request.currency,
)
.change_context(ConnectorError::RequestEncodingFailed)?;
let txn_amount = amount;
let reference_no = item
.router_data
.resource_common_data
.connector_request_reference_id
.clone();
let verify_key = auth.verify_key.peek().to_string();
let signature = calculate_signature(format!(
"{}{merchant_id}{reference_no}{verify_key}",
txn_amount.get_amount_as_string()
))?;
let txn_type = match item.router_data.request.is_auto_capture()? {
true => TxnType::Sals,
false => TxnType::Auts,
};
let return_url = item.router_data.request.router_return_url.clone();
| {
"chunk": 3,
"crate": "connector-integration",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_mini_connector-integration_2738435745298344692_4 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/fiuu/transformers.rs
let non_3ds = match item.router_data.request.enrolled_for_3ds {
false => 1,
true => 0,
};
let notification_url = Some(
Url::parse(&item.router_data.request.get_webhook_url()?)
.change_context(errors::ConnectorError::RequestEncodingFailed)?,
);
let payment_method_data = match item
.router_data
.request
.mandate_id
.clone()
.and_then(|mandate_id| mandate_id.mandate_reference_id)
{
None => match item.router_data.request.payment_method_data {
PaymentMethodData::Card(ref card) => {
FiuuPaymentMethodData::try_from((card, &item.router_data))
}
PaymentMethodData::RealTimePayment(ref real_time_payment_data) => {
match *real_time_payment_data.clone() {
RealTimePaymentData::DuitNow {} => {
Ok(FiuuPaymentMethodData::FiuuQRData(Box::new(FiuuQRData {
txn_channel: TxnChannel::RppDuitNowQr,
})))
}
RealTimePaymentData::Fps {}
| RealTimePaymentData::PromptPay {}
| RealTimePaymentData::VietQr {} => {
Err(errors::ConnectorError::NotImplemented(
utils::get_unimplemented_payment_method_error_message("fiuu"),
)
.into())
}
}
}
PaymentMethodData::BankRedirect(ref bank_redirect_data) => match bank_redirect_data
{
BankRedirectData::OnlineBankingFpx { ref issuer } => {
Ok(FiuuPaymentMethodData::FiuuFpxData(Box::new(FiuuFPXData {
txn_channel: FPXTxnChannel::try_from(*issuer)?,
non_3ds,
})))
}
BankRedirectData::BancontactCard { .. }
| BankRedirectData::Bizum {}
| BankRedirectData::Blik { .. }
| BankRedirectData::Eft { .. }
| BankRedirectData::Eps { .. }
| BankRedirectData::Giropay { .. }
| BankRedirectData::Ideal { .. }
| BankRedirectData::Interac { .. }
| BankRedirectData::OnlineBankingCzechRepublic { .. }
| BankRedirectData::OnlineBankingFinland { .. }
| BankRedirectData::OnlineBankingPoland { .. }
| BankRedirectData::OnlineBankingSlovakia { .. }
| BankRedirectData::OpenBankingUk { .. }
| BankRedirectData::Przelewy24 { .. }
| BankRedirectData::Sofort { .. }
| BankRedirectData::Trustly { .. }
| BankRedirectData::OnlineBankingThailand { .. }
| BankRedirectData::LocalBankRedirect {} => {
Err(errors::ConnectorError::NotImplemented(
utils::get_unimplemented_payment_method_error_message("fiuu"),
)
.into())
}
},
PaymentMethodData::Wallet(ref wallet_data) => match wallet_data {
WalletData::GooglePay(google_pay_data) => {
FiuuPaymentMethodData::try_from(google_pay_data)
}
WalletData::ApplePay(_apple_pay_data) => {
let payment_method_token = item
.router_data
.resource_common_data
.get_payment_method_token()?;
match payment_method_token {
PaymentMethodToken::Token(_) => {
Err(unimplemented_payment_method!("Apple Pay", "Manual", "Fiuu"))?
}
PaymentMethodToken::ApplePayDecrypt(decrypt_data) => {
| {
"chunk": 4,
"crate": "connector-integration",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_mini_connector-integration_2738435745298344692_5 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/fiuu/transformers.rs
FiuuPaymentMethodData::try_from(decrypt_data)
}
PaymentMethodToken::PazeDecrypt(_) => {
Err(unimplemented_payment_method!("Paze", "Fiuu"))?
}
PaymentMethodToken::GooglePayDecrypt(_) => {
Err(unimplemented_payment_method!("Google Pay", "Fiuu"))?
}
}
}
WalletData::AliPayQr(_)
| WalletData::AliPayRedirect(_)
| WalletData::AliPayHkRedirect(_)
| WalletData::AmazonPayRedirect(_)
| WalletData::MomoRedirect(_)
| WalletData::KakaoPayRedirect(_)
| WalletData::GoPayRedirect(_)
| WalletData::GcashRedirect(_)
| WalletData::ApplePayRedirect(_)
| WalletData::ApplePayThirdPartySdk(_)
| WalletData::DanaRedirect {}
| WalletData::GooglePayRedirect(_)
| WalletData::GooglePayThirdPartySdk(_)
| WalletData::MbWayRedirect(_)
| WalletData::MobilePayRedirect(_)
| WalletData::PaypalRedirect(_)
| WalletData::PaypalSdk(_)
| WalletData::Paze(_)
| WalletData::SamsungPay(_)
| WalletData::TwintRedirect {}
| WalletData::VippsRedirect {}
| WalletData::TouchNGoRedirect(_)
| WalletData::WeChatPayRedirect(_)
| WalletData::WeChatPayQr(_)
| WalletData::CashappQr(_)
| WalletData::SwishQr(_)
| WalletData::Mifinity(_)
| WalletData::RevolutPay(_)
| WalletData::BluecodeRedirect { .. } => {
Err(errors::ConnectorError::NotImplemented(
utils::get_unimplemented_payment_method_error_message("fiuu"),
)
.into())
}
},
PaymentMethodData::CardRedirect(_)
| PaymentMethodData::PayLater(_)
| PaymentMethodData::BankDebit(_)
| PaymentMethodData::BankTransfer(_)
| PaymentMethodData::Crypto(_)
| PaymentMethodData::MandatePayment
| PaymentMethodData::MobilePayment(_)
| PaymentMethodData::Reward
| PaymentMethodData::Upi(_)
| PaymentMethodData::Voucher(_)
| PaymentMethodData::GiftCard(_)
| PaymentMethodData::CardToken(_)
| PaymentMethodData::OpenBanking(_)
| PaymentMethodData::NetworkToken(_)
| PaymentMethodData::CardDetailsForNetworkTransactionId(_) => {
Err(errors::ConnectorError::NotImplemented(
utils::get_unimplemented_payment_method_error_message("fiuu"),
)
.into())
}
},
// Card payments using network transaction ID
Some(MandateReferenceId::NetworkMandateId(network_transaction_id)) => {
match item.router_data.request.payment_method_data {
PaymentMethodData::CardDetailsForNetworkTransactionId(ref raw_card_details) => {
FiuuPaymentMethodData::try_from((raw_card_details, network_transaction_id))
}
_ => Err(errors::ConnectorError::NotImplemented(
utils::get_unimplemented_payment_method_error_message("fiuu"),
)
.into()),
}
}
_ => Err(errors::ConnectorError::NotImplemented(
utils::get_unimplemented_payment_method_error_message("fiuu"),
)
.into()),
}?;
Ok(Self {
merchant_id: auth.merchant_id,
reference_no,
txn_type,
txn_currency,
txn_amount,
| {
"chunk": 5,
"crate": "connector-integration",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_mini_connector-integration_2738435745298344692_6 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/fiuu/transformers.rs
return_url,
payment_method_data,
signature,
notification_url,
})
}
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
TryFrom<(
&Card<T>,
&RouterDataV2<Authorize, PaymentFlowData, PaymentsAuthorizeData<T>, PaymentsResponseData>,
)> for FiuuPaymentMethodData<T>
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
(req_card, item): (
&Card<T>,
&RouterDataV2<
Authorize,
PaymentFlowData,
PaymentsAuthorizeData<T>,
PaymentsResponseData,
>,
),
) -> Result<Self, Self::Error> {
let (mps_token_status, customer_email) = (Some(3), None);
let non_3ds = match item.request.enrolled_for_3ds {
false => 1,
true => 0,
};
Ok(Self::FiuuCardData(Box::new(FiuuCardData {
txn_channel: TxnChannel::Creditan,
non_3ds,
cc_pan: req_card.card_number.clone(),
cc_cvv2: req_card.card_cvc.clone(),
cc_month: req_card.card_exp_month.clone(),
cc_year: req_card.card_exp_year.clone(),
mps_token_status,
customer_email,
})))
}
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> TryFrom<(&CardDetailsForNetworkTransactionId, String)> for FiuuPaymentMethodData<T>
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
(raw_card_data, network_transaction_id): (&CardDetailsForNetworkTransactionId, String),
) -> Result<Self, Self::Error> {
Ok(Self::FiuuCardWithNTI(Box::new(FiuuCardWithNTI {
txn_channel: TxnChannel::Creditan,
cc_pan: raw_card_data.card_number.clone(),
cc_month: raw_card_data.card_exp_month.clone(),
cc_year: raw_card_data.card_exp_year.clone(),
original_scheme_id: Secret::new(network_transaction_id),
})))
}
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> TryFrom<&GooglePayWalletData> for FiuuPaymentMethodData<T>
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(data: &GooglePayWalletData) -> Result<Self, Self::Error> {
Ok(Self::FiuuGooglePayData(Box::new(FiuuGooglePayData {
txn_channel: TxnChannel::Creditan,
api_version: GOOGLEPAY_API_VERSION,
api_version_minor: GOOGLEPAY_API_VERSION_MINOR,
account_verified: data
.info
.assurance_details
.as_ref()
.map(|details| details.account_verified),
card_holder_authenticated: data
.info
.assurance_details
.as_ref()
.map(|details| details.card_holder_authenticated),
card_details: data.info.card_details.clone(),
card_network: data.info.card_network.clone(),
token: data
.tokenization_data
.get_encrypted_google_pay_token()
.change_context(errors::ConnectorError::MissingRequiredField {
field_name: "gpay wallet_token",
})?
.clone()
.into(),
tokenization_data_type: data
.tokenization_data
.get_encrypted_token_type()
.change_context(errors::ConnectorError::MissingRequiredField {
field_name: "gpay wallet token type",
})?
.clone()
.into(),
pm_type: data.pm_type.clone(),
token_type: FiuuTokenType::GooglePay,
// non_3ds field Applicable to card processing via specific processor using specific currency for pre-approved partner only.
// Equal to 0 by default and 1 for non-3DS transaction, That is why it is hardcoded to 1 for googlepay transactions.
| {
"chunk": 6,
"crate": "connector-integration",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_mini_connector-integration_2738435745298344692_7 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/fiuu/transformers.rs
non_3ds: 1,
})))
}
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> TryFrom<Box<ApplePayPredecryptData>> for FiuuPaymentMethodData<T>
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(decrypt_data: Box<ApplePayPredecryptData>) -> Result<Self, Self::Error> {
Ok(Self::FiuuApplePayData(Box::new(FiuuApplePayData {
txn_channel: TxnChannel::Creditan,
cc_month: decrypt_data.get_expiry_month()?,
cc_year: decrypt_data.get_four_digit_expiry_year()?,
cc_token: decrypt_data.application_primary_account_number,
eci: decrypt_data.payment_data.eci_indicator,
token_cryptogram: decrypt_data.payment_data.online_payment_cryptogram,
token_type: FiuuTokenType::ApplePay,
// non_3ds field Applicable to card processing via specific processor using specific currency for pre-approved partner only.
// Equal to 0 by default and 1 for non-3DS transaction, That is why it is hardcoded to 1 for apple pay decrypt flow transactions.
non_3ds: 1,
})))
}
}
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "PascalCase")]
pub struct PaymentsResponse {
pub reference_no: String,
#[serde(rename = "TxnID")]
pub txn_id: String,
pub txn_type: TxnType,
pub txn_currency: Currency,
pub txn_amount: StringMajorUnit,
pub txn_channel: String,
pub txn_data: TxnData,
}
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "PascalCase")]
pub struct DuitNowQrCodeResponse {
pub reference_no: String,
pub txn_type: TxnType,
pub txn_currency: Currency,
pub txn_amount: StringMajorUnit,
pub txn_channel: String,
#[serde(rename = "TxnID")]
pub txn_id: String,
pub txn_data: QrTxnData,
}
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "PascalCase")]
pub struct QrTxnData {
pub request_data: QrRequestData,
}
#[derive(Debug, Serialize, Deserialize)]
pub struct QrRequestData {
pub qr_data: Secret<String>,
}
#[derive(Debug, Serialize, Deserialize)]
#[serde(untagged)]
pub enum FiuuPaymentsResponse {
PaymentResponse(Box<PaymentsResponse>),
QRPaymentResponse(Box<DuitNowQrCodeResponse>),
Error(FiuuErrorResponse),
RecurringResponse(Vec<Box<FiuuRecurringResponse>>),
}
#[derive(Debug, Serialize, Deserialize)]
pub struct FiuuRecurringResponse {
status: FiuuRecurringStautus,
#[serde(rename = "orderid")]
order_id: String,
#[serde(rename = "tranID")]
tran_id: Option<String>,
reason: Option<String>,
}
#[derive(Debug, Serialize, Deserialize, Clone)]
#[serde(rename_all = "snake_case")]
pub enum FiuuRecurringStautus {
Accepted,
Failed,
}
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "PascalCase")]
pub struct TxnData {
#[serde(rename = "RequestURL")]
pub request_url: String,
pub request_type: RequestType,
pub request_data: RequestData,
pub request_method: String,
}
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "UPPERCASE")]
pub enum RequestType {
Redirect,
Response,
}
#[derive(Debug, Serialize, Deserialize)]
#[serde(untagged)]
pub enum RequestData {
NonThreeDS(NonThreeDSResponseData),
RedirectData(Option<HashMap<String, String>>),
}
#[derive(Debug, Serialize, Deserialize)]
pub struct QrCodeData {
#[serde(rename = "tranID")]
pub tran_id: String,
pub status: String,
}
#[derive(Debug, Serialize, Deserialize)]
pub struct NonThreeDSResponseData {
#[serde(rename = "tranID")]
pub tran_id: String,
pub status: String,
#[serde(rename = "extraP")]
pub extra_parameters: Option<ExtraParameters>,
pub error_code: Option<String>,
pub error_desc: Option<String>,
}
#[derive(Debug, Serialize, Deserialize, Clone)]
pub struct ExtraParameters {
pub token: Option<Secret<String>>,
}
impl<
F,
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize
+ Serialize,
> TryFrom<ResponseRouterData<FiuuPaymentsResponse, Self>>
for RouterDataV2<F, PaymentFlowData, PaymentsAuthorizeData<T>, PaymentsResponseData>
{
| {
"chunk": 7,
"crate": "connector-integration",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_mini_connector-integration_2738435745298344692_8 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/fiuu/transformers.rs
type Error = error_stack::Report<ConnectorError>;
fn try_from(item: ResponseRouterData<FiuuPaymentsResponse, Self>) -> Result<Self, Self::Error> {
let ResponseRouterData {
response,
router_data,
http_code: _http_code,
} = item;
match response {
FiuuPaymentsResponse::QRPaymentResponse(ref response) => Ok(Self {
resource_common_data: PaymentFlowData {
status: common_enums::AttemptStatus::AuthenticationPending,
..router_data.resource_common_data
},
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(response.txn_id.clone()),
redirection_data: None,
mandate_reference: None,
connector_metadata: get_qr_metadata(response)?,
network_txn_id: None,
connector_response_reference_id: None,
incremental_authorization_allowed: None,
status_code: item.http_code,
}),
..router_data
}),
FiuuPaymentsResponse::Error(error) => Ok(Self {
response: Err(ErrorResponse {
code: error.error_code.clone(),
message: error.error_desc.clone(),
reason: Some(error.error_desc),
status_code: item.http_code,
attempt_status: None,
connector_transaction_id: None,
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
}),
..router_data
}),
FiuuPaymentsResponse::PaymentResponse(data) => match data.txn_data.request_data {
RequestData::RedirectData(redirection_data) => {
let redirection_data = Some(RedirectForm::Form {
endpoint: data.txn_data.request_url.to_string(),
method: if data.txn_data.request_method.as_str() == "POST" {
Method::Post
} else {
Method::Get
},
form_fields: redirection_data.unwrap_or_default(),
});
Ok(Self {
resource_common_data: PaymentFlowData {
status: common_enums::AttemptStatus::AuthenticationPending,
..router_data.resource_common_data
},
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(data.txn_id),
redirection_data: redirection_data.map(Box::new),
mandate_reference: None,
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: None,
incremental_authorization_allowed: None,
status_code: item.http_code,
}),
..router_data
})
}
RequestData::NonThreeDS(non_threeds_data) => {
let mandate_reference =
non_threeds_data
.extra_parameters
.as_ref()
.and_then(|extra_p| {
extra_p.token.as_ref().map(|token| MandateReference {
connector_mandate_id: Some(token.clone().expose()),
payment_method_id: None,
})
});
let status = match non_threeds_data.status.as_str() {
"00" => {
if router_data.request.is_auto_capture()? {
Ok(common_enums::AttemptStatus::Charged)
} else {
| {
"chunk": 8,
"crate": "connector-integration",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_mini_connector-integration_2738435745298344692_9 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/fiuu/transformers.rs
Ok(common_enums::AttemptStatus::Authorized)
}
}
"11" => Ok(common_enums::AttemptStatus::Failure),
"22" => Ok(common_enums::AttemptStatus::Pending),
other => Err(errors::ConnectorError::UnexpectedResponseError(
bytes::Bytes::from(other.to_owned()),
)),
}?;
let response = if status == common_enums::AttemptStatus::Failure {
Err(ErrorResponse {
code: non_threeds_data
.error_code
.clone()
.unwrap_or_else(|| consts::NO_ERROR_CODE.to_string()),
message: non_threeds_data
.error_desc
.clone()
.unwrap_or_else(|| consts::NO_ERROR_MESSAGE.to_string()),
reason: non_threeds_data.error_desc.clone(),
status_code: item.http_code,
attempt_status: None,
connector_transaction_id: Some(data.txn_id),
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
})
} else {
Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(data.txn_id.clone()),
redirection_data: None,
mandate_reference: mandate_reference.map(Box::new),
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: None,
incremental_authorization_allowed: None,
status_code: item.http_code,
})
};
Ok(Self {
resource_common_data: PaymentFlowData {
status,
..router_data.resource_common_data
},
response,
..router_data
})
}
},
FiuuPaymentsResponse::RecurringResponse(ref recurring_response_vec) => {
let recurring_response_item = recurring_response_vec.first();
let router_data_response = match recurring_response_item {
Some(recurring_response) => {
let status =
common_enums::AttemptStatus::from(recurring_response.status.clone());
let connector_transaction_id = recurring_response
.tran_id
.as_ref()
.map_or(ResponseId::NoResponseId, |tran_id| {
ResponseId::ConnectorTransactionId(tran_id.clone())
});
let response = if status == common_enums::AttemptStatus::Failure {
Err(ErrorResponse {
code: recurring_response
.reason
.clone()
.unwrap_or_else(|| consts::NO_ERROR_CODE.to_string()),
message: recurring_response
.reason
.clone()
.unwrap_or_else(|| consts::NO_ERROR_MESSAGE.to_string()),
reason: recurring_response.reason.clone(),
status_code: item.http_code,
attempt_status: None,
connector_transaction_id: recurring_response.tran_id.clone(),
network_advice_code: None,
| {
"chunk": 9,
"crate": "connector-integration",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_mini_connector-integration_2738435745298344692_10 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/fiuu/transformers.rs
network_decline_code: None,
network_error_message: None,
})
} else {
Ok(PaymentsResponseData::TransactionResponse {
resource_id: connector_transaction_id,
redirection_data: None,
mandate_reference: None,
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: None,
incremental_authorization_allowed: None,
status_code: item.http_code,
})
};
Self {
resource_common_data: PaymentFlowData {
status,
..router_data.resource_common_data
},
response,
..router_data
}
}
None => {
// It is not expected to get empty response from the connector, if we get we are not updating the payment response since we don't have any info in the authorize response.
let response = Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::NoResponseId,
redirection_data: None,
mandate_reference: None,
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: None,
incremental_authorization_allowed: None,
status_code: item.http_code,
});
Self {
response,
..router_data
}
}
};
Ok(router_data_response)
}
}
}
}
impl From<FiuuRecurringStautus> for common_enums::AttemptStatus {
fn from(status: FiuuRecurringStautus) -> Self {
match status {
FiuuRecurringStautus::Accepted => Self::Charged,
FiuuRecurringStautus::Failed => Self::Failure,
}
}
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "PascalCase")]
pub struct FiuuRefundRequest {
pub refund_type: RefundType,
#[serde(rename = "MerchantID")]
pub merchant_id: Secret<String>,
#[serde(rename = "RefID")]
pub ref_id: String,
#[serde(rename = "TxnID")]
pub txn_id: String,
pub amount: StringMajorUnit,
pub signature: Secret<String>,
#[serde(rename = "notify_url")]
pub notify_url: Option<Url>,
}
#[derive(Debug, Serialize, Display)]
pub enum RefundType {
#[serde(rename = "P")]
#[strum(serialize = "P")]
Partial,
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
TryFrom<
FiuuRouterData<RouterDataV2<Refund, RefundFlowData, RefundsData, RefundsResponseData>, T>,
> for FiuuRefundRequest
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: FiuuRouterData<
RouterDataV2<Refund, RefundFlowData, RefundsData, RefundsResponseData>,
T,
>,
) -> Result<Self, Self::Error> {
let auth: FiuuAuthType = FiuuAuthType::try_from(&item.router_data.connector_auth_type)?;
let merchant_id = auth.merchant_id.peek().to_string();
let converter = StringMajorUnitForConnector;
let amount = converter
.convert(
item.router_data.request.minor_refund_amount,
item.router_data.request.currency,
)
.change_context(ConnectorError::RequestEncodingFailed)?;
let txn_amount = amount;
let reference_no = item
.router_data
.resource_common_data
.refund_id
.clone()
| {
"chunk": 10,
"crate": "connector-integration",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_mini_connector-integration_2738435745298344692_11 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/fiuu/transformers.rs
.ok_or_else(|| errors::ConnectorError::MissingConnectorRefundID)?;
let txn_id = item.router_data.request.connector_transaction_id.clone();
let secret_key = auth.secret_key.peek().to_string();
Ok(Self {
refund_type: RefundType::Partial,
merchant_id: auth.merchant_id,
ref_id: reference_no.clone(),
txn_id: txn_id.clone(),
amount: txn_amount.clone(),
signature: calculate_signature(format!(
"{}{merchant_id}{reference_no}{txn_id}{}{secret_key}",
RefundType::Partial,
txn_amount.get_amount_as_string()
))?,
notify_url: Some(
Url::parse(&item.router_data.request.get_webhook_url()?)
.change_context(errors::ConnectorError::RequestEncodingFailed)?,
),
})
}
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "PascalCase")]
pub struct FiuuRefundSuccessResponse {
#[serde(rename = "RefundID")]
refund_id: i64,
status: String,
#[serde(rename = "reason")]
reason: Option<String>,
}
#[derive(Debug, Serialize, Deserialize)]
#[serde(untagged)]
pub enum FiuuRefundResponse {
Success(FiuuRefundSuccessResponse),
Error(FiuuErrorResponse),
}
impl<F> TryFrom<ResponseRouterData<FiuuRefundResponse, Self>>
for RouterDataV2<F, RefundFlowData, RefundsData, RefundsResponseData>
{
type Error = error_stack::Report<ConnectorError>;
fn try_from(item: ResponseRouterData<FiuuRefundResponse, Self>) -> Result<Self, Self::Error> {
let ResponseRouterData {
response,
router_data,
http_code: _http_code,
} = item;
match response {
FiuuRefundResponse::Error(error) => Ok(Self {
response: Err(ErrorResponse {
code: error.error_code.clone(),
message: error.error_desc.clone(),
reason: Some(error.error_desc),
status_code: item.http_code,
attempt_status: None,
connector_transaction_id: None,
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
}),
..router_data
}),
FiuuRefundResponse::Success(refund_data) => {
let refund_status = match refund_data.status.as_str() {
"00" => Ok(common_enums::RefundStatus::Success),
"11" => Ok(common_enums::RefundStatus::Failure),
"22" => Ok(common_enums::RefundStatus::Pending),
other => Err(errors::ConnectorError::UnexpectedResponseError(
bytes::Bytes::from(other.to_owned()),
)),
}?;
if refund_status == common_enums::RefundStatus::Failure {
Ok(Self {
response: Err(ErrorResponse {
code: refund_data.status.clone(),
message: refund_data
.reason
.clone()
.unwrap_or(consts::NO_ERROR_MESSAGE.to_string()),
reason: refund_data.reason.clone(),
status_code: item.http_code,
attempt_status: None,
connector_transaction_id: Some(refund_data.refund_id.to_string()),
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
}),
..router_data
})
} else {
Ok(Self {
response: Ok(RefundsResponseData {
connector_refund_id: refund_data.refund_id.clone().to_string(),
refund_status,
status_code: item.http_code,
}),
..router_data
})
}
}
}
}
}
#[derive(Debug, Serialize, Deserialize)]
| {
"chunk": 11,
"crate": "connector-integration",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_mini_connector-integration_2738435745298344692_12 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/fiuu/transformers.rs
pub struct FiuuErrorResponse {
pub error_code: String,
pub error_desc: String,
}
#[derive(Debug, Serialize, Deserialize)]
pub struct FiuuPaymentSyncRequest {
amount: StringMajorUnit,
#[serde(rename = "txID")]
tx_id: String,
domain: String,
skey: Secret<String>,
}
#[derive(Debug, Serialize, Deserialize, Clone)]
#[serde(untagged)]
pub enum FiuuPaymentResponse {
FiuuPaymentSyncResponse(FiuuPaymentSyncResponse),
FiuuWebhooksPaymentResponse(FiuuWebhooksPaymentResponse),
}
#[derive(Debug, Serialize, Deserialize, Clone)]
#[serde(rename_all = "PascalCase")]
pub struct FiuuPaymentSyncResponse {
stat_code: StatCode,
stat_name: StatName,
#[serde(rename = "TranID")]
tran_id: String,
error_code: Option<String>,
error_desc: Option<String>,
#[serde(rename = "miscellaneous")]
miscellaneous: Option<HashMap<String, Secret<String>>>,
#[serde(rename = "SchemeTransactionID")]
scheme_transaction_id: Option<Secret<String>>,
}
#[derive(Debug, Serialize, Deserialize, Display, Clone, PartialEq)]
pub enum StatCode {
#[serde(rename = "00")]
Success,
#[serde(rename = "11")]
Failure,
#[serde(rename = "22")]
Pending,
}
#[derive(Debug, Serialize, Deserialize, Display, Clone, Copy, PartialEq)]
#[serde(rename_all = "lowercase")]
pub enum StatName {
Captured,
Settled,
Authorized,
Failed,
Cancelled,
Chargeback,
Release,
#[serde(rename = "reject/hold")]
RejectHold,
Blocked,
#[serde(rename = "ReqCancel")]
ReqCancel,
#[serde(rename = "ReqChargeback")]
ReqChargeback,
#[serde(rename = "Pending")]
Pending,
#[serde(rename = "Unknown")]
Unknown,
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
TryFrom<
FiuuRouterData<
RouterDataV2<PSync, PaymentFlowData, PaymentsSyncData, PaymentsResponseData>,
T,
>,
> for FiuuPaymentSyncRequest
{
type Error = error_stack::Report<ConnectorError>;
fn try_from(
item: FiuuRouterData<
RouterDataV2<PSync, PaymentFlowData, PaymentsSyncData, PaymentsResponseData>,
T,
>,
) -> Result<Self, Self::Error> {
let auth = FiuuAuthType::try_from(&item.router_data.connector_auth_type)?;
let txn_id = item
.router_data
.request
.connector_transaction_id
.get_connector_transaction_id()
.change_context(errors::ConnectorError::MissingConnectorTransactionID)?;
let merchant_id = auth.merchant_id.peek().to_string();
let verify_key = auth.verify_key.peek().to_string();
let amount = StringMajorUnitForConnector
.convert(
item.router_data.request.amount,
item.router_data.request.currency,
)
.change_context(errors::ConnectorError::AmountConversionFailed)?;
Ok(Self {
amount: amount.clone(),
tx_id: txn_id.clone(),
domain: merchant_id.clone(),
skey: calculate_signature(format!(
"{txn_id}{merchant_id}{verify_key}{}",
amount.get_amount_as_string()
))?,
})
}
}
struct ErrorInputs {
encoded_data: Option<String>,
response_error_code: Option<String>,
response_error_desc: Option<String>,
}
struct ErrorDetails {
pub code: String,
pub message: String,
pub reason: Option<String>,
}
impl TryFrom<ErrorInputs> for ErrorDetails {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(value: ErrorInputs) -> Result<Self, Self::Error> {
let query_params = value
.encoded_data
.as_ref()
.map(|encoded_data| {
serde_urlencoded::from_str::<FiuuPaymentRedirectResponse>(encoded_data)
})
.transpose()
.change_context(errors::ConnectorError::ResponseDeserializationFailed)
.attach_printable("Failed to deserialize FiuuPaymentRedirectResponse")?;
let error_message = value
.response_error_desc
.as_ref()
.filter(|s| !s.is_empty())
.cloned()
.or_else(|| {
query_params
.as_ref()
| {
"chunk": 12,
"crate": "connector-integration",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_mini_connector-integration_2738435745298344692_13 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/fiuu/transformers.rs
.and_then(|qp| qp.error_desc.as_ref())
.filter(|s| !s.is_empty())
.cloned()
});
let error_code = value
.response_error_code
.as_ref()
.filter(|s| !s.is_empty())
.cloned()
.or_else(|| {
query_params
.as_ref()
.and_then(|qp| qp.error_code.as_ref())
.filter(|s| !s.is_empty())
.cloned()
})
.unwrap_or_else(|| consts::NO_ERROR_CODE.to_owned());
Ok(Self {
code: error_code,
message: error_message
.clone()
.unwrap_or_else(|| consts::NO_ERROR_MESSAGE.to_owned()),
reason: error_message,
})
}
}
impl<F> TryFrom<ResponseRouterData<FiuuPaymentResponse, Self>>
for RouterDataV2<F, PaymentFlowData, PaymentsSyncData, PaymentsResponseData>
{
type Error = error_stack::Report<ConnectorError>;
fn try_from(item: ResponseRouterData<FiuuPaymentResponse, Self>) -> Result<Self, Self::Error> {
let ResponseRouterData {
response,
router_data,
http_code: _http_code,
} = item;
match response {
FiuuPaymentResponse::FiuuPaymentSyncResponse(response) => {
let stat_name = response.stat_name;
let stat_code = response.stat_code.clone();
let txn_id = response.tran_id;
let status = common_enums::AttemptStatus::try_from(FiuuSyncStatus {
stat_name,
stat_code,
})?;
let error_response = if status == common_enums::AttemptStatus::Failure {
let error_details = ErrorDetails::try_from(ErrorInputs {
encoded_data: router_data.request.encoded_data.clone(),
response_error_code: response.error_code.clone(),
response_error_desc: response.error_desc.clone(),
})?;
Some(ErrorResponse {
status_code: item.http_code,
code: error_details.code,
message: error_details.message,
reason: error_details.reason,
attempt_status: Some(common_enums::AttemptStatus::Failure),
connector_transaction_id: Some(txn_id.clone()),
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
})
} else {
None
};
let payments_response_data = PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(txn_id.clone().to_string()),
redirection_data: None,
mandate_reference: None,
connector_metadata: None,
network_txn_id: response
.scheme_transaction_id
.as_ref()
.map(|id| id.clone().expose()),
connector_response_reference_id: None,
incremental_authorization_allowed: None,
status_code: item.http_code,
};
Ok(Self {
resource_common_data: PaymentFlowData {
status,
..router_data.resource_common_data
},
response: error_response.map_or_else(|| Ok(payments_response_data), Err),
..router_data
})
}
FiuuPaymentResponse::FiuuWebhooksPaymentResponse(response) => {
let status = common_enums::AttemptStatus::try_from(FiuuWebhookStatus {
capture_method: router_data.request.capture_method,
status: response.status,
})?;
let txn_id = response.tran_id;
let mandate_reference = response.extra_parameters.as_ref().and_then(|extra_p| {
| {
"chunk": 13,
"crate": "connector-integration",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_mini_connector-integration_2738435745298344692_14 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/fiuu/transformers.rs
let mandate_token: Result<ExtraParameters, _> =
serde_json::from_str(&extra_p.clone().expose());
match mandate_token {
Ok(token) => token.token.as_ref().map(|token| MandateReference {
connector_mandate_id: Some(token.clone().expose()),
payment_method_id: None,
}),
Err(_err) => None,
}
});
let error_response = if status == common_enums::AttemptStatus::Failure {
let error_details = ErrorDetails::try_from(ErrorInputs {
encoded_data: router_data.request.encoded_data.clone(),
response_error_code: response.error_code.clone(),
response_error_desc: response.error_desc.clone(),
})?;
Some(ErrorResponse {
status_code: item.http_code,
code: error_details.code,
message: error_details.message,
reason: error_details.reason,
attempt_status: Some(common_enums::AttemptStatus::Failure),
connector_transaction_id: Some(txn_id.clone()),
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
})
} else {
None
};
let payments_response_data = PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(txn_id.clone().to_string()),
redirection_data: None,
mandate_reference: mandate_reference.map(Box::new),
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: None,
incremental_authorization_allowed: None,
status_code: item.http_code,
};
Ok(Self {
resource_common_data: PaymentFlowData {
status,
..router_data.resource_common_data
},
response: error_response.map_or_else(|| Ok(payments_response_data), Err),
..router_data
})
}
}
}
}
pub struct FiuuWebhookStatus {
pub capture_method: Option<CaptureMethod>,
pub status: FiuuPaymentWebhookStatus,
}
impl TryFrom<FiuuWebhookStatus> for common_enums::AttemptStatus {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(webhook_status: FiuuWebhookStatus) -> Result<Self, Self::Error> {
match webhook_status.status {
FiuuPaymentWebhookStatus::Success => match webhook_status.capture_method {
Some(CaptureMethod::Automatic) | Some(CaptureMethod::SequentialAutomatic) => {
Ok(Self::Charged)
}
Some(CaptureMethod::Manual) => Ok(Self::Authorized),
_ => Err(errors::ConnectorError::UnexpectedResponseError(
bytes::Bytes::from(webhook_status.status.to_string()),
))?,
},
FiuuPaymentWebhookStatus::Failure => Ok(Self::Failure),
FiuuPaymentWebhookStatus::Pending => Ok(Self::AuthenticationPending),
}
}
}
#[derive(Debug, Serialize, Deserialize)]
pub struct PaymentCaptureRequest {
domain: String,
#[serde(rename = "tranID")]
tran_id: String,
amount: StringMajorUnit,
#[serde(rename = "RefID")]
ref_id: String,
skey: Secret<String>,
}
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "PascalCase")]
pub struct PaymentCaptureResponse {
#[serde(rename = "TranID")]
tran_id: String,
stat_code: String,
}
pub struct FiuuSyncStatus {
pub stat_name: StatName,
pub stat_code: StatCode,
}
impl TryFrom<FiuuSyncStatus> for common_enums::AttemptStatus {
type Error = errors::ConnectorError;
fn try_from(sync_status: FiuuSyncStatus) -> Result<Self, Self::Error> {
| {
"chunk": 14,
"crate": "connector-integration",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_mini_connector-integration_2738435745298344692_15 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/fiuu/transformers.rs
match (sync_status.stat_code, sync_status.stat_name) {
(StatCode::Success, StatName::Captured | StatName::Settled) => Ok(Self::Charged), // For Success as StatCode we can only expect Captured,Settled and Authorized as StatName.
(StatCode::Success, StatName::Authorized) => Ok(Self::Authorized),
(StatCode::Pending, StatName::Pending) => Ok(Self::AuthenticationPending), // For Pending as StatCode we can only expect Pending and Unknown as StatName.
(StatCode::Pending, StatName::Unknown) => Ok(Self::Pending),
(StatCode::Failure, StatName::Cancelled) | (StatCode::Failure, StatName::ReqCancel) => {
Ok(Self::Voided)
}
(StatCode::Failure, _) => Ok(Self::Failure),
(other, _) => Err(errors::ConnectorError::UnexpectedResponseError(
bytes::Bytes::from(other.to_string()),
)),
}
}
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
TryFrom<
FiuuRouterData<
RouterDataV2<Capture, PaymentFlowData, PaymentsCaptureData, PaymentsResponseData>,
T,
>,
> for PaymentCaptureRequest
{
type Error = error_stack::Report<ConnectorError>;
fn try_from(
item: FiuuRouterData<
RouterDataV2<Capture, PaymentFlowData, PaymentsCaptureData, PaymentsResponseData>,
T,
>,
) -> Result<Self, Self::Error> {
let auth = FiuuAuthType::try_from(&item.router_data.connector_auth_type)?;
let merchant_id = auth.merchant_id.peek().to_string();
let converter = StringMajorUnitForConnector;
let amount = converter
.convert(
item.router_data.request.minor_amount_to_capture,
item.router_data.request.currency,
)
.change_context(ConnectorError::RequestEncodingFailed)?;
let txn_id = match item.router_data.request.connector_transaction_id {
ResponseId::ConnectorTransactionId(tid) => tid,
_ => {
return Err(errors::ConnectorError::MissingConnectorTransactionID.into());
}
};
let verify_key = auth.verify_key.peek().to_string();
let signature = calculate_signature(format!(
"{txn_id}{}{merchant_id}{verify_key}",
amount.get_amount_as_string()
))?;
Ok(Self {
domain: merchant_id,
tran_id: txn_id,
amount,
ref_id: item
.router_data
.resource_common_data
.connector_request_reference_id
.clone(),
skey: signature,
})
}
}
fn capture_status_codes() -> HashMap<&'static str, &'static str> {
[
("00", "Capture successful"),
("11", "Capture failed"),
("12", "Invalid or unmatched security hash string"),
("13", "Not a credit card transaction"),
("15", "Requested day is on settlement day"),
("16", "Forbidden transaction"),
("17", "Transaction not found"),
("18", "Missing required parameter"),
("19", "Domain not found"),
("20", "Temporary out of service"),
("21", "Authorization expired"),
("23", "Partial capture not allowed"),
("24", "Transaction already captured"),
("25", "Requested amount exceeds available capture amount"),
("99", "General error (contact payment gateway support)"),
]
.into_iter()
.collect()
}
impl<F> TryFrom<ResponseRouterData<PaymentCaptureResponse, Self>>
for RouterDataV2<F, PaymentFlowData, PaymentsCaptureData, PaymentsResponseData>
{
type Error = error_stack::Report<ConnectorError>;
fn try_from(
item: ResponseRouterData<PaymentCaptureResponse, Self>,
) -> Result<Self, Self::Error> {
let ResponseRouterData {
response,
router_data,
http_code: _http_code,
} = item;
let status_code = response.stat_code;
let status = match status_code.as_str() {
"00" => Ok(common_enums::AttemptStatus::Charged),
| {
"chunk": 15,
"crate": "connector-integration",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_mini_connector-integration_2738435745298344692_16 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/fiuu/transformers.rs
"22" => Ok(common_enums::AttemptStatus::Pending),
"11" | "12" | "13" | "15" | "16" | "17" | "18" | "19" | "20" | "21" | "23" | "24"
| "25" | "99" => Ok(common_enums::AttemptStatus::Failure),
other => Err(errors::ConnectorError::UnexpectedResponseError(
bytes::Bytes::from(other.to_owned()),
)),
}?;
let capture_message_status = capture_status_codes();
let error_response = if status == common_enums::AttemptStatus::Failure {
let optional_message = capture_message_status
.get(status_code.as_str())
.copied()
.map(String::from);
Some(ErrorResponse {
status_code: item.http_code,
code: status_code.to_owned(),
message: optional_message
.clone()
.unwrap_or_else(|| consts::NO_ERROR_MESSAGE.to_string()),
reason: optional_message,
attempt_status: None,
connector_transaction_id: Some(response.tran_id.clone()),
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
})
} else {
None
};
let payments_response_data = PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(response.tran_id.clone().to_string()),
redirection_data: None,
mandate_reference: None,
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: None,
incremental_authorization_allowed: None,
status_code: item.http_code,
};
Ok(Self {
resource_common_data: PaymentFlowData {
status,
..router_data.resource_common_data
},
response: error_response.map_or_else(|| Ok(payments_response_data), Err),
..router_data
})
}
}
#[derive(Debug, Serialize, Deserialize)]
pub struct FiuuPaymentCancelRequest {
#[serde(rename = "txnID")]
txn_id: String,
domain: String,
skey: Secret<String>,
}
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "PascalCase")]
pub struct FiuuPaymentCancelResponse {
#[serde(rename = "TranID")]
tran_id: String,
stat_code: String,
#[serde(rename = "miscellaneous")]
miscellaneous: Option<HashMap<String, Secret<String>>>,
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
TryFrom<
FiuuRouterData<
RouterDataV2<Void, PaymentFlowData, PaymentVoidData, PaymentsResponseData>,
T,
>,
> for FiuuPaymentCancelRequest
{
type Error = error_stack::Report<ConnectorError>;
fn try_from(
item: FiuuRouterData<
RouterDataV2<Void, PaymentFlowData, PaymentVoidData, PaymentsResponseData>,
T,
>,
) -> Result<Self, Self::Error> {
let auth = FiuuAuthType::try_from(&item.router_data.connector_auth_type)?;
let txn_id = item.router_data.request.connector_transaction_id.clone();
let merchant_id = auth.merchant_id.peek().to_string();
let secret_key = auth.secret_key.peek().to_string();
Ok(Self {
txn_id: txn_id.clone(),
domain: merchant_id.clone(),
skey: calculate_signature(format!("{txn_id}{merchant_id}{secret_key}"))?,
})
}
}
fn void_status_codes() -> HashMap<&'static str, &'static str> {
[
("00", "Success (will proceed the request)"),
("11", "Failure"),
("12", "Invalid or unmatched security hash string"),
("13", "Not a refundable transaction"),
("14", "Transaction date more than 180 days"),
("15", "Requested day is on settlement day"),
("16", "Forbidden transaction"),
("17", "Transaction not found"),
("18", "Duplicate partial refund request"),
("19", "Merchant not found"),
("20", "Missing required parameter"),
(
"21",
"Transaction must be in authorized/captured/settled status",
),
]
| {
"chunk": 16,
"crate": "connector-integration",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_mini_connector-integration_2738435745298344692_17 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/fiuu/transformers.rs
.into_iter()
.collect()
}
impl<F> TryFrom<ResponseRouterData<FiuuPaymentCancelResponse, Self>>
for RouterDataV2<F, PaymentFlowData, PaymentVoidData, PaymentsResponseData>
{
type Error = error_stack::Report<ConnectorError>;
fn try_from(
item: ResponseRouterData<FiuuPaymentCancelResponse, Self>,
) -> Result<Self, Self::Error> {
let ResponseRouterData {
response,
router_data,
http_code: _http_code,
} = item;
let status_code = response.stat_code;
let status = match status_code.as_str() {
"00" => Ok(common_enums::AttemptStatus::Voided),
"11" | "12" | "13" | "14" | "15" | "16" | "17" | "18" | "19" | "20" | "21" => {
Ok(common_enums::AttemptStatus::VoidFailed)
}
other => Err(errors::ConnectorError::UnexpectedResponseError(
bytes::Bytes::from(other.to_owned()),
)),
}?;
let void_message_status = void_status_codes();
let error_response = if status == common_enums::AttemptStatus::VoidFailed {
let optional_message = void_message_status
.get(status_code.as_str())
.copied()
.map(String::from);
Some(ErrorResponse {
status_code: item.http_code,
code: status_code.to_owned(),
message: optional_message
.clone()
.unwrap_or_else(|| consts::NO_ERROR_MESSAGE.to_string()),
reason: optional_message,
attempt_status: None,
connector_transaction_id: Some(response.tran_id.clone()),
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
})
} else {
None
};
let payments_response_data = PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(response.tran_id.clone().to_string()),
redirection_data: None,
mandate_reference: None,
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: None,
incremental_authorization_allowed: None,
status_code: item.http_code,
};
Ok(Self {
resource_common_data: PaymentFlowData {
status,
..router_data.resource_common_data
},
response: error_response.map_or_else(|| Ok(payments_response_data), Err),
..router_data
})
}
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "PascalCase")]
pub struct FiuuRefundSyncRequest {
#[serde(rename = "TxnID")]
txn_id: String,
#[serde(rename = "MerchantID")]
merchant_id: Secret<String>,
signature: Secret<String>,
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
TryFrom<
FiuuRouterData<RouterDataV2<RSync, RefundFlowData, RefundSyncData, RefundsResponseData>, T>,
> for FiuuRefundSyncRequest
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: FiuuRouterData<
RouterDataV2<RSync, RefundFlowData, RefundSyncData, RefundsResponseData>,
T,
>,
) -> Result<Self, Self::Error> {
let auth = FiuuAuthType::try_from(&item.router_data.connector_auth_type)?;
let (txn_id, merchant_id, verify_key) = (
item.router_data.request.connector_transaction_id.clone(),
auth.merchant_id.peek().to_string(),
auth.verify_key.peek().to_string(),
);
let signature = calculate_signature(format!("{txn_id}{merchant_id}{verify_key}"))?;
Ok(Self {
txn_id,
merchant_id: auth.merchant_id,
signature,
})
}
}
#[derive(Debug, Serialize, Deserialize)]
#[serde(untagged)]
pub enum FiuuRefundSyncResponse {
Success(Vec<RefundData>),
Error(FiuuErrorResponse),
Webhook(FiuuWebhooksRefundResponse),
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "PascalCase")]
pub struct RefundData {
| {
"chunk": 17,
"crate": "connector-integration",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_mini_connector-integration_2738435745298344692_18 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/fiuu/transformers.rs
#[serde(rename = "RefundID")]
refund_id: String,
status: RefundStatus,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "lowercase")]
pub enum RefundStatus {
Success,
Pending,
Rejected,
Processing,
}
impl<F> TryFrom<ResponseRouterData<FiuuRefundSyncResponse, Self>>
for RouterDataV2<F, RefundFlowData, RefundSyncData, RefundsResponseData>
{
type Error = error_stack::Report<ConnectorError>;
fn try_from(
item: ResponseRouterData<FiuuRefundSyncResponse, Self>,
) -> Result<Self, Self::Error> {
let ResponseRouterData {
response,
router_data,
http_code: _http_code,
} = item;
match response {
FiuuRefundSyncResponse::Error(error) => Ok(Self {
response: Err(ErrorResponse {
code: error.error_code.clone(),
message: error.error_desc.clone(),
reason: Some(error.error_desc),
status_code: item.http_code,
attempt_status: None,
connector_transaction_id: None,
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
}),
..router_data
}),
FiuuRefundSyncResponse::Success(refund_data) => {
let refund = refund_data
.iter()
.find(|refund| {
Some(refund.refund_id.clone())
== Some(router_data.request.connector_refund_id.clone())
})
.ok_or_else(|| errors::ConnectorError::MissingConnectorRefundID)?;
Ok(Self {
response: Ok(RefundsResponseData {
connector_refund_id: refund.refund_id.clone(),
refund_status: common_enums::RefundStatus::from(refund.status.clone()),
status_code: item.http_code,
}),
..router_data
})
}
FiuuRefundSyncResponse::Webhook(fiuu_webhooks_refund_response) => Ok(Self {
response: Ok(RefundsResponseData {
connector_refund_id: fiuu_webhooks_refund_response.refund_id,
refund_status: common_enums::RefundStatus::from(
fiuu_webhooks_refund_response.status.clone(),
),
status_code: item.http_code,
}),
..router_data
}),
}
}
}
impl From<RefundStatus> for common_enums::RefundStatus {
fn from(item: RefundStatus) -> Self {
match item {
RefundStatus::Pending => Self::Pending,
RefundStatus::Success => Self::Success,
RefundStatus::Rejected => Self::Failure,
RefundStatus::Processing => Self::Pending,
}
}
}
pub fn get_qr_metadata(
response: &DuitNowQrCodeResponse,
) -> CustomResult<Option<serde_json::Value>, errors::ConnectorError> {
let image_data = QrImage::new_colored_from_data(
response.txn_data.request_data.qr_data.peek().clone(),
DUIT_NOW_BRAND_COLOR,
)
.change_context(errors::ConnectorError::ResponseHandlingFailed)?;
let image_data_url = Url::parse(image_data.data.clone().as_str()).ok();
let display_to_timestamp = None;
if let Some(color_image_data_url) = image_data_url {
let qr_code_info = QrCodeInformation::QrColorDataUrl {
color_image_data_url,
display_to_timestamp,
display_text: Some(DUIT_NOW_BRAND_TEXT.to_string()),
border_color: Some(DUIT_NOW_BRAND_COLOR.to_string()),
};
Some(qr_code_info.encode_to_value())
.transpose()
.change_context(errors::ConnectorError::ResponseHandlingFailed)
} else {
Ok(None)
}
}
#[derive(Debug, Deserialize, Serialize, Clone)]
#[serde(untagged)]
pub enum FiuuWebhooksResponse {
FiuuWebhookPaymentResponse(FiuuWebhooksPaymentResponse),
FiuuWebhookRefundResponse(FiuuWebhooksRefundResponse),
}
#[derive(Debug, Deserialize, Serialize, Clone)]
pub struct FiuuWebhooksPaymentResponse {
pub skey: Secret<String>,
| {
"chunk": 18,
"crate": "connector-integration",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_mini_connector-integration_2738435745298344692_19 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/fiuu/transformers.rs
pub status: FiuuPaymentWebhookStatus,
#[serde(rename = "orderid")]
pub order_id: String,
#[serde(rename = "tranID")]
pub tran_id: String,
pub nbcb: String,
pub amount: StringMajorUnit,
pub currency: String,
pub domain: Secret<String>,
pub appcode: Option<Secret<String>>,
pub paydate: String,
pub channel: String,
pub error_desc: Option<String>,
pub error_code: Option<String>,
#[serde(rename = "extraP")]
pub extra_parameters: Option<Secret<String>>,
}
#[derive(Debug, Deserialize, Serialize, Clone)]
pub struct FiuuPaymentRedirectResponse {
pub skey: Secret<String>,
#[serde(rename = "tranID")]
pub tran_id: String,
pub status: FiuuPaymentWebhookStatus,
pub appcode: Option<String>,
pub error_code: Option<String>,
pub error_desc: Option<String>,
}
#[derive(Debug, Deserialize, Serialize, Clone)]
#[serde(rename_all = "PascalCase")]
pub struct FiuuWebhooksRefundResponse {
pub refund_type: FiuuWebhooksRefundType,
#[serde(rename = "MerchantID")]
pub merchant_id: Secret<String>,
#[serde(rename = "RefID")]
pub ref_id: String,
#[serde(rename = "RefundID")]
pub refund_id: String,
#[serde(rename = "TxnID")]
pub txn_id: String,
pub amount: StringMajorUnit,
pub status: FiuuRefundsWebhookStatus,
pub signature: Secret<String>,
}
#[derive(Debug, Deserialize, Serialize, Clone, strum::Display)]
pub enum FiuuRefundsWebhookStatus {
#[strum(serialize = "00")]
#[serde(rename = "00")]
RefundSuccess,
#[strum(serialize = "11")]
#[serde(rename = "11")]
RefundFailure,
#[strum(serialize = "22")]
#[serde(rename = "22")]
RefundPending,
}
#[derive(Debug, Deserialize, Serialize, Clone, strum::Display)]
pub enum FiuuWebhooksRefundType {
P,
}
#[derive(Debug, Deserialize, Serialize, Clone)]
pub struct FiuuWebhookSignature {
pub skey: Secret<String>,
}
#[derive(Debug, Deserialize, Serialize, Clone)]
pub struct FiuuWebhookResourceId {
pub skey: Secret<String>,
}
#[derive(Debug, Deserialize, Serialize, Clone)]
pub struct FiuWebhookEvent {
pub status: FiuuPaymentWebhookStatus,
}
#[derive(Debug, Deserialize, Serialize, Clone, strum::Display)]
pub enum FiuuPaymentWebhookStatus {
#[strum(serialize = "00")]
#[serde(rename = "00")]
Success,
#[strum(serialize = "11")]
#[serde(rename = "11")]
Failure,
#[strum(serialize = "22")]
#[serde(rename = "22")]
Pending,
}
impl From<FiuuPaymentWebhookStatus> for StatCode {
fn from(value: FiuuPaymentWebhookStatus) -> Self {
match value {
FiuuPaymentWebhookStatus::Success => Self::Success,
FiuuPaymentWebhookStatus::Failure => Self::Failure,
FiuuPaymentWebhookStatus::Pending => Self::Pending,
}
}
}
impl From<FiuuPaymentWebhookStatus> for interfaces::webhooks::IncomingWebhookEvent {
fn from(value: FiuuPaymentWebhookStatus) -> Self {
match value {
FiuuPaymentWebhookStatus::Success => Self::PaymentIntentSuccess,
FiuuPaymentWebhookStatus::Failure => Self::PaymentIntentFailure,
FiuuPaymentWebhookStatus::Pending => Self::PaymentIntentProcessing,
}
}
}
impl From<FiuuRefundsWebhookStatus> for interfaces::webhooks::IncomingWebhookEvent {
fn from(value: FiuuRefundsWebhookStatus) -> Self {
match value {
FiuuRefundsWebhookStatus::RefundSuccess => Self::RefundSuccess,
FiuuRefundsWebhookStatus::RefundFailure => Self::RefundFailure,
FiuuRefundsWebhookStatus::RefundPending => Self::EventNotSupported,
}
}
}
impl From<FiuuRefundsWebhookStatus> for common_enums::RefundStatus {
fn from(value: FiuuRefundsWebhookStatus) -> Self {
match value {
FiuuRefundsWebhookStatus::RefundFailure => Self::Failure,
FiuuRefundsWebhookStatus::RefundSuccess => Self::Success,
FiuuRefundsWebhookStatus::RefundPending => Self::Pending,
}
}
}
//new additions structs
#[derive(Serialize, Debug, Clone)]
#[serde(untagged)]
pub enum FiuuPaymentsRequest<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> {
FiuuPaymentRequest(Box<FiuuPaymentRequest<T>>),
FiuuMandateRequest(FiuuMandateRequest),
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
| {
"chunk": 19,
"crate": "connector-integration",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_mini_connector-integration_2738435745298344692_20 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/fiuu/transformers.rs
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> GetFormData for FiuuPaymentsRequest<T>
{
fn get_form_data(&self) -> reqwest::multipart::Form {
match self {
FiuuPaymentsRequest::FiuuPaymentRequest::<T>(req) => {
build_form_from_struct(req).unwrap_or_else(|_| reqwest::multipart::Form::new())
}
FiuuPaymentsRequest::FiuuMandateRequest(req) => {
build_form_from_struct(req).unwrap_or_else(|_| reqwest::multipart::Form::new())
}
}
}
}
impl GetFormData for FiuuPaymentSyncRequest {
fn get_form_data(&self) -> reqwest::multipart::Form {
build_form_from_struct(self).unwrap_or_else(|_| reqwest::multipart::Form::new())
}
}
impl GetFormData for PaymentCaptureRequest {
fn get_form_data(&self) -> reqwest::multipart::Form {
build_form_from_struct(self).unwrap_or_else(|_| reqwest::multipart::Form::new())
}
}
impl GetFormData for FiuuPaymentCancelRequest {
fn get_form_data(&self) -> reqwest::multipart::Form {
build_form_from_struct(self).unwrap_or_else(|_| reqwest::multipart::Form::new())
}
}
impl GetFormData for FiuuRefundRequest {
fn get_form_data(&self) -> reqwest::multipart::Form {
build_form_from_struct(self).unwrap_or_else(|_| reqwest::multipart::Form::new())
}
}
impl GetFormData for FiuuRefundSyncRequest {
fn get_form_data(&self) -> reqwest::multipart::Form {
build_form_from_struct(self).unwrap_or_else(|_| reqwest::multipart::Form::new())
}
}
pub fn build_form_from_struct<T: Serialize>(
data: T,
) -> Result<reqwest::multipart::Form, errors::ParsingError> {
let mut form = reqwest::multipart::Form::new();
let serialized =
serde_json::to_value(&data).map_err(|_| errors::ParsingError::EncodeError("json-value"))?;
let serialized_object = serialized
.as_object()
.ok_or(errors::ParsingError::EncodeError("Expected object"))?;
for (key, values) in serialized_object {
let value = match values {
Value::String(s) => s.clone(),
Value::Number(n) => n.to_string(),
Value::Bool(b) => b.to_string(),
Value::Array(_) | Value::Object(_) | Value::Null => "".to_string(),
};
form = form.text(key.clone(), value.clone());
}
Ok(form)
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
TryFrom<
FiuuRouterData<
RouterDataV2<
Authorize,
PaymentFlowData,
PaymentsAuthorizeData<T>,
PaymentsResponseData,
>,
T,
>,
> for FiuuPaymentsRequest<T>
{
type Error = error_stack::Report<ConnectorError>;
fn try_from(
item: FiuuRouterData<
RouterDataV2<
Authorize,
PaymentFlowData,
PaymentsAuthorizeData<T>,
PaymentsResponseData,
>,
T,
>,
) -> Result<Self, Self::Error> {
let optional_is_mit_flow = item.router_data.request.off_session;
let optional_is_nti_flow = item
.router_data
.request
.mandate_id
.as_ref()
.map(|mandate_id| mandate_id.is_network_transaction_id_flow());
match (optional_is_mit_flow, optional_is_nti_flow) {
(Some(true), Some(false)) => {
let recurring_request = FiuuMandateRequest::try_from(&item)?;
Ok(FiuuPaymentsRequest::FiuuMandateRequest(recurring_request))
}
_ => {
let payment_request: FiuuPaymentRequest<T> = FiuuPaymentRequest::try_from(&item)?;
Ok(FiuuPaymentsRequest::FiuuPaymentRequest(Box::new(
payment_request,
)))
}
}
}
}
#[macro_export]
macro_rules! unimplemented_payment_method {
($payment_method:expr, $connector:expr) => {
errors::ConnectorError::NotImplemented(format!(
"{} through {}",
$payment_method, $connector
))
};
($payment_method:expr, $flow:expr, $connector:expr) => {
| {
"chunk": 20,
"crate": "connector-integration",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_mini_connector-integration_2738435745298344692_21 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/fiuu/transformers.rs
errors::ConnectorError::NotImplemented(format!(
"{} {} through {}",
$payment_method, $flow, $connector
))
};
}
use crate::unimplemented_payment_method;
pub const DUIT_NOW_BRAND_COLOR: &str = "#ED2E67";
pub const DUIT_NOW_BRAND_TEXT: &str = "MALAYSIA NATIONAL QR";
#[derive(Debug)]
pub struct QrImage {
pub data: String,
}
// Qr Image data source starts with this string
// The base64 image data will be appended to it to image data source
pub(crate) const QR_IMAGE_DATA_SOURCE_STRING: &str = "data:image/png;base64";
impl QrImage {
pub fn new_from_data(data: String) -> Result<Self, error_stack::Report<QrCodeError>> {
let qr_code = qrcode::QrCode::new(data.as_bytes())
.change_context(QrCodeError::FailedToCreateQrCode)?;
let qrcode_image_buffer = qr_code.render::<Luma<u8>>().build();
let qrcode_dynamic_image = DynamicImage::ImageLuma8(qrcode_image_buffer);
let mut image_bytes = std::io::BufWriter::new(std::io::Cursor::new(Vec::new()));
// Encodes qrcode_dynamic_image and write it to image_bytes
let _ = qrcode_dynamic_image.write_to(&mut image_bytes, ImageFormat::Png);
let image_data_source = format!(
"{},{}",
QR_IMAGE_DATA_SOURCE_STRING,
BASE64_ENGINE.encode(image_bytes.buffer())
);
Ok(Self {
data: image_data_source,
})
}
pub fn new_colored_from_data(
data: String,
hex_color: &str,
) -> Result<Self, error_stack::Report<QrCodeError>> {
let qr_code = qrcode::QrCode::new(data.as_bytes())
.change_context(QrCodeError::FailedToCreateQrCode)?;
let qrcode_image_buffer = qr_code.render::<Luma<u8>>().build();
let (width, height) = qrcode_image_buffer.dimensions();
let mut colored_image = ImageBuffer::new(width, height);
let rgb = Self::parse_hex_color(hex_color)?;
for (x, y, pixel) in qrcode_image_buffer.enumerate_pixels() {
let luminance = pixel.0[0];
let color = if luminance == 0 {
Rgba([rgb.0, rgb.1, rgb.2, 255])
} else {
Rgba([255, 255, 255, 255])
};
colored_image.put_pixel(x, y, color);
}
let qrcode_dynamic_image = DynamicImage::ImageRgba8(colored_image);
let mut image_bytes = std::io::Cursor::new(Vec::new());
qrcode_dynamic_image
.write_to(&mut image_bytes, ImageFormat::Png)
.change_context(QrCodeError::FailedToCreateQrCode)?;
let image_data_source = format!(
"{},{}",
QR_IMAGE_DATA_SOURCE_STRING,
BASE64_ENGINE.encode(image_bytes.get_ref())
);
Ok(Self {
data: image_data_source,
})
}
pub fn parse_hex_color(hex: &str) -> Result<(u8, u8, u8), QrCodeError> {
let hex = hex.trim_start_matches('#');
if hex.len() == 6 {
let r = u8::from_str_radix(&hex[0..2], 16).ok();
let g = u8::from_str_radix(&hex[2..4], 16).ok();
let b = u8::from_str_radix(&hex[4..6], 16).ok();
if let (Some(r), Some(g), Some(b)) = (r, g, b) {
return Ok((r, g, b));
}
}
Err(QrCodeError::InvalidHexColor)
}
}
/// Errors for Qr code handling
#[derive(Debug, thiserror::Error)]
pub enum QrCodeError {
/// Failed to encode data into Qr code
#[error("Failed to create Qr code")]
FailedToCreateQrCode,
/// Failed to parse hex color
#[error("Invalid hex color code supplied")]
InvalidHexColor,
}
use base64::Engine;
pub const BASE64_ENGINE: base64::engine::GeneralPurpose = base64::engine::general_purpose::STANDARD;
use image::{DynamicImage, ImageBuffer, ImageFormat, Luma, Rgba};
#[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "snake_case")]
#[serde(untagged)]
// the enum order shouldn't be changed as this is being used during serialization and deserialization
pub enum QrCodeInformation {
QrCodeUrl {
image_data_url: Url,
qr_code_url: Url,
display_to_timestamp: Option<i64>,
},
QrDataUrl {
image_data_url: Url,
display_to_timestamp: Option<i64>,
},
QrCodeImageUrl {
qr_code_url: Url,
| {
"chunk": 21,
"crate": "connector-integration",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_mini_connector-integration_2738435745298344692_22 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/fiuu/transformers.rs
display_to_timestamp: Option<i64>,
},
QrColorDataUrl {
color_image_data_url: Url,
display_to_timestamp: Option<i64>,
display_text: Option<String>,
border_color: Option<String>,
},
}
impl From<FiuuPaymentWebhookStatus> for EventType {
fn from(value: FiuuPaymentWebhookStatus) -> Self {
match value {
FiuuPaymentWebhookStatus::Success => Self::PaymentIntentSuccess,
FiuuPaymentWebhookStatus::Failure => Self::PaymentIntentFailure,
FiuuPaymentWebhookStatus::Pending => Self::PaymentIntentProcessing,
}
}
}
impl From<FiuuRefundsWebhookStatus> for EventType {
fn from(value: FiuuRefundsWebhookStatus) -> Self {
match value {
FiuuRefundsWebhookStatus::RefundSuccess => Self::RefundSuccess,
FiuuRefundsWebhookStatus::RefundFailure => Self::RefundFailure,
FiuuRefundsWebhookStatus::RefundPending => Self::IncomingWebhookEventUnspecified,
}
}
}
impl TryFrom<FiuuRefundSyncResponse> for RefundWebhookDetailsResponse {
type Error = error_stack::Report<ConnectorError>;
fn try_from(notif: FiuuRefundSyncResponse) -> Result<Self, Self::Error> {
match notif {
FiuuRefundSyncResponse::Webhook(fiuu_webhooks_refund_response) => Ok(Self {
connector_refund_id: Some(fiuu_webhooks_refund_response.refund_id),
status: common_enums::RefundStatus::from(
fiuu_webhooks_refund_response.status.clone(),
),
status_code: 200,
connector_response_reference_id: None,
error_code: None,
error_message: None,
raw_connector_response: None,
response_headers: None,
}),
_ => Err(errors::ConnectorError::WebhookBodyDecodingFailed)?,
}
}
}
| {
"chunk": 22,
"crate": "connector-integration",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_mini_connector-integration_-6830782010146565307_0 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/aci/aci_result_codes.rs
pub(super) const FAILURE_CODES: [&str; 502] = [
"100.370.100",
"100.370.110",
"100.370.111",
"100.380.100",
"100.380.101",
"100.380.110",
"100.380.201",
"100.380.305",
"100.380.306",
"100.380.401",
"100.380.501",
"100.395.502",
"100.396.101",
"100.400.000",
"100.400.001",
"100.400.002",
"100.400.005",
"100.400.007",
"100.400.020",
"100.400.021",
"100.400.030",
"100.400.039",
"100.400.040",
"100.400.041",
"100.400.042",
"100.400.043",
"100.400.044",
"100.400.045",
"100.400.051",
"100.400.060",
"100.400.061",
"100.400.063",
"100.400.064",
"100.400.065",
"100.400.071",
"100.400.080",
"100.400.081",
"100.400.083",
"100.400.084",
"100.400.085",
"100.400.086",
"100.400.087",
"100.400.091",
"100.400.100",
"100.400.120",
"100.400.121",
"100.400.122",
"100.400.123",
"100.400.130",
"100.400.139",
"100.400.140",
"100.400.141",
"100.400.142",
"100.400.143",
"100.400.144",
"100.400.145",
"100.400.146",
"100.400.147",
"100.400.148",
"100.400.149",
"100.400.150",
"100.400.151",
"100.400.152",
"100.400.241",
"100.400.242",
"100.400.243",
"100.400.260",
"100.400.300",
"100.400.301",
"100.400.302",
"100.400.303",
"100.400.304",
"100.400.305",
"100.400.306",
"100.400.307",
"100.400.308",
"100.400.309",
"100.400.310",
"100.400.311",
"100.400.312",
"100.400.313",
"100.400.314",
"100.400.315",
"100.400.316",
"100.400.317",
"100.400.318",
"100.400.319",
"100.400.320",
"100.400.321",
"100.400.322",
"100.400.323",
"100.400.324",
"100.400.325",
"100.400.326",
"100.400.327",
"100.400.328",
"800.400.100",
"800.400.101",
"800.400.102",
"800.400.103",
"800.400.104",
"800.400.105",
"800.400.110",
"800.400.150",
"800.400.151",
"100.380.401",
"100.390.101",
"100.390.102",
"100.390.103",
"100.390.104",
"100.390.105",
"100.390.106",
"100.390.107",
"100.390.108",
"100.390.109",
"100.390.110",
"100.390.111",
"100.390.112",
"100.390.113",
"100.390.114",
"100.390.115",
"100.390.116",
"100.390.117",
"100.390.118",
"800.400.200",
"100.100.701",
"800.200.159",
"800.200.160",
"800.200.165",
"800.200.202",
"800.200.208",
"800.200.220",
"800.300.101",
"800.300.102",
"800.300.200",
"800.300.301",
"800.300.302",
"800.300.401",
"800.300.500",
"800.300.501",
"800.310.200",
"800.310.210",
"800.310.211",
"800.110.100",
"800.120.100",
"800.120.101",
"800.120.102",
"800.120.103",
"800.120.200",
"800.120.201",
"800.120.202",
"800.120.203",
"800.120.300",
"800.120.401",
"800.130.100",
"800.140.100",
"800.140.101",
"800.140.110",
"800.140.111",
"800.140.112",
"800.140.113",
"800.150.100",
"800.160.100",
"800.160.110",
"800.160.120",
"800.160.130",
"500.100.201",
"500.100.202",
"500.100.203",
"500.100.301",
"500.100.302",
"500.100.303",
"500.100.304",
"500.100.401",
"500.100.402",
"500.100.403",
"500.200.101",
"600.200.100",
"600.200.200",
"600.200.201",
"600.200.202",
"600.200.300",
"600.200.310",
"600.200.400",
"600.200.500",
"600.200.501",
"600.200.600",
"600.200.700",
"600.200.800",
"600.200.810",
"600.300.101",
"600.300.200",
"600.300.210",
"600.300.211",
"800.121.100",
"800.121.200",
"100.150.100",
"100.150.101",
"100.150.200",
"100.150.201",
"100.150.202",
"100.150.203",
"100.150.204",
"100.150.205",
"100.150.300",
"100.350.100",
"100.350.101",
"100.350.200",
"100.350.201",
"100.350.301",
"100.350.302",
"100.350.303",
"100.350.310",
"100.350.311",
"100.350.312",
"100.350.313",
"100.350.314",
"100.350.315",
"100.350.316",
"100.350.400",
"100.350.500",
"100.350.601",
"100.350.602",
"100.250.100",
"100.250.105",
"100.250.106",
"100.250.107",
"100.250.110",
"100.250.111",
"100.250.120",
"100.250.121",
"100.250.122",
"100.250.123",
"100.250.124",
"100.250.125",
"100.250.250",
"100.360.201",
"100.360.300",
"100.360.303",
"100.360.400",
"700.100.100",
"700.100.200",
"700.100.300",
"700.100.400",
"700.100.500",
"700.100.600",
"700.100.700",
"700.100.701",
"700.100.710",
"700.300.100",
"700.300.200",
"700.300.300",
"700.300.400",
| {
"chunk": 0,
"crate": "connector-integration",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_mini_connector-integration_-6830782010146565307_1 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/aci/aci_result_codes.rs
"700.300.500",
"700.300.600",
"700.300.700",
"700.300.800",
"700.400.000",
"700.400.100",
"700.400.101",
"700.400.200",
"700.400.300",
"700.400.400",
"700.400.402",
"700.400.410",
"700.400.411",
"700.400.420",
"700.400.510",
"700.400.520",
"700.400.530",
"700.400.540",
"700.400.550",
"700.400.560",
"700.400.561",
"700.400.562",
"700.400.565",
"700.400.570",
"700.400.580",
"700.400.590",
"700.400.600",
"700.400.700",
"700.450.001",
"700.500.001",
"700.500.002",
"700.500.003",
"700.500.004",
"100.300.101",
"100.300.200",
"100.300.300",
"100.300.400",
"100.300.401",
"100.300.402",
"100.300.501",
"100.300.600",
"100.300.601",
"100.300.700",
"100.300.701",
"100.370.100",
"100.370.101",
"100.370.102",
"100.370.110",
"100.370.111",
"100.370.121",
"100.370.122",
"100.370.123",
"100.370.124",
"100.370.125",
"100.370.131",
"100.370.132",
"100.500.101",
"100.500.201",
"100.500.301",
"100.500.302",
"100.500.303",
"100.500.304",
"100.600.500",
"100.900.500",
"200.100.101",
"200.100.102",
"200.100.103",
"200.100.150",
"200.100.151",
"200.100.199",
"200.100.201",
"200.100.300",
"200.100.301",
"200.100.302",
"200.100.401",
"200.100.402",
"200.100.403",
"200.100.404",
"200.100.501",
"200.100.502",
"200.100.503",
"200.100.504",
"200.100.601",
"200.100.602",
"200.100.603",
"200.200.106",
"200.300.403",
"200.300.404",
"200.300.405",
"200.300.406",
"200.300.407",
"800.900.100",
"800.900.101",
"800.900.200",
"800.900.201",
"800.900.300",
"800.900.301",
"800.900.302",
"800.900.303",
"800.900.399",
"800.900.401",
"800.900.450",
"100.800.100",
"100.800.101",
"100.800.102",
"100.800.200",
"100.800.201",
"100.800.202",
"100.800.300",
"100.800.301",
"100.800.302",
"100.800.400",
"100.800.401",
"100.800.500",
"100.800.501",
"100.700.100",
"100.700.101",
"100.700.200",
"100.700.201",
"100.700.300",
"100.700.400",
"100.700.500",
"100.700.800",
"100.700.801",
"100.700.802",
"100.700.810",
"100.900.100",
"100.900.101",
"100.900.105",
"100.900.200",
"100.900.300",
"100.900.301",
"100.900.400",
"100.900.401",
"100.900.450",
"100.900.500",
"100.100.100",
"100.100.101",
"100.100.104",
"100.100.200",
"100.100.201",
"100.100.300",
"100.100.301",
"100.100.303",
"100.100.304",
"100.100.305",
"100.100.400",
"100.100.401",
"100.100.402",
"100.100.500",
"100.100.501",
"100.100.600",
"100.100.601",
"100.100.650",
"100.100.651",
"100.100.700",
"100.100.701",
"100.200.100",
"100.200.103",
"100.200.104",
"100.200.200",
"100.210.101",
"100.210.102",
"100.211.101",
"100.211.102",
"100.211.103",
"100.211.104",
"100.211.105",
"100.211.106",
"100.212.101",
"100.212.102",
"100.212.103",
"100.550.300",
"100.550.301",
"100.550.303",
"100.550.310",
"100.550.311",
"100.550.312",
"100.550.400",
"100.550.401",
"100.550.601",
"100.550.603",
"100.550.605",
"100.550.701",
"100.550.702",
"100.380.101",
"100.380.201",
"100.380.305",
"100.380.306",
"800.100.100",
"800.100.150",
"800.100.151",
"800.100.152",
"800.100.153",
"800.100.154",
"800.100.155",
"800.100.156",
"800.100.157",
"800.100.158",
"800.100.159",
"800.100.160",
"800.100.161",
"800.100.162",
"800.100.163",
"800.100.164",
"800.100.165",
"800.100.166",
"800.100.167",
"800.100.168",
"800.100.169",
"800.100.170",
"800.100.171",
"800.100.172",
"800.100.173",
"800.100.174",
"800.100.175",
"800.100.176",
"800.100.177",
"800.100.178",
"800.100.179",
"800.100.190",
"800.100.191",
"800.100.192",
"800.100.195",
"800.100.196",
"800.100.197",
"800.100.198",
"800.100.199",
"800.100.200",
"800.100.201",
"800.100.202",
"800.100.203",
"800.100.204",
"800.100.205",
"800.100.206",
"800.100.207",
"800.100.208",
"800.100.402",
"800.100.403",
"800.100.500",
"800.100.501",
"800.700.100",
"800.700.101",
"800.700.201",
"800.700.500",
"800.800.102",
"800.800.202",
"800.800.302",
"100.390.100",
];
pub(super) const SUCCESSFUL_CODES: [&str; 16] = [
"000.000.000",
"000.000.100",
"000.100.105",
"000.100.106",
| {
"chunk": 1,
"crate": "connector-integration",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_mini_connector-integration_-6830782010146565307_2 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/aci/aci_result_codes.rs
"000.100.110",
"000.100.111",
"000.100.112",
"000.300.000",
"000.300.100",
"000.300.101",
"000.300.102",
"000.300.103",
"000.310.100",
"000.310.101",
"000.310.110",
"000.600.000",
];
pub(super) const PENDING_CODES: [&str; 26] = [
"000.400.000",
"000.400.010",
"000.400.020",
"000.400.040",
"000.400.050",
"000.400.060",
"000.400.070",
"000.400.080",
"000.400.081",
"000.400.082",
"000.400.090",
"000.400.091",
"000.400.100",
"000.400.110",
"000.200.000",
"000.200.001",
"000.200.100",
"000.200.101",
"000.200.102",
"000.200.103",
"000.200.200",
"000.200.201",
"100.400.500",
"800.400.500",
"800.400.501",
"800.400.502",
];
| {
"chunk": 2,
"crate": "connector-integration",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_mini_connector-integration_2188691800113068569_0 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/aci/transformers.rs
use common_utils::{request::Method, CustomerId, Email, StringMajorUnit};
use domain_types::{
connector_flow::{Authorize, Capture, Refund, RepeatPayment, SetupMandate, Void},
connector_types::{
MandateIds, MandateReference, PaymentFlowData, PaymentVoidData, PaymentsAuthorizeData,
PaymentsCaptureData, PaymentsResponseData, PaymentsSyncData, RefundFlowData, RefundsData,
RefundsResponseData, RepeatPaymentData, ResponseId, SetupMandateRequestData,
},
errors::{self, ConnectorError},
payment_method_data::{
BankRedirectData, Card, NetworkTokenData, PayLaterData, PaymentMethodData,
PaymentMethodDataTypes, RawCardNumber, WalletData,
},
router_data::{ConnectorAuthType, ErrorResponse, NetworkTokenNumber},
router_data_v2::RouterDataV2,
router_response_types::RedirectForm,
};
use error_stack::{self, report, ResultExt};
use hyperswitch_masking::{ExposeInterface, Secret};
use serde::{Deserialize, Serialize};
use std::fmt::Debug;
use std::str::FromStr;
use url::Url;
use super::aci_result_codes::{FAILURE_CODES, PENDING_CODES, SUCCESSFUL_CODES};
use super::AciRouterData;
use crate::{types::ResponseRouterData, utils};
type Error = error_stack::Report<errors::ConnectorError>;
trait GetCaptureMethod {
fn get_capture_method(&self) -> Option<common_enums::CaptureMethod>;
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize> GetCaptureMethod
for PaymentsAuthorizeData<T>
{
fn get_capture_method(&self) -> Option<common_enums::CaptureMethod> {
self.capture_method
}
}
impl GetCaptureMethod for PaymentsSyncData {
fn get_capture_method(&self) -> Option<common_enums::CaptureMethod> {
self.capture_method
}
}
impl GetCaptureMethod for RepeatPaymentData {
fn get_capture_method(&self) -> Option<common_enums::CaptureMethod> {
self.capture_method
}
}
impl GetCaptureMethod for PaymentVoidData {
fn get_capture_method(&self) -> Option<common_enums::CaptureMethod> {
None
}
}
pub struct AciAuthType {
pub api_key: Secret<String>,
pub entity_id: Secret<String>,
}
impl TryFrom<&ConnectorAuthType> for AciAuthType {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(item: &ConnectorAuthType) -> Result<Self, Self::Error> {
if let ConnectorAuthType::BodyKey { api_key, key1 } = item {
Ok(Self {
api_key: api_key.to_owned(),
entity_id: key1.to_owned(),
})
} else {
Err(errors::ConnectorError::FailedToObtainAuthType)?
}
}
}
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "UPPERCASE")]
pub enum AciRecurringType {
Initial,
Repeated,
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct AciPaymentsRequest<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> {
#[serde(flatten)]
pub txn_details: TransactionDetails,
#[serde(flatten)]
pub payment_method: PaymentDetails<T>,
#[serde(flatten)]
pub instruction: Option<Instruction>,
pub shopper_result_url: Option<String>,
#[serde(rename = "customParameters[3DS2_enrolled]")]
pub three_ds_two_enrolled: Option<bool>,
pub recurring_type: Option<AciRecurringType>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct TransactionDetails {
pub entity_id: Secret<String>,
pub amount: StringMajorUnit,
pub currency: String,
pub payment_type: AciPaymentType,
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct AciCancelRequest {
pub entity_id: Secret<String>,
pub payment_type: AciPaymentType,
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct AciMandateRequest<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> {
pub entity_id: Secret<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub payment_brand: Option<PaymentBrand>,
#[serde(flatten)]
pub payment_details: PaymentDetails<T>,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct AciMandateResponse {
pub id: String,
| {
"chunk": 0,
"crate": "connector-integration",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_mini_connector-integration_2188691800113068569_1 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/aci/transformers.rs
pub result: ResultCode,
pub build_number: String,
pub timestamp: String,
}
#[derive(Debug, Clone, Serialize)]
#[serde(untagged)]
pub enum PaymentDetails<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> {
#[serde(rename = "card")]
AciCard(Box<CardDetails<T>>),
BankRedirect(Box<BankRedirectionPMData>),
Wallet(Box<WalletPMData>),
Klarna,
Mandate,
AciNetworkToken(Box<AciNetworkTokenData>),
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
TryFrom<(
&WalletData,
&RouterDataV2<Authorize, PaymentFlowData, PaymentsAuthorizeData<T>, PaymentsResponseData>,
)> for PaymentDetails<T>
{
type Error = Error;
fn try_from(
value: (
&WalletData,
&RouterDataV2<
Authorize,
PaymentFlowData,
PaymentsAuthorizeData<T>,
PaymentsResponseData,
>,
),
) -> Result<Self, Self::Error> {
let (wallet_data, item) = value;
let payment_data = match wallet_data {
WalletData::MbWayRedirect(_) => {
let phone_details = item.resource_common_data.get_billing_phone()?;
Self::Wallet(Box::new(WalletPMData {
payment_brand: PaymentBrand::Mbway,
account_id: Some(phone_details.get_number_with_hash_country_code()?),
}))
}
WalletData::AliPayRedirect { .. } => Self::Wallet(Box::new(WalletPMData {
payment_brand: PaymentBrand::AliPay,
account_id: None,
})),
WalletData::AliPayHkRedirect(_)
| WalletData::AmazonPayRedirect(_)
| WalletData::MomoRedirect(_)
| WalletData::KakaoPayRedirect(_)
| WalletData::GoPayRedirect(_)
| WalletData::GcashRedirect(_)
| WalletData::ApplePay(_)
| WalletData::ApplePayThirdPartySdk(_)
| WalletData::DanaRedirect { .. }
| WalletData::GooglePay(_)
| WalletData::BluecodeRedirect {}
| WalletData::GooglePayThirdPartySdk(_)
| WalletData::MobilePayRedirect(_)
| WalletData::PaypalRedirect(_)
| WalletData::PaypalSdk(_)
| WalletData::Paze(_)
| WalletData::SamsungPay(_)
| WalletData::TwintRedirect { .. }
| WalletData::VippsRedirect { .. }
| WalletData::TouchNGoRedirect(_)
| WalletData::WeChatPayRedirect(_)
| WalletData::WeChatPayQr(_)
| WalletData::CashappQr(_)
| WalletData::SwishQr(_)
| WalletData::AliPayQr(_)
| WalletData::ApplePayRedirect(_)
| WalletData::GooglePayRedirect(_)
| WalletData::Mifinity(_)
| WalletData::RevolutPay(_) => Err(errors::ConnectorError::NotImplemented(
"Payment method".to_string(),
))?,
};
Ok(payment_data)
}
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
TryFrom<(
&AciRouterData<
RouterDataV2<
Authorize,
PaymentFlowData,
PaymentsAuthorizeData<T>,
PaymentsResponseData,
>,
T,
>,
&BankRedirectData,
)> for PaymentDetails<T>
{
type Error = Error;
fn try_from(
value: (
&AciRouterData<
RouterDataV2<
Authorize,
PaymentFlowData,
PaymentsAuthorizeData<T>,
PaymentsResponseData,
>,
T,
>,
&BankRedirectData,
),
) -> Result<Self, Self::Error> {
let (item, bank_redirect_data) = value;
let payment_data = match bank_redirect_data {
BankRedirectData::Eps { .. } => Self::BankRedirect(Box::new(BankRedirectionPMData {
payment_brand: PaymentBrand::Eps,
| {
"chunk": 1,
"crate": "connector-integration",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_mini_connector-integration_2188691800113068569_2 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/aci/transformers.rs
bank_account_country: Some(
item.router_data
.resource_common_data
.get_billing_country()?,
),
bank_account_bank_name: None,
bank_account_bic: None,
bank_account_iban: None,
billing_country: None,
merchant_customer_id: None,
merchant_transaction_id: None,
customer_email: None,
})),
BankRedirectData::Eft { .. } => Self::BankRedirect(Box::new(BankRedirectionPMData {
payment_brand: PaymentBrand::Eft,
bank_account_country: Some(
item.router_data
.resource_common_data
.get_billing_country()?,
),
bank_account_bank_name: None,
bank_account_bic: None,
bank_account_iban: None,
billing_country: None,
merchant_customer_id: None,
merchant_transaction_id: None,
customer_email: None,
})),
BankRedirectData::Giropay {
bank_account_bic,
bank_account_iban,
..
} => Self::BankRedirect(Box::new(BankRedirectionPMData {
payment_brand: PaymentBrand::Giropay,
bank_account_country: Some(
item.router_data
.resource_common_data
.get_billing_country()?,
),
bank_account_bank_name: None,
bank_account_bic: bank_account_bic.clone(),
bank_account_iban: bank_account_iban.clone(),
billing_country: None,
merchant_customer_id: None,
merchant_transaction_id: None,
customer_email: None,
})),
BankRedirectData::Ideal { bank_name, .. } => {
Self::BankRedirect(Box::new(BankRedirectionPMData {
payment_brand: PaymentBrand::Ideal,
bank_account_country: Some(
item.router_data
.resource_common_data
.get_billing_country()?,
),
bank_account_bank_name: Some(bank_name.ok_or(
errors::ConnectorError::MissingRequiredField {
field_name: "ideal.bank_name",
},
)?),
bank_account_bic: None,
bank_account_iban: None,
billing_country: None,
merchant_customer_id: None,
merchant_transaction_id: None,
customer_email: None,
}))
}
BankRedirectData::Sofort { .. } => {
Self::BankRedirect(Box::new(BankRedirectionPMData {
payment_brand: PaymentBrand::Sofortueberweisung,
bank_account_country: Some(
item.router_data
.resource_common_data
.get_billing_country()?,
),
bank_account_bank_name: None,
bank_account_bic: None,
bank_account_iban: None,
billing_country: None,
merchant_customer_id: None,
merchant_transaction_id: None,
customer_email: None,
}))
}
BankRedirectData::Przelewy24 { .. } => {
Self::BankRedirect(Box::new(BankRedirectionPMData {
payment_brand: PaymentBrand::Przelewy,
bank_account_country: None,
bank_account_bank_name: None,
bank_account_bic: None,
bank_account_iban: None,
billing_country: None,
merchant_customer_id: None,
merchant_transaction_id: None,
customer_email: Some(
item.router_data.resource_common_data.get_billing_email()?,
),
}))
| {
"chunk": 2,
"crate": "connector-integration",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_mini_connector-integration_2188691800113068569_3 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/aci/transformers.rs
}
BankRedirectData::Interac { .. } => {
Self::BankRedirect(Box::new(BankRedirectionPMData {
payment_brand: PaymentBrand::InteracOnline,
bank_account_country: Some(
item.router_data
.resource_common_data
.get_billing_country()?,
),
bank_account_bank_name: None,
bank_account_bic: None,
bank_account_iban: None,
billing_country: None,
merchant_customer_id: None,
merchant_transaction_id: None,
customer_email: Some(
item.router_data.resource_common_data.get_billing_email()?,
),
}))
}
BankRedirectData::Trustly { .. } => {
Self::BankRedirect(Box::new(BankRedirectionPMData {
payment_brand: PaymentBrand::Trustly,
bank_account_country: None,
bank_account_bank_name: None,
bank_account_bic: None,
bank_account_iban: None,
billing_country: Some(
item.router_data
.resource_common_data
.get_billing_country()?,
),
merchant_customer_id: Some(Secret::new(
item.router_data.resource_common_data.get_customer_id()?,
)),
merchant_transaction_id: Some(Secret::new(
item.router_data
.resource_common_data
.connector_request_reference_id
.clone(),
)),
customer_email: None,
}))
}
BankRedirectData::Bizum { .. }
| BankRedirectData::Blik { .. }
| BankRedirectData::BancontactCard { .. }
| BankRedirectData::OnlineBankingCzechRepublic { .. }
| BankRedirectData::OnlineBankingFinland { .. }
| BankRedirectData::OnlineBankingFpx { .. }
| BankRedirectData::OnlineBankingPoland { .. }
| BankRedirectData::OnlineBankingSlovakia { .. }
| BankRedirectData::OnlineBankingThailand { .. }
| BankRedirectData::LocalBankRedirect {}
| BankRedirectData::OpenBankingUk { .. } => Err(
errors::ConnectorError::NotImplemented("Payment method".to_string()),
)?,
};
Ok(payment_data)
}
}
fn get_aci_payment_brand(
card_network: Option<common_enums::CardNetwork>,
is_network_token_flow: bool,
) -> Result<PaymentBrand, Error> {
match card_network {
Some(common_enums::CardNetwork::Visa) => Ok(PaymentBrand::Visa),
Some(common_enums::CardNetwork::Mastercard) => Ok(PaymentBrand::Mastercard),
Some(common_enums::CardNetwork::AmericanExpress) => Ok(PaymentBrand::AmericanExpress),
Some(common_enums::CardNetwork::JCB) => Ok(PaymentBrand::Jcb),
Some(common_enums::CardNetwork::DinersClub) => Ok(PaymentBrand::DinersClub),
Some(common_enums::CardNetwork::Discover) => Ok(PaymentBrand::Discover),
Some(common_enums::CardNetwork::UnionPay) => Ok(PaymentBrand::UnionPay),
Some(common_enums::CardNetwork::Maestro) => Ok(PaymentBrand::Maestro),
Some(unsupported_network) => Err(errors::ConnectorError::NotSupported {
message: format!("Card network {unsupported_network} is not supported by ACI"),
connector: "ACI",
})?,
None => {
if is_network_token_flow {
Ok(PaymentBrand::Visa)
} else {
Err(errors::ConnectorError::MissingRequiredField {
field_name: "card.card_network",
}
.into())
}
}
}
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> TryFrom<(Card<T>, Option<Secret<String>>)> for PaymentDetails<T>
{
| {
"chunk": 3,
"crate": "connector-integration",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_mini_connector-integration_2188691800113068569_4 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/aci/transformers.rs
type Error = Error;
fn try_from(
(card_data, card_holder_name): (Card<T>, Option<Secret<String>>),
) -> Result<Self, Self::Error> {
let card_expiry_year = card_data.get_expiry_year_4_digit();
let payment_brand = get_aci_payment_brand(card_data.card_network, false).ok();
Ok(Self::AciCard(Box::new(CardDetails {
card_number: card_data.card_number,
card_holder: card_holder_name.ok_or(errors::ConnectorError::MissingRequiredField {
field_name: "card_holder_name",
})?,
card_expiry_month: card_data.card_exp_month.clone(),
card_expiry_year,
card_cvv: card_data.card_cvc,
payment_brand,
})))
}
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
TryFrom<(
&AciRouterData<
RouterDataV2<
Authorize,
PaymentFlowData,
PaymentsAuthorizeData<T>,
PaymentsResponseData,
>,
T,
>,
&NetworkTokenData,
)> for PaymentDetails<T>
{
type Error = Error;
fn try_from(
value: (
&AciRouterData<
RouterDataV2<
Authorize,
PaymentFlowData,
PaymentsAuthorizeData<T>,
PaymentsResponseData,
>,
T,
>,
&NetworkTokenData,
),
) -> Result<Self, Self::Error> {
let (_item, network_token_data) = value;
let token_number = network_token_data.get_network_token();
let payment_brand = get_aci_payment_brand(network_token_data.card_network.clone(), true)?;
let aci_network_token_data = AciNetworkTokenData {
token_type: AciTokenAccountType::Network,
token_number,
token_expiry_month: network_token_data.get_network_token_expiry_month(),
token_expiry_year: network_token_data.get_expiry_year_4_digit(),
token_cryptogram: Some(
network_token_data
.get_cryptogram()
.clone()
.unwrap_or_default(),
),
payment_brand,
};
Ok(Self::AciNetworkToken(Box::new(aci_network_token_data)))
}
}
#[derive(Debug, Clone, Serialize)]
#[serde(rename_all = "UPPERCASE")]
pub enum AciTokenAccountType {
Network,
}
#[derive(Debug, Clone, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct AciNetworkTokenData {
#[serde(rename = "tokenAccount.type")]
pub token_type: AciTokenAccountType,
#[serde(rename = "tokenAccount.number")]
pub token_number: NetworkTokenNumber,
#[serde(rename = "tokenAccount.expiryMonth")]
pub token_expiry_month: Secret<String>,
#[serde(rename = "tokenAccount.expiryYear")]
pub token_expiry_year: Secret<String>,
#[serde(rename = "tokenAccount.cryptogram")]
pub token_cryptogram: Option<Secret<String>>,
#[serde(rename = "paymentBrand")]
pub payment_brand: PaymentBrand,
}
#[derive(Debug, Clone, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct BankRedirectionPMData {
payment_brand: PaymentBrand,
#[serde(rename = "bankAccount.country")]
bank_account_country: Option<common_enums::CountryAlpha2>,
#[serde(rename = "bankAccount.bankName")]
bank_account_bank_name: Option<common_enums::BankNames>,
#[serde(rename = "bankAccount.bic")]
bank_account_bic: Option<Secret<String>>,
#[serde(rename = "bankAccount.iban")]
bank_account_iban: Option<Secret<String>>,
#[serde(rename = "billing.country")]
billing_country: Option<common_enums::CountryAlpha2>,
#[serde(rename = "customer.email")]
customer_email: Option<Email>,
#[serde(rename = "customer.merchantCustomerId")]
merchant_customer_id: Option<Secret<CustomerId>>,
merchant_transaction_id: Option<Secret<String>>,
}
#[derive(Debug, Clone, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct WalletPMData {
payment_brand: PaymentBrand,
#[serde(rename = "virtualAccount.accountId")]
account_id: Option<Secret<String>>,
}
#[derive(Debug, Clone, Eq, PartialEq, Serialize, Deserialize)]
| {
"chunk": 4,
"crate": "connector-integration",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_mini_connector-integration_2188691800113068569_5 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/aci/transformers.rs
#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
pub enum PaymentBrand {
Eps,
Eft,
Ideal,
Giropay,
Sofortueberweisung,
InteracOnline,
Przelewy,
Trustly,
Mbway,
#[serde(rename = "ALIPAY")]
AliPay,
// Card network brands
#[serde(rename = "VISA")]
Visa,
#[serde(rename = "MASTER")]
Mastercard,
#[serde(rename = "AMEX")]
AmericanExpress,
#[serde(rename = "JCB")]
Jcb,
#[serde(rename = "DINERS")]
DinersClub,
#[serde(rename = "DISCOVER")]
Discover,
#[serde(rename = "UNIONPAY")]
UnionPay,
#[serde(rename = "MAESTRO")]
Maestro,
}
#[derive(Debug, Clone, Eq, PartialEq, Serialize)]
pub struct CardDetails<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> {
#[serde(rename = "card.number")]
pub card_number: RawCardNumber<T>,
#[serde(rename = "card.holder")]
pub card_holder: Secret<String>,
#[serde(rename = "card.expiryMonth")]
pub card_expiry_month: Secret<String>,
#[serde(rename = "card.expiryYear")]
pub card_expiry_year: Secret<String>,
#[serde(rename = "card.cvv")]
pub card_cvv: Secret<String>,
#[serde(rename = "paymentBrand")]
#[serde(skip_serializing_if = "Option::is_none")]
pub payment_brand: Option<PaymentBrand>,
}
#[derive(Debug, Clone, Serialize)]
#[serde(rename_all = "UPPERCASE")]
pub enum InstructionMode {
Initial,
Repeated,
}
#[derive(Debug, Clone, Serialize)]
#[serde(rename_all = "UPPERCASE")]
pub enum InstructionType {
Unscheduled,
}
#[derive(Debug, Clone, Serialize)]
pub enum InstructionSource {
#[serde(rename = "CIT")]
CardholderInitiatedTransaction,
#[serde(rename = "MIT")]
MerchantInitiatedTransaction,
}
#[derive(Debug, Clone, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct Instruction {
#[serde(rename = "standingInstruction.mode")]
mode: InstructionMode,
#[serde(rename = "standingInstruction.type")]
transaction_type: InstructionType,
#[serde(rename = "standingInstruction.source")]
source: InstructionSource,
create_registration: Option<bool>,
}
#[derive(Debug, Clone, Eq, PartialEq, Serialize)]
pub struct BankDetails {
#[serde(rename = "bankAccount.holder")]
pub account_holder: Secret<String>,
}
#[allow(dead_code)]
#[derive(Debug, Default, Clone, Eq, PartialEq, Serialize, Deserialize)]
pub enum AciPaymentType {
#[serde(rename = "PA")]
Preauthorization,
#[default]
#[serde(rename = "DB")]
Debit,
#[serde(rename = "CD")]
Credit,
#[serde(rename = "CP")]
Capture,
#[serde(rename = "RV")]
Reversal,
#[serde(rename = "RF")]
Refund,
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
TryFrom<
AciRouterData<
RouterDataV2<
Authorize,
PaymentFlowData,
PaymentsAuthorizeData<T>,
PaymentsResponseData,
>,
T,
>,
> for AciPaymentsRequest<T>
{
type Error = Error;
fn try_from(
item: AciRouterData<
RouterDataV2<
Authorize,
PaymentFlowData,
PaymentsAuthorizeData<T>,
PaymentsResponseData,
>,
T,
>,
) -> Result<Self, Self::Error> {
match item.router_data.request.payment_method_data.clone() {
PaymentMethodData::Card(ref card_data) => Self::try_from((&item, card_data)),
PaymentMethodData::NetworkToken(ref network_token_data) => {
Self::try_from((&item, network_token_data))
}
PaymentMethodData::Wallet(ref wallet_data) => Self::try_from((&item, wallet_data)),
PaymentMethodData::PayLater(ref pay_later_data) => {
Self::try_from((&item, pay_later_data))
}
PaymentMethodData::BankRedirect(ref bank_redirect_data) => {
Self::try_from((&item, bank_redirect_data))
}
PaymentMethodData::MandatePayment => {
let mandate_id = item.router_data.request.mandate_id.clone().ok_or(
errors::ConnectorError::MissingRequiredField {
field_name: "mandate_id",
| {
"chunk": 5,
"crate": "connector-integration",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.