id stringlengths 20 153 | type stringclasses 1
value | granularity stringclasses 14
values | content stringlengths 16 84.3k | metadata dict |
|---|---|---|---|---|
connector-service_mini_connector-integration_-8961258080012439964_2 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/fiserv.rs
request_body: FiservCaptureRequest,
response_body: FiservCaptureResponse,
router_data: RouterDataV2<Capture, PaymentFlowData, PaymentsCaptureData, PaymentsResponseData>,
),
(
flow: Void,
request_body: FiservVoidRequest,
response_body: FiservVoidResponse,
router_data: RouterDataV2<Void, PaymentFlowData, PaymentVoidData, PaymentsResponseData>,
),
(
flow: Refund,
request_body: FiservRefundRequest,
response_body: FiservRefundResponse,
router_data: RouterDataV2<Refund, RefundFlowData, RefundsData, RefundsResponseData>,
),
(
flow: RSync,
request_body: FiservRefundSyncRequest,
response_body: FiservRefundSyncResponse,
router_data: RouterDataV2<RSync, RefundFlowData, RefundSyncData, RefundsResponseData>,
)
],
amount_converters: [
amount_converter: FloatMajorUnit
],
member_functions: {
pub fn generate_authorization_signature(
&self,
auth: &self::transformers::FiservAuthType,
client_request_id: &str,
payload_str: &str,
timestamp_ms: i128,
) -> CustomResult<String, errors::ConnectorError> {
let raw_signature = format!(
"{}{}{}{}",
auth.api_key.peek(),
client_request_id,
timestamp_ms,
payload_str
);
let key = hmac::Key::new(hmac::HMAC_SHA256, auth.api_secret.clone().expose().as_bytes());
let tag = hmac::sign(&key, raw_signature.as_bytes());
Ok(BASE64_STANDARD_ENGINE.encode(tag.as_ref()))
}
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 temp_request_body_for_sig = self.get_request_body(req)?;
let payload_string_for_sig = match temp_request_body_for_sig {
Some(RequestContent::Json(json_body)) => serde_json::to_string(&json_body)
.change_context(errors::ConnectorError::RequestEncodingFailed)
.attach_printable("Failed to serialize JSON request body for signature")?,
Some(RequestContent::FormUrlEncoded(form_body)) => serde_urlencoded::to_string(&form_body)
.change_context(errors::ConnectorError::RequestEncodingFailed)
.attach_printable("Failed to serialize form request body for signature")?,
None => "".to_string(),
_ => return Err(errors::ConnectorError::RequestEncodingFailed)
.attach_printable("Unsupported request body type for signature generation")?,
};
let timestamp_ms = OffsetDateTime::now_utc().unix_timestamp_nanos() / 1_000_000;
let client_request_id = Uuid::new_v4().to_string();
let auth_type_for_sig = self::transformers::FiservAuthType::try_from(&req.connector_auth_type)
.change_context(errors::ConnectorError::FailedToObtainAuthType)?;
let signature = self.generate_authorization_signature(
&auth_type_for_sig,
&client_request_id,
&payload_string_for_sig,
timestamp_ms,
)?;
// Step 4: Build and return the headers
let mut http_headers = vec![
(headers::CONTENT_TYPE.to_string(), self.common_get_content_type().into()),
(headers::CLIENT_REQUEST_ID.to_string(), client_request_id.into()),
(headers::TIMESTAMP.to_string(), timestamp_ms.to_string().into()),
(headers::AUTH_TOKEN_TYPE.to_string(), "HMAC".to_string().into()),
(headers::AUTHORIZATION.to_string(), signature.into_masked()),
];
let mut api_key_header = self.get_auth_header(&req.connector_auth_type)?;
http_headers.append(&mut api_key_header);
Ok(http_headers)
}
| {
"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_-8961258080012439964_3 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/fiserv.rs
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.fiserv.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.fiserv.base_url
}
}
);
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> ConnectorCommon for Fiserv<T>
{
fn id(&self) -> &'static str {
"fiserv"
}
fn common_get_content_type(&self) -> &'static str {
"application/json"
}
fn base_url<'a>(&self, connectors: &'a Connectors) -> &'a str {
connectors.fiserv.base_url.as_ref()
}
fn get_auth_header(
&self,
auth_type: &ConnectorAuthType,
) -> CustomResult<Vec<(String, Maskable<String>)>, errors::ConnectorError> {
let auth: self::transformers::FiservAuthType =
self::transformers::FiservAuthType::try_from(auth_type)
.change_context(errors::ConnectorError::FailedToObtainAuthType)?;
Ok(vec![(
headers::API_KEY.to_string(),
auth.api_key.clone().into_masked(),
)])
}
fn build_error_response(
&self,
res: Response,
event_builder: Option<&mut events::Event>,
) -> CustomResult<ErrorResponse, errors::ConnectorError> {
let response: self::transformers::FiservErrorResponse = res
.response
.parse_struct("FiservErrorResponse")
.change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
with_error_response_body!(event_builder, response);
let first_error_detail = response
.error
.as_ref()
.or(response.details.as_ref())
.and_then(|e| e.first());
Ok(ErrorResponse {
status_code: res.status_code,
code: first_error_detail
.and_then(|e| e.code.clone())
.unwrap_or_else(|| NO_ERROR_CODE.to_string()),
message: first_error_detail.map_or(NO_ERROR_MESSAGE.to_string(), |e| e.message.clone()),
reason: first_error_detail.and_then(|e| e.field.clone()),
attempt_status: None,
connector_transaction_id: None,
network_decline_code: None,
network_advice_code: None,
network_error_message: None,
})
}
}
macros::macro_connector_implementation!(
connector_default_implementations: [get_content_type, get_error_response_v2],
connector: Fiserv,
curl_request: Json(FiservPaymentsRequest),
curl_response: FiservPaymentsResponse,
flow_name: Authorize,
resource_common_data: PaymentFlowData,
flow_request: PaymentsAuthorizeData<T>,
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<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!(
"{}ch/payments/v1/charges",
self.connector_base_url_payments(req)
))
}
}
);
macros::macro_connector_implementation!(
connector_default_implementations: [get_content_type, get_error_response_v2],
connector: Fiserv,
curl_request: Json(FiservSyncRequest),
curl_response: FiservSyncResponse,
flow_name: PSync,
resource_common_data: PaymentFlowData,
flow_request: PaymentsSyncData,
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_-8961258080012439964_4 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/fiserv.rs
[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!(
"{}ch/payments/v1/transaction-inquiry",
self.connector_base_url_payments(req)
))
}
}
);
macros::macro_connector_implementation!(
connector_default_implementations: [get_content_type, get_error_response_v2],
connector: Fiserv,
curl_request: Json(FiservCaptureRequest),
curl_response: FiservCaptureResponse,
flow_name: Capture,
resource_common_data: PaymentFlowData,
flow_request: PaymentsCaptureData,
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<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!(
"{}ch/payments/v1/charges",
self.connector_base_url_payments(req)
))
}
}
);
macros::macro_connector_implementation!(
connector_default_implementations: [get_content_type, get_error_response_v2],
connector: Fiserv,
curl_request: Json(FiservVoidRequest),
curl_response: FiservVoidResponse,
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> {
Ok(format!(
"{}ch/payments/v1/cancels",
self.connector_base_url_payments(req)
))
}
}
);
macros::macro_connector_implementation!(
connector_default_implementations: [get_content_type, get_error_response_v2],
connector: Fiserv,
curl_request: Json(FiservRefundRequest),
curl_response: FiservRefundResponse,
flow_name: Refund,
resource_common_data: RefundFlowData,
flow_request: RefundsData,
flow_response: RefundsResponseData,
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<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!(
"{}ch/payments/v1/refunds",
self.connector_base_url_refunds(req)
))
}
}
);
macros::macro_connector_implementation!(
| {
"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_-8961258080012439964_5 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/fiserv.rs
connector_default_implementations: [get_content_type, get_error_response_v2],
connector: Fiserv,
curl_request: Json(FiservRefundSyncRequest),
curl_response: FiservRefundSyncResponse,
flow_name: RSync,
resource_common_data: RefundFlowData,
flow_request: RefundSyncData,
flow_response: RefundsResponseData,
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<RSync, RefundFlowData, RefundSyncData, RefundsResponseData>,
) -> CustomResult<Vec<(String, Maskable<String>)>, errors::ConnectorError> {
self.build_headers(req)
}
fn get_url(
&self,
req: &RouterDataV2<domain_types::connector_flow::RSync, RefundFlowData, RefundSyncData, RefundsResponseData>,
) -> CustomResult<String, errors::ConnectorError> {
Ok(format!(
"{}ch/payments/v1/transaction-inquiry",
self.connector_base_url_refunds(req)
))
}
}
);
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
ConnectorIntegrationV2<
CreateOrder,
PaymentFlowData,
PaymentCreateOrderData,
PaymentCreateOrderResponse,
> for Fiserv<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
ConnectorIntegrationV2<
SetupMandate,
PaymentFlowData,
SetupMandateRequestData<T>,
PaymentsResponseData,
> for Fiserv<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> ConnectorIntegrationV2<Accept, DisputeFlowData, AcceptDisputeData, DisputeResponseData>
for Fiserv<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
ConnectorIntegrationV2<SubmitEvidence, DisputeFlowData, SubmitEvidenceData, DisputeResponseData>
for Fiserv<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> ConnectorIntegrationV2<DefendDispute, DisputeFlowData, DisputeDefendData, DisputeResponseData>
for Fiserv<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
ConnectorIntegrationV2<
PaymentMethodToken,
PaymentFlowData,
PaymentMethodTokenizationData<T>,
PaymentMethodTokenResponse,
> for Fiserv<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 Fiserv<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
interfaces::verification::SourceVerification<
PSync,
PaymentFlowData,
PaymentsSyncData,
PaymentsResponseData,
> for Fiserv<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
interfaces::verification::SourceVerification<
Capture,
PaymentFlowData,
PaymentsCaptureData,
PaymentsResponseData,
> for Fiserv<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
| {
"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_-8961258080012439964_6 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/fiserv.rs
interfaces::verification::SourceVerification<
Void,
PaymentFlowData,
PaymentVoidData,
PaymentsResponseData,
> for Fiserv<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
interfaces::verification::SourceVerification<
Refund,
RefundFlowData,
RefundsData,
RefundsResponseData,
> for Fiserv<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
interfaces::verification::SourceVerification<
RSync,
RefundFlowData,
RefundSyncData,
RefundsResponseData,
> for Fiserv<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
interfaces::verification::SourceVerification<
SetupMandate,
PaymentFlowData,
SetupMandateRequestData<T>,
PaymentsResponseData,
> for Fiserv<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
interfaces::verification::SourceVerification<
Accept,
DisputeFlowData,
AcceptDisputeData,
DisputeResponseData,
> for Fiserv<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
interfaces::verification::SourceVerification<
SubmitEvidence,
DisputeFlowData,
SubmitEvidenceData,
DisputeResponseData,
> for Fiserv<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
interfaces::verification::SourceVerification<
DefendDispute,
DisputeFlowData,
DisputeDefendData,
DisputeResponseData,
> for Fiserv<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
interfaces::verification::SourceVerification<
CreateOrder,
PaymentFlowData,
PaymentCreateOrderData,
PaymentCreateOrderResponse,
> for Fiserv<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
interfaces::verification::SourceVerification<
CreateSessionToken,
PaymentFlowData,
SessionTokenRequestData,
SessionTokenResponseData,
> for Fiserv<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
interfaces::verification::SourceVerification<
CreateAccessToken,
PaymentFlowData,
AccessTokenRequestData,
AccessTokenResponseData,
> for Fiserv<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
interfaces::verification::SourceVerification<
CreateConnectorCustomer,
PaymentFlowData,
ConnectorCustomerData,
ConnectorCustomerResponse,
> for Fiserv<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
ConnectorIntegrationV2<
VoidPC,
PaymentFlowData,
PaymentsCancelPostCaptureData,
PaymentsResponseData,
> for Fiserv<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
interfaces::verification::SourceVerification<
VoidPC,
PaymentFlowData,
PaymentsCancelPostCaptureData,
PaymentsResponseData,
> for Fiserv<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_-8961258080012439964_7 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/fiserv.rs
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> ConnectorSpecifications for Fiserv<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
interfaces::verification::SourceVerification<
PaymentMethodToken,
PaymentFlowData,
PaymentMethodTokenizationData<T>,
PaymentMethodTokenResponse,
> for Fiserv<T>
{
}
// We already have an implementation for ValidationTrait above
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
interfaces::verification::SourceVerification<
RepeatPayment,
PaymentFlowData,
RepeatPaymentData,
PaymentsResponseData,
> for Fiserv<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
ConnectorIntegrationV2<RepeatPayment, PaymentFlowData, RepeatPaymentData, PaymentsResponseData>
for Fiserv<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
ConnectorIntegrationV2<
CreateSessionToken,
PaymentFlowData,
SessionTokenRequestData,
SessionTokenResponseData,
> for Fiserv<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
ConnectorIntegrationV2<
CreateAccessToken,
PaymentFlowData,
AccessTokenRequestData,
AccessTokenResponseData,
> for Fiserv<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
ConnectorIntegrationV2<
CreateConnectorCustomer,
PaymentFlowData,
ConnectorCustomerData,
ConnectorCustomerResponse,
> for Fiserv<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
ConnectorIntegrationV2<
PreAuthenticate,
PaymentFlowData,
PaymentsPreAuthenticateData<T>,
PaymentsResponseData,
> for Fiserv<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
ConnectorIntegrationV2<
Authenticate,
PaymentFlowData,
PaymentsAuthenticateData<T>,
PaymentsResponseData,
> for Fiserv<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
ConnectorIntegrationV2<
PostAuthenticate,
PaymentFlowData,
PaymentsPostAuthenticateData<T>,
PaymentsResponseData,
> for Fiserv<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
interfaces::verification::SourceVerification<
PreAuthenticate,
PaymentFlowData,
PaymentsPreAuthenticateData<T>,
PaymentsResponseData,
> for Fiserv<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
interfaces::verification::SourceVerification<
Authenticate,
PaymentFlowData,
PaymentsAuthenticateData<T>,
PaymentsResponseData,
> for Fiserv<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
interfaces::verification::SourceVerification<
PostAuthenticate,
PaymentFlowData,
| {
"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_-6237025837336624155_0 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/razorpay.rs
pub mod test;
pub mod transformers;
use std::sync::LazyLock;
use common_enums::{
AttemptStatus, CaptureMethod, CardNetwork, EventClass, PaymentMethod, PaymentMethodType,
};
use common_utils::{
errors::CustomResult,
events,
ext_traits::ByteSliceExt,
pii::SecretSerdeValue,
request::{Method, RequestContent},
types::{AmountConvertor, MinorUnit},
};
use domain_types::{
connector_flow::{
Accept, Authenticate, Authorize, Capture, CreateAccessToken, CreateConnectorCustomer,
CreateOrder, CreateSessionToken, DefendDispute, PSync, PaymentMethodToken,
PostAuthenticate, PreAuthenticate, RSync, Refund, 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, RequestDetails, ResponseId, SessionTokenRequestData,
SessionTokenResponseData, SetupMandateRequestData, SubmitEvidenceData,
SupportedPaymentMethodsExt, WebhookDetailsResponse,
},
errors,
payment_method_data::{DefaultPCIHolder, PaymentMethodData, PaymentMethodDataTypes},
router_data::{ConnectorAuthType, ErrorResponse},
router_data_v2::RouterDataV2,
router_response_types::Response,
types::{
CardSpecificFeatures, ConnectorInfo, Connectors, FeatureStatus, PaymentConnectorCategory,
PaymentMethodDataType, PaymentMethodDetails, PaymentMethodSpecificFeatures,
SupportedPaymentMethods,
},
};
use error_stack::{report, ResultExt};
use hyperswitch_masking::{Mask, Maskable};
use interfaces::{
api::ConnectorCommon,
connector_integration_v2::ConnectorIntegrationV2,
connector_types::{self, is_mandate_supported},
};
use serde::Serialize;
use transformers::{self as razorpay, ForeignTryFrom};
use crate::{
connectors::razorpayv2::transformers::RazorpayV2SyncResponse, with_error_response_body,
with_response_body,
};
pub(crate) mod headers {
pub(crate) const CONTENT_TYPE: &str = "Content-Type";
pub(crate) const AUTHORIZATION: &str = "Authorization";
pub(crate) const ACCEPT: &str = "Accept";
}
#[derive(Clone)]
pub struct Razorpay<T> {
#[allow(dead_code)]
pub(crate) amount_converter: &'static (dyn AmountConvertor<Output = MinorUnit> + Sync),
#[allow(dead_code)]
_phantom: std::marker::PhantomData<T>,
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> connector_types::ValidationTrait for Razorpay<T>
{
fn should_do_order_create(&self) -> bool {
true
}
}
// Type alias for non-generic trait implementations
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> connector_types::ConnectorServiceTrait<T> for Razorpay<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> connector_types::PaymentAuthorizeV2<T> for Razorpay<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> connector_types::PaymentSessionToken for Razorpay<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> connector_types::PaymentAccessToken for Razorpay<T>
{
}
impl<
T: PaymentMethodDataTypes
| {
"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_-6237025837336624155_1 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/razorpay.rs
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> connector_types::CreateConnectorCustomer for Razorpay<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> connector_types::PaymentSyncV2 for Razorpay<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> connector_types::PaymentOrderCreate for Razorpay<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> connector_types::PaymentVoidV2 for Razorpay<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> connector_types::RefundSyncV2 for Razorpay<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> connector_types::RefundV2 for Razorpay<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> connector_types::PaymentCapture for Razorpay<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> connector_types::SetupMandateV2<T> for Razorpay<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> connector_types::AcceptDispute for Razorpay<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> connector_types::SubmitEvidenceV2 for Razorpay<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> connector_types::DisputeDefend for Razorpay<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> connector_types::RepeatPaymentV2 for Razorpay<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> connector_types::PaymentVoidPostCaptureV2 for Razorpay<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
ConnectorIntegrationV2<
VoidPC,
PaymentFlowData,
PaymentsCancelPostCaptureData,
PaymentsResponseData,
> for Razorpay<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> connector_types::PaymentTokenV2<T> for Razorpay<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> connector_types::PaymentPreAuthenticateV2<T> for Razorpay<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> connector_types::PaymentAuthenticateV2<T> for Razorpay<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> connector_types::PaymentPostAuthenticateV2<T> for Razorpay<T>
{
}
impl<T> Razorpay<T> {
pub const fn new() -> &'static Self {
&Self {
| {
"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_-6237025837336624155_2 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/razorpay.rs
amount_converter: &common_utils::types::MinorUnitForConnector,
_phantom: std::marker::PhantomData,
}
}
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> ConnectorCommon for Razorpay<T>
{
fn id(&self) -> &'static str {
"razorpay"
}
fn get_currency_unit(&self) -> common_enums::CurrencyUnit {
common_enums::CurrencyUnit::Minor
}
fn get_auth_header(
&self,
auth_type: &ConnectorAuthType,
) -> CustomResult<Vec<(String, Maskable<String>)>, errors::ConnectorError> {
let auth = razorpay::RazorpayAuthType::try_from(auth_type)
.change_context(errors::ConnectorError::FailedToObtainAuthType)?;
Ok(vec![(
headers::AUTHORIZATION.to_string(),
auth.generate_authorization_header().into_masked(),
)])
}
fn base_url<'a>(&self, connectors: &'a Connectors) -> &'a str {
connectors.razorpay.base_url.as_ref()
}
fn build_error_response(
&self,
res: Response,
event_builder: Option<&mut events::Event>,
) -> CustomResult<ErrorResponse, errors::ConnectorError> {
let response: razorpay::RazorpayErrorResponse = res
.response
.parse_struct("ErrorResponse")
.map_err(|_| errors::ConnectorError::ResponseDeserializationFailed)?;
with_error_response_body!(event_builder, response);
let (code, message, reason, attempt_status) = match response {
razorpay::RazorpayErrorResponse::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, error.reason, attempt_status)
}
razorpay::RazorpayErrorResponse::SimpleError { message } => {
// For simple error messages like "no Route matched with those values"
// Default to a generic error code
(
"ROUTE_ERROR".to_string(),
message.clone(),
Some(message.clone()),
AttemptStatus::Failure,
)
}
};
Ok(ErrorResponse {
status_code: res.status_code,
code,
message: message.clone(),
reason,
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<
Authorize,
PaymentFlowData,
PaymentsAuthorizeData<T>,
PaymentsResponseData,
> for Razorpay<T>
{
fn get_headers(
&self,
req: &RouterDataV2<
Authorize,
PaymentFlowData,
PaymentsAuthorizeData<T>,
PaymentsResponseData,
>,
) -> CustomResult<Vec<(String, Maskable<String>)>, errors::ConnectorError>
where
Self: ConnectorIntegrationV2<
Authorize,
PaymentFlowData,
PaymentsAuthorizeData<T>,
PaymentsResponseData,
>,
{
let mut header = vec![
(
headers::CONTENT_TYPE.to_string(),
"application/x-www-form-urlencoded".to_string().into(),
),
(
headers::ACCEPT.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)
}
fn get_url(
&self,
| {
"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_-6237025837336624155_3 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/razorpay.rs
req: &RouterDataV2<
Authorize,
PaymentFlowData,
PaymentsAuthorizeData<T>,
PaymentsResponseData,
>,
) -> CustomResult<String, errors::ConnectorError> {
let base_url = &req.resource_common_data.connectors.razorpay.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/create/json")),
}
}
fn get_request_body(
&self,
req: &RouterDataV2<
Authorize,
PaymentFlowData,
PaymentsAuthorizeData<T>,
PaymentsResponseData,
>,
) -> CustomResult<Option<RequestContent>, errors::ConnectorError> {
let converted_amount = self
.amount_converter
.convert(req.request.minor_amount, req.request.currency)
.change_context(errors::ConnectorError::RequestEncodingFailed)?;
let connector_router_data =
razorpay::RazorpayRouterData::try_from((converted_amount, req))?;
match &req.request.payment_method_data {
PaymentMethodData::Upi(_) => {
let connector_req =
razorpay::RazorpayWebCollectRequest::try_from(&connector_router_data)?;
Ok(Some(RequestContent::FormUrlEncoded(Box::new(
connector_req,
))))
}
_ => {
let connector_req =
razorpay::RazorpayPaymentRequest::try_from(&connector_router_data)?;
Ok(Some(RequestContent::Json(Box::new(connector_req))))
}
}
}
fn handle_response_v2(
&self,
data: &RouterDataV2<
Authorize,
PaymentFlowData,
PaymentsAuthorizeData<T>,
PaymentsResponseData,
>,
event_builder: Option<&mut events::Event>,
res: Response,
) -> CustomResult<
RouterDataV2<Authorize, PaymentFlowData, PaymentsAuthorizeData<T>, PaymentsResponseData>,
errors::ConnectorError,
> {
// Handle UPI payments differently from regular payments
match &data.request.payment_method_data {
PaymentMethodData::Upi(_) => {
// Try to parse as UPI response first
let upi_response_result = res
.response
.parse_struct::<razorpay::RazorpayUpiPaymentsResponse>(
"RazorpayUpiPaymentsResponse",
);
match upi_response_result {
Ok(upi_response) => {
with_response_body!(event_builder, 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: razorpay::RazorpayResponse = res
.response
.parse_struct("RazorpayPaymentResponse")
.change_context(
errors::ConnectorError::ResponseDeserializationFailed,
)?;
with_response_body!(event_builder, response);
RouterDataV2::foreign_try_from((
response,
data.clone(),
res.status_code,
data.request.capture_method,
false,
data.request.payment_method_type,
))
.change_context(errors::ConnectorError::ResponseHandlingFailed)
}
}
}
_ => {
| {
"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_-6237025837336624155_4 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/razorpay.rs
// Regular payment response handling
let response: razorpay::RazorpayResponse = res
.response
.parse_struct("RazorpayPaymentResponse")
.map_err(|_| errors::ConnectorError::ResponseDeserializationFailed)?;
with_response_body!(event_builder, response);
RouterDataV2::foreign_try_from((
response,
data.clone(),
res.status_code,
data.request.capture_method,
false,
data.request.payment_method_type,
))
.change_context(errors::ConnectorError::ResponseHandlingFailed)
}
}
}
fn get_error_response_v2(
&self,
res: Response,
event_builder: Option<&mut events::Event>,
) -> CustomResult<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<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<PSync, PaymentFlowData, PaymentsSyncData, PaymentsResponseData>
for Razorpay<T>
{
fn get_http_method(&self) -> Method {
Method::Get
}
fn get_headers(
&self,
req: &RouterDataV2<PSync, PaymentFlowData, PaymentsSyncData, PaymentsResponseData>,
) -> CustomResult<Vec<(String, Maskable<String>)>, errors::ConnectorError>
where
Self: ConnectorIntegrationV2<
Authorize,
PaymentFlowData,
PaymentsAuthorizeData<T>,
PaymentsResponseData,
>,
{
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)
}
fn get_url(
&self,
req: &RouterDataV2<PSync, PaymentFlowData, PaymentsSyncData, PaymentsResponseData>,
) -> CustomResult<String, errors::ConnectorError> {
let base_url = &req.resource_common_data.connectors.razorpay.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 != "default_reference_id" {
// 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 = req
.request
.connector_transaction_id
.get_connector_transaction_id()
.change_context(errors::ConnectorError::RequestEncodingFailed)?;
let url = format!("{base_url}v1/payments/{payment_id}");
Ok(url)
}
}
fn handle_response_v2(
&self,
data: &RouterDataV2<PSync, PaymentFlowData, PaymentsSyncData, PaymentsResponseData>,
event_builder: Option<&mut events::Event>,
res: Response,
) -> CustomResult<
RouterDataV2<PSync, PaymentFlowData, PaymentsSyncData, PaymentsResponseData>,
errors::ConnectorError,
> {
// Parse the response using the enum that handles both collection and direct payment responses
let sync_response: RazorpayV2SyncResponse = res
.response
.parse_struct("RazorpayV2SyncResponse")
.change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
with_response_body!(event_builder, sync_response);
// Use the transformer for PSync response handling
RouterDataV2::foreign_try_from((
sync_response,
data.clone(),
res.status_code,
res.response.to_vec(),
))
| {
"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_-6237025837336624155_5 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/razorpay.rs
.change_context(errors::ConnectorError::ResponseHandlingFailed)
}
fn get_error_response_v2(
&self,
res: Response,
event_builder: Option<&mut events::Event>,
) -> CustomResult<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<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<
CreateOrder,
PaymentFlowData,
PaymentCreateOrderData,
PaymentCreateOrderResponse,
> for Razorpay<T>
{
fn get_headers(
&self,
req: &RouterDataV2<
CreateOrder,
PaymentFlowData,
PaymentCreateOrderData,
PaymentCreateOrderResponse,
>,
) -> CustomResult<Vec<(String, Maskable<String>)>, errors::ConnectorError> {
let mut header = vec![
(
headers::CONTENT_TYPE.to_string(),
"application/x-www-form-urlencoded".to_string().into(),
),
(
headers::ACCEPT.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)
}
fn get_url(
&self,
req: &RouterDataV2<
CreateOrder,
PaymentFlowData,
PaymentCreateOrderData,
PaymentCreateOrderResponse,
>,
) -> CustomResult<String, errors::ConnectorError> {
Ok(format!(
"{}v1/orders",
req.resource_common_data.connectors.razorpay.base_url
))
}
fn get_request_body(
&self,
req: &RouterDataV2<
CreateOrder,
PaymentFlowData,
PaymentCreateOrderData,
PaymentCreateOrderResponse,
>,
) -> CustomResult<Option<RequestContent>, errors::ConnectorError> {
let converted_amount = self
.amount_converter
.convert(req.request.amount, req.request.currency)
.change_context(errors::ConnectorError::RequestEncodingFailed)?;
let connector_router_data =
razorpay::RazorpayRouterData::try_from((converted_amount, req))?;
let connector_req = razorpay::RazorpayOrderRequest::try_from(&connector_router_data)?;
Ok(Some(RequestContent::FormUrlEncoded(Box::new(
connector_req,
))))
}
fn handle_response_v2(
&self,
data: &RouterDataV2<
CreateOrder,
PaymentFlowData,
PaymentCreateOrderData,
PaymentCreateOrderResponse,
>,
event_builder: Option<&mut events::Event>,
res: Response,
) -> CustomResult<
RouterDataV2<
CreateOrder,
PaymentFlowData,
PaymentCreateOrderData,
PaymentCreateOrderResponse,
>,
errors::ConnectorError,
> {
let response: razorpay::RazorpayOrderResponse = res
.response
.parse_struct("RazorpayOrderResponse")
.map_err(|_| errors::ConnectorError::ResponseDeserializationFailed)?;
with_response_body!(event_builder, response);
RouterDataV2::foreign_try_from((response, data.clone(), res.status_code, false))
.change_context(errors::ConnectorError::ResponseHandlingFailed)
}
fn get_error_response_v2(
&self,
res: Response,
event_builder: Option<&mut events::Event>,
) -> CustomResult<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<ErrorResponse, errors::ConnectorError> {
self.build_error_response(res, event_builder)
}
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
| {
"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_-6237025837336624155_6 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/razorpay.rs
+ Serialize,
> ConnectorIntegrationV2<RSync, RefundFlowData, RefundSyncData, RefundsResponseData>
for Razorpay<T>
{
fn get_http_method(&self) -> Method {
Method::Get
}
fn get_headers(
&self,
req: &RouterDataV2<RSync, RefundFlowData, RefundSyncData, RefundsResponseData>,
) -> CustomResult<Vec<(String, Maskable<String>)>, errors::ConnectorError>
where
Self: ConnectorIntegrationV2<RSync, RefundFlowData, RefundSyncData, RefundsResponseData>,
{
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)
}
fn get_url(
&self,
req: &RouterDataV2<RSync, RefundFlowData, RefundSyncData, RefundsResponseData>,
) -> CustomResult<String, errors::ConnectorError> {
let refund_id = req.request.connector_refund_id.clone();
Ok(format!(
"{}v1/refunds/{}",
req.resource_common_data.connectors.razorpay.base_url, refund_id
))
}
fn handle_response_v2(
&self,
data: &RouterDataV2<RSync, RefundFlowData, RefundSyncData, RefundsResponseData>,
event_builder: Option<&mut events::Event>,
res: Response,
) -> CustomResult<
RouterDataV2<RSync, RefundFlowData, RefundSyncData, RefundsResponseData>,
errors::ConnectorError,
> {
let response: razorpay::RazorpayRefundResponse = res
.response
.parse_struct("RazorpayRefundSyncResponse")
.change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
with_response_body!(event_builder, response);
RouterDataV2::foreign_try_from((response, data.clone(), res.status_code))
.change_context(errors::ConnectorError::ResponseHandlingFailed)
}
fn get_error_response_v2(
&self,
res: Response,
event_builder: Option<&mut events::Event>,
) -> CustomResult<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<ErrorResponse, errors::ConnectorError> {
self.build_error_response(res, event_builder)
}
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> connector_types::IncomingWebhook for Razorpay<T>
{
fn get_event_type(
&self,
request: RequestDetails,
_connector_webhook_secret: Option<ConnectorWebhookSecrets>,
_connector_account_details: Option<ConnectorAuthType>,
) -> Result<EventType, error_stack::Report<errors::ConnectorError>> {
let payload = transformers::get_webhook_object_from_body(request.body).map_err(|err| {
report!(errors::ConnectorError::WebhookBodyDecodingFailed)
.attach_printable(format!("error while decoing webhook body {err}"))
})?;
if payload.refund.is_some() {
Ok(EventType::RefundSuccess)
} else {
Ok(EventType::PaymentIntentSuccess)
}
}
fn process_payment_webhook(
&self,
request: RequestDetails,
_connector_webhook_secret: Option<ConnectorWebhookSecrets>,
_connector_account_details: Option<ConnectorAuthType>,
) -> Result<WebhookDetailsResponse, error_stack::Report<errors::ConnectorError>> {
let request_body_copy = request.body.clone();
let payload = transformers::get_webhook_object_from_body(request.body).map_err(|err| {
report!(errors::ConnectorError::WebhookBodyDecodingFailed)
.attach_printable(format!("error while decoding webhook body {err}"))
})?;
let notif = payload.payment.ok_or_else(|| {
error_stack::Report::new(errors::ConnectorError::RequestEncodingFailed)
})?;
Ok(WebhookDetailsResponse {
resource_id: Some(ResponseId::ConnectorTransactionId(notif.entity.order_id)),
status: transformers::get_razorpay_payment_webhook_status(
| {
"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_-6237025837336624155_7 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/razorpay.rs
notif.entity.entity,
notif.entity.status,
)?,
mandate_reference: None,
connector_response_reference_id: None,
error_code: notif.entity.error_code,
error_message: notif.entity.error_reason,
raw_connector_response: Some(String::from_utf8_lossy(&request_body_copy).to_string()),
status_code: 200,
response_headers: None,
transformation_status: common_enums::WebhookTransformationStatus::Complete,
minor_amount_captured: None,
amount_captured: None,
error_reason: None,
network_txn_id: None,
})
}
fn process_refund_webhook(
&self,
request: RequestDetails,
_connector_webhook_secret: Option<ConnectorWebhookSecrets>,
_connector_account_details: Option<ConnectorAuthType>,
) -> Result<RefundWebhookDetailsResponse, error_stack::Report<errors::ConnectorError>> {
let request_body_copy = request.body.clone();
let payload = transformers::get_webhook_object_from_body(request.body).map_err(|err| {
report!(errors::ConnectorError::WebhookBodyDecodingFailed)
.attach_printable(format!("error while decoing webhook body {err}"))
})?;
let notif = payload.refund.ok_or_else(|| {
error_stack::Report::new(errors::ConnectorError::RequestEncodingFailed)
})?;
Ok(RefundWebhookDetailsResponse {
connector_refund_id: Some(notif.entity.id),
status: transformers::get_razorpay_refund_webhook_status(
notif.entity.entity,
notif.entity.status,
)?,
connector_response_reference_id: None,
error_code: None,
error_message: None,
raw_connector_response: Some(String::from_utf8_lossy(&request_body_copy).to_string()),
status_code: 200,
response_headers: None,
})
}
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> ConnectorIntegrationV2<Void, PaymentFlowData, PaymentVoidData, PaymentsResponseData>
for Razorpay<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> ConnectorIntegrationV2<Refund, RefundFlowData, RefundsData, RefundsResponseData>
for Razorpay<T>
{
fn get_headers(
&self,
req: &RouterDataV2<Refund, RefundFlowData, RefundsData, RefundsResponseData>,
) -> CustomResult<Vec<(String, Maskable<String>)>, errors::ConnectorError>
where
Self: ConnectorIntegrationV2<Refund, RefundFlowData, RefundsData, RefundsResponseData>,
{
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)
}
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/{}/refund",
req.resource_common_data.connectors.razorpay.base_url, connector_payment_id
))
}
fn get_request_body(
&self,
req: &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 refund_router_data = razorpay::RazorpayRouterData::try_from((converted_amount, req))?;
let connector_req = razorpay::RazorpayRefundRequest::try_from(&refund_router_data)?;
Ok(Some(RequestContent::Json(Box::new(connector_req))))
}
fn handle_response_v2(
&self,
| {
"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_-6237025837336624155_8 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/razorpay.rs
data: &RouterDataV2<Refund, RefundFlowData, RefundsData, RefundsResponseData>,
event_builder: Option<&mut events::Event>,
res: Response,
) -> CustomResult<
RouterDataV2<Refund, RefundFlowData, RefundsData, RefundsResponseData>,
errors::ConnectorError,
> {
let response: razorpay::RazorpayRefundResponse = res
.response
.parse_struct("RazorpayRefundResponse")
.change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
with_response_body!(event_builder, response);
RouterDataV2::foreign_try_from((response, data.clone(), res.status_code))
.change_context(errors::ConnectorError::ResponseHandlingFailed)
}
fn get_error_response_v2(
&self,
res: Response,
event_builder: Option<&mut events::Event>,
) -> CustomResult<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<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<Capture, PaymentFlowData, PaymentsCaptureData, PaymentsResponseData>
for Razorpay<T>
{
fn get_headers(
&self,
req: &RouterDataV2<Capture, PaymentFlowData, PaymentsCaptureData, PaymentsResponseData>,
) -> CustomResult<Vec<(String, Maskable<String>)>, errors::ConnectorError>
where
Self: ConnectorIntegrationV2<
Capture,
PaymentFlowData,
PaymentsCaptureData,
PaymentsResponseData,
>,
{
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)
}
fn get_url(
&self,
req: &RouterDataV2<Capture, PaymentFlowData, PaymentsCaptureData, PaymentsResponseData>,
) -> CustomResult<String, errors::ConnectorError> {
let id = match &req.request.connector_transaction_id {
ResponseId::ConnectorTransactionId(id) => id,
_ => {
return Err(errors::ConnectorError::MissingConnectorTransactionID.into());
}
};
Ok(format!(
"{}v1/payments/{}/capture",
req.resource_common_data.connectors.razorpay.base_url, id
))
}
fn get_request_body(
&self,
req: &RouterDataV2<Capture, PaymentFlowData, PaymentsCaptureData, PaymentsResponseData>,
) -> CustomResult<Option<RequestContent>, errors::ConnectorError> {
let converted_amount = self
.amount_converter
.convert(req.request.minor_amount_to_capture, req.request.currency)
.change_context(errors::ConnectorError::RequestEncodingFailed)?;
let connector_router_data =
razorpay::RazorpayRouterData::try_from((converted_amount, req))?;
let connector_req = razorpay::RazorpayCaptureRequest::try_from(&connector_router_data)?;
Ok(Some(RequestContent::Json(Box::new(connector_req))))
}
fn handle_response_v2(
&self,
data: &RouterDataV2<Capture, PaymentFlowData, PaymentsCaptureData, PaymentsResponseData>,
event_builder: Option<&mut events::Event>,
res: Response,
) -> CustomResult<
RouterDataV2<Capture, PaymentFlowData, PaymentsCaptureData, PaymentsResponseData>,
errors::ConnectorError,
> {
let response: razorpay::RazorpayCaptureResponse = res
.response
.parse_struct("RazorpayCaptureResponse")
.map_err(|err| {
report!(errors::ConnectorError::ResponseDeserializationFailed)
.attach_printable(format!("Failed to parse RazorpayCaptureResponse: {err:?}"))
})?;
with_response_body!(event_builder, response);
RouterDataV2::foreign_try_from((response, data.clone(), res.status_code))
| {
"chunk": 8,
"crate": "connector-integration",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_mini_connector-integration_-6237025837336624155_9 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/razorpay.rs
.change_context(errors::ConnectorError::ResponseHandlingFailed)
}
fn get_error_response_v2(
&self,
res: Response,
event_builder: Option<&mut events::Event>,
) -> CustomResult<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<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 Razorpay<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> ConnectorIntegrationV2<Accept, DisputeFlowData, AcceptDisputeData, DisputeResponseData>
for Razorpay<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
ConnectorIntegrationV2<SubmitEvidence, DisputeFlowData, SubmitEvidenceData, DisputeResponseData>
for Razorpay<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> ConnectorIntegrationV2<DefendDispute, DisputeFlowData, DisputeDefendData, DisputeResponseData>
for Razorpay<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
ConnectorIntegrationV2<
PaymentMethodToken,
PaymentFlowData,
PaymentMethodTokenizationData<T>,
PaymentMethodTokenResponse,
> for Razorpay<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
ConnectorIntegrationV2<
PreAuthenticate,
PaymentFlowData,
PaymentsPreAuthenticateData<T>,
PaymentsResponseData,
> for Razorpay<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
ConnectorIntegrationV2<
Authenticate,
PaymentFlowData,
PaymentsAuthenticateData<T>,
PaymentsResponseData,
> for Razorpay<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
ConnectorIntegrationV2<
PostAuthenticate,
PaymentFlowData,
PaymentsPostAuthenticateData<T>,
PaymentsResponseData,
> for Razorpay<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 Razorpay<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
interfaces::verification::SourceVerification<
CreateSessionToken,
PaymentFlowData,
SessionTokenRequestData,
SessionTokenResponseData,
> for Razorpay<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
interfaces::verification::SourceVerification<
CreateAccessToken,
PaymentFlowData,
AccessTokenRequestData,
AccessTokenResponseData,
> for Razorpay<T>
{
}
impl<
T: PaymentMethodDataTypes
| {
"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_-6237025837336624155_10 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/razorpay.rs
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
interfaces::verification::SourceVerification<
CreateConnectorCustomer,
PaymentFlowData,
ConnectorCustomerData,
ConnectorCustomerResponse,
> for Razorpay<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
interfaces::verification::SourceVerification<
PSync,
PaymentFlowData,
PaymentsSyncData,
PaymentsResponseData,
> for Razorpay<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
interfaces::verification::SourceVerification<
Capture,
PaymentFlowData,
PaymentsCaptureData,
PaymentsResponseData,
> for Razorpay<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
interfaces::verification::SourceVerification<
Void,
PaymentFlowData,
PaymentVoidData,
PaymentsResponseData,
> for Razorpay<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
interfaces::verification::SourceVerification<
Refund,
RefundFlowData,
RefundsData,
RefundsResponseData,
> for Razorpay<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
interfaces::verification::SourceVerification<
RSync,
RefundFlowData,
RefundSyncData,
RefundsResponseData,
> for Razorpay<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
interfaces::verification::SourceVerification<
SetupMandate,
PaymentFlowData,
SetupMandateRequestData<T>,
PaymentsResponseData,
> for Razorpay<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
interfaces::verification::SourceVerification<
Accept,
DisputeFlowData,
AcceptDisputeData,
DisputeResponseData,
> for Razorpay<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
interfaces::verification::SourceVerification<
SubmitEvidence,
DisputeFlowData,
SubmitEvidenceData,
DisputeResponseData,
> for Razorpay<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
interfaces::verification::SourceVerification<
DefendDispute,
DisputeFlowData,
DisputeDefendData,
DisputeResponseData,
> for Razorpay<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
interfaces::verification::SourceVerification<
CreateOrder,
PaymentFlowData,
PaymentCreateOrderData,
PaymentCreateOrderResponse,
> for Razorpay<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
interfaces::verification::SourceVerification<
PaymentMethodToken,
PaymentFlowData,
PaymentMethodTokenizationData<T>,
PaymentMethodTokenResponse,
> for Razorpay<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
| {
"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_-6237025837336624155_11 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/razorpay.rs
+ Serialize,
>
interfaces::verification::SourceVerification<
PreAuthenticate,
PaymentFlowData,
PaymentsPreAuthenticateData<T>,
PaymentsResponseData,
> for Razorpay<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
interfaces::verification::SourceVerification<
Authenticate,
PaymentFlowData,
PaymentsAuthenticateData<T>,
PaymentsResponseData,
> for Razorpay<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
interfaces::verification::SourceVerification<
PostAuthenticate,
PaymentFlowData,
PaymentsPostAuthenticateData<T>,
PaymentsResponseData,
> for Razorpay<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
interfaces::verification::SourceVerification<
VoidPC,
PaymentFlowData,
PaymentsCancelPostCaptureData,
PaymentsResponseData,
> for Razorpay<T>
{
}
impl connector_types::ConnectorValidation for Razorpay<DefaultPCIHolder> {
fn validate_mandate_payment(
&self,
pm_type: Option<PaymentMethodType>,
pm_data: PaymentMethodData<DefaultPCIHolder>,
) -> CustomResult<(), errors::ConnectorError> {
let mandate_supported_pmd = std::collections::HashSet::from([PaymentMethodDataType::Card]);
is_mandate_supported(pm_data, pm_type, mandate_supported_pmd, self.id())
}
fn validate_psync_reference_id(
&self,
data: &PaymentsSyncData,
_is_three_ds: bool,
_status: AttemptStatus,
_connector_meta_data: Option<SecretSerdeValue>,
) -> CustomResult<(), errors::ConnectorError> {
if data.encoded_data.is_some() {
return Ok(());
}
Err(errors::ConnectorError::MissingRequiredField {
field_name: "encoded_data",
}
.into())
}
fn is_webhook_source_verification_mandatory(&self) -> bool {
false
}
}
static RAZORPAY_SUPPORTED_PAYMENT_METHODS: LazyLock<SupportedPaymentMethods> =
LazyLock::new(|| {
let razorpay_supported_capture_methods = vec![
CaptureMethod::Automatic,
CaptureMethod::Manual,
CaptureMethod::ManualMultiple,
// CaptureMethod::Scheduled,
];
let razorpay_supported_card_network = vec![
CardNetwork::Visa,
CardNetwork::Mastercard,
CardNetwork::AmericanExpress,
CardNetwork::Maestro,
CardNetwork::RuPay,
CardNetwork::DinersClub,
//have to add bajaj to this list too
// ref : https://razorpay.com/docs/payments/payment-methods/cards/
];
let mut razorpay_supported_payment_methods = SupportedPaymentMethods::new();
razorpay_supported_payment_methods.add(
PaymentMethod::Card,
PaymentMethodType::Debit,
PaymentMethodDetails {
mandates: FeatureStatus::NotSupported,
refunds: FeatureStatus::Supported,
supported_capture_methods: razorpay_supported_capture_methods.clone(),
specific_features: Some(PaymentMethodSpecificFeatures::Card(
CardSpecificFeatures {
three_ds: FeatureStatus::NotSupported,
no_three_ds: FeatureStatus::Supported,
supported_card_networks: razorpay_supported_card_network.clone(),
},
)),
},
);
razorpay_supported_payment_methods.add(
PaymentMethod::Card,
PaymentMethodType::Credit,
PaymentMethodDetails {
mandates: FeatureStatus::NotSupported,
refunds: FeatureStatus::Supported,
supported_capture_methods: razorpay_supported_capture_methods.clone(),
specific_features: Some(PaymentMethodSpecificFeatures::Card(
CardSpecificFeatures {
| {
"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_-6237025837336624155_12 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/razorpay.rs
three_ds: FeatureStatus::NotSupported,
no_three_ds: FeatureStatus::Supported,
supported_card_networks: razorpay_supported_card_network.clone(),
},
)),
},
);
razorpay_supported_payment_methods
});
static RAZORPAY_CONNECTOR_INFO: ConnectorInfo = ConnectorInfo {
display_name: "Razorpay",
description: "Razorpay is a payment gateway that allows businesses to accept, process, and disburse payments with its product suite.",
connector_type: PaymentConnectorCategory::PaymentGateway
};
static RAZORPAY_SUPPORTED_WEBHOOK_FLOWS: &[EventClass] =
&[EventClass::Payments, EventClass::Refunds];
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> ConnectorSpecifications for Razorpay<T>
{
fn get_connector_about(&self) -> Option<&'static ConnectorInfo> {
Some(&RAZORPAY_CONNECTOR_INFO)
}
fn get_supported_webhook_flows(&self) -> Option<&'static [EventClass]> {
Some(RAZORPAY_SUPPORTED_WEBHOOK_FLOWS)
}
fn get_supported_payment_methods(&self) -> Option<&'static SupportedPaymentMethods> {
Some(&RAZORPAY_SUPPORTED_PAYMENT_METHODS)
}
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
ConnectorIntegrationV2<
domain_types::connector_flow::RepeatPayment,
PaymentFlowData,
domain_types::connector_types::RepeatPaymentData,
PaymentsResponseData,
> for Razorpay<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
interfaces::verification::SourceVerification<
domain_types::connector_flow::RepeatPayment,
PaymentFlowData,
domain_types::connector_types::RepeatPaymentData,
PaymentsResponseData,
> for Razorpay<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
ConnectorIntegrationV2<
CreateSessionToken,
PaymentFlowData,
SessionTokenRequestData,
SessionTokenResponseData,
> for Razorpay<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
ConnectorIntegrationV2<
CreateAccessToken,
PaymentFlowData,
AccessTokenRequestData,
AccessTokenResponseData,
> for Razorpay<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
ConnectorIntegrationV2<
CreateConnectorCustomer,
PaymentFlowData,
ConnectorCustomerData,
ConnectorCustomerResponse,
> for Razorpay<T>
{
}
| {
"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_5316159584132742197_0 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/worldpay.rs
pub mod requests;
pub mod response;
pub mod transformers;
use self::requests::{
WorldpayAuthorizeRequest, WorldpayCaptureRequest, WorldpayPostAuthenticateRequest,
WorldpayPreAuthenticateRequest, WorldpayRefundRequest, WorldpayRepeatPaymentRequest,
};
use self::response::{
WorldpayAuthorizeResponse, WorldpayCaptureResponse, WorldpayErrorResponse,
WorldpayPostAuthenticateResponse, WorldpayPreAuthenticateResponse, WorldpayRefundResponse,
WorldpayRefundSyncResponse, WorldpayRepeatPaymentResponse, WorldpaySyncResponse,
WorldpayVoidResponse,
};
use common_utils::{errors::CustomResult, events, ext_traits::BytesExt};
use domain_types::{
connector_flow::{
Accept, Authorize, Capture, CreateOrder, CreateSessionToken, DefendDispute, PSync,
PostAuthenticate, PreAuthenticate, RSync, Refund, RepeatPayment, SetupMandate,
SubmitEvidence, Void, VoidPC,
},
connector_types::{
AcceptDisputeData, DisputeDefendData, DisputeFlowData, DisputeResponseData,
PaymentCreateOrderData, PaymentCreateOrderResponse, PaymentFlowData, PaymentVoidData,
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::{Mask, Maskable, PeekInterface};
use interfaces::{
api::ConnectorCommon, connector_integration_v2::ConnectorIntegrationV2, connector_types,
};
use serde::Serialize;
use std::fmt::Debug;
use transformers::{self as worldpay};
use super::macros;
use crate::{types::ResponseRouterData, with_error_response_body};
pub const BASE64_ENGINE: base64::engine::GeneralPurpose = base64::engine::general_purpose::STANDARD;
use error_stack::ResultExt;
// Trait implementations with generic type parameters
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::ConnectorServiceTrait<T> for Worldpay<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::PaymentAuthorizeV2<T> for Worldpay<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::PaymentSyncV2 for Worldpay<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::PaymentVoidV2 for Worldpay<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::PaymentVoidPostCaptureV2 for Worldpay<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::RefundSyncV2 for Worldpay<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::RefundV2 for Worldpay<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::PaymentCapture for Worldpay<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::ValidationTrait for Worldpay<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::PaymentOrderCreate for Worldpay<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::SetupMandateV2<T> for Worldpay<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::RepeatPaymentV2 for Worldpay<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::AcceptDispute for Worldpay<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::SubmitEvidenceV2 for Worldpay<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::DisputeDefend for Worldpay<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_5316159584132742197_1 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/worldpay.rs
connector_types::IncomingWebhook for Worldpay<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::PaymentSessionToken for Worldpay<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::PaymentPostAuthenticateV2<T> for Worldpay<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::PaymentAuthenticateV2<T> for Worldpay<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::PaymentPreAuthenticateV2<T> for Worldpay<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::PaymentTokenV2<T> for Worldpay<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::PaymentAccessToken for Worldpay<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::CreateConnectorCustomer for Worldpay<T>
{
}
pub(crate) mod headers {
pub(crate) const AUTHORIZATION: &str = "Authorization";
}
macros::create_all_prerequisites!(
connector_name: Worldpay,
generic_type: T,
api: [
(
flow: Authorize,
request_body: WorldpayAuthorizeRequest<T>,
response_body: WorldpayAuthorizeResponse,
router_data: RouterDataV2<Authorize, PaymentFlowData, PaymentsAuthorizeData<T>, PaymentsResponseData>,
),
(
flow: PSync,
response_body: WorldpaySyncResponse,
router_data: RouterDataV2<PSync, PaymentFlowData, PaymentsSyncData, PaymentsResponseData>,
),
(
flow: Capture,
request_body: WorldpayCaptureRequest,
response_body: WorldpayCaptureResponse,
router_data: RouterDataV2<Capture, PaymentFlowData, PaymentsCaptureData, PaymentsResponseData>,
),
(
flow: Void,
response_body: WorldpayVoidResponse,
router_data: RouterDataV2<Void, PaymentFlowData, PaymentVoidData, PaymentsResponseData>,
),
(
flow: Refund,
request_body: WorldpayRefundRequest,
response_body: WorldpayRefundResponse,
router_data: RouterDataV2<Refund, RefundFlowData, RefundsData, RefundsResponseData>,
),
(
flow: RSync,
response_body: WorldpayRefundSyncResponse,
router_data: RouterDataV2<RSync, RefundFlowData, RefundSyncData, RefundsResponseData>,
),
(
flow: PreAuthenticate,
request_body: WorldpayPreAuthenticateRequest,
response_body: WorldpayPreAuthenticateResponse,
router_data: RouterDataV2<PreAuthenticate, PaymentFlowData, PaymentsPreAuthenticateData<T>, PaymentsResponseData>,
),
(
flow: PostAuthenticate,
request_body: WorldpayPostAuthenticateRequest,
response_body: WorldpayPostAuthenticateResponse,
router_data: RouterDataV2<PostAuthenticate, PaymentFlowData, PaymentsPostAuthenticateData<T>, PaymentsResponseData>,
),
(
flow: RepeatPayment,
request_body: WorldpayRepeatPaymentRequest<T>,
response_body: WorldpayRepeatPaymentResponse,
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 headers = vec![
(
"Accept".to_string(),
self.get_content_type().to_string().into(),
),
(
"Content-Type".to_string(),
self.get_content_type().to_string().into(),
),
("WP-API-Version".to_string(), "2024-06-01".into()),
];
let mut api_key = self.get_auth_header(&req.connector_auth_type)?;
headers.append(&mut api_key);
Ok(headers)
| {
"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_5316159584132742197_2 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/worldpay.rs
}
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.worldpay.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.worldpay.base_url
}
/// Helper function to extract link_data from connector_meta_data
/// Used by PreAuthenticate and PostAuthenticate flows to avoid code duplication
pub fn extract_link_data_from_metadata<F, Req, Res>(
req: &RouterDataV2<F, PaymentFlowData, Req, Res>,
) -> Result<String, error_stack::Report<errors::ConnectorError>> {
let metadata_obj = req
.resource_common_data
.connector_meta_data
.as_ref()
.and_then(|metadata| metadata.peek().as_object())
.ok_or(errors::ConnectorError::MissingRequiredField {
field_name: "connector_meta_data",
})?;
metadata_obj
.get("link_data")
.and_then(|value| value.as_str())
.map(|s| s.to_string())
.ok_or(errors::ConnectorError::MissingRequiredField {
field_name: "connector_meta_data.link_data",
}.into())
}
}
);
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize> ConnectorCommon
for Worldpay<T>
{
fn id(&self) -> &'static str {
"worldpay"
}
fn get_currency_unit(&self) -> common_enums::CurrencyUnit {
common_enums::CurrencyUnit::Minor
}
fn common_get_content_type(&self) -> &'static str {
"application/json"
}
fn base_url<'a>(&self, connectors: &'a Connectors) -> &'a str {
connectors.worldpay.base_url.as_ref()
}
fn get_auth_header(
&self,
auth_type: &ConnectorAuthType,
) -> CustomResult<Vec<(String, hyperswitch_masking::Maskable<String>)>, errors::ConnectorError>
{
let auth = worldpay::WorldpayAuthType::try_from(auth_type)
.change_context(errors::ConnectorError::FailedToObtainAuthType)?;
Ok(vec![(
headers::AUTHORIZATION.to_string(),
auth.api_key.into_masked(),
)])
}
fn build_error_response(
&self,
res: Response,
event_builder: Option<&mut events::Event>,
) -> CustomResult<ErrorResponse, errors::ConnectorError> {
let response = if !res.response.is_empty() {
res.response
.parse_struct("WorldpayErrorResponse")
.change_context(errors::ConnectorError::ResponseDeserializationFailed)?
} else {
WorldpayErrorResponse::default(res.status_code)
};
with_error_response_body!(event_builder, response);
Ok(ErrorResponse {
status_code: res.status_code,
code: response.error_name,
message: response.message,
reason: response.validation_errors.map(|e| e.to_string()),
attempt_status: Some(common_enums::AttemptStatus::Failure),
connector_transaction_id: None,
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
})
}
}
macros::macro_connector_implementation!(
connector_default_implementations: [get_content_type, get_error_response_v2],
connector: Worldpay,
curl_request: Json(WorldpayAuthorizeRequest<T>),
curl_response: WorldpayAuthorizeResponse,
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,
| {
"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_5316159584132742197_3 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/worldpay.rs
req: &RouterDataV2<Authorize, PaymentFlowData, PaymentsAuthorizeData<T>, PaymentsResponseData>,
) -> CustomResult<String, errors::ConnectorError> {
Ok(format!("{}api/payments", self.connector_base_url_payments(req)))
}
}
);
macros::macro_connector_implementation!(
connector_default_implementations: [get_content_type, get_error_response_v2],
connector: Worldpay,
curl_response: WorldpaySyncResponse,
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 connector_payment_id = req
.request
.connector_transaction_id
.get_connector_transaction_id()
.change_context(errors::ConnectorError::MissingConnectorTransactionID)?;
Ok(format!(
"{}api/payments/{}",
self.connector_base_url_payments(req),
urlencoding::encode(&connector_payment_id),
))
}
}
);
macros::macro_connector_implementation!(
connector_default_implementations: [get_content_type, get_error_response_v2],
connector: Worldpay,
curl_request: Json(WorldpayCaptureRequest),
curl_response: WorldpayCaptureResponse,
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> {
let connector_payment_id = req.request.connector_transaction_id.get_connector_transaction_id()
.change_context(errors::ConnectorError::MissingConnectorTransactionID)?;
// Use /settlements for full capture, /partialSettlements for partial captures
let endpoint = if req.request.is_multiple_capture() {
"partialSettlements"
} else {
"settlements"
};
Ok(format!(
"{}api/payments/{}/{}",
self.connector_base_url_payments(req),
urlencoding::encode(&connector_payment_id),
endpoint
))
}
}
);
macros::macro_connector_implementation!(
connector_default_implementations: [get_content_type, get_error_response_v2],
connector: Worldpay,
curl_response: WorldpayVoidResponse,
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!(
| {
"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_5316159584132742197_4 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/worldpay.rs
"{}api/payments/{}/cancellations",
self.connector_base_url_payments(req),
urlencoding::encode(&req.request.connector_transaction_id),
))
}
}
);
macros::macro_connector_implementation!(
connector_default_implementations: [get_content_type, get_error_response_v2],
connector: Worldpay,
curl_request: Json(WorldpayRefundRequest),
curl_response: WorldpayRefundResponse,
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!(
"{}api/payments/{}/partialRefunds",
self.connector_base_url_refunds(req),
urlencoding::encode(&connector_payment_id),
))
}
}
);
macros::macro_connector_implementation!(
connector_default_implementations: [get_content_type, get_error_response_v2],
connector: Worldpay,
curl_response: WorldpayRefundSyncResponse,
flow_name: RSync,
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<domain_types::connector_flow::RSync, RefundFlowData, RefundSyncData, RefundsResponseData>,
) -> CustomResult<String, errors::ConnectorError> {
Ok(format!(
"{}api/payments/{}",
self.connector_base_url_refunds(req),
urlencoding::encode(&req.request.connector_refund_id),
))
}
}
);
macros::macro_connector_implementation!(
connector_default_implementations: [get_content_type, get_error_response_v2],
connector: Worldpay,
curl_request: Json(WorldpayPreAuthenticateRequest),
curl_response: WorldpayPreAuthenticateResponse,
flow_name: PreAuthenticate,
resource_common_data: PaymentFlowData,
flow_request: PaymentsPreAuthenticateData<T>,
flow_response: PaymentsResponseData,
http_method: Post,
generic_type: T,
[PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize],
other_functions: {
fn get_headers(
&self,
req: &RouterDataV2<PreAuthenticate, PaymentFlowData, PaymentsPreAuthenticateData<T>, PaymentsResponseData>,
) -> CustomResult<Vec<(String, Maskable<String>)>, errors::ConnectorError> {
self.build_headers(req)
}
fn get_url(
&self,
req: &RouterDataV2<PreAuthenticate, PaymentFlowData, PaymentsPreAuthenticateData<T>, PaymentsResponseData>,
) -> CustomResult<String, errors::ConnectorError> {
let link_data = Self::extract_link_data_from_metadata(req)?;
Ok(format!(
"{}api/payments/{}/3dsDeviceData",
self.connector_base_url_payments(req),
urlencoding::encode(&link_data),
))
}
}
);
macros::macro_connector_implementation!(
connector_default_implementations: [get_content_type, get_error_response_v2],
connector: Worldpay,
curl_request: Json(WorldpayPostAuthenticateRequest),
curl_response: WorldpayPostAuthenticateResponse,
flow_name: PostAuthenticate,
resource_common_data: 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_5316159584132742197_5 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/worldpay.rs
flow_request: PaymentsPostAuthenticateData<T>,
flow_response: PaymentsResponseData,
http_method: Post,
generic_type: T,
[PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize],
other_functions: {
fn get_headers(
&self,
req: &RouterDataV2<PostAuthenticate, PaymentFlowData, PaymentsPostAuthenticateData<T>, PaymentsResponseData>,
) -> CustomResult<Vec<(String, Maskable<String>)>, errors::ConnectorError> {
self.build_headers(req)
}
fn get_url(
&self,
req: &RouterDataV2<PostAuthenticate, PaymentFlowData, PaymentsPostAuthenticateData<T>, PaymentsResponseData>,
) -> CustomResult<String, errors::ConnectorError> {
let link_data = Self::extract_link_data_from_metadata(req)?;
Ok(format!(
"{}api/payments/{}/3dsChallenges",
self.connector_base_url_payments(req),
urlencoding::encode(&link_data),
))
}
}
);
macros::macro_connector_implementation!(
connector_default_implementations: [get_content_type, get_error_response_v2],
connector: Worldpay,
curl_request: Json(WorldpayRepeatPaymentRequest<T>),
curl_response: WorldpayRepeatPaymentResponse,
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,
req: &RouterDataV2<RepeatPayment, PaymentFlowData, RepeatPaymentData, PaymentsResponseData>,
) -> CustomResult<String, errors::ConnectorError> {
Ok(format!("{}api/payments", self.connector_base_url_payments(req)))
}
}
);
// Stub implementations for unsupported flows - removed conflicting ones that are now macro-generated
// Authenticate flow is replaced by PreAuthenticate and PostAuthenticate, but we need this stub for trait bounds
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 Worldpay<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
ConnectorIntegrationV2<
CreateOrder,
PaymentFlowData,
PaymentCreateOrderData,
PaymentCreateOrderResponse,
> for Worldpay<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
ConnectorIntegrationV2<SubmitEvidence, DisputeFlowData, SubmitEvidenceData, DisputeResponseData>
for Worldpay<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> ConnectorIntegrationV2<DefendDispute, DisputeFlowData, DisputeDefendData, DisputeResponseData>
for Worldpay<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> ConnectorIntegrationV2<Accept, DisputeFlowData, AcceptDisputeData, DisputeResponseData>
for Worldpay<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
ConnectorIntegrationV2<
SetupMandate,
PaymentFlowData,
SetupMandateRequestData<T>,
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_5316159584132742197_6 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/worldpay.rs
> for Worldpay<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
ConnectorIntegrationV2<
CreateSessionToken,
PaymentFlowData,
SessionTokenRequestData,
SessionTokenResponseData,
> for Worldpay<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 Worldpay<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 Worldpay<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 Worldpay<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
ConnectorIntegrationV2<
VoidPC,
PaymentFlowData,
PaymentsCancelPostCaptureData,
PaymentsResponseData,
> for Worldpay<T>
{
}
// SourceVerification implementations for all flows
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
Authorize,
PaymentFlowData,
PaymentsAuthorizeData<T>,
PaymentsResponseData,
> for Worldpay<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
PSync,
PaymentFlowData,
PaymentsSyncData,
PaymentsResponseData,
> for Worldpay<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
Capture,
PaymentFlowData,
PaymentsCaptureData,
PaymentsResponseData,
> for Worldpay<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
Void,
PaymentFlowData,
PaymentVoidData,
PaymentsResponseData,
> for Worldpay<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
Refund,
RefundFlowData,
RefundsData,
RefundsResponseData,
> for Worldpay<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
RSync,
RefundFlowData,
RefundSyncData,
RefundsResponseData,
> for Worldpay<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
SetupMandate,
PaymentFlowData,
SetupMandateRequestData<T>,
PaymentsResponseData,
> for Worldpay<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
Accept,
DisputeFlowData,
AcceptDisputeData,
DisputeResponseData,
> for Worldpay<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
SubmitEvidence,
DisputeFlowData,
SubmitEvidenceData,
DisputeResponseData,
> for Worldpay<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_5316159584132742197_7 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/worldpay.rs
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
DefendDispute,
DisputeFlowData,
DisputeDefendData,
DisputeResponseData,
> for Worldpay<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
CreateOrder,
PaymentFlowData,
PaymentCreateOrderData,
PaymentCreateOrderResponse,
> for Worldpay<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
RepeatPayment,
PaymentFlowData,
RepeatPaymentData,
PaymentsResponseData,
> for Worldpay<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
CreateSessionToken,
PaymentFlowData,
SessionTokenRequestData,
SessionTokenResponseData,
> for Worldpay<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 Worldpay<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 Worldpay<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 Worldpay<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 Worldpay<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 Worldpay<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
domain_types::connector_flow::CreateConnectorCustomer,
PaymentFlowData,
domain_types::connector_types::ConnectorCustomerData,
domain_types::connector_types::ConnectorCustomerResponse,
> for Worldpay<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
VoidPC,
PaymentFlowData,
PaymentsCancelPostCaptureData,
PaymentsResponseData,
> for Worldpay<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_3605506694904348107_0 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/volt.rs
pub mod transformers;
use std::fmt::Debug;
use common_enums::CurrencyUnit;
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,
},
connector_types::{
AcceptDisputeData, AccessTokenRequestData, AccessTokenResponseData, ConnectorCustomerData,
ConnectorCustomerResponse, DisputeDefendData, DisputeFlowData, DisputeResponseData,
PaymentCreateOrderData, PaymentCreateOrderResponse, PaymentFlowData,
PaymentMethodTokenResponse, PaymentMethodTokenizationData, PaymentVoidData,
PaymentsAuthenticateData, PaymentsAuthorizeData, 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 hyperswitch_masking::{Mask, Maskable};
use interfaces::{
api::ConnectorCommon, connector_integration_v2::ConnectorIntegrationV2, connector_types,
};
use serde::Serialize;
use transformers::{
self as volt, VoltAuthUpdateRequest, VoltAuthUpdateResponse, VoltPaymentsRequest,
VoltPaymentsResponse, VoltPsyncRequest, VoltPsyncResponse,
};
use super::macros;
use crate::{types::ResponseRouterData, with_error_response_body};
pub const BASE64_ENGINE: base64::engine::GeneralPurpose = base64::engine::general_purpose::STANDARD;
use error_stack::ResultExt;
// Trait implementations with generic type parameters
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::ConnectorServiceTrait<T> for Volt<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::PaymentAuthorizeV2<T> for Volt<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::PaymentSyncV2 for Volt<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::PaymentVoidV2 for Volt<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::PaymentVoidPostCaptureV2 for Volt<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::RefundSyncV2 for Volt<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::RefundV2 for Volt<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::PaymentCapture for Volt<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::ValidationTrait for Volt<T>
{
fn should_do_access_token(&self) -> bool {
true
}
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::PaymentOrderCreate for Volt<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::SetupMandateV2<T> for Volt<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::RepeatPaymentV2 for Volt<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::AcceptDispute for Volt<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::SubmitEvidenceV2 for Volt<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::DisputeDefend for Volt<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::IncomingWebhook for Volt<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::PaymentSessionToken for Volt<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_3605506694904348107_1 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/volt.rs
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::PaymentAccessToken for Volt<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::CreateConnectorCustomer for Volt<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::PaymentTokenV2<T> for Volt<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::PaymentPreAuthenticateV2<T> for Volt<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::PaymentAuthenticateV2<T> for Volt<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::PaymentPostAuthenticateV2<T> for Volt<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
ConnectorIntegrationV2<
domain_types::connector_flow::VoidPC,
PaymentFlowData,
domain_types::connector_types::PaymentsCancelPostCaptureData,
PaymentsResponseData,
> for Volt<T>
{
}
pub(crate) mod headers {
pub(crate) const CONTENT_TYPE: &str = "Content-Type";
pub(crate) const AUTHORIZATION: &str = "Authorization";
}
macros::create_all_prerequisites!(
connector_name: Volt,
generic_type: T,
api: [
(
flow: CreateAccessToken,
request_body: VoltAuthUpdateRequest,
response_body: VoltAuthUpdateResponse,
router_data: RouterDataV2<CreateAccessToken, PaymentFlowData, AccessTokenRequestData, AccessTokenResponseData>,
),
(
flow: Authorize,
request_body: VoltPaymentsRequest,
response_body: VoltPaymentsResponse,
router_data: RouterDataV2<Authorize, PaymentFlowData, PaymentsAuthorizeData<T>, PaymentsResponseData>,
),
(
flow: PSync,
request_body: VoltPsyncRequest,
response_body: VoltPsyncResponse,
router_data: RouterDataV2<PSync, PaymentFlowData, PaymentsSyncData, PaymentsResponseData>,
)
],
amount_converters: [],
member_functions: {
pub fn build_headers<F, Req, Res>(
&self,
req: &RouterDataV2<F, PaymentFlowData, Req, Res>,
) -> CustomResult<Vec<(String, Maskable<String>)>, errors::ConnectorError>
where
Self: ConnectorIntegrationV2<F, PaymentFlowData, Req, Res>,
{
let mut header = vec![(
headers::CONTENT_TYPE.to_string(),
"application/json".to_string().into(),
)];
// Add Bearer token for access token authentication
let access_token = req.resource_common_data
.get_access_token()
.change_context(errors::ConnectorError::FailedToObtainAuthType)?;
let auth_header = (
headers::AUTHORIZATION.to_string(),
format!("Bearer {access_token}").into_masked(),
);
header.push(auth_header);
Ok(header)
}
pub fn connector_base_url<F, Req, Res>(
&self,
req: &RouterDataV2<F, PaymentFlowData, Req, Res>,
) -> String {
req.resource_common_data.connectors.volt.base_url.to_string()
}
}
);
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize> ConnectorCommon
for Volt<T>
{
fn id(&self) -> &'static str {
"volt"
}
fn get_currency_unit(&self) -> CurrencyUnit {
CurrencyUnit::Minor
}
fn common_get_content_type(&self) -> &'static str {
"application/json"
}
fn base_url<'a>(&self, connectors: &'a Connectors) -> &'a str {
&connectors.volt.base_url
}
fn build_error_response(
&self,
res: Response,
event_builder: Option<&mut events::Event>,
) -> CustomResult<ErrorResponse, errors::ConnectorError> {
let response: volt::VoltErrorResponse = res
.response
.parse_struct("VoltErrorResponse")
.change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
with_error_response_body!(event_builder, response);
let reason = match &response.exception.error_list {
Some(error_list) => error_list
.iter()
| {
"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_3605506694904348107_2 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/volt.rs
.map(|error| error.message.clone())
.collect::<Vec<String>>()
.join(" & "),
None => response.exception.message.clone(),
};
Ok(ErrorResponse {
status_code: res.status_code,
code: response.exception.message.to_string(),
message: response.exception.message.clone(),
reason: Some(reason),
attempt_status: None,
connector_transaction_id: None,
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
})
}
}
macros::macro_connector_implementation!(
connector_default_implementations: [get_content_type, get_error_response_v2],
connector: Volt,
curl_request: Json(VoltPaymentsRequest),
curl_response: VoltPaymentsResponse,
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> {
let base_url = self.connector_base_url(req);
Ok(format!("{base_url}v2/payments"))
}
}
);
macros::macro_connector_implementation!(
connector_default_implementations: [get_content_type, get_error_response_v2],
connector: Volt,
curl_request: FormUrlEncoded(VoltAuthUpdateRequest),
curl_response: VoltAuthUpdateResponse,
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> {
Ok(vec![(
headers::CONTENT_TYPE.to_string(),
"application/x-www-form-urlencoded".to_string().into(),
)])
}
fn get_url(
&self,
req: &RouterDataV2<CreateAccessToken, PaymentFlowData, AccessTokenRequestData, AccessTokenResponseData>,
) -> CustomResult<String, errors::ConnectorError> {
let base_url = self.connector_base_url(req);
Ok(format!("{base_url}oauth"))
}
}
);
macros::macro_connector_implementation!(
connector_default_implementations: [get_content_type, get_error_response_v2],
connector: Volt,
curl_request: Json(VoltPsyncRequest),
curl_response: VoltPsyncResponse,
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 base_url = self.connector_base_url(req);
let connector_payment_id = req
.request
.connector_transaction_id
.get_connector_transaction_id()
.change_context(errors::ConnectorError::MissingConnectorTransactionID)?;
| {
"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_3605506694904348107_3 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/volt.rs
Ok(format!("{base_url}payments/{connector_payment_id}"))
}
}
);
// Stub implementations for unsupported flows (required by macro system)
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> ConnectorIntegrationV2<Capture, PaymentFlowData, PaymentsCaptureData, PaymentsResponseData>
for Volt<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> ConnectorIntegrationV2<Void, PaymentFlowData, PaymentVoidData, PaymentsResponseData>
for Volt<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> ConnectorIntegrationV2<Refund, RefundFlowData, RefundsData, RefundsResponseData> for Volt<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> ConnectorIntegrationV2<RSync, RefundFlowData, RefundSyncData, RefundsResponseData>
for Volt<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
ConnectorIntegrationV2<
CreateOrder,
PaymentFlowData,
PaymentCreateOrderData,
PaymentCreateOrderResponse,
> for Volt<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
ConnectorIntegrationV2<SubmitEvidence, DisputeFlowData, SubmitEvidenceData, DisputeResponseData>
for Volt<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> ConnectorIntegrationV2<DefendDispute, DisputeFlowData, DisputeDefendData, DisputeResponseData>
for Volt<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> ConnectorIntegrationV2<Accept, DisputeFlowData, AcceptDisputeData, DisputeResponseData>
for Volt<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
ConnectorIntegrationV2<
SetupMandate,
PaymentFlowData,
SetupMandateRequestData<T>,
PaymentsResponseData,
> for Volt<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
ConnectorIntegrationV2<RepeatPayment, PaymentFlowData, RepeatPaymentData, PaymentsResponseData>
for Volt<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
ConnectorIntegrationV2<
CreateSessionToken,
PaymentFlowData,
SessionTokenRequestData,
SessionTokenResponseData,
> for Volt<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
ConnectorIntegrationV2<
CreateConnectorCustomer,
PaymentFlowData,
ConnectorCustomerData,
ConnectorCustomerResponse,
> for Volt<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
ConnectorIntegrationV2<
PaymentMethodToken,
PaymentFlowData,
PaymentMethodTokenizationData<T>,
PaymentMethodTokenResponse,
> for Volt<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
ConnectorIntegrationV2<
PreAuthenticate,
PaymentFlowData,
PaymentsPreAuthenticateData<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_3605506694904348107_4 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/volt.rs
PaymentsResponseData,
> for Volt<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
ConnectorIntegrationV2<
Authenticate,
PaymentFlowData,
PaymentsAuthenticateData<T>,
PaymentsResponseData,
> for Volt<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
ConnectorIntegrationV2<
PostAuthenticate,
PaymentFlowData,
PaymentsPostAuthenticateData<T>,
PaymentsResponseData,
> for Volt<T>
{
}
// SourceVerification implementations for all flows
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
Authorize,
PaymentFlowData,
PaymentsAuthorizeData<T>,
PaymentsResponseData,
> for Volt<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
PSync,
PaymentFlowData,
PaymentsSyncData,
PaymentsResponseData,
> for Volt<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
Capture,
PaymentFlowData,
PaymentsCaptureData,
PaymentsResponseData,
> for Volt<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
Void,
PaymentFlowData,
PaymentVoidData,
PaymentsResponseData,
> for Volt<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
Refund,
RefundFlowData,
RefundsData,
RefundsResponseData,
> for Volt<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
RSync,
RefundFlowData,
RefundSyncData,
RefundsResponseData,
> for Volt<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
SetupMandate,
PaymentFlowData,
SetupMandateRequestData<T>,
PaymentsResponseData,
> for Volt<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
Accept,
DisputeFlowData,
AcceptDisputeData,
DisputeResponseData,
> for Volt<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
SubmitEvidence,
DisputeFlowData,
SubmitEvidenceData,
DisputeResponseData,
> for Volt<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
DefendDispute,
DisputeFlowData,
DisputeDefendData,
DisputeResponseData,
> for Volt<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
CreateOrder,
PaymentFlowData,
PaymentCreateOrderData,
PaymentCreateOrderResponse,
> for Volt<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
RepeatPayment,
PaymentFlowData,
RepeatPaymentData,
PaymentsResponseData,
> for Volt<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
CreateSessionToken,
PaymentFlowData,
SessionTokenRequestData,
SessionTokenResponseData,
> for Volt<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
CreateAccessToken,
PaymentFlowData,
AccessTokenRequestData,
AccessTokenResponseData,
> for Volt<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
CreateConnectorCustomer,
PaymentFlowData,
ConnectorCustomerData,
ConnectorCustomerResponse,
> for Volt<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_3605506694904348107_5 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/volt.rs
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
PaymentMethodToken,
PaymentFlowData,
PaymentMethodTokenizationData<T>,
PaymentMethodTokenResponse,
> for Volt<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
PreAuthenticate,
PaymentFlowData,
PaymentsPreAuthenticateData<T>,
PaymentsResponseData,
> for Volt<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
Authenticate,
PaymentFlowData,
PaymentsAuthenticateData<T>,
PaymentsResponseData,
> for Volt<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
PostAuthenticate,
PaymentFlowData,
PaymentsPostAuthenticateData<T>,
PaymentsResponseData,
> for Volt<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 Volt<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_-8523968573508846507_0 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/fiuu.rs
pub mod transformers;
use std::{any::type_name, borrow::Cow, collections::HashMap, fmt::Debug};
use bytes::Bytes;
use common_enums::CurrencyUnit;
use common_utils::{
crypto::{self, GenerateDigest, VerifySignature},
errors::CustomResult,
events,
ext_traits::{ByteSliceExt, 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, 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,
SessionTokenRequestData, SessionTokenResponseData, SetupMandateRequestData,
SubmitEvidenceData, WebhookDetailsResponse,
},
errors,
payment_method_data::PaymentMethodDataTypes,
router_data::{ConnectorAuthType, ErrorResponse},
router_data_v2::RouterDataV2,
router_response_types::Response,
types::Connectors,
utils,
};
use error_stack::ResultExt;
use hyperswitch_masking::{ExposeInterface, Maskable, PeekInterface, Secret};
use interfaces::{
api::ConnectorCommon,
connector_integration_v2::ConnectorIntegrationV2,
connector_types::{self},
};
use serde::{Deserialize, Serialize};
use serde_json::Value;
use tracing::{error, info, warn};
use transformers::{
self as fiuu, FiuuPaymentCancelRequest, FiuuPaymentCancelResponse, FiuuPaymentResponse,
FiuuPaymentSyncRequest, FiuuPaymentsRequest, FiuuPaymentsResponse, FiuuRefundRequest,
FiuuRefundResponse, FiuuRefundSyncRequest, FiuuRefundSyncResponse, FiuuWebhooksResponse,
PaymentCaptureRequest, PaymentCaptureResponse,
};
use super::macros;
use crate::{
types::ResponseRouterData, utils::xml_utils::flatten_json_structure, with_error_response_body,
with_response_body,
};
// Trait implementations with generic type parameters
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> connector_types::ConnectorServiceTrait<T> for Fiuu<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> connector_types::PaymentAuthorizeV2<T> for Fiuu<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> connector_types::PaymentSessionToken for Fiuu<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::PaymentAccessToken for Fiuu<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> connector_types::CreateConnectorCustomer for Fiuu<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> connector_types::PaymentSyncV2 for Fiuu<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> connector_types::PaymentVoidV2 for Fiuu<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
| {
"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_-8523968573508846507_1 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/fiuu.rs
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> connector_types::RefundSyncV2 for Fiuu<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> connector_types::RefundV2 for Fiuu<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> connector_types::PaymentCapture for Fiuu<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> connector_types::ValidationTrait for Fiuu<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> connector_types::PaymentOrderCreate for Fiuu<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> connector_types::SetupMandateV2<T> for Fiuu<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> connector_types::AcceptDispute for Fiuu<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> connector_types::SubmitEvidenceV2 for Fiuu<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> connector_types::DisputeDefend for Fiuu<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> connector_types::RepeatPaymentV2 for Fiuu<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> connector_types::PaymentVoidPostCaptureV2 for Fiuu<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> connector_types::PaymentTokenV2<T> for Fiuu<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
ConnectorIntegrationV2<
VoidPC,
PaymentFlowData,
PaymentsCancelPostCaptureData,
PaymentsResponseData,
> for Fiuu<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
interfaces::verification::SourceVerification<
VoidPC,
PaymentFlowData,
PaymentsCancelPostCaptureData,
PaymentsResponseData,
> for Fiuu<T>
{
}
// Authentication trait implementations
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> connector_types::PaymentPreAuthenticateV2<T> for Fiuu<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> connector_types::PaymentAuthenticateV2<T> for Fiuu<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> connector_types::PaymentPostAuthenticateV2<T> for Fiuu<T>
{
}
macros::create_all_prerequisites!(
connector_name: Fiuu,
generic_type: T,
api: [
(
flow: Authorize,
request_body: FiuuPaymentsRequest<T>,
response_body: FiuuPaymentsResponse,
| {
"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_-8523968573508846507_2 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/fiuu.rs
router_data: RouterDataV2<Authorize, PaymentFlowData, PaymentsAuthorizeData<T>, PaymentsResponseData>,
),
(
flow: PSync,
request_body: FiuuPaymentSyncRequest,
response_body: FiuuPaymentResponse,
router_data: RouterDataV2<PSync, PaymentFlowData, PaymentsSyncData, PaymentsResponseData>,
),
(
flow: Capture,
request_body: PaymentCaptureRequest,
response_body: PaymentCaptureResponse,
router_data: RouterDataV2<Capture, PaymentFlowData, PaymentsCaptureData, PaymentsResponseData>,
),
(
flow: Void,
request_body: FiuuPaymentCancelRequest,
response_body: FiuuPaymentCancelResponse,
router_data: RouterDataV2<Void, PaymentFlowData, PaymentVoidData, PaymentsResponseData>,
),
(
flow: Refund,
request_body: FiuuRefundRequest,
response_body: FiuuRefundResponse,
router_data: RouterDataV2<Refund, RefundFlowData, RefundsData, RefundsResponseData>,
),
(
flow: RSync,
request_body: FiuuRefundSyncRequest,
response_body: FiuuRefundSyncResponse,
router_data: RouterDataV2<RSync, RefundFlowData, RefundSyncData, RefundsResponseData>,
)
],
amount_converters: [
amount_converter: StringMajorUnit
],
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> {
let response_str = String::from_utf8(response_bytes.to_vec()).map_err(|e| {
error!("Error in Deserializing Response Data: {:?}", e);
errors::ConnectorError::ResponseDeserializationFailed
})?;
let mut json = serde_json::Map::new();
let mut miscellaneous: HashMap<String, Secret<String>> = HashMap::new();
for line in response_str.lines() {
if let Some((key, value)) = line.split_once('=') {
if key.trim().is_empty() {
error!("Null or empty key encountered in response.");
continue;
}
if let Some(old_value) = json.insert(key.to_string(), Value::String(value.to_string()))
{
warn!("Repeated key encountered: {}", key);
miscellaneous.insert(key.to_string(), Secret::new(old_value.to_string()));
}
}
}
if !miscellaneous.is_empty() {
let misc_value = serde_json::to_value(miscellaneous).map_err(|e| {
error!("Error serializing miscellaneous data: {:?}", e);
errors::ConnectorError::ResponseDeserializationFailed
})?;
json.insert("miscellaneous".to_string(), misc_value);
}
// Extract and flatten the JSON structure
let flattened_json = flatten_json_structure(Value::Object(json));
// Convert JSON Value to string and then to bytes
let json_string = serde_json::to_string(&flattened_json).map_err(|e| {
tracing::error!(error=?e, "Failed to convert to JSON string");
errors::ConnectorError::ResponseDeserializationFailed
})?;
tracing::info!(json=?json_string, "Flattened JSON structure");
// Return JSON as bytes
Ok(Bytes::from(json_string.into_bytes()))
}
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>,
{
Ok(vec![])
}
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.fiuu.base_url
}
| {
"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_-8523968573508846507_3 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/fiuu.rs
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.fiuu.base_url
}
}
);
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> ConnectorCommon for Fiuu<T>
{
fn id(&self) -> &'static str {
"fiuu"
}
fn get_currency_unit(&self) -> CurrencyUnit {
CurrencyUnit::Base
}
fn common_get_content_type(&self) -> &'static str {
"multipart/form-data"
}
fn base_url<'a>(&self, connectors: &'a Connectors) -> &'a str {
connectors.fiuu.base_url.as_ref()
}
fn build_error_response(
&self,
res: Response,
event_builder: Option<&mut events::Event>,
) -> CustomResult<ErrorResponse, errors::ConnectorError> {
let response: fiuu::FiuuErrorResponse = res
.response
.parse_struct("fiuu::FiuuErrorResponse")
.change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
with_error_response_body!(event_builder, response);
Ok(ErrorResponse {
status_code: res.status_code,
code: response.error_code.clone(),
message: response.error_desc.clone(),
reason: Some(response.error_desc.clone()),
attempt_status: None,
connector_transaction_id: None,
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
})
}
}
macros::macro_connector_implementation!(
connector_default_implementations: [get_content_type, get_error_response_v2],
connector: Fiuu,
curl_request: FormData(FiuuPaymentsRequest<T>),
curl_response: FiuuPaymentsResponse,
flow_name: Authorize,
resource_common_data: PaymentFlowData,
flow_request: PaymentsAuthorizeData<T>,
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<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> {
let optional_is_mit_flow = req.request.off_session;
let optional_is_nti_flow = req
.request
.mandate_id
.as_ref()
.map(|mandate_id| mandate_id.is_network_transaction_id_flow());
let url = match (optional_is_mit_flow, optional_is_nti_flow) {
(Some(true), Some(false)) => format!(
"{}/RMS/API/Recurring/input_v7.php",
self.connector_base_url_payments(req)
),
_ => {
format!(
"{}RMS/API/Direct/1.4.0/index.php",
self.connector_base_url_payments(req)
)
}
};
Ok(url)
}
}
);
macros::macro_connector_implementation!(
connector_default_implementations: [get_content_type, get_error_response_v2],
connector: Fiuu,
curl_request: FormData(PaymentCaptureRequest),
curl_response: PaymentCaptureResponse,
flow_name: Capture,
resource_common_data: PaymentFlowData,
flow_request: PaymentsCaptureData,
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<Capture, PaymentFlowData, PaymentsCaptureData, PaymentsResponseData>,
) -> CustomResult<Vec<(String, Maskable<String>)>, errors::ConnectorError> {
self.build_headers(req)
}
| {
"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_-8523968573508846507_4 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/fiuu.rs
fn get_url(
&self,
req: &RouterDataV2<Capture, PaymentFlowData, PaymentsCaptureData, PaymentsResponseData>,
) -> CustomResult<String, errors::ConnectorError> {
Ok(format!(
"{}RMS/API/capstxn/index.php",
self.connector_base_url_payments(req)
))
}
}
);
// Add implementation for Void
macros::macro_connector_implementation!(
connector_default_implementations: [get_content_type, get_error_response_v2],
connector: Fiuu,
curl_request: FormData(FiuuPaymentCancelRequest),
curl_response: FiuuPaymentCancelResponse,
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>)>, errors::ConnectorError> {
self.build_headers(req)
}
fn get_url(
&self,
req: &RouterDataV2<Void, PaymentFlowData, PaymentVoidData, PaymentsResponseData>,
) -> CustomResult<String, errors::ConnectorError> {
Ok(format!(
"{}RMS/API/refundAPI/refund.php",
self.connector_base_url_payments(req)
))
}
}
);
// Add implementation for Refund
macros::macro_connector_implementation!(
connector_default_implementations: [get_content_type, get_error_response_v2],
connector: Fiuu,
curl_request: FormData(FiuuRefundRequest),
curl_response: FiuuRefundResponse,
flow_name: Refund,
resource_common_data: RefundFlowData,
flow_request: RefundsData,
flow_response: RefundsResponseData,
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<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!(
"{}RMS/API/refundAPI/index.php",
self.connector_base_url_refunds(req)
))
}
}
);
macros::macro_connector_implementation!(
connector_default_implementations: [get_content_type, get_error_response_v2],
connector: Fiuu,
curl_request: FormData(FiuuRefundSyncRequest),
curl_response: FiuuRefundSyncResponse,
flow_name: RSync,
resource_common_data: RefundFlowData,
flow_request: RefundSyncData,
flow_response: RefundsResponseData,
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<RSync, RefundFlowData, RefundSyncData, RefundsResponseData>,
) -> CustomResult<Vec<(String, Maskable<String>)>, errors::ConnectorError> {
self.build_headers(req)
}
fn get_url(
&self,
req: &RouterDataV2<domain_types::connector_flow::RSync, RefundFlowData, RefundSyncData, RefundsResponseData>,
) -> CustomResult<String, errors::ConnectorError> {
Ok(format!(
"{}RMS/API/refundAPI/q_by_txn.php",
self.connector_base_url_refunds(req)
))
}
}
);
// PSync is not implemented using the macro structure because the response is parsed differently according to the header
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_-8523968573508846507_5 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/fiuu.rs
> ConnectorIntegrationV2<PSync, PaymentFlowData, PaymentsSyncData, PaymentsResponseData>
for Fiuu<T>
{
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!(
"{}RMS/API/gate-query/index.php",
self.connector_base_url_payments(req)
))
}
fn get_content_type(&self) -> &'static str {
self.common_get_content_type()
}
fn get_request_body(
&self,
req: &RouterDataV2<PSync, PaymentFlowData, PaymentsSyncData, PaymentsResponseData>,
) -> CustomResult<Option<macro_types::RequestContent>, macro_types::ConnectorError> {
let bridge = self.p_sync;
let input_data = FiuuRouterData {
connector: self.to_owned(),
router_data: req.clone(),
};
let request = bridge.request_body(input_data)?;
let form_data = <FiuuPaymentSyncRequest as GetFormData>::get_form_data(&request);
Ok(Some(macro_types::RequestContent::FormData(form_data)))
}
fn handle_response_v2(
&self,
data: &RouterDataV2<PSync, PaymentFlowData, PaymentsSyncData, PaymentsResponseData>,
event_builder: Option<&mut events::Event>,
res: Response,
) -> CustomResult<
RouterDataV2<PSync, PaymentFlowData, PaymentsSyncData, PaymentsResponseData>,
macro_types::ConnectorError,
> {
match res.headers {
Some(headers) => {
let content_header = utils::get_http_header("Content-type", &headers)
.attach_printable("Missing content type in headers")
.change_context(errors::ConnectorError::ResponseHandlingFailed)?;
let response: fiuu::FiuuPaymentResponse = if content_header
== "text/plain;charset=UTF-8"
{
parse_response(&res.response)
} else {
Err(errors::ConnectorError::ResponseDeserializationFailed)
.attach_printable(format!("Expected content type to be text/plain;charset=UTF-8 , but received different content type as {content_header} in response"))?
}?;
with_response_body!(event_builder, response);
RouterDataV2::try_from(ResponseRouterData {
response,
router_data: data.clone(),
http_code: res.status_code,
})
.change_context(errors::ConnectorError::ResponseHandlingFailed)
}
None => {
// We don't get headers for payment webhook response handling
let response: fiuu::FiuuPaymentResponse = res
.response
.parse_struct("fiuu::FiuuPaymentResponse")
.change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
with_response_body!(event_builder, response);
RouterDataV2::try_from(ResponseRouterData {
response,
router_data: data.clone(),
http_code: res.status_code,
})
.change_context(errors::ConnectorError::ResponseHandlingFailed)
}
}
}
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)
}
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> connector_types::IncomingWebhook for Fiuu<T>
{
fn get_webhook_source_verification_signature(
&self,
request: &RequestDetails,
_connector_webhook_secret: &ConnectorWebhookSecrets,
) -> Result<Vec<u8>, error_stack::Report<domain_types::errors::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_-8523968573508846507_6 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/fiuu.rs
let header = request
.headers
.get("content-type")
.ok_or(errors::ConnectorError::WebhookSourceVerificationFailed)?;
let resource: FiuuWebhooksResponse = if header == "application/x-www-form-urlencoded" {
parse_and_log_keys_in_url_encoded_response::<FiuuWebhooksResponse>(&request.body);
serde_urlencoded::from_bytes::<FiuuWebhooksResponse>(&request.body)
.change_context(errors::ConnectorError::WebhookSourceVerificationFailed)?
} else {
request
.body
.parse_struct("fiuu::FiuuWebhooksResponse")
.change_context(errors::ConnectorError::WebhookSourceVerificationFailed)?
};
let signature = match resource {
FiuuWebhooksResponse::FiuuWebhookPaymentResponse(webhooks_payment_response) => {
webhooks_payment_response.skey
}
FiuuWebhooksResponse::FiuuWebhookRefundResponse(webhooks_refunds_response) => {
webhooks_refunds_response.signature
}
};
hex::decode(signature.expose())
.change_context(errors::ConnectorError::WebhookSourceVerificationFailed)
}
fn get_webhook_source_verification_message(
&self,
request: &RequestDetails,
connector_webhook_secrets: &ConnectorWebhookSecrets,
) -> Result<Vec<u8>, error_stack::Report<domain_types::errors::ConnectorError>> {
let header = request
.headers
.get("content-type")
.ok_or(errors::ConnectorError::WebhookSourceVerificationFailed)?;
let resource: FiuuWebhooksResponse = if header == "application/x-www-form-urlencoded" {
parse_and_log_keys_in_url_encoded_response::<FiuuWebhooksResponse>(&request.body);
serde_urlencoded::from_bytes::<FiuuWebhooksResponse>(&request.body)
.change_context(errors::ConnectorError::WebhookSourceVerificationFailed)?
} else {
request
.body
.parse_struct("fiuu::FiuuWebhooksResponse")
.change_context(errors::ConnectorError::WebhookSourceVerificationFailed)?
};
let verification_message = match resource {
FiuuWebhooksResponse::FiuuWebhookPaymentResponse(webhooks_payment_response) => {
let key0 = format!(
"{}{}{}{}{}{}",
webhooks_payment_response.tran_id,
webhooks_payment_response.order_id,
webhooks_payment_response.status,
webhooks_payment_response.domain.clone().peek(),
webhooks_payment_response.amount.get_amount_as_string(),
webhooks_payment_response.currency
);
let md5_key0 = hex::encode(
crypto::Md5
.generate_digest(key0.as_bytes())
.change_context(errors::ConnectorError::WebhookSourceVerificationFailed)?,
);
let key1 = format!(
"{}{}{}{}{}",
webhooks_payment_response.paydate,
webhooks_payment_response.domain.peek(),
md5_key0,
webhooks_payment_response
.appcode
.map_or("".to_string(), |appcode| appcode.expose()),
String::from_utf8_lossy(&connector_webhook_secrets.secret)
);
key1
}
FiuuWebhooksResponse::FiuuWebhookRefundResponse(webhooks_refunds_response) => {
format!(
"{}{}{}{}{}{}{}{}",
webhooks_refunds_response.refund_type,
webhooks_refunds_response.merchant_id.peek(),
webhooks_refunds_response.ref_id,
webhooks_refunds_response.refund_id,
webhooks_refunds_response.txn_id,
webhooks_refunds_response.amount.get_amount_as_string(),
webhooks_refunds_response.status,
String::from_utf8_lossy(&connector_webhook_secrets.secret)
)
}
};
| {
"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_-8523968573508846507_7 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/fiuu.rs
Ok(verification_message.as_bytes().to_vec())
}
fn verify_webhook_source(
&self,
request: RequestDetails,
connector_webhook_secret: Option<ConnectorWebhookSecrets>,
_connector_account_details: Option<ConnectorAuthType>,
) -> Result<bool, error_stack::Report<domain_types::errors::ConnectorError>> {
let algorithm = crypto::Md5;
let connector_webhook_secrets = match connector_webhook_secret {
Some(secrets) => secrets,
None => Err(domain_types::errors::ConnectorError::WebhookSourceVerificationFailed)?,
};
let signature =
self.get_webhook_source_verification_signature(&request, &connector_webhook_secrets)?;
let message =
self.get_webhook_source_verification_message(&request, &connector_webhook_secrets)?;
algorithm
.verify_signature(&connector_webhook_secrets.secret, &signature, &message)
.change_context(errors::ConnectorError::WebhookSourceVerificationFailed)
}
fn get_event_type(
&self,
request: RequestDetails,
_connector_webhook_secret: Option<ConnectorWebhookSecrets>,
_connector_account_details: Option<ConnectorAuthType>,
) -> Result<EventType, error_stack::Report<domain_types::errors::ConnectorError>> {
let header = request
.headers
.get("content-type")
.ok_or(errors::ConnectorError::WebhookSourceVerificationFailed)?;
let resource: FiuuWebhooksResponse = if header == "application/x-www-form-urlencoded" {
parse_and_log_keys_in_url_encoded_response::<FiuuWebhooksResponse>(&request.body);
serde_urlencoded::from_bytes::<FiuuWebhooksResponse>(&request.body)
.change_context(errors::ConnectorError::WebhookEventTypeNotFound)?
} else {
request
.body
.parse_struct("fiuu::FiuuWebhooksResponse")
.change_context(errors::ConnectorError::WebhookEventTypeNotFound)?
};
match resource {
FiuuWebhooksResponse::FiuuWebhookPaymentResponse(webhooks_payment_response) => {
Ok(EventType::from(webhooks_payment_response.status))
}
FiuuWebhooksResponse::FiuuWebhookRefundResponse(webhooks_refunds_response) => {
Ok(EventType::from(webhooks_refunds_response.status))
}
}
}
fn get_webhook_resource_object(
&self,
request: RequestDetails,
) -> CustomResult<
Box<dyn hyperswitch_masking::ErasedMaskSerialize>,
domain_types::errors::ConnectorError,
> {
let header = request
.headers
.get("content-type")
.ok_or(errors::ConnectorError::WebhookBodyDecodingFailed)?;
let payload: FiuuWebhooksResponse = if header == "application/x-www-form-urlencoded" {
parse_and_log_keys_in_url_encoded_response::<FiuuWebhooksResponse>(&request.body);
serde_urlencoded::from_bytes::<FiuuWebhooksResponse>(&request.body)
.change_context(errors::ConnectorError::WebhookResourceObjectNotFound)?
} else {
request
.body
.parse_struct("fiuu::FiuuWebhooksResponse")
.change_context(errors::ConnectorError::WebhookResourceObjectNotFound)?
};
match payload.clone() {
FiuuWebhooksResponse::FiuuWebhookPaymentResponse(webhook_payment_response) => Ok(
Box::new(fiuu::FiuuPaymentResponse::FiuuWebhooksPaymentResponse(
webhook_payment_response,
)),
),
FiuuWebhooksResponse::FiuuWebhookRefundResponse(webhook_refund_response) => {
Ok(Box::new(fiuu::FiuuRefundSyncResponse::Webhook(
webhook_refund_response,
)))
}
}
}
fn process_payment_webhook(
&self,
_request: RequestDetails,
_connector_webhook_secret: Option<ConnectorWebhookSecrets>,
_connector_account_details: Option<ConnectorAuthType>,
) -> Result<WebhookDetailsResponse, error_stack::Report<domain_types::errors::ConnectorError>>
{
Ok(WebhookDetailsResponse {
resource_id: None,
| {
"chunk": 7,
"crate": "connector-integration",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_mini_connector-integration_-8523968573508846507_8 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/fiuu.rs
status: common_enums::AttemptStatus::Unknown,
connector_response_reference_id: None,
error_code: None,
error_message: None,
raw_connector_response: None,
status_code: 200,
response_headers: None,
mandate_reference: None,
minor_amount_captured: None,
amount_captured: None,
error_reason: None,
network_txn_id: None,
transformation_status: common_enums::WebhookTransformationStatus::Incomplete,
})
}
fn process_refund_webhook(
&self,
request: RequestDetails,
_connector_webhook_secret: Option<ConnectorWebhookSecrets>,
_connector_account_details: Option<ConnectorAuthType>,
) -> Result<
RefundWebhookDetailsResponse,
error_stack::Report<domain_types::errors::ConnectorError>,
> {
let header = request
.headers
.get("content-type")
.ok_or(errors::ConnectorError::WebhookBodyDecodingFailed)?;
let payload: FiuuWebhooksResponse = if header == "application/x-www-form-urlencoded" {
parse_and_log_keys_in_url_encoded_response::<FiuuWebhooksResponse>(&request.body);
serde_urlencoded::from_bytes::<FiuuWebhooksResponse>(&request.body)
.change_context(errors::ConnectorError::WebhookResourceObjectNotFound)?
} else {
request
.body
.parse_struct("fiuu::FiuuWebhooksResponse")
.change_context(errors::ConnectorError::WebhookResourceObjectNotFound)?
};
let notif = match payload.clone() {
FiuuWebhooksResponse::FiuuWebhookPaymentResponse(_) => {
Err(errors::ConnectorError::WebhookBodyDecodingFailed)
}
FiuuWebhooksResponse::FiuuWebhookRefundResponse(webhook_refund_response) => Ok(
fiuu::FiuuRefundSyncResponse::Webhook(webhook_refund_response),
),
}?;
let response = RefundWebhookDetailsResponse::try_from(notif)
.change_context(errors::ConnectorError::WebhookBodyDecodingFailed);
response.map(|mut response| {
response.raw_connector_response =
Some(String::from_utf8_lossy(&request.body).to_string());
response
})
}
}
// Implementation for empty stubs - these will need to be properly implemented later
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
ConnectorIntegrationV2<
CreateOrder,
PaymentFlowData,
PaymentCreateOrderData,
PaymentCreateOrderResponse,
> for Fiuu<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
ConnectorIntegrationV2<
SetupMandate,
PaymentFlowData,
SetupMandateRequestData<T>,
PaymentsResponseData,
> for Fiuu<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> ConnectorIntegrationV2<Accept, DisputeFlowData, AcceptDisputeData, DisputeResponseData>
for Fiuu<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
ConnectorIntegrationV2<
CreateSessionToken,
PaymentFlowData,
SessionTokenRequestData,
SessionTokenResponseData,
> for Fiuu<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
ConnectorIntegrationV2<
CreateAccessToken,
PaymentFlowData,
AccessTokenRequestData,
AccessTokenResponseData,
> for Fiuu<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
ConnectorIntegrationV2<
CreateConnectorCustomer,
| {
"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_-8523968573508846507_9 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/fiuu.rs
PaymentFlowData,
ConnectorCustomerData,
ConnectorCustomerResponse,
> for Fiuu<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
ConnectorIntegrationV2<SubmitEvidence, DisputeFlowData, SubmitEvidenceData, DisputeResponseData>
for Fiuu<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> ConnectorIntegrationV2<DefendDispute, DisputeFlowData, DisputeDefendData, DisputeResponseData>
for Fiuu<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
ConnectorIntegrationV2<RepeatPayment, PaymentFlowData, RepeatPaymentData, PaymentsResponseData>
for Fiuu<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> ConnectorSpecifications for Fiuu<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
ConnectorIntegrationV2<
PaymentMethodToken,
PaymentFlowData,
PaymentMethodTokenizationData<T>,
PaymentMethodTokenResponse,
> for Fiuu<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 Fiuu<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
interfaces::verification::SourceVerification<
PSync,
PaymentFlowData,
PaymentsSyncData,
PaymentsResponseData,
> for Fiuu<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
interfaces::verification::SourceVerification<
Capture,
PaymentFlowData,
PaymentsCaptureData,
PaymentsResponseData,
> for Fiuu<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
interfaces::verification::SourceVerification<
Void,
PaymentFlowData,
PaymentVoidData,
PaymentsResponseData,
> for Fiuu<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
interfaces::verification::SourceVerification<
Refund,
RefundFlowData,
RefundsData,
RefundsResponseData,
> for Fiuu<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
interfaces::verification::SourceVerification<
RSync,
RefundFlowData,
RefundSyncData,
RefundsResponseData,
> for Fiuu<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
interfaces::verification::SourceVerification<
SetupMandate,
PaymentFlowData,
SetupMandateRequestData<T>,
PaymentsResponseData,
> for Fiuu<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
interfaces::verification::SourceVerification<
Accept,
DisputeFlowData,
AcceptDisputeData,
DisputeResponseData,
> for Fiuu<T>
{
}
impl<
| {
"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_-8523968573508846507_10 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/fiuu.rs
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
interfaces::verification::SourceVerification<
SubmitEvidence,
DisputeFlowData,
SubmitEvidenceData,
DisputeResponseData,
> for Fiuu<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
interfaces::verification::SourceVerification<
DefendDispute,
DisputeFlowData,
DisputeDefendData,
DisputeResponseData,
> for Fiuu<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
interfaces::verification::SourceVerification<
CreateOrder,
PaymentFlowData,
PaymentCreateOrderData,
PaymentCreateOrderResponse,
> for Fiuu<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
interfaces::verification::SourceVerification<
CreateSessionToken,
PaymentFlowData,
SessionTokenRequestData,
SessionTokenResponseData,
> for Fiuu<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
interfaces::verification::SourceVerification<
CreateAccessToken,
PaymentFlowData,
AccessTokenRequestData,
AccessTokenResponseData,
> for Fiuu<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
interfaces::verification::SourceVerification<
RepeatPayment,
PaymentFlowData,
RepeatPaymentData,
PaymentsResponseData,
> for Fiuu<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
interfaces::verification::SourceVerification<
PaymentMethodToken,
PaymentFlowData,
PaymentMethodTokenizationData<T>,
PaymentMethodTokenResponse,
> for Fiuu<T>
{
}
// Authentication flow ConnectorIntegrationV2 implementations
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
ConnectorIntegrationV2<
PreAuthenticate,
PaymentFlowData,
PaymentsPreAuthenticateData<T>,
PaymentsResponseData,
> for Fiuu<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
ConnectorIntegrationV2<
Authenticate,
PaymentFlowData,
PaymentsAuthenticateData<T>,
PaymentsResponseData,
> for Fiuu<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
ConnectorIntegrationV2<
PostAuthenticate,
PaymentFlowData,
PaymentsPostAuthenticateData<T>,
PaymentsResponseData,
> for Fiuu<T>
{
}
// Authentication flow SourceVerification implementations
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
interfaces::verification::SourceVerification<
PreAuthenticate,
PaymentFlowData,
PaymentsPreAuthenticateData<T>,
PaymentsResponseData,
> for Fiuu<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
interfaces::verification::SourceVerification<
Authenticate,
PaymentFlowData,
PaymentsAuthenticateData<T>,
PaymentsResponseData,
| {
"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_-8523968573508846507_11 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/fiuu.rs
> for Fiuu<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
interfaces::verification::SourceVerification<
PostAuthenticate,
PaymentFlowData,
PaymentsPostAuthenticateData<T>,
PaymentsResponseData,
> for Fiuu<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
interfaces::verification::SourceVerification<
CreateConnectorCustomer,
PaymentFlowData,
ConnectorCustomerData,
ConnectorCustomerResponse,
> for Fiuu<T>
{
}
fn parse_response<T>(data: &[u8]) -> Result<T, errors::ConnectorError>
where
T: for<'de> Deserialize<'de>,
{
let response_str = String::from_utf8(data.to_vec()).map_err(|e| {
error!("Error in Deserializing Response Data: {:?}", e);
errors::ConnectorError::ResponseDeserializationFailed
})?;
let mut json = serde_json::Map::new();
let mut miscellaneous: HashMap<String, Secret<String>> = HashMap::new();
for line in response_str.lines() {
if let Some((key, value)) = line.split_once('=') {
if key.trim().is_empty() {
error!("Null or empty key encountered in response.");
continue;
}
if let Some(old_value) = json.insert(key.to_string(), Value::String(value.to_string()))
{
warn!("Repeated key encountered: {}", key);
miscellaneous.insert(key.to_string(), Secret::new(old_value.to_string()));
}
}
}
if !miscellaneous.is_empty() {
let misc_value = serde_json::to_value(miscellaneous).map_err(|e| {
error!("Error serializing miscellaneous data: {:?}", e);
errors::ConnectorError::ResponseDeserializationFailed
})?;
json.insert("miscellaneous".to_string(), misc_value);
}
let response: T = serde_json::from_value(Value::Object(json)).map_err(|e| {
error!("Error in Deserializing Response Data: {:?}", e);
errors::ConnectorError::ResponseDeserializationFailed
})?;
Ok(response)
}
pub fn parse_and_log_keys_in_url_encoded_response<T>(data: &[u8]) {
match std::str::from_utf8(data) {
Ok(query_str) => {
let loggable_keys = [
"status",
"orderid",
"tranID",
"nbcb",
"amount",
"currency",
"paydate",
"channel",
"error_desc",
"error_code",
"extraP",
];
let keys: Vec<(Cow<'_, str>, String)> =
url::form_urlencoded::parse(query_str.as_bytes())
.map(|(key, value)| {
if loggable_keys.contains(&key.to_string().as_str()) {
(key, value.to_string())
} else {
(key, "SECRET".to_string())
}
})
.collect();
info!("Keys in {} response\n{:?}", type_name::<T>(), keys);
}
Err(err) => {
error!("Failed to convert bytes to string: {:?}", err);
}
}
}
| {
"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_706034505544759133_0 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/phonepe.rs
pub mod constants;
pub mod headers;
pub mod transformers;
use common_enums as enums;
use common_utils::{errors::CustomResult, events, ext_traits::BytesExt, types::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, 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::{ConnectorInfo, Connectors},
};
use error_stack::ResultExt;
use hyperswitch_masking::{Maskable, PeekInterface};
use interfaces::{
api::ConnectorCommon,
connector_integration_v2::ConnectorIntegrationV2,
connector_types,
verification::{ConnectorSourceVerificationSecrets, SourceVerification},
};
use serde::Serialize;
use transformers as phonepe;
use self::transformers::{
PhonepePaymentsRequest, PhonepePaymentsResponse, PhonepeSyncRequest, PhonepeSyncResponse,
};
use super::macros;
use crate::types::ResponseRouterData;
// Trait implementations with generic type parameters
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> connector_types::PaymentPreAuthenticateV2<T> for Phonepe<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> connector_types::PaymentAuthenticateV2<T> for Phonepe<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> connector_types::PaymentPostAuthenticateV2<T> for Phonepe<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> connector_types::ConnectorServiceTrait<T> for Phonepe<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> connector_types::PaymentSessionToken for Phonepe<T>
{
}
impl<T: PaymentMethodDataTypes + std::fmt::Debug + Sync + Send + 'static + Serialize>
connector_types::PaymentAccessToken for Phonepe<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> connector_types::CreateConnectorCustomer for Phonepe<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> connector_types::PaymentAuthorizeV2<T> for Phonepe<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> connector_types::PaymentSyncV2 for Phonepe<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
| {
"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_706034505544759133_1 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/phonepe.rs
+ Serialize,
> connector_types::PaymentVoidV2 for Phonepe<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> connector_types::RefundSyncV2 for Phonepe<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> connector_types::RefundV2 for Phonepe<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> connector_types::PaymentCapture for Phonepe<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> connector_types::SetupMandateV2<T> for Phonepe<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> connector_types::AcceptDispute for Phonepe<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> connector_types::SubmitEvidenceV2 for Phonepe<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> connector_types::DisputeDefend for Phonepe<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> connector_types::IncomingWebhook for Phonepe<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> connector_types::PaymentOrderCreate for Phonepe<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> connector_types::ValidationTrait for Phonepe<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> connector_types::RepeatPaymentV2 for Phonepe<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> connector_types::PaymentVoidPostCaptureV2 for Phonepe<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> connector_types::PaymentTokenV2<T> for Phonepe<T>
{
}
// Define connector prerequisites
macros::create_all_prerequisites!(
connector_name: Phonepe,
generic_type: T,
api: [
(
flow: Authorize,
request_body: PhonepePaymentsRequest,
response_body: PhonepePaymentsResponse,
router_data: RouterDataV2<Authorize, PaymentFlowData, PaymentsAuthorizeData<T>, PaymentsResponseData>,
),
(
flow: PSync,
request_body: PhonepeSyncRequest,
response_body: PhonepeSyncResponse,
router_data: RouterDataV2<PSync, PaymentFlowData, PaymentsSyncData, PaymentsResponseData>,
)
],
amount_converters: [
amount_converter: MinorUnit
],
member_functions: {
pub fn connector_base_url<F, Req, Res>(
&self,
req: &RouterDataV2<F, PaymentFlowData, Req, Res>,
) -> String {
req.resource_common_data.connectors.phonepe.base_url.to_string()
}
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.phonepe.base_url
}
pub fn connector_base_url_refunds<'a, F, Req, Res>(
&self,
| {
"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_706034505544759133_2 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/phonepe.rs
req: &'a RouterDataV2<F, RefundFlowData, Req, Res>,
) -> &'a str {
&req.resource_common_data.connectors.phonepe.base_url
}
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>,
{
Ok(vec![(
headers::CONTENT_TYPE.to_string(),
"application/json".to_string().into(),
)])
}
}
);
// Authorize flow implementation using macros
macros::macro_connector_implementation!(
connector_default_implementations: [get_content_type, get_error_response_v2],
connector: Phonepe,
curl_request: Json(PhonepePaymentsRequest),
curl_response: PhonepePaymentsResponse,
flow_name: Authorize,
resource_common_data: PaymentFlowData,
flow_request: PaymentsAuthorizeData<T>,
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<Authorize, PaymentFlowData, PaymentsAuthorizeData<T>, PaymentsResponseData>,
) -> CustomResult<Vec<(String, Maskable<String>)>, errors::ConnectorError> {
// Get base headers first
let mut headers = vec![
(
headers::CONTENT_TYPE.to_string(),
"application/json".to_string().into(),
),
];
// Build the request to get the checksum for X-VERIFY header
let connector_router_data = PhonepeRouterData {
connector: self.clone(),
router_data: req,
};
let connector_req = phonepe::PhonepePaymentsRequest::try_from(&connector_router_data)?;
headers.push((headers::X_VERIFY.to_string(), connector_req.checksum.into()));
Ok(headers)
}
fn get_url(
&self,
req: &RouterDataV2<Authorize, PaymentFlowData, PaymentsAuthorizeData<T>, PaymentsResponseData>,
) -> CustomResult<String, errors::ConnectorError> {
let base_url = self.connector_base_url(req);
Ok(format!("{}{}", base_url, constants::API_PAY_ENDPOINT))
}
}
);
// PSync flow implementation using macros
macros::macro_connector_implementation!(
connector_default_implementations: [get_content_type, get_error_response_v2],
connector: Phonepe,
curl_request: Json(PhonepeSyncRequest),
curl_response: PhonepeSyncResponse,
flow_name: PSync,
resource_common_data: PaymentFlowData,
flow_request: PaymentsSyncData,
flow_response: PaymentsResponseData,
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<PSync, PaymentFlowData, PaymentsSyncData, PaymentsResponseData>,
) -> CustomResult<Vec<(String, Maskable<String>)>, errors::ConnectorError> {
// Get base headers first
let mut headers = vec![
(
headers::CONTENT_TYPE.to_string(),
"application/json".to_string().into(),
),
];
// Build the request to get the checksum for X-VERIFY header
let connector_router_data = PhonepeRouterData {
connector: self.clone(),
router_data: req,
};
let connector_req = phonepe::PhonepeSyncRequest::try_from(&connector_router_data)?;
// Get merchant ID for X-MERCHANT-ID header
let auth = phonepe::PhonepeAuthType::try_from(&req.connector_auth_type)?;
headers.push((headers::X_VERIFY.to_string(), connector_req.checksum.into()));
headers.push((headers::X_MERCHANT_ID.to_string(), auth.merchant_id.peek().to_string().into()));
Ok(headers)
}
fn get_url(
&self,
| {
"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_706034505544759133_3 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/phonepe.rs
req: &RouterDataV2<PSync, PaymentFlowData, PaymentsSyncData, PaymentsResponseData>,
) -> CustomResult<String, errors::ConnectorError> {
let base_url = self.connector_base_url(req);
let merchant_transaction_id = &req.resource_common_data.connector_request_reference_id;
let auth = phonepe::PhonepeAuthType::try_from(&req.connector_auth_type)?;
let api_endpoint = constants::API_STATUS_ENDPOINT;
let merchant_id = auth.merchant_id.peek();
Ok(format!("{base_url}{api_endpoint}/{merchant_id}/{merchant_transaction_id}"))
}
}
);
// Type alias for non-generic trait implementations
// Implement ConnectorServiceTrait by virtue of implementing all required traits
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> ConnectorCommon for Phonepe<T>
{
fn id(&self) -> &'static str {
"phonepe"
}
fn get_currency_unit(&self) -> enums::CurrencyUnit {
enums::CurrencyUnit::Minor
}
fn common_get_content_type(&self) -> &'static str {
"application/json"
}
fn get_auth_header(
&self,
auth_type: &ConnectorAuthType,
) -> CustomResult<Vec<(String, Maskable<String>)>, errors::ConnectorError> {
let _auth = phonepe::PhonepeAuthType::try_from(auth_type)
.change_context(errors::ConnectorError::FailedToObtainAuthType)?;
Ok(vec![(
"Content-Type".to_string(),
"application/json".to_string().into(),
)])
}
fn base_url<'a>(&self, connectors: &'a Connectors) -> &'a str {
connectors.phonepe.base_url.as_ref()
}
fn build_error_response(
&self,
res: Response,
_event_builder: Option<&mut events::Event>,
) -> CustomResult<ErrorResponse, errors::ConnectorError> {
// Parse PhonePe error response (unified for both sync and payments)
let (error_message, error_code, attempt_status) = if let Ok(error_response) =
res.response
.parse_struct::<phonepe::PhonepeErrorResponse>("PhonePe ErrorResponse")
{
let attempt_status = phonepe::get_phonepe_error_status(&error_response.code);
(error_response.message, error_response.code, attempt_status)
} else {
let raw_response = String::from_utf8_lossy(&res.response);
(
"Unknown PhonePe error".to_string(),
raw_response.to_string(),
None,
)
};
Ok(ErrorResponse {
status_code: res.status_code,
code: error_code,
message: error_message.clone(),
reason: Some(error_message),
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<
VoidPC,
PaymentFlowData,
PaymentsCancelPostCaptureData,
PaymentsResponseData,
> for Phonepe<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> ConnectorSpecifications for Phonepe<T>
{
fn get_supported_payment_methods(
&self,
) -> Option<&'static domain_types::types::SupportedPaymentMethods> {
None // TODO: Add UPI payment methods support
}
fn get_supported_webhook_flows(&self) -> Option<&'static [enums::EventClass]> {
None // TODO: Add webhook support
}
fn get_connector_about(&self) -> Option<&'static ConnectorInfo> {
None // TODO: Add connector info
}
}
// Default empty implementations for unsupported flows - the traits will use default implementations
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
ConnectorIntegrationV2<
CreateOrder,
| {
"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_706034505544759133_4 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/phonepe.rs
PaymentFlowData,
PaymentCreateOrderData,
PaymentCreateOrderResponse,
> for Phonepe<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> ConnectorIntegrationV2<Void, PaymentFlowData, PaymentVoidData, PaymentsResponseData>
for Phonepe<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> ConnectorIntegrationV2<Refund, RefundFlowData, RefundsData, RefundsResponseData>
for Phonepe<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> ConnectorIntegrationV2<Capture, PaymentFlowData, PaymentsCaptureData, PaymentsResponseData>
for Phonepe<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
ConnectorIntegrationV2<
SetupMandate,
PaymentFlowData,
SetupMandateRequestData<T>,
PaymentsResponseData,
> for Phonepe<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
ConnectorIntegrationV2<RepeatPayment, PaymentFlowData, RepeatPaymentData, PaymentsResponseData>
for Phonepe<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> ConnectorIntegrationV2<Accept, DisputeFlowData, AcceptDisputeData, DisputeResponseData>
for Phonepe<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> ConnectorIntegrationV2<RSync, RefundFlowData, RefundSyncData, RefundsResponseData>
for Phonepe<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> ConnectorIntegrationV2<DefendDispute, DisputeFlowData, DisputeDefendData, DisputeResponseData>
for Phonepe<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
ConnectorIntegrationV2<SubmitEvidence, DisputeFlowData, SubmitEvidenceData, DisputeResponseData>
for Phonepe<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
ConnectorIntegrationV2<
PaymentMethodToken,
PaymentFlowData,
PaymentMethodTokenizationData<T>,
PaymentMethodTokenResponse,
> for Phonepe<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
ConnectorIntegrationV2<
PreAuthenticate,
PaymentFlowData,
PaymentsPreAuthenticateData<T>,
PaymentsResponseData,
> for Phonepe<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
ConnectorIntegrationV2<
Authenticate,
PaymentFlowData,
PaymentsAuthenticateData<T>,
PaymentsResponseData,
> for Phonepe<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
ConnectorIntegrationV2<
PostAuthenticate,
PaymentFlowData,
PaymentsPostAuthenticateData<T>,
PaymentsResponseData,
> for Phonepe<T>
{
}
// SourceVerification implementations for all flows - using macro to generate stubs
macro_rules! impl_source_verification_stub {
($flow:ty, $common_data:ty, $req:ty, $resp:ty) => {
| {
"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_706034505544759133_5 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/phonepe.rs
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> SourceVerification<$flow, $common_data, $req, $resp> for Phonepe<T>
{
fn get_secrets(
&self,
_secrets: ConnectorSourceVerificationSecrets,
) -> CustomResult<Vec<u8>, errors::ConnectorError> {
Ok(Vec::new()) // Stub implementation
}
fn get_algorithm(
&self,
) -> CustomResult<
Box<dyn common_utils::crypto::VerifySignature + Send>,
errors::ConnectorError,
> {
Ok(Box::new(common_utils::crypto::NoAlgorithm)) // Stub implementation
}
fn get_signature(
&self,
_payload: &[u8],
_router_data: &RouterDataV2<$flow, $common_data, $req, $resp>,
_secrets: &[u8],
) -> CustomResult<Vec<u8>, errors::ConnectorError> {
Ok(Vec::new()) // Stub implementation
}
fn get_message(
&self,
payload: &[u8],
_router_data: &RouterDataV2<$flow, $common_data, $req, $resp>,
_secrets: &[u8],
) -> CustomResult<Vec<u8>, errors::ConnectorError> {
Ok(payload.to_owned()) // Stub implementation
}
}
};
}
// Stub implementations for missing flows
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
ConnectorIntegrationV2<
CreateSessionToken,
PaymentFlowData,
SessionTokenRequestData,
SessionTokenResponseData,
> for Phonepe<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
ConnectorIntegrationV2<
CreateAccessToken,
PaymentFlowData,
AccessTokenRequestData,
AccessTokenResponseData,
> for Phonepe<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
ConnectorIntegrationV2<
CreateConnectorCustomer,
PaymentFlowData,
ConnectorCustomerData,
ConnectorCustomerResponse,
> for Phonepe<T>
{
}
// Apply to all flows
impl_source_verification_stub!(
CreateSessionToken,
PaymentFlowData,
SessionTokenRequestData,
SessionTokenResponseData
);
impl_source_verification_stub!(
CreateAccessToken,
PaymentFlowData,
AccessTokenRequestData,
AccessTokenResponseData
);
impl_source_verification_stub!(
Authorize,
PaymentFlowData,
PaymentsAuthorizeData<T>,
PaymentsResponseData
);
impl_source_verification_stub!(
CreateOrder,
PaymentFlowData,
PaymentCreateOrderData,
PaymentCreateOrderResponse
);
impl_source_verification_stub!(
PSync,
PaymentFlowData,
PaymentsSyncData,
PaymentsResponseData
);
impl_source_verification_stub!(
Capture,
PaymentFlowData,
PaymentsCaptureData,
PaymentsResponseData
);
impl_source_verification_stub!(Void, PaymentFlowData, PaymentVoidData, PaymentsResponseData);
impl_source_verification_stub!(Refund, RefundFlowData, RefundsData, RefundsResponseData);
impl_source_verification_stub!(RSync, RefundFlowData, RefundSyncData, RefundsResponseData);
impl_source_verification_stub!(
SetupMandate,
PaymentFlowData,
SetupMandateRequestData<T>,
PaymentsResponseData
);
impl_source_verification_stub!(
RepeatPayment,
PaymentFlowData,
RepeatPaymentData,
PaymentsResponseData
);
impl_source_verification_stub!(
Accept,
DisputeFlowData,
AcceptDisputeData,
DisputeResponseData
);
impl_source_verification_stub!(
SubmitEvidence,
DisputeFlowData,
SubmitEvidenceData,
DisputeResponseData
);
impl_source_verification_stub!(
DefendDispute,
DisputeFlowData,
DisputeDefendData,
DisputeResponseData
);
impl_source_verification_stub!(
PaymentMethodToken,
PaymentFlowData,
PaymentMethodTokenizationData<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_706034505544759133_6 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/phonepe.rs
PaymentMethodTokenResponse
);
impl_source_verification_stub!(
PreAuthenticate,
PaymentFlowData,
PaymentsPreAuthenticateData<T>,
PaymentsResponseData
);
impl_source_verification_stub!(
Authenticate,
PaymentFlowData,
PaymentsAuthenticateData<T>,
PaymentsResponseData
);
impl_source_verification_stub!(
PostAuthenticate,
PaymentFlowData,
PaymentsPostAuthenticateData<T>,
PaymentsResponseData
);
impl_source_verification_stub!(
CreateConnectorCustomer,
PaymentFlowData,
ConnectorCustomerData,
ConnectorCustomerResponse
);
impl_source_verification_stub!(
VoidPC,
PaymentFlowData,
PaymentsCancelPostCaptureData,
PaymentsResponseData
);
| {
"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_-2841440142200969754_0 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/helcim.rs
pub mod transformers;
use common_utils::{
consts::NO_ERROR_CODE, errors::CustomResult, events, ext_traits::BytesExt,
fp_utils::generate_id, types::FloatMajorUnit,
};
use domain_types::{
connector_flow::{
Accept, Authenticate, Authorize, Capture, CreateConnectorCustomer, CreateOrder,
CreateSessionToken, DefendDispute, PSync, PostAuthenticate, PreAuthenticate, RSync, Refund,
RepeatPayment, SetupMandate, SubmitEvidence, Void, VoidPC,
},
connector_types::{
AcceptDisputeData, ConnectorCustomerData, ConnectorCustomerResponse, DisputeDefendData,
DisputeFlowData, DisputeResponseData, PaymentCreateOrderData, PaymentCreateOrderResponse,
PaymentFlowData, 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::{ExposeInterface, Mask, Maskable};
use interfaces::{
api::ConnectorCommon, connector_integration_v2::ConnectorIntegrationV2, connector_types,
};
use serde::Serialize;
use std::{
fmt::Debug,
marker::{Send, Sync},
};
use transformers::{
self as helcim, HelcimCaptureRequest, HelcimPaymentsCaptureResponse, HelcimPaymentsRequest,
HelcimPaymentsResponse, HelcimPaymentsSyncResponse, HelcimPaymentsVoidResponse,
HelcimRefundRequest, HelcimVoidRequest, RefundResponse, RefundSyncResponse,
};
use super::macros;
use crate::{types::ResponseRouterData, with_error_response_body};
pub const BASE64_ENGINE: base64::engine::GeneralPurpose = base64::engine::general_purpose::STANDARD;
// Helcim requires an Idempotency Key of length 25. We prefix every ID by "HS_".
const ID_LENGTH: usize = 22;
pub(crate) mod headers {
pub(crate) const CONTENT_TYPE: &str = "Content-Type";
pub(crate) const API_TOKEN: &str = "api-token";
pub(crate) const IDEMPOTENCY_KEY: &str = "idempotency-key";
}
// Trait implementations with generic type parameters
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::ConnectorServiceTrait<T> for Helcim<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::PaymentAuthorizeV2<T> for Helcim<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::PaymentSyncV2 for Helcim<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::PaymentVoidV2 for Helcim<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::RefundSyncV2 for Helcim<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::RefundV2 for Helcim<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::PaymentCapture for Helcim<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::PaymentVoidPostCaptureV2 for Helcim<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
ConnectorIntegrationV2<
VoidPC,
PaymentFlowData,
PaymentsCancelPostCaptureData,
PaymentsResponseData,
> for Helcim<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
VoidPC,
PaymentFlowData,
PaymentsCancelPostCaptureData,
PaymentsResponseData,
> for Helcim<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::ValidationTrait for Helcim<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::PaymentOrderCreate for Helcim<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_-2841440142200969754_1 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/helcim.rs
connector_types::SetupMandateV2<T> for Helcim<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::RepeatPaymentV2 for Helcim<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::AcceptDispute for Helcim<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::SubmitEvidenceV2 for Helcim<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::DisputeDefend for Helcim<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::IncomingWebhook for Helcim<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::PaymentSessionToken for Helcim<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::PaymentTokenV2<T> for Helcim<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::PaymentAccessToken for Helcim<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::CreateConnectorCustomer for Helcim<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::PaymentPreAuthenticateV2<T> for Helcim<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::PaymentAuthenticateV2<T> for Helcim<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::PaymentPostAuthenticateV2<T> for Helcim<T>
{
}
macros::create_all_prerequisites!(
connector_name: Helcim,
generic_type: T,
api: [
(
flow: Authorize,
request_body: HelcimPaymentsRequest<T>,
response_body: HelcimPaymentsResponse,
router_data: RouterDataV2<Authorize, PaymentFlowData, PaymentsAuthorizeData<T>, PaymentsResponseData>,
),
(
flow: PSync,
response_body: HelcimPaymentsSyncResponse,
router_data: RouterDataV2<PSync, PaymentFlowData, PaymentsSyncData, PaymentsResponseData>,
),
(
flow: Capture,
request_body: HelcimCaptureRequest,
response_body: HelcimPaymentsCaptureResponse,
router_data: RouterDataV2<Capture, PaymentFlowData, PaymentsCaptureData, PaymentsResponseData>,
),
(
flow: Void,
request_body: HelcimVoidRequest,
response_body: HelcimPaymentsVoidResponse,
router_data: RouterDataV2<Void, PaymentFlowData, PaymentVoidData, PaymentsResponseData>,
),
(
flow: Refund,
request_body: HelcimRefundRequest,
response_body: RefundResponse,
router_data: RouterDataV2<Refund, RefundFlowData, RefundsData, RefundsResponseData>,
),
(
flow: RSync,
response_body: RefundSyncResponse,
router_data: RouterDataV2<RSync, RefundFlowData, RefundSyncData, RefundsResponseData>,
)
],
amount_converters: [amount_converter: FloatMajorUnit],
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(),
"application/json".to_string().into(),
)];
let mut api_key = self.get_auth_header(&req.connector_auth_type)?;
// Helcim requires an Idempotency Key of length 25. We prefix every ID by "HS_".
let mut idempotency_key = vec![(
headers::IDEMPOTENCY_KEY.to_string(),
generate_id(ID_LENGTH, "HS").into_masked(),
)];
header.append(&mut api_key);
header.append(&mut idempotency_key);
Ok(header)
}
pub fn connector_base_url_payments<'a, F, Req, Res>(
&self,
req: &'a RouterDataV2<F, PaymentFlowData, Req, Res>,
) -> &'a 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_-2841440142200969754_2 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/helcim.rs
&req.resource_common_data.connectors.helcim.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.helcim.base_url
}
}
);
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize> ConnectorCommon
for Helcim<T>
{
fn id(&self) -> &'static str {
"helcim"
}
fn get_currency_unit(&self) -> common_enums::CurrencyUnit {
common_enums::CurrencyUnit::Base
}
fn get_auth_header(
&self,
auth_type: &ConnectorAuthType,
) -> CustomResult<Vec<(String, Maskable<String>)>, errors::ConnectorError> {
let auth = helcim::HelcimAuthType::try_from(auth_type)
.change_context(errors::ConnectorError::FailedToObtainAuthType)?;
Ok(vec![(
headers::API_TOKEN.to_string(),
auth.api_key.expose().into_masked(),
)])
}
fn base_url<'a>(&self, connectors: &'a Connectors) -> &'a str {
connectors.helcim.base_url.as_ref()
}
fn build_error_response(
&self,
res: Response,
event_builder: Option<&mut events::Event>,
) -> CustomResult<ErrorResponse, errors::ConnectorError> {
let response: helcim::HelcimErrorResponse = res
.response
.parse_struct("HelcimErrorResponse")
.change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
with_error_response_body!(event_builder, response);
let error_string = match response {
helcim::HelcimErrorResponse::Payment(response) => match response.errors {
helcim::HelcimErrorTypes::StringType(error) => error,
helcim::HelcimErrorTypes::JsonType(error) => error.to_string(),
},
helcim::HelcimErrorResponse::General(error_string) => error_string,
};
Ok(ErrorResponse {
status_code: res.status_code,
code: NO_ERROR_CODE.to_owned(),
message: error_string.clone(),
reason: Some(error_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: Helcim,
curl_request: Json(HelcimPaymentsRequest),
curl_response: HelcimPaymentsResponse,
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> {
if req.request.is_auto_capture()? {
return Ok(format!("{}v2/payment/purchase", self.connector_base_url_payments(req)));
}
Ok(format!("{}v2/payment/preauth", self.connector_base_url_payments(req)))
}
}
);
// PSync flow implementation
macros::macro_connector_implementation!(
connector_default_implementations: [get_content_type, get_error_response_v2],
connector: Helcim,
curl_response: HelcimPaymentsResponse,
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>,
| {
"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_-2841440142200969754_3 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/helcim.rs
) -> CustomResult<Vec<(String, Maskable<String>)>, errors::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)
}
fn get_url(
&self,
req: &RouterDataV2<PSync, PaymentFlowData, PaymentsSyncData, PaymentsResponseData>,
) -> CustomResult<String, errors::ConnectorError> {
let connector_payment_id = req.request.get_connector_transaction_id()?;
Ok(format!(
"{}v2/card-transactions/{connector_payment_id}",
self.connector_base_url_payments(req)
))
}
}
);
// Capture flow implementation
macros::macro_connector_implementation!(
connector_default_implementations: [get_content_type, get_error_response_v2],
connector: Helcim,
curl_request: Json(HelcimCaptureRequest),
curl_response: HelcimPaymentsResponse,
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!("{}v2/payment/capture", self.connector_base_url_payments(req)))
}
}
);
// Void flow implementation
macros::macro_connector_implementation!(
connector_default_implementations: [get_content_type, get_error_response_v2],
connector: Helcim,
curl_request: Json(HelcimVoidRequest),
curl_response: HelcimPaymentsResponse,
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!("{}v2/payment/reverse", self.connector_base_url_payments(req)))
}
}
);
// Refund flow implementation
macros::macro_connector_implementation!(
connector_default_implementations: [get_content_type, get_error_response_v2],
connector: Helcim,
curl_request: Json(HelcimRefundRequest),
curl_response: RefundResponse,
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!("{}v2/payment/refund", self.connector_base_url_refunds(req)))
}
}
);
// RSync flow implementation
macros::macro_connector_implementation!(
connector_default_implementations: [get_content_type, get_error_response_v2],
connector: Helcim,
| {
"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_-2841440142200969754_4 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/helcim.rs
curl_response: RefundResponse,
flow_name: RSync,
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> {
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)
}
fn get_url(
&self,
req: &RouterDataV2<RSync, RefundFlowData, RefundSyncData, RefundsResponseData>,
) -> CustomResult<String, errors::ConnectorError> {
let connector_refund_id = req.request.connector_refund_id.clone();
Ok(format!(
"{}v2/card-transactions/{connector_refund_id}",
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<
SetupMandate,
PaymentFlowData,
SetupMandateRequestData<T>,
PaymentsResponseData,
> for Helcim<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
ConnectorIntegrationV2<
CreateOrder,
PaymentFlowData,
PaymentCreateOrderData,
PaymentCreateOrderResponse,
> for Helcim<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
ConnectorIntegrationV2<SubmitEvidence, DisputeFlowData, SubmitEvidenceData, DisputeResponseData>
for Helcim<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> ConnectorIntegrationV2<DefendDispute, DisputeFlowData, DisputeDefendData, DisputeResponseData>
for Helcim<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> ConnectorIntegrationV2<Accept, DisputeFlowData, AcceptDisputeData, DisputeResponseData>
for Helcim<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
ConnectorIntegrationV2<RepeatPayment, PaymentFlowData, RepeatPaymentData, PaymentsResponseData>
for Helcim<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
ConnectorIntegrationV2<
CreateSessionToken,
PaymentFlowData,
SessionTokenRequestData,
SessionTokenResponseData,
> for Helcim<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 Helcim<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,
| {
"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_-2841440142200969754_5 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/helcim.rs
domain_types::connector_types::AccessTokenResponseData,
> for Helcim<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
ConnectorIntegrationV2<
PreAuthenticate,
PaymentFlowData,
PaymentsPreAuthenticateData<T>,
PaymentsResponseData,
> for Helcim<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
ConnectorIntegrationV2<
Authenticate,
PaymentFlowData,
PaymentsAuthenticateData<T>,
PaymentsResponseData,
> for Helcim<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
ConnectorIntegrationV2<
PostAuthenticate,
PaymentFlowData,
PaymentsPostAuthenticateData<T>,
PaymentsResponseData,
> for Helcim<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
ConnectorIntegrationV2<
CreateConnectorCustomer,
PaymentFlowData,
ConnectorCustomerData,
ConnectorCustomerResponse,
> for Helcim<T>
{
}
// SourceVerification implementations for all flows
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
Authorize,
PaymentFlowData,
PaymentsAuthorizeData<T>,
PaymentsResponseData,
> for Helcim<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
PSync,
PaymentFlowData,
PaymentsSyncData,
PaymentsResponseData,
> for Helcim<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
Capture,
PaymentFlowData,
PaymentsCaptureData,
PaymentsResponseData,
> for Helcim<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
Void,
PaymentFlowData,
PaymentVoidData,
PaymentsResponseData,
> for Helcim<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
Refund,
RefundFlowData,
RefundsData,
RefundsResponseData,
> for Helcim<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
RSync,
RefundFlowData,
RefundSyncData,
RefundsResponseData,
> for Helcim<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
SetupMandate,
PaymentFlowData,
SetupMandateRequestData<T>,
PaymentsResponseData,
> for Helcim<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
Accept,
DisputeFlowData,
AcceptDisputeData,
DisputeResponseData,
> for Helcim<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
SubmitEvidence,
DisputeFlowData,
SubmitEvidenceData,
DisputeResponseData,
> for Helcim<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
DefendDispute,
DisputeFlowData,
DisputeDefendData,
DisputeResponseData,
> for Helcim<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
CreateOrder,
PaymentFlowData,
PaymentCreateOrderData,
PaymentCreateOrderResponse,
> for Helcim<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
RepeatPayment,
PaymentFlowData,
RepeatPaymentData,
PaymentsResponseData,
> for Helcim<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
CreateSessionToken,
PaymentFlowData,
SessionTokenRequestData,
SessionTokenResponseData,
> for Helcim<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
| {
"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_-2841440142200969754_6 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/helcim.rs
interfaces::verification::SourceVerification<
domain_types::connector_flow::PaymentMethodToken,
PaymentFlowData,
domain_types::connector_types::PaymentMethodTokenizationData<T>,
domain_types::connector_types::PaymentMethodTokenResponse,
> for Helcim<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 Helcim<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
PreAuthenticate,
PaymentFlowData,
PaymentsPreAuthenticateData<T>,
PaymentsResponseData,
> for Helcim<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
Authenticate,
PaymentFlowData,
PaymentsAuthenticateData<T>,
PaymentsResponseData,
> for Helcim<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
PostAuthenticate,
PaymentFlowData,
PaymentsPostAuthenticateData<T>,
PaymentsResponseData,
> for Helcim<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
CreateConnectorCustomer,
PaymentFlowData,
ConnectorCustomerData,
ConnectorCustomerResponse,
> for Helcim<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_2096961394584609998_0 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/mifinity.rs
pub mod transformers;
use std::fmt::Debug;
use common_enums::CurrencyUnit;
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,
PaymentCreateOrderData, PaymentCreateOrderResponse, PaymentFlowData,
PaymentMethodTokenResponse, PaymentMethodTokenizationData, PaymentVoidData,
PaymentsAuthenticateData, PaymentsAuthorizeData, PaymentsCancelPostCaptureData,
PaymentsCaptureData, PaymentsPostAuthenticateData, PaymentsPreAuthenticateData,
PaymentsResponseData, PaymentsSyncData, RefundFlowData, RefundSyncData, RefundsData,
RefundsResponseData, RepeatPaymentData, SessionTokenRequestData, SessionTokenResponseData,
SetupMandateRequestData, SubmitEvidenceData,
},
errors::{self, ConnectorError},
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::{ExposeInterface, Mask, Maskable};
use interfaces::{
api::ConnectorCommon, connector_integration_v2::ConnectorIntegrationV2, connector_types,
};
use serde::Serialize;
use super::macros;
use crate::{
connectors::mifinity::transformers::{
auth_headers, MifinityAuthType, MifinityErrorResponse, MifinityPaymentsRequest,
MifinityPaymentsResponse, MifinityPsyncResponse,
},
types::ResponseRouterData,
};
pub(crate) mod headers {
pub(crate) const CONTENT_TYPE: &str = "Content-Type";
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::PaymentPreAuthenticateV2<T> for Mifinity<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::PaymentAuthenticateV2<T> for Mifinity<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::PaymentPostAuthenticateV2<T> for Mifinity<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::ConnectorServiceTrait<T> for Mifinity<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::PaymentAuthorizeV2<T> for Mifinity<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::PaymentSyncV2 for Mifinity<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::PaymentVoidV2 for Mifinity<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::RefundSyncV2 for Mifinity<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::RefundV2 for Mifinity<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::PaymentCapture for Mifinity<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::ValidationTrait for Mifinity<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::SetupMandateV2<T> for Mifinity<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::RepeatPaymentV2 for Mifinity<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::PaymentVoidPostCaptureV2 for Mifinity<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::AcceptDispute for Mifinity<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::SubmitEvidenceV2 for Mifinity<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_2096961394584609998_1 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/mifinity.rs
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::DisputeDefend for Mifinity<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::IncomingWebhook for Mifinity<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::PaymentOrderCreate for Mifinity<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::PaymentSessionToken for Mifinity<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::PaymentAccessToken for Mifinity<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> connector_types::CreateConnectorCustomer for Mifinity<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::PaymentTokenV2<T> for Mifinity<T>
{
}
const API_VERSION: &str = "1";
macros::create_all_prerequisites!(
connector_name: Mifinity,
generic_type: T,
api: [
(
flow: Authorize,
request_body: MifinityPaymentsRequest,
response_body: MifinityPaymentsResponse,
router_data: RouterDataV2<Authorize, PaymentFlowData, PaymentsAuthorizeData<T>, PaymentsResponseData>,
),
(
flow: PSync,
response_body: MifinityPsyncResponse,
router_data: RouterDataV2<PSync, PaymentFlowData, PaymentsSyncData, 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>)>, ConnectorError> {
let mut header = vec![(
headers::CONTENT_TYPE.to_string(),
"application/json".to_string().into(),
),
(
auth_headers::API_VERSION.to_string(),
API_VERSION.to_string().into(),
),
];
let mut auth_header = self.get_auth_header(&req.connector_auth_type)?;
header.append(&mut auth_header);
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.mifinity.base_url
}
}
);
macros::macro_connector_implementation!(
connector_default_implementations: [get_content_type, get_error_response_v2],
connector: Mifinity,
curl_request: Json(MifinityPaymentsRequest),
curl_response: MifinityPaymentsResponse,
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!("{}pegasus-ci/api/gateway/init-iframe", self.connector_base_url_payments(req)))
}
}
);
macros::macro_connector_implementation!(
connector_default_implementations: [get_content_type, get_error_response_v2],
connector: Mifinity,
curl_response: MifinityPsyncResponse,
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,
| {
"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_2096961394584609998_2 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/mifinity.rs
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 merchant_id = &req.resource_common_data.merchant_id;
let payment_id = &req.resource_common_data.connector_request_reference_id;
Ok(format!(
"{}api/gateway/payment-status/payment_validation_key_{}_{}",
self.connector_base_url_payments(req),
merchant_id.get_string_repr(),
payment_id
))
}
}
);
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
ConnectorIntegrationV2<Void, PaymentFlowData, PaymentVoidData, PaymentsResponseData>
for Mifinity<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
ConnectorIntegrationV2<RSync, RefundFlowData, RefundSyncData, RefundsResponseData>
for Mifinity<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
ConnectorIntegrationV2<Refund, RefundFlowData, RefundsData, RefundsResponseData>
for Mifinity<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
ConnectorIntegrationV2<Capture, PaymentFlowData, PaymentsCaptureData, PaymentsResponseData>
for Mifinity<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
ConnectorIntegrationV2<
SetupMandate,
PaymentFlowData,
SetupMandateRequestData<T>,
PaymentsResponseData,
> for Mifinity<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
ConnectorIntegrationV2<Accept, DisputeFlowData, AcceptDisputeData, DisputeResponseData>
for Mifinity<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
ConnectorIntegrationV2<SubmitEvidence, DisputeFlowData, SubmitEvidenceData, DisputeResponseData>
for Mifinity<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
ConnectorIntegrationV2<DefendDispute, DisputeFlowData, DisputeDefendData, DisputeResponseData>
for Mifinity<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
ConnectorIntegrationV2<
CreateOrder,
PaymentFlowData,
PaymentCreateOrderData,
PaymentCreateOrderResponse,
> for Mifinity<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
ConnectorIntegrationV2<
CreateSessionToken,
PaymentFlowData,
SessionTokenRequestData,
SessionTokenResponseData,
> for Mifinity<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
ConnectorIntegrationV2<
CreateAccessToken,
PaymentFlowData,
AccessTokenRequestData,
AccessTokenResponseData,
> for Mifinity<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
ConnectorIntegrationV2<
CreateConnectorCustomer,
PaymentFlowData,
ConnectorCustomerData,
ConnectorCustomerResponse,
> for Mifinity<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
ConnectorIntegrationV2<
PaymentMethodToken,
PaymentFlowData,
PaymentMethodTokenizationData<T>,
PaymentMethodTokenResponse,
> for Mifinity<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
ConnectorIntegrationV2<
PreAuthenticate,
PaymentFlowData,
PaymentsPreAuthenticateData<T>,
PaymentsResponseData,
> for Mifinity<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
ConnectorIntegrationV2<
Authenticate,
PaymentFlowData,
PaymentsAuthenticateData<T>,
PaymentsResponseData,
> for Mifinity<T>
{
}
| {
"chunk": 2,
"crate": "connector-integration",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_mini_connector-integration_2096961394584609998_3 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/mifinity.rs
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
ConnectorIntegrationV2<
PostAuthenticate,
PaymentFlowData,
PaymentsPostAuthenticateData<T>,
PaymentsResponseData,
> for Mifinity<T>
{
}
// SourceVerification implementations for all flows
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
Authorize,
PaymentFlowData,
PaymentsAuthorizeData<T>,
PaymentsResponseData,
> for Mifinity<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
PSync,
PaymentFlowData,
PaymentsSyncData,
PaymentsResponseData,
> for Mifinity<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
Capture,
PaymentFlowData,
PaymentsCaptureData,
PaymentsResponseData,
> for Mifinity<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
Void,
PaymentFlowData,
PaymentVoidData,
PaymentsResponseData,
> for Mifinity<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
Refund,
RefundFlowData,
RefundsData,
RefundsResponseData,
> for Mifinity<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
RSync,
RefundFlowData,
RefundSyncData,
RefundsResponseData,
> for Mifinity<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
SetupMandate,
PaymentFlowData,
SetupMandateRequestData<T>,
PaymentsResponseData,
> for Mifinity<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
Accept,
DisputeFlowData,
AcceptDisputeData,
DisputeResponseData,
> for Mifinity<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
SubmitEvidence,
DisputeFlowData,
SubmitEvidenceData,
DisputeResponseData,
> for Mifinity<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
DefendDispute,
DisputeFlowData,
DisputeDefendData,
DisputeResponseData,
> for Mifinity<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
CreateOrder,
PaymentFlowData,
PaymentCreateOrderData,
PaymentCreateOrderResponse,
> for Mifinity<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
RepeatPayment,
PaymentFlowData,
RepeatPaymentData,
PaymentsResponseData,
> for Mifinity<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
ConnectorIntegrationV2<RepeatPayment, PaymentFlowData, RepeatPaymentData, PaymentsResponseData>
for Mifinity<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
ConnectorIntegrationV2<
VoidPC,
PaymentFlowData,
PaymentsCancelPostCaptureData,
PaymentsResponseData,
> for Mifinity<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
VoidPC,
PaymentFlowData,
PaymentsCancelPostCaptureData,
PaymentsResponseData,
> for Mifinity<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
CreateSessionToken,
PaymentFlowData,
SessionTokenRequestData,
SessionTokenResponseData,
> for Mifinity<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
| {
"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_2096961394584609998_4 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/mifinity.rs
CreateAccessToken,
PaymentFlowData,
AccessTokenRequestData,
AccessTokenResponseData,
> for Mifinity<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
interfaces::verification::SourceVerification<
CreateConnectorCustomer,
PaymentFlowData,
ConnectorCustomerData,
ConnectorCustomerResponse,
> for Mifinity<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
interfaces::verification::SourceVerification<
PaymentMethodToken,
PaymentFlowData,
PaymentMethodTokenizationData<T>,
PaymentMethodTokenResponse,
> for Mifinity<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
PreAuthenticate,
PaymentFlowData,
PaymentsPreAuthenticateData<T>,
PaymentsResponseData,
> for Mifinity<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
Authenticate,
PaymentFlowData,
PaymentsAuthenticateData<T>,
PaymentsResponseData,
> for Mifinity<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
PostAuthenticate,
PaymentFlowData,
PaymentsPostAuthenticateData<T>,
PaymentsResponseData,
> for Mifinity<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize> ConnectorCommon
for Mifinity<T>
{
fn id(&self) -> &'static str {
"mifinity"
}
fn get_currency_unit(&self) -> CurrencyUnit {
CurrencyUnit::Base
}
fn common_get_content_type(&self) -> &'static str {
"application/json"
}
fn base_url<'a>(&self, connectors: &'a Connectors) -> &'a str {
connectors.mifinity.base_url.as_ref()
}
fn get_auth_header(
&self,
auth_type: &ConnectorAuthType,
) -> CustomResult<Vec<(String, hyperswitch_masking::Maskable<String>)>, errors::ConnectorError>
{
let auth = MifinityAuthType::try_from(auth_type)
.change_context(errors::ConnectorError::FailedToObtainAuthType)?;
Ok(vec![("key".to_string(), auth.key.expose().into_masked())])
}
fn build_error_response(
&self,
res: Response,
event_builder: Option<&mut events::Event>,
) -> CustomResult<ErrorResponse, errors::ConnectorError> {
if res.response.is_empty() {
Ok(ErrorResponse {
status_code: res.status_code,
code: "No error code".to_string(),
message: "No error message".to_string(),
reason: Some("Authentication Error from the connector".to_string()),
attempt_status: None,
connector_transaction_id: None,
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
})
} else {
let response: Result<
MifinityErrorResponse,
Report<common_utils::errors::ParsingError>,
> = res.response.parse_struct("MifinityErrorResponse");
match response {
Ok(response) => {
if let Some(i) = event_builder {
i.set_connector_response(&response);
}
let error_codes = response
.errors
.iter()
.map(|error| error.error_code.clone())
.collect::<Vec<String>>()
.join(" & ");
let error_messages = response
.errors
.iter()
.map(|error| error.message.clone())
.collect::<Vec<String>>()
.join(" & ");
Ok(ErrorResponse {
status_code: res.status_code,
code: error_codes,
| {
"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_2096961394584609998_5 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/mifinity.rs
message: error_messages.clone(),
reason: Some(error_messages),
attempt_status: None,
connector_transaction_id: None,
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}));
}
crate::utils::handle_json_response_deserialization_failure(res, "mifinity")
}
}
}
}
}
| {
"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_-175746656888889134_0 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/bluecode.rs
#[cfg(test)]
mod test;
pub mod transformers;
use std::{
fmt::Debug,
marker::{Send, Sync},
sync::LazyLock,
};
use common_enums::{enums, PaymentMethodType};
use common_utils::{
consts,
errors::CustomResult,
events,
ext_traits::{ByteSliceExt, BytesExt},
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,
},
connector_types::{
AcceptDisputeData, AccessTokenRequestData, AccessTokenResponseData, ConnectorCustomerData,
ConnectorCustomerResponse, ConnectorSpecifications, ConnectorWebhookSecrets,
DisputeDefendData, DisputeFlowData, DisputeResponseData, EventType, PaymentCreateOrderData,
PaymentCreateOrderResponse, PaymentFlowData, PaymentMethodTokenResponse,
PaymentMethodTokenizationData, PaymentVoidData, PaymentsAuthenticateData,
PaymentsAuthorizeData, PaymentsCaptureData, PaymentsPostAuthenticateData,
PaymentsPreAuthenticateData, PaymentsResponseData, PaymentsSyncData, RefundFlowData,
RefundSyncData, RefundsData, RefundsResponseData, RepeatPaymentData, RequestDetails,
ResponseId, SessionTokenRequestData, SessionTokenResponseData, SetupMandateRequestData,
SubmitEvidenceData, SupportedPaymentMethodsExt, WebhookDetailsResponse,
},
errors::{self, ConnectorError},
payment_method_data::{DefaultPCIHolder, PaymentMethodData, PaymentMethodDataTypes},
router_data::{ConnectorAuthType, ErrorResponse},
router_data_v2::RouterDataV2,
router_response_types::Response,
types::{
self, ConnectorInfo, Connectors, FeatureStatus, PaymentMethodDetails,
SupportedPaymentMethods,
},
};
use error_stack::ResultExt;
use hyperswitch_masking::{ExposeInterface, Mask, Maskable};
use interfaces::{
api::ConnectorCommon,
connector_integration_v2::ConnectorIntegrationV2,
connector_types::{self, ConnectorValidation},
};
use serde::Serialize;
use transformers::*;
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";
}
const BLUECODE_API_VERSION: &str = "v1";
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::IncomingWebhook for Bluecode<T>
{
fn verify_webhook_source(
&self,
request: RequestDetails,
connector_webhook_secret: Option<ConnectorWebhookSecrets>,
_connector_account_details: Option<ConnectorAuthType>,
) -> CustomResult<bool, errors::ConnectorError> {
let connector_webhook_secrets = match connector_webhook_secret {
Some(secrets) => secrets.secret,
None => return Ok(false),
};
let security_header = request
.headers
.get("x-eorder-webhook-signature")
.ok_or(domain_types::errors::ConnectorError::WebhookSignatureNotFound)?
.clone();
let signature = hex::decode(security_header)
.change_context(errors::ConnectorError::WebhookSignatureNotFound)?;
let parsed: serde_json::Value = serde_json::from_slice(&request.body)
.change_context(errors::ConnectorError::ParsingFailed)?;
let sorted_payload = transformers::sort_and_minify_json(&parsed)?;
let key = ring::hmac::Key::new(ring::hmac::HMAC_SHA512, &connector_webhook_secrets);
let verify = ring::hmac::verify(&key, sorted_payload.as_bytes(), &signature)
.map(|_| true)
.change_context(errors::ConnectorError::WebhookSourceVerificationFailed)?;
Ok(verify)
}
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();
| {
"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_-175746656888889134_1 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/bluecode.rs
let webhook_body: transformers::BluecodeWebhookResponse = request
.body
.parse_struct("BluecodeWebhookResponse")
.change_context(ConnectorError::WebhookResourceObjectNotFound)
.attach_printable_lazy(|| "Failed to parse Bluecode payment webhook body structure")?;
let transaction_id = webhook_body.order_id.clone();
let status: common_enums::AttemptStatus = webhook_body.status.into();
Ok(WebhookDetailsResponse {
resource_id: Some(ResponseId::ConnectorTransactionId(transaction_id.clone())),
status,
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,
mandate_reference: None,
minor_amount_captured: None,
amount_captured: None,
error_reason: None,
network_txn_id: None,
transformation_status: common_enums::WebhookTransformationStatus::Complete,
})
}
fn get_event_type(
&self,
_request: RequestDetails,
_connector_webhook_secret: Option<ConnectorWebhookSecrets>,
_connector_account_details: Option<ConnectorAuthType>,
) -> Result<EventType, error_stack::Report<ConnectorError>> {
Ok(EventType::Payment)
}
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::ConnectorServiceTrait<T> for Bluecode<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::PaymentTokenV2<T> for Bluecode<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::PaymentAuthorizeV2<T> for Bluecode<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::PaymentSessionToken for Bluecode<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::PaymentSyncV2 for Bluecode<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::PaymentVoidV2 for Bluecode<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::PaymentVoidPostCaptureV2 for Bluecode<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::RefundSyncV2 for Bluecode<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::RefundV2 for Bluecode<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::PaymentCapture for Bluecode<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::SetupMandateV2<T> for Bluecode<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::AcceptDispute for Bluecode<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::SubmitEvidenceV2 for Bluecode<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::DisputeDefend for Bluecode<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::RepeatPaymentV2 for Bluecode<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::ValidationTrait for Bluecode<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::PaymentOrderCreate for Bluecode<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::PaymentPreAuthenticateV2<T> for Bluecode<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::PaymentAuthenticateV2<T> for Bluecode<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::PaymentPostAuthenticateV2<T> for Bluecode<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
ConnectorIntegrationV2<
CreateOrder,
PaymentFlowData,
PaymentCreateOrderData,
| {
"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_-175746656888889134_2 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/bluecode.rs
PaymentCreateOrderResponse,
> for Bluecode<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
ConnectorIntegrationV2<RSync, RefundFlowData, RefundSyncData, RefundsResponseData>
for Bluecode<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
ConnectorIntegrationV2<Refund, RefundFlowData, RefundsData, RefundsResponseData>
for Bluecode<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
ConnectorIntegrationV2<Capture, PaymentFlowData, PaymentsCaptureData, PaymentsResponseData>
for Bluecode<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
ConnectorIntegrationV2<
CreateSessionToken,
PaymentFlowData,
SessionTokenRequestData,
SessionTokenResponseData,
> for Bluecode<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
ConnectorIntegrationV2<SubmitEvidence, DisputeFlowData, SubmitEvidenceData, DisputeResponseData>
for Bluecode<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
ConnectorIntegrationV2<DefendDispute, DisputeFlowData, DisputeDefendData, DisputeResponseData>
for Bluecode<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
ConnectorIntegrationV2<Accept, DisputeFlowData, AcceptDisputeData, DisputeResponseData>
for Bluecode<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
ConnectorIntegrationV2<
SetupMandate,
PaymentFlowData,
SetupMandateRequestData<T>,
PaymentsResponseData,
> for Bluecode<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
ConnectorIntegrationV2<Void, PaymentFlowData, PaymentVoidData, PaymentsResponseData>
for Bluecode<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
ConnectorIntegrationV2<
PreAuthenticate,
PaymentFlowData,
PaymentsPreAuthenticateData<T>,
PaymentsResponseData,
> for Bluecode<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
ConnectorIntegrationV2<
Authenticate,
PaymentFlowData,
PaymentsAuthenticateData<T>,
PaymentsResponseData,
> for Bluecode<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
ConnectorIntegrationV2<
PostAuthenticate,
PaymentFlowData,
PaymentsPostAuthenticateData<T>,
PaymentsResponseData,
> for Bluecode<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
ConnectorIntegrationV2<
domain_types::connector_flow::VoidPC,
PaymentFlowData,
domain_types::connector_types::PaymentsCancelPostCaptureData,
PaymentsResponseData,
> for Bluecode<T>
{
}
// SourceVerification implementations for all flows
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
Authorize,
PaymentFlowData,
PaymentsAuthorizeData<T>,
PaymentsResponseData,
> for Bluecode<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
PSync,
PaymentFlowData,
PaymentsSyncData,
PaymentsResponseData,
> for Bluecode<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
Capture,
PaymentFlowData,
PaymentsCaptureData,
PaymentsResponseData,
> for Bluecode<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
Void,
PaymentFlowData,
PaymentVoidData,
PaymentsResponseData,
> for Bluecode<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
Refund,
RefundFlowData,
RefundsData,
RefundsResponseData,
> for Bluecode<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
RSync,
RefundFlowData,
RefundSyncData,
| {
"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_-175746656888889134_3 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/bluecode.rs
RefundsResponseData,
> for Bluecode<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
SetupMandate,
PaymentFlowData,
SetupMandateRequestData<T>,
PaymentsResponseData,
> for Bluecode<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
Accept,
DisputeFlowData,
AcceptDisputeData,
DisputeResponseData,
> for Bluecode<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
SubmitEvidence,
DisputeFlowData,
SubmitEvidenceData,
DisputeResponseData,
> for Bluecode<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
interfaces::verification::SourceVerification<
CreateAccessToken,
PaymentFlowData,
AccessTokenRequestData,
AccessTokenResponseData,
> for Bluecode<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
interfaces::verification::SourceVerification<
CreateConnectorCustomer,
PaymentFlowData,
ConnectorCustomerData,
ConnectorCustomerResponse,
> for Bluecode<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
DefendDispute,
DisputeFlowData,
DisputeDefendData,
DisputeResponseData,
> for Bluecode<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
CreateSessionToken,
PaymentFlowData,
SessionTokenRequestData,
SessionTokenResponseData,
> for Bluecode<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
CreateOrder,
PaymentFlowData,
PaymentCreateOrderData,
PaymentCreateOrderResponse,
> for Bluecode<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
RepeatPayment,
PaymentFlowData,
RepeatPaymentData,
PaymentsResponseData,
> for Bluecode<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 Bluecode<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
ConnectorIntegrationV2<RepeatPayment, PaymentFlowData, RepeatPaymentData, PaymentsResponseData>
for Bluecode<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
ConnectorIntegrationV2<
PaymentMethodToken,
PaymentFlowData,
PaymentMethodTokenizationData<T>,
PaymentMethodTokenResponse,
> for Bluecode<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
interfaces::verification::SourceVerification<
PaymentMethodToken,
PaymentFlowData,
PaymentMethodTokenizationData<T>,
PaymentMethodTokenResponse,
> for Bluecode<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::PaymentAccessToken for Bluecode<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::CreateConnectorCustomer for Bluecode<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
ConnectorIntegrationV2<
CreateAccessToken,
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_-175746656888889134_4 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/bluecode.rs
AccessTokenRequestData,
AccessTokenResponseData,
> for Bluecode<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
ConnectorIntegrationV2<
CreateConnectorCustomer,
PaymentFlowData,
ConnectorCustomerData,
ConnectorCustomerResponse,
> for Bluecode<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
PreAuthenticate,
PaymentFlowData,
PaymentsPreAuthenticateData<T>,
PaymentsResponseData,
> for Bluecode<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
Authenticate,
PaymentFlowData,
PaymentsAuthenticateData<T>,
PaymentsResponseData,
> for Bluecode<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
PostAuthenticate,
PaymentFlowData,
PaymentsPostAuthenticateData<T>,
PaymentsResponseData,
> for Bluecode<T>
{
}
macros::create_all_prerequisites!(
connector_name: Bluecode,
generic_type: T,
api: [
(
flow: Authorize,
request_body: BluecodePaymentsRequest,
response_body: BluecodePaymentsResponse,
router_data: RouterDataV2<Authorize, PaymentFlowData, PaymentsAuthorizeData<T>, PaymentsResponseData>,
),
(
flow: PSync,
response_body: BluecodeSyncResponse,
router_data: RouterDataV2<PSync, PaymentFlowData, PaymentsSyncData, PaymentsResponseData>,
)
],
amount_converters: [
amount_converter: FloatMajorUnit
],
member_functions: {
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<'a, F, Req, Res>(
&self,
req: &'a RouterDataV2<F, PaymentFlowData, Req, Res>,
) -> &'a str {
req.resource_common_data.connectors.bluecode.base_url.as_ref()
}
}
);
// present
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize> ConnectorCommon
for Bluecode<T>
{
fn id(&self) -> &'static str {
"bluecode"
}
fn get_currency_unit(&self) -> common_enums::CurrencyUnit {
common_enums::CurrencyUnit::Base
}
fn common_get_content_type(&self) -> &'static str {
"application/json"
}
fn base_url<'a>(&self, connectors: &'a Connectors) -> &'a str {
connectors.bluecode.base_url.as_ref()
}
fn get_auth_header(
&self,
auth_type: &ConnectorAuthType,
) -> CustomResult<Vec<(String, Maskable<String>)>, errors::ConnectorError> {
let auth = BluecodeAuthType::try_from(auth_type)
.change_context(errors::ConnectorError::FailedToObtainAuthType)?;
Ok(vec![(
headers::AUTHORIZATION.to_string(),
format!("token {}", auth.api_key.expose()).into_masked(),
)])
}
fn build_error_response(
&self,
res: Response,
event_builder: Option<&mut events::Event>,
) -> CustomResult<ErrorResponse, errors::ConnectorError> {
let response: BluecodeErrorResponse = res
.response
.parse_struct("BluecodeErrorResponse")
.change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
with_error_response_body!(event_builder, response);
Ok(ErrorResponse {
status_code: res.status_code,
code: consts::NO_ERROR_CODE.to_string(),
message: response.message.clone(),
reason: Some(response.message),
attempt_status: None,
connector_transaction_id: None,
| {
"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_-175746656888889134_5 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/bluecode.rs
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
})
}
}
impl ConnectorValidation for Bluecode<DefaultPCIHolder> {
fn validate_mandate_payment(
&self,
_pm_type: Option<PaymentMethodType>,
pm_data: PaymentMethodData<DefaultPCIHolder>,
) -> CustomResult<(), errors::ConnectorError> {
match pm_data {
PaymentMethodData::Card(_) => Err(errors::ConnectorError::NotImplemented(
"validate_mandate_payment does not support cards".to_string(),
)
.into()),
_ => Ok(()),
}
}
fn validate_psync_reference_id(
&self,
_data: &PaymentsSyncData,
_is_three_ds: bool,
_status: enums::AttemptStatus,
_connector_meta_data: Option<common_utils::pii::SecretSerdeValue>,
) -> CustomResult<(), errors::ConnectorError> {
Ok(())
}
fn is_webhook_source_verification_mandatory(&self) -> bool {
true
}
}
macros::macro_connector_implementation!(
connector_default_implementations: [get_content_type, get_error_response_v2],
connector: Bluecode,
curl_request: Json(BluecodePaymentsRequest),
curl_response: BluecodePaymentsResponse,
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!(
"{}api/{}/order/payin/start",
self.connector_base_url_payments(req),
BLUECODE_API_VERSION
))
}
}
);
macros::macro_connector_implementation!(
connector_default_implementations: [get_content_type, get_error_response_v2],
connector: Bluecode,
curl_response: BluecodeSyncResponse,
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 connector_transaction_id = req
.request
.connector_transaction_id
.get_connector_transaction_id()
.change_context(errors::ConnectorError::MissingConnectorTransactionID)?;
Ok(format!(
"{}api/{}/order/{}/status",
self.connector_base_url_payments(req),
BLUECODE_API_VERSION,
connector_transaction_id
))
}
}
);
static BLUECODE_SUPPORTED_PAYMENT_METHODS: LazyLock<SupportedPaymentMethods> =
LazyLock::new(|| {
let supported_capture_methods = vec![enums::CaptureMethod::Automatic];
let mut santander_supported_payment_methods = SupportedPaymentMethods::new();
santander_supported_payment_methods.add(
enums::PaymentMethod::Wallet,
enums::PaymentMethodType::Bluecode,
PaymentMethodDetails {
mandates: FeatureStatus::NotSupported,
refunds: FeatureStatus::NotSupported,
supported_capture_methods,
specific_features: None,
},
);
| {
"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_-175746656888889134_6 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/bluecode.rs
santander_supported_payment_methods
});
static BLUECODE_CONNECTOR_INFO: ConnectorInfo = ConnectorInfo {
display_name: "Bluecode",
description: "Bluecode is building a global payment network that combines Alipay+, Discover and EMPSA and enables seamless payments in 75 countries. With over 160 million acceptance points, payments are processed according to the highest European security and data protection standards to make Europe less dependent on international players.",
connector_type: types::PaymentConnectorCategory::AlternativePaymentMethod,
};
static BLUECODE_SUPPORTED_WEBHOOK_FLOWS: [enums::EventClass; 1] = [enums::EventClass::Payments];
impl ConnectorSpecifications for Bluecode<DefaultPCIHolder> {
fn get_connector_about(&self) -> Option<&'static ConnectorInfo> {
Some(&BLUECODE_CONNECTOR_INFO)
}
fn get_supported_payment_methods(&self) -> Option<&'static SupportedPaymentMethods> {
Some(&*BLUECODE_SUPPORTED_PAYMENT_METHODS)
}
fn get_supported_webhook_flows(&self) -> Option<&'static [enums::EventClass]> {
Some(&BLUECODE_SUPPORTED_WEBHOOK_FLOWS)
}
}
| {
"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_3873789764865049366_0 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/stripe.rs
pub mod transformers;
use std::{
fmt::Debug,
marker::{Send, Sync},
};
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::{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::{ExposeInterface, Mask, Maskable, PeekInterface, Secret};
use interfaces::{
api::ConnectorCommon, connector_integration_v2::ConnectorIntegrationV2, connector_types,
verification::SourceVerification,
};
use serde::Serialize;
use transformers::{
self as stripe, CancelRequest, CaptureRequest, CreateConnectorCustomerRequest,
CreateConnectorCustomerResponse, PaymentIntentRequest,
PaymentIntentRequest as RepeatPaymentRequest, PaymentSyncResponse, PaymentsAuthorizeResponse,
PaymentsAuthorizeResponse as RepeatPaymentResponse, PaymentsCaptureResponse,
PaymentsVoidResponse, RefundResponse, RefundResponse as RefundSyncResponse,
SetupMandateRequest, SetupMandateResponse, StripeRefundRequest,
};
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";
pub(crate) const STRIPE_COMPATIBLE_CONNECT_ACCOUNT: &str = "Stripe-Account";
}
use stripe::auth_headers;
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::ConnectorServiceTrait<T> for Stripe<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::PaymentAuthorizeV2<T> for Stripe<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::PaymentSessionToken for Stripe<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::PaymentAccessToken for Stripe<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::CreateConnectorCustomer for Stripe<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::PaymentSyncV2 for Stripe<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::PaymentVoidV2 for Stripe<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::PaymentVoidPostCaptureV2 for Stripe<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
ConnectorIntegrationV2<
VoidPC,
PaymentFlowData,
PaymentsCancelPostCaptureData,
PaymentsResponseData,
> for Stripe<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
SourceVerification<VoidPC, PaymentFlowData, PaymentsCancelPostCaptureData, PaymentsResponseData>
for Stripe<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::RefundSyncV2 for Stripe<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_3873789764865049366_1 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/stripe.rs
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::RefundV2 for Stripe<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::PaymentCapture for Stripe<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::SetupMandateV2<T> for Stripe<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::AcceptDispute for Stripe<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::SubmitEvidenceV2 for Stripe<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::DisputeDefend for Stripe<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::RepeatPaymentV2 for Stripe<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::PaymentTokenV2<T> for Stripe<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::PaymentPreAuthenticateV2<T> for Stripe<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::PaymentOrderCreate for Stripe<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::PaymentAuthenticateV2<T> for Stripe<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::PaymentPostAuthenticateV2<T> for Stripe<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::IncomingWebhook for Stripe<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::ValidationTrait for Stripe<T>
{
fn should_create_connector_customer(&self) -> bool {
true
}
}
macros::create_amount_converter_wrapper!(connector_name: Stripe, amount_type: MinorUnit);
macros::create_all_prerequisites!(
connector_name: Stripe,
generic_type: T,
api: [
(
flow: Authorize,
request_body: PaymentIntentRequest<T>,
response_body: PaymentsAuthorizeResponse,
router_data: RouterDataV2<Authorize, PaymentFlowData, PaymentsAuthorizeData<T>, PaymentsResponseData>,
),
(
flow: RepeatPayment,
request_body: RepeatPaymentRequest<T>,
response_body: RepeatPaymentResponse,
router_data: RouterDataV2<RepeatPayment, PaymentFlowData, RepeatPaymentData, PaymentsResponseData>,
),
(
flow: PSync,
response_body: PaymentSyncResponse,
router_data: RouterDataV2<PSync, PaymentFlowData, PaymentsSyncData, PaymentsResponseData>,
),
(
flow: Capture,
request_body: CaptureRequest,
response_body: PaymentsCaptureResponse,
router_data: RouterDataV2<Capture, PaymentFlowData, PaymentsCaptureData, PaymentsResponseData>,
),
(
flow: Void,
request_body: CancelRequest,
response_body: PaymentsVoidResponse,
router_data: RouterDataV2<Void, PaymentFlowData, PaymentVoidData, PaymentsResponseData>,
),
(
flow: Refund,
request_body: StripeRefundRequest,
response_body: RefundResponse,
router_data: RouterDataV2<Refund, RefundFlowData, RefundsData, RefundsResponseData>,
),
(
flow: RSync,
response_body: RefundSyncResponse,
router_data: RouterDataV2<RSync, RefundFlowData, RefundSyncData, RefundsResponseData>,
),
(
flow: SetupMandate,
request_body: SetupMandateRequest<T>,
response_body: SetupMandateResponse,
router_data: RouterDataV2<SetupMandate, PaymentFlowData, SetupMandateRequestData<T>, PaymentsResponseData>,
),
(
flow: CreateConnectorCustomer,
request_body: CreateConnectorCustomerRequest,
response_body: CreateConnectorCustomerResponse,
router_data: RouterDataV2<CreateConnectorCustomer, PaymentFlowData, ConnectorCustomerData, ConnectorCustomerResponse>,
)
],
amount_converters: [],
| {
"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_3873789764865049366_2 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/stripe.rs
member_functions: {
pub fn build_headers<F, FCD, Req, Res>(
&self,
req: &RouterDataV2<F, FCD, Req, Res>,
) -> CustomResult<Vec<(String, Maskable<String>)>, errors::ConnectorError> {
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.stripe.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.stripe.base_url
}
}
);
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize> ConnectorCommon
for Stripe<T>
{
fn id(&self) -> &'static str {
"stripe"
}
fn common_get_content_type(&self) -> &'static str {
"application/x-www-form-urlencoded"
}
fn base_url<'a>(&self, connectors: &'a Connectors) -> &'a str {
// &self.base_url
connectors.stripe.base_url.as_ref()
}
fn get_auth_header(
&self,
auth_type: &ConnectorAuthType,
) -> CustomResult<Vec<(String, Maskable<String>)>, errors::ConnectorError> {
let auth = stripe::StripeAuthType::try_from(auth_type)
.change_context(errors::ConnectorError::FailedToObtainAuthType)?;
Ok(vec![
(
headers::AUTHORIZATION.to_string(),
format!("Bearer {}", auth.api_key.peek()).into_masked(),
),
(
auth_headers::STRIPE_API_VERSION.to_string(),
auth_headers::STRIPE_VERSION.to_string().into_masked(),
),
])
}
fn build_error_response(
&self,
res: Response,
event_builder: Option<&mut events::Event>,
) -> CustomResult<ErrorResponse, errors::ConnectorError> {
let response: stripe::ErrorResponse = res
.response
.parse_struct("ErrorResponse")
.change_context(ConnectorError::ResponseDeserializationFailed)?;
with_error_response_body!(event_builder, response);
Ok(ErrorResponse {
status_code: res.status_code,
code: response
.error
.code
.clone()
.unwrap_or_else(|| NO_ERROR_CODE.to_string()),
message: response
.error
.code
.unwrap_or_else(|| NO_ERROR_MESSAGE.to_string()),
reason: response.error.message.map(|message| {
response
.error
.decline_code
.clone()
.map(|decline_code| {
format!("message - {message}, decline_code - {decline_code}")
})
.unwrap_or(message)
}),
attempt_status: None,
connector_transaction_id: response.error.payment_intent.map(|pi| pi.id),
network_advice_code: response.error.network_advice_code,
network_decline_code: response.error.network_decline_code,
network_error_message: response.error.decline_code.or(response.error.advice_code),
})
}
}
macros::macro_connector_implementation!(
connector_default_implementations: [get_content_type, get_error_response_v2],
connector: Stripe,
curl_request: FormUrlEncoded(PaymentIntentRequest),
curl_response: PaymentsAuthorizeResponse,
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>,
| {
"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_3873789764865049366_3 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/stripe.rs
) -> CustomResult<Vec<(String, Maskable<String>)>, errors::ConnectorError> {
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);
let stripe_split_payment_metadata = stripe::StripeSplitPaymentRequest::try_from(req)?;
// if the request has split payment object, then append the transfer account id in headers in charge_type is Direct
if let Some(domain_types::connector_types::SplitPaymentsRequest::StripeSplitPayment(
stripe_split_payment,
)) = &req.request.split_payments
{
if stripe_split_payment.charge_type
==common_enums::PaymentChargeType::Stripe(common_enums::StripeChargeType::Direct)
{
let mut customer_account_header = vec![(
headers::STRIPE_COMPATIBLE_CONNECT_ACCOUNT.to_string(),
stripe_split_payment
.transfer_account_id
.clone()
.into_masked(),
)];
header.append(&mut customer_account_header);
}
}
// if request doesn't have transfer_account_id, but stripe_split_payment_metadata has it, append it
else if let Some(transfer_account_id) =
stripe_split_payment_metadata.transfer_account_id.clone()
{
let mut customer_account_header = vec![(
headers::STRIPE_COMPATIBLE_CONNECT_ACCOUNT.to_string(),
transfer_account_id.into_masked(),
)];
header.append(&mut customer_account_header);
}
Ok(header)
}
fn get_url(
&self,
req: &RouterDataV2<Authorize, PaymentFlowData, PaymentsAuthorizeData<T>, PaymentsResponseData>,
) -> CustomResult<String, errors::ConnectorError> {
Ok(format!(
"{}{}",
self.connector_base_url_payments(req),
"v1/payment_intents"
))
}
}
);
macros::macro_connector_implementation!(
connector_default_implementations: [get_content_type, get_error_response_v2],
connector: Stripe,
curl_request: FormUrlEncoded(RepeatPaymentRequest),
curl_response: RepeatPaymentResponse,
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> {
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);
let stripe_split_payment_metadata = stripe::StripeSplitPaymentRequest::try_from(req)?;
let transfer_account_id = req
.request
.split_payments
.as_ref()
.map(|split_payments| {
let domain_types::connector_types::SplitPaymentsRequest::StripeSplitPayment(stripe_split_payment) =
split_payments;
stripe_split_payment
})
.filter(|stripe_split_payment| {
matches!(stripe_split_payment.charge_type, common_enums::PaymentChargeType::Stripe(common_enums::StripeChargeType::Direct))
})
.map(|stripe_split_payment| stripe_split_payment.transfer_account_id.clone())
| {
"chunk": 3,
"crate": "connector-integration",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_mini_connector-integration_3873789764865049366_4 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/stripe.rs
.or_else(|| stripe_split_payment_metadata.transfer_account_id.clone().map(|s| s.expose()));
if let Some(transfer_account_id) = transfer_account_id {
let mut customer_account_header = vec![(
headers::STRIPE_COMPATIBLE_CONNECT_ACCOUNT.to_string(),
transfer_account_id.clone().into_masked(),
)];
header.append(&mut customer_account_header);
};
Ok(header)
}
fn get_url(
&self,
req: &RouterDataV2<RepeatPayment, PaymentFlowData, RepeatPaymentData, PaymentsResponseData>,
) -> CustomResult<String, errors::ConnectorError> {
Ok(format!(
"{}{}",
self.connector_base_url_payments(req),
"v1/payment_intents"
))
}
}
);
macros::macro_connector_implementation!(
connector_default_implementations: [get_content_type, get_error_response_v2],
connector: Stripe,
curl_request: FormUrlEncoded(SetupMandateRequest),
curl_response: SetupMandateResponse,
flow_name: SetupMandate,
resource_common_data: PaymentFlowData,
flow_request: SetupMandateRequestData<T>,
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<SetupMandate, PaymentFlowData, SetupMandateRequestData<T>, PaymentsResponseData>,
) -> CustomResult<Vec<(String, Maskable<String>)>, errors::ConnectorError> {
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)
}
fn get_url(
&self,
req: &RouterDataV2<SetupMandate, PaymentFlowData, SetupMandateRequestData<T>, PaymentsResponseData>,
) -> CustomResult<String, errors::ConnectorError> {
Ok(format!(
"{}{}",
self.connector_base_url_payments(req),
"v1/setup_intents"
))
}
}
);
macros::macro_connector_implementation!(
connector_default_implementations: [get_content_type, get_error_response_v2],
connector: Stripe,
curl_request: FormUrlEncoded(CreateConnectorCustomerRequest),
curl_response: CreateConnectorCustomerResponse,
flow_name: CreateConnectorCustomer,
resource_common_data: PaymentFlowData,
flow_request: ConnectorCustomerData,
flow_response: ConnectorCustomerResponse,
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<CreateConnectorCustomer, PaymentFlowData, ConnectorCustomerData, ConnectorCustomerResponse>,
) -> CustomResult<Vec<(String, Maskable<String>)>, errors::ConnectorError> {
let mut header = vec![(
headers::CONTENT_TYPE.to_string(),
self.common_get_content_type()
.to_string()
.into(),
)];
let transfer_account_id = req
.request
.split_payments
.as_ref()
.map(|split_payments| {
let domain_types::connector_types::SplitPaymentsRequest::StripeSplitPayment(stripe_split_payment) =
split_payments;
stripe_split_payment
})
.filter(|stripe_split_payment| {
matches!(stripe_split_payment.charge_type, common_enums::PaymentChargeType::Stripe(common_enums::StripeChargeType::Direct))
})
.map(|stripe_split_payment| stripe_split_payment.transfer_account_id.clone());
if let Some(transfer_account_id) = transfer_account_id {
let mut customer_account_header = vec![(
| {
"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_3873789764865049366_5 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/stripe.rs
headers::STRIPE_COMPATIBLE_CONNECT_ACCOUNT.to_string(),
transfer_account_id.clone().into_masked(),
)];
header.append(&mut customer_account_header);
};
let mut api_key = self.get_auth_header(&req.connector_auth_type)?;
header.append(&mut api_key);
Ok(header)
}
fn get_url(
&self,
req: &RouterDataV2<CreateConnectorCustomer, PaymentFlowData, ConnectorCustomerData, ConnectorCustomerResponse>,
) -> CustomResult<String, errors::ConnectorError> {
Ok(format!("{}{}", self.connector_base_url_payments(req), "v1/customers"))
}
}
);
macros::macro_connector_implementation!(
connector_default_implementations: [get_content_type, get_error_response_v2],
connector: Stripe,
curl_response: PaymentSyncResponse,
flow_name: PSync,
resource_common_data: PaymentFlowData,
flow_request: PaymentsSyncData,
flow_response: PaymentsResponseData,
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<PSync, PaymentFlowData, PaymentsSyncData, PaymentsResponseData>,
) -> CustomResult<Vec<(String, Maskable<String>)>, errors::ConnectorError> {
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);
if let Some(domain_types::connector_types::SplitPaymentsRequest::StripeSplitPayment(
stripe_split_payment,
)) = &req.request.split_payments
{
transformers::transform_headers_for_connect_platform(
stripe_split_payment.charge_type.clone(),
Secret::new(stripe_split_payment.transfer_account_id.clone()),
&mut header,
);
}
Ok(header)
}
fn get_url(
&self,
req: &RouterDataV2<PSync, PaymentFlowData, PaymentsSyncData, PaymentsResponseData>,
) -> CustomResult<String, errors::ConnectorError> {
let id = req.request.connector_transaction_id.clone();
match id.get_connector_transaction_id() {
Ok(x) if x.starts_with("set") => Ok(format!(
"{}{}/{}?expand[0]=latest_attempt", // expand latest attempt to extract payment checks and three_d_secure data
self.connector_base_url_payments(req),
"v1/setup_intents",
x,
)),
Ok(x) => Ok(format!(
"{}{}/{}{}",
self.connector_base_url_payments(req),
"v1/payment_intents",
x,
"?expand[0]=latest_charge" //updated payment_id(if present) reside inside latest_charge field
)),
x => x.change_context(ConnectorError::MissingConnectorTransactionID),
}
}
}
);
macros::macro_connector_implementation!(
connector_default_implementations: [get_content_type, get_error_response_v2],
connector: Stripe,
curl_request: FormUrlEncoded(CaptureRequest),
curl_response: PaymentsCaptureResponse,
flow_name: Capture,
resource_common_data: PaymentFlowData,
flow_request: PaymentsCaptureData,
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<Capture, PaymentFlowData, PaymentsCaptureData, PaymentsResponseData>,
) -> CustomResult<Vec<(String, Maskable<String>)>, errors::ConnectorError> {
let mut header = vec![(
headers::CONTENT_TYPE.to_string(),
Self::common_get_content_type(self).to_string().into(),
)];
| {
"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_3873789764865049366_6 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/stripe.rs
let mut api_key = self.get_auth_header(&req.connector_auth_type)?;
header.append(&mut api_key);
Ok(header)
}
fn get_url(
&self,
req: &RouterDataV2<Capture, PaymentFlowData, PaymentsCaptureData, PaymentsResponseData>,
) -> CustomResult<String, errors::ConnectorError> {
let id = req.request.connector_transaction_id.get_connector_transaction_id()
.change_context(errors::ConnectorError::MissingConnectorTransactionID)?;
Ok(format!(
"{}{}/{}/capture",
self.connector_base_url_payments(req),
"v1/payment_intents",
id
))
}
}
);
macros::macro_connector_implementation!(
connector_default_implementations: [get_content_type, get_error_response_v2],
connector: Stripe,
curl_request: FormUrlEncoded(CancelRequest),
curl_response: PaymentsVoidResponse,
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> {
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)
}
fn get_url(
&self,
req: &RouterDataV2<Void, PaymentFlowData, PaymentVoidData, PaymentsResponseData>,
) -> CustomResult<String, errors::ConnectorError> {
let payment_id = &req.request.connector_transaction_id;
Ok(format!(
"{}v1/payment_intents/{}/cancel",
self.connector_base_url_payments(req),
payment_id
))
}
}
);
macros::macro_connector_implementation!(
connector_default_implementations: [get_content_type, get_error_response_v2],
connector: Stripe,
curl_request: FormUrlEncoded(StripeRefundRequest),
curl_response: RefundResponse,
flow_name: Refund,
resource_common_data: RefundFlowData,
flow_request: RefundsData,
flow_response: RefundsResponseData,
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<Refund, RefundFlowData, RefundsData, RefundsResponseData>,
) -> CustomResult<Vec<(String, Maskable<String>)>, errors::ConnectorError> {
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);
if let Some(domain_types::connector_types::SplitRefundsRequest::StripeSplitRefund(ref stripe_split_refund)) =
req.request.split_refunds.as_ref()
{
match &stripe_split_refund.charge_type {
common_enums::PaymentChargeType::Stripe(stripe_charge) => {
if stripe_charge == &common_enums::StripeChargeType::Direct {
let mut customer_account_header = vec![(
headers::STRIPE_COMPATIBLE_CONNECT_ACCOUNT.to_string(),
stripe_split_refund
.transfer_account_id
.clone()
.into_masked(),
)];
header.append(&mut customer_account_header);
}
}
}
}
Ok(header)
}
fn get_url(
| {
"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_3873789764865049366_7 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/stripe.rs
&self,
req: &RouterDataV2<Refund, RefundFlowData, RefundsData, RefundsResponseData>,
) -> CustomResult<String, errors::ConnectorError> {
Ok(format!("{}{}", self.connector_base_url_refunds(req), "v1/refunds"))
}
}
);
macros::macro_connector_implementation!(
connector_default_implementations: [get_content_type, get_error_response_v2],
connector: Stripe,
curl_response: RefundSyncResponse,
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> {
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);
if let Some(domain_types::connector_types::SplitRefundsRequest::StripeSplitRefund(ref stripe_refund)) =
req.request.split_refunds.as_ref()
{
transformers::transform_headers_for_connect_platform(
stripe_refund.charge_type.clone(),
Secret::new(stripe_refund.transfer_account_id.clone()),
&mut header,
);
}
Ok(header)
}
fn get_url(
&self,
req: &RouterDataV2<RSync, RefundFlowData, RefundSyncData, RefundsResponseData>,
) -> CustomResult<String, errors::ConnectorError> {
let id = req.request.connector_refund_id.clone();
Ok(format!("{}v1/refunds/{}", self.connector_base_url_refunds(req), id))
}
}
);
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
ConnectorIntegrationV2<Accept, DisputeFlowData, AcceptDisputeData, DisputeResponseData>
for Stripe<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
ConnectorIntegrationV2<SubmitEvidence, DisputeFlowData, SubmitEvidenceData, DisputeResponseData>
for Stripe<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
ConnectorIntegrationV2<DefendDispute, DisputeFlowData, DisputeDefendData, DisputeResponseData>
for Stripe<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
ConnectorIntegrationV2<
CreateOrder,
PaymentFlowData,
PaymentCreateOrderData,
PaymentCreateOrderResponse,
> for Stripe<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
ConnectorIntegrationV2<
CreateSessionToken,
PaymentFlowData,
SessionTokenRequestData,
SessionTokenResponseData,
> for Stripe<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
ConnectorIntegrationV2<
CreateAccessToken,
PaymentFlowData,
AccessTokenRequestData,
AccessTokenResponseData,
> for Stripe<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
ConnectorIntegrationV2<
PaymentMethodToken,
PaymentFlowData,
PaymentMethodTokenizationData<T>,
PaymentMethodTokenResponse,
> for Stripe<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
ConnectorIntegrationV2<
PreAuthenticate,
PaymentFlowData,
PaymentsPreAuthenticateData<T>,
PaymentsResponseData,
> for Stripe<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
ConnectorIntegrationV2<
Authenticate,
PaymentFlowData,
PaymentsAuthenticateData<T>,
PaymentsResponseData,
> for Stripe<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
ConnectorIntegrationV2<
PostAuthenticate,
PaymentFlowData,
PaymentsPostAuthenticateData<T>,
PaymentsResponseData,
| {
"chunk": 7,
"crate": "connector-integration",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_mini_connector-integration_3873789764865049366_8 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/stripe.rs
> for Stripe<T>
{
}
// SourceVerification implementations for all flows
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
Authorize,
PaymentFlowData,
PaymentsAuthorizeData<T>,
PaymentsResponseData,
> for Stripe<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
PSync,
PaymentFlowData,
PaymentsSyncData,
PaymentsResponseData,
> for Stripe<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
Capture,
PaymentFlowData,
PaymentsCaptureData,
PaymentsResponseData,
> for Stripe<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
Void,
PaymentFlowData,
PaymentVoidData,
PaymentsResponseData,
> for Stripe<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
Refund,
RefundFlowData,
RefundsData,
RefundsResponseData,
> for Stripe<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
RSync,
RefundFlowData,
RefundSyncData,
RefundsResponseData,
> for Stripe<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
SetupMandate,
PaymentFlowData,
SetupMandateRequestData<T>,
PaymentsResponseData,
> for Stripe<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
Accept,
DisputeFlowData,
AcceptDisputeData,
DisputeResponseData,
> for Stripe<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
SubmitEvidence,
DisputeFlowData,
SubmitEvidenceData,
DisputeResponseData,
> for Stripe<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
DefendDispute,
DisputeFlowData,
DisputeDefendData,
DisputeResponseData,
> for Stripe<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
CreateOrder,
PaymentFlowData,
PaymentCreateOrderData,
PaymentCreateOrderResponse,
> for Stripe<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
RepeatPayment,
PaymentFlowData,
RepeatPaymentData,
PaymentsResponseData,
> for Stripe<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
CreateSessionToken,
PaymentFlowData,
SessionTokenRequestData,
SessionTokenResponseData,
> for Stripe<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
CreateAccessToken,
PaymentFlowData,
AccessTokenRequestData,
AccessTokenResponseData,
> for Stripe<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
PaymentMethodToken,
PaymentFlowData,
PaymentMethodTokenizationData<T>,
PaymentMethodTokenResponse,
> for Stripe<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
PreAuthenticate,
PaymentFlowData,
PaymentsPreAuthenticateData<T>,
PaymentsResponseData,
> for Stripe<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
Authenticate,
PaymentFlowData,
PaymentsAuthenticateData<T>,
PaymentsResponseData,
> for Stripe<T>
{
}
| {
"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_3873789764865049366_9 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/stripe.rs
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
PostAuthenticate,
PaymentFlowData,
PaymentsPostAuthenticateData<T>,
PaymentsResponseData,
> for Stripe<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
CreateConnectorCustomer,
PaymentFlowData,
ConnectorCustomerData,
ConnectorCustomerResponse,
> for Stripe<T>
{
}
| {
"chunk": 9,
"crate": "connector-integration",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_mini_connector-integration_8289081459172705603_0 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/rapyd.rs
pub mod transformers;
use base64::Engine;
use common_utils::{errors::CustomResult, events, ext_traits::ByteSliceExt, 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, 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::{ExposeInterface, Mask, Maskable, PeekInterface};
use interfaces::{
api::ConnectorCommon, connector_integration_v2::ConnectorIntegrationV2, connector_types,
};
use rand::distributions::{Alphanumeric, DistString};
use ring::hmac;
use serde::Serialize;
use std::fmt::Debug;
use transformers::{
CaptureRequest, RapydAuthType, RapydPaymentsRequest,
RapydPaymentsResponse as RapydCaptureResponse, RapydPaymentsResponse as RapydPSyncResponse,
RapydPaymentsResponse, RapydPaymentsResponse as RapydVoidResponse,
RapydPaymentsResponse as RapydAuthorizeResponse, RapydRefundRequest, RefundResponse,
RefundResponse as RapydRSyncResponse,
};
use super::macros;
use crate::{types::ResponseRouterData, with_error_response_body};
pub(crate) mod headers {
pub(crate) const CONTENT_TYPE: &str = "Content-Type";
}
pub const BASE64_ENGINE_URL_SAFE: base64::engine::GeneralPurpose =
base64::engine::general_purpose::URL_SAFE;
// Trait implementations with generic type parameters
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::ConnectorServiceTrait<T> for Rapyd<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::PaymentAuthorizeV2<T> for Rapyd<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::PaymentSyncV2 for Rapyd<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::PaymentVoidV2 for Rapyd<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::RefundSyncV2 for Rapyd<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::RefundV2 for Rapyd<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::PaymentCapture for Rapyd<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::PaymentVoidPostCaptureV2 for Rapyd<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
ConnectorIntegrationV2<
VoidPC,
PaymentFlowData,
PaymentsCancelPostCaptureData,
PaymentsResponseData,
> for Rapyd<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
VoidPC,
PaymentFlowData,
PaymentsCancelPostCaptureData,
PaymentsResponseData,
> for Rapyd<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::ValidationTrait for Rapyd<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::PaymentOrderCreate for Rapyd<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_8289081459172705603_1 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/rapyd.rs
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::SetupMandateV2<T> for Rapyd<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::RepeatPaymentV2 for Rapyd<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::AcceptDispute for Rapyd<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::SubmitEvidenceV2 for Rapyd<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::DisputeDefend for Rapyd<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::IncomingWebhook for Rapyd<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::PaymentSessionToken for Rapyd<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::PaymentPreAuthenticateV2<T> for Rapyd<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::PaymentAuthenticateV2<T> for Rapyd<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::PaymentPostAuthenticateV2<T> for Rapyd<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize> ConnectorCommon
for Rapyd<T>
{
fn id(&self) -> &'static str {
"rapyd"
}
fn get_currency_unit(&self) -> common_enums::CurrencyUnit {
common_enums::CurrencyUnit::Base
}
fn get_auth_header(
&self,
auth_type: &ConnectorAuthType,
) -> CustomResult<Vec<(String, Maskable<String>)>, errors::ConnectorError> {
let auth = RapydAuthType::try_from(auth_type)
.change_context(errors::ConnectorError::FailedToObtainAuthType)?;
// Return basic auth headers - signature will be added in get_headers method
Ok(vec![(
"access_key".to_string(),
auth.access_key.into_masked(),
)])
}
fn base_url<'a>(&self, connectors: &'a Connectors) -> &'a str {
connectors.rapyd.base_url.as_ref()
}
fn build_error_response(
&self,
res: Response,
event_builder: Option<&mut events::Event>,
) -> CustomResult<ErrorResponse, errors::ConnectorError> {
let response: Result<RapydPaymentsResponse, Report<common_utils::errors::ParsingError>> =
res.response.parse_struct("rapyd ErrorResponse");
match response {
Ok(response_data) => {
with_error_response_body!(event_builder, response_data);
Ok(ErrorResponse {
status_code: res.status_code,
code: response_data.status.error_code,
message: response_data.status.status.unwrap_or_default(),
reason: response_data.status.message,
attempt_status: None,
connector_transaction_id: None,
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, "rapyd")
}
}
}
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
PaymentMethodToken,
PaymentFlowData,
PaymentMethodTokenizationData<T>,
PaymentMethodTokenResponse,
> for Rapyd<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
ConnectorIntegrationV2<
PaymentMethodToken,
PaymentFlowData,
PaymentMethodTokenizationData<T>,
PaymentMethodTokenResponse,
> for Rapyd<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::PaymentTokenV2<T> for Rapyd<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_8289081459172705603_2 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/rapyd.rs
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
CreateAccessToken,
PaymentFlowData,
AccessTokenRequestData,
AccessTokenResponseData,
> for Rapyd<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
ConnectorIntegrationV2<
CreateAccessToken,
PaymentFlowData,
AccessTokenRequestData,
AccessTokenResponseData,
> for Rapyd<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::PaymentAccessToken for Rapyd<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::CreateConnectorCustomer for Rapyd<T>
{
}
macros::create_all_prerequisites!(
connector_name: Rapyd,
generic_type: T,
api: [
(
flow: Authorize,
request_body: RapydPaymentsRequest<T>,
response_body: RapydAuthorizeResponse,
router_data: RouterDataV2<Authorize, PaymentFlowData, PaymentsAuthorizeData<T>, PaymentsResponseData>,
),
(
flow: PSync,
response_body: RapydPSyncResponse,
router_data: RouterDataV2<PSync, PaymentFlowData, PaymentsSyncData, PaymentsResponseData>,
),
(
flow: Capture,
request_body: CaptureRequest,
response_body: RapydCaptureResponse,
router_data: RouterDataV2<Capture, PaymentFlowData, PaymentsCaptureData, PaymentsResponseData>,
),
(
flow: Void,
response_body: RapydVoidResponse,
router_data: RouterDataV2<Void, PaymentFlowData, PaymentVoidData, PaymentsResponseData>,
),
(
flow: Refund,
request_body: RapydRefundRequest,
response_body: RefundResponse,
router_data: RouterDataV2<Refund, RefundFlowData, RefundsData, RefundsResponseData>,
),
(
flow: RSync,
response_body: RapydRSyncResponse,
router_data: RouterDataV2<RSync, RefundFlowData, RefundSyncData, RefundsResponseData>,
)
],
amount_converters: [
amount_converter: FloatMajorUnit
],
member_functions: {
pub fn build_headers<F, FCD, Req, Res>(
&self,
req: &RouterDataV2<F, FCD, Req, Res>,
http_method: &str,
url_path: &str,
body: &str,
) -> CustomResult<Vec<(String, Maskable<String>)>, errors::ConnectorError>
where
Self: ConnectorIntegrationV2<F, FCD, Req, Res>,
{
let auth = RapydAuthType::try_from(&req.connector_auth_type)?;
let timestamp = common_utils::date_time::now_unix_timestamp();
let salt = Alphanumeric.sample_string(&mut rand::thread_rng(), 12);
let signature = self.generate_signature(
&auth,
http_method,
url_path,
body,
timestamp,
&salt,
)?;
let headers = vec![
(headers::CONTENT_TYPE.to_string(), "application/json".to_string().into()),
("access_key".to_string(), auth.access_key.into_masked()),
("salt".to_string(), salt.into()),
("timestamp".to_string(), timestamp.to_string().into()),
("signature".to_string(), signature.into()),
];
Ok(headers)
}
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.rapyd.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.rapyd.base_url
}
pub fn generate_signature(
&self,
auth: &RapydAuthType,
http_method: &str,
url_path: &str,
body: &str,
timestamp: i64,
salt: &str,
) -> CustomResult<String, errors::ConnectorError> {
let RapydAuthType {
access_key,
secret_key,
} = auth;
| {
"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_8289081459172705603_3 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/rapyd.rs
let to_sign = format!(
"{http_method}{url_path}{salt}{timestamp}{}{}{body}",
access_key.peek(),
secret_key.peek()
);
let key = hmac::Key::new(hmac::HMAC_SHA256, secret_key.peek().as_bytes());
let tag = hmac::sign(&key, to_sign.as_bytes());
let hmac_sign = hex::encode(tag);
let signature_value = BASE64_ENGINE_URL_SAFE.encode(hmac_sign);
Ok(signature_value)
}
}
);
macros::macro_connector_implementation!(
connector_default_implementations: [get_content_type, get_error_response_v2],
connector: Rapyd,
curl_request: Json(RapydPaymentsRequest),
curl_response: RapydAuthorizeResponse,
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> {
let url = self.get_url(req)?;
let url_path = url.strip_prefix(self.connector_base_url_payments(req))
.unwrap_or(&url);
// Get the exact request body that will be sent
let body = self.get_request_body(req)?
.map(|content| content.get_inner_value().expose())
.unwrap_or_default();
self.build_headers(req, "post", url_path, &body)
}
fn get_url(
&self,
req: &RouterDataV2<Authorize, PaymentFlowData, PaymentsAuthorizeData<T>, PaymentsResponseData>,
) -> CustomResult<String, errors::ConnectorError> {
Ok(format!("{}/v1/payments", self.connector_base_url_payments(req)))
}
}
);
macros::macro_connector_implementation!(
connector_default_implementations: [get_content_type, get_error_response_v2],
connector: Rapyd,
curl_response: RapydPSyncResponse,
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> {
let url = self.get_url(req)?;
let url_path = url.strip_prefix(self.connector_base_url_payments(req))
.unwrap_or(&url);
let body = "";
self.build_headers(req, "get", url_path, body)
}
fn get_url(
&self,
req: &RouterDataV2<PSync, PaymentFlowData, PaymentsSyncData, PaymentsResponseData>,
) -> CustomResult<String, errors::ConnectorError> {
let id = req.request.get_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: Rapyd,
curl_request: Json(CaptureRequest),
curl_response: RapydCaptureResponse,
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> {
let url = self.get_url(req)?;
let url_path = url.strip_prefix(self.connector_base_url_payments(req))
.unwrap_or(&url);
let body = self.get_request_body(req)?
.map(|content| content.get_inner_value().expose())
| {
"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_8289081459172705603_4 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/rapyd.rs
.unwrap_or_default();
self.build_headers(req, "post", url_path, &body)
}
fn get_url(
&self,
req: &RouterDataV2<Capture, PaymentFlowData, PaymentsCaptureData, PaymentsResponseData>,
) -> CustomResult<String, errors::ConnectorError> {
let id = req.request.get_connector_transaction_id()?;
Ok(format!("{}/v1/payments/{}/capture", self.connector_base_url_payments(req), id))
}
}
);
macros::macro_connector_implementation!(
connector_default_implementations: [get_content_type, get_error_response_v2],
connector: Rapyd,
curl_response: RapydVoidResponse,
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> {
let url = self.get_url(req)?;
let url_path = url.strip_prefix(self.connector_base_url_payments(req))
.unwrap_or(&url);
let body = "";
self.build_headers(req, "post", url_path, body)
}
fn get_url(
&self,
req: &RouterDataV2<Void, PaymentFlowData, PaymentVoidData, PaymentsResponseData>,
) -> CustomResult<String, errors::ConnectorError> {
Ok(format!("{}/v1/payments/{}", self.connector_base_url_payments(req), req.request.connector_transaction_id))
}
}
);
macros::macro_connector_implementation!(
connector_default_implementations: [get_content_type, get_error_response_v2],
connector: Rapyd,
curl_request: Json(RapydRefundRequest),
curl_response: RefundResponse,
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> {
let url = self.get_url(req)?;
let url_path = url.strip_prefix(self.connector_base_url_refunds(req))
.unwrap_or(&url);
let body = self.get_request_body(req)?
.map(|content| content.get_inner_value().expose())
.unwrap_or_default();
self.build_headers(req, "post", url_path, &body)
}
fn get_url(
&self,
req: &RouterDataV2<Refund, RefundFlowData, RefundsData, RefundsResponseData>,
) -> CustomResult<String, errors::ConnectorError> {
Ok(format!("{}/v1/refunds", self.connector_base_url_refunds(req)))
}
}
);
macros::macro_connector_implementation!(
connector_default_implementations: [get_content_type, get_error_response_v2],
connector: Rapyd,
curl_response: RapydRSyncResponse,
flow_name: RSync,
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> {
let url = self.get_url(req)?;
let url_path = url.strip_prefix(self.connector_base_url_refunds(req))
.unwrap_or(&url);
let body = "";
self.build_headers(req, "get", url_path, body)
}
fn get_url(
&self,
req: &RouterDataV2<RSync, RefundFlowData, RefundSyncData, RefundsResponseData>,
) -> CustomResult<String, errors::ConnectorError> {
| {
"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_8289081459172705603_5 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/rapyd.rs
Ok(format!("{}/v1/refunds/{}", self.connector_base_url_refunds(req), req.request.connector_refund_id))
}
}
);
// 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 Rapyd<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
ConnectorIntegrationV2<SubmitEvidence, DisputeFlowData, SubmitEvidenceData, DisputeResponseData>
for Rapyd<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> ConnectorIntegrationV2<DefendDispute, DisputeFlowData, DisputeDefendData, DisputeResponseData>
for Rapyd<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> ConnectorIntegrationV2<Accept, DisputeFlowData, AcceptDisputeData, DisputeResponseData>
for Rapyd<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
ConnectorIntegrationV2<
SetupMandate,
PaymentFlowData,
SetupMandateRequestData<T>,
PaymentsResponseData,
> for Rapyd<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
ConnectorIntegrationV2<RepeatPayment, PaymentFlowData, RepeatPaymentData, PaymentsResponseData>
for Rapyd<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
ConnectorIntegrationV2<
CreateSessionToken,
PaymentFlowData,
SessionTokenRequestData,
SessionTokenResponseData,
> for Rapyd<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
ConnectorIntegrationV2<
CreateConnectorCustomer,
PaymentFlowData,
ConnectorCustomerData,
ConnectorCustomerResponse,
> for Rapyd<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
ConnectorIntegrationV2<
PreAuthenticate,
PaymentFlowData,
PaymentsPreAuthenticateData<T>,
PaymentsResponseData,
> for Rapyd<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
ConnectorIntegrationV2<
Authenticate,
PaymentFlowData,
PaymentsAuthenticateData<T>,
PaymentsResponseData,
> for Rapyd<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
ConnectorIntegrationV2<
PostAuthenticate,
PaymentFlowData,
PaymentsPostAuthenticateData<T>,
PaymentsResponseData,
> for Rapyd<T>
{
}
// SourceVerification implementations for all flows
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
Authorize,
PaymentFlowData,
PaymentsAuthorizeData<T>,
PaymentsResponseData,
> for Rapyd<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
PSync,
PaymentFlowData,
PaymentsSyncData,
PaymentsResponseData,
> for Rapyd<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
Capture,
PaymentFlowData,
PaymentsCaptureData,
PaymentsResponseData,
> for Rapyd<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
Void,
| {
"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_8289081459172705603_6 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/rapyd.rs
PaymentFlowData,
PaymentVoidData,
PaymentsResponseData,
> for Rapyd<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
Refund,
RefundFlowData,
RefundsData,
RefundsResponseData,
> for Rapyd<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
RSync,
RefundFlowData,
RefundSyncData,
RefundsResponseData,
> for Rapyd<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
SetupMandate,
PaymentFlowData,
SetupMandateRequestData<T>,
PaymentsResponseData,
> for Rapyd<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
Accept,
DisputeFlowData,
AcceptDisputeData,
DisputeResponseData,
> for Rapyd<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
SubmitEvidence,
DisputeFlowData,
SubmitEvidenceData,
DisputeResponseData,
> for Rapyd<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
DefendDispute,
DisputeFlowData,
DisputeDefendData,
DisputeResponseData,
> for Rapyd<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
CreateOrder,
PaymentFlowData,
PaymentCreateOrderData,
PaymentCreateOrderResponse,
> for Rapyd<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
RepeatPayment,
PaymentFlowData,
RepeatPaymentData,
PaymentsResponseData,
> for Rapyd<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
CreateSessionToken,
PaymentFlowData,
SessionTokenRequestData,
SessionTokenResponseData,
> for Rapyd<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
PreAuthenticate,
PaymentFlowData,
PaymentsPreAuthenticateData<T>,
PaymentsResponseData,
> for Rapyd<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
Authenticate,
PaymentFlowData,
PaymentsAuthenticateData<T>,
PaymentsResponseData,
> for Rapyd<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
PostAuthenticate,
PaymentFlowData,
PaymentsPostAuthenticateData<T>,
PaymentsResponseData,
> for Rapyd<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
CreateConnectorCustomer,
PaymentFlowData,
ConnectorCustomerData,
ConnectorCustomerResponse,
> for Rapyd<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_-3022467040228752237_0 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/cryptopay.rs
pub mod transformers;
use std::fmt::Debug;
use common_enums::CurrencyUnit;
use transformers::{
self as cryptopay, CryptopayPaymentsRequest, CryptopayPaymentsResponse,
CryptopayPaymentsResponse as CryptopayPaymentsSyncResponse,
};
use super::macros;
use crate::types::ResponseRouterData;
use hex::encode;
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, ConnectorWebhookSecrets, DisputeDefendData, DisputeFlowData,
DisputeResponseData, EventType, PaymentCreateOrderData, PaymentCreateOrderResponse,
PaymentFlowData, PaymentMethodTokenResponse, PaymentMethodTokenizationData,
PaymentVoidData, PaymentsAuthenticateData, PaymentsAuthorizeData,
PaymentsCancelPostCaptureData, PaymentsCaptureData, PaymentsPostAuthenticateData,
PaymentsPreAuthenticateData, PaymentsResponseData, PaymentsSyncData, RefundFlowData,
RefundSyncData, RefundsData, RefundsResponseData, RepeatPaymentData, RequestDetails,
SessionTokenRequestData, SessionTokenResponseData, SetupMandateRequestData,
SubmitEvidenceData, WebhookDetailsResponse,
},
payment_method_data::PaymentMethodDataTypes,
types::Connectors,
};
use common_utils::{
crypto::{self, GenerateDigest, SignMessage, VerifySignature},
date_time,
errors::CustomResult,
events,
ext_traits::ByteSliceExt,
request::Method,
};
use serde::Serialize;
use domain_types::{
router_data::{ConnectorAuthType, ErrorResponse},
router_data_v2::RouterDataV2,
};
use domain_types::errors;
use domain_types::router_response_types::Response;
use interfaces::{
api::ConnectorCommon, connector_integration_v2::ConnectorIntegrationV2, connector_types,
verification::SourceVerification,
};
use hyperswitch_masking::{Mask, Maskable, PeekInterface};
use crate::with_error_response_body;
use base64::Engine;
pub const BASE64_ENGINE: base64::engine::GeneralPurpose = base64::engine::general_purpose::STANDARD;
use error_stack::ResultExt;
pub(crate) mod headers {
pub(crate) const CONTENT_TYPE: &str = "Content-Type";
pub(crate) const AUTHORIZATION: &str = "Authorization";
pub(crate) const DATE: &str = "Date";
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> ConnectorCommon for Cryptopay<T>
{
fn id(&self) -> &'static str {
"cryptopay"
}
fn get_currency_unit(&self) -> CurrencyUnit {
CurrencyUnit::Base
}
fn common_get_content_type(&self) -> &'static str {
"application/json"
}
fn get_auth_header(
&self,
auth_type: &ConnectorAuthType,
) -> CustomResult<Vec<(String, Maskable<String>)>, errors::ConnectorError> {
let auth = cryptopay::CryptopayAuthType::try_from(auth_type)
.change_context(errors::ConnectorError::FailedToObtainAuthType)?;
Ok(vec![(
headers::AUTHORIZATION.to_string(),
auth.api_key.peek().to_owned().into_masked(),
)])
}
fn base_url<'a>(&self, connectors: &'a Connectors) -> &'a str {
connectors.cryptopay.base_url.as_ref()
}
fn build_error_response(
&self,
res: Response,
event_builder: Option<&mut events::Event>,
) -> CustomResult<ErrorResponse, errors::ConnectorError> {
let response: cryptopay::CryptopayErrorResponse = res
.response
.parse_struct("CryptopayErrorResponse")
.change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
with_error_response_body!(event_builder, response);
Ok(ErrorResponse {
status_code: res.status_code,
code: response.error.code,
message: response.error.message,
reason: response.error.reason,
attempt_status: None,
connector_transaction_id: None,
| {
"chunk": 0,
"crate": "connector-integration",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": null,
"is_async": null,
"is_pub": null,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_mini_connector-integration_-3022467040228752237_1 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/cryptopay.rs
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
})
}
}
// Trait implementations with generic type parameters
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> connector_types::ConnectorServiceTrait<T> for Cryptopay<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> connector_types::PaymentAuthorizeV2<T> for Cryptopay<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> connector_types::PaymentSyncV2 for Cryptopay<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> connector_types::PaymentAccessToken for Cryptopay<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> connector_types::CreateConnectorCustomer for Cryptopay<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> connector_types::PaymentSessionToken for Cryptopay<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> connector_types::PaymentVoidPostCaptureV2 for Cryptopay<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
ConnectorIntegrationV2<
VoidPC,
PaymentFlowData,
PaymentsCancelPostCaptureData,
PaymentsResponseData,
> for Cryptopay<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
>
SourceVerification<VoidPC, PaymentFlowData, PaymentsCancelPostCaptureData, PaymentsResponseData>
for Cryptopay<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> connector_types::PaymentVoidV2 for Cryptopay<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> connector_types::RefundSyncV2 for Cryptopay<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> connector_types::RefundV2 for Cryptopay<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> connector_types::PaymentCapture for Cryptopay<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> connector_types::SetupMandateV2<T> for Cryptopay<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> connector_types::AcceptDispute for Cryptopay<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> connector_types::SubmitEvidenceV2 for Cryptopay<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> connector_types::DisputeDefend for Cryptopay<T>
{
}
impl<
| {
"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_-3022467040228752237_2 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/cryptopay.rs
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> connector_types::PaymentOrderCreate for Cryptopay<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> connector_types::ValidationTrait for Cryptopay<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> connector_types::RepeatPaymentV2 for Cryptopay<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> connector_types::PaymentTokenV2<T> for Cryptopay<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::PaymentPreAuthenticateV2<T> for Cryptopay<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::PaymentAuthenticateV2<T> for Cryptopay<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::PaymentPostAuthenticateV2<T> for Cryptopay<T>
{
}
macros::create_amount_converter_wrapper!(connector_name: Cryptopay, amount_type: StringMajorUnit);
macros::create_all_prerequisites!(
connector_name: Cryptopay,
generic_type: T,
api: [
(
flow: Authorize,
request_body: CryptopayPaymentsRequest,
response_body: CryptopayPaymentsResponse,
router_data: RouterDataV2<Authorize, PaymentFlowData, PaymentsAuthorizeData<T>, PaymentsResponseData>,
),
(
flow: PSync,
response_body: CryptopayPaymentsSyncResponse,
router_data: RouterDataV2<PSync, PaymentFlowData, PaymentsSyncData, PaymentsResponseData>,
)
],
amount_converters: [],
member_functions: {
pub fn build_headers<F, Req, Res>(
&self,
req: &RouterDataV2<F, PaymentFlowData, Req, Res>,
) -> CustomResult<Vec<(String, Maskable<String>)>, errors::ConnectorError>
where
Self: ConnectorIntegrationV2<F, PaymentFlowData, Req, Res>,
{
let method = self.get_http_method();
let payload = match method {
Method::Get => String::default(),
Method::Post | Method::Put | Method::Delete | Method::Patch => {
let body = self
.get_request_body(req)?
.map(|content| content.get_inner_value().peek().to_owned())
.unwrap_or_default();
let md5_payload = crypto::Md5
.generate_digest(body.as_bytes())
.change_context(errors::ConnectorError::RequestEncodingFailed)?;
encode(md5_payload)
}
};
let api_method = method.to_string();
let now = date_time::date_as_yyyymmddthhmmssmmmz()
.change_context(errors::ConnectorError::RequestEncodingFailed)?;
let date = format!("{}+00:00", now.split_at(now.len() - 5).0);
let content_type = self.get_content_type().to_string();
let api = (self.get_url(req)?).replace(self.connector_base_url_payments(req), "");
let auth = cryptopay::CryptopayAuthType::try_from(&req.connector_auth_type)?;
let sign_req: String = format!("{api_method}\n{payload}\n{content_type}\n{date}\n{api}");
let authz = crypto::HmacSha1::sign_message(
&crypto::HmacSha1,
auth.api_secret.peek().as_bytes(),
sign_req.as_bytes(),
)
.change_context(errors::ConnectorError::RequestEncodingFailed)
.attach_printable("Failed to sign the message")?;
let authz = BASE64_ENGINE.encode(authz);
let auth_string: String = format!("HMAC {}:{}", auth.api_key.peek(), authz);
let headers = vec![
(
headers::AUTHORIZATION.to_string(),
| {
"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_-3022467040228752237_3 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/cryptopay.rs
auth_string.into_masked(),
),
(headers::DATE.to_string(), date.into()),
(
headers::CONTENT_TYPE.to_string(),
self.get_content_type().to_string().into(),
),
];
Ok(headers)
}
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.cryptopay.base_url
}
}
);
macros::macro_connector_implementation!(
connector_default_implementations: [get_content_type, get_error_response_v2],
connector: Cryptopay,
curl_request: Json(CryptopayPaymentsRequest),
curl_response: CryptopayResponse,
flow_name: Authorize,
resource_common_data: PaymentFlowData,
flow_request: PaymentsAuthorizeData<T>,
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<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!("{}/api/invoices", self.connector_base_url_payments(req)))
}
}
);
macros::macro_connector_implementation!(
connector_default_implementations: [get_content_type, get_error_response_v2],
connector: Cryptopay,
curl_response: CryptopayPaymentResponse,
flow_name: PSync,
resource_common_data: PaymentFlowData,
flow_request: PaymentsSyncData,
flow_response: PaymentsResponseData,
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<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 custom_id = req.resource_common_data.connector_request_reference_id.clone();
Ok(format!(
"{}/api/invoices/custom_id/{custom_id}",
self.connector_base_url_payments(req),
))
}
}
);
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::IncomingWebhook for Cryptopay<T>
{
fn get_webhook_source_verification_signature(
&self,
request: &RequestDetails,
_connector_webhook_secret: &ConnectorWebhookSecrets,
) -> Result<Vec<u8>, error_stack::Report<domain_types::errors::ConnectorError>> {
let base64_signature = request
.headers
.get("x-cryptopay-signature")
.ok_or(errors::ConnectorError::WebhookSourceVerificationFailed)
.attach_printable("Missing incoming webhook signature for Cryptopay")?;
hex::decode(base64_signature)
.change_context(errors::ConnectorError::WebhookSourceVerificationFailed)
}
fn get_webhook_source_verification_message(
&self,
request: &RequestDetails,
_connector_webhook_secrets: &ConnectorWebhookSecrets,
) -> Result<Vec<u8>, error_stack::Report<domain_types::errors::ConnectorError>> {
let message = std::str::from_utf8(&request.body)
.change_context(errors::ConnectorError::WebhookSourceVerificationFailed)
.attach_printable("Webhook source verification message parsing failed for Cryptopay")?;
Ok(message.to_string().into_bytes())
}
fn verify_webhook_source(
&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_-3022467040228752237_4 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/cryptopay.rs
request: RequestDetails,
connector_webhook_secret: Option<ConnectorWebhookSecrets>,
_connector_account_details: Option<ConnectorAuthType>,
) -> Result<bool, error_stack::Report<domain_types::errors::ConnectorError>> {
let algorithm = crypto::HmacSha256;
let connector_webhook_secrets = match connector_webhook_secret {
Some(secrets) => secrets,
None => Err(domain_types::errors::ConnectorError::WebhookSourceVerificationFailed)?,
};
let signature =
self.get_webhook_source_verification_signature(&request, &connector_webhook_secrets)?;
let message =
self.get_webhook_source_verification_message(&request, &connector_webhook_secrets)?;
algorithm
.verify_signature(&connector_webhook_secrets.secret, &signature, &message)
.change_context(errors::ConnectorError::WebhookSourceVerificationFailed)
.attach_printable("Webhook source verification failed for Cryptopay")
}
fn get_event_type(
&self,
request: RequestDetails,
_connector_webhook_secret: Option<ConnectorWebhookSecrets>,
_connector_account_details: Option<ConnectorAuthType>,
) -> Result<EventType, error_stack::Report<domain_types::errors::ConnectorError>> {
let notif: cryptopay::CryptopayWebhookDetails = request
.body
.parse_struct("CryptopayWebhookDetails")
.change_context(errors::ConnectorError::WebhookEventTypeNotFound)?;
match notif.data.status {
cryptopay::CryptopayPaymentStatus::Completed => Ok(EventType::PaymentIntentSuccess),
cryptopay::CryptopayPaymentStatus::Unresolved => Ok(EventType::PaymentActionRequired),
cryptopay::CryptopayPaymentStatus::Cancelled => Ok(EventType::PaymentIntentFailure),
_ => Ok(EventType::IncomingWebhookEventUnspecified),
}
}
fn process_payment_webhook(
&self,
request: RequestDetails,
_connector_webhook_secret: Option<ConnectorWebhookSecrets>,
_connector_account_details: Option<ConnectorAuthType>,
) -> Result<WebhookDetailsResponse, error_stack::Report<domain_types::errors::ConnectorError>>
{
let notif: cryptopay::CryptopayWebhookDetails = request
.body
.parse_struct("CryptopayWebhookDetails")
.change_context(errors::ConnectorError::WebhookEventTypeNotFound)?;
let response = WebhookDetailsResponse::try_from(notif)
.change_context(errors::ConnectorError::WebhookBodyDecodingFailed);
response.map(|mut response| {
response.raw_connector_response =
Some(String::from_utf8_lossy(&request.body).to_string());
response
})
}
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
ConnectorIntegrationV2<Void, PaymentFlowData, PaymentVoidData, PaymentsResponseData>
for Cryptopay<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
ConnectorIntegrationV2<RSync, RefundFlowData, RefundSyncData, RefundsResponseData>
for Cryptopay<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
ConnectorIntegrationV2<Refund, RefundFlowData, RefundsData, RefundsResponseData>
for Cryptopay<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
ConnectorIntegrationV2<Capture, PaymentFlowData, PaymentsCaptureData, PaymentsResponseData>
for Cryptopay<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
ConnectorIntegrationV2<
SetupMandate,
PaymentFlowData,
SetupMandateRequestData<T>,
PaymentsResponseData,
> for Cryptopay<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
ConnectorIntegrationV2<Accept, DisputeFlowData, AcceptDisputeData, DisputeResponseData>
for Cryptopay<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
ConnectorIntegrationV2<SubmitEvidence, DisputeFlowData, SubmitEvidenceData, DisputeResponseData>
for Cryptopay<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_-3022467040228752237_5 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/cryptopay.rs
ConnectorIntegrationV2<DefendDispute, DisputeFlowData, DisputeDefendData, DisputeResponseData>
for Cryptopay<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
ConnectorIntegrationV2<
CreateOrder,
PaymentFlowData,
PaymentCreateOrderData,
PaymentCreateOrderResponse,
> for Cryptopay<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
ConnectorIntegrationV2<
CreateSessionToken,
PaymentFlowData,
SessionTokenRequestData,
SessionTokenResponseData,
> for Cryptopay<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
ConnectorIntegrationV2<
CreateAccessToken,
PaymentFlowData,
AccessTokenRequestData,
AccessTokenResponseData,
> for Cryptopay<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
ConnectorIntegrationV2<
PaymentMethodToken,
PaymentFlowData,
PaymentMethodTokenizationData<T>,
PaymentMethodTokenResponse,
> for Cryptopay<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
ConnectorIntegrationV2<
PreAuthenticate,
PaymentFlowData,
PaymentsPreAuthenticateData<T>,
PaymentsResponseData,
> for Cryptopay<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
ConnectorIntegrationV2<
Authenticate,
PaymentFlowData,
PaymentsAuthenticateData<T>,
PaymentsResponseData,
> for Cryptopay<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
ConnectorIntegrationV2<
PostAuthenticate,
PaymentFlowData,
PaymentsPostAuthenticateData<T>,
PaymentsResponseData,
> for Cryptopay<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
ConnectorIntegrationV2<
CreateConnectorCustomer,
PaymentFlowData,
ConnectorCustomerData,
ConnectorCustomerResponse,
> for Cryptopay<T>
{
}
// SourceVerification implementations for all flows
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
Authorize,
PaymentFlowData,
PaymentsAuthorizeData<T>,
PaymentsResponseData,
> for Cryptopay<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
PSync,
PaymentFlowData,
PaymentsSyncData,
PaymentsResponseData,
> for Cryptopay<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
Capture,
PaymentFlowData,
PaymentsCaptureData,
PaymentsResponseData,
> for Cryptopay<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
Void,
PaymentFlowData,
PaymentVoidData,
PaymentsResponseData,
> for Cryptopay<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
Refund,
RefundFlowData,
RefundsData,
RefundsResponseData,
> for Cryptopay<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
RSync,
RefundFlowData,
RefundSyncData,
RefundsResponseData,
> for Cryptopay<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
SetupMandate,
PaymentFlowData,
SetupMandateRequestData<T>,
PaymentsResponseData,
> for Cryptopay<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
Accept,
DisputeFlowData,
AcceptDisputeData,
DisputeResponseData,
> for Cryptopay<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
SubmitEvidence,
DisputeFlowData,
SubmitEvidenceData,
DisputeResponseData,
> for Cryptopay<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_-3022467040228752237_6 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/cryptopay.rs
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
DefendDispute,
DisputeFlowData,
DisputeDefendData,
DisputeResponseData,
> for Cryptopay<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
CreateOrder,
PaymentFlowData,
PaymentCreateOrderData,
PaymentCreateOrderResponse,
> for Cryptopay<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
RepeatPayment,
PaymentFlowData,
RepeatPaymentData,
PaymentsResponseData,
> for Cryptopay<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
ConnectorIntegrationV2<RepeatPayment, PaymentFlowData, RepeatPaymentData, PaymentsResponseData>
for Cryptopay<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
CreateSessionToken,
PaymentFlowData,
SessionTokenRequestData,
SessionTokenResponseData,
> for Cryptopay<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
CreateAccessToken,
PaymentFlowData,
AccessTokenRequestData,
AccessTokenResponseData,
> for Cryptopay<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
PaymentMethodToken,
PaymentFlowData,
PaymentMethodTokenizationData<T>,
PaymentMethodTokenResponse,
> for Cryptopay<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
PreAuthenticate,
PaymentFlowData,
PaymentsPreAuthenticateData<T>,
PaymentsResponseData,
> for Cryptopay<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
Authenticate,
PaymentFlowData,
PaymentsAuthenticateData<T>,
PaymentsResponseData,
> for Cryptopay<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
PostAuthenticate,
PaymentFlowData,
PaymentsPostAuthenticateData<T>,
PaymentsResponseData,
> for Cryptopay<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
interfaces::verification::SourceVerification<
CreateConnectorCustomer,
PaymentFlowData,
ConnectorCustomerData,
ConnectorCustomerResponse,
> for Cryptopay<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_5127189373612706197_0 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/checkout.rs
pub mod transformers;
use std::fmt::Debug;
use common_utils::{consts, 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, ResponseId, SessionTokenRequestData,
SessionTokenResponseData, SetupMandateRequestData, SubmitEvidenceData,
},
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::{Mask, Maskable, PeekInterface};
use interfaces::{
api::ConnectorCommon, connector_integration_v2::ConnectorIntegrationV2, connector_types,
};
use serde::Serialize;
use transformers::{
ActionResponse, CheckoutAuthorizeResponse, CheckoutErrorResponse, CheckoutPSyncResponse,
CheckoutPaymentsRequest, CheckoutRefundSyncRequest, CheckoutSyncRequest, PaymentCaptureRequest,
PaymentCaptureResponse, PaymentVoidRequest, PaymentVoidResponse, RefundRequest, RefundResponse,
};
use super::macros;
use crate::types::ResponseRouterData;
pub(crate) mod headers {
pub(crate) const CONTENT_TYPE: &str = "Content-Type";
pub(crate) const AUTHORIZATION: &str = "Authorization";
}
// Type alias for non-generic trait implementations
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> connector_types::ConnectorServiceTrait<T> for Checkout<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> connector_types::PaymentAuthorizeV2<T> for Checkout<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> connector_types::PaymentSessionToken for Checkout<T>
{
}
impl<T: PaymentMethodDataTypes + Debug + Sync + Send + 'static + Serialize>
connector_types::PaymentAccessToken for Checkout<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> connector_types::CreateConnectorCustomer for Checkout<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> connector_types::PaymentSyncV2 for Checkout<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> connector_types::PaymentVoidV2 for Checkout<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> connector_types::RefundSyncV2 for Checkout<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> connector_types::RefundV2 for Checkout<T>
{
}
impl<
| {
"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_5127189373612706197_1 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/checkout.rs
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> connector_types::PaymentCapture for Checkout<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> connector_types::ValidationTrait for Checkout<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> connector_types::SetupMandateV2<T> for Checkout<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> connector_types::AcceptDispute for Checkout<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> connector_types::SubmitEvidenceV2 for Checkout<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> connector_types::DisputeDefend for Checkout<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> connector_types::IncomingWebhook for Checkout<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> connector_types::PaymentOrderCreate for Checkout<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> connector_types::RepeatPaymentV2 for Checkout<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> connector_types::PaymentTokenV2<T> for Checkout<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> connector_types::PaymentPreAuthenticateV2<T> for Checkout<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> connector_types::PaymentAuthenticateV2<T> for Checkout<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> connector_types::PaymentPostAuthenticateV2<T> for Checkout<T>
{
}
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> connector_types::PaymentVoidPostCaptureV2 for Checkout<T>
{
}
macros::create_all_prerequisites!(
connector_name: Checkout,
generic_type: T,
api: [
(
flow: Authorize,
request_body: CheckoutPaymentsRequest<T>,
response_body: CheckoutAuthorizeResponse,
router_data: RouterDataV2<Authorize, PaymentFlowData, PaymentsAuthorizeData<T>, PaymentsResponseData>,
),
(
flow: PSync,
request_body: CheckoutSyncRequest,
response_body: CheckoutPSyncResponse,
router_data: RouterDataV2<PSync, PaymentFlowData, PaymentsSyncData, PaymentsResponseData>,
),
(
flow: Capture,
request_body: PaymentCaptureRequest,
response_body: PaymentCaptureResponse,
router_data: RouterDataV2<Capture, PaymentFlowData, PaymentsCaptureData, PaymentsResponseData>,
),
(
flow: Void,
request_body: PaymentVoidRequest,
response_body: PaymentVoidResponse,
| {
"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_5127189373612706197_2 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/checkout.rs
router_data: RouterDataV2<Void, PaymentFlowData, PaymentVoidData, PaymentsResponseData>,
),
(
flow: Refund,
request_body: RefundRequest,
response_body: RefundResponse,
router_data: RouterDataV2<Refund, RefundFlowData, RefundsData, RefundsResponseData>,
),
(
flow: RSync,
request_body: CheckoutRefundSyncRequest,
response_body: ActionResponse,
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>,
) -> CustomResult<Vec<(String, Maskable<String>)>, ConnectorError> {
let mut header = vec![(
headers::CONTENT_TYPE.to_string(),
"application/json".to_string().into(),
)];
let mut auth_header = self.get_auth_header(&req.connector_auth_type)?;
header.append(&mut auth_header);
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.checkout.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.checkout.base_url
}
}
);
impl<
T: PaymentMethodDataTypes
+ std::fmt::Debug
+ std::marker::Sync
+ std::marker::Send
+ 'static
+ Serialize,
> ConnectorCommon for Checkout<T>
{
fn id(&self) -> &'static str {
"checkout"
}
fn common_get_content_type(&self) -> &'static str {
"application/json"
}
fn get_auth_header(
&self,
auth_type: &ConnectorAuthType,
) -> CustomResult<Vec<(String, Maskable<String>)>, errors::ConnectorError> {
let auth = transformers::CheckoutAuthType::try_from(auth_type)
.change_context(errors::ConnectorError::FailedToObtainAuthType)?;
Ok(vec![(
headers::AUTHORIZATION.to_string(),
format!("Bearer {}", auth.api_secret.peek()).into_masked(),
)])
}
fn base_url<'a>(&self, connectors: &'a Connectors) -> &'a str {
connectors.checkout.base_url.as_ref()
}
fn build_error_response(
&self,
res: Response,
event_builder: Option<&mut events::Event>,
) -> CustomResult<ErrorResponse, errors::ConnectorError> {
let response: CheckoutErrorResponse = if res.response.is_empty() {
let (error_codes, error_type) = if res.status_code == 401 {
(
Some(vec!["Invalid api key".to_string()]),
Some("invalid_api_key".to_string()),
)
} else {
(None, None)
};
CheckoutErrorResponse {
request_id: None,
error_codes,
error_type,
}
} else {
res.response
.parse_struct("ErrorResponse")
.change_context(errors::ConnectorError::ResponseDeserializationFailed)?
};
if let Some(i) = event_builder {
i.set_connector_response(&response);
}
Ok(ErrorResponse {
status_code: res.status_code,
code: consts::NO_ERROR_CODE.to_string(),
message: consts::NO_ERROR_MESSAGE.to_string(),
reason: response
.error_codes
.map(|errors| errors.join(" & "))
.or(response.error_type),
attempt_status: None,
connector_transaction_id: response.request_id,
network_decline_code: None,
network_advice_code: None,
network_error_message: None,
})
}
}
macros::macro_connector_implementation!(
connector_default_implementations: [get_content_type, get_error_response_v2],
connector: Checkout,
curl_request: Json(CheckoutPaymentsRequest),
curl_response: CheckoutAuthorizeResponse,
| {
"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_5127189373612706197_3 | clm | mini_chunk | // connector-service/backend/connector-integration/src/connectors/checkout.rs
flow_name: Authorize,
resource_common_data: PaymentFlowData,
flow_request: PaymentsAuthorizeData<T>,
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<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!("{}payments", self.connector_base_url_payments(req)))
}
}
);
macros::macro_connector_implementation!(
connector_default_implementations: [get_content_type, get_error_response_v2],
connector: Checkout,
curl_request: Json(CheckoutSyncRequest),
curl_response: CheckoutPSyncResponse,
flow_name: PSync,
resource_common_data: PaymentFlowData,
flow_request: PaymentsSyncData,
flow_response: PaymentsResponseData,
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<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 connector_tx_id = match &req.request.connector_transaction_id {
domain_types::connector_types::ResponseId::ConnectorTransactionId(id) => id.clone(),
_ => return Err(errors::ConnectorError::MissingConnectorTransactionID.into()),
};
Ok(format!("{}payments/{}", self.connector_base_url_payments(req), connector_tx_id))
}
}
);
macros::macro_connector_implementation!(
connector_default_implementations: [get_content_type, get_error_response_v2],
connector: Checkout,
curl_request: Json(PaymentCaptureRequest),
curl_response: PaymentCaptureResponse,
flow_name: Capture,
resource_common_data: PaymentFlowData,
flow_request: PaymentsCaptureData,
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<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_tx_id = match &req.request.connector_transaction_id {
ResponseId::ConnectorTransactionId(id) => id.clone(),
_ => return Err(errors::ConnectorError::MissingConnectorTransactionID.into()),
};
Ok(format!("{}payments/{}/captures", self.connector_base_url_payments(req), connector_tx_id))
}
}
);
macros::macro_connector_implementation!(
connector_default_implementations: [get_content_type, get_error_response_v2],
connector: Checkout,
curl_request: Json(RefundRequest),
curl_response: RefundResponse,
flow_name: Refund,
resource_common_data: RefundFlowData,
flow_request: RefundsData,
flow_response: RefundsResponseData,
http_method: Post,
generic_type: T,
[PaymentMethodDataTypes + std::fmt::Debug + std::marker::Sync + std::marker::Send + 'static + Serialize],
other_functions: {
fn get_headers(
&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
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.