id stringlengths 20 153 | type stringclasses 1
value | granularity stringclasses 14
values | content stringlengths 16 84.3k | metadata dict |
|---|---|---|---|---|
connector-service_mini_connector-integration_5127189373612706197_4 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/checkout.rs
req: &RouterDataV2<Refund, RefundFlowData, RefundsData, RefundsResponseData>,
) -> CustomResult<Vec<(String, Maskable<String>)>, errors::ConnectorError> {
self.build_headers(req)
}
fn get_url(
&self,
req: &RouterDataV2<Refund, RefundFlowData, RefundsData, RefundsResponseData>,
) -> CustomResult<String, errors::ConnectorError> {
let connector_tx_id = &req.request.connector_transaction_id;
Ok(format!("{}payments/{}/refunds", self.connector_base_url_refunds(req), connector_tx_id))
}
}
);
macros::macro_connector_implementation!(
connector_default_implementations: [get_content_type, get_error_response_v2],
connector: Checkout,
curl_request: Json(CheckoutRefundSyncRequest),
curl_response: ActionResponse,
flow_name: RSync,
resource_common_data: RefundFlowData,
flow_request: RefundSyncData,
flow_response: RefundsResponseData,
http_method: Get,
generic_type: T,
[PaymentMethodDataTypes + std::fmt::Debug + std::marker::Sync + std::marker::Send + 'static + Serialize],
other_functions: {
fn get_headers(
&self,
req: &RouterDataV2<RSync, RefundFlowData, RefundSyncData, RefundsResponseData>,
) -> CustomResult<Vec<(String, Maskable<String>)>, errors::ConnectorError> {
self.build_headers(req)
}
fn get_url(
&self,
req: &RouterDataV2<RSync, RefundFlowData, RefundSyncData, RefundsResponseData>,
) -> CustomResult<String, errors::ConnectorError> {
let connector_tx_id = &req.request.connector_transaction_id;
Ok(format!(
"{}payments/{}/actions",
self.connector_base_url_refunds(req),
connector_tx_id
))
}
}
);
macros::macro_connector_implementation!(
connector_default_implementations: [get_content_type, get_error_response_v2],
connector: Checkout,
curl_request: Json(PaymentVoidRequest),
curl_response: PaymentVoidResponse,
flow_name: Void,
resource_common_data: PaymentFlowData,
flow_request: PaymentVoidData,
flow_response: PaymentsResponseData,
http_method: Post,
generic_type: T,
[PaymentMethodDataTypes + std::fmt::Debug + std::marker::Sync + std::marker::Send + 'static + Serialize],
other_functions: {
fn get_headers(
&self,
req: &RouterDataV2<Void, PaymentFlowData, PaymentVoidData, PaymentsResponseData>,
) -> CustomResult<Vec<(String, Maskable<String>)>, errors::ConnectorError> {
self.build_headers(req)
}
fn get_url(
&self,
req: &RouterDataV2<Void, PaymentFlowData, PaymentVoidData, PaymentsResponseData>,
) -> CustomResult<String, errors::ConnectorError> {
let connector_tx_id = req.request.connector_transaction_id.clone();
Ok(format!("{}payments/{}/voids", self.connector_base_url_payments(req), connector_tx_id))
}
}
);
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
ConnectorIntegrationV2<
SetupMandate,
PaymentFlowData,
SetupMandateRequestData<T>,
PaymentsResponseData,
> for Checkout<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
ConnectorIntegrationV2<
CreateSessionToken,
PaymentFlowData,
SessionTokenRequestData,
SessionTokenResponseData,
> for Checkout<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
ConnectorIntegrationV2<
CreateAccessToken,
PaymentFlowData,
AccessTokenRequestData,
AccessTokenResponseData,
> for Checkout<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
ConnectorIntegrationV2<
CreateConnectorCustomer,
| {
"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_5127189373612706197_5 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/checkout.rs
PaymentFlowData,
ConnectorCustomerData,
ConnectorCustomerResponse,
> for Checkout<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
interfaces::verification::SourceVerification<
CreateSessionToken,
PaymentFlowData,
SessionTokenRequestData,
SessionTokenResponseData,
> for Checkout<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
interfaces::verification::SourceVerification<
CreateAccessToken,
PaymentFlowData,
AccessTokenRequestData,
AccessTokenResponseData,
> for Checkout<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
interfaces::verification::SourceVerification<
CreateConnectorCustomer,
PaymentFlowData,
ConnectorCustomerData,
ConnectorCustomerResponse,
> for Checkout<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> ConnectorIntegrationV2<Accept, DisputeFlowData, AcceptDisputeData, DisputeResponseData>
for Checkout<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
ConnectorIntegrationV2<SubmitEvidence, DisputeFlowData, SubmitEvidenceData, DisputeResponseData>
for Checkout<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> ConnectorIntegrationV2<DefendDispute, DisputeFlowData, DisputeDefendData, DisputeResponseData>
for Checkout<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
ConnectorIntegrationV2<
CreateOrder,
PaymentFlowData,
PaymentCreateOrderData,
PaymentCreateOrderResponse,
> for Checkout<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
ConnectorIntegrationV2<
PaymentMethodToken,
PaymentFlowData,
PaymentMethodTokenizationData<T>,
PaymentMethodTokenResponse,
> for Checkout<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
ConnectorIntegrationV2<
PreAuthenticate,
PaymentFlowData,
PaymentsPreAuthenticateData<T>,
PaymentsResponseData,
> for Checkout<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
ConnectorIntegrationV2<
Authenticate,
PaymentFlowData,
PaymentsAuthenticateData<T>,
PaymentsResponseData,
> for Checkout<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
ConnectorIntegrationV2<
PostAuthenticate,
PaymentFlowData,
PaymentsPostAuthenticateData<T>,
PaymentsResponseData,
> for Checkout<T>
{
}
// SourceVerification implementations for all flows
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
interfaces::verification::SourceVerification<
Authorize,
PaymentFlowData,
PaymentsAuthorizeData<T>,
PaymentsResponseData,
> for Checkout<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
| {
"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_5127189373612706197_6 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/checkout.rs
+ std::marker::Send
+ 'static
+ Serialize,
>
interfaces::verification::SourceVerification<
PSync,
PaymentFlowData,
PaymentsSyncData,
PaymentsResponseData,
> for Checkout<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
interfaces::verification::SourceVerification<
Capture,
PaymentFlowData,
PaymentsCaptureData,
PaymentsResponseData,
> for Checkout<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
interfaces::verification::SourceVerification<
Void,
PaymentFlowData,
PaymentVoidData,
PaymentsResponseData,
> for Checkout<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
interfaces::verification::SourceVerification<
Refund,
RefundFlowData,
RefundsData,
RefundsResponseData,
> for Checkout<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
interfaces::verification::SourceVerification<
RSync,
RefundFlowData,
RefundSyncData,
RefundsResponseData,
> for Checkout<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
interfaces::verification::SourceVerification<
SetupMandate,
PaymentFlowData,
SetupMandateRequestData<T>,
PaymentsResponseData,
> for Checkout<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
interfaces::verification::SourceVerification<
Accept,
DisputeFlowData,
AcceptDisputeData,
DisputeResponseData,
> for Checkout<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
interfaces::verification::SourceVerification<
SubmitEvidence,
DisputeFlowData,
SubmitEvidenceData,
DisputeResponseData,
> for Checkout<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
interfaces::verification::SourceVerification<
DefendDispute,
DisputeFlowData,
DisputeDefendData,
DisputeResponseData,
> for Checkout<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
interfaces::verification::SourceVerification<
CreateOrder,
PaymentFlowData,
PaymentCreateOrderData,
PaymentCreateOrderResponse,
> for Checkout<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
interfaces::verification::SourceVerification<
RepeatPayment,
PaymentFlowData,
RepeatPaymentData,
PaymentsResponseData,
> for Checkout<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
ConnectorIntegrationV2<RepeatPayment, PaymentFlowData, RepeatPaymentData, PaymentsResponseData>
for Checkout<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
interfaces::verification::SourceVerification<
PaymentMethodToken,
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_5127189373612706197_7 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/checkout.rs
PaymentMethodTokenizationData<T>,
PaymentMethodTokenResponse,
> for Checkout<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
interfaces::verification::SourceVerification<
PreAuthenticate,
PaymentFlowData,
PaymentsPreAuthenticateData<T>,
PaymentsResponseData,
> for Checkout<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
interfaces::verification::SourceVerification<
Authenticate,
PaymentFlowData,
PaymentsAuthenticateData<T>,
PaymentsResponseData,
> for Checkout<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
interfaces::verification::SourceVerification<
PostAuthenticate,
PaymentFlowData,
PaymentsPostAuthenticateData<T>,
PaymentsResponseData,
> for Checkout<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
ConnectorIntegrationV2<
VoidPC,
PaymentFlowData,
PaymentsCancelPostCaptureData,
PaymentsResponseData,
> for Checkout<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
interfaces::verification::SourceVerification<
VoidPC,
PaymentFlowData,
PaymentsCancelPostCaptureData,
PaymentsResponseData,
> for Checkout<T>
{
}
| {
"chunk": 7,
"crate": "connector-integration",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_mini_connector-integration_3314128609778487701_0 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/razorpayv2.rs
pub mod test;
pub mod transformers;
use common_enums::AttemptStatus;
use common_utils::{
errors::CustomResult,
events,
ext_traits::BytesExt,
request::RequestContent,
types::{AmountConvertor, MinorUnit},
};
use domain_types::{
connector_flow::{
Accept, Authenticate, Authorize, Capture, CreateAccessToken, CreateConnectorCustomer,
CreateOrder, CreateSessionToken, DefendDispute, PSync, PaymentMethodToken,
PostAuthenticate, PreAuthenticate, RSync, Refund, RepeatPayment, SetupMandate,
SubmitEvidence, Void, VoidPC,
},
connector_types::{
AcceptDisputeData, AccessTokenRequestData, AccessTokenResponseData, ConnectorCustomerData,
ConnectorCustomerResponse, DisputeDefendData, DisputeFlowData, DisputeResponseData,
PaymentCreateOrderData, PaymentCreateOrderResponse, PaymentFlowData,
PaymentMethodTokenResponse, PaymentMethodTokenizationData, PaymentVoidData,
PaymentsAuthenticateData, PaymentsAuthorizeData, PaymentsCancelPostCaptureData,
PaymentsCaptureData, PaymentsPostAuthenticateData, PaymentsPreAuthenticateData,
PaymentsResponseData, PaymentsSyncData, RefundFlowData, RefundSyncData, RefundsData,
RefundsResponseData, RepeatPaymentData, ResponseId, SessionTokenRequestData,
SessionTokenResponseData, SetupMandateRequestData, SubmitEvidenceData,
},
errors,
payment_method_data::{DefaultPCIHolder, PaymentMethodData, PaymentMethodDataTypes},
router_data_v2::RouterDataV2,
router_response_types::Response,
types::Connectors,
};
use error_stack::ResultExt;
use hyperswitch_masking::Maskable;
use interfaces::{
api::ConnectorCommon,
connector_integration_v2::ConnectorIntegrationV2,
connector_types::{self},
};
use serde::Serialize;
use transformers as razorpayv2;
use crate::connectors::razorpay::transformers::ForeignTryFrom;
pub(crate) mod headers {
pub(crate) const CONTENT_TYPE: &str = "Content-Type";
pub(crate) const AUTHORIZATION: &str = "Authorization";
}
#[derive(Clone)]
pub struct RazorpayV2<T> {
#[allow(dead_code)]
pub(crate) amount_converter: &'static (dyn AmountConvertor<Output = MinorUnit> + Sync),
#[allow(dead_code)]
_phantom: std::marker::PhantomData<T>,
}
impl<T> RazorpayV2<T> {
pub const fn new() -> &'static Self {
&Self {
amount_converter: &common_utils::types::MinorUnitForConnector,
_phantom: std::marker::PhantomData,
}
}
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> interfaces::connector_types::ValidationTrait for RazorpayV2<T>
{
fn should_do_order_create(&self) -> bool {
true
}
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> ConnectorCommon for RazorpayV2<T>
{
fn id(&self) -> &'static str {
"razorpayv2"
}
fn get_currency_unit(&self) -> common_enums::CurrencyUnit {
common_enums::CurrencyUnit::Base
}
fn get_auth_header(
&self,
auth_type: &domain_types::router_data::ConnectorAuthType,
) -> CustomResult<Vec<(String, Maskable<String>)>, errors::ConnectorError> {
let auth = razorpayv2::RazorpayV2AuthType::try_from(auth_type)
.change_context(errors::ConnectorError::FailedToObtainAuthType)?;
Ok(vec![(
headers::AUTHORIZATION.to_string(),
auth.generate_authorization_header().into(),
)])
}
fn base_url<'a>(&self, connectors: &'a Connectors) -> &'a str {
&connectors.razorpayv2.base_url
}
fn build_error_response(
&self,
res: Response,
event_builder: Option<&mut events::Event>,
) -> CustomResult<domain_types::router_data::ErrorResponse, errors::ConnectorError> {
let response: razorpayv2::RazorpayV2ErrorResponse = res
.response
.parse_struct("RazorpayV2ErrorResponse")
.change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
if let Some(i) = event_builder {
i.set_connector_response(&response)
}
let (code, message, attempt_status) = match response {
| {
"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_3314128609778487701_1 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/razorpayv2.rs
razorpayv2::RazorpayV2ErrorResponse::StandardError { error } => {
let attempt_status = match error.code.as_str() {
"BAD_REQUEST_ERROR" => AttemptStatus::Failure,
"GATEWAY_ERROR" => AttemptStatus::Failure,
"AUTHENTICATION_ERROR" => AttemptStatus::AuthenticationFailed,
"AUTHORIZATION_ERROR" => AttemptStatus::AuthorizationFailed,
"SERVER_ERROR" => AttemptStatus::Pending,
_ => AttemptStatus::Pending,
};
(error.code, error.description.clone(), attempt_status)
}
razorpayv2::RazorpayV2ErrorResponse::SimpleError { message } => {
// For simple error messages like "no Route matched with those values"
// Default to failure status and use a generic error code
(
"ROUTE_ERROR".to_string(),
message.clone(),
AttemptStatus::Failure,
)
}
};
Ok(domain_types::router_data::ErrorResponse {
code,
message: message.clone(),
reason: Some(message),
status_code: res.status_code,
attempt_status: Some(attempt_status),
connector_transaction_id: None,
network_decline_code: None,
network_advice_code: None,
network_error_message: None,
})
}
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
ConnectorIntegrationV2<
CreateOrder,
PaymentFlowData,
PaymentCreateOrderData,
PaymentCreateOrderResponse,
> for RazorpayV2<T>
{
fn get_headers(
&self,
req: &domain_types::router_data_v2::RouterDataV2<
CreateOrder,
PaymentFlowData,
PaymentCreateOrderData,
PaymentCreateOrderResponse,
>,
) -> CustomResult<Vec<(String, Maskable<String>)>, errors::ConnectorError> {
let mut headers = vec![(
headers::CONTENT_TYPE.to_string(),
"application/json".to_string().into(),
)];
let mut auth_headers = self.get_auth_header(&req.connector_auth_type)?;
headers.append(&mut auth_headers);
Ok(headers)
}
fn get_url(
&self,
req: &domain_types::router_data_v2::RouterDataV2<
CreateOrder,
PaymentFlowData,
PaymentCreateOrderData,
PaymentCreateOrderResponse,
>,
) -> CustomResult<String, errors::ConnectorError> {
let base_url = &req.resource_common_data.connectors.razorpayv2.base_url;
Ok(format!("{base_url}v1/orders"))
}
fn get_request_body(
&self,
req: &domain_types::router_data_v2::RouterDataV2<
CreateOrder,
PaymentFlowData,
PaymentCreateOrderData,
PaymentCreateOrderResponse,
>,
) -> CustomResult<Option<RequestContent>, errors::ConnectorError> {
let connector_router_data: razorpayv2::RazorpayV2RouterData<&PaymentCreateOrderData, T> =
razorpayv2::RazorpayV2RouterData::try_from((
req.request.amount,
&req.request,
Some(
req.resource_common_data
.connector_request_reference_id
.clone(),
),
))?;
let connector_req =
razorpayv2::RazorpayV2CreateOrderRequest::try_from(&connector_router_data)?;
Ok(Some(RequestContent::Json(Box::new(connector_req))))
}
fn handle_response_v2(
&self,
data: &domain_types::router_data_v2::RouterDataV2<
CreateOrder,
PaymentFlowData,
PaymentCreateOrderData,
PaymentCreateOrderResponse,
>,
event_builder: Option<&mut events::Event>,
res: Response,
) -> CustomResult<
domain_types::router_data_v2::RouterDataV2<
CreateOrder,
PaymentFlowData,
PaymentCreateOrderData,
PaymentCreateOrderResponse,
>,
errors::ConnectorError,
> {
| {
"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_3314128609778487701_2 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/razorpayv2.rs
let response: razorpayv2::RazorpayV2CreateOrderResponse = res
.response
.parse_struct("RazorpayV2CreateOrderResponse")
.change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
if let Some(i) = event_builder {
i.set_connector_response(&response)
}
let order_response = PaymentCreateOrderResponse {
order_id: response.id,
};
Ok(domain_types::router_data_v2::RouterDataV2 {
response: Ok(order_response),
..data.clone()
})
}
fn get_error_response_v2(
&self,
res: Response,
event_builder: Option<&mut events::Event>,
) -> CustomResult<domain_types::router_data::ErrorResponse, errors::ConnectorError> {
self.build_error_response(res, event_builder)
}
fn get_5xx_error_response(
&self,
res: Response,
event_builder: Option<&mut events::Event>,
) -> CustomResult<domain_types::router_data::ErrorResponse, errors::ConnectorError> {
let response: razorpayv2::RazorpayV2ErrorResponse = res
.response
.parse_struct("RazorpayV2ErrorResponse")
.change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
if let Some(i) = event_builder {
i.set_connector_response(&response)
}
let (code, message) = match response {
razorpayv2::RazorpayV2ErrorResponse::StandardError { error } => {
(error.code, error.description.clone())
}
razorpayv2::RazorpayV2ErrorResponse::SimpleError { message } => {
("ROUTE_ERROR".to_string(), message.clone())
}
};
Ok(domain_types::router_data::ErrorResponse {
code,
message: message.clone(),
reason: Some(message),
status_code: res.status_code,
attempt_status: Some(AttemptStatus::Pending),
connector_transaction_id: None,
network_decline_code: None,
network_advice_code: None,
network_error_message: None,
})
}
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
ConnectorIntegrationV2<
Authorize,
PaymentFlowData,
PaymentsAuthorizeData<T>,
PaymentsResponseData,
> for RazorpayV2<T>
{
fn get_headers(
&self,
req: &domain_types::router_data_v2::RouterDataV2<
Authorize,
PaymentFlowData,
PaymentsAuthorizeData<T>,
PaymentsResponseData,
>,
) -> CustomResult<Vec<(String, Maskable<String>)>, errors::ConnectorError> {
let mut headers = vec![(
headers::CONTENT_TYPE.to_string(),
"application/json".to_string().into(),
)];
let mut auth_headers = self.get_auth_header(&req.connector_auth_type)?;
headers.append(&mut auth_headers);
Ok(headers)
}
fn get_url(
&self,
req: &domain_types::router_data_v2::RouterDataV2<
Authorize,
PaymentFlowData,
PaymentsAuthorizeData<T>,
PaymentsResponseData,
>,
) -> CustomResult<String, errors::ConnectorError> {
let base_url = &req.resource_common_data.connectors.razorpayv2.base_url;
// For UPI payments, use the specific UPI endpoint
match &req.request.payment_method_data {
PaymentMethodData::Upi(_) => Ok(format!("{base_url}v1/payments/create/upi")),
_ => Ok(format!("{base_url}v1/payments")),
}
}
fn get_request_body(
&self,
req: &domain_types::router_data_v2::RouterDataV2<
Authorize,
PaymentFlowData,
PaymentsAuthorizeData<T>,
PaymentsResponseData,
>,
) -> CustomResult<Option<RequestContent>, errors::ConnectorError> {
let order_id = req
.resource_common_data
.reference_id
.as_ref()
.ok_or_else(|| errors::ConnectorError::MissingRequiredField {
field_name: "reference_id",
})?
.clone();
let converted_amount = self
.amount_converter
| {
"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_3314128609778487701_3 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/razorpayv2.rs
.convert(req.request.minor_amount, req.request.currency)
.change_context(domain_types::errors::ConnectorError::RequestEncodingFailed)?;
let connector_router_data = razorpayv2::RazorpayV2RouterData::try_from((
converted_amount,
req,
Some(order_id),
req.resource_common_data
.address
.get_payment_method_billing()
.cloned(),
))?;
// Always use v2 request format
let connector_req =
razorpayv2::RazorpayV2PaymentsRequest::try_from(&connector_router_data)?;
Ok(Some(RequestContent::Json(Box::new(connector_req))))
}
fn handle_response_v2(
&self,
data: &domain_types::router_data_v2::RouterDataV2<
Authorize,
PaymentFlowData,
PaymentsAuthorizeData<T>,
PaymentsResponseData,
>,
event_builder: Option<&mut events::Event>,
res: Response,
) -> CustomResult<
domain_types::router_data_v2::RouterDataV2<
Authorize,
PaymentFlowData,
PaymentsAuthorizeData<T>,
PaymentsResponseData,
>,
errors::ConnectorError,
> {
// Try to parse as UPI response first
let upi_response_result = res
.response
.parse_struct::<razorpayv2::RazorpayV2UpiPaymentsResponse>(
"RazorpayV2UpiPaymentsResponse",
);
match upi_response_result {
Ok(upi_response) => {
if let Some(i) = event_builder {
i.set_connector_response(&upi_response)
}
// Use the transformer for UPI response handling
RouterDataV2::foreign_try_from((
upi_response,
data.clone(),
res.status_code,
res.response.to_vec(),
))
.change_context(errors::ConnectorError::ResponseHandlingFailed)
}
Err(_) => {
// Fall back to regular payment response
let response: razorpayv2::RazorpayV2PaymentsResponse = res
.response
.parse_struct("RazorpayV2PaymentsResponse")
.change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
if let Some(i) = event_builder {
i.set_connector_response(&response)
}
// Use the transformer for regular response handling
RouterDataV2::foreign_try_from((
response,
data.clone(),
res.status_code,
res.response.to_vec(),
))
.change_context(errors::ConnectorError::ResponseHandlingFailed)
}
}
}
fn get_error_response_v2(
&self,
res: Response,
event_builder: Option<&mut events::Event>,
) -> CustomResult<domain_types::router_data::ErrorResponse, errors::ConnectorError> {
self.build_error_response(res, event_builder)
}
fn get_5xx_error_response(
&self,
res: Response,
event_builder: Option<&mut events::Event>,
) -> CustomResult<domain_types::router_data::ErrorResponse, errors::ConnectorError> {
self.build_error_response(res, event_builder)
}
}
// Implement required traits for ConnectorServiceTrait
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> interfaces::connector_types::PaymentAuthorizeV2<T> for RazorpayV2<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> interfaces::connector_types::PaymentSyncV2 for RazorpayV2<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> interfaces::connector_types::PaymentOrderCreate for RazorpayV2<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
| {
"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_3314128609778487701_4 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/razorpayv2.rs
+ std::marker::Send
+ 'static
+ Serialize,
> interfaces::connector_types::PaymentVoidV2 for RazorpayV2<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> interfaces::connector_types::IncomingWebhook for RazorpayV2<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> interfaces::connector_types::RefundV2 for RazorpayV2<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> interfaces::connector_types::PaymentCapture for RazorpayV2<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> interfaces::connector_types::SetupMandateV2<T> for RazorpayV2<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> interfaces::connector_types::AcceptDispute for RazorpayV2<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> interfaces::connector_types::RefundSyncV2 for RazorpayV2<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> interfaces::connector_types::DisputeDefend for RazorpayV2<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> interfaces::connector_types::SubmitEvidenceV2 for RazorpayV2<T>
{
}
// Type alias for non-generic trait implementations
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
ConnectorIntegrationV2<
CreateSessionToken,
PaymentFlowData,
SessionTokenRequestData,
SessionTokenResponseData,
> for RazorpayV2<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
ConnectorIntegrationV2<
CreateAccessToken,
PaymentFlowData,
AccessTokenRequestData,
AccessTokenResponseData,
> for RazorpayV2<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
ConnectorIntegrationV2<
CreateConnectorCustomer,
PaymentFlowData,
ConnectorCustomerData,
ConnectorCustomerResponse,
> for RazorpayV2<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> interfaces::connector_types::ConnectorServiceTrait<T> for RazorpayV2<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> interfaces::connector_types::PaymentSessionToken for RazorpayV2<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> interfaces::connector_types::PaymentAccessToken for RazorpayV2<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> connector_types::CreateConnectorCustomer for RazorpayV2<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
| {
"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_3314128609778487701_5 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/razorpayv2.rs
> interfaces::connector_types::PaymentTokenV2<T> for RazorpayV2<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> interfaces::connector_types::RepeatPaymentV2 for RazorpayV2<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> interfaces::connector_types::PaymentPreAuthenticateV2<T> for RazorpayV2<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> interfaces::connector_types::PaymentAuthenticateV2<T> for RazorpayV2<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> interfaces::connector_types::PaymentPostAuthenticateV2<T> for RazorpayV2<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> interfaces::connector_types::PaymentVoidPostCaptureV2 for RazorpayV2<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
ConnectorIntegrationV2<
VoidPC,
PaymentFlowData,
PaymentsCancelPostCaptureData,
PaymentsResponseData,
> for RazorpayV2<T>
{
}
// Stub implementations for flows not yet implemented
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> ConnectorIntegrationV2<Void, PaymentFlowData, PaymentVoidData, PaymentsResponseData>
for RazorpayV2<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> ConnectorIntegrationV2<Capture, PaymentFlowData, PaymentsCaptureData, PaymentsResponseData>
for RazorpayV2<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> ConnectorIntegrationV2<PSync, PaymentFlowData, PaymentsSyncData, PaymentsResponseData>
for RazorpayV2<T>
{
fn get_http_method(&self) -> common_utils::Method {
common_utils::Method::Get
}
fn get_headers(
&self,
req: &domain_types::router_data_v2::RouterDataV2<
PSync,
PaymentFlowData,
PaymentsSyncData,
PaymentsResponseData,
>,
) -> CustomResult<Vec<(String, Maskable<String>)>, errors::ConnectorError> {
let mut headers = vec![(
headers::CONTENT_TYPE.to_string(),
"application/json".to_string().into(),
)];
let mut auth_headers = self.get_auth_header(&req.connector_auth_type)?;
headers.append(&mut auth_headers);
Ok(headers)
}
fn get_url(
&self,
req: &domain_types::router_data_v2::RouterDataV2<
PSync,
PaymentFlowData,
PaymentsSyncData,
PaymentsResponseData,
>,
) -> CustomResult<String, errors::ConnectorError> {
let base_url = &req.resource_common_data.connectors.razorpayv2.base_url;
// Check if request_ref_id is provided to determine URL pattern
let request_ref_id = &req.resource_common_data.connector_request_reference_id;
if !request_ref_id.is_empty() {
// Use orders endpoint when request_ref_id is provided
let url = format!("{base_url}v1/orders/{request_ref_id}/payments");
Ok(url)
} else {
// Extract payment ID from connector_transaction_id for standard payment sync
let payment_id = match &req.request.connector_transaction_id {
ResponseId::ConnectorTransactionId(id) => id,
ResponseId::EncodedData(data) => data,
ResponseId::NoResponseId => {
| {
"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_3314128609778487701_6 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/razorpayv2.rs
return Err(errors::ConnectorError::MissingRequiredField {
field_name: "connector_transaction_id",
}
.into());
}
};
let url = format!("{base_url}v1/payments/{payment_id}");
Ok(url)
}
}
fn get_request_body(
&self,
_req: &domain_types::router_data_v2::RouterDataV2<
PSync,
PaymentFlowData,
PaymentsSyncData,
PaymentsResponseData,
>,
) -> CustomResult<Option<RequestContent>, errors::ConnectorError> {
// GET request doesn't need a body
Ok(None)
}
fn handle_response_v2(
&self,
data: &domain_types::router_data_v2::RouterDataV2<
PSync,
PaymentFlowData,
PaymentsSyncData,
PaymentsResponseData,
>,
event_builder: Option<&mut events::Event>,
res: Response,
) -> CustomResult<
domain_types::router_data_v2::RouterDataV2<
PSync,
PaymentFlowData,
PaymentsSyncData,
PaymentsResponseData,
>,
errors::ConnectorError,
> {
// Parse the response using the enum that handles both collection and direct payment responses
let sync_response: razorpayv2::RazorpayV2SyncResponse = res
.response
.parse_struct("RazorpayV2SyncResponse")
.change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
if let Some(i) = event_builder {
i.set_connector_response(&sync_response)
}
// Use the transformer for PSync response handling
RouterDataV2::foreign_try_from((
sync_response,
data.clone(),
res.status_code,
res.response.to_vec(),
))
.change_context(errors::ConnectorError::ResponseHandlingFailed)
}
fn get_error_response_v2(
&self,
res: Response,
event_builder: Option<&mut events::Event>,
) -> CustomResult<domain_types::router_data::ErrorResponse, errors::ConnectorError> {
self.build_error_response(res, event_builder)
}
fn get_5xx_error_response(
&self,
res: Response,
event_builder: Option<&mut events::Event>,
) -> CustomResult<domain_types::router_data::ErrorResponse, errors::ConnectorError> {
self.build_error_response(res, event_builder)
}
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
ConnectorIntegrationV2<
SetupMandate,
PaymentFlowData,
SetupMandateRequestData<T>,
PaymentsResponseData,
> for RazorpayV2<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> ConnectorIntegrationV2<RSync, RefundFlowData, RefundSyncData, RefundsResponseData>
for RazorpayV2<T>
{
fn get_http_method(&self) -> common_utils::Method {
common_utils::Method::Get
}
fn get_headers(
&self,
req: &domain_types::router_data_v2::RouterDataV2<
RSync,
RefundFlowData,
RefundSyncData,
RefundsResponseData,
>,
) -> CustomResult<Vec<(String, Maskable<String>)>, errors::ConnectorError> {
let mut headers = vec![(
headers::CONTENT_TYPE.to_string(),
"application/json".to_string().into(),
)];
let mut auth_headers = self.get_auth_header(&req.connector_auth_type)?;
headers.append(&mut auth_headers);
Ok(headers)
}
fn get_url(
&self,
req: &domain_types::router_data_v2::RouterDataV2<
RSync,
RefundFlowData,
RefundSyncData,
RefundsResponseData,
>,
) -> CustomResult<String, errors::ConnectorError> {
let base_url = &req.resource_common_data.connectors.razorpayv2.base_url;
// Extract refund ID from connector_refund_id
let refund_id = &req.request.connector_refund_id;
Ok(format!("{base_url}v1/refunds/{refund_id}"))
}
fn get_request_body(
&self,
| {
"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_3314128609778487701_7 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/razorpayv2.rs
_req: &domain_types::router_data_v2::RouterDataV2<
RSync,
RefundFlowData,
RefundSyncData,
RefundsResponseData,
>,
) -> CustomResult<Option<RequestContent>, errors::ConnectorError> {
// GET request doesn't need a body
Ok(None)
}
fn handle_response_v2(
&self,
data: &domain_types::router_data_v2::RouterDataV2<
RSync,
RefundFlowData,
RefundSyncData,
RefundsResponseData,
>,
event_builder: Option<&mut events::Event>,
res: Response,
) -> CustomResult<
domain_types::router_data_v2::RouterDataV2<
RSync,
RefundFlowData,
RefundSyncData,
RefundsResponseData,
>,
errors::ConnectorError,
> {
let response: razorpayv2::RazorpayV2RefundResponse = res
.response
.parse_struct("RazorpayV2RefundResponse")
.change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
if let Some(i) = event_builder {
i.set_connector_response(&response)
}
RouterDataV2::foreign_try_from((
response,
data.clone(),
res.status_code,
res.response.to_vec(),
))
.change_context(errors::ConnectorError::ResponseHandlingFailed)
}
fn get_error_response_v2(
&self,
res: Response,
event_builder: Option<&mut events::Event>,
) -> CustomResult<domain_types::router_data::ErrorResponse, errors::ConnectorError> {
self.build_error_response(res, event_builder)
}
fn get_5xx_error_response(
&self,
res: Response,
event_builder: Option<&mut events::Event>,
) -> CustomResult<domain_types::router_data::ErrorResponse, errors::ConnectorError> {
self.build_error_response(res, event_builder)
}
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> ConnectorIntegrationV2<Refund, RefundFlowData, RefundsData, RefundsResponseData>
for RazorpayV2<T>
{
fn get_headers(
&self,
req: &domain_types::router_data_v2::RouterDataV2<
Refund,
RefundFlowData,
RefundsData,
RefundsResponseData,
>,
) -> CustomResult<Vec<(String, Maskable<String>)>, errors::ConnectorError> {
let mut headers = vec![(
headers::CONTENT_TYPE.to_string(),
"application/json".to_string().into(),
)];
let mut auth_headers = self.get_auth_header(&req.connector_auth_type)?;
headers.append(&mut auth_headers);
Ok(headers)
}
fn get_url(
&self,
req: &domain_types::router_data_v2::RouterDataV2<
Refund,
RefundFlowData,
RefundsData,
RefundsResponseData,
>,
) -> CustomResult<String, errors::ConnectorError> {
let base_url = &req.resource_common_data.connectors.razorpayv2.base_url;
let connector_payment_id = &req.request.connector_transaction_id;
Ok(format!(
"{base_url}v1/payments/{connector_payment_id}/refund"
))
}
fn get_request_body(
&self,
req: &domain_types::router_data_v2::RouterDataV2<
Refund,
RefundFlowData,
RefundsData,
RefundsResponseData,
>,
) -> CustomResult<Option<RequestContent>, errors::ConnectorError> {
let converted_amount = self
.amount_converter
.convert(req.request.minor_refund_amount, req.request.currency)
.change_context(errors::ConnectorError::RequestEncodingFailed)?;
let connector_router_data = razorpayv2::RazorpayV2RouterData::<
&RefundsData,
DefaultPCIHolder,
>::try_from((converted_amount, &req.request, None))?;
let connector_req = razorpayv2::RazorpayV2RefundRequest::try_from(&connector_router_data)?;
Ok(Some(RequestContent::Json(Box::new(connector_req))))
}
fn handle_response_v2(
&self,
data: &domain_types::router_data_v2::RouterDataV2<
Refund,
RefundFlowData,
RefundsData,
RefundsResponseData,
>,
| {
"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_3314128609778487701_8 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/razorpayv2.rs
event_builder: Option<&mut events::Event>,
res: Response,
) -> CustomResult<
domain_types::router_data_v2::RouterDataV2<
Refund,
RefundFlowData,
RefundsData,
RefundsResponseData,
>,
errors::ConnectorError,
> {
let response: razorpayv2::RazorpayV2RefundResponse = res
.response
.parse_struct("RazorpayV2RefundResponse")
.change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
if let Some(i) = event_builder {
i.set_connector_response(&response)
}
RouterDataV2::foreign_try_from((
response,
data.clone(),
res.status_code,
res.response.to_vec(),
))
.change_context(errors::ConnectorError::ResponseHandlingFailed)
}
fn get_error_response_v2(
&self,
res: Response,
event_builder: Option<&mut events::Event>,
) -> CustomResult<domain_types::router_data::ErrorResponse, errors::ConnectorError> {
self.build_error_response(res, event_builder)
}
fn get_5xx_error_response(
&self,
res: Response,
event_builder: Option<&mut events::Event>,
) -> CustomResult<domain_types::router_data::ErrorResponse, errors::ConnectorError> {
self.build_error_response(res, event_builder)
}
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> ConnectorIntegrationV2<Accept, DisputeFlowData, AcceptDisputeData, DisputeResponseData>
for RazorpayV2<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
ConnectorIntegrationV2<SubmitEvidence, DisputeFlowData, SubmitEvidenceData, DisputeResponseData>
for RazorpayV2<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> ConnectorIntegrationV2<DefendDispute, DisputeFlowData, DisputeDefendData, DisputeResponseData>
for RazorpayV2<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
interfaces::verification::SourceVerification<
CreateSessionToken,
PaymentFlowData,
SessionTokenRequestData,
SessionTokenResponseData,
> for RazorpayV2<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
interfaces::verification::SourceVerification<
CreateAccessToken,
PaymentFlowData,
AccessTokenRequestData,
AccessTokenResponseData,
> for RazorpayV2<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
interfaces::verification::SourceVerification<
CreateConnectorCustomer,
PaymentFlowData,
ConnectorCustomerData,
ConnectorCustomerResponse,
> for RazorpayV2<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
ConnectorIntegrationV2<
PaymentMethodToken,
PaymentFlowData,
PaymentMethodTokenizationData<T>,
PaymentMethodTokenResponse,
> for RazorpayV2<T>
{
}
// SourceVerification implementations for all flows
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
interfaces::verification::SourceVerification<
Authorize,
PaymentFlowData,
PaymentsAuthorizeData<T>,
PaymentsResponseData,
> for RazorpayV2<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
| {
"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_3314128609778487701_9 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/razorpayv2.rs
interfaces::verification::SourceVerification<
PSync,
PaymentFlowData,
PaymentsSyncData,
PaymentsResponseData,
> for RazorpayV2<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
interfaces::verification::SourceVerification<
Capture,
PaymentFlowData,
PaymentsCaptureData,
PaymentsResponseData,
> for RazorpayV2<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
interfaces::verification::SourceVerification<
Void,
PaymentFlowData,
PaymentVoidData,
PaymentsResponseData,
> for RazorpayV2<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
interfaces::verification::SourceVerification<
Refund,
RefundFlowData,
RefundsData,
RefundsResponseData,
> for RazorpayV2<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
interfaces::verification::SourceVerification<
RSync,
RefundFlowData,
RefundSyncData,
RefundsResponseData,
> for RazorpayV2<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
interfaces::verification::SourceVerification<
SetupMandate,
PaymentFlowData,
SetupMandateRequestData<T>,
PaymentsResponseData,
> for RazorpayV2<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
interfaces::verification::SourceVerification<
Accept,
DisputeFlowData,
AcceptDisputeData,
DisputeResponseData,
> for RazorpayV2<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
interfaces::verification::SourceVerification<
SubmitEvidence,
DisputeFlowData,
SubmitEvidenceData,
DisputeResponseData,
> for RazorpayV2<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
interfaces::verification::SourceVerification<
DefendDispute,
DisputeFlowData,
DisputeDefendData,
DisputeResponseData,
> for RazorpayV2<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
interfaces::verification::SourceVerification<
CreateOrder,
PaymentFlowData,
PaymentCreateOrderData,
PaymentCreateOrderResponse,
> for RazorpayV2<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
interfaces::verification::SourceVerification<
VoidPC,
PaymentFlowData,
PaymentsCancelPostCaptureData,
PaymentsResponseData,
> for RazorpayV2<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> domain_types::connector_types::ConnectorSpecifications for RazorpayV2<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
interfaces::verification::SourceVerification<
RepeatPayment,
PaymentFlowData,
RepeatPaymentData,
PaymentsResponseData,
> for RazorpayV2<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
| {
"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_3314128609778487701_10 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/razorpayv2.rs
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
ConnectorIntegrationV2<RepeatPayment, PaymentFlowData, RepeatPaymentData, PaymentsResponseData>
for RazorpayV2<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
interfaces::verification::SourceVerification<
PaymentMethodToken,
PaymentFlowData,
PaymentMethodTokenizationData<T>,
PaymentMethodTokenResponse,
> for RazorpayV2<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
ConnectorIntegrationV2<
PreAuthenticate,
PaymentFlowData,
PaymentsPreAuthenticateData<T>,
PaymentsResponseData,
> for RazorpayV2<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
ConnectorIntegrationV2<
Authenticate,
PaymentFlowData,
PaymentsAuthenticateData<T>,
PaymentsResponseData,
> for RazorpayV2<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
ConnectorIntegrationV2<
PostAuthenticate,
PaymentFlowData,
PaymentsPostAuthenticateData<T>,
PaymentsResponseData,
> for RazorpayV2<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
interfaces::verification::SourceVerification<
PreAuthenticate,
PaymentFlowData,
PaymentsPreAuthenticateData<T>,
PaymentsResponseData,
> for RazorpayV2<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
interfaces::verification::SourceVerification<
Authenticate,
PaymentFlowData,
PaymentsAuthenticateData<T>,
PaymentsResponseData,
> for RazorpayV2<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
interfaces::verification::SourceVerification<
PostAuthenticate,
PaymentFlowData,
PaymentsPostAuthenticateData<T>,
PaymentsResponseData,
> for RazorpayV2<T>
{
}
| {
"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_-7996050285594493577_0 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/macros.rs
use std::marker::PhantomData;
use common_utils::{errors::CustomResult, ext_traits::BytesExt};
use domain_types::{errors, router_data_v2::RouterDataV2};
use error_stack::ResultExt;
use crate::types;
pub trait FlowTypes {
type Flow;
type FlowCommonData;
type Request;
type Response;
}
impl<F, FCD, Req, Resp> FlowTypes for RouterDataV2<F, FCD, Req, Resp> {
type Flow = F;
type FlowCommonData = FCD;
type Request = Req;
type Response = Resp;
}
impl<F, FCD, Req, Resp> FlowTypes for &RouterDataV2<F, FCD, Req, Resp> {
type Flow = F;
type FlowCommonData = FCD;
type Request = Req;
type Response = Resp;
}
pub trait GetFormData {
fn get_form_data(&self) -> reqwest::multipart::Form;
}
pub struct NoRequestBody;
pub struct NoRequestBodyTemplating;
impl<F, FCD, Req, Resp> TryFrom<RouterDataV2<F, FCD, Req, Resp>> for NoRequestBody {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(_value: RouterDataV2<F, FCD, Req, Resp>) -> Result<Self, Self::Error> {
Ok(Self)
}
}
type RouterDataType<T> = RouterDataV2<
<T as FlowTypes>::Flow,
<T as FlowTypes>::FlowCommonData,
<T as FlowTypes>::Request,
<T as FlowTypes>::Response,
>;
type ResponseRouterDataType<T, R> = types::ResponseRouterData<
R,
RouterDataV2<
<T as FlowTypes>::Flow,
<T as FlowTypes>::FlowCommonData,
<T as FlowTypes>::Request,
<T as FlowTypes>::Response,
>,
>;
pub trait BridgeRequestResponse: Send + Sync {
type RequestBody;
type ResponseBody;
type ConnectorInputData: FlowTypes;
fn request_body(
&self,
rd: Self::ConnectorInputData,
) -> CustomResult<Self::RequestBody, errors::ConnectorError>
where
Self::RequestBody:
TryFrom<Self::ConnectorInputData, Error = error_stack::Report<errors::ConnectorError>>,
{
Self::RequestBody::try_from(rd)
}
fn response(
&self,
bytes: bytes::Bytes,
) -> CustomResult<Self::ResponseBody, errors::ConnectorError>
where
Self::ResponseBody: for<'a> serde::Deserialize<'a>,
{
if bytes.is_empty() {
serde_json::from_str("{}")
.change_context(errors::ConnectorError::ResponseDeserializationFailed)
} else {
bytes
.parse_struct(std::any::type_name::<Self::ResponseBody>())
.change_context(errors::ConnectorError::ResponseDeserializationFailed)
}
}
fn router_data(
&self,
response: ResponseRouterDataType<Self::ConnectorInputData, Self::ResponseBody>,
) -> CustomResult<RouterDataType<Self::ConnectorInputData>, errors::ConnectorError>
where
RouterDataType<Self::ConnectorInputData>: TryFrom<
ResponseRouterDataType<Self::ConnectorInputData, Self::ResponseBody>,
Error = error_stack::Report<errors::ConnectorError>,
>,
{
RouterDataType::<Self::ConnectorInputData>::try_from(response)
}
}
#[derive(Clone)]
pub struct Bridge<Q, S, T>(pub PhantomData<(Q, S, T)>);
macro_rules! expand_fn_get_request_body {
($connector: ident, $curl_res: ty, $flow: ident, $resource_common_data: ty, $request: ident, $response: ty) => {
paste::paste! {
fn get_request_body(
&self,
_req: &RouterDataV2<$flow, $resource_common_data, $request, $response>,
) -> CustomResult<Option<macro_types::RequestContent>, macro_types::ConnectorError>
{
// always return None
Ok(None)
}
}
};
(
$connector: ident,
$curl_req: ty,
FormData,
$curl_res: ty,
$flow: ident,
$resource_common_data: ty,
$request: ty,
$response: ty
) => {
paste::paste! {
fn get_request_body(
&self,
req: &RouterDataV2<$flow, $resource_common_data, $request, $response>,
) -> CustomResult<Option<macro_types::RequestContent>, macro_types::ConnectorError>
{
let bridge = self.[< $flow:snake >];
let input_data = [<$connector RouterData>] {
connector: self.to_owned(),
router_data: req.clone(),
};
let request = bridge.request_body(input_data)?;
| {
"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_-7996050285594493577_1 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/macros.rs
let form_data = <$curl_req as GetFormData>::get_form_data(&request);
Ok(Some(macro_types::RequestContent::FormData(form_data)))
}
}
};
(
$connector: ty,
$curl_req: ty,
$content_type: ident,
$curl_res: ty,
$flow: ident,
$resource_common_data: ty,
$request: ty,
$response: ty
) => {
paste::paste! {
fn get_request_body(
&self,
req: &RouterDataV2<$flow, $resource_common_data, $request, $response>,
) -> CustomResult<Option<macro_types::RequestContent>, macro_types::ConnectorError>
{
let bridge = self.[< $flow:snake >];
let input_data = [< $connector RouterData >] {
connector: self.to_owned(),
router_data: req.clone(),
};
let request = bridge.request_body(input_data)?;
Ok(Some(macro_types::RequestContent::$content_type(Box::new(request))))
}
}
};
}
pub(crate) use expand_fn_get_request_body;
macro_rules! expand_fn_handle_response {
// When preprocess_response is enabled - only for connectors that explicitly set it
($connector: ident, $flow: ident, $resource_common_data: ty, $request: ty, $response: ty, preprocess_enabled) => {
fn handle_response_v2(
&self,
data: &RouterDataV2<$flow, $resource_common_data, $request, $response>,
event_builder: Option<&mut events::Event>,
res: Response,
) -> CustomResult<
RouterDataV2<$flow, $resource_common_data, $request, $response>,
macro_types::ConnectorError,
> {
use error_stack::ResultExt;
paste::paste! {let bridge = self.[< $flow:snake >];}
// Apply preprocessing if specified in the macro
let response_bytes = self
.preprocess_response_bytes(data, res.response)
.change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
let response_body = bridge.response(response_bytes)?;
event_builder.map(|i| i.set_connector_response(&response_body));
let response_router_data = ResponseRouterData {
response: response_body,
router_data: data.clone(),
http_code: res.status_code,
};
let result = bridge.router_data(response_router_data)?;
Ok(result)
}
};
// When preprocess_response is disabled or default
($connector: ident, $flow: ident, $resource_common_data: ty, $request: ty, $response: ty, $preprocess_flag:tt) => {
fn handle_response_v2(
&self,
data: &RouterDataV2<$flow, $resource_common_data, $request, $response>,
event_builder: Option<&mut events::Event>,
res: Response,
) -> CustomResult<
RouterDataV2<$flow, $resource_common_data, $request, $response>,
macro_types::ConnectorError,
> {
paste::paste! {let bridge = self.[< $flow:snake >];}
let response_body = bridge.response(res.response)?;
event_builder.map(|i| i.set_connector_response(&response_body));
let response_router_data = ResponseRouterData {
response: response_body,
router_data: data.clone(),
http_code: res.status_code,
};
let result = bridge.router_data(response_router_data)?;
Ok(result)
}
};
}
pub(crate) use expand_fn_handle_response;
macro_rules! expand_default_functions {
(
function: get_headers,
flow_name:$flow: ident,
resource_common_data:$resource_common_data: ty,
flow_request:$request: ty,
flow_response:$response: ty,
) => {
fn get_headers(
&self,
req: &RouterDataV2<$flow, $resource_common_data, $request, $response>,
) -> macro_types::CustomResult<
Vec<(String, macro_types::Maskable<String>)>,
macro_types::ConnectorError,
> {
self.build_headers(req)
}
};
(
function: get_content_type,
flow_name:$flow: ident,
resource_common_data:$resource_common_data: ty,
| {
"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_-7996050285594493577_2 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/macros.rs
flow_request:$request: ty,
flow_response:$response: ty,
) => {
fn get_content_type(&self) -> &'static str {
self.common_get_content_type()
}
};
(
function: get_error_response_v2,
flow_name:$flow: ident,
resource_common_data:$resource_common_data: ty,
flow_request:$request: ty,
flow_response:$response: ty,
) => {
fn get_error_response_v2(
&self,
res: Response,
event_builder: Option<&mut events::Event>,
) -> CustomResult<ErrorResponse, macro_types::ConnectorError> {
self.build_error_response(res, event_builder)
}
};
}
pub(crate) use expand_default_functions;
macro_rules! macro_connector_implementation {
// MOST SPECIFIC PATTERNS FIRST - Version with preprocess_response: true and curl_request
(
connector_default_implementations: [$($function_name: ident), *],
connector: $connector: ident,
curl_request: $content_type:ident($curl_req: ty),
curl_response:$curl_res: ty,
flow_name:$flow: ident,
resource_common_data:$resource_common_data: ty,
flow_request:$request: ty,
flow_response:$response: ty,
http_method: $http_method_type:ident,
preprocess_response: true,
generic_type: $generic_type:tt,
[$($bounds:tt)*],
other_functions: {
$($function_def: tt)*
}
) => {
impl <$generic_type: $($bounds)*>
ConnectorIntegrationV2<
$flow,
$resource_common_data,
$request,
$response,
> for $connector<$generic_type>
{
fn get_http_method(&self) -> common_utils::request::Method {
common_utils::request::Method::$http_method_type
}
$($function_def)*
$(
macros::expand_default_functions!(
function: $function_name,
flow_name:$flow,
resource_common_data:$resource_common_data,
flow_request:$request,
flow_response:$response,
);
)*
macros::expand_fn_get_request_body!(
$connector,
$curl_req,
$content_type,
$curl_res,
$flow,
$resource_common_data,
$request,
$response
);
macros::expand_fn_handle_response!(
$connector,
$flow,
$resource_common_data,
$request,
$response,
preprocess_enabled
);
}
};
// Version with preprocess_response: true but no curl_request
(
connector_default_implementations: [$($function_name: ident), *],
connector: $connector: ident,
curl_response:$curl_res: ty,
flow_name:$flow: ident,
resource_common_data:$resource_common_data: ty,
flow_request:$request: ty,
flow_response:$response: ty,
http_method: $http_method_type:ident,
preprocess_response: true,
generic_type: $generic_type:tt,
[$($bounds:tt)*],
other_functions: {
$($function_def: tt)*
}
) => {
impl <$generic_type: $($bounds)*>
ConnectorIntegrationV2<
$flow,
$resource_common_data,
$request,
$response,
> for $connector<$generic_type>
{
fn get_http_method(&self) -> common_utils::request::Method {
common_utils::request::Method::$http_method_type
}
$($function_def)*
$(
macros::expand_default_functions!(
function: $function_name,
flow_name:$flow,
resource_common_data:$resource_common_data,
flow_request:$request,
flow_response:$response,
);
)*
macros::expand_fn_get_request_body!(
$connector,
$curl_res,
$flow,
$resource_common_data,
$request,
$response
);
| {
"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_-7996050285594493577_3 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/macros.rs
macros::expand_fn_handle_response!(
$connector,
$flow,
$resource_common_data,
$request,
$response,
preprocess_enabled
);
}
};
//Version without preprocess_response parameter (defaults to false)
(
connector_default_implementations: [$($function_name:ident), *],
connector: $connector:ident,
curl_request: $content_type:ident($curl_req:ty),
curl_response: $curl_res:ty,
flow_name: $flow:ident,
resource_common_data:$resource_common_data:ty,
flow_request: $request:ty,
flow_response: $response:ty,
http_method: $http_method_type:ident,
generic_type: $generic_type:tt,
[$($bounds:tt)*],
other_functions: {
$($function_def: tt)*
}
) => {
impl<$generic_type: $($bounds)*>
ConnectorIntegrationV2<
$flow,
$resource_common_data,
$request,
$response,
> for $connector<$generic_type>
{
fn get_http_method(&self) -> common_utils::request::Method {
common_utils::request::Method::$http_method_type
}
$($function_def)*
$(
macros::expand_default_functions!(
function: $function_name,
flow_name:$flow,
resource_common_data:$resource_common_data,
flow_request:$request,
flow_response:$response,
);
)*
macros::expand_fn_get_request_body!(
$connector,
$curl_req,
$content_type,
$curl_res,
$flow,
$resource_common_data,
$request,
$response
);
macros::expand_fn_handle_response!(
$connector,
$flow,
$resource_common_data,
$request,
$response,
no_preprocess
);
}
};
(
connector_default_implementations: [$($function_name:ident), *],
connector: $connector:ident,
curl_response: $curl_res:ty,
flow_name: $flow:ident,
resource_common_data:$resource_common_data:ty,
flow_request: $request:ident,
flow_response: $response:ty,
http_method: $http_method_type:ident,
generic_type: $generic_type:tt,
[$($bounds:tt)*],
other_functions: {
$($function_def: tt)*
}
) => {
impl<$generic_type: $($bounds)*>
ConnectorIntegrationV2<
$flow,
$resource_common_data,
$request,
$response,
> for $connector<$generic_type>
{
fn get_http_method(&self) -> common_utils::request::Method {
common_utils::request::Method::$http_method_type
}
$($function_def)*
$(
macros::expand_default_functions!(
function: $function_name,
flow_name:$flow,
resource_common_data:$resource_common_data,
flow_request:$request,
flow_response:$response,
);
)*
macros::expand_fn_get_request_body!(
$connector,
$curl_res,
$flow,
$resource_common_data,
$request,
$response
);
macros::expand_fn_handle_response!(
$connector,
$flow,
$resource_common_data,
$request,
$response,
no_preprocess
);
}
};
(
connector_default_implementations: [$($function_name:ident), *],
connector: $connector:ident,
curl_response: $curl_res:ty,
flow_name: $flow:ident,
resource_common_data:$resource_common_data:ty,
flow_request: $request:ty,
flow_response: $response:ty,
http_method: $http_method_type:ident,
preprocess_response: $preprocess_response: expr,
generic_type: $generic_type:tt,
| {
"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_-7996050285594493577_4 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/macros.rs
[$($bounds:tt)*],
other_functions: {
$($function_def: tt)*
}
) => {
impl<$generic_type: $($bounds)*>
ConnectorIntegrationV2<
$flow,
$resource_common_data,
$request,
$response,
> for $connector<$generic_type>
{
fn get_http_method(&self) -> common_utils::request::Method {
common_utils::request::Method::$http_method_type
}
$($function_def)*
$(
macros::expand_default_functions!(
function: $function_name,
flow_name:$flow,
resource_common_data:$resource_common_data,
flow_request:$request,
flow_response:$response,
);
)*
macros::expand_fn_get_request_body!(
$connector,
$curl_res,
$flow,
$resource_common_data,
$request,
$response
);
macros::expand_fn_handle_response!(
$connector,
$flow,
$resource_common_data,
$request,
$response,
preprocess_enabled
);
}
};
}
pub(crate) use macro_connector_implementation;
macro_rules! impl_templating {
(
connector: $connector: ident,
curl_request: $curl_req: ident,
curl_response: $curl_res: ident,
router_data: $router_data: ty,
generic_type: $generic_type: tt,
) => {
paste::paste!{
pub struct [<$curl_req Templating>];
pub struct [<$curl_res Templating>];
impl<$generic_type: PaymentMethodDataTypes + std::fmt::Debug + std::marker::Sync + std::marker::Send + 'static + serde::Serialize> BridgeRequestResponse for Bridge<[<$curl_req Templating>], [<$curl_res Templating>], $generic_type>{
type RequestBody = $curl_req;
type ResponseBody = $curl_res;
type ConnectorInputData = [<$connector RouterData>]<$router_data, $generic_type>;
}
}
};
(
connector: $connector: ident,
curl_response: $curl_res: ident,
router_data: $router_data: ty,
generic_type: $generic_type:tt,
) => {
paste::paste!{
pub struct [<$curl_res Templating>];
impl<$generic_type: PaymentMethodDataTypes + std::fmt::Debug + std::marker::Sync + std::marker::Send + 'static + serde::Serialize> BridgeRequestResponse for Bridge<NoRequestBodyTemplating, [<$curl_res Templating>], $generic_type> {
type RequestBody = NoRequestBody;
type ResponseBody = $curl_res;
type ConnectorInputData = [<$connector RouterData>]<$router_data, $generic_type>;
}
}
};
}
pub(crate) use impl_templating;
macro_rules! impl_templating_mixed {
// Pattern for generic request types like AdyenPaymentRequest<T>
(
connector: $connector: ident,
curl_request: $base_req: ident<$req_generic: ident>,
curl_response: $curl_res: ident,
router_data: $router_data: ty,
generic_type: $generic_type: tt,
) => {
paste::paste!{
pub struct [<$base_req Templating>];
pub struct [<$curl_res Templating>];
impl<$generic_type: PaymentMethodDataTypes + std::fmt::Debug + std::marker::Sync + std::marker::Send + 'static + serde::Serialize> BridgeRequestResponse for Bridge<[<$base_req Templating>], [<$curl_res Templating>], $generic_type>{
type RequestBody = $base_req<$generic_type>;
type ResponseBody = $curl_res;
type ConnectorInputData = [<$connector RouterData>]<$router_data, $generic_type>;
}
}
};
// Pattern for non-generic request types like AdyenRedirectRequest
(
connector: $connector: ident,
curl_request: $base_req: ident,
curl_response: $curl_res: ident,
router_data: $router_data: ty,
generic_type: $generic_type: tt,
) => {
paste::paste!{
pub struct [<$base_req Templating>];
pub struct [<$curl_res Templating>];
| {
"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_-7996050285594493577_5 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/macros.rs
impl<$generic_type: PaymentMethodDataTypes + std::fmt::Debug + std::marker::Sync + std::marker::Send + 'static + serde::Serialize> BridgeRequestResponse for Bridge<[<$base_req Templating>], [<$curl_res Templating>], $generic_type>{
type RequestBody = $base_req;
type ResponseBody = $curl_res;
type ConnectorInputData = [<$connector RouterData>]<$router_data, $generic_type>;
}
}
};
}
pub(crate) use impl_templating_mixed;
macro_rules! resolve_request_body_type {
// Generic type like AdyenPaymentRequest<T>
($base_req: ident<$req_generic: ident>, $generic_type: tt) => {
$base_req<$generic_type>
};
// Non-generic type like AdyenRedirectRequest
($base_req: ident, $generic_type: tt) => {
$base_req
};
}
pub(crate) use resolve_request_body_type;
macro_rules! resolve_templating_type {
// Generic type like AdyenPaymentRequest<T>
($base_req: ident<$req_generic: ident>) => {
paste::paste! { [<$base_req Templating>] }
};
// Non-generic type like AdyenRedirectRequest
($base_req: ident) => {
paste::paste! { [<$base_req Templating>] }
};
}
pub(crate) use resolve_templating_type;
macro_rules! expand_connector_input_data {
($connector: ident, $generics: tt) => {
paste::paste! {
pub struct [<$connector RouterData>]<RD: FlowTypes, $generics: PaymentMethodDataTypes + std::fmt::Debug + std::marker::Sync + std::marker::Send + 'static + serde::Serialize> {
pub connector: $connector<$generics>,
pub router_data: RD,
}
impl<RD: FlowTypes, $generics: PaymentMethodDataTypes + std::fmt::Debug + std::marker::Sync + std::marker::Send + 'static + serde::Serialize> FlowTypes for [<$connector RouterData>]<RD, $generics> { //here too
type Flow = RD::Flow;
type FlowCommonData = RD::FlowCommonData;
type Request = RD::Request;
type Response = RD::Response;
}
}
};
}
pub(crate) use expand_connector_input_data;
macro_rules! create_all_prerequisites {
(
connector_name: $connector: ident,
generic_type: $generic_type:tt,
api: [
$(
(
flow: $flow_name: ident,
$(request_body: $flow_request: ident $(<$generic_param: ident>)?,)?
response_body: $flow_response: ident,
router_data: $router_data_type: ty,
)
),*
],
amount_converters: [
$($converter_name:ident : $amount_unit:ty),*
],
member_functions: {
$($function_def: tt)*
}
) => {
crate::connectors::macros::expand_imports!();
crate::connectors::macros::expand_connector_input_data!($connector, $generic_type);
$(
crate::connectors::macros::create_all_prerequisites_impl_templating!(
connector: $connector,
$(request_body: $flow_request $(<$generic_param>)?,)?
response_body: $flow_response,
router_data: $router_data_type,
generic_type: $generic_type,
);
)*
paste::paste! {
pub struct $connector<$generic_type: PaymentMethodDataTypes + std::fmt::Debug + std::marker::Sync + std::marker::Send + 'static + serde::Serialize> {
$(
pub $converter_name: &'static (dyn common_utils::types::AmountConvertor<Output = $amount_unit> + Sync),
)*
$(
[<$flow_name:snake>]: &'static dyn BridgeRequestResponse<
RequestBody = crate::connectors::macros::create_all_prerequisites_resolve_request_body_type!($(request_body: $flow_request $(<$generic_param>)?,)? generic_type: $generic_type),
ResponseBody = $flow_response,
ConnectorInputData = [<$connector RouterData>]<$router_data_type, $generic_type>,
>,
)*
}
impl<$generic_type: PaymentMethodDataTypes + std::fmt::Debug + std::marker::Sync + std::marker::Send + 'static + serde::Serialize> Clone for $connector<$generic_type> {
| {
"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_-7996050285594493577_6 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/macros.rs
fn clone(&self) -> Self {
Self {
$(
$converter_name: self.$converter_name,
)*
$(
[<$flow_name:snake>]: self.[<$flow_name:snake>],
)*
}
}
}
impl<$generic_type: PaymentMethodDataTypes + std::fmt::Debug + std::marker::Sync + std::marker::Send + 'static + serde::Serialize> $connector<$generic_type> {
pub const fn new() -> &'static Self {
&Self{
$(
$converter_name: &common_utils::types::[<$amount_unit ForConnector>],
)*
$(
[<$flow_name:snake>]: &Bridge::<
crate::connectors::macros::create_all_prerequisites_resolve_templating_type!($(request_body: $flow_request $(<$generic_param>)?,)?),
[<$flow_response Templating>], $generic_type
>(PhantomData),
)*
}
}
$($function_def)*
}
}
};
}
pub(crate) use create_all_prerequisites;
macro_rules! create_all_prerequisites_impl_templating {
// Pattern with request body
(
connector: $connector: ident,
request_body: $flow_request: ident $(<$generic_param: ident>)?,
response_body: $flow_response: ident,
router_data: $router_data_type: ty,
generic_type: $generic_type: tt,
) => {
crate::connectors::macros::impl_templating_mixed!(
connector: $connector,
curl_request: $flow_request $(<$generic_param>)?,
curl_response: $flow_response,
router_data: $router_data_type,
generic_type: $generic_type,
);
};
// Pattern without request body
(
connector: $connector: ident,
response_body: $flow_response: ident,
router_data: $router_data_type: ty,
generic_type: $generic_type: tt,
) => {
crate::connectors::macros::impl_templating!(
connector: $connector,
curl_response: $flow_response,
router_data: $router_data_type,
generic_type: $generic_type,
);
};
}
pub(crate) use create_all_prerequisites_impl_templating;
macro_rules! create_all_prerequisites_resolve_request_body_type {
// Pattern with request body
(
request_body: $flow_request: ident $(<$generic_param: ident>)?,
generic_type: $generic_type: tt
) => {
crate::connectors::macros::resolve_request_body_type!($flow_request $(<$generic_param>)?, $generic_type)
};
// Pattern without request body
(
generic_type: $generic_type: tt
) => {
NoRequestBody
};
}
pub(crate) use create_all_prerequisites_resolve_request_body_type;
macro_rules! create_all_prerequisites_resolve_templating_type {
// Pattern with request body
(
request_body: $flow_request: ident $(<$generic_param: ident>)?,
) => {
crate::connectors::macros::resolve_templating_type!($flow_request $(<$generic_param>)?)
};
// Pattern without request body
() => {
NoRequestBodyTemplating
};
}
pub(crate) use create_all_prerequisites_resolve_templating_type;
macro_rules! expand_imports {
() => {
use std::marker::PhantomData;
#[allow(unused_imports)]
use crate::connectors::macros::{
Bridge, BridgeRequestResponse, FlowTypes, GetFormData, NoRequestBody,
NoRequestBodyTemplating,
};
#[allow(unused_imports)]
mod macro_types {
// pub(super) use domain_models::{
// AuthenticationInitiation, Confirmation, PostAuthenticationSync, PreAuthentication,
// };
pub(super) use common_utils::{errors::CustomResult, events, request::RequestContent};
pub(super) use domain_types::{
errors::ConnectorError, router_data::ErrorResponse, router_data_v2::RouterDataV2,
router_response_types::Response,
};
pub(super) use hyperswitch_masking::Maskable;
| {
"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_-7996050285594493577_7 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/macros.rs
pub(super) use crate::types::*;
}
};
}
pub(crate) use expand_imports;
macro_rules! create_amount_converter_wrapper {
(connector_name: $connector_name:ident, amount_type: $amount_type:ty) => {
paste::paste! {
#[derive(Default, Debug, Clone, Copy, PartialEq)]
pub struct [<$connector_name AmountConvertor>];
impl [<$connector_name AmountConvertor>] {
pub fn convert(
amount: common_utils::types::MinorUnit,
currency: common_enums::Currency,
) -> Result<common_utils::types::$amount_type, error_stack::Report<errors::ConnectorError>> {
domain_types::utils::convert_amount(
&common_utils::types::[<$amount_type ForConnector>],
amount,
currency,
)
}
pub fn convert_back(
amount: common_utils::types::$amount_type,
currency: common_enums::Currency,
) -> Result<common_utils::types::MinorUnit, error_stack::Report<errors::ConnectorError>> {
domain_types::utils::convert_back_amount_to_minor_units(
&common_utils::types::[<$amount_type ForConnector>],
amount,
currency,
)
}
}
}
};
}
pub(crate) use create_amount_converter_wrapper;
| {
"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_-5935928029102272606_0 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/aci.rs
pub mod aci_result_codes;
pub mod transformers;
use common_utils::{errors::CustomResult, events, ext_traits::ByteSliceExt, StringMajorUnit};
use domain_types::{
connector_flow::{
Accept, Authenticate, Authorize, Capture, CreateAccessToken, CreateConnectorCustomer,
CreateOrder, CreateSessionToken, DefendDispute, PSync, PaymentMethodToken,
PostAuthenticate, PreAuthenticate, RSync, Refund, RepeatPayment, SetupMandate,
SubmitEvidence, Void, VoidPC,
},
connector_types::{
AcceptDisputeData, AccessTokenRequestData, AccessTokenResponseData, ConnectorCustomerData,
ConnectorCustomerResponse, DisputeDefendData, DisputeFlowData, DisputeResponseData,
MandateReferenceId, PaymentCreateOrderData, PaymentCreateOrderResponse, PaymentFlowData,
PaymentMethodTokenResponse, PaymentMethodTokenizationData, PaymentVoidData,
PaymentsAuthenticateData, PaymentsAuthorizeData, PaymentsCancelPostCaptureData,
PaymentsCaptureData, PaymentsPostAuthenticateData, PaymentsPreAuthenticateData,
PaymentsResponseData, PaymentsSyncData, RefundFlowData, RefundSyncData, RefundsData,
RefundsResponseData, RepeatPaymentData, SessionTokenRequestData, SessionTokenResponseData,
SetupMandateRequestData, SubmitEvidenceData,
},
errors,
payment_method_data::PaymentMethodDataTypes,
router_data::{ConnectorAuthType, ErrorResponse},
router_data_v2::RouterDataV2,
router_response_types::Response,
types::Connectors,
};
use error_stack::ResultExt;
use hyperswitch_masking::{Mask, Maskable, PeekInterface};
use interfaces::{
api::ConnectorCommon, connector_integration_v2::ConnectorIntegrationV2, connector_types,
};
use common_enums::CurrencyUnit;
use serde::Serialize;
use std::fmt::Debug;
use transformers::{
self as aci, AciCancelRequest, AciCaptureRequest, AciCaptureResponse, AciMandateRequest,
AciMandateResponse, AciPaymentsRequest, AciPaymentsResponse,
AciPaymentsResponse as AciPaymentsSyncResponse,
AciPaymentsResponse as AciRepeatPaymentResponse, AciRefundRequest, AciRefundResponse,
AciRepeatPaymentRequest, AciVoidResponse,
};
use super::macros;
use crate::{types::ResponseRouterData, with_error_response_body};
pub(crate) mod headers {
pub(crate) const CONTENT_TYPE: &str = "Content-Type";
pub(crate) const AUTHORIZATION: &str = "Authorization";
}
// Trait implementations with generic type parameters
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::PaymentPreAuthenticateV2<T> for Aci<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::PaymentAuthenticateV2<T> for Aci<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::PaymentPostAuthenticateV2<T> for Aci<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::ConnectorServiceTrait<T> for Aci<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::PaymentAuthorizeV2<T> for Aci<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::PaymentSyncV2 for Aci<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::PaymentVoidV2 for Aci<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::RefundSyncV2 for Aci<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::RefundV2 for Aci<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::PaymentCapture for Aci<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::ValidationTrait for Aci<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::SetupMandateV2<T> for Aci<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::RepeatPaymentV2 for Aci<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::AcceptDispute for Aci<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
| {
"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_-5935928029102272606_1 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/aci.rs
connector_types::SubmitEvidenceV2 for Aci<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::DisputeDefend for Aci<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::IncomingWebhook for Aci<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::PaymentOrderCreate for Aci<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::PaymentSessionToken for Aci<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::PaymentAccessToken for Aci<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> connector_types::CreateConnectorCustomer for Aci<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::PaymentTokenV2<T> for Aci<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::PaymentVoidPostCaptureV2 for Aci<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize> ConnectorCommon
for Aci<T>
{
fn id(&self) -> &'static str {
"aci"
}
fn get_currency_unit(&self) -> CurrencyUnit {
CurrencyUnit::Base
}
fn common_get_content_type(&self) -> &'static str {
"application/x-www-form-urlencoded"
}
fn base_url<'a>(&self, connectors: &'a Connectors) -> &'a str {
connectors.aci.base_url.as_ref()
}
fn get_auth_header(
&self,
auth_type: &ConnectorAuthType,
) -> CustomResult<Vec<(String, hyperswitch_masking::Maskable<String>)>, errors::ConnectorError>
{
let auth = aci::AciAuthType::try_from(auth_type)
.change_context(errors::ConnectorError::FailedToObtainAuthType)?;
Ok(vec![(
headers::AUTHORIZATION.to_string(),
format!("Bearer {}", auth.api_key.peek()).into_masked(),
)])
}
fn build_error_response(
&self,
res: Response,
event_builder: Option<&mut events::Event>,
) -> CustomResult<ErrorResponse, errors::ConnectorError> {
let response: aci::AciErrorResponse = res
.response
.parse_struct("AciErrorResponse")
.change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
with_error_response_body!(event_builder, response);
Ok(ErrorResponse {
status_code: res.status_code,
code: response.result.code,
message: response.result.description,
reason: response.result.parameter_errors.map(|errors| {
errors
.into_iter()
.map(|error_description| {
format!(
"Field is {} and the message is {}",
error_description.name, error_description.message
)
})
.collect::<Vec<String>>()
.join("; ")
}),
attempt_status: None,
connector_transaction_id: None,
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
})
}
}
macros::create_all_prerequisites!(
connector_name: Aci,
generic_type: T,
api: [
(
flow: Authorize,
request_body: AciPaymentsRequest<T>,
response_body: AciPaymentsResponse,
router_data: RouterDataV2<Authorize, PaymentFlowData, PaymentsAuthorizeData<T>, PaymentsResponseData>,
),
(
flow: SetupMandate,
request_body: AciMandateRequest<T>,
response_body: AciMandateResponse,
router_data: RouterDataV2<SetupMandate, PaymentFlowData, SetupMandateRequestData<T>, PaymentsResponseData>,
),
(
flow: PSync,
response_body: AciPaymentsSyncResponse,
router_data: RouterDataV2<PSync, PaymentFlowData, PaymentsSyncData, PaymentsResponseData>,
),
(
flow: Capture,
request_body: AciCaptureRequest,
response_body: AciCaptureResponse,
| {
"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_-5935928029102272606_2 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/aci.rs
router_data: RouterDataV2<Capture, PaymentFlowData, PaymentsCaptureData, PaymentsResponseData>,
),
(
flow: Void,
request_body: AciCancelRequest,
response_body: AciVoidResponse,
router_data: RouterDataV2<Void, PaymentFlowData, PaymentVoidData, PaymentsResponseData>,
),
(
flow: Refund,
request_body: AciRefundRequest,
response_body: AciRefundResponse,
router_data: RouterDataV2<Refund, RefundFlowData, RefundsData, RefundsResponseData>,
),
(
flow: RepeatPayment,
request_body: AciRepeatPaymentRequest<T>,
response_body: AciRepeatPaymentResponse,
router_data: RouterDataV2<RepeatPayment, PaymentFlowData, RepeatPaymentData, PaymentsResponseData>,
)
],
amount_converters: [
amount_converter: StringMajorUnit
],
member_functions: {
pub fn build_headers<F, FCD, Req, Res>(
&self,
req: &RouterDataV2<F, FCD, Req, Res>,
) -> CustomResult<Vec<(String, Maskable<String>)>, errors::ConnectorError>
where
Self: ConnectorIntegrationV2<F, FCD, Req, Res>,
{
let mut header = vec![(
headers::CONTENT_TYPE.to_string(),
self.common_get_content_type().to_string().into(),
)];
let mut api_key = self.get_auth_header(&req.connector_auth_type)?;
header.append(&mut api_key);
Ok(header)
}
pub fn connector_base_url_payments<'a, F, Req, Res>(
&self,
req: &'a RouterDataV2<F, PaymentFlowData, Req, Res>,
) -> &'a str {
&req.resource_common_data.connectors.aci.base_url
}
pub fn connector_base_url_refunds<'a, F, Req, Res>(
&self,
req: &'a RouterDataV2<F, RefundFlowData, Req, Res>,
) -> &'a str {
&req.resource_common_data.connectors.aci.base_url
}
pub fn extract_mandate_id(
&self,
mandate_reference: &MandateReferenceId,
) -> CustomResult<String, errors::ConnectorError> {
match mandate_reference {
MandateReferenceId::ConnectorMandateId(connector_mandate_ref) => connector_mandate_ref
.get_connector_mandate_id()
.ok_or_else(|| {
error_stack::report!(errors::ConnectorError::MissingRequiredField {
field_name: "connector_mandate_id"
})
}),
MandateReferenceId::NetworkMandateId(_) => {
Err(error_stack::report!(errors::ConnectorError::NotImplemented(
"Network mandate ID not supported for repeat payments in aci"
.to_string(),
)))
}
MandateReferenceId::NetworkTokenWithNTI(_) => {
Err(error_stack::report!(errors::ConnectorError::NotImplemented(
"Network token with NTI not supported for aci".to_string(),
)))
}
}
}
}
);
macros::macro_connector_implementation!(
connector_default_implementations: [get_content_type, get_error_response_v2],
connector: Aci,
curl_request: FormUrlEncoded(AciPaymentsRequest),
curl_response: AciPaymentsResponse,
flow_name: Authorize,
resource_common_data: PaymentFlowData,
flow_request: PaymentsAuthorizeData<T>,
flow_response: PaymentsResponseData,
http_method: Post,
generic_type: T,
[PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize],
other_functions: {
fn get_headers(
&self,
req: &RouterDataV2<Authorize, PaymentFlowData, PaymentsAuthorizeData<T>, PaymentsResponseData>,
) -> CustomResult<Vec<(String, Maskable<String>)>, errors::ConnectorError> {
self.build_headers(req)
}
fn get_url(
&self,
req: &RouterDataV2<Authorize, PaymentFlowData, PaymentsAuthorizeData<T>, PaymentsResponseData>,
) -> CustomResult<String, errors::ConnectorError> {
Ok(format!("{}{}", self.connector_base_url_payments(req), "v1/payments"))
}
}
);
| {
"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_-5935928029102272606_3 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/aci.rs
macros::macro_connector_implementation!(
connector_default_implementations: [get_content_type, get_error_response_v2],
connector: Aci,
curl_request: FormUrlEncoded(AciMandateRequest<T>),
curl_response: AciMandateResponse,
flow_name: SetupMandate,
resource_common_data: PaymentFlowData,
flow_request: SetupMandateRequestData<T>,
flow_response: PaymentsResponseData,
http_method: Post,
generic_type: T,
[PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize],
other_functions: {
fn get_headers(
&self,
req: &RouterDataV2<SetupMandate, PaymentFlowData, SetupMandateRequestData<T>, PaymentsResponseData>,
) -> CustomResult<Vec<(String, Maskable<String>)>, errors::ConnectorError> {
self.build_headers(req)
}
fn get_url(
&self,
req: &RouterDataV2<SetupMandate, PaymentFlowData, SetupMandateRequestData<T>, PaymentsResponseData>,
) -> CustomResult<String, errors::ConnectorError> {
Ok(format!("{}v1/registrations", self.connector_base_url_payments(req)))
}
}
);
macros::macro_connector_implementation!(
connector_default_implementations: [get_content_type, get_error_response_v2],
connector: Aci,
curl_response: AciPaymentsSyncResponse,
flow_name: PSync,
resource_common_data: PaymentFlowData,
flow_request: PaymentsSyncData,
flow_response: PaymentsResponseData,
http_method: Get,
generic_type: T,
[PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize],
other_functions: {
fn get_headers(
&self,
req: &RouterDataV2<PSync, PaymentFlowData, PaymentsSyncData, PaymentsResponseData>,
) -> CustomResult<Vec<(String, Maskable<String>)>, errors::ConnectorError> {
self.build_headers(req)
}
fn get_url(
&self,
req: &RouterDataV2<PSync, PaymentFlowData, PaymentsSyncData, PaymentsResponseData>,
) -> CustomResult<String, errors::ConnectorError> {
let auth = aci::AciAuthType::try_from(&req.connector_auth_type)?;
Ok(format!(
"{}{}{}{}{}",
self.connector_base_url_payments(req),
"v1/payments/",
req.request
.connector_transaction_id
.get_connector_transaction_id()
.change_context(errors::ConnectorError::MissingConnectorTransactionID)?,
"?entityId=",
auth.entity_id.peek()
))
}
}
);
macros::macro_connector_implementation!(
connector_default_implementations: [get_content_type, get_error_response_v2],
connector: Aci,
curl_request: FormUrlEncoded(AciCaptureRequest),
curl_response: AciCaptureResponse,
flow_name: Capture,
resource_common_data: PaymentFlowData,
flow_request: PaymentsCaptureData,
flow_response: PaymentsResponseData,
http_method: Post,
generic_type: T,
[PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize],
other_functions: {
fn get_headers(
&self,
req: &RouterDataV2<Capture, PaymentFlowData, PaymentsCaptureData, PaymentsResponseData>,
) -> CustomResult<Vec<(String, Maskable<String>)>, errors::ConnectorError> {
self.build_headers(req)
}
fn get_url(
&self,
req: &RouterDataV2<Capture, PaymentFlowData, PaymentsCaptureData, PaymentsResponseData>,
) -> CustomResult<String, errors::ConnectorError> {
Ok(format!(
"{}{}{}",
self.connector_base_url_payments(req),
"v1/payments/",
req.request
.connector_transaction_id
.get_connector_transaction_id()
.change_context(errors::ConnectorError::MissingConnectorTransactionID)?,
))
}
}
);
macros::macro_connector_implementation!(
connector_default_implementations: [get_content_type, get_error_response_v2],
connector: Aci,
curl_request: FormUrlEncoded(AciCancelRequest),
curl_response: AciVoidResponse,
flow_name: Void,
resource_common_data: PaymentFlowData,
flow_request: PaymentVoidData,
flow_response: PaymentsResponseData,
http_method: Post,
generic_type: 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_-5935928029102272606_4 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/aci.rs
[PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize],
other_functions: {
fn get_headers(
&self,
req: &RouterDataV2<Void, PaymentFlowData, PaymentVoidData, PaymentsResponseData>,
) -> CustomResult<Vec<(String, Maskable<String>)>, errors::ConnectorError> {
self.build_headers(req)
}
fn get_url(
&self,
req: &RouterDataV2<Void, PaymentFlowData, PaymentVoidData, PaymentsResponseData>,
) -> CustomResult<String, errors::ConnectorError> {
let id = &req.request.connector_transaction_id;
Ok(format!("{}v1/payments/{}", self.connector_base_url_payments(req), id))
}
}
);
macros::macro_connector_implementation!(
connector_default_implementations: [get_content_type, get_error_response_v2],
connector: Aci,
curl_request: FormUrlEncoded(AciRefundRequest),
curl_response: AciRefundResponse,
flow_name: Refund,
resource_common_data: RefundFlowData,
flow_request: RefundsData,
flow_response: RefundsResponseData,
http_method: Post,
generic_type: T,
[PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize],
other_functions: {
fn get_headers(
&self,
req: &RouterDataV2<Refund, RefundFlowData, RefundsData, RefundsResponseData>,
) -> CustomResult<Vec<(String, Maskable<String>)>, errors::ConnectorError> {
self.build_headers(req)
}
fn get_url(
&self,
req: &RouterDataV2<Refund, RefundFlowData, RefundsData, RefundsResponseData>,
) -> CustomResult<String, errors::ConnectorError> {
let connector_payment_id = req.request.connector_transaction_id.clone();
Ok(format!(
"{}v1/payments/{}",
self.connector_base_url_refunds(req),
connector_payment_id,
))
}
}
);
macros::macro_connector_implementation!(
connector_default_implementations: [get_content_type, get_error_response_v2],
connector: Aci,
curl_request: FormUrlEncoded(AciRepeatPaymentRequest<T>),
curl_response: AciRepeatPaymentResponse,
flow_name: RepeatPayment,
resource_common_data: PaymentFlowData,
flow_request: RepeatPaymentData,
flow_response: PaymentsResponseData,
http_method: Post,
generic_type: T,
[PaymentMethodDataTypes + std::fmt::Debug + std::marker::Sync + std::marker::Send + 'static + Serialize],
other_functions: {
fn get_headers(
&self,
req: &RouterDataV2<RepeatPayment, PaymentFlowData, RepeatPaymentData, PaymentsResponseData>,
) -> CustomResult<Vec<(String, Maskable<String>)>, errors::ConnectorError> {
self.build_headers(req)
}
fn get_url(
&self,
req: &RouterDataV2<RepeatPayment, PaymentFlowData, RepeatPaymentData, PaymentsResponseData>,
) -> CustomResult<String, errors::ConnectorError> {
let mandate_id = self.extract_mandate_id(&req.request.mandate_reference)?;
Ok(format!("{}v1/registrations/{}/payments",self.connector_base_url_payments(req),mandate_id))
}
}
);
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
ConnectorIntegrationV2<RSync, RefundFlowData, RefundSyncData, RefundsResponseData> for Aci<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
ConnectorIntegrationV2<Accept, DisputeFlowData, AcceptDisputeData, DisputeResponseData>
for Aci<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
ConnectorIntegrationV2<SubmitEvidence, DisputeFlowData, SubmitEvidenceData, DisputeResponseData>
for Aci<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
ConnectorIntegrationV2<DefendDispute, DisputeFlowData, DisputeDefendData, DisputeResponseData>
for Aci<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
ConnectorIntegrationV2<
CreateOrder,
PaymentFlowData,
PaymentCreateOrderData,
PaymentCreateOrderResponse,
> for Aci<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
ConnectorIntegrationV2<
CreateSessionToken,
PaymentFlowData,
| {
"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_-5935928029102272606_5 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/aci.rs
SessionTokenRequestData,
SessionTokenResponseData,
> for Aci<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
ConnectorIntegrationV2<
CreateAccessToken,
PaymentFlowData,
AccessTokenRequestData,
AccessTokenResponseData,
> for Aci<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
ConnectorIntegrationV2<
PaymentMethodToken,
PaymentFlowData,
PaymentMethodTokenizationData<T>,
PaymentMethodTokenResponse,
> for Aci<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
ConnectorIntegrationV2<
PreAuthenticate,
PaymentFlowData,
PaymentsPreAuthenticateData<T>,
PaymentsResponseData,
> for Aci<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
ConnectorIntegrationV2<
Authenticate,
PaymentFlowData,
PaymentsAuthenticateData<T>,
PaymentsResponseData,
> for Aci<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
ConnectorIntegrationV2<
PostAuthenticate,
PaymentFlowData,
PaymentsPostAuthenticateData<T>,
PaymentsResponseData,
> for Aci<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
ConnectorIntegrationV2<
CreateConnectorCustomer,
PaymentFlowData,
ConnectorCustomerData,
ConnectorCustomerResponse,
> for Aci<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
ConnectorIntegrationV2<
VoidPC,
PaymentFlowData,
PaymentsCancelPostCaptureData,
PaymentsResponseData,
> for Aci<T>
{
}
// SourceVerification implementations for all flows
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
Authorize,
PaymentFlowData,
PaymentsAuthorizeData<T>,
PaymentsResponseData,
> for Aci<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
PSync,
PaymentFlowData,
PaymentsSyncData,
PaymentsResponseData,
> for Aci<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
Capture,
PaymentFlowData,
PaymentsCaptureData,
PaymentsResponseData,
> for Aci<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
Void,
PaymentFlowData,
PaymentVoidData,
PaymentsResponseData,
> for Aci<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
Refund,
RefundFlowData,
RefundsData,
RefundsResponseData,
> for Aci<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
RSync,
RefundFlowData,
RefundSyncData,
RefundsResponseData,
> for Aci<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
SetupMandate,
PaymentFlowData,
SetupMandateRequestData<T>,
PaymentsResponseData,
> for Aci<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
Accept,
DisputeFlowData,
AcceptDisputeData,
DisputeResponseData,
> for Aci<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
SubmitEvidence,
DisputeFlowData,
SubmitEvidenceData,
DisputeResponseData,
> for Aci<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
DefendDispute,
DisputeFlowData,
DisputeDefendData,
DisputeResponseData,
> for Aci<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_-5935928029102272606_6 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/aci.rs
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
CreateOrder,
PaymentFlowData,
PaymentCreateOrderData,
PaymentCreateOrderResponse,
> for Aci<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
RepeatPayment,
PaymentFlowData,
RepeatPaymentData,
PaymentsResponseData,
> for Aci<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
CreateSessionToken,
PaymentFlowData,
SessionTokenRequestData,
SessionTokenResponseData,
> for Aci<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
CreateAccessToken,
PaymentFlowData,
AccessTokenRequestData,
AccessTokenResponseData,
> for Aci<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
interfaces::verification::SourceVerification<
PaymentMethodToken,
PaymentFlowData,
PaymentMethodTokenizationData<T>,
PaymentMethodTokenResponse,
> for Aci<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
PreAuthenticate,
PaymentFlowData,
PaymentsPreAuthenticateData<T>,
PaymentsResponseData,
> for Aci<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
Authenticate,
PaymentFlowData,
PaymentsAuthenticateData<T>,
PaymentsResponseData,
> for Aci<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
PostAuthenticate,
PaymentFlowData,
PaymentsPostAuthenticateData<T>,
PaymentsResponseData,
> for Aci<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
CreateConnectorCustomer,
PaymentFlowData,
ConnectorCustomerData,
ConnectorCustomerResponse,
> for Aci<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
VoidPC,
PaymentFlowData,
PaymentsCancelPostCaptureData,
PaymentsResponseData,
> for Aci<T>
{
}
| {
"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_8667937960801972772_0 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/elavon.rs
pub mod transformers;
use std::fmt::Debug;
use bytes::Bytes;
use common_utils::{errors::CustomResult, events, ext_traits::ByteSliceExt};
use domain_types::{
connector_flow::{
Accept, Authenticate, Authorize, Capture, CreateAccessToken, CreateConnectorCustomer,
CreateOrder, CreateSessionToken, DefendDispute, PSync, PaymentMethodToken,
PostAuthenticate, PreAuthenticate, RSync, Refund, RepeatPayment, SetupMandate,
SubmitEvidence, Void, VoidPC,
},
connector_types::{
AcceptDisputeData, AccessTokenRequestData, AccessTokenResponseData, ConnectorCustomerData,
ConnectorCustomerResponse, ConnectorSpecifications, DisputeDefendData, DisputeFlowData,
DisputeResponseData, PaymentCreateOrderData, PaymentCreateOrderResponse, PaymentFlowData,
PaymentMethodTokenResponse, PaymentMethodTokenizationData, PaymentVoidData,
PaymentsAuthenticateData, PaymentsAuthorizeData, PaymentsCancelPostCaptureData,
PaymentsCaptureData, PaymentsPostAuthenticateData, PaymentsPreAuthenticateData,
PaymentsResponseData, PaymentsSyncData, RefundFlowData, RefundSyncData, RefundsData,
RefundsResponseData, RepeatPaymentData, SessionTokenRequestData, SessionTokenResponseData,
SetupMandateRequestData, SubmitEvidenceData,
},
errors,
payment_method_data::PaymentMethodDataTypes,
router_data::{ConnectorAuthType, ErrorResponse},
router_data_v2::RouterDataV2,
router_response_types::Response,
types::Connectors,
};
use hyperswitch_masking::Maskable;
use interfaces::{
api::ConnectorCommon,
connector_integration_v2::{self, ConnectorIntegrationV2},
connector_types,
};
use serde::Serialize;
use transformers::{
self as elavon, ElavonCaptureResponse, ElavonPSyncResponse, ElavonPaymentsResponse,
ElavonRSyncResponse, ElavonRefundResponse, XMLCaptureRequest, XMLElavonRequest,
XMLPSyncRequest, XMLRSyncRequest, XMLRefundRequest,
};
use super::macros;
use crate::{
types::ResponseRouterData, utils::preprocess_xml_response_bytes, with_error_response_body,
};
pub(crate) mod headers {
pub(crate) const CONTENT_TYPE: &str = "Content-Type";
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> connector_types::ConnectorServiceTrait<T> for Elavon<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> connector_types::PaymentSessionToken for Elavon<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::PaymentAccessToken for Elavon<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> connector_types::CreateConnectorCustomer for Elavon<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> connector_types::PaymentAuthorizeV2<T> for Elavon<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> connector_types::PaymentSyncV2 for Elavon<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> connector_types::PaymentVoidV2 for Elavon<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> connector_types::RefundSyncV2 for Elavon<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> connector_types::RefundV2 for Elavon<T>
{
}
// Type alias for non-generic trait implementations
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
| {
"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_8667937960801972772_1 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/elavon.rs
+ 'static
+ Serialize,
> connector_types::ValidationTrait for Elavon<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> connector_types::PaymentCapture for Elavon<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> connector_types::SetupMandateV2<T> for Elavon<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> connector_types::AcceptDispute for Elavon<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> connector_types::SubmitEvidenceV2 for Elavon<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> connector_types::DisputeDefend for Elavon<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> connector_types::IncomingWebhook for Elavon<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> connector_types::PaymentOrderCreate for Elavon<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> connector_types::RepeatPaymentV2 for Elavon<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> connector_types::PaymentTokenV2<T> for Elavon<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> connector_types::PaymentPreAuthenticateV2<T> for Elavon<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> connector_types::PaymentAuthenticateV2<T> for Elavon<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> connector_types::PaymentPostAuthenticateV2<T> for Elavon<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> connector_types::PaymentVoidPostCaptureV2 for Elavon<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> ConnectorCommon for Elavon<T>
{
fn id(&self) -> &'static str {
"elavon"
}
fn common_get_content_type(&self) -> &'static str {
"application/x-www-form-urlencoded"
}
fn get_auth_header(
&self,
_auth_type: &ConnectorAuthType,
) -> CustomResult<Vec<(String, Maskable<String>)>, errors::ConnectorError> {
Ok(Vec::new())
}
fn base_url<'a>(&self, _connectors: &'a Connectors) -> &'a str {
"https://api.demo.convergepay.com/VirtualMerchantDemo/"
}
fn build_error_response(
&self,
res: Response,
event_builder: Option<&mut events::Event>,
) -> CustomResult<ErrorResponse, errors::ConnectorError> {
match res
.response
.parse_struct::<elavon::ElavonPaymentsResponse>("ElavonPaymentsResponse")
.map_err(|_| errors::ConnectorError::ResponseDeserializationFailed)
{
Ok(elavon_response) => {
with_error_response_body!(event_builder, elavon_response);
| {
"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_8667937960801972772_2 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/elavon.rs
match elavon_response.result {
elavon::ElavonResult::Error(error_payload) => Ok(ErrorResponse {
status_code: res.status_code,
code: error_payload.error_code.unwrap_or_else(|| "".to_string()),
message: error_payload.error_message,
reason: error_payload.error_name,
attempt_status: Some(common_enums::AttemptStatus::Failure),
connector_transaction_id: error_payload.ssl_txn_id,
network_decline_code: None,
network_advice_code: None,
network_error_message: None,
}),
elavon::ElavonResult::Success(success_payload) => Ok(ErrorResponse {
status_code: res.status_code,
code: "".to_string(),
message: "Received success response in error flow".to_string(),
reason: Some(format!(
"Unexpected success: {:?}",
success_payload.ssl_result_message
)),
attempt_status: Some(common_enums::AttemptStatus::Failure),
connector_transaction_id: Some(success_payload.ssl_txn_id),
network_decline_code: None,
network_advice_code: None,
network_error_message: None,
}),
}
}
Err(_parsing_error) => {
let (message, reason) = match res.status_code {
500..=599 => (
"Elavon server error".to_string(),
Some(String::from_utf8_lossy(&res.response).into_owned()),
),
_ => (
"Elavon error response".to_string(),
Some(String::from_utf8_lossy(&res.response).into_owned()),
),
};
Ok(ErrorResponse {
status_code: res.status_code,
code: "".to_string(),
message,
reason,
attempt_status: Some(common_enums::AttemptStatus::Failure),
connector_transaction_id: None,
network_decline_code: None,
network_advice_code: None,
network_error_message: None,
})
}
}
}
}
macros::create_all_prerequisites!(
connector_name: Elavon,
generic_type: T,
api: [
(
flow: Authorize,
request_body: XMLElavonRequest,
response_body: ElavonPaymentsResponse,
router_data: RouterDataV2<Authorize, PaymentFlowData, PaymentsAuthorizeData<T>, PaymentsResponseData>,
),
(
flow: PSync,
request_body: XMLPSyncRequest,
response_body: ElavonPSyncResponse,
router_data: RouterDataV2<PSync, PaymentFlowData, PaymentsSyncData, PaymentsResponseData>,
),
(
flow: Capture,
request_body: XMLCaptureRequest,
response_body: ElavonCaptureResponse,
router_data: RouterDataV2<Capture, PaymentFlowData, PaymentsCaptureData, PaymentsResponseData>,
),
(
flow: Refund,
request_body: XMLRefundRequest,
response_body: ElavonRefundResponse,
router_data: RouterDataV2<Refund, RefundFlowData, RefundsData, RefundsResponseData>,
),
(
flow: RSync,
request_body: XMLRSyncRequest,
response_body: ElavonRSyncResponse,
router_data: RouterDataV2<RSync, RefundFlowData, RefundSyncData, RefundsResponseData>,
)
],
amount_converters: [],
member_functions: {
pub fn preprocess_response_bytes<F, FCD, Req, Res>(
&self,
_req: &RouterDataV2<F, FCD, Req, Res>,
response_bytes: Bytes,
) -> Result<Bytes, errors::ConnectorError> {
// Use the utility function to preprocess XML response bytes
preprocess_xml_response_bytes(response_bytes)
}
| {
"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_8667937960801972772_3 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/elavon.rs
pub fn build_headers<F, FCD, Req, Res>(
&self,
_req: &RouterDataV2<F, FCD, Req, Res>,
) -> CustomResult<Vec<(String, Maskable<String>)>, errors::ConnectorError> {
Ok(vec![(
headers::CONTENT_TYPE.to_string(),
self.common_get_content_type().to_string().into(),
)])
}
}
);
macros::macro_connector_implementation!(
connector_default_implementations: [get_content_type],
connector: Elavon,
curl_request: FormUrlEncoded(XMLElavonRequest),
curl_response: ElavonPaymentsResponse,
flow_name: Authorize,
resource_common_data: PaymentFlowData,
flow_request: PaymentsAuthorizeData<T>,
flow_response: PaymentsResponseData,
http_method: Post,
preprocess_response: true,
generic_type: T,
[PaymentMethodDataTypes + std::fmt::Debug + std::marker::Sync + std::marker::Send + 'static + Serialize],
other_functions: {
fn get_headers(
&self,
req: &RouterDataV2<Authorize, PaymentFlowData, PaymentsAuthorizeData<T>, PaymentsResponseData>,
) -> CustomResult<Vec<(String, Maskable<String>)>, errors::ConnectorError> {
self.build_headers(req)
}
fn get_url(
&self,
req: &RouterDataV2<Authorize, PaymentFlowData, PaymentsAuthorizeData<T>, PaymentsResponseData>,
) -> CustomResult<String, errors::ConnectorError> {
Ok(format!(
"{}processxml.do",
req.resource_common_data.connectors.elavon.base_url
))
}
}
);
macros::macro_connector_implementation!(
connector_default_implementations: [get_content_type],
connector: Elavon,
curl_request: FormUrlEncoded(XMLPSyncRequest),
curl_response: ElavonPSyncResponse,
flow_name: PSync,
resource_common_data: PaymentFlowData,
flow_request: PaymentsSyncData,
flow_response: PaymentsResponseData,
http_method: Post,
preprocess_response: true,
generic_type: T,
[PaymentMethodDataTypes + std::fmt::Debug + std::marker::Sync + std::marker::Send + 'static + Serialize],
other_functions: {
fn get_headers(
&self,
req: &RouterDataV2<PSync, PaymentFlowData, PaymentsSyncData, PaymentsResponseData>,
) -> CustomResult<Vec<(String, Maskable<String>)>, errors::ConnectorError> {
self.build_headers(req)
}
fn get_url(
&self,
req: &RouterDataV2<PSync, PaymentFlowData, PaymentsSyncData, PaymentsResponseData>,
) -> CustomResult<String, errors::ConnectorError> {
Ok(format!(
"{}processxml.do",
req.resource_common_data.connectors.elavon.base_url
))
}
}
);
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
connector_integration_v2::ConnectorIntegrationV2<
CreateOrder,
PaymentFlowData,
PaymentCreateOrderData,
PaymentCreateOrderResponse,
> for Elavon<T>
{
}
macros::macro_connector_implementation!(
connector_default_implementations: [get_content_type],
connector: Elavon,
curl_request: FormUrlEncoded(XMLCaptureRequest),
curl_response: ElavonCaptureResponse,
flow_name: Capture,
resource_common_data: PaymentFlowData,
flow_request: PaymentsCaptureData,
flow_response: PaymentsResponseData,
http_method: Post,
preprocess_response: true,
generic_type: T,
[PaymentMethodDataTypes + std::fmt::Debug + std::marker::Sync + std::marker::Send + 'static + Serialize],
other_functions: {
fn get_headers(
&self,
req: &RouterDataV2<Capture, PaymentFlowData, PaymentsCaptureData, PaymentsResponseData>,
) -> CustomResult<Vec<(String, Maskable<String>)>, errors::ConnectorError> {
self.build_headers(req)
}
fn get_url(
&self,
req: &RouterDataV2<Capture, PaymentFlowData, PaymentsCaptureData, PaymentsResponseData>,
) -> CustomResult<String, errors::ConnectorError> {
Ok(format!(
"{}processxml.do",
req.resource_common_data.connectors.elavon.base_url
))
}
}
);
macros::macro_connector_implementation!(
| {
"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_8667937960801972772_4 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/elavon.rs
connector_default_implementations: [get_content_type],
connector: Elavon,
curl_request: FormUrlEncoded(XMLRefundRequest),
curl_response: ElavonRefundResponse,
flow_name: Refund,
resource_common_data: RefundFlowData,
flow_request: RefundsData,
flow_response: RefundsResponseData,
http_method: Post,
preprocess_response: true,
generic_type: T,
[PaymentMethodDataTypes + std::fmt::Debug + std::marker::Sync + std::marker::Send + 'static + Serialize],
other_functions: {
fn get_headers(
&self,
req: &RouterDataV2<Refund, RefundFlowData, RefundsData, RefundsResponseData>,
) -> CustomResult<Vec<(String, Maskable<String>)>, errors::ConnectorError> {
self.build_headers(req)
}
fn get_url(
&self,
req: &RouterDataV2<Refund, RefundFlowData, RefundsData, RefundsResponseData>,
) -> CustomResult<String, errors::ConnectorError> {
Ok(format!(
"{}processxml.do",
req.resource_common_data.connectors.elavon.base_url
))
}
}
);
macros::macro_connector_implementation!(
connector_default_implementations: [get_content_type],
connector: Elavon,
curl_request: FormUrlEncoded(XMLRSyncRequest),
curl_response: ElavonRSyncResponse,
flow_name: RSync,
resource_common_data: RefundFlowData,
flow_request: RefundSyncData,
flow_response: RefundsResponseData,
http_method: Post,
preprocess_response: true,
generic_type: T,
[PaymentMethodDataTypes + std::fmt::Debug + std::marker::Sync + std::marker::Send + 'static + Serialize],
other_functions: {
fn get_headers(
&self,
req: &RouterDataV2<RSync, RefundFlowData, RefundSyncData, RefundsResponseData>,
) -> CustomResult<Vec<(String, Maskable<String>)>, errors::ConnectorError> {
self.build_headers(req)
}
fn get_url(
&self,
req: &RouterDataV2<RSync, RefundFlowData, RefundSyncData, RefundsResponseData>,
) -> CustomResult<String, errors::ConnectorError> {
Ok(format!(
"{}processxml.do",
req.resource_common_data.connectors.elavon.base_url
))
}
}
);
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
connector_integration_v2::ConnectorIntegrationV2<
Void,
PaymentFlowData,
PaymentVoidData,
PaymentsResponseData,
> for Elavon<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
connector_integration_v2::ConnectorIntegrationV2<
SetupMandate,
PaymentFlowData,
SetupMandateRequestData<T>,
PaymentsResponseData,
> for Elavon<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
connector_integration_v2::ConnectorIntegrationV2<
Accept,
DisputeFlowData,
AcceptDisputeData,
DisputeResponseData,
> for Elavon<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
connector_integration_v2::ConnectorIntegrationV2<
SubmitEvidence,
DisputeFlowData,
SubmitEvidenceData,
DisputeResponseData,
> for Elavon<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
connector_integration_v2::ConnectorIntegrationV2<
DefendDispute,
DisputeFlowData,
DisputeDefendData,
DisputeResponseData,
> for Elavon<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
ConnectorIntegrationV2<
PaymentMethodToken,
PaymentFlowData,
PaymentMethodTokenizationData<T>,
| {
"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_8667937960801972772_5 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/elavon.rs
PaymentMethodTokenResponse,
> for Elavon<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
ConnectorIntegrationV2<
PreAuthenticate,
PaymentFlowData,
PaymentsPreAuthenticateData<T>,
PaymentsResponseData,
> for Elavon<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
ConnectorIntegrationV2<
Authenticate,
PaymentFlowData,
PaymentsAuthenticateData<T>,
PaymentsResponseData,
> for Elavon<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
ConnectorIntegrationV2<
PostAuthenticate,
PaymentFlowData,
PaymentsPostAuthenticateData<T>,
PaymentsResponseData,
> for Elavon<T>
{
}
// SourceVerification implementations for all flows
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
interfaces::verification::SourceVerification<
Authorize,
PaymentFlowData,
PaymentsAuthorizeData<T>,
PaymentsResponseData,
> for Elavon<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
interfaces::verification::SourceVerification<
CreateSessionToken,
PaymentFlowData,
SessionTokenRequestData,
SessionTokenResponseData,
> for Elavon<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
interfaces::verification::SourceVerification<
CreateAccessToken,
PaymentFlowData,
AccessTokenRequestData,
AccessTokenResponseData,
> for Elavon<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
interfaces::verification::SourceVerification<
CreateConnectorCustomer,
PaymentFlowData,
ConnectorCustomerData,
ConnectorCustomerResponse,
> for Elavon<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
interfaces::verification::SourceVerification<
PSync,
PaymentFlowData,
PaymentsSyncData,
PaymentsResponseData,
> for Elavon<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
interfaces::verification::SourceVerification<
Capture,
PaymentFlowData,
PaymentsCaptureData,
PaymentsResponseData,
> for Elavon<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
interfaces::verification::SourceVerification<
Void,
PaymentFlowData,
PaymentVoidData,
PaymentsResponseData,
> for Elavon<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
interfaces::verification::SourceVerification<
Refund,
RefundFlowData,
RefundsData,
RefundsResponseData,
> for Elavon<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
interfaces::verification::SourceVerification<
RSync,
RefundFlowData,
RefundSyncData,
RefundsResponseData,
> for Elavon<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
| {
"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_8667937960801972772_6 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/elavon.rs
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
interfaces::verification::SourceVerification<
SetupMandate,
PaymentFlowData,
SetupMandateRequestData<T>,
PaymentsResponseData,
> for Elavon<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
interfaces::verification::SourceVerification<
Accept,
DisputeFlowData,
AcceptDisputeData,
DisputeResponseData,
> for Elavon<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
interfaces::verification::SourceVerification<
SubmitEvidence,
DisputeFlowData,
SubmitEvidenceData,
DisputeResponseData,
> for Elavon<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
interfaces::verification::SourceVerification<
DefendDispute,
DisputeFlowData,
DisputeDefendData,
DisputeResponseData,
> for Elavon<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
interfaces::verification::SourceVerification<
CreateOrder,
PaymentFlowData,
PaymentCreateOrderData,
PaymentCreateOrderResponse,
> for Elavon<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
ConnectorIntegrationV2<
VoidPC,
PaymentFlowData,
PaymentsCancelPostCaptureData,
PaymentsResponseData,
> for Elavon<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
interfaces::verification::SourceVerification<
VoidPC,
PaymentFlowData,
PaymentsCancelPostCaptureData,
PaymentsResponseData,
> for Elavon<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> ConnectorSpecifications for Elavon<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
ConnectorIntegrationV2<
CreateSessionToken,
PaymentFlowData,
SessionTokenRequestData,
SessionTokenResponseData,
> for Elavon<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
ConnectorIntegrationV2<
CreateAccessToken,
PaymentFlowData,
AccessTokenRequestData,
AccessTokenResponseData,
> for Elavon<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
ConnectorIntegrationV2<
CreateConnectorCustomer,
PaymentFlowData,
ConnectorCustomerData,
ConnectorCustomerResponse,
> for Elavon<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
interfaces::verification::SourceVerification<
RepeatPayment,
PaymentFlowData,
RepeatPaymentData,
PaymentsResponseData,
> for Elavon<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
ConnectorIntegrationV2<RepeatPayment, PaymentFlowData, RepeatPaymentData, PaymentsResponseData>
for Elavon<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
| {
"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_8667937960801972772_7 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/elavon.rs
+ std::marker::Send
+ 'static
+ Serialize,
>
interfaces::verification::SourceVerification<
PaymentMethodToken,
PaymentFlowData,
PaymentMethodTokenizationData<T>,
PaymentMethodTokenResponse,
> for Elavon<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
interfaces::verification::SourceVerification<
PreAuthenticate,
PaymentFlowData,
PaymentsPreAuthenticateData<T>,
PaymentsResponseData,
> for Elavon<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
interfaces::verification::SourceVerification<
Authenticate,
PaymentFlowData,
PaymentsAuthenticateData<T>,
PaymentsResponseData,
> for Elavon<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
interfaces::verification::SourceVerification<
PostAuthenticate,
PaymentFlowData,
PaymentsPostAuthenticateData<T>,
PaymentsResponseData,
> for Elavon<T>
{
}
| {
"chunk": 7,
"crate": "connector-integration",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_mini_connector-integration_1422429809174256361_0 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/authorizedotnet.rs
pub mod transformers;
use common_enums;
use common_utils::{
consts, errors::CustomResult, events, ext_traits::ByteSliceExt, request::RequestContent,
types::FloatMajorUnit,
};
use domain_types::{
connector_flow::{
Accept, Authenticate, Authorize, Capture, CreateAccessToken, CreateConnectorCustomer,
CreateOrder, CreateSessionToken, DefendDispute, PSync, PaymentMethodToken,
PostAuthenticate, PreAuthenticate, RSync, Refund, RepeatPayment, SetupMandate,
SubmitEvidence, Void, VoidPC,
},
connector_types::{
AcceptDisputeData, AccessTokenRequestData, AccessTokenResponseData, ConnectorCustomerData,
ConnectorCustomerResponse, ConnectorSpecifications, ConnectorWebhookSecrets,
DisputeDefendData, DisputeFlowData, DisputeResponseData, EventType, PaymentCreateOrderData,
PaymentCreateOrderResponse, PaymentFlowData, PaymentMethodTokenResponse,
PaymentMethodTokenizationData, PaymentVoidData, PaymentsAuthenticateData,
PaymentsAuthorizeData, PaymentsCancelPostCaptureData, PaymentsCaptureData,
PaymentsPostAuthenticateData, PaymentsPreAuthenticateData, PaymentsResponseData,
PaymentsSyncData, RefundFlowData, RefundSyncData, RefundWebhookDetailsResponse,
RefundsData, RefundsResponseData, RepeatPaymentData, RequestDetails, ResponseId,
SessionTokenRequestData, SessionTokenResponseData, SetupMandateRequestData,
SubmitEvidenceData, WebhookDetailsResponse,
},
errors::{self, ConnectorError},
payment_method_data::PaymentMethodDataTypes,
router_data::{ConnectorAuthType, ErrorResponse},
router_data_v2::RouterDataV2,
router_response_types::Response,
types::Connectors,
};
use error_stack::ResultExt;
use hyperswitch_masking::Maskable;
use interfaces::{
api::ConnectorCommon,
connector_integration_v2::ConnectorIntegrationV2,
connector_types::{
self, AcceptDispute, ConnectorServiceTrait, DisputeDefend, IncomingWebhook,
PaymentAccessToken, PaymentAuthorizeV2, PaymentCapture, PaymentOrderCreate,
PaymentSessionToken, PaymentSyncV2, PaymentTokenV2, PaymentVoidPostCaptureV2,
PaymentVoidV2, RefundSyncV2, RefundV2, RepeatPaymentV2, SetupMandateV2, SubmitEvidenceV2,
ValidationTrait,
},
verification::SourceVerification,
};
use serde::Serialize;
use self::transformers::{
get_trans_id, AuthorizedotnetAuthorizeResponse, AuthorizedotnetCaptureRequest,
AuthorizedotnetCaptureResponse, AuthorizedotnetCreateConnectorCustomerRequest,
AuthorizedotnetCreateConnectorCustomerResponse, AuthorizedotnetCreateSyncRequest,
AuthorizedotnetPSyncResponse, AuthorizedotnetPaymentsRequest, AuthorizedotnetRSyncRequest,
AuthorizedotnetRSyncResponse, AuthorizedotnetRefundRequest, AuthorizedotnetRefundResponse,
AuthorizedotnetRepeatPaymentRequest, AuthorizedotnetRepeatPaymentResponse,
AuthorizedotnetSetupMandateRequest, AuthorizedotnetSetupMandateResponse,
AuthorizedotnetVoidRequest, AuthorizedotnetVoidResponse, AuthorizedotnetWebhookEventType,
AuthorizedotnetWebhookObjectId,
};
use super::macros;
use crate::{types::ResponseRouterData, with_response_body};
pub(crate) mod headers {
pub(crate) const CONTENT_TYPE: &str = "Content-Type";
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> ConnectorServiceTrait<T> for Authorizedotnet<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> PaymentSessionToken for Authorizedotnet<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> PaymentAccessToken for Authorizedotnet<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> SetupMandateV2<T> for Authorizedotnet<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
| {
"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_1422429809174256361_1 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/authorizedotnet.rs
+ 'static
+ Serialize,
> connector_types::CreateConnectorCustomer for Authorizedotnet<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> ValidationTrait for Authorizedotnet<T>
{
fn should_create_connector_customer(&self) -> bool {
true
}
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> IncomingWebhook for Authorizedotnet<T>
{
fn verify_webhook_source(
&self,
request: RequestDetails,
connector_webhook_secret: Option<ConnectorWebhookSecrets>,
_connector_account_details: Option<ConnectorAuthType>,
) -> Result<bool, error_stack::Report<ConnectorError>> {
// If no webhook secret is provided, cannot verify
let webhook_secret = match connector_webhook_secret {
Some(secrets) => secrets.secret,
None => return Ok(false),
};
// Extract X-ANET-Signature header (case-insensitive)
let signature_header = match request
.headers
.get("X-ANET-Signature")
.or_else(|| request.headers.get("x-anet-signature"))
{
Some(header) => header,
None => {
tracing::warn!(
target: "authorizedotnet_webhook",
"Missing X-ANET-Signature header in webhook request from Authorize.Net - verification failed but continuing processing"
);
return Ok(false); // Missing signature -> verification fails but continue processing
}
};
// Parse "sha512=<hex>" format
let signature_hex = match signature_header.strip_prefix("sha512=") {
Some(hex) => hex,
None => {
tracing::warn!(
target: "authorizedotnet_webhook",
"Invalid signature format in X-ANET-Signature header, expected 'sha512=<hex>' but got: '{}' - verification failed but continuing processing",
signature_header
);
return Ok(false); // Invalid format -> verification fails but continue processing
}
};
// Decode hex signature
let expected_signature = match hex::decode(signature_hex) {
Ok(sig) => sig,
Err(hex_error) => {
tracing::warn!(
target: "authorizedotnet_webhook",
"Failed to decode hex signature from X-ANET-Signature header: '{}', error: {} - verification failed but continuing processing",
signature_hex,
hex_error
);
return Ok(false); // Invalid hex -> verification fails but continue processing
}
};
// Compute HMAC-SHA512 of request body
use common_utils::crypto::{HmacSha512, SignMessage};
let crypto_algorithm = HmacSha512;
let computed_signature = match crypto_algorithm.sign_message(&webhook_secret, &request.body)
{
Ok(sig) => sig,
Err(crypto_error) => {
tracing::error!(
target: "authorizedotnet_webhook",
"Failed to compute HMAC-SHA512 signature for webhook verification, error: {:?} - verification failed but continuing processing",
crypto_error
);
return Ok(false); // Crypto error -> verification fails but continue processing
}
};
// Constant-time comparison to prevent timing attacks
Ok(computed_signature == expected_signature)
}
fn get_event_type(
&self,
request: RequestDetails,
_connector_webhook_secret: Option<ConnectorWebhookSecrets>,
_connector_account_details: Option<ConnectorAuthType>,
) -> Result<EventType, error_stack::Report<ConnectorError>> {
let webhook_body: AuthorizedotnetWebhookEventType = request
.body
.parse_struct("AuthorizedotnetWebhookEventType")
.change_context(ConnectorError::WebhookEventTypeNotFound)
| {
"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_1422429809174256361_2 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/authorizedotnet.rs
.attach_printable_lazy(|| {
"Failed to parse webhook event type from Authorize.Net webhook body"
})?;
Ok(match webhook_body.event_type {
transformers::AuthorizedotnetIncomingWebhookEventType::AuthorizationCreated => {
EventType::PaymentIntentAuthorizationSuccess
}
transformers::AuthorizedotnetIncomingWebhookEventType::PriorAuthCapture
| transformers::AuthorizedotnetIncomingWebhookEventType::CaptureCreated => {
EventType::PaymentIntentCaptureSuccess
}
transformers::AuthorizedotnetIncomingWebhookEventType::AuthCapCreated => {
EventType::PaymentIntentSuccess // Combined auth+capture
}
transformers::AuthorizedotnetIncomingWebhookEventType::VoidCreated => {
EventType::PaymentIntentCancelled
}
transformers::AuthorizedotnetIncomingWebhookEventType::RefundCreated => {
EventType::RefundSuccess
}
transformers::AuthorizedotnetIncomingWebhookEventType::CustomerCreated
| transformers::AuthorizedotnetIncomingWebhookEventType::CustomerPaymentProfileCreated => {
EventType::MandateActive
}
transformers::AuthorizedotnetIncomingWebhookEventType::Unknown => {
tracing::warn!(
target: "authorizedotnet_webhook",
"Received unknown webhook event type from Authorize.Net - rejecting webhook"
);
return Err(
error_stack::report!(ConnectorError::WebhookEventTypeNotFound)
.attach_printable("Unknown webhook event type"),
)
}
})
}
fn process_payment_webhook(
&self,
request: RequestDetails,
_connector_webhook_secret: Option<ConnectorWebhookSecrets>,
_connector_account_details: Option<ConnectorAuthType>,
) -> Result<WebhookDetailsResponse, error_stack::Report<ConnectorError>> {
let request_body_copy = request.body.clone();
let webhook_body: AuthorizedotnetWebhookObjectId = request
.body
.parse_struct("AuthorizedotnetWebhookObjectId")
.change_context(ConnectorError::WebhookResourceObjectNotFound)
.attach_printable_lazy(|| {
"Failed to parse Authorize.Net payment webhook body structure"
})?;
let transaction_id = get_trans_id(&webhook_body).attach_printable_lazy(|| {
format!(
"Failed to extract transaction ID from payment webhook for event: {:?}",
webhook_body.event_type
)
})?;
let status = transformers::SyncStatus::from(webhook_body.event_type.clone());
Ok(WebhookDetailsResponse {
resource_id: Some(ResponseId::ConnectorTransactionId(transaction_id.clone())),
status: common_enums::AttemptStatus::from(status),
status_code: 200,
mandate_reference: None,
connector_response_reference_id: Some(transaction_id),
error_code: None,
error_message: None,
raw_connector_response: Some(String::from_utf8_lossy(&request_body_copy).to_string()),
response_headers: None,
minor_amount_captured: None,
amount_captured: None,
error_reason: None,
network_txn_id: None,
transformation_status: common_enums::WebhookTransformationStatus::Complete,
})
}
fn process_refund_webhook(
&self,
request: RequestDetails,
_connector_webhook_secret: Option<ConnectorWebhookSecrets>,
_connector_account_details: Option<ConnectorAuthType>,
) -> Result<RefundWebhookDetailsResponse, error_stack::Report<ConnectorError>> {
let request_body_copy = request.body.clone();
let webhook_body: AuthorizedotnetWebhookObjectId = request
.body
.parse_struct("AuthorizedotnetWebhookObjectId")
.change_context(ConnectorError::WebhookResourceObjectNotFound)
.attach_printable_lazy(|| {
| {
"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_1422429809174256361_3 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/authorizedotnet.rs
"Failed to parse Authorize.Net refund webhook body structure"
})?;
let transaction_id = get_trans_id(&webhook_body).attach_printable_lazy(|| {
format!(
"Failed to extract transaction ID from refund webhook for event: {:?}",
webhook_body.event_type
)
})?;
Ok(RefundWebhookDetailsResponse {
connector_refund_id: Some(transaction_id.clone()),
status: common_enums::RefundStatus::Success, // Authorize.Net only sends successful refund webhooks
status_code: 200,
connector_response_reference_id: Some(transaction_id),
error_code: None,
error_message: None,
raw_connector_response: Some(String::from_utf8_lossy(&request_body_copy).to_string()),
response_headers: None,
})
}
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> SubmitEvidenceV2 for Authorizedotnet<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> DisputeDefend for Authorizedotnet<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> RefundSyncV2 for Authorizedotnet<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> AcceptDispute for Authorizedotnet<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> RepeatPaymentV2 for Authorizedotnet<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> PaymentVoidPostCaptureV2 for Authorizedotnet<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> PaymentOrderCreate for Authorizedotnet<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> PaymentAuthorizeV2<T> for Authorizedotnet<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> PaymentSyncV2 for Authorizedotnet<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> PaymentVoidV2 for Authorizedotnet<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> RefundV2 for Authorizedotnet<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> PaymentCapture for Authorizedotnet<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> PaymentTokenV2<T> for Authorizedotnet<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> interfaces::connector_types::PaymentPreAuthenticateV2<T> for Authorizedotnet<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> interfaces::connector_types::PaymentAuthenticateV2<T> for Authorizedotnet<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
| {
"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_1422429809174256361_4 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/authorizedotnet.rs
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> interfaces::connector_types::PaymentPostAuthenticateV2<T> for Authorizedotnet<T>
{
}
// Basic connector implementation
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> ConnectorCommon for Authorizedotnet<T>
{
fn id(&self) -> &'static str {
"authorizedotnet"
}
fn common_get_content_type(&self) -> &'static str {
"application/json"
}
fn base_url<'a>(&self, connectors: &'a Connectors) -> &'a str {
connectors.authorizedotnet.base_url.as_ref()
}
fn build_error_response(
&self,
res: Response,
event_builder: Option<&mut events::Event>,
) -> CustomResult<ErrorResponse, errors::ConnectorError> {
let response: transformers::ResponseMessages = res
.response
.parse_struct("ResponseMessages")
.map_err(|_| ConnectorError::ResponseDeserializationFailed)?;
with_response_body!(event_builder, response);
Ok(ErrorResponse {
status_code: res.status_code,
code: response
.message
.first()
.map(|m| m.code.clone())
.unwrap_or_else(|| consts::NO_ERROR_CODE.to_string()),
message: response
.message
.first()
.map(|m| m.text.clone())
.unwrap_or_else(|| consts::NO_ERROR_MESSAGE.to_string()),
reason: None,
attempt_status: None,
connector_transaction_id: None,
network_decline_code: None,
network_advice_code: None,
network_error_message: None,
})
}
fn get_currency_unit(&self) -> common_enums::CurrencyUnit {
common_enums::CurrencyUnit::Base
}
}
// Define connector prerequisites
macros::create_all_prerequisites!(
connector_name: Authorizedotnet,
generic_type: T,
api: [
(
flow: Authorize,
request_body: AuthorizedotnetPaymentsRequest<T>,
response_body: AuthorizedotnetAuthorizeResponse,
router_data: RouterDataV2<Authorize, PaymentFlowData, PaymentsAuthorizeData<T>, PaymentsResponseData>,
),
(
flow: PSync,
request_body: AuthorizedotnetCreateSyncRequest,
response_body: AuthorizedotnetPSyncResponse,
router_data: RouterDataV2<PSync, PaymentFlowData, PaymentsSyncData, PaymentsResponseData>,
),
(
flow: Capture,
request_body: AuthorizedotnetCaptureRequest,
response_body: AuthorizedotnetCaptureResponse,
router_data: RouterDataV2<Capture, PaymentFlowData, PaymentsCaptureData, PaymentsResponseData>,
),
(
flow: Void,
request_body: AuthorizedotnetVoidRequest,
response_body: AuthorizedotnetVoidResponse,
router_data: RouterDataV2<Void, PaymentFlowData, PaymentVoidData, PaymentsResponseData>,
),
(
flow: Refund,
request_body: AuthorizedotnetRefundRequest<T>,
response_body: AuthorizedotnetRefundResponse,
router_data: RouterDataV2<Refund, RefundFlowData, RefundsData, RefundsResponseData>,
),
(
flow: RSync,
request_body: AuthorizedotnetRSyncRequest,
response_body: AuthorizedotnetRSyncResponse,
router_data: RouterDataV2<RSync, RefundFlowData, RefundSyncData, RefundsResponseData>,
),
(
flow: RepeatPayment,
request_body: AuthorizedotnetRepeatPaymentRequest,
response_body: AuthorizedotnetRepeatPaymentResponse,
router_data: RouterDataV2<RepeatPayment, PaymentFlowData, RepeatPaymentData, PaymentsResponseData>,
),
(
flow: CreateConnectorCustomer,
request_body: AuthorizedotnetCreateConnectorCustomerRequest<T>,
response_body: AuthorizedotnetCreateConnectorCustomerResponse,
router_data: RouterDataV2<CreateConnectorCustomer, PaymentFlowData, ConnectorCustomerData, ConnectorCustomerResponse>,
| {
"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_1422429809174256361_5 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/authorizedotnet.rs
),
(
flow: SetupMandate,
request_body: AuthorizedotnetSetupMandateRequest<T>,
response_body: AuthorizedotnetSetupMandateResponse,
router_data: RouterDataV2<SetupMandate, PaymentFlowData, SetupMandateRequestData<T>, PaymentsResponseData>,
)
],
amount_converters: [
amount_converter: FloatMajorUnit
],
member_functions: {
fn preprocess_response_bytes<F, FCD, Req, Res>(
&self,
_req: &RouterDataV2<F, FCD, Req, Res>,
bytes: bytes::Bytes,
) -> CustomResult<bytes::Bytes, errors::ConnectorError> {
// Check if the bytes begin with UTF-8 BOM (EF BB BF)
let encoding = encoding_rs::UTF_8;
let intermediate_response_bytes = encoding.decode_with_bom_removal(&bytes);
let processed_bytes = bytes::Bytes::copy_from_slice(intermediate_response_bytes.0.as_bytes());
Ok(processed_bytes)
}
pub fn build_headers<F, FCD, Req, Res>(
&self,
req: &RouterDataV2<F, FCD, Req, Res>,
) -> CustomResult<Vec<(String, Maskable<String>)>, ConnectorError> {
let mut header = vec![(
headers::CONTENT_TYPE.to_string(),
"application/json".to_string().into(),
)];
let mut api_key = self.get_auth_header(&req.connector_auth_type)?;
header.append(&mut api_key);
Ok(header)
}
pub fn connector_base_url_payments<F, Req, Res>(
&self,
req: &RouterDataV2<F, PaymentFlowData, Req, Res>,
) -> String {
let base_url = &req.resource_common_data.connectors.authorizedotnet.base_url;
base_url.to_string()
}
pub fn connector_base_url_refunds<F, Req, Res>(
&self,
req: &RouterDataV2<F, RefundFlowData, Req, Res>,
) -> String {
req.resource_common_data.connectors.authorizedotnet.base_url.to_string()
}
}
);
// Implement the specific flows
macros::macro_connector_implementation!(
connector_default_implementations: [get_content_type, get_error_response_v2],
connector: Authorizedotnet,
curl_request: Json(AuthorizedotnetPaymentsRequest),
curl_response: AuthorizedotnetAuthorizeResponse,
flow_name: Authorize,
resource_common_data: PaymentFlowData,
flow_request: PaymentsAuthorizeData<T>,
flow_response: PaymentsResponseData,
http_method: Post,
preprocess_response: true,
generic_type: T,
[PaymentMethodDataTypes + std::fmt::Debug + std::marker::Sync + std::marker::Send + 'static + Serialize],
other_functions: {
fn get_headers(
&self,
req: &RouterDataV2<Authorize, PaymentFlowData, PaymentsAuthorizeData<T>, PaymentsResponseData>,
) -> CustomResult<Vec<(String, Maskable<String>)>, ConnectorError> {
self.build_headers(req)
}
fn get_url(
&self,
req: &RouterDataV2<Authorize, PaymentFlowData, PaymentsAuthorizeData<T>, PaymentsResponseData>,
) -> CustomResult<String, ConnectorError> {
Ok(self.connector_base_url_payments(req).to_string())
}
}
);
macros::macro_connector_implementation!(
connector_default_implementations: [get_content_type, get_error_response_v2],
connector: Authorizedotnet,
curl_request: Json(AuthorizedotnetCreateSyncRequest),
curl_response: AuthorizedotnetPSyncResponse,
flow_name: PSync,
resource_common_data: PaymentFlowData,
flow_request: PaymentsSyncData,
flow_response: PaymentsResponseData,
http_method: Post,
preprocess_response: true,
generic_type: T,
[PaymentMethodDataTypes + std::fmt::Debug + std::marker::Sync + std::marker::Send + 'static + Serialize],
other_functions: {
fn get_headers(
&self,
req: &RouterDataV2<PSync, PaymentFlowData, PaymentsSyncData, PaymentsResponseData>,
) -> CustomResult<Vec<(String, Maskable<String>)>, ConnectorError> {
self.build_headers(req)
}
fn get_url(
&self,
req: &RouterDataV2<PSync, PaymentFlowData, PaymentsSyncData, PaymentsResponseData>,
) -> CustomResult<String, ConnectorError> {
| {
"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_1422429809174256361_6 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/authorizedotnet.rs
Ok(self.connector_base_url_payments(req).to_string())
}
}
);
macros::macro_connector_implementation!(
connector_default_implementations: [get_content_type, get_error_response_v2],
connector: Authorizedotnet,
curl_request: Json(AuthorizedotnetCaptureRequest),
curl_response: AuthorizedotnetCaptureResponse,
flow_name: Capture,
resource_common_data: PaymentFlowData,
flow_request: PaymentsCaptureData,
flow_response: PaymentsResponseData,
http_method: Post,
preprocess_response: true,
generic_type: T,
[PaymentMethodDataTypes + std::fmt::Debug + std::marker::Sync + std::marker::Send + 'static + Serialize],
other_functions: {
fn get_headers(
&self,
req: &RouterDataV2<Capture, PaymentFlowData, PaymentsCaptureData, PaymentsResponseData>,
) -> CustomResult<Vec<(String, Maskable<String>)>, ConnectorError> {
self.build_headers(req)
}
fn get_url(
&self,
req: &RouterDataV2<Capture, PaymentFlowData, PaymentsCaptureData, PaymentsResponseData>,
) -> CustomResult<String, ConnectorError> {
Ok(self.connector_base_url_payments(req).to_string())
}
}
);
macros::macro_connector_implementation!(
connector_default_implementations: [get_content_type, get_error_response_v2],
connector: Authorizedotnet,
curl_request: Json(AuthorizedotnetVoidRequest),
curl_response: AuthorizedotnetVoidResponse,
flow_name: Void,
resource_common_data: PaymentFlowData,
flow_request: PaymentVoidData,
flow_response: PaymentsResponseData,
http_method: Post,
preprocess_response: true,
generic_type: T,
[PaymentMethodDataTypes + std::fmt::Debug + std::marker::Sync + std::marker::Send + 'static + Serialize],
other_functions: {
fn get_headers(
&self,
req: &RouterDataV2<Void, PaymentFlowData, PaymentVoidData, PaymentsResponseData>,
) -> CustomResult<Vec<(String, Maskable<String>)>, ConnectorError> {
self.build_headers(req)
}
fn get_url(
&self,
req: &RouterDataV2<Void, PaymentFlowData, PaymentVoidData, PaymentsResponseData>,
) -> CustomResult<String, ConnectorError> {
Ok(self.connector_base_url_payments(req).to_string())
}
}
);
// Empty implementation for Refund flow to satisfy trait bounds
// The actual refund logic is handled by the specific implementations in transformers.rs
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> ConnectorIntegrationV2<Refund, RefundFlowData, RefundsData, RefundsResponseData>
for Authorizedotnet<T>
{
fn get_headers(
&self,
req: &RouterDataV2<Refund, RefundFlowData, RefundsData, RefundsResponseData>,
) -> CustomResult<Vec<(String, Maskable<String>)>, ConnectorError> {
self.build_headers(req)
}
fn get_content_type(&self) -> &'static str {
self.common_get_content_type()
}
fn get_url(
&self,
req: &RouterDataV2<Refund, RefundFlowData, RefundsData, RefundsResponseData>,
) -> CustomResult<String, ConnectorError> {
Ok(self.connector_base_url_refunds(req).to_string())
}
fn get_request_body(
&self,
_req: &RouterDataV2<Refund, RefundFlowData, RefundsData, RefundsResponseData>,
) -> CustomResult<Option<RequestContent>, ConnectorError> {
// This is a placeholder implementation
// The actual refund logic should be handled by specific implementations
Err(ConnectorError::NotImplemented("Refund not implemented for generic type".into()).into())
}
}
// Implement RSync flow
macros::macro_connector_implementation!(
connector_default_implementations: [get_content_type, get_error_response_v2],
connector: Authorizedotnet,
curl_request: Json(AuthorizedotnetRSyncRequest),
curl_response: AuthorizedotnetRSyncResponse,
flow_name: RSync,
resource_common_data: RefundFlowData,
flow_request: RefundSyncData,
flow_response: RefundsResponseData,
http_method: Post,
preprocess_response: true,
generic_type: T,
| {
"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_1422429809174256361_7 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/authorizedotnet.rs
[PaymentMethodDataTypes + std::fmt::Debug + std::marker::Sync + std::marker::Send + 'static + Serialize],
other_functions: {
fn get_headers(
&self,
req: &RouterDataV2<RSync, RefundFlowData, RefundSyncData, RefundsResponseData>,
) -> CustomResult<Vec<(String, Maskable<String>)>, ConnectorError> {
self.build_headers(req)
}
fn get_url(
&self,
req: &RouterDataV2<RSync, RefundFlowData, RefundSyncData, RefundsResponseData>,
) -> CustomResult<String, ConnectorError> {
Ok(self.connector_base_url_refunds(req).to_string())
}
}
);
// Implement SetupMandate flow
macros::macro_connector_implementation!(
connector_default_implementations: [get_content_type, get_error_response_v2],
connector: Authorizedotnet,
curl_request: Json(AuthorizedotnetSetupMandateRequest),
curl_response: AuthorizedotnetSetupMandateResponse,
flow_name: SetupMandate,
resource_common_data: PaymentFlowData,
flow_request: SetupMandateRequestData<T>,
flow_response: PaymentsResponseData,
http_method: Post,
preprocess_response: true,
generic_type: T,
[PaymentMethodDataTypes + std::fmt::Debug + std::marker::Sync + std::marker::Send + 'static + Serialize],
other_functions: {
fn get_headers(
&self,
req: &RouterDataV2<SetupMandate, PaymentFlowData, SetupMandateRequestData<T>, PaymentsResponseData>,
) -> CustomResult<Vec<(String, Maskable<String>)>, ConnectorError> {
self.build_headers(req)
}
fn get_url(
&self,
req: &RouterDataV2<SetupMandate, PaymentFlowData, SetupMandateRequestData<T>, PaymentsResponseData>,
) -> CustomResult<String, ConnectorError> {
Ok(self.connector_base_url_payments(req).to_string())
}
}
);
macros::macro_connector_implementation!(
connector_default_implementations: [get_content_type, get_error_response_v2],
connector: Authorizedotnet,
curl_request: Json(AuthorizedotnetRepeatPaymentRequest),
curl_response: AuthorizedotnetRepeatPaymentResponse,
flow_name: RepeatPayment,
resource_common_data: PaymentFlowData,
flow_request: RepeatPaymentData,
flow_response: PaymentsResponseData,
http_method: Post,
preprocess_response: true, // Keeping true for Authorize.net which needs BOM handling
generic_type: T,
[PaymentMethodDataTypes + std::fmt::Debug + std::marker::Sync + std::marker::Send + 'static + Serialize],
other_functions: {
fn get_headers(
&self,
req: &RouterDataV2<RepeatPayment, PaymentFlowData, RepeatPaymentData, PaymentsResponseData>,
) -> CustomResult<Vec<(String, Maskable<String>)>, ConnectorError> {
self.build_headers(req)
}
fn get_url(
&self,
req: &RouterDataV2<RepeatPayment, PaymentFlowData, RepeatPaymentData, PaymentsResponseData>,
) -> CustomResult<String, ConnectorError> {
Ok(self.connector_base_url_payments(req).to_string())
}
}
);
// Implement CreateConnectorCustomer flow
macros::macro_connector_implementation!(
connector_default_implementations: [get_content_type, get_error_response_v2],
connector: Authorizedotnet,
curl_request: Json(AuthorizedotnetCreateConnectorCustomerRequest),
curl_response: AuthorizedotnetCreateConnectorCustomerResponse,
flow_name: CreateConnectorCustomer,
resource_common_data: PaymentFlowData,
flow_request: ConnectorCustomerData,
flow_response: ConnectorCustomerResponse,
http_method: Post,
preprocess_response: true,
generic_type: T,
[PaymentMethodDataTypes + std::fmt::Debug + std::marker::Sync + std::marker::Send + 'static + Serialize],
other_functions: {
fn get_headers(
&self,
req: &RouterDataV2<CreateConnectorCustomer, PaymentFlowData, ConnectorCustomerData, ConnectorCustomerResponse>,
) -> CustomResult<Vec<(String, Maskable<String>)>, ConnectorError> {
self.build_headers(req)
}
fn get_url(
&self,
req: &RouterDataV2<CreateConnectorCustomer, PaymentFlowData, ConnectorCustomerData, ConnectorCustomerResponse>,
| {
"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_1422429809174256361_8 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/authorizedotnet.rs
) -> CustomResult<String, ConnectorError> {
Ok(self.connector_base_url_payments(req).to_string())
}
}
);
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
ConnectorIntegrationV2<
CreateOrder,
PaymentFlowData,
PaymentCreateOrderData,
PaymentCreateOrderResponse,
> for Authorizedotnet<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
ConnectorIntegrationV2<
CreateSessionToken,
PaymentFlowData,
SessionTokenRequestData,
SessionTokenResponseData,
> for Authorizedotnet<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
ConnectorIntegrationV2<
CreateAccessToken,
PaymentFlowData,
AccessTokenRequestData,
AccessTokenResponseData,
> for Authorizedotnet<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> ConnectorIntegrationV2<Accept, DisputeFlowData, AcceptDisputeData, DisputeResponseData>
for Authorizedotnet<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
ConnectorIntegrationV2<SubmitEvidence, DisputeFlowData, SubmitEvidenceData, DisputeResponseData>
for Authorizedotnet<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> ConnectorIntegrationV2<DefendDispute, DisputeFlowData, DisputeDefendData, DisputeResponseData>
for Authorizedotnet<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
ConnectorIntegrationV2<
PaymentMethodToken,
PaymentFlowData,
PaymentMethodTokenizationData<T>,
PaymentMethodTokenResponse,
> for Authorizedotnet<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
ConnectorIntegrationV2<
PreAuthenticate,
PaymentFlowData,
PaymentsPreAuthenticateData<T>,
PaymentsResponseData,
> for Authorizedotnet<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
ConnectorIntegrationV2<
Authenticate,
PaymentFlowData,
PaymentsAuthenticateData<T>,
PaymentsResponseData,
> for Authorizedotnet<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
ConnectorIntegrationV2<
PostAuthenticate,
PaymentFlowData,
PaymentsPostAuthenticateData<T>,
PaymentsResponseData,
> for Authorizedotnet<T>
{
}
// SourceVerification implementations for all flows
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> SourceVerification<Authorize, PaymentFlowData, PaymentsAuthorizeData<T>, PaymentsResponseData>
for Authorizedotnet<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
SourceVerification<
CreateSessionToken,
PaymentFlowData,
SessionTokenRequestData,
SessionTokenResponseData,
> for Authorizedotnet<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
| {
"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_1422429809174256361_9 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/authorizedotnet.rs
+ 'static
+ Serialize,
>
SourceVerification<
CreateAccessToken,
PaymentFlowData,
AccessTokenRequestData,
AccessTokenResponseData,
> for Authorizedotnet<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> SourceVerification<PSync, PaymentFlowData, PaymentsSyncData, PaymentsResponseData>
for Authorizedotnet<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> SourceVerification<Capture, PaymentFlowData, PaymentsCaptureData, PaymentsResponseData>
for Authorizedotnet<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> SourceVerification<Void, PaymentFlowData, PaymentVoidData, PaymentsResponseData>
for Authorizedotnet<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> SourceVerification<Refund, RefundFlowData, RefundsData, RefundsResponseData>
for Authorizedotnet<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> SourceVerification<RSync, RefundFlowData, RefundSyncData, RefundsResponseData>
for Authorizedotnet<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
SourceVerification<
CreateOrder,
PaymentFlowData,
PaymentCreateOrderData,
PaymentCreateOrderResponse,
> for Authorizedotnet<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
SourceVerification<
SetupMandate,
PaymentFlowData,
SetupMandateRequestData<T>,
PaymentsResponseData,
> for Authorizedotnet<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> SourceVerification<RepeatPayment, PaymentFlowData, RepeatPaymentData, PaymentsResponseData>
for Authorizedotnet<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
SourceVerification<
CreateConnectorCustomer,
PaymentFlowData,
ConnectorCustomerData,
ConnectorCustomerResponse,
> for Authorizedotnet<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> SourceVerification<Accept, DisputeFlowData, AcceptDisputeData, DisputeResponseData>
for Authorizedotnet<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> SourceVerification<SubmitEvidence, DisputeFlowData, SubmitEvidenceData, DisputeResponseData>
for Authorizedotnet<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> SourceVerification<DefendDispute, DisputeFlowData, DisputeDefendData, DisputeResponseData>
for Authorizedotnet<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
ConnectorIntegrationV2<
VoidPC,
PaymentFlowData,
PaymentsCancelPostCaptureData,
PaymentsResponseData,
> for Authorizedotnet<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
| {
"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_1422429809174256361_10 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/authorizedotnet.rs
+ std::marker::Send
+ 'static
+ Serialize,
>
SourceVerification<VoidPC, PaymentFlowData, PaymentsCancelPostCaptureData, PaymentsResponseData>
for Authorizedotnet<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> ConnectorSpecifications for Authorizedotnet<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
interfaces::verification::SourceVerification<
PaymentMethodToken,
PaymentFlowData,
PaymentMethodTokenizationData<T>,
PaymentMethodTokenResponse,
> for Authorizedotnet<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
SourceVerification<
PreAuthenticate,
PaymentFlowData,
PaymentsPreAuthenticateData<T>,
PaymentsResponseData,
> for Authorizedotnet<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
SourceVerification<
Authenticate,
PaymentFlowData,
PaymentsAuthenticateData<T>,
PaymentsResponseData,
> for Authorizedotnet<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
SourceVerification<
PostAuthenticate,
PaymentFlowData,
PaymentsPostAuthenticateData<T>,
PaymentsResponseData,
> for Authorizedotnet<T>
{
}
| {
"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_-7993544184240262595_0 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/payload.rs
mod requests;
mod responses;
pub mod transformers;
use base64::Engine;
use common_enums::CurrencyUnit;
use common_utils::{
crypto::VerifySignature, errors::CustomResult, events, ext_traits::ByteSliceExt,
};
use domain_types::{
connector_flow::{
Accept, Authorize, Capture, CreateOrder, CreateSessionToken, DefendDispute, PSync, RSync,
Refund, RepeatPayment, SetupMandate, SubmitEvidence, Void,
},
connector_types::{
AcceptDisputeData, DisputeDefendData, DisputeFlowData, DisputeResponseData,
PaymentCreateOrderData, PaymentCreateOrderResponse, PaymentFlowData, PaymentVoidData,
PaymentsAuthorizeData, PaymentsCaptureData, PaymentsResponseData, PaymentsSyncData,
RefundFlowData, RefundSyncData, RefundsData, RefundsResponseData, RepeatPaymentData,
SessionTokenRequestData, SessionTokenResponseData, SetupMandateRequestData,
SubmitEvidenceData,
},
errors,
payment_method_data::PaymentMethodDataTypes,
router_data::{ConnectorAuthType, ErrorResponse},
router_data_v2::RouterDataV2,
router_response_types::Response,
types::Connectors,
};
use error_stack::ResultExt;
use hyperswitch_masking::{ExposeInterface, Mask, Maskable};
use interfaces::{
api::ConnectorCommon, connector_integration_v2::ConnectorIntegrationV2, connector_types,
};
use serde::Serialize;
use std::fmt::Debug;
use transformers::{
self as payload, PayloadAuthorizeResponse, PayloadCaptureRequest, PayloadCaptureResponse,
PayloadCardsRequestData, PayloadErrorResponse, PayloadPSyncResponse, PayloadPaymentsRequest,
PayloadRSyncResponse, PayloadRefundRequest, PayloadRefundResponse, PayloadRepeatPaymentRequest,
PayloadRepeatPaymentResponse, PayloadSetupMandateResponse, PayloadVoidRequest,
PayloadVoidResponse,
};
use super::macros;
use crate::{types::ResponseRouterData, with_error_response_body};
pub const BASE64_ENGINE: base64::engine::GeneralPurpose = base64::engine::general_purpose::STANDARD;
// Trait implementations with generic type parameters
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::ConnectorServiceTrait<T> for Payload<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::PaymentAuthorizeV2<T> for Payload<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::PaymentSyncV2 for Payload<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::PaymentVoidV2 for Payload<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::RefundSyncV2 for Payload<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::RefundV2 for Payload<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::PaymentCapture for Payload<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::ValidationTrait for Payload<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::PaymentOrderCreate for Payload<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::SetupMandateV2<T> for Payload<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::RepeatPaymentV2 for Payload<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::AcceptDispute for Payload<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::SubmitEvidenceV2 for Payload<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::DisputeDefend for Payload<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::PaymentSessionToken for Payload<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::PaymentPostAuthenticateV2<T> for Payload<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::PaymentAuthenticateV2<T> for Payload<T>
{
}
| {
"chunk": 0,
"crate": "connector-integration",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_mini_connector-integration_-7993544184240262595_1 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/payload.rs
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::PaymentPreAuthenticateV2<T> for Payload<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::PaymentVoidPostCaptureV2 for Payload<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::PaymentTokenV2<T> for Payload<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::CreateConnectorCustomer for Payload<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::PaymentAccessToken for Payload<T>
{
}
pub(crate) mod headers {
pub(crate) const AUTHORIZATION: &str = "Authorization";
pub(crate) const CONTENT_TYPE: &str = "Content-Type";
pub(crate) const X_PAYLOAD_SIGNATURE: &str = "X-PAYLOAD-SIGNATURE";
}
macros::create_amount_converter_wrapper!(connector_name: Payload, amount_type: FloatMajorUnit);
macros::create_all_prerequisites!(
connector_name: Payload,
generic_type: T,
api: [
(
flow: Authorize,
request_body: PayloadPaymentsRequest<T>,
response_body: PayloadAuthorizeResponse,
router_data: RouterDataV2<Authorize, PaymentFlowData, PaymentsAuthorizeData<T>, PaymentsResponseData>,
),
(
flow: PSync,
response_body: PayloadPSyncResponse,
router_data: RouterDataV2<PSync, PaymentFlowData, PaymentsSyncData, PaymentsResponseData>,
),
(
flow: Capture,
request_body: PayloadCaptureRequest,
response_body: PayloadCaptureResponse,
router_data: RouterDataV2<Capture, PaymentFlowData, PaymentsCaptureData, PaymentsResponseData>,
),
(
flow: Void,
request_body: PayloadVoidRequest,
response_body: PayloadVoidResponse,
router_data: RouterDataV2<Void, PaymentFlowData, PaymentVoidData, PaymentsResponseData>,
),
(
flow: Refund,
request_body: PayloadRefundRequest,
response_body: PayloadRefundResponse,
router_data: RouterDataV2<Refund, RefundFlowData, RefundsData, RefundsResponseData>,
),
(
flow: RSync,
response_body: PayloadRSyncResponse,
router_data: RouterDataV2<RSync, RefundFlowData, RefundSyncData, RefundsResponseData>,
),
(
flow: SetupMandate,
request_body: PayloadCardsRequestData<T>,
response_body: PayloadSetupMandateResponse,
router_data: RouterDataV2<SetupMandate, PaymentFlowData, SetupMandateRequestData<T>, PaymentsResponseData>,
),
(
flow: RepeatPayment,
request_body: PayloadRepeatPaymentRequest<T>,
response_body: PayloadRepeatPaymentResponse,
router_data: RouterDataV2<RepeatPayment, PaymentFlowData, RepeatPaymentData, PaymentsResponseData>,
)
],
amount_converters: [],
member_functions: {
pub fn build_headers<F, FCD, Req, Res>(
&self,
req: &RouterDataV2<F, FCD, Req, Res>,
) -> CustomResult<Vec<(String, Maskable<String>)>, errors::ConnectorError>
where
Self: ConnectorIntegrationV2<F, FCD, Req, Res>,
{
let mut header = vec![(
headers::CONTENT_TYPE.to_string(),
Self::common_get_content_type(self).to_string().into(),
)];
let mut api_key = self.get_auth_header(&req.connector_auth_type)?;
header.append(&mut api_key);
Ok(header)
}
pub fn connector_base_url_payments<'a, F, Req, Res>(
&self,
req: &'a RouterDataV2<F, PaymentFlowData, Req, Res>,
) -> &'a str {
&req.resource_common_data.connectors.payload.base_url
}
pub fn connector_base_url_refunds<'a, F, Req, Res>(
&self,
req: &'a RouterDataV2<F, RefundFlowData, Req, Res>,
) -> &'a str {
&req.resource_common_data.connectors.payload.base_url
}
}
);
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize> ConnectorCommon
for Payload<T>
{
fn id(&self) -> &'static str {
| {
"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_-7993544184240262595_2 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/payload.rs
"payload"
}
fn get_currency_unit(&self) -> CurrencyUnit {
CurrencyUnit::Minor
}
fn common_get_content_type(&self) -> &'static str {
"application/x-www-form-urlencoded"
}
fn base_url<'a>(&self, connectors: &'a Connectors) -> &'a str {
connectors.payload.base_url.as_ref()
}
fn get_auth_header(
&self,
auth_type: &ConnectorAuthType,
) -> CustomResult<Vec<(String, Maskable<String>)>, errors::ConnectorError> {
let auth = payload::PayloadAuthType::try_from(auth_type)
.change_context(errors::ConnectorError::FailedToObtainAuthType)?;
// The API key is the same for all currencies, so we can take any.
let api_key = auth
.auths
.values()
.next()
.ok_or(errors::ConnectorError::FailedToObtainAuthType)?
.api_key
.clone();
let encoded_api_key = BASE64_ENGINE.encode(format!("{}:", api_key.expose()));
Ok(vec![(
headers::AUTHORIZATION.to_string(),
format!("Basic {encoded_api_key}").into_masked(),
)])
}
fn build_error_response(
&self,
res: Response,
event_builder: Option<&mut events::Event>,
) -> CustomResult<ErrorResponse, errors::ConnectorError> {
let response: PayloadErrorResponse = res
.response
.parse_struct("PayloadErrorResponse")
.change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
with_error_response_body!(event_builder, response);
Ok(ErrorResponse {
status_code: res.status_code,
code: response.error_type,
message: response.error_description,
reason: response
.details
.as_ref()
.map(|details_value| details_value.to_string()),
attempt_status: None,
connector_transaction_id: None,
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
})
}
}
// Authorize flow implementation
macros::macro_connector_implementation!(
connector_default_implementations: [get_content_type, get_error_response_v2],
connector: Payload,
curl_request: FormUrlEncoded(PayloadPaymentsRequest<T>),
curl_response: PayloadAuthorizeResponse,
flow_name: Authorize,
resource_common_data: PaymentFlowData,
flow_request: PaymentsAuthorizeData<T>,
flow_response: PaymentsResponseData,
http_method: Post,
generic_type: T,
[PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize],
other_functions: {
fn get_headers(
&self,
req: &RouterDataV2<Authorize, PaymentFlowData, PaymentsAuthorizeData<T>, PaymentsResponseData>,
) -> CustomResult<Vec<(String, Maskable<String>)>, errors::ConnectorError> {
self.build_headers(req)
}
fn get_url(
&self,
req: &RouterDataV2<Authorize, PaymentFlowData, PaymentsAuthorizeData<T>, PaymentsResponseData>,
) -> CustomResult<String, errors::ConnectorError> {
Ok(format!("{}/transactions", self.connector_base_url_payments(req)))
}
}
);
// PSync flow implementation
macros::macro_connector_implementation!(
connector_default_implementations: [get_content_type, get_error_response_v2],
connector: Payload,
curl_response: PayloadPSyncResponse,
flow_name: PSync,
resource_common_data: PaymentFlowData,
flow_request: PaymentsSyncData,
flow_response: PaymentsResponseData,
http_method: Get,
generic_type: T,
[PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize],
other_functions: {
fn get_headers(
&self,
req: &RouterDataV2<PSync, PaymentFlowData, PaymentsSyncData, PaymentsResponseData>,
) -> CustomResult<Vec<(String, Maskable<String>)>, errors::ConnectorError> {
self.build_headers(req)
}
fn get_url(
&self,
req: &RouterDataV2<PSync, PaymentFlowData, PaymentsSyncData, PaymentsResponseData>,
) -> CustomResult<String, errors::ConnectorError> {
let payment_id = req
.request
.connector_transaction_id
| {
"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_-7993544184240262595_3 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/payload.rs
.get_connector_transaction_id()
.change_context(errors::ConnectorError::MissingConnectorTransactionID)?;
Ok(format!(
"{}/transactions/{}",
self.connector_base_url_payments(req),
payment_id
))
}
}
);
// Capture flow implementation
macros::macro_connector_implementation!(
connector_default_implementations: [get_content_type, get_error_response_v2],
connector: Payload,
curl_request: FormUrlEncoded(PayloadCaptureRequest),
curl_response: PayloadCaptureResponse,
flow_name: Capture,
resource_common_data: PaymentFlowData,
flow_request: PaymentsCaptureData,
flow_response: PaymentsResponseData,
http_method: Put,
generic_type: T,
[PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize],
other_functions: {
fn get_headers(
&self,
req: &RouterDataV2<Capture, PaymentFlowData, PaymentsCaptureData, PaymentsResponseData>,
) -> CustomResult<Vec<(String, Maskable<String>)>, errors::ConnectorError> {
self.build_headers(req)
}
fn get_url(
&self,
req: &RouterDataV2<Capture, PaymentFlowData, PaymentsCaptureData, PaymentsResponseData>,
) -> CustomResult<String, errors::ConnectorError> {
let connector_transaction_id = req.request.connector_transaction_id
.get_connector_transaction_id()
.change_context(errors::ConnectorError::MissingConnectorTransactionID)?;
Ok(format!(
"{}/transactions/{}",
self.connector_base_url_payments(req),
connector_transaction_id
))
}
}
);
// Void flow implementation
macros::macro_connector_implementation!(
connector_default_implementations: [get_content_type, get_error_response_v2],
connector: Payload,
curl_request: FormUrlEncoded(PayloadVoidRequest),
curl_response: PayloadVoidResponse,
flow_name: Void,
resource_common_data: PaymentFlowData,
flow_request: PaymentVoidData,
flow_response: PaymentsResponseData,
http_method: Put,
generic_type: T,
[PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize],
other_functions: {
fn get_headers(
&self,
req: &RouterDataV2<Void, PaymentFlowData, PaymentVoidData, PaymentsResponseData>,
) -> CustomResult<Vec<(String, Maskable<String>)>, errors::ConnectorError> {
self.build_headers(req)
}
fn get_url(
&self,
req: &RouterDataV2<Void, PaymentFlowData, PaymentVoidData, PaymentsResponseData>,
) -> CustomResult<String, errors::ConnectorError> {
let payment_id = &req.request.connector_transaction_id;
Ok(format!(
"{}/transactions/{}",
self.connector_base_url_payments(req),
payment_id
))
}
}
);
// Refund flow implementation
macros::macro_connector_implementation!(
connector_default_implementations: [get_content_type, get_error_response_v2],
connector: Payload,
curl_request: FormUrlEncoded(PayloadRefundRequest),
curl_response: PayloadRefundResponse,
flow_name: Refund,
resource_common_data: RefundFlowData,
flow_request: RefundsData,
flow_response: RefundsResponseData,
http_method: Post,
generic_type: T,
[PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize],
other_functions: {
fn get_headers(
&self,
req: &RouterDataV2<Refund, RefundFlowData, RefundsData, RefundsResponseData>,
) -> CustomResult<Vec<(String, Maskable<String>)>, errors::ConnectorError> {
self.build_headers(req)
}
fn get_url(
&self,
req: &RouterDataV2<Refund, RefundFlowData, RefundsData, RefundsResponseData>,
) -> CustomResult<String, errors::ConnectorError> {
Ok(format!("{}/transactions", self.connector_base_url_refunds(req)))
}
}
);
// RSync flow implementation
macros::macro_connector_implementation!(
connector_default_implementations: [get_content_type, get_error_response_v2],
connector: Payload,
curl_response: PayloadRSyncResponse,
flow_name: RSync,
| {
"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_-7993544184240262595_4 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/payload.rs
resource_common_data: RefundFlowData,
flow_request: RefundSyncData,
flow_response: RefundsResponseData,
http_method: Get,
generic_type: T,
[PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize],
other_functions: {
fn get_headers(
&self,
req: &RouterDataV2<RSync, RefundFlowData, RefundSyncData, RefundsResponseData>,
) -> CustomResult<Vec<(String, Maskable<String>)>, errors::ConnectorError> {
self.build_headers(req)
}
fn get_url(
&self,
req: &RouterDataV2<RSync, RefundFlowData, RefundSyncData, RefundsResponseData>,
) -> CustomResult<String, errors::ConnectorError> {
Ok(format!(
"{}/transactions/{}",
self.connector_base_url_refunds(req),
req.request.connector_refund_id
))
}
}
);
// SetupMandate flow implementation
macros::macro_connector_implementation!(
connector_default_implementations: [get_content_type, get_error_response_v2],
connector: Payload,
curl_request: FormUrlEncoded(PayloadCardsRequestData<T>),
curl_response: PayloadSetupMandateResponse,
flow_name: SetupMandate,
resource_common_data: PaymentFlowData,
flow_request: SetupMandateRequestData<T>,
flow_response: PaymentsResponseData,
http_method: Post,
generic_type: T,
[PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize],
other_functions: {
fn get_headers(
&self,
req: &RouterDataV2<SetupMandate, PaymentFlowData, SetupMandateRequestData<T>, PaymentsResponseData>,
) -> CustomResult<Vec<(String, Maskable<String>)>, errors::ConnectorError> {
self.build_headers(req)
}
fn get_url(
&self,
req: &RouterDataV2<SetupMandate, PaymentFlowData, SetupMandateRequestData<T>, PaymentsResponseData>,
) -> CustomResult<String, errors::ConnectorError> {
Ok(format!("{}/transactions", self.connector_base_url_payments(req)))
}
}
);
// Stub implementations for unsupported flows
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
ConnectorIntegrationV2<
CreateOrder,
PaymentFlowData,
PaymentCreateOrderData,
PaymentCreateOrderResponse,
> for Payload<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
ConnectorIntegrationV2<SubmitEvidence, DisputeFlowData, SubmitEvidenceData, DisputeResponseData>
for Payload<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> ConnectorIntegrationV2<DefendDispute, DisputeFlowData, DisputeDefendData, DisputeResponseData>
for Payload<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> ConnectorIntegrationV2<Accept, DisputeFlowData, AcceptDisputeData, DisputeResponseData>
for Payload<T>
{
}
// RepeatPayment flow implementation
macros::macro_connector_implementation!(
connector_default_implementations: [get_content_type, get_error_response_v2],
connector: Payload,
curl_request: FormUrlEncoded(PayloadRepeatPaymentRequest<T>),
curl_response: PayloadRepeatPaymentResponse,
flow_name: RepeatPayment,
resource_common_data: PaymentFlowData,
flow_request: RepeatPaymentData,
flow_response: PaymentsResponseData,
http_method: Post,
generic_type: T,
[PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize],
other_functions: {
fn get_headers(
&self,
req: &RouterDataV2<RepeatPayment, PaymentFlowData, RepeatPaymentData, PaymentsResponseData>,
) -> CustomResult<Vec<(String, Maskable<String>)>, errors::ConnectorError> {
self.build_headers(req)
}
fn get_url(
&self,
| {
"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_-7993544184240262595_5 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/payload.rs
req: &RouterDataV2<RepeatPayment, PaymentFlowData, RepeatPaymentData, PaymentsResponseData>,
) -> CustomResult<String, errors::ConnectorError> {
Ok(format!("{}/transactions", self.connector_base_url_payments(req)))
}
}
);
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
ConnectorIntegrationV2<
CreateSessionToken,
PaymentFlowData,
SessionTokenRequestData,
SessionTokenResponseData,
> for Payload<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
ConnectorIntegrationV2<
domain_types::connector_flow::PostAuthenticate,
PaymentFlowData,
domain_types::connector_types::PaymentsPostAuthenticateData<T>,
PaymentsResponseData,
> for Payload<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
ConnectorIntegrationV2<
domain_types::connector_flow::Authenticate,
PaymentFlowData,
domain_types::connector_types::PaymentsAuthenticateData<T>,
PaymentsResponseData,
> for Payload<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
ConnectorIntegrationV2<
domain_types::connector_flow::PreAuthenticate,
PaymentFlowData,
domain_types::connector_types::PaymentsPreAuthenticateData<T>,
PaymentsResponseData,
> for Payload<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
ConnectorIntegrationV2<
domain_types::connector_flow::VoidPC,
PaymentFlowData,
domain_types::connector_types::PaymentsCancelPostCaptureData,
PaymentsResponseData,
> for Payload<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
ConnectorIntegrationV2<
domain_types::connector_flow::PaymentMethodToken,
PaymentFlowData,
domain_types::connector_types::PaymentMethodTokenizationData<T>,
domain_types::connector_types::PaymentMethodTokenResponse,
> for Payload<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
ConnectorIntegrationV2<
domain_types::connector_flow::CreateConnectorCustomer,
PaymentFlowData,
domain_types::connector_types::ConnectorCustomerData,
domain_types::connector_types::ConnectorCustomerResponse,
> for Payload<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
ConnectorIntegrationV2<
domain_types::connector_flow::CreateAccessToken,
PaymentFlowData,
domain_types::connector_types::AccessTokenRequestData,
domain_types::connector_types::AccessTokenResponseData,
> for Payload<T>
{
}
// SourceVerification implementations for all flows
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
Authorize,
PaymentFlowData,
PaymentsAuthorizeData<T>,
PaymentsResponseData,
> for Payload<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
PSync,
PaymentFlowData,
PaymentsSyncData,
PaymentsResponseData,
> for Payload<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
Capture,
PaymentFlowData,
PaymentsCaptureData,
PaymentsResponseData,
| {
"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_-7993544184240262595_6 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/payload.rs
> for Payload<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
Void,
PaymentFlowData,
PaymentVoidData,
PaymentsResponseData,
> for Payload<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
Refund,
RefundFlowData,
RefundsData,
RefundsResponseData,
> for Payload<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
RSync,
RefundFlowData,
RefundSyncData,
RefundsResponseData,
> for Payload<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
SetupMandate,
PaymentFlowData,
SetupMandateRequestData<T>,
PaymentsResponseData,
> for Payload<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
Accept,
DisputeFlowData,
AcceptDisputeData,
DisputeResponseData,
> for Payload<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
SubmitEvidence,
DisputeFlowData,
SubmitEvidenceData,
DisputeResponseData,
> for Payload<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
DefendDispute,
DisputeFlowData,
DisputeDefendData,
DisputeResponseData,
> for Payload<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
CreateOrder,
PaymentFlowData,
PaymentCreateOrderData,
PaymentCreateOrderResponse,
> for Payload<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
RepeatPayment,
PaymentFlowData,
RepeatPaymentData,
PaymentsResponseData,
> for Payload<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
CreateSessionToken,
PaymentFlowData,
SessionTokenRequestData,
SessionTokenResponseData,
> for Payload<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
domain_types::connector_flow::PostAuthenticate,
PaymentFlowData,
domain_types::connector_types::PaymentsPostAuthenticateData<T>,
PaymentsResponseData,
> for Payload<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
domain_types::connector_flow::Authenticate,
PaymentFlowData,
domain_types::connector_types::PaymentsAuthenticateData<T>,
PaymentsResponseData,
> for Payload<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
domain_types::connector_flow::PreAuthenticate,
PaymentFlowData,
domain_types::connector_types::PaymentsPreAuthenticateData<T>,
PaymentsResponseData,
> for Payload<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
domain_types::connector_flow::VoidPC,
PaymentFlowData,
domain_types::connector_types::PaymentsCancelPostCaptureData,
PaymentsResponseData,
> for Payload<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
domain_types::connector_flow::PaymentMethodToken,
PaymentFlowData,
domain_types::connector_types::PaymentMethodTokenizationData<T>,
domain_types::connector_types::PaymentMethodTokenResponse,
> for Payload<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
| {
"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_-7993544184240262595_7 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/payload.rs
domain_types::connector_flow::CreateConnectorCustomer,
PaymentFlowData,
domain_types::connector_types::ConnectorCustomerData,
domain_types::connector_types::ConnectorCustomerResponse,
> for Payload<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
domain_types::connector_flow::CreateAccessToken,
PaymentFlowData,
domain_types::connector_types::AccessTokenRequestData,
domain_types::connector_types::AccessTokenResponseData,
> for Payload<T>
{
}
// Webhook implementation
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::IncomingWebhook for Payload<T>
{
fn get_webhook_source_verification_signature(
&self,
request: &domain_types::connector_types::RequestDetails,
_connector_webhook_secret: &domain_types::connector_types::ConnectorWebhookSecrets,
) -> Result<Vec<u8>, error_stack::Report<errors::ConnectorError>> {
let signature = request
.headers
.get(headers::X_PAYLOAD_SIGNATURE)
.map(|header_value| header_value.as_bytes().to_vec())
.ok_or(errors::ConnectorError::WebhookSourceVerificationFailed)?;
Ok(signature)
}
fn get_webhook_source_verification_message(
&self,
request: &domain_types::connector_types::RequestDetails,
_connector_webhook_secret: &domain_types::connector_types::ConnectorWebhookSecrets,
) -> Result<Vec<u8>, error_stack::Report<errors::ConnectorError>> {
Ok(request.body.to_vec())
}
fn verify_webhook_source(
&self,
request: domain_types::connector_types::RequestDetails,
connector_webhook_secret: Option<domain_types::connector_types::ConnectorWebhookSecrets>,
_connector_account_details: Option<ConnectorAuthType>,
) -> Result<bool, error_stack::Report<errors::ConnectorError>> {
let algorithm = common_utils::crypto::Sha256;
let connector_webhook_secrets = match connector_webhook_secret {
Some(secrets) => secrets,
None => {
return Ok(false);
}
};
let signature = self
.get_webhook_source_verification_signature(&request, &connector_webhook_secrets)
.change_context(errors::ConnectorError::WebhookSourceVerificationFailed)?;
let message = self
.get_webhook_source_verification_message(&request, &connector_webhook_secrets)
.change_context(errors::ConnectorError::WebhookSourceVerificationFailed)?;
algorithm
.verify_signature(&connector_webhook_secrets.secret, &signature, &message)
.change_context(errors::ConnectorError::WebhookSourceVerificationFailed)
}
fn get_event_type(
&self,
request: domain_types::connector_types::RequestDetails,
_connector_webhook_secret: Option<domain_types::connector_types::ConnectorWebhookSecrets>,
_connector_account_details: Option<ConnectorAuthType>,
) -> Result<domain_types::connector_types::EventType, error_stack::Report<errors::ConnectorError>>
{
let webhook_body: transformers::PayloadWebhookEvent = request
.body
.parse_struct("PayloadWebhookEvent")
.change_context(errors::ConnectorError::WebhookBodyDecodingFailed)?;
Ok(transformers::get_event_type_from_trigger(
webhook_body.trigger,
))
}
fn get_webhook_resource_object(
&self,
request: domain_types::connector_types::RequestDetails,
) -> Result<
Box<dyn hyperswitch_masking::ErasedMaskSerialize>,
error_stack::Report<errors::ConnectorError>,
> {
let webhook_body: transformers::PayloadWebhookEvent = request
.body
.parse_struct("PayloadWebhookEvent")
.change_context(errors::ConnectorError::WebhookBodyDecodingFailed)?;
Ok(Box::new(webhook_body))
}
}
| {
"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_34017170220941800_0 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/trustpay.rs
use base64::Engine;
use common_utils::{
consts, errors::CustomResult, events, ext_traits::BytesExt, types::StringMajorUnit,
};
use domain_types::{
connector_flow::{
Accept, Authenticate, Authorize, Capture, CreateAccessToken, CreateConnectorCustomer,
CreateOrder, CreateSessionToken, DefendDispute, PSync, PaymentMethodToken,
PostAuthenticate, PreAuthenticate, RSync, Refund, RepeatPayment, SetupMandate,
SubmitEvidence, Void, VoidPC,
},
connector_types::{
AcceptDisputeData, AccessTokenRequestData, AccessTokenResponseData, ConnectorCustomerData,
ConnectorCustomerResponse, ConnectorSpecifications, DisputeDefendData, DisputeFlowData,
DisputeResponseData, PaymentCreateOrderData, PaymentCreateOrderResponse, PaymentFlowData,
PaymentMethodTokenResponse, PaymentMethodTokenizationData, PaymentVoidData,
PaymentsAuthenticateData, PaymentsAuthorizeData, PaymentsCancelPostCaptureData,
PaymentsCaptureData, PaymentsPostAuthenticateData, PaymentsPreAuthenticateData,
PaymentsResponseData, PaymentsSyncData, RefundFlowData, RefundSyncData, RefundsData,
RefundsResponseData, RepeatPaymentData, SessionTokenRequestData, SessionTokenResponseData,
SetupMandateRequestData, SubmitEvidenceData,
},
errors,
payment_method_data::PaymentMethodDataTypes,
router_data::{ConnectorAuthType, ErrorResponse},
router_data_v2::RouterDataV2,
router_response_types::Response,
types::Connectors,
};
use error_stack::{Report, ResultExt};
use hyperswitch_masking::{Mask, Maskable};
use interfaces::{
api::ConnectorCommon, connector_integration_v2::ConnectorIntegrationV2, connector_types,
};
use serde::Serialize;
use std::fmt::Debug;
pub mod transformers;
pub const BASE64_ENGINE: base64::engine::GeneralPurpose = base64::engine::general_purpose::STANDARD;
use transformers::{
self as trustpay, TrustpayAuthUpdateRequest, TrustpayAuthUpdateResponse, TrustpayErrorResponse,
TrustpayPaymentsResponse as TrustpayPaymentsSyncResponse,
};
use super::macros;
use crate::types::ResponseRouterData;
// Local headers module
mod headers {
pub const CONTENT_TYPE: &str = "Content-Type";
pub const AUTHORIZATION: &str = "Authorization";
pub const X_API_KEY: &str = "X-Api-Key";
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::ConnectorServiceTrait<T> for Trustpay<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::PaymentAuthorizeV2<T> for Trustpay<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::PaymentSyncV2 for Trustpay<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::PaymentVoidV2 for Trustpay<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::RefundSyncV2 for Trustpay<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::RefundV2 for Trustpay<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::PaymentCapture for Trustpay<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::ValidationTrait for Trustpay<T>
{
fn should_do_access_token(&self) -> bool {
true
}
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::PaymentOrderCreate for Trustpay<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::SetupMandateV2<T> for Trustpay<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::RepeatPaymentV2 for Trustpay<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::AcceptDispute for Trustpay<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::SubmitEvidenceV2 for Trustpay<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::DisputeDefend for Trustpay<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::IncomingWebhook for Trustpay<T>
{
}
| {
"chunk": 0,
"crate": "connector-integration",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_mini_connector-integration_34017170220941800_1 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/trustpay.rs
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::PaymentSessionToken for Trustpay<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::PaymentAccessToken for Trustpay<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::CreateConnectorCustomer for Trustpay<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::PaymentTokenV2<T> for Trustpay<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::PaymentPreAuthenticateV2<T> for Trustpay<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::PaymentAuthenticateV2<T> for Trustpay<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::PaymentPostAuthenticateV2<T> for Trustpay<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::PaymentVoidPostCaptureV2 for Trustpay<T>
{
}
macros::create_all_prerequisites!(
connector_name: Trustpay,
generic_type: T,
api: [
(
flow: PSync,
response_body: TrustpayPaymentsSyncResponse,
router_data: RouterDataV2<PSync, PaymentFlowData, PaymentsSyncData, PaymentsResponseData>,
),
(
flow: CreateAccessToken,
request_body: TrustpayAuthUpdateRequest,
response_body: TrustpayAuthUpdateResponse,
router_data: RouterDataV2<CreateAccessToken, PaymentFlowData, AccessTokenRequestData, AccessTokenResponseData>,
)
],
amount_converters: [
amount_converter: StringMajorUnit
],
member_functions: {
pub fn build_headers_for_payments<F, Req, Res>(
&self,
req: &RouterDataV2<F, PaymentFlowData, Req, Res>,
) -> CustomResult<Vec<(String, Maskable<String>)>, errors::ConnectorError>
where
Self: ConnectorIntegrationV2<F, PaymentFlowData, Req, Res>,
{
match req.resource_common_data.payment_method {
common_enums::PaymentMethod::BankRedirect | common_enums::PaymentMethod::BankTransfer => {
let token = req
.resource_common_data
.get_access_token()
.change_context(errors::ConnectorError::MissingRequiredField {
field_name: "access_token",
})?;
Ok(vec![
(
headers::CONTENT_TYPE.to_string(),
"application/json".to_owned().into(),
),
(
headers::AUTHORIZATION.to_string(),
format!("Bearer {token}").into_masked(),
),
])
}
_ => {
let mut header = vec![(
headers::CONTENT_TYPE.to_string(),
self.get_content_type().to_string().into(),
)];
let mut api_key = self.get_auth_header(&req.connector_auth_type)?;
header.append(&mut api_key);
Ok(header)
}
}
}
pub fn connector_base_url_payments<'a, F, Req, Res>(
&self,
req: &'a RouterDataV2<F, PaymentFlowData, Req, Res>,
) -> &'a str {
&req.resource_common_data.connectors.trustpay.base_url
}
pub fn connector_base_url_bank_redirects_payments<'a, F, Req, Res>(
&self,
req: &'a RouterDataV2<F, PaymentFlowData, Req, Res>,
) -> &'a str {
&req.resource_common_data.connectors.trustpay.base_url_bank_redirects
}
pub fn get_auth_header(
&self,
auth_type: &ConnectorAuthType,
) -> CustomResult<Vec<(String, Maskable<String>)>, errors::ConnectorError> {
let auth = trustpay::TrustpayAuthType::try_from(auth_type)
.change_context(errors::ConnectorError::FailedToObtainAuthType)?;
Ok(vec![(
headers::X_API_KEY.to_string(),
auth.api_key.into_masked(),
)])
}
}
);
| {
"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_34017170220941800_2 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/trustpay.rs
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize> ConnectorCommon
for Trustpay<T>
{
fn id(&self) -> &'static str {
"trustpay"
}
fn common_get_content_type(&self) -> &'static str {
"application/x-www-form-urlencoded"
}
fn base_url<'a>(&self, connectors: &'a Connectors) -> &'a str {
connectors.trustpay.base_url.as_ref()
}
fn build_error_response(
&self,
res: Response,
event_builder: Option<&mut events::Event>,
) -> CustomResult<ErrorResponse, errors::ConnectorError> {
let response: Result<TrustpayErrorResponse, Report<common_utils::errors::ParsingError>> =
res.response.parse_struct("trustpay ErrorResponse");
match response {
Ok(response_data) => {
if let Some(i) = event_builder {
i.set_connector_response(&response_data);
}
let reason = response_data.errors.map(|errors| {
errors
.iter()
.map(|error| error.description.clone())
.collect::<Vec<String>>()
.join(" & ")
});
Ok(ErrorResponse {
status_code: res.status_code,
code: consts::NO_ERROR_CODE.to_string(),
message: consts::NO_ERROR_CODE.to_string(),
reason: reason
.or(response_data.description)
.or(response_data.payment_description),
attempt_status: None,
connector_transaction_id: response_data.instance_id,
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
})
}
Err(error_msg) => {
if let Some(event) = event_builder {
event.set_connector_response(&serde_json::json!({"error": "Error response parsing failed", "status_code": res.status_code}))
};
tracing::error!(deserialization_error =? error_msg);
domain_types::utils::handle_json_response_deserialization_failure(res, "trustpay")
}
}
}
}
macros::macro_connector_implementation!(
connector_default_implementations: [get_content_type, get_error_response_v2],
connector: Trustpay,
curl_response: TrustpayPaymentsSyncResponse,
flow_name: PSync,
resource_common_data: PaymentFlowData,
flow_request: PaymentsSyncData,
flow_response: PaymentsResponseData,
http_method: Get,
generic_type: T,
[PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize],
other_functions: {
fn get_headers(
&self,
req: &RouterDataV2<PSync, PaymentFlowData, PaymentsSyncData, PaymentsResponseData>,
) -> CustomResult<Vec<(String, Maskable<String>)>, errors::ConnectorError> {
self.build_headers_for_payments(req)
}
fn get_url(
&self,
req: &RouterDataV2<PSync, PaymentFlowData, PaymentsSyncData, PaymentsResponseData>,
) -> CustomResult<String, errors::ConnectorError> {
let transaction_id = req
.request
.connector_transaction_id
.get_connector_transaction_id()
.change_context(errors::ConnectorError::MissingConnectorTransactionID)?;
match req.resource_common_data.payment_method {
common_enums::PaymentMethod::BankRedirect | common_enums::PaymentMethod::BankTransfer => Ok(format!(
"{}{}/{}",
self.connector_base_url_bank_redirects_payments(req),
"api/Payments/Payment",
transaction_id,
)),
_ => Ok(format!(
"{}{}/{}",
self.connector_base_url_payments(req),
"api/v1/instance",
transaction_id,
)),
}
}
}
);
macros::macro_connector_implementation!(
connector_default_implementations: [get_content_type, get_error_response_v2],
connector: Trustpay,
curl_request: FormUrlEncoded(TrustpayAuthUpdateRequest),
| {
"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_34017170220941800_3 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/trustpay.rs
curl_response: TrustpayAuthUpdateResponse,
flow_name: CreateAccessToken,
resource_common_data: PaymentFlowData,
flow_request: AccessTokenRequestData,
flow_response: AccessTokenResponseData,
http_method: Post,
generic_type: T,
[PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize],
other_functions: {
fn get_headers(
&self,
req: &RouterDataV2<CreateAccessToken, PaymentFlowData, AccessTokenRequestData, AccessTokenResponseData>,
) -> CustomResult<Vec<(String, Maskable<String>)>, errors::ConnectorError> {
let auth = trustpay::TrustpayAuthType::try_from(&req.connector_auth_type)
.change_context(errors::ConnectorError::FailedToObtainAuthType)?;
let auth_value = auth
.project_id
.zip(auth.secret_key)
.map(|(project_id, secret_key)| {
format!(
"Basic {}",
BASE64_ENGINE
.encode(format!("{project_id}:{secret_key}"))
)
});
Ok(vec![
(
headers::CONTENT_TYPE.to_string(),
self.common_get_content_type().to_string().into(),
),
(headers::AUTHORIZATION.to_string(), auth_value.into_masked()),
])
}
fn get_url(
&self,
req: &RouterDataV2<CreateAccessToken, PaymentFlowData, AccessTokenRequestData, AccessTokenResponseData>,
) -> CustomResult<String, errors::ConnectorError> {
Ok(format!(
"{}{}",
self.connector_base_url_bank_redirects_payments(req), "api/oauth2/token"
))
}
}
);
// Implementation for empty stubs - these will need to be properly implemented later
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
ConnectorIntegrationV2<
Authorize,
PaymentFlowData,
PaymentsAuthorizeData<T>,
PaymentsResponseData,
> for Trustpay<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
ConnectorIntegrationV2<RSync, RefundFlowData, RefundSyncData, RefundsResponseData>
for Trustpay<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
ConnectorIntegrationV2<Refund, RefundFlowData, RefundsData, RefundsResponseData>
for Trustpay<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
ConnectorIntegrationV2<
CreateOrder,
PaymentFlowData,
PaymentCreateOrderData,
PaymentCreateOrderResponse,
> for Trustpay<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
ConnectorIntegrationV2<
CreateConnectorCustomer,
PaymentFlowData,
ConnectorCustomerData,
ConnectorCustomerResponse,
> for Trustpay<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
ConnectorIntegrationV2<Accept, DisputeFlowData, AcceptDisputeData, DisputeResponseData>
for Trustpay<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
ConnectorIntegrationV2<SubmitEvidence, DisputeFlowData, SubmitEvidenceData, DisputeResponseData>
for Trustpay<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
ConnectorIntegrationV2<DefendDispute, DisputeFlowData, DisputeDefendData, DisputeResponseData>
for Trustpay<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
ConnectorIntegrationV2<
CreateSessionToken,
PaymentFlowData,
SessionTokenRequestData,
SessionTokenResponseData,
> for Trustpay<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
ConnectorIntegrationV2<
SetupMandate,
PaymentFlowData,
SetupMandateRequestData<T>,
PaymentsResponseData,
> for Trustpay<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
ConnectorIntegrationV2<Void, PaymentFlowData, PaymentVoidData, PaymentsResponseData>
for Trustpay<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
ConnectorIntegrationV2<
VoidPC,
PaymentFlowData,
| {
"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_34017170220941800_4 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/trustpay.rs
PaymentsCancelPostCaptureData,
PaymentsResponseData,
> for Trustpay<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize
+ Serialize,
> ConnectorIntegrationV2<Capture, PaymentFlowData, PaymentsCaptureData, PaymentsResponseData>
for Trustpay<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
ConnectorIntegrationV2<
PaymentMethodToken,
PaymentFlowData,
PaymentMethodTokenizationData<T>,
PaymentMethodTokenResponse,
> for Trustpay<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
ConnectorIntegrationV2<
PreAuthenticate,
PaymentFlowData,
PaymentsPreAuthenticateData<T>,
PaymentsResponseData,
> for Trustpay<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
ConnectorIntegrationV2<
Authenticate,
PaymentFlowData,
PaymentsAuthenticateData<T>,
PaymentsResponseData,
> for Trustpay<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
ConnectorIntegrationV2<
PostAuthenticate,
PaymentFlowData,
PaymentsPostAuthenticateData<T>,
PaymentsResponseData,
> for Trustpay<T>
{
}
// SourceVerification implementations for all flows
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
Authorize,
PaymentFlowData,
PaymentsAuthorizeData<T>,
PaymentsResponseData,
> for Trustpay<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
PSync,
PaymentFlowData,
PaymentsSyncData,
PaymentsResponseData,
> for Trustpay<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
Capture,
PaymentFlowData,
PaymentsCaptureData,
PaymentsResponseData,
> for Trustpay<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
Void,
PaymentFlowData,
PaymentVoidData,
PaymentsResponseData,
> for Trustpay<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
Refund,
RefundFlowData,
RefundsData,
RefundsResponseData,
> for Trustpay<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
RSync,
RefundFlowData,
RefundSyncData,
RefundsResponseData,
> for Trustpay<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
SetupMandate,
PaymentFlowData,
SetupMandateRequestData<T>,
PaymentsResponseData,
> for Trustpay<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
Accept,
DisputeFlowData,
AcceptDisputeData,
DisputeResponseData,
> for Trustpay<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
SubmitEvidence,
DisputeFlowData,
SubmitEvidenceData,
DisputeResponseData,
> for Trustpay<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
DefendDispute,
DisputeFlowData,
DisputeDefendData,
DisputeResponseData,
> for Trustpay<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
CreateOrder,
PaymentFlowData,
PaymentCreateOrderData,
PaymentCreateOrderResponse,
> for Trustpay<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
| {
"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_34017170220941800_5 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/trustpay.rs
interfaces::verification::SourceVerification<
CreateConnectorCustomer,
PaymentFlowData,
ConnectorCustomerData,
ConnectorCustomerResponse,
> for Trustpay<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize> ConnectorSpecifications
for Trustpay<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
CreateSessionToken,
PaymentFlowData,
SessionTokenRequestData,
SessionTokenResponseData,
> for Trustpay<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
CreateAccessToken,
PaymentFlowData,
AccessTokenRequestData,
AccessTokenResponseData,
> for Trustpay<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
interfaces::verification::SourceVerification<
PaymentMethodToken,
PaymentFlowData,
PaymentMethodTokenizationData<T>,
PaymentMethodTokenResponse,
> for Trustpay<T>
{
}
// We already have an implementation for ValidationTrait above
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
RepeatPayment,
PaymentFlowData,
RepeatPaymentData,
PaymentsResponseData,
> for Trustpay<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
ConnectorIntegrationV2<RepeatPayment, PaymentFlowData, RepeatPaymentData, PaymentsResponseData>
for Trustpay<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
PreAuthenticate,
PaymentFlowData,
PaymentsPreAuthenticateData<T>,
PaymentsResponseData,
> for Trustpay<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
Authenticate,
PaymentFlowData,
PaymentsAuthenticateData<T>,
PaymentsResponseData,
> for Trustpay<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
PostAuthenticate,
PaymentFlowData,
PaymentsPostAuthenticateData<T>,
PaymentsResponseData,
> for Trustpay<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
VoidPC,
PaymentFlowData,
PaymentsCancelPostCaptureData,
PaymentsResponseData,
> for Trustpay<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_3959697425557219616_0 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/placetopay.rs
pub mod transformers;
use common_utils::{
consts::{NO_ERROR_CODE, NO_ERROR_MESSAGE},
errors::CustomResult,
events,
ext_traits::ByteSliceExt,
};
use domain_types::{
connector_flow::{
Accept, Authenticate, Authorize, Capture, CreateAccessToken, CreateConnectorCustomer,
CreateOrder, CreateSessionToken, DefendDispute, PSync, PaymentMethodToken,
PostAuthenticate, PreAuthenticate, RSync, Refund, RepeatPayment, SetupMandate,
SubmitEvidence, Void, VoidPC,
},
connector_types::{
AcceptDisputeData, AccessTokenRequestData, AccessTokenResponseData, ConnectorCustomerData,
ConnectorCustomerResponse, DisputeDefendData, DisputeFlowData, DisputeResponseData,
PaymentCreateOrderData, PaymentCreateOrderResponse, PaymentFlowData,
PaymentMethodTokenResponse, PaymentMethodTokenizationData, PaymentVoidData,
PaymentsAuthenticateData, PaymentsAuthorizeData, PaymentsCancelPostCaptureData,
PaymentsCaptureData, PaymentsPostAuthenticateData, PaymentsPreAuthenticateData,
PaymentsResponseData, PaymentsSyncData, RefundFlowData, RefundSyncData, RefundsData,
RefundsResponseData, RepeatPaymentData, SessionTokenRequestData, SessionTokenResponseData,
SetupMandateRequestData, SubmitEvidenceData,
},
errors,
payment_method_data::PaymentMethodDataTypes,
router_data::ErrorResponse,
router_data_v2::RouterDataV2,
router_response_types::Response,
types::Connectors,
};
use error_stack::ResultExt;
use hyperswitch_masking::Maskable;
use interfaces::{
api::ConnectorCommon, connector_integration_v2::ConnectorIntegrationV2, connector_types,
};
use serde::Serialize;
use std::fmt::Debug;
use transformers::{
self as placetopay, PlacetopayNextActionRequest,
PlacetopayNextActionRequest as PlacetopayVoidRequest, PlacetopayPaymentsRequest,
PlacetopayPaymentsResponse as PlacetopayPSyncResponse, PlacetopayPaymentsResponse,
PlacetopayPaymentsResponse as PlacetopayCaptureResponse,
PlacetopayPaymentsResponse as PlacetopayVoidResponse, PlacetopayPsyncRequest,
PlacetopayRefundRequest, PlacetopayRefundResponse as PlacetopayRSyncResponse,
PlacetopayRefundResponse, PlacetopayRsyncRequest,
};
use super::macros;
use crate::{types::ResponseRouterData, with_error_response_body};
pub(crate) mod headers {
pub(crate) const CONTENT_TYPE: &str = "Content-Type";
}
// Simplified macro usage to avoid duplicate type definitions
macros::create_all_prerequisites!(
connector_name: Placetopay,
generic_type: T,
api: [
(
flow: Authorize,
request_body: PlacetopayPaymentsRequest<T>,
response_body: PlacetopayPaymentsResponse,
router_data: RouterDataV2<Authorize, PaymentFlowData, PaymentsAuthorizeData<T>, PaymentsResponseData>,
),
(
flow: PSync,
request_body: PlacetopayPsyncRequest,
response_body: PlacetopayPSyncResponse,
router_data: RouterDataV2<PSync, PaymentFlowData, PaymentsSyncData, PaymentsResponseData>,
),
(
flow: Capture,
request_body: PlacetopayNextActionRequest,
response_body: PlacetopayCaptureResponse,
router_data: RouterDataV2<Capture, PaymentFlowData, PaymentsCaptureData, PaymentsResponseData>,
),
(
flow: Void,
request_body: PlacetopayVoidRequest,
response_body: PlacetopayVoidResponse,
router_data: RouterDataV2<Void, PaymentFlowData, PaymentVoidData, PaymentsResponseData>,
),
(
flow: Refund,
request_body: PlacetopayRefundRequest,
response_body: PlacetopayRefundResponse,
router_data: RouterDataV2<Refund, RefundFlowData, RefundsData, RefundsResponseData>,
),
(
flow: RSync,
request_body: PlacetopayRsyncRequest,
response_body: PlacetopayRSyncResponse,
router_data: RouterDataV2<RSync, RefundFlowData, RefundSyncData, RefundsResponseData>,
)
],
amount_converters: [],
member_functions: {
pub fn build_headers<F, FCD, Req, Res>(
&self,
req: &RouterDataV2<F, FCD, Req, Res>,
| {
"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_3959697425557219616_1 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/placetopay.rs
) -> CustomResult<Vec<(String, Maskable<String>)>, errors::ConnectorError>
where
Self: ConnectorIntegrationV2<F, FCD, Req, Res>,
{
let mut header = vec![(
headers::CONTENT_TYPE.to_string(),
"application/json".to_string().into(),
)];
let mut api_key = self.get_auth_header(&req.connector_auth_type)?;
header.append(&mut api_key);
Ok(header)
}
pub fn connector_base_url_payments<'a, F, Req, Res>(
&self,
req: &'a RouterDataV2<F, PaymentFlowData, Req, Res>,
) -> &'a str {
&req.resource_common_data.connectors.placetopay.base_url
}
pub fn connector_base_url_refunds<'a, F, Req, Res>(
&self,
req: &'a RouterDataV2<F, RefundFlowData, Req, Res>,
) -> &'a str {
&req.resource_common_data.connectors.placetopay.base_url
}
}
);
// Trait implementations with generic type parameters
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::PaymentAuthorizeV2<T> for Placetopay<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
ConnectorIntegrationV2<
PaymentMethodToken,
PaymentFlowData,
PaymentMethodTokenizationData<T>,
PaymentMethodTokenResponse,
> for Placetopay<T>
{
}
// Higher-level trait implementations
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::ValidationTrait for Placetopay<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::PaymentSyncV2 for Placetopay<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::PaymentOrderCreate for Placetopay<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::PaymentSessionToken for Placetopay<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::PaymentTokenV2<T> for Placetopay<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::PaymentVoidV2 for Placetopay<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::IncomingWebhook for Placetopay<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::RefundV2 for Placetopay<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::PaymentCapture for Placetopay<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::SetupMandateV2<T> for Placetopay<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::RepeatPaymentV2 for Placetopay<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::AcceptDispute for Placetopay<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::RefundSyncV2 for Placetopay<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::DisputeDefend for Placetopay<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::SubmitEvidenceV2 for Placetopay<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::PaymentAccessToken for Placetopay<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::CreateConnectorCustomer for Placetopay<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::PaymentPreAuthenticateV2<T> for Placetopay<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::PaymentAuthenticateV2<T> for Placetopay<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::PaymentPostAuthenticateV2<T> for Placetopay<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::PaymentVoidPostCaptureV2 for Placetopay<T>
{
}
| {
"chunk": 1,
"crate": "connector-integration",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_mini_connector-integration_3959697425557219616_2 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/placetopay.rs
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
ConnectorIntegrationV2<
VoidPC,
PaymentFlowData,
PaymentsCancelPostCaptureData,
PaymentsResponseData,
> for Placetopay<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
VoidPC,
PaymentFlowData,
PaymentsCancelPostCaptureData,
PaymentsResponseData,
> for Placetopay<T>
{
}
// Finally implement ConnectorServiceTrait
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::ConnectorServiceTrait<T> for Placetopay<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize> ConnectorCommon
for Placetopay<T>
{
fn id(&self) -> &'static str {
"placetopay"
}
fn get_currency_unit(&self) -> common_enums::CurrencyUnit {
common_enums::CurrencyUnit::Minor
}
fn base_url<'a>(&self, connectors: &'a Connectors) -> &'a str {
connectors.placetopay.base_url.as_ref()
}
fn build_error_response(
&self,
res: Response,
event_builder: Option<&mut events::Event>,
) -> CustomResult<ErrorResponse, errors::ConnectorError> {
let response: placetopay::PlacetopayErrorResponse = res
.response
.parse_struct("PlacetopayErrorResponse")
.change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
with_error_response_body!(event_builder, response);
Ok(ErrorResponse {
status_code: res.status_code,
code: response
.status
.reason
.unwrap_or_else(|| NO_ERROR_CODE.to_string()),
message: response
.status
.message
.clone()
.unwrap_or_else(|| NO_ERROR_MESSAGE.to_string()),
reason: response.status.message,
attempt_status: None,
connector_transaction_id: None,
network_decline_code: None,
network_advice_code: None,
network_error_message: None,
})
}
}
// Macro implementation for Authorize flow
macros::macro_connector_implementation!(
connector_default_implementations: [get_content_type, get_error_response_v2],
connector: Placetopay,
curl_request: Json(PlacetopayPaymentsRequest<T>),
curl_response: PlacetopayPaymentsResponse,
flow_name: Authorize,
resource_common_data: PaymentFlowData,
flow_request: PaymentsAuthorizeData<T>,
flow_response: PaymentsResponseData,
http_method: Post,
generic_type: T,
[PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize],
other_functions: {
fn get_headers(
&self,
req: &RouterDataV2<Authorize, PaymentFlowData, PaymentsAuthorizeData<T>, PaymentsResponseData>,
) -> CustomResult<Vec<(String, Maskable<String>)>, errors::ConnectorError> {
self.build_headers(req)
}
fn get_url(
&self,
req: &RouterDataV2<Authorize, PaymentFlowData, PaymentsAuthorizeData<T>, PaymentsResponseData>,
) -> CustomResult<String, errors::ConnectorError> {
Ok(format!("{}/process", self.connector_base_url_payments(req)))
}
}
);
// Macro implementation for PSync flow
macros::macro_connector_implementation!(
connector_default_implementations: [get_content_type, get_error_response_v2],
connector: Placetopay,
curl_request: Json(PlacetopayPsyncRequest),
curl_response: PlacetopayPSyncResponse,
flow_name: PSync,
resource_common_data: PaymentFlowData,
flow_request: PaymentsSyncData,
flow_response: PaymentsResponseData,
http_method: Post,
generic_type: T,
[PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize],
other_functions: {
fn get_headers(
&self,
req: &RouterDataV2<PSync, PaymentFlowData, PaymentsSyncData, PaymentsResponseData>,
) -> CustomResult<Vec<(String, Maskable<String>)>, errors::ConnectorError> {
self.build_headers(req)
}
fn get_url(
&self,
req: &RouterDataV2<PSync, PaymentFlowData, PaymentsSyncData, PaymentsResponseData>,
) -> CustomResult<String, errors::ConnectorError> {
| {
"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_3959697425557219616_3 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/placetopay.rs
Ok(format!("{}/query", self.connector_base_url_payments(req)))
}
}
);
// Macro implementation for Capture flow
macros::macro_connector_implementation!(
connector_default_implementations: [get_content_type, get_error_response_v2],
connector: Placetopay,
curl_request: Json(PlacetopayNextActionRequest),
curl_response: PlacetopayCaptureResponse,
flow_name: Capture,
resource_common_data: PaymentFlowData,
flow_request: PaymentsCaptureData,
flow_response: PaymentsResponseData,
http_method: Post,
generic_type: T,
[PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize],
other_functions: {
fn get_headers(
&self,
req: &RouterDataV2<Capture, PaymentFlowData, PaymentsCaptureData, PaymentsResponseData>,
) -> CustomResult<Vec<(String, Maskable<String>)>, errors::ConnectorError> {
self.build_headers(req)
}
fn get_url(
&self,
req: &RouterDataV2<Capture, PaymentFlowData, PaymentsCaptureData, PaymentsResponseData>,
) -> CustomResult<String, errors::ConnectorError> {
Ok(format!("{}/transaction", self.connector_base_url_payments(req)))
}
}
);
// Macro implementation for Void flow
macros::macro_connector_implementation!(
connector_default_implementations: [get_content_type, get_error_response_v2],
connector: Placetopay,
curl_request: Json(PlacetopayVoidRequest),
curl_response: PlacetopayVoidResponse,
flow_name: Void,
resource_common_data: PaymentFlowData,
flow_request: PaymentVoidData,
flow_response: PaymentsResponseData,
http_method: Post,
generic_type: T,
[PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize],
other_functions: {
fn get_headers(
&self,
req: &RouterDataV2<Void, PaymentFlowData, PaymentVoidData, PaymentsResponseData>,
) -> CustomResult<Vec<(String, Maskable<String>)>, errors::ConnectorError> {
self.build_headers(req)
}
fn get_url(
&self,
req: &RouterDataV2<Void, PaymentFlowData, PaymentVoidData, PaymentsResponseData>,
) -> CustomResult<String, errors::ConnectorError> {
Ok(format!("{}/transaction", self.connector_base_url_payments(req)))
}
}
);
// Macro implementation for Refund flow
macros::macro_connector_implementation!(
connector_default_implementations: [get_content_type, get_error_response_v2],
connector: Placetopay,
curl_request: Json(PlacetopayRefundRequest),
curl_response: PlacetopayRefundResponse,
flow_name: Refund,
resource_common_data: RefundFlowData,
flow_request: RefundsData,
flow_response: RefundsResponseData,
http_method: Post,
generic_type: T,
[PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize],
other_functions: {
fn get_headers(
&self,
req: &RouterDataV2<Refund, RefundFlowData, RefundsData, RefundsResponseData>,
) -> CustomResult<Vec<(String, Maskable<String>)>, errors::ConnectorError> {
self.build_headers(req)
}
fn get_url(
&self,
req: &RouterDataV2<Refund, RefundFlowData, RefundsData, RefundsResponseData>,
) -> CustomResult<String, errors::ConnectorError> {
Ok(format!("{}/transaction", self.connector_base_url_refunds(req)))
}
}
);
// Macro implementation for RSync flow
macros::macro_connector_implementation!(
connector_default_implementations: [get_content_type, get_error_response_v2],
connector: Placetopay,
curl_request: Json(PlacetopayRsyncRequest),
curl_response: PlacetopayRSyncResponse,
flow_name: RSync,
resource_common_data: RefundFlowData,
flow_request: RefundSyncData,
flow_response: RefundsResponseData,
http_method: Post,
generic_type: T,
[PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize],
other_functions: {
fn get_headers(
&self,
req: &RouterDataV2<RSync, RefundFlowData, RefundSyncData, RefundsResponseData>,
) -> CustomResult<Vec<(String, Maskable<String>)>, errors::ConnectorError> {
self.build_headers(req)
}
fn get_url(
&self,
| {
"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_3959697425557219616_4 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/placetopay.rs
req: &RouterDataV2<RSync, RefundFlowData, RefundSyncData, RefundsResponseData>,
) -> CustomResult<String, errors::ConnectorError> {
Ok(format!("{}/query", self.connector_base_url_refunds(req)))
}
}
);
// Stub implementations for unsupported flows
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
ConnectorIntegrationV2<
CreateOrder,
PaymentFlowData,
PaymentCreateOrderData,
PaymentCreateOrderResponse,
> for Placetopay<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
ConnectorIntegrationV2<SubmitEvidence, DisputeFlowData, SubmitEvidenceData, DisputeResponseData>
for Placetopay<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> ConnectorIntegrationV2<DefendDispute, DisputeFlowData, DisputeDefendData, DisputeResponseData>
for Placetopay<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> ConnectorIntegrationV2<Accept, DisputeFlowData, AcceptDisputeData, DisputeResponseData>
for Placetopay<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
ConnectorIntegrationV2<
SetupMandate,
PaymentFlowData,
SetupMandateRequestData<T>,
PaymentsResponseData,
> for Placetopay<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
ConnectorIntegrationV2<RepeatPayment, PaymentFlowData, RepeatPaymentData, PaymentsResponseData>
for Placetopay<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
ConnectorIntegrationV2<
CreateSessionToken,
PaymentFlowData,
SessionTokenRequestData,
SessionTokenResponseData,
> for Placetopay<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
ConnectorIntegrationV2<
CreateAccessToken,
PaymentFlowData,
AccessTokenRequestData,
AccessTokenResponseData,
> for Placetopay<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
ConnectorIntegrationV2<
PreAuthenticate,
PaymentFlowData,
PaymentsPreAuthenticateData<T>,
PaymentsResponseData,
> for Placetopay<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
ConnectorIntegrationV2<
Authenticate,
PaymentFlowData,
PaymentsAuthenticateData<T>,
PaymentsResponseData,
> for Placetopay<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
ConnectorIntegrationV2<
PostAuthenticate,
PaymentFlowData,
PaymentsPostAuthenticateData<T>,
PaymentsResponseData,
> for Placetopay<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
ConnectorIntegrationV2<
CreateConnectorCustomer,
PaymentFlowData,
ConnectorCustomerData,
ConnectorCustomerResponse,
> for Placetopay<T>
{
}
// SourceVerification implementations for all flows
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
Authorize,
PaymentFlowData,
PaymentsAuthorizeData<T>,
PaymentsResponseData,
> for Placetopay<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
PSync,
PaymentFlowData,
PaymentsSyncData,
PaymentsResponseData,
> for Placetopay<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
| {
"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_3959697425557219616_5 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/placetopay.rs
interfaces::verification::SourceVerification<
Capture,
PaymentFlowData,
PaymentsCaptureData,
PaymentsResponseData,
> for Placetopay<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
Void,
PaymentFlowData,
PaymentVoidData,
PaymentsResponseData,
> for Placetopay<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
Refund,
RefundFlowData,
RefundsData,
RefundsResponseData,
> for Placetopay<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
RSync,
RefundFlowData,
RefundSyncData,
RefundsResponseData,
> for Placetopay<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
SetupMandate,
PaymentFlowData,
SetupMandateRequestData<T>,
PaymentsResponseData,
> for Placetopay<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
Accept,
DisputeFlowData,
AcceptDisputeData,
DisputeResponseData,
> for Placetopay<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
SubmitEvidence,
DisputeFlowData,
SubmitEvidenceData,
DisputeResponseData,
> for Placetopay<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
DefendDispute,
DisputeFlowData,
DisputeDefendData,
DisputeResponseData,
> for Placetopay<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
CreateOrder,
PaymentFlowData,
PaymentCreateOrderData,
PaymentCreateOrderResponse,
> for Placetopay<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
RepeatPayment,
PaymentFlowData,
RepeatPaymentData,
PaymentsResponseData,
> for Placetopay<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
CreateSessionToken,
PaymentFlowData,
SessionTokenRequestData,
SessionTokenResponseData,
> for Placetopay<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
PaymentMethodToken,
PaymentFlowData,
PaymentMethodTokenizationData<T>,
PaymentMethodTokenResponse,
> for Placetopay<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
CreateAccessToken,
PaymentFlowData,
AccessTokenRequestData,
AccessTokenResponseData,
> for Placetopay<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
PreAuthenticate,
PaymentFlowData,
PaymentsPreAuthenticateData<T>,
PaymentsResponseData,
> for Placetopay<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
Authenticate,
PaymentFlowData,
PaymentsAuthenticateData<T>,
PaymentsResponseData,
> for Placetopay<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
PostAuthenticate,
PaymentFlowData,
PaymentsPostAuthenticateData<T>,
PaymentsResponseData,
> for Placetopay<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
CreateConnectorCustomer,
PaymentFlowData,
ConnectorCustomerData,
ConnectorCustomerResponse,
> for Placetopay<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_814751693867000820_0 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/helcim/transformers.rs
use common_utils::{pii, types::FloatMajorUnit};
use domain_types::{
connector_flow::{Authorize, Capture, SetupMandate, Void},
connector_types::{
MandateReference, PaymentFlowData, PaymentVoidData, PaymentsAuthorizeData,
PaymentsCaptureData, PaymentsResponseData, PaymentsSyncData, RefundFlowData,
RefundSyncData, RefundsData, RefundsResponseData, ResponseId, SetupMandateRequestData,
},
errors::{self, ConnectorError},
payment_method_data::{PaymentMethodData, PaymentMethodDataTypes, RawCardNumber},
router_data::ConnectorAuthType,
router_data_v2::RouterDataV2,
router_request_types::SyncRequestType,
};
use error_stack::ResultExt;
use hyperswitch_masking::Secret;
use serde::{Deserialize, Serialize};
use crate::{connectors::helcim::HelcimRouterData, types::ResponseRouterData};
// Note: HelcimRouterData is generated by the macro, so we don't define it here
// The macro generates: pub struct crate::connectors::helcim::HelcimRouterData<RD: FlowTypes, T: PaymentMethodDataTypes + ..., T> { pub connector: Helcim<T>, pub router_data: RD }
pub fn check_currency(
currency: common_enums::Currency,
) -> Result<common_enums::Currency, errors::ConnectorError> {
if currency == common_enums::Currency::USD {
Ok(currency)
} else {
Err(errors::ConnectorError::NotSupported {
message: format!("currency {currency} is not supported for this merchant account"),
connector: "Helcim",
})?
}
}
// Auth Struct
pub struct HelcimAuthType {
pub(super) api_key: Secret<String>,
}
impl TryFrom<&ConnectorAuthType> for HelcimAuthType {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(auth_type: &ConnectorAuthType) -> Result<Self, Self::Error> {
match auth_type {
ConnectorAuthType::HeaderKey { api_key } => Ok(Self {
api_key: api_key.to_owned(),
}),
_ => Err(errors::ConnectorError::FailedToObtainAuthType.into()),
}
}
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct HelcimPaymentsRequest<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> {
amount: FloatMajorUnit,
currency: common_enums::Currency,
ip_address: Secret<String, pii::IpAddress>,
card_data: HelcimCard<T>,
invoice: HelcimInvoice,
billing_address: HelcimBillingAddress,
#[serde(skip_serializing_if = "Option::is_none")]
ecommerce: Option<bool>,
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct HelcimBillingAddress {
name: Secret<String>,
street1: Secret<String>,
postal_code: Secret<String>,
#[serde(skip_serializing_if = "Option::is_none")]
street2: Option<Secret<String>>,
#[serde(skip_serializing_if = "Option::is_none")]
city: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
email: Option<common_utils::pii::Email>,
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct HelcimInvoice {
invoice_number: String,
line_items: Vec<HelcimLineItems>,
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct HelcimLineItems {
description: String,
quantity: u8,
price: FloatMajorUnit,
total: FloatMajorUnit,
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct HelcimCard<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> {
card_number: RawCardNumber<T>,
card_expiry: Secret<String>,
card_c_v_v: Secret<String>,
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
TryFrom<
HelcimRouterData<
RouterDataV2<
Authorize,
PaymentFlowData,
PaymentsAuthorizeData<T>,
PaymentsResponseData,
>,
T,
>,
> for HelcimPaymentsRequest<T>
{
type Error = error_stack::Report<ConnectorError>;
fn try_from(
item: HelcimRouterData<
RouterDataV2<
Authorize,
PaymentFlowData,
| {
"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_814751693867000820_1 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/helcim/transformers.rs
PaymentsAuthorizeData<T>,
PaymentsResponseData,
>,
T,
>,
) -> Result<Self, Self::Error> {
let card_data = match &item.router_data.request.payment_method_data {
PaymentMethodData::Card(card) => HelcimCard {
card_expiry: card
.get_card_expiry_month_year_2_digit_with_delimiter("".to_string())?,
card_number: card.card_number.clone(),
card_c_v_v: card.card_cvc.clone(),
},
_ => return Err(ConnectorError::NotImplemented("payment method".into()).into()),
};
let req_address = item
.router_data
.resource_common_data
.get_billing_address()?;
let billing_address = HelcimBillingAddress {
name: req_address.get_full_name()?,
street1: req_address.get_line1()?.to_owned(),
postal_code: req_address.get_zip()?.to_owned(),
street2: req_address.line2.clone(),
city: req_address.city.clone(),
email: item.router_data.request.email.clone(),
};
let ip_address = item.router_data.request.get_ip_address()?;
let amount = item
.connector
.amount_converter
.convert(
item.router_data.request.minor_amount,
item.router_data.request.currency,
)
.change_context(errors::ConnectorError::AmountConversionFailed)?;
let line_items = vec![HelcimLineItems {
description: item
.router_data
.resource_common_data
.description
.clone()
.unwrap_or("No Description".to_string()),
quantity: 1,
price: amount,
total: amount,
}];
let invoice = HelcimInvoice {
invoice_number: item
.router_data
.resource_common_data
.connector_request_reference_id
.clone(),
line_items,
};
let currency = check_currency(item.router_data.request.currency)?;
Ok(Self {
amount,
currency,
ip_address,
card_data,
invoice,
billing_address,
ecommerce: None,
})
}
}
// PaymentsResponse
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(rename_all = "UPPERCASE")]
pub enum HelcimPaymentStatus {
Approved,
Declined,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(rename_all = "lowercase")]
pub enum HelcimTransactionType {
Purchase,
PreAuth,
Capture,
Verify,
Reverse,
}
impl From<HelcimPaymentsResponse> for common_enums::AttemptStatus {
fn from(item: HelcimPaymentsResponse) -> Self {
match item.transaction_type {
HelcimTransactionType::Purchase | HelcimTransactionType::Verify => match item.status {
HelcimPaymentStatus::Approved => Self::Charged,
HelcimPaymentStatus::Declined => Self::Failure,
},
HelcimTransactionType::PreAuth => match item.status {
HelcimPaymentStatus::Approved => Self::Authorized,
HelcimPaymentStatus::Declined => Self::AuthorizationFailed,
},
HelcimTransactionType::Capture => match item.status {
HelcimPaymentStatus::Approved => Self::Charged,
HelcimPaymentStatus::Declined => Self::CaptureFailed,
},
HelcimTransactionType::Reverse => match item.status {
HelcimPaymentStatus::Approved => Self::Voided,
HelcimPaymentStatus::Declined => Self::VoidFailed,
},
}
}
}
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct HelcimPaymentsResponse {
status: HelcimPaymentStatus,
transaction_id: u64,
invoice_number: Option<String>,
#[serde(rename = "type")]
transaction_type: HelcimTransactionType,
#[serde(skip_serializing_if = "Option::is_none")]
errors: Option<String>,
}
#[derive(Debug, Deserialize, Serialize)]
pub struct HelcimMetaData {
pub preauth_transaction_id: String,
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
| {
"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_814751693867000820_2 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/helcim/transformers.rs
+ std::marker::Send
+ 'static
+ Serialize,
>
TryFrom<
ResponseRouterData<
HelcimPaymentsResponse,
RouterDataV2<
Authorize,
PaymentFlowData,
PaymentsAuthorizeData<T>,
PaymentsResponseData,
>,
>,
> for RouterDataV2<Authorize, PaymentFlowData, PaymentsAuthorizeData<T>, PaymentsResponseData>
{
type Error = error_stack::Report<ConnectorError>;
fn try_from(
item: ResponseRouterData<
HelcimPaymentsResponse,
RouterDataV2<
Authorize,
PaymentFlowData,
PaymentsAuthorizeData<T>,
PaymentsResponseData,
>,
>,
) -> Result<Self, Self::Error> {
//PreAuth Transaction ID is stored in connector metadata
//Initially resource_id is stored as NoResponseID for manual capture
//After Capture Transaction is completed it is updated to store the Capture ID
let is_auto_capture = item.router_data.request.is_auto_capture()?;
let resource_id = if is_auto_capture {
ResponseId::ConnectorTransactionId(item.response.transaction_id.to_string())
} else {
ResponseId::NoResponseId
};
let connector_metadata = if !is_auto_capture {
Some(serde_json::json!(HelcimMetaData {
preauth_transaction_id: item.response.transaction_id.to_string(),
}))
} else {
None
};
let status = common_enums::AttemptStatus::from(item.response.clone());
Ok(Self {
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id,
redirection_data: None,
connector_metadata,
network_txn_id: None,
connector_response_reference_id: item.response.invoice_number.clone(),
incremental_authorization_allowed: None,
mandate_reference: None,
status_code: item.http_code,
}),
resource_common_data: PaymentFlowData {
status,
..item.router_data.resource_common_data
},
..item.router_data
})
}
}
impl<F> TryFrom<ResponseRouterData<HelcimPaymentsResponse, Self>>
for RouterDataV2<F, PaymentFlowData, PaymentsSyncData, PaymentsResponseData>
{
type Error = error_stack::Report<ConnectorError>;
fn try_from(
item: ResponseRouterData<HelcimPaymentsResponse, Self>,
) -> Result<Self, Self::Error> {
match item.router_data.request.sync_type {
SyncRequestType::SinglePaymentSync => {
let status = common_enums::AttemptStatus::from(item.response.clone());
Ok(Self {
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(
item.response.transaction_id.to_string(),
),
redirection_data: None,
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: item.response.invoice_number.clone(),
incremental_authorization_allowed: None,
mandate_reference: None,
status_code: item.http_code,
}),
resource_common_data: PaymentFlowData {
status,
..item.router_data.resource_common_data
},
..item.router_data
})
}
SyncRequestType::MultipleCaptureSync(_) => {
Err(errors::ConnectorError::NotImplemented(
"manual multiple capture sync".to_string(),
)
.into())
// let capture_sync_response_list =
// utils::construct_captures_response_hashmap(vec![item.response]);
// Ok(Self {
// response: Ok(PaymentsResponseData::MultipleCaptureResponse {
// capture_sync_response_list,
| {
"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_814751693867000820_3 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/helcim/transformers.rs
// }),
// ..item.router_data
// })
}
}
}
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct HelcimCaptureRequest {
pre_auth_transaction_id: u64,
amount: FloatMajorUnit,
ip_address: Secret<String, pii::IpAddress>,
#[serde(skip_serializing_if = "Option::is_none")]
ecommerce: Option<bool>,
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
TryFrom<
HelcimRouterData<
RouterDataV2<Capture, PaymentFlowData, PaymentsCaptureData, PaymentsResponseData>,
T,
>,
> for HelcimCaptureRequest
{
type Error = error_stack::Report<ConnectorError>;
fn try_from(
item: HelcimRouterData<
RouterDataV2<Capture, PaymentFlowData, PaymentsCaptureData, PaymentsResponseData>,
T,
>,
) -> Result<Self, Self::Error> {
let ip_address = item.router_data.request.get_ip_address()?;
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)?;
Ok(Self {
pre_auth_transaction_id: item
.router_data
.request
.get_connector_transaction_id()?
.parse::<u64>()
.change_context(errors::ConnectorError::RequestEncodingFailed)?,
amount,
ip_address,
ecommerce: None,
})
}
}
impl<F> TryFrom<ResponseRouterData<HelcimPaymentsResponse, Self>>
for RouterDataV2<F, PaymentFlowData, PaymentsCaptureData, PaymentsResponseData>
{
type Error = error_stack::Report<ConnectorError>;
fn try_from(
item: ResponseRouterData<HelcimPaymentsResponse, Self>,
) -> Result<Self, Self::Error> {
let status = common_enums::AttemptStatus::from(item.response.clone());
Ok(Self {
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(
item.response.transaction_id.to_string(),
),
redirection_data: None,
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: item.response.invoice_number.clone(),
incremental_authorization_allowed: None,
mandate_reference: None,
status_code: item.http_code,
}),
resource_common_data: PaymentFlowData {
status,
..item.router_data.resource_common_data
},
..item.router_data
})
}
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct HelcimVoidRequest {
card_transaction_id: u64,
ip_address: Secret<String, pii::IpAddress>,
#[serde(skip_serializing_if = "Option::is_none")]
ecommerce: Option<bool>,
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
TryFrom<
HelcimRouterData<
RouterDataV2<Void, PaymentFlowData, PaymentVoidData, PaymentsResponseData>,
T,
>,
> for HelcimVoidRequest
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: HelcimRouterData<
RouterDataV2<Void, PaymentFlowData, PaymentVoidData, PaymentsResponseData>,
T,
>,
) -> Result<Self, Self::Error> {
let ip_address = item.router_data.request.get_ip_address()?;
Ok(Self {
card_transaction_id: item
.router_data
.request
.connector_transaction_id
.parse::<u64>()
.change_context(errors::ConnectorError::RequestEncodingFailed)?,
ip_address,
ecommerce: None,
})
}
}
// Old void implementation removed - using the updated one above
| {
"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_814751693867000820_4 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/helcim/transformers.rs
impl<F> TryFrom<ResponseRouterData<HelcimPaymentsResponse, Self>>
for RouterDataV2<F, PaymentFlowData, PaymentVoidData, PaymentsResponseData>
{
type Error = error_stack::Report<ConnectorError>;
fn try_from(
item: ResponseRouterData<HelcimPaymentsResponse, Self>,
) -> Result<Self, Self::Error> {
let status = common_enums::AttemptStatus::from(item.response.clone());
Ok(Self {
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(
item.response.transaction_id.to_string(),
),
redirection_data: None,
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: item.response.invoice_number.clone(),
incremental_authorization_allowed: None,
mandate_reference: None,
status_code: item.http_code,
}),
resource_common_data: PaymentFlowData {
status,
..item.router_data.resource_common_data
},
..item.router_data
})
}
}
// SetupMandate Request
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct HelcimSetupMandateRequest<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> {
amount: FloatMajorUnit,
currency: common_enums::Currency,
ip_address: Secret<String, pii::IpAddress>,
card_data: HelcimCard<T>,
invoice: HelcimInvoice,
billing_address: HelcimBillingAddress,
#[serde(skip_serializing_if = "Option::is_none")]
ecommerce: Option<bool>,
}
// SetupMandate TryFrom implementation
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
TryFrom<
HelcimRouterData<
RouterDataV2<
SetupMandate,
PaymentFlowData,
SetupMandateRequestData<T>,
PaymentsResponseData,
>,
T,
>,
> for HelcimSetupMandateRequest<T>
{
type Error = error_stack::Report<ConnectorError>;
fn try_from(
item: HelcimRouterData<
RouterDataV2<
SetupMandate,
PaymentFlowData,
SetupMandateRequestData<T>,
PaymentsResponseData,
>,
T,
>,
) -> Result<Self, Self::Error> {
let card_data = match &item.router_data.request.payment_method_data {
PaymentMethodData::Card(card) => HelcimCard {
card_expiry: card
.get_card_expiry_month_year_2_digit_with_delimiter("".to_string())?,
card_number: card.card_number.clone(),
card_c_v_v: card.card_cvc.clone(),
},
_ => return Err(ConnectorError::NotImplemented("payment method".into()).into()),
};
let req_address = item
.router_data
.resource_common_data
.get_billing_address()?;
let billing_address = HelcimBillingAddress {
name: req_address.get_full_name()?,
street1: req_address.get_line1()?.to_owned(),
postal_code: req_address.get_zip()?.to_owned(),
street2: req_address.line2.clone(),
city: req_address.city.clone(),
email: item.router_data.request.email.clone(),
};
let ip_address = item.router_data.request.get_ip_address()?;
let amount = item
.connector
.amount_converter
.convert(
item.router_data
.request
.minor_amount
.unwrap_or(common_utils::types::MinorUnit::new(0)),
item.router_data.request.currency,
)
.change_context(errors::ConnectorError::AmountConversionFailed)?;
let line_items = vec![HelcimLineItems {
description: item
.router_data
.resource_common_data
.description
.clone()
.unwrap_or("Setup Mandate".to_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_814751693867000820_5 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/helcim/transformers.rs
quantity: 1,
price: amount,
total: amount,
}];
let invoice = HelcimInvoice {
invoice_number: item
.router_data
.resource_common_data
.connector_request_reference_id
.clone(),
line_items,
};
let currency = check_currency(item.router_data.request.currency)?;
Ok(Self {
amount,
currency,
ip_address,
card_data,
invoice,
billing_address,
ecommerce: None,
})
}
}
// SetupMandate Response implementation
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
TryFrom<
ResponseRouterData<
HelcimPaymentsResponse,
RouterDataV2<
SetupMandate,
PaymentFlowData,
SetupMandateRequestData<T>,
PaymentsResponseData,
>,
>,
>
for RouterDataV2<
SetupMandate,
PaymentFlowData,
SetupMandateRequestData<T>,
PaymentsResponseData,
>
{
type Error = error_stack::Report<ConnectorError>;
fn try_from(
item: ResponseRouterData<
HelcimPaymentsResponse,
RouterDataV2<
SetupMandate,
PaymentFlowData,
SetupMandateRequestData<T>,
PaymentsResponseData,
>,
>,
) -> Result<Self, Self::Error> {
let status = common_enums::AttemptStatus::from(item.response.clone());
let mandate_reference = MandateReference {
connector_mandate_id: Some(item.response.transaction_id.to_string()),
payment_method_id: None,
};
Ok(Self {
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(
item.response.transaction_id.to_string(),
),
redirection_data: None,
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: item.response.invoice_number.clone(),
incremental_authorization_allowed: None,
mandate_reference: Some(Box::new(mandate_reference)),
status_code: item.http_code,
}),
resource_common_data: PaymentFlowData {
status,
..item.router_data.resource_common_data
},
..item.router_data
})
}
}
// REFUND:
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct HelcimRefundRequest {
amount: FloatMajorUnit,
original_transaction_id: u64,
ip_address: Secret<String, pii::IpAddress>,
#[serde(skip_serializing_if = "Option::is_none")]
ecommerce: Option<bool>,
}
impl<
F,
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
TryFrom<HelcimRouterData<RouterDataV2<F, RefundFlowData, RefundsData, RefundsResponseData>, T>>
for HelcimRefundRequest
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: HelcimRouterData<
RouterDataV2<F, RefundFlowData, RefundsData, RefundsResponseData>,
T,
>,
) -> Result<Self, Self::Error> {
let original_transaction_id = item
.router_data
.request
.connector_transaction_id
.parse::<u64>()
.change_context(errors::ConnectorError::RequestEncodingFailed)?;
let ip_address = item.router_data.request.get_ip_address()?;
let amount = item
.connector
.amount_converter
.convert(
item.router_data.request.minor_refund_amount,
item.router_data.request.currency,
)
.change_context(errors::ConnectorError::AmountConversionFailed)?;
Ok(Self {
amount,
original_transaction_id,
ip_address,
ecommerce: None,
})
}
}
// Old implementation removed - using the updated one above
| {
"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_814751693867000820_6 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/helcim/transformers.rs
#[derive(Debug, Deserialize, Serialize)]
#[serde(rename_all = "lowercase")]
pub enum HelcimRefundTransactionType {
Refund,
}
#[derive(Debug, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct RefundResponse {
status: HelcimPaymentStatus,
transaction_id: u64,
#[serde(rename = "type")]
transaction_type: HelcimRefundTransactionType,
}
impl From<RefundResponse> for common_enums::RefundStatus {
fn from(item: RefundResponse) -> Self {
match item.transaction_type {
HelcimRefundTransactionType::Refund => match item.status {
HelcimPaymentStatus::Approved => Self::Success,
HelcimPaymentStatus::Declined => Self::Failure,
},
}
}
}
impl<F> TryFrom<ResponseRouterData<RefundResponse, Self>>
for RouterDataV2<F, RefundFlowData, RefundsData, RefundsResponseData>
{
type Error = error_stack::Report<ConnectorError>;
fn try_from(item: ResponseRouterData<RefundResponse, Self>) -> Result<Self, Self::Error> {
Ok(Self {
response: Ok(RefundsResponseData {
connector_refund_id: item.response.transaction_id.to_string(),
refund_status: common_enums::RefundStatus::from(item.response),
status_code: item.http_code,
}),
..item.router_data
})
}
}
impl<F> TryFrom<ResponseRouterData<RefundResponse, Self>>
for RouterDataV2<F, RefundFlowData, RefundSyncData, RefundsResponseData>
{
type Error = error_stack::Report<ConnectorError>;
fn try_from(item: ResponseRouterData<RefundResponse, Self>) -> Result<Self, Self::Error> {
Ok(Self {
response: Ok(RefundsResponseData {
connector_refund_id: item.response.transaction_id.to_string(),
refund_status: common_enums::RefundStatus::from(item.response),
status_code: item.http_code,
}),
..item.router_data
})
}
}
#[derive(Debug, strum::Display, Deserialize, Serialize)]
#[serde(untagged)]
pub enum HelcimErrorTypes {
StringType(String),
JsonType(serde_json::Value),
}
#[derive(Debug, Deserialize, Serialize)]
pub struct HelcimPaymentsErrorResponse {
pub errors: HelcimErrorTypes,
}
#[derive(Debug, Deserialize, Serialize)]
#[serde(untagged)]
pub enum HelcimErrorResponse {
Payment(HelcimPaymentsErrorResponse),
General(String),
}
// Type aliases for different flow responses to avoid duplicate struct generation
pub type HelcimPaymentsSyncResponse = HelcimPaymentsResponse;
pub type HelcimPaymentsCaptureResponse = HelcimPaymentsResponse;
pub type HelcimPaymentsVoidResponse = HelcimPaymentsResponse;
pub type RefundSyncResponse = RefundResponse;
| {
"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_-5184931324552524607_0 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/braintree/transformers.rs
use common_enums::enums;
use common_utils::{
consts::{NO_ERROR_CODE, NO_ERROR_MESSAGE},
pii,
types::{MinorUnit, StringMajorUnit},
};
use domain_types::{
connector_flow::{Authorize, Capture, PSync, PaymentMethodToken, RSync, Void},
connector_types::{
MandateReference, PaymentFlowData, PaymentMethodTokenResponse,
PaymentMethodTokenizationData, PaymentVoidData, PaymentsAuthorizeData, PaymentsCaptureData,
PaymentsResponseData, PaymentsSyncData, RefundFlowData, RefundSyncData, RefundsData,
RefundsResponseData, ResponseId,
},
errors::{self, ConnectorError},
payment_method_data::{PaymentMethodData, PaymentMethodDataTypes, RawCardNumber},
router_data::{ConnectorAuthType, PaymentMethodToken as PaymentMethodTokenFlow},
router_data_v2::RouterDataV2,
router_response_types::RedirectForm,
};
use error_stack::ResultExt;
use hyperswitch_masking::{ExposeInterface, Secret};
use serde::{Deserialize, Serialize};
use time::PrimitiveDateTime;
use crate::{
connectors::braintree::BraintreeRouterData, types::ResponseRouterData,
unimplemented_payment_method, utils,
};
pub mod constants {
pub const CHANNEL_CODE: &str = "HyperSwitchBT_Ecom";
pub const CLIENT_TOKEN_MUTATION: &str = "mutation createClientToken($input: CreateClientTokenInput!) { createClientToken(input: $input) { clientToken}}";
pub const TOKENIZE_CREDIT_CARD: &str = "mutation tokenizeCreditCard($input: TokenizeCreditCardInput!) { tokenizeCreditCard(input: $input) { clientMutationId paymentMethod { id } } }";
pub const CHARGE_CREDIT_CARD_MUTATION: &str = "mutation ChargeCreditCard($input: ChargeCreditCardInput!) { chargeCreditCard(input: $input) { transaction { id legacyId createdAt amount { value currencyCode } status } } }";
pub const AUTHORIZE_CREDIT_CARD_MUTATION: &str = "mutation authorizeCreditCard($input: AuthorizeCreditCardInput!) { authorizeCreditCard(input: $input) { transaction { id legacyId amount { value currencyCode } status } } }";
pub const CAPTURE_TRANSACTION_MUTATION: &str = "mutation captureTransaction($input: CaptureTransactionInput!) { captureTransaction(input: $input) { clientMutationId transaction { id legacyId amount { value currencyCode } status } } }";
pub const VOID_TRANSACTION_MUTATION: &str = "mutation voidTransaction($input: ReverseTransactionInput!) { reverseTransaction(input: $input) { clientMutationId reversal { ... on Transaction { id legacyId amount { value currencyCode } status } } } }";
pub const REFUND_TRANSACTION_MUTATION: &str = "mutation refundTransaction($input: RefundTransactionInput!) { refundTransaction(input: $input) {clientMutationId refund { id legacyId amount { value currencyCode } status } } }";
pub const AUTHORIZE_AND_VAULT_CREDIT_CARD_MUTATION: &str="mutation authorizeCreditCard($input: AuthorizeCreditCardInput!) { authorizeCreditCard(input: $input) { transaction { id status createdAt paymentMethod { id } } } }";
pub const CHARGE_AND_VAULT_TRANSACTION_MUTATION: &str ="mutation ChargeCreditCard($input: ChargeCreditCardInput!) { chargeCreditCard(input: $input) { transaction { id status createdAt paymentMethod { id } } } }";
pub const DELETE_PAYMENT_METHOD_FROM_VAULT_MUTATION: &str = "mutation deletePaymentMethodFromVault($input: DeletePaymentMethodFromVaultInput!) { deletePaymentMethodFromVault(input: $input) { clientMutationId } }";
pub const TRANSACTION_QUERY: &str = "query($input: TransactionSearchInput!) { search { transactions(input: $input) { edges { node { id status } } } } }";
pub const REFUND_QUERY: &str = "query($input: RefundSearchInput!) { search { refunds(input: $input, first: 1) { edges { node { id status createdAt amount { value currencyCode } orderId } } } } }";
}
pub type CardPaymentRequest = GenericBraintreeRequest<VariablePaymentInput>;
pub type MandatePaymentRequest = GenericBraintreeRequest<VariablePaymentInput>;
pub type BraintreeClientTokenRequest = GenericBraintreeRequest<VariableClientTokenInput>;
pub type BraintreeTokenRequest<T> = GenericBraintreeRequest<VariableInput<T>>;
pub type BraintreeCaptureRequest = GenericBraintreeRequest<VariableCaptureInput>;
| {
"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_-5184931324552524607_1 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/braintree/transformers.rs
pub type BraintreeRefundRequest = GenericBraintreeRequest<BraintreeRefundVariables>;
pub type BraintreePSyncRequest = GenericBraintreeRequest<PSyncInput>;
pub type BraintreeRSyncRequest = GenericBraintreeRequest<RSyncInput>;
pub type BraintreeRefundResponse = GenericBraintreeResponse<RefundResponse>;
pub type BraintreeCaptureResponse = GenericBraintreeResponse<CaptureResponse>;
pub type BraintreePSyncResponse = GenericBraintreeResponse<PSyncResponse>;
pub type VariablePaymentInput = GenericVariableInput<PaymentInput>;
pub type VariableClientTokenInput = GenericVariableInput<InputClientTokenData>;
pub type VariableInput<T> = GenericVariableInput<InputData<T>>;
pub type VariableCaptureInput = GenericVariableInput<CaptureInputData>;
pub type BraintreeRefundVariables = GenericVariableInput<BraintreeRefundInput>;
pub type PSyncInput = GenericVariableInput<TransactionSearchInput>;
pub type RSyncInput = GenericVariableInput<RefundSearchInput>;
#[derive(Debug, Clone, Serialize)]
pub struct GenericBraintreeRequest<T> {
query: String,
variables: T,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(untagged)]
pub enum GenericBraintreeResponse<T> {
SuccessResponse(Box<T>),
ErrorResponse(Box<ErrorResponse>),
}
#[derive(Debug, Clone, Serialize)]
pub struct GenericVariableInput<T> {
input: T,
}
#[derive(Debug, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct BraintreeApiErrorResponse {
pub api_error_response: ApiErrorResponse,
}
#[derive(Debug, Deserialize, Serialize)]
pub struct ErrorsObject {
pub errors: Vec<ErrorObject>,
pub transaction: Option<TransactionError>,
}
#[derive(Debug, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct TransactionError {
pub errors: Vec<ErrorObject>,
pub credit_card: Option<CreditCardError>,
}
#[derive(Debug, Deserialize, Serialize)]
pub struct CreditCardError {
pub errors: Vec<ErrorObject>,
}
#[derive(Debug, Deserialize, Serialize)]
pub struct ErrorObject {
pub code: String,
pub message: String,
}
#[derive(Debug, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct BraintreeErrorResponse {
pub errors: String,
}
#[derive(Debug, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
#[serde(untagged)]
pub enum ErrorResponses {
BraintreeApiErrorResponse(Box<BraintreeApiErrorResponse>),
BraintreeErrorResponse(Box<BraintreeErrorResponse>),
}
#[derive(Debug, Deserialize, Serialize)]
pub struct ApiErrorResponse {
pub message: String,
pub errors: ErrorsObject,
}
pub struct BraintreeAuthType {
pub(super) public_key: Secret<String>,
pub(super) private_key: Secret<String>,
}
impl TryFrom<&ConnectorAuthType> for BraintreeAuthType {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(item: &ConnectorAuthType) -> Result<Self, Self::Error> {
if let ConnectorAuthType::SignatureKey {
api_key,
api_secret,
key1: _merchant_id,
} = item
{
Ok(Self {
public_key: api_key.to_owned(),
private_key: api_secret.to_owned(),
})
} else {
Err(errors::ConnectorError::FailedToObtainAuthType)?
}
}
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct PaymentInput {
payment_method_id: Secret<String>,
transaction: TransactionBody,
}
#[derive(Debug, Serialize)]
#[serde(untagged)]
pub enum BraintreePaymentsRequest {
Card(CardPaymentRequest),
CardThreeDs(BraintreeClientTokenRequest),
Mandate(MandatePaymentRequest),
}
#[derive(Debug, Deserialize)]
pub struct BraintreeMeta {
merchant_account_id: Secret<String>,
merchant_config_currency: enums::Currency,
}
impl TryFrom<&Option<pii::SecretSerdeValue>> for BraintreeMeta {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(meta_data: &Option<pii::SecretSerdeValue>) -> Result<Self, Self::Error> {
let metadata: Self = utils::to_connector_meta_from_secret::<Self>(meta_data.clone())
.change_context(errors::ConnectorError::InvalidConnectorConfig {
config: "metadata",
})?;
Ok(metadata)
}
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct CustomerBody {
email: pii::Email,
}
#[derive(Debug, Serialize)]
| {
"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_-5184931324552524607_2 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/braintree/transformers.rs
#[serde(rename_all = "camelCase")]
pub struct RegularTransactionBody {
amount: StringMajorUnit,
merchant_account_id: Secret<String>,
channel: String,
#[serde(skip_serializing_if = "Option::is_none")]
customer_details: Option<CustomerBody>,
order_id: String,
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct VaultTransactionBody {
amount: StringMajorUnit,
merchant_account_id: Secret<String>,
vault_payment_method_after_transacting: TransactionTiming,
#[serde(skip_serializing_if = "Option::is_none")]
customer_details: Option<CustomerBody>,
order_id: String,
}
#[derive(Debug, Serialize)]
#[serde(untagged)]
pub enum TransactionBody {
Regular(RegularTransactionBody),
Vault(VaultTransactionBody),
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct TransactionTiming {
when: String,
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
TryFrom<(
BraintreeRouterData<
RouterDataV2<
Authorize,
PaymentFlowData,
PaymentsAuthorizeData<T>,
PaymentsResponseData,
>,
T,
>,
String,
BraintreeMeta,
)> for MandatePaymentRequest
{
type Error = error_stack::Report<ConnectorError>;
fn try_from(
(item, connector_mandate_id, metadata): (
BraintreeRouterData<
RouterDataV2<
Authorize,
PaymentFlowData,
PaymentsAuthorizeData<T>,
PaymentsResponseData,
>,
T,
>,
String,
BraintreeMeta,
),
) -> Result<Self, Self::Error> {
let reference_id = Some(
item.router_data
.resource_common_data
.connector_request_reference_id
.clone(),
);
let order_id = reference_id.ok_or(
errors::ConnectorError::MissingConnectorRelatedTransactionID {
id: "order_id".to_string(),
},
)?;
let amount = item
.connector
.amount_converter
.convert(
item.router_data.request.minor_amount,
item.router_data.request.currency,
)
.change_context(ConnectorError::AmountConversionFailed)?;
let (query, transaction_body) = (
if item.router_data.request.is_auto_capture()? {
constants::CHARGE_CREDIT_CARD_MUTATION.to_string()
} else {
constants::AUTHORIZE_CREDIT_CARD_MUTATION.to_string()
},
TransactionBody::Regular(RegularTransactionBody {
amount,
merchant_account_id: metadata.merchant_account_id,
channel: constants::CHANNEL_CODE.to_string(),
customer_details: None,
order_id,
}),
);
Ok(Self {
query,
variables: VariablePaymentInput {
input: PaymentInput {
payment_method_id: connector_mandate_id.into(),
transaction: transaction_body,
},
},
})
}
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
TryFrom<
BraintreeRouterData<
RouterDataV2<
Authorize,
PaymentFlowData,
PaymentsAuthorizeData<T>,
PaymentsResponseData,
>,
T,
>,
> for BraintreePaymentsRequest
{
type Error = error_stack::Report<ConnectorError>;
fn try_from(
item: BraintreeRouterData<
RouterDataV2<
Authorize,
PaymentFlowData,
PaymentsAuthorizeData<T>,
PaymentsResponseData,
>,
T,
>,
) -> Result<Self, Self::Error> {
let metadata: BraintreeMeta = if let (
Some(merchant_account_id),
Some(merchant_config_currency),
) = (
| {
"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_-5184931324552524607_3 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/braintree/transformers.rs
item.router_data.request.merchant_account_id.clone(),
item.router_data.request.merchant_config_currency,
) {
BraintreeMeta {
merchant_account_id: merchant_account_id.into(),
merchant_config_currency,
}
} else {
utils::to_connector_meta_from_secret(
item.router_data
.resource_common_data
.connector_meta_data
.clone(),
)
.change_context(errors::ConnectorError::InvalidConnectorConfig { config: "metadata" })?
};
validate_currency(
item.router_data.request.currency,
Some(metadata.merchant_config_currency),
)?;
match item.router_data.request.payment_method_data.clone() {
PaymentMethodData::Card(_) => {
if item.router_data.resource_common_data.is_three_ds() {
Ok(Self::CardThreeDs(BraintreeClientTokenRequest::try_from(
metadata,
)?))
} else {
Ok(Self::Card(CardPaymentRequest::try_from((item, metadata))?))
}
}
PaymentMethodData::MandatePayment => {
let connector_mandate_id = item.router_data.request.connector_mandate_id().ok_or(
errors::ConnectorError::MissingRequiredField {
field_name: "connector_mandate_id",
},
)?;
Ok(Self::Mandate(MandatePaymentRequest::try_from((
item,
connector_mandate_id,
metadata,
))?))
}
PaymentMethodData::CardRedirect(_)
| PaymentMethodData::Wallet(_)
| PaymentMethodData::PayLater(_)
| PaymentMethodData::BankRedirect(_)
| PaymentMethodData::BankDebit(_)
| PaymentMethodData::BankTransfer(_)
| PaymentMethodData::Crypto(_)
| PaymentMethodData::Reward
| PaymentMethodData::RealTimePayment(_)
| PaymentMethodData::MobilePayment(_)
| PaymentMethodData::Upi(_)
| PaymentMethodData::Voucher(_)
| PaymentMethodData::GiftCard(_)
| PaymentMethodData::OpenBanking(_)
| PaymentMethodData::CardToken(_)
| PaymentMethodData::NetworkToken(_)
| PaymentMethodData::CardDetailsForNetworkTransactionId(_) => {
Err(errors::ConnectorError::NotImplemented(
utils::get_unimplemented_payment_method_error_message("braintree"),
)
.into())
}
}
}
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct AuthResponse {
data: DataAuthResponse,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(untagged)]
pub enum BraintreeAuthResponse {
AuthResponse(Box<AuthResponse>),
ClientTokenResponse(Box<ClientTokenResponse>),
ErrorResponse(Box<ErrorResponse>),
}
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(untagged)]
pub enum BraintreeCompleteAuthResponse {
AuthResponse(Box<AuthResponse>),
ErrorResponse(Box<ErrorResponse>),
}
#[derive(Debug, Clone, Deserialize, Serialize)]
struct PaymentMethodInfo {
id: Secret<String>,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct TransactionAuthChargeResponseBody {
id: String,
status: BraintreePaymentStatus,
payment_method: Option<PaymentMethodInfo>,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct DataAuthResponse {
authorize_credit_card: AuthChargeCreditCard,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct AuthChargeCreditCard {
transaction: TransactionAuthChargeResponseBody,
}
impl<
F,
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> TryFrom<ResponseRouterData<BraintreeAuthResponse, Self>>
for RouterDataV2<F, PaymentFlowData, PaymentsAuthorizeData<T>, PaymentsResponseData>
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
| {
"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_-5184931324552524607_4 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/braintree/transformers.rs
item: ResponseRouterData<BraintreeAuthResponse, Self>,
) -> Result<Self, Self::Error> {
match item.response {
BraintreeAuthResponse::ErrorResponse(error_response) => Ok(Self {
response: build_error_response(&error_response.errors, item.http_code)
.map_err(|err| *err),
..item.router_data
}),
BraintreeAuthResponse::AuthResponse(auth_response) => {
let transaction_data = auth_response.data.authorize_credit_card.transaction;
let status = enums::AttemptStatus::from(transaction_data.status.clone());
let response = if domain_types::utils::is_payment_failure(status) {
Err(create_failure_error_response(
transaction_data.status,
Some(transaction_data.id),
item.http_code,
))
} else {
Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(transaction_data.id),
redirection_data: None,
mandate_reference: transaction_data.payment_method.as_ref().map(|pm| {
Box::new(MandateReference {
connector_mandate_id: Some(pm.id.clone().expose()),
payment_method_id: 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
})
}
BraintreeAuthResponse::ClientTokenResponse(client_token_data) => Ok(Self {
resource_common_data: PaymentFlowData {
status: enums::AttemptStatus::AuthenticationPending,
..item.router_data.resource_common_data.clone()
},
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::NoResponseId,
redirection_data: Some(Box::new(get_braintree_redirect_form(
*client_token_data,
item.router_data
.resource_common_data
.get_payment_method_token()?,
item.router_data.request.payment_method_data.clone(),
item.router_data.request.get_complete_authorize_url()?,
)?)),
mandate_reference: None,
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: None,
incremental_authorization_allowed: None,
status_code: item.http_code,
}),
..item.router_data
}),
}
}
}
fn build_error_response<T>(
response: &[ErrorDetails],
http_code: u16,
) -> Result<T, Box<domain_types::router_data::ErrorResponse>> {
let error_messages = response
.iter()
.map(|error| error.message.to_string())
.collect::<Vec<String>>();
let reason = match !error_messages.is_empty() {
true => Some(error_messages.join(" ")),
false => None,
};
get_error_response(
response
.first()
.and_then(|err_details| err_details.extensions.as_ref())
.and_then(|extensions| extensions.legacy_code.clone()),
response
.first()
.map(|err_details| err_details.message.clone()),
reason,
http_code,
)
}
fn get_error_response<T>(
error_code: Option<String>,
error_msg: Option<String>,
error_reason: Option<String>,
http_code: u16,
| {
"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_-5184931324552524607_5 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/braintree/transformers.rs
) -> Result<T, Box<domain_types::router_data::ErrorResponse>> {
Err(Box::new(domain_types::router_data::ErrorResponse {
code: error_code.unwrap_or_else(|| NO_ERROR_CODE.to_string()),
message: error_msg.unwrap_or_else(|| NO_ERROR_MESSAGE.to_string()),
reason: error_reason,
status_code: http_code,
attempt_status: None,
connector_transaction_id: None,
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
}))
}
fn create_failure_error_response<T: ToString>(
status: T,
connector_id: Option<String>,
http_code: u16,
) -> domain_types::router_data::ErrorResponse {
let status_string = status.to_string();
domain_types::router_data::ErrorResponse {
code: status_string.clone(),
message: status_string.clone(),
reason: Some(status_string),
attempt_status: None,
connector_transaction_id: connector_id,
status_code: http_code,
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
}
}
#[derive(Debug, Clone, Deserialize, Serialize, strum::Display)]
#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
pub enum BraintreePaymentStatus {
Authorized,
Authorizing,
AuthorizedExpired,
Failed,
ProcessorDeclined,
GatewayRejected,
Voided,
Settling,
Settled,
SettlementPending,
SettlementDeclined,
SettlementConfirmed,
SubmittedForSettlement,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct ErrorDetails {
pub message: String,
pub extensions: Option<AdditionalErrorDetails>,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct AdditionalErrorDetails {
pub legacy_code: Option<String>,
}
impl From<BraintreePaymentStatus> for enums::AttemptStatus {
fn from(item: BraintreePaymentStatus) -> Self {
match item {
BraintreePaymentStatus::Settling
| BraintreePaymentStatus::Settled
| BraintreePaymentStatus::SettlementConfirmed
| BraintreePaymentStatus::SubmittedForSettlement
| BraintreePaymentStatus::SettlementPending => Self::Charged,
BraintreePaymentStatus::Authorizing => Self::Authorizing,
BraintreePaymentStatus::AuthorizedExpired => Self::AuthorizationFailed,
BraintreePaymentStatus::Failed
| BraintreePaymentStatus::GatewayRejected
| BraintreePaymentStatus::ProcessorDeclined
| BraintreePaymentStatus::SettlementDeclined => Self::Failure,
BraintreePaymentStatus::Authorized => Self::Authorized,
BraintreePaymentStatus::Voided => Self::Voided,
}
}
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
TryFrom<
ResponseRouterData<
BraintreePaymentsResponse,
RouterDataV2<
Authorize,
PaymentFlowData,
PaymentsAuthorizeData<T>,
PaymentsResponseData,
>,
>,
> for RouterDataV2<Authorize, PaymentFlowData, PaymentsAuthorizeData<T>, PaymentsResponseData>
{
type Error = error_stack::Report<ConnectorError>;
fn try_from(
item: ResponseRouterData<
BraintreePaymentsResponse,
RouterDataV2<
Authorize,
PaymentFlowData,
PaymentsAuthorizeData<T>,
PaymentsResponseData,
>,
>,
) -> Result<Self, Self::Error> {
match item.response {
BraintreePaymentsResponse::ErrorResponse(error_response) => Ok(Self {
response: build_error_response(&error_response.errors.clone(), item.http_code)
.map_err(|err| *err),
..item.router_data
}),
BraintreePaymentsResponse::PaymentsResponse(payment_response) => {
let transaction_data = payment_response.data.charge_credit_card.transaction;
let status = enums::AttemptStatus::from(transaction_data.status.clone());
let response = if domain_types::utils::is_payment_failure(status) {
Err(create_failure_error_response(
| {
"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_-5184931324552524607_6 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/braintree/transformers.rs
transaction_data.status,
Some(transaction_data.id),
item.http_code,
))
} else {
Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(transaction_data.id),
redirection_data: None,
mandate_reference: transaction_data.payment_method.as_ref().map(|pm| {
Box::new(MandateReference {
connector_mandate_id: Some(pm.id.clone().expose()),
payment_method_id: 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
})
}
BraintreePaymentsResponse::AuthResponse(auth_response) => {
let transaction_data = auth_response.data.authorize_credit_card.transaction;
let status = enums::AttemptStatus::from(transaction_data.status.clone());
let response = if domain_types::utils::is_payment_failure(status) {
Err(create_failure_error_response(
transaction_data.status,
Some(transaction_data.id),
item.http_code,
))
} else {
Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(transaction_data.id),
redirection_data: None,
mandate_reference: transaction_data.payment_method.as_ref().map(|pm| {
Box::new(MandateReference {
connector_mandate_id: Some(pm.id.clone().expose()),
payment_method_id: 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
})
}
BraintreePaymentsResponse::ClientTokenResponse(client_token_data) => Ok(Self {
resource_common_data: PaymentFlowData {
status: enums::AttemptStatus::AuthenticationPending,
..item.router_data.resource_common_data.clone()
},
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::NoResponseId,
redirection_data: Some(Box::new(get_braintree_redirect_form(
*client_token_data,
item.router_data
.resource_common_data
.get_payment_method_token()?,
item.router_data.request.payment_method_data.clone(),
item.router_data.request.get_complete_authorize_url()?,
)?)),
mandate_reference: None,
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: None,
incremental_authorization_allowed: None,
| {
"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_-5184931324552524607_7 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/braintree/transformers.rs
status_code: item.http_code,
}),
..item.router_data
}),
}
}
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct PaymentsResponse {
data: DataResponse,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(untagged)]
pub enum BraintreePaymentsResponse {
PaymentsResponse(Box<PaymentsResponse>),
AuthResponse(Box<AuthResponse>),
ClientTokenResponse(Box<ClientTokenResponse>),
ErrorResponse(Box<ErrorResponse>),
}
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(untagged)]
pub enum BraintreeCompleteChargeResponse {
PaymentsResponse(Box<PaymentsResponse>),
ErrorResponse(Box<ErrorResponse>),
}
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct DataResponse {
charge_credit_card: AuthChargeCreditCard,
}
#[derive(Debug, Clone, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct RefundInputData {
amount: StringMajorUnit,
merchant_account_id: Secret<String>,
#[serde(skip_serializing_if = "Option::is_none")]
order_id: Option<String>,
}
#[derive(Serialize, Debug, Clone)]
struct IdFilter {
is: String,
}
#[derive(Debug, Clone, Serialize)]
pub struct TransactionSearchInput {
id: IdFilter,
}
#[derive(Debug, Clone, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct BraintreeRefundInput {
transaction_id: String,
refund: RefundInputData,
}
impl<
F,
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
TryFrom<
BraintreeRouterData<RouterDataV2<F, RefundFlowData, RefundsData, RefundsResponseData>, T>,
> for BraintreeRefundRequest
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: BraintreeRouterData<
RouterDataV2<F, RefundFlowData, RefundsData, RefundsResponseData>,
T,
>,
) -> Result<Self, Self::Error> {
let metadata: BraintreeMeta = if let (Some(merchant_account_id), merchant_config_currency) = (
item.router_data.request.merchant_account_id.clone(),
item.router_data.request.currency,
) {
BraintreeMeta {
merchant_account_id: merchant_account_id.into(),
merchant_config_currency,
}
} else {
utils::to_connector_meta_from_secret(
item.router_data
.request
.connector_metadata
.clone()
.map(Secret::new),
)
.change_context(errors::ConnectorError::InvalidConnectorConfig { config: "metadata" })?
};
validate_currency(
item.router_data.request.currency,
Some(metadata.merchant_config_currency),
)?;
let query = constants::REFUND_TRANSACTION_MUTATION.to_string();
let amount = item
.connector
.amount_converter
.convert(
item.router_data.request.minor_refund_amount,
item.router_data.request.currency,
)
.change_context(ConnectorError::AmountConversionFailed)?;
let variables = BraintreeRefundVariables {
input: BraintreeRefundInput {
transaction_id: item.router_data.request.connector_transaction_id.clone(),
refund: RefundInputData {
amount,
merchant_account_id: metadata.merchant_account_id,
order_id: Some(item.router_data.request.refund_id),
},
},
};
Ok(Self { query, variables })
}
}
#[derive(Debug, Clone, Deserialize, Serialize, strum::Display)]
#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
pub enum BraintreeRefundStatus {
SettlementPending,
Settling,
Settled,
SubmittedForSettlement,
Failed,
}
impl From<BraintreeRefundStatus> for enums::RefundStatus {
fn from(item: BraintreeRefundStatus) -> Self {
match item {
BraintreeRefundStatus::Settled
| BraintreeRefundStatus::Settling
| BraintreeRefundStatus::SubmittedForSettlement
| BraintreeRefundStatus::SettlementPending => Self::Success,
| {
"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_-5184931324552524607_8 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/braintree/transformers.rs
BraintreeRefundStatus::Failed => Self::Failure,
}
}
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct BraintreeRefundTransactionBody {
pub id: String,
pub status: BraintreeRefundStatus,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct BraintreeRefundTransaction {
pub refund: BraintreeRefundTransactionBody,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct BraintreeRefundResponseData {
pub refund_transaction: BraintreeRefundTransaction,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct RefundResponse {
pub data: BraintreeRefundResponseData,
}
impl<F> TryFrom<ResponseRouterData<BraintreeRefundResponse, Self>>
for RouterDataV2<F, RefundFlowData, RefundsData, RefundsResponseData>
{
type Error = error_stack::Report<ConnectorError>;
fn try_from(
item: ResponseRouterData<BraintreeRefundResponse, Self>,
) -> Result<Self, Self::Error> {
Ok(Self {
response: match item.response {
BraintreeRefundResponse::ErrorResponse(error_response) => {
build_error_response(&error_response.errors, item.http_code).map_err(|err| *err)
}
BraintreeRefundResponse::SuccessResponse(refund_data) => {
let refund_data = refund_data.data.refund_transaction.refund;
let refund_status = enums::RefundStatus::from(refund_data.status.clone());
if utils::is_refund_failure(refund_status) {
Err(create_failure_error_response(
refund_data.status,
Some(refund_data.id),
item.http_code,
))
} else {
Ok(RefundsResponseData {
connector_refund_id: refund_data.id.clone(),
refund_status,
status_code: item.http_code,
})
}
}
},
..item.router_data
})
}
}
fn extract_metadata_field<T>(
metadata: &Option<pii::SecretSerdeValue>,
field_name: &'static str,
) -> Result<T, error_stack::Report<errors::ConnectorError>>
where
T: std::str::FromStr,
T::Err: std::fmt::Debug,
{
metadata
.as_ref()
.and_then(|metadata| {
let exposed = metadata.clone().expose();
exposed
.get(field_name)
.and_then(|v| v.as_str())
.and_then(|s| s.parse().ok())
})
.ok_or_else(|| errors::ConnectorError::MissingRequiredField { field_name }.into())
}
fn extract_metadata_string_field(
metadata: &Option<pii::SecretSerdeValue>,
field_name: &'static str,
) -> Result<Secret<String>, error_stack::Report<errors::ConnectorError>> {
metadata
.as_ref()
.and_then(|metadata| {
let exposed = metadata.clone().expose();
exposed
.get(field_name)
.and_then(|v| v.as_str())
.map(|s| Secret::new(s.to_string()))
})
.ok_or_else(|| errors::ConnectorError::MissingRequiredField { field_name }.into())
}
#[derive(Debug, Clone, Serialize)]
pub struct RefundSearchInput {
id: IdFilter,
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
TryFrom<
BraintreeRouterData<
RouterDataV2<RSync, RefundFlowData, RefundSyncData, RefundsResponseData>,
T,
>,
> for BraintreeRSyncRequest
{
type Error = error_stack::Report<ConnectorError>;
fn try_from(
item: BraintreeRouterData<
RouterDataV2<RSync, RefundFlowData, RefundSyncData, RefundsResponseData>,
T,
>,
) -> Result<Self, Self::Error> {
let metadata: BraintreeMeta = if let (
Some(merchant_account_id),
Some(merchant_config_currency),
) = (
extract_metadata_string_field(
&item.router_data.request.refund_connector_metadata,
"merchant_account_id",
)
.ok(),
extract_metadata_field(
| {
"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_-5184931324552524607_9 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/braintree/transformers.rs
&item.router_data.request.refund_connector_metadata,
"merchant_config_currency",
)
.ok(),
) {
BraintreeMeta {
merchant_account_id,
merchant_config_currency,
}
} else {
utils::to_connector_meta_from_secret(
item.router_data.request.refund_connector_metadata.clone(),
)
.change_context(errors::ConnectorError::InvalidConnectorConfig { config: "metadata" })?
};
let currency = extract_metadata_field(
&item.router_data.request.refund_connector_metadata,
"currency",
)?;
validate_currency(currency, Some(metadata.merchant_config_currency))?;
let refund_id = item.router_data.request.connector_refund_id;
Ok(Self {
query: constants::REFUND_QUERY.to_string(),
variables: RSyncInput {
input: RefundSearchInput {
id: IdFilter { is: refund_id },
},
},
})
}
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct RSyncNodeData {
id: String,
status: BraintreeRefundStatus,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct RSyncEdgeData {
node: RSyncNodeData,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct RefundData {
edges: Vec<RSyncEdgeData>,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct RSyncSearchData {
refunds: RefundData,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct RSyncResponseData {
search: RSyncSearchData,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct RSyncResponse {
data: RSyncResponseData,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(untagged)]
pub enum BraintreeRSyncResponse {
RSyncResponse(Box<RSyncResponse>),
ErrorResponse(Box<ErrorResponse>),
}
impl<F> TryFrom<ResponseRouterData<BraintreeRSyncResponse, Self>>
for RouterDataV2<F, RefundFlowData, RefundSyncData, RefundsResponseData>
{
type Error = error_stack::Report<ConnectorError>;
fn try_from(
item: ResponseRouterData<BraintreeRSyncResponse, Self>,
) -> Result<Self, Self::Error> {
match item.response {
BraintreeRSyncResponse::ErrorResponse(error_response) => Ok(Self {
response: build_error_response(&error_response.errors, item.http_code)
.map_err(|err| *err),
..item.router_data
}),
BraintreeRSyncResponse::RSyncResponse(rsync_response) => {
let edge_data = rsync_response
.data
.search
.refunds
.edges
.first()
.ok_or(errors::ConnectorError::MissingConnectorRefundID)?;
let connector_refund_id = &edge_data.node.id;
let response = Ok(RefundsResponseData {
connector_refund_id: connector_refund_id.to_string(),
refund_status: enums::RefundStatus::from(edge_data.node.status.clone()),
status_code: item.http_code,
});
Ok(Self {
response,
..item.router_data
})
}
}
}
}
#[derive(Debug, Clone, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct CreditCardData<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> {
number: RawCardNumber<T>,
expiration_year: Secret<String>,
expiration_month: Secret<String>,
cvv: Secret<String>,
cardholder_name: Secret<String>,
}
#[derive(Debug, Clone, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ClientTokenInput {
merchant_account_id: Secret<String>,
}
#[derive(Debug, Clone, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct InputData<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> {
credit_card: CreditCardData<T>,
}
#[derive(Debug, Clone, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct InputClientTokenData {
client_token: ClientTokenInput,
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
| {
"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_-5184931324552524607_10 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/braintree/transformers.rs
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
TryFrom<
BraintreeRouterData<
RouterDataV2<
PaymentMethodToken,
PaymentFlowData,
PaymentMethodTokenizationData<T>,
PaymentMethodTokenResponse,
>,
T,
>,
> for BraintreeTokenRequest<T>
{
type Error = error_stack::Report<ConnectorError>;
fn try_from(
item: BraintreeRouterData<
RouterDataV2<
PaymentMethodToken,
PaymentFlowData,
PaymentMethodTokenizationData<T>,
PaymentMethodTokenResponse,
>,
T,
>,
) -> Result<Self, Self::Error> {
match item.router_data.request.payment_method_data.clone() {
PaymentMethodData::Card(card_data) => Ok(Self {
query: constants::TOKENIZE_CREDIT_CARD.to_string(),
variables: VariableInput {
input: InputData {
credit_card: CreditCardData {
number: card_data.card_number,
expiration_year: card_data.card_exp_year,
expiration_month: card_data.card_exp_month,
cvv: card_data.card_cvc,
cardholder_name: item
.router_data
.resource_common_data
.get_optional_billing_full_name()
.unwrap_or(Secret::new("".to_string())),
},
},
},
}),
PaymentMethodData::CardRedirect(_)
| PaymentMethodData::Wallet(_)
| PaymentMethodData::PayLater(_)
| PaymentMethodData::BankRedirect(_)
| PaymentMethodData::BankDebit(_)
| PaymentMethodData::BankTransfer(_)
| PaymentMethodData::Crypto(_)
| PaymentMethodData::MandatePayment
| PaymentMethodData::OpenBanking(_)
| PaymentMethodData::Reward
| PaymentMethodData::RealTimePayment(_)
| PaymentMethodData::MobilePayment(_)
| PaymentMethodData::Upi(_)
| PaymentMethodData::Voucher(_)
| PaymentMethodData::GiftCard(_)
| PaymentMethodData::CardToken(_)
| PaymentMethodData::NetworkToken(_)
| PaymentMethodData::CardDetailsForNetworkTransactionId(_) => {
Err(errors::ConnectorError::NotImplemented(
utils::get_unimplemented_payment_method_error_message("braintree"),
)
.into())
}
}
}
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct TokenizePaymentMethodData {
id: Secret<String>,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct TokenizeCreditCardData {
payment_method: TokenizePaymentMethodData,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ClientToken {
client_token: Secret<String>,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct TokenizeCreditCard {
tokenize_credit_card: TokenizeCreditCardData,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ClientTokenData {
create_client_token: ClientToken,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct ClientTokenResponse {
data: ClientTokenData,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct TokenResponse {
data: TokenizeCreditCard,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct ErrorResponse {
errors: Vec<ErrorDetails>,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(untagged)]
pub enum BraintreeTokenResponse {
TokenResponse(Box<TokenResponse>),
ErrorResponse(Box<ErrorResponse>),
}
impl<
F,
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> TryFrom<ResponseRouterData<BraintreeTokenResponse, Self>>
for RouterDataV2<
F,
PaymentFlowData,
| {
"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_-5184931324552524607_11 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/braintree/transformers.rs
PaymentMethodTokenizationData<T>,
PaymentMethodTokenResponse,
>
{
type Error = error_stack::Report<ConnectorError>;
fn try_from(
item: ResponseRouterData<BraintreeTokenResponse, Self>,
) -> Result<Self, Self::Error> {
Ok(Self {
response: match item.response {
BraintreeTokenResponse::ErrorResponse(error_response) => {
build_error_response(error_response.errors.as_ref(), item.http_code)
.map_err(|err| *err)
}
BraintreeTokenResponse::TokenResponse(token_response) => {
Ok(PaymentMethodTokenResponse {
token: token_response
.data
.tokenize_credit_card
.payment_method
.id
.expose()
.clone(),
})
}
},
..item.router_data
})
}
}
#[derive(Debug, Clone, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct CaptureTransactionBody {
amount: StringMajorUnit,
}
#[derive(Debug, Clone, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct CaptureInputData {
transaction_id: String,
transaction: CaptureTransactionBody,
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
TryFrom<
BraintreeRouterData<
RouterDataV2<Capture, PaymentFlowData, PaymentsCaptureData, PaymentsResponseData>,
T,
>,
> for BraintreeCaptureRequest
{
type Error = error_stack::Report<ConnectorError>;
fn try_from(
item: BraintreeRouterData<
RouterDataV2<Capture, PaymentFlowData, PaymentsCaptureData, PaymentsResponseData>,
T,
>,
) -> Result<Self, Self::Error> {
let query = constants::CAPTURE_TRANSACTION_MUTATION.to_string();
let amount = item
.connector
.amount_converter
.convert(
item.router_data.request.minor_amount_to_capture,
item.router_data.request.currency,
)
.change_context(ConnectorError::AmountConversionFailed)?;
let variables = VariableCaptureInput {
input: CaptureInputData {
transaction_id: item
.router_data
.request
.connector_transaction_id
.get_connector_transaction_id()
.change_context(ConnectorError::MissingConnectorTransactionID)?,
transaction: CaptureTransactionBody { amount },
},
};
Ok(Self { query, variables })
}
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct CaptureResponseTransactionBody {
id: String,
status: BraintreePaymentStatus,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct CaptureTransactionData {
transaction: CaptureResponseTransactionBody,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct CaptureResponseData {
capture_transaction: CaptureTransactionData,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct CaptureResponse {
data: CaptureResponseData,
}
impl<F, T> TryFrom<ResponseRouterData<BraintreeCaptureResponse, Self>>
for RouterDataV2<F, PaymentFlowData, T, PaymentsResponseData>
{
type Error = error_stack::Report<ConnectorError>;
fn try_from(
item: ResponseRouterData<BraintreeCaptureResponse, Self>,
) -> Result<Self, Self::Error> {
match item.response {
BraintreeCaptureResponse::SuccessResponse(capture_data) => {
let transaction_data = capture_data.data.capture_transaction.transaction;
let status = enums::AttemptStatus::from(transaction_data.status.clone());
let response = if domain_types::utils::is_payment_failure(status) {
Err(create_failure_error_response(
transaction_data.status,
Some(transaction_data.id),
item.http_code,
))
} else {
| {
"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_-5184931324552524607_12 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/braintree/transformers.rs
Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(transaction_data.id),
redirection_data: None,
mandate_reference: None,
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: None,
incremental_authorization_allowed: None,
status_code: item.http_code,
})
};
Ok(Self {
resource_common_data: PaymentFlowData {
status,
..item.router_data.resource_common_data
},
response,
..item.router_data
})
}
BraintreeCaptureResponse::ErrorResponse(error_data) => Ok(Self {
response: build_error_response(&error_data.errors, item.http_code)
.map_err(|err| *err),
..item.router_data
}),
}
}
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct DeletePaymentMethodFromVaultInputData {
payment_method_id: Secret<String>,
}
#[derive(Debug, Serialize)]
pub struct VariableDeletePaymentMethodFromVaultInput {
input: DeletePaymentMethodFromVaultInputData,
}
#[derive(Debug, Serialize)]
pub struct BraintreeRevokeMandateRequest {
query: String,
variables: VariableDeletePaymentMethodFromVaultInput,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(untagged)]
pub enum BraintreeRevokeMandateResponse {
RevokeMandateResponse(Box<RevokeMandateResponse>),
ErrorResponse(Box<ErrorResponse>),
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct RevokeMandateResponse {
data: DeletePaymentMethodFromVault,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct DeletePaymentMethodFromVault {
client_mutation_id: Option<String>,
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct CancelInputData {
transaction_id: String,
}
#[derive(Debug, Serialize)]
pub struct VariableCancelInput {
input: CancelInputData,
}
#[derive(Debug, Serialize)]
pub struct BraintreeCancelRequest {
query: String,
variables: VariableCancelInput,
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
TryFrom<
BraintreeRouterData<
RouterDataV2<Void, PaymentFlowData, PaymentVoidData, PaymentsResponseData>,
T,
>,
> for BraintreeCancelRequest
{
type Error = error_stack::Report<ConnectorError>;
fn try_from(
item: BraintreeRouterData<
RouterDataV2<Void, PaymentFlowData, PaymentVoidData, PaymentsResponseData>,
T,
>,
) -> Result<Self, Self::Error> {
let query = constants::VOID_TRANSACTION_MUTATION.to_string();
let variables = VariableCancelInput {
input: CancelInputData {
transaction_id: item.router_data.request.connector_transaction_id.clone(),
},
};
Ok(Self { query, variables })
}
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct CancelResponseTransactionBody {
id: String,
status: BraintreePaymentStatus,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct CancelTransactionData {
reversal: CancelResponseTransactionBody,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct CancelResponseData {
reverse_transaction: CancelTransactionData,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct CancelResponse {
data: CancelResponseData,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(untagged)]
pub enum BraintreeCancelResponse {
CancelResponse(Box<CancelResponse>),
ErrorResponse(Box<ErrorResponse>),
}
impl<F> TryFrom<ResponseRouterData<BraintreeCancelResponse, Self>>
for RouterDataV2<F, PaymentFlowData, PaymentVoidData, PaymentsResponseData>
{
type Error = error_stack::Report<ConnectorError>;
fn try_from(
item: ResponseRouterData<BraintreeCancelResponse, Self>,
) -> Result<Self, Self::Error> {
| {
"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_-5184931324552524607_13 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/braintree/transformers.rs
match item.response {
BraintreeCancelResponse::ErrorResponse(error_response) => Ok(Self {
response: build_error_response(&error_response.errors, item.http_code)
.map_err(|err| *err),
..item.router_data
}),
BraintreeCancelResponse::CancelResponse(void_response) => {
let void_data = void_response.data.reverse_transaction.reversal;
let status = enums::AttemptStatus::from(void_data.status.clone());
let response = if domain_types::utils::is_payment_failure(status) {
Err(create_failure_error_response(
void_data.status,
None,
item.http_code,
))
} else {
Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::NoResponseId,
redirection_data: None,
mandate_reference: None,
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: None,
incremental_authorization_allowed: None,
status_code: item.http_code,
})
};
Ok(Self {
resource_common_data: PaymentFlowData {
status,
..item.router_data.resource_common_data
},
response,
..item.router_data
})
}
}
}
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
TryFrom<
BraintreeRouterData<
RouterDataV2<PSync, PaymentFlowData, PaymentsSyncData, PaymentsResponseData>,
T,
>,
> for BraintreePSyncRequest
{
type Error = error_stack::Report<ConnectorError>;
fn try_from(
item: BraintreeRouterData<
RouterDataV2<PSync, PaymentFlowData, PaymentsSyncData, PaymentsResponseData>,
T,
>,
) -> Result<Self, Self::Error> {
let transaction_id = item
.router_data
.request
.connector_transaction_id
.get_connector_transaction_id()
.change_context(errors::ConnectorError::MissingConnectorTransactionID)?;
Ok(Self {
query: constants::TRANSACTION_QUERY.to_string(),
variables: PSyncInput {
input: TransactionSearchInput {
id: IdFilter { is: transaction_id },
},
},
})
}
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct NodeData {
id: String,
status: BraintreePaymentStatus,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct EdgeData {
node: NodeData,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct TransactionData {
edges: Vec<EdgeData>,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct SearchData {
transactions: TransactionData,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct PSyncResponseData {
search: SearchData,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct PSyncResponse {
data: PSyncResponseData,
}
impl<F> TryFrom<ResponseRouterData<BraintreePSyncResponse, Self>>
for RouterDataV2<F, PaymentFlowData, PaymentsSyncData, PaymentsResponseData>
{
type Error = error_stack::Report<ConnectorError>;
fn try_from(
item: ResponseRouterData<BraintreePSyncResponse, Self>,
) -> Result<Self, Self::Error> {
match item.response {
BraintreePSyncResponse::ErrorResponse(error_response) => Ok(Self {
response: build_error_response(&error_response.errors, item.http_code)
.map_err(|err| *err),
..item.router_data
}),
BraintreePSyncResponse::SuccessResponse(psync_response) => {
let edge_data = psync_response
.data
.search
.transactions
.edges
.first()
| {
"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_-5184931324552524607_14 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/braintree/transformers.rs
.ok_or(errors::ConnectorError::MissingConnectorTransactionID)?;
let status = enums::AttemptStatus::from(edge_data.node.status.clone());
let response = if domain_types::utils::is_payment_failure(status) {
Err(create_failure_error_response(
edge_data.node.status.clone(),
None,
item.http_code,
))
} else {
Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(edge_data.node.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
})
}
}
}
}
#[derive(Debug, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct BraintreeThreeDsResponse {
pub nonce: Secret<String>,
pub liability_shifted: bool,
pub liability_shift_possible: bool,
}
#[derive(Debug, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct BraintreeThreeDsErrorResponse {
pub code: String,
pub message: String,
}
#[derive(Debug, Deserialize)]
pub struct BraintreeRedirectionResponse {
pub authentication_response: String,
}
fn get_card_isin_from_payment_method_data<T>(
card_details: &PaymentMethodData<T>,
) -> Result<String, error_stack::Report<errors::ConnectorError>>
where
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
{
match card_details {
PaymentMethodData::Card(card_data) => {
let card_number_str = format!("{:?}", card_data.card_number.0);
let cleaned_number = card_number_str
.chars()
.filter(|c| c.is_ascii_digit())
.take(6)
.collect::<String>();
Ok(cleaned_number)
}
_ => Err(errors::ConnectorError::NotImplemented("given payment method".to_owned()).into()),
}
}
impl TryFrom<BraintreeMeta> for BraintreeClientTokenRequest {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(metadata: BraintreeMeta) -> Result<Self, Self::Error> {
Ok(Self {
query: constants::CLIENT_TOKEN_MUTATION.to_owned(),
variables: VariableClientTokenInput {
input: InputClientTokenData {
client_token: ClientTokenInput {
merchant_account_id: metadata.merchant_account_id,
},
},
},
})
}
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
TryFrom<(
BraintreeRouterData<
RouterDataV2<
Authorize,
PaymentFlowData,
PaymentsAuthorizeData<T>,
PaymentsResponseData,
>,
T,
>,
BraintreeMeta,
)> for CardPaymentRequest
{
type Error = error_stack::Report<ConnectorError>;
fn try_from(
(item, metadata): (
BraintreeRouterData<
RouterDataV2<
Authorize,
PaymentFlowData,
PaymentsAuthorizeData<T>,
PaymentsResponseData,
>,
T,
>,
BraintreeMeta,
),
) -> Result<Self, Self::Error> {
let reference_id = Some(
item.router_data
.resource_common_data
.connector_request_reference_id
.clone(),
);
let order_id = reference_id.ok_or(
| {
"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_-5184931324552524607_15 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/braintree/transformers.rs
errors::ConnectorError::MissingConnectorRelatedTransactionID {
id: "order_id".to_string(),
},
)?;
let amount = item
.connector
.amount_converter
.convert(
item.router_data.request.minor_amount,
item.router_data.request.currency,
)
.change_context(ConnectorError::AmountConversionFailed)?;
let (query, transaction_body) = if item.router_data.request.is_mandate_payment() {
(
if item.router_data.request.is_auto_capture()? {
constants::CHARGE_AND_VAULT_TRANSACTION_MUTATION.to_string()
} else {
constants::AUTHORIZE_AND_VAULT_CREDIT_CARD_MUTATION.to_string()
},
TransactionBody::Vault(VaultTransactionBody {
amount,
merchant_account_id: metadata.merchant_account_id,
vault_payment_method_after_transacting: TransactionTiming {
when: "ALWAYS".to_string(),
},
customer_details: item
.router_data
.resource_common_data
.get_billing_email()
.ok()
.map(|email| CustomerBody { email }),
order_id,
}),
)
} else {
(
if item.router_data.request.is_auto_capture()? {
constants::CHARGE_CREDIT_CARD_MUTATION.to_string()
} else {
constants::AUTHORIZE_CREDIT_CARD_MUTATION.to_string()
},
TransactionBody::Regular(RegularTransactionBody {
amount,
merchant_account_id: metadata.merchant_account_id,
channel: constants::CHANNEL_CODE.to_string(),
customer_details: item
.router_data
.resource_common_data
.get_billing_email()
.ok()
.map(|email| CustomerBody { email }),
order_id,
}),
)
};
Ok(Self {
query,
variables: VariablePaymentInput {
input: PaymentInput {
payment_method_id: match item
.router_data
.resource_common_data
.get_payment_method_token()?
{
PaymentMethodTokenFlow::Token(token) => token,
PaymentMethodTokenFlow::ApplePayDecrypt(_) => Err(
unimplemented_payment_method!("Apple Pay", "Simplified", "Braintree"),
)?,
PaymentMethodTokenFlow::PazeDecrypt(_) => {
Err(unimplemented_payment_method!("Paze", "Braintree"))?
}
PaymentMethodTokenFlow::GooglePayDecrypt(_) => {
Err(unimplemented_payment_method!("Google Pay", "Braintree"))?
}
},
transaction: transaction_body,
},
},
})
}
}
fn get_braintree_redirect_form<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>(
client_token_data: ClientTokenResponse,
payment_method_token: PaymentMethodTokenFlow,
card_details: PaymentMethodData<T>,
complete_authorize_url: String,
) -> Result<RedirectForm, error_stack::Report<errors::ConnectorError>> {
Ok(RedirectForm::Braintree {
client_token: client_token_data
.data
.create_client_token
.client_token
.expose(),
card_token: match payment_method_token {
PaymentMethodTokenFlow::Token(token) => token.expose(),
PaymentMethodTokenFlow::ApplePayDecrypt(_) => Err(unimplemented_payment_method!(
"Apple Pay",
"Simplified",
"Braintree"
))?,
| {
"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_-5184931324552524607_16 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/braintree/transformers.rs
PaymentMethodTokenFlow::PazeDecrypt(_) => {
Err(unimplemented_payment_method!("Paze", "Braintree"))?
}
PaymentMethodTokenFlow::GooglePayDecrypt(_) => {
Err(unimplemented_payment_method!("Google Pay", "Braintree"))?
}
},
bin: match card_details {
PaymentMethodData::Card(_) => get_card_isin_from_payment_method_data(&card_details)?,
PaymentMethodData::CardRedirect(_)
| PaymentMethodData::Wallet(_)
| PaymentMethodData::PayLater(_)
| PaymentMethodData::BankRedirect(_)
| PaymentMethodData::BankDebit(_)
| PaymentMethodData::BankTransfer(_)
| PaymentMethodData::Crypto(_)
| PaymentMethodData::MandatePayment
| PaymentMethodData::OpenBanking(_)
| PaymentMethodData::Reward
| PaymentMethodData::RealTimePayment(_)
| PaymentMethodData::MobilePayment(_)
| PaymentMethodData::Upi(_)
| PaymentMethodData::Voucher(_)
| PaymentMethodData::GiftCard(_)
| PaymentMethodData::CardToken(_)
| PaymentMethodData::NetworkToken(_)
| PaymentMethodData::CardDetailsForNetworkTransactionId(_) => Err(
errors::ConnectorError::NotImplemented("given payment method".to_owned()),
)?,
},
acs_url: complete_authorize_url,
})
}
fn validate_currency(
request_currency: enums::Currency,
merchant_config_currency: Option<enums::Currency>,
) -> Result<(), errors::ConnectorError> {
let merchant_config_currency =
merchant_config_currency.ok_or(errors::ConnectorError::NoConnectorMetaData)?;
if request_currency != merchant_config_currency {
Err(errors::ConnectorError::NotSupported {
message: format!(
"currency {request_currency} is not supported for this merchant account",
),
connector: "Braintree",
})?
}
Ok(())
}
#[derive(Debug, Deserialize)]
pub struct BraintreeWebhookResponse {
pub bt_signature: String,
pub bt_payload: String,
}
#[derive(Debug, Deserialize, Serialize)]
#[serde(rename_all = "kebab-case")]
pub struct Notification {
pub kind: String, // xml parse only string to fields
pub timestamp: String,
pub dispute: Option<BraintreeDisputeData>,
}
#[derive(Debug, Deserialize, Serialize)]
pub struct BraintreeDisputeData {
pub amount_disputed: MinorUnit,
pub amount_won: Option<String>,
pub case_number: Option<String>,
pub chargeback_protection_level: Option<String>,
pub currency_iso_code: enums::Currency,
#[serde(default, with = "common_utils::custom_serde::iso8601::option")]
pub created_at: Option<PrimitiveDateTime>,
pub evidence: Option<DisputeEvidence>,
pub id: String,
pub kind: String, // xml parse only string to fields
pub status: String,
pub reason: Option<String>,
pub reason_code: Option<String>,
#[serde(default, with = "common_utils::custom_serde::iso8601::option")]
pub updated_at: Option<PrimitiveDateTime>,
#[serde(default, with = "common_utils::custom_serde::iso8601::option")]
pub reply_by_date: Option<PrimitiveDateTime>,
pub transaction: DisputeTransaction,
}
#[derive(Debug, Deserialize, Serialize)]
pub struct DisputeTransaction {
pub amount: StringMajorUnit,
pub id: String,
}
#[derive(Debug, Deserialize, Serialize)]
pub struct DisputeEvidence {
pub comment: String,
pub id: Secret<String>,
pub created_at: Option<PrimitiveDateTime>,
pub url: url::Url,
}
| {
"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_-5409969266194052518_0 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/worldpay/response.rs
use domain_types::errors;
use error_stack::ResultExt;
use hyperswitch_masking::Secret;
use serde::{Deserialize, Serialize};
use url::Url;
use super::requests::*;
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct WorldpayPaymentsResponse {
pub outcome: PaymentOutcome,
pub transaction_reference: Option<String>,
#[serde(rename = "_links", skip_serializing_if = "Option::is_none")]
pub links: Option<SelfLink>,
#[serde(rename = "_actions", skip_serializing_if = "Option::is_none")]
pub actions: Option<ActionLinks>,
#[serde(flatten)]
pub other_fields: Option<WorldpayPaymentResponseFields>,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
#[serde(untagged)]
pub enum WorldpayPaymentResponseFields {
RefusedResponse(RefusedResponse),
DDCResponse(DDCResponse),
ThreeDsChallenged(ThreeDsChallengedResponse),
FraudHighRisk(FraudHighRiskResponse),
AuthorizedResponse(Box<AuthorizedResponse>),
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct AuthorizedResponse {
pub payment_instrument: PaymentsResPaymentInstrument,
#[serde(skip_serializing_if = "Option::is_none")]
pub issuer: Option<Issuer>,
#[serde(skip_serializing_if = "Option::is_none")]
pub scheme: Option<PaymentsResponseScheme>,
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
pub risk_factors: Option<Vec<RiskFactorsInner>>,
pub fraud: Option<Fraud>,
/// Mandate's token
pub token: Option<MandateToken>,
/// Network transaction ID
pub scheme_reference: Option<Secret<String>>,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct MandateToken {
pub href: Secret<String>,
pub token_id: String,
pub token_expiry_date_time: String,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct FraudHighRiskResponse {
pub score: f32,
pub reason: Vec<String>,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct RefusedResponse {
pub refusal_description: String,
// 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.
pub refusal_code: String,
pub risk_factors: Option<Vec<RiskFactorsInner>>,
pub fraud: Option<Fraud>,
#[serde(rename = "threeDS")]
pub three_ds: Option<ThreeDsResponse>,
pub advice: Option<Advice>,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct Advice {
pub code: Option<String>,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ThreeDsResponse {
pub outcome: String,
pub issuer_response: IssuerResponse,
pub version: Option<String>,
pub eci: Option<String>,
pub applied: Option<String>,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ThreeDsChallengedResponse {
pub authentication: AuthenticationResponse,
pub challenge: ThreeDsChallenge,
#[serde(rename = "_actions")]
pub actions: CompleteThreeDsActionLink,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct AuthenticationResponse {
pub version: String,
pub eci: Option<String>,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct ThreeDsChallenge {
pub reference: String,
pub url: Url,
pub jwt: Secret<String>,
pub payload: Secret<String>,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct CompleteThreeDsActionLink {
#[serde(rename = "complete3dsChallenge")]
pub complete_three_ds_challenge: ActionLink,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "lowercase")]
pub enum IssuerResponse {
Challenged,
Frictionless,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct DDCResponse {
pub device_data_collection: DDCToken,
#[serde(rename = "_actions")]
pub actions: DDCActionLink,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
| {
"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_-5409969266194052518_1 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/worldpay/response.rs
pub struct DDCToken {
pub jwt: Secret<String>,
pub url: Url,
pub bin: Secret<String>,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct DDCActionLink {
#[serde(rename = "supply3dsDeviceData")]
pub supply_ddc_data: ActionLink,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub enum PaymentOutcome {
#[serde(alias = "authorized", alias = "Authorized")]
Authorized,
Refused,
SentForSettlement,
SentForRefund,
FraudHighRisk,
#[serde(alias = "3dsDeviceDataRequired")]
ThreeDsDeviceDataRequired,
SentForCancellation,
#[serde(alias = "3dsAuthenticationFailed")]
ThreeDsAuthenticationFailed,
SentForPartialRefund,
#[serde(alias = "3dsChallenged")]
ThreeDsChallenged,
#[serde(alias = "3dsUnavailable")]
ThreeDsUnavailable,
}
impl std::fmt::Display for PaymentOutcome {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self {
Self::Authorized => write!(f, "authorized"),
Self::Refused => write!(f, "refused"),
Self::SentForSettlement => write!(f, "sentForSettlement"),
Self::SentForRefund => write!(f, "sentForRefund"),
Self::FraudHighRisk => write!(f, "fraudHighRisk"),
Self::ThreeDsDeviceDataRequired => write!(f, "3dsDeviceDataRequired"),
Self::SentForCancellation => write!(f, "sentForCancellation"),
Self::ThreeDsAuthenticationFailed => write!(f, "3dsAuthenticationFailed"),
Self::SentForPartialRefund => write!(f, "sentForPartialRefund"),
Self::ThreeDsChallenged => write!(f, "3dsChallenged"),
Self::ThreeDsUnavailable => write!(f, "3dsUnavailable"),
}
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct SelfLink {
#[serde(rename = "self")]
pub self_link: SelfLinkInner,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct SelfLinkInner {
pub href: String,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ActionLinks {
supply_3ds_device_data: Option<ActionLink>,
settle_payment: Option<ActionLink>,
partially_settle_payment: Option<ActionLink>,
refund_payment: Option<ActionLink>,
partially_refund_payment: Option<ActionLink>,
cancel_payment: Option<ActionLink>,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct ActionLink {
pub href: String,
pub method: String,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct Fraud {
pub outcome: FraudOutcome,
pub score: f32,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub enum FraudOutcome {
LowRisk,
HighRisk,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct WorldpayEventResponse {
pub last_event: EventType,
#[serde(rename = "_links", skip_serializing_if = "Option::is_none")]
pub links: Option<EventLinks>,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub enum EventType {
SentForAuthorization,
#[serde(alias = "Authorized")]
Authorized,
#[serde(alias = "Sent for Settlement")]
SentForSettlement,
Settled,
SettlementFailed,
Cancelled,
Error,
Expired,
Refused,
#[serde(alias = "Sent for Refund")]
SentForRefund,
Refunded,
RefundFailed,
#[serde(other)]
Unknown,
}
#[derive(Clone, Debug, PartialEq, Default, Serialize, Deserialize)]
pub struct EventLinks {
#[serde(rename = "payments:events", skip_serializing_if = "Option::is_none")]
pub events: Option<String>,
}
#[derive(Clone, Debug, PartialEq, Default, Serialize, Deserialize)]
pub struct PaymentLink {
pub href: String,
}
pub fn get_resource_id<T, F>(
response: WorldpayPaymentsResponse,
connector_transaction_id: Option<String>,
transform_fn: F,
) -> Result<T, error_stack::Report<errors::ConnectorError>>
where
F: Fn(String) -> T,
{
// First check top-level _links (for capture, authorize, etc.)
let optional_reference_id = response
.links
.as_ref()
.and_then(|link| link.self_link.href.rsplit_once('/').map(|(_, h)| h))
.or_else(|| {
| {
"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_-5409969266194052518_2 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/worldpay/response.rs
// Fallback to variant-specific logic for DDC and 3DS challenges
response
.other_fields
.as_ref()
.and_then(|other_fields| match other_fields {
WorldpayPaymentResponseFields::DDCResponse(res) => {
res.actions.supply_ddc_data.href.split('/').nth_back(1)
}
WorldpayPaymentResponseFields::ThreeDsChallenged(res) => res
.actions
.complete_three_ds_challenge
.href
.split('/')
.nth_back(1),
_ => None,
})
})
.map(|href| {
urlencoding::decode(href)
.map(|s| transform_fn(s.into_owned()))
.change_context(errors::ConnectorError::ResponseHandlingFailed)
})
.transpose()?;
optional_reference_id
.or_else(|| response.transaction_reference.map(&transform_fn))
.or_else(|| connector_transaction_id.map(&transform_fn))
.ok_or_else(|| {
errors::ConnectorError::MissingRequiredField {
field_name: "_links.self.href or transactionReference",
}
.into()
})
}
pub struct ResponseIdStr {
pub id: String,
}
#[derive(Clone, Debug, PartialEq, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Issuer {
pub authorization_code: Secret<String>,
}
impl Issuer {
pub fn new(code: String) -> Self {
Self {
authorization_code: Secret::new(code),
}
}
}
#[derive(Clone, Debug, PartialEq, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct PaymentsResPaymentInstrument {
#[serde(rename = "type")]
pub payment_instrument_type: String,
pub card_bin: Option<String>,
pub last_four: Option<String>,
pub expiry_date: Option<ExpiryDate>,
pub card_brand: Option<String>,
pub funding_type: Option<String>,
pub category: Option<String>,
pub issuer_name: Option<String>,
pub payment_account_reference: Option<Secret<String>>,
}
#[derive(Clone, Debug, PartialEq, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct RiskFactorsInner {
#[serde(rename = "type")]
pub risk_type: RiskType,
#[serde(skip_serializing_if = "Option::is_none")]
pub detail: Option<Detail>,
pub risk: Risk,
}
impl RiskFactorsInner {
pub fn new(risk_type: RiskType, risk: Risk) -> Self {
Self {
risk_type,
detail: None,
risk,
}
}
}
#[derive(
Clone, Copy, Default, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize,
)]
#[serde(rename_all = "camelCase")]
pub enum RiskType {
#[default]
Avs,
Cvc,
RiskProfile,
}
#[derive(
Clone, Copy, Default, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize,
)]
#[serde(rename_all = "lowercase")]
pub enum Detail {
#[default]
Address,
Postcode,
}
#[derive(
Clone, Copy, Default, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize,
)]
#[serde(rename_all = "camelCase")]
pub enum Risk {
#[default]
NotChecked,
NotMatched,
NotSupplied,
VerificationFailed,
}
#[derive(Clone, Debug, PartialEq, Default, Serialize, Deserialize)]
pub struct PaymentsResponseScheme {
pub reference: String,
}
impl PaymentsResponseScheme {
pub fn new(reference: String) -> Self {
Self { reference }
}
}
#[derive(Debug, Serialize, Deserialize, PartialEq)]
#[serde(rename_all = "camelCase")]
pub struct WorldpayErrorResponse {
pub error_name: String,
pub message: String,
pub validation_errors: Option<serde_json::Value>,
}
impl WorldpayErrorResponse {
pub fn default(status_code: u16) -> Self {
match status_code {
code @ 404 => Self {
error_name: format!("{code} Not found"),
message: "Resource not found".to_string(),
validation_errors: None,
},
code => Self {
error_name: code.to_string(),
message: "Unknown error".to_string(),
validation_errors: None,
},
}
}
}
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct WorldpayWebhookTransactionId {
| {
"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_-5409969266194052518_3 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/worldpay/response.rs
pub event_details: EventDetails,
}
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct EventDetails {
#[serde(rename = "type")]
pub event_type: EventType,
pub transaction_reference: String,
/// Mandate's token
pub token: Option<MandateToken>,
/// Network transaction ID
pub scheme_reference: Option<Secret<String>>,
}
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct WorldpayWebhookEventType {
pub event_id: String,
pub event_timestamp: String,
pub event_details: EventDetails,
}
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
#[serde(rename_all = "camelCase")]
pub enum WorldpayWebhookStatus {
SentForSettlement,
Authorized,
SentForAuthorization,
Cancelled,
Error,
Expired,
Refused,
SentForRefund,
RefundFailed,
}
// Type aliases to avoid duplicate template structs in macro generation
pub type WorldpayAuthorizeResponse = WorldpayPaymentsResponse;
pub type WorldpaySyncResponse = WorldpayEventResponse;
pub type WorldpayCaptureResponse = WorldpayPaymentsResponse;
pub type WorldpayVoidResponse = WorldpayPaymentsResponse;
pub type WorldpayRefundResponse = WorldpayPaymentsResponse;
pub type WorldpayRefundSyncResponse = WorldpayEventResponse;
pub type WorldpayAuthenticateResponse = WorldpayPaymentsResponse;
pub type WorldpayPreAuthenticateResponse = WorldpayPaymentsResponse;
pub type WorldpayPostAuthenticateResponse = WorldpayPaymentsResponse;
pub type WorldpayRepeatPaymentResponse = WorldpayPaymentsResponse;
| {
"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_0 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/worldpay/transformers.rs
use std::collections::HashMap;
use common_enums as enums;
use common_utils::{ext_traits::OptionExt, pii, types::MinorUnit, CustomResult};
use domain_types::{
connector_flow::{Authorize, Capture, Void},
connector_types::{
MandateIds, MandateReference, MandateReferenceId, PaymentFlowData, PaymentVoidData,
PaymentsAuthorizeData, PaymentsCaptureData, PaymentsResponseData, PaymentsSyncData,
RefundFlowData, RefundSyncData, RefundsData, RefundsResponseData, RepeatPaymentData,
ResponseId,
},
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,
};
use error_stack::ResultExt;
use hyperswitch_masking::{ExposeInterface, PeekInterface, Secret};
use serde::{Deserialize, Serialize};
use crate::{connectors::worldpay::WorldpayRouterData, types::ResponseRouterData};
// Define ForeignTryFrom trait locally
pub trait ForeignTryFrom<T>: Sized {
type Error;
fn foreign_try_from(value: T) -> Result<Self, Self::Error>;
}
use super::requests::*;
use super::response::*;
// Form field keys
const FORM_FIELD_JWT: &str = "JWT";
const FORM_FIELD_BIN: &str = "Bin";
// Metadata keys
const METADATA_LINK_DATA: &str = "link_data";
const METADATA_3DS_STAGE: &str = "3ds_stage";
const METADATA_3DS_VERSION: &str = "3ds_version";
const METADATA_ECI: &str = "eci";
const METADATA_AUTH_APPLIED: &str = "authentication_applied";
const METADATA_DDC_REFERENCE: &str = "device_data_collection";
// 3DS stage values
const STAGE_DDC: &str = "ddc";
const STAGE_CHALLENGE: &str = "challenge";
/// Metadata object extracted from merchant_account_metadata
/// Contains Worldpay-specific merchant configuration
#[derive(Debug, Default, Serialize, Deserialize)]
pub struct WorldpayConnectorMetadataObject {
pub merchant_name: Option<Secret<String>>,
}
impl TryFrom<Option<&pii::SecretSerdeValue>> for WorldpayConnectorMetadataObject {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(meta_data: Option<&pii::SecretSerdeValue>) -> Result<Self, Self::Error> {
let metadata: Self =
crate::utils::to_connector_meta_from_secret::<Self>(meta_data.cloned())
.change_context(errors::ConnectorError::InvalidConnectorConfig {
config: "merchant_account_metadata",
})?;
Ok(metadata)
}
}
fn fetch_payment_instrument<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>(
payment_method: PaymentMethodData<T>,
billing_address: Option<&domain_types::payment_address::Address>,
) -> CustomResult<PaymentInstrument<T>, errors::ConnectorError> {
match payment_method {
PaymentMethodData::Card(card) => {
// Extract expiry month and year using helper functions
let expiry_month_i8 = card.get_expiry_month_as_i8()?;
let expiry_year_4_digit = card.get_expiry_year_4_digit();
let expiry_year: i32 = expiry_year_4_digit
.peek()
.parse::<i32>()
.change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
Ok(PaymentInstrument::Card(CardPayment {
raw_card_details: RawCardDetails {
payment_type: PaymentType::Plain,
expiry_date: ExpiryDate {
month: expiry_month_i8,
year: Secret::new(expiry_year),
},
card_number: card.card_number,
},
cvc: card.card_cvc,
card_holder_name: billing_address
.and_then(|address| address.get_optional_full_name()),
billing_address: billing_address
.and_then(|addr| addr.address.clone())
.and_then(|address| {
match (address.line1, address.city, address.zip, address.country) {
(Some(address1), Some(city), Some(postal_code), Some(country_code)) => {
| {
"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_9109066662545807561_1 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/worldpay/transformers.rs
Some(BillingAddress {
address1,
address2: address.line2,
address3: address.line3,
city,
state: address.state,
postal_code,
country_code,
})
}
_ => None,
}
}),
}))
}
PaymentMethodData::CardDetailsForNetworkTransactionId(raw_card_details) => {
// Extract expiry month and year using helper functions
let expiry_month_i8 = raw_card_details.get_expiry_month_as_i8()?;
let expiry_year_4_digit = raw_card_details.get_expiry_year_4_digit();
let expiry_year: i32 = expiry_year_4_digit
.peek()
.parse::<i32>()
.change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
Ok(PaymentInstrument::RawCardForNTI(RawCardDetails {
payment_type: PaymentType::Plain,
expiry_date: ExpiryDate {
month: expiry_month_i8,
year: Secret::new(expiry_year),
},
card_number: RawCardNumber(raw_card_details.card_number),
}))
}
PaymentMethodData::MandatePayment => {
Err(errors::ConnectorError::NotImplemented(
"MandatePayment should not be used in Authorize flow - use RepeatPayment flow for MIT transactions".to_string()
).into())
}
PaymentMethodData::Wallet(wallet) => match wallet {
WalletDataPaymentMethod::GooglePay(data) => {
Ok(PaymentInstrument::Googlepay(WalletPayment {
payment_type: PaymentType::Encrypted,
wallet_token: Secret::new(
data.tokenization_data
.get_encrypted_google_pay_token()
.change_context(errors::ConnectorError::MissingRequiredField {
field_name: "gpay wallet_token",
})?,
),
..WalletPayment::default()
}))
}
WalletDataPaymentMethod::ApplePay(data) => {
Ok(PaymentInstrument::Applepay(WalletPayment {
payment_type: PaymentType::Encrypted,
wallet_token: data.get_applepay_decoded_payment_data()?,
..WalletPayment::default()
}))
}
WalletDataPaymentMethod::AliPayQr(_)
| 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::PaypalRedirect(_)
| WalletDataPaymentMethod::PaypalSdk(_)
| WalletDataPaymentMethod::Paze(_)
| WalletDataPaymentMethod::SamsungPay(_)
| WalletDataPaymentMethod::TwintRedirect {}
| WalletDataPaymentMethod::VippsRedirect {}
| WalletDataPaymentMethod::TouchNGoRedirect(_)
| WalletDataPaymentMethod::WeChatPayRedirect(_)
| WalletDataPaymentMethod::CashappQr(_)
| WalletDataPaymentMethod::SwishQr(_)
| WalletDataPaymentMethod::WeChatPayQr(_)
| WalletDataPaymentMethod::Mifinity(_)
| {
"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_9109066662545807561_2 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/worldpay/transformers.rs
| WalletDataPaymentMethod::RevolutPay(_)
| WalletDataPaymentMethod::BluecodeRedirect {} => {
Err(errors::ConnectorError::NotImplemented(
utils::get_unimplemented_payment_method_error_message("worldpay"),
)
.into())
}
},
PaymentMethodData::PayLater(_)
| PaymentMethodData::BankRedirect(_)
| PaymentMethodData::BankDebit(_)
| PaymentMethodData::BankTransfer(_)
| PaymentMethodData::Crypto(_)
| PaymentMethodData::Reward
| PaymentMethodData::RealTimePayment(_)
| PaymentMethodData::MobilePayment(_)
| PaymentMethodData::Upi(_)
| PaymentMethodData::Voucher(_)
| PaymentMethodData::CardRedirect(_)
| PaymentMethodData::GiftCard(_)
| PaymentMethodData::OpenBanking(_)
| PaymentMethodData::CardToken(_)
| PaymentMethodData::NetworkToken(_) => Err(errors::ConnectorError::NotImplemented(
utils::get_unimplemented_payment_method_error_message("worldpay"),
)
.into()),
}
}
impl TryFrom<(enums::PaymentMethod, Option<enums::PaymentMethodType>)> for PaymentMethod {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
src: (enums::PaymentMethod, Option<enums::PaymentMethodType>),
) -> Result<Self, Self::Error> {
match (src.0, src.1) {
(enums::PaymentMethod::Card, _) => Ok(Self::Card),
(enums::PaymentMethod::Wallet, pmt) => {
let pm = pmt.ok_or(errors::ConnectorError::MissingRequiredField {
field_name: "payment_method_type",
})?;
match pm {
enums::PaymentMethodType::ApplePay => Ok(Self::ApplePay),
enums::PaymentMethodType::GooglePay => Ok(Self::GooglePay),
_ => Err(errors::ConnectorError::NotImplemented(
utils::get_unimplemented_payment_method_error_message("worldpay"),
)
.into()),
}
}
_ => Err(errors::ConnectorError::NotImplemented(
utils::get_unimplemented_payment_method_error_message("worldpay"),
)
.into()),
}
}
}
// Helper function to create ThreeDS request for RouterDataV2
fn create_three_ds_request<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>(
router_data: &RouterDataV2<
Authorize,
PaymentFlowData,
PaymentsAuthorizeData<T>,
PaymentsResponseData,
>,
is_mandate_payment: bool,
) -> Result<Option<ThreeDSRequest>, error_stack::Report<errors::ConnectorError>> {
match (
&router_data.resource_common_data.auth_type,
&router_data.request.payment_method_data,
) {
// 3DS for NTI flow
(_, PaymentMethodData::CardDetailsForNetworkTransactionId(_)) => Ok(None),
// 3DS for regular payments
(enums::AuthenticationType::ThreeDs, _) => {
let browser_info = router_data.request.browser_info.as_ref().ok_or(
errors::ConnectorError::MissingRequiredField {
field_name: "browser_info",
},
)?;
let accept_header = browser_info
.accept_header
.clone()
.get_required_value("accept_header")
.change_context(errors::ConnectorError::MissingRequiredField {
field_name: "accept_header",
})?;
let user_agent_header = browser_info
.user_agent
.clone()
.get_required_value("user_agent")
.change_context(errors::ConnectorError::MissingRequiredField {
field_name: "user_agent",
})?;
let channel = Some(ThreeDSRequestChannel::Browser);
Ok(Some(ThreeDSRequest {
three_ds_type: super::requests::THREE_DS_TYPE.to_string(),
mode: super::requests::THREE_DS_MODE.to_string(),
device_data: ThreeDSRequestDeviceData {
accept_header,
| {
"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
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.