id stringlengths 20 153 | type stringclasses 1
value | granularity stringclasses 14
values | content stringlengths 16 84.3k | metadata dict |
|---|---|---|---|---|
connector-service_body_grpc-server_-820437466479820270 | clm | function_body | // connector-service/backend/grpc-server/src/configs.rs
// Function: workspace_path
{
if let Ok(manifest_dir) = std::env::var("CARGO_MANIFEST_DIR") {
let mut path = PathBuf::from(manifest_dir);
path.pop();
path.pop();
path
} else {
PathBuf::from(".")
}
}
| {
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": "workspace_path",
"is_async": null,
"is_pub": null,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_body_grpc-server_-5507837353711763143 | clm | function_body | // connector-service/backend/grpc-server/src/main.rs
// Function: main
{
#[cfg(debug_assertions)]
verify_other_config_files();
#[allow(clippy::expect_used)]
let config = configs::Config::new().expect("Failed while parsing config");
let _guard = logger::setup(
&config.log,
grpc_server::service_name!(),
[grpc_server::service_name!(), "grpc_server", "tower_http"],
);
let metrics_server = app::metrics_server_builder(config.clone());
let server = app::server_builder(config);
#[allow(clippy::expect_used)]
tokio::try_join!(metrics_server, server)?;
Ok(())
}
| {
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": "main",
"is_async": null,
"is_pub": null,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_body_grpc-server_697788479093399678 | clm | function_body | // connector-service/backend/grpc-server/src/main.rs
// Function: verify_other_config_files
{
use std::path::PathBuf;
use crate::configs;
let config_file_names = vec!["production.toml", "sandbox.toml"];
let mut config_path = PathBuf::new();
config_path.push(configs::workspace_path());
let config_directory: String = "config".into();
config_path.push(config_directory);
for config_file_name in config_file_names {
config_path.push(config_file_name);
#[allow(clippy::panic)]
let _ = configs::Config::new_with_config_path(Some(config_path.clone()))
.unwrap_or_else(|_| panic!("Update {config_file_name} with the default config values"));
config_path.pop();
}
}
| {
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": "verify_other_config_files",
"is_async": null,
"is_pub": null,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_body_grpc-server_6289209603787135910 | clm | function_body | // connector-service/backend/grpc-server/src/app.rs
// Function: server_builder
{
let server_config = config.server.clone();
let socket_addr = net::SocketAddr::new(server_config.host.parse()?, server_config.port);
// Signal handler
let (tx, rx) = oneshot::channel();
#[allow(clippy::expect_used)]
tokio::spawn(async move {
let mut sig_int =
signal(SignalKind::interrupt()).expect("Failed to initialize SIGINT signal handler");
let mut sig_term =
signal(SignalKind::terminate()).expect("Failed to initialize SIGTERM signal handler");
let mut sig_quit =
signal(SignalKind::quit()).expect("Failed to initialize QUIT signal handler");
let mut sig_hup =
signal(SignalKind::hangup()).expect("Failed to initialize SIGHUP signal handler");
tokio::select! {
_ = sig_int.recv() => {
logger::info!("Received SIGINT");
tx.send(()).expect("Failed to send SIGINT signal");
}
_ = sig_term.recv() => {
logger::info!("Received SIGTERM");
tx.send(()).expect("Failed to send SIGTERM signal");
}
_ = sig_quit.recv() => {
logger::info!("Received QUIT");
tx.send(()).expect("Failed to send QUIT signal");
}
_ = sig_hup.recv() => {
logger::info!("Received SIGHUP");
tx.send(()).expect("Failed to send SIGHUP signal");
}
}
});
#[allow(clippy::expect_used)]
let shutdown_signal = async {
rx.await.expect("Failed to receive shutdown signal");
logger::info!("Shutdown signal received");
};
let service = Service::new(Arc::new(config));
logger::info!(host = %server_config.host, port = %server_config.port, r#type = ?server_config.type_, "starting connector service");
match server_config.type_ {
configs::ServiceType::Grpc => {
service
.await
.grpc_server(socket_addr, shutdown_signal)
.await?
}
configs::ServiceType::Http => {
service
.await
.http_server(socket_addr, shutdown_signal)
.await?
}
}
Ok(())
}
| {
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": "server_builder",
"is_async": null,
"is_pub": null,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_body_grpc-server_-7385361255211914550 | clm | function_body | // connector-service/backend/grpc-server/src/app.rs
// Function: new
{
// Initialize the global EventPublisher - fail fast on startup
if config.events.enabled {
common_utils::init_event_publisher(&config.events)
.expect("Failed to initialize global EventPublisher during startup");
logger::info!("Global EventPublisher initialized successfully");
} else {
logger::info!("EventPublisher disabled in configuration");
}
Self {
health_check_service: crate::server::health_check::HealthCheck,
payments_service: crate::server::payments::Payments {
config: Arc::clone(&config),
},
refunds_service: crate::server::refunds::Refunds {
config: Arc::clone(&config),
},
disputes_service: crate::server::disputes::Disputes { config },
}
}
| {
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": "new",
"is_async": null,
"is_pub": null,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_body_grpc-server_1459415815262552632 | clm | function_body | // connector-service/backend/grpc-server/src/app.rs
// Function: http_server
{
let logging_layer = tower_trace::TraceLayer::new_for_http()
.make_span_with(|request: &Request<_>| utils::record_fields_from_header(request))
.on_request(tower_trace::DefaultOnRequest::new().level(tracing::Level::INFO))
.on_response(
tower_trace::DefaultOnResponse::new()
.level(tracing::Level::INFO)
.latency_unit(tower_http::LatencyUnit::Micros),
)
.on_failure(
tower_trace::DefaultOnFailure::new()
.latency_unit(tower_http::LatencyUnit::Micros)
.level(tracing::Level::ERROR),
);
let request_id_layer = tower_http::request_id::SetRequestIdLayer::new(
http::HeaderName::from_static(consts::X_REQUEST_ID),
MakeRequestUuid,
);
let propagate_request_id_layer = tower_http::request_id::PropagateRequestIdLayer::new(
http::HeaderName::from_static(consts::X_REQUEST_ID),
);
let router = axum::Router::new()
.route("/health", axum::routing::get(|| async { "health is good" }))
.merge(payment_service_handler(self.payments_service))
.merge(refund_service_handler(self.refunds_service))
.merge(dispute_service_handler(self.disputes_service))
.layer(logging_layer)
.layer(request_id_layer)
.layer(propagate_request_id_layer);
let listener = tokio::net::TcpListener::bind(socket).await?;
axum::serve(listener, router.into_make_service())
.with_graceful_shutdown(shutdown_signal)
.await?;
Ok(())
}
| {
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": "http_server",
"is_async": null,
"is_pub": null,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_body_grpc-server_-4334339212374080029 | clm | function_body | // connector-service/backend/grpc-server/src/app.rs
// Function: grpc_server
{
let reflection_service = tonic_reflection::server::Builder::configure()
.register_encoded_file_descriptor_set(grpc_api_types::FILE_DESCRIPTOR_SET)
.build_v1()?;
let logging_layer = tower_trace::TraceLayer::new_for_http()
.make_span_with(|request: &http::request::Request<_>| {
utils::record_fields_from_header(request)
})
.on_request(tower_trace::DefaultOnRequest::new().level(tracing::Level::INFO))
.on_response(
tower_trace::DefaultOnResponse::new()
.level(tracing::Level::INFO)
.latency_unit(tower_http::LatencyUnit::Micros),
)
.on_failure(
tower_trace::DefaultOnFailure::new()
.latency_unit(tower_http::LatencyUnit::Micros)
.level(tracing::Level::ERROR),
);
let metrics_layer = metrics::GrpcMetricsLayer::new();
let request_id_layer = tower_http::request_id::SetRequestIdLayer::new(
http::HeaderName::from_static(consts::X_REQUEST_ID),
MakeRequestUuid,
);
let propagate_request_id_layer = tower_http::request_id::PropagateRequestIdLayer::new(
http::HeaderName::from_static(consts::X_REQUEST_ID),
);
Server::builder()
.layer(logging_layer)
.layer(request_id_layer)
.layer(propagate_request_id_layer)
.layer(metrics_layer)
.add_service(reflection_service)
.add_service(health_server::HealthServer::new(self.health_check_service))
.add_service(payment_service_server::PaymentServiceServer::new(
self.payments_service.clone(),
))
.add_service(refund_service_server::RefundServiceServer::new(
self.refunds_service,
))
.add_service(dispute_service_server::DisputeServiceServer::new(
self.disputes_service,
))
.serve_with_shutdown(socket, shutdown_signal)
.await?;
Ok(())
}
| {
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": "grpc_server",
"is_async": null,
"is_pub": null,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_body_grpc-server_-951835017135363923 | clm | function_body | // connector-service/backend/grpc-server/src/app.rs
// Function: metrics_server_builder
{
let listener = config.metrics.tcp_listener().await?;
let router = axum::Router::new().route(
"/metrics",
axum::routing::get(|| async {
let output = metrics::metrics_handler().await;
match output {
Ok(metrics) => Ok(metrics),
Err(error) => {
tracing::error!(?error, "Error fetching metrics");
Err((
http::StatusCode::INTERNAL_SERVER_ERROR,
"Error fetching metrics".to_string(),
))
}
}
}),
);
axum::serve(listener, router.into_make_service())
.with_graceful_shutdown(async {
let output = tokio::signal::ctrl_c().await;
tracing::error!(?output, "shutting down");
})
.await?;
Ok(())
}
| {
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": "metrics_server_builder",
"is_async": null,
"is_pub": null,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_body_grpc-server_-5374375827544403861 | clm | function_body | // connector-service/backend/grpc-server/src/utils.rs
// Function: flow_marker_to_flow_name
{
let type_id = std::any::TypeId::of::<F>();
if type_id == std::any::TypeId::of::<Authorize>() {
FlowName::Authorize
} else if type_id == std::any::TypeId::of::<PSync>() {
FlowName::Psync
} else if type_id == std::any::TypeId::of::<RSync>() {
FlowName::Rsync
} else if type_id == std::any::TypeId::of::<Void>() {
FlowName::Void
} else if type_id == std::any::TypeId::of::<VoidPC>() {
FlowName::VoidPostCapture
} else if type_id == std::any::TypeId::of::<Refund>() {
FlowName::Refund
} else if type_id == std::any::TypeId::of::<Capture>() {
FlowName::Capture
} else if type_id == std::any::TypeId::of::<SetupMandate>() {
FlowName::SetupMandate
} else if type_id == std::any::TypeId::of::<RepeatPayment>() {
FlowName::RepeatPayment
} else if type_id == std::any::TypeId::of::<CreateOrder>() {
FlowName::CreateOrder
} else if type_id == std::any::TypeId::of::<CreateSessionToken>() {
FlowName::CreateSessionToken
} else if type_id == std::any::TypeId::of::<Accept>() {
FlowName::AcceptDispute
} else if type_id == std::any::TypeId::of::<DefendDispute>() {
FlowName::DefendDispute
} else if type_id == std::any::TypeId::of::<SubmitEvidence>() {
FlowName::SubmitEvidence
} else if type_id == std::any::TypeId::of::<PaymentMethodToken>() {
FlowName::PaymentMethodToken
} else if type_id == std::any::TypeId::of::<PreAuthenticate>() {
FlowName::PreAuthenticate
} else if type_id == std::any::TypeId::of::<Authenticate>() {
FlowName::Authenticate
} else if type_id == std::any::TypeId::of::<PostAuthenticate>() {
FlowName::PostAuthenticate
} else {
tracing::warn!("Unknown flow marker type: {}", std::any::type_name::<F>());
FlowName::Unknown
}
}
| {
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": "flow_marker_to_flow_name",
"is_async": null,
"is_pub": null,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_body_grpc-server_-6909641310110877439 | clm | function_body | // connector-service/backend/grpc-server/src/utils.rs
// Function: extract_lineage_fields_from_metadata
{
if !config.enabled {
return LineageIds::empty(&config.field_prefix).to_owned();
}
metadata
.get(&config.header_name)
.and_then(|value| value.to_str().ok())
.map(|header_value| LineageIds::new(&config.field_prefix, header_value))
.transpose()
.inspect(|value| {
tracing::info!(
parsed_fields = ?value,
"Successfully parsed lineage header"
)
})
.inspect_err(|err| {
tracing::warn!(
error = %err,
"Failed to parse lineage header, continuing without lineage fields"
)
})
.ok()
.flatten()
.unwrap_or_else(|| LineageIds::empty(&config.field_prefix))
.to_owned()
}
| {
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": "extract_lineage_fields_from_metadata",
"is_async": null,
"is_pub": null,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_body_grpc-server_9127893895694593621 | clm | function_body | // connector-service/backend/grpc-server/src/utils.rs
// Function: record_fields_from_header
{
let url_path = request.uri().path();
let span = tracing::debug_span!(
"request",
uri = %url_path,
version = ?request.version(),
tenant_id = tracing::field::Empty,
request_id = tracing::field::Empty,
);
request
.headers()
.get(consts::X_TENANT_ID)
.and_then(|value| value.to_str().ok())
.map(|tenant_id| span.record("tenant_id", tenant_id));
request
.headers()
.get(consts::X_REQUEST_ID)
.and_then(|value| value.to_str().ok())
.map(|request_id| span.record("request_id", request_id));
span
}
| {
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": "record_fields_from_header",
"is_async": null,
"is_pub": null,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_body_grpc-server_-294474479787911615 | clm | function_body | // connector-service/backend/grpc-server/src/utils.rs
// Function: get_metadata_payload
{
let connector = connector_from_metadata(metadata)?;
let merchant_id = merchant_id_from_metadata(metadata)?;
let tenant_id = tenant_id_from_metadata(metadata)?;
let request_id = request_id_from_metadata(metadata)?;
let lineage_ids = extract_lineage_fields_from_metadata(metadata, &server_config.lineage);
let connector_auth_type = auth_from_metadata(metadata)?;
let reference_id = reference_id_from_metadata(metadata)?;
let shadow_mode = shadow_mode_from_metadata(metadata);
Ok(MetadataPayload {
tenant_id,
request_id,
merchant_id,
connector,
lineage_ids,
connector_auth_type,
reference_id,
shadow_mode,
})
}
| {
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": "get_metadata_payload",
"is_async": null,
"is_pub": null,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_body_grpc-server_428821496449645434 | clm | function_body | // connector-service/backend/grpc-server/src/utils.rs
// Function: connector_from_metadata
{
parse_metadata(metadata, consts::X_CONNECTOR_NAME).and_then(|inner| {
connector_types::ConnectorEnum::from_str(inner).map_err(|e| {
Report::new(ApplicationErrorResponse::BadRequest(ApiError {
sub_code: "INVALID_CONNECTOR".to_string(),
error_identifier: 400,
error_message: format!("Invalid connector: {e}"),
error_object: None,
}))
})
})
}
| {
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": "connector_from_metadata",
"is_async": null,
"is_pub": null,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_body_grpc-server_7616680197003847023 | clm | function_body | // connector-service/backend/grpc-server/src/utils.rs
// Function: merchant_id_from_metadata
{
parse_metadata(metadata, consts::X_MERCHANT_ID)
.map(|inner| inner.to_string())
.map_err(|e| {
Report::new(ApplicationErrorResponse::BadRequest(ApiError {
sub_code: "MISSING_MERCHANT_ID".to_string(),
error_identifier: 400,
error_message: format!("Missing merchant ID in request metadata: {e}"),
error_object: None,
}))
})
}
| {
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": "merchant_id_from_metadata",
"is_async": null,
"is_pub": null,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_body_grpc-server_-2951952758979057258 | clm | function_body | // connector-service/backend/grpc-server/src/utils.rs
// Function: request_id_from_metadata
{
parse_metadata(metadata, consts::X_REQUEST_ID)
.map(|inner| inner.to_string())
.map_err(|e| {
Report::new(ApplicationErrorResponse::BadRequest(ApiError {
sub_code: "MISSING_REQUEST_ID".to_string(),
error_identifier: 400,
error_message: format!("Missing request ID in request metadata: {e}"),
error_object: None,
}))
})
}
| {
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": "request_id_from_metadata",
"is_async": null,
"is_pub": null,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_body_grpc-server_-4570867008774434432 | clm | function_body | // connector-service/backend/grpc-server/src/utils.rs
// Function: tenant_id_from_metadata
{
parse_metadata(metadata, consts::X_TENANT_ID)
.map(|s| s.to_string())
.or_else(|_| Ok("DefaultTenantId".to_string()))
}
| {
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": "tenant_id_from_metadata",
"is_async": null,
"is_pub": null,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_body_grpc-server_-356012050329656718 | clm | function_body | // connector-service/backend/grpc-server/src/utils.rs
// Function: shadow_mode_from_metadata
{
parse_optional_metadata(metadata, X_SHADOW_MODE)
.ok()
.flatten()
.map(|value| value.to_lowercase() == "true")
.unwrap_or(false)
}
| {
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": "shadow_mode_from_metadata",
"is_async": null,
"is_pub": null,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_body_grpc-server_7752344221358907922 | clm | function_body | // connector-service/backend/grpc-server/src/utils.rs
// Function: auth_from_metadata
{
let auth = parse_metadata(metadata, X_AUTH)?;
#[allow(clippy::wildcard_in_or_patterns)]
match auth {
"header-key" => Ok(ConnectorAuthType::HeaderKey {
api_key: parse_metadata(metadata, X_API_KEY)?.to_string().into(),
}),
"body-key" => Ok(ConnectorAuthType::BodyKey {
api_key: parse_metadata(metadata, X_API_KEY)?.to_string().into(),
key1: parse_metadata(metadata, X_KEY1)?.to_string().into(),
}),
"signature-key" => Ok(ConnectorAuthType::SignatureKey {
api_key: parse_metadata(metadata, X_API_KEY)?.to_string().into(),
key1: parse_metadata(metadata, X_KEY1)?.to_string().into(),
api_secret: parse_metadata(metadata, X_API_SECRET)?.to_string().into(),
}),
"multi-auth-key" => Ok(ConnectorAuthType::MultiAuthKey {
api_key: parse_metadata(metadata, X_API_KEY)?.to_string().into(),
key1: parse_metadata(metadata, X_KEY1)?.to_string().into(),
key2: parse_metadata(metadata, X_KEY2)?.to_string().into(),
api_secret: parse_metadata(metadata, X_API_SECRET)?.to_string().into(),
}),
"no-key" => Ok(ConnectorAuthType::NoKey),
"temporary-auth" => Ok(ConnectorAuthType::TemporaryAuth),
"currency-auth-key" => {
let auth_key_map_str = parse_metadata(metadata, X_AUTH_KEY_MAP)?;
let auth_key_map: HashMap<
common_enums::enums::Currency,
common_utils::pii::SecretSerdeValue,
> = serde_json::from_str(auth_key_map_str).change_context(
ApplicationErrorResponse::BadRequest(ApiError {
sub_code: "INVALID_AUTH_KEY_MAP".to_string(),
error_identifier: 400,
error_message: "Invalid auth-key-map format".to_string(),
error_object: None,
}),
)?;
Ok(ConnectorAuthType::CurrencyAuthKey { auth_key_map })
}
"certificate-auth" | _ => Err(Report::new(ApplicationErrorResponse::BadRequest(
ApiError {
sub_code: "INVALID_AUTH_TYPE".to_string(),
error_identifier: 400,
error_message: format!("Invalid auth type: {auth}"),
error_object: None,
},
))),
}
}
| {
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": "auth_from_metadata",
"is_async": null,
"is_pub": null,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_body_grpc-server_8474006838814552387 | clm | function_body | // connector-service/backend/grpc-server/src/utils.rs
// Function: parse_metadata
{
metadata
.get(key)
.ok_or_else(|| {
Report::new(ApplicationErrorResponse::BadRequest(ApiError {
sub_code: "MISSING_METADATA".to_string(),
error_identifier: 400,
error_message: format!("Missing {key} in request metadata"),
error_object: None,
}))
})
.and_then(|value| {
value.to_str().map_err(|e| {
Report::new(ApplicationErrorResponse::BadRequest(ApiError {
sub_code: "INVALID_METADATA".to_string(),
error_identifier: 400,
error_message: format!("Invalid {key} in request metadata: {e}"),
error_object: None,
}))
})
})
}
| {
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": "parse_metadata",
"is_async": null,
"is_pub": null,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_body_grpc-server_7781144718467377355 | clm | function_body | // connector-service/backend/grpc-server/src/utils.rs
// Function: parse_optional_metadata
{
metadata
.get(key)
.map(|value| value.to_str())
.transpose()
.map_err(|e| {
Report::new(ApplicationErrorResponse::BadRequest(ApiError {
sub_code: "INVALID_METADATA".to_string(),
error_identifier: 400,
error_message: format!("Invalid {key} in request metadata: {e}"),
error_object: None,
}))
})
}
| {
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": "parse_optional_metadata",
"is_async": null,
"is_pub": null,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_body_grpc-server_3845593455049650327 | clm | function_body | // connector-service/backend/grpc-server/src/utils.rs
// Function: log_before_initialization
{
let metadata_payload = &request_data.extracted_metadata;
let MetadataPayload {
connector,
merchant_id,
tenant_id,
request_id,
..
} = metadata_payload;
let current_span = tracing::Span::current();
let req_body_json = match hyperswitch_masking::masked_serialize(&request_data.payload) {
Ok(masked_value) => masked_value.to_string(),
Err(e) => {
tracing::error!("Masked serialization error: {:?}", e);
"<masked serialization error>".to_string()
}
};
current_span.record("service_name", service_name);
current_span.record("request_body", req_body_json);
current_span.record("gateway", connector.to_string());
current_span.record("merchant_id", merchant_id);
current_span.record("tenant_id", tenant_id);
current_span.record("request_id", request_id);
tracing::info!("Golden Log Line (incoming)");
Ok(())
}
| {
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": "log_before_initialization",
"is_async": null,
"is_pub": null,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_body_grpc-server_-1382139200920325231 | clm | function_body | // connector-service/backend/grpc-server/src/utils.rs
// Function: log_after_initialization
{
let current_span = tracing::Span::current();
// let duration = start_time.elapsed().as_millis();
// current_span.record("response_time", duration);
match &result {
Ok(response) => {
current_span.record("response_body", tracing::field::debug(response.get_ref()));
let res_ref = response.get_ref();
// Try converting to JSON Value
if let Ok(serde_json::Value::Object(map)) = serde_json::to_value(res_ref) {
if let Some(status_val) = map.get("status") {
let status_num_opt = status_val.as_number();
let status_u32_opt: Option<u32> = status_num_opt
.and_then(|n| n.as_u64())
.and_then(|n| u32::try_from(n).ok());
let status_str = if let Some(s) = status_u32_opt {
common_enums::AttemptStatus::try_from(s)
.unwrap_or(common_enums::AttemptStatus::Unknown)
.to_string()
} else {
common_enums::AttemptStatus::Unknown.to_string()
};
current_span.record("flow_specific_fields.status", status_str);
}
} else {
tracing::warn!("Could not serialize response to JSON to extract status");
}
}
Err(status) => {
current_span.record("error_message", status.message());
current_span.record("status_code", status.code().to_string());
}
}
tracing::info!("Golden Log Line (incoming)");
}
| {
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": "log_after_initialization",
"is_async": null,
"is_pub": null,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_body_grpc-server_-5489667756637080977 | clm | function_body | // connector-service/backend/grpc-server/src/utils.rs
// Function: grpc_logging_wrapper
{
let current_span = tracing::Span::current();
let start_time = tokio::time::Instant::now();
let masked_request_data =
MaskedSerdeValue::from_masked_optional(request.get_ref(), "grpc_request");
let mut event_metadata_payload = None;
let mut event_headers = HashMap::new();
let grpc_response = async {
let request_data = RequestData::from_grpc_request(request, config.clone())?;
log_before_initialization(&request_data, service_name).into_grpc_status()?;
event_headers = request_data.masked_metadata.get_all_masked();
event_metadata_payload = Some(request_data.extracted_metadata.clone());
let result = handler(request_data).await;
let duration = start_time.elapsed().as_millis();
current_span.record("response_time", duration);
log_after_initialization(&result);
result
}
.await;
create_and_emit_grpc_event(
masked_request_data,
&grpc_response,
start_time,
flow_name,
&config,
event_metadata_payload.as_ref(),
event_headers,
);
grpc_response
}
| {
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": "grpc_logging_wrapper",
"is_async": null,
"is_pub": null,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_body_grpc-server_-4177316352647460377 | clm | function_body | // connector-service/backend/grpc-server/src/utils.rs
// Function: create_and_emit_grpc_event
{
let mut grpc_event = Event {
request_id: metadata_payload.map_or("unknown".to_string(), |md| md.request_id.clone()),
timestamp: chrono::Utc::now().timestamp().into(),
flow_type: flow_name,
connector: metadata_payload.map_or("unknown".to_string(), |md| md.connector.to_string()),
url: None,
stage: EventStage::GrpcRequest,
latency_ms: Some(u64::try_from(start_time.elapsed().as_millis()).unwrap_or(u64::MAX)),
status_code: None,
request_data: masked_request_data,
response_data: None,
headers: masked_headers,
additional_fields: HashMap::new(),
lineage_ids: metadata_payload
.map_or_else(|| LineageIds::empty(""), |md| md.lineage_ids.clone()),
};
grpc_event
.add_reference_id(metadata_payload.and_then(|metadata| metadata.reference_id.as_deref()));
match grpc_response {
Ok(response) => grpc_event.set_grpc_success_response(response.get_ref()),
Err(error) => grpc_event.set_grpc_error_response(error),
}
common_utils::emit_event_with_config(grpc_event, &config.events);
}
| {
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": "create_and_emit_grpc_event",
"is_async": null,
"is_pub": null,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_body_grpc-server_7081623782602058468 | clm | function_body | // connector-service/backend/grpc-server/src/logger/config.rs
// Function: deserialize
{
use std::str::FromStr as _;
let s = String::deserialize(deserializer)?;
tracing::Level::from_str(&s)
.map(Level)
.map_err(serde::de::Error::custom)
}
| {
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": "deserialize",
"is_async": null,
"is_pub": null,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_body_grpc-server_3346182125838728549 | clm | function_body | // connector-service/backend/grpc-server/src/logger/formatter.rs
// Function: fmt
{
let repr = match self {
Self::EnterSpan => "START",
Self::ExitSpan => "END",
Self::Event => "EVENT",
};
write!(f, "{repr}")
}
| {
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": "fmt",
"is_async": null,
"is_pub": null,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_body_grpc-server_-3830295597616003397 | clm | function_body | // connector-service/backend/grpc-server/src/logger/formatter.rs
// Function: new_with_implicit_entries
{
let pid = std::process::id();
let hostname = gethostname::gethostname().to_string_lossy().into_owned();
let service = service.to_string();
default_fields.retain(|key, value| {
if !IMPLICIT_KEYS.contains(key.as_str()) {
true
} else {
#[allow(clippy::print_stderr)]
{
eprintln!(
"Attempting to log a reserved entry. It won't be added to the logs. key: {:?}, value: {:?}",
key, value);
}
false
}
});
Self {
dst_writer,
pid,
hostname,
service,
default_fields,
}
}
| {
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": "new_with_implicit_entries",
"is_async": null,
"is_pub": null,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_body_grpc-server_-5413640562320834654 | clm | function_body | // connector-service/backend/grpc-server/src/logger/formatter.rs
// Function: common_serialize
{
let is_extra = |s: &str| !IMPLICIT_KEYS.contains(s);
map_serializer.serialize_entry(HOSTNAME, &self.hostname)?;
map_serializer.serialize_entry(PID, &self.pid)?;
map_serializer.serialize_entry(LEVEL, &format_args!("{}", metadata.level()))?;
map_serializer.serialize_entry(TARGET, metadata.target())?;
map_serializer.serialize_entry(SERVICE, &self.service)?;
map_serializer.serialize_entry(LINE, &metadata.line())?;
map_serializer.serialize_entry(FILE, &metadata.file())?;
map_serializer.serialize_entry(FN, name)?;
map_serializer
.serialize_entry(FULL_NAME, &format_args!("{}::{}", metadata.target(), name))?;
if let Ok(time) = &time::OffsetDateTime::now_utc().format(&Iso8601::DEFAULT) {
map_serializer.serialize_entry(TIME, time)?;
}
// Write down implicit default entries.
for (key, value) in self.default_fields.iter() {
map_serializer.serialize_entry(key, value)?;
}
let mut explicit_entries_set: HashSet<&str> = HashSet::default();
// Write down explicit event's entries.
for (key, value) in storage.values.iter() {
map_serializer.serialize_entry(key, value)?;
explicit_entries_set.insert(key);
}
// Write down entries from the span, if it exists.
if let Some(span) = &span {
let extensions = span.extensions();
if let Some(visitor) = extensions.get::<Storage<'_>>() {
for (key, value) in &visitor.values {
if is_extra(key) && !explicit_entries_set.contains(key) {
map_serializer.serialize_entry(key, value)?;
} else {
#[allow(clippy::print_stderr)]
{
eprintln!(
"Attempting to log a reserved entry. It won't be added to the logs. key: {key:?}, value: {value:?}"
);
}
}
}
}
}
Ok(())
}
| {
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": "common_serialize",
"is_async": null,
"is_pub": null,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_body_grpc-server_-2789373339398203576 | clm | function_body | // connector-service/backend/grpc-server/src/logger/formatter.rs
// Function: span_serialize
{
let mut buffer = Vec::new();
let mut serializer = serde_json::Serializer::new(&mut buffer);
let mut map_serializer = serializer.serialize_map(None)?;
let message = Self::span_message(span, ty);
let mut storage = Storage::default();
storage.record_value(MESSAGE, message.into());
self.common_serialize(
&mut map_serializer,
span.metadata(),
Some(span),
&storage,
span.name(),
)?;
map_serializer.end()?;
Ok(buffer)
}
| {
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": "span_serialize",
"is_async": null,
"is_pub": null,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_body_grpc-server_-2536802501550453707 | clm | function_body | // connector-service/backend/grpc-server/src/logger/formatter.rs
// Function: event_serialize
{
let mut buffer = Vec::new();
let mut serializer = serde_json::Serializer::new(&mut buffer);
let mut map_serializer = serializer.serialize_map(None)?;
let mut storage = Storage::default();
event.record(&mut storage);
let name = span.map_or("?", SpanRef::name);
Self::event_message(span, event, &mut storage);
self.common_serialize(&mut map_serializer, event.metadata(), *span, &storage, name)?;
map_serializer.end()?;
Ok(buffer)
}
| {
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": "event_serialize",
"is_async": null,
"is_pub": null,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_body_grpc-server_4561409223824187208 | clm | function_body | // connector-service/backend/grpc-server/src/logger/formatter.rs
// Function: event_message
{
let message = storage
.values
.entry(MESSAGE)
.or_insert_with(|| event.metadata().target().into());
// Prepend the span name to the message if span exists.
if let (Some(span), Value::String(a)) = (span, message) {
*a = format!("{} {}", Self::span_message(span, RecordType::Event), a,);
}
}
| {
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": "event_message",
"is_async": null,
"is_pub": null,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_body_grpc-server_-8507220926345532004 | clm | function_body | // connector-service/backend/grpc-server/src/logger/formatter.rs
// Function: on_event
{
// Event could have no span.
let span = ctx.lookup_current();
let result: std::io::Result<Vec<u8>> = self.event_serialize(&span.as_ref(), event);
if let Ok(formatted) = result {
let _ = self.flush(formatted);
}
}
| {
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": "on_event",
"is_async": null,
"is_pub": null,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_body_grpc-server_3101933580739936863 | clm | function_body | // connector-service/backend/grpc-server/src/logger/formatter.rs
// Function: on_enter
{
let span = ctx.span(id).expect("No span");
if let Ok(serialized) = self.span_serialize(&span, RecordType::EnterSpan) {
let _ = self.flush(serialized);
}
}
| {
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": "on_enter",
"is_async": null,
"is_pub": null,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_body_grpc-server_2863772409473158122 | clm | function_body | // connector-service/backend/grpc-server/src/logger/formatter.rs
// Function: on_close
{
let span = ctx.span(&id).expect("No span");
if let Ok(serialized) = self.span_serialize(&span, RecordType::ExitSpan) {
let _ = self.flush(serialized);
}
}
| {
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": "on_close",
"is_async": null,
"is_pub": null,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_body_grpc-server_-4940289520477183831 | clm | function_body | // connector-service/backend/grpc-server/src/logger/storage.rs
// Function: record_value
{
if super::formatter::IMPLICIT_KEYS.contains(key) {
#[allow(clippy::print_stderr)]
{
eprintln!("{key} is a reserved entry. Skipping it. value: {value}");
}
} else {
self.values.insert(key, value);
}
}
| {
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": "record_value",
"is_async": null,
"is_pub": null,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_body_grpc-server_-8698230775447774764 | clm | function_body | // connector-service/backend/grpc-server/src/logger/storage.rs
// Function: record_debug
{
match field.name() {
// Skip fields which are already handled
name if name.starts_with("log.") => (),
name if name.starts_with("r#") => {
self.record_value(&name[2..], serde_json::Value::from(format!("{value:?}")));
}
name => {
self.record_value(name, serde_json::Value::from(format!("{value:?}")));
}
};
}
| {
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": "record_debug",
"is_async": null,
"is_pub": null,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_body_grpc-server_6754094979629940676 | clm | function_body | // connector-service/backend/grpc-server/src/logger/storage.rs
// Function: on_new_span
{
let span = ctx.span(id).expect("No span");
let mut visitor = if let Some(parent_span) = span.parent() {
let mut extensions = parent_span.extensions_mut();
extensions
.get_mut::<Storage<'_>>()
.map(|v| v.to_owned())
.unwrap_or_default()
} else {
Storage::default()
};
let mut extensions = span.extensions_mut();
attrs.record(&mut visitor);
extensions.insert(visitor);
}
| {
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": "on_new_span",
"is_async": null,
"is_pub": null,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_body_grpc-server_5046648895714353419 | clm | function_body | // connector-service/backend/grpc-server/src/logger/storage.rs
// Function: on_record
{
let span = ctx.span(span).expect("No span");
let mut extensions = span.extensions_mut();
let visitor = extensions
.get_mut::<Storage<'_>>()
.expect("The span does not have storage");
values.record(visitor);
}
| {
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": "on_record",
"is_async": null,
"is_pub": null,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_body_grpc-server_5213610293517403766 | clm | function_body | // connector-service/backend/grpc-server/src/logger/storage.rs
// Function: on_enter
{
let span = ctx.span(span).expect("No span");
let mut extensions = span.extensions_mut();
if extensions.get_mut::<Instant>().is_none() {
extensions.insert(Instant::now());
}
}
| {
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": "on_enter",
"is_async": null,
"is_pub": null,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_body_grpc-server_6827489759571336852 | clm | function_body | // connector-service/backend/grpc-server/src/logger/storage.rs
// Function: on_close
{
let span = ctx.span(&span).expect("No span");
let elapsed_milliseconds = {
let extensions = span.extensions();
extensions
.get::<Instant>()
.map(|i| i.elapsed().as_millis())
.unwrap_or(0)
};
let mut extensions_mut = span.extensions_mut();
let visitor = extensions_mut
.get_mut::<Storage<'_>>()
.expect("No visitor in extensions");
if let Ok(elapsed) = serde_json::to_value(elapsed_milliseconds) {
visitor.record_value("elapsed_milliseconds", elapsed);
}
}
| {
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": "on_close",
"is_async": null,
"is_pub": null,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_body_grpc-server_4655584661241494246 | clm | function_body | // connector-service/backend/grpc-server/src/logger/setup.rs
// Function: setup
{
let static_top_level_fields = HashMap::from_iter([
("service".to_string(), serde_json::json!(service_name)),
(
"build_version".to_string(),
serde_json::json!(crate::version!()),
),
]);
let console_config = if config.console.enabled {
let console_filter_directive =
config
.console
.filtering_directive
.clone()
.unwrap_or_else(|| {
get_envfilter_directive(
tracing::Level::WARN,
config.console.level.into_level(),
crates_to_filter.as_ref(),
)
});
let log_format = match config.console.log_format {
config::LogFormat::Default => log_utils::ConsoleLogFormat::HumanReadable,
config::LogFormat::Json => {
// Disable color or emphasis related ANSI escape codes for JSON formats
error_stack::Report::set_color_mode(error_stack::fmt::ColorMode::None);
log_utils::ConsoleLogFormat::CompactJson
}
};
Some(log_utils::ConsoleLoggingConfig {
level: config.console.level.into_level(),
log_format,
filtering_directive: Some(console_filter_directive),
print_filtering_directive: log_utils::DirectivePrintTarget::Stderr,
})
} else {
None
};
let logger_config = log_utils::LoggerConfig {
static_top_level_fields: static_top_level_fields.clone(),
top_level_keys: HashSet::new(),
persistent_keys: HashSet::new(),
log_span_lifecycles: true,
additional_fields_placement: log_utils::AdditionalFieldsPlacement::TopLevel,
file_config: None,
console_config,
global_filtering_directive: None,
};
let logging_components = log_utils::build_logging_components(logger_config)?;
let mut subscriber_layers = Vec::new();
subscriber_layers.push(logging_components.storage_layer.boxed());
if let Some(console_layer) = logging_components.console_log_layer {
subscriber_layers.push(console_layer);
}
#[allow(unused_mut)]
let mut kafka_logging_enabled = false;
// Add Kafka layer if configured
#[cfg(feature = "kafka")]
if let Some(kafka_config) = &config.kafka {
if kafka_config.enabled {
// Initialize kafka metrics if the feature is enabled.
// This will cause the application to panic at startup if metric registration fails.
tracing_kafka::init();
let kafka_filter_directive =
kafka_config.filtering_directive.clone().unwrap_or_else(|| {
get_envfilter_directive(
tracing::Level::WARN,
kafka_config.level.into_level(),
crates_to_filter.as_ref(),
)
});
let brokers: Vec<&str> = kafka_config.brokers.iter().map(|s| s.as_str()).collect();
let mut builder = KafkaLayer::builder()
.brokers(&brokers)
.topic(&kafka_config.topic)
.static_fields(static_top_level_fields.clone());
// Add batch_size if configured
if let Some(batch_size) = kafka_config.batch_size {
builder = builder.batch_size(batch_size);
}
// Add flush_interval_ms if configured
if let Some(flush_interval_ms) = kafka_config.flush_interval_ms {
builder = builder.linger_ms(flush_interval_ms);
}
// Add buffer_limit if configured
if let Some(buffer_limit) = kafka_config.buffer_limit {
builder = builder.queue_buffering_max_messages(buffer_limit);
}
let kafka_layer = match builder.build() {
Ok(layer) => {
// Create filter with infinite feedback loop prevention
let kafka_filter_directive = format!(
"{kafka_filter_directive},rdkafka=off,librdkafka=off,kafka=off,kafka_writer=off,tracing_kafka=off",
);
let kafka_filter = tracing_subscriber::EnvFilter::builder()
.with_default_directive(kafka_config.level.into_level().into())
.parse_lossy(kafka_filter_directive);
Some(layer.with_filter(kafka_filter))
}
Err(e) => {
tracing::warn!(error = ?e, "Failed to enable Kafka logging");
// Continue without Kafka
None
}
};
if let Some(layer) = kafka_layer {
subscriber_layers.push(layer.boxed());
kafka_logging_enabled = true;
tracing::info!(topic = %kafka_config.topic, "Kafka logging enabled");
}
}
}
tracing_subscriber::registry()
.with(subscriber_layers)
.init();
tracing::info!(
service_name,
build_version = crate::version!(),
kafka_logging_enabled,
"Logging subsystem initialized"
);
// Returning the TelemetryGuard for logs to be printed and metrics to be collected until it is
// dropped
Ok(TelemetryGuard {
_log_guards: logging_components.guards,
})
}
| {
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": "setup",
"is_async": null,
"is_pub": null,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_body_grpc-server_-3157941024589326988 | clm | function_body | // connector-service/backend/grpc-server/src/logger/setup.rs
// Function: get_envfilter_directive
{
let mut explicitly_handled_targets = build_info::cargo_workspace_members!();
explicitly_handled_targets.extend(build_info::framework_libs_workspace_members());
explicitly_handled_targets.extend(crates_to_filter.as_ref());
// +1 for the default log level added as a directive
let num_directives = explicitly_handled_targets.len() + 1;
explicitly_handled_targets
.into_iter()
.map(|crate_name| crate_name.replace('-', "_"))
.zip(std::iter::repeat(filter_log_level))
.fold(
{
let mut directives = Vec::with_capacity(num_directives);
directives.push(default_log_level.to_string());
directives
},
|mut directives, (target, level)| {
directives.push(format!("{target}={level}"));
directives
},
)
.join(",")
}
| {
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": "get_envfilter_directive",
"is_async": null,
"is_pub": null,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_body_grpc-server_1142864864411545878 | clm | function_body | // connector-service/backend/grpc-server/src/server/refunds.rs
// Function: get
{
let service_name = request
.extensions()
.get::<String>()
.cloned()
.unwrap_or_else(|| "RefundService".to_string());
utils::grpc_logging_wrapper(
request,
&service_name,
self.config.clone(),
common_utils::events::FlowName::Rsync,
|request_data| async move { self.internal_get(request_data).await },
)
.await
}
| {
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": "get",
"is_async": null,
"is_pub": null,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_body_grpc-server_4320284921816181955 | clm | function_body | // connector-service/backend/grpc-server/src/server/refunds.rs
// Function: transform
{
let service_name = request
.extensions()
.get::<String>()
.cloned()
.unwrap_or_else(|| "RefundService".to_string());
utils::grpc_logging_wrapper(
request,
&service_name,
self.config.clone(),
common_utils::events::FlowName::IncomingWebhook,
|request_data| async move {
let payload = request_data.payload;
let connector = request_data.extracted_metadata.connector;
let connector_auth_details = request_data.extracted_metadata.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
.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_refunds_webhook_content(
connector_data,
request_details,
webhook_secrets,
Some(connector_auth_details),
)
.await
.map_err(|e| e.into_grpc_status())?;
let response = RefundServiceTransformResponse {
event_type: WebhookEventType::WebhookRefundSuccess.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": null,
"is_pub": null,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_body_grpc-server_1572383730327193971 | clm | function_body | // connector-service/backend/grpc-server/src/server/refunds.rs
// Function: get_refunds_webhook_content
{
let webhook_details = connector_data
.connector
.process_refund_webhook(request_details, webhook_secrets, connector_auth_details)
.switch()?;
// Generate 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(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": null,
"is_pub": null,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_body_grpc-server_7547660236758709169 | clm | function_body | // connector-service/backend/grpc-server/src/server/payments.rs
// Function: to_token_data_with_vault
{
let card_data = CardTokenData {
card_number: self
.card_number
.as_ref()
.map(|cn| cn.to_string())
.unwrap_or_default(),
cvv: self
.card_cvc
.as_ref()
.map(|cvc| cvc.clone().expose().to_string())
.unwrap_or_default(),
exp_month: self
.card_exp_month
.as_ref()
.map(|em| em.clone().expose().to_string())
.unwrap_or_default(),
exp_year: self
.card_exp_year
.as_ref()
.map(|ey| ey.clone().expose().to_string())
.unwrap_or_default(),
};
let card_json = serde_json::to_value(card_data).unwrap_or(serde_json::Value::Null);
TokenData {
specific_token_data: SecretSerdeValue::new(card_json),
vault_connector,
}
}
| {
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": "to_token_data_with_vault",
"is_async": null,
"is_pub": null,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_body_grpc-server_-3384819770676488938 | clm | function_body | // connector-service/backend/grpc-server/src/server/payments.rs
// Function: process_authorization_internal
{
//get connector data
let connector_data = ConnectorData::get_connector_by_name(&connector);
// Get connector integration
let connector_integration: BoxedConnectorIntegrationV2<
'_,
Authorize,
PaymentFlowData,
PaymentsAuthorizeData<T>,
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(),
metadata,
))
.map_err(|err| {
tracing::error!("Failed to process payment flow data: {:?}", err);
PaymentAuthorizationError::new(
grpc_api_types::payments::PaymentStatus::Pending,
Some("Failed to process payment flow data".to_string()),
Some("PAYMENT_FLOW_ERROR".to_string()),
None,
)
})?;
let lineage_ids = &metadata_payload.lineage_ids;
let reference_id = &metadata_payload.reference_id;
let should_do_order_create = connector_data.connector.should_do_order_create();
let payment_flow_data = if should_do_order_create {
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 order_id = Box::pin(self.handle_order_creation(
connector_data.clone(),
&payment_flow_data,
connector_auth_details.clone(),
&payload,
&connector.to_string(),
service_name,
event_params,
))
.await?;
tracing::info!("Order created successfully with order_id: {}", order_id);
payment_flow_data.set_order_reference_id(Some(order_id))
} else {
payment_flow_data
};
let should_do_session_token = connector_data.connector.should_do_session_token();
let payment_flow_data = if should_do_session_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 payment_session_data = Box::pin(self.handle_session_token(
connector_data.clone(),
&payment_flow_data,
connector_auth_details.clone(),
&payload,
&connector.to_string(),
service_name,
event_params,
))
.await?;
tracing::info!(
"Session Token created successfully with session_id: {}",
payment_session_data.session_token
);
payment_flow_data.set_session_token_id(Some(payment_session_data.session_token))
} else {
payment_flow_data
};
// 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,
connector_auth_details.clone(),
&connector.to_string(),
service_name,
event_params,
))
.await?;
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
};
// Extract connector customer ID (if provided by Hyperswitch)
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,
lineage_ids,
reference_id,
shadow_mode: metadata_payload.shadow_mode,
};
let connector_customer_response = Box::pin(self.handle_connector_customer(
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 should_do_payment_method_token =
connector_data.connector.should_do_payment_method_token();
let payment_flow_data = if should_do_payment_method_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 payment_method_token_data = self
.handle_payment_session_token(
connector_data.clone(),
&payment_flow_data,
connector_auth_details.clone(),
event_params,
&payload,
&connector.to_string(),
service_name,
)
.await?;
tracing::info!("Payment Method Token created successfully");
payment_flow_data.set_payment_method_token(Some(payment_method_token_data.token))
} else {
payment_flow_data
};
// This duplicate session token check has been removed - the session token handling is already done above
// Create connector request data
let payment_authorize_data = PaymentsAuthorizeData::foreign_try_from(payload.clone())
.map_err(|err| {
tracing::error!("Failed to process payment authorize data: {:?}", err);
PaymentAuthorizationError::new(
grpc_api_types::payments::PaymentStatus::Pending,
Some("Failed to process payment authorize data".to_string()),
Some("PAYMENT_AUTHORIZE_DATA_ERROR".to_string()),
None,
)
})?
// Set session token from payment flow data if available
.set_session_token(payment_flow_data.session_token.clone());
// Construct router data
let router_data = RouterDataV2::<
Authorize,
PaymentFlowData,
PaymentsAuthorizeData<T>,
PaymentsResponseData,
> {
flow: std::marker::PhantomData,
resource_common_data: payment_flow_data.clone(),
connector_auth_type: connector_auth_details.clone(),
request: payment_authorize_data,
response: Err(ErrorResponse::default()),
};
// Execute connector processing
let event_params = EventProcessingParams {
connector_name: &connector.to_string(),
service_name,
flow_name: FlowName::Authorize,
event_config: &self.config.events,
request_id,
lineage_ids,
reference_id,
shadow_mode: metadata_payload.shadow_mode,
};
// Execute connector processing
let response = external_services::service::execute_connector_processing_step(
&self.config.proxy,
connector_integration,
router_data,
None,
event_params,
token_data,
common_enums::CallConnectorAction::Trigger,
)
.await;
// Generate response - pass both success and error cases
let authorize_response = match response {
Ok(success_response) => domain_types::types::generate_payment_authorize_response(
success_response,
)
.map_err(|err| {
tracing::error!("Failed to generate authorize response: {:?}", err);
PaymentAuthorizationError::new(
grpc_api_types::payments::PaymentStatus::Pending,
Some("Failed to generate authorize response".to_string()),
Some("RESPONSE_GENERATION_ERROR".to_string()),
None,
)
})?,
Err(error_report) => {
// Convert error to RouterDataV2 with error response
let error_router_data = RouterDataV2 {
flow: std::marker::PhantomData,
resource_common_data: payment_flow_data,
connector_auth_type: connector_auth_details,
request: PaymentsAuthorizeData::foreign_try_from(payload.clone()).map_err(
|err| {
tracing::error!(
"Failed to process payment authorize data in error path: {:?}",
err
);
PaymentAuthorizationError::new(
grpc_api_types::payments::PaymentStatus::Pending,
Some(
"Failed to process payment authorize data in error path"
.to_string(),
),
Some("PAYMENT_AUTHORIZE_DATA_ERROR".to_string()),
None,
)
},
)?,
response: Err(ErrorResponse {
status_code: 400,
code: "CONNECTOR_ERROR".to_string(),
message: format!("{error_report}"),
reason: None,
attempt_status: Some(common_enums::AttemptStatus::Failure),
connector_transaction_id: None,
network_decline_code: None,
network_advice_code: None,
network_error_message: None,
}),
};
domain_types::types::generate_payment_authorize_response::<T>(error_router_data)
.map_err(|err| {
tracing::error!(
"Failed to generate authorize response for connector error: {:?}",
err
);
PaymentAuthorizationError::new(
grpc_api_types::payments::PaymentStatus::Pending,
Some(format!("Connector error: {error_report}")),
Some("CONNECTOR_ERROR".to_string()),
None,
)
})?
}
};
Ok(authorize_response)
}
| {
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": "process_authorization_internal",
"is_async": null,
"is_pub": null,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_body_grpc-server_4645052546479072000 | clm | function_body | // connector-service/backend/grpc-server/src/server/payments.rs
// Function: handle_order_creation
{
// 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| {
PaymentAuthorizationError::new(
grpc_api_types::payments::PaymentStatus::Pending,
Some(format!("Currency conversion failed: {e}")),
Some("CURRENCY_ERROR".to_string()),
None,
)
})?;
let order_create_data = PaymentCreateOrderData {
amount: common_utils::types::MinorUnit::new(payload.minor_amount),
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()),
};
// Create event processing parameters
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
.map_err(
|e: error_stack::Report<domain_types::errors::ConnectorError>| {
PaymentAuthorizationError::new(
grpc_api_types::payments::PaymentStatus::Pending,
Some(format!("Order creation failed: {e}")),
Some("ORDER_CREATION_ERROR".to_string()),
None,
)
},
)?;
match response.response {
Ok(PaymentCreateOrderResponse { order_id, .. }) => Ok(order_id),
Err(e) => Err(PaymentAuthorizationError::new(
grpc_api_types::payments::PaymentStatus::Pending,
Some(e.message.clone()),
Some(e.code.clone()),
Some(e.status_code.into()),
)),
}
}
| {
"chunk": null,
"crate": "grpc-server",
"enum_name": null,
"file_size": null,
"for_type": null,
"function_name": "handle_order_creation",
"is_async": null,
"is_pub": null,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_body_grpc-server_-3438328200384070630 | clm | function_body | // connector-service/backend/grpc-server/src/server/payments.rs
// Function: handle_order_creation_for_setup_mandate
{
// 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": null,
"is_pub": null,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_body_grpc-server_3118207782561495407 | clm | function_body | // connector-service/backend/grpc-server/src/server/payments.rs
// Function: handle_session_token
{
// 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": null,
"is_pub": null,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_body_grpc-server_1163810725903300883 | clm | function_body | // connector-service/backend/grpc-server/src/server/payments.rs
// Function: handle_access_token
{
// 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": null,
"is_pub": null,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_body_grpc-server_-8289574315249616664 | clm | function_body | // connector-service/backend/grpc-server/src/server/payments.rs
// Function: handle_connector_customer
{
// 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": null,
"is_pub": null,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_body_grpc-server_-9217058443951536110 | clm | function_body | // connector-service/backend/grpc-server/src/server/payments.rs
// Function: handle_connector_customer_for_setup_mandate
{
// 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": null,
"is_pub": null,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_body_grpc-server_-4490740975507371133 | clm | function_body | // connector-service/backend/grpc-server/src/server/payments.rs
// Function: handle_payment_session_token
{
// 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": null,
"is_pub": null,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_body_grpc-server_-2125080601767551134 | clm | function_body | // connector-service/backend/grpc-server/src/server/payments.rs
// Function: authorize
{
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": null,
"is_pub": null,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_body_grpc-server_6293499016738968107 | clm | function_body | // connector-service/backend/grpc-server/src/server/payments.rs
// Function: get
{
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": null,
"is_pub": null,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_body_grpc-server_2641381016457535420 | clm | function_body | // connector-service/backend/grpc-server/src/server/payments.rs
// Function: void
{
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": null,
"is_pub": null,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_body_grpc-server_-1691506971339418603 | clm | function_body | // connector-service/backend/grpc-server/src/server/payments.rs
// Function: void_post_capture
{
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": null,
"is_pub": null,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_body_grpc-server_5798579520823863730 | clm | function_body | // connector-service/backend/grpc-server/src/server/payments.rs
// Function: transform
{
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": null,
"is_pub": null,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_body_grpc-server_7669360379203482642 | clm | function_body | // connector-service/backend/grpc-server/src/server/payments.rs
// Function: refund
{
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": null,
"is_pub": null,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_body_grpc-server_686698646402302221 | clm | function_body | // connector-service/backend/grpc-server/src/server/payments.rs
// Function: dispute
{
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": null,
"is_pub": null,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_body_grpc-server_5570048028234178648 | clm | function_body | // connector-service/backend/grpc-server/src/server/payments.rs
// Function: capture
{
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": null,
"is_pub": null,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_body_grpc-server_2690148189299557326 | clm | function_body | // connector-service/backend/grpc-server/src/server/payments.rs
// Function: register
{
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": null,
"is_pub": null,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_body_grpc-server_-7709097329130294000 | clm | function_body | // connector-service/backend/grpc-server/src/server/payments.rs
// Function: repeat_everything
{
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": null,
"is_pub": null,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_body_grpc-server_4988184054883374868 | clm | function_body | // connector-service/backend/grpc-server/src/server/payments.rs
// Function: pre_authenticate
{
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": null,
"is_pub": null,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_body_grpc-server_69996089778591858 | clm | function_body | // connector-service/backend/grpc-server/src/server/payments.rs
// Function: authenticate
{
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": null,
"is_pub": null,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_body_grpc-server_3596249420929772877 | clm | function_body | // connector-service/backend/grpc-server/src/server/payments.rs
// Function: post_authenticate
{
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": null,
"is_pub": null,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_body_grpc-server_4962492850098973143 | clm | function_body | // connector-service/backend/grpc-server/src/server/payments.rs
// Function: get_payments_webhook_content
{
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": null,
"is_pub": null,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_body_grpc-server_4618141101747958615 | clm | function_body | // connector-service/backend/grpc-server/src/server/payments.rs
// Function: get_refunds_webhook_content
{
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": null,
"is_pub": null,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_body_grpc-server_913377641800377970 | clm | function_body | // connector-service/backend/grpc-server/src/server/payments.rs
// Function: get_disputes_webhook_content
{
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": null,
"is_pub": null,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_body_grpc-server_7795258065850016122 | clm | function_body | // connector-service/backend/grpc-server/src/server/payments.rs
// Function: generate_payment_pre_authenticate_response
{
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": null,
"is_pub": null,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_body_grpc-server_3262422893288869427 | clm | function_body | // connector-service/backend/grpc-server/src/server/payments.rs
// Function: generate_payment_authenticate_response
{
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": null,
"is_pub": null,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_body_grpc-server_7230651373193303354 | clm | function_body | // connector-service/backend/grpc-server/src/server/payments.rs
// Function: generate_payment_post_authenticate_response
{
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": null,
"is_pub": null,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_body_grpc-server_2031413733425933813 | clm | function_body | // connector-service/backend/grpc-server/src/server/disputes.rs
// Function: submit_evidence
{
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": null,
"is_pub": null,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_body_grpc-server_-3278941850027429226 | clm | function_body | // connector-service/backend/grpc-server/src/server/disputes.rs
// Function: get
{
// 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": null,
"is_pub": null,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_body_grpc-server_-218339538236795674 | clm | function_body | // connector-service/backend/grpc-server/src/server/disputes.rs
// Function: defend
{
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": null,
"is_pub": null,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_body_grpc-server_-8403690431121274655 | clm | function_body | // connector-service/backend/grpc-server/src/server/disputes.rs
// Function: accept
{
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": null,
"is_pub": null,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_body_grpc-server_4380569431456917537 | clm | function_body | // connector-service/backend/grpc-server/src/server/disputes.rs
// Function: transform
{
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": null,
"is_pub": null,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_body_grpc-server_-4396904337498835905 | clm | function_body | // connector-service/backend/grpc-server/src/server/disputes.rs
// Function: get_disputes_webhook_content
{
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": null,
"is_pub": null,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_body_grpc-server_3233543653241132822 | clm | function_body | // connector-service/backend/grpc-server/src/server/health_check.rs
// Function: check
{
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": null,
"is_pub": null,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_body_interfaces_-8427543665593442032 | clm | function_body | // connector-service/backend/interfaces/src/verification.rs
// Function: verify
{
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": null,
"is_pub": null,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_body_interfaces_-6797427122303227818 | clm | function_body | // connector-service/backend/interfaces/src/connector_types.rs
// Function: get_event_type
{
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": null,
"is_pub": null,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_body_interfaces_-746232449507976469 | clm | function_body | // connector-service/backend/interfaces/src/connector_types.rs
// Function: process_payment_webhook
{
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": null,
"is_pub": null,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_body_interfaces_7046929677796791626 | clm | function_body | // connector-service/backend/interfaces/src/connector_types.rs
// Function: process_refund_webhook
{
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": null,
"is_pub": null,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_body_interfaces_-7334983424329949003 | clm | function_body | // connector-service/backend/interfaces/src/connector_types.rs
// Function: process_dispute_webhook
{
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": null,
"is_pub": null,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_body_interfaces_-3273185454774027288 | clm | function_body | // connector-service/backend/interfaces/src/connector_types.rs
// Function: get_webhook_resource_object
{
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": null,
"is_pub": null,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_body_interfaces_-4016073787511400179 | clm | function_body | // connector-service/backend/interfaces/src/connector_types.rs
// Function: validate_connector_against_payment_request
{
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": null,
"is_pub": null,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_body_interfaces_5653381627481173452 | clm | function_body | // connector-service/backend/interfaces/src/connector_types.rs
// Function: validate_mandate_payment
{
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": null,
"is_pub": null,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_body_interfaces_2100301772043126149 | clm | function_body | // connector-service/backend/interfaces/src/connector_types.rs
// Function: validate_psync_reference_id
{
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": null,
"is_pub": null,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_body_interfaces_8998734169015978571 | clm | function_body | // connector-service/backend/interfaces/src/connector_types.rs
// Function: get_connector_payment_method_type_info
{
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": null,
"is_pub": null,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_body_interfaces_-5902888379317477341 | clm | function_body | // connector-service/backend/interfaces/src/connector_types.rs
// Function: is_mandate_supported
{
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": null,
"is_pub": null,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_body_interfaces_-2543964029645814028 | clm | function_body | // connector-service/backend/interfaces/src/integrity.rs
// Function: get_request_integrity_object
{
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": null,
"is_pub": null,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_body_interfaces_-1340448511782822228 | clm | function_body | // connector-service/backend/interfaces/src/integrity.rs
// Function: compare
{
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": null,
"is_pub": null,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_body_interfaces_3767528725818782279 | clm | function_body | // connector-service/backend/interfaces/src/integrity.rs
// Function: check_integrity_result
{
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": null,
"is_pub": null,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_body_interfaces_-250960067738591458 | clm | function_body | // connector-service/backend/interfaces/src/webhooks.rs
// Function: decode_webhook_body
{
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": null,
"is_pub": null,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_body_interfaces_3263610587134362028 | clm | function_body | // connector-service/backend/interfaces/src/webhooks.rs
// Function: get_webhook_source_verification_merchant_secret
{
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": null,
"is_pub": null,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_body_interfaces_-6022705827761258943 | clm | function_body | // connector-service/backend/interfaces/src/webhooks.rs
// Function: verify_webhook_source
{
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": null,
"is_pub": null,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_body_interfaces_-627268752418460137 | clm | function_body | // connector-service/backend/interfaces/src/webhooks.rs
// Function: get_dispute_details
{
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": null,
"is_pub": null,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_body_interfaces_5957321670385618724 | clm | function_body | // connector-service/backend/interfaces/src/webhooks.rs
// Function: get_external_authentication_details
{
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": null,
"is_pub": null,
"lines": null,
"method_name": null,
"num_enums": null,
"num_items": null,
"num_structs": null,
"repo": "connector-service",
"start_line": null,
"struct_name": null,
"total_crates": null,
"trait_name": null
} |
connector-service_body_interfaces_-6363562458875186917 | clm | function_body | // connector-service/backend/interfaces/src/connector_integration_v2.rs
// Function: get_url
{
// 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": null,
"is_pub": null,
"lines": null,
"method_name": null,
"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.