text stringlengths 70 351k | source stringclasses 4
values |
|---|---|
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_interfaces/src/webhooks.rs | crate: hyperswitch_interfaces
use common_utils::{crypto, errors::CustomResult, ext_traits::ValueExt};
use hyperswitch_domain_models::{
api::ApplicationResponse, errors::api_error_response::ApiErrorResponse,
};
use crate::{api::ConnectorCommon, errors};
/// get revenue recovery transaction details
fn get_revenue_recovery_invoice_details(
&self,
_request: &IncomingWebhookRequestDetails<'_>,
) -> CustomResult<
hyperswitch_domain_models::revenue_recovery::RevenueRecoveryInvoiceData,
errors::ConnectorError,
> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_interfaces/src/webhooks.rs | crate: hyperswitch_interfaces
use common_utils::{crypto, errors::CustomResult, ext_traits::ValueExt};
use hyperswitch_domain_models::{
api::ApplicationResponse, errors::api_error_response::ApiErrorResponse,
};
use masking::{ExposeInterface, Secret};
use crate::{api::ConnectorCommon, errors};
/// fn verify_webhook_source
async fn verify_webhook_source(
&self,
request: &IncomingWebhookRequestDetails<'_>,
merchant_id: &common_utils::id_type::MerchantId,
connector_webhook_details: Option<common_utils::pii::SecretSerdeValue>,
_connector_account_details: crypto::Encryptable<Secret<serde_json::Value>>,
connector_name: &str,
) -> CustomResult<bool, errors::ConnectorError> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
// file: hyperswitch/crates/hyperswitch_interfaces/src/webhooks.rs | crate: hyperswitch_interfaces
use common_utils::{crypto, errors::CustomResult, ext_traits::ValueExt};
use hyperswitch_domain_models::{
api::ApplicationResponse, errors::api_error_response::ApiErrorResponse,
};
use crate::{api::ConnectorCommon, errors};
/// get revenue recovery transaction details
fn get_revenue_recovery_invoice_details(
&self,
_request: &IncomingWebhookRequestDetails<'_>,
) -> CustomResult<
hyperswitch_domain_models::revenue_recovery::RevenueRecoveryInvoiceData,
errors::ConnectorError,
> {
Err(errors::ConnectorError::NotImplemented(
"get_revenue_recovery_invoice_details method".to_string(),
)
.into())
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_interfaces/src/webhooks.rs | crate: hyperswitch_interfaces
use common_utils::{crypto, errors::CustomResult, ext_traits::ValueExt};
use hyperswitch_domain_models::{
api::ApplicationResponse, errors::api_error_response::ApiErrorResponse,
};
use crate::{api::ConnectorCommon, errors};
/// get revenue recovery invoice details
fn get_revenue_recovery_attempt_details(
&self,
_request: &IncomingWebhookRequestDetails<'_>,
) -> CustomResult<
hyperswitch_domain_models::revenue_recovery::RevenueRecoveryAttemptData,
errors::ConnectorError,
> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_interfaces/src/webhooks.rs | crate: hyperswitch_interfaces
use common_utils::{crypto, errors::CustomResult, ext_traits::ValueExt};
use hyperswitch_domain_models::{
api::ApplicationResponse, errors::api_error_response::ApiErrorResponse,
};
use crate::{api::ConnectorCommon, errors};
/// fn get_network_txn_id
fn get_network_txn_id(
&self,
_request: &IncomingWebhookRequestDetails<'_>,
) -> CustomResult<
Option<hyperswitch_domain_models::router_flow_types::ConnectorNetworkTxnId>,
errors::ConnectorError,
> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_interfaces/src/webhooks.rs | crate: hyperswitch_interfaces
use common_utils::{crypto, errors::CustomResult, ext_traits::ValueExt};
use hyperswitch_domain_models::{
api::ApplicationResponse, errors::api_error_response::ApiErrorResponse,
};
use crate::{api::ConnectorCommon, errors};
/// fn get_mandate_details
fn get_mandate_details(
&self,
_request: &IncomingWebhookRequestDetails<'_>,
) -> CustomResult<
Option<hyperswitch_domain_models::router_flow_types::ConnectorMandateDetails>,
errors::ConnectorError,
> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_interfaces/src/webhooks.rs | crate: hyperswitch_interfaces
use common_utils::{crypto, errors::CustomResult, ext_traits::ValueExt};
use hyperswitch_domain_models::{
api::ApplicationResponse, errors::api_error_response::ApiErrorResponse,
};
use crate::{api::ConnectorCommon, errors};
/// fn get_external_authentication_details
fn get_external_authentication_details(
&self,
_request: &IncomingWebhookRequestDetails<'_>,
) -> CustomResult<crate::authentication::ExternalAuthenticationPayload, errors::ConnectorError>
{
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_interfaces/src/webhooks.rs | crate: hyperswitch_interfaces
use common_utils::{crypto, errors::CustomResult, ext_traits::ValueExt};
use hyperswitch_domain_models::{
api::ApplicationResponse, errors::api_error_response::ApiErrorResponse,
};
use crate::{api::ConnectorCommon, errors};
/// fn get_dispute_details
fn get_dispute_details(
&self,
_request: &IncomingWebhookRequestDetails<'_>,
) -> CustomResult<crate::disputes::DisputePayload, errors::ConnectorError> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_interfaces/src/webhooks.rs | crate: hyperswitch_interfaces
use common_utils::{crypto, errors::CustomResult, ext_traits::ValueExt};
use hyperswitch_domain_models::{
api::ApplicationResponse, errors::api_error_response::ApiErrorResponse,
};
use crate::{api::ConnectorCommon, errors};
/// fn get_webhook_api_response
fn get_webhook_api_response(
&self,
_request: &IncomingWebhookRequestDetails<'_>,
_error_kind: Option<IncomingWebhookFlowError>,
) -> CustomResult<ApplicationResponse<serde_json::Value>, errors::ConnectorError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_interfaces/src/webhooks.rs | crate: hyperswitch_interfaces
use common_utils::{crypto, errors::CustomResult, ext_traits::ValueExt};
use hyperswitch_domain_models::{
api::ApplicationResponse, errors::api_error_response::ApiErrorResponse,
};
use crate::{api::ConnectorCommon, errors};
/// fn get_webhook_source_verification_message
fn get_webhook_source_verification_message(
&self,
_request: &IncomingWebhookRequestDetails<'_>,
_merchant_id: &common_utils::id_type::MerchantId,
_connector_webhook_secrets: &api_models::webhooks::ConnectorWebhookSecrets,
) -> CustomResult<Vec<u8>, errors::ConnectorError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_interfaces/src/webhooks.rs | crate: hyperswitch_interfaces
use common_utils::{crypto, errors::CustomResult, ext_traits::ValueExt};
use hyperswitch_domain_models::{
api::ApplicationResponse, errors::api_error_response::ApiErrorResponse,
};
use crate::{api::ConnectorCommon, errors};
/// fn get_webhook_source_verification_signature
fn get_webhook_source_verification_signature(
&self,
_request: &IncomingWebhookRequestDetails<'_>,
_connector_webhook_secrets: &api_models::webhooks::ConnectorWebhookSecrets,
) -> CustomResult<Vec<u8>, errors::ConnectorError> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_interfaces/src/webhooks.rs | crate: hyperswitch_interfaces
use common_utils::{crypto, errors::CustomResult, ext_traits::ValueExt};
use hyperswitch_domain_models::{
api::ApplicationResponse, errors::api_error_response::ApiErrorResponse,
};
use crate::{api::ConnectorCommon, errors};
/// fn get_webhook_source_verification_algorithm
fn get_webhook_source_verification_algorithm(
&self,
_request: &IncomingWebhookRequestDetails<'_>,
) -> CustomResult<Box<dyn crypto::VerifySignature + Send>, errors::ConnectorError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_interfaces/src/webhooks.rs | crate: hyperswitch_interfaces
use common_utils::{crypto, errors::CustomResult, ext_traits::ValueExt};
use hyperswitch_domain_models::{
api::ApplicationResponse, errors::api_error_response::ApiErrorResponse,
};
use crate::{api::ConnectorCommon, errors};
/// fn decode_webhook_body
async fn decode_webhook_body(
&self,
request: &IncomingWebhookRequestDetails<'_>,
merchant_id: &common_utils::id_type::MerchantId,
connector_webhook_details: Option<common_utils::pii::SecretSerdeValue>,
connector_name: &str,
) -> CustomResult<Vec<u8>, errors::ConnectorError> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_interfaces/src/webhooks.rs | crate: hyperswitch_interfaces
use common_utils::{crypto, errors::CustomResult, ext_traits::ValueExt};
use hyperswitch_domain_models::{
api::ApplicationResponse, errors::api_error_response::ApiErrorResponse,
};
use crate::{api::ConnectorCommon, errors};
/// fn get_webhook_body_decoding_message
fn get_webhook_body_decoding_message(
&self,
request: &IncomingWebhookRequestDetails<'_>,
) -> CustomResult<Vec<u8>, errors::ConnectorError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
// file: hyperswitch/crates/hyperswitch_interfaces/src/webhooks.rs | crate: hyperswitch_interfaces
use common_utils::{crypto, errors::CustomResult, ext_traits::ValueExt};
use hyperswitch_domain_models::{
api::ApplicationResponse, errors::api_error_response::ApiErrorResponse,
};
use crate::{api::ConnectorCommon, errors};
/// fn get_webhook_body_decoding_algorithm
fn get_webhook_body_decoding_algorithm(
&self,
_request: &IncomingWebhookRequestDetails<'_>,
) -> CustomResult<Box<dyn crypto::DecodeMessage + Send>, errors::ConnectorError> {
Ok(Box::new(crypto::NoAlgorithm))
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_interfaces/src/webhooks.rs | crate: hyperswitch_interfaces
use hyperswitch_domain_models::{
api::ApplicationResponse, errors::api_error_response::ApiErrorResponse,
};
fn from(api_error_response: &ApiErrorResponse) -> Self {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_interfaces/src/errors.rs | crate: hyperswitch_interfaces
/// fn is_connector_timeout
pub fn is_connector_timeout(&self) -> bool {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_interfaces/src/errors.rs | crate: hyperswitch_interfaces
use hyperswitch_domain_models::errors::api_error_response::ApiErrorResponse;
fn switch(&self) -> ApiErrorResponse {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_interfaces/src/errors.rs | crate: hyperswitch_interfaces
fn switch(&self) -> ConnectorError {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
// file: hyperswitch/crates/hyperswitch_interfaces/src/errors.rs | crate: hyperswitch_interfaces
/// fn is_connector_timeout
pub fn is_connector_timeout(&self) -> bool {
self == &Self::RequestTimeoutReceived
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_interfaces/src/connector_integration_v2.rs | crate: hyperswitch_interfaces
use common_utils::{
errors::CustomResult,
request::{Method, Request, RequestBuilder, RequestContent},
};
use hyperswitch_domain_models::{router_data::ErrorResponse, router_data_v2::RouterDataV2};
use serde_json::json;
use crate::{
api::{self, CaptureSyncMethod},
errors,
events::connector_api_logs::ConnectorEvent,
metrics, types, webhooks,
};
/// accepts the raw 5xx error response and decodes it
fn get_5xx_error_response(
&self,
res: types::Response,
event_builder: Option<&mut ConnectorEvent>,
) -> CustomResult<ErrorResponse, errors::ConnectorError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_interfaces/src/connector_integration_v2.rs | crate: hyperswitch_interfaces
use common_utils::{
errors::CustomResult,
request::{Method, Request, RequestBuilder, RequestContent},
};
use hyperswitch_domain_models::{router_data::ErrorResponse, router_data_v2::RouterDataV2};
use masking::Maskable;
use crate::{
api::{self, CaptureSyncMethod},
errors,
events::connector_api_logs::ConnectorEvent,
metrics, types, webhooks,
};
pub type BoxedConnectorIntegrationV2<'a, Flow, ResourceCommonData, Req, Resp> =
Box<&'a (dyn ConnectorIntegrationV2<Flow, ResourceCommonData, Req, Resp> + Send + Sync)>;
/// returns certificate string
fn get_certificate(
&self,
_req: &RouterDataV2<Flow, ResourceCommonData, Req, Resp>,
) -> CustomResult<Option<masking::Secret<String>>, errors::ConnectorError> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_interfaces/src/connector_integration_v2.rs | crate: hyperswitch_interfaces
use common_utils::{
errors::CustomResult,
request::{Method, Request, RequestBuilder, RequestContent},
};
use hyperswitch_domain_models::{router_data::ErrorResponse, router_data_v2::RouterDataV2};
use serde_json::json;
use crate::{
api::{self, CaptureSyncMethod},
errors,
events::connector_api_logs::ConnectorEvent,
metrics, types, webhooks,
};
/// accepts the raw 5xx error response and decodes it
fn get_5xx_error_response(
&self,
res: types::Response,
event_builder: Option<&mut ConnectorEvent>,
) -> CustomResult<ErrorResponse, errors::ConnectorError> {
{
500 => "internal_server_error",<|fim_suffix|>
<|fim_middle|>
_ => "unknown_error",
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_interfaces/src/connector_integration_v2.rs | crate: hyperswitch_interfaces
use common_utils::{
errors::CustomResult,
request::{Method, Request, RequestBuilder, RequestContent},
};
use hyperswitch_domain_models::{router_data::ErrorResponse, router_data_v2::RouterDataV2};
use masking::Maskable;
use crate::{
api::{self, CaptureSyncMethod},
errors,
events::connector_api_logs::ConnectorEvent,
metrics, types, webhooks,
};
pub type BoxedConnectorIntegrationV2<'a, Flow, ResourceCommonData, Req, Resp> =
Box<&'a (dyn ConnectorIntegrationV2<Flow, ResourceCommonData, Req, Resp> + Send + Sync)>;
/// returns private key string
fn get_certificate_key(
&self,
_req: &RouterDataV2<Flow, ResourceCommonData, Req, Resp>,
) -> CustomResult<Option<masking::Secret<String>>, errors::ConnectorError> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
// file: hyperswitch/crates/hyperswitch_interfaces/src/connector_integration_v2.rs | crate: hyperswitch_interfaces
use common_utils::{
errors::CustomResult,
request::{Method, Request, RequestBuilder, RequestContent},
};
use hyperswitch_domain_models::{router_data::ErrorResponse, router_data_v2::RouterDataV2};
use masking::Maskable;
use crate::{
api::{self, CaptureSyncMethod},
errors,
events::connector_api_logs::ConnectorEvent,
metrics, types, webhooks,
};
pub type BoxedConnectorIntegrationV2<'a, Flow, ResourceCommonData, Req, Resp> =
Box<&'a (dyn ConnectorIntegrationV2<Flow, ResourceCommonData, Req, Resp> + Send + Sync)>;
/// returns certificate string
fn get_certificate(
&self,
_req: &RouterDataV2<Flow, ResourceCommonData, Req, Resp>,
) -> CustomResult<Option<masking::Secret<String>>, errors::ConnectorError> {
Ok(None)
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_interfaces/src/connector_integration_v2.rs | crate: hyperswitch_interfaces
use common_utils::{
errors::CustomResult,
request::{Method, Request, RequestBuilder, RequestContent},
};
use crate::{
api::{self, CaptureSyncMethod},
errors,
events::connector_api_logs::ConnectorEvent,
metrics, types, webhooks,
};
/// retunes the capture sync method
fn get_multiple_capture_sync_method(
&self,
) -> CustomResult<CaptureSyncMethod, errors::ConnectorError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_interfaces/src/connector_integration_v2.rs | crate: hyperswitch_interfaces
use common_utils::{
errors::CustomResult,
request::{Method, Request, RequestBuilder, RequestContent},
};
use hyperswitch_domain_models::{router_data::ErrorResponse, router_data_v2::RouterDataV2};
use serde_json::json;
use crate::{
api::{self, CaptureSyncMethod},
errors,
events::connector_api_logs::ConnectorEvent,
metrics, types, webhooks,
};
/// accepts the raw api error response and decodes it
fn get_error_response_v2(
&self,
res: types::Response,
event_builder: Option<&mut ConnectorEvent>,
) -> CustomResult<ErrorResponse, errors::ConnectorError> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_interfaces/src/connector_integration_v2.rs | crate: hyperswitch_interfaces
use common_utils::{
errors::CustomResult,
request::{Method, Request, RequestBuilder, RequestContent},
};
use hyperswitch_domain_models::{router_data::ErrorResponse, router_data_v2::RouterDataV2};
use serde_json::json;
use crate::{
api::{self, CaptureSyncMethod},
errors,
events::connector_api_logs::ConnectorEvent,
metrics, types, webhooks,
};
pub type BoxedConnectorIntegrationV2<'a, Flow, ResourceCommonData, Req, Resp> =
Box<&'a (dyn ConnectorIntegrationV2<Flow, ResourceCommonData, Req, Resp> + Send + Sync)>;
/// accepts the raw api response and decodes it
fn handle_response_v2(
&self,
data: &RouterDataV2<Flow, ResourceCommonData, Req, Resp>,
event_builder: Option<&mut ConnectorEvent>,
_res: types::Response,
) -> CustomResult<RouterDataV2<Flow, ResourceCommonData, Req, Resp>, errors::ConnectorError>
where
Flow: Clone,
ResourceCommonData: Clone,
Req: Clone,
Resp: Clone,
{
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
// file: hyperswitch/crates/hyperswitch_interfaces/src/connector_integration_v2.rs | crate: hyperswitch_interfaces
use common_utils::{
errors::CustomResult,
request::{Method, Request, RequestBuilder, RequestContent},
};
use hyperswitch_domain_models::{router_data::ErrorResponse, router_data_v2::RouterDataV2};
use crate::{
api::{self, CaptureSyncMethod},
errors,
events::connector_api_logs::ConnectorEvent,
metrics, types, webhooks,
};
pub type BoxedConnectorIntegrationV2<'a, Flow, ResourceCommonData, Req, Resp> =
Box<&'a (dyn ConnectorIntegrationV2<Flow, ResourceCommonData, Req, Resp> + Send + Sync)>;
/// builds the request and returns it
fn build_request_v2(
&self,
req: &RouterDataV2<Flow, ResourceCommonData, Req, Resp>,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Ok(Some(
RequestBuilder::new()
.method(self.get_http_method())
.url(self.get_url(req)?.as_str())
.attach_default_headers()
.headers(self.get_headers(req)?)
.set_optional_body(self.get_request_body(req)?)
.add_certificate(self.get_certificate(req)?)
.add_certificate_key(self.get_certificate_key(req)?)
.build(),
))
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_interfaces/src/connector_integration_v2.rs | crate: hyperswitch_interfaces
use common_utils::{
errors::CustomResult,
request::{Method, Request, RequestBuilder, RequestContent},
};
use hyperswitch_domain_models::{router_data::ErrorResponse, router_data_v2::RouterDataV2};
use crate::{
api::{self, CaptureSyncMethod},
errors,
events::connector_api_logs::ConnectorEvent,
metrics, types, webhooks,
};
pub type BoxedConnectorIntegrationV2<'a, Flow, ResourceCommonData, Req, Resp> =
Box<&'a (dyn ConnectorIntegrationV2<Flow, ResourceCommonData, Req, Resp> + Send + Sync)>;
/// returns form data
fn get_request_form_data(
&self,
_req: &RouterDataV2<Flow, ResourceCommonData, Req, Resp>,
) -> CustomResult<Option<reqwest::multipart::Form>, errors::ConnectorError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_interfaces/src/connector_integration_v2.rs | crate: hyperswitch_interfaces
use common_utils::{
errors::CustomResult,
request::{Method, Request, RequestBuilder, RequestContent},
};
use hyperswitch_domain_models::{router_data::ErrorResponse, router_data_v2::RouterDataV2};
use crate::{
api::{self, CaptureSyncMethod},
errors,
events::connector_api_logs::ConnectorEvent,
metrics, types, webhooks,
};
pub type BoxedConnectorIntegrationV2<'a, Flow, ResourceCommonData, Req, Resp> =
Box<&'a (dyn ConnectorIntegrationV2<Flow, ResourceCommonData, Req, Resp> + Send + Sync)>;
/// returns request body
fn get_request_body(
&self,
_req: &RouterDataV2<Flow, ResourceCommonData, Req, Resp>,
) -> CustomResult<Option<RequestContent>, errors::ConnectorError> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_interfaces/src/connector_integration_v2.rs | crate: hyperswitch_interfaces
use common_utils::{
errors::CustomResult,
request::{Method, Request, RequestBuilder, RequestContent},
};
use hyperswitch_domain_models::{router_data::ErrorResponse, router_data_v2::RouterDataV2};
use crate::{
api::{self, CaptureSyncMethod},
errors,
events::connector_api_logs::ConnectorEvent,
metrics, types, webhooks,
};
pub type BoxedConnectorIntegrationV2<'a, Flow, ResourceCommonData, Req, Resp> =
Box<&'a (dyn ConnectorIntegrationV2<Flow, ResourceCommonData, Req, Resp> + Send + Sync)>;
/// returns url
fn get_url(
&self,
_req: &RouterDataV2<Flow, ResourceCommonData, Req, Resp>,
) -> CustomResult<String, errors::ConnectorError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_interfaces/src/connector_integration_v2.rs | crate: hyperswitch_interfaces
use common_utils::{
errors::CustomResult,
request::{Method, Request, RequestBuilder, RequestContent},
};
use crate::{
api::{self, CaptureSyncMethod},
errors,
events::connector_api_logs::ConnectorEvent,
metrics, types, webhooks,
};
/// primarily used when creating signature based on request method of payment flow
fn get_http_method(&self) -> Method {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_interfaces/src/connector_integration_v2.rs | crate: hyperswitch_interfaces
use crate::{
api::{self, CaptureSyncMethod},
errors,
events::connector_api_logs::ConnectorEvent,
metrics, types, webhooks,
};
pub type BoxedConnectorV2 = Box<&'static (dyn ConnectorV2 + Sync)>;
/// returns content type
fn get_content_type(&self) -> &'static str {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_interfaces/src/connector_integration_v2.rs | crate: hyperswitch_interfaces
use common_utils::{
errors::CustomResult,
request::{Method, Request, RequestBuilder, RequestContent},
};
use hyperswitch_domain_models::{router_data::ErrorResponse, router_data_v2::RouterDataV2};
use masking::Maskable;
use crate::{
api::{self, CaptureSyncMethod},
errors,
events::connector_api_logs::ConnectorEvent,
metrics, types, webhooks,
};
pub type BoxedConnectorIntegrationV2<'a, Flow, ResourceCommonData, Req, Resp> =
Box<&'a (dyn ConnectorIntegrationV2<Flow, ResourceCommonData, Req, Resp> + Send + Sync)>;
/// returns a vec of tuple of header key and value
fn get_headers(
&self,
_req: &RouterDataV2<Flow, ResourceCommonData, Req, Resp>,
) -> CustomResult<Vec<(String, Maskable<String>)>, errors::ConnectorError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
// file: hyperswitch/crates/hyperswitch_interfaces/src/connector_integration_v2.rs | crate: hyperswitch_interfaces
use crate::{
api::{self, CaptureSyncMethod},
errors,
events::connector_api_logs::ConnectorEvent,
metrics, types, webhooks,
};
pub type BoxedConnectorV2 = Box<&'static (dyn ConnectorV2 + Sync)>;
pub type BoxedConnectorIntegrationV2<'a, Flow, ResourceCommonData, Req, Resp> =
Box<&'a (dyn ConnectorIntegrationV2<Flow, ResourceCommonData, Req, Resp> + Send + Sync)>;
fn get_connector_integration_v2(
&self,
) -> BoxedConnectorIntegrationV2<'_, Flow, ResourceCommonData, Req, Resp> {
Box::new(self)
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_interfaces/src/api.rs | crate: hyperswitch_interfaces
use common_enums::{
enums::{CallConnectorAction, CaptureMethod, EventClass, PaymentAction, PaymentMethodType},
PaymentMethod,
};
use common_utils::{
errors::CustomResult,
request::{Method, Request, RequestContent},
};
use hyperswitch_domain_models::{
configs::Connectors,
errors::api_error_response::ApiErrorResponse,
payment_method_data::PaymentMethodData,
router_data::{AccessToken, ConnectorAuthType, ErrorResponse, RouterData},
router_data_v2::{
flow_common_types::WebhookSourceVerifyData, AccessTokenFlowData, MandateRevokeFlowData,
UasFlowData,
},
router_flow_types::{
mandate_revoke::MandateRevoke, AccessTokenAuth, Authenticate, AuthenticationConfirmation,
PostAuthenticate, PreAuthenticate, VerifyWebhookSource,
},
router_request_types::{
unified_authentication_service::{
UasAuthenticationRequestData, UasAuthenticationResponseData,
UasConfirmationRequestData, UasPostAuthenticationRequestData,
UasPreAuthenticationRequestData,
},
AccessTokenRequestData, MandateRevokeRequestData, VerifyWebhookSourceRequestData,
},
router_response_types::{
ConnectorInfo, MandateRevokeResponseData, PaymentMethodDetails, SupportedPaymentMethods,
VerifyWebhookSourceResponseData,
},
};
use crate::{
connector_integration_v2::ConnectorIntegrationV2, consts, errors,
events::connector_api_logs::ConnectorEvent, metrics, types, webhooks,
};
pub type BoxedConnector = Box<&'static (dyn Connector + Sync)>;
fn get_connector_payment_method_type_info(
supported_payment_method: &SupportedPaymentMethods,
payment_method: PaymentMethod,
payment_method_type: Option<PaymentMethodType>,
connector: &'static str,
) -> CustomResult<Option<PaymentMethodDetails>, errors::ConnectorError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_interfaces/src/api.rs | crate: hyperswitch_interfaces
ConnectorIntegrationV2<
Authenticate,
UasFlowData,
UasAuthenticationRequestData,
UasAuthenticationResponseData,
>
{
}
/// trait ConnectorValidation
pub trait ConnectorValidation: ConnectorCommon + ConnectorSpecifications {
/// Validate, the payment request against the connector supported features
fn validate_connector_against_payment_request(
&self,
capture_method: Option<CaptureMethod>,
payment_method: PaymentMethod,
pmt: Option<PaymentMethodType>,
) -> CustomResult<(), errors::ConnectorError> {
let capture_method = capture_method.unwrap_or_default();
let is_default_capture_method =
[CaptureMethod::Automatic, CaptureMethod::SequentialAutomatic]
.contains(&capture_method);
let is_feature_supported = match self.get_supported_payment_methods() {
Some(supported_payment_methods) => {
let connector_payment_method_type_info = get_connector_payment_method_type_info(
/// Validate, the payment request against the connector supported features
fn validate_connector_against_payment_request(
&self,
capture_method: Option<CaptureMethod>,
payment_method: PaymentMethod,
pmt: Option<PaymentMethodType>,
) -> CustomResult<(), errors::ConnectorError> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
// file: hyperswitch/crates/hyperswitch_interfaces/src/api.rs | crate: hyperswitch_interfaces
/// fn get_error_response
fn get_error_response(
&self,
res: types::Response,
event_builder: Option<&mut ConnectorEvent>,
) -> CustomResult<ErrorResponse, errors::ConnectorError> {
event_builder.map(|event| event.set_error(json!({"error": res.response.escape_ascii().to_string(), "status_code": res.status_code})));
Ok(ErrorResponse::get_not_implemented())
}
/// fn get_5xx_error_response
fn get_5xx_error_response(
&self,
res: types::Response,
event_builder: Option<&mut ConnectorEvent>,
) -> CustomResult<ErrorResponse, errors::ConnectorError> {
event_builder.map(|event| event.set_error(json!({"error": res.response.escape_ascii().to_string(), "status_code": res.status_code})));
let error_message = match res.status_code {
500 => "internal_server_error",
501 => "not_implemented",
502 => "bad_gateway",
503 => "service_unavailable",
504 => "gateway_timeout",
505 => "http_version_not_supported",
/// fn get_5xx_error_response
fn get_5xx_error_response(
&self,
res: types::Response,
event_builder: Option<&mut ConnectorEvent>,
) -> CustomResult<ErrorResponse, errors::ConnectorError> {
event_builder.map(|event| event.set_error(json!({"error": res.response.escape_ascii().to_string(), "status_code": res.status_code})));
let error_message = match res.status_code {
500 => "internal_server_error",
501 => "not_implemented",
502 => "bad_gateway",
503 => "service_unavailable",
504 => "gateway_timeout",
505 => "http_version_not_supported",
506 => "variant_also_negotiates",
507 => "insufficient_storage",
508 => "loop_detected",
510 => "not_extended",
511 => "network_authentication_required",
_ => "unknown_error",
};
Ok(ErrorResponse {
code: res.status_code.to_string(),
message: error_message.to_string(),
reason: String::from_utf8(res.response.to_vec()).ok(),
status_code: res.status_code,
attempt_status: None,
connector_transaction_id: None,
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
})
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_interfaces/src/api.rs | crate: hyperswitch_interfaces
message: format!("{} {}", payment_method, pmt),
connector,
}
.into()
})
})
.transpose()
}
/// ConnectorTransactionId trait
pub trait ConnectorTransactionId: ConnectorCommon + Sync {
/// fn connector_transaction_id
fn connector_transaction_id(
&self,
payment_attempt: hyperswitch_domain_models::payments::payment_attempt::PaymentAttempt,
) -> Result<Option<String>, ApiErrorResponse> {
Ok(payment_attempt
.get_connector_payment_id()
.map(ToString::to_string))
}
}
/// fn connector_transaction_id
fn connector_transaction_id(
&self,
payment_attempt: hyperswitch_domain_models::payments::payment_attempt::PaymentAttempt,
) -> Result<Option<String>, ApiErrorResponse> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_interfaces/src/api.rs | crate: hyperswitch_interfaces
if is_feature_supported {
Ok(())
} else {
Err(errors::ConnectorError::NotSupported {
message: capture_method.to_string(),
connector: self.id(),
}
.into())
}
}
/// fn validate_mandate_payment
fn validate_mandate_payment(
&self,
pm_type: Option<PaymentMethodType>,
_pm_data: PaymentMethodData,
) -> CustomResult<(), errors::ConnectorError> {
let connector = self.id();
match pm_type {
Some(pm_type) => Err(errors::ConnectorError::NotSupported {
message: format!("{} mandate payment", pm_type),
connector,
}
.into()),
None => Err(errors::ConnectorError::NotSupported {
/// fn validate_mandate_payment
fn validate_mandate_payment(
&self,
pm_type: Option<PaymentMethodType>,
_pm_data: PaymentMethodData,
) -> CustomResult<(), errors::ConnectorError> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
// file: hyperswitch/crates/hyperswitch_interfaces/src/api.rs | crate: hyperswitch_interfaces
use hyperswitch_domain_models::{
configs::Connectors,
errors::api_error_response::ApiErrorResponse,
payment_method_data::PaymentMethodData,
router_data::{AccessToken, ConnectorAuthType, ErrorResponse, RouterData},
router_data_v2::{
flow_common_types::WebhookSourceVerifyData, AccessTokenFlowData, MandateRevokeFlowData,
UasFlowData,
},
router_flow_types::{
mandate_revoke::MandateRevoke, AccessTokenAuth, Authenticate, AuthenticationConfirmation,
PostAuthenticate, PreAuthenticate, VerifyWebhookSource,
},
router_request_types::{
unified_authentication_service::{
UasAuthenticationRequestData, UasAuthenticationResponseData,
UasConfirmationRequestData, UasPostAuthenticationRequestData,
UasPreAuthenticationRequestData,
},
AccessTokenRequestData, MandateRevokeRequestData, VerifyWebhookSourceRequestData,
},
router_response_types::{
ConnectorInfo, MandateRevokeResponseData, PaymentMethodDetails, SupportedPaymentMethods,
VerifyWebhookSourceResponseData,
},
};
pub use self::fraud_check::*;
pub use self::fraud_check_v2::*;
pub use self::payouts::*;
pub use self::payouts_v2::*;
pub use self::{payments::*, refunds::*};
/// fn connector_transaction_id
fn connector_transaction_id(
&self,
payment_attempt: hyperswitch_domain_models::payments::payment_attempt::PaymentAttempt,
) -> Result<Option<String>, ApiErrorResponse> {
Ok(payment_attempt
.get_connector_payment_id()
.map(ToString::to_string))
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_interfaces/src/api.rs | crate: hyperswitch_interfaces
.map(|_| ())
}
/// fn is_webhook_source_verification_mandatory
fn is_webhook_source_verification_mandatory(&self) -> bool {
false
}
}
/// trait ConnectorRedirectResponse
pub trait ConnectorRedirectResponse {
/// fn get_flow_type
fn get_flow_type(
&self,
_query_params: &str,
_json_payload: Option<serde_json::Value>,
_action: PaymentAction,
) -> CustomResult<CallConnectorAction, errors::ConnectorError> {
Ok(CallConnectorAction::Avoid)
}
}
/// Empty trait for when payouts feature is disabled
#[cfg(not(feature = "payouts"))]
pub trait Payouts {}
/// fn get_flow_type
fn get_flow_type(
&self,
_query_params: &str,
_json_payload: Option<serde_json::Value>,
_action: PaymentAction,
) -> CustomResult<CallConnectorAction, errors::ConnectorError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_interfaces/src/api.rs | crate: hyperswitch_interfaces
pub use self::fraud_check::*;
pub use self::fraud_check_v2::*;
pub use self::payouts::*;
pub use self::payouts_v2::*;
pub use self::{payments::*, refunds::*};
/// fn is_webhook_source_verification_mandatory
fn is_webhook_source_verification_mandatory(&self) -> bool {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_interfaces/src/api.rs | crate: hyperswitch_interfaces
connector,
}
.into()),
None => Err(errors::ConnectorError::NotSupported {
message: " mandate payment".to_string(),
connector,
}
.into()),
}
}
/// fn validate_psync_reference_id
fn validate_psync_reference_id(
&self,
data: &hyperswitch_domain_models::router_request_types::PaymentsSyncData,
_is_three_ds: bool,
_status: common_enums::enums::AttemptStatus,
_connector_meta_data: Option<common_utils::pii::SecretSerdeValue>,
) -> CustomResult<(), errors::ConnectorError> {
data.connector_transaction_id
.get_connector_transaction_id()
.change_context(errors::ConnectorError::MissingConnectorTransactionID)
.map(|_| ())
}
/// fn validate_psync_reference_id
fn validate_psync_reference_id(
&self,
data: &hyperswitch_domain_models::router_request_types::PaymentsSyncData,
_is_three_ds: bool,
_status: common_enums::enums::AttemptStatus,
_connector_meta_data: Option<common_utils::pii::SecretSerdeValue>,
) -> CustomResult<(), errors::ConnectorError> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_interfaces/src/api.rs | crate: hyperswitch_interfaces
if is_feature_supported {
Ok(())
} else {
Err(errors::ConnectorError::NotSupported {
message: capture_method.to_string(),
connector: self.id(),
}
.into())
}
}
/// fn validate_mandate_payment
fn validate_mandate_payment(
&self,
pm_type: Option<PaymentMethodType>,
_pm_data: PaymentMethodData,
) -> CustomResult<(), errors::ConnectorError> {
let connector = self.id();
match pm_type {
Some(pm_type) => Err(errors::ConnectorError::NotSupported {
message: format!("{} mandate payment", pm_type),
connector,
}
.into()),
None => Err(errors::ConnectorError::NotSupported {
/// fn validate_mandate_payment
fn validate_mandate_payment(
&self,
pm_type: Option<PaymentMethodType>,
_pm_data: PaymentMethodData,
) -> CustomResult<(), errors::ConnectorError> {
{
Some(pm_type) => Err(errors::ConnectorError::NotSupported {
message: format!("{} mandate payment", pm_type),
connector,
}
.into()),<|fim_suffix|>
<|fim_middle|>
None => Err(errors::ConnectorError::NotSupported {
message: " mandate payment".to_string(),
connector,
}
.into()),
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_interfaces/src/api.rs | crate: hyperswitch_interfaces
/// About the connector
fn get_connector_about(&self) -> Option<&'static ConnectorInfo> {
None
}
}
/// Extended trait for connector common to allow functions with generic type
pub trait ConnectorCommonExt<Flow, Req, Resp>:
ConnectorCommon + ConnectorIntegration<Flow, Req, Resp>
{
/// common header builder when every request for the connector have same headers
fn build_headers(
&self,
_req: &RouterData<Flow, Req, Resp>,
_connectors: &Connectors,
) -> CustomResult<Vec<(String, Maskable<String>)>, errors::ConnectorError> {
Ok(Vec::new())
}
}
/// trait ConnectorMandateRevoke
pub trait ConnectorMandateRevoke:
ConnectorIntegration<MandateRevoke, MandateRevokeRequestData, MandateRevokeResponseData>
{
/// common header builder when every request for the connector have same headers
fn build_headers(
&self,
_req: &RouterData<Flow, Req, Resp>,
_connectors: &Connectors,
) -> CustomResult<Vec<(String, Maskable<String>)>, errors::ConnectorError> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_interfaces/src/api.rs | crate: hyperswitch_interfaces
use hyperswitch_domain_models::{
configs::Connectors,
errors::api_error_response::ApiErrorResponse,
payment_method_data::PaymentMethodData,
router_data::{AccessToken, ConnectorAuthType, ErrorResponse, RouterData},
router_data_v2::{
flow_common_types::WebhookSourceVerifyData, AccessTokenFlowData, MandateRevokeFlowData,
UasFlowData,
},
router_flow_types::{
mandate_revoke::MandateRevoke, AccessTokenAuth, Authenticate, AuthenticationConfirmation,
PostAuthenticate, PreAuthenticate, VerifyWebhookSource,
},
router_request_types::{
unified_authentication_service::{
UasAuthenticationRequestData, UasAuthenticationResponseData,
UasConfirmationRequestData, UasPostAuthenticationRequestData,
UasPreAuthenticationRequestData,
},
AccessTokenRequestData, MandateRevokeRequestData, VerifyWebhookSourceRequestData,
},
router_response_types::{
ConnectorInfo, MandateRevokeResponseData, PaymentMethodDetails, SupportedPaymentMethods,
VerifyWebhookSourceResponseData,
},
};
pub use self::fraud_check::*;
pub use self::fraud_check_v2::*;
pub use self::payouts::*;
pub use self::payouts_v2::*;
pub use self::{payments::*, refunds::*};
pub type BoxedConnector = Box<&'static (dyn Connector + Sync)>;
/// About the connector
fn get_connector_about(&self) -> Option<&'static ConnectorInfo> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_interfaces/src/api.rs | crate: hyperswitch_interfaces
use common_enums::{
enums::{CallConnectorAction, CaptureMethod, EventClass, PaymentAction, PaymentMethodType},
PaymentMethod,
};
pub use self::fraud_check::*;
pub use self::fraud_check_v2::*;
pub use self::payouts::*;
pub use self::payouts_v2::*;
pub use self::{payments::*, refunds::*};
pub type BoxedConnector = Box<&'static (dyn Connector + Sync)>;
/// Supported webhooks flows
fn get_supported_webhook_flows(&self) -> Option<&'static [EventClass]> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_interfaces/src/api.rs | crate: hyperswitch_interfaces
use hyperswitch_domain_models::{
configs::Connectors,
errors::api_error_response::ApiErrorResponse,
payment_method_data::PaymentMethodData,
router_data::{AccessToken, ConnectorAuthType, ErrorResponse, RouterData},
router_data_v2::{
flow_common_types::WebhookSourceVerifyData, AccessTokenFlowData, MandateRevokeFlowData,
UasFlowData,
},
router_flow_types::{
mandate_revoke::MandateRevoke, AccessTokenAuth, Authenticate, AuthenticationConfirmation,
PostAuthenticate, PreAuthenticate, VerifyWebhookSource,
},
router_request_types::{
unified_authentication_service::{
UasAuthenticationRequestData, UasAuthenticationResponseData,
UasConfirmationRequestData, UasPostAuthenticationRequestData,
UasPreAuthenticationRequestData,
},
AccessTokenRequestData, MandateRevokeRequestData, VerifyWebhookSourceRequestData,
},
router_response_types::{
ConnectorInfo, MandateRevokeResponseData, PaymentMethodDetails, SupportedPaymentMethods,
VerifyWebhookSourceResponseData,
},
};
pub use self::fraud_check::*;
pub use self::fraud_check_v2::*;
pub use self::payouts::*;
pub use self::payouts_v2::*;
pub use self::{payments::*, refunds::*};
pub type BoxedConnector = Box<&'static (dyn Connector + Sync)>;
/// Details related to payment method supported by the connector
fn get_supported_payment_methods(&self) -> Option<&'static SupportedPaymentMethods> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_interfaces/src/api.rs | crate: hyperswitch_interfaces
use common_utils::{
errors::CustomResult,
request::{Method, Request, RequestContent},
};
use hyperswitch_domain_models::{
configs::Connectors,
errors::api_error_response::ApiErrorResponse,
payment_method_data::PaymentMethodData,
router_data::{AccessToken, ConnectorAuthType, ErrorResponse, RouterData},
router_data_v2::{
flow_common_types::WebhookSourceVerifyData, AccessTokenFlowData, MandateRevokeFlowData,
UasFlowData,
},
router_flow_types::{
mandate_revoke::MandateRevoke, AccessTokenAuth, Authenticate, AuthenticationConfirmation,
PostAuthenticate, PreAuthenticate, VerifyWebhookSource,
},
router_request_types::{
unified_authentication_service::{
UasAuthenticationRequestData, UasAuthenticationResponseData,
UasConfirmationRequestData, UasPostAuthenticationRequestData,
UasPreAuthenticationRequestData,
},
AccessTokenRequestData, MandateRevokeRequestData, VerifyWebhookSourceRequestData,
},
router_response_types::{
ConnectorInfo, MandateRevokeResponseData, PaymentMethodDetails, SupportedPaymentMethods,
VerifyWebhookSourceResponseData,
},
};
pub use self::fraud_check::*;
pub use self::fraud_check_v2::*;
pub use self::payouts::*;
pub use self::payouts_v2::*;
pub use self::{payments::*, refunds::*};
use crate::{
connector_integration_v2::ConnectorIntegrationV2, consts, errors,
events::connector_api_logs::ConnectorEvent, metrics, types, webhooks,
};
/// common error response for a connector if it is same in all case
fn build_error_response(
&self,
res: types::Response,
_event_builder: Option<&mut ConnectorEvent>,
) -> CustomResult<ErrorResponse, errors::ConnectorError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_interfaces/src/api.rs | crate: hyperswitch_interfaces
use serde_json::json;
pub use self::fraud_check::*;
pub use self::fraud_check_v2::*;
pub use self::payouts::*;
pub use self::payouts_v2::*;
pub use self::{payments::*, refunds::*};
pub type BoxedConnector = Box<&'static (dyn Connector + Sync)>;
/// HTTP `Content-Type` to be used for POST requests.
/// Defaults to `application/json`.
fn common_get_content_type(&self) -> &'static str {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_interfaces/src/api.rs | crate: hyperswitch_interfaces
/// The trait that provides the common
pub trait ConnectorCommon {
/// Name of the connector (in lowercase).
fn id(&self) -> &'static str;
/// Connector accepted currency unit as either "Base" or "Minor"
fn get_currency_unit(&self) -> CurrencyUnit {
CurrencyUnit::Minor // Default implementation should be remove once it is implemented in all connectors
}
/// HTTP header used for authorization.
fn get_auth_header(
&self,
_auth_type: &ConnectorAuthType,
) -> CustomResult<Vec<(String, Maskable<String>)>, errors::ConnectorError> {
Ok(Vec::new())
}
/// HTTP `Content-Type` to be used for POST requests.
/// Defaults to `application/json`.
fn common_get_content_type(&self) -> &'static str {
"application/json"
}
/// HTTP header used for authorization.
fn get_auth_header(
&self,
_auth_type: &ConnectorAuthType,
) -> CustomResult<Vec<(String, Maskable<String>)>, errors::ConnectorError> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_interfaces/src/api.rs | crate: hyperswitch_interfaces
pub use self::fraud_check::*;
pub use self::fraud_check_v2::*;
pub use self::payouts::*;
pub use self::payouts_v2::*;
pub use self::{payments::*, refunds::*};
/// Connector accepted currency unit as either "Base" or "Minor"
fn get_currency_unit(&self) -> CurrencyUnit {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_interfaces/src/api.rs | crate: hyperswitch_interfaces
Err(errors::ConnectorError::NotImplemented("multiple capture sync".into()).into())
}
/// fn get_certificate
fn get_certificate(
&self,
_req: &RouterData<T, Req, Resp>,
) -> CustomResult<Option<String>, errors::ConnectorError> {
Ok(None)
}
/// fn get_certificate_key
fn get_certificate_key(
&self,
_req: &RouterData<T, Req, Resp>,
) -> CustomResult<Option<String>, errors::ConnectorError> {
Ok(None)
}
}
/// Sync Methods for multiple captures
#[derive(Debug)]
pub enum CaptureSyncMethod {
/// For syncing multiple captures individually
Individual,
/// fn get_certificate_key
fn get_certificate_key(
&self,
_req: &RouterData<T, Req, Resp>,
) -> CustomResult<Option<String>, errors::ConnectorError> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_interfaces/src/api.rs | crate: hyperswitch_interfaces
network_error_message: None,
})
}
/// whenever capture sync is implemented at the connector side, this method should be overridden
fn get_multiple_capture_sync_method(
&self,
) -> CustomResult<CaptureSyncMethod, errors::ConnectorError> {
Err(errors::ConnectorError::NotImplemented("multiple capture sync".into()).into())
}
/// fn get_certificate
fn get_certificate(
&self,
_req: &RouterData<T, Req, Resp>,
) -> CustomResult<Option<String>, errors::ConnectorError> {
Ok(None)
}
/// fn get_certificate_key
fn get_certificate_key(
&self,
_req: &RouterData<T, Req, Resp>,
) -> CustomResult<Option<String>, errors::ConnectorError> {
Ok(None)
/// fn get_certificate
fn get_certificate(
&self,
_req: &RouterData<T, Req, Resp>,
) -> CustomResult<Option<String>, errors::ConnectorError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_interfaces/src/api.rs | crate: hyperswitch_interfaces
use common_utils::{
errors::CustomResult,
request::{Method, Request, RequestContent},
};
use hyperswitch_domain_models::{
configs::Connectors,
errors::api_error_response::ApiErrorResponse,
payment_method_data::PaymentMethodData,
router_data::{AccessToken, ConnectorAuthType, ErrorResponse, RouterData},
router_data_v2::{
flow_common_types::WebhookSourceVerifyData, AccessTokenFlowData, MandateRevokeFlowData,
UasFlowData,
},
router_flow_types::{
mandate_revoke::MandateRevoke, AccessTokenAuth, Authenticate, AuthenticationConfirmation,
PostAuthenticate, PreAuthenticate, VerifyWebhookSource,
},
router_request_types::{
unified_authentication_service::{
UasAuthenticationRequestData, UasAuthenticationResponseData,
UasConfirmationRequestData, UasPostAuthenticationRequestData,
UasPreAuthenticationRequestData,
},
AccessTokenRequestData, MandateRevokeRequestData, VerifyWebhookSourceRequestData,
},
router_response_types::{
ConnectorInfo, MandateRevokeResponseData, PaymentMethodDetails, SupportedPaymentMethods,
VerifyWebhookSourceResponseData,
},
};
pub use self::fraud_check::*;
pub use self::fraud_check_v2::*;
pub use self::payouts::*;
pub use self::payouts_v2::*;
pub use self::{payments::*, refunds::*};
use crate::{
connector_integration_v2::ConnectorIntegrationV2, consts, errors,
events::connector_api_logs::ConnectorEvent, metrics, types, webhooks,
};
/// whenever capture sync is implemented at the connector side, this method should be overridden
fn get_multiple_capture_sync_method(
&self,
) -> CustomResult<CaptureSyncMethod, errors::ConnectorError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_interfaces/src/api.rs | crate: hyperswitch_interfaces
_res: types::Response,
) -> CustomResult<RouterData<T, Req, Resp>, errors::ConnectorError>
where
T: Clone,
Req: Clone,
Resp: Clone,
{
event_builder.map(|e| e.set_error(json!({"error": "Not Implemented"})));
Ok(data.clone())
}
/// fn get_error_response
fn get_error_response(
&self,
res: types::Response,
event_builder: Option<&mut ConnectorEvent>,
) -> CustomResult<ErrorResponse, errors::ConnectorError> {
event_builder.map(|event| event.set_error(json!({"error": res.response.escape_ascii().to_string(), "status_code": res.status_code})));
Ok(ErrorResponse::get_not_implemented())
}
/// fn get_5xx_error_response
fn get_5xx_error_response(
&self,
res: types::Response,
/// fn get_error_response
fn get_error_response(
&self,
res: types::Response,
event_builder: Option<&mut ConnectorEvent>,
) -> CustomResult<ErrorResponse, errors::ConnectorError> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_interfaces/src/api.rs | crate: hyperswitch_interfaces
&self,
req: &RouterData<T, Req, Resp>,
_connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
metrics::UNIMPLEMENTED_FLOW.add(
1,
router_env::metric_attributes!(("connector", req.connector.clone())),
);
Ok(None)
}
/// fn handle_response
fn handle_response(
&self,
data: &RouterData<T, Req, Resp>,
event_builder: Option<&mut ConnectorEvent>,
_res: types::Response,
) -> CustomResult<RouterData<T, Req, Resp>, errors::ConnectorError>
where
T: Clone,
Req: Clone,
Resp: Clone,
{
event_builder.map(|e| e.set_error(json!({"error": "Not Implemented"})));
Ok(data.clone())
/// fn handle_response
fn handle_response(
&self,
data: &RouterData<T, Req, Resp>,
event_builder: Option<&mut ConnectorEvent>,
_res: types::Response,
) -> CustomResult<RouterData<T, Req, Resp>, errors::ConnectorError>
where
T: Clone,
Req: Clone,
Resp: Clone,
{
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_interfaces/src/api.rs | crate: hyperswitch_interfaces
Ok(RequestContent::Json(Box::new(json!(r#"{}"#))))
}
/// fn get_request_form_data
fn get_request_form_data(
&self,
_req: &RouterData<T, Req, Resp>,
) -> CustomResult<Option<reqwest::multipart::Form>, errors::ConnectorError> {
Ok(None)
}
/// fn build_request
fn build_request(
&self,
req: &RouterData<T, Req, Resp>,
_connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
metrics::UNIMPLEMENTED_FLOW.add(
1,
router_env::metric_attributes!(("connector", req.connector.clone())),
);
Ok(None)
}
/// fn handle_response
/// fn build_request
fn build_request(
&self,
req: &RouterData<T, Req, Resp>,
_connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_interfaces/src/api.rs | crate: hyperswitch_interfaces
}
/// fn get_request_body
fn get_request_body(
&self,
_req: &RouterData<T, Req, Resp>,
_connectors: &Connectors,
) -> CustomResult<RequestContent, errors::ConnectorError> {
Ok(RequestContent::Json(Box::new(json!(r#"{}"#))))
}
/// fn get_request_form_data
fn get_request_form_data(
&self,
_req: &RouterData<T, Req, Resp>,
) -> CustomResult<Option<reqwest::multipart::Form>, errors::ConnectorError> {
Ok(None)
}
/// fn build_request
fn build_request(
&self,
req: &RouterData<T, Req, Resp>,
_connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
/// fn get_request_form_data
fn get_request_form_data(
&self,
_req: &RouterData<T, Req, Resp>,
) -> CustomResult<Option<reqwest::multipart::Form>, errors::ConnectorError> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_interfaces/src/api.rs | crate: hyperswitch_interfaces
}
/// fn get_url
fn get_url(
&self,
_req: &RouterData<T, Req, Resp>,
_connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
Ok(String::new())
}
/// fn get_request_body
fn get_request_body(
&self,
_req: &RouterData<T, Req, Resp>,
_connectors: &Connectors,
) -> CustomResult<RequestContent, errors::ConnectorError> {
Ok(RequestContent::Json(Box::new(json!(r#"{}"#))))
}
/// fn get_request_form_data
fn get_request_form_data(
&self,
_req: &RouterData<T, Req, Resp>,
) -> CustomResult<Option<reqwest::multipart::Form>, errors::ConnectorError> {
/// fn get_request_body
fn get_request_body(
&self,
_req: &RouterData<T, Req, Resp>,
_connectors: &Connectors,
) -> CustomResult<RequestContent, errors::ConnectorError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_interfaces/src/api.rs | crate: hyperswitch_interfaces
/// fn get_content_type
fn get_accept_type(&self) -> &'static str {
mime::APPLICATION_JSON.essence_str()
}
/// primarily used when creating signature based on request method of payment flow
fn get_http_method(&self) -> Method {
Method::Post
}
/// fn get_url
fn get_url(
&self,
_req: &RouterData<T, Req, Resp>,
_connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
Ok(String::new())
}
/// fn get_request_body
fn get_request_body(
&self,
_req: &RouterData<T, Req, Resp>,
_connectors: &Connectors,
/// fn get_url
fn get_url(
&self,
_req: &RouterData<T, Req, Resp>,
_connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
// file: hyperswitch/crates/hyperswitch_interfaces/src/api.rs | crate: hyperswitch_interfaces
pub use self::fraud_check::*;
pub use self::fraud_check_v2::*;
pub use self::payouts::*;
pub use self::payouts_v2::*;
pub use self::{payments::*, refunds::*};
pub type BoxedConnector = Box<&'static (dyn Connector + Sync)>;
/// fn get_content_type
fn get_accept_type(&self) -> &'static str {
mime::APPLICATION_JSON.essence_str()
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_interfaces/src/api.rs | crate: hyperswitch_interfaces
pub use self::fraud_check::*;
pub use self::fraud_check_v2::*;
pub use self::payouts::*;
pub use self::payouts_v2::*;
pub use self::{payments::*, refunds::*};
pub type BoxedConnector = Box<&'static (dyn Connector + Sync)>;
/// fn get_content_type
fn get_content_type(&self) -> &'static str {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_interfaces/src/api.rs | crate: hyperswitch_interfaces
S: ConnectorIntegration<T, Req, Resp> + Send + Sync,
{
fn get_connector_integration(&self) -> BoxedConnectorIntegration<'_, T, Req, Resp> {
Box::new(self)
}
}
/// trait ConnectorIntegration
pub trait ConnectorIntegration<T, Req, Resp>:
ConnectorIntegrationAny<T, Req, Resp> + Sync + ConnectorCommon
{
/// fn get_headers
fn get_headers(
&self,
_req: &RouterData<T, Req, Resp>,
_connectors: &Connectors,
) -> CustomResult<Vec<(String, Maskable<String>)>, errors::ConnectorError> {
Ok(vec![])
}
/// fn get_content_type
fn get_content_type(&self) -> &'static str {
mime::APPLICATION_JSON.essence_str()
}
/// fn get_headers
fn get_headers(
&self,
_req: &RouterData<T, Req, Resp>,
_connectors: &Connectors,
) -> CustomResult<Vec<(String, Maskable<String>)>, errors::ConnectorError> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_interfaces/src/events/connector_api_logs.rs | crate: hyperswitch_interfaces
use common_utils::request::Method;
use router_env::tracing_actix_web::RequestId;
use serde_json::json;
use time::OffsetDateTime;
pub fn new(
tenant_id: common_utils::id_type::TenantId,
connector_name: String,
flow: &str,
request: serde_json::Value,
url: String,
method: Method,
payment_id: String,
merchant_id: common_utils::id_type::MerchantId,
request_id: Option<&RequestId>,
latency: u128,
refund_id: Option<String>,
dispute_id: Option<String>,
status_code: u16,
) -> Self {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_interfaces/src/events/connector_api_logs.rs | crate: hyperswitch_interfaces
use serde::Serialize;
use serde_json::json;
/// fn set_error_response_body
pub fn set_error_response_body<T: Serialize>(&mut self, response: &T) {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_interfaces/src/events/connector_api_logs.rs | crate: hyperswitch_interfaces
use serde_json::json;
/// fn set_error
pub fn set_error(&mut self, error: serde_json::Value) {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
// file: hyperswitch/crates/hyperswitch_interfaces/src/events/connector_api_logs.rs | crate: hyperswitch_interfaces
use serde::Serialize;
use serde_json::json;
/// fn set_error_response_body
pub fn set_error_response_body<T: Serialize>(&mut self, response: &T) {
match masking::masked_serialize(response) {
Ok(masked) => {
self.error = Some(masked.to_string());
}
Err(er) => self.set_error(json!({"error": er.to_string()})),
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_interfaces/src/events/connector_api_logs.rs | crate: hyperswitch_interfaces
use serde::Serialize;
use serde_json::json;
/// fn set_response_body
pub fn set_response_body<T: Serialize>(&mut self, response: &T) {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
// file: hyperswitch/crates/router/tests/integration_demo.rs | crate: router
use test_utils::connector_auth::ConnectorAuthentication;
use utils::{mk_service, ApiKey, AppClient, MerchantId, PaymentId, Status};
async fn exceed_refund() {
let authentication = ConnectorAuthentication::new();
let server = Box::pin(mk_service()).await;
let client = AppClient::guest();
let admin_client = client.admin("test_admin");
let hlist_pat![merchant_id, api_key]: HList![MerchantId, ApiKey] =
admin_client.create_merchant_account(&server, None).await;
let _connector: serde_json::Value = admin_client
.create_connector(
&server,
&merchant_id,
"stripe",
authentication.checkout.unwrap().api_key.peek(),
)
.await;
let user_client = client.user(&api_key);
let hlist_pat![payment_id]: HList![PaymentId] =
user_client.create_payment(&server, 100, 100).await;
let hlist_pat![status]: HList![Status] =
user_client.create_refund(&server, &payment_id, 50).await;
assert_eq!(&*status, "pending");
let message: serde_json::Value = user_client.create_refund(&server, &payment_id, 100).await;
assert_eq!(
message.get("error").unwrap().get("message").unwrap(),
"The refund amount exceeds the amount captured."
);
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/tests/integration_demo.rs | crate: router
use test_utils::connector_auth::ConnectorAuthentication;
use utils::{mk_service, ApiKey, AppClient, MerchantId, PaymentId, Status};
async fn partial_refund() {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/tests/integration_demo.rs | crate: router
use test_utils::connector_auth::ConnectorAuthentication;
use utils::{mk_service, ApiKey, AppClient, MerchantId, PaymentId, Status};
async fn exceed_refund() {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/tests/integration_demo.rs | crate: router
use utils::{mk_service, ApiKey, AppClient, MerchantId, PaymentId, Status};
async fn create_merchant_account() {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
// file: hyperswitch/crates/router/tests/services.rs | crate: router
use std::sync::{atomic, Arc};
use router::{configs::settings::Settings, routes, services};
async fn get_redis_conn_failure() {
// Arrange
utils::setup().await;
let (tx, _) = tokio::sync::oneshot::channel();
let app_state = Box::pin(routes::AppState::new(
Settings::default(),
tx,
Box::new(services::MockApiClient),
))
.await;
let state = Arc::new(app_state)
.get_session_state(
&common_utils::id_type::TenantId::try_from_string("public".to_string()).unwrap(),
None,
|| {},
)
.unwrap();
let _ = state.store.get_redis_conn().map(|conn| {
conn.is_redis_available
.store(false, atomic::Ordering::SeqCst)
});
// Act
let _ = state.store.get_redis_conn();
// Assert
// based on #[should_panic] attribute
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/tests/services.rs | crate: router
use std::sync::{atomic, Arc};
use router::{configs::settings::Settings, routes, services};
async fn get_redis_conn_success() {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/tests/services.rs | crate: router
use std::sync::{atomic, Arc};
use router::{configs::settings::Settings, routes, services};
async fn get_redis_conn_failure() {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
// file: hyperswitch/crates/router/tests/services.rs | crate: router
use std::sync::{atomic, Arc};
use router::{configs::settings::Settings, routes, services};
async fn get_redis_conn_success() {
// Arrange
Box::pin(utils::setup()).await;
let (tx, _) = tokio::sync::oneshot::channel();
let app_state = Box::pin(routes::AppState::new(
Settings::default(),
tx,
Box::new(services::MockApiClient),
))
.await;
let state = Arc::new(app_state)
.get_session_state(
&common_utils::id_type::TenantId::try_from_string("public".to_string()).unwrap(),
None,
|| {},
)
.unwrap();
// Act
let result = state.store.get_redis_conn();
// Assert
assert!(result.is_ok())
} | ast_fragments |
// file: hyperswitch/crates/router/tests/customers.rs | crate: router
async fn customer_success() {
Box::pin(utils::setup()).await;
let customer_id = format!("customer_{}", uuid::Uuid::new_v4());
let api_key = ("API-KEY", "MySecretApiKey");
let name = "Doe";
let new_name = "new Doe";
let request = serde_json::json!({
"customer_id" : customer_id,
"name" : name,
});
let update_request = serde_json::json!({
"name" : new_name,
});
let client = awc::Client::default();
let mut response;
let mut response_body;
// create customer
response = client
.post("http://127.0.0.1:8080/customers")
.insert_header(api_key)
.send_json(&request)
.await
.unwrap();
response_body = response.body().await;
println!("customer-create: {response:?} : {response_body:?}");
assert_eq!(response.status(), awc::http::StatusCode::OK);
// retrieve customer
response = client
.get(format!("http://127.0.0.1:8080/customers/{customer_id}"))
.insert_header(api_key)
.send()
.await
.unwrap();
response_body = response.body().await;
println!("customer-retrieve: {response:?} =:= {response_body:?}");
assert_eq!(response.status(), awc::http::StatusCode::OK);
// update customer
response = client
.post(format!("http://127.0.0.1:8080/customers/{customer_id}"))
.insert_header(api_key)
.send_json(&update_request)
.await
.unwrap();
response_body = response.body().await;
println!("customer-update: {response:?} =:= {response_body:?}");
assert_eq!(response.status(), awc::http::StatusCode::OK);
// delete customer
response = client
.delete(format!("http://127.0.0.1:8080/customers/{customer_id}"))
.insert_header(api_key)
.send()
.await
.unwrap();
response_body = response.body().await;
println!("customer-delete : {response:?} =:= {response_body:?}");
assert_eq!(response.status(), awc::http::StatusCode::OK);
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/tests/customers.rs | crate: router
async fn customer_failure() {
{Box::pin(utils::setup()).await;let customer_id = format!("customer_{}", uuid::Uuid::new_v4());let api_key = ("api-key", "MySecretApiKey");<|fim_suffix|>
<|fim_middle|>
response_body = response.body().await;println!("{response:?} : {response_body:?}");assert_eq!(
response.status(),
awc::http::StatusCode::UNPROCESSABLE_ENTITY
);}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/tests/customers.rs | crate: router
async fn customer_success() {
{Box::pin(utils::setup()).await;let customer_id = format!("customer_{}", uuid::Uuid::new_v4());<|fim_suffix|>
<|fim_middle|>
println!("customer-delete : {response:?} =:= {response_body:?}");assert_eq!(response.status(), awc::http::StatusCode::OK);}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/tests/customers.rs | crate: router
async fn customer_failure() {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
// file: hyperswitch/crates/router/tests/macros.rs | crate: router
fn test_flat_struct() {
#[derive(FlatStruct, Serialize)]
struct User {
address: Address,
}
#[derive(Serialize)]
struct Address {
line1: String,
zip: String,
city: String,
}
let line1 = "1397".to_string();
let zip = "Some street".to_string();
let city = "941222".to_string();
let address = Address {
line1: line1.clone(),
zip: zip.clone(),
city: city.clone(),
};
let user = User { address };
let flat_user_map = user.flat_struct();
let mut required_map = HashMap::new();
required_map.insert("address.line1".to_string(), line1);
required_map.insert("address.zip".to_string(), zip);
required_map.insert("address.city".to_string(), city);
assert_eq!(flat_user_map, required_map);
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/tests/macros.rs | crate: router
fn test_flat_struct() {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/tests/connectors/adyen.rs | crate: router | connector: adyen | op: payout
use hyperswitch_domain_models::address::{Address, AddressDetails, PhoneDetails};
use masking::Secret;
use router::types::{self, storage::enums, PaymentAddress};
use crate::{
connector_auth,
utils::{self, ConnectorActions, PaymentInfo},
};
fn get_payout_info(payout_type: enums::PayoutType) -> Option<PaymentInfo> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/tests/connectors/adyen.rs | crate: router | connector: adyen
use hyperswitch_domain_models::address::{Address, AddressDetails, PhoneDetails};
use masking::Secret;
use router::types::{self, storage::enums, PaymentAddress};
fn get_payment_info() -> Option<PaymentInfo> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/tests/connectors/adyen.rs | crate: router | connector: adyen | op: payout
use hyperswitch_domain_models::address::{Address, AddressDetails, PhoneDetails};
use masking::Secret;
use router::types::{self, storage::enums, PaymentAddress};
use crate::{
connector_auth,
utils::{self, ConnectorActions, PaymentInfo},
};
fn get_payout_info(payout_type: enums::PayoutType) -> Option<PaymentInfo> {
{
enums::PayoutType::Card => Some(types::api::PayoutMethodData::Card(
types::api::payouts::CardPayout {
card_number: cards::CardNumber::from_str("4111111111111111").unwrap(),
expiry_month: Secret::new("3".to_string()),
expiry_year: Secret::new("2030".to_string()),
card_holder_name: Some(Secret::new("John Doe".to_string())),
},
)),<|fim_suffix|>
<|fim_middle|>
enums::PayoutType::Wallet => Some(types::api::PayoutMethodData::Wallet(
types::api::payouts::WalletPayout::Paypal(api_models::payouts::Paypal {
email: Email::from_str("EmailUsedForPayPalAccount@example.com").ok(),
telephone_number: None,
paypal_id: None,
}),
)),
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/tests/connectors/adyen.rs | crate: router | connector: adyen | op: cancel
use router::types::{self, storage::enums, PaymentAddress};
async fn should_create_and_cancel_created_payout() {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/tests/connectors/adyen.rs | crate: router | connector: adyen | op: payout
use router::types::{self, storage::enums, PaymentAddress};
async fn should_fulfill_card_payout() {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/tests/connectors/adyen.rs | crate: router | connector: adyen | op: verify
use router::types::{self, storage::enums, PaymentAddress};
async fn should_verify_payout_eligibility() {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/tests/connectors/adyen.rs | crate: router | connector: adyen | op: payout
use router::types::{self, storage::enums, PaymentAddress};
async fn should_create_and_fulfill_sepa_payout() {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/tests/connectors/adyen.rs | crate: router | connector: adyen | op: payout
use router::types::{self, storage::enums, PaymentAddress};
async fn should_create_sepa_payout() {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
// file: hyperswitch/crates/router/tests/connectors/adyen.rs | crate: router | connector: adyen | op: authorize
use router::types::{self, storage::enums, PaymentAddress};
async fn should_void_authorized_payment() {
let response = CONNECTOR
.authorize_and_void_payment(
AdyenTest::get_payment_authorize_data(
"4293189100000008",
"03",
"2030",
"737",
enums::CaptureMethod::Manual,
),
Some(types::PaymentsCancelData {
connector_transaction_id: String::from(""),
cancellation_reason: Some("requested_by_customer".to_string()),
..Default::default()
}),
AdyenTest::get_payment_info(),
)
.await
.expect("Void payment response");
assert_eq!(response.status, enums::AttemptStatus::Voided);
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/tests/connectors/adyen.rs | crate: router | connector: adyen | op: payout
use masking::Secret;
use router::types::{self, storage::enums, PaymentAddress};
use crate::{
connector_auth,
utils::{self, ConnectorActions, PaymentInfo},
};
fn get_payout_data(&self) -> Option<types::api::ConnectorData> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
// file: hyperswitch/crates/router/tests/connectors/adyen.rs | crate: router | connector: adyen
use masking::Secret;
use router::types::{self, storage::enums, PaymentAddress};
use crate::{
connector_auth,
utils::{self, ConnectorActions, PaymentInfo},
};
fn get_data(&self) -> types::api::ConnectorData {
use router::connector::Adyen;
utils::construct_connector_data_old(
Box::new(Adyen::new()),
types::Connector::Adyen,
types::api::GetToken::Connector,
None,
)
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/tests/connectors/stax.rs | crate: router | connector: stax
use masking::Secret;
use router::types::{self, domain, storage::enums, PaymentsResponseData};
async fn should_fail_payment_for_invalid_exp_month() {
{
PaymentsResponseData::ConnectorCustomerResponse {
connector_customer_id,
} => Some(connector_customer_id),<|fim_suffix|>
<|fim_middle|>
_ => None,
}
} | ast_fragments |
// file: hyperswitch/crates/router/tests/connectors/stax.rs | crate: router | connector: stax
use masking::Secret;
use router::types::{self, domain, storage::enums, PaymentsResponseData};
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 {
connector_customer_id,
} => Some(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,
}),
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()),
);
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/tests/connectors/stax.rs | crate: router | connector: stax
use masking::Secret;
use router::types::{self, domain, storage::enums, PaymentsResponseData};
async fn should_fail_payment_for_incorrect_expiry_year() {
{
PaymentsResponseData::ConnectorCustomerResponse {
connector_customer_id,
} => Some(connector_customer_id),<|fim_suffix|>
<|fim_middle|>
_ => None,
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/tests/connectors/stax.rs | crate: router | connector: stax
use router::types::{self, domain, storage::enums, PaymentsResponseData};
async fn create_customer_and_get_token() -> Option<String> {
{
PaymentsResponseData::TokenizationResponse { token } => Some(token),<|fim_suffix|>
<|fim_middle|>
_ => None,
}
} | ast_fragments |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.