id stringlengths 20 153 | type stringclasses 1
value | granularity stringclasses 14
values | content stringlengths 16 84.3k | metadata dict |
|---|---|---|---|---|
connector-service_mini_connector-integration_9109066662545807561_3 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/worldpay/transformers.rs
user_agent_header,
browser_language: browser_info.language.clone(),
browser_screen_width: browser_info.screen_width,
browser_screen_height: browser_info.screen_height,
browser_color_depth: browser_info.color_depth.map(|depth| depth.to_string()),
time_zone: browser_info.time_zone.map(|tz| tz.to_string()),
browser_java_enabled: browser_info.java_enabled,
browser_javascript_enabled: browser_info.java_script_enabled,
channel,
},
challenge: ThreeDSRequestChallenge {
return_url: router_data.request.get_complete_authorize_url()?,
preference: if is_mandate_payment {
Some(super::requests::THREE_DS_CHALLENGE_PREFERENCE.to_string())
} else {
None
},
},
}))
}
// Non 3DS
_ => Ok(None),
}
}
// Helper function to get settlement info for RouterDataV2
fn get_settlement_info<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>(
router_data: &RouterDataV2<
Authorize,
PaymentFlowData,
PaymentsAuthorizeData<T>,
PaymentsResponseData,
>,
amount: MinorUnit,
) -> Option<AutoSettlement> {
match router_data.request.capture_method.unwrap_or_default() {
_ if amount == MinorUnit::zero() => None,
enums::CaptureMethod::Automatic | enums::CaptureMethod::SequentialAutomatic => {
Some(AutoSettlement { auto: true })
}
enums::CaptureMethod::Manual | enums::CaptureMethod::ManualMultiple => {
Some(AutoSettlement { auto: false })
}
_ => None,
}
}
// Dangling helper function to determine token and agreement settings
fn get_token_and_agreement<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>(
payment_method_data: &PaymentMethodData<T>,
setup_future_usage: Option<enums::FutureUsage>,
off_session: Option<bool>,
mandate_ids: Option<MandateIds>,
) -> (Option<TokenCreation>, Option<CustomerAgreement>) {
match (payment_method_data, setup_future_usage, off_session) {
// CIT - Setup for future usage (creates token for future MIT via RepeatPayment)
(PaymentMethodData::Card(_), Some(enums::FutureUsage::OffSession), _) => (
Some(TokenCreation {
token_type: TokenCreationType::Worldpay,
}),
Some(CustomerAgreement {
agreement_type: CustomerAgreementType::Subscription,
stored_card_usage: Some(StoredCardUsageType::First),
scheme_reference: None,
}),
),
// NTI with raw card data
(PaymentMethodData::CardDetailsForNetworkTransactionId(_), _, _) => (
None,
mandate_ids.and_then(|mandate_ids| {
mandate_ids
.mandate_reference_id
.and_then(|mandate_id| match mandate_id {
MandateReferenceId::NetworkMandateId(network_transaction_id) => {
Some(CustomerAgreement {
agreement_type: CustomerAgreementType::Unscheduled,
scheme_reference: Some(network_transaction_id.into()),
stored_card_usage: None,
})
}
_ => None,
})
}),
),
_ => (None, None),
}
}
// Implementation for WorldpayAuthorizeRequest using abstracted request
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
TryFrom<
WorldpayRouterData<
RouterDataV2<
Authorize,
PaymentFlowData,
PaymentsAuthorizeData<T>,
PaymentsResponseData,
>,
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_9109066662545807561_4 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/worldpay/transformers.rs
> for WorldpayAuthorizeRequest<T>
{
type Error = error_stack::Report<ConnectorError>;
fn try_from(
item: WorldpayRouterData<
RouterDataV2<
Authorize,
PaymentFlowData,
PaymentsAuthorizeData<T>,
PaymentsResponseData,
>,
T,
>,
) -> Result<Self, Self::Error> {
let worldpay_connector_metadata_object: WorldpayConnectorMetadataObject =
WorldpayConnectorMetadataObject::try_from(
item.router_data.request.merchant_account_metadata.as_ref(),
)?;
let merchant_name = worldpay_connector_metadata_object.merchant_name.ok_or(
errors::ConnectorError::InvalidConnectorConfig {
config: "merchant_account_metadata.merchant_name",
},
)?;
let is_mandate_payment = item.router_data.request.is_mandate_payment();
let three_ds = create_three_ds_request(&item.router_data, is_mandate_payment)?;
let (token_creation, customer_agreement) = get_token_and_agreement(
&item.router_data.request.payment_method_data,
item.router_data.request.setup_future_usage,
item.router_data.request.off_session,
item.router_data.request.mandate_id.clone(),
);
Ok(Self {
instruction: Instruction {
settlement: get_settlement_info(
&item.router_data,
item.router_data.request.minor_amount,
),
method: PaymentMethod::try_from((
item.router_data.resource_common_data.payment_method,
item.router_data.request.payment_method_type,
))?,
payment_instrument: fetch_payment_instrument(
item.router_data.request.payment_method_data.clone(),
item.router_data.resource_common_data.get_optional_billing(),
)?,
narrative: InstructionNarrative {
line1: merchant_name.expose(),
},
value: PaymentValue {
amount: item.router_data.request.minor_amount,
currency: item.router_data.request.currency,
},
debt_repayment: None,
three_ds,
token_creation,
customer_agreement,
},
merchant: Merchant {
entity: WorldpayAuthType::try_from(&item.router_data.connector_auth_type)?
.entity_id,
..Default::default()
},
transaction_reference: item
.router_data
.resource_common_data
.connector_request_reference_id
.clone(),
customer: None,
})
}
}
// RepeatPayment request transformer - for MIT (Merchant Initiated Transactions)
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
TryFrom<
WorldpayRouterData<
RouterDataV2<
domain_types::connector_flow::RepeatPayment,
PaymentFlowData,
RepeatPaymentData,
PaymentsResponseData,
>,
T,
>,
> for WorldpayRepeatPaymentRequest<T>
{
type Error = error_stack::Report<ConnectorError>;
fn try_from(
item: WorldpayRouterData<
RouterDataV2<
domain_types::connector_flow::RepeatPayment,
PaymentFlowData,
RepeatPaymentData,
PaymentsResponseData,
>,
T,
>,
) -> Result<Self, Self::Error> {
// Extract merchant name from metadata
let worldpay_connector_metadata_object: WorldpayConnectorMetadataObject =
WorldpayConnectorMetadataObject::try_from(
item.router_data.request.merchant_account_metadata.as_ref(),
)?;
let merchant_name = worldpay_connector_metadata_object.merchant_name.ok_or(
errors::ConnectorError::InvalidConnectorConfig {
config: "merchant_account_metadata.merchant_name",
},
| {
"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_9109066662545807561_5 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/worldpay/transformers.rs
)?;
// Extract payment instrument from mandate_reference
let payment_instrument = match &item.router_data.request.mandate_reference {
MandateReferenceId::ConnectorMandateId(connector_mandate_ref) => {
let href = connector_mandate_ref.get_connector_mandate_id().ok_or(
errors::ConnectorError::MissingRequiredField {
field_name: "connector_mandate_id",
},
)?;
PaymentInstrument::CardToken(CardToken {
payment_type: PaymentType::Token,
href,
cvc: None,
})
}
MandateReferenceId::NetworkMandateId(_network_txn_id) => {
// NTI flow would need raw card details, which RepeatPayment doesn't have
return Err(errors::ConnectorError::NotImplemented(
"NetworkMandateId not supported in RepeatPayment".to_string(),
)
.into());
}
MandateReferenceId::NetworkTokenWithNTI(_) => {
return Err(errors::ConnectorError::NotImplemented(
"NetworkTokenWithNTI not supported in RepeatPayment yet".to_string(),
)
.into());
}
};
// Determine settlement from capture_method
let settlement = match item.router_data.request.capture_method {
Some(enums::CaptureMethod::Automatic)
| Some(enums::CaptureMethod::SequentialAutomatic)
| None => Some(AutoSettlement { auto: true }),
Some(enums::CaptureMethod::Manual) | Some(enums::CaptureMethod::ManualMultiple) => {
Some(AutoSettlement { auto: false })
}
_ => None,
};
Ok(Self {
instruction: Instruction {
settlement,
method: PaymentMethod::Card, // RepeatPayment is always card-based
payment_instrument,
narrative: InstructionNarrative {
line1: merchant_name.expose(),
},
value: PaymentValue {
amount: item.router_data.request.minor_amount,
currency: item.router_data.request.currency,
},
debt_repayment: None,
three_ds: None, // MIT transactions don't require 3DS
token_creation: None, // No new token creation for repeat payments
customer_agreement: Some(CustomerAgreement {
agreement_type: CustomerAgreementType::Subscription,
stored_card_usage: Some(StoredCardUsageType::Subsequent), // CRITICAL: MIT indicator
scheme_reference: None,
}),
},
merchant: Merchant {
entity: WorldpayAuthType::try_from(&item.router_data.connector_auth_type)?
.entity_id,
..Default::default()
},
transaction_reference: item
.router_data
.resource_common_data
.connector_request_reference_id
.clone(),
customer: None,
})
}
}
pub struct WorldpayAuthType {
pub(super) api_key: Secret<String>,
pub(super) entity_id: Secret<String>,
}
impl TryFrom<&ConnectorAuthType> for WorldpayAuthType {
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,
} => {
let auth_key = format!("{}:{}", key1.peek(), api_key.peek());
let auth_header = format!(
"Basic {}",
base64::Engine::encode(&base64::engine::general_purpose::STANDARD, auth_key)
);
Ok(Self {
api_key: Secret::new(auth_header),
entity_id: api_secret.clone(),
})
}
_ => Err(errors::ConnectorError::FailedToObtainAuthType)?,
}
}
}
| {
"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_9109066662545807561_6 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/worldpay/transformers.rs
impl From<PaymentOutcome> for enums::AttemptStatus {
fn from(item: PaymentOutcome) -> Self {
match item {
PaymentOutcome::Authorized => Self::Authorized,
PaymentOutcome::SentForSettlement => Self::Charged,
PaymentOutcome::ThreeDsDeviceDataRequired => Self::DeviceDataCollectionPending,
PaymentOutcome::ThreeDsAuthenticationFailed => Self::AuthenticationFailed,
PaymentOutcome::ThreeDsChallenged => Self::AuthenticationPending,
PaymentOutcome::SentForCancellation => Self::VoidInitiated,
PaymentOutcome::SentForPartialRefund | PaymentOutcome::SentForRefund => {
Self::AutoRefunded
}
PaymentOutcome::Refused | PaymentOutcome::FraudHighRisk => Self::Failure,
PaymentOutcome::ThreeDsUnavailable => Self::AuthenticationFailed,
}
}
}
impl From<PaymentOutcome> for enums::RefundStatus {
fn from(item: PaymentOutcome) -> Self {
match item {
PaymentOutcome::SentForPartialRefund | PaymentOutcome::SentForRefund => Self::Success,
PaymentOutcome::Refused
| PaymentOutcome::FraudHighRisk
| PaymentOutcome::Authorized
| PaymentOutcome::SentForSettlement
| PaymentOutcome::ThreeDsDeviceDataRequired
| PaymentOutcome::ThreeDsAuthenticationFailed
| PaymentOutcome::ThreeDsChallenged
| PaymentOutcome::SentForCancellation
| PaymentOutcome::ThreeDsUnavailable => Self::Failure,
}
}
}
impl From<&EventType> for enums::AttemptStatus {
fn from(value: &EventType) -> Self {
match value {
EventType::SentForAuthorization => Self::Authorizing,
EventType::SentForSettlement => Self::Charged,
EventType::Settled => Self::Charged,
EventType::Authorized => Self::Authorized,
EventType::Refused
| EventType::SettlementFailed
| EventType::Expired
| EventType::Cancelled => Self::Failure,
EventType::SentForRefund | EventType::RefundFailed | EventType::Refunded => {
Self::Charged
}
EventType::Error | EventType::Unknown => Self::Pending,
}
}
}
impl From<EventType> for enums::RefundStatus {
fn from(value: EventType) -> Self {
match value {
EventType::Refunded | EventType::SentForRefund => Self::Success,
EventType::RefundFailed => Self::Failure,
EventType::Authorized
| EventType::Cancelled
| EventType::Settled
| EventType::Refused
| EventType::Error
| EventType::SentForSettlement
| EventType::SentForAuthorization
| EventType::SettlementFailed
| EventType::Expired
| EventType::Unknown => Self::Pending,
}
}
}
// Add the TryFrom implementation that the macro system expects
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
TryFrom<
ResponseRouterData<
WorldpayPaymentsResponse,
RouterDataV2<
Authorize,
PaymentFlowData,
PaymentsAuthorizeData<T>,
PaymentsResponseData,
>,
>,
> for RouterDataV2<Authorize, PaymentFlowData, PaymentsAuthorizeData<T>, PaymentsResponseData>
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: ResponseRouterData<
WorldpayPaymentsResponse,
RouterDataV2<
Authorize,
PaymentFlowData,
PaymentsAuthorizeData<T>,
PaymentsResponseData,
>,
>,
) -> Result<Self, Self::Error> {
// Use the existing ForeignTryFrom implementation
Self::foreign_try_from((item, None, MinorUnit::zero()))
}
}
// RepeatPayment response transformer
impl
TryFrom<
ResponseRouterData<
WorldpayPaymentsResponse,
RouterDataV2<
domain_types::connector_flow::RepeatPayment,
PaymentFlowData,
RepeatPaymentData,
| {
"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_9109066662545807561_7 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/worldpay/transformers.rs
PaymentsResponseData,
>,
>,
>
for RouterDataV2<
domain_types::connector_flow::RepeatPayment,
PaymentFlowData,
RepeatPaymentData,
PaymentsResponseData,
>
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: ResponseRouterData<
WorldpayPaymentsResponse,
RouterDataV2<
domain_types::connector_flow::RepeatPayment,
PaymentFlowData,
RepeatPaymentData,
PaymentsResponseData,
>,
>,
) -> Result<Self, Self::Error> {
// Extract amount before moving item to pass for correct status determination
let amount = item.router_data.request.minor_amount;
// Use the existing ForeignTryFrom implementation
Self::foreign_try_from((item, None, amount))
}
}
impl<F, T>
ForeignTryFrom<(
ResponseRouterData<
WorldpayPaymentsResponse,
RouterDataV2<F, PaymentFlowData, T, PaymentsResponseData>,
>,
Option<String>,
MinorUnit,
)> for RouterDataV2<F, PaymentFlowData, T, PaymentsResponseData>
{
type Error = error_stack::Report<errors::ConnectorError>;
fn foreign_try_from(
item: (
ResponseRouterData<
WorldpayPaymentsResponse,
RouterDataV2<F, PaymentFlowData, T, PaymentsResponseData>,
>,
Option<String>,
MinorUnit,
),
) -> Result<Self, Self::Error> {
let (router_data, optional_correlation_id, amount) = item;
let (description, redirection_data, mandate_reference, network_txn_id, error) = router_data
.response
.other_fields
.as_ref()
.map(|other_fields| match other_fields {
WorldpayPaymentResponseFields::AuthorizedResponse(res) => (
res.description.clone(),
None,
res.token.as_ref().map(|mandate_token| MandateReference {
connector_mandate_id: Some(mandate_token.href.clone().expose()),
payment_method_id: Some(mandate_token.token_id.clone()),
}),
res.scheme_reference.clone(),
None,
),
WorldpayPaymentResponseFields::DDCResponse(res) => {
let link_data = res
.actions
.supply_ddc_data
.href
.split('/')
.nth_back(1)
.map(|s| s.to_string());
(
None,
Some(RedirectForm::WorldpayDDCForm {
endpoint: res.device_data_collection.url.clone(),
method: common_utils::request::Method::Post,
collection_id: link_data,
form_fields: HashMap::from([
(
FORM_FIELD_BIN.to_string(),
res.device_data_collection.bin.clone().expose(),
),
(
FORM_FIELD_JWT.to_string(),
res.device_data_collection.jwt.clone().expose(),
),
]),
}),
None,
None,
None,
)
}
WorldpayPaymentResponseFields::ThreeDsChallenged(res) => (
None,
Some(RedirectForm::Form {
endpoint: res.challenge.url.to_string(),
method: common_utils::request::Method::Post,
form_fields: HashMap::from([(
FORM_FIELD_JWT.to_string(),
res.challenge.jwt.clone().expose(),
)]),
}),
None,
None,
None,
),
| {
"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_9109066662545807561_8 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/worldpay/transformers.rs
WorldpayPaymentResponseFields::RefusedResponse(res) => (
None,
None,
None,
None,
Some((
res.refusal_code.clone(),
res.refusal_description.clone(),
res.advice
.as_ref()
.and_then(|advice_code| advice_code.code.clone()),
)),
),
WorldpayPaymentResponseFields::FraudHighRisk(_) => (None, None, None, None, None),
})
.unwrap_or((None, None, None, None, None));
let worldpay_status = router_data.response.outcome.clone();
let optional_error_message = match worldpay_status {
PaymentOutcome::ThreeDsAuthenticationFailed => {
Some("3DS authentication failed from issuer".to_string())
}
PaymentOutcome::ThreeDsUnavailable => {
Some("3DS authentication unavailable from issuer".to_string())
}
PaymentOutcome::FraudHighRisk => Some("Transaction marked as high risk".to_string()),
_ => None,
};
let status = if amount == MinorUnit::zero() && worldpay_status == PaymentOutcome::Authorized
{
enums::AttemptStatus::Charged
} else {
enums::AttemptStatus::from(worldpay_status.clone())
};
// Extract linkData for 3DS flows and store in metadata with stage indicator
let connector_metadata = match &router_data.response.other_fields {
Some(WorldpayPaymentResponseFields::DDCResponse(res)) => res
.actions
.supply_ddc_data
.href
.split('/')
.nth_back(1)
.map(|link_data| {
let mut metadata = serde_json::Map::new();
metadata.insert(
METADATA_LINK_DATA.to_string(),
serde_json::Value::String(link_data.to_string()),
);
metadata.insert(
METADATA_3DS_STAGE.to_string(),
serde_json::Value::String(STAGE_DDC.to_string()),
);
serde_json::Value::Object(metadata)
}),
Some(WorldpayPaymentResponseFields::ThreeDsChallenged(res)) => res
.actions
.complete_three_ds_challenge
.href
.split('/')
.nth_back(1)
.map(|link_data| {
let mut metadata = serde_json::Map::new();
metadata.insert(
METADATA_LINK_DATA.to_string(),
serde_json::Value::String(link_data.to_string()),
);
metadata.insert(
METADATA_3DS_STAGE.to_string(),
serde_json::Value::String(STAGE_CHALLENGE.to_string()),
);
serde_json::Value::Object(metadata)
}),
_ => None,
};
let response = match (optional_error_message, error) {
(None, None) => Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::foreign_try_from((
router_data.response,
optional_correlation_id.clone(),
))?,
redirection_data: redirection_data.map(Box::new),
mandate_reference: mandate_reference.map(Box::new),
connector_metadata,
network_txn_id: network_txn_id.map(|id| id.expose()),
connector_response_reference_id: optional_correlation_id.clone(),
incremental_authorization_allowed: None,
status_code: router_data.http_code,
}),
(Some(reason), _) => Err(ErrorResponse {
code: worldpay_status.to_string(),
message: reason.clone(),
reason: Some(reason),
status_code: router_data.http_code,
attempt_status: Some(status),
connector_transaction_id: optional_correlation_id,
| {
"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_9109066662545807561_9 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/worldpay/transformers.rs
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
}),
(_, Some((code, message, advice_code))) => Err(ErrorResponse {
code: code.clone(),
message: message.clone(),
reason: Some(message.clone()),
status_code: router_data.http_code,
attempt_status: Some(status),
connector_transaction_id: optional_correlation_id,
network_advice_code: advice_code,
// Access Worldpay returns a raw response code in the refusalCode field (if enabled) containing the unmodified response code received either directly from the card scheme for Worldpay-acquired transactions, or from third party acquirers.
// You can use raw response codes to inform your retry logic. A rawCode is only returned if specifically requested.
network_decline_code: Some(code),
network_error_message: Some(message),
}),
};
Ok(Self {
resource_common_data: PaymentFlowData {
status,
description,
..router_data.router_data.resource_common_data
},
response,
..router_data.router_data
})
}
}
// Note: Old RouterData TryFrom implementations removed as we're using RouterDataV2
// The following implementations are kept for compatibility with existing response processing
// Steps 100-109: TryFrom implementations for Capture flow
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
TryFrom<
WorldpayRouterData<
RouterDataV2<Capture, PaymentFlowData, PaymentsCaptureData, PaymentsResponseData>,
T,
>,
> for WorldpayPartialRequest
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: WorldpayRouterData<
RouterDataV2<Capture, PaymentFlowData, PaymentsCaptureData, PaymentsResponseData>,
T,
>,
) -> Result<Self, Self::Error> {
if item.router_data.request.is_multiple_capture() {
// Partial capture - include both reference and value
Ok(Self {
reference: Some(
item.router_data
.resource_common_data
.connector_request_reference_id
.clone(),
),
value: Some(PaymentValue {
amount: item.router_data.request.minor_amount_to_capture,
currency: item.router_data.request.currency,
}),
})
} else {
// Full capture - send empty body
Ok(Self {
reference: None,
value: None,
})
}
}
}
impl
TryFrom<
ResponseRouterData<
WorldpayPaymentsResponse,
RouterDataV2<Capture, PaymentFlowData, PaymentsCaptureData, PaymentsResponseData>,
>,
> for RouterDataV2<Capture, PaymentFlowData, PaymentsCaptureData, PaymentsResponseData>
{
type Error = error_stack::Report<ConnectorError>;
fn try_from(
item: ResponseRouterData<
WorldpayPaymentsResponse,
RouterDataV2<Capture, PaymentFlowData, PaymentsCaptureData, PaymentsResponseData>,
>,
) -> Result<Self, Self::Error> {
let status = enums::AttemptStatus::from(item.response.outcome.clone());
let response = Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::foreign_try_from((item.response.clone(), None))?,
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,
..item.router_data.resource_common_data
},
response,
..item.router_data
})
}
}
impl<F>
| {
"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_9109066662545807561_10 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/worldpay/transformers.rs
TryFrom<(
&RouterDataV2<F, RefundFlowData, RefundsData, RefundsResponseData>,
MinorUnit,
)> for WorldpayPartialRequest
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
req: (
&RouterDataV2<F, RefundFlowData, RefundsData, RefundsResponseData>,
MinorUnit,
),
) -> Result<Self, Self::Error> {
let (item, amount) = req;
Ok(Self {
reference: Some(item.request.refund_id.clone()),
value: Some(PaymentValue {
amount,
currency: item.request.currency,
}),
})
}
}
impl TryFrom<WorldpayWebhookEventType> for WorldpayEventResponse {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(event: WorldpayWebhookEventType) -> Result<Self, Self::Error> {
Ok(Self {
last_event: event.event_details.event_type,
links: None,
})
}
}
// Step 80-84: TryFrom implementations for PSync flow
impl<F> TryFrom<ResponseRouterData<WorldpayEventResponse, Self>>
for RouterDataV2<F, PaymentFlowData, PaymentsSyncData, PaymentsResponseData>
{
type Error = error_stack::Report<ConnectorError>;
fn try_from(
item: ResponseRouterData<WorldpayEventResponse, Self>,
) -> Result<Self, Self::Error> {
let status = enums::AttemptStatus::from(&item.response.last_event);
let response = Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(
item.router_data
.resource_common_data
.connector_request_reference_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: item.http_code,
});
Ok(Self {
resource_common_data: PaymentFlowData {
status,
..item.router_data.resource_common_data
},
response,
..item.router_data
})
}
}
// Steps 85-94: TryFrom implementations for Refund flow
impl<
F,
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
TryFrom<
WorldpayRouterData<RouterDataV2<F, RefundFlowData, RefundsData, RefundsResponseData>, T>,
> for WorldpayPartialRequest
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: WorldpayRouterData<
RouterDataV2<F, RefundFlowData, RefundsData, RefundsResponseData>,
T,
>,
) -> Result<Self, Self::Error> {
Ok(Self {
reference: Some(item.router_data.request.refund_id.clone()),
value: Some(PaymentValue {
amount: item.router_data.request.minor_refund_amount,
currency: item.router_data.request.currency,
}),
})
}
}
impl<F> TryFrom<ResponseRouterData<WorldpayPaymentsResponse, Self>>
for RouterDataV2<F, RefundFlowData, RefundsData, RefundsResponseData>
{
type Error = error_stack::Report<ConnectorError>;
fn try_from(
item: ResponseRouterData<WorldpayPaymentsResponse, Self>,
) -> Result<Self, Self::Error> {
let refund_status = enums::RefundStatus::from(item.response.outcome.clone());
let response = Ok(RefundsResponseData {
connector_refund_id: item.router_data.request.refund_id.clone(),
refund_status,
status_code: item.http_code,
});
Ok(Self {
resource_common_data: RefundFlowData {
..item.router_data.resource_common_data
},
response,
..item.router_data
})
}
}
// Steps 95-99: TryFrom implementations for RSync flow
impl<F> TryFrom<ResponseRouterData<WorldpayEventResponse, Self>>
for RouterDataV2<F, RefundFlowData, RefundSyncData, RefundsResponseData>
{
type Error = error_stack::Report<ConnectorError>;
fn try_from(
item: ResponseRouterData<WorldpayEventResponse, 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_9109066662545807561_11 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/worldpay/transformers.rs
) -> Result<Self, Self::Error> {
let refund_status = enums::RefundStatus::from(item.response.last_event);
let response = Ok(RefundsResponseData {
connector_refund_id: item
.router_data
.resource_common_data
.connector_request_reference_id
.clone(),
refund_status,
status_code: item.http_code,
});
Ok(Self {
resource_common_data: RefundFlowData {
..item.router_data.resource_common_data
},
response,
..item.router_data
})
}
}
// Steps 110-119: TryFrom implementations for Void flow
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
TryFrom<
WorldpayRouterData<
RouterDataV2<Void, PaymentFlowData, PaymentVoidData, PaymentsResponseData>,
T,
>,
> for ()
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
_item: WorldpayRouterData<
RouterDataV2<Void, PaymentFlowData, PaymentVoidData, PaymentsResponseData>,
T,
>,
) -> Result<Self, Self::Error> {
// Void request has empty body
Ok(())
}
}
impl TryFrom<ResponseRouterData<WorldpayPaymentsResponse, Self>>
for RouterDataV2<Void, PaymentFlowData, PaymentVoidData, PaymentsResponseData>
{
type Error = error_stack::Report<ConnectorError>;
fn try_from(
item: ResponseRouterData<WorldpayPaymentsResponse, Self>,
) -> Result<Self, Self::Error> {
let status = enums::AttemptStatus::from(item.response.outcome.clone());
let response = Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::foreign_try_from((item.response.clone(), None))?,
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,
..item.router_data.resource_common_data
},
response,
..item.router_data
})
}
}
impl ForeignTryFrom<(WorldpayPaymentsResponse, Option<String>)> for ResponseIdStr {
type Error = error_stack::Report<errors::ConnectorError>;
fn foreign_try_from(
item: (WorldpayPaymentsResponse, Option<String>),
) -> Result<Self, Self::Error> {
get_resource_id(item.0, item.1, |id| Self { id })
}
}
impl ForeignTryFrom<(WorldpayPaymentsResponse, Option<String>)> for ResponseId {
type Error = error_stack::Report<errors::ConnectorError>;
fn foreign_try_from(
item: (WorldpayPaymentsResponse, Option<String>),
) -> Result<Self, Self::Error> {
get_resource_id(item.0, item.1, Self::ConnectorTransactionId)
}
}
// Authentication flow implementations
// PreAuthenticate request transformer (for 3dsDeviceData/DDC)
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
TryFrom<
WorldpayRouterData<
RouterDataV2<
domain_types::connector_flow::PreAuthenticate,
PaymentFlowData,
domain_types::connector_types::PaymentsPreAuthenticateData<T>,
PaymentsResponseData,
>,
T,
>,
> for WorldpayPreAuthenticateRequest
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: WorldpayRouterData<
RouterDataV2<
domain_types::connector_flow::PreAuthenticate,
PaymentFlowData,
domain_types::connector_types::PaymentsPreAuthenticateData<T>,
PaymentsResponseData,
>,
T,
>,
) -> Result<Self, Self::Error> {
let params = item
.router_data
.request
.redirect_response
.as_ref()
| {
"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_9109066662545807561_12 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/worldpay/transformers.rs
.and_then(|redirect_response| redirect_response.params.as_ref())
.ok_or(errors::ConnectorError::ResponseDeserializationFailed)?;
let parsed_request =
serde_urlencoded::from_str::<WorldpayAuthenticateRequest>(params.peek())
.change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
Ok(parsed_request)
}
}
// PostAuthenticate request transformer (for 3dsChallenges)
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
TryFrom<
WorldpayRouterData<
RouterDataV2<
domain_types::connector_flow::PostAuthenticate,
PaymentFlowData,
domain_types::connector_types::PaymentsPostAuthenticateData<T>,
PaymentsResponseData,
>,
T,
>,
> for WorldpayPostAuthenticateRequest
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: WorldpayRouterData<
RouterDataV2<
domain_types::connector_flow::PostAuthenticate,
PaymentFlowData,
domain_types::connector_types::PaymentsPostAuthenticateData<T>,
PaymentsResponseData,
>,
T,
>,
) -> Result<Self, Self::Error> {
let params = item
.router_data
.request
.redirect_response
.as_ref()
.and_then(|redirect_response| redirect_response.params.as_ref())
.ok_or(errors::ConnectorError::ResponseDeserializationFailed)?;
let parsed_request =
serde_urlencoded::from_str::<WorldpayAuthenticateRequest>(params.peek())
.change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
Ok(parsed_request)
}
}
// Response implementations for authentication flows
// PreAuthenticate response transformer
impl<T> TryFrom<ResponseRouterData<WorldpayPaymentsResponse, Self>>
for RouterDataV2<
domain_types::connector_flow::PreAuthenticate,
PaymentFlowData,
domain_types::connector_types::PaymentsPreAuthenticateData<T>,
PaymentsResponseData,
>
where
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
{
type Error = error_stack::Report<ConnectorError>;
fn try_from(
item: ResponseRouterData<WorldpayPaymentsResponse, Self>,
) -> Result<Self, Self::Error> {
let status = enums::AttemptStatus::from(item.response.outcome.clone());
let (redirection_data, connector_response_reference_id) =
extract_redirection_data(&item.response)?;
let _connector_metadata = extract_three_ds_metadata(&item.response);
let response = Ok(PaymentsResponseData::PreAuthenticateResponse {
redirection_data: redirection_data.map(Box::new),
connector_response_reference_id,
status_code: item.http_code,
});
Ok(Self {
resource_common_data: PaymentFlowData {
status,
..item.router_data.resource_common_data
},
response,
..item.router_data
})
}
}
// PostAuthenticate response transformer
impl<T> TryFrom<ResponseRouterData<WorldpayPaymentsResponse, Self>>
for RouterDataV2<
domain_types::connector_flow::PostAuthenticate,
PaymentFlowData,
domain_types::connector_types::PaymentsPostAuthenticateData<T>,
PaymentsResponseData,
>
where
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
{
type Error = error_stack::Report<ConnectorError>;
fn try_from(
item: ResponseRouterData<WorldpayPaymentsResponse, Self>,
) -> Result<Self, Self::Error> {
let status = enums::AttemptStatus::from(item.response.outcome.clone());
let (_redirection_data, connector_response_reference_id) =
extract_redirection_data(&item.response)?;
let _connector_metadata = extract_three_ds_metadata(&item.response);
| {
"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_9109066662545807561_13 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/worldpay/transformers.rs
let response = Ok(PaymentsResponseData::PostAuthenticateResponse {
authentication_data: None,
connector_response_reference_id,
status_code: item.http_code,
});
Ok(Self {
resource_common_data: PaymentFlowData {
status,
..item.router_data.resource_common_data
},
response,
..item.router_data
})
}
}
fn extract_redirection_data(
response: &WorldpayPaymentsResponse,
) -> Result<(Option<RedirectForm>, Option<String>), error_stack::Report<errors::ConnectorError>> {
match &response.other_fields {
Some(WorldpayPaymentResponseFields::ThreeDsChallenged(challenged)) => {
let redirect_form = RedirectForm::Form {
endpoint: challenged.challenge.url.to_string(),
method: common_utils::request::Method::Post,
form_fields: std::collections::HashMap::from([(
"JWT".to_string(),
challenged.challenge.jwt.clone().expose(),
)]),
};
Ok((
Some(redirect_form),
Some(challenged.challenge.reference.clone()),
))
}
Some(WorldpayPaymentResponseFields::DDCResponse(ddc)) => {
let link_data = ddc
.actions
.supply_ddc_data
.href
.split('/')
.nth_back(1)
.map(|s| s.to_string());
let redirect_form = RedirectForm::WorldpayDDCForm {
endpoint: ddc.device_data_collection.url.clone(),
method: common_utils::request::Method::Post,
collection_id: link_data,
form_fields: std::collections::HashMap::from([
(
FORM_FIELD_BIN.to_string(),
ddc.device_data_collection.bin.clone().expose(),
),
(
FORM_FIELD_JWT.to_string(),
ddc.device_data_collection.jwt.clone().expose(),
),
]),
};
Ok((
Some(redirect_form),
Some(METADATA_DDC_REFERENCE.to_string()),
))
}
_ => Ok((None, None)),
}
}
// Helper function to extract 3DS authentication metadata
fn extract_three_ds_metadata(response: &WorldpayPaymentsResponse) -> Option<serde_json::Value> {
match &response.other_fields {
Some(WorldpayPaymentResponseFields::RefusedResponse(refused)) => {
// Check for 3DS data in refused response
if let Some(three_ds) = &refused.three_ds {
let mut metadata = serde_json::Map::new();
if let Some(version) = &three_ds.version {
metadata.insert(
METADATA_3DS_VERSION.to_string(),
serde_json::Value::String(version.clone()),
);
}
if let Some(eci) = &three_ds.eci {
metadata.insert(
METADATA_ECI.to_string(),
serde_json::Value::String(eci.clone()),
);
}
if let Some(applied) = &three_ds.applied {
metadata.insert(
METADATA_AUTH_APPLIED.to_string(),
serde_json::Value::String(applied.clone()),
);
}
if !metadata.is_empty() {
return Some(serde_json::Value::Object(metadata));
}
}
None
}
Some(WorldpayPaymentResponseFields::ThreeDsChallenged(challenged)) => {
let mut metadata = serde_json::Map::new();
metadata.insert(
METADATA_3DS_VERSION.to_string(),
serde_json::Value::String(challenged.authentication.version.clone()),
);
if let Some(eci) = &challenged.authentication.eci {
metadata.insert(
METADATA_ECI.to_string(),
serde_json::Value::String(eci.clone()),
);
}
| {
"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_9109066662545807561_14 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/worldpay/transformers.rs
// Extract linkData and stage for Authenticate response with 3DS challenge
if let Some(link_data) = challenged
.actions
.complete_three_ds_challenge
.href
.split('/')
.nth_back(1)
{
metadata.insert(
"link_data".to_string(),
serde_json::Value::String(link_data.to_string()),
);
metadata.insert(
"3ds_stage".to_string(),
serde_json::Value::String("challenge".to_string()),
);
}
Some(serde_json::Value::Object(metadata))
}
Some(WorldpayPaymentResponseFields::DDCResponse(ddc)) => {
// Extract linkData and stage for Authenticate response with DDC
let mut metadata = serde_json::Map::new();
if let Some(link_data) = ddc.actions.supply_ddc_data.href.split('/').nth_back(1) {
metadata.insert(
"link_data".to_string(),
serde_json::Value::String(link_data.to_string()),
);
metadata.insert(
"3ds_stage".to_string(),
serde_json::Value::String("ddc".to_string()),
);
}
if !metadata.is_empty() {
Some(serde_json::Value::Object(metadata))
} else {
None
}
}
_ => None,
}
}
| {
"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_426009472564931438_0 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/worldpay/requests.rs
use common_utils::types::MinorUnit;
use hyperswitch_masking::Secret;
use serde::{Deserialize, Serialize};
#[derive(Clone, Debug, PartialEq, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct WorldpayAuthorizeRequest<
T: domain_types::payment_method_data::PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ serde::Serialize,
> {
pub transaction_reference: String,
pub merchant: Merchant,
pub instruction: Instruction<T>,
#[serde(skip_serializing_if = "Option::is_none")]
pub customer: Option<Customer>,
}
#[derive(Clone, Debug, PartialEq, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Merchant {
pub entity: Secret<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub mcc: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub payment_facilitator: Option<PaymentFacilitator>,
}
#[derive(Clone, Debug, PartialEq, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct Instruction<
T: domain_types::payment_method_data::PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ serde::Serialize,
> {
#[serde(skip_serializing_if = "Option::is_none")]
pub settlement: Option<AutoSettlement>,
pub method: PaymentMethod,
pub payment_instrument: PaymentInstrument<T>,
pub narrative: InstructionNarrative,
pub value: PaymentValue,
#[serde(skip_serializing_if = "Option::is_none")]
pub debt_repayment: Option<bool>,
#[serde(rename = "threeDS", skip_serializing_if = "Option::is_none")]
pub three_ds: Option<ThreeDSRequest>,
/// For setting up mandates
pub token_creation: Option<TokenCreation>,
/// For specifying CIT vs MIT
pub customer_agreement: Option<CustomerAgreement>,
}
#[derive(Clone, Debug, PartialEq, Serialize)]
pub struct TokenCreation {
#[serde(rename = "type")]
pub token_type: TokenCreationType,
}
#[derive(Clone, Debug, PartialEq, Serialize)]
#[serde(rename_all = "lowercase")]
pub enum TokenCreationType {
Worldpay,
}
#[serde_with::skip_serializing_none]
#[derive(Clone, Debug, PartialEq, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct CustomerAgreement {
#[serde(rename = "type")]
pub agreement_type: CustomerAgreementType,
pub stored_card_usage: Option<StoredCardUsageType>,
#[serde(skip_serializing_if = "Option::is_none")]
pub scheme_reference: Option<Secret<String>>,
}
#[derive(Clone, Debug, PartialEq, Serialize)]
#[serde(rename_all = "lowercase")]
pub enum CustomerAgreementType {
Subscription,
Unscheduled,
}
#[derive(Clone, Debug, PartialEq, Serialize)]
#[serde(rename_all = "lowercase")]
pub enum StoredCardUsageType {
First,
Subsequent,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
#[serde(untagged)]
pub enum PaymentInstrument<
T: domain_types::payment_method_data::PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ serde::Serialize,
> {
Card(CardPayment<T>),
CardToken(CardToken),
RawCardForNTI(RawCardDetails<domain_types::payment_method_data::DefaultPCIHolder>),
Googlepay(WalletPayment),
Applepay(WalletPayment),
}
#[derive(Clone, Debug, PartialEq, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct CardPayment<
T: domain_types::payment_method_data::PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ serde::Serialize,
> {
#[serde(flatten)]
pub raw_card_details: RawCardDetails<T>,
pub cvc: Secret<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub card_holder_name: Option<Secret<String>>,
#[serde(skip_serializing_if = "Option::is_none")]
pub billing_address: Option<BillingAddress>,
}
#[derive(Clone, Debug, PartialEq, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct RawCardDetails<
T: domain_types::payment_method_data::PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ serde::Serialize,
> {
#[serde(rename = "type")]
pub payment_type: PaymentType,
| {
"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_426009472564931438_1 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/worldpay/requests.rs
pub card_number: domain_types::payment_method_data::RawCardNumber<T>,
pub expiry_date: ExpiryDate,
}
#[derive(Clone, Debug, PartialEq, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct CardToken {
#[serde(rename = "type")]
pub payment_type: PaymentType,
pub href: String,
#[serde(skip_serializing_if = "Option::is_none")]
pub cvc: Option<Secret<String>>,
}
#[derive(Clone, Debug, PartialEq, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct WalletPayment {
#[serde(rename = "type")]
pub payment_type: PaymentType,
pub wallet_token: Secret<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub billing_address: Option<BillingAddress>,
}
#[derive(
Clone, Copy, Debug, Eq, Default, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize,
)]
#[serde(rename_all = "lowercase")]
pub enum PaymentType {
#[default]
Plain,
Token,
Encrypted,
Checkout,
}
#[derive(Clone, Debug, PartialEq, Default, Serialize, Deserialize)]
pub struct ExpiryDate {
pub month: Secret<i8>,
pub year: Secret<i32>,
}
#[derive(Clone, Debug, PartialEq, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct BillingAddress {
pub address1: Secret<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub address2: Option<Secret<String>>,
#[serde(skip_serializing_if = "Option::is_none")]
pub address3: Option<Secret<String>>,
pub city: String,
#[serde(skip_serializing_if = "Option::is_none")]
pub state: Option<Secret<String>>,
pub postal_code: Secret<String>,
pub country_code: common_enums::CountryAlpha2,
}
#[derive(
Clone, Copy, Default, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize,
)]
#[serde(rename_all = "camelCase")]
pub enum Channel {
#[default]
Ecom,
Moto,
}
#[derive(Clone, Debug, PartialEq, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Customer {
#[serde(skip_serializing_if = "Option::is_none")]
pub risk_profile: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub authentication: Option<CustomerAuthentication>,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub enum CustomerAuthentication {
ThreeDS(ThreeDS),
Token(NetworkToken),
}
#[derive(Clone, Debug, PartialEq, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ThreeDS {
#[serde(skip_serializing_if = "Option::is_none")]
pub authentication_value: Option<Secret<String>>,
pub version: ThreeDSVersion,
#[serde(skip_serializing_if = "Option::is_none")]
pub transaction_id: Option<String>,
pub eci: String,
#[serde(rename = "type")]
pub auth_type: CustomerAuthType,
}
#[derive(
Clone, Copy, Default, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize,
)]
pub enum ThreeDSVersion {
#[default]
#[serde(rename = "1")]
One,
#[serde(rename = "2")]
Two,
}
#[derive(
Clone, Copy, Default, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize,
)]
pub enum CustomerAuthType {
#[serde(rename = "3DS")]
#[default]
Variant3Ds,
#[serde(rename = "card/networkToken")]
NetworkToken,
}
#[derive(Clone, Debug, PartialEq, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct NetworkToken {
#[serde(rename = "type")]
pub auth_type: CustomerAuthType,
pub authentication_value: Secret<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub eci: Option<String>,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct AutoSettlement {
pub auto: bool,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ThreeDSRequest {
#[serde(rename = "type")]
pub three_ds_type: String,
pub mode: String,
pub device_data: ThreeDSRequestDeviceData,
pub challenge: ThreeDSRequestChallenge,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ThreeDSRequestDeviceData {
pub accept_header: String,
pub user_agent_header: String,
pub browser_language: Option<String>,
pub browser_screen_width: Option<u32>,
pub browser_screen_height: Option<u32>,
pub browser_color_depth: Option<String>,
| {
"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_426009472564931438_2 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/worldpay/requests.rs
pub time_zone: Option<String>,
pub browser_java_enabled: Option<bool>,
pub browser_javascript_enabled: Option<bool>,
pub channel: Option<ThreeDSRequestChannel>,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "lowercase")]
pub enum ThreeDSRequestChannel {
Browser,
Native,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ThreeDSRequestChallenge {
pub return_url: String,
#[serde(skip_serializing_if = "Option::is_none")]
pub preference: Option<String>,
}
#[derive(Clone, Debug, PartialEq, Default, Serialize, Deserialize)]
#[serde(rename_all = "lowercase")]
pub enum PaymentMethod {
#[default]
Card,
ApplePay,
GooglePay,
}
#[derive(Clone, Debug, PartialEq, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct InstructionNarrative {
pub line1: String,
}
#[derive(Clone, Debug, PartialEq, Default, Serialize, Deserialize)]
pub struct PaymentValue {
pub amount: MinorUnit,
pub currency: common_enums::Currency,
}
#[derive(Clone, Debug, PartialEq, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct PaymentFacilitator {
pub pf_id: Secret<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub iso_id: Option<Secret<String>>,
pub sub_merchant: SubMerchant,
}
#[derive(Clone, Debug, PartialEq, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct SubMerchant {
pub city: String,
pub name: Secret<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub state: Option<String>,
pub postal_code: Secret<String>,
pub merchant_id: Secret<String>,
pub country_code: String,
pub street: Secret<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub tax_id: Option<Secret<String>>,
}
#[derive(Default, Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct WorldpayPartialRequest {
#[serde(skip_serializing_if = "Option::is_none")]
pub value: Option<PaymentValue>,
#[serde(skip_serializing_if = "Option::is_none")]
pub reference: Option<String>,
}
// Type aliases to avoid duplicate template structs in macro generation
pub type WorldpayCaptureRequest = WorldpayPartialRequest;
pub type WorldpayRefundRequest = WorldpayPartialRequest;
pub(super) const THREE_DS_MODE: &str = "always";
pub(super) const THREE_DS_TYPE: &str = "integrated";
pub(super) const THREE_DS_CHALLENGE_PREFERENCE: &str = "challengeMandated";
#[derive(Clone, Debug, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct WorldpayAuthenticateRequest {
#[serde(skip_serializing_if = "Option::is_none")]
pub collection_reference: Option<String>,
}
// Type aliases to avoid duplicate template structs in macro generation
pub type WorldpayPreAuthenticateRequest = WorldpayAuthenticateRequest;
pub type WorldpayPostAuthenticateRequest = WorldpayAuthenticateRequest;
// RepeatPayment uses the same request structure as Authorize (MIT vs CIT)
pub type WorldpayRepeatPaymentRequest<T> = WorldpayAuthorizeRequest<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_-8005942479899491151_0 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/payu/transformers.rs
use common_enums::{self, AttemptStatus, Currency};
use common_utils::{pii::IpAddress, Email};
use domain_types::{
connector_flow::{Authorize, PSync},
connector_types::{
PaymentFlowData, PaymentsAuthorizeData, PaymentsResponseData, PaymentsSyncData, ResponseId,
},
errors::ConnectorError,
payment_method_data::{PaymentMethodData, PaymentMethodDataTypes, UpiData},
router_data::{ConnectorAuthType, ErrorResponse},
router_data_v2::RouterDataV2,
router_request_types::AuthoriseIntegrityObject,
router_response_types::RedirectForm,
};
use error_stack::{report, ResultExt};
use hyperswitch_masking::{ExposeInterface, PeekInterface, Secret};
use serde::{Deserialize, Serialize};
use crate::types::ResponseRouterData;
pub mod constants {
// Payu API versions
pub const API_VERSION: &str = "2.0";
// Payu device info
pub const DEVICE_INFO: &str = "web";
// Payu UPI specific constants
pub const PRODUCT_INFO: &str = "Payment"; // Default product info
pub const UPI_PG: &str = "UPI"; // UPI payment gateway
pub const UPI_COLLECT_BANKCODE: &str = "UPI"; // UPI Collect bank code
pub const UPI_INTENT_BANKCODE: &str = "INTENT"; // UPI Intent bank code
pub const UPI_S2S_FLOW: &str = "2"; // S2S flow type for UPI
// Payu PSync specific constants
pub const COMMAND: &str = "verify_payment";
}
// PayU Status enum to handle both integer and string status values
#[derive(Debug, Serialize, Clone)]
pub enum PayuStatusValue {
IntStatus(i32), // 1 for UPI Intent success
StringStatus(String), // "success" for UPI Collect success
}
// Custom deserializer for PayU status field that can be either int or string
fn deserialize_payu_status<'de, D>(deserializer: D) -> Result<Option<PayuStatusValue>, D::Error>
where
D: serde::Deserializer<'de>,
{
use serde_json::Value;
let value: Option<Value> = Option::deserialize(deserializer)?;
match value {
Some(Value::Number(n)) => {
if let Some(i) = n.as_i64() {
Ok(Some(PayuStatusValue::IntStatus(i as i32)))
} else {
Ok(None)
}
}
Some(Value::String(s)) => Ok(Some(PayuStatusValue::StringStatus(s))),
_ => Ok(None),
}
}
// Authentication structure based on Payu analysis
#[derive(Debug, Clone)]
pub struct PayuAuthType {
pub api_key: Secret<String>,
pub api_secret: Secret<String>, // Merchant salt for signature
}
impl TryFrom<&ConnectorAuthType> for PayuAuthType {
type Error = error_stack::Report<ConnectorError>;
fn try_from(auth_type: &ConnectorAuthType) -> Result<Self, Self::Error> {
match auth_type {
ConnectorAuthType::BodyKey { api_key, key1 } => Ok(Self {
api_key: api_key.to_owned(),
api_secret: key1.to_owned(), // key1 is merchant salt
}),
_ => Err(ConnectorError::FailedToObtainAuthType.into()),
}
}
}
// Note: Integrity Framework implementation will be handled by the framework itself
// since we can't implement foreign traits for foreign types (orphan rules)
// Request structure based on Payu UPI analysis
#[derive(Debug, Serialize)]
pub struct PayuPaymentRequest {
// Core payment fields
pub key: String, // Merchant key
pub txnid: String, // Transaction ID
pub amount: common_utils::types::StringMajorUnit, // Amount in string major units
pub currency: Currency, // Currency code
pub productinfo: String, // Product description
// Customer information
pub firstname: Secret<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub lastname: Option<Secret<String>>,
pub email: Email,
pub phone: Secret<String>,
// URLs
pub surl: String, // Success URL
pub furl: String, // Failure URL
// Payment method specific
#[serde(skip_serializing_if = "Option::is_none")]
pub pg: Option<String>, // Payment gateway code (UPI)
#[serde(skip_serializing_if = "Option::is_none")]
pub bankcode: Option<String>, // Bank code (TEZ, INTENT, TEZOMNI)
#[serde(skip_serializing_if = "Option::is_none")]
pub vpa: Option<Secret<String>>, // UPI VPA (for collect)
// UPI specific fields
| {
"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_-8005942479899491151_1 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/payu/transformers.rs
pub txn_s2s_flow: String, // S2S flow type ("2" for UPI)
pub s2s_client_ip: Secret<String, IpAddress>, // Client IP
pub s2s_device_info: String, // Device info
#[serde(skip_serializing_if = "Option::is_none")]
pub api_version: Option<String>, // API version ("2.0")
// Security
pub hash: String, // SHA-512 signature
// User defined fields (10 fields as per PayU spec)
#[serde(skip_serializing_if = "Option::is_none")]
pub udf1: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub udf2: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub udf3: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub udf4: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub udf5: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub udf6: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub udf7: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub udf8: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub udf9: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub udf10: Option<String>,
// Optional PayU fields for UPI
#[serde(skip_serializing_if = "Option::is_none")]
pub offer_key: Option<String>, // Offer identifier
#[serde(skip_serializing_if = "Option::is_none")]
pub si: Option<i32>, // Standing instruction flag
#[serde(skip_serializing_if = "Option::is_none")]
pub si_details: Option<String>, // SI details JSON
#[serde(skip_serializing_if = "Option::is_none")]
pub beneficiarydetail: Option<String>, // TPV beneficiary details
#[serde(skip_serializing_if = "Option::is_none")]
pub user_token: Option<String>, // User token for repeat transactions
#[serde(skip_serializing_if = "Option::is_none")]
pub offer_auto_apply: Option<i32>, // Auto apply offer flag (0 or 1)
#[serde(skip_serializing_if = "Option::is_none")]
pub additional_charges: Option<String>, // Surcharge/fee amount
#[serde(skip_serializing_if = "Option::is_none")]
pub additional_gst_charges: Option<String>, // GST charges
#[serde(skip_serializing_if = "Option::is_none")]
pub upi_app_name: Option<String>, // UPI app name for intent flows
}
// Response structure based on actual PayU API response
#[derive(Debug, Deserialize, Serialize)]
pub struct PayuPaymentResponse {
// Success response fields - PayU can return status as either int or string
#[serde(deserialize_with = "deserialize_payu_status")]
pub status: Option<PayuStatusValue>, // Status can be 1 (int) or "success" (string)
pub token: Option<String>, // PayU token
#[serde(alias = "referenceId")]
pub reference_id: Option<String>, // PayU reference ID
#[serde(alias = "returnUrl")]
pub return_url: Option<String>, // Return URL
#[serde(alias = "merchantName")]
pub merchant_name: Option<String>, // Merchant display name
#[serde(alias = "merchantVpa")]
pub merchant_vpa: Option<Secret<String>>, // Merchant UPI VPA
pub amount: Option<String>, // Transaction amount
#[serde(alias = "txnId")]
pub txn_id: Option<String>, // Transaction ID
#[serde(alias = "intentURIData")]
pub intent_uri_data: Option<String>, // UPI intent URI data
// UPI-specific fields
pub apps: Option<Vec<PayuUpiApp>>, // Available UPI apps
#[serde(alias = "upiPushDisabled")]
pub upi_push_disabled: Option<String>, // UPI push disabled flag
#[serde(alias = "pushServiceUrl")]
pub push_service_url: Option<String>, // Push service URL
#[serde(alias = "pushServiceUrlV2")]
pub push_service_url_v2: Option<String>, // Push service URL V2
#[serde(alias = "encodedPayuId")]
pub encoded_payu_id: Option<String>, // Encoded PayU ID
#[serde(alias = "vpaRegex")]
pub vpa_regex: Option<String>, // VPA validation regex
// Polling and timeout configuration
#[serde(alias = "upiServicePollInterval")]
pub upi_service_poll_interval: Option<String>, // Poll interval
#[serde(alias = "sdkUpiPushExpiry")]
pub sdk_upi_push_expiry: Option<String>, // Push expiry time
#[serde(alias = "sdkUpiVerificationInterval")]
| {
"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_-8005942479899491151_2 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/payu/transformers.rs
pub sdk_upi_verification_interval: Option<String>, // Verification interval
// Additional flags
#[serde(alias = "disableIntentSeamlessFailure")]
pub disable_intent_seamless_failure: Option<String>,
#[serde(alias = "intentSdkCombineVerifyAndPayButton")]
pub intent_sdk_combine_verify_and_pay_button: Option<String>,
// Error response fields (actual PayU format)
pub result: Option<PayuResult>, // PayU result field (null for errors)
pub error: Option<String>, // Error code like "EX158"
pub message: Option<String>, // Error message
}
#[derive(Debug, Deserialize, Serialize)]
pub struct PayuResult {
pub status: String, // UPI Collect Status
pub mihpayid: String, // ID
}
#[derive(Debug, Deserialize, Serialize)]
pub struct PayuUpiApp {
pub name: String, // App display name
pub package: String, // Android package name
}
// Error response structure matching actual PayU format
#[derive(Debug, Deserialize, Serialize)]
pub struct PayuErrorResponse {
pub result: Option<serde_json::Value>, // null for errors
pub status: Option<String>, // "failed" for errors
pub error: Option<String>, // Error code like "EX158", "EX311"
pub message: Option<String>, // Error description
// Legacy fields for backward compatibility
pub error_code: Option<String>,
pub error_message: Option<String>,
pub error_description: Option<String>,
pub transaction_id: Option<String>,
}
// Request conversion with Framework Integration
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
TryFrom<
super::PayuRouterData<
RouterDataV2<
Authorize,
PaymentFlowData,
PaymentsAuthorizeData<T>,
PaymentsResponseData,
>,
T,
>,
> for PayuPaymentRequest
{
type Error = error_stack::Report<ConnectorError>;
fn try_from(
item: super::PayuRouterData<
RouterDataV2<
Authorize,
PaymentFlowData,
PaymentsAuthorizeData<T>,
PaymentsResponseData,
>,
T,
>,
) -> Result<Self, Self::Error> {
// Extract router data
let router_data = &item.router_data;
// Use AmountConvertor framework for proper amount handling
let amount = item
.connector
.amount_converter
.convert(
router_data.request.minor_amount,
router_data.request.currency,
)
.change_context(ConnectorError::AmountConversionFailed)?;
// Extract authentication
let auth = PayuAuthType::try_from(&router_data.connector_auth_type)?;
// Determine payment flow based on payment method
let (pg, bankcode, vpa, s2s_flow) = determine_upi_flow(&router_data.request)?;
// Generate UDF fields based on Haskell implementation
let udf_fields = generate_udf_fields(
&router_data.resource_common_data.payment_id,
router_data
.resource_common_data
.merchant_id
.get_string_repr(),
router_data,
);
// Build base request
let mut request = Self {
key: auth.api_key.peek().to_string(),
txnid: router_data
.resource_common_data
.connector_request_reference_id
.clone(),
amount,
currency: router_data.request.currency,
productinfo: constants::PRODUCT_INFO.to_string(), // Default product info
// Customer info - extract from billing address if available
firstname: router_data.resource_common_data.get_billing_first_name()?,
lastname: router_data
.resource_common_data
.get_optional_billing_last_name(),
email: router_data.resource_common_data.get_billing_email()?,
phone: router_data
.resource_common_data
.get_billing_phone_number()?,
// URLs - use router return URL if available
| {
"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_-8005942479899491151_3 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/payu/transformers.rs
surl: router_data.request.get_router_return_url()?,
furl: router_data.request.get_router_return_url()?,
// Payment method specific
pg,
bankcode,
vpa: vpa.map(Secret::new),
// UPI specific - corrected based on PayU docs
txn_s2s_flow: s2s_flow,
s2s_client_ip: router_data
.request
.get_ip_address_as_optional()
.ok_or_else(|| {
report!(ConnectorError::MissingRequiredField {
field_name: "IP address"
})
})?,
s2s_device_info: constants::DEVICE_INFO.to_string(),
api_version: Some(constants::API_VERSION.to_string()), // As per PayU analysis
// Will be calculated after struct creation
hash: String::new(),
// User defined fields based on Haskell implementation logic
udf1: udf_fields.first().and_then(|f| f.clone()), // Transaction ID or metadata value
udf2: udf_fields.get(1).and_then(|f| f.clone()), // Merchant ID or metadata value
udf3: udf_fields.get(2).and_then(|f| f.clone()), // From metadata or order reference
udf4: udf_fields.get(3).and_then(|f| f.clone()), // From metadata or order reference
udf5: udf_fields.get(4).and_then(|f| f.clone()), // From metadata or order reference
udf6: udf_fields.get(5).and_then(|f| f.clone()), // From order reference (udf6)
udf7: udf_fields.get(6).and_then(|f| f.clone()), // From order reference (udf7)
udf8: udf_fields.get(7).and_then(|f| f.clone()), // From order reference (udf8)
udf9: udf_fields.get(8).and_then(|f| f.clone()), // From order reference (udf9)
udf10: udf_fields.get(9).and_then(|f| f.clone()), // Always empty string
// Optional PayU fields for UPI
offer_key: None,
si: None, // Not implementing mandate flows initially
si_details: None,
beneficiarydetail: None, // Not implementing TPV initially
user_token: None,
offer_auto_apply: None,
additional_charges: None,
additional_gst_charges: None,
upi_app_name: determine_upi_app_name(&router_data.request)?,
};
// Generate hash signature
request.hash = generate_payu_hash(&request, &auth.api_secret)?;
Ok(request)
}
}
// PayU Sync/Verify Payment Request structure
#[derive(Debug, Serialize)]
pub struct PayuSyncRequest {
pub key: String, // Merchant key
pub command: String, // "verify_payment"
pub var1: String, // Transaction ID to verify
pub hash: String, // SHA-512 signature
}
// PayU Sync Response structure based on Haskell implementation
#[derive(Debug, Deserialize, Serialize)]
pub struct PayuSyncResponse {
pub status: Option<i32>, // 0 = error, non-zero = success
pub msg: Option<String>, // Status message
pub transaction_details: Option<std::collections::HashMap<String, PayuTransactionDetail>>, // Map of txnId -> details
pub result: Option<serde_json::Value>, // Optional result field
#[serde(alias = "field3")]
pub field3: Option<String>, // Additional field
}
// PayU Transaction Detail structure from sync response
#[derive(Debug, Deserialize, Serialize)]
pub struct PayuTransactionDetail {
pub mihpayid: Option<String>, // PayU transaction ID
pub txnid: Option<String>, // Merchant transaction ID
pub amount: Option<String>, // Transaction amount
pub status: String, // Transaction status: "success", "failure", "pending", "cancel"
pub firstname: Option<String>, // Customer first name
pub lastname: Option<String>, // Customer last name
pub email: Option<Secret<String>>, // Customer email
pub phone: Option<Secret<String>>, // Customer phone
pub productinfo: Option<String>, // Product description
pub hash: Option<String>, // Response hash for verification
pub field1: Option<String>, // UPI transaction ID
pub field2: Option<String>, // Bank reference number
pub field3: Option<String>, // Payment source
| {
"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_-8005942479899491151_4 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/payu/transformers.rs
pub field9: Option<String>, // Additional field
pub error_code: Option<String>, // Error code if failed
pub error_message: Option<String>, // Error message if failed
pub card_token: Option<String>, // Card token if applicable
pub card_category: Option<String>, // Card category
pub offer_key: Option<String>, // Offer key used
pub discount: Option<String>, // Discount applied
pub net_amount_debit: Option<String>, // Net amount debited
pub addedon: Option<String>, // Transaction timestamp
pub payment_source: Option<String>, // Payment method used
pub bank_ref_num: Option<String>, // Bank reference number
pub upi_va: Option<String>, // UPI virtual address
pub cardnum: Option<String>, // Masked card number
pub issuing_bank: Option<String>, // Card issuing bank
}
// PayU Sync Request conversion from RouterData
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
TryFrom<
super::PayuRouterData<
RouterDataV2<PSync, PaymentFlowData, PaymentsSyncData, PaymentsResponseData>,
T,
>,
> for PayuSyncRequest
{
type Error = error_stack::Report<ConnectorError>;
fn try_from(
item: super::PayuRouterData<
RouterDataV2<PSync, PaymentFlowData, PaymentsSyncData, PaymentsResponseData>,
T,
>,
) -> Result<Self, Self::Error> {
let router_data = &item.router_data;
// Extract authentication
let auth = PayuAuthType::try_from(&router_data.connector_auth_type)?;
// Extract transaction ID from connector_transaction_id
let transaction_id = router_data
.request
.connector_transaction_id
.get_connector_transaction_id()
.change_context(ConnectorError::MissingRequiredField {
field_name: "connector_transaction_id",
})?;
let command = constants::COMMAND;
// Build sync request
let mut request = Self {
key: auth.api_key.peek().to_string(),
command: command.to_string(),
var1: transaction_id,
hash: String::new(), // Will be calculated below
};
// Generate hash signature for verification request
// PayU verify hash: SHA512(key|command|var1|salt)
request.hash = generate_payu_verify_hash(&request, &auth.api_secret)?;
Ok(request)
}
}
// Hash generation for PayU verify payment request
// Based on Haskell: makePayuVerifyHash payuDetails txnId command
fn generate_payu_verify_hash(
request: &PayuSyncRequest,
merchant_salt: &Secret<String>,
) -> Result<String, ConnectorError> {
use sha2::{Digest, Sha512};
// PayU verify hash format: key|command|var1|salt
let hash_fields = [
request.key.clone(),
request.command.clone(),
request.var1.clone(),
merchant_salt.peek().to_string(),
];
// Join with pipe separator
let hash_string = hash_fields.join("|");
// Log hash string for debugging (remove in production)
#[cfg(debug_assertions)]
{
let masked_hash = format!(
"{}|***MASKED***",
hash_fields[..hash_fields.len() - 1].join("|")
);
tracing::debug!("PayU verify hash string (salt masked): {}", masked_hash);
tracing::debug!("PayU verify expected format: key|command|var1|salt");
}
// Generate SHA-512 hash
let mut hasher = Sha512::new();
hasher.update(hash_string.as_bytes());
let result = hasher.finalize();
Ok(hex::encode(result))
}
// UDF field generation based on Haskell implementation
// Implements the logic from getUdf1-getUdf5 functions and orderReference fields
fn generate_udf_fields<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>(
payment_id: &str,
merchant_id: &str,
router_data: &RouterDataV2<
Authorize,
PaymentFlowData,
PaymentsAuthorizeData<T>,
PaymentsResponseData,
>,
) -> [Option<String>; 10] {
// Based on Haskell implementation:
// udf1-udf5 come from PayuMetaData (if available) or default values
// udf6-udf9 come from orderReference fields
| {
"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_-8005942479899491151_5 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/payu/transformers.rs
// udf10 is always empty string
// Extract metadata from request
let metadata = router_data.request.metadata.as_ref();
// Helper function to get string value from metadata
let get_metadata_field = |field: &str| -> Option<String> {
metadata
.and_then(|m| m.get(field))
.and_then(|v| v.as_str())
.map(|s| s.to_string())
};
[
// udf1: From metadata "udf1" or default to transaction ID
get_metadata_field("udf1").or(Some(payment_id.to_string())),
// udf2: From metadata "udf2" or default to merchant ID
get_metadata_field("udf2").or(Some(merchant_id.to_string())),
// udf3: From metadata "udf3" or empty
get_metadata_field("udf3"),
// udf4: From metadata "udf4" or empty
get_metadata_field("udf4"),
// udf5: From metadata "udf5" or empty
get_metadata_field("udf5"),
// udf6: From metadata "udf6" or empty
get_metadata_field("udf6"),
// udf7: From metadata "udf7" or empty
get_metadata_field("udf7"),
// udf8: From metadata "udf8" or empty
get_metadata_field("udf8"),
// udf9: From metadata "udf9" or empty
get_metadata_field("udf9"),
// udf9: From metadata "udf10" or empty
get_metadata_field("udf10"),
]
}
// UPI app name determination based on Haskell getUpiAppName implementation
fn determine_upi_app_name<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>(
request: &PaymentsAuthorizeData<T>,
) -> Result<Option<String>, ConnectorError> {
// From Haskell getUpiAppName implementation:
// getUpiAppName txnDetail = case getJuspayBankCodeFromInternalMetadata txnDetail of
// Just "JP_PHONEPE" -> "phonepe"
// Just "JP_GOOGLEPAY" -> "googlepay"
// Just "JP_BHIM" -> "bhim"
// Just "JP_PAYTM" -> "paytm"
// Just "JP_CRED" -> "cred"
// Just "JP_AMAZONPAY" -> "amazonpay"
// Just "JP_WHATSAPP" -> "whatsapp"
// _ -> "genericintent"
match &request.payment_method_data {
PaymentMethodData::Upi(upi_data) => {
match upi_data {
UpiData::UpiIntent(_) | UpiData::UpiQr(_) => {
// For UPI Intent and UPI QR, return generic intent as fallback
// TODO: Extract bank code from metadata if available
Ok(None)
}
UpiData::UpiCollect(upi_collect_data) => {
// UPI Collect doesn't typically use app name
Ok(upi_collect_data.vpa_id.clone().map(|vpa| vpa.expose()))
}
}
}
_ => Ok(None),
}
}
// PayU flow determination based on Haskell getTxnS2SType implementation
#[allow(clippy::type_complexity)]
fn determine_upi_flow<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>(
request: &PaymentsAuthorizeData<T>,
) -> Result<(Option<String>, Option<String>, Option<String>, String), ConnectorError> {
// Based on Haskell implementation:
// getTxnS2SType :: Bool -> Bool -> Bool -> Bool -> Bool -> Maybe Text
// getTxnS2SType isTxnS2SFlow4Enabled s2sEnabled isDirectOTPTxn isEmandateRegister isDirectAuthorization
match &request.payment_method_data {
PaymentMethodData::Upi(upi_data) => {
match upi_data {
UpiData::UpiCollect(collect_data) => {
if let Some(vpa) = &collect_data.vpa_id {
// UPI Collect flow - based on Haskell implementation
// For UPI Collect: pg = UPI, bankcode = UPI, VPA required
// The key is that VPA must be populated for sourceObject == "UPI_COLLECT"
Ok((
Some(constants::UPI_PG.to_string()),
Some(constants::UPI_COLLECT_BANKCODE.to_string()),
Some(vpa.peek().to_string()),
constants::UPI_S2S_FLOW.to_string(), // UPI Collect typically uses S2S flow "2"
))
} else {
| {
"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_-8005942479899491151_6 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/payu/transformers.rs
// Missing VPA for UPI Collect - this should be an error
Err(ConnectorError::MissingRequiredField {
field_name: "vpa_id",
})
}
}
UpiData::UpiIntent(_) | UpiData::UpiQr(_) => {
// UPI Intent flow - uses S2S flow "2" for intent-based transactions
// pg=UPI, bankcode=INTENT for intent flows
Ok((
Some(constants::UPI_PG.to_string()),
Some(constants::UPI_INTENT_BANKCODE.to_string()),
None,
constants::UPI_S2S_FLOW.to_string(),
))
}
}
}
_ => Err(ConnectorError::NotSupported {
message: "Payment method not supported by PayU. Only UPI payments are supported"
.to_string(),
connector: "PayU",
}),
}
}
pub fn is_upi_collect_flow<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>(
request: &PaymentsAuthorizeData<T>,
) -> bool {
// Check if the payment method is UPI Collect
matches!(
request.payment_method_data,
PaymentMethodData::Upi(UpiData::UpiCollect(_))
)
}
// Hash generation based on Haskell PayU implementation (makePayuTxnHash)
// PayU expects: sha512(key|txnid|amount|productinfo|firstname|email|udf1|udf2|udf3|udf4|udf5|udf6|udf7|udf8|udf9|udf10|salt)
fn generate_payu_hash(
request: &PayuPaymentRequest,
merchant_salt: &Secret<String>,
) -> Result<String, ConnectorError> {
use sha2::{Digest, Sha512};
// Build hash fields array exactly as PayU expects based on Haskell implementation
// Pattern from Haskell: key|txnid|amount|productinfo|firstname|email|udf1|udf2|udf3|udf4|udf5|udf6|udf7|udf8|udf9|udf10|salt
let hash_fields = vec![
request.key.clone(), // key
request.txnid.clone(), // txnid
request.amount.get_amount_as_string(), // amount
request.productinfo.clone(), // productinfo
request.firstname.peek().clone(), // firstname
request.email.peek().clone(), // email
request.udf1.as_deref().unwrap_or("").to_string(), // udf1
request.udf2.as_deref().unwrap_or("").to_string(), // udf2
request.udf3.as_deref().unwrap_or("").to_string(), // udf3
request.udf4.as_deref().unwrap_or("").to_string(), // udf4
request.udf5.as_deref().unwrap_or("").to_string(), // udf5
request.udf6.as_deref().unwrap_or("").to_string(), // udf6
request.udf7.as_deref().unwrap_or("").to_string(), // udf7
request.udf8.as_deref().unwrap_or("").to_string(), // udf8
request.udf9.as_deref().unwrap_or("").to_string(), // udf9
request.udf10.as_deref().unwrap_or("").to_string(), // udf10
merchant_salt.peek().to_string(), // salt
];
// Join with pipe separator as PayU expects
let hash_string = hash_fields.join("|");
// Log hash string for debugging (remove in production)
#[cfg(debug_assertions)]
{
let masked_hash = format!(
"{}|***MASKED***",
hash_fields[..hash_fields.len() - 1].join("|")
);
tracing::debug!("PayU hash string (salt masked): {}", masked_hash);
tracing::debug!("PayU expected format from Haskell: key|txnid|amount|productinfo|firstname|email|udf1|udf2|udf3|udf4|udf5|udf6|udf7|udf8|udf9|udf10|salt");
}
// Generate SHA-512 hash as PayU expects
let mut hasher = Sha512::new();
hasher.update(hash_string.as_bytes());
let result = hasher.finalize();
Ok(hex::encode(result))
}
// Response conversion with Framework Integration
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
TryFrom<
ResponseRouterData<
PayuPaymentResponse,
RouterDataV2<
Authorize,
PaymentFlowData,
| {
"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_-8005942479899491151_7 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/payu/transformers.rs
PaymentsAuthorizeData<T>,
PaymentsResponseData,
>,
>,
> for RouterDataV2<Authorize, PaymentFlowData, PaymentsAuthorizeData<T>, PaymentsResponseData>
{
type Error = error_stack::Report<ConnectorError>;
fn try_from(
item: ResponseRouterData<
PayuPaymentResponse,
RouterDataV2<
Authorize,
PaymentFlowData,
PaymentsAuthorizeData<T>,
PaymentsResponseData,
>,
>,
) -> Result<Self, Self::Error> {
let response = item.response;
// Check if this is an error response first
if let Some(error_code) = &response.error {
// Extract transaction ID for error response
let error_transaction_id = response
.reference_id
.clone()
.or_else(|| response.txn_id.clone())
.or_else(|| response.token.clone());
// This is an error response - return error with actual status code
let error_response = ErrorResponse {
status_code: item.http_code, // Use actual HTTP response code instead of hardcoded 200
code: error_code.clone(),
message: response.message.clone().unwrap_or_default(),
reason: None,
attempt_status: Some(AttemptStatus::Failure),
connector_transaction_id: error_transaction_id,
network_error_message: None,
network_advice_code: None,
network_decline_code: None,
};
return Ok(Self {
response: Err(error_response),
resource_common_data: PaymentFlowData {
status: AttemptStatus::Failure,
..item.router_data.resource_common_data
},
..item.router_data
});
}
// Extract reference ID for transaction tracking (success case)
let upi_transaction_id = response
.reference_id
.or_else(|| response.txn_id.clone())
.or_else(|| response.token.clone())
.unwrap_or_else(|| item.router_data.resource_common_data.payment_id.clone());
// Convert amount back using AmountConvertor framework if available
let response_amount = if let Some(_amount_str) = response.amount {
// For now, we'll use the request amount since convert_back has complex requirements
// This will be improved in the full implementation
item.router_data.request.minor_amount
} else {
item.router_data.request.minor_amount // Use request amount if response doesn't have it
};
// Create integrity object for response validation
let _integrity_object = Some(AuthoriseIntegrityObject {
amount: response_amount,
currency: item.router_data.request.currency,
});
// This is a success response - determine type based on response format
let (status, transaction_id, redirection_data) = match &response.status {
Some(PayuStatusValue::IntStatus(1)) => {
// UPI Intent success - PayU returns status=1 for successful UPI intent generation
let redirection_data = response.intent_uri_data.map(|intent_data| {
// PayU returns UPI intent parameters that need to be formatted as UPI URI
Box::new(RedirectForm::Uri { uri: intent_data })
});
(
AttemptStatus::AuthenticationPending,
upi_transaction_id.clone(),
redirection_data,
)
}
Some(PayuStatusValue::StringStatus(s)) if s == "success" => {
// UPI Collect success - PayU returns status="success" with result object
let (status, transaction_id) = response
.result
.map(|result| {
if result.status == "pending" {
(
AttemptStatus::AuthenticationPending,
result.mihpayid.clone(),
)
| {
"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_-8005942479899491151_8 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/payu/transformers.rs
} else {
(AttemptStatus::Failure, result.mihpayid.clone())
}
})
.unwrap_or((AttemptStatus::Failure, "".to_owned()));
(status, transaction_id, None)
}
_ => {
// Unknown success status
(AttemptStatus::Failure, upi_transaction_id.clone(), None)
}
};
let payment_response_data = PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(transaction_id.clone()),
redirection_data,
mandate_reference: None,
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: Some(transaction_id),
incremental_authorization_allowed: None,
status_code: item.http_code,
};
Ok(Self {
response: Ok(payment_response_data),
resource_common_data: PaymentFlowData {
status,
..item.router_data.resource_common_data
},
..item.router_data
})
}
}
// PayU Sync Response conversion to RouterData
impl
TryFrom<
ResponseRouterData<
PayuSyncResponse,
RouterDataV2<PSync, PaymentFlowData, PaymentsSyncData, PaymentsResponseData>,
>,
> for RouterDataV2<PSync, PaymentFlowData, PaymentsSyncData, PaymentsResponseData>
{
type Error = error_stack::Report<ConnectorError>;
fn try_from(
item: ResponseRouterData<
PayuSyncResponse,
RouterDataV2<PSync, PaymentFlowData, PaymentsSyncData, PaymentsResponseData>,
>,
) -> Result<Self, Self::Error> {
let response = item.response;
let error_message = response
.msg
.unwrap_or_else(|| "PayU PSync error".to_string());
// Check PayU status field - 0 means error, 1 means success response structure
match (response.status, response.transaction_details) {
(Some(1), Some(transaction_details)) => {
// PayU returned success status, check transaction_details
// Try to find the transaction in the response by iterating through all transactions
// Since PayU returns transaction details as a map with txnid as key
let txn_detail = transaction_details.values().next();
let connector_transaction_id = txn_detail.and_then(|detail| detail.txnid.clone());
match (txn_detail, connector_transaction_id) {
(Some(txn_detail), Some(connector_transaction_id)) => {
// Found transaction details, map status
let attempt_status = map_payu_sync_status(&txn_detail.status, txn_detail);
let payment_response_data = PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(
connector_transaction_id.clone(),
),
redirection_data: None,
mandate_reference: None,
connector_metadata: None,
network_txn_id: txn_detail.field1.clone(), // UPI transaction ID
connector_response_reference_id: txn_detail.mihpayid.clone(),
incremental_authorization_allowed: None,
status_code: item.http_code,
};
Ok(Self {
response: Ok(payment_response_data),
resource_common_data: PaymentFlowData {
status: attempt_status,
..item.router_data.resource_common_data
},
..item.router_data
})
}
_ => {
// Transaction not found in PayU response
let error_response = ErrorResponse {
status_code: item.http_code,
| {
"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_-8005942479899491151_9 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/payu/transformers.rs
code: "TRANSACTION_NOT_FOUND".to_string(),
message: error_message,
reason: None,
attempt_status: Some(AttemptStatus::Failure),
connector_transaction_id: None,
network_error_message: None,
network_advice_code: None,
network_decline_code: None,
};
Ok(Self {
response: Err(error_response),
resource_common_data: PaymentFlowData {
status: AttemptStatus::Failure,
..item.router_data.resource_common_data
},
..item.router_data
})
}
}
}
_ => {
// PayU returned error status
let error_response = ErrorResponse {
status_code: item.http_code,
code: "PAYU_SYNC_ERROR".to_string(),
message: error_message,
reason: None,
attempt_status: Some(AttemptStatus::Failure),
connector_transaction_id: None,
network_error_message: None,
network_advice_code: None,
network_decline_code: None,
};
Ok(Self {
response: Err(error_response),
resource_common_data: PaymentFlowData {
status: AttemptStatus::Failure,
..item.router_data.resource_common_data
},
..item.router_data
})
}
}
}
}
// Map PayU transaction status to internal AttemptStatus
// Based on Haskell implementation analysis
fn map_payu_sync_status(payu_status: &str, txn_detail: &PayuTransactionDetail) -> AttemptStatus {
match payu_status.to_lowercase().as_str() {
"success" => {
// For success, check if it's captured or just authorized
// Based on Haskell: "success" + "captured" -> CHARGED, "success" + "auth" -> AUTHORIZED
if txn_detail.field3.as_deref() == Some("captured") {
AttemptStatus::Charged
} else if txn_detail.field3.as_deref() == Some("auth") {
AttemptStatus::Authorized
} else {
// Default success case - treat as charged for UPI
AttemptStatus::Charged
}
}
"pending" => {
// Pending status - typically for UPI Collect waiting for customer approval
AttemptStatus::AuthenticationPending
}
"failure" | "failed" | "cancel" | "cancelled" => {
// Transaction failed
AttemptStatus::Failure
}
_ => {
// Unknown status - treat as failure for safety
AttemptStatus::Failure
}
}
}
| {
"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_-2910212303359634675_0 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/elavon/transformers.rs
use std::collections::HashMap;
use common_enums::{
AttemptStatus as HyperswitchAttemptStatus, CaptureMethod as HyperswitchCaptureMethod, Currency,
FutureUsage,
};
use common_utils::{
consts::NO_ERROR_CODE,
types::{AmountConvertor, StringMajorUnit, StringMajorUnitForConnector},
};
use domain_types::{
connector_flow::{Authorize, Capture, PSync, RSync, Refund},
connector_types::{
PaymentFlowData, PaymentsAuthorizeData, PaymentsCaptureData, PaymentsResponseData,
PaymentsSyncData, RefundFlowData, RefundSyncData, RefundsData, RefundsResponseData,
ResponseId as DomainResponseId,
},
errors::{self},
payment_address::PaymentAddress,
payment_method_data::{PaymentMethodData, PaymentMethodDataTypes, RawCardNumber},
router_data::{ConnectorAuthType, ErrorResponse, PaymentMethodToken},
router_data_v2::RouterDataV2,
};
use error_stack::{report, ResultExt};
use hyperswitch_masking::{ExposeInterface, PeekInterface, Secret, WithoutType};
use serde::{
de::{self, Deserializer},
Deserialize, Serialize,
};
use serde_with::skip_serializing_none;
use super::ElavonRouterData;
use crate::types::ResponseRouterData;
#[derive(Debug, Clone, Serialize)]
pub struct ElavonAuthType {
pub(super) ssl_merchant_id: Secret<String>,
pub(super) ssl_user_id: Secret<String>,
pub(super) ssl_pin: Secret<String>,
}
impl TryFrom<&ConnectorAuthType> for ElavonAuthType {
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 {
ssl_merchant_id: api_key.clone(),
ssl_user_id: key1.clone(),
ssl_pin: api_secret.clone(),
}),
_ => Err(report!(errors::ConnectorError::FailedToObtainAuthType)),
}
}
}
#[derive(Debug, Deserialize, Clone, PartialEq, Eq)]
#[serde(rename_all = "lowercase")]
pub enum TransactionType {
CcSale,
CcAuthOnly,
CcComplete,
CcReturn,
TxnQuery,
}
impl Serialize for TransactionType {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
let value = match self {
TransactionType::CcSale => "ccsale",
TransactionType::CcAuthOnly => "ccauthonly",
TransactionType::CcComplete => "cccomplete",
TransactionType::CcReturn => "ccreturn",
TransactionType::TxnQuery => "txnquery",
};
serializer.serialize_str(value)
}
}
#[skip_serializing_none]
#[derive(Debug, Serialize)]
pub struct CardPaymentRequest<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> {
pub ssl_transaction_type: TransactionType,
pub ssl_account_id: Secret<String>,
pub ssl_user_id: Secret<String>,
pub ssl_pin: Secret<String>,
pub ssl_amount: StringMajorUnit,
pub ssl_card_number: RawCardNumber<T>,
pub ssl_exp_date: Secret<String>,
pub ssl_cvv2cvc2: Option<Secret<String>>,
pub ssl_cvv2cvc2_indicator: Option<i32>,
pub ssl_email: Option<common_utils::pii::Email>,
#[serde(skip_serializing_if = "Option::is_none")]
pub ssl_add_token: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub ssl_token_source: Option<String>,
pub ssl_get_token: Option<String>,
pub ssl_transaction_currency: Currency,
#[serde(skip_serializing_if = "Option::is_none")]
pub ssl_avs_address: Option<Secret<String>>,
#[serde(skip_serializing_if = "Option::is_none")]
pub ssl_avs_zip: Option<Secret<String>>,
#[serde(skip_serializing_if = "Option::is_none")]
pub ssl_customer_code: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub ssl_invoice_number: Option<String>,
}
#[derive(Debug, Serialize)]
#[serde(untagged)]
pub enum ElavonPaymentsRequest<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> {
Card(CardPaymentRequest<T>),
}
fn get_avs_details_from_payment_address(
payment_address: Option<&PaymentAddress>,
| {
"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_-2910212303359634675_1 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/elavon/transformers.rs
) -> (Option<Secret<String>>, Option<Secret<String>>) {
payment_address
.and_then(|addr| {
addr.get_payment_billing()
.as_ref()
.and_then(|billing_api_address| {
billing_api_address
.address
.as_ref()
.map(|detailed_address| {
(detailed_address.line1.clone(), detailed_address.zip.clone())
})
})
})
.unwrap_or((None, None))
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
TryFrom<
ElavonRouterData<
RouterDataV2<
Authorize,
PaymentFlowData,
PaymentsAuthorizeData<T>,
PaymentsResponseData,
>,
T,
>,
> for ElavonPaymentsRequest<T>
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: ElavonRouterData<
RouterDataV2<
Authorize,
PaymentFlowData,
PaymentsAuthorizeData<T>,
PaymentsResponseData,
>,
T,
>,
) -> Result<Self, Self::Error> {
match item.router_data.request.payment_method_data.clone() {
PaymentMethodData::Card(ref card) => {
let router_data = item.router_data.clone();
let request_data = &router_data.request;
let auth_type = ElavonAuthType::try_from(&router_data.connector_auth_type)?;
let transaction_type = match request_data.capture_method {
Some(HyperswitchCaptureMethod::Manual) => TransactionType::CcAuthOnly,
Some(HyperswitchCaptureMethod::Automatic) => TransactionType::CcSale,
None => TransactionType::CcSale,
Some(other_capture_method) => {
Err(report!(errors::ConnectorError::FlowNotSupported {
flow: format!("Capture method: {other_capture_method:?}"),
connector: "Elavon".to_string()
}))?
}
};
let exp_month = card.card_exp_month.peek().to_string();
let formatted_exp_month = format!("{exp_month:0>2}");
let exp_year = card.card_exp_year.peek().to_string();
let formatted_exp_year = if exp_year.len() == 4 {
&exp_year[2..]
} else {
&exp_year
};
let exp_date = format!("{formatted_exp_month}{formatted_exp_year}");
let (avs_address, avs_zip) = get_avs_details_from_payment_address(Some(
&router_data.resource_common_data.address,
));
let _cvv_indicator = if card.card_cvc.peek().is_empty() {
Some(0)
} else {
Some(1)
};
let customer_id_str = request_data
.customer_id
.as_ref()
.map(|c| c.get_string_repr().to_string());
let add_token =
request_data
.setup_future_usage
.as_ref()
.and_then(|sfu: &FutureUsage| {
if *sfu == FutureUsage::OnSession || *sfu == FutureUsage::OffSession {
Some("ADD".to_string())
} else {
None
}
});
let token_source = add_token.as_ref().map(|_| "ECOMMERCE".to_string());
// Manually convert to StringMajorUnit to avoid error handling issues
let amount_converter = StringMajorUnitForConnector;
let amount = amount_converter
.convert(request_data.minor_amount, request_data.currency)
.map_err(|e| {
report!(errors::ConnectorError::AmountConversionFailed)
| {
"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_-2910212303359634675_2 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/elavon/transformers.rs
.attach_printable(format!("Failed to convert amount: {e}"))
})?;
let card_req = CardPaymentRequest {
ssl_transaction_type: transaction_type,
ssl_account_id: auth_type.ssl_merchant_id.clone(),
ssl_user_id: auth_type.ssl_user_id.clone(),
ssl_pin: auth_type.ssl_pin.clone(),
ssl_amount: amount,
ssl_card_number: card.card_number.clone(),
ssl_exp_date: Secret::new(exp_date),
ssl_cvv2cvc2: Some(card.card_cvc.clone()),
ssl_cvv2cvc2_indicator: Some(1),
ssl_email: request_data.email.clone(),
ssl_add_token: add_token,
ssl_token_source: token_source,
ssl_get_token: None,
ssl_transaction_currency: request_data.currency,
ssl_avs_address: avs_address,
ssl_avs_zip: avs_zip,
ssl_customer_code: customer_id_str,
ssl_invoice_number: Some(router_data.resource_common_data.payment_id.clone()),
};
tracing::debug!(?card_req, "Elavon Card Payment Request");
Ok(ElavonPaymentsRequest::Card(card_req))
}
_ => Err(report!(errors::ConnectorError::NotImplemented(
"Only card payments are supported for Elavon".to_string()
))),
}
}
}
// Define structs to hold the XML request and response formats
#[derive(Debug, Serialize)]
pub struct XMLElavonRequest(pub HashMap<String, Secret<String, WithoutType>>);
// Define a dedicated type for PSync XML requests
#[derive(Debug, Serialize)]
pub struct XMLPSyncRequest(pub HashMap<String, Secret<String, WithoutType>>);
// Define dedicated types for Capture, Refund, and RSync XML requests
#[derive(Debug, Serialize)]
pub struct XMLCaptureRequest(pub HashMap<String, Secret<String, WithoutType>>);
#[derive(Debug, Serialize)]
pub struct XMLRefundRequest(pub HashMap<String, Secret<String, WithoutType>>);
#[derive(Debug, Serialize)]
pub struct XMLRSyncRequest(pub HashMap<String, Secret<String, WithoutType>>);
// TryFrom implementation to convert from the router data to XMLElavonRequest
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
TryFrom<
ElavonRouterData<
RouterDataV2<
Authorize,
PaymentFlowData,
PaymentsAuthorizeData<T>,
PaymentsResponseData,
>,
T,
>,
> for XMLElavonRequest
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
data: ElavonRouterData<
RouterDataV2<
Authorize,
PaymentFlowData,
PaymentsAuthorizeData<T>,
PaymentsResponseData,
>,
T,
>,
) -> Result<Self, Self::Error> {
// Instead of using request_body which could cause a recursive call,
// directly create the ElavonPaymentsRequest from data directly
let request = ElavonPaymentsRequest::try_from(data)
.change_context(errors::ConnectorError::RequestEncodingFailed)
.attach_printable("Failed to create ElavonPaymentsRequest from ElavonRouterData")?;
// Log that we're creating the XML request
tracing::info!("Creating XML for Elavon request using direct implementation");
// Generate XML content directly
let xml_content = quick_xml::se::to_string_with_root("txn", &request).map_err(|err| {
tracing::info!(error=?err, "XML serialization error");
error_stack::report!(errors::ConnectorError::ResponseDeserializationFailed)
})?;
// Log generated XML for debugging
let raw_xml = xml_content.clone();
tracing::info!(xml=?raw_xml, "Generated raw XML");
let mut result = HashMap::new();
result.insert(
"xmldata".to_string(),
Secret::<_, WithoutType>::new(xml_content),
);
// Log form data keys
| {
"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_-2910212303359634675_3 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/elavon/transformers.rs
let keys = result.keys().collect::<Vec<_>>();
tracing::info!(form_keys=?keys, "Form data keys");
Ok(XMLElavonRequest(result))
}
}
// TryFrom implementation for PSync flow using XMLPSyncRequest
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
TryFrom<
ElavonRouterData<
RouterDataV2<PSync, PaymentFlowData, PaymentsSyncData, PaymentsResponseData>,
T,
>,
> for XMLPSyncRequest
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
data: ElavonRouterData<
RouterDataV2<PSync, PaymentFlowData, PaymentsSyncData, PaymentsResponseData>,
T,
>,
) -> Result<Self, Self::Error> {
// Direct implementation to avoid recursive calls
let request = SyncRequest::try_from(&data.router_data)
.change_context(errors::ConnectorError::RequestEncodingFailed)
.attach_printable("Failed to create SyncRequest from RouterData")?;
// Log that we're creating the XML request for PSync
tracing::info!("Creating XML for Elavon PSync request using direct implementation");
// Generate XML content directly
let xml_content = quick_xml::se::to_string_with_root("txn", &request).map_err(|err| {
tracing::info!(error=?err, "XML serialization error");
error_stack::report!(errors::ConnectorError::ResponseDeserializationFailed)
})?;
// Log generated XML for debugging
let raw_xml = xml_content.clone();
tracing::info!(xml=?raw_xml, "Generated raw XML");
let mut result = HashMap::new();
result.insert(
"xmldata".to_string(),
Secret::<_, WithoutType>::new(xml_content),
);
// Log form data keys
let keys = result.keys().collect::<Vec<_>>();
tracing::info!(form_keys=?keys, "PSync XML data map keys");
Ok(XMLPSyncRequest(result))
}
}
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
pub enum SslResult {
#[serde(rename = "0")]
Approved,
#[serde(rename = "1")]
Declined,
Other(String),
}
impl TryFrom<String> for SslResult {
type Error = errors::ConnectorError;
fn try_from(value: String) -> Result<Self, Self::Error> {
match value.as_str() {
"0" => Ok(SslResult::Approved),
"1" => Ok(SslResult::Declined),
_ => Ok(SslResult::Other(value)),
}
}
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct PaymentResponse {
pub ssl_result: SslResult,
pub ssl_txn_id: String,
pub ssl_result_message: String,
pub ssl_token: Option<Secret<String>>,
pub ssl_approval_code: Option<String>,
pub ssl_transaction_type: Option<String>,
pub ssl_cvv2_response: Option<Secret<String>>,
pub ssl_avs_response: Option<String>,
pub ssl_token_response: Option<String>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ElavonErrorResponse {
pub error_code: Option<String>,
pub error_message: String,
pub error_name: Option<String>,
pub ssl_txn_id: Option<String>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum ElavonResult {
Success(PaymentResponse),
Error(ElavonErrorResponse),
}
#[derive(Debug, Clone, Serialize)]
pub struct ElavonPaymentsResponse {
pub result: ElavonResult,
}
// Create distinct response types for Capture and Refund to avoid templating conflicts
#[derive(Debug, Clone, Serialize)]
pub struct ElavonCaptureResponse {
pub result: ElavonResult,
}
#[derive(Debug, Clone, Serialize)]
pub struct ElavonRefundResponse {
pub result: ElavonResult,
}
// Implement the same deserialization logic for all response types
impl<'de> Deserialize<'de> for ElavonPaymentsResponse {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: Deserializer<'de>,
{
#[derive(Deserialize, Debug)]
#[serde(rename = "txn")]
struct XmlIshResponse {
#[serde(default)]
error_code: Option<String>,
#[serde(default)]
error_message: Option<String>,
#[serde(default)]
error_name: Option<String>,
| {
"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_-2910212303359634675_4 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/elavon/transformers.rs
#[serde(default)]
ssl_result: Option<String>,
#[serde(default)]
ssl_txn_id: Option<String>,
#[serde(default)]
ssl_result_message: Option<String>,
#[serde(default)]
ssl_token: Option<Secret<String>>,
#[serde(default)]
ssl_token_response: Option<Secret<String>>,
#[serde(default)]
ssl_approval_code: Option<String>,
#[serde(default)]
ssl_transaction_type: Option<String>,
#[serde(default)]
ssl_cvv2_response: Option<Secret<String>>,
#[serde(default)]
ssl_avs_response: Option<String>,
}
let flat_res = XmlIshResponse::deserialize(deserializer)?;
let result = {
if flat_res.ssl_result.as_deref() == Some("0") {
ElavonResult::Success(PaymentResponse {
ssl_result: SslResult::try_from(
flat_res
.ssl_result
.expect("ssl_result checked to be Some(\\\"0\\\")"),
)
.map_err(de::Error::custom)?,
ssl_txn_id: flat_res
.ssl_txn_id
.ok_or_else(|| de::Error::missing_field("ssl_txn_id"))?,
ssl_result_message: flat_res
.ssl_result_message
.ok_or_else(|| de::Error::missing_field("ssl_result_message"))?,
ssl_token: flat_res.ssl_token,
ssl_approval_code: flat_res.ssl_approval_code,
ssl_transaction_type: flat_res.ssl_transaction_type.clone(),
ssl_cvv2_response: flat_res.ssl_cvv2_response,
ssl_avs_response: flat_res.ssl_avs_response,
ssl_token_response: flat_res.ssl_token_response.map(|s| s.expose()),
})
} else if flat_res.error_message.is_some() {
ElavonResult::Error(ElavonErrorResponse {
error_code: flat_res.error_code.or(flat_res.ssl_result.clone()),
error_message: flat_res.error_message.expect("error_message checked"),
error_name: flat_res.error_name,
ssl_txn_id: flat_res.ssl_txn_id,
})
} else if flat_res.ssl_result.is_some() {
ElavonResult::Error(ElavonErrorResponse {
error_code: flat_res.ssl_result.clone(),
error_message: flat_res
.ssl_result_message
.unwrap_or_else(|| "Transaction resulted in an error".to_string()),
error_name: None,
ssl_txn_id: flat_res.ssl_txn_id,
})
} else {
return Err(de::Error::custom(
"Invalid Response from Elavon - cannot determine success or error state, missing critical fields.",
));
}
};
Ok(Self { result })
}
}
impl<'de> Deserialize<'de> for ElavonCaptureResponse {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: Deserializer<'de>,
{
#[derive(Deserialize, Debug)]
#[serde(rename = "txn")]
struct XmlIshResponse {
#[serde(default)]
error_code: Option<String>,
#[serde(default)]
error_message: Option<String>,
#[serde(default)]
error_name: Option<String>,
#[serde(default)]
ssl_result: Option<String>,
#[serde(default)]
ssl_txn_id: Option<String>,
#[serde(default)]
ssl_result_message: Option<String>,
#[serde(default)]
ssl_token: Option<Secret<String>>,
#[serde(default)]
ssl_token_response: Option<Secret<String>>,
#[serde(default)]
ssl_approval_code: Option<String>,
#[serde(default)]
ssl_transaction_type: Option<String>,
#[serde(default)]
ssl_cvv2_response: Option<Secret<String>>,
#[serde(default)]
ssl_avs_response: Option<String>,
}
| {
"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_-2910212303359634675_5 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/elavon/transformers.rs
let flat_res = XmlIshResponse::deserialize(deserializer)?;
let result = {
if flat_res.ssl_result.as_deref() == Some("0") {
ElavonResult::Success(PaymentResponse {
ssl_result: SslResult::try_from(
flat_res
.ssl_result
.expect("ssl_result checked to be Some(\\\"0\\\")"),
)
.map_err(de::Error::custom)?,
ssl_txn_id: flat_res
.ssl_txn_id
.ok_or_else(|| de::Error::missing_field("ssl_txn_id"))?,
ssl_result_message: flat_res
.ssl_result_message
.ok_or_else(|| de::Error::missing_field("ssl_result_message"))?,
ssl_token: flat_res.ssl_token,
ssl_approval_code: flat_res.ssl_approval_code,
ssl_transaction_type: flat_res.ssl_transaction_type.clone(),
ssl_cvv2_response: flat_res.ssl_cvv2_response,
ssl_avs_response: flat_res.ssl_avs_response,
ssl_token_response: flat_res.ssl_token_response.map(|s| s.expose()),
})
} else if flat_res.error_message.is_some() {
ElavonResult::Error(ElavonErrorResponse {
error_code: flat_res.error_code.or(flat_res.ssl_result.clone()),
error_message: flat_res.error_message.expect("error_message checked"),
error_name: flat_res.error_name,
ssl_txn_id: flat_res.ssl_txn_id,
})
} else if flat_res.ssl_result.is_some() {
ElavonResult::Error(ElavonErrorResponse {
error_code: flat_res.ssl_result.clone(),
error_message: flat_res
.ssl_result_message
.unwrap_or_else(|| "Transaction resulted in an error".to_string()),
error_name: None,
ssl_txn_id: flat_res.ssl_txn_id,
})
} else {
return Err(de::Error::custom(
"Invalid Response from Elavon - cannot determine success or error state, missing critical fields.",
));
}
};
Ok(Self { result })
}
}
impl<'de> Deserialize<'de> for ElavonRefundResponse {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: Deserializer<'de>,
{
#[derive(Deserialize, Debug)]
#[serde(rename = "txn")]
struct XmlIshResponse {
#[serde(default)]
error_code: Option<String>,
#[serde(default)]
error_message: Option<String>,
#[serde(default)]
error_name: Option<String>,
#[serde(default)]
ssl_result: Option<String>,
#[serde(default)]
ssl_txn_id: Option<String>,
#[serde(default)]
ssl_result_message: Option<String>,
#[serde(default)]
ssl_token: Option<Secret<String>>,
#[serde(default)]
ssl_token_response: Option<Secret<String>>,
#[serde(default)]
ssl_approval_code: Option<String>,
#[serde(default)]
ssl_transaction_type: Option<String>,
#[serde(default)]
ssl_cvv2_response: Option<Secret<String>>,
#[serde(default)]
ssl_avs_response: Option<String>,
}
let flat_res = XmlIshResponse::deserialize(deserializer)?;
let result = {
if flat_res.ssl_result.as_deref() == Some("0") {
ElavonResult::Success(PaymentResponse {
ssl_result: SslResult::try_from(
flat_res
.ssl_result
.expect("ssl_result checked to be Some(\\\"0\\\")"),
)
.map_err(de::Error::custom)?,
ssl_txn_id: flat_res
.ssl_txn_id
.ok_or_else(|| de::Error::missing_field("ssl_txn_id"))?,
ssl_result_message: flat_res
| {
"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_-2910212303359634675_6 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/elavon/transformers.rs
.ssl_result_message
.ok_or_else(|| de::Error::missing_field("ssl_result_message"))?,
ssl_token: flat_res.ssl_token,
ssl_approval_code: flat_res.ssl_approval_code,
ssl_transaction_type: flat_res.ssl_transaction_type.clone(),
ssl_cvv2_response: flat_res.ssl_cvv2_response,
ssl_avs_response: flat_res.ssl_avs_response,
ssl_token_response: flat_res.ssl_token_response.map(|s| s.expose()),
})
} else if flat_res.error_message.is_some() {
ElavonResult::Error(ElavonErrorResponse {
error_code: flat_res.error_code.or(flat_res.ssl_result.clone()),
error_message: flat_res.error_message.expect("error_message checked"),
error_name: flat_res.error_name,
ssl_txn_id: flat_res.ssl_txn_id,
})
} else if flat_res.ssl_result.is_some() {
ElavonResult::Error(ElavonErrorResponse {
error_code: flat_res.ssl_result.clone(),
error_message: flat_res
.ssl_result_message
.unwrap_or_else(|| "Transaction resulted in an error".to_string()),
error_name: None,
ssl_txn_id: flat_res.ssl_txn_id,
})
} else {
return Err(de::Error::custom(
"Invalid Response from Elavon - cannot determine success or error state, missing critical fields.",
));
}
};
Ok(Self { result })
}
}
pub fn get_elavon_attempt_status(
elavon_result: &ElavonResult,
http_code: u16,
) -> (HyperswitchAttemptStatus, Option<ErrorResponse>) {
match elavon_result {
ElavonResult::Success(payment_response) => {
let status = match payment_response.ssl_transaction_type.as_deref() {
Some("ccauthonly") | Some("AUTHONLY") => HyperswitchAttemptStatus::Authorized,
Some("ccsale") | Some("cccomplete") | Some("SALE") | Some("COMPLETE") => {
HyperswitchAttemptStatus::Charged
}
_ => match payment_response.ssl_result {
SslResult::Approved => HyperswitchAttemptStatus::Charged,
_ => HyperswitchAttemptStatus::Failure,
},
};
(status, None)
}
ElavonResult::Error(error_resp) => (
HyperswitchAttemptStatus::Failure,
Some(ErrorResponse {
status_code: http_code,
code: error_resp
.error_code
.clone()
.unwrap_or_else(|| NO_ERROR_CODE.to_string()),
message: error_resp.error_message.clone(),
reason: error_resp.error_name.clone(),
attempt_status: Some(HyperswitchAttemptStatus::Failure),
connector_transaction_id: error_resp.ssl_txn_id.clone(),
network_decline_code: None,
network_advice_code: None,
network_error_message: None,
}),
),
}
}
impl<
F,
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize
+ Serialize,
> TryFrom<ResponseRouterData<ElavonPaymentsResponse, Self>>
for RouterDataV2<F, PaymentFlowData, PaymentsAuthorizeData<T>, PaymentsResponseData>
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
value: ResponseRouterData<ElavonPaymentsResponse, Self>,
) -> Result<Self, Self::Error> {
let ResponseRouterData {
response,
router_data,
http_code,
} = value;
// Log the response for debugging
tracing::info!(response=?response, "Processing Elavon response");
let (attempt_status, error_response) =
get_elavon_attempt_status(&response.result, http_code);
let payment_method_token = match &response.result {
ElavonResult::Success(payment_resp_struct) => {
| {
"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_-2910212303359634675_7 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/elavon/transformers.rs
if payment_resp_struct.ssl_token_response.as_deref() == Some("SUCCESS") {
payment_resp_struct
.ssl_token
.clone()
.map(PaymentMethodToken::Token)
} else {
None
}
}
ElavonResult::Error(_) => None,
};
let payments_response_data = match (&response.result, error_response) {
(ElavonResult::Success(payment_resp_struct), None) => {
Ok(PaymentsResponseData::TransactionResponse {
resource_id: DomainResponseId::ConnectorTransactionId(
payment_resp_struct.ssl_txn_id.clone(),
),
redirection_data: None,
connector_metadata: None,
network_txn_id: payment_resp_struct.ssl_approval_code.clone(),
connector_response_reference_id: None,
incremental_authorization_allowed: None,
mandate_reference: None,
status_code: http_code,
})
}
(_, Some(err_resp)) => Err(err_resp),
(ElavonResult::Error(error_payload), None) => Err(ErrorResponse {
status_code: http_code,
code: error_payload
.error_code
.clone()
.unwrap_or_else(|| NO_ERROR_CODE.to_string()),
message: error_payload.error_message.clone(),
reason: error_payload.error_name.clone(),
attempt_status: Some(HyperswitchAttemptStatus::Failure),
connector_transaction_id: error_payload.ssl_txn_id.clone(),
network_decline_code: None,
network_advice_code: None,
network_error_message: None,
}),
};
Ok(Self {
response: payments_response_data,
resource_common_data: PaymentFlowData {
status: attempt_status,
payment_method_token,
..router_data.resource_common_data
},
..router_data
})
}
}
#[derive(Debug, Serialize)]
#[serde(rename = "txn")]
pub struct SyncRequest {
pub ssl_transaction_type: TransactionType,
pub ssl_account_id: Secret<String>,
pub ssl_user_id: Secret<String>,
pub ssl_pin: Secret<String>,
pub ssl_txn_id: String,
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
TryFrom<
ElavonRouterData<
RouterDataV2<PSync, PaymentFlowData, PaymentsSyncData, PaymentsResponseData>,
T,
>,
> for SyncRequest
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: ElavonRouterData<
RouterDataV2<PSync, PaymentFlowData, PaymentsSyncData, PaymentsResponseData>,
T,
>,
) -> Result<Self, Self::Error> {
Self::try_from(&item.router_data)
}
}
impl TryFrom<&RouterDataV2<PSync, PaymentFlowData, PaymentsSyncData, PaymentsResponseData>>
for SyncRequest
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
router_data: &RouterDataV2<PSync, PaymentFlowData, PaymentsSyncData, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
let request_data = &router_data.request;
let auth_type = ElavonAuthType::try_from(&router_data.connector_auth_type)?;
let connector_txn_id = match &request_data.connector_transaction_id {
DomainResponseId::ConnectorTransactionId(id) => id.clone(),
_ => {
return Err(report!(
errors::ConnectorError::MissingConnectorTransactionID
))
.attach_printable("Missing connector_transaction_id for Elavon PSync")
}
};
Ok(Self {
ssl_transaction_type: TransactionType::TxnQuery,
ssl_account_id: auth_type.ssl_merchant_id,
ssl_user_id: auth_type.ssl_user_id,
ssl_pin: auth_type.ssl_pin,
ssl_txn_id: connector_txn_id,
})
}
}
#[skip_serializing_none]
| {
"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_-2910212303359634675_8 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/elavon/transformers.rs
#[derive(Debug, Serialize)]
pub struct ElavonCaptureRequest {
pub ssl_transaction_type: TransactionType,
pub ssl_account_id: Secret<String>,
pub ssl_user_id: Secret<String>,
pub ssl_pin: Secret<String>,
pub ssl_amount: StringMajorUnit,
pub ssl_txn_id: String,
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
TryFrom<
ElavonRouterData<
RouterDataV2<Capture, PaymentFlowData, PaymentsCaptureData, PaymentsResponseData>,
T,
>,
> for ElavonCaptureRequest
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: ElavonRouterData<
RouterDataV2<Capture, PaymentFlowData, PaymentsCaptureData, PaymentsResponseData>,
T,
>,
) -> Result<Self, Self::Error> {
let router_data = item.router_data;
let auth_type = ElavonAuthType::try_from(&router_data.connector_auth_type)?;
let previous_connector_txn_id = match &router_data.request.connector_transaction_id {
DomainResponseId::ConnectorTransactionId(id) => id.clone(),
_ => {
return Err(report!(
errors::ConnectorError::MissingConnectorTransactionID
))
}
};
// Convert amount for capture
let amount_converter = StringMajorUnitForConnector;
let amount = amount_converter
.convert(
router_data.request.minor_amount_to_capture,
router_data.request.currency,
)
.map_err(|_| errors::ConnectorError::RequestEncodingFailed)?;
Ok(Self {
ssl_transaction_type: TransactionType::CcComplete,
ssl_account_id: auth_type.ssl_merchant_id,
ssl_user_id: auth_type.ssl_user_id,
ssl_pin: auth_type.ssl_pin,
ssl_amount: amount,
ssl_txn_id: previous_connector_txn_id,
})
}
}
// Implementation for XMLCaptureRequest
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
TryFrom<
ElavonRouterData<
RouterDataV2<Capture, PaymentFlowData, PaymentsCaptureData, PaymentsResponseData>,
T,
>,
> for XMLCaptureRequest
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
data: ElavonRouterData<
RouterDataV2<Capture, PaymentFlowData, PaymentsCaptureData, PaymentsResponseData>,
T,
>,
) -> Result<Self, Self::Error> {
// Create the ElavonCaptureRequest
let request = ElavonCaptureRequest::try_from(data)
.change_context(errors::ConnectorError::RequestEncodingFailed)
.attach_printable("Failed to create ElavonCaptureRequest")?;
// Generate XML content
let xml_content = quick_xml::se::to_string_with_root("txn", &request)
.map_err(|_| errors::ConnectorError::RequestEncodingFailed)?;
// Create the form data HashMap
let mut result = HashMap::new();
result.insert(
"xmldata".to_string(),
Secret::<_, WithoutType>::new(xml_content),
);
Ok(XMLCaptureRequest(result))
}
}
// Response handling for Capture flow
impl<F> TryFrom<ResponseRouterData<ElavonCaptureResponse, Self>>
for RouterDataV2<F, PaymentFlowData, PaymentsCaptureData, PaymentsResponseData>
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
value: ResponseRouterData<ElavonCaptureResponse, Self>,
) -> Result<Self, Self::Error> {
let ResponseRouterData {
response,
router_data,
http_code,
} = value;
let (attempt_status, error_response) =
get_elavon_attempt_status(&response.result, http_code);
// Determine final status based on the transaction type
let final_status = match &response.result {
ElavonResult::Success(success_payload) => {
match success_payload.ssl_transaction_type.as_deref() {
Some("cccomplete") | Some("ccsale") => match success_payload.ssl_result {
| {
"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_-2910212303359634675_9 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/elavon/transformers.rs
SslResult::Approved => HyperswitchAttemptStatus::Charged,
_ => HyperswitchAttemptStatus::Failure,
},
_ => attempt_status,
}
}
_ => attempt_status,
};
// Build the response data
let response_data = match (&response.result, error_response) {
(ElavonResult::Success(payment_resp_struct), None) => {
Ok(PaymentsResponseData::TransactionResponse {
resource_id: DomainResponseId::ConnectorTransactionId(
payment_resp_struct.ssl_txn_id.clone(),
),
redirection_data: None,
connector_metadata: Some(
serde_json::to_value(payment_resp_struct.clone())
.unwrap_or(serde_json::Value::Null),
),
network_txn_id: None,
connector_response_reference_id: payment_resp_struct.ssl_approval_code.clone(),
incremental_authorization_allowed: None,
mandate_reference: None,
status_code: http_code,
})
}
(_, Some(err_resp)) => Err(err_resp),
(ElavonResult::Error(error_payload), None) => Err(ErrorResponse {
status_code: http_code,
code: error_payload
.error_code
.clone()
.unwrap_or_else(|| NO_ERROR_CODE.to_string()),
message: error_payload.error_message.clone(),
reason: error_payload.error_name.clone(),
attempt_status: Some(HyperswitchAttemptStatus::Failure),
connector_transaction_id: error_payload.ssl_txn_id.clone(),
network_decline_code: None,
network_advice_code: None,
network_error_message: None,
}),
};
Ok(Self {
response: response_data,
resource_common_data: PaymentFlowData {
status: final_status,
..router_data.resource_common_data
},
..router_data
})
}
}
// Implementation for Refund
#[skip_serializing_none]
#[derive(Debug, Serialize)]
pub struct ElavonRefundRequest {
pub ssl_transaction_type: TransactionType,
pub ssl_account_id: Secret<String>,
pub ssl_user_id: Secret<String>,
pub ssl_pin: Secret<String>,
pub ssl_amount: StringMajorUnit,
pub ssl_txn_id: String,
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
TryFrom<
ElavonRouterData<RouterDataV2<Refund, RefundFlowData, RefundsData, RefundsResponseData>, T>,
> for ElavonRefundRequest
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: ElavonRouterData<
RouterDataV2<Refund, RefundFlowData, RefundsData, RefundsResponseData>,
T,
>,
) -> Result<Self, Self::Error> {
let router_data = item.router_data;
let request_data = &router_data.request;
let auth_type = ElavonAuthType::try_from(&router_data.connector_auth_type)?;
// Convert amount for refund
let amount_converter = StringMajorUnitForConnector;
let amount = amount_converter
.convert(request_data.minor_refund_amount, request_data.currency)
.map_err(|_| errors::ConnectorError::RequestEncodingFailed)?;
Ok(Self {
ssl_transaction_type: TransactionType::CcReturn,
ssl_account_id: auth_type.ssl_merchant_id,
ssl_user_id: auth_type.ssl_user_id,
ssl_pin: auth_type.ssl_pin,
ssl_amount: amount,
ssl_txn_id: request_data.connector_transaction_id.clone(),
})
}
}
// Implementation for XMLRefundRequest
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
TryFrom<
ElavonRouterData<RouterDataV2<Refund, RefundFlowData, RefundsData, RefundsResponseData>, T>,
| {
"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_-2910212303359634675_10 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/elavon/transformers.rs
> for XMLRefundRequest
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
data: ElavonRouterData<
RouterDataV2<Refund, RefundFlowData, RefundsData, RefundsResponseData>,
T,
>,
) -> Result<Self, Self::Error> {
// Create the ElavonRefundRequest
let request = ElavonRefundRequest::try_from(data)
.change_context(errors::ConnectorError::RequestEncodingFailed)
.attach_printable("Failed to create ElavonRefundRequest")?;
// Generate XML content
let xml_content = quick_xml::se::to_string_with_root("txn", &request)
.map_err(|_| errors::ConnectorError::RequestEncodingFailed)?;
// Create the form data HashMap
let mut result = HashMap::new();
result.insert(
"xmldata".to_string(),
Secret::<_, WithoutType>::new(xml_content),
);
Ok(XMLRefundRequest(result))
}
}
// Response handling for Refund flow
impl<F> TryFrom<ResponseRouterData<ElavonRefundResponse, Self>>
for RouterDataV2<F, RefundFlowData, RefundsData, RefundsResponseData>
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
value: ResponseRouterData<ElavonRefundResponse, Self>,
) -> Result<Self, Self::Error> {
let ResponseRouterData {
response,
router_data,
http_code,
} = value;
let (attempt_status, error_response) =
get_elavon_attempt_status(&response.result, http_code);
// Determine refund status
let refund_status = match &response.result {
ElavonResult::Success(success_payload) => {
match success_payload.ssl_transaction_type.as_deref() {
Some("RETURN") => match success_payload.ssl_result {
SslResult::Approved => common_enums::RefundStatus::Success,
SslResult::Declined => common_enums::RefundStatus::Failure,
SslResult::Other(_) => common_enums::RefundStatus::Pending,
},
_ => common_enums::RefundStatus::Pending,
}
}
_ => common_enums::RefundStatus::Failure,
};
// Build the response data
let response_data = match (&response.result, error_response) {
(ElavonResult::Success(payment_resp_struct), None) => Ok(RefundsResponseData {
connector_refund_id: payment_resp_struct.ssl_txn_id.clone(),
refund_status,
status_code: http_code,
}),
(_, Some(err_resp)) => Err(err_resp),
(ElavonResult::Error(error_payload), None) => Err(ErrorResponse {
status_code: http_code,
code: error_payload
.error_code
.clone()
.unwrap_or_else(|| NO_ERROR_CODE.to_string()),
message: error_payload.error_message.clone(),
reason: error_payload.error_name.clone(),
attempt_status: Some(attempt_status),
connector_transaction_id: error_payload.ssl_txn_id.clone(),
network_decline_code: None,
network_advice_code: None,
network_error_message: None,
}),
};
Ok(Self {
response: response_data,
resource_common_data: RefundFlowData {
status: refund_status,
..router_data.resource_common_data
},
..router_data
})
}
}
// Implementation for Refund Sync
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
TryFrom<
ElavonRouterData<
RouterDataV2<RSync, RefundFlowData, RefundSyncData, RefundsResponseData>,
T,
>,
> for SyncRequest
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: ElavonRouterData<
RouterDataV2<RSync, RefundFlowData, RefundSyncData, RefundsResponseData>,
T,
>,
) -> Result<Self, Self::Error> {
Self::try_from(&item.router_data)
}
}
| {
"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_-2910212303359634675_11 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/elavon/transformers.rs
impl TryFrom<&RouterDataV2<RSync, RefundFlowData, RefundSyncData, RefundsResponseData>>
for SyncRequest
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
router_data: &RouterDataV2<RSync, RefundFlowData, RefundSyncData, RefundsResponseData>,
) -> Result<Self, Self::Error> {
let auth_type = ElavonAuthType::try_from(&router_data.connector_auth_type)?;
let connector_refund_id = router_data.request.connector_refund_id.clone();
Ok(Self {
ssl_transaction_type: TransactionType::TxnQuery,
ssl_account_id: auth_type.ssl_merchant_id,
ssl_user_id: auth_type.ssl_user_id,
ssl_pin: auth_type.ssl_pin,
ssl_txn_id: connector_refund_id,
})
}
}
// Implementation for XMLRSyncRequest
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
TryFrom<
ElavonRouterData<
RouterDataV2<RSync, RefundFlowData, RefundSyncData, RefundsResponseData>,
T,
>,
> for XMLRSyncRequest
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
data: ElavonRouterData<
RouterDataV2<RSync, RefundFlowData, RefundSyncData, RefundsResponseData>,
T,
>,
) -> Result<Self, Self::Error> {
// Create the SyncRequest
let request = SyncRequest::try_from(data)
.change_context(errors::ConnectorError::RequestEncodingFailed)
.attach_printable("Failed to create SyncRequest for RSync")?;
// Generate XML content
let xml_content = quick_xml::se::to_string_with_root("txn", &request)
.map_err(|_| errors::ConnectorError::RequestEncodingFailed)?;
// Create the form data HashMap
let mut result = HashMap::new();
result.insert(
"xmldata".to_string(),
Secret::<_, WithoutType>::new(xml_content),
);
Ok(XMLRSyncRequest(result))
}
}
// Define RSync response type
#[derive(Debug, Deserialize, Serialize, Clone)]
pub struct ElavonRSyncResponse {
pub ssl_trans_status: TransactionSyncStatus,
pub ssl_transaction_type: SyncTransactionType,
pub ssl_txn_id: String,
}
// Function to determine refund status from RSync response
pub fn get_refund_status_from_elavon_sync_response(
elavon_response: &ElavonRSyncResponse,
) -> common_enums::RefundStatus {
match elavon_response.ssl_transaction_type {
SyncTransactionType::Return => match elavon_response.ssl_trans_status {
TransactionSyncStatus::STL => common_enums::RefundStatus::Success,
TransactionSyncStatus::PEN => common_enums::RefundStatus::Pending,
TransactionSyncStatus::OPN => common_enums::RefundStatus::Pending,
TransactionSyncStatus::REV => common_enums::RefundStatus::ManualReview,
TransactionSyncStatus::PST
| TransactionSyncStatus::FPR
| TransactionSyncStatus::PRE => common_enums::RefundStatus::Failure,
},
_ => common_enums::RefundStatus::Pending,
}
}
// Response handling for RSync flow
impl<F> TryFrom<ResponseRouterData<ElavonRSyncResponse, Self>>
for RouterDataV2<F, RefundFlowData, RefundSyncData, RefundsResponseData>
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(value: ResponseRouterData<ElavonRSyncResponse, Self>) -> Result<Self, Self::Error> {
let ResponseRouterData {
response,
router_data,
http_code: _,
} = value;
let refund_status = get_refund_status_from_elavon_sync_response(&response);
let response_data = RefundsResponseData {
connector_refund_id: response.ssl_txn_id.clone(),
refund_status,
status_code: value.http_code,
};
Ok(Self {
response: Ok(response_data),
resource_common_data: RefundFlowData {
status: refund_status,
..router_data.resource_common_data
},
..router_data
})
}
}
#[derive(Debug, Deserialize, Serialize, Clone)]
pub struct ElavonPSyncResponse {
pub ssl_trans_status: TransactionSyncStatus,
| {
"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_-2910212303359634675_12 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/elavon/transformers.rs
pub ssl_transaction_type: SyncTransactionType,
pub ssl_txn_id: String,
}
#[derive(Debug, Serialize, Deserialize, Clone, PartialEq)]
pub enum TransactionSyncStatus {
PEN,
OPN,
REV,
STL,
PST,
FPR,
PRE,
}
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq)]
#[serde(rename_all = "UPPERCASE")]
pub enum SyncTransactionType {
Sale,
AuthOnly,
Return,
}
impl<F> TryFrom<ResponseRouterData<ElavonPSyncResponse, Self>>
for RouterDataV2<F, PaymentFlowData, PaymentsSyncData, PaymentsResponseData>
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(value: ResponseRouterData<ElavonPSyncResponse, Self>) -> Result<Self, Self::Error> {
let ResponseRouterData {
response,
router_data,
http_code: _,
} = value;
let final_status = match response.ssl_trans_status {
TransactionSyncStatus::STL => match response.ssl_transaction_type {
SyncTransactionType::Sale => HyperswitchAttemptStatus::Charged,
SyncTransactionType::AuthOnly => HyperswitchAttemptStatus::Charged,
SyncTransactionType::Return => HyperswitchAttemptStatus::Pending,
},
TransactionSyncStatus::OPN => match response.ssl_transaction_type {
SyncTransactionType::AuthOnly => HyperswitchAttemptStatus::Authorized,
SyncTransactionType::Sale => HyperswitchAttemptStatus::Pending,
SyncTransactionType::Return => HyperswitchAttemptStatus::Pending,
},
TransactionSyncStatus::PEN | TransactionSyncStatus::REV => {
HyperswitchAttemptStatus::Pending
}
TransactionSyncStatus::PST
| TransactionSyncStatus::FPR
| TransactionSyncStatus::PRE => {
if response.ssl_transaction_type == SyncTransactionType::AuthOnly
&& response.ssl_trans_status == TransactionSyncStatus::PRE
{
HyperswitchAttemptStatus::AuthenticationFailed
} else {
HyperswitchAttemptStatus::Failure
}
}
};
let payments_response_data = PaymentsResponseData::TransactionResponse {
resource_id: DomainResponseId::ConnectorTransactionId(response.ssl_txn_id.clone()),
redirection_data: None,
connector_metadata: Some(serde_json::json!(response)),
network_txn_id: None,
connector_response_reference_id: None,
incremental_authorization_allowed: None,
mandate_reference: None,
status_code: value.http_code,
};
Ok(RouterDataV2 {
response: Ok(payments_response_data),
resource_common_data: PaymentFlowData {
status: final_status,
..router_data.resource_common_data
},
..router_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_-7118378565780451163_0 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/phonepe/constants.rs
//! Constants for PhonePe connector
// ===== API ENDPOINTS =====
pub const API_PAY_ENDPOINT: &str = "pg/v1/pay";
pub const API_STATUS_ENDPOINT: &str = "pg/v1/status";
// ===== UPI INSTRUMENT TYPES =====
pub const UPI_INTENT: &str = "UPI_INTENT";
pub const UPI_COLLECT: &str = "UPI_COLLECT";
pub const UPI_QR: &str = "UPI_QR";
// ===== DEFAULT VALUES =====
pub const DEFAULT_KEY_INDEX: &str = "1";
pub const DEFAULT_DEVICE_OS: &str = "Android";
pub const DEFAULT_IP: &str = "127.0.0.1";
pub const DEFAULT_USER_AGENT: &str = "Mozilla/5.0";
// ===== CHECKSUM =====
pub const CHECKSUM_SEPARATOR: &str = "###";
// ===== CONTENT TYPES =====
pub const APPLICATION_JSON: &str = "application/json";
| {
"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_3522933810268649801_0 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/phonepe/transformers.rs
use base64::Engine;
use common_enums;
use common_utils::{
crypto::{self, GenerateDigest},
ext_traits::Encode,
types::MinorUnit,
};
use domain_types::{
connector_flow::{Authorize, PSync},
connector_types::{
PaymentFlowData, PaymentsAuthorizeData, PaymentsResponseData, PaymentsSyncData, ResponseId,
},
errors,
payment_method_data::{PaymentMethodData, PaymentMethodDataTypes, UpiData},
router_data::ConnectorAuthType,
router_data_v2::RouterDataV2,
router_response_types::RedirectForm,
};
use error_stack::ResultExt;
use hyperswitch_masking::{PeekInterface, Secret};
use serde::{Deserialize, Serialize};
use super::constants;
use crate::{connectors::phonepe::PhonepeRouterData, types::ResponseRouterData};
type Error = error_stack::Report<errors::ConnectorError>;
// ===== AMOUNT CONVERSION =====
// Using macro-generated PhonepeRouterData from crate::connectors::phonepe
// ===== REQUEST STRUCTURES =====
#[derive(Debug, Serialize)]
pub struct PhonepePaymentsRequest {
request: Secret<String>,
#[serde(skip)]
pub checksum: String,
}
#[derive(Debug, Serialize)]
struct PhonepePaymentRequestPayload {
#[serde(rename = "merchantId")]
merchant_id: Secret<String>,
#[serde(rename = "merchantTransactionId")]
merchant_transaction_id: String,
#[serde(rename = "merchantUserId", skip_serializing_if = "Option::is_none")]
merchant_user_id: Option<Secret<String>>,
amount: MinorUnit,
#[serde(rename = "callbackUrl")]
callback_url: String,
#[serde(rename = "mobileNumber", skip_serializing_if = "Option::is_none")]
mobile_number: Option<Secret<String>>,
#[serde(rename = "paymentInstrument")]
payment_instrument: PhonepePaymentInstrument,
#[serde(rename = "deviceContext", skip_serializing_if = "Option::is_none")]
device_context: Option<PhonepeDeviceContext>,
}
#[derive(Debug, Serialize)]
struct PhonepeDeviceContext {
#[serde(rename = "deviceOS", skip_serializing_if = "Option::is_none")]
device_os: Option<String>,
}
#[derive(Debug, Serialize)]
struct PhonepePaymentInstrument {
#[serde(rename = "type")]
instrument_type: String,
#[serde(rename = "targetApp", skip_serializing_if = "Option::is_none")]
target_app: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
vpa: Option<Secret<String>>,
}
// ===== SYNC REQUEST STRUCTURES =====
#[derive(Debug, Serialize)]
pub struct PhonepeSyncRequest {
#[serde(skip)]
pub merchant_transaction_id: String,
#[serde(skip)]
pub checksum: String,
}
// ===== RESPONSE STRUCTURES =====
#[derive(Debug, Deserialize, Serialize)]
pub struct PhonepeErrorResponse {
pub success: bool,
pub code: String,
#[serde(default = "default_error_message")]
pub message: String,
}
#[derive(Debug, Deserialize, Serialize)]
pub struct PhonepePaymentsResponse {
pub success: bool,
pub code: String,
pub message: String,
pub data: Option<PhonepeResponseData>,
}
#[derive(Debug, Deserialize, Serialize)]
pub struct PhonepeSyncResponse {
pub success: bool,
pub code: String,
#[serde(default = "default_sync_error_message")]
pub message: String,
#[serde(default)]
pub data: Option<PhonepeSyncResponseData>,
}
fn default_error_message() -> String {
"Payment processing failed".to_string()
}
fn default_sync_error_message() -> String {
"Payment sync failed".to_string()
}
#[derive(Debug, Deserialize, Serialize)]
pub struct PhonepeResponseData {
#[serde(rename = "merchantId")]
merchant_id: String,
#[serde(rename = "merchantTransactionId")]
merchant_transaction_id: String,
#[serde(rename = "transactionId", skip_serializing_if = "Option::is_none")]
transaction_id: Option<String>,
#[serde(rename = "instrumentResponse", skip_serializing_if = "Option::is_none")]
instrument_response: Option<PhonepeInstrumentResponse>,
#[serde(rename = "responseCode", skip_serializing_if = "Option::is_none")]
response_code: Option<String>,
#[serde(
rename = "responseCodeDescription",
skip_serializing_if = "Option::is_none"
)]
response_code_description: Option<String>,
}
#[derive(Debug, Deserialize, Serialize)]
pub struct PhonepeInstrumentResponse {
#[serde(rename = "type")]
instrument_type: String,
#[serde(rename = "intentUrl", skip_serializing_if = "Option::is_none")]
| {
"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_3522933810268649801_1 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/phonepe/transformers.rs
intent_url: Option<String>,
#[serde(rename = "qrData", skip_serializing_if = "Option::is_none")]
qr_data: Option<String>,
}
#[derive(Debug, Deserialize, Serialize)]
pub struct PhonepeSyncResponseData {
#[serde(rename = "merchantId", skip_serializing_if = "Option::is_none")]
merchant_id: Option<String>,
#[serde(
rename = "merchantTransactionId",
skip_serializing_if = "Option::is_none"
)]
merchant_transaction_id: Option<String>,
#[serde(rename = "transactionId", skip_serializing_if = "Option::is_none")]
transaction_id: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
amount: Option<MinorUnit>,
#[serde(skip_serializing_if = "Option::is_none")]
state: Option<String>,
#[serde(rename = "responseCode", skip_serializing_if = "Option::is_none")]
response_code: Option<String>,
#[serde(rename = "paymentInstrument", skip_serializing_if = "Option::is_none")]
payment_instrument: Option<serde_json::Value>,
}
// ===== REQUEST BUILDING =====
// TryFrom implementation for macro-generated PhonepeRouterData wrapper (owned)
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
TryFrom<
PhonepeRouterData<
RouterDataV2<
Authorize,
PaymentFlowData,
PaymentsAuthorizeData<T>,
PaymentsResponseData,
>,
T,
>,
> for PhonepePaymentsRequest
{
type Error = Error;
fn try_from(
wrapper: PhonepeRouterData<
RouterDataV2<
Authorize,
PaymentFlowData,
PaymentsAuthorizeData<T>,
PaymentsResponseData,
>,
T,
>,
) -> Result<Self, Self::Error> {
let router_data = &wrapper.router_data;
let auth = PhonepeAuthType::try_from(&router_data.connector_auth_type)?;
// Use amount converter to get proper amount in minor units
let amount_in_minor_units = wrapper
.connector
.amount_converter
.convert(
router_data.request.minor_amount,
router_data.request.currency,
)
.change_context(errors::ConnectorError::RequestEncodingFailed)?;
// Get customer mobile number from billing address
let mobile_number = router_data
.resource_common_data
.get_optional_billing_phone_number()
.map(|phone| Secret::new(phone.peek().to_string()));
// Create payment instrument based on payment method data
let payment_instrument = match &router_data.request.payment_method_data {
PaymentMethodData::Upi(upi_data) => match upi_data {
UpiData::UpiIntent(_) => PhonepePaymentInstrument {
instrument_type: constants::UPI_INTENT.to_string(),
target_app: None, // Could be extracted from payment method details if needed
vpa: None,
},
UpiData::UpiQr(_) => PhonepePaymentInstrument {
instrument_type: constants::UPI_QR.to_string(),
target_app: None,
vpa: None,
},
UpiData::UpiCollect(collect_data) => PhonepePaymentInstrument {
instrument_type: constants::UPI_COLLECT.to_string(),
target_app: None,
vpa: collect_data
.vpa_id
.as_ref()
.map(|vpa| Secret::new(vpa.peek().to_string())),
},
},
_ => {
return Err(errors::ConnectorError::NotSupported {
message: "Payment method not supported".to_string(),
connector: "Phonepe",
}
.into())
}
};
// For UPI Intent, add device context with proper OS detection
let device_context = match &router_data.request.payment_method_data {
PaymentMethodData::Upi(UpiData::UpiIntent(_)) => {
let device_os = match router_data
.request
| {
"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_3522933810268649801_2 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/phonepe/transformers.rs
.browser_info
.as_ref()
.and_then(|info| info.os_type.clone())
.unwrap_or_else(|| constants::DEFAULT_DEVICE_OS.to_string())
.to_uppercase()
.as_str()
{
"IOS" | "IPHONE" | "IPAD" | "MACOS" | "DARWIN" => "IOS".to_string(),
"ANDROID" => "ANDROID".to_string(),
_ => "ANDROID".to_string(), // Default to ANDROID for unknown OS
};
Some(PhonepeDeviceContext {
device_os: Some(device_os),
})
}
_ => None,
};
// Build payload
let payload = PhonepePaymentRequestPayload {
merchant_id: auth.merchant_id.clone(),
merchant_transaction_id: router_data
.resource_common_data
.connector_request_reference_id
.clone(),
merchant_user_id: router_data
.resource_common_data
.customer_id
.clone()
.map(|id| Secret::new(id.get_string_repr().to_string())),
amount: amount_in_minor_units,
callback_url: router_data.request.get_webhook_url()?,
mobile_number,
payment_instrument,
device_context,
};
// Convert to JSON and encode
let json_payload = Encode::encode_to_string_of_json(&payload)
.change_context(errors::ConnectorError::RequestEncodingFailed)?;
// Base64 encode the payload
let base64_payload = base64::engine::general_purpose::STANDARD.encode(&json_payload);
// Generate checksum
let api_path = format!("/{}", constants::API_PAY_ENDPOINT);
let checksum =
generate_phonepe_checksum(&base64_payload, &api_path, &auth.salt_key, &auth.key_index)?;
Ok(Self {
request: Secret::new(base64_payload),
checksum,
})
}
}
// TryFrom implementation for borrowed PhonepeRouterData wrapper (for header generation)
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
TryFrom<
&PhonepeRouterData<
&RouterDataV2<
Authorize,
PaymentFlowData,
PaymentsAuthorizeData<T>,
PaymentsResponseData,
>,
T,
>,
> for PhonepePaymentsRequest
{
type Error = Error;
fn try_from(
item: &PhonepeRouterData<
&RouterDataV2<
Authorize,
PaymentFlowData,
PaymentsAuthorizeData<T>,
PaymentsResponseData,
>,
T,
>,
) -> Result<Self, Self::Error> {
let router_data = item.router_data;
let auth = PhonepeAuthType::try_from(&router_data.connector_auth_type)?;
// Use amount converter to get proper amount in minor units
let amount_in_minor_units = item
.connector
.amount_converter
.convert(
router_data.request.minor_amount,
router_data.request.currency,
)
.change_context(errors::ConnectorError::RequestEncodingFailed)?;
// Get customer mobile number from billing address
let mobile_number = router_data
.resource_common_data
.get_optional_billing_phone_number()
.map(|phone| Secret::new(phone.peek().to_string()));
// Create payment instrument based on payment method data
let payment_instrument = match &router_data.request.payment_method_data {
PaymentMethodData::Upi(upi_data) => match upi_data {
UpiData::UpiIntent(_) => PhonepePaymentInstrument {
instrument_type: constants::UPI_INTENT.to_string(),
target_app: None, // Could be extracted from payment method details if needed
vpa: None,
},
UpiData::UpiQr(_) => PhonepePaymentInstrument {
instrument_type: constants::UPI_QR.to_string(),
target_app: 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_3522933810268649801_3 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/phonepe/transformers.rs
vpa: None,
},
UpiData::UpiCollect(collect_data) => PhonepePaymentInstrument {
instrument_type: constants::UPI_COLLECT.to_string(),
target_app: None,
vpa: collect_data
.vpa_id
.as_ref()
.map(|vpa| Secret::new(vpa.peek().to_string())),
},
},
_ => {
return Err(errors::ConnectorError::NotSupported {
message: "Payment method not supported".to_string(),
connector: "Phonepe",
}
.into())
}
};
// For UPI Intent, add device context with proper OS detection
let device_context = match &router_data.request.payment_method_data {
PaymentMethodData::Upi(UpiData::UpiIntent(_)) => {
let device_os = match router_data
.request
.browser_info
.as_ref()
.and_then(|info| info.os_type.clone())
.unwrap_or_else(|| constants::DEFAULT_DEVICE_OS.to_string())
.to_uppercase()
.as_str()
{
"IOS" | "IPHONE" | "IPAD" | "MACOS" | "DARWIN" => "IOS".to_string(),
"ANDROID" => "ANDROID".to_string(),
_ => "ANDROID".to_string(), // Default to ANDROID for unknown OS
};
Some(PhonepeDeviceContext {
device_os: Some(device_os),
})
}
_ => None,
};
// Build payload
let payload = PhonepePaymentRequestPayload {
merchant_id: auth.merchant_id.clone(),
merchant_transaction_id: router_data
.resource_common_data
.connector_request_reference_id
.clone(),
merchant_user_id: router_data
.resource_common_data
.customer_id
.clone()
.map(|id| Secret::new(id.get_string_repr().to_string())),
amount: amount_in_minor_units,
callback_url: router_data.request.get_webhook_url()?,
mobile_number,
payment_instrument,
device_context,
};
// Convert to JSON and encode
let json_payload = Encode::encode_to_string_of_json(&payload)
.change_context(errors::ConnectorError::RequestEncodingFailed)?;
// Base64 encode the payload
let base64_payload = base64::engine::general_purpose::STANDARD.encode(&json_payload);
// Generate checksum
let api_path = format!("/{}", constants::API_PAY_ENDPOINT);
let checksum =
generate_phonepe_checksum(&base64_payload, &api_path, &auth.salt_key, &auth.key_index)?;
Ok(Self {
request: Secret::new(base64_payload),
checksum,
})
}
}
// ===== RESPONSE HANDLING =====
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
TryFrom<
ResponseRouterData<
PhonepePaymentsResponse,
RouterDataV2<
Authorize,
PaymentFlowData,
PaymentsAuthorizeData<T>,
PaymentsResponseData,
>,
>,
> for RouterDataV2<Authorize, PaymentFlowData, PaymentsAuthorizeData<T>, PaymentsResponseData>
{
type Error = Error;
fn try_from(
item: ResponseRouterData<
PhonepePaymentsResponse,
RouterDataV2<
Authorize,
PaymentFlowData,
PaymentsAuthorizeData<T>,
PaymentsResponseData,
>,
>,
) -> Result<Self, Self::Error> {
let response = &item.response;
if response.success {
if let Some(data) = &response.data {
if let Some(instrument_response) = &data.instrument_response {
// Handle different UPI flow responses
let (redirect_form, connector_metadata) =
| {
"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_3522933810268649801_4 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/phonepe/transformers.rs
match instrument_response.instrument_type.as_str() {
instrument_type if instrument_type == constants::UPI_INTENT => {
let redirect_form = instrument_response
.intent_url
.as_ref()
.map(|url| RedirectForm::Uri { uri: url.clone() });
(redirect_form, None)
}
instrument_type if instrument_type == constants::UPI_QR => {
let redirect_form = instrument_response
.intent_url
.as_ref()
.map(|url| RedirectForm::Uri { uri: url.clone() });
let connector_metadata =
instrument_response.qr_data.as_ref().map(|qr| {
serde_json::json!({
"qr_data": qr
})
});
(redirect_form, connector_metadata)
}
_ => (None, None),
};
Ok(Self {
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: match &data.transaction_id {
Some(txn_id) => ResponseId::ConnectorTransactionId(txn_id.clone()),
None => ResponseId::NoResponseId,
},
redirection_data: redirect_form.map(Box::new),
mandate_reference: None,
connector_metadata,
network_txn_id: None,
connector_response_reference_id: Some(
data.merchant_transaction_id.clone(),
),
incremental_authorization_allowed: None,
status_code: item.http_code,
}),
resource_common_data: PaymentFlowData {
status: common_enums::AttemptStatus::AuthenticationPending,
..item.router_data.resource_common_data
},
..item.router_data
})
} else {
// Success but no instrument response
Ok(Self {
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: match &data.transaction_id {
Some(txn_id) => ResponseId::ConnectorTransactionId(txn_id.clone()),
None => ResponseId::NoResponseId,
},
redirection_data: None,
mandate_reference: None,
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: Some(
data.merchant_transaction_id.clone(),
),
incremental_authorization_allowed: None,
status_code: item.http_code,
}),
..item.router_data
})
}
} else {
Err(errors::ConnectorError::ResponseDeserializationFailed.into())
}
} else {
// Error response - PhonePe returned success: false
let error_message = response.message.clone();
let error_code = response.code.clone();
tracing::warn!(
"PhonePe payment failed - Code: {}, Message: {}, Status: {}",
error_code,
error_message,
item.http_code
);
// Get merchant transaction ID from data if available for better tracking
| {
"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_3522933810268649801_5 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/phonepe/transformers.rs
let connector_transaction_id = response
.data
.as_ref()
.map(|data| data.merchant_transaction_id.clone());
// Map specific PhonePe error codes to attempt status if needed
let attempt_status = match error_code.as_str() {
"INVALID_TRANSACTION_ID" => Some(common_enums::AttemptStatus::Failure),
"TRANSACTION_NOT_FOUND" => Some(common_enums::AttemptStatus::Failure),
"INVALID_REQUEST" => Some(common_enums::AttemptStatus::Failure),
"INTERNAL_SERVER_ERROR" => Some(common_enums::AttemptStatus::Failure),
"PAYMENT_PENDING" => Some(common_enums::AttemptStatus::Pending),
"PAYMENT_DECLINED" => Some(common_enums::AttemptStatus::Failure),
_ => Some(common_enums::AttemptStatus::Pending),
};
tracing::warn!(
"PhonePe payment failed - Code: {}, Message: {}, Status: {}",
error_code,
error_message,
item.http_code
);
Ok(Self {
response: Err(domain_types::router_data::ErrorResponse {
code: error_code,
message: error_message.clone(),
reason: Some(error_message),
status_code: item.http_code,
attempt_status,
connector_transaction_id,
network_decline_code: None,
network_advice_code: None,
network_error_message: None,
}),
..item.router_data
})
}
}
}
// ===== AUTHENTICATION =====
#[derive(Debug)]
pub struct PhonepeAuthType {
pub merchant_id: Secret<String>,
pub salt_key: Secret<String>,
pub key_index: String,
}
impl TryFrom<&ConnectorAuthType> for PhonepeAuthType {
type Error = Error;
fn try_from(auth_type: &ConnectorAuthType) -> Result<Self, Self::Error> {
match auth_type {
ConnectorAuthType::SignatureKey {
api_key,
key1,
api_secret,
} => Ok(Self {
merchant_id: api_key.clone(),
salt_key: key1.clone(),
key_index: api_secret.peek().clone(), // Use api_secret for key index
}),
_ => Err(errors::ConnectorError::FailedToObtainAuthType.into()),
}
}
}
// ===== HELPER FUNCTIONS =====
fn generate_phonepe_checksum(
base64_payload: &str,
api_path: &str,
salt_key: &Secret<String>,
key_index: &str,
) -> Result<String, Error> {
// PhonePe checksum algorithm: SHA256(base64Payload + apiPath + saltKey) + "###" + keyIndex
let checksum_input = format!("{}{}{}", base64_payload, api_path, salt_key.peek());
let sha256 = crypto::Sha256;
let hash_bytes = sha256
.generate_digest(checksum_input.as_bytes())
.change_context(errors::ConnectorError::RequestEncodingFailed)?;
let hash = hash_bytes.iter().fold(String::new(), |mut acc, byte| {
use std::fmt::Write;
write!(&mut acc, "{byte:02x}").unwrap();
acc
});
// Format: hash###keyIndex
Ok(format!(
"{}{}{}",
hash,
constants::CHECKSUM_SEPARATOR,
key_index
))
}
// ===== SYNC REQUEST BUILDING =====
// TryFrom implementation for owned PhonepeRouterData wrapper (sync)
impl<
T: domain_types::payment_method_data::PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ serde::Serialize,
>
TryFrom<
PhonepeRouterData<
RouterDataV2<PSync, PaymentFlowData, PaymentsSyncData, PaymentsResponseData>,
T,
>,
> for PhonepeSyncRequest
{
type Error = Error;
fn try_from(
wrapper: PhonepeRouterData<
RouterDataV2<PSync, PaymentFlowData, PaymentsSyncData, PaymentsResponseData>,
T,
>,
) -> Result<Self, Self::Error> {
let router_data = &wrapper.router_data;
let auth = PhonepeAuthType::try_from(&router_data.connector_auth_type)?;
let merchant_transaction_id = &router_data
.resource_common_data
.connector_request_reference_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
} |
connector-service_mini_connector-integration_3522933810268649801_6 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/phonepe/transformers.rs
// Generate checksum for status API
let api_path = format!(
"/{}/{}/{}",
constants::API_STATUS_ENDPOINT,
auth.merchant_id.peek(),
merchant_transaction_id
);
let checksum = generate_phonepe_sync_checksum(&api_path, &auth.salt_key, &auth.key_index)?;
Ok(Self {
merchant_transaction_id: merchant_transaction_id.clone(),
checksum,
})
}
}
// TryFrom implementation for borrowed PhonepeRouterData wrapper (sync header generation)
impl<
T: domain_types::payment_method_data::PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ serde::Serialize,
>
TryFrom<
&PhonepeRouterData<
&RouterDataV2<PSync, PaymentFlowData, PaymentsSyncData, PaymentsResponseData>,
T,
>,
> for PhonepeSyncRequest
{
type Error = Error;
fn try_from(
item: &PhonepeRouterData<
&RouterDataV2<PSync, PaymentFlowData, PaymentsSyncData, PaymentsResponseData>,
T,
>,
) -> Result<Self, Self::Error> {
let router_data = item.router_data;
let auth = PhonepeAuthType::try_from(&router_data.connector_auth_type)?;
let merchant_transaction_id = &router_data
.resource_common_data
.connector_request_reference_id;
// Generate checksum for status API
let api_path = format!(
"/{}/{}/{}",
constants::API_STATUS_ENDPOINT,
auth.merchant_id.peek(),
merchant_transaction_id
);
let checksum = generate_phonepe_sync_checksum(&api_path, &auth.salt_key, &auth.key_index)?;
Ok(Self {
merchant_transaction_id: merchant_transaction_id.clone(),
checksum,
})
}
}
// ===== SYNC RESPONSE HANDLING =====
impl
TryFrom<
ResponseRouterData<
PhonepeSyncResponse,
RouterDataV2<PSync, PaymentFlowData, PaymentsSyncData, PaymentsResponseData>,
>,
> for RouterDataV2<PSync, PaymentFlowData, PaymentsSyncData, PaymentsResponseData>
{
type Error = Error;
fn try_from(
item: ResponseRouterData<
PhonepeSyncResponse,
RouterDataV2<PSync, PaymentFlowData, PaymentsSyncData, PaymentsResponseData>,
>,
) -> Result<Self, Self::Error> {
let response = &item.response;
if response.success {
if let Some(data) = &response.data {
// Check if we have required fields for a successful transaction
if let (Some(merchant_transaction_id), Some(transaction_id)) =
(&data.merchant_transaction_id, &data.transaction_id)
{
// Map PhonePe response codes to payment statuses based on documentation
let status = match response.code.as_str() {
"PAYMENT_SUCCESS" => common_enums::AttemptStatus::Charged,
"PAYMENT_PENDING" => common_enums::AttemptStatus::Pending,
"PAYMENT_ERROR" | "PAYMENT_DECLINED" | "TIMED_OUT" => {
common_enums::AttemptStatus::Failure
}
"BAD_REQUEST" | "AUTHORIZATION_FAILED" | "TRANSACTION_NOT_FOUND" => {
common_enums::AttemptStatus::Failure
}
"INTERNAL_SERVER_ERROR" => common_enums::AttemptStatus::Pending, // Requires retry per docs
_ => common_enums::AttemptStatus::Pending, // Default to pending for unknown codes
};
Ok(Self {
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(transaction_id.clone()),
redirection_data: None,
mandate_reference: None,
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: Some(merchant_transaction_id.clone()),
| {
"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_3522933810268649801_7 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/phonepe/transformers.rs
incremental_authorization_allowed: None,
status_code: item.http_code,
}),
resource_common_data: PaymentFlowData {
status,
..item.router_data.resource_common_data
},
..item.router_data
})
} else {
// Data object exists but missing required fields - treat as error
Ok(Self {
response: Err(domain_types::router_data::ErrorResponse {
code: response.code.clone(),
message: response.message.clone(),
reason: None,
status_code: item.http_code,
attempt_status: Some(common_enums::AttemptStatus::Failure),
connector_transaction_id: data.transaction_id.clone(),
network_decline_code: None,
network_advice_code: None,
network_error_message: None,
}),
..item.router_data
})
}
} else {
Err(errors::ConnectorError::ResponseDeserializationFailed.into())
}
} else {
// Error response from sync API - handle specific PhonePe error codes
let error_message = response.message.clone();
let error_code = response.code.clone();
// Map PhonePe error codes to attempt status
let attempt_status = get_phonepe_error_status(&error_code);
Ok(Self {
response: Err(domain_types::router_data::ErrorResponse {
code: error_code,
message: error_message,
reason: None,
status_code: item.http_code,
attempt_status,
connector_transaction_id: response
.data
.as_ref()
.and_then(|data| data.transaction_id.clone()),
network_decline_code: None,
network_advice_code: None,
network_error_message: None,
}),
..item.router_data
})
}
}
}
fn generate_phonepe_sync_checksum(
api_path: &str,
salt_key: &Secret<String>,
key_index: &str,
) -> Result<String, Error> {
// PhonePe sync checksum algorithm: SHA256(apiPath + saltKey) + "###" + keyIndex
let checksum_input = format!("{}{}", api_path, salt_key.peek());
let sha256 = crypto::Sha256;
let hash_bytes = sha256
.generate_digest(checksum_input.as_bytes())
.change_context(errors::ConnectorError::RequestEncodingFailed)?;
let hash = hash_bytes.iter().fold(String::new(), |mut acc, byte| {
use std::fmt::Write;
write!(&mut acc, "{byte:02x}").unwrap();
acc
});
// Format: hash###keyIndex
Ok(format!(
"{}{}{}",
hash,
constants::CHECKSUM_SEPARATOR,
key_index
))
}
pub fn get_phonepe_error_status(error_code: &str) -> Option<common_enums::AttemptStatus> {
match error_code {
"TRANSACTION_NOT_FOUND" => Some(common_enums::AttemptStatus::Failure),
"401" => Some(common_enums::AttemptStatus::AuthenticationFailed),
"400" | "BAD_REQUEST" => Some(common_enums::AttemptStatus::Failure),
"PAYMENT_ERROR" | "PAYMENT_DECLINED" | "TIMED_OUT" => {
Some(common_enums::AttemptStatus::Failure)
}
"AUTHORIZATION_FAILED" => Some(common_enums::AttemptStatus::AuthenticationFailed),
_ => None,
}
}
| {
"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_6052179881447595478_0 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/phonepe/headers.rs
//! Header constants for PhonePe connector
pub const CONTENT_TYPE: &str = "Content-Type";
pub const AUTHORIZATION: &str = "Authorization";
pub const X_VERIFY: &str = "X-VERIFY";
pub const X_MERCHANT_ID: &str = "X-MERCHANT-ID";
| {
"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_353540475883723703_0 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/novalnet/transformers.rs
use std::collections::HashMap;
use cards::CardNumber;
use common_utils::{
ext_traits::OptionExt,
pii,
request::Method,
types::{MinorUnit, StringMinorUnit},
};
use domain_types::{
connector_flow::{self, Authorize, PSync, RSync, RepeatPayment, SetupMandate, Void},
connector_types::{
EventType, MandateReference, MandateReferenceId, PaymentFlowData, PaymentVoidData,
PaymentsAuthorizeData, PaymentsCaptureData, PaymentsResponseData, PaymentsSyncData,
RefundFlowData, RefundSyncData, RefundWebhookDetailsResponse, RefundsData,
RefundsResponseData, RepeatPaymentData, ResponseId, SetupMandateRequestData,
WebhookDetailsResponse,
},
errors::{self, ConnectorError},
payment_method_data::{
PaymentMethodData, PaymentMethodDataTypes, RawCardNumber,
WalletData as WalletDataPaymentMethod,
},
router_data::{ConnectorAuthType, ErrorResponse},
router_data_v2::RouterDataV2,
router_response_types::RedirectForm,
utils::{self, ForeignTryFrom},
};
use error_stack::ResultExt;
use hyperswitch_masking::{ExposeInterface, Secret};
use serde::{Deserialize, Serialize};
use strum::Display;
use crate::{connectors::novalnet::NovalnetRouterData, types::ResponseRouterData};
/// Default locale
const DEFAULT_LOCALE: &str = "en";
const MINIMAL_CUSTOMER_DATA_PASSED: i64 = 1;
const CREATE_TOKEN_REQUIRED: i8 = 1;
const TEST_MODE_ENABLED: i8 = 1;
const TEST_MODE_DISABLED: i8 = 0;
fn get_test_mode(item: Option<bool>) -> i8 {
match item {
Some(true) => TEST_MODE_ENABLED,
Some(false) | None => TEST_MODE_DISABLED,
}
}
#[derive(Debug, Copy, Serialize, Deserialize, Clone)]
pub enum NovalNetPaymentTypes {
CREDITCARD,
PAYPAL,
GOOGLEPAY,
APPLEPAY,
}
#[derive(Default, Debug, Serialize, Clone)]
pub struct NovalnetPaymentsRequestMerchant {
signature: Secret<String>,
tariff: Secret<String>,
}
#[derive(Default, Debug, Serialize, Clone)]
pub struct NovalnetPaymentsRequestBilling {
house_no: Option<Secret<String>>,
street: Option<Secret<String>>,
city: Option<Secret<String>>,
zip: Option<Secret<String>>,
country_code: Option<common_enums::CountryAlpha2>,
}
#[derive(Default, Debug, Serialize, Clone)]
pub struct NovalnetPaymentsRequestCustomer {
first_name: Option<Secret<String>>,
last_name: Option<Secret<String>>,
email: pii::Email,
mobile: Option<Secret<String>>,
billing: Option<NovalnetPaymentsRequestBilling>,
no_nc: i64,
}
#[derive(Default, Debug, Clone, Serialize, Deserialize)]
pub struct NovalnetCard<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> {
card_number: RawCardNumber<T>,
card_expiry_month: Secret<String>,
card_expiry_year: Secret<String>,
card_cvc: Secret<String>,
card_holder: Secret<String>,
}
#[derive(Default, Debug, Clone, Serialize, Deserialize)]
pub struct NovalnetRawCardDetails {
card_number: CardNumber,
card_expiry_month: Secret<String>,
card_expiry_year: Secret<String>,
}
#[derive(Debug, Serialize, Deserialize, Clone)]
pub struct NovalnetMandate {
token: Secret<String>,
}
#[derive(Default, Debug, Clone, Serialize, Deserialize)]
pub struct NovalnetGooglePay {
wallet_data: Secret<String>,
}
#[derive(Default, Debug, Clone, Serialize, Deserialize)]
pub struct NovalnetApplePay {
wallet_data: Secret<String>,
}
#[derive(Debug, Serialize, Deserialize, Clone)]
#[serde(untagged)]
pub enum NovalNetPaymentData<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> {
Card(NovalnetCard<T>),
RawCardForNTI(NovalnetRawCardDetails),
GooglePay(NovalnetGooglePay),
ApplePay(NovalnetApplePay),
MandatePayment(NovalnetMandate),
}
#[derive(Default, Debug, Serialize, Clone)]
pub struct NovalnetCustom {
lang: String,
}
#[derive(Debug, Serialize, Deserialize, Clone)]
#[serde(untagged)]
pub enum NovalNetAmount {
StringMinor(StringMinorUnit),
Int(i64),
}
#[derive(Debug, Serialize, Deserialize, Clone)]
pub struct NovalnetPaymentsRequestTransaction<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> {
test_mode: i8,
payment_type: NovalNetPaymentTypes,
| {
"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_353540475883723703_1 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/novalnet/transformers.rs
amount: NovalNetAmount,
currency: common_enums::Currency,
order_no: String,
payment_data: Option<NovalNetPaymentData<T>>,
hook_url: Option<String>,
return_url: Option<String>,
error_return_url: Option<String>,
enforce_3d: Option<i8>, //NOTE: Needed for CREDITCARD, GOOGLEPAY
create_token: Option<i8>,
scheme_tid: Option<Secret<String>>, // Card network's transaction ID
}
#[derive(Debug, Serialize, Clone)]
pub struct NovalnetPaymentsRequest<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> {
merchant: NovalnetPaymentsRequestMerchant,
customer: NovalnetPaymentsRequestCustomer,
transaction: NovalnetPaymentsRequestTransaction<T>,
custom: NovalnetCustom,
}
impl TryFrom<&common_enums::PaymentMethodType> for NovalNetPaymentTypes {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(item: &common_enums::PaymentMethodType) -> Result<Self, Self::Error> {
match item {
common_enums::PaymentMethodType::ApplePay => Ok(Self::APPLEPAY),
common_enums::PaymentMethodType::Credit | common_enums::PaymentMethodType::Debit => {
Ok(Self::CREDITCARD)
}
common_enums::PaymentMethodType::GooglePay => Ok(Self::GOOGLEPAY),
common_enums::PaymentMethodType::Paypal => Ok(Self::PAYPAL),
_ => Err(errors::ConnectorError::NotImplemented(
utils::get_unimplemented_payment_method_error_message("Novalnet"),
))?,
}
}
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
TryFrom<
NovalnetRouterData<
RouterDataV2<
Authorize,
PaymentFlowData,
PaymentsAuthorizeData<T>,
PaymentsResponseData,
>,
T,
>,
> for NovalnetPaymentsRequest<T>
{
type Error = error_stack::Report<ConnectorError>;
fn try_from(
item: NovalnetRouterData<
RouterDataV2<
Authorize,
PaymentFlowData,
PaymentsAuthorizeData<T>,
PaymentsResponseData,
>,
T,
>,
) -> Result<Self, Self::Error> {
let auth = NovalnetAuthType::try_from(&item.router_data.connector_auth_type)?;
let merchant = NovalnetPaymentsRequestMerchant {
signature: auth.product_activation_key,
tariff: auth.tariff_id,
};
let enforce_3d = match item.router_data.resource_common_data.auth_type {
common_enums::AuthenticationType::ThreeDs => Some(1),
common_enums::AuthenticationType::NoThreeDs => None,
};
let test_mode = get_test_mode(item.router_data.resource_common_data.test_mode);
let billing = NovalnetPaymentsRequestBilling {
house_no: item
.router_data
.resource_common_data
.get_optional_billing_line1(),
street: item
.router_data
.resource_common_data
.get_optional_billing_line2(),
city: item
.router_data
.resource_common_data
.get_optional_billing_city()
.map(Secret::new),
zip: item
.router_data
.resource_common_data
.get_optional_billing_zip(),
country_code: item
.router_data
.resource_common_data
.get_optional_billing_country(),
};
let customer = NovalnetPaymentsRequestCustomer {
first_name: item
.router_data
.resource_common_data
.get_optional_billing_first_name(),
last_name: item
.router_data
.resource_common_data
.get_optional_billing_last_name(),
email: item
.router_data
.resource_common_data
.get_billing_email()
.or(item.router_data.request.get_email())?,
mobile: item
| {
"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_353540475883723703_2 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/novalnet/transformers.rs
.router_data
.resource_common_data
.get_optional_billing_phone_number(),
billing: Some(billing),
// no_nc is used to indicate if minimal customer data is passed or not
no_nc: MINIMAL_CUSTOMER_DATA_PASSED,
};
let lang = item
.router_data
.request
.get_optional_language_from_browser_info()
.unwrap_or(DEFAULT_LOCALE.to_string().to_string());
let custom = NovalnetCustom { lang };
let hook_url = item.router_data.request.get_webhook_url()?;
let return_url = item.router_data.request.get_router_return_url()?;
let create_token = None;
let amount = item
.connector
.amount_converter
.convert(
item.router_data.request.minor_amount,
item.router_data.request.currency,
)
.change_context(errors::ConnectorError::AmountConversionFailed)?;
match item.router_data.request.payment_method_data {
PaymentMethodData::Card(ref req_card) => {
let novalnet_card = NovalNetPaymentData::Card(NovalnetCard {
card_number: req_card.card_number.clone(),
card_expiry_month: req_card.card_exp_month.clone(),
card_expiry_year: req_card.card_exp_year.clone(),
card_cvc: req_card.card_cvc.clone(),
card_holder: item
.router_data
.resource_common_data
.get_billing_full_name()?,
});
let transaction = NovalnetPaymentsRequestTransaction {
test_mode,
payment_type: NovalNetPaymentTypes::CREDITCARD,
amount: NovalNetAmount::StringMinor(amount.clone()),
currency: item.router_data.request.currency,
order_no: item
.router_data
.resource_common_data
.connector_request_reference_id
.clone(),
hook_url: Some(hook_url),
return_url: Some(return_url.clone()),
error_return_url: Some(return_url.clone()),
payment_data: Some(novalnet_card),
enforce_3d,
create_token,
scheme_tid: None,
};
Ok(Self {
merchant,
transaction,
customer,
custom,
})
}
PaymentMethodData::Wallet(ref wallet_data) => match wallet_data {
WalletDataPaymentMethod::GooglePay(ref req_wallet) => {
let novalnet_google_pay: NovalNetPaymentData<T> =
NovalNetPaymentData::GooglePay(NovalnetGooglePay {
wallet_data: Secret::new(
req_wallet
.tokenization_data
.get_encrypted_google_pay_token()
.change_context(errors::ConnectorError::MissingRequiredField {
field_name: "gpay wallet_token",
})?
.clone(),
),
});
let transaction = NovalnetPaymentsRequestTransaction {
test_mode,
payment_type: NovalNetPaymentTypes::GOOGLEPAY,
amount: NovalNetAmount::StringMinor(amount.clone()),
currency: item.router_data.request.currency,
order_no: item
.router_data
.resource_common_data
.connector_request_reference_id
.clone(),
hook_url: Some(hook_url),
return_url: None,
error_return_url: None,
payment_data: Some(novalnet_google_pay),
| {
"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_353540475883723703_3 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/novalnet/transformers.rs
enforce_3d,
create_token,
scheme_tid: None,
};
Ok(Self {
merchant,
transaction,
customer,
custom,
})
}
WalletDataPaymentMethod::ApplePay(payment_method_data) => {
let transaction = NovalnetPaymentsRequestTransaction {
test_mode,
payment_type: NovalNetPaymentTypes::APPLEPAY,
amount: NovalNetAmount::StringMinor(amount.clone()),
currency: item.router_data.request.currency,
order_no: item
.router_data
.resource_common_data
.connector_request_reference_id
.clone(),
hook_url: Some(hook_url),
return_url: None,
error_return_url: None,
payment_data: Some(NovalNetPaymentData::ApplePay(NovalnetApplePay {
wallet_data: payment_method_data.get_applepay_decoded_payment_data()?,
})),
enforce_3d: None,
create_token,
scheme_tid: None,
};
Ok(Self {
merchant,
transaction,
customer,
custom,
})
}
WalletDataPaymentMethod::PaypalRedirect(_) => {
let transaction = NovalnetPaymentsRequestTransaction {
test_mode,
payment_type: NovalNetPaymentTypes::PAYPAL,
amount: NovalNetAmount::StringMinor(amount.clone()),
currency: item.router_data.request.currency,
order_no: item
.router_data
.resource_common_data
.connector_request_reference_id
.clone(),
hook_url: Some(hook_url),
return_url: Some(return_url.clone()),
error_return_url: Some(return_url.clone()),
payment_data: None,
enforce_3d: None,
create_token,
scheme_tid: None,
};
Ok(Self {
merchant,
transaction,
customer,
custom,
})
}
WalletDataPaymentMethod::AliPayQr(_)
| WalletDataPaymentMethod::BluecodeRedirect {}
| WalletDataPaymentMethod::AliPayRedirect(_)
| WalletDataPaymentMethod::AliPayHkRedirect(_)
| WalletDataPaymentMethod::AmazonPayRedirect(_)
| WalletDataPaymentMethod::MomoRedirect(_)
| WalletDataPaymentMethod::KakaoPayRedirect(_)
| WalletDataPaymentMethod::GoPayRedirect(_)
| WalletDataPaymentMethod::GcashRedirect(_)
| WalletDataPaymentMethod::ApplePayRedirect(_)
| WalletDataPaymentMethod::ApplePayThirdPartySdk(_)
| WalletDataPaymentMethod::DanaRedirect {}
| WalletDataPaymentMethod::GooglePayRedirect(_)
| WalletDataPaymentMethod::GooglePayThirdPartySdk(_)
| WalletDataPaymentMethod::MbWayRedirect(_)
| WalletDataPaymentMethod::MobilePayRedirect(_)
| WalletDataPaymentMethod::RevolutPay(_)
| WalletDataPaymentMethod::PaypalSdk(_)
| WalletDataPaymentMethod::Paze(_)
| WalletDataPaymentMethod::SamsungPay(_)
| WalletDataPaymentMethod::TwintRedirect {}
| WalletDataPaymentMethod::VippsRedirect {}
| WalletDataPaymentMethod::TouchNGoRedirect(_)
| {
"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_353540475883723703_4 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/novalnet/transformers.rs
| WalletDataPaymentMethod::WeChatPayRedirect(_)
| WalletDataPaymentMethod::CashappQr(_)
| WalletDataPaymentMethod::SwishQr(_)
| WalletDataPaymentMethod::WeChatPayQr(_)
| WalletDataPaymentMethod::Mifinity(_) => {
Err(errors::ConnectorError::NotImplemented(
utils::get_unimplemented_payment_method_error_message("novalnet"),
)
.into())
}
},
_ => Err(errors::ConnectorError::NotImplemented(
utils::get_unimplemented_payment_method_error_message("novalnet"),
)
.into()),
}
}
}
// Auth Struct
pub struct NovalnetAuthType {
pub(super) product_activation_key: Secret<String>,
pub(super) payment_access_key: Secret<String>,
pub(super) tariff_id: Secret<String>,
}
impl TryFrom<&ConnectorAuthType> for NovalnetAuthType {
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 {
product_activation_key: api_key.to_owned(),
payment_access_key: key1.to_owned(),
tariff_id: api_secret.to_owned(),
}),
_ => Err(errors::ConnectorError::FailedToObtainAuthType.into()),
}
}
}
// PaymentsResponse
#[derive(Debug, Display, Copy, Clone, Serialize, Deserialize, PartialEq)]
#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
pub enum NovalnetTransactionStatus {
Success,
Failure,
Confirmed,
OnHold,
Pending,
Deactivated,
Progress,
}
#[derive(Debug, Copy, Display, Clone, Serialize, Deserialize, PartialEq)]
#[strum(serialize_all = "UPPERCASE")]
#[serde(rename_all = "UPPERCASE")]
pub enum NovalnetAPIStatus {
Success,
Failure,
}
impl From<NovalnetTransactionStatus> for common_enums::AttemptStatus {
fn from(item: NovalnetTransactionStatus) -> Self {
match item {
NovalnetTransactionStatus::Success | NovalnetTransactionStatus::Confirmed => {
Self::Charged
}
NovalnetTransactionStatus::OnHold => Self::Authorized,
NovalnetTransactionStatus::Pending => Self::Pending,
NovalnetTransactionStatus::Progress => Self::AuthenticationPending,
NovalnetTransactionStatus::Deactivated => Self::Voided,
NovalnetTransactionStatus::Failure => Self::Failure,
}
}
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ResultData {
pub redirect_url: Option<Secret<url::Url>>,
pub status: NovalnetAPIStatus,
pub status_code: u64,
pub status_text: String,
pub additional_message: Option<String>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct NovalnetPaymentsResponseTransactionData {
pub amount: Option<MinorUnit>,
pub currency: Option<common_enums::Currency>,
pub date: Option<String>,
pub order_no: Option<String>,
pub payment_data: Option<NovalnetResponsePaymentData>,
pub payment_type: Option<String>,
pub status_code: Option<u64>,
pub txn_secret: Option<Secret<String>>,
pub tid: Option<Secret<i64>>,
pub test_mode: Option<i8>,
pub status: Option<NovalnetTransactionStatus>,
pub authorization: Option<NovalnetAuthorizationResponse>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct NovalnetPaymentsResponse {
result: ResultData,
transaction: Option<NovalnetPaymentsResponseTransactionData>,
}
pub fn get_error_response(result: ResultData, status_code: u16) -> ErrorResponse {
let error_code = result.status;
let error_reason = result.status_text.clone();
ErrorResponse {
code: error_code.to_string(),
message: error_reason.clone(),
reason: Some(error_reason),
status_code,
attempt_status: None,
connector_transaction_id: None,
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
}
}
impl NovalnetPaymentsResponseTransactionData {
pub fn get_token(transaction_data: Option<&Self>) -> Option<String> {
| {
"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_353540475883723703_5 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/novalnet/transformers.rs
if let Some(data) = transaction_data {
match &data.payment_data {
Some(NovalnetResponsePaymentData::Card(card_data)) => {
card_data.token.clone().map(|token| token.expose())
}
Some(NovalnetResponsePaymentData::Paypal(paypal_data)) => {
paypal_data.token.clone().map(|token| token.expose())
}
None => None,
}
} else {
None
}
}
}
// Specific implementations for Authorize flow
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
TryFrom<
ResponseRouterData<
NovalnetPaymentsResponse,
RouterDataV2<
Authorize,
PaymentFlowData,
PaymentsAuthorizeData<T>,
PaymentsResponseData,
>,
>,
> for RouterDataV2<Authorize, PaymentFlowData, PaymentsAuthorizeData<T>, PaymentsResponseData>
{
type Error = error_stack::Report<ConnectorError>;
fn try_from(
item: ResponseRouterData<
NovalnetPaymentsResponse,
RouterDataV2<
Authorize,
PaymentFlowData,
PaymentsAuthorizeData<T>,
PaymentsResponseData,
>,
>,
) -> Result<Self, Self::Error> {
match item.response.result.status {
NovalnetAPIStatus::Success => {
let redirection_data: Option<RedirectForm> =
item.response
.result
.redirect_url
.map(|url| RedirectForm::Form {
endpoint: url.expose().to_string(),
method: Method::Get,
form_fields: HashMap::new(),
});
let transaction_id = item
.response
.transaction
.clone()
.and_then(|data| data.tid.map(|tid| tid.expose().to_string()));
let mandate_reference_id = NovalnetPaymentsResponseTransactionData::get_token(
item.response.transaction.clone().as_ref(),
);
let transaction_status = item
.response
.transaction
.as_ref()
.and_then(|transaction_data| transaction_data.status)
.unwrap_or(if redirection_data.is_some() {
NovalnetTransactionStatus::Progress
// NOTE: Novalnet does not send us the transaction.status for redirection flow
// so status is mapped to Progress if flow has redirection data
} else {
NovalnetTransactionStatus::Pending
});
Ok(Self {
resource_common_data: PaymentFlowData {
status: common_enums::AttemptStatus::from(transaction_status),
..item.router_data.resource_common_data
},
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: transaction_id
.clone()
.map(ResponseId::ConnectorTransactionId)
.unwrap_or(ResponseId::NoResponseId),
redirection_data: redirection_data.map(Box::new),
mandate_reference: mandate_reference_id
.as_ref()
.map(|id| MandateReference {
connector_mandate_id: Some(id.clone()),
payment_method_id: None,
})
.map(Box::new),
connector_metadata: None,
network_txn_id: item.response.transaction.and_then(|data| {
data.payment_data
.and_then(|payment_data| match payment_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_353540475883723703_6 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/novalnet/transformers.rs
NovalnetResponsePaymentData::Card(card) => {
card.scheme_tid.map(|tid| tid.expose())
}
NovalnetResponsePaymentData::Paypal(_) => None,
})
}),
connector_response_reference_id: transaction_id.clone(),
incremental_authorization_allowed: None,
status_code: item.http_code,
}),
..item.router_data
})
}
NovalnetAPIStatus::Failure => {
let response = Err(get_error_response(item.response.result, item.http_code));
Ok(Self {
response,
..item.router_data
})
}
}
}
}
// Specific implementations for SetupMandate flow
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
TryFrom<
ResponseRouterData<
NovalnetPaymentsResponse,
RouterDataV2<
SetupMandate,
PaymentFlowData,
SetupMandateRequestData<T>,
PaymentsResponseData,
>,
>,
>
for RouterDataV2<
SetupMandate,
PaymentFlowData,
SetupMandateRequestData<T>,
PaymentsResponseData,
>
{
type Error = error_stack::Report<ConnectorError>;
fn try_from(
item: ResponseRouterData<
NovalnetPaymentsResponse,
RouterDataV2<
SetupMandate,
PaymentFlowData,
SetupMandateRequestData<T>,
PaymentsResponseData,
>,
>,
) -> Result<Self, Self::Error> {
match item.response.result.status {
NovalnetAPIStatus::Success => {
let redirection_data: Option<RedirectForm> =
item.response
.result
.redirect_url
.map(|url| RedirectForm::Form {
endpoint: url.expose().to_string(),
method: Method::Get,
form_fields: HashMap::new(),
});
let transaction_id = item
.response
.transaction
.clone()
.and_then(|data| data.tid.map(|tid| tid.expose().to_string()));
let mandate_reference_id = NovalnetPaymentsResponseTransactionData::get_token(
item.response.transaction.clone().as_ref(),
);
let transaction_status = item
.response
.transaction
.as_ref()
.and_then(|transaction_data| transaction_data.status)
.unwrap_or(if redirection_data.is_some() {
NovalnetTransactionStatus::Progress
// NOTE: Novalnet does not send us the transaction.status for redirection flow
// so status is mapped to Progress if flow has redirection data
} else {
NovalnetTransactionStatus::Pending
});
Ok(Self {
resource_common_data: PaymentFlowData {
status: common_enums::AttemptStatus::from(transaction_status),
..item.router_data.resource_common_data
},
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: transaction_id
.clone()
.map(ResponseId::ConnectorTransactionId)
.unwrap_or(ResponseId::NoResponseId),
redirection_data: redirection_data.map(Box::new),
mandate_reference: mandate_reference_id
.as_ref()
.map(|id| MandateReference {
| {
"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_353540475883723703_7 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/novalnet/transformers.rs
connector_mandate_id: Some(id.clone()),
payment_method_id: None,
})
.map(Box::new),
connector_metadata: None,
network_txn_id: item.response.transaction.and_then(|data| {
data.payment_data
.and_then(|payment_data| match payment_data {
NovalnetResponsePaymentData::Card(card) => {
card.scheme_tid.map(|tid| tid.expose())
}
NovalnetResponsePaymentData::Paypal(_) => None,
})
}),
connector_response_reference_id: transaction_id.clone(),
incremental_authorization_allowed: None,
status_code: item.http_code,
}),
..item.router_data
})
}
NovalnetAPIStatus::Failure => {
let response = Err(get_error_response(item.response.result, item.http_code));
Ok(Self {
response,
..item.router_data
})
}
}
}
}
// Specific implementations for RepeatPayment flow
impl
TryFrom<
ResponseRouterData<
NovalnetPaymentsResponse,
RouterDataV2<RepeatPayment, PaymentFlowData, RepeatPaymentData, PaymentsResponseData>,
>,
> for RouterDataV2<RepeatPayment, PaymentFlowData, RepeatPaymentData, PaymentsResponseData>
{
type Error = error_stack::Report<ConnectorError>;
fn try_from(
item: ResponseRouterData<
NovalnetPaymentsResponse,
RouterDataV2<RepeatPayment, PaymentFlowData, RepeatPaymentData, PaymentsResponseData>,
>,
) -> Result<Self, Self::Error> {
match item.response.result.status {
NovalnetAPIStatus::Success => {
let redirection_data: Option<RedirectForm> =
item.response
.result
.redirect_url
.map(|url| RedirectForm::Form {
endpoint: url.expose().to_string(),
method: Method::Get,
form_fields: HashMap::new(),
});
let transaction_id = item
.response
.transaction
.clone()
.and_then(|data| data.tid.map(|tid| tid.expose().to_string()));
let mandate_reference_id = NovalnetPaymentsResponseTransactionData::get_token(
item.response.transaction.clone().as_ref(),
);
let transaction_status = item
.response
.transaction
.as_ref()
.and_then(|transaction_data| transaction_data.status)
.unwrap_or(if redirection_data.is_some() {
NovalnetTransactionStatus::Progress
// NOTE: Novalnet does not send us the transaction.status for redirection flow
// so status is mapped to Progress if flow has redirection data
} else {
NovalnetTransactionStatus::Pending
});
Ok(Self {
resource_common_data: PaymentFlowData {
status: common_enums::AttemptStatus::from(transaction_status),
..item.router_data.resource_common_data
},
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: transaction_id
.clone()
.map(ResponseId::ConnectorTransactionId)
.unwrap_or(ResponseId::NoResponseId),
redirection_data: redirection_data.map(Box::new),
mandate_reference: mandate_reference_id
.as_ref()
| {
"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_353540475883723703_8 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/novalnet/transformers.rs
.map(|id| MandateReference {
connector_mandate_id: Some(id.clone()),
payment_method_id: None,
})
.map(Box::new),
connector_metadata: None,
network_txn_id: item.response.transaction.and_then(|data| {
data.payment_data
.and_then(|payment_data| match payment_data {
NovalnetResponsePaymentData::Card(card) => {
card.scheme_tid.map(|tid| tid.expose())
}
NovalnetResponsePaymentData::Paypal(_) => None,
})
}),
connector_response_reference_id: transaction_id.clone(),
incremental_authorization_allowed: None,
status_code: item.http_code,
}),
..item.router_data
})
}
NovalnetAPIStatus::Failure => {
let response = Err(get_error_response(item.response.result, item.http_code));
Ok(Self {
response,
..item.router_data
})
}
}
}
}
#[derive(Serialize, Deserialize, Clone, Debug)]
pub struct NovalnetResponseCustomer {
pub billing: Option<NovalnetResponseBilling>,
pub customer_ip: Option<Secret<String>>,
pub email: Option<pii::Email>,
pub first_name: Option<Secret<String>>,
pub gender: Option<Secret<String>>,
pub last_name: Option<Secret<String>>,
pub mobile: Option<Secret<String>>,
pub tel: Option<Secret<String>>,
pub fax: Option<Secret<String>>,
}
#[derive(Serialize, Deserialize, Clone, Debug)]
pub struct NovalnetResponseBilling {
pub city: Option<Secret<String>>,
pub country_code: Option<Secret<String>>,
pub house_no: Option<Secret<String>>,
pub street: Option<Secret<String>>,
pub zip: Option<Secret<String>>,
pub state: Option<Secret<String>>,
}
#[derive(Serialize, Deserialize, Clone, Debug)]
pub struct NovalnetResponseMerchant {
pub project: Option<Secret<i64>>,
pub project_name: Option<Secret<String>>,
pub project_url: Option<url::Url>,
pub vendor: Option<Secret<i64>>,
}
#[derive(Serialize, Deserialize, Clone, Debug)]
pub struct NovalnetAuthorizationResponse {
expiry_date: Option<String>,
auto_action: Option<String>,
}
#[derive(Serialize, Deserialize, Clone, Debug)]
pub struct NovalnetSyncResponseTransactionData {
pub amount: Option<MinorUnit>,
pub currency: Option<common_enums::Currency>,
pub date: Option<String>,
pub order_no: Option<String>,
pub payment_data: Option<NovalnetResponsePaymentData>,
pub payment_type: String,
pub status: NovalnetTransactionStatus,
pub status_code: u64,
pub test_mode: u8,
pub tid: Option<Secret<i64>>,
pub txn_secret: Option<Secret<String>>,
pub authorization: Option<NovalnetAuthorizationResponse>,
pub reason: Option<String>,
pub reason_code: Option<String>,
}
#[derive(Debug, Serialize, Deserialize, Clone)]
#[serde(untagged)]
pub enum NovalnetResponsePaymentData {
Card(NovalnetResponseCard),
Paypal(NovalnetResponsePaypal),
}
#[derive(Serialize, Deserialize, Clone, Debug)]
pub struct NovalnetResponseCard {
pub card_brand: Option<Secret<String>>,
pub card_expiry_month: Secret<u8>,
pub card_expiry_year: Secret<u16>,
pub card_holder: Secret<String>,
pub card_number: Secret<String>,
pub cc_3d: Option<Secret<u8>>,
pub last_four: Option<Secret<String>>,
pub token: Option<Secret<String>>,
pub scheme_tid: Option<Secret<String>>,
}
#[derive(Serialize, Deserialize, Clone, Debug)]
pub struct NovalnetResponsePaypal {
pub paypal_account: Option<pii::Email>,
pub paypal_transaction_id: Option<Secret<String>>,
pub token: Option<Secret<String>>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct NovalnetPSyncResponse {
pub customer: Option<NovalnetResponseCustomer>,
pub merchant: Option<NovalnetResponseMerchant>,
pub result: ResultData,
| {
"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_353540475883723703_9 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/novalnet/transformers.rs
pub transaction: Option<NovalnetSyncResponseTransactionData>,
}
#[derive(Debug, Copy, Serialize, Default, Deserialize, Clone)]
pub enum CaptureType {
#[default]
Partial,
Final,
}
#[derive(Default, Debug, Serialize)]
pub struct Capture {
#[serde(rename = "type")]
cap_type: CaptureType,
reference: String,
}
#[derive(Default, Debug, Serialize)]
pub struct NovalnetTransaction {
tid: String,
amount: Option<StringMinorUnit>,
capture: Capture,
}
#[derive(Default, Debug, Serialize)]
pub struct NovalnetCaptureRequest {
pub transaction: NovalnetTransaction,
pub custom: NovalnetCustom,
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
TryFrom<
NovalnetRouterData<
RouterDataV2<
connector_flow::Capture,
PaymentFlowData,
PaymentsCaptureData,
PaymentsResponseData,
>,
T,
>,
> for NovalnetCaptureRequest
{
type Error = error_stack::Report<ConnectorError>;
fn try_from(
item: NovalnetRouterData<
RouterDataV2<
connector_flow::Capture,
PaymentFlowData,
PaymentsCaptureData,
PaymentsResponseData,
>,
T,
>,
) -> Result<Self, Self::Error> {
let capture_type = CaptureType::Final;
let reference = item
.router_data
.resource_common_data
.connector_request_reference_id
.clone();
let capture = Capture {
cap_type: capture_type,
reference,
};
let amount = item
.connector
.amount_converter
.convert(
item.router_data.request.minor_amount_to_capture,
item.router_data.request.currency,
)
.change_context(errors::ConnectorError::AmountConversionFailed)?;
let transaction = NovalnetTransaction {
tid: item
.router_data
.request
.get_connector_transaction_id()
.change_context(errors::ConnectorError::MissingConnectorTransactionID)?,
capture,
amount: Some(amount.to_owned()),
};
let custom = NovalnetCustom {
lang: item
.router_data
.request
.get_optional_language_from_browser_info()
.unwrap_or(DEFAULT_LOCALE.to_string()),
};
Ok(Self {
transaction,
custom,
})
}
}
// Type definition for RefundRequest
#[derive(Default, Debug, Serialize)]
pub struct NovalnetRefundTransaction {
tid: String,
amount: Option<StringMinorUnit>,
}
#[derive(Default, Debug, Serialize)]
pub struct NovalnetRefundRequest {
pub transaction: NovalnetRefundTransaction,
pub custom: NovalnetCustom,
}
impl<
F,
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
TryFrom<
NovalnetRouterData<RouterDataV2<F, RefundFlowData, RefundsData, RefundsResponseData>, T>,
> for NovalnetRefundRequest
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: NovalnetRouterData<
RouterDataV2<F, RefundFlowData, RefundsData, RefundsResponseData>,
T,
>,
) -> Result<Self, Self::Error> {
let amount = item
.connector
.amount_converter
.convert(
item.router_data.request.minor_refund_amount,
item.router_data.request.currency,
)
.change_context(errors::ConnectorError::AmountConversionFailed)?;
let transaction = NovalnetRefundTransaction {
tid: item.router_data.request.connector_transaction_id.clone(),
amount: Some(amount.to_owned()),
};
let custom = NovalnetCustom {
lang: item
.router_data
.request
.get_optional_language_from_browser_info()
.unwrap_or(DEFAULT_LOCALE.to_string().to_string()),
};
| {
"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_353540475883723703_10 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/novalnet/transformers.rs
Ok(Self {
transaction,
custom,
})
}
}
impl From<NovalnetTransactionStatus> for common_enums::RefundStatus {
fn from(item: NovalnetTransactionStatus) -> Self {
match item {
NovalnetTransactionStatus::Success | NovalnetTransactionStatus::Confirmed => {
Self::Success
}
NovalnetTransactionStatus::Pending => Self::Pending,
NovalnetTransactionStatus::Failure
| NovalnetTransactionStatus::OnHold
| NovalnetTransactionStatus::Deactivated
| NovalnetTransactionStatus::Progress => Self::Failure,
}
}
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct NovalnetRefundSyncResponse {
result: ResultData,
transaction: Option<NovalnetSyncResponseTransactionData>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct NovalnetRefundsTransactionData {
pub amount: Option<MinorUnit>,
pub date: Option<String>,
pub currency: Option<common_enums::Currency>,
pub order_no: Option<String>,
pub payment_type: String,
pub refund: RefundData,
pub refunded_amount: Option<u64>,
pub status: NovalnetTransactionStatus,
pub status_code: u64,
pub test_mode: u8,
pub tid: Option<Secret<i64>>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct RefundData {
amount: u64,
currency: common_enums::Currency,
payment_type: Option<String>,
tid: Option<Secret<i64>>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct NovalnetRefundResponse {
pub customer: Option<NovalnetResponseCustomer>,
pub merchant: Option<NovalnetResponseMerchant>,
pub result: ResultData,
pub transaction: Option<NovalnetRefundsTransactionData>,
}
impl<F> TryFrom<ResponseRouterData<NovalnetRefundResponse, Self>>
for RouterDataV2<F, RefundFlowData, RefundsData, RefundsResponseData>
{
type Error = error_stack::Report<ConnectorError>;
fn try_from(
item: ResponseRouterData<NovalnetRefundResponse, Self>,
) -> Result<Self, Self::Error> {
match item.response.result.status {
NovalnetAPIStatus::Success => {
let refund_id = item
.response
.transaction
.clone()
.and_then(|data| data.refund.tid.map(|tid| tid.expose().to_string()))
.ok_or(errors::ConnectorError::ResponseHandlingFailed)?;
let transaction_status = item
.response
.transaction
.map(|transaction| transaction.status)
.unwrap_or(NovalnetTransactionStatus::Pending);
Ok(Self {
response: Ok(RefundsResponseData {
connector_refund_id: refund_id,
refund_status: common_enums::RefundStatus::from(transaction_status),
status_code: item.http_code,
}),
..item.router_data
})
}
NovalnetAPIStatus::Failure => {
let response = Err(get_error_response(item.response.result, item.http_code));
Ok(Self {
response,
..item.router_data
})
}
}
}
}
#[derive(Debug, Serialize, Deserialize)]
pub struct NovalnetRedirectionResponse {
status: NovalnetTransactionStatus,
tid: Secret<String>,
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
TryFrom<
NovalnetRouterData<
RouterDataV2<PSync, PaymentFlowData, PaymentsSyncData, PaymentsResponseData>,
T,
>,
> for NovalnetSyncRequest
{
type Error = error_stack::Report<ConnectorError>;
fn try_from(
item: NovalnetRouterData<
RouterDataV2<PSync, PaymentFlowData, PaymentsSyncData, PaymentsResponseData>,
T,
>,
) -> Result<Self, Self::Error> {
let transaction = if item
.router_data
.request
.encoded_data
.clone()
.get_required_value("encoded_data")
.is_ok()
{
let encoded_data = item
| {
"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_353540475883723703_11 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/novalnet/transformers.rs
.router_data
.request
.encoded_data
.clone()
.get_required_value("encoded_data")
.change_context(errors::ConnectorError::RequestEncodingFailed)?;
let novalnet_redirection_response =
serde_urlencoded::from_str::<NovalnetRedirectionResponse>(encoded_data.as_str())
.change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
NovalnetSyncTransaction {
tid: novalnet_redirection_response.tid.expose(),
}
} else {
NovalnetSyncTransaction {
tid: item
.router_data
.request
.get_connector_transaction_id()
.change_context(errors::ConnectorError::MissingConnectorTransactionID)?,
}
};
let custom = NovalnetCustom {
lang: DEFAULT_LOCALE.to_string().to_string(),
};
Ok(Self {
transaction,
custom,
})
}
}
impl NovalnetSyncResponseTransactionData {
pub fn get_token(transaction_data: Option<&Self>) -> Option<String> {
if let Some(data) = transaction_data {
match &data.payment_data {
Some(NovalnetResponsePaymentData::Card(card_data)) => {
card_data.token.clone().map(|token| token.expose())
}
Some(NovalnetResponsePaymentData::Paypal(paypal_data)) => {
paypal_data.token.clone().map(|token| token.expose())
}
None => None,
}
} else {
None
}
}
}
impl<F> TryFrom<ResponseRouterData<NovalnetPSyncResponse, Self>>
for RouterDataV2<F, PaymentFlowData, PaymentsSyncData, PaymentsResponseData>
{
type Error = error_stack::Report<ConnectorError>;
fn try_from(
item: ResponseRouterData<NovalnetPSyncResponse, Self>,
) -> Result<Self, Self::Error> {
match item.response.result.status {
NovalnetAPIStatus::Success => {
let transaction_id = item
.response
.transaction
.clone()
.and_then(|data| data.tid)
.map(|tid| tid.expose().to_string());
let transaction_status = item
.response
.transaction
.clone()
.map(|transaction_data| transaction_data.status)
.unwrap_or(NovalnetTransactionStatus::Pending);
let mandate_reference_id = NovalnetSyncResponseTransactionData::get_token(
item.response.transaction.as_ref(),
);
Ok(Self {
resource_common_data: PaymentFlowData {
status: common_enums::AttemptStatus::from(transaction_status),
..item.router_data.resource_common_data
},
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: transaction_id
.clone()
.map(ResponseId::ConnectorTransactionId)
.unwrap_or(ResponseId::NoResponseId),
redirection_data: None,
mandate_reference: mandate_reference_id
.as_ref()
.map(|id| MandateReference {
connector_mandate_id: Some(id.clone()),
payment_method_id: None,
})
.map(Box::new),
connector_metadata: None,
network_txn_id: item.response.transaction.and_then(|data| {
data.payment_data
.and_then(|payment_data| match payment_data {
NovalnetResponsePaymentData::Card(card) => {
card.scheme_tid.map(|tid| tid.expose())
}
| {
"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_353540475883723703_12 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/novalnet/transformers.rs
NovalnetResponsePaymentData::Paypal(_) => None,
})
}),
connector_response_reference_id: transaction_id.clone(),
incremental_authorization_allowed: None,
status_code: item.http_code,
}),
..item.router_data
})
}
NovalnetAPIStatus::Failure => {
let response = Err(get_error_response(item.response.result, item.http_code));
Ok(Self {
response,
..item.router_data
})
}
}
}
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct NovalnetCaptureTransactionData {
pub amount: Option<MinorUnit>,
pub capture: CaptureData,
pub currency: Option<common_enums::Currency>,
pub order_no: Option<String>,
pub payment_type: String,
pub status: NovalnetTransactionStatus,
pub status_code: Option<u64>,
pub test_mode: Option<u8>,
pub tid: Secret<i64>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct CaptureData {
amount: Option<u64>,
payment_type: Option<String>,
status: Option<String>,
status_code: u64,
tid: Option<Secret<i64>>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct NovalnetCaptureResponse {
pub result: ResultData,
pub transaction: Option<NovalnetCaptureTransactionData>,
}
impl<F> TryFrom<ResponseRouterData<NovalnetCaptureResponse, Self>>
for RouterDataV2<F, PaymentFlowData, PaymentsCaptureData, PaymentsResponseData>
{
type Error = error_stack::Report<ConnectorError>;
fn try_from(
item: ResponseRouterData<NovalnetCaptureResponse, Self>,
) -> Result<Self, Self::Error> {
match item.response.result.status {
NovalnetAPIStatus::Success => {
let transaction_id = item
.response
.transaction
.clone()
.map(|data| data.tid.expose().to_string());
let transaction_status = item
.response
.transaction
.map(|transaction_data| transaction_data.status)
.unwrap_or(NovalnetTransactionStatus::Pending);
Ok(Self {
resource_common_data: PaymentFlowData {
status: common_enums::AttemptStatus::from(transaction_status),
..item.router_data.resource_common_data
},
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: transaction_id
.clone()
.map(ResponseId::ConnectorTransactionId)
.unwrap_or(ResponseId::NoResponseId),
redirection_data: None,
mandate_reference: None,
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: transaction_id.clone(),
incremental_authorization_allowed: None,
status_code: item.http_code,
}),
..item.router_data
})
}
NovalnetAPIStatus::Failure => {
let response = Err(get_error_response(item.response.result, item.http_code));
Ok(Self {
response,
..item.router_data
})
}
}
}
}
#[derive(Default, Debug, Serialize)]
pub struct NovalnetSyncTransaction {
tid: String,
}
#[derive(Default, Debug, Serialize)]
pub struct NovalnetSyncRequest {
pub transaction: NovalnetSyncTransaction,
pub custom: NovalnetCustom,
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
TryFrom<
NovalnetRouterData<
RouterDataV2<RSync, RefundFlowData, RefundSyncData, RefundsResponseData>,
T,
>,
> for NovalnetSyncRequest
{
| {
"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_353540475883723703_13 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/novalnet/transformers.rs
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: NovalnetRouterData<
RouterDataV2<RSync, RefundFlowData, RefundSyncData, RefundsResponseData>,
T,
>,
) -> Result<Self, Self::Error> {
let transaction = NovalnetSyncTransaction {
tid: item.router_data.request.connector_transaction_id.clone(),
};
let custom = NovalnetCustom {
lang: item
.router_data
.request
.get_optional_language_from_browser_info()
.unwrap_or(DEFAULT_LOCALE.to_string().to_string()),
};
Ok(Self {
transaction,
custom,
})
}
}
impl<F> TryFrom<ResponseRouterData<NovalnetRefundSyncResponse, Self>>
for RouterDataV2<F, RefundFlowData, RefundSyncData, RefundsResponseData>
{
type Error = error_stack::Report<ConnectorError>;
fn try_from(
item: ResponseRouterData<NovalnetRefundSyncResponse, Self>,
) -> Result<Self, Self::Error> {
match item.response.result.status {
NovalnetAPIStatus::Success => {
let refund_id = item
.response
.transaction
.clone()
.and_then(|data| data.tid)
.map(|tid| tid.expose().to_string())
.unwrap_or("".to_string());
//NOTE: Mapping refund_id with "" incase we dont get any tid
let transaction_status = item
.response
.transaction
.map(|transaction_data| transaction_data.status)
.unwrap_or(NovalnetTransactionStatus::Pending);
Ok(Self {
response: Ok(RefundsResponseData {
connector_refund_id: refund_id,
refund_status: common_enums::RefundStatus::from(transaction_status),
status_code: item.http_code,
}),
..item.router_data
})
}
NovalnetAPIStatus::Failure => {
let response = Err(get_error_response(item.response.result, item.http_code));
Ok(Self {
response,
..item.router_data
})
}
}
}
}
#[derive(Default, Debug, Serialize)]
pub struct NovalnetCancelTransaction {
tid: String,
}
#[derive(Default, Debug, Serialize)]
pub struct NovalnetCancelRequest {
pub transaction: NovalnetCancelTransaction,
pub custom: NovalnetCustom,
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
TryFrom<
NovalnetRouterData<
RouterDataV2<Void, PaymentFlowData, PaymentVoidData, PaymentsResponseData>,
T,
>,
> for NovalnetCancelRequest
{
type Error = error_stack::Report<ConnectorError>;
fn try_from(
item: NovalnetRouterData<
RouterDataV2<Void, PaymentFlowData, PaymentVoidData, PaymentsResponseData>,
T,
>,
) -> Result<Self, Self::Error> {
let transaction = NovalnetCancelTransaction {
tid: item.router_data.request.connector_transaction_id.clone(),
};
let custom = NovalnetCustom {
lang: item
.router_data
.request
.get_optional_language_from_browser_info()
.unwrap_or(DEFAULT_LOCALE.to_string().to_string()),
};
Ok(Self {
transaction,
custom,
})
}
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct NovalnetCancelResponse {
result: ResultData,
transaction: Option<NovalnetPaymentsResponseTransactionData>,
}
impl<F> TryFrom<ResponseRouterData<NovalnetCancelResponse, Self>>
for RouterDataV2<F, PaymentFlowData, PaymentVoidData, PaymentsResponseData>
{
type Error = error_stack::Report<ConnectorError>;
fn try_from(
item: ResponseRouterData<NovalnetCancelResponse, Self>,
) -> Result<Self, Self::Error> {
match item.response.result.status {
NovalnetAPIStatus::Success => {
let transaction_id = item
| {
"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_353540475883723703_14 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/novalnet/transformers.rs
.response
.transaction
.clone()
.and_then(|data| data.tid.map(|tid| tid.expose().to_string()));
let transaction_status = item
.response
.transaction
.and_then(|transaction_data| transaction_data.status)
.unwrap_or(NovalnetTransactionStatus::Pending);
Ok(Self {
resource_common_data: PaymentFlowData {
status: if transaction_status == NovalnetTransactionStatus::Deactivated {
common_enums::AttemptStatus::Voided
} else {
common_enums::AttemptStatus::VoidFailed
},
..item.router_data.resource_common_data
},
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: transaction_id
.clone()
.map(ResponseId::ConnectorTransactionId)
.unwrap_or(ResponseId::NoResponseId),
redirection_data: None,
mandate_reference: None,
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: transaction_id.clone(),
incremental_authorization_allowed: None,
status_code: item.http_code,
}),
..item.router_data
})
}
NovalnetAPIStatus::Failure => {
let response = Err(get_error_response(item.response.result, item.http_code));
Ok(Self {
response,
..item.router_data
})
}
}
}
}
//TODO: Fill the struct with respective fields
#[derive(Default, Debug, Serialize, Deserialize)]
pub struct NovalnetErrorResponse {
pub status_code: u64,
pub code: String,
pub message: String,
pub reason: Option<String>,
}
#[derive(Display, Debug, Serialize, Deserialize)]
#[strum(serialize_all = "SCREAMING_SNAKE_CASE")]
#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
pub enum WebhookEventType {
Payment,
TransactionCapture,
TransactionCancel,
TransactionRefund,
Chargeback,
Credit,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct NovalnetWebhookEvent {
pub checksum: String,
pub tid: i64,
pub parent_tid: Option<i64>,
#[serde(rename = "type")]
pub event_type: WebhookEventType,
}
#[derive(Debug, Serialize, Deserialize, Clone)]
#[serde(untagged)]
pub enum NovalnetWebhookTransactionData {
SyncTransactionData(NovalnetSyncResponseTransactionData),
CaptureTransactionData(NovalnetCaptureTransactionData),
CancelTransactionData(NovalnetPaymentsResponseTransactionData),
RefundsTransactionData(NovalnetRefundsTransactionData),
}
#[derive(Serialize, Deserialize, Debug)]
pub struct NovalnetWebhookNotificationResponse {
pub event: NovalnetWebhookEvent,
pub result: ResultData,
pub transaction: NovalnetWebhookTransactionData,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct NovalnetWebhookNotificationResponseRefunds {
pub event: NovalnetWebhookEvent,
pub result: ResultData,
pub transaction: NovalnetRefundsTransactionData,
}
pub fn is_refund_event(event_code: &WebhookEventType) -> bool {
matches!(event_code, WebhookEventType::TransactionRefund)
}
pub fn reverse_string(s: &str) -> String {
s.chars().rev().collect()
}
#[derive(Display, Debug, Serialize, Deserialize)]
pub enum WebhookDisputeStatus {
DisputeOpened,
DisputeWon,
Unknown,
}
pub fn get_novalnet_dispute_status(status: WebhookEventType) -> WebhookDisputeStatus {
match status {
WebhookEventType::Chargeback => WebhookDisputeStatus::DisputeOpened,
WebhookEventType::Credit => WebhookDisputeStatus::DisputeWon,
_ => WebhookDisputeStatus::Unknown,
}
}
impl ForeignTryFrom<WebhookDisputeStatus> for common_enums::DisputeStatus {
type Error = ConnectorError;
fn foreign_try_from(value: WebhookDisputeStatus) -> error_stack::Result<Self, Self::Error> {
match value {
| {
"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_353540475883723703_15 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/novalnet/transformers.rs
WebhookDisputeStatus::DisputeOpened => Ok(Self::DisputeOpened),
WebhookDisputeStatus::DisputeWon => Ok(Self::DisputeWon),
WebhookDisputeStatus::Unknown => Err(ConnectorError::WebhookBodyDecodingFailed)?,
}
}
}
pub fn option_to_result<T>(opt: Option<T>) -> Result<T, errors::ConnectorError> {
opt.ok_or(errors::ConnectorError::WebhookBodyDecodingFailed)
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
TryFrom<
NovalnetRouterData<
RouterDataV2<
SetupMandate,
PaymentFlowData,
SetupMandateRequestData<T>,
PaymentsResponseData,
>,
T,
>,
> for NovalnetPaymentsRequest<T>
{
type Error = error_stack::Report<ConnectorError>;
fn try_from(
item: NovalnetRouterData<
RouterDataV2<
SetupMandate,
PaymentFlowData,
SetupMandateRequestData<T>,
PaymentsResponseData,
>,
T,
>,
) -> Result<Self, error_stack::Report<ConnectorError>> {
let auth = NovalnetAuthType::try_from(&item.router_data.connector_auth_type)?;
let merchant = NovalnetPaymentsRequestMerchant {
signature: auth.product_activation_key,
tariff: auth.tariff_id,
};
let enforce_3d = match item.router_data.resource_common_data.auth_type {
common_enums::AuthenticationType::ThreeDs => Some(1),
common_enums::AuthenticationType::NoThreeDs => None,
};
let test_mode = get_test_mode(item.router_data.resource_common_data.test_mode);
let req_address = item.router_data.resource_common_data.get_optional_billing();
let billing = NovalnetPaymentsRequestBilling {
house_no: item
.router_data
.resource_common_data
.get_optional_billing_line1(),
street: item
.router_data
.resource_common_data
.get_optional_billing_line2(),
city: item
.router_data
.resource_common_data
.get_optional_billing_city()
.map(Secret::new),
zip: item
.router_data
.resource_common_data
.get_optional_billing_zip(),
country_code: item
.router_data
.resource_common_data
.get_optional_billing_country(),
};
let email = item
.router_data
.resource_common_data
.get_billing_email()
.or(item.router_data.request.get_email())?;
let customer = NovalnetPaymentsRequestCustomer {
first_name: req_address.and_then(|addr| addr.get_optional_first_name()),
last_name: req_address.and_then(|addr| addr.get_optional_last_name()),
email,
mobile: item
.router_data
.resource_common_data
.get_optional_billing_phone_number(),
billing: Some(billing),
// no_nc is used to indicate if minimal customer data is passed or not
no_nc: MINIMAL_CUSTOMER_DATA_PASSED,
};
let lang = item
.router_data
.request
.get_optional_language_from_browser_info()
.unwrap_or(DEFAULT_LOCALE.to_string().to_string());
let custom = NovalnetCustom { lang };
let hook_url = item.router_data.request.get_webhook_url()?;
let return_url = item.router_data.request.get_router_return_url()?;
let create_token = Some(CREATE_TOKEN_REQUIRED);
match item.router_data.request.payment_method_data {
PaymentMethodData::Card(ref req_card) => {
let novalnet_card = NovalNetPaymentData::Card(NovalnetCard {
card_number: req_card.card_number.clone(),
card_expiry_month: req_card.card_exp_month.clone(),
card_expiry_year: req_card.card_exp_year.clone(),
card_cvc: req_card.card_cvc.clone(),
| {
"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_353540475883723703_16 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/novalnet/transformers.rs
card_holder: item
.router_data
.resource_common_data
.get_billing_address()?
.get_full_name()?,
});
let transaction = NovalnetPaymentsRequestTransaction {
test_mode,
payment_type: NovalNetPaymentTypes::CREDITCARD,
amount: NovalNetAmount::Int(0),
currency: item.router_data.request.currency,
order_no: item
.router_data
.resource_common_data
.connector_request_reference_id
.clone(),
hook_url: Some(hook_url),
return_url: Some(return_url.clone()),
error_return_url: Some(return_url.clone()),
payment_data: Some(novalnet_card),
enforce_3d,
create_token,
scheme_tid: None,
};
Ok(Self {
merchant,
transaction,
customer,
custom,
})
}
PaymentMethodData::Wallet(ref wallet_data) => match wallet_data {
WalletDataPaymentMethod::GooglePay(ref req_wallet) => {
let novalnet_google_pay: NovalNetPaymentData<T> =
NovalNetPaymentData::GooglePay(NovalnetGooglePay {
wallet_data: Secret::new(
req_wallet
.tokenization_data
.get_encrypted_google_pay_token()
.change_context(errors::ConnectorError::MissingRequiredField {
field_name: "gpay wallet_token",
})?
.clone(),
),
});
let transaction = NovalnetPaymentsRequestTransaction {
test_mode,
payment_type: NovalNetPaymentTypes::GOOGLEPAY,
amount: NovalNetAmount::Int(0),
currency: item.router_data.request.currency,
order_no: item
.router_data
.resource_common_data
.connector_request_reference_id
.clone(),
hook_url: Some(hook_url),
return_url: None,
error_return_url: None,
payment_data: Some(novalnet_google_pay),
enforce_3d,
create_token,
scheme_tid: None,
};
Ok(Self {
merchant,
transaction,
customer,
custom,
})
}
WalletDataPaymentMethod::ApplePay(payment_method_data) => {
let transaction = NovalnetPaymentsRequestTransaction {
test_mode,
payment_type: NovalNetPaymentTypes::APPLEPAY,
amount: NovalNetAmount::Int(0),
currency: item.router_data.request.currency,
order_no: item
.router_data
.resource_common_data
.connector_request_reference_id
.clone(),
hook_url: Some(hook_url),
return_url: None,
error_return_url: None,
payment_data: Some(NovalNetPaymentData::ApplePay(NovalnetApplePay {
wallet_data: payment_method_data.get_applepay_decoded_payment_data()?,
})),
enforce_3d: None,
create_token,
scheme_tid: None,
};
Ok(Self {
| {
"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_353540475883723703_17 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/novalnet/transformers.rs
merchant,
transaction,
customer,
custom,
})
}
WalletDataPaymentMethod::AliPayQr(_)
| WalletDataPaymentMethod::BluecodeRedirect { .. }
| WalletDataPaymentMethod::AliPayRedirect(_)
| WalletDataPaymentMethod::AliPayHkRedirect(_)
| WalletDataPaymentMethod::AmazonPayRedirect(_)
| WalletDataPaymentMethod::MomoRedirect(_)
| WalletDataPaymentMethod::KakaoPayRedirect(_)
| WalletDataPaymentMethod::GoPayRedirect(_)
| WalletDataPaymentMethod::GcashRedirect(_)
| WalletDataPaymentMethod::ApplePayRedirect(_)
| WalletDataPaymentMethod::ApplePayThirdPartySdk(_)
| WalletDataPaymentMethod::DanaRedirect {}
| WalletDataPaymentMethod::GooglePayRedirect(_)
| WalletDataPaymentMethod::GooglePayThirdPartySdk(_)
| WalletDataPaymentMethod::MbWayRedirect(_)
| WalletDataPaymentMethod::MobilePayRedirect(_)
| WalletDataPaymentMethod::RevolutPay(_) => {
Err(errors::ConnectorError::NotImplemented(
utils::get_unimplemented_payment_method_error_message("novalnet"),
))?
}
WalletDataPaymentMethod::PaypalRedirect(_) => {
let transaction = NovalnetPaymentsRequestTransaction {
test_mode,
payment_type: NovalNetPaymentTypes::PAYPAL,
amount: NovalNetAmount::Int(0),
currency: item.router_data.request.currency,
order_no: item
.router_data
.resource_common_data
.connector_request_reference_id
.clone(),
hook_url: Some(hook_url),
return_url: Some(return_url.clone()),
error_return_url: Some(return_url.clone()),
payment_data: None,
enforce_3d: None,
create_token,
scheme_tid: None,
};
Ok(Self {
merchant,
transaction,
customer,
custom,
})
}
WalletDataPaymentMethod::PaypalSdk(_)
| WalletDataPaymentMethod::Paze(_)
| WalletDataPaymentMethod::SamsungPay(_)
| WalletDataPaymentMethod::TwintRedirect {}
| WalletDataPaymentMethod::VippsRedirect {}
| WalletDataPaymentMethod::TouchNGoRedirect(_)
| WalletDataPaymentMethod::WeChatPayRedirect(_)
| WalletDataPaymentMethod::CashappQr(_)
| WalletDataPaymentMethod::SwishQr(_)
| WalletDataPaymentMethod::WeChatPayQr(_)
| WalletDataPaymentMethod::Mifinity(_) => {
Err(errors::ConnectorError::NotImplemented(
utils::get_unimplemented_payment_method_error_message("novalnet"),
))?
}
},
_ => Err(errors::ConnectorError::NotImplemented(
utils::get_unimplemented_payment_method_error_message("novalnet"),
))?,
}
}
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
TryFrom<
NovalnetRouterData<
RouterDataV2<RepeatPayment, PaymentFlowData, RepeatPaymentData, PaymentsResponseData>,
T,
>,
> for NovalnetPaymentsRequest<T>
{
type Error = error_stack::Report<ConnectorError>;
fn try_from(
item: NovalnetRouterData<
RouterDataV2<RepeatPayment, PaymentFlowData, RepeatPaymentData, PaymentsResponseData>,
T,
>,
) -> Result<Self, Self::Error> {
| {
"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_353540475883723703_18 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/novalnet/transformers.rs
let auth = NovalnetAuthType::try_from(&item.router_data.connector_auth_type)?;
let merchant = NovalnetPaymentsRequestMerchant {
signature: auth.product_activation_key,
tariff: auth.tariff_id,
};
let enforce_3d = match item.router_data.resource_common_data.auth_type {
common_enums::AuthenticationType::ThreeDs => Some(1),
common_enums::AuthenticationType::NoThreeDs => None,
};
let test_mode = get_test_mode(item.router_data.resource_common_data.test_mode);
let billing = NovalnetPaymentsRequestBilling {
house_no: item
.router_data
.resource_common_data
.get_optional_billing_line1(),
street: item
.router_data
.resource_common_data
.get_optional_billing_line2(),
city: item
.router_data
.resource_common_data
.get_optional_billing_city()
.map(Secret::new),
zip: item
.router_data
.resource_common_data
.get_optional_billing_zip(),
country_code: item
.router_data
.resource_common_data
.get_optional_billing_country(),
};
let customer = NovalnetPaymentsRequestCustomer {
first_name: item
.router_data
.resource_common_data
.get_optional_billing_first_name(),
last_name: item
.router_data
.resource_common_data
.get_optional_billing_last_name(),
email: item
.router_data
.resource_common_data
.get_billing_email()
.or(item.router_data.request.get_email())?,
mobile: item
.router_data
.resource_common_data
.get_optional_billing_phone_number(),
billing: Some(billing),
// no_nc is used to indicate if minimal customer data is passed or not
no_nc: MINIMAL_CUSTOMER_DATA_PASSED,
};
let lang = item
.router_data
.request
.get_optional_language_from_browser_info()
.unwrap_or(DEFAULT_LOCALE.to_string().to_string());
let custom = NovalnetCustom { lang };
let hook_url = item.router_data.request.get_webhook_url()?;
let amount = item
.connector
.amount_converter
.convert(
item.router_data.request.minor_amount,
item.router_data.request.currency,
)
.change_context(errors::ConnectorError::AmountConversionFailed)?;
match item.router_data.request.mandate_reference {
MandateReferenceId::ConnectorMandateId(mandate_data) => {
let connector_mandate_id = mandate_data.get_connector_mandate_id().ok_or(
errors::ConnectorError::MissingRequiredField {
field_name: "connector_mandate_id",
},
)?;
let novalnet_mandate_data = NovalNetPaymentData::MandatePayment(NovalnetMandate {
token: Secret::new(connector_mandate_id),
});
let payment_type = match item.router_data.request.payment_method_type {
Some(pm_type) => NovalNetPaymentTypes::try_from(&pm_type)?,
None => NovalNetPaymentTypes::CREDITCARD,
};
let transaction = NovalnetPaymentsRequestTransaction {
test_mode,
payment_type,
amount: NovalNetAmount::StringMinor(amount.clone()),
currency: item.router_data.request.currency,
order_no: item
.router_data
.resource_common_data
.connector_request_reference_id
.clone(),
hook_url: Some(hook_url),
return_url: None,
error_return_url: None,
payment_data: Some(novalnet_mandate_data),
| {
"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_353540475883723703_19 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/novalnet/transformers.rs
enforce_3d,
create_token: None,
scheme_tid: None,
};
Ok(Self {
merchant,
transaction,
customer,
custom,
})
}
_ => Err(errors::ConnectorError::NotImplemented(
utils::get_unimplemented_payment_method_error_message("novalnet"),
)
.into()),
}
}
}
pub fn get_incoming_webhook_event(
status: WebhookEventType,
transaction_status: NovalnetTransactionStatus,
) -> EventType {
match status {
WebhookEventType::Payment => match transaction_status {
NovalnetTransactionStatus::Confirmed | NovalnetTransactionStatus::Success => {
EventType::PaymentIntentSuccess
}
NovalnetTransactionStatus::OnHold => EventType::PaymentIntentAuthorizationSuccess,
NovalnetTransactionStatus::Pending => EventType::PaymentIntentProcessing,
NovalnetTransactionStatus::Progress => EventType::IncomingWebhookEventUnspecified,
_ => EventType::PaymentIntentFailure,
},
WebhookEventType::TransactionCapture => match transaction_status {
NovalnetTransactionStatus::Confirmed | NovalnetTransactionStatus::Success => {
EventType::PaymentIntentCaptureSuccess
}
_ => EventType::PaymentIntentCaptureFailure,
},
WebhookEventType::TransactionCancel => match transaction_status {
NovalnetTransactionStatus::Deactivated => EventType::PaymentIntentCancelled,
_ => EventType::PaymentIntentCancelFailure,
},
WebhookEventType::TransactionRefund => match transaction_status {
NovalnetTransactionStatus::Confirmed | NovalnetTransactionStatus::Success => {
EventType::RefundSuccess
}
_ => EventType::RefundFailure,
},
WebhookEventType::Chargeback => EventType::DisputeOpened,
WebhookEventType::Credit => EventType::DisputeWon,
}
}
impl TryFrom<NovalnetWebhookNotificationResponse> for WebhookDetailsResponse {
type Error = error_stack::Report<ConnectorError>;
fn try_from(notif: NovalnetWebhookNotificationResponse) -> Result<Self, Self::Error> {
match notif.transaction {
NovalnetWebhookTransactionData::SyncTransactionData(response) => {
match notif.result.status {
NovalnetAPIStatus::Success => {
let mandate_reference_id =
NovalnetSyncResponseTransactionData::get_token(Some(&response));
let transaction_id = response.tid.map(|tid| tid.expose().to_string());
let transaction_status = response.status;
Ok(Self {
status: common_enums::AttemptStatus::from(transaction_status),
resource_id: Some(
transaction_id
.clone()
.map(ResponseId::ConnectorTransactionId)
.unwrap_or(ResponseId::NoResponseId),
),
mandate_reference: mandate_reference_id
.as_ref()
.map(|id| MandateReference {
connector_mandate_id: Some(id.clone()),
payment_method_id: None,
})
.map(Box::new),
status_code: 200,
connector_response_reference_id: transaction_id.clone(),
error_code: None,
error_message: None,
raw_connector_response: None,
response_headers: None,
minor_amount_captured: None,
amount_captured: None,
error_reason: None,
network_txn_id: response.payment_data.and_then(|payment_data| {
| {
"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_353540475883723703_20 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/novalnet/transformers.rs
match payment_data {
NovalnetResponsePaymentData::Card(card) => {
card.scheme_tid.map(|tid| tid.expose())
}
NovalnetResponsePaymentData::Paypal(_) => None,
}
}),
transformation_status:
common_enums::WebhookTransformationStatus::Complete,
})
}
NovalnetAPIStatus::Failure => Ok(Self {
status: common_enums::AttemptStatus::Failure,
resource_id: None,
status_code: 200,
mandate_reference: None,
connector_response_reference_id: None,
error_code: Some(notif.result.status.to_string()),
error_message: Some(notif.result.status_text),
raw_connector_response: None,
response_headers: None,
minor_amount_captured: None,
amount_captured: None,
error_reason: None,
network_txn_id: None,
transformation_status: common_enums::WebhookTransformationStatus::Complete,
}),
}
}
_ => Err(ConnectorError::WebhookBodyDecodingFailed)?,
}
}
}
impl TryFrom<NovalnetWebhookNotificationResponseRefunds> for RefundWebhookDetailsResponse {
type Error = error_stack::Report<ConnectorError>;
fn try_from(notif: NovalnetWebhookNotificationResponseRefunds) -> Result<Self, Self::Error> {
match notif.result.status {
NovalnetAPIStatus::Success => {
let refund_id = notif
.transaction
.refund
.tid
.map(|tid| tid.expose().to_string())
.ok_or(errors::ConnectorError::ResponseHandlingFailed)?;
let transaction_status = notif.transaction.status;
Ok(Self {
connector_refund_id: Some(refund_id),
status: common_enums::RefundStatus::from(transaction_status),
status_code: 200,
connector_response_reference_id: None,
error_code: None,
error_message: None,
raw_connector_response: None,
response_headers: None,
})
}
NovalnetAPIStatus::Failure => Ok(Self {
status: common_enums::RefundStatus::Failure,
connector_refund_id: None,
status_code: 200,
connector_response_reference_id: None,
error_code: Some(notif.result.status.to_string()),
error_message: Some(notif.result.status_text),
raw_connector_response: None,
response_headers: None,
}),
}
}
}
| {
"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_-3244127140999352642_0 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/adyen/test.rs
#[cfg(test)]
mod tests {
pub mod authorize {
use std::{borrow::Cow, marker::PhantomData, str::FromStr};
use common_utils::{pii::Email, request::RequestContent, types::MinorUnit};
use domain_types::{
connector_flow::Authorize,
connector_types::{
ConnectorEnum, PaymentFlowData, PaymentsAuthorizeData, PaymentsResponseData,
},
payment_method_data::{DefaultPCIHolder, PaymentMethodData, RawCardNumber},
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::Adyen, types::ConnectorData};
#[test]
fn test_build_request_valid() {
let api_key = "test_adyen_api_key".to_string(); // Hardcoded dummy value
let key1 = "test_adyen_key1".to_string(); // Hardcoded dummy value
let req: RouterDataV2<
Authorize,
PaymentFlowData,
PaymentsAuthorizeData<DefaultPCIHolder>,
PaymentsResponseData,
> = RouterDataV2 {
flow: PhantomData::<domain_types::connector_flow::Authorize>,
resource_common_data: PaymentFlowData {
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::Card,
description: Some("Payment for order #12345".to_string()),
return_url: Some("www.google.com".to_string()),
address: domain_types::payment_address::PaymentAddress::new(
None, None, None, None,
),
auth_type: common_enums::AuthenticationType::ThreeDs,
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: "conn_ref_123456789".to_string(),
test_mode: None,
connector_http_status_code: None,
connectors: Connectors {
adyen: ConnectorParams {
base_url: "https://checkout-test.adyen.com/".to_string(),
dispute_base_url: Some("https://ca-test.adyen.com/ca/services/DisputeService/v30/defendDispute".to_string()),
..Default::default()
},
..Default::default()
},
external_latency: None,
connector_response_headers: None,
raw_connector_response: None,
vault_headers: None,
raw_connector_request: None,
minor_amount_capturable: None,
connector_response: None,
recurring_mandate_payment_data: None,
},
connector_auth_type: ConnectorAuthType::BodyKey {
api_key: Secret::new(api_key),
key1: Secret::new(key1),
},
request: PaymentsAuthorizeData {
authentication_data: None,
payment_method_data: PaymentMethodData::Card(
domain_types::payment_method_data::Card {
card_number: RawCardNumber(cards::CardNumber::from_str(
| {
"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_-3244127140999352642_1 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/adyen/test.rs
"5123456789012346",
)
.unwrap()),
card_cvc: Secret::new("100".into()),
card_exp_month: Secret::new("03".into()),
card_exp_year: Secret::new("2030".into()),
..Default::default()
},
),
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("www.google.com".to_string()),
webhook_url: None,
complete_authorize_url: None,
mandate_id: None,
setup_future_usage: None,
off_session: None,
browser_info: Some(
domain_types::router_request_types::BrowserInformation {
color_depth: None,
java_enabled: Some(false),
screen_height: Some(1080),
screen_width: Some(1920),
user_agent: Some(
"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7)".to_string(),
),
accept_header: Some(
"text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8"
.to_string(),
),
java_script_enabled: Some(false),
language: Some("en-US".to_string()),
time_zone: None,
referer: None,
ip_address: None,
os_type: None,
os_version: None,
device_model: None,
accept_language: None,
},
),
order_category: None,
session_token: None,
enrolled_for_3ds: true,
related_transaction_id: None,
payment_experience: None,
payment_method_type: Some(common_enums::PaymentMethodType::Credit),
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,
access_token: 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(Adyen::new());
let connector_data = ConnectorData {
connector,
connector_name: ConnectorEnum::Adyen,
};
let connector_integration: BoxedConnectorIntegrationV2<
'_,
Authorize,
PaymentFlowData,
| {
"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_-3244127140999352642_2 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/adyen/test.rs
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"}),
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() {
let api_key = "test_adyen_api_key_missing".to_string(); // Hardcoded dummy value
let key1 = "test_adyen_key1_missing".to_string(); // Hardcoded dummy value
let req: RouterDataV2<
Authorize,
PaymentFlowData,
PaymentsAuthorizeData<DefaultPCIHolder>,
PaymentsResponseData,
> = RouterDataV2 {
flow: PhantomData::<Authorize>,
resource_common_data: PaymentFlowData {
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::Card,
description: None,
return_url: None,
address: domain_types::payment_address::PaymentAddress::new(
None, None, None, None,
),
auth_type: common_enums::AuthenticationType::ThreeDs,
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 {
adyen: ConnectorParams {
base_url: "https://checkout-test.adyen.com/".to_string(),
dispute_base_url: Some("https://ca-test.adyen.com/ca/services/DisputeService/v30/defendDispute".to_string()),
..Default::default()
},
..Default::default()
},
external_latency: None,
connector_response_headers: None,
raw_connector_response: None,
vault_headers: None,
raw_connector_request: None,
minor_amount_capturable: None,
connector_response: None,
recurring_mandate_payment_data: None,
},
connector_auth_type: ConnectorAuthType::BodyKey {
api_key: Secret::new(api_key),
key1: Secret::new(key1),
},
request: PaymentsAuthorizeData {
authentication_data: 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_-3244127140999352642_3 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/adyen/test.rs
payment_method_data: PaymentMethodData::Card(Default::default()),
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,
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,
access_token: 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(Adyen::new());
let connector_data = ConnectorData {
connector,
connector_name: ConnectorEnum::Adyen,
};
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");
}
// #[test]
// fn test_build_request_invalid() {
// let api_key = env::var("API_KEY").expect("API_KEY not set");
// let key1 = env::var("KEY1").expect("KEY1 not set");
// let req: RouterDataV2<
// Authorize,
// PaymentFlowData,
// PaymentsAuthorizeData,
// PaymentsResponseData
// > = RouterDataV2 {
// flow: PhantomData::<Authorize>,
// resource_common_data: PaymentFlowData {
// merchant_id: common_utils::id_type::MerchantId::default(),
// customer_id: None,
// connector_customer: None,
// payment_id: "pay_invalid".to_string(),
// attempt_id: "attempt_invalid".to_string(),
// status: common_enums::AttemptStatus::Pending,
// payment_method: common_enums::PaymentMethod::Card,
// description: Some("Invalid test".to_string()),
// return_url: None,
// address: domain_types::payment_address::PaymentAddress::new(
// None,
// None,
// None,
// None
// ),
// auth_type: common_enums::AuthenticationType::ThreeDs,
// connector_meta_data: None,
// amount_captured: None,
// minor_amount_captured: None,
// access_token: None,
// session_token: None,
| {
"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_-3244127140999352642_4 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/adyen/test.rs
// reference_id: None,
// payment_method_token: None,
// preprocessing_id: None,
// connector_api_version: None,
// connector_request_reference_id: "invalid_ref".to_string(),
// test_mode: None,
// connector_http_status_code: None,
// connectors: Connectors {
// adyen: ConnectorParams {
// base_url: "https://checkout-test.adyen.com/".to_string(),
// },
// razorpay: ConnectorParams {
// base_url: "https://sandbox.juspay.in/".to_string(),
// },
// },
// external_latency: None,
// },
// connector_auth_type: ConnectorAuthType::BodyKey {
// api_key: Secret::new(api_key.into()),
// key1: Secret::new(key1.into()),
// },
// request: PaymentsAuthorizeData {
// payment_method_data: PaymentMethodData::Card(
// (domain_types::payment_method_data::Card {
// card_number: cards::CardNumber
// ::from_str("1234567890123456")
// .unwrap(),
// card_cvc: Secret::new("12".into()),
// card_exp_month: Secret::new("00".into()), // invalid month
// card_exp_year: Secret::new("1999".into()), // past year
// ..Default::default()
// }).into()
// ),
// amount: 100,
// order_tax_amount: None,
// email: Some("invalid-email".to_string())
// .map(|email_str| Email::try_from(email_str))
// .transpose()
// .unwrap_or(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,
// order_category: None,
// session_token: None,
// enrolled_for_3ds: false,
// related_transaction_id: None,
// payment_experience: None,
// payment_method_type: None,
// customer_id: None,
// request_incremental_authorization: false,
// metadata: None,
// minor_amount: MinorUnit::new(100),
// merchant_order_reference_id: None,
// shipping_cost: None,
// merchant_account_id: None,
// merchant_config_currency: None,
// },
// response: Err(ErrorResponse::default()),
// };
// let connector: BoxedConnector = Box::new(Adyen::new());
// let connector_data = ConnectorData {
// connector,
// connector_name: ConnectorEnum::Adyen,
// };
// let connector_integration: BoxedConnectorIntegrationV2<
// '_,
// Authorize,
// PaymentFlowData,
// PaymentsAuthorizeData,
// PaymentsResponseData
// > = connector_data.connector.get_connector_integration_v2();
// let result = connector_integration.build_request_v2(&req);
// assert!(result.is_err(), "Expected error for invalid fields");
// }
}
}
| {
"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_-8249547783947283321_0 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/adyen/transformers.rs
use base64::{engine::general_purpose::STANDARD, Engine};
use common_enums::{self, AttemptStatus, RefundStatus};
use common_utils::{
consts::{NO_ERROR_CODE, NO_ERROR_MESSAGE},
errors::CustomResult,
ext_traits::{ByteSliceExt, OptionExt},
request::Method,
types::MinorUnit,
};
use domain_types::{
connector_flow::{
Accept, Authorize, Capture, DefendDispute, PSync, Refund, SetupMandate, SubmitEvidence,
Void,
},
connector_types::{
AcceptDisputeData, DisputeDefendData, DisputeFlowData, DisputeResponseData, EventType,
MandateReference, PaymentFlowData, PaymentVoidData, PaymentsAuthorizeData,
PaymentsCaptureData, PaymentsResponseData, PaymentsSyncData, RefundFlowData, RefundsData,
RefundsResponseData, ResponseId, SetupMandateRequestData, SubmitEvidenceData,
},
errors,
payment_method_data::{
Card, PaymentMethodData, PaymentMethodDataTypes, RawCardNumber, WalletData,
},
router_data::{ConnectorAuthType, ErrorResponse},
router_data_v2::RouterDataV2,
router_response_types::RedirectForm,
};
use error_stack::{Report, ResultExt};
use hyperswitch_masking::{ExposeInterface, PeekInterface, Secret};
use serde::{Deserialize, Serialize};
use time::{Duration, OffsetDateTime};
use url::Url;
use super::AdyenRouterData;
use crate::types::ResponseRouterData;
#[derive(Default, Debug, Clone, Serialize, Deserialize)]
pub enum Currency {
#[default]
USD,
EUR,
}
#[derive(Default, Debug, Clone, Serialize, Deserialize)]
pub struct Amount {
pub currency: common_enums::Currency,
pub value: MinorUnit,
}
type Error = error_stack::Report<domain_types::errors::ConnectorError>;
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "lowercase")]
pub enum CardBrand {
Visa,
}
#[derive(Debug, Serialize, PartialEq)]
pub enum ConnectorError {
ParsingFailed,
NotImplemented,
FailedToObtainAuthType,
}
#[serde_with::skip_serializing_none]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct AdyenCard<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> {
number: RawCardNumber<T>,
expiry_month: Secret<String>,
expiry_year: Secret<String>,
cvc: Option<Secret<String>>,
holder_name: Option<Secret<String>>,
brand: Option<CardBrand>, //Mandatory for mandate using network_txns_id
network_payment_reference: Option<Secret<String>>,
}
#[derive(Debug, Clone, Serialize)]
#[serde(tag = "type")]
#[serde(rename_all = "lowercase")]
pub enum AdyenPaymentMethod<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> {
#[serde(rename = "scheme")]
AdyenCard(Box<AdyenCard<T>>),
#[serde(rename = "googlepay")]
Gpay(Box<AdyenGPay>),
ApplePay(Box<AdyenApplePay>),
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
struct AdyenBrowserInfo {
user_agent: String,
accept_header: String,
language: String,
color_depth: u8,
screen_height: u32,
screen_width: u32,
time_zone_offset: i32,
java_enabled: bool,
}
#[derive(Clone, Default, Debug, Serialize, Deserialize)]
pub enum AuthType {
#[default]
PreAuth,
}
#[serde_with::skip_serializing_none]
#[derive(Default, Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Address {
city: String,
country: common_enums::CountryAlpha2,
house_number_or_name: Secret<String>,
postal_code: Secret<String>,
state_or_province: Option<Secret<String>>,
street: Option<Secret<String>>,
}
#[derive(Debug, Clone, Serialize)]
#[serde(untagged)]
pub enum PaymentMethod<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> {
AdyenPaymentMethod(Box<AdyenPaymentMethod<T>>),
}
#[serde_with::skip_serializing_none]
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
struct AdyenMpiData {
directory_response: String,
authentication_response: String,
token_authentication_verification_value: Secret<String>,
eci: Option<String>,
}
#[derive(Default, Debug, Serialize, Deserialize)]
pub enum AdyenShopperInteraction {
#[default]
Ecommerce,
#[serde(rename = "ContAuth")]
| {
"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_-8249547783947283321_1 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/adyen/transformers.rs
ContinuedAuthentication,
Moto,
#[serde(rename = "POS")]
Pos,
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
From<&RouterDataV2<Authorize, PaymentFlowData, PaymentsAuthorizeData<T>, PaymentsResponseData>>
for AdyenShopperInteraction
{
fn from(
item: &RouterDataV2<
Authorize,
PaymentFlowData,
PaymentsAuthorizeData<T>,
PaymentsResponseData,
>,
) -> Self {
match item.request.off_session {
Some(true) => Self::ContinuedAuthentication,
_ => Self::Ecommerce,
}
}
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "PascalCase")]
pub enum AdyenRecurringModel {
UnscheduledCardOnFile,
CardOnFile,
}
#[serde_with::skip_serializing_none]
#[derive(Clone, Default, Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct AdditionalData {
authorisation_type: Option<AuthType>,
manual_capture: Option<String>,
execute_three_d: Option<String>,
pub recurring_processing_model: Option<AdyenRecurringModel>,
/// Enable recurring details in dashboard to receive this ID, https://docs.adyen.com/online-payments/tokenization/create-and-use-tokens#test-and-go-live
#[serde(rename = "recurring.recurringDetailReference")]
recurring_detail_reference: Option<Secret<String>>,
#[serde(rename = "recurring.shopperReference")]
recurring_shopper_reference: Option<String>,
network_tx_reference: Option<Secret<String>>,
funds_availability: Option<String>,
refusal_reason_raw: Option<String>,
refusal_code_raw: Option<String>,
merchant_advice_code: Option<String>,
#[serde(flatten)]
riskdata: Option<RiskData>,
}
#[serde_with::skip_serializing_none]
#[derive(Clone, Default, Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct RiskData {
#[serde(rename = "riskdata.basket.item1.itemID")]
item_i_d: Option<String>,
#[serde(rename = "riskdata.basket.item1.productTitle")]
product_title: Option<String>,
#[serde(rename = "riskdata.basket.item1.amountPerItem")]
amount_per_item: Option<String>,
#[serde(rename = "riskdata.basket.item1.currency")]
currency: Option<String>,
#[serde(rename = "riskdata.basket.item1.upc")]
upc: Option<String>,
#[serde(rename = "riskdata.basket.item1.brand")]
brand: Option<String>,
#[serde(rename = "riskdata.basket.item1.manufacturer")]
manufacturer: Option<String>,
#[serde(rename = "riskdata.basket.item1.category")]
category: Option<String>,
#[serde(rename = "riskdata.basket.item1.quantity")]
quantity: Option<String>,
#[serde(rename = "riskdata.basket.item1.color")]
color: Option<String>,
#[serde(rename = "riskdata.basket.item1.size")]
size: Option<String>,
#[serde(rename = "riskdata.deviceCountry")]
device_country: Option<String>,
#[serde(rename = "riskdata.houseNumberorName")]
house_numberor_name: Option<String>,
#[serde(rename = "riskdata.accountCreationDate")]
account_creation_date: Option<String>,
#[serde(rename = "riskdata.affiliateChannel")]
affiliate_channel: Option<String>,
#[serde(rename = "riskdata.avgOrderValue")]
avg_order_value: Option<String>,
#[serde(rename = "riskdata.deliveryMethod")]
delivery_method: Option<String>,
#[serde(rename = "riskdata.emailName")]
email_name: Option<String>,
#[serde(rename = "riskdata.emailDomain")]
email_domain: Option<String>,
#[serde(rename = "riskdata.lastOrderDate")]
last_order_date: Option<String>,
#[serde(rename = "riskdata.merchantReference")]
merchant_reference: Option<String>,
#[serde(rename = "riskdata.paymentMethod")]
payment_method: Option<String>,
#[serde(rename = "riskdata.promotionName")]
promotion_name: Option<String>,
#[serde(rename = "riskdata.secondaryPhoneNumber")]
secondary_phone_number: Option<Secret<String>>,
#[serde(rename = "riskdata.timefromLogintoOrder")]
timefrom_loginto_order: Option<String>,
#[serde(rename = "riskdata.totalSessionTime")]
total_session_time: Option<String>,
#[serde(rename = "riskdata.totalAuthorizedAmountInLast30Days")]
| {
"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_-8249547783947283321_2 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/adyen/transformers.rs
total_authorized_amount_in_last30_days: Option<String>,
#[serde(rename = "riskdata.totalOrderQuantity")]
total_order_quantity: Option<String>,
#[serde(rename = "riskdata.totalLifetimeValue")]
total_lifetime_value: Option<String>,
#[serde(rename = "riskdata.visitsMonth")]
visits_month: Option<String>,
#[serde(rename = "riskdata.visitsWeek")]
visits_week: Option<String>,
#[serde(rename = "riskdata.visitsYear")]
visits_year: Option<String>,
#[serde(rename = "riskdata.shipToName")]
ship_to_name: Option<String>,
#[serde(rename = "riskdata.first8charactersofAddressLine1Zip")]
first8charactersof_address_line1_zip: Option<String>,
#[serde(rename = "riskdata.affiliateOrder")]
affiliate_order: Option<bool>,
}
#[serde_with::skip_serializing_none]
#[derive(Default, Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ShopperName {
first_name: Option<Secret<String>>,
last_name: Option<Secret<String>>,
}
#[serde_with::skip_serializing_none]
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct LineItem {
amount_excluding_tax: Option<MinorUnit>,
amount_including_tax: Option<MinorUnit>,
description: Option<String>,
id: Option<String>,
tax_amount: Option<MinorUnit>,
quantity: Option<u16>,
}
#[derive(Debug, Clone, Serialize)]
pub enum Channel {
Web,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
struct AdyenSplitData {
amount: Option<Amount>,
#[serde(rename = "type")]
split_type: AdyenSplitType,
account: Option<String>,
reference: String,
description: Option<String>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct AdyenGPay {
#[serde(rename = "googlePayToken")]
google_pay_token: Secret<String>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct AdyenApplePay {
#[serde(rename = "applePayToken")]
apple_pay_token: Secret<String>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "lowercase")]
pub enum PaymentType {
Affirm,
Afterpaytouch,
Alipay,
#[serde(rename = "alipay_hk")]
AlipayHk,
#[serde(rename = "doku_alfamart")]
Alfamart,
Alma,
Applepay,
Bizum,
Atome,
Blik,
#[serde(rename = "boletobancario")]
BoletoBancario,
ClearPay,
Dana,
Eps,
Gcash,
Googlepay,
#[serde(rename = "gopay_wallet")]
GoPay,
Ideal,
#[serde(rename = "doku_indomaret")]
Indomaret,
Klarna,
Kakaopay,
Mbway,
MobilePay,
#[serde(rename = "momo_wallet")]
Momo,
#[serde(rename = "momo_atm")]
MomoAtm,
#[serde(rename = "onlineBanking_CZ")]
OnlineBankingCzechRepublic,
#[serde(rename = "ebanking_FI")]
OnlineBankingFinland,
#[serde(rename = "onlineBanking_PL")]
OnlineBankingPoland,
#[serde(rename = "onlineBanking_SK")]
OnlineBankingSlovakia,
#[serde(rename = "molpay_ebanking_fpx_MY")]
OnlineBankingFpx,
#[serde(rename = "molpay_ebanking_TH")]
OnlineBankingThailand,
#[serde(rename = "paybybank")]
OpenBankingUK,
#[serde(rename = "oxxo")]
Oxxo,
#[serde(rename = "paysafecard")]
PaySafeCard,
PayBright,
Paypal,
Scheme,
#[serde(rename = "networkToken")]
NetworkToken,
#[serde(rename = "trustly")]
Trustly,
#[serde(rename = "touchngo")]
TouchNGo,
Walley,
#[serde(rename = "wechatpayWeb")]
WeChatPayWeb,
#[serde(rename = "ach")]
AchDirectDebit,
SepaDirectDebit,
#[serde(rename = "directdebit_GB")]
BacsDirectDebit,
Samsungpay,
Twint,
Vipps,
Giftcard,
Knet,
Benefit,
Swish,
#[serde(rename = "doku_permata_lite_atm")]
PermataBankTransfer,
#[serde(rename = "doku_bca_va")]
BcaBankTransfer,
#[serde(rename = "doku_bni_va")]
BniVa,
#[serde(rename = "doku_bri_va")]
BriVa,
#[serde(rename = "doku_cimb_va")]
CimbVa,
#[serde(rename = "doku_danamon_va")]
DanamonVa,
#[serde(rename = "doku_mandiri_va")]
MandiriVa,
#[serde(rename = "econtext_seven_eleven")]
SevenEleven,
#[serde(rename = "econtext_stores")]
Lawson,
}
#[derive(
Clone,
Debug,
Eq,
PartialEq,
serde::Deserialize,
serde::Serialize,
strum::Display,
strum::EnumString,
)]
#[strum(serialize_all = "PascalCase")]
#[serde(rename_all = "PascalCase")]
pub enum AdyenSplitType {
| {
"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_-8249547783947283321_3 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/adyen/transformers.rs
/// Books split amount to the specified account.
BalanceAccount,
/// The aggregated amount of the interchange and scheme fees.
AcquiringFees,
/// The aggregated amount of all transaction fees.
PaymentFee,
/// The aggregated amount of Adyen's commission and markup fees.
AdyenFees,
/// The transaction fees due to Adyen under blended rates.
AdyenCommission,
/// The transaction fees due to Adyen under Interchange ++ pricing.
AdyenMarkup,
/// The fees paid to the issuer for each payment made with the card network.
Interchange,
/// The fees paid to the card scheme for using their network.
SchemeFee,
/// Your platform's commission on the payment (specified in amount), booked to your liable balance account.
Commission,
/// Allows you and your users to top up balance accounts using direct debit, card payments, or other payment methods.
TopUp,
/// The value-added tax charged on the payment, booked to your platforms liable balance account.
Vat,
}
#[serde_with::skip_serializing_none]
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct AdyenPaymentRequest<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> {
amount: Amount,
merchant_account: Secret<String>,
payment_method: PaymentMethod<T>,
mpi_data: Option<AdyenMpiData>,
reference: String,
return_url: String,
browser_info: Option<AdyenBrowserInfo>,
shopper_interaction: AdyenShopperInteraction,
recurring_processing_model: Option<AdyenRecurringModel>,
additional_data: Option<AdditionalData>,
shopper_reference: Option<String>,
store_payment_method: Option<bool>,
shopper_name: Option<ShopperName>,
#[serde(rename = "shopperIP")]
shopper_ip: Option<Secret<String, common_utils::pii::IpAddress>>,
shopper_locale: Option<String>,
shopper_email: Option<common_utils::pii::Email>,
shopper_statement: Option<String>,
social_security_number: Option<Secret<String>>,
telephone_number: Option<Secret<String>>,
billing_address: Option<Address>,
delivery_address: Option<Address>,
country_code: Option<common_enums::CountryAlpha2>,
line_items: Option<Vec<LineItem>>,
channel: Option<Channel>,
merchant_order_reference: Option<String>,
splits: Option<Vec<AdyenSplitData>>,
store: Option<String>,
device_fingerprint: Option<Secret<String>>,
}
#[derive(Debug, Serialize)]
pub struct SetupMandateRequest<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>(AdyenPaymentRequest<T>);
#[serde_with::skip_serializing_none]
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct AdyenVoidRequest {
merchant_account: Secret<String>,
reference: String,
}
#[derive(Debug, Serialize)]
pub struct AdyenRouterData1<T> {
pub amount: MinorUnit,
pub router_data: T,
}
impl<T> TryFrom<(MinorUnit, T)> for AdyenRouterData1<T> {
type Error = domain_types::errors::ConnectorError;
fn try_from((amount, item): (MinorUnit, T)) -> Result<Self, Self::Error> {
Ok(Self {
amount,
router_data: item,
})
}
}
fn get_amount_data<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>(
item: &AdyenRouterData<
RouterDataV2<Authorize, PaymentFlowData, PaymentsAuthorizeData<T>, PaymentsResponseData>,
T,
>,
) -> Amount {
Amount {
currency: item.router_data.request.currency,
value: item.router_data.request.minor_amount.to_owned(),
}
}
pub struct AdyenAuthType {
pub(super) api_key: Secret<String>,
pub(super) merchant_account: Secret<String>,
#[allow(dead_code)]
pub(super) review_key: Option<Secret<String>>,
}
impl TryFrom<&ConnectorAuthType> for AdyenAuthType {
type Error = domain_types::errors::ConnectorError;
fn try_from(auth_type: &ConnectorAuthType) -> Result<Self, Self::Error> {
match auth_type {
ConnectorAuthType::BodyKey { api_key, key1 } => Ok(Self {
api_key: api_key.to_owned(),
merchant_account: key1.to_owned(),
review_key: None,
| {
"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_-8249547783947283321_4 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/adyen/transformers.rs
}),
ConnectorAuthType::SignatureKey {
api_key,
key1,
api_secret,
} => Ok(Self {
api_key: api_key.to_owned(),
merchant_account: key1.to_owned(),
review_key: Some(api_secret.to_owned()),
}),
_ => Err(domain_types::errors::ConnectorError::FailedToObtainAuthType),
}
}
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> TryFrom<(&Card<T>, Option<String>)> for AdyenPaymentMethod<T>
{
type Error = domain_types::errors::ConnectorError;
fn try_from((card, card_holder_name): (&Card<T>, Option<String>)) -> Result<Self, Self::Error> {
let adyen_card = AdyenCard {
number: card.card_number.clone(),
expiry_month: card.card_exp_month.clone(),
expiry_year: card.card_exp_year.clone(),
cvc: Some(card.card_cvc.clone()),
holder_name: card_holder_name.map(Secret::new),
brand: Some(CardBrand::Visa),
network_payment_reference: None,
};
Ok(AdyenPaymentMethod::AdyenCard(Box::new(adyen_card)))
}
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
TryFrom<(
&WalletData,
&RouterDataV2<Authorize, PaymentFlowData, PaymentsAuthorizeData<T>, PaymentsResponseData>,
)> for AdyenPaymentMethod<T>
{
type Error = Error;
fn try_from(
value: (
&WalletData,
&RouterDataV2<
Authorize,
PaymentFlowData,
PaymentsAuthorizeData<T>,
PaymentsResponseData,
>,
),
) -> Result<Self, Self::Error> {
let (wallet_data, _item) = value;
match wallet_data {
WalletData::GooglePay(data) => {
let gpay_data = AdyenGPay {
google_pay_token: Secret::new(
data.tokenization_data
.get_encrypted_google_pay_token()
.change_context(errors::ConnectorError::MissingRequiredField {
field_name: "gpay wallet_token",
})?
.to_owned(),
),
};
Ok(AdyenPaymentMethod::Gpay(Box::new(gpay_data)))
}
WalletData::ApplePay(data) => {
let apple_pay_encrypted_data = data
.payment_data
.get_encrypted_apple_pay_payment_data_mandatory()
.change_context(errors::ConnectorError::MissingRequiredField {
field_name: "Apple pay encrypted data",
})?;
let apple_pay_data = AdyenApplePay {
apple_pay_token: Secret::new(apple_pay_encrypted_data.to_string()),
};
Ok(AdyenPaymentMethod::ApplePay(Box::new(apple_pay_data)))
}
WalletData::PaypalRedirect(_)
| WalletData::AmazonPayRedirect(_)
| WalletData::Paze(_)
| WalletData::RevolutPay(_)
| WalletData::AliPayRedirect(_)
| WalletData::AliPayHkRedirect(_)
| WalletData::GoPayRedirect(_)
| WalletData::KakaoPayRedirect(_)
| WalletData::GcashRedirect(_)
| WalletData::MomoRedirect(_)
| WalletData::TouchNGoRedirect(_)
| WalletData::MbWayRedirect(_)
| WalletData::MobilePayRedirect(_)
| WalletData::WeChatPayRedirect(_)
| WalletData::SamsungPay(_)
| WalletData::TwintRedirect { .. }
| WalletData::VippsRedirect { .. }
| WalletData::DanaRedirect { .. }
| WalletData::SwishQr(_)
| WalletData::AliPayQr(_)
| WalletData::ApplePayRedirect(_)
| WalletData::ApplePayThirdPartySdk(_)
| WalletData::GooglePayRedirect(_)
| WalletData::GooglePayThirdPartySdk(_)
| WalletData::PaypalSdk(_)
| {
"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_-8249547783947283321_5 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/adyen/transformers.rs
| WalletData::WeChatPayQr(_)
| WalletData::CashappQr(_)
| WalletData::Mifinity(_)
| WalletData::BluecodeRedirect { .. } => Err(errors::ConnectorError::NotImplemented(
"payment_method".into(),
))?,
}
}
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
TryFrom<(
AdyenRouterData<
RouterDataV2<
Authorize,
PaymentFlowData,
PaymentsAuthorizeData<T>,
PaymentsResponseData,
>,
T,
>,
&Card<T>,
)> for AdyenPaymentRequest<T>
{
type Error = Error;
fn try_from(
value: (
AdyenRouterData<
RouterDataV2<
Authorize,
PaymentFlowData,
PaymentsAuthorizeData<T>,
PaymentsResponseData,
>,
T,
>,
&Card<T>,
),
) -> Result<Self, Self::Error> {
let (item, card_data) = value;
let amount = get_amount_data(&item);
let auth_type = AdyenAuthType::try_from(&item.router_data.connector_auth_type)?;
let shopper_interaction = AdyenShopperInteraction::from(&item.router_data);
let shopper_reference = build_shopper_reference(
&item.router_data.request.customer_id.clone(),
item.router_data.resource_common_data.merchant_id.clone(),
);
let (recurring_processing_model, store_payment_method, _) =
get_recurring_processing_model(&item.router_data)?;
let return_url = item.router_data.request.get_router_return_url()?;
let billing_address = get_address_info(
item.router_data
.resource_common_data
.address
.get_payment_billing(),
)
.and_then(Result::ok);
let card_holder_name = item.router_data.request.customer_name.clone();
let additional_data = get_additional_data(&item.router_data);
let payment_method = PaymentMethod::AdyenPaymentMethod(Box::new(
AdyenPaymentMethod::try_from((card_data, card_holder_name))?,
));
Ok(AdyenPaymentRequest {
amount,
merchant_account: auth_type.merchant_account,
payment_method,
reference: item
.router_data
.resource_common_data
.connector_request_reference_id
.clone(),
return_url,
shopper_interaction,
recurring_processing_model,
browser_info: None,
additional_data,
mpi_data: None,
telephone_number: None,
shopper_name: None,
shopper_email: None,
shopper_locale: None,
social_security_number: None,
billing_address,
delivery_address: None,
country_code: None,
line_items: None,
shopper_reference,
store_payment_method,
channel: None,
shopper_statement: item.router_data.request.statement_descriptor.clone(),
shopper_ip: None,
merchant_order_reference: item.router_data.request.merchant_order_reference_id.clone(),
store: None,
splits: None,
device_fingerprint: None,
})
}
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
TryFrom<(
AdyenRouterData<
RouterDataV2<
Authorize,
PaymentFlowData,
PaymentsAuthorizeData<T>,
PaymentsResponseData,
>,
T,
>,
&WalletData,
)> for AdyenPaymentRequest<T>
{
type Error = Error;
fn try_from(
value: (
AdyenRouterData<
RouterDataV2<
Authorize,
PaymentFlowData,
PaymentsAuthorizeData<T>,
PaymentsResponseData,
>,
T,
>,
| {
"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_-8249547783947283321_6 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/adyen/transformers.rs
&WalletData,
),
) -> Result<Self, Self::Error> {
let (item, wallet_data) = value;
let amount = get_amount_data(&item);
let auth_type = AdyenAuthType::try_from(&item.router_data.connector_auth_type)?;
let payment_method = PaymentMethod::AdyenPaymentMethod(Box::new(
AdyenPaymentMethod::try_from((wallet_data, &item.router_data))?,
));
let shopper_interaction = AdyenShopperInteraction::from(&item.router_data);
let (recurring_processing_model, store_payment_method, shopper_reference) =
get_recurring_processing_model(&item.router_data)?;
let return_url = item.router_data.request.get_router_return_url()?;
let additional_data = get_additional_data(&item.router_data);
Ok(AdyenPaymentRequest {
amount,
merchant_account: auth_type.merchant_account,
payment_method,
reference: item
.router_data
.resource_common_data
.connector_request_reference_id
.clone(),
return_url,
shopper_interaction,
recurring_processing_model,
browser_info: None,
additional_data,
mpi_data: None,
telephone_number: None,
shopper_name: None,
shopper_email: None,
shopper_locale: None,
social_security_number: None,
billing_address: None,
delivery_address: None,
country_code: None,
line_items: None,
shopper_reference,
store_payment_method,
channel: None,
shopper_statement: item.router_data.request.statement_descriptor.clone(),
shopper_ip: None,
merchant_order_reference: item.router_data.request.merchant_order_reference_id.clone(),
store: None,
splits: None,
device_fingerprint: None,
})
}
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
TryFrom<
AdyenRouterData<
RouterDataV2<
Authorize,
PaymentFlowData,
PaymentsAuthorizeData<T>,
PaymentsResponseData,
>,
T,
>,
> for AdyenPaymentRequest<T>
{
type Error = Error;
fn try_from(
item: AdyenRouterData<
RouterDataV2<
Authorize,
PaymentFlowData,
PaymentsAuthorizeData<T>,
PaymentsResponseData,
>,
T,
>,
) -> Result<Self, Self::Error> {
match item
.router_data
.request
.mandate_id
.to_owned()
.and_then(|mandate_ids| mandate_ids.mandate_reference_id)
{
Some(_mandate_ref) => Err(domain_types::errors::ConnectorError::NotImplemented(
"payment_method".into(),
))?,
None => match item.router_data.request.payment_method_data.clone() {
PaymentMethodData::Card(ref card) => AdyenPaymentRequest::try_from((item, card)),
PaymentMethodData::Wallet(ref wallet_data) => {
AdyenPaymentRequest::try_from((item, wallet_data))
}
PaymentMethodData::PayLater(_)
| PaymentMethodData::BankRedirect(_)
| PaymentMethodData::BankDebit(_)
| PaymentMethodData::BankTransfer(_)
| PaymentMethodData::CardRedirect(_)
| PaymentMethodData::Voucher(_)
| PaymentMethodData::GiftCard(_)
| PaymentMethodData::Crypto(_)
| PaymentMethodData::MandatePayment
| PaymentMethodData::Reward
| PaymentMethodData::RealTimePayment(_)
| PaymentMethodData::Upi(_)
| PaymentMethodData::OpenBanking(_)
| PaymentMethodData::CardDetailsForNetworkTransactionId(_)
| PaymentMethodData::NetworkToken(_)
| PaymentMethodData::MobilePayment(_)
| PaymentMethodData::CardToken(_) => Err(
| {
"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_-8249547783947283321_7 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/adyen/transformers.rs
domain_types::errors::ConnectorError::NotImplemented("payment method".into()),
)?,
},
}
}
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
TryFrom<
AdyenRouterData<
RouterDataV2<PSync, PaymentFlowData, PaymentsSyncData, PaymentsResponseData>,
T,
>,
> for AdyenRedirectRequest
{
type Error = Error;
fn try_from(
item: AdyenRouterData<
RouterDataV2<PSync, PaymentFlowData, PaymentsSyncData, PaymentsResponseData>,
T,
>,
) -> Result<Self, Self::Error> {
let encoded_data = item
.router_data
.request
.encoded_data
.clone()
.get_required_value("encoded_data")
.change_context(errors::ConnectorError::RequestEncodingFailed)?;
let adyen_redirection_type =
serde_urlencoded::from_str::<AdyenRedirectRequestTypes>(encoded_data.as_str())
.change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
let adyen_redirect_request = match adyen_redirection_type {
AdyenRedirectRequestTypes::AdyenRedirection(req) => AdyenRedirectRequest {
details: AdyenRedirectRequestTypes::AdyenRedirection(AdyenRedirection {
redirect_result: req.redirect_result,
type_of_redirection_result: None,
result_code: None,
}),
},
AdyenRedirectRequestTypes::AdyenThreeDS(req) => AdyenRedirectRequest {
details: AdyenRedirectRequestTypes::AdyenThreeDS(AdyenThreeDS {
three_ds_result: req.three_ds_result,
type_of_redirection_result: None,
result_code: None,
}),
},
AdyenRedirectRequestTypes::AdyenRefusal(req) => AdyenRedirectRequest {
details: AdyenRedirectRequestTypes::AdyenRefusal(AdyenRefusal {
payload: req.payload,
type_of_redirection_result: None,
result_code: None,
}),
},
};
Ok(adyen_redirect_request)
}
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
TryFrom<
AdyenRouterData<
RouterDataV2<Void, PaymentFlowData, PaymentVoidData, PaymentsResponseData>,
T,
>,
> for AdyenVoidRequest
{
type Error = Error;
fn try_from(
item: AdyenRouterData<
RouterDataV2<Void, PaymentFlowData, PaymentVoidData, PaymentsResponseData>,
T,
>,
) -> Result<Self, Self::Error> {
let auth_type = AdyenAuthType::try_from(&item.router_data.connector_auth_type)?;
Ok(Self {
merchant_account: auth_type.merchant_account,
reference: item.router_data.request.connector_transaction_id.clone(),
})
}
}
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(untagged)]
pub enum AdyenPaymentResponse {
Response(Box<AdyenResponse>),
RedirectionResponse(Box<RedirectionResponse>),
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct AdyenPSyncResponse(AdyenPaymentResponse);
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct SetupMandateResponse(AdyenPaymentResponse);
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct AdyenResponse {
psp_reference: String,
result_code: AdyenStatus,
amount: Option<Amount>,
merchant_reference: String,
refusal_reason: Option<String>,
refusal_reason_code: Option<String>,
additional_data: Option<AdditionalData>,
splits: Option<Vec<AdyenSplitData>>,
store: Option<String>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct AdyenVoidResponse {
payment_psp_reference: String,
status: AdyenVoidStatus,
reference: String,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct RedirectionResponse {
result_code: AdyenStatus,
| {
"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_-8249547783947283321_8 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/adyen/transformers.rs
action: AdyenRedirectAction,
refusal_reason: Option<String>,
refusal_reason_code: Option<String>,
psp_reference: Option<String>,
merchant_reference: Option<String>,
store: Option<String>,
splits: Option<Vec<AdyenSplitData>>,
additional_data: Option<AdditionalData>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct AdyenRedirectAction {
payment_method_type: PaymentType,
url: Option<Url>,
method: Option<common_utils::request::Method>,
#[serde(rename = "type")]
type_of_response: ActionType,
data: Option<std::collections::HashMap<String, String>>,
payment_data: Option<String>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "lowercase")]
pub enum ActionType {
Redirect,
Await,
#[serde(rename = "qrCode")]
QrCode,
Voucher,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum AdyenStatus {
AuthenticationFinished,
AuthenticationNotRequired,
Authorised,
Cancelled,
ChallengeShopper,
Error,
Pending,
Received,
RedirectShopper,
Refused,
PresentToShopper,
}
#[derive(Default, Debug, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum CaptureMethod {
/// Post the payment authorization, the capture will be executed on the full amount immediately
#[default]
Automatic,
/// The capture will happen only if the merchant triggers a Capture API request
Manual,
/// The capture will happen only if the merchant triggers a Capture API request
ManualMultiple,
/// The capture can be scheduled to automatically get triggered at a specific date & time
Scheduled,
/// Handles separate auth and capture sequentially; same as `Automatic` for most connectors.
SequentialAutomatic,
}
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum PaymentMethodType {
Credit,
}
pub trait ForeignTryFrom<F>: Sized {
type Error;
fn foreign_try_from(from: F) -> Result<Self, Self::Error>;
}
fn get_adyen_payment_status(
is_manual_capture: bool,
adyen_status: AdyenStatus,
_pmt: Option<common_enums::PaymentMethodType>,
) -> AttemptStatus {
match adyen_status {
AdyenStatus::AuthenticationFinished => AttemptStatus::AuthenticationSuccessful,
AdyenStatus::AuthenticationNotRequired | AdyenStatus::Received => AttemptStatus::Pending,
AdyenStatus::Authorised => match is_manual_capture {
true => AttemptStatus::Authorized,
// In case of Automatic capture Authorized is the final status of the payment
false => AttemptStatus::Charged,
},
AdyenStatus::Cancelled => AttemptStatus::Voided,
AdyenStatus::ChallengeShopper
| AdyenStatus::RedirectShopper
| AdyenStatus::PresentToShopper => AttemptStatus::AuthenticationPending,
AdyenStatus::Error | AdyenStatus::Refused => AttemptStatus::Failure,
AdyenStatus::Pending => AttemptStatus::Pending,
}
}
impl<
F,
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> TryFrom<ResponseRouterData<AdyenPaymentResponse, Self>>
for RouterDataV2<F, PaymentFlowData, PaymentsAuthorizeData<T>, PaymentsResponseData>
{
type Error = Error;
fn try_from(
value: ResponseRouterData<AdyenPaymentResponse, Self>,
) -> Result<Self, Self::Error> {
let ResponseRouterData {
response,
router_data,
http_code,
} = value;
let is_manual_capture = false;
let pmt = router_data.request.payment_method_type;
let (status, error, payment_response_data) = match response {
AdyenPaymentResponse::Response(response) => {
get_adyen_response(*response, is_manual_capture, http_code, pmt)?
}
AdyenPaymentResponse::RedirectionResponse(response) => {
get_redirection_response(*response, is_manual_capture, http_code, pmt)?
}
};
Ok(Self {
response: error.map_or_else(|| Ok(payment_response_data), Err),
resource_common_data: PaymentFlowData {
status,
..router_data.resource_common_data
| {
"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_-8249547783947283321_9 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/adyen/transformers.rs
},
..router_data
})
}
}
impl<F> TryFrom<ResponseRouterData<AdyenPSyncResponse, Self>>
for RouterDataV2<F, PaymentFlowData, PaymentsSyncData, PaymentsResponseData>
{
type Error = Error;
fn try_from(value: ResponseRouterData<AdyenPSyncResponse, Self>) -> Result<Self, Self::Error> {
let ResponseRouterData {
response,
router_data,
http_code,
} = value;
let pmt = router_data.request.payment_method_type;
let is_manual_capture = false;
let (status, error, payment_response_data) = match response {
AdyenPSyncResponse(AdyenPaymentResponse::Response(response)) => {
get_adyen_response(*response, is_manual_capture, http_code, pmt)?
}
AdyenPSyncResponse(AdyenPaymentResponse::RedirectionResponse(response)) => {
get_redirection_response(*response, is_manual_capture, http_code, pmt)?
}
};
Ok(Self {
response: error.map_or_else(|| Ok(payment_response_data), Err),
resource_common_data: PaymentFlowData {
status,
..router_data.resource_common_data
},
..router_data
})
}
}
#[derive(Default, Debug, Deserialize, Serialize, Clone)]
#[serde(rename_all = "lowercase")]
pub enum AdyenVoidStatus {
Received,
#[default]
Processing,
}
impl ForeignTryFrom<AdyenVoidStatus> for common_enums::AttemptStatus {
type Error = domain_types::errors::ConnectorError;
fn foreign_try_from(item: AdyenVoidStatus) -> Result<Self, Self::Error> {
match item {
AdyenVoidStatus::Received => Ok(Self::Voided),
AdyenVoidStatus::Processing => Ok(Self::VoidInitiated),
}
}
}
impl TryFrom<ResponseRouterData<AdyenVoidResponse, Self>>
for RouterDataV2<Void, PaymentFlowData, PaymentVoidData, PaymentsResponseData>
{
type Error = Error;
fn try_from(value: ResponseRouterData<AdyenVoidResponse, Self>) -> Result<Self, Self::Error> {
let ResponseRouterData {
response,
router_data,
http_code,
} = value;
let status = AttemptStatus::Pending;
let payment_void_response_data = PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(response.payment_psp_reference),
redirection_data: None,
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: Some(response.reference),
incremental_authorization_allowed: None,
mandate_reference: None,
status_code: http_code,
};
Ok(Self {
response: Ok(payment_void_response_data),
resource_common_data: PaymentFlowData {
status,
..router_data.resource_common_data
},
..router_data
})
}
}
pub fn get_adyen_response(
response: AdyenResponse,
is_capture_manual: bool,
status_code: u16,
pmt: Option<common_enums::PaymentMethodType>,
) -> CustomResult<
(
common_enums::AttemptStatus,
Option<domain_types::router_data::ErrorResponse>,
PaymentsResponseData,
),
domain_types::errors::ConnectorError,
> {
let status = get_adyen_payment_status(is_capture_manual, response.result_code, pmt);
let error = if response.refusal_reason.is_some()
|| response.refusal_reason_code.is_some()
|| status == common_enums::AttemptStatus::Failure
{
Some(domain_types::router_data::ErrorResponse {
code: response
.refusal_reason_code
.unwrap_or_else(|| NO_ERROR_CODE.to_string()),
message: response
.refusal_reason
.clone()
.unwrap_or_else(|| NO_ERROR_MESSAGE.to_string()),
reason: response.refusal_reason,
status_code,
attempt_status: Some(common_enums::AttemptStatus::Failure),
connector_transaction_id: Some(response.psp_reference.clone()),
network_decline_code: None,
network_advice_code: None,
network_error_message: None,
})
} else {
None
};
let mandate_reference = response
| {
"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_-8249547783947283321_10 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/adyen/transformers.rs
.additional_data
.as_ref()
.and_then(|data| data.recurring_detail_reference.to_owned())
.map(|mandate_id| MandateReference {
connector_mandate_id: Some(mandate_id.expose()),
payment_method_id: None,
});
let network_txn_id = response.additional_data.and_then(|additional_data| {
additional_data
.network_tx_reference
.map(|network_tx_id| network_tx_id.expose())
});
let payments_response_data = PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(response.psp_reference),
redirection_data: None,
connector_metadata: None,
network_txn_id,
connector_response_reference_id: Some(response.merchant_reference),
incremental_authorization_allowed: None,
mandate_reference: mandate_reference.map(Box::new),
status_code,
};
Ok((status, error, payments_response_data))
}
pub fn get_redirection_response(
response: RedirectionResponse,
is_manual_capture: bool,
status_code: u16,
pmt: Option<common_enums::PaymentMethodType>,
) -> CustomResult<
(
common_enums::AttemptStatus,
Option<ErrorResponse>,
PaymentsResponseData,
),
domain_types::errors::ConnectorError,
> {
let status = get_adyen_payment_status(is_manual_capture, response.result_code.clone(), pmt);
let error = if response.refusal_reason.is_some()
|| response.refusal_reason_code.is_some()
|| status == common_enums::AttemptStatus::Failure
{
Some(ErrorResponse {
code: response
.refusal_reason_code
.clone()
.unwrap_or_else(|| NO_ERROR_CODE.to_string()),
message: response
.refusal_reason
.clone()
.unwrap_or_else(|| NO_ERROR_MESSAGE.to_string()),
reason: response.refusal_reason.to_owned(),
status_code,
attempt_status: None,
connector_transaction_id: response.psp_reference.clone(),
network_decline_code: None,
network_advice_code: None,
network_error_message: None,
})
} else {
None
};
let redirection_data = response.action.url.clone().map(|url| {
let form_fields = response.action.data.clone().unwrap_or_else(|| {
std::collections::HashMap::from_iter(
url.query_pairs()
.map(|(key, value)| (key.to_string(), value.to_string())),
)
});
RedirectForm::Form {
endpoint: url.to_string(),
method: response.action.method.unwrap_or(Method::Get),
form_fields,
}
});
let connector_metadata = get_wait_screen_metadata(&response)?;
let payments_response_data = PaymentsResponseData::TransactionResponse {
resource_id: match response.psp_reference.as_ref() {
Some(psp) => ResponseId::ConnectorTransactionId(psp.to_string()),
None => ResponseId::NoResponseId,
},
redirection_data: redirection_data.map(Box::new),
connector_metadata,
network_txn_id: None,
connector_response_reference_id: response
.merchant_reference
.clone()
.or(response.psp_reference),
incremental_authorization_allowed: None,
mandate_reference: None,
status_code,
};
Ok((status, error, payments_response_data))
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct WaitScreenData {
display_from_timestamp: i128,
display_to_timestamp: Option<i128>,
}
pub fn get_wait_screen_metadata(
next_action: &RedirectionResponse,
) -> CustomResult<Option<serde_json::Value>, domain_types::errors::ConnectorError> {
match next_action.action.payment_method_type {
PaymentType::Blik => {
let current_time = OffsetDateTime::now_utc().unix_timestamp_nanos();
Ok(Some(serde_json::json!(WaitScreenData {
display_from_timestamp: current_time,
display_to_timestamp: Some(current_time + Duration::minutes(1).whole_nanoseconds())
})))
}
PaymentType::Mbway => {
| {
"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_-8249547783947283321_11 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/adyen/transformers.rs
let current_time = OffsetDateTime::now_utc().unix_timestamp_nanos();
Ok(Some(serde_json::json!(WaitScreenData {
display_from_timestamp: current_time,
display_to_timestamp: None
})))
}
PaymentType::Affirm
| PaymentType::Oxxo
| PaymentType::Afterpaytouch
| PaymentType::Alipay
| PaymentType::AlipayHk
| PaymentType::Alfamart
| PaymentType::Alma
| PaymentType::Applepay
| PaymentType::Bizum
| PaymentType::Atome
| PaymentType::BoletoBancario
| PaymentType::ClearPay
| PaymentType::Dana
| PaymentType::Eps
| PaymentType::Gcash
| PaymentType::Googlepay
| PaymentType::GoPay
| PaymentType::Ideal
| PaymentType::Indomaret
| PaymentType::Klarna
| PaymentType::Kakaopay
| PaymentType::MobilePay
| PaymentType::Momo
| PaymentType::MomoAtm
| PaymentType::OnlineBankingCzechRepublic
| PaymentType::OnlineBankingFinland
| PaymentType::OnlineBankingPoland
| PaymentType::OnlineBankingSlovakia
| PaymentType::OnlineBankingFpx
| PaymentType::OnlineBankingThailand
| PaymentType::OpenBankingUK
| PaymentType::PayBright
| PaymentType::Paypal
| PaymentType::Scheme
| PaymentType::NetworkToken
| PaymentType::Trustly
| PaymentType::TouchNGo
| PaymentType::Walley
| PaymentType::WeChatPayWeb
| PaymentType::AchDirectDebit
| PaymentType::SepaDirectDebit
| PaymentType::BacsDirectDebit
| PaymentType::Samsungpay
| PaymentType::Twint
| PaymentType::Vipps
| PaymentType::Swish
| PaymentType::Knet
| PaymentType::Benefit
| PaymentType::PermataBankTransfer
| PaymentType::BcaBankTransfer
| PaymentType::BniVa
| PaymentType::BriVa
| PaymentType::CimbVa
| PaymentType::DanamonVa
| PaymentType::Giftcard
| PaymentType::MandiriVa
| PaymentType::PaySafeCard
| PaymentType::SevenEleven
| PaymentType::Lawson => Ok(None),
}
}
#[derive(Debug, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct AdyenErrorResponse {
pub status: i32,
pub error_code: String,
pub message: String,
pub error_type: String,
pub psp_reference: Option<String>,
}
#[derive(Clone, Debug, Deserialize, Serialize, strum::Display, PartialEq)]
#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
#[strum(serialize_all = "SCREAMING_SNAKE_CASE")]
pub enum WebhookEventCode {
Authorisation,
Cancellation,
Capture,
CaptureFailed,
Refund,
RefundFailed,
RefundReversed,
CancelOrRefund,
NotificationOfChargeback,
Chargeback,
ChargebackReversed,
SecondChargeback,
PrearbitrationWon,
PrearbitrationLost,
}
#[derive(Debug, Deserialize)]
pub enum DisputeStatus {
Undefended,
Pending,
Lost,
Accepted,
Won,
}
#[derive(Debug, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct AdyenAdditionalDataWH {
pub dispute_status: Option<DisputeStatus>,
pub chargeback_reason_code: Option<String>,
}
#[derive(Debug, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct AdyenNotificationRequestItemWH {
pub original_reference: Option<String>,
pub psp_reference: String,
pub amount: AdyenAmountWH,
pub event_code: WebhookEventCode,
pub merchant_account_code: String,
pub merchant_reference: String,
pub success: String,
pub reason: Option<String>,
pub additional_data: AdyenAdditionalDataWH,
}
#[derive(Debug, Deserialize)]
pub struct AdyenAmountWH {
pub value: MinorUnit,
pub currency: common_enums::Currency,
}
fn is_success_scenario(is_success: &str) -> bool {
is_success == "true"
}
pub(crate) fn get_adyen_payment_webhook_event(
code: WebhookEventCode,
is_success: String,
) -> Result<AttemptStatus, errors::ConnectorError> {
match code {
WebhookEventCode::Authorisation => {
if is_success_scenario(&is_success) {
Ok(AttemptStatus::Authorized)
} else {
Ok(AttemptStatus::Failure)
}
}
WebhookEventCode::Cancellation => {
if is_success_scenario(&is_success) {
| {
"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_-8249547783947283321_12 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/adyen/transformers.rs
Ok(AttemptStatus::Voided)
} else {
Ok(AttemptStatus::Authorized)
}
}
WebhookEventCode::Capture => {
if is_success_scenario(&is_success) {
Ok(AttemptStatus::Charged)
} else {
Ok(AttemptStatus::Failure)
}
}
WebhookEventCode::CaptureFailed => Ok(AttemptStatus::Failure),
_ => Err(errors::ConnectorError::RequestEncodingFailed),
}
}
pub(crate) fn get_adyen_refund_webhook_event(
code: WebhookEventCode,
is_success: String,
) -> Result<RefundStatus, errors::ConnectorError> {
match code {
WebhookEventCode::Refund | WebhookEventCode::CancelOrRefund => {
if is_success_scenario(&is_success) {
Ok(RefundStatus::Success)
} else {
Ok(RefundStatus::Failure)
}
}
WebhookEventCode::RefundFailed | WebhookEventCode::RefundReversed => {
Ok(RefundStatus::Failure)
}
_ => Err(errors::ConnectorError::RequestEncodingFailed),
}
}
pub(crate) fn get_adyen_webhook_event_type(code: WebhookEventCode) -> EventType {
match code {
WebhookEventCode::Authorisation => EventType::PaymentIntentAuthorizationSuccess,
WebhookEventCode::Cancellation => EventType::PaymentIntentCancelled,
WebhookEventCode::Capture => EventType::PaymentIntentCaptureSuccess,
WebhookEventCode::CaptureFailed => EventType::PaymentIntentCaptureFailure,
WebhookEventCode::Refund | WebhookEventCode::CancelOrRefund => EventType::RefundSuccess,
WebhookEventCode::RefundFailed | WebhookEventCode::RefundReversed => {
EventType::RefundFailure
}
WebhookEventCode::NotificationOfChargeback | WebhookEventCode::Chargeback => {
EventType::DisputeOpened
}
WebhookEventCode::ChargebackReversed | WebhookEventCode::PrearbitrationWon => {
EventType::DisputeWon
}
WebhookEventCode::SecondChargeback | WebhookEventCode::PrearbitrationLost => {
EventType::DisputeLost
}
}
}
#[derive(Debug, Deserialize)]
#[serde(rename_all = "PascalCase")]
pub struct AdyenItemObjectWH {
pub notification_request_item: AdyenNotificationRequestItemWH,
}
#[derive(Debug, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct AdyenIncomingWebhook {
pub notification_items: Vec<AdyenItemObjectWH>,
}
pub fn get_webhook_object_from_body(
body: Vec<u8>,
) -> Result<AdyenNotificationRequestItemWH, error_stack::Report<errors::ConnectorError>> {
let mut webhook: AdyenIncomingWebhook = body
.parse_struct("AdyenIncomingWebhook")
.change_context(errors::ConnectorError::WebhookBodyDecodingFailed)?;
let item_object = webhook
.notification_items
.drain(..)
.next()
.ok_or(errors::ConnectorError::WebhookBodyDecodingFailed)?;
Ok(item_object.notification_request_item)
}
fn build_shopper_reference(
customer_id: &Option<common_utils::id_type::CustomerId>,
merchant_id: common_utils::id_type::MerchantId,
) -> Option<String> {
customer_id.clone().map(|c_id| {
format!(
"{}_{}",
merchant_id.get_string_repr(),
c_id.get_string_repr()
)
})
}
type RecurringDetails = (Option<AdyenRecurringModel>, Option<bool>, Option<String>);
fn get_recurring_processing_model<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>(
item: &RouterDataV2<Authorize, PaymentFlowData, PaymentsAuthorizeData<T>, PaymentsResponseData>,
) -> Result<RecurringDetails, Error> {
let customer_id = item
.request
.customer_id
.clone()
.ok_or_else(Box::new(move || {
errors::ConnectorError::MissingRequiredField {
field_name: "customer_id",
}
}))?;
match (item.request.setup_future_usage, item.request.off_session) {
(Some(common_enums::FutureUsage::OffSession), _) => {
let shopper_reference = format!(
"{}_{}",
item.resource_common_data.merchant_id.get_string_repr(),
customer_id.get_string_repr()
);
| {
"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_-8249547783947283321_13 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/adyen/transformers.rs
let store_payment_method = is_mandate_payment(item);
Ok((
Some(AdyenRecurringModel::UnscheduledCardOnFile),
Some(store_payment_method),
Some(shopper_reference),
))
}
(_, Some(true)) => Ok((
Some(AdyenRecurringModel::UnscheduledCardOnFile),
None,
Some(format!(
"{}_{}",
item.resource_common_data.merchant_id.get_string_repr(),
customer_id.get_string_repr()
)),
)),
_ => Ok((None, None, None)),
}
}
fn is_mandate_payment<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>(
item: &RouterDataV2<Authorize, PaymentFlowData, PaymentsAuthorizeData<T>, PaymentsResponseData>,
) -> bool {
(item.request.setup_future_usage == Some(common_enums::FutureUsage::OffSession))
|| item
.request
.mandate_id
.as_ref()
.and_then(|mandate_ids| mandate_ids.mandate_reference_id.as_ref())
.is_some()
}
pub fn get_address_info(
address: Option<&domain_types::payment_address::Address>,
) -> Option<Result<Address, error_stack::Report<domain_types::errors::ConnectorError>>> {
address.and_then(|add| {
add.address.as_ref().map(
|a| -> Result<Address, error_stack::Report<domain_types::errors::ConnectorError>> {
Ok(Address {
city: a.city.clone().unwrap(),
country: a.country.unwrap(),
house_number_or_name: a.line1.clone().unwrap(),
postal_code: a.zip.clone().unwrap(),
state_or_province: a.state.clone(),
street: a.line2.clone(),
})
},
)
})
}
fn get_additional_data<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>(
item: &RouterDataV2<Authorize, PaymentFlowData, PaymentsAuthorizeData<T>, PaymentsResponseData>,
) -> Option<AdditionalData> {
let (authorisation_type, manual_capture) = match item.request.capture_method {
Some(common_enums::CaptureMethod::Manual)
| Some(common_enums::CaptureMethod::ManualMultiple) => {
(Some(AuthType::PreAuth), Some("true".to_string()))
}
_ => (None, None),
};
let riskdata = item.request.metadata.clone().and_then(get_risk_data);
let execute_three_d = if matches!(
item.resource_common_data.auth_type,
common_enums::AuthenticationType::ThreeDs
) {
Some("true".to_string())
} else {
None
};
if authorisation_type.is_none()
&& manual_capture.is_none()
&& execute_three_d.is_none()
&& riskdata.is_none()
{
//without this if-condition when the above 3 values are None, additionalData will be serialized to JSON like this -> additionalData: {}
//returning None, ensures that additionalData key will not be present in the serialized JSON
None
} else {
Some(AdditionalData {
authorisation_type,
manual_capture,
execute_three_d,
network_tx_reference: None,
recurring_detail_reference: None,
recurring_shopper_reference: None,
recurring_processing_model: None,
riskdata,
..AdditionalData::default()
})
}
}
pub fn get_risk_data(metadata: serde_json::Value) -> Option<RiskData> {
let item_i_d = get_str("riskdata.basket.item1.itemID", &metadata);
let product_title = get_str("riskdata.basket.item1.productTitle", &metadata);
let amount_per_item = get_str("riskdata.basket.item1.amountPerItem", &metadata);
let currency = get_str("riskdata.basket.item1.currency", &metadata);
let upc = get_str("riskdata.basket.item1.upc", &metadata);
let brand = get_str("riskdata.basket.item1.brand", &metadata);
let manufacturer = get_str("riskdata.basket.item1.manufacturer", &metadata);
let category = get_str("riskdata.basket.item1.category", &metadata);
let quantity = get_str("riskdata.basket.item1.quantity", &metadata);
| {
"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_-8249547783947283321_14 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/adyen/transformers.rs
let color = get_str("riskdata.basket.item1.color", &metadata);
let size = get_str("riskdata.basket.item1.size", &metadata);
let device_country = get_str("riskdata.deviceCountry", &metadata);
let house_numberor_name = get_str("riskdata.houseNumberorName", &metadata);
let account_creation_date = get_str("riskdata.accountCreationDate", &metadata);
let affiliate_channel = get_str("riskdata.affiliateChannel", &metadata);
let avg_order_value = get_str("riskdata.avgOrderValue", &metadata);
let delivery_method = get_str("riskdata.deliveryMethod", &metadata);
let email_name = get_str("riskdata.emailName", &metadata);
let email_domain = get_str("riskdata.emailDomain", &metadata);
let last_order_date = get_str("riskdata.lastOrderDate", &metadata);
let merchant_reference = get_str("riskdata.merchantReference", &metadata);
let payment_method = get_str("riskdata.paymentMethod", &metadata);
let promotion_name = get_str("riskdata.promotionName", &metadata);
let secondary_phone_number = get_str("riskdata.secondaryPhoneNumber", &metadata);
let timefrom_loginto_order = get_str("riskdata.timefromLogintoOrder", &metadata);
let total_session_time = get_str("riskdata.totalSessionTime", &metadata);
let total_authorized_amount_in_last30_days =
get_str("riskdata.totalAuthorizedAmountInLast30Days", &metadata);
let total_order_quantity = get_str("riskdata.totalOrderQuantity", &metadata);
let total_lifetime_value = get_str("riskdata.totalLifetimeValue", &metadata);
let visits_month = get_str("riskdata.visitsMonth", &metadata);
let visits_week = get_str("riskdata.visitsWeek", &metadata);
let visits_year = get_str("riskdata.visitsYear", &metadata);
let ship_to_name = get_str("riskdata.shipToName", &metadata);
let first8charactersof_address_line1_zip =
get_str("riskdata.first8charactersofAddressLine1Zip", &metadata);
let affiliate_order = get_bool("riskdata.affiliateOrder", &metadata);
Some(RiskData {
item_i_d,
product_title,
amount_per_item,
currency,
upc,
brand,
manufacturer,
category,
quantity,
color,
size,
device_country,
house_numberor_name,
account_creation_date,
affiliate_channel,
avg_order_value,
delivery_method,
email_name,
email_domain,
last_order_date,
merchant_reference,
payment_method,
promotion_name,
secondary_phone_number: secondary_phone_number.map(Secret::new),
timefrom_loginto_order,
total_session_time,
total_authorized_amount_in_last30_days,
total_order_quantity,
total_lifetime_value,
visits_month,
visits_week,
visits_year,
ship_to_name,
first8charactersof_address_line1_zip,
affiliate_order,
})
}
fn get_str(key: &str, riskdata: &serde_json::Value) -> Option<String> {
riskdata
.get(key)
.and_then(|v| v.as_str())
.map(|s| s.to_string())
}
fn get_bool(key: &str, riskdata: &serde_json::Value) -> Option<bool> {
riskdata.get(key).and_then(|v| v.as_bool())
}
#[derive(Debug, Serialize, Deserialize, Eq, PartialEq)]
pub struct AdyenRedirectRequest {
pub details: AdyenRedirectRequestTypes,
}
#[derive(Debug, Clone, Serialize, serde::Deserialize, Eq, PartialEq)]
#[serde(untagged)]
pub enum AdyenRedirectRequestTypes {
AdyenRedirection(AdyenRedirection),
AdyenThreeDS(AdyenThreeDS),
AdyenRefusal(AdyenRefusal),
}
#[derive(Debug, Clone, Serialize, serde::Deserialize, Eq, PartialEq)]
#[serde(rename_all = "camelCase")]
pub struct AdyenRedirection {
pub redirect_result: String,
#[serde(rename = "type")]
pub type_of_redirection_result: Option<String>,
pub result_code: Option<String>,
}
#[derive(Debug, Clone, Serialize, serde::Deserialize, Eq, PartialEq)]
#[serde(rename_all = "camelCase")]
pub struct AdyenThreeDS {
#[serde(rename = "threeDSResult")]
pub three_ds_result: String,
#[serde(rename = "type")]
pub type_of_redirection_result: Option<String>,
pub result_code: Option<String>,
}
#[derive(Debug, Clone, Serialize, serde::Deserialize, Eq, PartialEq)]
#[serde(rename_all = "camelCase")]
pub struct AdyenRefusal {
| {
"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_-8249547783947283321_15 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/adyen/transformers.rs
pub payload: String,
#[serde(rename = "type")]
pub type_of_redirection_result: Option<String>,
pub result_code: Option<String>,
}
#[serde_with::skip_serializing_none]
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct AdyenRefundRequest {
merchant_account: Secret<String>,
amount: Amount,
merchant_refund_reason: Option<String>,
reference: String,
splits: Option<Vec<AdyenSplitData>>,
store: Option<String>,
}
#[derive(Default, Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct AdyenRefundResponse {
merchant_account: Secret<String>,
psp_reference: String,
payment_psp_reference: String,
reference: String,
status: String,
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
TryFrom<
AdyenRouterData<RouterDataV2<Refund, RefundFlowData, RefundsData, RefundsResponseData>, T>,
> for AdyenRefundRequest
{
type Error = Error;
fn try_from(
item: AdyenRouterData<
RouterDataV2<Refund, RefundFlowData, RefundsData, RefundsResponseData>,
T,
>,
) -> Result<Self, Self::Error> {
let auth_type = AdyenAuthType::try_from(&item.router_data.connector_auth_type)?;
Ok(Self {
merchant_account: auth_type.merchant_account,
amount: Amount {
currency: item.router_data.request.currency,
value: item.router_data.request.minor_refund_amount,
},
merchant_refund_reason: item.router_data.request.reason.clone(),
reference: item.router_data.request.refund_id.clone(),
store: None,
splits: None,
})
}
}
impl<F, Req> TryFrom<ResponseRouterData<AdyenRefundResponse, Self>>
for RouterDataV2<F, RefundFlowData, Req, RefundsResponseData>
{
type Error = Error;
fn try_from(value: ResponseRouterData<AdyenRefundResponse, Self>) -> Result<Self, Self::Error> {
let ResponseRouterData {
response,
router_data,
http_code,
} = value;
let status = common_enums::RefundStatus::Pending;
let refunds_response_data = RefundsResponseData {
connector_refund_id: response.psp_reference,
refund_status: status,
status_code: http_code,
};
Ok(Self {
resource_common_data: RefundFlowData {
status,
..router_data.resource_common_data
},
response: Ok(refunds_response_data),
..router_data
})
}
}
#[derive(Default, Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct AdyenCaptureRequest {
merchant_account: Secret<String>,
amount: Amount,
reference: String,
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
TryFrom<
AdyenRouterData<
RouterDataV2<Capture, PaymentFlowData, PaymentsCaptureData, PaymentsResponseData>,
T,
>,
> for AdyenCaptureRequest
{
type Error = Error;
fn try_from(
item: AdyenRouterData<
RouterDataV2<Capture, PaymentFlowData, PaymentsCaptureData, PaymentsResponseData>,
T,
>,
) -> Result<Self, Self::Error> {
let auth_type = AdyenAuthType::try_from(&item.router_data.connector_auth_type)?;
let reference = match item.router_data.request.multiple_capture_data.clone() {
// if multiple capture request, send capture_id as our reference for the capture
Some(multiple_capture_request_data) => multiple_capture_request_data.capture_reference,
// if single capture request, send connector_request_reference_id(attempt_id)
None => item
.router_data
.resource_common_data
.connector_request_reference_id
.clone(),
};
Ok(Self {
merchant_account: auth_type.merchant_account,
reference,
amount: Amount {
currency: item.router_data.request.currency,
| {
"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_-8249547783947283321_16 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/adyen/transformers.rs
value: item.router_data.request.minor_amount_to_capture.to_owned(),
},
})
}
}
#[derive(Default, Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct AdyenCaptureResponse {
merchant_account: Secret<String>,
payment_psp_reference: String,
psp_reference: String,
reference: String,
status: String,
amount: Amount,
merchant_reference: Option<String>,
store: Option<String>,
splits: Option<Vec<AdyenSplitData>>,
}
impl<F> TryFrom<ResponseRouterData<AdyenCaptureResponse, Self>>
for RouterDataV2<F, PaymentFlowData, PaymentsCaptureData, PaymentsResponseData>
{
type Error = Error;
fn try_from(
value: ResponseRouterData<AdyenCaptureResponse, Self>,
) -> Result<Self, Self::Error> {
let ResponseRouterData {
response,
router_data,
http_code,
} = value;
let is_multiple_capture_psync_flow = router_data.request.multiple_capture_data.is_some();
let connector_transaction_id = if is_multiple_capture_psync_flow {
response.psp_reference.clone()
} else {
response.payment_psp_reference
};
Ok(Self {
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(connector_transaction_id),
redirection_data: None,
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: Some(response.reference),
incremental_authorization_allowed: None,
mandate_reference: None,
status_code: http_code,
}),
resource_common_data: PaymentFlowData {
status: AttemptStatus::Pending,
..router_data.resource_common_data
},
..router_data
})
}
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
TryFrom<(
AdyenRouterData<
RouterDataV2<
SetupMandate,
PaymentFlowData,
SetupMandateRequestData<T>,
PaymentsResponseData,
>,
T,
>,
&Card<T>,
)> for SetupMandateRequest<T>
{
type Error = Error;
fn try_from(
value: (
AdyenRouterData<
RouterDataV2<
SetupMandate,
PaymentFlowData,
SetupMandateRequestData<T>,
PaymentsResponseData,
>,
T,
>,
&Card<T>,
),
) -> Result<Self, Self::Error> {
let (item, card_data) = value;
let amount = get_amount_data_for_setup_mandate(&item);
let auth_type = AdyenAuthType::try_from(&item.router_data.connector_auth_type)?;
let shopper_interaction = AdyenShopperInteraction::from(&item.router_data);
let shopper_reference = build_shopper_reference(
&item.router_data.request.customer_id.clone(),
item.router_data.resource_common_data.merchant_id.clone(),
);
let (recurring_processing_model, store_payment_method, _) =
get_recurring_processing_model_for_setup_mandate(&item.router_data)?;
let return_url = item
.router_data
.request
.router_return_url
.clone()
.ok_or_else(Box::new(move || {
errors::ConnectorError::MissingRequiredField {
field_name: "return_url",
}
}))?;
let billing_address = get_address_info(
item.router_data
.resource_common_data
.address
.get_payment_billing(),
)
.and_then(Result::ok);
let card_holder_name = item.router_data.request.customer_name.clone();
let additional_data = get_additional_data_for_setup_mandate(&item.router_data);
let payment_method = PaymentMethod::AdyenPaymentMethod(Box::new(
AdyenPaymentMethod::try_from((card_data, card_holder_name))?,
));
Ok(SetupMandateRequest(AdyenPaymentRequest {
amount,
| {
"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_-8249547783947283321_17 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/adyen/transformers.rs
merchant_account: auth_type.merchant_account,
payment_method,
reference: item
.router_data
.resource_common_data
.connector_request_reference_id
.clone(),
return_url,
shopper_interaction,
recurring_processing_model,
browser_info: None,
additional_data,
mpi_data: None,
telephone_number: None,
shopper_name: None,
shopper_email: None,
shopper_locale: None,
social_security_number: None,
billing_address,
delivery_address: None,
country_code: None,
line_items: None,
shopper_reference,
store_payment_method,
channel: None,
shopper_statement: item.router_data.request.statement_descriptor.clone(),
shopper_ip: None,
merchant_order_reference: item.router_data.request.merchant_order_reference_id.clone(),
store: None,
splits: None,
device_fingerprint: None,
}))
}
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
TryFrom<
AdyenRouterData<
RouterDataV2<
SetupMandate,
PaymentFlowData,
SetupMandateRequestData<T>,
PaymentsResponseData,
>,
T,
>,
> for SetupMandateRequest<T>
{
type Error = Error;
fn try_from(
item: AdyenRouterData<
RouterDataV2<
SetupMandate,
PaymentFlowData,
SetupMandateRequestData<T>,
PaymentsResponseData,
>,
T,
>,
) -> Result<Self, Self::Error> {
match item
.router_data
.request
.mandate_id
.to_owned()
.and_then(|mandate_ids| mandate_ids.mandate_reference_id)
{
Some(_mandate_ref) => Err(domain_types::errors::ConnectorError::NotImplemented(
"payment_method".into(),
))?,
None => match item.router_data.request.payment_method_data.clone() {
PaymentMethodData::Card(ref card) => SetupMandateRequest::try_from((item, card)),
PaymentMethodData::Wallet(_)
| PaymentMethodData::PayLater(_)
| PaymentMethodData::BankRedirect(_)
| PaymentMethodData::BankDebit(_)
| PaymentMethodData::BankTransfer(_)
| PaymentMethodData::CardRedirect(_)
| PaymentMethodData::Voucher(_)
| PaymentMethodData::GiftCard(_)
| PaymentMethodData::Crypto(_)
| PaymentMethodData::MandatePayment
| PaymentMethodData::Reward
| PaymentMethodData::RealTimePayment(_)
| PaymentMethodData::Upi(_)
| PaymentMethodData::OpenBanking(_)
| PaymentMethodData::CardDetailsForNetworkTransactionId(_)
| PaymentMethodData::NetworkToken(_)
| PaymentMethodData::MobilePayment(_)
| PaymentMethodData::CardToken(_) => Err(
domain_types::errors::ConnectorError::NotImplemented("payment method".into()),
)?,
},
}
}
}
impl<
F,
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> TryFrom<ResponseRouterData<SetupMandateResponse, Self>>
for RouterDataV2<F, PaymentFlowData, SetupMandateRequestData<T>, PaymentsResponseData>
{
type Error = Error;
fn try_from(
value: ResponseRouterData<SetupMandateResponse, Self>,
) -> Result<Self, Self::Error> {
let ResponseRouterData {
response,
router_data,
http_code,
} = value;
let pmt = router_data.request.payment_method_type;
let is_manual_capture = false;
let (status, error, payment_response_data) = match response {
| {
"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_-8249547783947283321_18 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/adyen/transformers.rs
SetupMandateResponse(AdyenPaymentResponse::Response(response)) => {
get_adyen_response(*response, is_manual_capture, http_code, pmt)?
}
SetupMandateResponse(AdyenPaymentResponse::RedirectionResponse(response)) => {
get_redirection_response(*response, is_manual_capture, http_code, pmt)?
}
};
Ok(Self {
response: error.map_or_else(|| Ok(payment_response_data), Err),
resource_common_data: PaymentFlowData {
status,
..router_data.resource_common_data
},
..router_data
})
}
}
fn get_amount_data_for_setup_mandate<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>(
item: &AdyenRouterData<
RouterDataV2<
SetupMandate,
PaymentFlowData,
SetupMandateRequestData<T>,
PaymentsResponseData,
>,
T,
>,
) -> Amount {
Amount {
currency: item.router_data.request.currency,
value: MinorUnit::new(item.router_data.request.amount.unwrap_or(0)),
}
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
From<
&RouterDataV2<
SetupMandate,
PaymentFlowData,
SetupMandateRequestData<T>,
PaymentsResponseData,
>,
> for AdyenShopperInteraction
{
fn from(
item: &RouterDataV2<
SetupMandate,
PaymentFlowData,
SetupMandateRequestData<T>,
PaymentsResponseData,
>,
) -> Self {
match item.request.off_session {
Some(true) => Self::ContinuedAuthentication,
_ => Self::Ecommerce,
}
}
}
fn get_recurring_processing_model_for_setup_mandate<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>(
item: &RouterDataV2<
SetupMandate,
PaymentFlowData,
SetupMandateRequestData<T>,
PaymentsResponseData,
>,
) -> Result<RecurringDetails, Error> {
let customer_id = item
.request
.customer_id
.clone()
.ok_or_else(Box::new(move || {
errors::ConnectorError::MissingRequiredField {
field_name: "customer_id",
}
}))?;
match (item.request.setup_future_usage, item.request.off_session) {
(Some(common_enums::FutureUsage::OffSession), _) => {
let shopper_reference = format!(
"{}_{}",
item.resource_common_data.merchant_id.get_string_repr(),
customer_id.get_string_repr()
);
let store_payment_method = is_mandate_payment_for_setup_mandate(item);
Ok((
Some(AdyenRecurringModel::UnscheduledCardOnFile),
Some(store_payment_method),
Some(shopper_reference),
))
}
(_, Some(true)) => Ok((
Some(AdyenRecurringModel::UnscheduledCardOnFile),
None,
Some(format!(
"{}_{}",
item.resource_common_data.merchant_id.get_string_repr(),
customer_id.get_string_repr()
)),
)),
_ => Ok((None, None, None)),
}
}
fn get_additional_data_for_setup_mandate<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>(
item: &RouterDataV2<
SetupMandate,
PaymentFlowData,
SetupMandateRequestData<T>,
PaymentsResponseData,
>,
) -> Option<AdditionalData> {
let (authorisation_type, manual_capture) = match item.request.capture_method {
Some(common_enums::CaptureMethod::Manual)
| Some(common_enums::CaptureMethod::ManualMultiple) => {
(Some(AuthType::PreAuth), Some("true".to_string()))
}
_ => (None, None),
};
let riskdata = item.request.metadata.clone().and_then(get_risk_data);
let execute_three_d = if matches!(
item.resource_common_data.auth_type,
| {
"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_-8249547783947283321_19 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/adyen/transformers.rs
common_enums::AuthenticationType::ThreeDs
) {
Some("true".to_string())
} else {
None
};
if authorisation_type.is_none()
&& manual_capture.is_none()
&& execute_three_d.is_none()
&& riskdata.is_none()
{
//without this if-condition when the above 3 values are None, additionalData will be serialized to JSON like this -> additionalData: {}
//returning None, ensures that additionalData key will not be present in the serialized JSON
None
} else {
Some(AdditionalData {
authorisation_type,
manual_capture,
execute_three_d,
network_tx_reference: None,
recurring_detail_reference: None,
recurring_shopper_reference: None,
recurring_processing_model: None,
riskdata,
..AdditionalData::default()
})
}
}
fn is_mandate_payment_for_setup_mandate<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>(
item: &RouterDataV2<
SetupMandate,
PaymentFlowData,
SetupMandateRequestData<T>,
PaymentsResponseData,
>,
) -> bool {
(item.request.setup_future_usage == Some(common_enums::FutureUsage::OffSession))
|| item
.request
.mandate_id
.as_ref()
.and_then(|mandate_ids| mandate_ids.mandate_reference_id.as_ref())
.is_some()
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct AdyenDisputeAcceptRequest {
pub dispute_psp_reference: String,
pub merchant_account_code: String,
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
TryFrom<
AdyenRouterData<
RouterDataV2<Accept, DisputeFlowData, AcceptDisputeData, DisputeResponseData>,
T,
>,
> for AdyenDisputeAcceptRequest
{
type Error = Error;
fn try_from(
item: AdyenRouterData<
RouterDataV2<Accept, DisputeFlowData, AcceptDisputeData, DisputeResponseData>,
T,
>,
) -> Result<Self, Self::Error> {
let auth = AdyenAuthType::try_from(&item.router_data.connector_auth_type)?;
Ok(Self {
dispute_psp_reference: item
.router_data
.resource_common_data
.connector_dispute_id
.clone(),
merchant_account_code: auth.merchant_account.peek().to_string(),
})
}
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct AdyenDisputeAcceptResponse {
pub dispute_service_result: Option<DisputeServiceResult>,
}
impl<F, Req> TryFrom<ResponseRouterData<AdyenDisputeAcceptResponse, Self>>
for RouterDataV2<F, DisputeFlowData, Req, DisputeResponseData>
{
type Error = Error;
fn try_from(
value: ResponseRouterData<AdyenDisputeAcceptResponse, Self>,
) -> Result<Self, Self::Error> {
let ResponseRouterData {
response,
router_data,
http_code,
} = value;
let success = response
.dispute_service_result
.as_ref()
.is_some_and(|r| r.success);
if success {
let status = common_enums::DisputeStatus::DisputeAccepted;
let dispute_response_data = DisputeResponseData {
dispute_status: status,
connector_dispute_id: router_data
.resource_common_data
.connector_dispute_id
.clone(),
connector_dispute_status: None,
status_code: http_code,
};
Ok(Self {
resource_common_data: DisputeFlowData {
..router_data.resource_common_data
},
response: Ok(dispute_response_data),
..router_data
})
} else {
let error_message = response
.dispute_service_result
.as_ref()
.and_then(|r| r.error_message.clone())
.unwrap_or_else(|| NO_ERROR_MESSAGE.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_-8249547783947283321_20 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/adyen/transformers.rs
let error_response = ErrorResponse {
code: NO_ERROR_CODE.to_string(),
message: error_message.clone(),
reason: Some(error_message.clone()),
status_code: http_code,
attempt_status: None,
connector_transaction_id: None,
network_decline_code: None,
network_advice_code: None,
network_error_message: None,
};
Ok(Self {
resource_common_data: router_data.resource_common_data.clone(),
response: Err(error_response),
..router_data
})
}
}
}
#[derive(Default, Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct AdyenDisputeSubmitEvidenceRequest {
defense_documents: Vec<DefenseDocuments>,
merchant_account_code: Secret<String>,
dispute_psp_reference: String,
}
#[derive(Default, Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct DefenseDocuments {
content: Secret<String>,
content_type: Option<String>,
defense_document_type_code: String,
}
fn get_defence_documents(item: SubmitEvidenceData) -> Option<Vec<DefenseDocuments>> {
let mut defense_documents: Vec<DefenseDocuments> = Vec::new();
if let Some(shipping_documentation) = item.shipping_documentation {
defense_documents.push(DefenseDocuments {
content: get_content(shipping_documentation).into(),
content_type: item.shipping_documentation_provider_file_id,
defense_document_type_code: "DefenseMaterial".into(),
})
}
if let Some(receipt) = item.receipt {
defense_documents.push(DefenseDocuments {
content: get_content(receipt).into(),
content_type: item.receipt_file_type,
defense_document_type_code: "DefenseMaterial".into(),
})
}
if let Some(invoice_showing_distinct_transactions) = item.invoice_showing_distinct_transactions
{
defense_documents.push(DefenseDocuments {
content: get_content(invoice_showing_distinct_transactions).into(),
content_type: item.invoice_showing_distinct_transactions_file_type,
defense_document_type_code: "DefenseMaterial".into(),
})
}
if let Some(customer_communication) = item.customer_communication {
defense_documents.push(DefenseDocuments {
content: get_content(customer_communication).into(),
content_type: item.customer_communication_file_type,
defense_document_type_code: "DefenseMaterial".into(),
})
}
if let Some(refund_policy) = item.refund_policy {
defense_documents.push(DefenseDocuments {
content: get_content(refund_policy).into(),
content_type: item.refund_policy_file_type,
defense_document_type_code: "DefenseMaterial".into(),
})
}
if let Some(recurring_transaction_agreement) = item.recurring_transaction_agreement {
defense_documents.push(DefenseDocuments {
content: get_content(recurring_transaction_agreement).into(),
content_type: item.recurring_transaction_agreement_file_type,
defense_document_type_code: "DefenseMaterial".into(),
})
}
if let Some(uncategorized_file) = item.uncategorized_file {
defense_documents.push(DefenseDocuments {
content: get_content(uncategorized_file).into(),
content_type: item.uncategorized_file_type,
defense_document_type_code: "DefenseMaterial".into(),
})
}
if let Some(cancellation_policy) = item.cancellation_policy {
defense_documents.push(DefenseDocuments {
content: get_content(cancellation_policy).into(),
content_type: item.cancellation_policy_file_type,
defense_document_type_code: "DefenseMaterial".into(),
})
}
if let Some(customer_signature) = item.customer_signature {
defense_documents.push(DefenseDocuments {
content: get_content(customer_signature).into(),
content_type: item.customer_signature_file_type,
defense_document_type_code: "DefenseMaterial".into(),
})
}
if let Some(service_documentation) = item.service_documentation {
| {
"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_-8249547783947283321_21 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/adyen/transformers.rs
defense_documents.push(DefenseDocuments {
content: get_content(service_documentation).into(),
content_type: item.service_documentation_file_type,
defense_document_type_code: "DefenseMaterial".into(),
})
}
if defense_documents.is_empty() {
None
} else {
Some(defense_documents)
}
}
fn get_content(item: Vec<u8>) -> String {
STANDARD.encode(item)
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
TryFrom<
AdyenRouterData<
RouterDataV2<SubmitEvidence, DisputeFlowData, SubmitEvidenceData, DisputeResponseData>,
T,
>,
> for AdyenDisputeSubmitEvidenceRequest
{
type Error = Error;
fn try_from(
item: AdyenRouterData<
RouterDataV2<SubmitEvidence, DisputeFlowData, SubmitEvidenceData, DisputeResponseData>,
T,
>,
) -> Result<Self, Self::Error> {
let auth = AdyenAuthType::try_from(&item.router_data.connector_auth_type)?;
Ok(Self {
defense_documents: get_defence_documents(item.router_data.request.clone()).ok_or(
errors::ConnectorError::MissingRequiredField {
field_name: "Missing Defence Documents",
},
)?,
merchant_account_code: auth.merchant_account.peek().to_string().into(),
dispute_psp_reference: item.router_data.request.connector_dispute_id.clone(),
})
}
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct AdyenSubmitEvidenceResponse {
pub dispute_service_result: Option<DisputeServiceResult>,
}
impl<F, Req> TryFrom<ResponseRouterData<AdyenSubmitEvidenceResponse, Self>>
for RouterDataV2<F, DisputeFlowData, Req, DisputeResponseData>
{
type Error = Error;
fn try_from(
value: ResponseRouterData<AdyenSubmitEvidenceResponse, Self>,
) -> Result<Self, Self::Error> {
let ResponseRouterData {
response,
router_data,
http_code,
} = value;
let success = response
.dispute_service_result
.as_ref()
.is_some_and(|r| r.success);
if success {
let status = common_enums::DisputeStatus::DisputeChallenged;
let dispute_response_data = DisputeResponseData {
dispute_status: status,
connector_dispute_id: router_data
.resource_common_data
.connector_dispute_id
.clone(),
connector_dispute_status: None,
status_code: http_code,
};
Ok(Self {
resource_common_data: DisputeFlowData {
..router_data.resource_common_data
},
response: Ok(dispute_response_data),
..router_data
})
} else {
let error_message = response
.dispute_service_result
.as_ref()
.and_then(|r| r.error_message.clone())
.unwrap_or_else(|| NO_ERROR_MESSAGE.to_string());
let error_response = ErrorResponse {
code: NO_ERROR_CODE.to_string(),
message: error_message.clone(),
reason: Some(error_message.clone()),
status_code: http_code,
attempt_status: None,
connector_transaction_id: None,
network_decline_code: None,
network_advice_code: None,
network_error_message: None,
};
Ok(Self {
resource_common_data: router_data.resource_common_data.clone(),
response: Err(error_response),
..router_data
})
}
}
}
#[derive(Default, Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct AdyenDefendDisputeRequest {
dispute_psp_reference: String,
merchant_account_code: Secret<String>,
defense_reason_code: String,
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
| {
"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_-8249547783947283321_22 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/adyen/transformers.rs
>
TryFrom<
AdyenRouterData<
RouterDataV2<DefendDispute, DisputeFlowData, DisputeDefendData, DisputeResponseData>,
T,
>,
> for AdyenDefendDisputeRequest
{
type Error = Error;
fn try_from(
item: AdyenRouterData<
RouterDataV2<DefendDispute, DisputeFlowData, DisputeDefendData, DisputeResponseData>,
T,
>,
) -> Result<Self, Self::Error> {
let auth_type = AdyenAuthType::try_from(&item.router_data.connector_auth_type)?;
Ok(Self {
dispute_psp_reference: item.router_data.request.connector_dispute_id.clone(),
merchant_account_code: auth_type.merchant_account.clone(),
defense_reason_code: item.router_data.request.defense_reason_code.clone(),
})
}
}
#[derive(Debug, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
#[serde(untagged)]
pub enum AdyenDefendDisputeResponse {
DefendDisputeSuccessResponse(DefendDisputeSuccessResponse),
DefendDisputeFailedResponse(DefendDisputeErrorResponse),
}
#[derive(Default, Debug, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct DefendDisputeErrorResponse {
error_code: String,
error_type: String,
message: String,
psp_reference: String,
status: String,
}
#[derive(Default, Debug, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct DefendDisputeSuccessResponse {
dispute_service_result: DisputeServiceResult,
}
#[derive(Default, Debug, Deserialize, Serialize, Clone)]
#[serde(rename_all = "camelCase")]
pub struct DisputeServiceResult {
error_message: Option<String>,
success: bool,
}
impl<F, Req> TryFrom<ResponseRouterData<AdyenDefendDisputeResponse, Self>>
for RouterDataV2<F, DisputeFlowData, Req, DisputeResponseData>
{
type Error = Report<domain_types::errors::ConnectorError>;
fn try_from(
value: ResponseRouterData<AdyenDefendDisputeResponse, Self>,
) -> Result<Self, Self::Error> {
let ResponseRouterData {
response,
router_data,
http_code,
} = value;
match response {
AdyenDefendDisputeResponse::DefendDisputeSuccessResponse(result) => {
let dispute_status = if result.dispute_service_result.success {
common_enums::DisputeStatus::DisputeWon
} else {
common_enums::DisputeStatus::DisputeLost
};
Ok(Self {
response: Ok(DisputeResponseData {
dispute_status,
connector_dispute_status: None,
connector_dispute_id: router_data
.resource_common_data
.connector_dispute_id
.clone(),
status_code: http_code,
}),
..router_data
})
}
AdyenDefendDisputeResponse::DefendDisputeFailedResponse(result) => Ok(Self {
response: Err(ErrorResponse {
code: result.error_code,
message: result.message.clone(),
reason: Some(result.message),
status_code: http_code,
attempt_status: None,
connector_transaction_id: Some(result.psp_reference),
network_decline_code: None,
network_advice_code: None,
network_error_message: None,
}),
..router_data
}),
}
}
}
pub(crate) fn get_dispute_stage_and_status(
code: WebhookEventCode,
dispute_status: Option<DisputeStatus>,
) -> (common_enums::DisputeStage, common_enums::DisputeStatus) {
use common_enums::{DisputeStage, DisputeStatus as HSDisputeStatus};
match code {
WebhookEventCode::NotificationOfChargeback => {
(DisputeStage::PreDispute, HSDisputeStatus::DisputeOpened)
}
WebhookEventCode::Chargeback => {
let status = match dispute_status {
Some(DisputeStatus::Undefended) | Some(DisputeStatus::Pending) => {
HSDisputeStatus::DisputeOpened
}
| {
"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_-8249547783947283321_23 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/adyen/transformers.rs
Some(DisputeStatus::Lost) | None => HSDisputeStatus::DisputeLost,
Some(DisputeStatus::Accepted) => HSDisputeStatus::DisputeAccepted,
Some(DisputeStatus::Won) => HSDisputeStatus::DisputeWon,
};
(DisputeStage::Dispute, status)
}
WebhookEventCode::ChargebackReversed => {
let status = match dispute_status {
Some(DisputeStatus::Pending) => HSDisputeStatus::DisputeChallenged,
_ => HSDisputeStatus::DisputeWon,
};
(DisputeStage::Dispute, status)
}
WebhookEventCode::SecondChargeback => {
(DisputeStage::PreArbitration, HSDisputeStatus::DisputeLost)
}
WebhookEventCode::PrearbitrationWon => {
let status = match dispute_status {
Some(DisputeStatus::Pending) => HSDisputeStatus::DisputeOpened,
_ => HSDisputeStatus::DisputeWon,
};
(DisputeStage::PreArbitration, status)
}
WebhookEventCode::PrearbitrationLost => {
(DisputeStage::PreArbitration, HSDisputeStatus::DisputeLost)
}
_ => (DisputeStage::Dispute, HSDisputeStatus::DisputeOpened),
}
}
| {
"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_2054780185909450401_0 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/worldpayvantiv/transformers.rs
use common_enums::{self, CountryAlpha2, Currency};
use common_utils::{types::MinorUnit, StringMajorUnit};
use domain_types::{
connector_flow::{Authorize, Capture, PSync, RSync, Refund, Void, VoidPC},
connector_types::{
PaymentFlowData, PaymentVoidData, PaymentsAuthorizeData, PaymentsCancelPostCaptureData,
PaymentsCaptureData, PaymentsResponseData, PaymentsSyncData, RefundFlowData,
RefundSyncData, RefundsData, RefundsResponseData, ResponseId,
},
errors::ConnectorError,
payment_method_data::{PaymentMethodData, PaymentMethodDataTypes, RawCardNumber, WalletData},
router_data::{ConnectorAuthType, ErrorResponse, PaymentMethodToken},
router_data_v2::RouterDataV2,
};
use error_stack::ResultExt;
use hyperswitch_masking::{ExposeInterface, PeekInterface, Secret};
use serde::{Deserialize, Serialize};
use crate::{connectors::worldpayvantiv::WorldpayvantivRouterData, types::ResponseRouterData};
// Helper function to extract report group from connector metadata
fn extract_report_group(
connector_meta_data: &Option<hyperswitch_masking::Secret<serde_json::Value>>,
) -> Option<String> {
connector_meta_data.as_ref().and_then(|metadata| {
let metadata_value = metadata.peek();
if let serde_json::Value::String(metadata_str) = metadata_value {
// Try to parse the metadata string as JSON
serde_json::from_str::<WorldpayvantivMetadataObject>(metadata_str)
.ok()
.map(|obj| obj.report_group)
} else {
// Try to parse metadata directly as object
serde_json::from_value::<WorldpayvantivMetadataObject>(metadata_value.clone())
.ok()
.map(|obj| obj.report_group)
}
})
}
// Metadata structures for WorldpayVantiv
#[derive(Debug, Default, Serialize, Deserialize)]
pub struct WorldpayvantivMetadataObject {
pub report_group: String,
pub merchant_config_currency: common_enums::Currency,
}
#[derive(Debug, Default, Serialize, Deserialize)]
pub struct WorldpayvantivPaymentMetadata {
pub report_group: Option<String>,
}
pub const BASE64_ENGINE: base64::engine::GeneralPurpose = base64::engine::general_purpose::STANDARD;
// WorldpayVantiv Payments Request - wrapper for all payment flows with custom XML serialization
#[derive(Debug)]
pub struct WorldpayvantivPaymentsRequest<T: PaymentMethodDataTypes> {
pub cnp_request: CnpOnlineRequest<T>,
}
// Serialize implementation
impl<T: PaymentMethodDataTypes + Serialize> Serialize for WorldpayvantivPaymentsRequest<T> {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
let full_xml =
crate::utils::serialize_to_xml_string_with_root("cnpOnlineRequest", &self.cnp_request)
.map_err(serde::ser::Error::custom)?;
// Serialize the complete XML string
full_xml.serialize(serializer)
}
}
// TryFrom implementations for macro integration
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
TryFrom<
WorldpayvantivRouterData<
RouterDataV2<
Authorize,
PaymentFlowData,
PaymentsAuthorizeData<T>,
PaymentsResponseData,
>,
T,
>,
> for WorldpayvantivPaymentsRequest<T>
{
type Error = error_stack::Report<ConnectorError>;
fn try_from(
item: WorldpayvantivRouterData<
RouterDataV2<
Authorize,
PaymentFlowData,
PaymentsAuthorizeData<T>,
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 payment_method_data = &item.router_data.request.payment_method_data;
let order_source = OrderSource::from(payment_method_data.clone());
// Handle payment info directly without generic constraints
| {
"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_2054780185909450401_1 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/worldpayvantiv/transformers.rs
let payment_info = match payment_method_data {
PaymentMethodData::Card(card_data) => {
let card_type = match card_data.card_network.clone() {
Some(network) => WorldpayvativCardType::try_from(network)?,
None => {
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()),
};
PaymentInfo::Card(CardData {
card: worldpay_card,
processing_type: None,
network_transaction_id: None,
})
}
_ => {
return Err(ConnectorError::NotSupported {
message: "Payment method".to_string(),
connector: "worldpayvantiv",
}
.into());
}
};
let merchant_txn_id = get_valid_transaction_id(
item.router_data
.resource_common_data
.connector_request_reference_id
.clone(),
"transaction_id",
)?;
let amount = item.router_data.request.minor_amount;
// Extract report group from metadata or use default
let report_group =
extract_report_group(&item.router_data.resource_common_data.connector_meta_data)
.unwrap_or_else(|| "rtpGrp".to_string());
let bill_to_address = get_billing_address(
&item
.router_data
.resource_common_data
.address
.get_payment_method_billing()
.cloned(),
);
let ship_to_address = get_shipping_address(
&item
.router_data
.resource_common_data
.address
.get_shipping()
.cloned(),
);
let (authorization, sale) =
if item.router_data.request.is_auto_capture()? && amount != MinorUnit::zero() {
let sale = Sale {
id: format!("{}_{}", OperationId::Sale, merchant_txn_id),
report_group: report_group.clone(),
customer_id: item
.router_data
.resource_common_data
.get_customer_id()
.ok()
.map(|id| Secret::new(id.get_string_repr().to_string())),
order_id: merchant_txn_id.clone(),
amount,
order_source,
bill_to_address,
ship_to_address,
payment_info,
enhanced_data: None,
processing_instructions: None,
cardholder_authentication: None,
};
(None, Some(sale))
} else {
let authorization = Authorization {
id: format!("{}_{}", OperationId::Auth, merchant_txn_id),
report_group: report_group.clone(),
customer_id: item
.router_data
.resource_common_data
.get_customer_id()
.ok()
.map(|id| Secret::new(id.get_string_repr().to_string())),
order_id: merchant_txn_id.clone(),
amount,
order_source,
bill_to_address,
ship_to_address,
payment_info,
| {
"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
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.