id stringlengths 20 153 | type stringclasses 1
value | granularity stringclasses 14
values | content stringlengths 16 84.3k | metadata dict |
|---|---|---|---|---|
connector-service_fn_grpc-server_-3438328200384070630 | clm | function | // connector-service/backend/grpc-server/src/server/payments.rs
async fn handle_order_creation_for_setup_mandate<
T: PaymentMethodDataTypes
+ Default
+ Eq
+ Debug
+ Send
+ serde::Serialize
+ serde::de::DeserializeOwned
+ Clone
+ Sync
+ domain_types::types::CardConversionHelper<T>,
>(
&self,
connector_data: ConnectorData<T>,
payment_flow_data: &PaymentFlowData,
connector_auth_details: ConnectorAuthType,
event_params: EventParams<'_>,
payload: &PaymentServiceRegisterRequest,
connector_name: &str,
service_name: &str,
) -> Result<String, tonic::Status> {
// Get connector integration
let connector_integration: BoxedConnectorIntegrationV2<
'_,
CreateOrder,
PaymentFlowData,
PaymentCreateOrderData,
PaymentCreateOrderResponse,
> = connector_data.connector.get_connector_integration_v2();
let currency = common_enums::Currency::foreign_try_from(payload.currency())
.map_err(|e| e.into_grpc_status())?;
let order_create_data = PaymentCreateOrderData {
amount: common_utils::types::MinorUnit::new(0),
currency,
integrity_object: None,
metadata: if payload.metadata.is_empty() {
None
} else {
Some(serde_json::to_value(payload.metadata.clone()).unwrap_or_default())
},
webhook_url: payload.webhook_url.clone(),
};
let order_router_data = RouterDataV2::<
CreateOrder,
PaymentFlowData,
PaymentCreateOrderData,
PaymentCreateOrderResponse,
> {
flow: std::marker::PhantomData,
resource_common_data: payment_flow_data.clone(),
connector_auth_type: connector_auth_details,
request: order_create_data,
response: Err(ErrorResponse::default()),
};
// Execute connector processing
let external_event_params = EventProcessingParams {
connector_name,
service_name,
flow_name: FlowName::CreateOrder,
event_config: &self.config.events,
request_id: event_params.request_id,
lineage_ids: event_params.lineage_ids,
reference_id: event_params.reference_id,
shadow_mode: event_params.shadow_mode,
};
// Execute connector processing
let response = Box::pin(
external_services::service::execute_connector_processing_step(
&self.config.proxy,
connector_integration,
order_router_data,
None,
external_event_params,
None,
common_enums::CallConnectorAction::Trigger,
),
)
.await
.switch()
.map_err(|e| e.into_grpc_status())?;
match response.response {
Ok(PaymentCreateOrderResponse { order_id, .. }) => Ok(order_id),
Err(ErrorResponse { message, .. }) => Err(tonic::Status::internal(format!(
"Order creation error: {message}"
))),
}
}
| {
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": "handle_order_creation_for_setup_mandate",
"is_async": false,
"is_pub": false,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_fn_grpc-server_3118207782561495407 | clm | function | // connector-service/backend/grpc-server/src/server/payments.rs
async fn handle_session_token<
T: PaymentMethodDataTypes
+ Default
+ Eq
+ Debug
+ Send
+ serde::Serialize
+ serde::de::DeserializeOwned
+ Clone
+ Sync
+ domain_types::types::CardConversionHelper<T>
+ 'static,
P: serde::Serialize + Clone,
>(
&self,
connector_data: ConnectorData<T>,
payment_flow_data: &PaymentFlowData,
connector_auth_details: ConnectorAuthType,
payload: &P,
connector_name: &str,
service_name: &str,
event_params: EventParams<'_>,
) -> Result<SessionTokenResponseData, PaymentAuthorizationError>
where
SessionTokenRequestData: ForeignTryFrom<P, Error = ApplicationErrorResponse>,
{
// Get connector integration
let connector_integration: BoxedConnectorIntegrationV2<
'_,
CreateSessionToken,
PaymentFlowData,
SessionTokenRequestData,
SessionTokenResponseData,
> = connector_data.connector.get_connector_integration_v2();
// Create session token request data using try_from_foreign
let session_token_request_data = SessionTokenRequestData::foreign_try_from(payload.clone())
.map_err(|e| {
PaymentAuthorizationError::new(
grpc_api_types::payments::PaymentStatus::Pending,
Some(format!("Session Token creation failed: {e}")),
Some("SESSION_TOKEN_CREATION_ERROR".to_string()),
Some(400), // Bad Request - client data issue
)
})?;
let session_token_router_data = RouterDataV2::<
CreateSessionToken,
PaymentFlowData,
SessionTokenRequestData,
SessionTokenResponseData,
> {
flow: std::marker::PhantomData,
resource_common_data: payment_flow_data.clone(),
connector_auth_type: connector_auth_details,
request: session_token_request_data,
response: Err(ErrorResponse::default()),
};
// Create event processing parameters
let external_event_params = EventProcessingParams {
connector_name,
service_name,
flow_name: FlowName::CreateSessionToken,
event_config: &self.config.events,
request_id: event_params.request_id,
lineage_ids: event_params.lineage_ids,
reference_id: event_params.reference_id,
shadow_mode: event_params.shadow_mode,
};
// Execute connector processing
let response = external_services::service::execute_connector_processing_step(
&self.config.proxy,
connector_integration,
session_token_router_data,
None,
external_event_params,
None,
common_enums::CallConnectorAction::Trigger,
)
.await
.switch()
.map_err(|e: error_stack::Report<ApplicationErrorResponse>| {
PaymentAuthorizationError::new(
grpc_api_types::payments::PaymentStatus::Pending,
Some(format!("Session Token creation failed: {e}")),
Some("SESSION_TOKEN_CREATION_ERROR".to_string()),
Some(500), // Internal Server Error - connector processing failed
)
})?;
match response.response {
Ok(session_token_data) => {
tracing::info!(
"Session token created successfully: {}",
session_token_data.session_token
);
Ok(session_token_data)
}
Err(ErrorResponse {
message,
status_code,
..
}) => Err(PaymentAuthorizationError::new(
grpc_api_types::payments::PaymentStatus::Pending,
Some(format!("Session Token creation failed: {message}")),
Some("SESSION_TOKEN_CREATION_ERROR".to_string()),
Some(status_code.into()), // Use actual status code from ErrorResponse
)),
}
}
| {
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": "handle_session_token",
"is_async": false,
"is_pub": false,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_fn_grpc-server_1163810725903300883 | clm | function | // connector-service/backend/grpc-server/src/server/payments.rs
async fn handle_access_token<
T: PaymentMethodDataTypes
+ Default
+ Eq
+ Debug
+ Send
+ serde::Serialize
+ serde::de::DeserializeOwned
+ Clone
+ Sync
+ domain_types::types::CardConversionHelper<T>
+ 'static,
>(
&self,
connector_data: ConnectorData<T>,
payment_flow_data: &PaymentFlowData,
connector_auth_details: ConnectorAuthType,
connector_name: &str,
service_name: &str,
event_params: EventParams<'_>,
) -> Result<AccessTokenResponseData, PaymentAuthorizationError>
where
AccessTokenRequestData:
for<'a> ForeignTryFrom<&'a ConnectorAuthType, Error = ApplicationErrorResponse>,
{
// Get connector integration for CreateAccessToken flow
let connector_integration: BoxedConnectorIntegrationV2<
'_,
CreateAccessToken,
PaymentFlowData,
AccessTokenRequestData,
AccessTokenResponseData,
> = connector_data.connector.get_connector_integration_v2();
// Create access token request data - grant type determined by connector
let access_token_request_data = AccessTokenRequestData::foreign_try_from(
&connector_auth_details, // Contains connector-specific auth details
)
.map_err(|e| {
PaymentAuthorizationError::new(
grpc_api_types::payments::PaymentStatus::Pending,
Some(format!("Failed to create access token request: {e}")),
Some("ACCESS_TOKEN_REQUEST_ERROR".to_string()),
Some(400),
)
})?;
// Create router data for access token flow
let access_token_router_data = RouterDataV2::<
CreateAccessToken,
PaymentFlowData,
AccessTokenRequestData,
AccessTokenResponseData,
> {
flow: std::marker::PhantomData,
resource_common_data: payment_flow_data.clone(),
connector_auth_type: connector_auth_details,
request: access_token_request_data,
response: Err(ErrorResponse::default()),
};
// Execute connector processing
let external_event_params = EventProcessingParams {
connector_name,
service_name,
flow_name: FlowName::CreateAccessToken,
event_config: &self.config.events,
request_id: event_params.request_id,
lineage_ids: event_params.lineage_ids,
reference_id: event_params.reference_id,
shadow_mode: event_params.shadow_mode,
};
let response = external_services::service::execute_connector_processing_step(
&self.config.proxy,
connector_integration,
access_token_router_data,
None,
external_event_params,
None,
common_enums::CallConnectorAction::Trigger,
)
.await
.switch()
.map_err(|e: error_stack::Report<ApplicationErrorResponse>| {
PaymentAuthorizationError::new(
grpc_api_types::payments::PaymentStatus::Pending,
Some(format!("Access Token creation failed: {e}")),
Some("ACCESS_TOKEN_CREATION_ERROR".to_string()),
Some(500),
)
})?;
match response.response {
Ok(access_token_data) => {
tracing::info!(
"Access token created successfully with expiry: {:?}",
access_token_data.expires_in
);
Ok(access_token_data)
}
Err(ErrorResponse {
message,
status_code,
..
}) => Err(PaymentAuthorizationError::new(
grpc_api_types::payments::PaymentStatus::Pending,
Some(format!("Access Token creation failed: {message}")),
Some("ACCESS_TOKEN_CREATION_ERROR".to_string()),
Some(status_code.into()),
)),
}
}
| {
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": "handle_access_token",
"is_async": false,
"is_pub": false,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_fn_grpc-server_-8289574315249616664 | clm | function | // connector-service/backend/grpc-server/src/server/payments.rs
async fn handle_connector_customer<
T: PaymentMethodDataTypes
+ Default
+ Eq
+ Debug
+ Send
+ serde::Serialize
+ serde::de::DeserializeOwned
+ Clone
+ Sync
+ domain_types::types::CardConversionHelper<T>
+ 'static,
>(
&self,
connector_data: ConnectorData<T>,
payment_flow_data: &PaymentFlowData,
connector_auth_details: ConnectorAuthType,
payload: &PaymentServiceAuthorizeRequest,
connector_name: &str,
service_name: &str,
event_params: EventParams<'_>,
) -> Result<ConnectorCustomerResponse, PaymentAuthorizationError> {
// Get connector integration for CreateConnectorCustomer flow
let connector_integration: BoxedConnectorIntegrationV2<
'_,
CreateConnectorCustomer,
PaymentFlowData,
ConnectorCustomerData,
ConnectorCustomerResponse,
> = connector_data.connector.get_connector_integration_v2();
// Create connector customer request data using ForeignTryFrom
let connector_customer_request_data =
ConnectorCustomerData::foreign_try_from(payload.clone()).map_err(|err| {
tracing::error!("Failed to process connector customer data: {:?}", err);
PaymentAuthorizationError::new(
grpc_api_types::payments::PaymentStatus::Pending,
Some("Failed to process connector customer data".to_string()),
Some("CONNECTOR_CUSTOMER_DATA_ERROR".to_string()),
None,
)
})?;
// Create router data for connector customer flow
let connector_customer_router_data = RouterDataV2::<
CreateConnectorCustomer,
PaymentFlowData,
ConnectorCustomerData,
ConnectorCustomerResponse,
> {
flow: std::marker::PhantomData,
resource_common_data: payment_flow_data.clone(),
connector_auth_type: connector_auth_details,
request: connector_customer_request_data,
response: Err(ErrorResponse::default()),
};
// Execute connector processing
let external_event_params = EventProcessingParams {
connector_name,
service_name,
flow_name: FlowName::CreateConnectorCustomer,
event_config: &self.config.events,
request_id: event_params.request_id,
lineage_ids: event_params.lineage_ids,
reference_id: event_params.reference_id,
shadow_mode: event_params.shadow_mode,
};
let response = Box::pin(
external_services::service::execute_connector_processing_step(
&self.config.proxy,
connector_integration,
connector_customer_router_data,
None,
external_event_params,
None,
common_enums::CallConnectorAction::Trigger,
),
)
.await
.switch()
.map_err(|e: error_stack::Report<ApplicationErrorResponse>| {
PaymentAuthorizationError::new(
grpc_api_types::payments::PaymentStatus::Pending,
Some(format!("Connector customer creation failed: {e}")),
Some("CONNECTOR_CUSTOMER_CREATION_ERROR".to_string()),
Some(500),
)
})?;
match response.response {
Ok(connector_customer_data) => Ok(connector_customer_data),
Err(ErrorResponse {
message,
status_code,
..
}) => Err(PaymentAuthorizationError::new(
grpc_api_types::payments::PaymentStatus::Pending,
Some(format!("Connector customer creation failed: {message}")),
Some("CONNECTOR_CUSTOMER_CREATION_ERROR".to_string()),
Some(status_code.into()),
)),
}
}
| {
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": "handle_connector_customer",
"is_async": false,
"is_pub": false,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_fn_grpc-server_-9217058443951536110 | clm | function | // connector-service/backend/grpc-server/src/server/payments.rs
async fn handle_connector_customer_for_setup_mandate<
T: PaymentMethodDataTypes
+ Default
+ Eq
+ Debug
+ Send
+ serde::Serialize
+ serde::de::DeserializeOwned
+ Clone
+ Sync
+ domain_types::types::CardConversionHelper<T>
+ 'static,
>(
&self,
connector_data: ConnectorData<T>,
payment_flow_data: &PaymentFlowData,
connector_auth_details: ConnectorAuthType,
payload: &PaymentServiceRegisterRequest,
connector_name: &str,
service_name: &str,
event_params: EventParams<'_>,
) -> Result<ConnectorCustomerResponse, tonic::Status> {
// Get connector integration for CreateConnectorCustomer flow
let connector_integration: BoxedConnectorIntegrationV2<
'_,
CreateConnectorCustomer,
PaymentFlowData,
ConnectorCustomerData,
ConnectorCustomerResponse,
> = connector_data.connector.get_connector_integration_v2();
// Create connector customer request data using ForeignTryFrom
let connector_customer_request_data =
ConnectorCustomerData::foreign_try_from(payload.clone()).map_err(|err| {
tracing::error!("Failed to process connector customer data: {:?}", err);
tonic::Status::internal(format!("Failed to process connector customer data: {err}"))
})?;
// Create router data for connector customer flow
let connector_customer_router_data = RouterDataV2::<
CreateConnectorCustomer,
PaymentFlowData,
ConnectorCustomerData,
ConnectorCustomerResponse,
> {
flow: std::marker::PhantomData,
resource_common_data: payment_flow_data.clone(),
connector_auth_type: connector_auth_details,
request: connector_customer_request_data,
response: Err(ErrorResponse::default()),
};
// Execute connector processing
let external_event_params = EventProcessingParams {
connector_name,
service_name,
flow_name: FlowName::CreateConnectorCustomer,
event_config: &self.config.events,
request_id: event_params.request_id,
lineage_ids: event_params.lineage_ids,
reference_id: event_params.reference_id,
shadow_mode: event_params.shadow_mode,
};
let response = Box::pin(
external_services::service::execute_connector_processing_step(
&self.config.proxy,
connector_integration,
connector_customer_router_data,
None,
external_event_params,
None,
common_enums::CallConnectorAction::Trigger,
),
)
.await
.switch()
.map_err(|e: error_stack::Report<ApplicationErrorResponse>| {
tonic::Status::internal(format!("Connector customer creation failed: {e}"))
})?;
match response.response {
Ok(connector_customer_data) => Ok(connector_customer_data),
Err(ErrorResponse {
message,
status_code,
..
}) => Err(tonic::Status::internal(format!(
"Connector customer creation failed: {message} (status: {status_code})"
))),
}
}
| {
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": "handle_connector_customer_for_setup_mandate",
"is_async": false,
"is_pub": false,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_fn_grpc-server_-4490740975507371133 | clm | function | // connector-service/backend/grpc-server/src/server/payments.rs
async fn handle_payment_session_token<
T: PaymentMethodDataTypes
+ Default
+ Eq
+ Debug
+ Send
+ serde::Serialize
+ serde::de::DeserializeOwned
+ Clone
+ Sync
+ domain_types::types::CardConversionHelper<T>,
>(
&self,
connector_data: ConnectorData<T>,
payment_flow_data: &PaymentFlowData,
connector_auth_details: ConnectorAuthType,
event_params: EventParams<'_>,
payload: &PaymentServiceAuthorizeRequest,
connector_name: &str,
service_name: &str,
) -> Result<PaymentMethodTokenResponse, PaymentAuthorizationError> {
// Get connector integration
let connector_integration: BoxedConnectorIntegrationV2<
'_,
PaymentMethodToken,
PaymentFlowData,
PaymentMethodTokenizationData<T>,
PaymentMethodTokenResponse,
> = connector_data.connector.get_connector_integration_v2();
let currency =
common_enums::Currency::foreign_try_from(payload.currency()).map_err(|e| {
PaymentAuthorizationError::new(
grpc_api_types::payments::PaymentStatus::Pending,
Some(format!("Currency conversion failed: {e}")),
Some("CURRENCY_ERROR".to_string()),
None,
)
})?;
let payment_method_tokenization_data = PaymentMethodTokenizationData {
amount: common_utils::types::MinorUnit::new(payload.amount),
currency,
integrity_object: None,
browser_info: None,
customer_acceptance: None,
mandate_id: None,
setup_future_usage: None,
setup_mandate_details: None,
payment_method_data:
domain_types::payment_method_data::PaymentMethodData::foreign_try_from(
payload.payment_method.clone().ok_or_else(|| {
PaymentAuthorizationError::new(
grpc_api_types::payments::PaymentStatus::Pending,
Some("Payment method is required".to_string()),
Some("PAYMENT_METHOD_MISSING".to_string()),
None,
)
})?,
)
.map_err(|e| {
PaymentAuthorizationError::new(
grpc_api_types::payments::PaymentStatus::Pending,
Some(format!("Payment method data conversion failed: {e}")),
Some("PAYMENT_METHOD_DATA_ERROR".to_string()),
None,
)
})?,
};
let payment_method_token_router_data = RouterDataV2::<
PaymentMethodToken,
PaymentFlowData,
PaymentMethodTokenizationData<T>,
PaymentMethodTokenResponse,
> {
flow: std::marker::PhantomData,
resource_common_data: payment_flow_data.clone(),
connector_auth_type: connector_auth_details,
request: payment_method_tokenization_data,
response: Err(ErrorResponse::default()),
};
// Execute connector processing
let external_event_params = EventProcessingParams {
connector_name,
service_name,
flow_name: FlowName::PaymentMethodToken,
event_config: &self.config.events,
request_id: event_params.request_id,
lineage_ids: event_params.lineage_ids,
reference_id: event_params.reference_id,
shadow_mode: event_params.shadow_mode,
};
let response = external_services::service::execute_connector_processing_step(
&self.config.proxy,
connector_integration,
payment_method_token_router_data,
None,
external_event_params,
None,
common_enums::CallConnectorAction::Trigger,
)
.await
.switch()
.map_err(|e: error_stack::Report<ApplicationErrorResponse>| {
PaymentAuthorizationError::new(
grpc_api_types::payments::PaymentStatus::Pending,
Some(format!("Payment Method Token creation failed: {e}")),
Some("PAYMENT_METHOD_TOKEN_CREATION_ERROR".to_string()),
Some(500),
)
})?;
match response.response {
Ok(payment_method_token_data) => {
tracing::info!("Payment method token created successfully");
Ok(payment_method_token_data)
}
Err(ErrorResponse {
message,
status_code,
..
}) => Err(PaymentAuthorizationError::new(
grpc_api_types::payments::PaymentStatus::Pending,
Some(format!("Payment Method Token creation failed: {message}")),
Some("PAYMENT_METHOD_TOKEN_CREATION_ERROR".to_string()),
Some(status_code.into()),
)),
}
}
| {
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": "handle_payment_session_token",
"is_async": false,
"is_pub": false,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_fn_grpc-server_-2125080601767551134 | clm | function | // connector-service/backend/grpc-server/src/server/payments.rs
async fn authorize(
&self,
request: tonic::Request<PaymentServiceAuthorizeRequest>,
) -> Result<tonic::Response<PaymentServiceAuthorizeResponse>, tonic::Status> {
info!("PAYMENT_AUTHORIZE_FLOW: initiated");
let service_name = request
.extensions()
.get::<String>()
.cloned()
.unwrap_or_else(|| "PaymentService".to_string());
grpc_logging_wrapper(request, &service_name, self.config.clone(), FlowName::Authorize, |request_data| {
let service_name = service_name.clone();
Box::pin(async move {
let metadata_payload = request_data.extracted_metadata;
let metadata = &request_data.masked_metadata;
let payload = request_data.payload;
let authorize_response = match payload.payment_method.as_ref() {
Some(pm) => {
match pm.payment_method.as_ref() {
Some(payment_method::PaymentMethod::Card(card_details)) => {
match &card_details.card_type {
Some(grpc_api_types::payments::card_payment_method_type::CardType::CreditProxy(proxy_card_details)) | Some(grpc_api_types::payments::card_payment_method_type::CardType::DebitProxy(proxy_card_details)) => {
let token_data = proxy_card_details.to_token_data();
match Box::pin(self.process_authorization_internal::<VaultTokenHolder>(
payload.clone(),
metadata_payload.connector,
metadata_payload.connector_auth_type.clone(),
metadata,
&metadata_payload,
&service_name,
&metadata_payload.request_id,
Some(token_data),
))
.await
{
Ok(response) => {
tracing::info!("INJECTOR: Authorization completed successfully with injector");
response
},
Err(error_response) => {
tracing::error!("INJECTOR: Authorization failed with injector - error: {:?}", error_response);
PaymentServiceAuthorizeResponse::from(error_response)
},
}
}
_ => {
tracing::info!("REGULAR: Processing regular payment (no injector)");
match Box::pin(self.process_authorization_internal::<DefaultPCIHolder>(
payload.clone(),
metadata_payload.connector,
metadata_payload.connector_auth_type.clone(),
metadata,
&metadata_payload,
&service_name,
&metadata_payload.request_id,
None,
))
.await
{
Ok(response) => {
tracing::info!("REGULAR: Authorization completed successfully without injector");
response
},
Err(error_response) => {
tracing::error!("REGULAR: Authorization failed without injector - error: {:?}", error_response);
PaymentServiceAuthorizeResponse::from(error_response)
},
}
}
}
}
_ => {
match Box::pin(self.process_authorization_internal::<DefaultPCIHolder>(
payload.clone(),
metadata_payload.connector,
metadata_payload.connector_auth_type.clone(),
metadata,
&metadata_payload,
&service_name,
&metadata_payload.request_id,
None,
))
.await
{
Ok(response) => response,
Err(error_response) => PaymentServiceAuthorizeResponse::from(error_response),
}
}
}
}
_ => {
match Box::pin(self.process_authorization_internal::<DefaultPCIHolder>(
payload.clone(),
metadata_payload.connector,
metadata_payload.connector_auth_type.clone(),
metadata,
&metadata_payload,
&service_name,
&metadata_payload.request_id,
None,
))
.await
{
Ok(response) => response,
Err(error_response) => PaymentServiceAuthorizeResponse::from(error_response),
}
}
};
Ok(tonic::Response::new(authorize_response))
})
})
.await
}
| {
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": "authorize",
"is_async": false,
"is_pub": false,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_fn_grpc-server_6293499016738968107 | clm | function | // connector-service/backend/grpc-server/src/server/payments.rs
async fn get(
&self,
request: tonic::Request<PaymentServiceGetRequest>,
) -> Result<tonic::Response<PaymentServiceGetResponse>, tonic::Status> {
info!("PAYMENT_SYNC_FLOW: initiated");
let service_name = request
.extensions()
.get::<String>()
.cloned()
.unwrap_or_else(|| "PaymentService".to_string());
grpc_logging_wrapper(
request,
&service_name,
self.config.clone(),
FlowName::Psync,
|request_data| {
let service_name = service_name.clone();
Box::pin(async move {
let metadata_payload = request_data.extracted_metadata;
let utils::MetadataPayload {
connector,
ref request_id,
ref lineage_ids,
ref reference_id,
..
} = metadata_payload;
let payload = request_data.payload;
// Get connector data
let connector_data: ConnectorData<DefaultPCIHolder> =
ConnectorData::get_connector_by_name(&connector);
// Get connector integration
let connector_integration: BoxedConnectorIntegrationV2<
'_,
PSync,
PaymentFlowData,
PaymentsSyncData,
PaymentsResponseData,
> = connector_data.connector.get_connector_integration_v2();
// Create connector request data
let payments_sync_data =
PaymentsSyncData::foreign_try_from(payload.clone()).into_grpc_status()?;
// Create common request data
let payment_flow_data = PaymentFlowData::foreign_try_from((
payload.clone(),
self.config.connectors.clone(),
&request_data.masked_metadata,
))
.into_grpc_status()?;
// Extract access token from Hyperswitch request
let cached_access_token = payload
.state
.as_ref()
.and_then(|state| state.access_token.as_ref())
.map(|access| (access.token.clone(), access.expires_in_seconds));
// Check if connector supports access tokens
let should_do_access_token = connector_data.connector.should_do_access_token();
// Conditional token generation - ONLY if not provided in request
let payment_flow_data = if should_do_access_token {
let access_token_data = match cached_access_token {
Some((token, expires_in)) => {
// If provided cached token - use it, don't generate new one
tracing::info!("Using cached access token from Hyperswitch");
Some(AccessTokenResponseData {
access_token: token,
token_type: None,
expires_in,
})
}
None => {
// No cached token - generate fresh one
tracing::info!(
"No cached access token found, generating new token"
);
let event_params = EventParams {
_connector_name: &connector.to_string(),
_service_name: &service_name,
request_id,
lineage_ids,
reference_id,
shadow_mode: metadata_payload.shadow_mode,
};
let access_token_data = Box::pin(self.handle_access_token(
connector_data.clone(),
&payment_flow_data,
metadata_payload.connector_auth_type.clone(),
&metadata_payload.connector.to_string(),
&service_name,
event_params,
))
.await
.map_err(|e| {
let message = e.error_message.unwrap_or_else(|| {
"Access token creation failed".to_string()
});
tonic::Status::internal(message)
})?;
tracing::info!(
"Access token created successfully with expiry: {:?}",
access_token_data.expires_in
);
Some(access_token_data)
}
};
// Store in flow data for connector API calls
payment_flow_data.set_access_token(access_token_data)
} else {
// Connector doesn't support access tokens
payment_flow_data
};
// Create router data
let router_data = RouterDataV2::<
PSync,
PaymentFlowData,
PaymentsSyncData,
PaymentsResponseData,
> {
flow: std::marker::PhantomData,
resource_common_data: payment_flow_data,
connector_auth_type: metadata_payload.connector_auth_type.clone(),
request: payments_sync_data,
response: Err(ErrorResponse::default()),
};
// Execute connector processing
let flow_name = utils::flow_marker_to_flow_name::<PSync>();
let event_params = EventProcessingParams {
connector_name: &metadata_payload.connector.to_string(),
service_name: &service_name,
flow_name,
event_config: &self.config.events,
request_id: &metadata_payload.request_id,
lineage_ids: &metadata_payload.lineage_ids,
reference_id: &metadata_payload.reference_id,
shadow_mode: metadata_payload.shadow_mode,
};
let consume_or_trigger_flow = match payload.handle_response {
Some(resource_object) => {
common_enums::CallConnectorAction::HandleResponse(resource_object)
}
None => common_enums::CallConnectorAction::Trigger,
};
let response_result = Box::pin(
external_services::service::execute_connector_processing_step(
&self.config.proxy,
connector_integration,
router_data,
None,
event_params,
None,
consume_or_trigger_flow,
),
)
.await
.switch()
.into_grpc_status()?;
// Generate response
let final_response =
generate_payment_sync_response(response_result).into_grpc_status()?;
Ok(tonic::Response::new(final_response))
})
},
)
.await
}
| {
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": "get",
"is_async": false,
"is_pub": false,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_fn_grpc-server_2641381016457535420 | clm | function | // connector-service/backend/grpc-server/src/server/payments.rs
async fn void(
&self,
request: tonic::Request<PaymentServiceVoidRequest>,
) -> Result<tonic::Response<PaymentServiceVoidResponse>, tonic::Status> {
let service_name = request
.extensions()
.get::<String>()
.cloned()
.unwrap_or_else(|| "PaymentService".to_string());
grpc_logging_wrapper(
request,
&service_name,
self.config.clone(),
FlowName::Void,
|request_data| async move { self.internal_void_payment(request_data).await },
)
.await
}
| {
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": "void",
"is_async": false,
"is_pub": false,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_fn_grpc-server_-1691506971339418603 | clm | function | // connector-service/backend/grpc-server/src/server/payments.rs
async fn void_post_capture(
&self,
request: tonic::Request<PaymentServiceVoidPostCaptureRequest>,
) -> Result<tonic::Response<PaymentServiceVoidPostCaptureResponse>, tonic::Status> {
let service_name = request
.extensions()
.get::<String>()
.cloned()
.unwrap_or_else(|| "PaymentService".to_string());
grpc_logging_wrapper(
request,
&service_name,
self.config.clone(),
FlowName::VoidPostCapture,
|request_data| async move { self.internal_void_post_capture(request_data).await },
)
.await
}
| {
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": "void_post_capture",
"is_async": false,
"is_pub": false,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_fn_grpc-server_5798579520823863730 | clm | function | // connector-service/backend/grpc-server/src/server/payments.rs
async fn transform(
&self,
request: tonic::Request<PaymentServiceTransformRequest>,
) -> Result<tonic::Response<PaymentServiceTransformResponse>, tonic::Status> {
let service_name = request
.extensions()
.get::<String>()
.cloned()
.unwrap_or_else(|| "PaymentService".to_string());
grpc_logging_wrapper(
request,
&service_name,
self.config.clone(),
FlowName::IncomingWebhook,
|request_data| {
async move {
let payload = request_data.payload;
let metadata_payload = request_data.extracted_metadata;
let connector = metadata_payload.connector;
let _request_id = &metadata_payload.request_id;
let connector_auth_details = &metadata_payload.connector_auth_type;
let request_details = payload
.request_details
.map(domain_types::connector_types::RequestDetails::foreign_try_from)
.ok_or_else(|| {
tonic::Status::invalid_argument("missing request_details in the payload")
})?
.map_err(|e| e.into_grpc_status())?;
let webhook_secrets = payload
.webhook_secrets
.clone()
.map(|details| {
domain_types::connector_types::ConnectorWebhookSecrets::foreign_try_from(
details,
)
.map_err(|e| e.into_grpc_status())
})
.transpose()?;
//get connector data
let connector_data: ConnectorData<DefaultPCIHolder> =
ConnectorData::get_connector_by_name(&connector);
let source_verified = match connector_data
.connector
.verify_webhook_source(
request_details.clone(),
webhook_secrets.clone(),
Some(connector_auth_details.clone()),
) {
Ok(result) => result,
Err(err) => {
tracing::warn!(
target: "webhook",
"{:?}",
err
);
false
}
};
let event_type = connector_data
.connector
.get_event_type(
request_details.clone(),
webhook_secrets.clone(),
Some(connector_auth_details.clone()),
)
.switch()
.into_grpc_status()?;
// Get content for the webhook based on the event type using categorization
let content = if event_type.is_payment_event() {
get_payments_webhook_content(
connector_data,
request_details,
webhook_secrets,
Some(connector_auth_details.clone()),
)
.await
.into_grpc_status()?
} else if event_type.is_refund_event() {
get_refunds_webhook_content(
connector_data,
request_details,
webhook_secrets,
Some(connector_auth_details.clone()),
)
.await
.into_grpc_status()?
} else if event_type.is_dispute_event() {
get_disputes_webhook_content(
connector_data,
request_details,
webhook_secrets,
Some(connector_auth_details.clone()),
)
.await
.into_grpc_status()?
} else {
// For all other event types, default to payment webhook content for now
// This includes mandate, payout, recovery, and misc events
get_payments_webhook_content(
connector_data,
request_details,
webhook_secrets,
Some(connector_auth_details.clone()),
)
.await
.into_grpc_status()?
};
let api_event_type =
grpc_api_types::payments::WebhookEventType::foreign_try_from(event_type)
.map_err(|e| e.into_grpc_status())?;
let webhook_transformation_status = match content.content {
Some(grpc_api_types::payments::webhook_response_content::Content::IncompleteTransformation(_)) => WebhookTransformationStatus::Incomplete,
_ => WebhookTransformationStatus::Complete,
};
let response = PaymentServiceTransformResponse {
event_type: api_event_type.into(),
content: Some(content),
source_verified,
response_ref_id: None,
transformation_status: webhook_transformation_status.into(),
};
Ok(tonic::Response::new(response))
}
},
)
.await
}
| {
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": "transform",
"is_async": false,
"is_pub": false,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_fn_grpc-server_7669360379203482642 | clm | function | // connector-service/backend/grpc-server/src/server/payments.rs
async fn refund(
&self,
request: tonic::Request<PaymentServiceRefundRequest>,
) -> Result<tonic::Response<RefundResponse>, tonic::Status> {
let service_name = request
.extensions()
.get::<String>()
.cloned()
.unwrap_or_else(|| "PaymentService".to_string());
grpc_logging_wrapper(
request,
&service_name,
self.config.clone(),
FlowName::Refund,
|request_data| async move { self.internal_refund(request_data).await },
)
.await
}
| {
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": "refund",
"is_async": false,
"is_pub": false,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_fn_grpc-server_686698646402302221 | clm | function | // connector-service/backend/grpc-server/src/server/payments.rs
async fn dispute(
&self,
request: tonic::Request<PaymentServiceDisputeRequest>,
) -> Result<tonic::Response<DisputeResponse>, tonic::Status> {
let service_name = request
.extensions()
.get::<String>()
.cloned()
.unwrap_or_else(|| "PaymentService".to_string());
grpc_logging_wrapper(
request,
&service_name,
self.config.clone(),
FlowName::DefendDispute,
|_request_data| async {
let response = DisputeResponse {
..Default::default()
};
Ok(tonic::Response::new(response))
},
)
.await
}
| {
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": "dispute",
"is_async": false,
"is_pub": false,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_fn_grpc-server_5570048028234178648 | clm | function | // connector-service/backend/grpc-server/src/server/payments.rs
async fn capture(
&self,
request: tonic::Request<PaymentServiceCaptureRequest>,
) -> Result<tonic::Response<PaymentServiceCaptureResponse>, tonic::Status> {
let service_name = request
.extensions()
.get::<String>()
.cloned()
.unwrap_or_else(|| "PaymentService".to_string());
grpc_logging_wrapper(
request,
&service_name,
self.config.clone(),
FlowName::Capture,
|request_data| async move { self.internal_payment_capture(request_data).await },
)
.await
}
| {
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": "capture",
"is_async": false,
"is_pub": false,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_fn_grpc-server_2690148189299557326 | clm | function | // connector-service/backend/grpc-server/src/server/payments.rs
async fn register(
&self,
request: tonic::Request<PaymentServiceRegisterRequest>,
) -> Result<tonic::Response<PaymentServiceRegisterResponse>, tonic::Status> {
info!("SETUP_MANDATE_FLOW: initiated");
let service_name = request
.extensions()
.get::<String>()
.cloned()
.unwrap_or_else(|| "PaymentService".to_string());
grpc_logging_wrapper(
request,
&service_name,
self.config.clone(),
FlowName::SetupMandate,
|request_data| {
let service_name = service_name.clone();
Box::pin(async move {
let payload = request_data.payload;
let metadata_payload = request_data.extracted_metadata;
let (connector, request_id, lineage_ids) = (
metadata_payload.connector,
metadata_payload.request_id,
metadata_payload.lineage_ids,
);
let connector_auth_details = &metadata_payload.connector_auth_type;
//get connector data
let connector_data = ConnectorData::get_connector_by_name(&connector);
// Get connector integration
let connector_integration: BoxedConnectorIntegrationV2<
'_,
SetupMandate,
PaymentFlowData,
SetupMandateRequestData<DefaultPCIHolder>,
PaymentsResponseData,
> = connector_data.connector.get_connector_integration_v2();
// Create common request data
let payment_flow_data = PaymentFlowData::foreign_try_from((
payload.clone(),
self.config.connectors.clone(),
self.config.common.environment,
&request_data.masked_metadata,
))
.map_err(|e| e.into_grpc_status())?;
let should_do_order_create = connector_data.connector.should_do_order_create();
let order_id = if should_do_order_create {
let event_params = EventParams {
_connector_name: &connector.to_string(),
_service_name: &service_name,
request_id: &request_id,
lineage_ids: &lineage_ids,
reference_id: &metadata_payload.reference_id,
shadow_mode: metadata_payload.shadow_mode,
};
Some(
Box::pin(self.handle_order_creation_for_setup_mandate(
connector_data.clone(),
&payment_flow_data,
connector_auth_details.clone(),
event_params,
&payload,
&connector.to_string(),
&service_name,
))
.await?,
)
} else {
None
};
let payment_flow_data = payment_flow_data.set_order_reference_id(order_id);
// Extract connector customer ID (if provided)
let cached_connector_customer_id = payload.connector_customer_id.clone();
// Check if connector supports customer creation
let should_create_connector_customer =
connector_data.connector.should_create_connector_customer();
// Conditional customer creation - ONLY if connector needs it AND no existing customer ID
let payment_flow_data = if should_create_connector_customer {
match cached_connector_customer_id {
Some(_customer_id) => payment_flow_data,
None => {
let event_params = EventParams {
_connector_name: &connector.to_string(),
_service_name: &service_name,
request_id: &request_id,
lineage_ids: &lineage_ids,
reference_id: &metadata_payload.reference_id,
shadow_mode: metadata_payload.shadow_mode,
};
let connector_customer_response =
Box::pin(self.handle_connector_customer_for_setup_mandate(
connector_data.clone(),
&payment_flow_data,
connector_auth_details.clone(),
&payload,
&connector.to_string(),
&service_name,
event_params,
))
.await?;
payment_flow_data.set_connector_customer_id(Some(
connector_customer_response.connector_customer_id,
))
}
}
} else {
// Connector doesn't support customer creation
payment_flow_data
};
let setup_mandate_request_data =
SetupMandateRequestData::foreign_try_from(payload.clone())
.map_err(|e| e.into_grpc_status())?;
// Create router data
let router_data: RouterDataV2<
SetupMandate,
PaymentFlowData,
SetupMandateRequestData<DefaultPCIHolder>,
PaymentsResponseData,
> = RouterDataV2 {
flow: std::marker::PhantomData,
resource_common_data: payment_flow_data,
connector_auth_type: connector_auth_details.clone(),
request: setup_mandate_request_data,
response: Err(ErrorResponse::default()),
};
let event_params = EventProcessingParams {
connector_name: &connector.to_string(),
service_name: &service_name,
flow_name: FlowName::SetupMandate,
event_config: &self.config.events,
request_id: &request_id,
lineage_ids: &lineage_ids,
reference_id: &metadata_payload.reference_id,
shadow_mode: metadata_payload.shadow_mode,
};
let response = Box::pin(
external_services::service::execute_connector_processing_step(
&self.config.proxy,
connector_integration,
router_data,
None,
event_params,
None, // token_data - None for non-proxy payments
common_enums::CallConnectorAction::Trigger,
),
)
.await
.switch()
.map_err(|e| e.into_grpc_status())?;
// Generate response
let setup_mandate_response = generate_setup_mandate_response(response)
.map_err(|e| e.into_grpc_status())?;
Ok(tonic::Response::new(setup_mandate_response))
})
},
)
.await
}
| {
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": "register",
"is_async": false,
"is_pub": false,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_fn_grpc-server_-7709097329130294000 | clm | function | // connector-service/backend/grpc-server/src/server/payments.rs
async fn repeat_everything(
&self,
request: tonic::Request<PaymentServiceRepeatEverythingRequest>,
) -> Result<tonic::Response<PaymentServiceRepeatEverythingResponse>, tonic::Status> {
info!("REPEAT_PAYMENT_FLOW: initiated");
let service_name = request
.extensions()
.get::<String>()
.cloned()
.unwrap_or_else(|| "PaymentService".to_string());
grpc_logging_wrapper(
request,
&service_name,
self.config.clone(),
FlowName::RepeatPayment,
|request_data| {
let service_name = service_name.clone();
Box::pin(async move {
let payload = request_data.payload;
let metadata_payload = request_data.extracted_metadata;
let (connector, request_id, lineage_ids) = (
metadata_payload.connector,
metadata_payload.request_id,
metadata_payload.lineage_ids,
);
let connector_auth_details = &metadata_payload.connector_auth_type;
//get connector data
let connector_data: ConnectorData<DefaultPCIHolder> =
ConnectorData::get_connector_by_name(&connector);
// Get connector integration
let connector_integration: BoxedConnectorIntegrationV2<
'_,
RepeatPayment,
PaymentFlowData,
RepeatPaymentData,
PaymentsResponseData,
> = connector_data.connector.get_connector_integration_v2();
// Create payment flow data
let payment_flow_data = PaymentFlowData::foreign_try_from((
payload.clone(),
self.config.connectors.clone(),
&request_data.masked_metadata,
))
.map_err(|e| e.into_grpc_status())?;
// Create repeat payment data
let repeat_payment_data = RepeatPaymentData::foreign_try_from(payload.clone())
.map_err(|e| e.into_grpc_status())?;
// Create router data
let router_data: RouterDataV2<
RepeatPayment,
PaymentFlowData,
RepeatPaymentData,
PaymentsResponseData,
> = RouterDataV2 {
flow: std::marker::PhantomData,
resource_common_data: payment_flow_data,
connector_auth_type: connector_auth_details.clone(),
request: repeat_payment_data,
response: Err(ErrorResponse::default()),
};
let event_params = EventProcessingParams {
connector_name: &connector.to_string(),
service_name: &service_name,
flow_name: FlowName::RepeatPayment,
event_config: &self.config.events,
request_id: &request_id,
lineage_ids: &lineage_ids,
reference_id: &metadata_payload.reference_id,
shadow_mode: metadata_payload.shadow_mode,
};
let response = Box::pin(
external_services::service::execute_connector_processing_step(
&self.config.proxy,
connector_integration,
router_data,
None,
event_params,
None, // token_data - None for non-proxy payments
common_enums::CallConnectorAction::Trigger,
),
)
.await
.switch()
.map_err(|e| e.into_grpc_status())?;
// Generate response
let repeat_payment_response = generate_repeat_payment_response(response)
.map_err(|e| e.into_grpc_status())?;
Ok(tonic::Response::new(repeat_payment_response))
})
},
)
.await
}
| {
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": "repeat_everything",
"is_async": false,
"is_pub": false,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_fn_grpc-server_4988184054883374868 | clm | function | // connector-service/backend/grpc-server/src/server/payments.rs
async fn pre_authenticate(
&self,
request: tonic::Request<PaymentServicePreAuthenticateRequest>,
) -> Result<tonic::Response<PaymentServicePreAuthenticateResponse>, tonic::Status> {
let service_name = request
.extensions()
.get::<String>()
.cloned()
.unwrap_or_else(|| "PaymentService".to_string());
grpc_logging_wrapper(
request,
&service_name,
self.config.clone(),
FlowName::PreAuthenticate,
|request_data| async move { self.internal_pre_authenticate(request_data).await },
)
.await
}
| {
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": "pre_authenticate",
"is_async": false,
"is_pub": false,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_fn_grpc-server_69996089778591858 | clm | function | // connector-service/backend/grpc-server/src/server/payments.rs
async fn authenticate(
&self,
request: tonic::Request<PaymentServiceAuthenticateRequest>,
) -> Result<tonic::Response<PaymentServiceAuthenticateResponse>, tonic::Status> {
let service_name = request
.extensions()
.get::<String>()
.cloned()
.unwrap_or_else(|| "PaymentService".to_string());
grpc_logging_wrapper(
request,
&service_name,
self.config.clone(),
FlowName::Authenticate,
|request_data| async move { self.internal_authenticate(request_data).await },
)
.await
}
| {
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": "authenticate",
"is_async": false,
"is_pub": false,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_fn_grpc-server_3596249420929772877 | clm | function | // connector-service/backend/grpc-server/src/server/payments.rs
async fn post_authenticate(
&self,
request: tonic::Request<PaymentServicePostAuthenticateRequest>,
) -> Result<tonic::Response<PaymentServicePostAuthenticateResponse>, tonic::Status> {
let service_name = request
.extensions()
.get::<String>()
.cloned()
.unwrap_or_else(|| "PaymentService".to_string());
grpc_logging_wrapper(
request,
&service_name,
self.config.clone(),
FlowName::PostAuthenticate,
|request_data| async move { self.internal_post_authenticate(request_data).await },
)
.await
}
| {
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": "post_authenticate",
"is_async": false,
"is_pub": false,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_fn_grpc-server_4962492850098973143 | clm | function | // connector-service/backend/grpc-server/src/server/payments.rs
async fn get_payments_webhook_content(
connector_data: ConnectorData<DefaultPCIHolder>,
request_details: domain_types::connector_types::RequestDetails,
webhook_secrets: Option<domain_types::connector_types::ConnectorWebhookSecrets>,
connector_auth_details: Option<ConnectorAuthType>,
) -> CustomResult<grpc_api_types::payments::WebhookResponseContent, ApplicationErrorResponse> {
let webhook_details = connector_data
.connector
.process_payment_webhook(
request_details.clone(),
webhook_secrets,
connector_auth_details,
)
.switch()?;
match webhook_details.transformation_status {
common_enums::WebhookTransformationStatus::Complete => {
// Generate response
let response = PaymentServiceGetResponse::foreign_try_from(webhook_details)
.change_context(ApplicationErrorResponse::InternalServerError(ApiError {
sub_code: "RESPONSE_CONSTRUCTION_ERROR".to_string(),
error_identifier: 500,
error_message: "Error while constructing response".to_string(),
error_object: None,
}))?;
Ok(grpc_api_types::payments::WebhookResponseContent {
content: Some(
grpc_api_types::payments::webhook_response_content::Content::PaymentsResponse(
response,
),
),
})
}
common_enums::WebhookTransformationStatus::Incomplete => {
let resource_object = connector_data
.connector
.get_webhook_resource_object(request_details)
.switch()?;
let resource_object_vec = serde_json::to_vec(&resource_object).change_context(
ApplicationErrorResponse::InternalServerError(ApiError {
sub_code: "SERIALIZATION_ERROR".to_string(),
error_identifier: 500,
error_message: "Error while serializing resource object".to_string(),
error_object: None,
}),
)?;
Ok(grpc_api_types::payments::WebhookResponseContent {
content: Some(
grpc_api_types::payments::webhook_response_content::Content::IncompleteTransformation(
grpc_api_types::payments::IncompleteTransformationResponse {
resource_object: resource_object_vec,
reason: "Payment information required".to_string(),
}
),
),
})
}
}
}
| {
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": "get_payments_webhook_content",
"is_async": false,
"is_pub": false,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_fn_grpc-server_4618141101747958615 | clm | function | // connector-service/backend/grpc-server/src/server/payments.rs
async fn get_refunds_webhook_content<
T: PaymentMethodDataTypes
+ Default
+ Eq
+ Debug
+ Send
+ serde::Serialize
+ serde::de::DeserializeOwned
+ Clone
+ Sync
+ domain_types::types::CardConversionHelper<T>
+ 'static,
>(
connector_data: ConnectorData<T>,
request_details: domain_types::connector_types::RequestDetails,
webhook_secrets: Option<domain_types::connector_types::ConnectorWebhookSecrets>,
connector_auth_details: Option<ConnectorAuthType>,
) -> CustomResult<grpc_api_types::payments::WebhookResponseContent, ApplicationErrorResponse> {
let webhook_details = connector_data
.connector
.process_refund_webhook(request_details, webhook_secrets, connector_auth_details)
.switch()?;
// Generate response - RefundService should handle this, for now return basic response
let response = RefundResponse::foreign_try_from(webhook_details).change_context(
ApplicationErrorResponse::InternalServerError(ApiError {
sub_code: "RESPONSE_CONSTRUCTION_ERROR".to_string(),
error_identifier: 500,
error_message: "Error while constructing response".to_string(),
error_object: None,
}),
)?;
Ok(grpc_api_types::payments::WebhookResponseContent {
content: Some(
grpc_api_types::payments::webhook_response_content::Content::RefundsResponse(response),
),
})
}
| {
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": "get_refunds_webhook_content",
"is_async": false,
"is_pub": false,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_fn_grpc-server_913377641800377970 | clm | function | // connector-service/backend/grpc-server/src/server/payments.rs
async fn get_disputes_webhook_content<
T: PaymentMethodDataTypes
+ Default
+ Eq
+ Debug
+ Send
+ serde::Serialize
+ serde::de::DeserializeOwned
+ Clone
+ Sync
+ domain_types::types::CardConversionHelper<T>
+ 'static,
>(
connector_data: ConnectorData<T>,
request_details: domain_types::connector_types::RequestDetails,
webhook_secrets: Option<domain_types::connector_types::ConnectorWebhookSecrets>,
connector_auth_details: Option<ConnectorAuthType>,
) -> CustomResult<grpc_api_types::payments::WebhookResponseContent, ApplicationErrorResponse> {
let webhook_details = connector_data
.connector
.process_dispute_webhook(request_details, webhook_secrets, connector_auth_details)
.switch()?;
// Generate response - DisputeService should handle this, for now return basic response
let response = DisputeResponse::foreign_try_from(webhook_details).change_context(
ApplicationErrorResponse::InternalServerError(ApiError {
sub_code: "RESPONSE_CONSTRUCTION_ERROR".to_string(),
error_identifier: 500,
error_message: "Error while constructing response".to_string(),
error_object: None,
}),
)?;
Ok(grpc_api_types::payments::WebhookResponseContent {
content: Some(
grpc_api_types::payments::webhook_response_content::Content::DisputesResponse(response),
),
})
}
| {
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": "get_disputes_webhook_content",
"is_async": false,
"is_pub": false,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_fn_grpc-server_7795258065850016122 | clm | function | // connector-service/backend/grpc-server/src/server/payments.rs
pub fn generate_payment_pre_authenticate_response<T: PaymentMethodDataTypes>(
router_data_v2: RouterDataV2<
PreAuthenticate,
PaymentFlowData,
PaymentsPreAuthenticateData<T>,
PaymentsResponseData,
>,
) -> Result<PaymentServicePreAuthenticateResponse, error_stack::Report<ApplicationErrorResponse>> {
let transaction_response = router_data_v2.response;
let status = router_data_v2.resource_common_data.status;
let grpc_status = grpc_api_types::payments::PaymentStatus::foreign_from(status);
let raw_connector_response = router_data_v2
.resource_common_data
.get_raw_connector_response();
let response_headers = router_data_v2
.resource_common_data
.get_connector_response_headers_as_map();
let response = match transaction_response {
Ok(response) => match response {
PaymentsResponseData::PreAuthenticateResponse {
redirection_data,
connector_response_reference_id,
status_code,
} => PaymentServicePreAuthenticateResponse {
transaction_id: None,
redirection_data: redirection_data
.map(|form| match *form {
router_response_types::RedirectForm::Form {
endpoint,
method,
form_fields,
} => Ok::<grpc_api_types::payments::RedirectForm, ApplicationErrorResponse>(
grpc_api_types::payments::RedirectForm {
form_type: Some(
grpc_api_types::payments::redirect_form::FormType::Form(
grpc_api_types::payments::FormData {
endpoint,
method:
grpc_api_types::payments::HttpMethod::foreign_from(
method,
)
.into(),
form_fields,
},
),
),
},
),
router_response_types::RedirectForm::Html { html_data } => {
Ok(grpc_api_types::payments::RedirectForm {
form_type: Some(
grpc_api_types::payments::redirect_form::FormType::Html(
grpc_api_types::payments::HtmlData { html_data },
),
),
})
}
router_response_types::RedirectForm::Uri { uri } => {
Ok(grpc_api_types::payments::RedirectForm {
form_type: Some(
grpc_api_types::payments::redirect_form::FormType::Uri(
grpc_api_types::payments::UriData { uri },
),
),
})
}
router_response_types::RedirectForm::Mifinity {
initialization_token,
} => Ok(grpc_api_types::payments::RedirectForm {
form_type: Some(
grpc_api_types::payments::redirect_form::FormType::Uri(
grpc_api_types::payments::UriData {
uri: initialization_token,
},
),
),
}),
router_response_types::RedirectForm::CybersourceAuthSetup {
access_token,
ddc_url,
reference_id,
} => {
let mut form_fields = HashMap::new();
form_fields.insert("access_token".to_string(), access_token);
form_fields.insert("ddc_url".to_string(), ddc_url.clone());
form_fields.insert("reference_id".to_string(), reference_id);
Ok(grpc_api_types::payments::RedirectForm {
form_type: Some(
grpc_api_types::payments::redirect_form::FormType::Form(
grpc_api_types::payments::FormData {
endpoint: ddc_url,
method: grpc_api_types::payments::HttpMethod::Post
.into(),
form_fields,
},
),
),
})
}
_ => Err(ApplicationErrorResponse::BadRequest(ApiError {
sub_code: "INVALID_RESPONSE".to_owned(),
error_identifier: 400,
error_message: "Invalid response from connector".to_owned(),
error_object: None,
}))?,
})
.transpose()?,
connector_metadata: HashMap::new(),
response_ref_id: connector_response_reference_id.map(|id| {
grpc_api_types::payments::Identifier {
id_type: Some(grpc_api_types::payments::identifier::IdType::Id(id)),
}
}),
status: grpc_status.into(),
error_message: None,
error_code: None,
raw_connector_response,
status_code: status_code.into(),
response_headers,
network_txn_id: None,
state: None,
},
_ => {
return Err(ApplicationErrorResponse::BadRequest(ApiError {
sub_code: "INVALID_RESPONSE".to_owned(),
error_identifier: 400,
error_message: "Invalid response type for pre authenticate".to_owned(),
error_object: None,
})
.into())
}
},
Err(err) => {
let status = err
.attempt_status
.map(grpc_api_types::payments::PaymentStatus::foreign_from)
.unwrap_or_default();
PaymentServicePreAuthenticateResponse {
transaction_id: Some(grpc_api_types::payments::Identifier {
id_type: Some(
grpc_api_types::payments::identifier::IdType::NoResponseIdMarker(()),
),
}),
redirection_data: None,
network_txn_id: None,
response_ref_id: None,
status: status.into(),
error_message: Some(err.message),
error_code: Some(err.code),
status_code: err.status_code.into(),
response_headers,
raw_connector_response,
connector_metadata: HashMap::new(),
state: None,
}
}
};
Ok(response)
}
| {
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": "generate_payment_pre_authenticate_response",
"is_async": false,
"is_pub": true,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_fn_grpc-server_3262422893288869427 | clm | function | // connector-service/backend/grpc-server/src/server/payments.rs
pub fn generate_payment_authenticate_response<T: PaymentMethodDataTypes>(
router_data_v2: RouterDataV2<
Authenticate,
PaymentFlowData,
PaymentsAuthenticateData<T>,
PaymentsResponseData,
>,
) -> Result<PaymentServiceAuthenticateResponse, error_stack::Report<ApplicationErrorResponse>> {
let transaction_response = router_data_v2.response;
let status = router_data_v2.resource_common_data.status;
let grpc_status = grpc_api_types::payments::PaymentStatus::foreign_from(status);
let raw_connector_response = router_data_v2
.resource_common_data
.get_raw_connector_response();
let response_headers = router_data_v2
.resource_common_data
.get_connector_response_headers_as_map();
let response = match transaction_response {
Ok(response) => match response {
PaymentsResponseData::AuthenticateResponse {
redirection_data,
authentication_data,
connector_response_reference_id,
status_code,
} => PaymentServiceAuthenticateResponse {
response_ref_id: connector_response_reference_id.map(|id| {
grpc_api_types::payments::Identifier {
id_type: Some(grpc_api_types::payments::identifier::IdType::Id(id)),
}
}),
transaction_id: None,
redirection_data: redirection_data
.map(|form| match *form {
router_response_types::RedirectForm::Form {
endpoint,
method,
form_fields,
} => Ok::<grpc_api_types::payments::RedirectForm, ApplicationErrorResponse>(
grpc_api_types::payments::RedirectForm {
form_type: Some(
grpc_api_types::payments::redirect_form::FormType::Form(
grpc_api_types::payments::FormData {
endpoint,
method:
grpc_api_types::payments::HttpMethod::foreign_from(
method,
)
.into(),
form_fields,
},
),
),
},
),
router_response_types::RedirectForm::Html { html_data } => {
Ok(grpc_api_types::payments::RedirectForm {
form_type: Some(
grpc_api_types::payments::redirect_form::FormType::Html(
grpc_api_types::payments::HtmlData { html_data },
),
),
})
}
router_response_types::RedirectForm::Uri { uri } => {
Ok(grpc_api_types::payments::RedirectForm {
form_type: Some(
grpc_api_types::payments::redirect_form::FormType::Uri(
grpc_api_types::payments::UriData { uri },
),
),
})
}
router_response_types::RedirectForm::Mifinity {
initialization_token,
} => Ok(grpc_api_types::payments::RedirectForm {
form_type: Some(
grpc_api_types::payments::redirect_form::FormType::Uri(
grpc_api_types::payments::UriData {
uri: initialization_token,
},
),
),
}),
router_response_types::RedirectForm::CybersourceConsumerAuth {
access_token,
step_up_url,
} => {
let mut form_fields = HashMap::new();
form_fields.insert("access_token".to_string(), access_token);
form_fields.insert("step_up_url".to_string(), step_up_url.clone());
Ok(grpc_api_types::payments::RedirectForm {
form_type: Some(
grpc_api_types::payments::redirect_form::FormType::Form(
grpc_api_types::payments::FormData {
endpoint: step_up_url,
method: grpc_api_types::payments::HttpMethod::Post
.into(),
form_fields,
},
),
),
})
}
_ => Err(ApplicationErrorResponse::BadRequest(ApiError {
sub_code: "INVALID_RESPONSE".to_owned(),
error_identifier: 400,
error_message: "Invalid response from connector".to_owned(),
error_object: None,
}))?,
})
.transpose()?,
connector_metadata: HashMap::new(),
authentication_data: authentication_data.map(ForeignFrom::foreign_from),
status: grpc_status.into(),
error_message: None,
error_code: None,
raw_connector_response,
status_code: status_code.into(),
response_headers,
network_txn_id: None,
state: None,
},
_ => {
return Err(ApplicationErrorResponse::BadRequest(ApiError {
sub_code: "INVALID_RESPONSE".to_owned(),
error_identifier: 400,
error_message: "Invalid response type for authenticate".to_owned(),
error_object: None,
})
.into())
}
},
Err(err) => {
let status = err
.attempt_status
.map(grpc_api_types::payments::PaymentStatus::foreign_from)
.unwrap_or_default();
PaymentServiceAuthenticateResponse {
transaction_id: Some(grpc_api_types::payments::Identifier {
id_type: Some(grpc_api_types::payments::identifier::IdType::Id(
"session_created".to_string(),
)),
}),
redirection_data: None,
network_txn_id: None,
response_ref_id: None,
authentication_data: None,
status: status.into(),
error_message: Some(err.message),
error_code: Some(err.code),
status_code: err.status_code.into(),
raw_connector_response,
response_headers,
connector_metadata: HashMap::new(),
state: None,
}
}
};
Ok(response)
}
| {
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": "generate_payment_authenticate_response",
"is_async": false,
"is_pub": true,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_fn_grpc-server_7230651373193303354 | clm | function | // connector-service/backend/grpc-server/src/server/payments.rs
pub fn generate_payment_post_authenticate_response<T: PaymentMethodDataTypes>(
router_data_v2: RouterDataV2<
PostAuthenticate,
PaymentFlowData,
PaymentsPostAuthenticateData<T>,
PaymentsResponseData,
>,
) -> Result<PaymentServicePostAuthenticateResponse, error_stack::Report<ApplicationErrorResponse>> {
let transaction_response = router_data_v2.response;
let status = router_data_v2.resource_common_data.status;
let grpc_status = grpc_api_types::payments::PaymentStatus::foreign_from(status);
let raw_connector_response = router_data_v2
.resource_common_data
.get_raw_connector_response();
let response_headers = router_data_v2
.resource_common_data
.get_connector_response_headers_as_map();
let response = match transaction_response {
Ok(response) => match response {
PaymentsResponseData::PostAuthenticateResponse {
authentication_data,
connector_response_reference_id,
status_code,
} => PaymentServicePostAuthenticateResponse {
transaction_id: None,
redirection_data: None,
connector_metadata: HashMap::new(),
network_txn_id: None,
response_ref_id: connector_response_reference_id.map(|id| {
grpc_api_types::payments::Identifier {
id_type: Some(grpc_api_types::payments::identifier::IdType::Id(id)),
}
}),
authentication_data: authentication_data.map(ForeignFrom::foreign_from),
incremental_authorization_allowed: None,
status: grpc_status.into(),
error_message: None,
error_code: None,
raw_connector_response,
status_code: status_code.into(),
response_headers,
state: None,
},
_ => {
return Err(ApplicationErrorResponse::BadRequest(ApiError {
sub_code: "INVALID_RESPONSE".to_owned(),
error_identifier: 400,
error_message: "Invalid response type for post authenticate".to_owned(),
error_object: None,
})
.into())
}
},
Err(err) => {
let status = err
.attempt_status
.map(grpc_api_types::payments::PaymentStatus::foreign_from)
.unwrap_or_default();
PaymentServicePostAuthenticateResponse {
transaction_id: Some(grpc_api_types::payments::Identifier {
id_type: Some(
grpc_api_types::payments::identifier::IdType::NoResponseIdMarker(()),
),
}),
redirection_data: None,
network_txn_id: None,
response_ref_id: None,
authentication_data: None,
incremental_authorization_allowed: None,
status: status.into(),
error_message: Some(err.message),
error_code: Some(err.code),
status_code: err.status_code.into(),
response_headers,
raw_connector_response,
connector_metadata: HashMap::new(),
state: None,
}
}
};
Ok(response)
}
| {
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": "generate_payment_post_authenticate_response",
"is_async": false,
"is_pub": true,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_fn_grpc-server_2031413733425933813 | clm | function | // connector-service/backend/grpc-server/src/server/disputes.rs
async fn submit_evidence(
&self,
request: tonic::Request<DisputeServiceSubmitEvidenceRequest>,
) -> Result<tonic::Response<DisputeServiceSubmitEvidenceResponse>, tonic::Status> {
info!("DISPUTE_FLOW: initiated");
let service_name = request
.extensions()
.get::<String>()
.cloned()
.unwrap_or_else(|| "DisputeService".to_string());
Box::pin(grpc_logging_wrapper(
request,
&service_name,
self.config.clone(),
common_utils::events::FlowName::SubmitEvidence,
|request_data| {
let service_name = service_name.clone();
async move {
let payload = request_data.payload;
let MetadataPayload {
connector,
request_id,
lineage_ids,
connector_auth_type,
reference_id,
shadow_mode,
..
} = request_data.extracted_metadata;
let connector_data: ConnectorData<DefaultPCIHolder> =
ConnectorData::get_connector_by_name(&connector);
let connector_integration: BoxedConnectorIntegrationV2<
'_,
SubmitEvidence,
DisputeFlowData,
SubmitEvidenceData,
DisputeResponseData,
> = connector_data.connector.get_connector_integration_v2();
let dispute_data = SubmitEvidenceData::foreign_try_from(payload.clone())
.map_err(|e| e.into_grpc_status())?;
let dispute_flow_data = DisputeFlowData::foreign_try_from((
payload.clone(),
self.config.connectors.clone(),
))
.map_err(|e| e.into_grpc_status())?;
let router_data: RouterDataV2<
SubmitEvidence,
DisputeFlowData,
SubmitEvidenceData,
DisputeResponseData,
> = RouterDataV2 {
flow: std::marker::PhantomData,
resource_common_data: dispute_flow_data,
connector_auth_type,
request: dispute_data,
response: Err(ErrorResponse::default()),
};
let event_params = external_services::service::EventProcessingParams {
connector_name: &connector.to_string(),
service_name: &service_name,
flow_name: common_utils::events::FlowName::SubmitEvidence,
event_config: &self.config.events,
request_id: &request_id,
lineage_ids: &lineage_ids,
reference_id: &reference_id,
shadow_mode,
};
let response = external_services::service::execute_connector_processing_step(
&self.config.proxy,
connector_integration,
router_data,
None,
event_params,
None,
common_enums::CallConnectorAction::Trigger,
)
.await
.switch()
.map_err(|e| e.into_grpc_status())?;
let dispute_response = generate_submit_evidence_response(response)
.map_err(|e| e.into_grpc_status())?;
Ok(tonic::Response::new(dispute_response))
}
},
))
.await
}
| {
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": "submit_evidence",
"is_async": false,
"is_pub": false,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_fn_grpc-server_-3278941850027429226 | clm | function | // connector-service/backend/grpc-server/src/server/disputes.rs
async fn get(
&self,
request: tonic::Request<DisputeServiceGetRequest>,
) -> Result<tonic::Response<DisputeResponse>, tonic::Status> {
// For now, return a basic dispute response
// This will need proper implementation based on domain logic
let service_name = request
.extensions()
.get::<String>()
.cloned()
.unwrap_or_else(|| "DisputeService".to_string());
grpc_logging_wrapper(
request,
&service_name,
self.config.clone(),
common_utils::events::FlowName::Dsync,
|request_data| async {
let _payload = request_data.payload;
let response = DisputeResponse {
..Default::default()
};
Ok(tonic::Response::new(response))
},
)
.await
}
| {
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": "get",
"is_async": false,
"is_pub": false,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_fn_grpc-server_-218339538236795674 | clm | function | // connector-service/backend/grpc-server/src/server/disputes.rs
async fn defend(
&self,
request: tonic::Request<DisputeDefendRequest>,
) -> Result<tonic::Response<DisputeDefendResponse>, tonic::Status> {
let service_name = request
.extensions()
.get::<String>()
.cloned()
.unwrap_or_else(|| "DisputeService".to_string());
grpc_logging_wrapper(
request,
&service_name,
self.config.clone(),
common_utils::events::FlowName::DefendDispute,
|request_data| async move { self.internal_defend(request_data).await },
)
.await
}
| {
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": "defend",
"is_async": false,
"is_pub": false,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_fn_grpc-server_-8403690431121274655 | clm | function | // connector-service/backend/grpc-server/src/server/disputes.rs
async fn accept(
&self,
request: tonic::Request<AcceptDisputeRequest>,
) -> Result<tonic::Response<AcceptDisputeResponse>, tonic::Status> {
info!("DISPUTE_FLOW: initiated");
let service_name = request
.extensions()
.get::<String>()
.cloned()
.unwrap_or_else(|| "DisputeService".to_string());
grpc_logging_wrapper(
request,
&service_name,
self.config.clone(),
common_utils::events::FlowName::AcceptDispute,
|request_data| {
let service_name = service_name.clone();
async move {
let payload = request_data.payload;
let MetadataPayload {
connector,
request_id,
lineage_ids,
connector_auth_type,
reference_id,
shadow_mode,
..
} = request_data.extracted_metadata;
let connector_data: ConnectorData<DefaultPCIHolder> =
ConnectorData::get_connector_by_name(&connector);
let connector_integration: BoxedConnectorIntegrationV2<
'_,
Accept,
DisputeFlowData,
AcceptDisputeData,
DisputeResponseData,
> = connector_data.connector.get_connector_integration_v2();
let dispute_data = AcceptDisputeData::foreign_try_from(payload.clone())
.map_err(|e| e.into_grpc_status())?;
let dispute_flow_data = DisputeFlowData::foreign_try_from((
payload.clone(),
self.config.connectors.clone(),
))
.map_err(|e| e.into_grpc_status())?;
let router_data: RouterDataV2<
Accept,
DisputeFlowData,
AcceptDisputeData,
DisputeResponseData,
> = RouterDataV2 {
flow: std::marker::PhantomData,
resource_common_data: dispute_flow_data,
connector_auth_type,
request: dispute_data,
response: Err(ErrorResponse::default()),
};
let event_params = external_services::service::EventProcessingParams {
connector_name: &connector.to_string(),
service_name: &service_name,
flow_name: common_utils::events::FlowName::AcceptDispute,
event_config: &self.config.events,
request_id: &request_id,
lineage_ids: &lineage_ids,
reference_id: &reference_id,
shadow_mode,
};
let response = external_services::service::execute_connector_processing_step(
&self.config.proxy,
connector_integration,
router_data,
None,
event_params,
None,
common_enums::CallConnectorAction::Trigger,
)
.await
.switch()
.map_err(|e| e.into_grpc_status())?;
let dispute_response = generate_accept_dispute_response(response)
.map_err(|e| e.into_grpc_status())?;
Ok(tonic::Response::new(dispute_response))
}
},
)
.await
}
| {
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": "accept",
"is_async": false,
"is_pub": false,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_fn_grpc-server_4380569431456917537 | clm | function | // connector-service/backend/grpc-server/src/server/disputes.rs
async fn transform(
&self,
request: tonic::Request<DisputeServiceTransformRequest>,
) -> Result<tonic::Response<DisputeServiceTransformResponse>, tonic::Status> {
let service_name = request
.extensions()
.get::<String>()
.cloned()
.unwrap_or_else(|| "DisputeService".to_string());
grpc_logging_wrapper(
request,
&service_name,
self.config.clone(),
common_utils::events::FlowName::IncomingWebhook,
|request_data| {
async move {
let connector = request_data.extracted_metadata.connector;
let connector_auth_details = request_data.extracted_metadata.connector_auth_type;
let payload = request_data.payload;
let request_details = payload
.request_details
.map(domain_types::connector_types::RequestDetails::foreign_try_from)
.ok_or_else(|| {
tonic::Status::invalid_argument("missing request_details in the payload")
})?
.map_err(|e| e.into_grpc_status())?;
let webhook_secrets = payload
.webhook_secrets
.map(|details| {
domain_types::connector_types::ConnectorWebhookSecrets::foreign_try_from(
details,
)
.map_err(|e| e.into_grpc_status())
})
.transpose()?;
// Get connector data
let connector_data = ConnectorData::get_connector_by_name(&connector);
let source_verified = connector_data
.connector
.verify_webhook_source(
request_details.clone(),
webhook_secrets.clone(),
Some(connector_auth_details.clone()),
)
.switch()
.map_err(|e| e.into_grpc_status())?;
let content = get_disputes_webhook_content(
connector_data,
request_details,
webhook_secrets,
Some(connector_auth_details),
)
.await
.map_err(|e| e.into_grpc_status())?;
let response = DisputeServiceTransformResponse {
event_type: WebhookEventType::WebhookDisputeOpened.into(),
content: Some(content),
source_verified,
response_ref_id: None,
};
Ok(tonic::Response::new(response))
}
},
)
.await
}
| {
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": "transform",
"is_async": false,
"is_pub": false,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_fn_grpc-server_-4396904337498835905 | clm | function | // connector-service/backend/grpc-server/src/server/disputes.rs
async fn get_disputes_webhook_content(
connector_data: ConnectorData<DefaultPCIHolder>,
request_details: domain_types::connector_types::RequestDetails,
webhook_secrets: Option<domain_types::connector_types::ConnectorWebhookSecrets>,
connector_auth_details: Option<ConnectorAuthType>,
) -> CustomResult<WebhookResponseContent, ApplicationErrorResponse> {
let webhook_details = connector_data
.connector
.process_dispute_webhook(request_details, webhook_secrets, connector_auth_details)
.switch()?;
// Generate response
let response = DisputeResponse::foreign_try_from(webhook_details).change_context(
ApplicationErrorResponse::InternalServerError(ApiError {
sub_code: "RESPONSE_CONSTRUCTION_ERROR".to_string(),
error_identifier: 500,
error_message: "Error while constructing response".to_string(),
error_object: None,
}),
)?;
Ok(WebhookResponseContent {
content: Some(
grpc_api_types::payments::webhook_response_content::Content::DisputesResponse(response),
),
})
}
| {
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": "get_disputes_webhook_content",
"is_async": false,
"is_pub": false,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_fn_grpc-server_3233543653241132822 | clm | function | // connector-service/backend/grpc-server/src/server/health_check.rs
async fn check(
&self,
request: Request<health_check::HealthCheckRequest>,
) -> Result<Response<health_check::HealthCheckResponse>, Status> {
tracing::debug!(?request, "health_check request");
let response = health_check::HealthCheckResponse {
status: health_check::health_check_response::ServingStatus::Serving.into(),
};
tracing::info!(?response, "health_check response");
Ok(Response::new(response))
}
| {
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": "check",
"is_async": false,
"is_pub": false,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_fn_interfaces_1860956086567116218 | clm | function | // connector-service/backend/interfaces/src/verification.rs
fn get_secrets(
&self,
_secrets: ConnectorSourceVerificationSecrets,
) -> CustomResult<Vec<u8>, domain_types::errors::ConnectorError> {
Ok(Vec::new())
}
| {
"chunk": null,
"crate": "interfaces",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": "get_secrets",
"is_async": false,
"is_pub": false,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_fn_interfaces_1552929894553044163 | clm | function | // connector-service/backend/interfaces/src/verification.rs
fn get_algorithm(
&self,
) -> CustomResult<Box<dyn crypto::VerifySignature + Send>, domain_types::errors::ConnectorError>
{
Ok(Box::new(crypto::NoAlgorithm))
}
| {
"chunk": null,
"crate": "interfaces",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": "get_algorithm",
"is_async": false,
"is_pub": false,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_fn_interfaces_9171571836703418490 | clm | function | // connector-service/backend/interfaces/src/verification.rs
fn get_signature(
&self,
_payload: &[u8],
_router_data: &RouterDataV2<Flow, ResourceCommonData, Req, Resp>,
_secrets: &[u8],
) -> CustomResult<Vec<u8>, domain_types::errors::ConnectorError> {
Ok(Vec::new())
}
| {
"chunk": null,
"crate": "interfaces",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": "get_signature",
"is_async": false,
"is_pub": false,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_fn_interfaces_5181331827577067623 | clm | function | // connector-service/backend/interfaces/src/verification.rs
fn get_message(
&self,
payload: &[u8],
_router_data: &RouterDataV2<Flow, ResourceCommonData, Req, Resp>,
_secrets: &[u8],
) -> CustomResult<Vec<u8>, domain_types::errors::ConnectorError> {
Ok(payload.to_owned())
}
| {
"chunk": null,
"crate": "interfaces",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": "get_message",
"is_async": false,
"is_pub": false,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_fn_interfaces_-8427543665593442032 | clm | function | // connector-service/backend/interfaces/src/verification.rs
fn verify(
&self,
router_data: &RouterDataV2<Flow, ResourceCommonData, Req, Resp>,
secrets: ConnectorSourceVerificationSecrets,
payload: &[u8],
) -> CustomResult<bool, domain_types::errors::ConnectorError> {
let algorithm = self.get_algorithm()?;
let extracted_secrets = self.get_secrets(secrets)?;
let signature = self.get_signature(payload, router_data, &extracted_secrets)?;
let message = self.get_message(payload, router_data, &extracted_secrets)?;
// Verify the signature against the message
algorithm
.verify_signature(&extracted_secrets, &signature, &message)
.change_context(domain_types::errors::ConnectorError::SourceVerificationFailed)
}
| {
"chunk": null,
"crate": "interfaces",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": "verify",
"is_async": false,
"is_pub": false,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_fn_interfaces_234822631721137142 | clm | function | // connector-service/backend/interfaces/src/connector_types.rs
fn should_do_order_create(&self) -> bool {
false
}
| {
"chunk": null,
"crate": "interfaces",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": "should_do_order_create",
"is_async": false,
"is_pub": false,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_fn_interfaces_-3770222603980530517 | clm | function | // connector-service/backend/interfaces/src/connector_types.rs
fn should_do_session_token(&self) -> bool {
false
}
| {
"chunk": null,
"crate": "interfaces",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": "should_do_session_token",
"is_async": false,
"is_pub": false,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_fn_interfaces_8119151635925968901 | clm | function | // connector-service/backend/interfaces/src/connector_types.rs
fn should_do_access_token(&self) -> bool {
false
}
| {
"chunk": null,
"crate": "interfaces",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": "should_do_access_token",
"is_async": false,
"is_pub": false,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_fn_interfaces_7919969932084239796 | clm | function | // connector-service/backend/interfaces/src/connector_types.rs
fn should_create_connector_customer(&self) -> bool {
false
}
| {
"chunk": null,
"crate": "interfaces",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": "should_create_connector_customer",
"is_async": false,
"is_pub": false,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_fn_interfaces_-4091764765228251624 | clm | function | // connector-service/backend/interfaces/src/connector_types.rs
fn should_do_payment_method_token(&self) -> bool {
false
}
| {
"chunk": null,
"crate": "interfaces",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": "should_do_payment_method_token",
"is_async": false,
"is_pub": false,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_fn_interfaces_-4987703221146061836 | clm | function | // connector-service/backend/interfaces/src/connector_types.rs
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>> {
Ok(false)
}
| {
"chunk": null,
"crate": "interfaces",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": "verify_webhook_source",
"is_async": false,
"is_pub": false,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_fn_interfaces_7460154948973115440 | clm | function | // connector-service/backend/interfaces/src/connector_types.rs
fn get_webhook_source_verification_signature(
&self,
_request: &RequestDetails,
_connector_webhook_secret: &ConnectorWebhookSecrets,
) -> Result<Vec<u8>, error_stack::Report<domain_types::errors::ConnectorError>> {
Ok(Vec::new())
}
| {
"chunk": null,
"crate": "interfaces",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": "get_webhook_source_verification_signature",
"is_async": false,
"is_pub": false,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_fn_interfaces_-1503845428673231174 | clm | function | // connector-service/backend/interfaces/src/connector_types.rs
fn get_webhook_source_verification_message(
&self,
_request: &RequestDetails,
_connector_webhook_secret: &ConnectorWebhookSecrets,
) -> Result<Vec<u8>, error_stack::Report<domain_types::errors::ConnectorError>> {
Ok(Vec::new())
}
| {
"chunk": null,
"crate": "interfaces",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": "get_webhook_source_verification_message",
"is_async": false,
"is_pub": false,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_fn_interfaces_-6797427122303227818 | clm | function | // connector-service/backend/interfaces/src/connector_types.rs
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>> {
Err(
domain_types::errors::ConnectorError::NotImplemented("get_event_type".to_string())
.into(),
)
}
| {
"chunk": null,
"crate": "interfaces",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": "get_event_type",
"is_async": false,
"is_pub": false,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_fn_interfaces_-746232449507976469 | clm | function | // connector-service/backend/interfaces/src/connector_types.rs
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>>
{
Err(domain_types::errors::ConnectorError::NotImplemented(
"process_payment_webhook".to_string(),
)
.into())
}
| {
"chunk": null,
"crate": "interfaces",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": "process_payment_webhook",
"is_async": false,
"is_pub": false,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_fn_interfaces_7046929677796791626 | clm | function | // connector-service/backend/interfaces/src/connector_types.rs
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>,
> {
Err(domain_types::errors::ConnectorError::NotImplemented(
"process_refund_webhook".to_string(),
)
.into())
}
| {
"chunk": null,
"crate": "interfaces",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": "process_refund_webhook",
"is_async": false,
"is_pub": false,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_fn_interfaces_-7334983424329949003 | clm | function | // connector-service/backend/interfaces/src/connector_types.rs
fn process_dispute_webhook(
&self,
_request: RequestDetails,
_connector_webhook_secret: Option<ConnectorWebhookSecrets>,
_connector_account_details: Option<ConnectorAuthType>,
) -> Result<
DisputeWebhookDetailsResponse,
error_stack::Report<domain_types::errors::ConnectorError>,
> {
Err(domain_types::errors::ConnectorError::NotImplemented(
"process_dispute_webhook".to_string(),
)
.into())
}
| {
"chunk": null,
"crate": "interfaces",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": "process_dispute_webhook",
"is_async": false,
"is_pub": false,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_fn_interfaces_-3273185454774027288 | clm | function | // connector-service/backend/interfaces/src/connector_types.rs
fn get_webhook_resource_object(
&self,
_request: RequestDetails,
) -> Result<
Box<dyn hyperswitch_masking::ErasedMaskSerialize>,
error_stack::Report<domain_types::errors::ConnectorError>,
> {
Err(domain_types::errors::ConnectorError::NotImplemented(
"get_webhook_resource_object".to_string(),
)
.into())
}
| {
"chunk": null,
"crate": "interfaces",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": "get_webhook_resource_object",
"is_async": false,
"is_pub": false,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_fn_interfaces_-4016073787511400179 | clm | function | // connector-service/backend/interfaces/src/connector_types.rs
fn validate_connector_against_payment_request(
&self,
capture_method: Option<CaptureMethod>,
payment_method: PaymentMethod,
pmt: Option<PaymentMethodType>,
) -> CustomResult<(), domain_types::errors::ConnectorError> {
let capture_method = capture_method.unwrap_or_default();
let is_default_capture_method = [CaptureMethod::Automatic].contains(&capture_method);
let is_feature_supported = match self.get_supported_payment_methods() {
Some(supported_payment_methods) => {
let connector_payment_method_type_info = get_connector_payment_method_type_info(
supported_payment_methods,
payment_method,
pmt,
self.id(),
)?;
connector_payment_method_type_info
.map(|payment_method_type_info| {
payment_method_type_info
.supported_capture_methods
.contains(&capture_method)
})
.unwrap_or(true)
}
None => is_default_capture_method,
};
if is_feature_supported {
Ok(())
} else {
Err(domain_types::errors::ConnectorError::NotSupported {
message: capture_method.to_string(),
connector: self.id(),
}
.into())
}
}
| {
"chunk": null,
"crate": "interfaces",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": "validate_connector_against_payment_request",
"is_async": false,
"is_pub": false,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_fn_interfaces_5653381627481173452 | clm | function | // connector-service/backend/interfaces/src/connector_types.rs
fn validate_mandate_payment(
&self,
pm_type: Option<PaymentMethodType>,
_pm_data: PaymentMethodData<domain_types::payment_method_data::DefaultPCIHolder>,
) -> CustomResult<(), domain_types::errors::ConnectorError> {
let connector = self.id();
match pm_type {
Some(pm_type) => Err(domain_types::errors::ConnectorError::NotSupported {
message: format!("{pm_type} mandate payment"),
connector,
}
.into()),
None => Err(domain_types::errors::ConnectorError::NotSupported {
message: " mandate payment".to_string(),
connector,
}
.into()),
}
}
| {
"chunk": null,
"crate": "interfaces",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": "validate_mandate_payment",
"is_async": false,
"is_pub": false,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_fn_interfaces_2100301772043126149 | clm | function | // connector-service/backend/interfaces/src/connector_types.rs
fn validate_psync_reference_id(
&self,
data: &PaymentsSyncData,
_is_three_ds: bool,
_status: AttemptStatus,
_connector_meta_data: Option<SecretSerdeValue>,
) -> CustomResult<(), domain_types::errors::ConnectorError> {
data.connector_transaction_id
.get_connector_transaction_id()
.change_context(domain_types::errors::ConnectorError::MissingConnectorTransactionID)
.map(|_| ())
}
| {
"chunk": null,
"crate": "interfaces",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": "validate_psync_reference_id",
"is_async": false,
"is_pub": false,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_fn_interfaces_6568017622285420655 | clm | function | // connector-service/backend/interfaces/src/connector_types.rs
fn is_webhook_source_verification_mandatory(&self) -> bool {
false
}
| {
"chunk": null,
"crate": "interfaces",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": "is_webhook_source_verification_mandatory",
"is_async": false,
"is_pub": false,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_fn_interfaces_8998734169015978571 | clm | function | // connector-service/backend/interfaces/src/connector_types.rs
fn get_connector_payment_method_type_info(
supported_payment_method: &SupportedPaymentMethods,
payment_method: PaymentMethod,
payment_method_type: Option<PaymentMethodType>,
connector: &'static str,
) -> CustomResult<Option<PaymentMethodDetails>, domain_types::errors::ConnectorError> {
let payment_method_details =
supported_payment_method
.get(&payment_method)
.ok_or_else(|| domain_types::errors::ConnectorError::NotSupported {
message: payment_method.to_string(),
connector,
})?;
payment_method_type
.map(|pmt| {
payment_method_details.get(&pmt).cloned().ok_or_else(|| {
domain_types::errors::ConnectorError::NotSupported {
message: format!("{payment_method} {pmt}"),
connector,
}
.into()
})
})
.transpose()
}
| {
"chunk": null,
"crate": "interfaces",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": "get_connector_payment_method_type_info",
"is_async": false,
"is_pub": false,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_fn_interfaces_-5902888379317477341 | clm | function | // connector-service/backend/interfaces/src/connector_types.rs
pub fn is_mandate_supported<T: PaymentMethodDataTypes>(
selected_pmd: PaymentMethodData<T>,
payment_method_type: Option<PaymentMethodType>,
mandate_implemented_pmds: HashSet<PaymentMethodDataType>,
connector: &'static str,
) -> Result<(), error_stack::Report<domain_types::errors::ConnectorError>> {
if mandate_implemented_pmds.contains(&PaymentMethodDataType::from(selected_pmd.clone())) {
Ok(())
} else {
match payment_method_type {
Some(pm_type) => Err(domain_types::errors::ConnectorError::NotSupported {
message: format!("{pm_type} mandate payment"),
connector,
}
.into()),
None => Err(domain_types::errors::ConnectorError::NotSupported {
message: "mandate payment".to_string(),
connector,
}
.into()),
}
}
}
| {
"chunk": null,
"crate": "interfaces",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": "is_mandate_supported",
"is_async": false,
"is_pub": true,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_fn_interfaces_8880510218249287521 | clm | function | // connector-service/backend/interfaces/src/integrity.rs
fn get_response_integrity_object(&self) -> Option<CreateConnectorCustomerIntegrityObject> {
None // Customer creation responses don't have integrity objects
}
| {
"chunk": null,
"crate": "interfaces",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": "get_response_integrity_object",
"is_async": false,
"is_pub": false,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_fn_interfaces_-2543964029645814028 | clm | function | // connector-service/backend/interfaces/src/integrity.rs
fn get_request_integrity_object(&self) -> CreateConnectorCustomerIntegrityObject {
CreateConnectorCustomerIntegrityObject {
customer_id: self.customer_id.clone(),
email: self.email.as_ref().map(|e| {
let email_inner = e.peek().clone().expose();
Secret::new(email_inner.expose())
}),
}
}
| {
"chunk": null,
"crate": "interfaces",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": "get_request_integrity_object",
"is_async": false,
"is_pub": false,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_fn_interfaces_-1340448511782822228 | clm | function | // connector-service/backend/interfaces/src/integrity.rs
fn compare(
req_integrity_object: Self,
res_integrity_object: Self,
connector_transaction_id: Option<String>,
) -> Result<(), IntegrityCheckError> {
let mut mismatched_fields = Vec::new();
// Check customer_id
if req_integrity_object.customer_id != res_integrity_object.customer_id {
let req_customer_id = req_integrity_object
.customer_id
.as_ref()
.map(|s| s.clone().expose())
.unwrap_or_else(|| "None".to_string());
let res_customer_id = res_integrity_object
.customer_id
.as_ref()
.map(|s| s.clone().expose())
.unwrap_or_else(|| "None".to_string());
mismatched_fields.push(format_mismatch(
"customer_id",
&req_customer_id,
&res_customer_id,
));
}
// Check email
if req_integrity_object.email != res_integrity_object.email {
let req_email = req_integrity_object
.email
.as_ref()
.map(|s| s.clone().expose())
.unwrap_or_else(|| "None".to_string());
let res_email = res_integrity_object
.email
.as_ref()
.map(|s| s.clone().expose())
.unwrap_or_else(|| "None".to_string());
mismatched_fields.push(format_mismatch("email", &req_email, &res_email));
}
check_integrity_result(mismatched_fields, connector_transaction_id)
}
| {
"chunk": null,
"crate": "interfaces",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": "compare",
"is_async": false,
"is_pub": false,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_fn_interfaces_5430504874184157263 | clm | function | // connector-service/backend/interfaces/src/integrity.rs
fn format_mismatch(field: &str, expected: &str, found: &str) -> String {
format!("{field} expected {expected} but found {found}")
}
| {
"chunk": null,
"crate": "interfaces",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": "format_mismatch",
"is_async": false,
"is_pub": false,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_fn_interfaces_3767528725818782279 | clm | function | // connector-service/backend/interfaces/src/integrity.rs
fn check_integrity_result(
mismatched_fields: Vec<String>,
connector_transaction_id: Option<String>,
) -> Result<(), IntegrityCheckError> {
if mismatched_fields.is_empty() {
Ok(())
} else {
let field_names = mismatched_fields.join(", ");
Err(IntegrityCheckError {
field_names,
connector_transaction_id,
})
}
}
| {
"chunk": null,
"crate": "interfaces",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": "check_integrity_result",
"is_async": false,
"is_pub": false,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_fn_interfaces_4621325876480943403 | clm | function | // connector-service/backend/interfaces/src/webhooks.rs
fn get_webhook_body_decoding_algorithm(
&self,
_request: &IncomingWebhookRequestDetails<'_>,
) -> CustomResult<Box<dyn crypto::DecodeMessage + Send>, domain_types::errors::ConnectorError>
{
Ok(Box::new(crypto::NoAlgorithm))
}
| {
"chunk": null,
"crate": "interfaces",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": "get_webhook_body_decoding_algorithm",
"is_async": false,
"is_pub": false,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_fn_interfaces_362605187853551203 | clm | function | // connector-service/backend/interfaces/src/webhooks.rs
fn get_webhook_body_decoding_message(
&self,
request: &IncomingWebhookRequestDetails<'_>,
) -> CustomResult<Vec<u8>, domain_types::errors::ConnectorError> {
Ok(request.body.to_vec())
}
| {
"chunk": null,
"crate": "interfaces",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": "get_webhook_body_decoding_message",
"is_async": false,
"is_pub": false,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_fn_interfaces_-250960067738591458 | clm | function | // connector-service/backend/interfaces/src/webhooks.rs
async fn decode_webhook_body(
&self,
request: &IncomingWebhookRequestDetails<'_>,
merchant_id: &common_utils::id_type::MerchantId,
connector_webhook_details: Option<common_utils::pii::SecretSerdeValue>,
connector_name: &str,
) -> CustomResult<Vec<u8>, domain_types::errors::ConnectorError> {
let algorithm = self.get_webhook_body_decoding_algorithm(request)?;
let message = self
.get_webhook_body_decoding_message(request)
.change_context(domain_types::errors::ConnectorError::WebhookBodyDecodingFailed)?;
let secret = self
.get_webhook_source_verification_merchant_secret(
merchant_id,
connector_name,
connector_webhook_details,
)
.await
.change_context(
domain_types::errors::ConnectorError::WebhookSourceVerificationFailed,
)?;
algorithm
.decode_message(&secret.secret, message.into())
.change_context(domain_types::errors::ConnectorError::WebhookBodyDecodingFailed)
}
| {
"chunk": null,
"crate": "interfaces",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": "decode_webhook_body",
"is_async": false,
"is_pub": false,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_fn_interfaces_1533670866290525920 | clm | function | // connector-service/backend/interfaces/src/webhooks.rs
fn get_webhook_source_verification_algorithm(
&self,
_request: &IncomingWebhookRequestDetails<'_>,
) -> CustomResult<Box<dyn crypto::VerifySignature + Send>, domain_types::errors::ConnectorError>
{
Ok(Box::new(crypto::NoAlgorithm))
}
| {
"chunk": null,
"crate": "interfaces",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": "get_webhook_source_verification_algorithm",
"is_async": false,
"is_pub": false,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_fn_interfaces_3263610587134362028 | clm | function | // connector-service/backend/interfaces/src/webhooks.rs
async fn get_webhook_source_verification_merchant_secret(
&self,
merchant_id: &common_utils::id_type::MerchantId,
connector_name: &str,
connector_webhook_details: Option<common_utils::pii::SecretSerdeValue>,
) -> CustomResult<ConnectorWebhookSecrets, domain_types::errors::ConnectorError> {
let debug_suffix =
format!("For merchant_id: {merchant_id:?}, and connector_name: {connector_name}");
let default_secret = "default_secret".to_string();
let merchant_secret = match connector_webhook_details {
Some(merchant_connector_webhook_details) => {
let connector_webhook_details = merchant_connector_webhook_details
.parse_value::<MerchantConnectorWebhookDetails>(
"MerchantConnectorWebhookDetails",
)
.change_context_lazy(|| {
domain_types::errors::ConnectorError::WebhookSourceVerificationFailed
})
.attach_printable_lazy(|| {
format!(
"Deserializing MerchantConnectorWebhookDetails failed {debug_suffix}"
)
})?;
ConnectorWebhookSecrets {
secret: connector_webhook_details
.merchant_secret
.expose()
.into_bytes(),
additional_secret: connector_webhook_details.additional_secret,
}
}
None => ConnectorWebhookSecrets {
secret: default_secret.into_bytes(),
additional_secret: None,
},
};
//need to fetch merchant secret from config table with caching in future for enhanced performance
//If merchant has not set the secret for webhook source verification, "default_secret" is returned.
//So it will fail during verification step and goes to psync flow.
Ok(merchant_secret)
}
| {
"chunk": null,
"crate": "interfaces",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": "get_webhook_source_verification_merchant_secret",
"is_async": false,
"is_pub": false,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_fn_interfaces_-5449578033364109320 | clm | function | // connector-service/backend/interfaces/src/webhooks.rs
fn get_webhook_source_verification_signature(
&self,
_request: &IncomingWebhookRequestDetails<'_>,
_connector_webhook_secrets: &ConnectorWebhookSecrets,
) -> CustomResult<Vec<u8>, domain_types::errors::ConnectorError> {
Ok(Vec::new())
}
| {
"chunk": null,
"crate": "interfaces",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": "get_webhook_source_verification_signature",
"is_async": false,
"is_pub": false,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_fn_interfaces_-9005759783036525639 | clm | function | // connector-service/backend/interfaces/src/webhooks.rs
fn get_webhook_source_verification_message(
&self,
_request: &IncomingWebhookRequestDetails<'_>,
_merchant_id: &common_utils::id_type::MerchantId,
_connector_webhook_secrets: &ConnectorWebhookSecrets,
) -> CustomResult<Vec<u8>, domain_types::errors::ConnectorError> {
Ok(Vec::new())
}
| {
"chunk": null,
"crate": "interfaces",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": "get_webhook_source_verification_message",
"is_async": false,
"is_pub": false,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_fn_interfaces_-6022705827761258943 | clm | function | // connector-service/backend/interfaces/src/webhooks.rs
async fn verify_webhook_source(
&self,
request: &IncomingWebhookRequestDetails<'_>,
merchant_id: &common_utils::id_type::MerchantId,
connector_webhook_details: Option<common_utils::pii::SecretSerdeValue>,
_connector_account_details: crypto::Encryptable<Secret<serde_json::Value>>,
connector_name: &str,
) -> CustomResult<bool, domain_types::errors::ConnectorError> {
let algorithm = self
.get_webhook_source_verification_algorithm(request)
.change_context(
domain_types::errors::ConnectorError::WebhookSourceVerificationFailed,
)?;
let connector_webhook_secrets = self
.get_webhook_source_verification_merchant_secret(
merchant_id,
connector_name,
connector_webhook_details,
)
.await
.change_context(
domain_types::errors::ConnectorError::WebhookSourceVerificationFailed,
)?;
let signature = self
.get_webhook_source_verification_signature(request, &connector_webhook_secrets)
.change_context(
domain_types::errors::ConnectorError::WebhookSourceVerificationFailed,
)?;
let message = self
.get_webhook_source_verification_message(
request,
merchant_id,
&connector_webhook_secrets,
)
.change_context(
domain_types::errors::ConnectorError::WebhookSourceVerificationFailed,
)?;
algorithm
.verify_signature(&connector_webhook_secrets.secret, &signature, &message)
.change_context(domain_types::errors::ConnectorError::WebhookSourceVerificationFailed)
}
| {
"chunk": null,
"crate": "interfaces",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": "verify_webhook_source",
"is_async": false,
"is_pub": false,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_fn_interfaces_-6089759324262980766 | clm | function | // connector-service/backend/interfaces/src/webhooks.rs
fn get_webhook_api_response(
&self,
_request: &IncomingWebhookRequestDetails<'_>,
_error_kind: Option<IncomingWebhookFlowError>,
) -> CustomResult<ApplicationResponse<serde_json::Value>, domain_types::errors::ConnectorError>
{
Ok(ApplicationResponse::StatusOk)
}
| {
"chunk": null,
"crate": "interfaces",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": "get_webhook_api_response",
"is_async": false,
"is_pub": false,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_fn_interfaces_-627268752418460137 | clm | function | // connector-service/backend/interfaces/src/webhooks.rs
fn get_dispute_details(
&self,
_request: &IncomingWebhookRequestDetails<'_>,
) -> CustomResult<crate::disputes::DisputePayload, domain_types::errors::ConnectorError> {
Err(domain_types::errors::ConnectorError::NotImplemented(
"get_dispute_details method".to_string(),
)
.into())
}
| {
"chunk": null,
"crate": "interfaces",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": "get_dispute_details",
"is_async": false,
"is_pub": false,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_fn_interfaces_5957321670385618724 | clm | function | // connector-service/backend/interfaces/src/webhooks.rs
fn get_external_authentication_details(
&self,
_request: &IncomingWebhookRequestDetails<'_>,
) -> CustomResult<
crate::authentication::ExternalAuthenticationPayload,
domain_types::errors::ConnectorError,
> {
Err(domain_types::errors::ConnectorError::NotImplemented(
"get_external_authentication_details method".to_string(),
)
.into())
}
| {
"chunk": null,
"crate": "interfaces",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": "get_external_authentication_details",
"is_async": false,
"is_pub": false,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_fn_interfaces_-2356250103223420130 | clm | function | // connector-service/backend/interfaces/src/webhooks.rs
fn get_mandate_details(
&self,
_request: &IncomingWebhookRequestDetails<'_>,
) -> CustomResult<
Option<domain_types::router_flow_types::ConnectorMandateDetails>,
domain_types::errors::ConnectorError,
> {
Ok(None)
}
| {
"chunk": null,
"crate": "interfaces",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": "get_mandate_details",
"is_async": false,
"is_pub": false,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_fn_interfaces_4560581825185006504 | clm | function | // connector-service/backend/interfaces/src/webhooks.rs
fn get_network_txn_id(
&self,
_request: &IncomingWebhookRequestDetails<'_>,
) -> CustomResult<
Option<domain_types::router_flow_types::ConnectorNetworkTxnId>,
domain_types::errors::ConnectorError,
> {
Ok(None)
}
| {
"chunk": null,
"crate": "interfaces",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": "get_network_txn_id",
"is_async": false,
"is_pub": false,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_fn_interfaces_3116248988077772156 | clm | function | // connector-service/backend/interfaces/src/connector_integration_v2.rs
fn get_connector_integration_v2(
&self,
) -> BoxedConnectorIntegrationV2<'_, Flow, ResourceCommonData, Req, Resp> {
Box::new(self)
}
| {
"chunk": null,
"crate": "interfaces",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": "get_connector_integration_v2",
"is_async": false,
"is_pub": false,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_fn_interfaces_7666535149177270072 | clm | function | // connector-service/backend/interfaces/src/connector_integration_v2.rs
fn get_headers(
&self,
_req: &RouterDataV2<Flow, ResourceCommonData, Req, Resp>,
) -> CustomResult<Vec<(String, Maskable<String>)>, domain_types::errors::ConnectorError> {
Ok(vec![])
}
| {
"chunk": null,
"crate": "interfaces",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": "get_headers",
"is_async": false,
"is_pub": false,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_fn_interfaces_-4096561353871998888 | clm | function | // connector-service/backend/interfaces/src/connector_integration_v2.rs
fn get_content_type(&self) -> &'static str {
mime::APPLICATION_JSON.essence_str()
}
| {
"chunk": null,
"crate": "interfaces",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": "get_content_type",
"is_async": false,
"is_pub": false,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_fn_interfaces_-3699458729581995167 | clm | function | // connector-service/backend/interfaces/src/connector_integration_v2.rs
fn get_http_method(&self) -> Method {
Method::Post
}
| {
"chunk": null,
"crate": "interfaces",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": "get_http_method",
"is_async": false,
"is_pub": false,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_fn_interfaces_-6363562458875186917 | clm | function | // connector-service/backend/interfaces/src/connector_integration_v2.rs
fn get_url(
&self,
_req: &RouterDataV2<Flow, ResourceCommonData, Req, Resp>,
) -> CustomResult<String, domain_types::errors::ConnectorError> {
// metrics::UNIMPLEMENTED_FLOW
// .add(1, router_env::metric_attributes!(("connector", self.id()))); // TODO: discuss env
Ok(String::new())
}
| {
"chunk": null,
"crate": "interfaces",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": "get_url",
"is_async": false,
"is_pub": false,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_fn_interfaces_7604686390906833614 | clm | function | // connector-service/backend/interfaces/src/connector_integration_v2.rs
fn get_request_body(
&self,
_req: &RouterDataV2<Flow, ResourceCommonData, Req, Resp>,
) -> CustomResult<Option<RequestContent>, domain_types::errors::ConnectorError> {
Ok(None)
}
| {
"chunk": null,
"crate": "interfaces",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": "get_request_body",
"is_async": false,
"is_pub": false,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_fn_interfaces_5058330424503503752 | clm | function | // connector-service/backend/interfaces/src/connector_integration_v2.rs
fn get_request_form_data(
&self,
_req: &RouterDataV2<Flow, ResourceCommonData, Req, Resp>,
) -> CustomResult<Option<reqwest::multipart::Form>, domain_types::errors::ConnectorError> {
Ok(None)
}
| {
"chunk": null,
"crate": "interfaces",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": "get_request_form_data",
"is_async": false,
"is_pub": false,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_fn_interfaces_5586597295264513272 | clm | function | // connector-service/backend/interfaces/src/connector_integration_v2.rs
fn build_request_v2(
&self,
req: &RouterDataV2<Flow, ResourceCommonData, Req, Resp>,
) -> CustomResult<Option<Request>, domain_types::errors::ConnectorError> {
Ok(Some(
RequestBuilder::new()
.method(self.get_http_method())
.url(self.get_url(req)?.as_str())
.attach_default_headers()
.headers(self.get_headers(req)?)
.set_optional_body(self.get_request_body(req)?)
.add_certificate(self.get_certificate(req)?)
.add_certificate_key(self.get_certificate_key(req)?)
.build(),
))
}
| {
"chunk": null,
"crate": "interfaces",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": "build_request_v2",
"is_async": false,
"is_pub": false,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_fn_interfaces_3410150817892312159 | clm | function | // connector-service/backend/interfaces/src/connector_integration_v2.rs
fn handle_response_v2(
&self,
data: &RouterDataV2<Flow, ResourceCommonData, Req, Resp>,
event_builder: Option<&mut events::Event>,
_res: domain_types::router_response_types::Response,
) -> CustomResult<
RouterDataV2<Flow, ResourceCommonData, Req, Resp>,
domain_types::errors::ConnectorError,
>
where
Flow: Clone,
ResourceCommonData: Clone,
Req: Clone,
Resp: Clone,
{
if let Some(e) = event_builder {
e.set_connector_response(&json!({"error": "Not Implemented"}))
}
Ok(data.clone())
}
| {
"chunk": null,
"crate": "interfaces",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": "handle_response_v2",
"is_async": false,
"is_pub": false,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_fn_interfaces_-2191993840471531092 | clm | function | // connector-service/backend/interfaces/src/connector_integration_v2.rs
fn get_error_response_v2(
&self,
res: domain_types::router_response_types::Response,
event_builder: Option<&mut events::Event>,
) -> CustomResult<ErrorResponse, domain_types::errors::ConnectorError> {
if let Some(event) = event_builder {
event.set_connector_response(&json!({"error": "Error response parsing not implemented", "status_code": res.status_code}))
}
Ok(ErrorResponse::get_not_implemented())
}
| {
"chunk": null,
"crate": "interfaces",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": "get_error_response_v2",
"is_async": false,
"is_pub": false,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_fn_interfaces_2946311555777257891 | clm | function | // connector-service/backend/interfaces/src/connector_integration_v2.rs
fn get_5xx_error_response(
&self,
res: domain_types::router_response_types::Response,
event_builder: Option<&mut events::Event>,
) -> CustomResult<ErrorResponse, domain_types::errors::ConnectorError> {
let error_message = match res.status_code {
500 => "internal_server_error",
501 => "not_implemented",
502 => "bad_gateway",
503 => "service_unavailable",
504 => "gateway_timeout",
505 => "http_version_not_supported",
506 => "variant_also_negotiates",
507 => "insufficient_storage",
508 => "loop_detected",
510 => "not_extended",
511 => "network_authentication_required",
_ => "unknown_error",
};
if let Some(event) = event_builder {
event.set_connector_response(
&json!({"error": error_message, "status_code": res.status_code}),
)
}
Ok(ErrorResponse {
code: res.status_code.to_string(),
message: error_message.to_string(),
reason: String::from_utf8(res.response.to_vec()).ok(),
status_code: res.status_code,
attempt_status: None,
connector_transaction_id: None,
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
})
}
| {
"chunk": null,
"crate": "interfaces",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": "get_5xx_error_response",
"is_async": false,
"is_pub": false,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_fn_interfaces_-3092557119283906712 | clm | function | // connector-service/backend/interfaces/src/connector_integration_v2.rs
fn get_certificate(
&self,
_req: &RouterDataV2<Flow, ResourceCommonData, Req, Resp>,
) -> CustomResult<
Option<hyperswitch_masking::Secret<String>>,
domain_types::errors::ConnectorError,
> {
Ok(None)
}
| {
"chunk": null,
"crate": "interfaces",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": "get_certificate",
"is_async": false,
"is_pub": false,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_fn_interfaces_-1889672786474004496 | clm | function | // connector-service/backend/interfaces/src/connector_integration_v2.rs
fn get_certificate_key(
&self,
_req: &RouterDataV2<Flow, ResourceCommonData, Req, Resp>,
) -> CustomResult<
Option<hyperswitch_masking::Secret<String>>,
domain_types::errors::ConnectorError,
> {
Ok(None)
}
| {
"chunk": null,
"crate": "interfaces",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": "get_certificate_key",
"is_async": false,
"is_pub": false,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_fn_interfaces_-1107571576907130061 | clm | function | // connector-service/backend/interfaces/src/routing.rs
fn from(value: RoutableConnectorChoice) -> Self {
match value.choice_kind {
RoutableChoiceKind::OnlyConnector => Self::OnlyConnector(Box::new(value.connector)),
RoutableChoiceKind::FullStruct => Self::FullStruct {
connector: value.connector,
merchant_connector_id: value.merchant_connector_id,
},
}
}
| {
"chunk": null,
"crate": "interfaces",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": "from",
"is_async": false,
"is_pub": false,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_fn_interfaces_-3354065068773545319 | clm | function | // connector-service/backend/interfaces/src/api.rs
fn get_currency_unit(&self) -> CurrencyUnit {
CurrencyUnit::Minor // Default implementation should be remove once it is implemented in all connectors
}
| {
"chunk": null,
"crate": "interfaces",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": "get_currency_unit",
"is_async": false,
"is_pub": false,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_fn_interfaces_-1633379885255838739 | clm | function | // connector-service/backend/interfaces/src/api.rs
fn get_auth_header(
&self,
_auth_type: &ConnectorAuthType,
) -> CustomResult<
Vec<(String, hyperswitch_masking::Maskable<String>)>,
domain_types::errors::ConnectorError,
> {
Ok(Vec::new())
}
| {
"chunk": null,
"crate": "interfaces",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": "get_auth_header",
"is_async": false,
"is_pub": false,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_fn_interfaces_1495450922813113758 | clm | function | // connector-service/backend/interfaces/src/api.rs
fn common_get_content_type(&self) -> &'static str {
"application/json"
}
| {
"chunk": null,
"crate": "interfaces",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": "common_get_content_type",
"is_async": false,
"is_pub": false,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_fn_interfaces_1437126371773985393 | clm | function | // connector-service/backend/interfaces/src/api.rs
fn build_error_response(
&self,
res: domain_types::router_response_types::Response,
_event_builder: Option<&mut events::Event>,
) -> CustomResult<ErrorResponse, domain_types::errors::ConnectorError> {
Ok(ErrorResponse {
status_code: res.status_code,
code: NO_ERROR_CODE.to_string(),
message: NO_ERROR_MESSAGE.to_string(),
reason: None,
attempt_status: None,
connector_transaction_id: None,
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
})
}
| {
"chunk": null,
"crate": "interfaces",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": "build_error_response",
"is_async": false,
"is_pub": false,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_fn_interfaces_-1142216780450418505 | clm | function | // connector-service/backend/interfaces/src/events/routing_api_logs.rs
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
Self::Grpc => write!(f, "Grpc"),
Self::Rest(method) => write!(f, "Rest ({method})"),
}
}
| {
"chunk": null,
"crate": "interfaces",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": "fmt",
"is_async": false,
"is_pub": false,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_fn_interfaces_-894004033856134410 | clm | function | // connector-service/backend/interfaces/src/events/routing_api_logs.rs
pub fn new(
// tenant_id: common_utils::id_type::TenantId,
routable_connectors: String,
flow: &str,
request: serde_json::Value,
url: String,
method: ApiMethod,
payment_id: String,
profile_id: common_utils::id_type::ProfileId,
merchant_id: common_utils::id_type::MerchantId,
request_id: Option<RequestId>,
routing_engine: RoutingEngine,
) -> Self {
Self {
// tenant_id,
routable_connectors,
flow: flow.to_string(),
request: request.to_string(),
response: None,
error: None,
url,
method: method.to_string(),
payment_id,
profile_id,
merchant_id,
created_at: OffsetDateTime::now_utc().unix_timestamp_nanos(),
status_code: None,
request_id: request_id
.map(|i| i.as_hyphenated().to_string())
.unwrap_or("NO_REQUEST_ID".to_string()),
routing_engine,
payment_connector: None,
routing_approach: None,
}
}
| {
"chunk": null,
"crate": "interfaces",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": "new",
"is_async": false,
"is_pub": true,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_fn_interfaces_194142193830043864 | clm | function | // connector-service/backend/interfaces/src/events/routing_api_logs.rs
pub fn set_response_body<T: Serialize>(&mut self, response: &T) {
match hyperswitch_masking::masked_serialize(response) {
Ok(masked) => {
self.response = Some(masked.to_string());
}
Err(er) => self.set_error(json!({"error": er.to_string()})),
}
}
| {
"chunk": null,
"crate": "interfaces",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": "set_response_body",
"is_async": false,
"is_pub": true,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_fn_interfaces_2042826047251046568 | clm | function | // connector-service/backend/interfaces/src/events/routing_api_logs.rs
pub fn set_error_response_body<T: Serialize>(&mut self, response: &T) {
match hyperswitch_masking::masked_serialize(response) {
Ok(masked) => {
self.error = Some(masked.to_string());
}
Err(er) => self.set_error(json!({"error": er.to_string()})),
}
}
| {
"chunk": null,
"crate": "interfaces",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": "set_error_response_body",
"is_async": false,
"is_pub": true,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_fn_interfaces_-1603415910903849255 | clm | function | // connector-service/backend/interfaces/src/events/routing_api_logs.rs
pub fn set_error(&mut self, error: serde_json::Value) {
self.error = Some(error.to_string());
}
| {
"chunk": null,
"crate": "interfaces",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": "set_error",
"is_async": false,
"is_pub": true,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_fn_interfaces_-2575072780960312138 | clm | function | // connector-service/backend/interfaces/src/events/routing_api_logs.rs
pub fn set_status_code(&mut self, code: u16) {
self.status_code = Some(code);
}
| {
"chunk": null,
"crate": "interfaces",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": "set_status_code",
"is_async": false,
"is_pub": true,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_fn_interfaces_-7174398996036853649 | clm | function | // connector-service/backend/interfaces/src/events/routing_api_logs.rs
pub fn set_routable_connectors(&mut self, connectors: Vec<RoutableConnectorChoice>) {
let connectors = connectors
.into_iter()
.map(|c| {
format!(
"{:?}:{:?}",
c.connector,
c.merchant_connector_id
.map(|id| id.get_string_repr().to_string())
.unwrap_or(String::from(""))
)
})
.collect::<Vec<_>>()
.join(",");
self.routable_connectors = connectors;
}
| {
"chunk": null,
"crate": "interfaces",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": "set_routable_connectors",
"is_async": false,
"is_pub": true,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_fn_interfaces_63904391771406050 | clm | function | // connector-service/backend/interfaces/src/events/routing_api_logs.rs
pub fn set_payment_connector(&mut self, connector: RoutableConnectorChoice) {
self.payment_connector = Some(format!(
"{:?}:{:?}",
connector.connector,
connector
.merchant_connector_id
.map(|id| id.get_string_repr().to_string())
.unwrap_or(String::from(""))
));
}
| {
"chunk": null,
"crate": "interfaces",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": "set_payment_connector",
"is_async": false,
"is_pub": true,
"lines": null,
"method_name": null,
"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.