text
stringlengths 65
57.3k
| file_path
stringlengths 22
92
| module
stringclasses 38
values | type
stringclasses 7
values | struct_name
stringlengths 3
60
⌀ | impl_count
int64 0
60
⌀ | traits
listlengths 0
59
⌀ | tokens
int64 16
8.19k
| function_name
stringlengths 3
85
⌀ | type_name
stringlengths 1
67
⌀ | trait_name
stringclasses 573
values | method_count
int64 0
31
⌀ | public_method_count
int64 0
19
⌀ | submodule_count
int64 0
56
⌀ | export_count
int64 0
9
⌀ |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
// Struct: Breadpay
// File: crates/hyperswitch_connectors/src/connectors/breadpay.rs
// Module: hyperswitch_connectors
// Implementations: 19
// Traits: api::Payment, api::PaymentSession, api::PaymentsCompleteAuthorize, api::ConnectorAccessToken, api::MandateSetup, api::PaymentAuthorize, api::PaymentSync, api::PaymentCapture, api::PaymentVoid, api::Refund, api::RefundExecute, api::RefundSync, api::PaymentToken, ConnectorCommon, ConnectorValidation, webhooks::IncomingWebhook, ConnectorSpecifications, ConnectorRedirectResponse
pub struct Breadpay
|
crates/hyperswitch_connectors/src/connectors/breadpay.rs
|
hyperswitch_connectors
|
struct_definition
|
Breadpay
| 19
|
[
"api::Payment",
"api::PaymentSession",
"api::PaymentsCompleteAuthorize",
"api::ConnectorAccessToken",
"api::MandateSetup",
"api::PaymentAuthorize",
"api::PaymentSync",
"api::PaymentCapture",
"api::PaymentVoid",
"api::Refund",
"api::RefundExecute",
"api::RefundSync",
"api::PaymentToken",
"ConnectorCommon",
"ConnectorValidation",
"webhooks::IncomingWebhook",
"ConnectorSpecifications",
"ConnectorRedirectResponse"
] | 136
| null | null | null | null | null | null | null |
// Function: authentication_authenticate
// File: crates/router/src/routes/authentication.rs
// Module: router
pub fn authentication_authenticate(
state: web::Data<app::AppState>,
req: HttpRequest,
json_payload: web::Json<AuthenticationAuthenticateRequest>,
path: web::Path<common_utils::id_type::AuthenticationId>,
) -> impl Responder
|
crates/router/src/routes/authentication.rs
|
router
|
function_signature
| null | null | null | 77
|
authentication_authenticate
| null | null | null | null | null | null |
// Struct: ActionLink
// File: crates/hyperswitch_connectors/src/connectors/worldpay/response.rs
// Module: hyperswitch_connectors
// Implementations: 0
pub struct ActionLink
|
crates/hyperswitch_connectors/src/connectors/worldpay/response.rs
|
hyperswitch_connectors
|
struct_definition
|
ActionLink
| 0
|
[] | 43
| null | null | null | null | null | null | null |
.unwrap_or(source.is_debit_routing_enabled),
merchant_business_country: merchant_business_country
.or(source.merchant_business_country),
revenue_recovery_retry_algorithm_type: revenue_recovery_retry_algorithm_type
.or(source.revenue_recovery_retry_algorithm_type),
revenue_recovery_retry_algorithm_data: revenue_recovery_retry_algorithm_data
.or(source.revenue_recovery_retry_algorithm_data),
is_iframe_redirection_enabled: is_iframe_redirection_enabled
.or(source.is_iframe_redirection_enabled),
is_external_vault_enabled: is_external_vault_enabled
.or(source.is_external_vault_enabled),
external_vault_connector_details: external_vault_connector_details
.or(source.external_vault_connector_details),
three_ds_decision_rule_algorithm: None,
acquirer_config_map: None,
merchant_category_code: merchant_category_code.or(source.merchant_category_code),
merchant_country_code: merchant_country_code.or(source.merchant_country_code),
dispute_polling_interval: None,
split_txns_enabled: split_txns_enabled.or(source.split_txns_enabled),
is_manual_retry_enabled: None,
always_enable_overcapture: None,
billing_processor_id: billing_processor_id.or(source.billing_processor_id),
}
}
}
#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, diesel::AsExpression)]
#[diesel(sql_type = diesel::sql_types::Jsonb)]
pub struct AuthenticationConnectorDetails {
pub authentication_connectors: Vec<AuthenticationConnectors>,
pub three_ds_requestor_url: String,
pub three_ds_requestor_app_url: Option<String>,
}
common_utils::impl_to_sql_from_sql_json!(AuthenticationConnectorDetails);
#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, diesel::AsExpression)]
#[diesel(sql_type = diesel::sql_types::Jsonb)]
pub struct ExternalVaultConnectorDetails {
pub vault_connector_id: common_utils::id_type::MerchantConnectorAccountId,
pub vault_sdk: Option<VaultSdk>,
}
common_utils::impl_to_sql_from_sql_json!(ExternalVaultConnectorDetails);
#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, diesel::AsExpression)]
#[diesel(sql_type = diesel::sql_types::Jsonb)]
pub struct CardTestingGuardConfig {
pub is_card_ip_blocking_enabled: bool,
pub card_ip_blocking_threshold: i32,
pub is_guest_user_card_blocking_enabled: bool,
pub guest_user_card_blocking_threshold: i32,
pub is_customer_id_blocking_enabled: bool,
pub customer_id_blocking_threshold: i32,
pub card_testing_guard_expiry: i32,
}
common_utils::impl_to_sql_from_sql_json!(CardTestingGuardConfig);
impl Default for CardTestingGuardConfig {
fn default() -> Self {
Self {
is_card_ip_blocking_enabled: common_utils::consts::DEFAULT_CARD_IP_BLOCKING_STATUS,
card_ip_blocking_threshold: common_utils::consts::DEFAULT_CARD_IP_BLOCKING_THRESHOLD,
is_guest_user_card_blocking_enabled:
common_utils::consts::DEFAULT_GUEST_USER_CARD_BLOCKING_STATUS,
guest_user_card_blocking_threshold:
common_utils::consts::DEFAULT_GUEST_USER_CARD_BLOCKING_THRESHOLD,
is_customer_id_blocking_enabled:
common_utils::consts::DEFAULT_CUSTOMER_ID_BLOCKING_STATUS,
customer_id_blocking_threshold:
common_utils::consts::DEFAULT_CUSTOMER_ID_BLOCKING_THRESHOLD,
card_testing_guard_expiry:
common_utils::consts::DEFAULT_CARD_TESTING_GUARD_EXPIRY_IN_SECS,
}
}
}
#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, diesel::AsExpression)]
#[diesel(sql_type = diesel::sql_types::Json)]
pub struct WebhookDetails {
pub webhook_version: Option<String>,
pub webhook_username: Option<String>,
pub webhook_password: Option<Secret<String>>,
pub webhook_url: Option<Secret<String>>,
pub payment_created_enabled: Option<bool>,
pub payment_succeeded_enabled: Option<bool>,
pub payment_failed_enabled: Option<bool>,
pub payment_statuses_enabled: Option<Vec<common_enums::IntentStatus>>,
pub refund_statuses_enabled: Option<Vec<common_enums::RefundStatus>>,
pub payout_statuses_enabled: Option<Vec<common_enums::PayoutStatus>>,
}
common_utils::impl_to_sql_from_sql_json!(WebhookDetails);
#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, diesel::AsExpression)]
#[diesel(sql_type = diesel::sql_types::Jsonb)]
pub struct BusinessPaymentLinkConfig {
pub domain_name: Option<String>,
#[serde(flatten)]
pub default_config: Option<PaymentLinkConfigRequest>,
pub business_specific_configs: Option<HashMap<String, PaymentLinkConfigRequest>>,
pub allowed_domains: Option<HashSet<String>>,
pub branding_visibility: Option<bool>,
}
#[derive(Clone, Debug, serde::Deserialize, serde::Serialize)]
pub struct PaymentLinkConfigRequest {
pub theme: Option<String>,
pub logo: Option<String>,
pub seller_name: Option<String>,
pub sdk_layout: Option<String>,
pub display_sdk_only: Option<bool>,
pub enabled_saved_payment_method: Option<bool>,
pub hide_card_nickname_field: Option<bool>,
pub show_card_form_by_default: Option<bool>,
pub background_image: Option<PaymentLinkBackgroundImageConfig>,
pub details_layout: Option<common_enums::PaymentLinkDetailsLayout>,
pub payment_button_text: Option<String>,
pub custom_message_for_card_terms: Option<String>,
pub payment_button_colour: Option<String>,
pub skip_status_screen: Option<bool>,
pub payment_button_text_colour: Option<String>,
pub background_colour: Option<String>,
pub sdk_ui_rules: Option<HashMap<String, HashMap<String, String>>>,
pub payment_link_ui_rules: Option<HashMap<String, HashMap<String, String>>>,
pub enable_button_only_on_form_ready: Option<bool>,
pub payment_form_header_text: Option<String>,
pub payment_form_label_type: Option<common_enums::PaymentLinkSdkLabelType>,
pub show_card_terms: Option<common_enums::PaymentLinkShowSdkTerms>,
pub is_setup_mandate_flow: Option<bool>,
pub color_icon_card_cvc_error: Option<String>,
}
#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, PartialEq)]
pub struct PaymentLinkBackgroundImageConfig {
pub url: common_utils::types::Url,
pub position: Option<common_enums::ElementPosition>,
pub size: Option<common_enums::ElementSize>,
}
common_utils::impl_to_sql_from_sql_json!(BusinessPaymentLinkConfig);
#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, diesel::AsExpression)]
#[diesel(sql_type = diesel::sql_types::Jsonb)]
pub struct BusinessPayoutLinkConfig {
#[serde(flatten)]
pub config: BusinessGenericLinkConfig,
pub form_layout: Option<UIWidgetFormLayout>,
pub payout_test_mode: Option<bool>,
}
#[derive(Clone, Debug, serde::Deserialize, serde::Serialize)]
pub struct BusinessGenericLinkConfig {
pub domain_name: Option<String>,
pub allowed_domains: HashSet<String>,
#[serde(flatten)]
pub ui_config: common_utils::link_utils::GenericLinkUiConfig,
}
common_utils::impl_to_sql_from_sql_json!(BusinessPayoutLinkConfig);
#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, diesel::AsExpression)]
#[diesel(sql_type = diesel::sql_types::Jsonb)]
pub struct RevenueRecoveryAlgorithmData {
pub monitoring_configured_timestamp: time::PrimitiveDateTime,
}
impl RevenueRecoveryAlgorithmData {
pub fn has_exceeded_monitoring_threshold(&self, monitoring_threshold_in_seconds: i64) -> bool {
let total_threshold_time = self.monitoring_configured_timestamp
+ Duration::seconds(monitoring_threshold_in_seconds);
common_utils::date_time::now() >= total_threshold_time
}
}
common_utils::impl_to_sql_from_sql_json!(RevenueRecoveryAlgorithmData);
|
crates/diesel_models/src/business_profile.rs#chunk1
|
diesel_models
|
chunk
| null | null | null | 1,682
| null | null | null | null | null | null | null |
// Function: new
// File: crates/api_models/src/routing.rs
// Module: api_models
pub fn new(routable_connector_choice: RoutableConnectorChoice, status: bool) -> Self
|
crates/api_models/src/routing.rs
|
api_models
|
function_signature
| null | null | null | 42
|
new
| null | null | null | null | null | null |
// Implementation: impl DummyConnector
// File: crates/hyperswitch_connectors/src/connectors/dummyconnector.rs
// Module: hyperswitch_connectors
// Methods: 1 total (1 public)
impl DummyConnector
|
crates/hyperswitch_connectors/src/connectors/dummyconnector.rs
|
hyperswitch_connectors
|
impl_block
| null | null | null | 46
| null |
DummyConnector
| null | 1
| 1
| null | null |
// File: crates/diesel_models/src/payouts.rs
// Module: diesel_models
// Public functions: 1
// Public structs: 3
use common_utils::{pii, types::MinorUnit};
use diesel::{AsChangeset, Identifiable, Insertable, Queryable, Selectable};
use serde::{self, Deserialize, Serialize};
use time::PrimitiveDateTime;
use crate::{enums as storage_enums, schema::payouts};
// Payouts
#[derive(
Clone, Debug, Eq, PartialEq, Identifiable, Queryable, Selectable, Serialize, Deserialize,
)]
#[diesel(table_name = payouts, primary_key(payout_id), check_for_backend(diesel::pg::Pg))]
pub struct Payouts {
pub payout_id: common_utils::id_type::PayoutId,
pub merchant_id: common_utils::id_type::MerchantId,
pub customer_id: Option<common_utils::id_type::CustomerId>,
pub address_id: Option<String>,
pub payout_type: Option<storage_enums::PayoutType>,
pub payout_method_id: Option<String>,
pub amount: MinorUnit,
pub destination_currency: storage_enums::Currency,
pub source_currency: storage_enums::Currency,
pub description: Option<String>,
pub recurring: bool,
pub auto_fulfill: bool,
pub return_url: Option<String>,
pub entity_type: storage_enums::PayoutEntityType,
pub metadata: Option<pii::SecretSerdeValue>,
#[serde(with = "common_utils::custom_serde::iso8601")]
pub created_at: PrimitiveDateTime,
#[serde(with = "common_utils::custom_serde::iso8601")]
pub last_modified_at: PrimitiveDateTime,
pub attempt_count: i16,
pub profile_id: common_utils::id_type::ProfileId,
pub status: storage_enums::PayoutStatus,
pub confirm: Option<bool>,
pub payout_link_id: Option<String>,
pub client_secret: Option<String>,
pub priority: Option<storage_enums::PayoutSendPriority>,
}
#[derive(
Clone,
Debug,
Eq,
PartialEq,
Insertable,
serde::Serialize,
serde::Deserialize,
router_derive::DebugAsDisplay,
router_derive::Setter,
)]
#[diesel(table_name = payouts)]
pub struct PayoutsNew {
pub payout_id: common_utils::id_type::PayoutId,
pub merchant_id: common_utils::id_type::MerchantId,
pub customer_id: Option<common_utils::id_type::CustomerId>,
pub address_id: Option<String>,
pub payout_type: Option<storage_enums::PayoutType>,
pub payout_method_id: Option<String>,
pub amount: MinorUnit,
pub destination_currency: storage_enums::Currency,
pub source_currency: storage_enums::Currency,
pub description: Option<String>,
pub recurring: bool,
pub auto_fulfill: bool,
pub return_url: Option<String>,
pub entity_type: storage_enums::PayoutEntityType,
pub metadata: Option<pii::SecretSerdeValue>,
#[serde(with = "common_utils::custom_serde::iso8601")]
pub created_at: PrimitiveDateTime,
#[serde(with = "common_utils::custom_serde::iso8601")]
pub last_modified_at: PrimitiveDateTime,
pub attempt_count: i16,
pub profile_id: common_utils::id_type::ProfileId,
pub status: storage_enums::PayoutStatus,
pub confirm: Option<bool>,
pub payout_link_id: Option<String>,
pub client_secret: Option<String>,
pub priority: Option<storage_enums::PayoutSendPriority>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum PayoutsUpdate {
Update {
amount: MinorUnit,
destination_currency: storage_enums::Currency,
source_currency: storage_enums::Currency,
description: Option<String>,
recurring: bool,
auto_fulfill: bool,
return_url: Option<String>,
entity_type: storage_enums::PayoutEntityType,
metadata: Option<pii::SecretSerdeValue>,
profile_id: Option<common_utils::id_type::ProfileId>,
status: Option<storage_enums::PayoutStatus>,
confirm: Option<bool>,
payout_type: Option<storage_enums::PayoutType>,
address_id: Option<String>,
customer_id: Option<common_utils::id_type::CustomerId>,
},
PayoutMethodIdUpdate {
payout_method_id: String,
},
RecurringUpdate {
recurring: bool,
},
AttemptCountUpdate {
attempt_count: i16,
},
StatusUpdate {
status: storage_enums::PayoutStatus,
},
}
#[derive(Clone, Debug, AsChangeset, router_derive::DebugAsDisplay)]
#[diesel(table_name = payouts)]
pub struct PayoutsUpdateInternal {
pub amount: Option<MinorUnit>,
pub destination_currency: Option<storage_enums::Currency>,
pub source_currency: Option<storage_enums::Currency>,
pub description: Option<String>,
pub recurring: Option<bool>,
pub auto_fulfill: Option<bool>,
pub return_url: Option<String>,
pub entity_type: Option<storage_enums::PayoutEntityType>,
pub metadata: Option<pii::SecretSerdeValue>,
pub payout_method_id: Option<String>,
pub profile_id: Option<common_utils::id_type::ProfileId>,
pub status: Option<storage_enums::PayoutStatus>,
pub last_modified_at: PrimitiveDateTime,
pub attempt_count: Option<i16>,
pub confirm: Option<bool>,
pub payout_type: Option<common_enums::PayoutType>,
pub address_id: Option<String>,
pub customer_id: Option<common_utils::id_type::CustomerId>,
}
impl Default for PayoutsUpdateInternal {
fn default() -> Self {
Self {
amount: None,
destination_currency: None,
source_currency: None,
description: None,
recurring: None,
auto_fulfill: None,
return_url: None,
entity_type: None,
metadata: None,
payout_method_id: None,
profile_id: None,
status: None,
last_modified_at: common_utils::date_time::now(),
attempt_count: None,
confirm: None,
payout_type: None,
address_id: None,
customer_id: None,
}
}
}
impl From<PayoutsUpdate> for PayoutsUpdateInternal {
fn from(payout_update: PayoutsUpdate) -> Self {
match payout_update {
PayoutsUpdate::Update {
amount,
destination_currency,
source_currency,
description,
recurring,
auto_fulfill,
return_url,
entity_type,
metadata,
profile_id,
status,
confirm,
payout_type,
address_id,
customer_id,
} => Self {
amount: Some(amount),
destination_currency: Some(destination_currency),
source_currency: Some(source_currency),
description,
recurring: Some(recurring),
auto_fulfill: Some(auto_fulfill),
return_url,
entity_type: Some(entity_type),
metadata,
profile_id,
status,
confirm,
payout_type,
address_id,
customer_id,
..Default::default()
},
PayoutsUpdate::PayoutMethodIdUpdate { payout_method_id } => Self {
payout_method_id: Some(payout_method_id),
..Default::default()
},
PayoutsUpdate::RecurringUpdate { recurring } => Self {
recurring: Some(recurring),
..Default::default()
},
PayoutsUpdate::AttemptCountUpdate { attempt_count } => Self {
attempt_count: Some(attempt_count),
..Default::default()
},
PayoutsUpdate::StatusUpdate { status } => Self {
status: Some(status),
..Default::default()
},
}
}
}
impl PayoutsUpdate {
pub fn apply_changeset(self, source: Payouts) -> Payouts {
let PayoutsUpdateInternal {
amount,
destination_currency,
source_currency,
description,
recurring,
auto_fulfill,
return_url,
entity_type,
metadata,
payout_method_id,
profile_id,
status,
last_modified_at,
attempt_count,
confirm,
payout_type,
address_id,
customer_id,
} = self.into();
Payouts {
amount: amount.unwrap_or(source.amount),
destination_currency: destination_currency.unwrap_or(source.destination_currency),
source_currency: source_currency.unwrap_or(source.source_currency),
description: description.or(source.description),
recurring: recurring.unwrap_or(source.recurring),
auto_fulfill: auto_fulfill.unwrap_or(source.auto_fulfill),
return_url: return_url.or(source.return_url),
entity_type: entity_type.unwrap_or(source.entity_type),
metadata: metadata.or(source.metadata),
payout_method_id: payout_method_id.or(source.payout_method_id),
profile_id: profile_id.unwrap_or(source.profile_id),
status: status.unwrap_or(source.status),
last_modified_at,
attempt_count: attempt_count.unwrap_or(source.attempt_count),
confirm: confirm.or(source.confirm),
payout_type: payout_type.or(source.payout_type),
address_id: address_id.or(source.address_id),
customer_id: customer_id.or(source.customer_id),
..source
}
}
}
|
crates/diesel_models/src/payouts.rs
|
diesel_models
|
full_file
| null | null | null | 2,027
| null | null | null | null | null | null | null |
// Function: get_new_organization
// File: crates/router/src/types/domain/user.rs
// Module: router
pub fn get_new_organization(&self) -> NewUserOrganization
|
crates/router/src/types/domain/user.rs
|
router
|
function_signature
| null | null | null | 35
|
get_new_organization
| null | null | null | null | null | null |
// Struct: UpdateEliminationBucketEventRequest
// File: crates/router/src/core/payments/routing/utils.rs
// Module: router
// Implementations: 0
pub struct UpdateEliminationBucketEventRequest
|
crates/router/src/core/payments/routing/utils.rs
|
router
|
struct_definition
|
UpdateEliminationBucketEventRequest
| 0
|
[] | 44
| null | null | null | null | null | null | null |
// File: crates/analytics/src/auth_events.rs
// Module: analytics
pub mod accumulator;
mod core;
pub mod filters;
pub mod metrics;
pub mod sankey;
pub mod types;
pub use accumulator::{AuthEventMetricAccumulator, AuthEventMetricsAccumulator};
pub use self::core::{get_filters, get_metrics, get_sankey};
|
crates/analytics/src/auth_events.rs
|
analytics
|
full_file
| null | null | null | 74
| null | null | null | null | null | null | null |
// Function: get_webhook_url_from_profile
// File: crates/hyperswitch_domain_models/src/business_profile.rs
// Module: hyperswitch_domain_models
pub fn get_webhook_url_from_profile(&self) -> CustomResult<String, ValidationError>
|
crates/hyperswitch_domain_models/src/business_profile.rs
|
hyperswitch_domain_models
|
function_signature
| null | null | null | 51
|
get_webhook_url_from_profile
| null | null | null | null | null | null |
// Struct: OnlineMandate
// File: crates/common_types/src/payments.rs
// Module: common_types
// Implementations: 0
pub struct OnlineMandate
|
crates/common_types/src/payments.rs
|
common_types
|
struct_definition
|
OnlineMandate
| 0
|
[] | 38
| null | null | null | null | null | null | null |
// File: crates/hyperswitch_connectors/src/connectors/bankofamerica.rs
// Module: hyperswitch_connectors
// Public functions: 3
// Public structs: 1
pub mod transformers;
use std::sync::LazyLock;
use base64::Engine;
use common_enums::enums;
use common_utils::{
consts,
errors::CustomResult,
ext_traits::BytesExt,
request::{Method, Request, RequestBuilder, RequestContent},
types::{AmountConvertor, StringMajorUnit, StringMajorUnitForConnector},
};
use error_stack::{report, ResultExt};
use hyperswitch_domain_models::{
payment_method_data::PaymentMethodData,
router_data::{AccessToken, ErrorResponse, RouterData},
router_flow_types::{
access_token_auth::AccessTokenAuth,
payments::{Authorize, Capture, PSync, PaymentMethodToken, Session, SetupMandate, Void},
refunds::{Execute, RSync},
},
router_request_types::{
AccessTokenRequestData, PaymentMethodTokenizationData, PaymentsAuthorizeData,
PaymentsCancelData, PaymentsCaptureData, PaymentsSessionData, PaymentsSyncData,
RefundsData, SetupMandateRequestData,
},
router_response_types::{
ConnectorInfo, PaymentMethodDetails, PaymentsResponseData, RefundsResponseData,
SupportedPaymentMethods, SupportedPaymentMethodsExt,
},
types::{
PaymentsAuthorizeRouterData, PaymentsCancelRouterData, PaymentsCaptureRouterData,
PaymentsSyncRouterData, RefundSyncRouterData, RefundsRouterData, SetupMandateRouterData,
},
};
use hyperswitch_interfaces::{
api::{
self, ConnectorCommon, ConnectorCommonExt, ConnectorIntegration, ConnectorSpecifications,
ConnectorValidation,
},
configs::Connectors,
errors,
events::connector_api_logs::ConnectorEvent,
types::{
PaymentsAuthorizeType, PaymentsCaptureType, PaymentsSyncType, PaymentsVoidType,
RefundExecuteType, RefundSyncType, Response, SetupMandateType,
},
webhooks,
};
use masking::{ExposeInterface, Mask, Maskable, PeekInterface};
use ring::{digest, hmac};
use time::OffsetDateTime;
use transformers as bankofamerica;
use url::Url;
use crate::{
connectors::bankofamerica::transformers::BankOfAmericaRouterData,
constants::{self, headers},
types::ResponseRouterData,
utils::{self, convert_amount, PaymentMethodDataType, RefundsRequestData},
};
pub const V_C_MERCHANT_ID: &str = "v-c-merchant-id";
#[derive(Clone)]
pub struct Bankofamerica {
amount_convertor: &'static (dyn AmountConvertor<Output = StringMajorUnit> + Sync),
}
impl Bankofamerica {
pub fn new() -> &'static Self {
&Self {
amount_convertor: &StringMajorUnitForConnector,
}
}
}
impl api::Payment for Bankofamerica {}
impl api::PaymentSession for Bankofamerica {}
impl api::ConnectorAccessToken for Bankofamerica {}
impl api::MandateSetup for Bankofamerica {}
impl api::PaymentAuthorize for Bankofamerica {}
impl api::PaymentSync for Bankofamerica {}
impl api::PaymentCapture for Bankofamerica {}
impl api::PaymentVoid for Bankofamerica {}
impl api::Refund for Bankofamerica {}
impl api::RefundExecute for Bankofamerica {}
impl api::RefundSync for Bankofamerica {}
impl api::PaymentToken for Bankofamerica {}
impl Bankofamerica {
pub fn generate_digest(&self, payload: &[u8]) -> String {
let payload_digest = digest::digest(&digest::SHA256, payload);
consts::BASE64_ENGINE.encode(payload_digest)
}
pub fn generate_signature(
&self,
auth: bankofamerica::BankOfAmericaAuthType,
host: String,
resource: &str,
payload: &String,
date: OffsetDateTime,
http_method: Method,
) -> CustomResult<String, errors::ConnectorError> {
let bankofamerica::BankOfAmericaAuthType {
api_key,
merchant_account,
api_secret,
} = auth;
let is_post_method = matches!(http_method, Method::Post);
let digest_str = if is_post_method { "digest " } else { "" };
let headers = format!("host date (request-target) {digest_str}{V_C_MERCHANT_ID}");
let request_target = if is_post_method {
format!("(request-target): post {resource}\ndigest: SHA-256={payload}\n")
} else {
format!("(request-target): get {resource}\n")
};
let signature_string = format!(
"host: {host}\ndate: {date}\n{request_target}{V_C_MERCHANT_ID}: {}",
merchant_account.peek()
);
let key_value = consts::BASE64_ENGINE
.decode(api_secret.expose())
.change_context(errors::ConnectorError::InvalidConnectorConfig {
config: "connector_account_details.api_secret",
})?;
let key = hmac::Key::new(hmac::HMAC_SHA256, &key_value);
let signature_value =
consts::BASE64_ENGINE.encode(hmac::sign(&key, signature_string.as_bytes()).as_ref());
let signature_header = format!(
r#"keyid="{}", algorithm="HmacSHA256", headers="{headers}", signature="{signature_value}""#,
api_key.peek()
);
Ok(signature_header)
}
}
impl ConnectorIntegration<PaymentMethodToken, PaymentMethodTokenizationData, PaymentsResponseData>
for Bankofamerica
{
// Not Implemented (R)
}
impl<Flow, Request, Response> ConnectorCommonExt<Flow, Request, Response> for Bankofamerica
where
Self: ConnectorIntegration<Flow, Request, Response>,
{
fn build_headers(
&self,
req: &RouterData<Flow, Request, Response>,
connectors: &Connectors,
) -> CustomResult<Vec<(String, Maskable<String>)>, errors::ConnectorError> {
let date = OffsetDateTime::now_utc();
let boa_req = self.get_request_body(req, connectors)?;
let http_method = self.get_http_method();
let auth = bankofamerica::BankOfAmericaAuthType::try_from(&req.connector_auth_type)?;
let merchant_account = auth.merchant_account.clone();
let base_url = connectors.bankofamerica.base_url.as_str();
let boa_host =
Url::parse(base_url).change_context(errors::ConnectorError::RequestEncodingFailed)?;
let host = boa_host
.host_str()
.ok_or(errors::ConnectorError::RequestEncodingFailed)?;
let path: String = self
.get_url(req, connectors)?
.chars()
.skip(base_url.len() - 1)
.collect();
let sha256 = self.generate_digest(boa_req.get_inner_value().expose().as_bytes());
let signature = self.generate_signature(
auth,
host.to_string(),
path.as_str(),
&sha256,
date,
http_method,
)?;
let mut headers = vec![
(
headers::CONTENT_TYPE.to_string(),
self.get_content_type().to_string().into(),
),
(
headers::ACCEPT.to_string(),
"application/hal+json;charset=utf-8".to_string().into(),
),
(V_C_MERCHANT_ID.to_string(), merchant_account.into_masked()),
("Date".to_string(), date.to_string().into()),
("Host".to_string(), host.to_string().into()),
("Signature".to_string(), signature.into_masked()),
];
if matches!(http_method, Method::Post | Method::Put) {
headers.push((
"Digest".to_string(),
format!("SHA-256={sha256}").into_masked(),
));
}
Ok(headers)
}
}
impl ConnectorCommon for Bankofamerica {
fn id(&self) -> &'static str {
"bankofamerica"
}
fn get_currency_unit(&self) -> api::CurrencyUnit {
api::CurrencyUnit::Base
}
fn common_get_content_type(&self) -> &'static str {
"application/json;charset=utf-8"
}
fn base_url<'a>(&self, connectors: &'a Connectors) -> &'a str {
connectors.bankofamerica.base_url.as_ref()
}
fn build_error_response(
&self,
res: Response,
event_builder: Option<&mut ConnectorEvent>,
) -> CustomResult<ErrorResponse, errors::ConnectorError> {
let response: bankofamerica::BankOfAmericaErrorResponse = res
.response
.parse_struct("BankOfAmerica ErrorResponse")
.change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
event_builder.map(|i| i.set_error_response_body(&response));
router_env::logger::info!(connector_response=?response);
let error_message = if res.status_code == 401 {
constants::CONNECTOR_UNAUTHORIZED_ERROR
} else {
hyperswitch_interfaces::consts::NO_ERROR_MESSAGE
};
match response {
transformers::BankOfAmericaErrorResponse::StandardError(response) => {
let (code, message, reason) = match response.error_information {
Some(ref error_info) => {
let detailed_error_info = error_info.details.as_ref().map(|details| {
details
.iter()
.map(|det| format!("{} : {}", det.field, det.reason))
.collect::<Vec<_>>()
.join(", ")
});
(
error_info.reason.clone(),
error_info.reason.clone(),
transformers::get_error_reason(
Some(error_info.message.clone()),
detailed_error_info,
None,
),
)
}
None => {
let detailed_error_info = response.details.map(|details| {
details
.iter()
.map(|det| format!("{} : {}", det.field, det.reason))
.collect::<Vec<_>>()
.join(", ")
});
(
response.reason.clone().map_or(
hyperswitch_interfaces::consts::NO_ERROR_CODE.to_string(),
|reason| reason.to_string(),
),
response
.reason
.map_or(error_message.to_string(), |reason| reason.to_string()),
transformers::get_error_reason(
response.message,
detailed_error_info,
None,
),
)
}
};
Ok(ErrorResponse {
status_code: res.status_code,
code,
message,
reason,
attempt_status: None,
connector_transaction_id: None,
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
connector_metadata: None,
})
}
transformers::BankOfAmericaErrorResponse::AuthenticationError(response) => {
Ok(ErrorResponse {
status_code: res.status_code,
code: hyperswitch_interfaces::consts::NO_ERROR_CODE.to_string(),
message: response.response.rmsg.clone(),
reason: Some(response.response.rmsg),
attempt_status: None,
connector_transaction_id: None,
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
connector_metadata: None,
})
}
}
}
}
impl ConnectorValidation for Bankofamerica {
fn validate_mandate_payment(
&self,
pm_type: Option<enums::PaymentMethodType>,
pm_data: PaymentMethodData,
) -> CustomResult<(), errors::ConnectorError> {
let mandate_supported_pmd = std::collections::HashSet::from([
PaymentMethodDataType::Card,
PaymentMethodDataType::ApplePay,
PaymentMethodDataType::GooglePay,
]);
utils::is_mandate_supported(pm_data, pm_type, mandate_supported_pmd, self.id())
}
}
impl ConnectorIntegration<Session, PaymentsSessionData, PaymentsResponseData> for Bankofamerica {
//TODO: implement sessions flow
}
impl ConnectorIntegration<AccessTokenAuth, AccessTokenRequestData, AccessToken> for Bankofamerica {}
impl ConnectorIntegration<SetupMandate, SetupMandateRequestData, PaymentsResponseData>
for Bankofamerica
{
fn get_headers(
&self,
req: &SetupMandateRouterData,
connectors: &Connectors,
) -> CustomResult<Vec<(String, Maskable<String>)>, errors::ConnectorError> {
self.build_headers(req, connectors)
}
fn get_content_type(&self) -> &'static str {
self.common_get_content_type()
}
fn get_url(
&self,
_req: &SetupMandateRouterData,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
Ok(format!("{}pts/v2/payments/", self.base_url(connectors)))
}
fn get_request_body(
&self,
req: &SetupMandateRouterData,
_connectors: &Connectors,
) -> CustomResult<RequestContent, errors::ConnectorError> {
let connector_req = bankofamerica::BankOfAmericaPaymentsRequest::try_from(req)?;
Ok(RequestContent::Json(Box::new(connector_req)))
}
fn build_request(
&self,
req: &RouterData<SetupMandate, SetupMandateRequestData, PaymentsResponseData>,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Ok(Some(
RequestBuilder::new()
.method(Method::Post)
.url(&SetupMandateType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(SetupMandateType::get_headers(self, req, connectors)?)
.set_body(SetupMandateType::get_request_body(self, req, connectors)?)
.build(),
))
}
fn handle_response(
&self,
data: &SetupMandateRouterData,
event_builder: Option<&mut ConnectorEvent>,
res: Response,
) -> CustomResult<SetupMandateRouterData, errors::ConnectorError> {
let response: bankofamerica::BankOfAmericaSetupMandatesResponse = res
.response
.parse_struct("BankOfAmericaSetupMandatesResponse")
.change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
event_builder.map(|i| i.set_response_body(&response));
router_env::logger::info!(connector_response=?response);
RouterData::try_from(ResponseRouterData {
response,
data: data.clone(),
http_code: res.status_code,
})
}
fn get_error_response(
&self,
res: Response,
event_builder: Option<&mut ConnectorEvent>,
) -> CustomResult<ErrorResponse, errors::ConnectorError> {
self.build_error_response(res, event_builder)
}
fn get_5xx_error_response(
&self,
res: Response,
event_builder: Option<&mut ConnectorEvent>,
) -> CustomResult<ErrorResponse, errors::ConnectorError> {
let response: bankofamerica::BankOfAmericaServerErrorResponse = res
.response
.parse_struct("BankOfAmericaServerErrorResponse")
.change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
event_builder.map(|event| event.set_response_body(&response));
router_env::logger::info!(error_response=?response);
let attempt_status = match response.reason {
Some(reason) => match reason {
transformers::Reason::SystemError => Some(enums::AttemptStatus::Failure),
transformers::Reason::ServerTimeout | transformers::Reason::ServiceTimeout => None,
},
None => None,
};
Ok(ErrorResponse {
status_code: res.status_code,
reason: response.status.clone(),
code: response
.status
.unwrap_or(hyperswitch_interfaces::consts::NO_ERROR_CODE.to_string()),
message: response
.message
.unwrap_or(hyperswitch_interfaces::consts::NO_ERROR_MESSAGE.to_string()),
attempt_status,
connector_transaction_id: None,
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
connector_metadata: None,
})
}
}
impl ConnectorIntegration<Authorize, PaymentsAuthorizeData, PaymentsResponseData>
for Bankofamerica
{
fn get_headers(
&self,
req: &PaymentsAuthorizeRouterData,
connectors: &Connectors,
) -> CustomResult<Vec<(String, Maskable<String>)>, errors::ConnectorError> {
self.build_headers(req, connectors)
}
fn get_content_type(&self) -> &'static str {
self.common_get_content_type()
}
fn get_url(
&self,
_req: &PaymentsAuthorizeRouterData,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
Ok(format!(
"{}pts/v2/payments/",
ConnectorCommon::base_url(self, connectors)
))
}
fn get_request_body(
&self,
req: &PaymentsAuthorizeRouterData,
_connectors: &Connectors,
) -> CustomResult<RequestContent, errors::ConnectorError> {
let amount = convert_amount(
self.amount_convertor,
req.request.minor_amount,
req.request.currency,
)?;
let connector_router_data = BankOfAmericaRouterData::try_from((amount, req))?;
let connector_req =
bankofamerica::BankOfAmericaPaymentsRequest::try_from(&connector_router_data)?;
Ok(RequestContent::Json(Box::new(connector_req)))
}
fn build_request(
&self,
req: &PaymentsAuthorizeRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Ok(Some(
RequestBuilder::new()
.method(Method::Post)
.url(&PaymentsAuthorizeType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(PaymentsAuthorizeType::get_headers(self, req, connectors)?)
.set_body(PaymentsAuthorizeType::get_request_body(
self, req, connectors,
)?)
.build(),
))
}
fn handle_response(
&self,
data: &PaymentsAuthorizeRouterData,
event_builder: Option<&mut ConnectorEvent>,
res: Response,
) -> CustomResult<PaymentsAuthorizeRouterData, errors::ConnectorError> {
let response: bankofamerica::BankOfAmericaPaymentsResponse = res
.response
.parse_struct("Bankofamerica PaymentResponse")
.change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
event_builder.map(|i| i.set_response_body(&response));
router_env::logger::info!(connector_response=?response);
RouterData::try_from(ResponseRouterData {
response,
data: data.clone(),
http_code: res.status_code,
})
}
fn get_error_response(
&self,
res: Response,
event_builder: Option<&mut ConnectorEvent>,
) -> CustomResult<ErrorResponse, errors::ConnectorError> {
self.build_error_response(res, event_builder)
}
fn get_5xx_error_response(
&self,
res: Response,
event_builder: Option<&mut ConnectorEvent>,
) -> CustomResult<ErrorResponse, errors::ConnectorError> {
let response: bankofamerica::BankOfAmericaServerErrorResponse = res
.response
.parse_struct("BankOfAmericaServerErrorResponse")
.change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
event_builder.map(|event| event.set_response_body(&response));
router_env::logger::info!(error_response=?response);
let attempt_status = match response.reason {
Some(reason) => match reason {
transformers::Reason::SystemError => Some(enums::AttemptStatus::Failure),
transformers::Reason::ServerTimeout | transformers::Reason::ServiceTimeout => None,
},
None => None,
};
Ok(ErrorResponse {
status_code: res.status_code,
reason: response.status.clone(),
code: response
.status
.unwrap_or(hyperswitch_interfaces::consts::NO_ERROR_CODE.to_string()),
message: response
.message
.unwrap_or(hyperswitch_interfaces::consts::NO_ERROR_MESSAGE.to_string()),
attempt_status,
connector_transaction_id: None,
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
connector_metadata: None,
})
}
}
impl ConnectorIntegration<PSync, PaymentsSyncData, PaymentsResponseData> for Bankofamerica {
fn get_headers(
&self,
req: &PaymentsSyncRouterData,
connectors: &Connectors,
) -> CustomResult<Vec<(String, Maskable<String>)>, errors::ConnectorError> {
self.build_headers(req, connectors)
}
fn get_content_type(&self) -> &'static str {
self.common_get_content_type()
}
fn get_http_method(&self) -> Method {
Method::Get
}
fn get_url(
&self,
req: &PaymentsSyncRouterData,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
let connector_payment_id = req
.request
.connector_transaction_id
.get_connector_transaction_id()
.change_context(errors::ConnectorError::MissingConnectorTransactionID)?;
Ok(format!(
"{}tss/v2/transactions/{connector_payment_id}",
self.base_url(connectors)
))
}
fn build_request(
&self,
req: &PaymentsSyncRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Ok(Some(
RequestBuilder::new()
.method(Method::Get)
.url(&PaymentsSyncType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(PaymentsSyncType::get_headers(self, req, connectors)?)
.build(),
))
}
fn handle_response(
&self,
data: &PaymentsSyncRouterData,
event_builder: Option<&mut ConnectorEvent>,
res: Response,
) -> CustomResult<PaymentsSyncRouterData, errors::ConnectorError> {
let response: bankofamerica::BankOfAmericaTransactionResponse = res
.response
.parse_struct("BankOfAmerica PaymentSyncResponse")
.change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
event_builder.map(|i| i.set_response_body(&response));
router_env::logger::info!(connector_response=?response);
RouterData::try_from(ResponseRouterData {
response,
data: data.clone(),
http_code: res.status_code,
})
}
fn get_error_response(
&self,
res: Response,
event_builder: Option<&mut ConnectorEvent>,
) -> CustomResult<ErrorResponse, errors::ConnectorError> {
self.build_error_response(res, event_builder)
}
}
impl ConnectorIntegration<Capture, PaymentsCaptureData, PaymentsResponseData> for Bankofamerica {
fn get_headers(
&self,
req: &PaymentsCaptureRouterData,
connectors: &Connectors,
) -> CustomResult<Vec<(String, Maskable<String>)>, errors::ConnectorError> {
self.build_headers(req, connectors)
}
fn get_content_type(&self) -> &'static str {
self.common_get_content_type()
}
fn get_url(
&self,
req: &PaymentsCaptureRouterData,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
let connector_payment_id = req.request.connector_transaction_id.clone();
Ok(format!(
"{}pts/v2/payments/{connector_payment_id}/captures",
self.base_url(connectors)
))
}
fn get_request_body(
&self,
req: &PaymentsCaptureRouterData,
_connectors: &Connectors,
) -> CustomResult<RequestContent, errors::ConnectorError> {
let amount = convert_amount(
self.amount_convertor,
req.request.minor_amount_to_capture,
req.request.currency,
)?;
let connector_router_data = BankOfAmericaRouterData::try_from((amount, req))?;
let connector_req =
bankofamerica::BankOfAmericaCaptureRequest::try_from(&connector_router_data)?;
Ok(RequestContent::Json(Box::new(connector_req)))
}
fn build_request(
&self,
req: &PaymentsCaptureRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Ok(Some(
RequestBuilder::new()
.method(Method::Post)
.url(&PaymentsCaptureType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(PaymentsCaptureType::get_headers(self, req, connectors)?)
.set_body(PaymentsCaptureType::get_request_body(
self, req, connectors,
)?)
.build(),
))
}
fn handle_response(
&self,
data: &PaymentsCaptureRouterData,
event_builder: Option<&mut ConnectorEvent>,
res: Response,
) -> CustomResult<PaymentsCaptureRouterData, errors::ConnectorError> {
let response: bankofamerica::BankOfAmericaPaymentsResponse = res
.response
.parse_struct("BankOfAmerica PaymentResponse")
.change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
event_builder.map(|i| i.set_response_body(&response));
router_env::logger::info!(connector_response=?response);
RouterData::try_from(ResponseRouterData {
response,
data: data.clone(),
http_code: res.status_code,
})
}
fn get_error_response(
&self,
res: Response,
event_builder: Option<&mut ConnectorEvent>,
) -> CustomResult<ErrorResponse, errors::ConnectorError> {
self.build_error_response(res, event_builder)
}
fn get_5xx_error_response(
&self,
res: Response,
event_builder: Option<&mut ConnectorEvent>,
) -> CustomResult<ErrorResponse, errors::ConnectorError> {
let response: bankofamerica::BankOfAmericaServerErrorResponse = res
.response
.parse_struct("BankOfAmericaServerErrorResponse")
.change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
event_builder.map(|event| event.set_response_body(&response));
router_env::logger::info!(error_response=?response);
Ok(ErrorResponse {
status_code: res.status_code,
reason: response.status.clone(),
code: response
.status
.unwrap_or(hyperswitch_interfaces::consts::NO_ERROR_CODE.to_string()),
message: response
.message
.unwrap_or(hyperswitch_interfaces::consts::NO_ERROR_MESSAGE.to_string()),
attempt_status: None,
connector_transaction_id: None,
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
connector_metadata: None,
})
}
}
impl ConnectorIntegration<Void, PaymentsCancelData, PaymentsResponseData> for Bankofamerica {
fn get_headers(
&self,
req: &PaymentsCancelRouterData,
connectors: &Connectors,
) -> CustomResult<Vec<(String, Maskable<String>)>, errors::ConnectorError> {
self.build_headers(req, connectors)
}
fn get_url(
&self,
req: &PaymentsCancelRouterData,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
let connector_payment_id = req.request.connector_transaction_id.clone();
Ok(format!(
"{}pts/v2/payments/{connector_payment_id}/reversals",
self.base_url(connectors)
))
}
fn get_content_type(&self) -> &'static str {
self.common_get_content_type()
}
fn get_request_body(
&self,
req: &PaymentsCancelRouterData,
_connectors: &Connectors,
) -> CustomResult<RequestContent, errors::ConnectorError> {
let minor_amount =
req.request
.minor_amount
.ok_or(errors::ConnectorError::MissingRequiredField {
field_name: "Amount",
})?;
let currency =
req.request
.currency
.ok_or(errors::ConnectorError::MissingRequiredField {
field_name: "Currency",
})?;
let amount = convert_amount(self.amount_convertor, minor_amount, currency)?;
let connector_router_data = BankOfAmericaRouterData::try_from((amount, req))?;
let connector_req =
bankofamerica::BankOfAmericaVoidRequest::try_from(&connector_router_data)?;
Ok(RequestContent::Json(Box::new(connector_req)))
}
fn build_request(
&self,
req: &PaymentsCancelRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Ok(Some(
RequestBuilder::new()
.method(Method::Post)
.url(&PaymentsVoidType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(PaymentsVoidType::get_headers(self, req, connectors)?)
.set_body(PaymentsVoidType::get_request_body(self, req, connectors)?)
.build(),
))
}
fn handle_response(
&self,
data: &PaymentsCancelRouterData,
event_builder: Option<&mut ConnectorEvent>,
res: Response,
) -> CustomResult<PaymentsCancelRouterData, errors::ConnectorError> {
let response: bankofamerica::BankOfAmericaPaymentsResponse = res
.response
.parse_struct("BankOfAmerica PaymentResponse")
.change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
event_builder.map(|i| i.set_response_body(&response));
router_env::logger::info!(connector_response=?response);
RouterData::try_from(ResponseRouterData {
response,
data: data.clone(),
http_code: res.status_code,
})
}
fn get_error_response(
&self,
res: Response,
event_builder: Option<&mut ConnectorEvent>,
) -> CustomResult<ErrorResponse, errors::ConnectorError> {
self.build_error_response(res, event_builder)
}
fn get_5xx_error_response(
&self,
res: Response,
event_builder: Option<&mut ConnectorEvent>,
) -> CustomResult<ErrorResponse, errors::ConnectorError> {
let response: bankofamerica::BankOfAmericaServerErrorResponse = res
.response
.parse_struct("BankOfAmericaServerErrorResponse")
.change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
event_builder.map(|event| event.set_response_body(&response));
router_env::logger::info!(error_response=?response);
Ok(ErrorResponse {
status_code: res.status_code,
reason: response.status.clone(),
code: response
.status
.unwrap_or(hyperswitch_interfaces::consts::NO_ERROR_CODE.to_string()),
message: response
.message
.unwrap_or(hyperswitch_interfaces::consts::NO_ERROR_MESSAGE.to_string()),
attempt_status: None,
connector_transaction_id: None,
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
connector_metadata: None,
})
}
}
impl ConnectorIntegration<Execute, RefundsData, RefundsResponseData> for Bankofamerica {
fn get_headers(
&self,
req: &RefundsRouterData<Execute>,
connectors: &Connectors,
) -> CustomResult<Vec<(String, Maskable<String>)>, errors::ConnectorError> {
self.build_headers(req, connectors)
}
fn get_content_type(&self) -> &'static str {
self.common_get_content_type()
}
fn get_url(
&self,
req: &RefundsRouterData<Execute>,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
let connector_payment_id = req.request.connector_transaction_id.clone();
Ok(format!(
"{}pts/v2/payments/{connector_payment_id}/refunds",
self.base_url(connectors)
))
}
fn get_request_body(
&self,
req: &RefundsRouterData<Execute>,
_connectors: &Connectors,
) -> CustomResult<RequestContent, errors::ConnectorError> {
let amount = convert_amount(
self.amount_convertor,
req.request.minor_refund_amount,
req.request.currency,
)?;
let connector_router_data = BankOfAmericaRouterData::try_from((amount, req))?;
let connector_req =
bankofamerica::BankOfAmericaRefundRequest::try_from(&connector_router_data)?;
Ok(RequestContent::Json(Box::new(connector_req)))
}
fn build_request(
&self,
req: &RefundsRouterData<Execute>,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
let request = RequestBuilder::new()
.method(Method::Post)
.url(&RefundExecuteType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(RefundExecuteType::get_headers(self, req, connectors)?)
.set_body(RefundExecuteType::get_request_body(self, req, connectors)?)
.build();
Ok(Some(request))
}
fn handle_response(
&self,
data: &RefundsRouterData<Execute>,
event_builder: Option<&mut ConnectorEvent>,
res: Response,
) -> CustomResult<RefundsRouterData<Execute>, errors::ConnectorError> {
let response: bankofamerica::BankOfAmericaRefundResponse = res
.response
.parse_struct("bankofamerica RefundResponse")
.change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
event_builder.map(|i| i.set_response_body(&response));
router_env::logger::info!(connector_response=?response);
RouterData::try_from(ResponseRouterData {
response,
data: data.clone(),
http_code: res.status_code,
})
}
fn get_error_response(
&self,
res: Response,
event_builder: Option<&mut ConnectorEvent>,
) -> CustomResult<ErrorResponse, errors::ConnectorError> {
self.build_error_response(res, event_builder)
}
}
impl ConnectorIntegration<RSync, RefundsData, RefundsResponseData> for Bankofamerica {
fn get_headers(
&self,
req: &RefundSyncRouterData,
connectors: &Connectors,
) -> CustomResult<Vec<(String, Maskable<String>)>, errors::ConnectorError> {
self.build_headers(req, connectors)
}
fn get_content_type(&self) -> &'static str {
self.common_get_content_type()
}
fn get_http_method(&self) -> Method {
Method::Get
}
fn get_url(
&self,
req: &RefundSyncRouterData,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
let refund_id = req.request.get_connector_refund_id()?;
Ok(format!(
"{}tss/v2/transactions/{refund_id}",
self.base_url(connectors)
))
}
fn build_request(
&self,
req: &RefundSyncRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Ok(Some(
RequestBuilder::new()
.method(Method::Get)
.url(&RefundSyncType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(RefundSyncType::get_headers(self, req, connectors)?)
.build(),
))
}
fn handle_response(
&self,
data: &RefundSyncRouterData,
event_builder: Option<&mut ConnectorEvent>,
res: Response,
) -> CustomResult<RefundSyncRouterData, errors::ConnectorError> {
let response: bankofamerica::BankOfAmericaRsyncResponse = res
.response
.parse_struct("bankofamerica RefundSyncResponse")
.change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
event_builder.map(|i| i.set_response_body(&response));
router_env::logger::info!(connector_response=?response);
RouterData::try_from(ResponseRouterData {
response,
data: data.clone(),
http_code: res.status_code,
})
}
fn get_error_response(
&self,
res: Response,
event_builder: Option<&mut ConnectorEvent>,
) -> CustomResult<ErrorResponse, errors::ConnectorError> {
self.build_error_response(res, event_builder)
}
}
#[async_trait::async_trait]
impl webhooks::IncomingWebhook for Bankofamerica {
fn get_webhook_object_reference_id(
&self,
_request: &webhooks::IncomingWebhookRequestDetails<'_>,
) -> CustomResult<api_models::webhooks::ObjectReferenceId, errors::ConnectorError> {
Err(report!(errors::ConnectorError::WebhooksNotImplemented))
}
fn get_webhook_event_type(
&self,
_request: &webhooks::IncomingWebhookRequestDetails<'_>,
) -> CustomResult<api_models::webhooks::IncomingWebhookEvent, errors::ConnectorError> {
|
crates/hyperswitch_connectors/src/connectors/bankofamerica.rs#chunk0
|
hyperswitch_connectors
|
chunk
| null | null | null | 8,180
| null | null | null | null | null | null | null |
// Struct: RiskFactorsInner
// File: crates/hyperswitch_connectors/src/connectors/worldpay/response.rs
// Module: hyperswitch_connectors
// Implementations: 1
pub struct RiskFactorsInner
|
crates/hyperswitch_connectors/src/connectors/worldpay/response.rs
|
hyperswitch_connectors
|
struct_definition
|
RiskFactorsInner
| 1
|
[] | 45
| null | null | null | null | null | null | null |
// Struct: HyperwalletAuthType
// File: crates/hyperswitch_connectors/src/connectors/hyperwallet/transformers.rs
// Module: hyperswitch_connectors
// Implementations: 0
pub struct HyperwalletAuthType
|
crates/hyperswitch_connectors/src/connectors/hyperwallet/transformers.rs
|
hyperswitch_connectors
|
struct_definition
|
HyperwalletAuthType
| 0
|
[] | 50
| null | null | null | null | null | null | null |
// File: crates/analytics/src/api_event/metrics/api_count.rs
// Module: analytics
use std::collections::HashSet;
use api_models::analytics::{
api_event::{ApiEventDimensions, ApiEventFilters, ApiEventMetricsBucketIdentifier},
Granularity, TimeRange,
};
use common_utils::errors::ReportSwitchExt;
use error_stack::ResultExt;
use time::PrimitiveDateTime;
use super::ApiEventMetricRow;
use crate::{
query::{Aggregate, GroupByClause, QueryBuilder, QueryFilter, SeriesBucket, ToSql, Window},
types::{AnalyticsCollection, AnalyticsDataSource, MetricsError, MetricsResult},
};
#[derive(Default)]
pub(super) struct ApiCount;
#[async_trait::async_trait]
impl<T> super::ApiEventMetric<T> for ApiCount
where
T: AnalyticsDataSource + super::ApiEventMetricAnalytics,
PrimitiveDateTime: ToSql<T>,
AnalyticsCollection: ToSql<T>,
Granularity: GroupByClause<T>,
Aggregate<&'static str>: ToSql<T>,
Window<&'static str>: ToSql<T>,
{
async fn load_metrics(
&self,
_dimensions: &[ApiEventDimensions],
merchant_id: &common_utils::id_type::MerchantId,
filters: &ApiEventFilters,
granularity: Option<Granularity>,
time_range: &TimeRange,
pool: &T,
) -> MetricsResult<HashSet<(ApiEventMetricsBucketIdentifier, ApiEventMetricRow)>> {
let mut query_builder: QueryBuilder<T> = QueryBuilder::new(AnalyticsCollection::ApiEvents);
query_builder
.add_select_column(Aggregate::Count {
field: None,
alias: Some("api_count"),
})
.switch()?;
if !filters.flow_type.is_empty() {
query_builder
.add_filter_in_range_clause(ApiEventDimensions::FlowType, &filters.flow_type)
.attach_printable("Error adding flow_type filter")
.switch()?;
}
query_builder
.add_select_column(Aggregate::Min {
field: "created_at",
alias: Some("start_bucket"),
})
.switch()?;
query_builder
.add_select_column(Aggregate::Max {
field: "created_at",
alias: Some("end_bucket"),
})
.switch()?;
if let Some(granularity) = granularity {
granularity
.set_group_by_clause(&mut query_builder)
.attach_printable("Error adding granularity")
.switch()?;
}
query_builder
.add_filter_clause("merchant_id", merchant_id)
.switch()?;
time_range
.set_filter_clause(&mut query_builder)
.attach_printable("Error filtering time range")
.switch()?;
query_builder
.execute_query::<ApiEventMetricRow, _>(pool)
.await
.change_context(MetricsError::QueryBuildingError)?
.change_context(MetricsError::QueryExecutionFailure)?
.into_iter()
.map(|i| {
Ok((
ApiEventMetricsBucketIdentifier::new(TimeRange {
start_time: match (granularity, i.start_bucket) {
(Some(g), Some(st)) => g.clip_to_start(st)?,
_ => time_range.start_time,
},
end_time: granularity.as_ref().map_or_else(
|| Ok(time_range.end_time),
|g| i.end_bucket.map(|et| g.clip_to_end(et)).transpose(),
)?,
}),
i,
))
})
.collect::<error_stack::Result<
HashSet<(ApiEventMetricsBucketIdentifier, ApiEventMetricRow)>,
crate::query::PostProcessingError,
>>()
.change_context(MetricsError::PostProcessingFailure)
}
}
|
crates/analytics/src/api_event/metrics/api_count.rs
|
analytics
|
full_file
| null | null | null | 795
| null | null | null | null | null | null | null |
// Function: generate_pm_vaulting_req_from_update_request
// File: crates/router/src/core/payment_methods/transformers.rs
// Module: router
pub fn generate_pm_vaulting_req_from_update_request(
pm_create: domain::PaymentMethodVaultingData,
pm_update: api::PaymentMethodUpdateData,
) -> domain::PaymentMethodVaultingData
|
crates/router/src/core/payment_methods/transformers.rs
|
router
|
function_signature
| null | null | null | 76
|
generate_pm_vaulting_req_from_update_request
| null | null | null | null | null | null |
authentication_type: None,
payment_method: None,
error_message: None,
payment_method_id: None,
mandate_id: None,
browser_info: None,
payment_token: None,
error_code: None,
connector_metadata: None,
payment_method_data: None,
payment_method_type: None,
payment_experience: None,
business_sub_label: None,
straight_through_algorithm: None,
preprocessing_step_id: None,
error_reason: None,
capture_method: None,
connector_response_reference_id: None,
multiple_capture_count: None,
surcharge_amount: None,
tax_amount: None,
amount_capturable: None,
merchant_connector_id: None,
authentication_data: None,
encoded_data: None,
unified_code: None,
unified_message: None,
external_three_ds_authentication_attempted: None,
authentication_connector: None,
authentication_id: None,
fingerprint_id: None,
payment_method_billing_address_id: None,
client_source: None,
client_version: None,
customer_acceptance: None,
card_network: None,
shipping_cost: None,
order_tax_amount: None,
capture_before: None,
extended_authorization_applied: None,
processor_transaction_data: None,
connector_mandate_detail: None,
card_discovery: None,
charges: None,
issuer_error_code: None,
issuer_error_message: None,
setup_future_usage_applied: None,
routing_approach: None,
connector_request_reference_id: None,
network_transaction_id: None,
is_overcapture_enabled: None,
network_details: None,
is_stored_credential: None,
request_extended_authorization: None,
},
PaymentAttemptUpdate::RejectUpdate {
status,
error_code,
error_message,
updated_by,
} => Self {
status: Some(status),
modified_at: common_utils::date_time::now(),
error_code,
error_message,
updated_by,
amount: None,
net_amount: None,
currency: None,
connector_transaction_id: None,
amount_to_capture: None,
connector: None,
authentication_type: None,
payment_method: None,
payment_method_id: None,
cancellation_reason: None,
mandate_id: None,
browser_info: None,
payment_token: None,
connector_metadata: None,
payment_method_data: None,
payment_method_type: None,
payment_experience: None,
business_sub_label: None,
straight_through_algorithm: None,
preprocessing_step_id: None,
error_reason: None,
capture_method: None,
connector_response_reference_id: None,
multiple_capture_count: None,
surcharge_amount: None,
tax_amount: None,
amount_capturable: None,
merchant_connector_id: None,
authentication_data: None,
encoded_data: None,
unified_code: None,
unified_message: None,
external_three_ds_authentication_attempted: None,
authentication_connector: None,
authentication_id: None,
fingerprint_id: None,
payment_method_billing_address_id: None,
client_source: None,
client_version: None,
customer_acceptance: None,
card_network: None,
shipping_cost: None,
order_tax_amount: None,
capture_before: None,
extended_authorization_applied: None,
processor_transaction_data: None,
connector_mandate_detail: None,
card_discovery: None,
charges: None,
issuer_error_code: None,
issuer_error_message: None,
setup_future_usage_applied: None,
routing_approach: None,
connector_request_reference_id: None,
network_transaction_id: None,
is_overcapture_enabled: None,
network_details: None,
is_stored_credential: None,
request_extended_authorization: None,
},
PaymentAttemptUpdate::BlocklistUpdate {
status,
error_code,
error_message,
updated_by,
} => Self {
status: Some(status),
modified_at: common_utils::date_time::now(),
error_code,
connector: Some(None),
error_message,
updated_by,
merchant_connector_id: Some(None),
amount: None,
net_amount: None,
currency: None,
connector_transaction_id: None,
amount_to_capture: None,
authentication_type: None,
payment_method: None,
payment_method_id: None,
cancellation_reason: None,
mandate_id: None,
browser_info: None,
payment_token: None,
connector_metadata: None,
payment_method_data: None,
payment_method_type: None,
payment_experience: None,
business_sub_label: None,
straight_through_algorithm: None,
preprocessing_step_id: None,
error_reason: None,
capture_method: None,
connector_response_reference_id: None,
multiple_capture_count: None,
surcharge_amount: None,
tax_amount: None,
amount_capturable: None,
authentication_data: None,
encoded_data: None,
unified_code: None,
unified_message: None,
external_three_ds_authentication_attempted: None,
authentication_connector: None,
authentication_id: None,
fingerprint_id: None,
payment_method_billing_address_id: None,
client_source: None,
client_version: None,
customer_acceptance: None,
card_network: None,
shipping_cost: None,
order_tax_amount: None,
capture_before: None,
extended_authorization_applied: None,
processor_transaction_data: None,
connector_mandate_detail: None,
card_discovery: None,
charges: None,
issuer_error_code: None,
issuer_error_message: None,
setup_future_usage_applied: None,
routing_approach: None,
connector_request_reference_id: None,
network_transaction_id: None,
is_overcapture_enabled: None,
network_details: None,
is_stored_credential: None,
request_extended_authorization: None,
},
PaymentAttemptUpdate::ConnectorMandateDetailUpdate {
connector_mandate_detail,
updated_by,
} => Self {
payment_method_id: None,
modified_at: common_utils::date_time::now(),
updated_by,
amount: None,
net_amount: None,
currency: None,
status: None,
connector_transaction_id: None,
amount_to_capture: None,
connector: None,
authentication_type: None,
payment_method: None,
error_message: None,
cancellation_reason: None,
mandate_id: None,
browser_info: None,
payment_token: None,
error_code: None,
connector_metadata: None,
payment_method_data: None,
payment_method_type: None,
payment_experience: None,
business_sub_label: None,
straight_through_algorithm: None,
preprocessing_step_id: None,
error_reason: None,
capture_method: None,
connector_response_reference_id: None,
multiple_capture_count: None,
surcharge_amount: None,
tax_amount: None,
amount_capturable: None,
merchant_connector_id: None,
authentication_data: None,
encoded_data: None,
unified_code: None,
unified_message: None,
external_three_ds_authentication_attempted: None,
authentication_connector: None,
authentication_id: None,
fingerprint_id: None,
payment_method_billing_address_id: None,
client_source: None,
client_version: None,
customer_acceptance: None,
card_network: None,
shipping_cost: None,
order_tax_amount: None,
capture_before: None,
extended_authorization_applied: None,
processor_transaction_data: None,
connector_mandate_detail,
card_discovery: None,
charges: None,
issuer_error_code: None,
issuer_error_message: None,
setup_future_usage_applied: None,
routing_approach: None,
connector_request_reference_id: None,
network_transaction_id: None,
is_overcapture_enabled: None,
network_details: None,
is_stored_credential: None,
request_extended_authorization: None,
},
PaymentAttemptUpdate::PaymentMethodDetailsUpdate {
payment_method_id,
updated_by,
} => Self {
payment_method_id,
modified_at: common_utils::date_time::now(),
updated_by,
amount: None,
net_amount: None,
currency: None,
status: None,
connector_transaction_id: None,
amount_to_capture: None,
connector: None,
authentication_type: None,
payment_method: None,
error_message: None,
cancellation_reason: None,
mandate_id: None,
browser_info: None,
payment_token: None,
error_code: None,
connector_metadata: None,
payment_method_data: None,
payment_method_type: None,
payment_experience: None,
business_sub_label: None,
straight_through_algorithm: None,
preprocessing_step_id: None,
error_reason: None,
capture_method: None,
connector_response_reference_id: None,
multiple_capture_count: None,
surcharge_amount: None,
tax_amount: None,
amount_capturable: None,
merchant_connector_id: None,
authentication_data: None,
encoded_data: None,
unified_code: None,
unified_message: None,
external_three_ds_authentication_attempted: None,
authentication_connector: None,
authentication_id: None,
fingerprint_id: None,
payment_method_billing_address_id: None,
client_source: None,
client_version: None,
customer_acceptance: None,
card_network: None,
shipping_cost: None,
order_tax_amount: None,
capture_before: None,
extended_authorization_applied: None,
processor_transaction_data: None,
connector_mandate_detail: None,
card_discovery: None,
charges: None,
issuer_error_code: None,
issuer_error_message: None,
setup_future_usage_applied: None,
routing_approach: None,
connector_request_reference_id: None,
network_transaction_id: None,
is_overcapture_enabled: None,
network_details: None,
is_stored_credential: None,
request_extended_authorization: None,
},
PaymentAttemptUpdate::ResponseUpdate {
status,
connector,
connector_transaction_id,
authentication_type,
payment_method_id,
mandate_id,
connector_metadata,
payment_token,
error_code,
error_message,
error_reason,
connector_response_reference_id,
amount_capturable,
updated_by,
authentication_data,
encoded_data,
unified_code,
unified_message,
capture_before,
extended_authorization_applied,
payment_method_data,
connector_mandate_detail,
charges,
setup_future_usage_applied,
network_transaction_id,
is_overcapture_enabled,
} => {
let (connector_transaction_id, processor_transaction_data) =
connector_transaction_id
.map(ConnectorTransactionId::form_id_and_data)
.map(|(txn_id, txn_data)| (Some(txn_id), txn_data))
.unwrap_or((None, None));
Self {
status: Some(status),
connector: connector.map(Some),
connector_transaction_id,
authentication_type,
payment_method_id,
modified_at: common_utils::date_time::now(),
mandate_id,
connector_metadata,
error_code,
error_message,
payment_token,
error_reason,
connector_response_reference_id,
amount_capturable,
updated_by,
authentication_data,
encoded_data,
unified_code,
unified_message,
payment_method_data,
processor_transaction_data,
connector_mandate_detail,
charges,
amount: None,
net_amount: None,
currency: None,
amount_to_capture: None,
payment_method: None,
cancellation_reason: None,
browser_info: None,
payment_method_type: None,
payment_experience: None,
business_sub_label: None,
straight_through_algorithm: None,
preprocessing_step_id: None,
capture_method: None,
multiple_capture_count: None,
surcharge_amount: None,
tax_amount: None,
merchant_connector_id: None,
external_three_ds_authentication_attempted: None,
authentication_connector: None,
authentication_id: None,
fingerprint_id: None,
payment_method_billing_address_id: None,
client_source: None,
client_version: None,
customer_acceptance: None,
card_network: None,
capture_before,
extended_authorization_applied,
shipping_cost: None,
order_tax_amount: None,
card_discovery: None,
issuer_error_code: None,
issuer_error_message: None,
setup_future_usage_applied,
routing_approach: None,
connector_request_reference_id: None,
network_transaction_id,
is_overcapture_enabled,
network_details: None,
is_stored_credential: None,
request_extended_authorization: None,
}
}
PaymentAttemptUpdate::ErrorUpdate {
connector,
status,
error_code,
error_message,
error_reason,
amount_capturable,
updated_by,
unified_code,
unified_message,
connector_transaction_id,
payment_method_data,
authentication_type,
issuer_error_code,
issuer_error_message,
network_details,
} => {
let (connector_transaction_id, processor_transaction_data) =
connector_transaction_id
.map(ConnectorTransactionId::form_id_and_data)
.map(|(txn_id, txn_data)| (Some(txn_id), txn_data))
.unwrap_or((None, None));
Self {
connector: connector.map(Some),
status: Some(status),
error_message,
error_code,
modified_at: common_utils::date_time::now(),
error_reason,
amount_capturable,
updated_by,
unified_code,
unified_message,
connector_transaction_id,
payment_method_data,
authentication_type,
processor_transaction_data,
issuer_error_code,
issuer_error_message,
amount: None,
net_amount: None,
currency: None,
amount_to_capture: None,
payment_method: None,
payment_method_id: None,
cancellation_reason: None,
mandate_id: None,
browser_info: None,
payment_token: None,
connector_metadata: None,
payment_method_type: None,
payment_experience: None,
business_sub_label: None,
straight_through_algorithm: None,
preprocessing_step_id: None,
capture_method: None,
connector_response_reference_id: None,
multiple_capture_count: None,
surcharge_amount: None,
tax_amount: None,
merchant_connector_id: None,
authentication_data: None,
encoded_data: None,
external_three_ds_authentication_attempted: None,
authentication_connector: None,
authentication_id: None,
fingerprint_id: None,
payment_method_billing_address_id: None,
client_source: None,
client_version: None,
customer_acceptance: None,
card_network: None,
capture_before: None,
extended_authorization_applied: None,
shipping_cost: None,
order_tax_amount: None,
connector_mandate_detail: None,
card_discovery: None,
charges: None,
setup_future_usage_applied: None,
routing_approach: None,
connector_request_reference_id: None,
network_transaction_id: None,
is_overcapture_enabled: None,
network_details,
is_stored_credential: None,
request_extended_authorization: None,
}
}
PaymentAttemptUpdate::StatusUpdate { status, updated_by } => Self {
status: Some(status),
modified_at: common_utils::date_time::now(),
updated_by,
amount: None,
net_amount: None,
currency: None,
connector_transaction_id: None,
amount_to_capture: None,
connector: None,
authentication_type: None,
payment_method: None,
error_message: None,
payment_method_id: None,
cancellation_reason: None,
mandate_id: None,
browser_info: None,
payment_token: None,
error_code: None,
connector_metadata: None,
payment_method_data: None,
payment_method_type: None,
payment_experience: None,
business_sub_label: None,
straight_through_algorithm: None,
preprocessing_step_id: None,
error_reason: None,
capture_method: None,
connector_response_reference_id: None,
multiple_capture_count: None,
surcharge_amount: None,
tax_amount: None,
amount_capturable: None,
merchant_connector_id: None,
authentication_data: None,
encoded_data: None,
unified_code: None,
unified_message: None,
external_three_ds_authentication_attempted: None,
authentication_connector: None,
authentication_id: None,
fingerprint_id: None,
payment_method_billing_address_id: None,
client_source: None,
client_version: None,
customer_acceptance: None,
card_network: None,
shipping_cost: None,
capture_before: None,
extended_authorization_applied: None,
order_tax_amount: None,
processor_transaction_data: None,
connector_mandate_detail: None,
card_discovery: None,
charges: None,
issuer_error_code: None,
issuer_error_message: None,
setup_future_usage_applied: None,
routing_approach: None,
connector_request_reference_id: None,
network_transaction_id: None,
is_overcapture_enabled: None,
network_details: None,
is_stored_credential: None,
request_extended_authorization: None,
},
PaymentAttemptUpdate::UpdateTrackers {
payment_token,
connector,
straight_through_algorithm,
amount_capturable,
surcharge_amount,
tax_amount,
updated_by,
merchant_connector_id,
routing_approach,
is_stored_credential,
} => Self {
payment_token,
modified_at: common_utils::date_time::now(),
connector: connector.map(Some),
straight_through_algorithm,
amount_capturable,
surcharge_amount,
tax_amount,
updated_by,
merchant_connector_id: merchant_connector_id.map(Some),
amount: None,
net_amount: None,
currency: None,
status: None,
connector_transaction_id: None,
amount_to_capture: None,
authentication_type: None,
payment_method: None,
error_message: None,
payment_method_id: None,
cancellation_reason: None,
mandate_id: None,
browser_info: None,
error_code: None,
connector_metadata: None,
payment_method_data: None,
payment_method_type: None,
payment_experience: None,
business_sub_label: None,
preprocessing_step_id: None,
error_reason: None,
capture_method: None,
connector_response_reference_id: None,
multiple_capture_count: None,
authentication_data: None,
encoded_data: None,
unified_code: None,
unified_message: None,
external_three_ds_authentication_attempted: None,
authentication_connector: None,
authentication_id: None,
fingerprint_id: None,
payment_method_billing_address_id: None,
client_source: None,
client_version: None,
customer_acceptance: None,
card_network: None,
shipping_cost: None,
capture_before: None,
extended_authorization_applied: None,
order_tax_amount: None,
processor_transaction_data: None,
connector_mandate_detail: None,
card_discovery: None,
charges: None,
issuer_error_code: None,
issuer_error_message: None,
setup_future_usage_applied: None,
routing_approach,
connector_request_reference_id: None,
network_transaction_id: None,
is_overcapture_enabled: None,
network_details: None,
is_stored_credential,
request_extended_authorization: None,
},
PaymentAttemptUpdate::UnresolvedResponseUpdate {
status,
connector,
connector_transaction_id,
payment_method_id,
error_code,
error_message,
error_reason,
connector_response_reference_id,
updated_by,
} => {
let (connector_transaction_id, processor_transaction_data) =
connector_transaction_id
.map(ConnectorTransactionId::form_id_and_data)
.map(|(txn_id, txn_data)| (Some(txn_id), txn_data))
.unwrap_or((None, None));
Self {
status: Some(status),
connector: connector.map(Some),
connector_transaction_id,
payment_method_id,
modified_at: common_utils::date_time::now(),
error_code,
error_message,
error_reason,
connector_response_reference_id,
updated_by,
processor_transaction_data,
amount: None,
net_amount: None,
currency: None,
amount_to_capture: None,
authentication_type: None,
payment_method: None,
cancellation_reason: None,
mandate_id: None,
browser_info: None,
payment_token: None,
connector_metadata: None,
payment_method_data: None,
payment_method_type: None,
payment_experience: None,
business_sub_label: None,
straight_through_algorithm: None,
preprocessing_step_id: None,
capture_method: None,
multiple_capture_count: None,
surcharge_amount: None,
tax_amount: None,
amount_capturable: None,
merchant_connector_id: None,
authentication_data: None,
encoded_data: None,
unified_code: None,
unified_message: None,
external_three_ds_authentication_attempted: None,
authentication_connector: None,
authentication_id: None,
fingerprint_id: None,
payment_method_billing_address_id: None,
client_source: None,
client_version: None,
customer_acceptance: None,
card_network: None,
shipping_cost: None,
capture_before: None,
extended_authorization_applied: None,
order_tax_amount: None,
connector_mandate_detail: None,
card_discovery: None,
charges: None,
issuer_error_code: None,
issuer_error_message: None,
setup_future_usage_applied: None,
routing_approach: None,
connector_request_reference_id: None,
network_transaction_id: None,
is_overcapture_enabled: None,
network_details: None,
is_stored_credential: None,
request_extended_authorization: None,
}
}
PaymentAttemptUpdate::PreprocessingUpdate {
status,
payment_method_id,
connector_metadata,
preprocessing_step_id,
connector_transaction_id,
connector_response_reference_id,
updated_by,
} => {
let (connector_transaction_id, processor_transaction_data) =
connector_transaction_id
.map(ConnectorTransactionId::form_id_and_data)
.map(|(txn_id, txn_data)| (Some(txn_id), txn_data))
.unwrap_or((None, None));
Self {
status: Some(status),
payment_method_id,
modified_at: common_utils::date_time::now(),
connector_metadata,
preprocessing_step_id,
connector_transaction_id,
connector_response_reference_id,
updated_by,
processor_transaction_data,
amount: None,
net_amount: None,
currency: None,
amount_to_capture: None,
connector: None,
authentication_type: None,
payment_method: None,
error_message: None,
cancellation_reason: None,
mandate_id: None,
browser_info: None,
payment_token: None,
error_code: None,
payment_method_data: None,
payment_method_type: None,
payment_experience: None,
business_sub_label: None,
straight_through_algorithm: None,
error_reason: None,
capture_method: None,
multiple_capture_count: None,
surcharge_amount: None,
tax_amount: None,
amount_capturable: None,
merchant_connector_id: None,
authentication_data: None,
encoded_data: None,
unified_code: None,
unified_message: None,
external_three_ds_authentication_attempted: None,
authentication_connector: None,
authentication_id: None,
fingerprint_id: None,
payment_method_billing_address_id: None,
client_source: None,
client_version: None,
customer_acceptance: None,
card_network: None,
capture_before: None,
extended_authorization_applied: None,
shipping_cost: None,
order_tax_amount: None,
connector_mandate_detail: None,
card_discovery: None,
charges: None,
issuer_error_code: None,
issuer_error_message: None,
setup_future_usage_applied: None,
routing_approach: None,
connector_request_reference_id: None,
network_transaction_id: None,
is_overcapture_enabled: None,
network_details: None,
is_stored_credential: None,
request_extended_authorization: None,
}
}
PaymentAttemptUpdate::CaptureUpdate {
multiple_capture_count,
updated_by,
amount_to_capture,
} => Self {
multiple_capture_count,
modified_at: common_utils::date_time::now(),
updated_by,
amount_to_capture,
amount: None,
net_amount: None,
currency: None,
status: None,
connector_transaction_id: None,
connector: None,
authentication_type: None,
payment_method: None,
error_message: None,
payment_method_id: None,
cancellation_reason: None,
mandate_id: None,
browser_info: None,
payment_token: None,
error_code: None,
connector_metadata: None,
payment_method_data: None,
payment_method_type: None,
payment_experience: None,
business_sub_label: None,
straight_through_algorithm: None,
preprocessing_step_id: None,
error_reason: None,
capture_method: None,
connector_response_reference_id: None,
surcharge_amount: None,
tax_amount: None,
amount_capturable: None,
merchant_connector_id: None,
authentication_data: None,
encoded_data: None,
unified_code: None,
unified_message: None,
external_three_ds_authentication_attempted: None,
authentication_connector: None,
authentication_id: None,
fingerprint_id: None,
payment_method_billing_address_id: None,
client_source: None,
client_version: None,
customer_acceptance: None,
card_network: None,
shipping_cost: None,
order_tax_amount: None,
capture_before: None,
extended_authorization_applied: None,
processor_transaction_data: None,
connector_mandate_detail: None,
card_discovery: None,
charges: None,
issuer_error_code: None,
issuer_error_message: None,
setup_future_usage_applied: None,
routing_approach: None,
connector_request_reference_id: None,
network_transaction_id: None,
is_overcapture_enabled: None,
network_details: None,
is_stored_credential: None,
request_extended_authorization: None,
},
PaymentAttemptUpdate::AmountToCaptureUpdate {
status,
amount_capturable,
updated_by,
} => Self {
status: Some(status),
modified_at: common_utils::date_time::now(),
amount_capturable: Some(amount_capturable),
updated_by,
amount: None,
net_amount: None,
currency: None,
connector_transaction_id: None,
amount_to_capture: None,
connector: None,
authentication_type: None,
payment_method: None,
error_message: None,
payment_method_id: None,
cancellation_reason: None,
mandate_id: None,
browser_info: None,
payment_token: None,
error_code: None,
connector_metadata: None,
payment_method_data: None,
payment_method_type: None,
payment_experience: None,
business_sub_label: None,
straight_through_algorithm: None,
preprocessing_step_id: None,
error_reason: None,
capture_method: None,
connector_response_reference_id: None,
multiple_capture_count: None,
surcharge_amount: None,
tax_amount: None,
merchant_connector_id: None,
authentication_data: None,
encoded_data: None,
unified_code: None,
unified_message: None,
external_three_ds_authentication_attempted: None,
authentication_connector: None,
authentication_id: None,
fingerprint_id: None,
payment_method_billing_address_id: None,
client_source: None,
client_version: None,
customer_acceptance: None,
card_network: None,
shipping_cost: None,
capture_before: None,
extended_authorization_applied: None,
order_tax_amount: None,
processor_transaction_data: None,
connector_mandate_detail: None,
card_discovery: None,
charges: None,
issuer_error_code: None,
issuer_error_message: None,
setup_future_usage_applied: None,
routing_approach: None,
connector_request_reference_id: None,
network_transaction_id: None,
is_overcapture_enabled: None,
network_details: None,
is_stored_credential: None,
request_extended_authorization: None,
},
PaymentAttemptUpdate::ConnectorResponse {
authentication_data,
encoded_data,
connector_transaction_id,
connector,
updated_by,
charges,
} => {
let (connector_transaction_id, processor_transaction_data) =
connector_transaction_id
.map(ConnectorTransactionId::form_id_and_data)
.map(|(txn_id, txn_data)| (Some(txn_id), txn_data))
.unwrap_or((None, None));
Self {
authentication_data,
encoded_data,
connector_transaction_id,
connector: connector.map(Some),
modified_at: common_utils::date_time::now(),
updated_by,
processor_transaction_data,
charges,
amount: None,
net_amount: None,
currency: None,
status: None,
amount_to_capture: None,
authentication_type: None,
payment_method: None,
error_message: None,
payment_method_id: None,
cancellation_reason: None,
mandate_id: None,
browser_info: None,
payment_token: None,
error_code: None,
connector_metadata: None,
payment_method_data: None,
payment_method_type: None,
payment_experience: None,
business_sub_label: None,
straight_through_algorithm: None,
preprocessing_step_id: None,
error_reason: None,
capture_method: None,
connector_response_reference_id: None,
multiple_capture_count: None,
surcharge_amount: None,
tax_amount: None,
amount_capturable: None,
merchant_connector_id: None,
unified_code: None,
unified_message: None,
external_three_ds_authentication_attempted: None,
authentication_connector: None,
authentication_id: None,
fingerprint_id: None,
payment_method_billing_address_id: None,
client_source: None,
client_version: None,
customer_acceptance: None,
card_network: None,
shipping_cost: None,
capture_before: None,
extended_authorization_applied: None,
order_tax_amount: None,
connector_mandate_detail: None,
card_discovery: None,
issuer_error_code: None,
issuer_error_message: None,
setup_future_usage_applied: None,
routing_approach: None,
connector_request_reference_id: None,
network_transaction_id: None,
is_overcapture_enabled: None,
network_details: None,
is_stored_credential: None,
request_extended_authorization: None,
}
}
PaymentAttemptUpdate::IncrementalAuthorizationAmountUpdate {
amount,
amount_capturable,
} => Self {
amount: Some(amount),
modified_at: common_utils::date_time::now(),
amount_capturable: Some(amount_capturable),
net_amount: None,
currency: None,
status: None,
connector_transaction_id: None,
amount_to_capture: None,
connector: None,
authentication_type: None,
payment_method: None,
error_message: None,
payment_method_id: None,
cancellation_reason: None,
mandate_id: None,
browser_info: None,
payment_token: None,
error_code: None,
connector_metadata: None,
payment_method_data: None,
payment_method_type: None,
payment_experience: None,
business_sub_label: None,
straight_through_algorithm: None,
preprocessing_step_id: None,
error_reason: None,
capture_method: None,
connector_response_reference_id: None,
multiple_capture_count: None,
surcharge_amount: None,
tax_amount: None,
updated_by: String::default(),
merchant_connector_id: None,
authentication_data: None,
encoded_data: None,
unified_code: None,
unified_message: None,
external_three_ds_authentication_attempted: None,
authentication_connector: None,
authentication_id: None,
fingerprint_id: None,
payment_method_billing_address_id: None,
client_source: None,
client_version: None,
customer_acceptance: None,
card_network: None,
shipping_cost: None,
order_tax_amount: None,
capture_before: None,
extended_authorization_applied: None,
processor_transaction_data: None,
connector_mandate_detail: None,
card_discovery: None,
charges: None,
issuer_error_code: None,
issuer_error_message: None,
setup_future_usage_applied: None,
routing_approach: None,
connector_request_reference_id: None,
network_transaction_id: None,
is_overcapture_enabled: None,
network_details: None,
is_stored_credential: None,
request_extended_authorization: None,
},
PaymentAttemptUpdate::AuthenticationUpdate {
status,
external_three_ds_authentication_attempted,
authentication_connector,
authentication_id,
updated_by,
} => Self {
status: Some(status),
modified_at: common_utils::date_time::now(),
external_three_ds_authentication_attempted,
authentication_connector,
authentication_id,
updated_by,
amount: None,
net_amount: None,
currency: None,
connector_transaction_id: None,
amount_to_capture: None,
connector: None,
authentication_type: None,
payment_method: None,
error_message: None,
payment_method_id: None,
cancellation_reason: None,
mandate_id: None,
browser_info: None,
payment_token: None,
error_code: None,
connector_metadata: None,
payment_method_data: None,
payment_method_type: None,
payment_experience: None,
business_sub_label: None,
straight_through_algorithm: None,
preprocessing_step_id: None,
error_reason: None,
capture_method: None,
connector_response_reference_id: None,
multiple_capture_count: None,
surcharge_amount: None,
tax_amount: None,
amount_capturable: None,
merchant_connector_id: None,
authentication_data: None,
encoded_data: None,
unified_code: None,
unified_message: None,
fingerprint_id: None,
payment_method_billing_address_id: None,
client_source: None,
client_version: None,
customer_acceptance: None,
card_network: None,
shipping_cost: None,
order_tax_amount: None,
capture_before: None,
extended_authorization_applied: None,
processor_transaction_data: None,
connector_mandate_detail: None,
card_discovery: None,
charges: None,
issuer_error_code: None,
issuer_error_message: None,
setup_future_usage_applied: None,
routing_approach: None,
connector_request_reference_id: None,
network_transaction_id: None,
is_overcapture_enabled: None,
network_details: None,
is_stored_credential: None,
request_extended_authorization: None,
},
PaymentAttemptUpdate::ManualUpdate {
status,
error_code,
error_message,
error_reason,
updated_by,
unified_code,
unified_message,
connector_transaction_id,
} => {
let (connector_transaction_id, processor_transaction_data) =
connector_transaction_id
.map(ConnectorTransactionId::form_id_and_data)
.map(|(txn_id, txn_data)| (Some(txn_id), txn_data))
.unwrap_or((None, None));
Self {
status,
error_code: error_code.map(Some),
modified_at: common_utils::date_time::now(),
error_message: error_message.map(Some),
error_reason: error_reason.map(Some),
updated_by,
unified_code: unified_code.map(Some),
unified_message: unified_message.map(Some),
connector_transaction_id,
processor_transaction_data,
amount: None,
net_amount: None,
currency: None,
amount_to_capture: None,
connector: None,
authentication_type: None,
payment_method: None,
payment_method_id: None,
cancellation_reason: None,
mandate_id: None,
browser_info: None,
payment_token: None,
connector_metadata: None,
payment_method_data: None,
payment_method_type: None,
payment_experience: None,
business_sub_label: None,
straight_through_algorithm: None,
preprocessing_step_id: None,
capture_method: None,
connector_response_reference_id: None,
multiple_capture_count: None,
surcharge_amount: None,
tax_amount: None,
amount_capturable: None,
merchant_connector_id: None,
authentication_data: None,
encoded_data: None,
external_three_ds_authentication_attempted: None,
authentication_connector: None,
authentication_id: None,
fingerprint_id: None,
payment_method_billing_address_id: None,
client_source: None,
client_version: None,
customer_acceptance: None,
card_network: None,
shipping_cost: None,
capture_before: None,
extended_authorization_applied: None,
order_tax_amount: None,
connector_mandate_detail: None,
card_discovery: None,
charges: None,
|
crates/diesel_models/src/payment_attempt.rs#chunk3
|
diesel_models
|
chunk
| null | null | null | 8,191
| null | null | null | null | null | null | null |
// Implementation: impl ResourceId
// File: crates/common_utils/src/types/authentication.rs
// Module: common_utils
// Methods: 1 total (1 public)
impl ResourceId
|
crates/common_utils/src/types/authentication.rs
|
common_utils
|
impl_block
| null | null | null | 37
| null |
ResourceId
| null | 1
| 1
| null | null |
// Function: create_identity_from_certificate_and_key
// File: crates/external_services/src/http_client/client.rs
// Module: external_services
pub fn create_identity_from_certificate_and_key(
encoded_certificate: masking::Secret<String>,
encoded_certificate_key: masking::Secret<String>,
) -> Result<reqwest::Identity, error_stack::Report<HttpClientError>>
|
crates/external_services/src/http_client/client.rs
|
external_services
|
function_signature
| null | null | null | 74
|
create_identity_from_certificate_and_key
| null | null | null | null | null | null |
// Function: should_call_connector
// File: crates/router/src/core/payments.rs
// Module: router
pub fn should_call_connector<Op: Debug, F: Clone, D>(operation: &Op, payment_data: &D) -> bool
where
D: OperationSessionGetters<F> + Send + Sync + Clone,
|
crates/router/src/core/payments.rs
|
router
|
function_signature
| null | null | null | 71
|
should_call_connector
| null | null | null | null | null | null |
// Function: delete_evidence_file
// File: crates/router/src/core/disputes/transformers.rs
// Module: router
pub fn delete_evidence_file(
dispute_evidence: DisputeEvidence,
evidence_type: EvidenceType,
) -> DisputeEvidence
|
crates/router/src/core/disputes/transformers.rs
|
router
|
function_signature
| null | null | null | 56
|
delete_evidence_file
| null | null | null | null | null | null |
// Implementation: impl PaymentSync for for Riskified
// File: crates/hyperswitch_connectors/src/connectors/riskified.rs
// Module: hyperswitch_connectors
// Methods: 0 total (0 public)
impl PaymentSync for for Riskified
|
crates/hyperswitch_connectors/src/connectors/riskified.rs
|
hyperswitch_connectors
|
impl_block
| null | null | null | 54
| null |
Riskified
|
PaymentSync for
| 0
| 0
| null | null |
// Struct: Trustpayments
// File: crates/hyperswitch_connectors/src/connectors/trustpayments.rs
// Module: hyperswitch_connectors
// Implementations: 17
// Traits: api::Payment, api::PaymentSession, api::ConnectorAccessToken, api::MandateSetup, api::PaymentAuthorize, api::PaymentSync, api::PaymentCapture, api::PaymentVoid, api::Refund, api::RefundExecute, api::RefundSync, api::PaymentToken, ConnectorCommon, ConnectorValidation, webhooks::IncomingWebhook, ConnectorSpecifications
pub struct Trustpayments
|
crates/hyperswitch_connectors/src/connectors/trustpayments.rs
|
hyperswitch_connectors
|
struct_definition
|
Trustpayments
| 17
|
[
"api::Payment",
"api::PaymentSession",
"api::ConnectorAccessToken",
"api::MandateSetup",
"api::PaymentAuthorize",
"api::PaymentSync",
"api::PaymentCapture",
"api::PaymentVoid",
"api::Refund",
"api::RefundExecute",
"api::RefundSync",
"api::PaymentToken",
"ConnectorCommon",
"ConnectorValidation",
"webhooks::IncomingWebhook",
"ConnectorSpecifications"
] | 126
| null | null | null | null | null | null | null |
// Struct: Authorization
// File: crates/hyperswitch_connectors/src/connectors/worldpayvantiv/transformers.rs
// Module: hyperswitch_connectors
// Implementations: 0
pub struct Authorization
|
crates/hyperswitch_connectors/src/connectors/worldpayvantiv/transformers.rs
|
hyperswitch_connectors
|
struct_definition
|
Authorization
| 0
|
[] | 45
| null | null | null | null | null | null | null |
// Trait: RoutingEventLogAnalytics
// File: crates/analytics/src/routing_events/events.rs
// Module: analytics
pub trait RoutingEventLogAnalytics: LoadRow<RoutingEventsResult>
|
crates/analytics/src/routing_events/events.rs
|
analytics
|
trait_definition
| null | null | null | 40
| null | null |
RoutingEventLogAnalytics
| null | null | null | null |
// Implementation: impl api::MandateSetup for for Gigadat
// File: crates/hyperswitch_connectors/src/connectors/gigadat.rs
// Module: hyperswitch_connectors
// Methods: 0 total (0 public)
impl api::MandateSetup for for Gigadat
|
crates/hyperswitch_connectors/src/connectors/gigadat.rs
|
hyperswitch_connectors
|
impl_block
| null | null | null | 65
| null |
Gigadat
|
api::MandateSetup for
| 0
| 0
| null | null |
// Function: get_network_token_webhook_details
// File: crates/common_types/src/callback_mapper.rs
// Module: common_types
// Documentation: Retrieves the details of the network token webhook type from callback mapper data.
pub fn get_network_token_webhook_details(
&self,
) -> (id_type::MerchantId, String, id_type::CustomerId)
|
crates/common_types/src/callback_mapper.rs
|
common_types
|
function_signature
| null | null | null | 74
|
get_network_token_webhook_details
| null | null | null | null | null | null |
// Implementation: impl Responder
// File: crates/router/src/routes/payments.rs
// Module: router
// Methods: 0 total (0 public)
impl Responder
|
crates/router/src/routes/payments.rs
|
router
|
impl_block
| null | null | null | 36
| null |
Responder
| null | 0
| 0
| null | null |
// Implementation: impl api::RefundExecute for for Square
// File: crates/hyperswitch_connectors/src/connectors/square.rs
// Module: hyperswitch_connectors
// Methods: 0 total (0 public)
impl api::RefundExecute for for Square
|
crates/hyperswitch_connectors/src/connectors/square.rs
|
hyperswitch_connectors
|
impl_block
| null | null | null | 57
| null |
Square
|
api::RefundExecute for
| 0
| 0
| null | null |
// Implementation: impl webhooks::IncomingWebhook for for Trustpay
// File: crates/hyperswitch_connectors/src/connectors/trustpay.rs
// Module: hyperswitch_connectors
// Methods: 7 total (0 public)
impl webhooks::IncomingWebhook for for Trustpay
|
crates/hyperswitch_connectors/src/connectors/trustpay.rs
|
hyperswitch_connectors
|
impl_block
| null | null | null | 62
| null |
Trustpay
|
webhooks::IncomingWebhook for
| 7
| 0
| null | null |
// Struct: FacilitapayRouterData
// File: crates/hyperswitch_connectors/src/connectors/facilitapay/requests.rs
// Module: hyperswitch_connectors
// Implementations: 0
pub struct FacilitapayRouterData<T>
|
crates/hyperswitch_connectors/src/connectors/facilitapay/requests.rs
|
hyperswitch_connectors
|
struct_definition
|
FacilitapayRouterData
| 0
|
[] | 57
| null | null | null | null | null | null | null |
// Implementation: impl Responder
// File: crates/router/src/routes/cards_info.rs
// Module: router
// Methods: 0 total (0 public)
impl Responder
|
crates/router/src/routes/cards_info.rs
|
router
|
impl_block
| null | null | null | 36
| null |
Responder
| null | 0
| 0
| null | null |
// Function: organization_create
// File: crates/router/src/routes/admin.rs
// Module: router
pub fn organization_create(
state: web::Data<AppState>,
req: HttpRequest,
json_payload: web::Json<admin::OrganizationCreateRequest>,
) -> HttpResponse
|
crates/router/src/routes/admin.rs
|
router
|
function_signature
| null | null | null | 57
|
organization_create
| null | null | null | null | null | null |
// Function: find_users_by_user_ids
// File: crates/diesel_models/src/query/user.rs
// Module: diesel_models
pub fn find_users_by_user_ids(
conn: &PgPooledConn,
user_ids: Vec<String>,
) -> StorageResult<Vec<Self>>
|
crates/diesel_models/src/query/user.rs
|
diesel_models
|
function_signature
| null | null | null | 59
|
find_users_by_user_ids
| null | null | null | null | null | null |
// Function: new
// File: crates/hyperswitch_constraint_graph/src/dense_map.rs
// Module: hyperswitch_constraint_graph
pub fn new() -> Self
|
crates/hyperswitch_constraint_graph/src/dense_map.rs
|
hyperswitch_constraint_graph
|
function_signature
| null | null | null | 35
|
new
| null | null | null | null | null | null |
// Struct: FraudCheckNew
// File: crates/diesel_models/src/fraud_check.rs
// Module: diesel_models
// Implementations: 0
pub struct FraudCheckNew
|
crates/diesel_models/src/fraud_check.rs
|
diesel_models
|
struct_definition
|
FraudCheckNew
| 0
|
[] | 38
| null | null | null | null | null | null | null |
// Function: gateway_response
// File: crates/hyperswitch_connectors/src/connectors/authipay/transformers.rs
// Module: hyperswitch_connectors
// Documentation: Get gateway response (like Fiserv's gateway_response)
pub fn gateway_response(&self) -> AuthipayGatewayResponse
|
crates/hyperswitch_connectors/src/connectors/authipay/transformers.rs
|
hyperswitch_connectors
|
function_signature
| null | null | null | 61
|
gateway_response
| null | null | null | null | null | null |
// Implementation: impl api::PaymentVoid for for Bankofamerica
// File: crates/hyperswitch_connectors/src/connectors/bankofamerica.rs
// Module: hyperswitch_connectors
// Methods: 0 total (0 public)
impl api::PaymentVoid for for Bankofamerica
|
crates/hyperswitch_connectors/src/connectors/bankofamerica.rs
|
hyperswitch_connectors
|
impl_block
| null | null | null | 64
| null |
Bankofamerica
|
api::PaymentVoid for
| 0
| 0
| null | null |
// Struct: PlacetopayError
// File: crates/hyperswitch_connectors/src/connectors/placetopay/transformers.rs
// Module: hyperswitch_connectors
// Implementations: 0
pub struct PlacetopayError
|
crates/hyperswitch_connectors/src/connectors/placetopay/transformers.rs
|
hyperswitch_connectors
|
struct_definition
|
PlacetopayError
| 0
|
[] | 53
| null | null | null | null | null | null | null |
// Implementation: impl api::PaymentAuthorize for for Nuvei
// File: crates/hyperswitch_connectors/src/connectors/nuvei.rs
// Module: hyperswitch_connectors
// Methods: 0 total (0 public)
impl api::PaymentAuthorize for for Nuvei
|
crates/hyperswitch_connectors/src/connectors/nuvei.rs
|
hyperswitch_connectors
|
impl_block
| null | null | null | 61
| null |
Nuvei
|
api::PaymentAuthorize for
| 0
| 0
| null | null |
// Implementation: impl Responder
// File: crates/router/src/analytics.rs
// Module: router
// Methods: 0 total (0 public)
impl Responder
|
crates/router/src/analytics.rs
|
router
|
impl_block
| null | null | null | 35
| null |
Responder
| null | 0
| 0
| null | null |
// Struct: SurchargeDetails
// File: crates/hyperswitch_domain_models/src/router_request_types.rs
// Module: hyperswitch_domain_models
// Implementations: 1
pub struct SurchargeDetails
|
crates/hyperswitch_domain_models/src/router_request_types.rs
|
hyperswitch_domain_models
|
struct_definition
|
SurchargeDetails
| 1
|
[] | 43
| null | null | null | null | null | null | null |
// Struct: ApplePayTokenizedCard
// File: crates/hyperswitch_connectors/src/connectors/barclaycard/transformers.rs
// Module: hyperswitch_connectors
// Implementations: 0
pub struct ApplePayTokenizedCard
|
crates/hyperswitch_connectors/src/connectors/barclaycard/transformers.rs
|
hyperswitch_connectors
|
struct_definition
|
ApplePayTokenizedCard
| 0
|
[] | 53
| null | null | null | null | null | null | null |
// Struct: FullyParsedGooglePayToken
// File: crates/hyperswitch_connectors/src/connectors/fiserv/transformers.rs
// Module: hyperswitch_connectors
// Implementations: 0
pub struct FullyParsedGooglePayToken
|
crates/hyperswitch_connectors/src/connectors/fiserv/transformers.rs
|
hyperswitch_connectors
|
struct_definition
|
FullyParsedGooglePayToken
| 0
|
[] | 52
| null | null | null | null | null | null | null |
// Implementation: impl api::PaymentSession for for Boku
// File: crates/hyperswitch_connectors/src/connectors/boku.rs
// Module: hyperswitch_connectors
// Methods: 0 total (0 public)
impl api::PaymentSession for for Boku
|
crates/hyperswitch_connectors/src/connectors/boku.rs
|
hyperswitch_connectors
|
impl_block
| null | null | null | 57
| null |
Boku
|
api::PaymentSession for
| 0
| 0
| null | null |
// File: crates/router/src/locale.rs
// Module: router
use rust_i18n::i18n;
i18n!("locales", fallback = "en");
|
crates/router/src/locale.rs
|
router
|
full_file
| null | null | null | 38
| null | null | null | null | null | null | null |
// Struct: RecoveryPaymentTuple
// File: crates/router/src/core/webhooks/recovery_incoming.rs
// Module: router
// Implementations: 1
pub struct RecoveryPaymentTuple
|
crates/router/src/core/webhooks/recovery_incoming.rs
|
router
|
struct_definition
|
RecoveryPaymentTuple
| 1
|
[] | 39
| null | null | null | null | null | null | null |
// Struct: HyperwalletRouterData
// File: crates/hyperswitch_connectors/src/connectors/hyperwallet/transformers.rs
// Module: hyperswitch_connectors
// Implementations: 0
pub struct HyperwalletRouterData<T>
|
crates/hyperswitch_connectors/src/connectors/hyperwallet/transformers.rs
|
hyperswitch_connectors
|
struct_definition
|
HyperwalletRouterData
| 0
|
[] | 52
| null | null | null | null | null | null | null |
// Function: list_by_merchant_id
// File: crates/diesel_models/src/query/customers.rs
// Module: diesel_models
pub fn list_by_merchant_id(
conn: &PgPooledConn,
merchant_id: &id_type::MerchantId,
constraints: CustomerListConstraints,
) -> StorageResult<Vec<Self>>
|
crates/diesel_models/src/query/customers.rs
|
diesel_models
|
function_signature
| null | null | null | 71
|
list_by_merchant_id
| null | null | null | null | null | null |
// Function: new
// File: crates/router/src/types/api/connector_onboarding/paypal.rs
// Module: router
pub fn new(tracking_id: String, return_url: String) -> Self
|
crates/router/src/types/api/connector_onboarding/paypal.rs
|
router
|
function_signature
| null | null | null | 42
|
new
| null | null | null | null | null | null |
// Struct: AliPayHkRedirection
// File: crates/hyperswitch_domain_models/src/payment_method_data.rs
// Module: hyperswitch_domain_models
// Implementations: 0
pub struct AliPayHkRedirection
|
crates/hyperswitch_domain_models/src/payment_method_data.rs
|
hyperswitch_domain_models
|
struct_definition
|
AliPayHkRedirection
| 0
|
[] | 49
| null | null | null | null | null | null | null |
connectors::Payone,
connectors::Paypal,
connectors::Paysafe,
connectors::Paystack,
connectors::Paytm,
connectors::Payu,
connectors::Peachpayments,
connectors::Phonepe,
connectors::Placetopay,
connectors::Powertranz,
connectors::Prophetpay,
connectors::Mifinity,
connectors::Mollie,
connectors::Moneris,
connectors::Mpgs,
connectors::Multisafepay,
connectors::Rapyd,
connectors::Razorpay,
connectors::Recurly,
connectors::Redsys,
connectors::Riskified,
connectors::Santander,
connectors::Shift4,
connectors::Sift,
connectors::Silverflow,
connectors::Signifyd,
connectors::Stax,
connectors::Square,
connectors::Stripe,
connectors::Stripebilling,
connectors::Taxjar,
connectors::Tesouro,
connectors::Threedsecureio,
connectors::Thunes,
connectors::Tokenex,
connectors::Tokenio,
connectors::Trustpay,
connectors::Trustpayments,
connectors::Tsys,
connectors::UnifiedAuthenticationService,
connectors::Wise,
connectors::Worldline,
connectors::Worldpay,
connectors::Worldpayvantiv,
connectors::Worldpayxml,
connectors::Wellsfargo,
connectors::Wellsfargopayout,
connectors::Volt,
connectors::Xendit,
connectors::Zen,
connectors::Zsl,
connectors::CtpMastercard
);
macro_rules! default_imp_for_approve {
($($path:ident::$connector:ident),*) => {
$(
impl PaymentApprove for $path::$connector {}
impl
ConnectorIntegration<
Approve,
PaymentsApproveData,
PaymentsResponseData,
> for $path::$connector
{}
)*
};
}
default_imp_for_approve!(
connectors::Vgs,
connectors::Aci,
connectors::Adyen,
connectors::Adyenplatform,
connectors::Affirm,
connectors::Airwallex,
connectors::Amazonpay,
connectors::Archipel,
connectors::Authipay,
connectors::Authorizedotnet,
connectors::Bambora,
connectors::Bamboraapac,
connectors::Bankofamerica,
connectors::Barclaycard,
connectors::Billwerk,
connectors::Bitpay,
connectors::Blackhawknetwork,
connectors::Bluecode,
connectors::Bluesnap,
connectors::Braintree,
connectors::Boku,
connectors::Breadpay,
connectors::Cashtocode,
connectors::Celero,
connectors::Chargebee,
connectors::Checkbook,
connectors::Checkout,
connectors::Coinbase,
connectors::Coingate,
connectors::Cryptopay,
connectors::Custombilling,
connectors::Cybersource,
connectors::Datatrans,
connectors::Deutschebank,
connectors::Digitalvirgo,
connectors::Dlocal,
connectors::Dwolla,
connectors::Ebanx,
connectors::Elavon,
connectors::Facilitapay,
connectors::Finix,
connectors::Fiserv,
connectors::Fiservemea,
connectors::Fiuu,
connectors::Flexiti,
connectors::Forte,
connectors::Getnet,
connectors::Gigadat,
connectors::Globalpay,
connectors::Globepay,
connectors::Gocardless,
connectors::Gpayments,
connectors::Hipay,
connectors::Helcim,
connectors::HyperswitchVault,
connectors::Hyperwallet,
connectors::Iatapay,
connectors::Inespay,
connectors::Itaubank,
connectors::Jpmorgan,
connectors::Juspaythreedsserver,
connectors::Katapult,
connectors::Klarna,
connectors::Loonio,
connectors::Netcetera,
connectors::Nomupay,
connectors::Noon,
connectors::Nordea,
connectors::Novalnet,
connectors::Nexinets,
connectors::Nexixpay,
connectors::Opayo,
connectors::Opennode,
connectors::Nmi,
connectors::Nuvei,
connectors::Paybox,
connectors::Payeezy,
connectors::Payload,
connectors::Payme,
connectors::Paypal,
connectors::Paysafe,
connectors::Paystack,
connectors::Paytm,
connectors::Payone,
connectors::Payu,
connectors::Peachpayments,
connectors::Phonepe,
connectors::Placetopay,
connectors::Plaid,
connectors::Powertranz,
connectors::Prophetpay,
connectors::Mifinity,
connectors::Mollie,
connectors::Moneris,
connectors::Mpgs,
connectors::Multisafepay,
connectors::Rapyd,
connectors::Razorpay,
connectors::Recurly,
connectors::Redsys,
connectors::Riskified,
connectors::Santander,
connectors::Shift4,
connectors::Sift,
connectors::Silverflow,
connectors::Signifyd,
connectors::Stax,
connectors::Square,
connectors::Stripe,
connectors::Stripebilling,
connectors::Taxjar,
connectors::Tesouro,
connectors::Threedsecureio,
connectors::Thunes,
connectors::Tokenex,
connectors::Tokenio,
connectors::Trustpay,
connectors::Trustpayments,
connectors::Tsys,
connectors::UnifiedAuthenticationService,
connectors::Wise,
connectors::Worldline,
connectors::Worldpay,
connectors::Worldpayvantiv,
connectors::Worldpayxml,
connectors::Wellsfargo,
connectors::Wellsfargopayout,
connectors::Volt,
connectors::Xendit,
connectors::Zen,
connectors::Zsl,
connectors::CtpMastercard
);
macro_rules! default_imp_for_reject {
($($path:ident::$connector:ident),*) => {
$(
impl PaymentReject for $path::$connector {}
impl
ConnectorIntegration<
Reject,
PaymentsRejectData,
PaymentsResponseData,
> for $path::$connector
{}
)*
};
}
default_imp_for_reject!(
connectors::Vgs,
connectors::Aci,
connectors::Adyen,
connectors::Adyenplatform,
connectors::Affirm,
connectors::Airwallex,
connectors::Amazonpay,
connectors::Archipel,
connectors::Authipay,
connectors::Authorizedotnet,
connectors::Bambora,
connectors::Bamboraapac,
connectors::Bankofamerica,
connectors::Barclaycard,
connectors::Billwerk,
connectors::Bitpay,
connectors::Blackhawknetwork,
connectors::Bluecode,
connectors::Bluesnap,
connectors::Braintree,
connectors::Boku,
connectors::Breadpay,
connectors::Cashtocode,
connectors::Celero,
connectors::Chargebee,
connectors::Checkbook,
connectors::Checkout,
connectors::Coinbase,
connectors::Coingate,
connectors::Cryptopay,
connectors::Custombilling,
connectors::Cybersource,
connectors::Datatrans,
connectors::Deutschebank,
connectors::Digitalvirgo,
connectors::Dlocal,
connectors::Dwolla,
connectors::Ebanx,
connectors::Elavon,
connectors::Facilitapay,
connectors::Finix,
connectors::Fiserv,
connectors::Fiservemea,
connectors::Fiuu,
connectors::Flexiti,
connectors::Forte,
connectors::Getnet,
connectors::Gigadat,
connectors::Globalpay,
connectors::Globepay,
connectors::Gocardless,
connectors::Gpayments,
connectors::Hipay,
connectors::Helcim,
connectors::HyperswitchVault,
connectors::Hyperwallet,
connectors::Iatapay,
connectors::Inespay,
connectors::Itaubank,
connectors::Jpmorgan,
connectors::Juspaythreedsserver,
connectors::Katapult,
connectors::Klarna,
connectors::Loonio,
connectors::Netcetera,
connectors::Nmi,
connectors::Nomupay,
connectors::Noon,
connectors::Nordea,
connectors::Novalnet,
connectors::Nexinets,
connectors::Nexixpay,
connectors::Opayo,
connectors::Opennode,
connectors::Nuvei,
connectors::Paybox,
connectors::Payeezy,
connectors::Payload,
connectors::Payone,
connectors::Payme,
connectors::Paypal,
connectors::Paysafe,
connectors::Paystack,
connectors::Paytm,
connectors::Payu,
connectors::Peachpayments,
connectors::Phonepe,
connectors::Placetopay,
connectors::Plaid,
connectors::Powertranz,
connectors::Prophetpay,
connectors::Mifinity,
connectors::Mollie,
connectors::Moneris,
connectors::Mpgs,
connectors::Multisafepay,
connectors::Rapyd,
connectors::Razorpay,
connectors::Recurly,
connectors::Redsys,
connectors::Riskified,
connectors::Santander,
connectors::Shift4,
connectors::Sift,
connectors::Silverflow,
connectors::Signifyd,
connectors::Stax,
connectors::Square,
connectors::Stripe,
connectors::Stripebilling,
connectors::Taxjar,
connectors::Tesouro,
connectors::Threedsecureio,
connectors::Thunes,
connectors::Tokenex,
connectors::Tokenio,
connectors::Trustpay,
connectors::Trustpayments,
connectors::Tsys,
connectors::UnifiedAuthenticationService,
connectors::Wise,
connectors::Worldline,
connectors::Worldpay,
connectors::Worldpayvantiv,
connectors::Worldpayxml,
connectors::Wellsfargo,
connectors::Wellsfargopayout,
connectors::Volt,
connectors::Xendit,
connectors::Zen,
connectors::Zsl,
connectors::CtpMastercard
);
macro_rules! default_imp_for_webhook_source_verification {
($($path:ident::$connector:ident),*) => {
$(
impl api::ConnectorVerifyWebhookSource for $path::$connector {}
impl
ConnectorIntegration<
VerifyWebhookSource,
VerifyWebhookSourceRequestData,
VerifyWebhookSourceResponseData,
> for $path::$connector
{}
)*
};
}
default_imp_for_webhook_source_verification!(
connectors::Paysafe,
connectors::Vgs,
connectors::Aci,
connectors::Adyen,
connectors::Adyenplatform,
connectors::Affirm,
connectors::Airwallex,
connectors::Amazonpay,
connectors::Archipel,
connectors::Authipay,
connectors::Authorizedotnet,
connectors::Bambora,
connectors::Bamboraapac,
connectors::Bankofamerica,
connectors::Barclaycard,
connectors::Billwerk,
connectors::Bitpay,
connectors::Blackhawknetwork,
connectors::Bluecode,
connectors::Bluesnap,
connectors::Braintree,
connectors::Boku,
connectors::Breadpay,
connectors::Cashtocode,
connectors::Celero,
connectors::Chargebee,
connectors::Checkbook,
connectors::Checkout,
connectors::Coinbase,
connectors::Coingate,
connectors::Cryptopay,
connectors::Custombilling,
connectors::Cybersource,
connectors::Datatrans,
connectors::Deutschebank,
connectors::Digitalvirgo,
connectors::Dlocal,
connectors::Dwolla,
connectors::Elavon,
connectors::Ebanx,
connectors::Facilitapay,
connectors::Finix,
connectors::Fiserv,
connectors::Fiservemea,
connectors::Fiuu,
connectors::Flexiti,
connectors::Forte,
connectors::Getnet,
connectors::Gigadat,
connectors::Globalpay,
connectors::Globepay,
connectors::Gocardless,
connectors::Gpayments,
connectors::Hipay,
connectors::Helcim,
connectors::HyperswitchVault,
connectors::Hyperwallet,
connectors::Iatapay,
connectors::Inespay,
connectors::Itaubank,
connectors::Jpmorgan,
connectors::Juspaythreedsserver,
connectors::Katapult,
connectors::Klarna,
connectors::Loonio,
connectors::Netcetera,
connectors::Nmi,
connectors::Nomupay,
connectors::Noon,
connectors::Nordea,
connectors::Novalnet,
connectors::Nexinets,
connectors::Nexixpay,
connectors::Opayo,
connectors::Opennode,
connectors::Nuvei,
connectors::Payone,
connectors::Paybox,
connectors::Payeezy,
connectors::Payload,
connectors::Payme,
connectors::Paystack,
connectors::Paytm,
connectors::Payu,
connectors::Peachpayments,
connectors::Phonepe,
connectors::Placetopay,
connectors::Plaid,
connectors::Powertranz,
connectors::Prophetpay,
connectors::Mifinity,
connectors::Mollie,
connectors::Moneris,
connectors::Mpgs,
connectors::Multisafepay,
connectors::Rapyd,
connectors::Razorpay,
connectors::Recurly,
connectors::Redsys,
connectors::Riskified,
connectors::Santander,
connectors::Shift4,
connectors::Sift,
connectors::Silverflow,
connectors::Signifyd,
connectors::Stax,
connectors::Square,
connectors::Stripe,
connectors::Stripebilling,
connectors::Taxjar,
connectors::Tesouro,
connectors::Threedsecureio,
connectors::Thunes,
connectors::Tokenex,
connectors::Tokenio,
connectors::Trustpay,
connectors::Trustpayments,
connectors::Tsys,
connectors::UnifiedAuthenticationService,
connectors::Wise,
connectors::Worldline,
connectors::Worldpay,
connectors::Worldpayvantiv,
connectors::Worldpayxml,
connectors::Wellsfargo,
connectors::Wellsfargopayout,
connectors::Volt,
connectors::Xendit,
connectors::Zen,
connectors::Zsl,
connectors::CtpMastercard
);
macro_rules! default_imp_for_accept_dispute {
($($path:ident::$connector:ident),*) => {
$(
impl Dispute for $path::$connector {}
impl AcceptDispute for $path::$connector {}
impl
ConnectorIntegration<
Accept,
AcceptDisputeRequestData,
AcceptDisputeResponse,
> for $path::$connector
{}
)*
};
}
default_imp_for_accept_dispute!(
connectors::Vgs,
connectors::Aci,
connectors::Adyenplatform,
connectors::Affirm,
connectors::Airwallex,
connectors::Amazonpay,
connectors::Archipel,
connectors::Authipay,
connectors::Authorizedotnet,
connectors::Bambora,
connectors::Bamboraapac,
connectors::Bankofamerica,
connectors::Barclaycard,
connectors::Billwerk,
connectors::Bitpay,
connectors::Blackhawknetwork,
connectors::Bluecode,
connectors::Bluesnap,
connectors::Braintree,
connectors::Boku,
connectors::Breadpay,
connectors::Cashtocode,
connectors::Celero,
connectors::Chargebee,
connectors::Checkbook,
connectors::Coinbase,
connectors::Coingate,
connectors::Cryptopay,
connectors::Custombilling,
connectors::Cybersource,
connectors::Datatrans,
connectors::Deutschebank,
connectors::Digitalvirgo,
connectors::Dlocal,
connectors::Dwolla,
connectors::Ebanx,
connectors::Elavon,
connectors::Facilitapay,
connectors::Finix,
connectors::Fiserv,
connectors::Fiservemea,
connectors::Fiuu,
connectors::Flexiti,
connectors::Forte,
connectors::Getnet,
connectors::Gigadat,
connectors::Globalpay,
connectors::Globepay,
connectors::Gocardless,
connectors::Gpayments,
connectors::Hipay,
connectors::Helcim,
connectors::HyperswitchVault,
connectors::Hyperwallet,
connectors::Iatapay,
connectors::Inespay,
connectors::Itaubank,
connectors::Jpmorgan,
connectors::Juspaythreedsserver,
connectors::Katapult,
connectors::Klarna,
connectors::Loonio,
connectors::Netcetera,
connectors::Nmi,
connectors::Nomupay,
connectors::Noon,
connectors::Nordea,
connectors::Novalnet,
connectors::Nexinets,
connectors::Nexixpay,
connectors::Opayo,
connectors::Opennode,
connectors::Nuvei,
connectors::Paybox,
connectors::Payeezy,
connectors::Payload,
connectors::Payme,
connectors::Payone,
connectors::Paypal,
connectors::Paysafe,
connectors::Paystack,
connectors::Paytm,
connectors::Payu,
connectors::Peachpayments,
connectors::Phonepe,
connectors::Placetopay,
connectors::Plaid,
connectors::Powertranz,
connectors::Prophetpay,
connectors::Mifinity,
connectors::Mollie,
connectors::Moneris,
connectors::Mpgs,
connectors::Multisafepay,
connectors::Rapyd,
connectors::Razorpay,
connectors::Recurly,
connectors::Redsys,
connectors::Riskified,
connectors::Santander,
connectors::Shift4,
connectors::Sift,
connectors::Silverflow,
connectors::Signifyd,
connectors::Stax,
connectors::Square,
connectors::Stripe,
connectors::Stripebilling,
connectors::Taxjar,
connectors::Tesouro,
connectors::Threedsecureio,
connectors::Thunes,
connectors::Tokenex,
connectors::Tokenio,
connectors::Trustpay,
connectors::Trustpayments,
connectors::Tsys,
connectors::UnifiedAuthenticationService,
connectors::Wise,
connectors::Worldline,
connectors::Worldpay,
connectors::Worldpayxml,
connectors::Wellsfargo,
connectors::Wellsfargopayout,
connectors::Volt,
connectors::Xendit,
connectors::Zen,
connectors::Zsl,
connectors::CtpMastercard
);
macro_rules! default_imp_for_submit_evidence {
($($path:ident::$connector:ident),*) => {
$(
impl SubmitEvidence for $path::$connector {}
impl
ConnectorIntegration<
Evidence,
SubmitEvidenceRequestData,
SubmitEvidenceResponse,
> for $path::$connector
{}
)*
};
}
default_imp_for_submit_evidence!(
connectors::Vgs,
connectors::Aci,
connectors::Adyenplatform,
connectors::Affirm,
connectors::Airwallex,
connectors::Amazonpay,
connectors::Archipel,
connectors::Authipay,
connectors::Authorizedotnet,
connectors::Bambora,
connectors::Bamboraapac,
connectors::Bankofamerica,
connectors::Barclaycard,
connectors::Billwerk,
connectors::Bitpay,
connectors::Blackhawknetwork,
connectors::Bluecode,
connectors::Bluesnap,
connectors::Braintree,
connectors::Boku,
connectors::Breadpay,
connectors::Cashtocode,
connectors::Celero,
connectors::Chargebee,
connectors::Checkbook,
connectors::Coinbase,
connectors::Coingate,
connectors::Cryptopay,
connectors::Custombilling,
connectors::Cybersource,
connectors::Datatrans,
connectors::Deutschebank,
connectors::Digitalvirgo,
connectors::Dlocal,
connectors::Dwolla,
connectors::Ebanx,
connectors::Elavon,
connectors::Facilitapay,
connectors::Finix,
connectors::Fiserv,
connectors::Fiservemea,
connectors::Fiuu,
connectors::Flexiti,
connectors::Forte,
connectors::Getnet,
connectors::Gigadat,
connectors::Globalpay,
connectors::Globepay,
connectors::Gocardless,
connectors::Gpayments,
connectors::Hipay,
connectors::Helcim,
connectors::HyperswitchVault,
connectors::Hyperwallet,
connectors::Iatapay,
connectors::Inespay,
connectors::Itaubank,
connectors::Jpmorgan,
connectors::Juspaythreedsserver,
connectors::Katapult,
connectors::Klarna,
connectors::Loonio,
connectors::Netcetera,
connectors::Nmi,
connectors::Nomupay,
connectors::Noon,
connectors::Nordea,
connectors::Novalnet,
connectors::Nexinets,
connectors::Nexixpay,
connectors::Opayo,
connectors::Opennode,
connectors::Nuvei,
connectors::Paybox,
connectors::Payeezy,
connectors::Payload,
connectors::Payme,
connectors::Paypal,
connectors::Paysafe,
connectors::Payone,
connectors::Paystack,
connectors::Paytm,
connectors::Payu,
connectors::Peachpayments,
connectors::Phonepe,
connectors::Placetopay,
connectors::Plaid,
connectors::Powertranz,
connectors::Prophetpay,
connectors::Mifinity,
connectors::Mollie,
connectors::Moneris,
connectors::Mpgs,
connectors::Multisafepay,
connectors::Rapyd,
connectors::Razorpay,
connectors::Recurly,
connectors::Redsys,
connectors::Riskified,
connectors::Santander,
connectors::Shift4,
connectors::Sift,
connectors::Silverflow,
connectors::Signifyd,
connectors::Stax,
connectors::Square,
connectors::Stripebilling,
connectors::Taxjar,
connectors::Tesouro,
connectors::Threedsecureio,
connectors::Thunes,
connectors::Tokenex,
connectors::Tokenio,
connectors::Trustpay,
connectors::Trustpayments,
connectors::Tsys,
connectors::UnifiedAuthenticationService,
connectors::Wise,
connectors::Worldline,
connectors::Worldpay,
connectors::Worldpayxml,
connectors::Wellsfargo,
connectors::Wellsfargopayout,
connectors::Volt,
connectors::Xendit,
connectors::Zen,
connectors::Zsl,
connectors::CtpMastercard
);
macro_rules! default_imp_for_defend_dispute {
($($path:ident::$connector:ident),*) => {
$(
impl DefendDispute for $path::$connector {}
impl
ConnectorIntegration<
Defend,
DefendDisputeRequestData,
DefendDisputeResponse,
> for $path::$connector
{}
)*
};
}
default_imp_for_defend_dispute!(
connectors::Vgs,
connectors::Aci,
connectors::Adyenplatform,
connectors::Affirm,
connectors::Airwallex,
connectors::Amazonpay,
connectors::Archipel,
connectors::Authipay,
connectors::Authorizedotnet,
connectors::Bambora,
connectors::Bamboraapac,
connectors::Bankofamerica,
connectors::Barclaycard,
connectors::Billwerk,
connectors::Bitpay,
connectors::Blackhawknetwork,
connectors::Bluecode,
connectors::Bluesnap,
connectors::Braintree,
connectors::Boku,
connectors::Breadpay,
connectors::Cashtocode,
connectors::Celero,
connectors::Chargebee,
connectors::Checkbook,
connectors::Coinbase,
connectors::Coingate,
connectors::Cryptopay,
connectors::Custombilling,
connectors::Cybersource,
connectors::Datatrans,
connectors::Deutschebank,
connectors::Digitalvirgo,
connectors::Dlocal,
connectors::Dwolla,
connectors::Ebanx,
connectors::Elavon,
connectors::Facilitapay,
connectors::Finix,
connectors::Fiserv,
connectors::Fiservemea,
connectors::Fiuu,
connectors::Flexiti,
connectors::Forte,
connectors::Getnet,
connectors::Gigadat,
connectors::Globalpay,
connectors::Globepay,
connectors::Gocardless,
connectors::Gpayments,
connectors::Hipay,
connectors::HyperswitchVault,
connectors::Hyperwallet,
connectors::Iatapay,
connectors::Inespay,
connectors::Itaubank,
connectors::Jpmorgan,
connectors::Juspaythreedsserver,
connectors::Katapult,
connectors::Klarna,
connectors::Loonio,
connectors::Helcim,
connectors::Netcetera,
connectors::Nmi,
connectors::Nomupay,
connectors::Noon,
connectors::Nordea,
connectors::Novalnet,
connectors::Nexinets,
connectors::Nexixpay,
connectors::Opayo,
connectors::Opennode,
connectors::Nuvei,
connectors::Paybox,
connectors::Payeezy,
connectors::Payload,
connectors::Payme,
connectors::Payone,
connectors::Paypal,
connectors::Paysafe,
connectors::Paystack,
connectors::Paytm,
connectors::Payu,
connectors::Peachpayments,
connectors::Phonepe,
connectors::Placetopay,
connectors::Plaid,
connectors::Powertranz,
connectors::Prophetpay,
connectors::Mifinity,
connectors::Mollie,
connectors::Moneris,
connectors::Mpgs,
connectors::Multisafepay,
connectors::Rapyd,
connectors::Razorpay,
connectors::Recurly,
connectors::Redsys,
connectors::Riskified,
connectors::Santander,
connectors::Shift4,
connectors::Sift,
connectors::Silverflow,
connectors::Signifyd,
connectors::Stax,
connectors::Square,
connectors::Stripe,
connectors::Stripebilling,
connectors::Taxjar,
connectors::Tesouro,
connectors::Threedsecureio,
connectors::Thunes,
connectors::Tokenex,
connectors::Tokenio,
connectors::Trustpay,
connectors::Trustpayments,
connectors::Tsys,
connectors::UnifiedAuthenticationService,
connectors::Wise,
connectors::Worldline,
connectors::Worldpay,
connectors::Worldpayvantiv,
connectors::Worldpayxml,
connectors::Wellsfargo,
connectors::Wellsfargopayout,
connectors::Volt,
connectors::Xendit,
connectors::Zen,
connectors::Zsl,
connectors::CtpMastercard
);
macro_rules! default_imp_for_fetch_disputes {
($($path:ident::$connector:ident),*) => {
$(
impl FetchDisputes for $path::$connector {}
impl
ConnectorIntegration<
Fetch,
FetchDisputesRequestData,
FetchDisputesResponse,
> for $path::$connector
{}
)*
};
}
default_imp_for_fetch_disputes!(
connectors::Vgs,
connectors::Aci,
connectors::Adyen,
connectors::Adyenplatform,
connectors::Affirm,
connectors::Airwallex,
connectors::Amazonpay,
connectors::Archipel,
connectors::Authipay,
connectors::Authorizedotnet,
connectors::Bambora,
connectors::Bamboraapac,
connectors::Bankofamerica,
connectors::Barclaycard,
connectors::Blackhawknetwork,
connectors::Bluecode,
connectors::Billwerk,
connectors::Bitpay,
connectors::Bluesnap,
connectors::Braintree,
connectors::Breadpay,
connectors::Boku,
connectors::Cashtocode,
connectors::Celero,
connectors::Chargebee,
connectors::Checkbook,
connectors::Checkout,
connectors::Coinbase,
connectors::Coingate,
connectors::Cryptopay,
connectors::Custombilling,
connectors::Cybersource,
connectors::Datatrans,
connectors::Deutschebank,
connectors::Digitalvirgo,
connectors::Dlocal,
connectors::Dwolla,
connectors::Ebanx,
connectors::Elavon,
connectors::Facilitapay,
connectors::Finix,
connectors::Fiserv,
connectors::Fiservemea,
connectors::Fiuu,
connectors::Forte,
connectors::Flexiti,
connectors::Getnet,
connectors::Gigadat,
connectors::Globalpay,
connectors::Globepay,
connectors::Gocardless,
connectors::Gpayments,
connectors::Hipay,
connectors::HyperswitchVault,
connectors::Hyperwallet,
connectors::Iatapay,
connectors::Inespay,
connectors::Itaubank,
connectors::Jpmorgan,
connectors::Juspaythreedsserver,
connectors::Klarna,
connectors::Loonio,
connectors::Katapult,
connectors::Helcim,
connectors::Netcetera,
connectors::Nmi,
connectors::Nomupay,
connectors::Noon,
connectors::Nordea,
connectors::Novalnet,
connectors::Nexinets,
connectors::Nexixpay,
connectors::Opayo,
connectors::Opennode,
connectors::Nuvei,
connectors::Paybox,
connectors::Payeezy,
connectors::Payload,
connectors::Payme,
connectors::Payone,
connectors::Paypal,
connectors::Paysafe,
connectors::Paystack,
connectors::Payu,
connectors::Paytm,
connectors::Peachpayments,
connectors::Phonepe,
connectors::Placetopay,
connectors::Plaid,
connectors::Powertranz,
connectors::Prophetpay,
connectors::Mifinity,
connectors::Mollie,
connectors::Moneris,
connectors::Mpgs,
connectors::Multisafepay,
connectors::Rapyd,
connectors::Razorpay,
connectors::Recurly,
connectors::Redsys,
connectors::Riskified,
connectors::Santander,
connectors::Shift4,
connectors::Sift,
connectors::Silverflow,
connectors::Signifyd,
connectors::Stax,
connectors::Square,
connectors::Stripe,
connectors::Stripebilling,
connectors::Taxjar,
connectors::Tesouro,
connectors::Threedsecureio,
connectors::Thunes,
connectors::Tokenex,
connectors::Tokenio,
connectors::Trustpay,
connectors::Trustpayments,
connectors::Tsys,
connectors::UnifiedAuthenticationService,
connectors::Wise,
connectors::Worldline,
connectors::Worldpay,
connectors::Worldpayxml,
connectors::Wellsfargo,
connectors::Wellsfargopayout,
connectors::Volt,
connectors::Xendit,
connectors::Zen,
connectors::Zsl,
connectors::CtpMastercard
);
macro_rules! default_imp_for_dispute_sync {
($($path:ident::$connector:ident),*) => {
$(
impl DisputeSync for $path::$connector {}
impl
ConnectorIntegration<
Dsync,
DisputeSyncData,
DisputeSyncResponse,
> for $path::$connector
{}
)*
};
}
default_imp_for_dispute_sync!(
connectors::Vgs,
connectors::Aci,
connectors::Adyen,
connectors::Adyenplatform,
connectors::Affirm,
connectors::Airwallex,
connectors::Amazonpay,
connectors::Archipel,
connectors::Authipay,
connectors::Authorizedotnet,
connectors::Bambora,
connectors::Bamboraapac,
connectors::Bankofamerica,
connectors::Barclaycard,
connectors::Billwerk,
connectors::Bitpay,
connectors::Bluesnap,
connectors::Blackhawknetwork,
connectors::Bluecode,
connectors::Braintree,
connectors::Breadpay,
connectors::Boku,
connectors::Cashtocode,
connectors::Celero,
connectors::Chargebee,
connectors::Checkbook,
connectors::Checkout,
connectors::Coinbase,
connectors::Coingate,
connectors::Cryptopay,
connectors::Custombilling,
connectors::Cybersource,
connectors::Datatrans,
connectors::Deutschebank,
connectors::Digitalvirgo,
connectors::Dlocal,
connectors::Dwolla,
connectors::Ebanx,
connectors::Elavon,
connectors::Facilitapay,
connectors::Finix,
connectors::Fiserv,
connectors::Fiservemea,
connectors::Fiuu,
connectors::Forte,
connectors::Flexiti,
connectors::Getnet,
connectors::Gigadat,
connectors::Globalpay,
connectors::Globepay,
connectors::Gocardless,
connectors::Gpayments,
connectors::Hipay,
connectors::HyperswitchVault,
connectors::Hyperwallet,
connectors::Iatapay,
connectors::Inespay,
connectors::Itaubank,
connectors::Jpmorgan,
connectors::Juspaythreedsserver,
connectors::Klarna,
connectors::Loonio,
connectors::Katapult,
connectors::Helcim,
connectors::Netcetera,
connectors::Nmi,
connectors::Nomupay,
connectors::Noon,
connectors::Nordea,
connectors::Novalnet,
connectors::Nexinets,
connectors::Nexixpay,
connectors::Opayo,
connectors::Opennode,
connectors::Nuvei,
connectors::Paybox,
connectors::Payeezy,
connectors::Payload,
connectors::Payme,
connectors::Payone,
connectors::Paypal,
connectors::Paysafe,
connectors::Paystack,
connectors::Payu,
connectors::Paytm,
connectors::Peachpayments,
connectors::Phonepe,
connectors::Placetopay,
connectors::Plaid,
connectors::Powertranz,
connectors::Prophetpay,
connectors::Mifinity,
connectors::Mollie,
connectors::Moneris,
connectors::Multisafepay,
connectors::Mpgs,
connectors::Rapyd,
connectors::Razorpay,
connectors::Recurly,
connectors::Redsys,
connectors::Riskified,
connectors::Santander,
connectors::Shift4,
connectors::Sift,
connectors::Silverflow,
connectors::Signifyd,
connectors::Stax,
connectors::Square,
connectors::Stripe,
connectors::Stripebilling,
connectors::Taxjar,
connectors::Tesouro,
connectors::Threedsecureio,
connectors::Thunes,
connectors::Tokenex,
connectors::Tokenio,
connectors::Trustpay,
connectors::Trustpayments,
connectors::Tsys,
connectors::UnifiedAuthenticationService,
connectors::Wise,
connectors::Worldline,
connectors::Worldpay,
connectors::Worldpayxml,
connectors::Wellsfargo,
connectors::Wellsfargopayout,
connectors::Volt,
connectors::Xendit,
connectors::Zen,
connectors::Zsl,
connectors::CtpMastercard
);
macro_rules! default_imp_for_file_upload {
($($path:ident::$connector:ident),*) => {
$(
impl FileUpload for $path::$connector {}
impl UploadFile for $path::$connector {}
impl
ConnectorIntegration<
Upload,
UploadFileRequestData,
UploadFileResponse,
> for $path::$connector
{}
impl RetrieveFile for $path::$connector {}
impl
ConnectorIntegration<
Retrieve,
RetrieveFileRequestData,
RetrieveFileResponse,
> for $path::$connector
{}
)*
};
}
default_imp_for_file_upload!(
connectors::Vgs,
connectors::Aci,
connectors::Adyenplatform,
|
crates/hyperswitch_connectors/src/default_implementations.rs#chunk2
|
hyperswitch_connectors
|
chunk
| null | null | null | 8,190
| null | null | null | null | null | null | null |
// Implementation: impl api::PaymentCapture for for CtpMastercard
// File: crates/hyperswitch_connectors/src/connectors/ctp_mastercard.rs
// Module: hyperswitch_connectors
// Methods: 0 total (0 public)
impl api::PaymentCapture for for CtpMastercard
|
crates/hyperswitch_connectors/src/connectors/ctp_mastercard.rs
|
hyperswitch_connectors
|
impl_block
| null | null | null | 63
| null |
CtpMastercard
|
api::PaymentCapture for
| 0
| 0
| null | null |
// Function: retrieve_payment_method_from_auth_service
// File: crates/router/src/core/pm_auth.rs
// Module: router
pub fn retrieve_payment_method_from_auth_service(
state: &SessionState,
key_store: &domain::MerchantKeyStore,
auth_token: &payment_methods::BankAccountTokenData,
payment_intent: &PaymentIntent,
_customer: &Option<domain::Customer>,
) -> RouterResult<Option<(domain::PaymentMethodData, enums::PaymentMethod)>>
|
crates/router/src/core/pm_auth.rs
|
router
|
function_signature
| null | null | null | 102
|
retrieve_payment_method_from_auth_service
| null | null | null | null | null | null |
// File: crates/router/src/utils/user/two_factor_auth.rs
// Module: router
// Public functions: 16
use common_utils::pii;
use error_stack::ResultExt;
use masking::{ExposeInterface, PeekInterface};
use totp_rs::{Algorithm, TOTP};
use crate::{
consts,
core::errors::{UserErrors, UserResult},
routes::SessionState,
};
pub fn generate_default_totp(
email: pii::Email,
secret: Option<masking::Secret<String>>,
issuer: String,
) -> UserResult<TOTP> {
let secret = secret
.map(|sec| totp_rs::Secret::Encoded(sec.expose()))
.unwrap_or_else(totp_rs::Secret::generate_secret)
.to_bytes()
.change_context(UserErrors::InternalServerError)?;
TOTP::new(
Algorithm::SHA1,
consts::user::TOTP_DIGITS,
consts::user::TOTP_TOLERANCE,
consts::user::TOTP_VALIDITY_DURATION_IN_SECONDS,
secret,
Some(issuer),
email.expose().expose(),
)
.change_context(UserErrors::InternalServerError)
}
pub async fn check_totp_in_redis(state: &SessionState, user_id: &str) -> UserResult<bool> {
let redis_conn = super::get_redis_connection_for_global_tenant(state)?;
let key = format!("{}{}", consts::user::REDIS_TOTP_PREFIX, user_id);
redis_conn
.exists::<()>(&key.into())
.await
.change_context(UserErrors::InternalServerError)
}
pub async fn check_recovery_code_in_redis(state: &SessionState, user_id: &str) -> UserResult<bool> {
let redis_conn = super::get_redis_connection_for_global_tenant(state)?;
let key = format!("{}{}", consts::user::REDIS_RECOVERY_CODE_PREFIX, user_id);
redis_conn
.exists::<()>(&key.into())
.await
.change_context(UserErrors::InternalServerError)
}
pub async fn insert_totp_in_redis(state: &SessionState, user_id: &str) -> UserResult<()> {
let redis_conn = super::get_redis_connection_for_global_tenant(state)?;
let key = format!("{}{}", consts::user::REDIS_TOTP_PREFIX, user_id);
redis_conn
.set_key_with_expiry(
&key.as_str().into(),
common_utils::date_time::now_unix_timestamp(),
state.conf.user.two_factor_auth_expiry_in_secs,
)
.await
.change_context(UserErrors::InternalServerError)
}
pub async fn insert_totp_secret_in_redis(
state: &SessionState,
user_id: &str,
secret: &masking::Secret<String>,
) -> UserResult<()> {
let redis_conn = super::get_redis_connection_for_global_tenant(state)?;
redis_conn
.set_key_with_expiry(
&get_totp_secret_key(user_id).into(),
secret.peek(),
consts::user::REDIS_TOTP_SECRET_TTL_IN_SECS,
)
.await
.change_context(UserErrors::InternalServerError)
}
pub async fn get_totp_secret_from_redis(
state: &SessionState,
user_id: &str,
) -> UserResult<Option<masking::Secret<String>>> {
let redis_conn = super::get_redis_connection_for_global_tenant(state)?;
redis_conn
.get_key::<Option<String>>(&get_totp_secret_key(user_id).into())
.await
.change_context(UserErrors::InternalServerError)
.map(|secret| secret.map(Into::into))
}
pub async fn delete_totp_secret_from_redis(state: &SessionState, user_id: &str) -> UserResult<()> {
let redis_conn = super::get_redis_connection_for_global_tenant(state)?;
redis_conn
.delete_key(&get_totp_secret_key(user_id).into())
.await
.change_context(UserErrors::InternalServerError)
.map(|_| ())
}
fn get_totp_secret_key(user_id: &str) -> String {
format!("{}{}", consts::user::REDIS_TOTP_SECRET_PREFIX, user_id)
}
pub async fn insert_recovery_code_in_redis(state: &SessionState, user_id: &str) -> UserResult<()> {
let redis_conn = super::get_redis_connection_for_global_tenant(state)?;
let key = format!("{}{}", consts::user::REDIS_RECOVERY_CODE_PREFIX, user_id);
redis_conn
.set_key_with_expiry(
&key.as_str().into(),
common_utils::date_time::now_unix_timestamp(),
state.conf.user.two_factor_auth_expiry_in_secs,
)
.await
.change_context(UserErrors::InternalServerError)
}
pub async fn delete_totp_from_redis(state: &SessionState, user_id: &str) -> UserResult<()> {
let redis_conn = super::get_redis_connection_for_global_tenant(state)?;
let key = format!("{}{}", consts::user::REDIS_TOTP_PREFIX, user_id);
redis_conn
.delete_key(&key.into())
.await
.change_context(UserErrors::InternalServerError)
.map(|_| ())
}
pub async fn delete_recovery_code_from_redis(
state: &SessionState,
user_id: &str,
) -> UserResult<()> {
let redis_conn = super::get_redis_connection_for_global_tenant(state)?;
let key = format!("{}{}", consts::user::REDIS_RECOVERY_CODE_PREFIX, user_id);
redis_conn
.delete_key(&key.into())
.await
.change_context(UserErrors::InternalServerError)
.map(|_| ())
}
fn get_totp_attempts_key(user_id: &str) -> String {
format!("{}{}", consts::user::REDIS_TOTP_ATTEMPTS_PREFIX, user_id)
}
fn get_recovery_code_attempts_key(user_id: &str) -> String {
format!(
"{}{}",
consts::user::REDIS_RECOVERY_CODE_ATTEMPTS_PREFIX,
user_id
)
}
pub async fn insert_totp_attempts_in_redis(
state: &SessionState,
user_id: &str,
user_totp_attempts: u8,
) -> UserResult<()> {
let redis_conn = super::get_redis_connection_for_global_tenant(state)?;
redis_conn
.set_key_with_expiry(
&get_totp_attempts_key(user_id).into(),
user_totp_attempts,
consts::user::REDIS_TOTP_ATTEMPTS_TTL_IN_SECS,
)
.await
.change_context(UserErrors::InternalServerError)
}
pub async fn get_totp_attempts_from_redis(state: &SessionState, user_id: &str) -> UserResult<u8> {
let redis_conn = super::get_redis_connection_for_global_tenant(state)?;
redis_conn
.get_key::<Option<u8>>(&get_totp_attempts_key(user_id).into())
.await
.change_context(UserErrors::InternalServerError)
.map(|v| v.unwrap_or(0))
}
pub async fn insert_recovery_code_attempts_in_redis(
state: &SessionState,
user_id: &str,
user_recovery_code_attempts: u8,
) -> UserResult<()> {
let redis_conn = super::get_redis_connection_for_global_tenant(state)?;
redis_conn
.set_key_with_expiry(
&get_recovery_code_attempts_key(user_id).into(),
user_recovery_code_attempts,
consts::user::REDIS_RECOVERY_CODE_ATTEMPTS_TTL_IN_SECS,
)
.await
.change_context(UserErrors::InternalServerError)
}
pub async fn get_recovery_code_attempts_from_redis(
state: &SessionState,
user_id: &str,
) -> UserResult<u8> {
let redis_conn = super::get_redis_connection_for_global_tenant(state)?;
redis_conn
.get_key::<Option<u8>>(&get_recovery_code_attempts_key(user_id).into())
.await
.change_context(UserErrors::InternalServerError)
.map(|v| v.unwrap_or(0))
}
pub async fn delete_totp_attempts_from_redis(
state: &SessionState,
user_id: &str,
) -> UserResult<()> {
let redis_conn = super::get_redis_connection_for_global_tenant(state)?;
redis_conn
.delete_key(&get_totp_attempts_key(user_id).into())
.await
.change_context(UserErrors::InternalServerError)
.map(|_| ())
}
pub async fn delete_recovery_code_attempts_from_redis(
state: &SessionState,
user_id: &str,
) -> UserResult<()> {
let redis_conn = super::get_redis_connection_for_global_tenant(state)?;
redis_conn
.delete_key(&get_recovery_code_attempts_key(user_id).into())
.await
.change_context(UserErrors::InternalServerError)
.map(|_| ())
}
|
crates/router/src/utils/user/two_factor_auth.rs
|
router
|
full_file
| null | null | null | 1,861
| null | null | null | null | null | null | null |
// Implementation: impl GetPaymentMethodDetails for for DummyConnectorPayLater
// File: crates/router/src/routes/dummy_connector/types.rs
// Module: router
// Methods: 2 total (0 public)
impl GetPaymentMethodDetails for for DummyConnectorPayLater
|
crates/router/src/routes/dummy_connector/types.rs
|
router
|
impl_block
| null | null | null | 54
| null |
DummyConnectorPayLater
|
GetPaymentMethodDetails for
| 2
| 0
| null | null |
// Struct: PayloadMandateRequestData
// File: crates/hyperswitch_connectors/src/connectors/payload/requests.rs
// Module: hyperswitch_connectors
// Implementations: 0
pub struct PayloadMandateRequestData
|
crates/hyperswitch_connectors/src/connectors/payload/requests.rs
|
hyperswitch_connectors
|
struct_definition
|
PayloadMandateRequestData
| 0
|
[] | 52
| null | null | null | null | null | null | null |
// Module Structure
// File: crates/router/src/core/payment_link.rs
// Module: router
// Public submodules:
pub mod validator;
|
crates/router/src/core/payment_link.rs
|
router
|
module_structure
| null | null | null | 29
| null | null | null | null | null | 1
| 0
|
// File: crates/router/tests/connectors/stax.rs
// Module: router
use std::{str::FromStr, time::Duration};
use masking::Secret;
use router::types::{self, domain, storage::enums, PaymentsResponseData};
use test_utils::connector_auth;
use crate::utils::{self, ConnectorActions};
#[derive(Clone, Copy)]
struct StaxTest;
impl ConnectorActions for StaxTest {}
impl utils::Connector for StaxTest {
fn get_data(&self) -> types::api::ConnectorData {
use router::connector::Stax;
utils::construct_connector_data_old(
Box::new(&Stax),
types::Connector::Stax,
types::api::GetToken::Connector,
None,
)
}
fn get_auth_token(&self) -> types::ConnectorAuthType {
utils::to_connector_auth_type(
connector_auth::ConnectorAuthentication::new()
.stax
.expect("Missing connector authentication configuration")
.into(),
)
}
fn get_name(&self) -> String {
"stax".to_string()
}
}
static CONNECTOR: StaxTest = StaxTest {};
fn get_default_payment_info(
connector_customer: Option<String>,
payment_method_token: Option<String>,
) -> Option<utils::PaymentInfo> {
Some(utils::PaymentInfo {
address: None,
auth_type: None,
access_token: None,
connector_meta_data: None,
connector_customer,
payment_method_token,
#[cfg(feature = "payouts")]
payout_method_data: None,
#[cfg(feature = "payouts")]
currency: None,
})
}
fn customer_details() -> Option<types::ConnectorCustomerData> {
Some(types::ConnectorCustomerData {
..utils::CustomerType::default().0
})
}
fn token_details() -> Option<types::PaymentMethodTokenizationData> {
Some(types::PaymentMethodTokenizationData {
payment_method_data: domain::PaymentMethodData::Card(domain::Card {
card_number: cards::CardNumber::from_str("4111111111111111").unwrap(),
card_exp_month: Secret::new("04".to_string()),
card_exp_year: Secret::new("2027".to_string()),
card_cvc: Secret::new("123".to_string()),
..utils::CCardType::default().0
}),
browser_info: None,
amount: None,
currency: enums::Currency::USD,
split_payments: None,
mandate_id: None,
setup_future_usage: None,
customer_acceptance: None,
setup_mandate_details: None,
})
}
fn payment_method_details() -> Option<types::PaymentsAuthorizeData> {
Some(types::PaymentsAuthorizeData {
..utils::PaymentAuthorizeType::default().0
})
}
async fn create_customer_and_get_token() -> Option<String> {
let customer_response = CONNECTOR
.create_connector_customer(customer_details(), get_default_payment_info(None, None))
.await
.expect("Authorize payment response");
let connector_customer_id = match customer_response.response.unwrap() {
PaymentsResponseData::ConnectorCustomerResponse(customer_data) => {
Some(customer_data.connector_customer_id)
}
_ => None,
};
let token_response = CONNECTOR
.create_connector_pm_token(
token_details(),
get_default_payment_info(connector_customer_id, None),
)
.await
.expect("Authorize payment response");
match token_response.response.unwrap() {
PaymentsResponseData::TokenizationResponse { token } => Some(token),
_ => None,
}
}
// Cards Positive Tests
// Creates a payment using the manual capture flow (Non 3DS).
#[actix_web::test]
async fn should_only_authorize_payment() {
let response = CONNECTOR
.authorize_payment(
payment_method_details(),
get_default_payment_info(None, create_customer_and_get_token().await),
)
.await
.expect("Authorize payment response");
assert_eq!(response.status, enums::AttemptStatus::Authorized);
}
// Captures a payment using the manual capture flow (Non 3DS).
#[actix_web::test]
async fn should_capture_authorized_payment() {
let response = CONNECTOR
.authorize_and_capture_payment(
payment_method_details(),
None,
get_default_payment_info(None, create_customer_and_get_token().await),
)
.await
.expect("Capture payment response");
assert_eq!(response.status, enums::AttemptStatus::Charged);
}
// Partially captures a payment using the manual capture flow (Non 3DS).
#[actix_web::test]
async fn should_partially_capture_authorized_payment() {
let response = CONNECTOR
.authorize_and_capture_payment(
payment_method_details(),
Some(types::PaymentsCaptureData {
amount_to_capture: 50,
..utils::PaymentCaptureType::default().0
}),
get_default_payment_info(None, create_customer_and_get_token().await),
)
.await
.expect("Capture payment response");
assert_eq!(response.status, enums::AttemptStatus::Charged);
}
// Synchronizes a payment using the manual capture flow (Non 3DS).
#[actix_web::test]
async fn should_sync_authorized_payment() {
let authorize_response = CONNECTOR
.authorize_payment(
payment_method_details(),
get_default_payment_info(None, create_customer_and_get_token().await),
)
.await
.expect("Authorize payment response");
let txn_id = utils::get_connector_transaction_id(authorize_response.response);
let response = CONNECTOR
.psync_retry_till_status_matches(
enums::AttemptStatus::Authorized,
Some(types::PaymentsSyncData {
connector_transaction_id: types::ResponseId::ConnectorTransactionId(
txn_id.unwrap(),
),
..Default::default()
}),
get_default_payment_info(None, None),
)
.await
.expect("PSync response");
assert_eq!(response.status, enums::AttemptStatus::Authorized,);
}
// Voids a payment using the manual capture flow (Non 3DS).
#[actix_web::test]
async fn should_void_authorized_payment() {
let response = CONNECTOR
.authorize_and_void_payment(
payment_method_details(),
Some(types::PaymentsCancelData {
connector_transaction_id: String::from(""),
cancellation_reason: Some("requested_by_customer".to_string()),
..Default::default()
}),
get_default_payment_info(None, create_customer_and_get_token().await),
)
.await
.expect("Void payment response");
assert_eq!(response.status, enums::AttemptStatus::Voided);
}
// Refunds a payment using the manual capture flow (Non 3DS).
#[actix_web::test]
async fn should_refund_manually_captured_payment() {
let capture_response = CONNECTOR
.authorize_and_capture_payment(
payment_method_details(),
Some(types::PaymentsCaptureData {
..utils::PaymentCaptureType::default().0
}),
get_default_payment_info(None, create_customer_and_get_token().await),
)
.await
.expect("Capture payment response");
let refund_txn_id =
utils::get_connector_transaction_id(capture_response.response.clone()).unwrap();
let refund_connector_meta = utils::get_connector_metadata(capture_response.response);
let response = CONNECTOR
.refund_payment(
refund_txn_id,
Some(types::RefundsData {
connector_metadata: refund_connector_meta,
..utils::PaymentRefundType::default().0
}),
get_default_payment_info(None, None),
)
.await
.unwrap();
assert_eq!(
response.response.unwrap().refund_status,
enums::RefundStatus::Success,
);
}
// Partially refunds a payment using the manual capture flow (Non 3DS).
#[actix_web::test]
async fn should_partially_refund_manually_captured_payment() {
let capture_response = CONNECTOR
.authorize_and_capture_payment(
payment_method_details(),
Some(types::PaymentsCaptureData {
..utils::PaymentCaptureType::default().0
}),
get_default_payment_info(None, create_customer_and_get_token().await),
)
.await
.expect("Capture payment response");
let refund_txn_id =
utils::get_connector_transaction_id(capture_response.response.clone()).unwrap();
let refund_connector_meta = utils::get_connector_metadata(capture_response.response);
let response = CONNECTOR
.refund_payment(
refund_txn_id,
Some(types::RefundsData {
refund_amount: 50,
connector_metadata: refund_connector_meta,
..utils::PaymentRefundType::default().0
}),
get_default_payment_info(None, None),
)
.await
.unwrap();
assert_eq!(
response.response.unwrap().refund_status,
enums::RefundStatus::Success,
);
}
// Synchronizes a refund using the manual capture flow (Non 3DS).
#[actix_web::test]
async fn should_sync_manually_captured_refund() {
let capture_response = CONNECTOR
.authorize_and_capture_payment(
payment_method_details(),
Some(types::PaymentsCaptureData {
..utils::PaymentCaptureType::default().0
}),
get_default_payment_info(None, create_customer_and_get_token().await),
)
.await
.expect("Capture payment response");
let refund_txn_id =
utils::get_connector_transaction_id(capture_response.response.clone()).unwrap();
let refund_connector_meta = utils::get_connector_metadata(capture_response.response);
let refund_response = CONNECTOR
.refund_payment(
refund_txn_id,
Some(types::RefundsData {
connector_metadata: refund_connector_meta,
..utils::PaymentRefundType::default().0
}),
get_default_payment_info(None, None),
)
.await
.unwrap();
let response = CONNECTOR
.rsync_retry_till_status_matches(
enums::RefundStatus::Success,
refund_response.response.unwrap().connector_refund_id,
None,
get_default_payment_info(None, None),
)
.await
.unwrap();
assert_eq!(
response.response.unwrap().refund_status,
enums::RefundStatus::Success,
);
}
// Creates a payment using the automatic capture flow (Non 3DS).
#[actix_web::test]
async fn should_make_payment() {
let authorize_response = CONNECTOR
.make_payment(
payment_method_details(),
get_default_payment_info(None, create_customer_and_get_token().await),
)
.await
.unwrap();
assert_eq!(authorize_response.status, enums::AttemptStatus::Charged);
}
// Synchronizes a payment using the automatic capture flow (Non 3DS).
#[actix_web::test]
async fn should_sync_auto_captured_payment() {
let authorize_response = CONNECTOR
.make_payment(
payment_method_details(),
get_default_payment_info(None, create_customer_and_get_token().await),
)
.await
.unwrap();
assert_eq!(authorize_response.status, enums::AttemptStatus::Charged);
let txn_id = utils::get_connector_transaction_id(authorize_response.response);
assert_ne!(txn_id, None, "Empty connector transaction id");
let response = CONNECTOR
.psync_retry_till_status_matches(
enums::AttemptStatus::Charged,
Some(types::PaymentsSyncData {
connector_transaction_id: types::ResponseId::ConnectorTransactionId(
txn_id.unwrap(),
),
capture_method: Some(enums::CaptureMethod::Automatic),
..Default::default()
}),
get_default_payment_info(None, None),
)
.await
.unwrap();
assert_eq!(response.status, enums::AttemptStatus::Charged,);
}
// Refunds a payment using the automatic capture flow (Non 3DS).
#[actix_web::test]
async fn should_refund_auto_captured_payment() {
let response = CONNECTOR
.make_payment_and_refund(
payment_method_details(),
None,
get_default_payment_info(None, create_customer_and_get_token().await),
)
.await
.unwrap();
assert_eq!(
response.response.unwrap().refund_status,
enums::RefundStatus::Success,
);
}
// Partially refunds a payment using the automatic capture flow (Non 3DS).
#[actix_web::test]
async fn should_partially_refund_succeeded_payment() {
let refund_response = CONNECTOR
.make_payment_and_refund(
payment_method_details(),
Some(types::RefundsData {
refund_amount: 50,
..utils::PaymentRefundType::default().0
}),
get_default_payment_info(None, create_customer_and_get_token().await),
)
.await
.unwrap();
assert_eq!(
refund_response.response.unwrap().refund_status,
enums::RefundStatus::Success,
);
}
// Creates multiple refunds against a payment using the automatic capture flow (Non 3DS).
#[actix_web::test]
async fn should_refund_succeeded_payment_multiple_times() {
let payment_method_token = create_customer_and_get_token().await;
let response = CONNECTOR
.make_payment(
payment_method_details(),
get_default_payment_info(None, payment_method_token.clone()),
)
.await
.unwrap();
//try refund for previous payment
let transaction_id = utils::get_connector_transaction_id(response.response).unwrap();
for _x in 0..2 {
tokio::time::sleep(Duration::from_secs(60)).await; // to avoid 404 error
let refund_response = CONNECTOR
.refund_payment(
transaction_id.clone(),
Some(types::RefundsData {
refund_amount: 50,
..utils::PaymentRefundType::default().0
}),
get_default_payment_info(None, payment_method_token.clone()),
)
.await
.unwrap();
assert_eq!(
refund_response.response.unwrap().refund_status,
enums::RefundStatus::Success,
);
}
}
// Synchronizes a refund using the automatic capture flow (Non 3DS).
#[actix_web::test]
async fn should_sync_refund() {
let refund_response = CONNECTOR
.make_payment_and_refund(
payment_method_details(),
None,
get_default_payment_info(None, create_customer_and_get_token().await),
)
.await
.unwrap();
let response = CONNECTOR
.rsync_retry_till_status_matches(
enums::RefundStatus::Success,
refund_response.response.unwrap().connector_refund_id,
None,
get_default_payment_info(None, None),
)
.await
.unwrap();
assert_eq!(
response.response.unwrap().refund_status,
enums::RefundStatus::Success,
);
}
// Cards Negative scenarios
// Creates a payment with incorrect CVC.
#[actix_web::test]
async fn should_fail_payment_for_incorrect_cvc() {
let customer_response = CONNECTOR
.create_connector_customer(customer_details(), get_default_payment_info(None, None))
.await
.expect("Authorize payment response");
let connector_customer_id = match customer_response.response.unwrap() {
PaymentsResponseData::ConnectorCustomerResponse(customer_data) => {
Some(customer_data.connector_customer_id)
}
_ => None,
};
let token_response = CONNECTOR
.create_connector_pm_token(
Some(types::PaymentMethodTokenizationData {
payment_method_data: domain::PaymentMethodData::Card(domain::Card {
card_number: cards::CardNumber::from_str("4111111111111111").unwrap(),
card_exp_month: Secret::new("11".to_string()),
card_exp_year: Secret::new("2027".to_string()),
card_cvc: Secret::new("123456".to_string()),
..utils::CCardType::default().0
}),
browser_info: None,
amount: None,
currency: enums::Currency::USD,
split_payments: None,
mandate_id: None,
setup_future_usage: None,
customer_acceptance: None,
setup_mandate_details: None,
}),
get_default_payment_info(connector_customer_id, None),
)
.await
.expect("Authorize payment response");
assert_eq!(
token_response.response.unwrap_err().reason,
Some(r#"{"card_cvv":["The card cvv may not be greater than 99999."]}"#.to_string()),
);
}
// Creates a payment with incorrect expiry month.
#[actix_web::test]
async fn should_fail_payment_for_invalid_exp_month() {
let customer_response = CONNECTOR
.create_connector_customer(customer_details(), get_default_payment_info(None, None))
.await
.expect("Authorize payment response");
let connector_customer_id = match customer_response.response.unwrap() {
PaymentsResponseData::ConnectorCustomerResponse(customer_data) => {
Some(customer_data.connector_customer_id)
}
_ => None,
};
let token_response = CONNECTOR
.create_connector_pm_token(
Some(types::PaymentMethodTokenizationData {
payment_method_data: domain::PaymentMethodData::Card(domain::Card {
card_number: cards::CardNumber::from_str("4111111111111111").unwrap(),
card_exp_month: Secret::new("20".to_string()),
card_exp_year: Secret::new("2027".to_string()),
card_cvc: Secret::new("123".to_string()),
..utils::CCardType::default().0
}),
browser_info: None,
amount: None,
currency: enums::Currency::USD,
split_payments: None,
mandate_id: None,
setup_future_usage: None,
customer_acceptance: None,
setup_mandate_details: None,
}),
get_default_payment_info(connector_customer_id, None),
)
.await
.expect("Authorize payment response");
assert_eq!(
token_response.response.unwrap_err().reason,
Some(r#"{"validation":["Tokenization Validation Errors: Month is invalid"]}"#.to_string()),
);
}
// Creates a payment with incorrect expiry year.
#[actix_web::test]
async fn should_fail_payment_for_incorrect_expiry_year() {
let customer_response = CONNECTOR
.create_connector_customer(customer_details(), get_default_payment_info(None, None))
.await
.expect("Authorize payment response");
let connector_customer_id = match customer_response.response.unwrap() {
PaymentsResponseData::ConnectorCustomerResponse(customer_data) => {
Some(customer_data.connector_customer_id)
}
_ => None,
};
let token_response = CONNECTOR
.create_connector_pm_token(
Some(types::PaymentMethodTokenizationData {
payment_method_data: domain::PaymentMethodData::Card(domain::Card {
card_number: cards::CardNumber::from_str("4111111111111111").unwrap(),
card_exp_month: Secret::new("04".to_string()),
card_exp_year: Secret::new("2000".to_string()),
card_cvc: Secret::new("123".to_string()),
..utils::CCardType::default().0
}),
browser_info: None,
amount: None,
currency: enums::Currency::USD,
split_payments: None,
mandate_id: None,
setup_future_usage: None,
customer_acceptance: None,
setup_mandate_details: None,
}),
get_default_payment_info(connector_customer_id, None),
)
.await
.expect("Authorize payment response");
assert_eq!(
token_response.response.unwrap_err().reason,
Some(r#"{"validation":["Tokenization Validation Errors: Year is invalid"]}"#.to_string()),
);
}
// Voids a payment using automatic capture flow (Non 3DS).
#[actix_web::test]
#[ignore = "Connector Refunds the payment on Void call for Auto Captured Payment"]
async fn should_fail_void_payment_for_auto_capture() {
let authorize_response = CONNECTOR
.make_payment(
payment_method_details(),
get_default_payment_info(None, create_customer_and_get_token().await),
)
.await
.unwrap();
assert_eq!(authorize_response.status, enums::AttemptStatus::Charged);
let txn_id = utils::get_connector_transaction_id(authorize_response.response);
assert_ne!(txn_id, None, "Empty connector transaction id");
let void_response = CONNECTOR
.void_payment(txn_id.unwrap(), None, get_default_payment_info(None, None))
.await
.unwrap();
assert_eq!(
void_response.response.unwrap_err().message,
"You cannot cancel this PaymentIntent because it has a status of succeeded."
);
}
// Captures a payment using invalid connector payment id.
#[actix_web::test]
async fn should_fail_capture_for_invalid_payment() {
let capture_response = CONNECTOR
.capture_payment(
"123456789".to_string(),
None,
get_default_payment_info(None, create_customer_and_get_token().await),
)
.await
.unwrap();
assert_eq!(
capture_response.response.unwrap_err().reason,
Some(r#"{"id":["The selected id is invalid."]}"#.to_string()),
);
}
// Refunds a payment with refund amount higher than payment amount.
#[actix_web::test]
async fn should_fail_for_refund_amount_higher_than_payment_amount() {
let response = CONNECTOR
.make_payment_and_refund(
payment_method_details(),
Some(types::RefundsData {
refund_amount: 150,
..utils::PaymentRefundType::default().0
}),
get_default_payment_info(None, create_customer_and_get_token().await),
)
.await
.unwrap();
assert_eq!(
response.response.unwrap_err().reason,
Some(r#"{"total":["The total may not be greater than 1."]}"#.to_string()),
);
}
// Connector dependent test cases goes here
// [#478]: add unit tests for non 3DS, wallets & webhooks in connector tests
|
crates/router/tests/connectors/stax.rs
|
router
|
full_file
| null | null | null | 4,807
| null | null | null | null | null | null | null |
// Function: get_mandate
// File: crates/router/src/routes/mandates.rs
// Module: router
pub fn get_mandate(
state: web::Data<AppState>,
req: HttpRequest,
path: web::Path<String>,
) -> HttpResponse
|
crates/router/src/routes/mandates.rs
|
router
|
function_signature
| null | null | null | 57
|
get_mandate
| null | null | null | null | null | null |
// Struct: Fulfillment
// File: crates/hyperswitch_domain_models/src/router_flow_types/fraud_check.rs
// Module: hyperswitch_domain_models
// Implementations: 0
pub struct Fulfillment
|
crates/hyperswitch_domain_models/src/router_flow_types/fraud_check.rs
|
hyperswitch_domain_models
|
struct_definition
|
Fulfillment
| 0
|
[] | 46
| null | null | null | null | null | null | null |
// Function: routing_create_config
// File: crates/openapi/src/routes/routing.rs
// Module: openapi
pub fn routing_create_config()
|
crates/openapi/src/routes/routing.rs
|
openapi
|
function_signature
| null | null | null | 31
|
routing_create_config
| null | null | null | null | null | null |
// Implementation: impl api::ConnectorAccessToken for for Wise
// File: crates/hyperswitch_connectors/src/connectors/wise.rs
// Module: hyperswitch_connectors
// Methods: 0 total (0 public)
impl api::ConnectorAccessToken for for Wise
|
crates/hyperswitch_connectors/src/connectors/wise.rs
|
hyperswitch_connectors
|
impl_block
| null | null | null | 55
| null |
Wise
|
api::ConnectorAccessToken for
| 0
| 0
| null | null |
// Function: authentication_create
// File: crates/openapi/src/routes/authentication.rs
// Module: openapi
pub fn authentication_create()
|
crates/openapi/src/routes/authentication.rs
|
openapi
|
function_signature
| null | null | null | 28
|
authentication_create
| null | null | null | null | null | null |
// Struct: PaymentIntentUpdateFields
// File: crates/hyperswitch_domain_models/src/payments/payment_intent.rs
// Module: hyperswitch_domain_models
// Implementations: 0
pub struct PaymentIntentUpdateFields
|
crates/hyperswitch_domain_models/src/payments/payment_intent.rs
|
hyperswitch_domain_models
|
struct_definition
|
PaymentIntentUpdateFields
| 0
|
[] | 46
| null | null | null | null | null | null | null |
// File: crates/hyperswitch_connectors/src/connectors/multisafepay.rs
// Module: hyperswitch_connectors
// Public functions: 1
// Public structs: 1
pub mod transformers;
use std::sync::LazyLock;
use api_models::webhooks::IncomingWebhookEvent;
use common_enums::{enums, AttemptStatus};
use common_utils::{
errors::CustomResult,
ext_traits::BytesExt,
request::{Method, Request, RequestBuilder, RequestContent},
types::{AmountConvertor, MinorUnit, MinorUnitForConnector},
};
use error_stack::{report, ResultExt};
use hyperswitch_domain_models::{
payment_method_data::PaymentMethodData,
router_data::{AccessToken, ConnectorAuthType, ErrorResponse, RouterData},
router_flow_types::{
access_token_auth::AccessTokenAuth,
payments::{Authorize, Capture, PSync, PaymentMethodToken, Session, SetupMandate, Void},
refunds::{Execute, RSync},
},
router_request_types::{
AccessTokenRequestData, PaymentMethodTokenizationData, PaymentsAuthorizeData,
PaymentsCancelData, PaymentsCaptureData, PaymentsSessionData, PaymentsSyncData,
RefundsData, SetupMandateRequestData,
},
router_response_types::{
ConnectorInfo, PaymentMethodDetails, PaymentsResponseData, RefundsResponseData,
SupportedPaymentMethods, SupportedPaymentMethodsExt,
},
types::{
PaymentsAuthorizeRouterData, PaymentsSyncRouterData, RefundSyncRouterData,
RefundsRouterData,
},
};
use hyperswitch_interfaces::{
api::{
self, ConnectorCommon, ConnectorCommonExt, ConnectorIntegration, ConnectorSpecifications,
ConnectorValidation,
},
configs::Connectors,
errors,
events::connector_api_logs::ConnectorEvent,
types::{self, Response},
webhooks::{IncomingWebhook, IncomingWebhookRequestDetails},
};
use masking::{ExposeInterface, Mask};
use transformers as multisafepay;
use crate::{
constants::headers,
types::ResponseRouterData,
utils::{convert_amount, is_mandate_supported, PaymentMethodDataType},
};
#[derive(Clone)]
pub struct Multisafepay {
amount_converter: &'static (dyn AmountConvertor<Output = MinorUnit> + Sync),
}
impl Multisafepay {
pub fn new() -> &'static Self {
&Self {
amount_converter: &MinorUnitForConnector,
}
}
}
impl<Flow, Request, Response> ConnectorCommonExt<Flow, Request, Response> for Multisafepay
where
Self: ConnectorIntegration<Flow, Request, Response>,
{
fn build_headers(
&self,
_req: &RouterData<Flow, Request, Response>,
_connectors: &Connectors,
) -> CustomResult<Vec<(String, masking::Maskable<String>)>, errors::ConnectorError> {
Ok(vec![])
}
}
impl ConnectorCommon for Multisafepay {
fn id(&self) -> &'static str {
"multisafepay"
}
fn get_currency_unit(&self) -> api::CurrencyUnit {
api::CurrencyUnit::Minor
}
fn common_get_content_type(&self) -> &'static str {
"application/json"
}
fn base_url<'a>(&self, connectors: &'a Connectors) -> &'a str {
connectors.multisafepay.base_url.as_ref()
}
fn get_auth_header(
&self,
auth_type: &ConnectorAuthType,
) -> CustomResult<Vec<(String, masking::Maskable<String>)>, errors::ConnectorError> {
let auth = multisafepay::MultisafepayAuthType::try_from(auth_type)
.change_context(errors::ConnectorError::FailedToObtainAuthType)?;
Ok(vec![(
headers::AUTHORIZATION.to_string(),
auth.api_key.into_masked(),
)])
}
fn build_error_response(
&self,
res: Response,
event_builder: Option<&mut ConnectorEvent>,
) -> CustomResult<ErrorResponse, errors::ConnectorError> {
let response: multisafepay::MultisafepayErrorResponse = res
.response
.parse_struct("MultisafepayErrorResponse")
.change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
event_builder.map(|i| i.set_error_response_body(&response));
router_env::logger::info!(connector_response=?response);
let attempt_status = Option::<AttemptStatus>::from(response.clone());
Ok(multisafepay::populate_error_reason(
Some(response.error_code.to_string()),
Some(response.error_info.clone()),
Some(response.error_info),
res.status_code,
attempt_status,
None,
))
}
}
impl ConnectorValidation for Multisafepay {
fn validate_mandate_payment(
&self,
pm_type: Option<enums::PaymentMethodType>,
pm_data: PaymentMethodData,
) -> CustomResult<(), errors::ConnectorError> {
let mandate_supported_pmd = std::collections::HashSet::from([
PaymentMethodDataType::Card,
PaymentMethodDataType::GooglePay,
]);
is_mandate_supported(pm_data, pm_type, mandate_supported_pmd, self.id())
}
}
impl api::Payment for Multisafepay {}
impl api::PaymentToken for Multisafepay {}
impl ConnectorIntegration<PaymentMethodToken, PaymentMethodTokenizationData, PaymentsResponseData>
for Multisafepay
{
// Not Implemented (R)
}
impl api::MandateSetup for Multisafepay {}
impl ConnectorIntegration<SetupMandate, SetupMandateRequestData, PaymentsResponseData>
for Multisafepay
{
fn build_request(
&self,
_req: &RouterData<SetupMandate, SetupMandateRequestData, PaymentsResponseData>,
_connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Err(errors::ConnectorError::NotImplemented(
"Setup Mandate flow for Multisafepay".to_string(),
)
.into())
}
}
impl api::PaymentVoid for Multisafepay {}
impl ConnectorIntegration<Void, PaymentsCancelData, PaymentsResponseData> for Multisafepay {}
impl api::ConnectorAccessToken for Multisafepay {}
impl ConnectorIntegration<AccessTokenAuth, AccessTokenRequestData, AccessToken> for Multisafepay {}
impl api::PaymentSync for Multisafepay {}
impl ConnectorIntegration<PSync, PaymentsSyncData, PaymentsResponseData> for Multisafepay {
fn get_headers(
&self,
req: &PaymentsSyncRouterData,
connectors: &Connectors,
) -> CustomResult<Vec<(String, masking::Maskable<String>)>, errors::ConnectorError> {
self.build_headers(req, connectors)
}
fn get_content_type(&self) -> &'static str {
self.common_get_content_type()
}
fn get_url(
&self,
req: &PaymentsSyncRouterData,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
let url = self.base_url(connectors);
let api_key = multisafepay::MultisafepayAuthType::try_from(&req.connector_auth_type)
.change_context(errors::ConnectorError::FailedToObtainAuthType)?
.api_key
.expose();
let ord_id = req.connector_request_reference_id.clone();
Ok(format!("{url}v1/json/orders/{ord_id}?api_key={api_key}"))
}
fn build_request(
&self,
req: &PaymentsSyncRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Ok(Some(
RequestBuilder::new()
.method(Method::Get)
.url(&types::PaymentsSyncType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(types::PaymentsSyncType::get_headers(self, req, connectors)?)
.build(),
))
}
fn get_error_response(
&self,
res: Response,
event_builder: Option<&mut ConnectorEvent>,
) -> CustomResult<ErrorResponse, errors::ConnectorError> {
self.build_error_response(res, event_builder)
}
fn handle_response(
&self,
data: &PaymentsSyncRouterData,
event_builder: Option<&mut ConnectorEvent>,
res: Response,
) -> CustomResult<PaymentsSyncRouterData, errors::ConnectorError> {
let response: multisafepay::MultisafepayAuthResponse = res
.response
.parse_struct("multisafepay PaymentsResponse")
.change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
event_builder.map(|i| i.set_response_body(&response));
router_env::logger::info!(connector_response=?response);
RouterData::try_from(ResponseRouterData {
response,
data: data.clone(),
http_code: res.status_code,
})
.change_context(errors::ConnectorError::ResponseHandlingFailed)
}
}
impl api::PaymentCapture for Multisafepay {}
impl ConnectorIntegration<Capture, PaymentsCaptureData, PaymentsResponseData> for Multisafepay {}
impl api::PaymentSession for Multisafepay {}
impl ConnectorIntegration<Session, PaymentsSessionData, PaymentsResponseData> for Multisafepay {
//TODO: implement sessions flow
}
impl api::PaymentAuthorize for Multisafepay {}
impl ConnectorIntegration<Authorize, PaymentsAuthorizeData, PaymentsResponseData> for Multisafepay {
fn get_headers(
&self,
req: &PaymentsAuthorizeRouterData,
connectors: &Connectors,
) -> CustomResult<Vec<(String, masking::Maskable<String>)>, errors::ConnectorError> {
self.build_headers(req, connectors)
}
fn get_content_type(&self) -> &'static str {
self.common_get_content_type()
}
fn get_url(
&self,
req: &PaymentsAuthorizeRouterData,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
let url = self.base_url(connectors);
let api_key = multisafepay::MultisafepayAuthType::try_from(&req.connector_auth_type)
.change_context(errors::ConnectorError::FailedToObtainAuthType)?
.api_key
.expose();
Ok(format!("{url}v1/json/orders?api_key={api_key}"))
}
fn get_request_body(
&self,
req: &PaymentsAuthorizeRouterData,
_connectors: &Connectors,
) -> CustomResult<RequestContent, errors::ConnectorError> {
let amount = convert_amount(
self.amount_converter,
req.request.minor_amount,
req.request.currency,
)?;
let connector_router_data = multisafepay::MultisafepayRouterData::from((amount, req));
let connector_req =
multisafepay::MultisafepayPaymentsRequest::try_from(&connector_router_data)?;
Ok(RequestContent::Json(Box::new(connector_req)))
}
fn build_request(
&self,
req: &PaymentsAuthorizeRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Ok(Some(
RequestBuilder::new()
.method(Method::Post)
.url(&types::PaymentsAuthorizeType::get_url(
self, req, connectors,
)?)
.attach_default_headers()
.headers(types::PaymentsAuthorizeType::get_headers(
self, req, connectors,
)?)
.set_body(types::PaymentsAuthorizeType::get_request_body(
self, req, connectors,
)?)
.build(),
))
}
fn handle_response(
&self,
data: &PaymentsAuthorizeRouterData,
event_builder: Option<&mut ConnectorEvent>,
res: Response,
) -> CustomResult<PaymentsAuthorizeRouterData, errors::ConnectorError> {
let response: multisafepay::MultisafepayAuthResponse = res
.response
.parse_struct("MultisafepayPaymentsResponse")
.change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
event_builder.map(|i| i.set_response_body(&response));
router_env::logger::info!(connector_response=?response);
RouterData::try_from(ResponseRouterData {
response,
data: data.clone(),
http_code: res.status_code,
})
.change_context(errors::ConnectorError::ResponseHandlingFailed)
}
fn get_error_response(
&self,
res: Response,
event_builder: Option<&mut ConnectorEvent>,
) -> CustomResult<ErrorResponse, errors::ConnectorError> {
self.build_error_response(res, event_builder)
}
}
impl api::Refund for Multisafepay {}
impl api::RefundExecute for Multisafepay {}
impl api::RefundSync for Multisafepay {}
impl ConnectorIntegration<Execute, RefundsData, RefundsResponseData> for Multisafepay {
fn get_headers(
&self,
req: &RefundsRouterData<Execute>,
connectors: &Connectors,
) -> CustomResult<Vec<(String, masking::Maskable<String>)>, errors::ConnectorError> {
self.build_headers(req, connectors)
}
fn get_content_type(&self) -> &'static str {
self.common_get_content_type()
}
fn get_url(
&self,
req: &RefundsRouterData<Execute>,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
let url = self.base_url(connectors);
let api_key = multisafepay::MultisafepayAuthType::try_from(&req.connector_auth_type)
.change_context(errors::ConnectorError::FailedToObtainAuthType)?
.api_key
.expose();
let ord_id = req.connector_request_reference_id.clone();
Ok(format!(
"{url}v1/json/orders/{ord_id}/refunds?api_key={api_key}"
))
}
fn get_request_body(
&self,
req: &RefundsRouterData<Execute>,
_connectors: &Connectors,
) -> CustomResult<RequestContent, errors::ConnectorError> {
let amount = convert_amount(
self.amount_converter,
req.request.minor_refund_amount,
req.request.currency,
)?;
let connector_router_data = multisafepay::MultisafepayRouterData::from((amount, req));
let connector_req =
multisafepay::MultisafepayRefundRequest::try_from(&connector_router_data)?;
Ok(RequestContent::Json(Box::new(connector_req)))
}
fn build_request(
&self,
req: &RefundsRouterData<Execute>,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
let request = RequestBuilder::new()
.method(Method::Post)
.url(&types::RefundExecuteType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(types::RefundExecuteType::get_headers(
self, req, connectors,
)?)
.set_body(types::RefundExecuteType::get_request_body(
self, req, connectors,
)?)
.build();
Ok(Some(request))
}
fn handle_response(
&self,
data: &RefundsRouterData<Execute>,
event_builder: Option<&mut ConnectorEvent>,
res: Response,
) -> CustomResult<RefundsRouterData<Execute>, errors::ConnectorError> {
let response: multisafepay::MultisafepayRefundResponse = res
.response
.parse_struct("multisafepay RefundResponse")
.change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
event_builder.map(|i| i.set_response_body(&response));
router_env::logger::info!(connector_response=?response);
RouterData::try_from(ResponseRouterData {
response,
data: data.clone(),
http_code: res.status_code,
})
.change_context(errors::ConnectorError::ResponseDeserializationFailed)
}
fn get_error_response(
&self,
res: Response,
event_builder: Option<&mut ConnectorEvent>,
) -> CustomResult<ErrorResponse, errors::ConnectorError> {
self.build_error_response(res, event_builder)
}
}
impl ConnectorIntegration<RSync, RefundsData, RefundsResponseData> for Multisafepay {
fn get_headers(
&self,
req: &RefundSyncRouterData,
connectors: &Connectors,
) -> CustomResult<Vec<(String, masking::Maskable<String>)>, errors::ConnectorError> {
self.build_headers(req, connectors)
}
fn get_content_type(&self) -> &'static str {
self.common_get_content_type()
}
fn get_url(
&self,
req: &RefundSyncRouterData,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
let url = self.base_url(connectors);
let api_key = multisafepay::MultisafepayAuthType::try_from(&req.connector_auth_type)
.change_context(errors::ConnectorError::FailedToObtainAuthType)?
.api_key
.expose();
let ord_id = req.connector_request_reference_id.clone();
Ok(format!(
"{url}v1/json/orders/{ord_id}/refunds?api_key={api_key}"
))
}
fn build_request(
&self,
req: &RefundSyncRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Ok(Some(
RequestBuilder::new()
.method(Method::Get)
.url(&types::RefundSyncType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(types::RefundSyncType::get_headers(self, req, connectors)?)
.build(),
))
}
fn handle_response(
&self,
data: &RefundSyncRouterData,
event_builder: Option<&mut ConnectorEvent>,
res: Response,
) -> CustomResult<RefundSyncRouterData, errors::ConnectorError> {
let response: multisafepay::MultisafepayRefundResponse = res
.response
.parse_struct("multisafepay RefundResponse")
.change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
event_builder.map(|i| i.set_response_body(&response));
router_env::logger::info!(connector_response=?response);
RouterData::try_from(ResponseRouterData {
response,
data: data.clone(),
http_code: res.status_code,
})
.change_context(errors::ConnectorError::ResponseDeserializationFailed)
}
fn get_error_response(
&self,
res: Response,
event_builder: Option<&mut ConnectorEvent>,
) -> CustomResult<ErrorResponse, errors::ConnectorError> {
self.build_error_response(res, event_builder)
}
}
#[async_trait::async_trait]
impl IncomingWebhook for Multisafepay {
fn get_webhook_object_reference_id(
&self,
_request: &IncomingWebhookRequestDetails<'_>,
) -> CustomResult<api_models::webhooks::ObjectReferenceId, errors::ConnectorError> {
Err(report!(errors::ConnectorError::WebhooksNotImplemented))
}
fn get_webhook_event_type(
&self,
_request: &IncomingWebhookRequestDetails<'_>,
) -> CustomResult<IncomingWebhookEvent, errors::ConnectorError> {
Ok(IncomingWebhookEvent::EventNotSupported)
}
fn get_webhook_resource_object(
&self,
_request: &IncomingWebhookRequestDetails<'_>,
) -> CustomResult<Box<dyn masking::ErasedMaskSerialize>, errors::ConnectorError> {
Err(report!(errors::ConnectorError::WebhooksNotImplemented))
}
}
static MULTISAFEPAY_SUPPORTED_PAYMENT_METHODS: LazyLock<SupportedPaymentMethods> =
LazyLock::new(|| {
let supported_capture_methods = vec![
enums::CaptureMethod::Automatic,
enums::CaptureMethod::SequentialAutomatic,
];
let supported_card_network = vec![
common_enums::CardNetwork::AmericanExpress,
common_enums::CardNetwork::CartesBancaires,
common_enums::CardNetwork::Maestro,
common_enums::CardNetwork::Mastercard,
common_enums::CardNetwork::Visa,
];
let mut multisafepay_supported_payment_methods = SupportedPaymentMethods::new();
multisafepay_supported_payment_methods.add(
enums::PaymentMethod::Card,
enums::PaymentMethodType::Credit,
PaymentMethodDetails {
mandates: enums::FeatureStatus::Supported,
refunds: enums::FeatureStatus::Supported,
supported_capture_methods: supported_capture_methods.clone(),
specific_features: Some(
api_models::feature_matrix::PaymentMethodSpecificFeatures::Card({
api_models::feature_matrix::CardSpecificFeatures {
three_ds: common_enums::FeatureStatus::Supported,
no_three_ds: common_enums::FeatureStatus::NotSupported,
supported_card_networks: supported_card_network.clone(),
}
}),
),
},
);
multisafepay_supported_payment_methods.add(
enums::PaymentMethod::Card,
enums::PaymentMethodType::Debit,
PaymentMethodDetails {
mandates: enums::FeatureStatus::Supported,
refunds: enums::FeatureStatus::Supported,
supported_capture_methods: supported_capture_methods.clone(),
specific_features: Some(
api_models::feature_matrix::PaymentMethodSpecificFeatures::Card({
api_models::feature_matrix::CardSpecificFeatures {
three_ds: common_enums::FeatureStatus::Supported,
no_three_ds: common_enums::FeatureStatus::NotSupported,
supported_card_networks: supported_card_network.clone(),
}
}),
),
},
);
multisafepay_supported_payment_methods.add(
enums::PaymentMethod::Wallet,
enums::PaymentMethodType::GooglePay,
PaymentMethodDetails {
mandates: enums::FeatureStatus::Supported,
refunds: enums::FeatureStatus::Supported,
supported_capture_methods: supported_capture_methods.clone(),
specific_features: None,
},
);
multisafepay_supported_payment_methods.add(
enums::PaymentMethod::Wallet,
enums::PaymentMethodType::Paypal,
PaymentMethodDetails {
mandates: enums::FeatureStatus::NotSupported,
refunds: enums::FeatureStatus::Supported,
supported_capture_methods: supported_capture_methods.clone(),
specific_features: None,
},
);
multisafepay_supported_payment_methods.add(
enums::PaymentMethod::Wallet,
enums::PaymentMethodType::AliPay,
PaymentMethodDetails {
mandates: enums::FeatureStatus::NotSupported,
refunds: enums::FeatureStatus::Supported,
supported_capture_methods: supported_capture_methods.clone(),
specific_features: None,
},
);
multisafepay_supported_payment_methods.add(
enums::PaymentMethod::Wallet,
enums::PaymentMethodType::WeChatPay,
PaymentMethodDetails {
mandates: enums::FeatureStatus::NotSupported,
refunds: enums::FeatureStatus::Supported,
supported_capture_methods: supported_capture_methods.clone(),
specific_features: None,
},
);
multisafepay_supported_payment_methods.add(
enums::PaymentMethod::BankRedirect,
enums::PaymentMethodType::Giropay,
PaymentMethodDetails {
mandates: enums::FeatureStatus::NotSupported,
refunds: enums::FeatureStatus::Supported,
supported_capture_methods: supported_capture_methods.clone(),
specific_features: None,
},
);
multisafepay_supported_payment_methods.add(
enums::PaymentMethod::BankRedirect,
enums::PaymentMethodType::Trustly,
PaymentMethodDetails {
mandates: enums::FeatureStatus::NotSupported,
refunds: enums::FeatureStatus::Supported,
supported_capture_methods: supported_capture_methods.clone(),
specific_features: None,
},
);
multisafepay_supported_payment_methods.add(
enums::PaymentMethod::BankRedirect,
enums::PaymentMethodType::Ideal,
PaymentMethodDetails {
mandates: enums::FeatureStatus::NotSupported,
refunds: enums::FeatureStatus::Supported,
supported_capture_methods: supported_capture_methods.clone(),
specific_features: None,
},
);
multisafepay_supported_payment_methods.add(
enums::PaymentMethod::PayLater,
enums::PaymentMethodType::Klarna,
PaymentMethodDetails {
mandates: enums::FeatureStatus::NotSupported,
refunds: enums::FeatureStatus::Supported,
supported_capture_methods: supported_capture_methods.clone(),
specific_features: None,
},
);
multisafepay_supported_payment_methods.add(
enums::PaymentMethod::BankRedirect,
enums::PaymentMethodType::Eps,
PaymentMethodDetails {
mandates: enums::FeatureStatus::NotSupported,
refunds: enums::FeatureStatus::Supported,
supported_capture_methods: supported_capture_methods.clone(),
specific_features: None,
},
);
multisafepay_supported_payment_methods.add(
enums::PaymentMethod::BankRedirect,
enums::PaymentMethodType::Sofort,
PaymentMethodDetails {
mandates: enums::FeatureStatus::NotSupported,
refunds: enums::FeatureStatus::Supported,
supported_capture_methods: supported_capture_methods.clone(),
specific_features: None,
},
);
multisafepay_supported_payment_methods.add(
enums::PaymentMethod::Wallet,
enums::PaymentMethodType::MbWay,
PaymentMethodDetails {
mandates: enums::FeatureStatus::NotSupported,
refunds: enums::FeatureStatus::Supported,
supported_capture_methods: supported_capture_methods.clone(),
specific_features: None,
},
);
multisafepay_supported_payment_methods
});
static MULTISAFEPAY_CONNECTOR_INFO: ConnectorInfo = ConnectorInfo {
display_name: "Multisafepay",
description: "MultiSafePay is a payment gateway and PSP enabling secure online transactions",
connector_type: enums::HyperswitchConnectorCategory::PaymentGateway,
integration_status: enums::ConnectorIntegrationStatus::Sandbox,
};
static MULTISAFEPAY_SUPPORTED_WEBHOOK_FLOWS: [enums::EventClass; 0] = [];
impl ConnectorSpecifications for Multisafepay {
fn get_connector_about(&self) -> Option<&'static ConnectorInfo> {
Some(&MULTISAFEPAY_CONNECTOR_INFO)
}
fn get_supported_payment_methods(&self) -> Option<&'static SupportedPaymentMethods> {
Some(&*MULTISAFEPAY_SUPPORTED_PAYMENT_METHODS)
}
fn get_supported_webhook_flows(&self) -> Option<&'static [enums::EventClass]> {
Some(&MULTISAFEPAY_SUPPORTED_WEBHOOK_FLOWS)
}
}
|
crates/hyperswitch_connectors/src/connectors/multisafepay.rs
|
hyperswitch_connectors
|
full_file
| null | null | null | 5,813
| null | null | null | null | null | null | null |
// Implementation: impl Elavon
// File: crates/hyperswitch_connectors/src/connectors/elavon.rs
// Module: hyperswitch_connectors
// Methods: 1 total (1 public)
impl Elavon
|
crates/hyperswitch_connectors/src/connectors/elavon.rs
|
hyperswitch_connectors
|
impl_block
| null | null | null | 48
| null |
Elavon
| null | 1
| 1
| null | null |
// Function: delete_tokenized_data_api
// File: crates/openapi/src/routes/tokenization.rs
// Module: openapi
pub fn delete_tokenized_data_api()
|
crates/openapi/src/routes/tokenization.rs
|
openapi
|
function_signature
| null | null | null | 35
|
delete_tokenized_data_api
| null | null | null | null | null | null |
// Struct: DisputeUpdateInternal
// File: crates/diesel_models/src/dispute.rs
// Module: diesel_models
// Implementations: 0
pub struct DisputeUpdateInternal
|
crates/diesel_models/src/dispute.rs
|
diesel_models
|
struct_definition
|
DisputeUpdateInternal
| 0
|
[] | 39
| null | null | null | null | null | null | null |
// Function: get_transaction_type
// File: crates/api_models/src/admin.rs
// Module: api_models
pub fn get_transaction_type(&self) -> api_enums::TransactionType
|
crates/api_models/src/admin.rs
|
api_models
|
function_signature
| null | null | null | 38
|
get_transaction_type
| null | null | null | null | null | null |
// Implementation: impl Responder
// File: crates/router/src/analytics.rs
// Module: router
// Methods: 0 total (0 public)
impl Responder
|
crates/router/src/analytics.rs
|
router
|
impl_block
| null | null | null | 35
| null |
Responder
| null | 0
| 0
| null | null |
// Implementation: impl api::Payment for for Worldline
// File: crates/hyperswitch_connectors/src/connectors/worldline.rs
// Module: hyperswitch_connectors
// Methods: 0 total (0 public)
impl api::Payment for for Worldline
|
crates/hyperswitch_connectors/src/connectors/worldline.rs
|
hyperswitch_connectors
|
impl_block
| null | null | null | 55
| null |
Worldline
|
api::Payment for
| 0
| 0
| null | null |
// Struct: ThreeDSMethodDataForm
// File: crates/hyperswitch_connectors/src/connectors/netcetera/transformers.rs
// Module: hyperswitch_connectors
// Implementations: 0
pub struct ThreeDSMethodDataForm
|
crates/hyperswitch_connectors/src/connectors/netcetera/transformers.rs
|
hyperswitch_connectors
|
struct_definition
|
ThreeDSMethodDataForm
| 0
|
[] | 53
| null | null | null | null | null | null | null |
// Implementation: impl api::PaymentToken for for Flexiti
// File: crates/hyperswitch_connectors/src/connectors/flexiti.rs
// Module: hyperswitch_connectors
// Methods: 0 total (0 public)
impl api::PaymentToken for for Flexiti
|
crates/hyperswitch_connectors/src/connectors/flexiti.rs
|
hyperswitch_connectors
|
impl_block
| null | null | null | 58
| null |
Flexiti
|
api::PaymentToken for
| 0
| 0
| null | null |
// Struct: BluecodeRouterData
// File: crates/hyperswitch_connectors/src/connectors/bluecode/transformers.rs
// Module: hyperswitch_connectors
// Implementations: 0
pub struct BluecodeRouterData<T>
|
crates/hyperswitch_connectors/src/connectors/bluecode/transformers.rs
|
hyperswitch_connectors
|
struct_definition
|
BluecodeRouterData
| 0
|
[] | 51
| null | null | null | null | null | null | null |
// Function: retrieve_forex
// File: crates/router/src/routes/currency.rs
// Module: router
pub fn retrieve_forex(state: web::Data<AppState>, req: HttpRequest) -> HttpResponse
|
crates/router/src/routes/currency.rs
|
router
|
function_signature
| null | null | null | 42
|
retrieve_forex
| null | null | null | null | null | null |
// Function: customers_create
// File: crates/openapi/src/routes/customers.rs
// Module: openapi
pub fn customers_create()
|
crates/openapi/src/routes/customers.rs
|
openapi
|
function_signature
| null | null | null | 29
|
customers_create
| null | null | null | null | null | null |
// Implementation: impl ConnectorAuthTypeAndMetadataValidation
// File: crates/router/src/core/connector_validation.rs
// Module: router
// Methods: 2 total (1 public)
impl ConnectorAuthTypeAndMetadataValidation
|
crates/router/src/core/connector_validation.rs
|
router
|
impl_block
| null | null | null | 45
| null |
ConnectorAuthTypeAndMetadataValidation
| null | 2
| 1
| null | null |
// Struct: VgsAuthType
// File: crates/hyperswitch_connectors/src/connectors/vgs/transformers.rs
// Module: hyperswitch_connectors
// Implementations: 0
pub struct VgsAuthType
|
crates/hyperswitch_connectors/src/connectors/vgs/transformers.rs
|
hyperswitch_connectors
|
struct_definition
|
VgsAuthType
| 0
|
[] | 49
| null | null | null | null | null | null | null |
// Implementation: impl BlocklistFingerprint
// File: crates/diesel_models/src/query/blocklist_fingerprint.rs
// Module: diesel_models
// Methods: 1 total (0 public)
impl BlocklistFingerprint
|
crates/diesel_models/src/query/blocklist_fingerprint.rs
|
diesel_models
|
impl_block
| null | null | null | 45
| null |
BlocklistFingerprint
| null | 1
| 0
| null | null |
// Function: build_generic_link_html
// File: crates/router/src/services/api/generic_link_response.rs
// Module: router
pub fn build_generic_link_html(
boxed_generic_link_data: GenericLinksData,
locale: String,
) -> CustomResult<String, errors::ApiErrorResponse>
|
crates/router/src/services/api/generic_link_response.rs
|
router
|
function_signature
| null | null | null | 60
|
build_generic_link_html
| null | null | null | null | null | null |
// Struct: RSyncNodeData
// File: crates/hyperswitch_connectors/src/connectors/braintree/transformers.rs
// Module: hyperswitch_connectors
// Implementations: 0
pub struct RSyncNodeData
|
crates/hyperswitch_connectors/src/connectors/braintree/transformers.rs
|
hyperswitch_connectors
|
struct_definition
|
RSyncNodeData
| 0
|
[] | 50
| null | null | null | null | null | null | null |
// Struct: MandateSource
// File: crates/hyperswitch_connectors/src/connectors/checkout/transformers.rs
// Module: hyperswitch_connectors
// Implementations: 0
pub struct MandateSource
|
crates/hyperswitch_connectors/src/connectors/checkout/transformers.rs
|
hyperswitch_connectors
|
struct_definition
|
MandateSource
| 0
|
[] | 47
| null | null | null | null | null | null | null |
// Function: validate
// File: crates/external_services/src/file_storage/aws_s3.rs
// Module: external_services
// Documentation: Validates the AWS S3 file storage configuration.
pub fn validate(&self) -> Result<(), InvalidFileStorageConfig>
|
crates/external_services/src/file_storage/aws_s3.rs
|
external_services
|
function_signature
| null | null | null | 52
|
validate
| null | null | null | null | null | null |
// Struct: Status
// File: crates/hyperswitch_connectors/src/connectors/rapyd/transformers.rs
// Module: hyperswitch_connectors
// Implementations: 0
pub struct Status
|
crates/hyperswitch_connectors/src/connectors/rapyd/transformers.rs
|
hyperswitch_connectors
|
struct_definition
|
Status
| 0
|
[] | 44
| null | null | null | null | null | null | null |
// Struct: InviteMultipleUserResponse
// File: crates/api_models/src/user.rs
// Module: api_models
// Implementations: 0
pub struct InviteMultipleUserResponse
|
crates/api_models/src/user.rs
|
api_models
|
struct_definition
|
InviteMultipleUserResponse
| 0
|
[] | 37
| null | null | null | null | null | null | null |
// Function: update
// File: crates/diesel_models/src/query/merchant_connector_account.rs
// Module: diesel_models
pub fn update(
self,
conn: &PgPooledConn,
merchant_connector_account: MerchantConnectorAccountUpdateInternal,
) -> StorageResult<Self>
|
crates/diesel_models/src/query/merchant_connector_account.rs
|
diesel_models
|
function_signature
| null | null | null | 60
|
update
| null | null | null | null | null | null |
// Implementation: impl api::Payment for for Forte
// File: crates/hyperswitch_connectors/src/connectors/forte.rs
// Module: hyperswitch_connectors
// Methods: 0 total (0 public)
impl api::Payment for for Forte
|
crates/hyperswitch_connectors/src/connectors/forte.rs
|
hyperswitch_connectors
|
impl_block
| null | null | null | 56
| null |
Forte
|
api::Payment for
| 0
| 0
| null | null |
// Struct: ListCountriesCurrenciesResponse
// File: crates/api_models/src/payment_methods.rs
// Module: api_models
// Implementations: 0
pub struct ListCountriesCurrenciesResponse
|
crates/api_models/src/payment_methods.rs
|
api_models
|
struct_definition
|
ListCountriesCurrenciesResponse
| 0
|
[] | 40
| null | null | null | null | null | null | null |
// Struct: RefundResponse
// File: crates/hyperswitch_connectors/src/connectors/checkout/transformers.rs
// Module: hyperswitch_connectors
// Implementations: 0
pub struct RefundResponse
|
crates/hyperswitch_connectors/src/connectors/checkout/transformers.rs
|
hyperswitch_connectors
|
struct_definition
|
RefundResponse
| 0
|
[] | 47
| null | null | null | null | null | null | null |
// Function: get_recon_acl
// File: crates/router/src/services/authorization/roles.rs
// Module: router
pub fn get_recon_acl(&self) -> HashMap<Resource, ReconPermissionScope>
|
crates/router/src/services/authorization/roles.rs
|
router
|
function_signature
| null | null | null | 43
|
get_recon_acl
| null | null | null | null | null | null |
// Struct: GetCardResponse
// File: crates/router/src/core/payment_methods/transformers.rs
// Module: router
// Implementations: 0
pub struct GetCardResponse
|
crates/router/src/core/payment_methods/transformers.rs
|
router
|
struct_definition
|
GetCardResponse
| 0
|
[] | 38
| null | null | null | null | null | null | null |
// Struct: PaypalCaptureResponse
// File: crates/hyperswitch_connectors/src/connectors/paypal/transformers.rs
// Module: hyperswitch_connectors
// Implementations: 0
pub struct PaypalCaptureResponse
|
crates/hyperswitch_connectors/src/connectors/paypal/transformers.rs
|
hyperswitch_connectors
|
struct_definition
|
PaypalCaptureResponse
| 0
|
[] | 47
| null | null | null | null | null | null | null |
// Function: construct_dsl_and_perform_eligibility_analysis
// File: crates/router/src/core/routing.rs
// Module: router
pub fn construct_dsl_and_perform_eligibility_analysis<F, D>(
self,
state: &SessionState,
key_store: &domain::MerchantKeyStore,
payment_data: &D,
profile_id: &common_utils::id_type::ProfileId,
) -> RouterResult<Vec<api::ConnectorData>>
where
F: Send + Clone,
D: OperationSessionGetters<F>,
|
crates/router/src/core/routing.rs
|
router
|
function_signature
| null | null | null | 119
|
construct_dsl_and_perform_eligibility_analysis
| null | null | null | null | null | null |
// File: crates/analytics/src/sdk_events/metrics/sdk_rendered_count.rs
// Module: analytics
use std::collections::HashSet;
use api_models::analytics::{
sdk_events::{
SdkEventDimensions, SdkEventFilters, SdkEventMetricsBucketIdentifier, SdkEventNames,
},
Granularity, TimeRange,
};
use common_utils::errors::ReportSwitchExt;
use error_stack::ResultExt;
use time::PrimitiveDateTime;
use super::SdkEventMetricRow;
use crate::{
query::{Aggregate, GroupByClause, QueryBuilder, QueryFilter, ToSql, Window},
types::{AnalyticsCollection, AnalyticsDataSource, MetricsError, MetricsResult},
};
#[derive(Default)]
pub(super) struct SdkRenderedCount;
#[async_trait::async_trait]
impl<T> super::SdkEventMetric<T> for SdkRenderedCount
where
T: AnalyticsDataSource + super::SdkEventMetricAnalytics,
PrimitiveDateTime: ToSql<T>,
AnalyticsCollection: ToSql<T>,
Granularity: GroupByClause<T>,
Aggregate<&'static str>: ToSql<T>,
Window<&'static str>: ToSql<T>,
{
async fn load_metrics(
&self,
dimensions: &[SdkEventDimensions],
publishable_key: &str,
filters: &SdkEventFilters,
granularity: Option<Granularity>,
time_range: &TimeRange,
pool: &T,
) -> MetricsResult<HashSet<(SdkEventMetricsBucketIdentifier, SdkEventMetricRow)>> {
let mut query_builder: QueryBuilder<T> =
QueryBuilder::new(AnalyticsCollection::SdkEventsAnalytics);
let dimensions = dimensions.to_vec();
for dim in dimensions.iter() {
query_builder.add_select_column(dim).switch()?;
}
query_builder
.add_select_column(Aggregate::Count {
field: None,
alias: Some("count"),
})
.switch()?;
if let Some(granularity) = granularity {
query_builder
.add_granularity_in_mins(granularity)
.switch()?;
}
filters.set_filter_clause(&mut query_builder).switch()?;
query_builder
.add_filter_clause("merchant_id", publishable_key)
.switch()?;
query_builder
.add_bool_filter_clause("first_event", 1)
.switch()?;
query_builder
.add_filter_clause("event_name", SdkEventNames::AppRendered)
.switch()?;
time_range
.set_filter_clause(&mut query_builder)
.attach_printable("Error filtering time range")
.switch()?;
for dim in dimensions.iter() {
query_builder
.add_group_by_clause(dim)
.attach_printable("Error grouping by dimensions")
.switch()?;
}
if let Some(_granularity) = granularity.as_ref() {
query_builder
.add_group_by_clause("time_bucket")
.attach_printable("Error adding granularity")
.switch()?;
}
query_builder
.execute_query::<SdkEventMetricRow, _>(pool)
.await
.change_context(MetricsError::QueryBuildingError)?
.change_context(MetricsError::QueryExecutionFailure)?
.into_iter()
.map(|i| {
Ok((
SdkEventMetricsBucketIdentifier::new(
i.payment_method.clone(),
i.platform.clone(),
i.browser_name.clone(),
i.source.clone(),
i.component.clone(),
i.payment_experience.clone(),
i.time_bucket.clone(),
),
i,
))
})
.collect::<error_stack::Result<
HashSet<(SdkEventMetricsBucketIdentifier, SdkEventMetricRow)>,
crate::query::PostProcessingError,
>>()
.change_context(MetricsError::PostProcessingFailure)
}
}
|
crates/analytics/src/sdk_events/metrics/sdk_rendered_count.rs
|
analytics
|
full_file
| null | null | null | 806
| null | null | null | null | null | null | null |
// File: crates/router/tests/connectors/vgs.rs
// Module: router
use masking::Secret;
use router::types::{self, domain, storage::enums};
use test_utils::connector_auth;
use crate::utils::{self, ConnectorActions};
#[derive(Clone, Copy)]
struct VgsTest;
impl ConnectorActions for VgsTest {}
impl utils::Connector for VgsTest {
fn get_data(&self) -> types::api::ConnectorData {
use router::connector::Vgs;
utils::construct_connector_data_old(
Box::new(&Vgs),
types::Connector::Vgs,
types::api::GetToken::Connector,
None,
)
}
fn get_auth_token(&self) -> types::ConnectorAuthType {
utils::to_connector_auth_type(
connector_auth::ConnectorAuthentication::new()
.vgs
.expect("Missing connector authentication configuration")
.into(),
)
}
fn get_name(&self) -> String {
"vgs".to_string()
}
}
static CONNECTOR: VgsTest = VgsTest {};
fn get_default_payment_info() -> Option<utils::PaymentInfo> {
None
}
fn payment_method_details() -> Option<types::PaymentsAuthorizeData> {
None
}
// Cards Positive Tests
// Creates a payment using the manual capture flow (Non 3DS).
#[actix_web::test]
async fn should_only_authorize_payment() {
let response = CONNECTOR
.authorize_payment(payment_method_details(), get_default_payment_info())
.await
.expect("Authorize payment response");
assert_eq!(response.status, enums::AttemptStatus::Authorized);
}
// Captures a payment using the manual capture flow (Non 3DS).
#[actix_web::test]
async fn should_capture_authorized_payment() {
let response = CONNECTOR
.authorize_and_capture_payment(payment_method_details(), None, get_default_payment_info())
.await
.expect("Capture payment response");
assert_eq!(response.status, enums::AttemptStatus::Charged);
}
// Partially captures a payment using the manual capture flow (Non 3DS).
#[actix_web::test]
async fn should_partially_capture_authorized_payment() {
let response = CONNECTOR
.authorize_and_capture_payment(
payment_method_details(),
Some(types::PaymentsCaptureData {
amount_to_capture: 50,
..utils::PaymentCaptureType::default().0
}),
get_default_payment_info(),
)
.await
.expect("Capture payment response");
assert_eq!(response.status, enums::AttemptStatus::Charged);
}
// Synchronizes a payment using the manual capture flow (Non 3DS).
#[actix_web::test]
async fn should_sync_authorized_payment() {
let authorize_response = CONNECTOR
.authorize_payment(payment_method_details(), get_default_payment_info())
.await
.expect("Authorize payment response");
let txn_id = utils::get_connector_transaction_id(authorize_response.response);
let response = CONNECTOR
.psync_retry_till_status_matches(
enums::AttemptStatus::Authorized,
Some(types::PaymentsSyncData {
connector_transaction_id: types::ResponseId::ConnectorTransactionId(
txn_id.unwrap(),
),
..Default::default()
}),
get_default_payment_info(),
)
.await
.expect("PSync response");
assert_eq!(response.status, enums::AttemptStatus::Authorized,);
}
// Voids a payment using the manual capture flow (Non 3DS).
#[actix_web::test]
async fn should_void_authorized_payment() {
let response = CONNECTOR
.authorize_and_void_payment(
payment_method_details(),
Some(types::PaymentsCancelData {
connector_transaction_id: String::from(""),
cancellation_reason: Some("requested_by_customer".to_string()),
..Default::default()
}),
get_default_payment_info(),
)
.await
.expect("Void payment response");
assert_eq!(response.status, enums::AttemptStatus::Voided);
}
// Refunds a payment using the manual capture flow (Non 3DS).
#[actix_web::test]
async fn should_refund_manually_captured_payment() {
let response = CONNECTOR
.capture_payment_and_refund(
payment_method_details(),
None,
None,
get_default_payment_info(),
)
.await
.unwrap();
assert_eq!(
response.response.unwrap().refund_status,
enums::RefundStatus::Success,
);
}
// Partially refunds a payment using the manual capture flow (Non 3DS).
#[actix_web::test]
async fn should_partially_refund_manually_captured_payment() {
let response = CONNECTOR
.capture_payment_and_refund(
payment_method_details(),
None,
Some(types::RefundsData {
refund_amount: 50,
..utils::PaymentRefundType::default().0
}),
get_default_payment_info(),
)
.await
.unwrap();
assert_eq!(
response.response.unwrap().refund_status,
enums::RefundStatus::Success,
);
}
// Synchronizes a refund using the manual capture flow (Non 3DS).
#[actix_web::test]
async fn should_sync_manually_captured_refund() {
let refund_response = CONNECTOR
.capture_payment_and_refund(
payment_method_details(),
None,
None,
get_default_payment_info(),
)
.await
.unwrap();
let response = CONNECTOR
.rsync_retry_till_status_matches(
enums::RefundStatus::Success,
refund_response.response.unwrap().connector_refund_id,
None,
get_default_payment_info(),
)
.await
.unwrap();
assert_eq!(
response.response.unwrap().refund_status,
enums::RefundStatus::Success,
);
}
// Creates a payment using the automatic capture flow (Non 3DS).
#[actix_web::test]
async fn should_make_payment() {
let authorize_response = CONNECTOR
.make_payment(payment_method_details(), get_default_payment_info())
.await
.unwrap();
assert_eq!(authorize_response.status, enums::AttemptStatus::Charged);
}
// Synchronizes a payment using the automatic capture flow (Non 3DS).
#[actix_web::test]
async fn should_sync_auto_captured_payment() {
let authorize_response = CONNECTOR
.make_payment(payment_method_details(), get_default_payment_info())
.await
.unwrap();
assert_eq!(authorize_response.status, enums::AttemptStatus::Charged);
let txn_id = utils::get_connector_transaction_id(authorize_response.response);
assert_ne!(txn_id, None, "Empty connector transaction id");
let response = CONNECTOR
.psync_retry_till_status_matches(
enums::AttemptStatus::Charged,
Some(types::PaymentsSyncData {
connector_transaction_id: types::ResponseId::ConnectorTransactionId(
txn_id.unwrap(),
),
capture_method: Some(enums::CaptureMethod::Automatic),
..Default::default()
}),
get_default_payment_info(),
)
.await
.unwrap();
assert_eq!(response.status, enums::AttemptStatus::Charged,);
}
// Refunds a payment using the automatic capture flow (Non 3DS).
#[actix_web::test]
async fn should_refund_auto_captured_payment() {
let response = CONNECTOR
.make_payment_and_refund(payment_method_details(), None, get_default_payment_info())
.await
.unwrap();
assert_eq!(
response.response.unwrap().refund_status,
enums::RefundStatus::Success,
);
}
// Partially refunds a payment using the automatic capture flow (Non 3DS).
#[actix_web::test]
async fn should_partially_refund_succeeded_payment() {
let refund_response = CONNECTOR
.make_payment_and_refund(
payment_method_details(),
Some(types::RefundsData {
refund_amount: 50,
..utils::PaymentRefundType::default().0
}),
get_default_payment_info(),
)
.await
.unwrap();
assert_eq!(
refund_response.response.unwrap().refund_status,
enums::RefundStatus::Success,
);
}
// Creates multiple refunds against a payment using the automatic capture flow (Non 3DS).
#[actix_web::test]
async fn should_refund_succeeded_payment_multiple_times() {
CONNECTOR
.make_payment_and_multiple_refund(
payment_method_details(),
Some(types::RefundsData {
refund_amount: 50,
..utils::PaymentRefundType::default().0
}),
get_default_payment_info(),
)
.await;
}
// Synchronizes a refund using the automatic capture flow (Non 3DS).
#[actix_web::test]
async fn should_sync_refund() {
let refund_response = CONNECTOR
.make_payment_and_refund(payment_method_details(), None, get_default_payment_info())
.await
.unwrap();
let response = CONNECTOR
.rsync_retry_till_status_matches(
enums::RefundStatus::Success,
refund_response.response.unwrap().connector_refund_id,
None,
get_default_payment_info(),
)
.await
.unwrap();
assert_eq!(
response.response.unwrap().refund_status,
enums::RefundStatus::Success,
);
}
// Cards Negative scenarios
// Creates a payment with incorrect CVC.
#[actix_web::test]
async fn should_fail_payment_for_incorrect_cvc() {
let response = CONNECTOR
.make_payment(
Some(types::PaymentsAuthorizeData {
payment_method_data: domain::PaymentMethodData::Card(domain::Card {
card_cvc: Secret::new("12345".to_string()),
..utils::CCardType::default().0
}),
..utils::PaymentAuthorizeType::default().0
}),
get_default_payment_info(),
)
.await
.unwrap();
assert_eq!(
response.response.unwrap_err().message,
"Your card's security code is invalid.".to_string(),
);
}
// Creates a payment with incorrect expiry month.
#[actix_web::test]
async fn should_fail_payment_for_invalid_exp_month() {
let response = CONNECTOR
.make_payment(
Some(types::PaymentsAuthorizeData {
payment_method_data: domain::PaymentMethodData::Card(domain::Card {
card_exp_month: Secret::new("20".to_string()),
..utils::CCardType::default().0
}),
..utils::PaymentAuthorizeType::default().0
}),
get_default_payment_info(),
)
.await
.unwrap();
assert_eq!(
response.response.unwrap_err().message,
"Your card's expiration month is invalid.".to_string(),
);
}
// Creates a payment with incorrect expiry year.
#[actix_web::test]
async fn should_fail_payment_for_incorrect_expiry_year() {
let response = CONNECTOR
.make_payment(
Some(types::PaymentsAuthorizeData {
payment_method_data: domain::PaymentMethodData::Card(domain::Card {
card_exp_year: Secret::new("2000".to_string()),
..utils::CCardType::default().0
}),
..utils::PaymentAuthorizeType::default().0
}),
get_default_payment_info(),
)
.await
.unwrap();
assert_eq!(
response.response.unwrap_err().message,
"Your card's expiration year is invalid.".to_string(),
);
}
// Voids a payment using automatic capture flow (Non 3DS).
#[actix_web::test]
async fn should_fail_void_payment_for_auto_capture() {
let authorize_response = CONNECTOR
.make_payment(payment_method_details(), get_default_payment_info())
.await
.unwrap();
assert_eq!(authorize_response.status, enums::AttemptStatus::Charged);
let txn_id = utils::get_connector_transaction_id(authorize_response.response);
assert_ne!(txn_id, None, "Empty connector transaction id");
let void_response = CONNECTOR
.void_payment(txn_id.unwrap(), None, get_default_payment_info())
.await
.unwrap();
assert_eq!(
void_response.response.unwrap_err().message,
"You cannot cancel this PaymentIntent because it has a status of succeeded."
);
}
// Captures a payment using invalid connector payment id.
#[actix_web::test]
async fn should_fail_capture_for_invalid_payment() {
let capture_response = CONNECTOR
.capture_payment("123456789".to_string(), None, get_default_payment_info())
.await
.unwrap();
assert_eq!(
capture_response.response.unwrap_err().message,
String::from("No such payment_intent: '123456789'")
);
}
// Refunds a payment with refund amount higher than payment amount.
#[actix_web::test]
async fn should_fail_for_refund_amount_higher_than_payment_amount() {
let response = CONNECTOR
.make_payment_and_refund(
payment_method_details(),
Some(types::RefundsData {
refund_amount: 150,
..utils::PaymentRefundType::default().0
}),
get_default_payment_info(),
)
.await
.unwrap();
assert_eq!(
response.response.unwrap_err().message,
"Refund amount (₹1.50) is greater than charge amount (₹1.00)",
);
}
// Connector dependent test cases goes here
// [#478]: add unit tests for non 3DS, wallets & webhooks in connector tests
|
crates/router/tests/connectors/vgs.rs
|
router
|
full_file
| null | null | null | 2,929
| null | null | null | null | null | null | null |
// Implementation: impl api::ConnectorAccessToken for for Elavon
// File: crates/hyperswitch_connectors/src/connectors/elavon.rs
// Module: hyperswitch_connectors
// Methods: 0 total (0 public)
impl api::ConnectorAccessToken for for Elavon
|
crates/hyperswitch_connectors/src/connectors/elavon.rs
|
hyperswitch_connectors
|
impl_block
| null | null | null | 60
| null |
Elavon
|
api::ConnectorAccessToken for
| 0
| 0
| null | null |
// Function: create_task
// File: crates/scheduler/src/consumer.rs
// Module: scheduler
pub fn create_task(
db: &dyn ProcessTrackerInterface,
process_tracker_entry: storage::ProcessTrackerNew,
) -> CustomResult<(), storage_impl::errors::StorageError>
|
crates/scheduler/src/consumer.rs
|
scheduler
|
function_signature
| null | null | null | 60
|
create_task
| null | null | null | null | null | null |
// Struct: DwollaCustomerRequest
// File: crates/hyperswitch_connectors/src/connectors/dwolla/transformers.rs
// Module: hyperswitch_connectors
// Implementations: 0
pub struct DwollaCustomerRequest
|
crates/hyperswitch_connectors/src/connectors/dwolla/transformers.rs
|
hyperswitch_connectors
|
struct_definition
|
DwollaCustomerRequest
| 0
|
[] | 50
| null | null | null | null | null | null | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.