text stringlengths 70 351k | source stringclasses 4
values |
|---|---|
<|fim_prefix|>
// file: hyperswitch/crates/router/src/utils/user/two_factor_auth.rs | crate: router
use common_utils::pii;
use crate::{
consts,
core::errors::{UserErrors, UserResult},
routes::SessionState,
};
pub async fn insert_totp_in_redis(state: &SessionState, user_id: &str) -> UserResult<()> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/utils/user/two_factor_auth.rs | crate: router
use crate::{
consts,
core::errors::{UserErrors, UserResult},
routes::SessionState,
};
pub async fn check_recovery_code_in_redis(state: &SessionState, user_id: &str) -> UserResult<bool> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/utils/user/two_factor_auth.rs | crate: router
use crate::{
consts,
core::errors::{UserErrors, UserResult},
routes::SessionState,
};
pub async fn check_totp_in_redis(state: &SessionState, user_id: &str) -> UserResult<bool> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/utils/user/two_factor_auth.rs | crate: router
use common_utils::pii;
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> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/utils/user/sample_data.rs | crate: router
fn get_payment_method_type(num: u8) -> common_enums::PaymentMethodType {
{
0 => common_enums::PaymentMethodType::Debit,<|fim_suffix|>
<|fim_middle|>
_ => common_enums::PaymentMethodType::Credit,
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/utils/user/sample_data.rs | crate: router
use api_models::{
enums::Connector::{DummyConnector4, DummyConnector7},
user::sample_data::SampleDataRequest,
};
use common_utils::{
id_type,
types::{ConnectorTransactionId, MinorUnit},
};
use diesel_models::user::sample_data::PaymentAttemptBatchNew;
use diesel_models::{enums as storage_enums, DisputeNew, RefundNew};
use hyperswitch_domain_models::payments::PaymentIntent;
use rand::{prelude::SliceRandom, thread_rng, Rng};
use time::OffsetDateTime;
use crate::{
consts,
core::errors::sample_data::{SampleDataError, SampleDataResult},
SessionState,
};
pub async fn generate_sample_data(
state: &SessionState,
req: SampleDataRequest,
merchant_id: &id_type::MerchantId,
org_id: &id_type::OrganizationId,
) -> SampleDataResult<
Vec<(
PaymentIntent,
PaymentAttemptBatchNew,
Option<RefundNew>,
Option<DisputeNew>,
)>,
> {
{
true => Some("This is a test payment which has a failed status".to_string()),<|fim_suffix|>
<|fim_middle|>
_ => None,
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/utils/user/sample_data.rs | crate: router
fn get_payment_method_type(num: u8) -> common_enums::PaymentMethodType {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
// file: hyperswitch/crates/router/src/utils/user/sample_data.rs | crate: router
use api_models::{
enums::Connector::{DummyConnector4, DummyConnector7},
user::sample_data::SampleDataRequest,
};
use common_utils::{
id_type,
types::{ConnectorTransactionId, MinorUnit},
};
use diesel_models::user::sample_data::PaymentAttemptBatchNew;
use diesel_models::{enums as storage_enums, DisputeNew, RefundNew};
use hyperswitch_domain_models::payments::PaymentIntent;
use rand::{prelude::SliceRandom, thread_rng, Rng};
use time::OffsetDateTime;
use crate::{
consts,
core::errors::sample_data::{SampleDataError, SampleDataResult},
SessionState,
};
pub async fn generate_sample_data(
state: &SessionState,
req: SampleDataRequest,
merchant_id: &id_type::MerchantId,
org_id: &id_type::OrganizationId,
) -> SampleDataResult<
Vec<(
PaymentIntent,
PaymentAttemptBatchNew,
Option<RefundNew>,
Option<DisputeNew>,
)>,
> {
let sample_data_size: usize = req.record.unwrap_or(100);
let key_manager_state = &state.into();
if !(10..=100).contains(&sample_data_size) {
return Err(SampleDataError::InvalidRange.into());
}
let key_store = state
.store
.get_merchant_key_store_by_merchant_id(
key_manager_state,
merchant_id,
&state.store.get_master_key().to_vec().into(),
)
.await
.change_context(SampleDataError::InternalServerError)?;
let merchant_from_db = state
.store
.find_merchant_account_by_merchant_id(key_manager_state, merchant_id, &key_store)
.await
.change_context::<SampleDataError>(SampleDataError::DataDoesNotExist)?;
#[cfg(feature = "v1")]
let (profile_id_result, business_country_default, business_label_default) = {
let merchant_parsed_details: Vec<api_models::admin::PrimaryBusinessDetails> =
serde_json::from_value(merchant_from_db.primary_business_details.clone())
.change_context(SampleDataError::InternalServerError)
.attach_printable("Error while parsing primary business details")?;
let business_country_default = merchant_parsed_details.first().map(|x| x.country);
let business_label_default = merchant_parsed_details.first().map(|x| x.business.clone());
let profile_id = crate::core::utils::get_profile_id_from_business_details(
key_manager_state,
&key_store,
business_country_default,
business_label_default.as_ref(),
&merchant_from_db,
req.profile_id.as_ref(),
&*state.store,
false,
)
.await;
(profile_id, business_country_default, business_label_default)
};
#[cfg(feature = "v2")]
let (profile_id_result, business_country_default, business_label_default) = {
let profile_id = req
.profile_id.clone()
.ok_or(hyperswitch_domain_models::errors::api_error_response::ApiErrorResponse::MissingRequiredField {
field_name: "profile_id",
});
(profile_id, None, None)
};
let profile_id = match profile_id_result {
Ok(id) => id.clone(),
Err(error) => {
router_env::logger::error!(
"Profile ID not found in business details. Attempting to fetch from the database {error:?}"
);
state
.store
.list_profile_by_merchant_id(key_manager_state, &key_store, merchant_id)
.await
.change_context(SampleDataError::InternalServerError)
.attach_printable("Failed to get business profile")?
.first()
.ok_or(SampleDataError::InternalServerError)?
.get_id()
.to_owned()
}
};
// 10 percent payments should be failed
#[allow(clippy::as_conversions)]
let failure_attempts = usize::try_from((sample_data_size as f32 / 10.0).round() as i64)
.change_context(SampleDataError::InvalidParameters)?;
let failure_after_attempts = sample_data_size / failure_attempts;
// 20 percent refunds for payments
#[allow(clippy::as_conversions)]
let number_of_refunds = usize::try_from((sample_data_size as f32 / 5.0).round() as i64)
.change_context(SampleDataError::InvalidParameters)?;
let mut refunds_count = 0;
// 2 disputes if generated data size is between 50 and 100, 1 dispute if it is less than 50.
let number_of_disputes: usize = if sample_data_size >= 50 { 2 } else { 1 };
let mut disputes_count = 0;
let mut random_array: Vec<usize> = (1..=sample_data_size).collect();
// Shuffle the array
let mut rng = thread_rng();
random_array.shuffle(&mut rng);
let mut res: Vec<(
PaymentIntent,
PaymentAttemptBatchNew,
Option<RefundNew>,
Option<DisputeNew>,
)> = Vec::new();
let start_time = req
.start_time
.unwrap_or(common_utils::date_time::now() - time::Duration::days(7))
.assume_utc()
.unix_timestamp();
let end_time = req
.end_time
.unwrap_or_else(common_utils::date_time::now)
.assume_utc()
.unix_timestamp();
let current_time = common_utils::date_time::now().assume_utc().unix_timestamp();
let min_amount = req.min_amount.unwrap_or(100);
let max_amount = req.max_amount.unwrap_or(min_amount + 100);
if min_amount > max_amount
|| start_time > end_time
|| start_time > current_time
|| end_time > current_time
{
return Err(SampleDataError::InvalidParameters.into());
};
let currency_vec = req.currency.unwrap_or(vec![common_enums::Currency::USD]);
let currency_vec_len = currency_vec.len();
let connector_vec = req
.connector
.unwrap_or(vec![DummyConnector4, DummyConnector7]);
let connector_vec_len = connector_vec.len();
let auth_type = req.auth_type.unwrap_or(vec![
common_enums::AuthenticationType::ThreeDs,
common_enums::AuthenticationType::NoThreeDs,
]);
let auth_type_len = auth_type.len();
if currency_vec_len == 0 || connector_vec_len == 0 || auth_type_len == 0 {
return Err(SampleDataError::InvalidParameters.into());
}
// This has to be an internal server error because, this function failing means that the intended functionality is not working as expected
let dashboard_customer_id =
id_type::CustomerId::try_from(std::borrow::Cow::from("hs-dashboard-user"))
.change_context(SampleDataError::InternalServerError)?;
for num in 1..=sample_data_size {
let payment_id = id_type::PaymentId::generate_test_payment_id_for_sample_data();
let attempt_id = payment_id.get_attempt_id(1);
let client_secret = payment_id.generate_client_secret();
let amount = thread_rng().gen_range(min_amount..=max_amount);
let created_at @ modified_at @ last_synced =
OffsetDateTime::from_unix_timestamp(thread_rng().gen_range(start_time..=end_time))
.map(common_utils::date_time::convert_to_pdt)
.unwrap_or(
req.start_time.unwrap_or_else(|| {
common_utils::date_time::now() - time::Duration::days(7)
}),
);
let session_expiry =
created_at.saturating_add(time::Duration::seconds(consts::DEFAULT_SESSION_EXPIRY));
// After some set of payments sample data will have a failed attempt
let is_failed_payment =
(random_array.get(num - 1).unwrap_or(&0) % failure_after_attempts) == 0;
let payment_intent = PaymentIntent {
payment_id: payment_id.clone(),
merchant_id: merchant_id.clone(),
status: match is_failed_payment {
true => common_enums::IntentStatus::Failed,
_ => common_enums::IntentStatus::Succeeded,
},
amount: MinorUnit::new(amount * 100),
currency: Some(
*currency_vec
.get((num - 1) % currency_vec_len)
.unwrap_or(&common_enums::Currency::USD),
),
description: Some("This is a sample payment".to_string()),
created_at,
modified_at,
last_synced: Some(last_synced),
client_secret: Some(client_secret),
business_country: business_country_default,
business_label: business_label_default.clone(),
active_attempt: hyperswitch_domain_models::RemoteStorageObject::ForeignID(
attempt_id.clone(),
),
attempt_count: 1,
customer_id: Some(dashboard_customer_id.clone()),
amount_captured: Some(MinorUnit::new(amount * 100)),
profile_id: Some(profile_id.clone()),
return_url: Default::default(),
metadata: Default::default(),
connector_id: Default::default(),
shipping_address_id: Default::default(),
billing_address_id: Default::default(),
statement_descriptor_name: Default::default(),
statement_descriptor_suffix: Default::default(),
setup_future_usage: Default::default(),
off_session: Default::default(),
order_details: Default::default(),
allowed_payment_method_types: Default::default(),
connector_metadata: Default::default(),
feature_metadata: Default::default(),
merchant_decision: Default::default(),
payment_link_id: Default::default(),
payment_confirm_source: Default::default(),
updated_by: merchant_from_db.storage_scheme.to_string(),
surcharge_applicable: Default::default(),
request_incremental_authorization: Default::default(),
incremental_authorization_allowed: Default::default(),
authorization_count: Default::default(),
fingerprint_id: None,
session_expiry: Some(session_expiry),
request_external_three_ds_authentication: None,
split_payments: None,
frm_metadata: Default::default(),
customer_details: None,
billing_details: None,
merchant_order_reference_id: Default::default(),
shipping_details: None,
is_payment_processor_token_flow: None,
organization_id: org_id.clone(),
shipping_cost: None,
tax_details: None,
skip_external_tax_calculation: None,
request_extended_authorization: None,
psd2_sca_exemption_type: None,
platform_merchant_id: None,
force_3ds_challenge: None,
force_3ds_challenge_trigger: None,
};
let (connector_transaction_id, processor_transaction_data) =
ConnectorTransactionId::form_id_and_data(attempt_id.clone());
let payment_attempt = PaymentAttemptBatchNew {
attempt_id: attempt_id.clone(),
payment_id: payment_id.clone(),
connector_transaction_id: Some(connector_transaction_id),
merchant_id: merchant_id.clone(),
status: match is_failed_payment {
true => common_enums::AttemptStatus::Failure,
_ => common_enums::AttemptStatus::Charged,
},
amount: MinorUnit::new(amount * 100),
currency: payment_intent.currency,
connector: Some(
(*connector_vec
.get((num - 1) % connector_vec_len)
.unwrap_or(&DummyConnector4))
.to_string(),
),
payment_method: Some(common_enums::PaymentMethod::Card),
payment_method_type: Some(get_payment_method_type(thread_rng().gen_range(1..=2))),
authentication_type: Some(
*auth_type
.get((num - 1) % auth_type_len)
.unwrap_or(&common_enums::AuthenticationType::NoThreeDs),
),
error_message: match is_failed_payment {
true => Some("This is a test payment which has a failed status".to_string()),
_ => None,
},
error_code: match is_failed_payment {
true => Some("HS001".to_string()),
_ => None,
},
confirm: true,
created_at,
modified_at,
last_synced: Some(last_synced),
amount_to_capture: Some(MinorUnit::new(amount * 100)),
connector_response_reference_id: Some(attempt_id.clone()),
updated_by: merchant_from_db.storage_scheme.to_string(),
save_to_locker: None,
offer_amount: None,
surcharge_amount: None,
tax_amount: None,
payment_method_id: None,
capture_method: None,
capture_on: None,
cancellation_reason: None,
mandate_id: None,
browser_info: None,
payment_token: None,
connector_metadata: None,
payment_experience: None,
payment_method_data: None,
business_sub_label: None,
straight_through_algorithm: None,
preprocessing_step_id: None,
mandate_details: None,
error_reason: None,
multiple_capture_count: None,
amount_capturable: MinorUnit::new(i64::default()),
merchant_connector_id: None,
authentication_data: None,
encoded_data: None,
unified_code: None,
unified_message: None,
net_amount: None,
external_three_ds_authentication_attempted: None,
authentication_connector: None,
authentication_id: None,
mandate_data: None,
payment_method_billing_address_id: None,
fingerprint_id: None,
charge_id: None,
client_source: None,
client_version: None,
customer_acceptance: None,
profile_id: profile_id.clone(),
organization_id: org_id.clone(),
shipping_cost: None,
order_tax_amount: None,
processor_transaction_data,
connector_mandate_detail: None,
request_extended_authorization: None,
extended_authorization_applied: None,
capture_before: None,
card_discovery: None,
};
let refund = if refunds_count < number_of_refunds && !is_failed_payment {
refunds_count += 1;
let (connector_transaction_id, processor_transaction_data) =
ConnectorTransactionId::form_id_and_data(attempt_id.clone());
Some(RefundNew {
refund_id: common_utils::generate_id_with_default_len("test"),
internal_reference_id: common_utils::generate_id_with_default_len("test"),
external_reference_id: None,
payment_id: payment_id.clone(),
attempt_id: attempt_id.clone(),
merchant_id: merchant_id.clone(),
connector_transaction_id,
connector_refund_id: None,
description: Some("This is a sample refund".to_string()),
created_at,
modified_at,
refund_reason: Some("Sample Refund".to_string()),
connector: payment_attempt
.connector
.clone()
.unwrap_or(DummyConnector4.to_string()),
currency: *currency_vec
.get((num - 1) % currency_vec_len)
.unwrap_or(&common_enums::Currency::USD),
total_amount: MinorUnit::new(amount * 100),
refund_amount: MinorUnit::new(amount * 100),
refund_status: common_enums::RefundStatus::Success,
sent_to_gateway: true,
refund_type: diesel_models::enums::RefundType::InstantRefund,
metadata: None,
refund_arn: None,
profile_id: payment_intent.profile_id.clone(),
updated_by: merchant_from_db.storage_scheme.to_string(),
merchant_connector_id: payment_attempt.merchant_connector_id.clone(),
charges: None,
split_refunds: None,
organization_id: org_id.clone(),
processor_refund_data: None,
processor_transaction_data,
})
} else {
None
};
let dispute =
if disputes_count < number_of_disputes && !is_failed_payment && refund.is_none() {
disputes_count += 1;
Some(DisputeNew {
dispute_id: common_utils::generate_id_with_default_len("test"),
amount: (amount * 100).to_string(),
currency: payment_intent
.currency
.unwrap_or(common_enums::Currency::USD)
.to_string(),
dispute_stage: storage_enums::DisputeStage::Dispute,
dispute_status: storage_enums::DisputeStatus::DisputeOpened,
payment_id: payment_id.clone(),
attempt_id: attempt_id.clone(),
merchant_id: merchant_id.clone(),
connector_status: "Sample connector status".into(),
connector_dispute_id: common_utils::generate_id_with_default_len("test"),
connector_reason: Some("Sample Dispute".into()),
connector_reason_code: Some("123".into()),
challenge_required_by: None,
connector_created_at: None,
connector_updated_at: None,
connector: payment_attempt
.connector
.clone()
.unwrap_or(DummyConnector4.to_string()),
evidence: None,
profile_id: payment_intent.profile_id.clone(),
merchant_connector_id: payment_attempt.merchant_connector_id.clone(),
dispute_amount: amount * 100,
organization_id: org_id.clone(),
dispute_currency: Some(payment_intent.currency.unwrap_or_default()),
})
} else {
None
};
res.push((payment_intent, payment_attempt, refund, dispute));
}
Ok(res)
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/configs/settings.rs | crate: router
use std::{
collections::{HashMap, HashSet},
path::PathBuf,
sync::Arc,
};
use analytics::{opensearch::OpenSearchConfig, ReportConfig};
use api_models::{enums, payment_methods::RequiredFieldInfo};
use common_utils::{ext_traits::ConfigExt, id_type, types::theme::EmailThemeConfig};
use config::{Environment, File};
use error_stack::ResultExt;
use external_services::email::EmailSettings;
use external_services::{
file_storage::FileStorageConfig,
grpc_client::GrpcClientSettings,
managers::{
encryption_management::EncryptionManagementConfig,
secrets_management::SecretsManagementConfig,
},
};
pub use hyperswitch_interfaces::configs::Connectors;
use hyperswitch_interfaces::secrets_interface::secret_state::{
RawSecret, SecretState, SecretStateContainer, SecuredSecret,
};
use masking::Secret;
use redis_interface::RedisSettings;
pub use router_env::config::{Log, LogConsole, LogFile, LogTelemetry};
use rust_decimal::Decimal;
use scheduler::SchedulerSettings;
use serde::Deserialize;
use storage_impl::config::QueueStrategy;
use crate::analytics::{AnalyticsConfig, AnalyticsProvider};
use crate::{
configs,
core::errors::{ApplicationError, ApplicationResult},
env::{self, Env},
events::EventsConfig,
routes::app,
AppState,
};
fn test_payment_method_and_payment_method_types_with_spaces() {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/configs/settings.rs | crate: router
use std::{
collections::{HashMap, HashSet},
path::PathBuf,
sync::Arc,
};
use analytics::{opensearch::OpenSearchConfig, ReportConfig};
use api_models::{enums, payment_methods::RequiredFieldInfo};
use common_utils::{ext_traits::ConfigExt, id_type, types::theme::EmailThemeConfig};
use config::{Environment, File};
use error_stack::ResultExt;
use external_services::email::EmailSettings;
use external_services::{
file_storage::FileStorageConfig,
grpc_client::GrpcClientSettings,
managers::{
encryption_management::EncryptionManagementConfig,
secrets_management::SecretsManagementConfig,
},
};
pub use hyperswitch_interfaces::configs::Connectors;
use hyperswitch_interfaces::secrets_interface::secret_state::{
RawSecret, SecretState, SecretStateContainer, SecuredSecret,
};
use masking::Secret;
use redis_interface::RedisSettings;
pub use router_env::config::{Log, LogConsole, LogFile, LogTelemetry};
use rust_decimal::Decimal;
use scheduler::SchedulerSettings;
use serde::Deserialize;
use storage_impl::config::QueueStrategy;
use crate::analytics::{AnalyticsConfig, AnalyticsProvider};
use crate::{
configs,
core::errors::{ApplicationError, ApplicationResult},
env::{self, Env},
events::EventsConfig,
routes::app,
AppState,
};
fn test_payment_method_and_payment_method_types() {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/configs/settings.rs | crate: router
use std::{
collections::{HashMap, HashSet},
path::PathBuf,
sync::Arc,
};
use common_utils::{ext_traits::ConfigExt, id_type, types::theme::EmailThemeConfig};
use serde::Deserialize;
fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/configs/settings.rs | crate: router
use std::{
collections::{HashMap, HashSet},
path::PathBuf,
sync::Arc,
};
use common_utils::{ext_traits::ConfigExt, id_type, types::theme::EmailThemeConfig};
use crate::{
configs,
core::errors::{ApplicationError, ApplicationResult},
env::{self, Env},
events::EventsConfig,
routes::app,
AppState,
};
fn deserialize_merchant_ids_inner(
value: impl AsRef<str>,
) -> Result<HashSet<id_type::MerchantId>, String> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/configs/settings.rs | crate: router
use std::{
collections::{HashMap, HashSet},
path::PathBuf,
sync::Arc,
};
use crate::{
configs,
core::errors::{ApplicationError, ApplicationResult},
env::{self, Env},
events::EventsConfig,
routes::app,
AppState,
};
fn deserialize_hashset_inner<T>(value: impl AsRef<str>) -> Result<HashSet<T>, String>
where
T: Eq + std::str::FromStr + std::hash::Hash,
<T as std::str::FromStr>::Err: std::fmt::Display,
{
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
// file: hyperswitch/crates/router/src/configs/settings.rs | crate: router
use std::{
collections::{HashMap, HashSet},
path::PathBuf,
sync::Arc,
};
use crate::{
configs,
core::errors::{ApplicationError, ApplicationResult},
env::{self, Env},
events::EventsConfig,
routes::app,
AppState,
};
fn deserialize_hashmap_inner<K, V>(
value: HashMap<String, String>,
) -> Result<HashMap<K, HashSet<V>>, String>
where
K: Eq + std::str::FromStr + std::hash::Hash,
V: Eq + std::str::FromStr + std::hash::Hash,
<K as std::str::FromStr>::Err: std::fmt::Display,
<V as std::str::FromStr>::Err: std::fmt::Display,
{
let (values, errors) = value
.into_iter()
.map(
|(k, v)| match (K::from_str(k.trim()), deserialize_hashset_inner(v)) {
(Err(error), _) => Err(format!(
"Unable to deserialize `{}` as `{}`: {error}",
k,
std::any::type_name::<K>()
)),
(_, Err(error)) => Err(error),
(Ok(key), Ok(value)) => Ok((key, value)),
},
)
.fold(
(HashMap::new(), Vec::new()),
|(mut values, mut errors), result| match result {
Ok((key, value)) => {
values.insert(key, value);
(values, errors)
}
Err(error) => {
errors.push(error);
(values, errors)
}
},
);
if !errors.is_empty() {
Err(format!("Some errors occurred:\n{}", errors.join("\n")))
} else {
Ok(values)
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/configs/settings.rs | crate: router
use std::{
collections::{HashMap, HashSet},
path::PathBuf,
sync::Arc,
};
use config::{Environment, File};
pub use hyperswitch_interfaces::configs::Connectors;
pub use router_env::config::{Log, LogConsole, LogFile, LogTelemetry};
use storage_impl::config::QueueStrategy;
use crate::{
configs,
core::errors::{ApplicationError, ApplicationResult},
env::{self, Env},
events::EventsConfig,
routes::app,
AppState,
};
pub fn with_config_path(config_path: Option<PathBuf>) -> ApplicationResult<Self> {
{// Configuration values are picked up in the following priority order (1 being least<|fim_suffix|>
<|fim_middle|>
serde_path_to_error::deserialize(config)
.attach_printable("Unable to deserialize application configuration")
.change_context(ApplicationError::ConfigurationError)}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/configs/settings.rs | crate: router
use std::{
collections::{HashMap, HashSet},
path::PathBuf,
sync::Arc,
};
use common_utils::{ext_traits::ConfigExt, id_type, types::theme::EmailThemeConfig};
pub use hyperswitch_interfaces::configs::Connectors;
pub use router_env::config::{Log, LogConsole, LogFile, LogTelemetry};
use storage_impl::config::QueueStrategy;
use crate::{
configs,
core::errors::{ApplicationError, ApplicationResult},
env::{self, Env},
events::EventsConfig,
routes::app,
AppState,
};
/// # Panics
///
/// Panics if Failed to create event handler
pub async fn get_accounts_store_interface_map(
&self,
storage_impl: &app::StorageImpl,
conf: &configs::Settings,
cache_store: Arc<storage_impl::redis::RedisStore>,
testable: bool,
) -> HashMap<id_type::TenantId, Box<dyn app::AccountsStorageInterface>> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/configs/settings.rs | crate: router
use std::{
collections::{HashMap, HashSet},
path::PathBuf,
sync::Arc,
};
use common_utils::{ext_traits::ConfigExt, id_type, types::theme::EmailThemeConfig};
pub use hyperswitch_interfaces::configs::Connectors;
pub use router_env::config::{Log, LogConsole, LogFile, LogTelemetry};
use storage_impl::config::QueueStrategy;
use crate::{
configs,
core::errors::{ApplicationError, ApplicationResult},
env::{self, Env},
events::EventsConfig,
routes::app,
AppState,
};
/// # Panics
///
/// Panics if Failed to create event handler
pub async fn get_store_interface_map(
&self,
storage_impl: &app::StorageImpl,
conf: &configs::Settings,
cache_store: Arc<storage_impl::redis::RedisStore>,
testable: bool,
) -> HashMap<id_type::TenantId, Box<dyn app::StorageInterface>> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/configs/settings.rs | crate: router
use std::{
collections::{HashMap, HashSet},
path::PathBuf,
sync::Arc,
};
use common_utils::{ext_traits::ConfigExt, id_type, types::theme::EmailThemeConfig};
use serde::Deserialize;
fn deserialize_merchant_ids<'de, D>(
deserializer: D,
) -> Result<HashSet<id_type::MerchantId>, D::Error>
where
D: serde::Deserializer<'de>,
{
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/configs/settings.rs | crate: router
use std::{
collections::{HashMap, HashSet},
path::PathBuf,
sync::Arc,
};
use common_utils::{ext_traits::ConfigExt, id_type, types::theme::EmailThemeConfig};
use crate::{
configs,
core::errors::{ApplicationError, ApplicationResult},
env::{self, Env},
events::EventsConfig,
routes::app,
AppState,
};
fn deserialize_merchant_ids_inner(
value: impl AsRef<str>,
) -> Result<HashSet<id_type::MerchantId>, String> {
{
Ok(t) => {
values.insert(t);
(values, errors)
}<|fim_suffix|>
<|fim_middle|>
Err(error) => {
errors.push(error);
(values, errors)
}
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/configs/settings.rs | crate: router
use std::{
collections::{HashMap, HashSet},
path::PathBuf,
sync::Arc,
};
use analytics::{opensearch::OpenSearchConfig, ReportConfig};
use api_models::{enums, payment_methods::RequiredFieldInfo};
use common_utils::{ext_traits::ConfigExt, id_type, types::theme::EmailThemeConfig};
use config::{Environment, File};
use error_stack::ResultExt;
use external_services::email::EmailSettings;
use external_services::{
file_storage::FileStorageConfig,
grpc_client::GrpcClientSettings,
managers::{
encryption_management::EncryptionManagementConfig,
secrets_management::SecretsManagementConfig,
},
};
pub use hyperswitch_interfaces::configs::Connectors;
use hyperswitch_interfaces::secrets_interface::secret_state::{
RawSecret, SecretState, SecretStateContainer, SecuredSecret,
};
use masking::Secret;
use redis_interface::RedisSettings;
pub use router_env::config::{Log, LogConsole, LogFile, LogTelemetry};
use rust_decimal::Decimal;
use scheduler::SchedulerSettings;
use serde::Deserialize;
use storage_impl::config::QueueStrategy;
use crate::analytics::{AnalyticsConfig, AnalyticsProvider};
use crate::{
configs,
core::errors::{ApplicationError, ApplicationResult},
env::{self, Env},
events::EventsConfig,
routes::app,
AppState,
};
fn test_payment_method_hashset_deserializer_error() {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/configs/settings.rs | crate: router
use std::{
collections::{HashMap, HashSet},
path::PathBuf,
sync::Arc,
};
use analytics::{opensearch::OpenSearchConfig, ReportConfig};
use api_models::{enums, payment_methods::RequiredFieldInfo};
use common_utils::{ext_traits::ConfigExt, id_type, types::theme::EmailThemeConfig};
use config::{Environment, File};
use error_stack::ResultExt;
use external_services::email::EmailSettings;
use external_services::{
file_storage::FileStorageConfig,
grpc_client::GrpcClientSettings,
managers::{
encryption_management::EncryptionManagementConfig,
secrets_management::SecretsManagementConfig,
},
};
pub use hyperswitch_interfaces::configs::Connectors;
use hyperswitch_interfaces::secrets_interface::secret_state::{
RawSecret, SecretState, SecretStateContainer, SecuredSecret,
};
use masking::Secret;
use redis_interface::RedisSettings;
pub use router_env::config::{Log, LogConsole, LogFile, LogTelemetry};
use rust_decimal::Decimal;
use scheduler::SchedulerSettings;
use serde::Deserialize;
use storage_impl::config::QueueStrategy;
use crate::analytics::{AnalyticsConfig, AnalyticsProvider};
use crate::{
configs,
core::errors::{ApplicationError, ApplicationResult},
env::{self, Env},
events::EventsConfig,
routes::app,
AppState,
};
fn test_payment_method_hashset_deserializer_with_spaces() {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/configs/settings.rs | crate: router
use std::{
collections::{HashMap, HashSet},
path::PathBuf,
sync::Arc,
};
use analytics::{opensearch::OpenSearchConfig, ReportConfig};
use api_models::{enums, payment_methods::RequiredFieldInfo};
use common_utils::{ext_traits::ConfigExt, id_type, types::theme::EmailThemeConfig};
use config::{Environment, File};
use error_stack::ResultExt;
use external_services::email::EmailSettings;
use external_services::{
file_storage::FileStorageConfig,
grpc_client::GrpcClientSettings,
managers::{
encryption_management::EncryptionManagementConfig,
secrets_management::SecretsManagementConfig,
},
};
pub use hyperswitch_interfaces::configs::Connectors;
use hyperswitch_interfaces::secrets_interface::secret_state::{
RawSecret, SecretState, SecretStateContainer, SecuredSecret,
};
use masking::Secret;
use redis_interface::RedisSettings;
pub use router_env::config::{Log, LogConsole, LogFile, LogTelemetry};
use rust_decimal::Decimal;
use scheduler::SchedulerSettings;
use serde::Deserialize;
use storage_impl::config::QueueStrategy;
use crate::analytics::{AnalyticsConfig, AnalyticsProvider};
use crate::{
configs,
core::errors::{ApplicationError, ApplicationResult},
env::{self, Env},
events::EventsConfig,
routes::app,
AppState,
};
fn test_payment_method_hashset_deserializer() {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/configs/settings.rs | crate: router
use std::{
collections::{HashMap, HashSet},
path::PathBuf,
sync::Arc,
};
use analytics::{opensearch::OpenSearchConfig, ReportConfig};
use api_models::{enums, payment_methods::RequiredFieldInfo};
use common_utils::{ext_traits::ConfigExt, id_type, types::theme::EmailThemeConfig};
use config::{Environment, File};
use error_stack::ResultExt;
use external_services::email::EmailSettings;
use external_services::{
file_storage::FileStorageConfig,
grpc_client::GrpcClientSettings,
managers::{
encryption_management::EncryptionManagementConfig,
secrets_management::SecretsManagementConfig,
},
};
pub use hyperswitch_interfaces::configs::Connectors;
use hyperswitch_interfaces::secrets_interface::secret_state::{
RawSecret, SecretState, SecretStateContainer, SecuredSecret,
};
use masking::Secret;
use redis_interface::RedisSettings;
pub use router_env::config::{Log, LogConsole, LogFile, LogTelemetry};
use rust_decimal::Decimal;
use scheduler::SchedulerSettings;
use serde::Deserialize;
use storage_impl::config::QueueStrategy;
use crate::analytics::{AnalyticsConfig, AnalyticsProvider};
use crate::{
configs,
core::errors::{ApplicationError, ApplicationResult},
env::{self, Env},
events::EventsConfig,
routes::app,
AppState,
};
fn test_payment_method_deserializer_error() {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
// file: hyperswitch/crates/router/src/configs/settings.rs | crate: router
use std::{
collections::{HashMap, HashSet},
path::PathBuf,
sync::Arc,
};
use common_utils::{ext_traits::ConfigExt, id_type, types::theme::EmailThemeConfig};
use serde::Deserialize;
fn deserialize_merchant_ids<'de, D>(
deserializer: D,
) -> Result<HashSet<id_type::MerchantId>, D::Error>
where
D: serde::Deserializer<'de>,
{
let s = String::deserialize(deserializer)?;
deserialize_merchant_ids_inner(s).map_err(serde::de::Error::custom)
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/configs/settings.rs | crate: router
use std::{
collections::{HashMap, HashSet},
path::PathBuf,
sync::Arc,
};
use analytics::{opensearch::OpenSearchConfig, ReportConfig};
use api_models::{enums, payment_methods::RequiredFieldInfo};
use common_utils::{ext_traits::ConfigExt, id_type, types::theme::EmailThemeConfig};
use config::{Environment, File};
use error_stack::ResultExt;
use external_services::email::EmailSettings;
use external_services::{
file_storage::FileStorageConfig,
grpc_client::GrpcClientSettings,
managers::{
encryption_management::EncryptionManagementConfig,
secrets_management::SecretsManagementConfig,
},
};
pub use hyperswitch_interfaces::configs::Connectors;
use hyperswitch_interfaces::secrets_interface::secret_state::{
RawSecret, SecretState, SecretStateContainer, SecuredSecret,
};
use masking::Secret;
use redis_interface::RedisSettings;
pub use router_env::config::{Log, LogConsole, LogFile, LogTelemetry};
use rust_decimal::Decimal;
use scheduler::SchedulerSettings;
use serde::Deserialize;
use storage_impl::config::QueueStrategy;
use crate::analytics::{AnalyticsConfig, AnalyticsProvider};
use crate::{
configs,
core::errors::{ApplicationError, ApplicationResult},
env::{self, Env},
events::EventsConfig,
routes::app,
AppState,
};
fn deserialize_optional_hashset<'a, D, T>(deserializer: D) -> Result<Option<HashSet<T>>, D::Error>
where
D: serde::Deserializer<'a>,
T: Eq + std::str::FromStr + std::hash::Hash,
<T as std::str::FromStr>::Err: std::fmt::Display,
{
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/configs/settings.rs | crate: router
use std::{
collections::{HashMap, HashSet},
path::PathBuf,
sync::Arc,
};
use analytics::{opensearch::OpenSearchConfig, ReportConfig};
use api_models::{enums, payment_methods::RequiredFieldInfo};
use common_utils::{ext_traits::ConfigExt, id_type, types::theme::EmailThemeConfig};
use config::{Environment, File};
use error_stack::ResultExt;
use external_services::email::EmailSettings;
use external_services::{
file_storage::FileStorageConfig,
grpc_client::GrpcClientSettings,
managers::{
encryption_management::EncryptionManagementConfig,
secrets_management::SecretsManagementConfig,
},
};
pub use hyperswitch_interfaces::configs::Connectors;
use hyperswitch_interfaces::secrets_interface::secret_state::{
RawSecret, SecretState, SecretStateContainer, SecuredSecret,
};
use masking::Secret;
use redis_interface::RedisSettings;
pub use router_env::config::{Log, LogConsole, LogFile, LogTelemetry};
use rust_decimal::Decimal;
use scheduler::SchedulerSettings;
use serde::Deserialize;
use storage_impl::config::QueueStrategy;
use crate::analytics::{AnalyticsConfig, AnalyticsProvider};
use crate::{
configs,
core::errors::{ApplicationError, ApplicationResult},
env::{self, Env},
events::EventsConfig,
routes::app,
AppState,
};
fn deserialize_hashset<'a, D, T>(deserializer: D) -> Result<HashSet<T>, D::Error>
where
D: serde::Deserializer<'a>,
T: Eq + std::str::FromStr + std::hash::Hash,
<T as std::str::FromStr>::Err: std::fmt::Display,
{
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/configs/settings.rs | crate: router
use std::{
collections::{HashMap, HashSet},
path::PathBuf,
sync::Arc,
};
use analytics::{opensearch::OpenSearchConfig, ReportConfig};
use api_models::{enums, payment_methods::RequiredFieldInfo};
use common_utils::{ext_traits::ConfigExt, id_type, types::theme::EmailThemeConfig};
use config::{Environment, File};
use error_stack::ResultExt;
use external_services::email::EmailSettings;
use external_services::{
file_storage::FileStorageConfig,
grpc_client::GrpcClientSettings,
managers::{
encryption_management::EncryptionManagementConfig,
secrets_management::SecretsManagementConfig,
},
};
pub use hyperswitch_interfaces::configs::Connectors;
use hyperswitch_interfaces::secrets_interface::secret_state::{
RawSecret, SecretState, SecretStateContainer, SecuredSecret,
};
use masking::Secret;
use redis_interface::RedisSettings;
pub use router_env::config::{Log, LogConsole, LogFile, LogTelemetry};
use rust_decimal::Decimal;
use scheduler::SchedulerSettings;
use serde::Deserialize;
use storage_impl::config::QueueStrategy;
use crate::analytics::{AnalyticsConfig, AnalyticsProvider};
use crate::{
configs,
core::errors::{ApplicationError, ApplicationResult},
env::{self, Env},
events::EventsConfig,
routes::app,
AppState,
};
fn deserialize_hashmap<'a, D, K, V>(deserializer: D) -> Result<HashMap<K, HashSet<V>>, D::Error>
where
D: serde::Deserializer<'a>,
K: Eq + std::str::FromStr + std::hash::Hash,
V: Eq + std::str::FromStr + std::hash::Hash,
<K as std::str::FromStr>::Err: std::fmt::Display,
<V as std::str::FromStr>::Err: std::fmt::Display,
{
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
// file: hyperswitch/crates/router/src/configs/settings.rs | crate: router
use common_utils::{ext_traits::ConfigExt, id_type, types::theme::EmailThemeConfig};
fn default() -> Self {
// We provide a static default cell id for constructing application settings.
// This will only panic at application startup if we're unable to construct the default,
// around the time of deserializing application settings.
// And a panic at application startup is considered acceptable.
#[allow(clippy::expect_used)]
let cell_id =
id_type::CellId::from_string("defid").expect("Failed to create a default for Cell Id");
Self { id: cell_id }
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/configs/settings.rs | crate: router
pub use hyperswitch_interfaces::configs::Connectors;
pub use router_env::config::{Log, LogConsole, LogFile, LogTelemetry};
use crate::{
configs,
core::errors::{ApplicationError, ApplicationResult},
env::{self, Env},
events::EventsConfig,
routes::app,
AppState,
};
pub fn is_kv_soft_kill_mode(&self) -> bool {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/configs/settings.rs | crate: router
pub use hyperswitch_interfaces::configs::Connectors;
pub use router_env::config::{Log, LogConsole, LogFile, LogTelemetry};
use crate::{
configs,
core::errors::{ApplicationError, ApplicationResult},
env::{self, Env},
events::EventsConfig,
routes::app,
AppState,
};
pub fn new() -> ApplicationResult<Self> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/configs/settings.rs | crate: router
fn from(val: Database) -> Self {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
// file: hyperswitch/crates/router/src/configs/settings.rs | crate: router
use std::{
collections::{HashMap, HashSet},
path::PathBuf,
sync::Arc,
};
fn default() -> Self {
Self {
#[allow(clippy::expect_used)]
sdk_url: url::Url::parse("http://localhost:9050/HyperLoader.js")
.expect("Failed to parse default SDK URL"),
expiry: 900,
ui_config: GenericLinkEnvUiConfig::default(),
enabled_payment_methods: HashMap::default(),
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/configs/settings.rs | crate: router
use crate::{
configs,
core::errors::{ApplicationError, ApplicationResult},
env::{self, Env},
events::EventsConfig,
routes::app,
AppState,
};
fn get_clickhouse_database(&self) -> &str {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/configs/settings.rs | crate: router
use crate::{
configs,
core::errors::{ApplicationError, ApplicationResult},
env::{self, Env},
events::EventsConfig,
routes::app,
AppState,
};
fn get_schema(&self) -> &str {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/configs/settings.rs | crate: router
use common_utils::{ext_traits::ConfigExt, id_type, types::theme::EmailThemeConfig};
use crate::{
configs,
core::errors::{ApplicationError, ApplicationResult},
env::{self, Env},
events::EventsConfig,
routes::app,
AppState,
};
fn get_tenant_id(&self) -> &id_type::TenantId {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/configs/settings.rs | crate: router
use crate::{
configs,
core::errors::{ApplicationError, ApplicationResult},
env::{self, Env},
events::EventsConfig,
routes::app,
AppState,
};
fn get_redis_key_prefix(&self) -> &str {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/configs/settings.rs | crate: router
use crate::{
configs,
core::errors::{ApplicationError, ApplicationResult},
env::{self, Env},
events::EventsConfig,
routes::app,
AppState,
};
fn get_accounts_schema(&self) -> &str {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/configs/settings.rs | crate: router
use std::{
collections::{HashMap, HashSet},
path::PathBuf,
sync::Arc,
};
use common_utils::{ext_traits::ConfigExt, id_type, types::theme::EmailThemeConfig};
pub use hyperswitch_interfaces::configs::Connectors;
pub use router_env::config::{Log, LogConsole, LogFile, LogTelemetry};
use crate::analytics::{AnalyticsConfig, AnalyticsProvider};
use crate::{
configs,
core::errors::{ApplicationError, ApplicationResult},
env::{self, Env},
events::EventsConfig,
routes::app,
AppState,
};
pub async fn get_pools_map(
&self,
analytics_config: &AnalyticsConfig,
) -> HashMap<id_type::TenantId, AnalyticsProvider> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/configs/settings.rs | crate: router
use std::{
collections::{HashMap, HashSet},
path::PathBuf,
sync::Arc,
};
use common_utils::{ext_traits::ConfigExt, id_type, types::theme::EmailThemeConfig};
pub use hyperswitch_interfaces::configs::Connectors;
pub use router_env::config::{Log, LogConsole, LogFile, LogTelemetry};
use crate::{
configs,
core::errors::{ApplicationError, ApplicationResult},
env::{self, Env},
events::EventsConfig,
routes::app,
AppState,
};
pub fn get_tenants(&self) -> &HashMap<id_type::TenantId, Tenant> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/configs/settings.rs | crate: router
use std::{
collections::{HashMap, HashSet},
path::PathBuf,
sync::Arc,
};
use analytics::{opensearch::OpenSearchConfig, ReportConfig};
use common_utils::{ext_traits::ConfigExt, id_type, types::theme::EmailThemeConfig};
use error_stack::ResultExt;
use external_services::email::EmailSettings;
use external_services::{
file_storage::FileStorageConfig,
grpc_client::GrpcClientSettings,
managers::{
encryption_management::EncryptionManagementConfig,
secrets_management::SecretsManagementConfig,
},
};
pub use hyperswitch_interfaces::configs::Connectors;
pub use router_env::config::{Log, LogConsole, LogFile, LogTelemetry};
use scheduler::SchedulerSettings;
use crate::{
configs,
core::errors::{ApplicationError, ApplicationResult},
env::{self, Env},
events::EventsConfig,
routes::app,
AppState,
};
pub fn validate(&self) -> ApplicationResult<()> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/configs/defaults/payout_required_fields.rs | crate: router
use api_models::{
enums::{
CountryAlpha2, FieldType,
PaymentMethod::{BankTransfer, Card, Wallet},
PaymentMethodType, PayoutConnectors,
},
payment_methods::RequiredFieldInfo,
};
fn get_countries_for_connector(connector: PayoutConnectors) -> Vec<CountryAlpha2> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/configs/defaults/payout_required_fields.rs | crate: router
use std::collections::HashMap;
use api_models::{
enums::{
CountryAlpha2, FieldType,
PaymentMethod::{BankTransfer, Card, Wallet},
PaymentMethodType, PayoutConnectors,
},
payment_methods::RequiredFieldInfo,
};
fn get_card_fields() -> HashMap<String, RequiredFieldInfo> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/configs/defaults/payout_required_fields.rs | crate: router
use std::collections::HashMap;
use api_models::{
enums::{
CountryAlpha2, FieldType,
PaymentMethod::{BankTransfer, Card, Wallet},
PaymentMethodType, PayoutConnectors,
},
payment_methods::RequiredFieldInfo,
};
fn get_pix_bank_transfer_fields() -> HashMap<String, RequiredFieldInfo> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/configs/defaults/payout_required_fields.rs | crate: router
use std::collections::HashMap;
use api_models::{
enums::{
CountryAlpha2, FieldType,
PaymentMethod::{BankTransfer, Card, Wallet},
PaymentMethodType, PayoutConnectors,
},
payment_methods::RequiredFieldInfo,
};
fn get_paypal_fields() -> HashMap<String, RequiredFieldInfo> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/configs/defaults/payout_required_fields.rs | crate: router
use std::collections::HashMap;
use api_models::{
enums::{
CountryAlpha2, FieldType,
PaymentMethod::{BankTransfer, Card, Wallet},
PaymentMethodType, PayoutConnectors,
},
payment_methods::RequiredFieldInfo,
};
fn get_sepa_fields() -> HashMap<String, RequiredFieldInfo> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
// file: hyperswitch/crates/router/src/configs/defaults/payout_required_fields.rs | crate: router
use std::collections::HashMap;
use api_models::{
enums::{
CountryAlpha2, FieldType,
PaymentMethod::{BankTransfer, Card, Wallet},
PaymentMethodType, PayoutConnectors,
},
payment_methods::RequiredFieldInfo,
};
fn get_pix_bank_transfer_fields() -> HashMap<String, RequiredFieldInfo> {
HashMap::from([
(
"payout_method_data.bank.bank_account_number".to_string(),
RequiredFieldInfo {
required_field: "payout_method_data.bank.bank_account_number".to_string(),
display_name: "bank_account_number".to_string(),
field_type: FieldType::Text,
value: None,
},
),
(
"payout_method_data.bank.pix_key".to_string(),
RequiredFieldInfo {
required_field: "payout_method_data.bank.pix_key".to_string(),
display_name: "pix_key".to_string(),
field_type: FieldType::Text,
value: None,
},
),
])
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/configs/defaults/payout_required_fields.rs | crate: router
use std::collections::HashMap;
use api_models::{
enums::{
CountryAlpha2, FieldType,
PaymentMethod::{BankTransfer, Card, Wallet},
PaymentMethodType, PayoutConnectors,
},
payment_methods::RequiredFieldInfo,
};
fn get_bacs_fields() -> HashMap<String, RequiredFieldInfo> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/configs/defaults/payout_required_fields.rs | crate: router
use std::collections::HashMap;
use api_models::{
enums::{
CountryAlpha2, FieldType,
PaymentMethod::{BankTransfer, Card, Wallet},
PaymentMethodType, PayoutConnectors,
},
payment_methods::RequiredFieldInfo,
};
use crate::settings::{
ConnectorFields, PaymentMethodType as PaymentMethodTypeInfo, PayoutRequiredFields,
RequiredFieldFinal,
};
fn get_connector_payment_method_type_fields(
connector: PayoutConnectors,
payment_method_type: PaymentMethodType,
) -> (PaymentMethodType, ConnectorFields) {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/configs/defaults/payout_required_fields.rs | crate: router
use std::collections::HashMap;
use api_models::{
enums::{
CountryAlpha2, FieldType,
PaymentMethod::{BankTransfer, Card, Wallet},
PaymentMethodType, PayoutConnectors,
},
payment_methods::RequiredFieldInfo,
};
fn get_billing_details(connector: PayoutConnectors) -> HashMap<String, RequiredFieldInfo> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/signifyd.rs | crate: router
use transformers as signifyd;
use crate::{
configs::settings,
core::errors::{self, CustomResult},
headers,
services::{self, request, ConnectorIntegration, ConnectorSpecifications, ConnectorValidation},
types::{
self,
api::{self, ConnectorCommon, ConnectorCommonExt},
},
};
use crate::{
consts,
events::connector_api_logs::ConnectorEvent,
types::{api::fraud_check as frm_api, fraud_check as frm_types, ErrorResponse, Response},
utils::BytesExt,
};
fn handle_response(
&self,
data: &frm_types::FrmRecordReturnRouterData,
event_builder: Option<&mut ConnectorEvent>,
res: Response,
) -> CustomResult<frm_types::FrmRecordReturnRouterData, errors::ConnectorError> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/signifyd.rs | crate: router
use common_utils::{crypto, ext_traits::ByteSliceExt, request::RequestContent};
use transformers as signifyd;
use crate::{
configs::settings,
core::errors::{self, CustomResult},
headers,
services::{self, request, ConnectorIntegration, ConnectorSpecifications, ConnectorValidation},
types::{
self,
api::{self, ConnectorCommon, ConnectorCommonExt},
},
};
use crate::{
consts,
events::connector_api_logs::ConnectorEvent,
types::{api::fraud_check as frm_api, fraud_check as frm_types, ErrorResponse, Response},
utils::BytesExt,
};
fn get_webhook_event_type(
&self,
request: &api::IncomingWebhookRequestDetails<'_>,
) -> CustomResult<api::IncomingWebhookEvent, errors::ConnectorError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/signifyd.rs | crate: router
use common_utils::{crypto, ext_traits::ByteSliceExt, request::RequestContent};
use transformers as signifyd;
use crate::{
configs::settings,
core::errors::{self, CustomResult},
headers,
services::{self, request, ConnectorIntegration, ConnectorSpecifications, ConnectorValidation},
types::{
self,
api::{self, ConnectorCommon, ConnectorCommonExt},
},
};
use crate::{
consts,
events::connector_api_logs::ConnectorEvent,
types::{api::fraud_check as frm_api, fraud_check as frm_types, ErrorResponse, Response},
utils::BytesExt,
};
fn get_webhook_object_reference_id(
&self,
request: &api::IncomingWebhookRequestDetails<'_>,
) -> CustomResult<api_models::webhooks::ObjectReferenceId, errors::ConnectorError> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/signifyd.rs | crate: router
use common_utils::{crypto, ext_traits::ByteSliceExt, request::RequestContent};
use ring::hmac;
use transformers as signifyd;
use super::utils as connector_utils;
use crate::{
configs::settings,
core::errors::{self, CustomResult},
headers,
services::{self, request, ConnectorIntegration, ConnectorSpecifications, ConnectorValidation},
types::{
self,
api::{self, ConnectorCommon, ConnectorCommonExt},
},
};
use crate::{
consts,
events::connector_api_logs::ConnectorEvent,
types::{api::fraud_check as frm_api, fraud_check as frm_types, ErrorResponse, Response},
utils::BytesExt,
};
fn get_webhook_source_verification_signature(
&self,
request: &api::IncomingWebhookRequestDetails<'_>,
_connector_webhook_secrets: &api_models::webhooks::ConnectorWebhookSecrets,
) -> CustomResult<Vec<u8>, errors::ConnectorError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
// file: hyperswitch/crates/router/src/connector/signifyd.rs | crate: router
use transformers as signifyd;
use crate::{
configs::settings,
core::errors::{self, CustomResult},
headers,
services::{self, request, ConnectorIntegration, ConnectorSpecifications, ConnectorValidation},
types::{
self,
api::{self, ConnectorCommon, ConnectorCommonExt},
},
};
use crate::{
consts,
events::connector_api_logs::ConnectorEvent,
types::{api::fraud_check as frm_api, fraud_check as frm_types, ErrorResponse, Response},
utils::BytesExt,
};
fn handle_response(
&self,
data: &frm_types::FrmRecordReturnRouterData,
event_builder: Option<&mut ConnectorEvent>,
res: Response,
) -> CustomResult<frm_types::FrmRecordReturnRouterData, errors::ConnectorError> {
let response: signifyd::SignifydPaymentsRecordReturnResponse = res
.response
.parse_struct("SignifydPaymentsResponse Transaction")
.change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
event_builder.map(|i| i.set_response_body(&response));
router_env::logger::info!(connector_response=?response);
<frm_types::FrmRecordReturnRouterData>::try_from(types::ResponseRouterData {
response,
data: data.clone(),
http_code: res.status_code,
})
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/signifyd.rs | crate: router
use crate::{
configs::settings,
core::errors::{self, CustomResult},
headers,
services::{self, request, ConnectorIntegration, ConnectorSpecifications, ConnectorValidation},
types::{
self,
api::{self, ConnectorCommon, ConnectorCommonExt},
},
};
use crate::{
consts,
events::connector_api_logs::ConnectorEvent,
types::{api::fraud_check as frm_api, fraud_check as frm_types, ErrorResponse, Response},
utils::BytesExt,
};
fn build_request(
&self,
req: &frm_types::FrmRecordReturnRouterData,
connectors: &settings::Connectors,
) -> CustomResult<Option<services::Request>, errors::ConnectorError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/signifyd.rs | crate: router
use common_utils::{crypto, ext_traits::ByteSliceExt, request::RequestContent};
use transformers as signifyd;
use crate::{
configs::settings,
core::errors::{self, CustomResult},
headers,
services::{self, request, ConnectorIntegration, ConnectorSpecifications, ConnectorValidation},
types::{
self,
api::{self, ConnectorCommon, ConnectorCommonExt},
},
};
use crate::{
consts,
events::connector_api_logs::ConnectorEvent,
types::{api::fraud_check as frm_api, fraud_check as frm_types, ErrorResponse, Response},
utils::BytesExt,
};
fn get_request_body(
&self,
req: &frm_types::FrmRecordReturnRouterData,
_connectors: &settings::Connectors,
) -> CustomResult<RequestContent, errors::ConnectorError> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/signifyd.rs | crate: router
use crate::{
configs::settings,
core::errors::{self, CustomResult},
headers,
services::{self, request, ConnectorIntegration, ConnectorSpecifications, ConnectorValidation},
types::{
self,
api::{self, ConnectorCommon, ConnectorCommonExt},
},
};
use crate::{
consts,
events::connector_api_logs::ConnectorEvent,
types::{api::fraud_check as frm_api, fraud_check as frm_types, ErrorResponse, Response},
utils::BytesExt,
};
fn get_url(
&self,
_req: &frm_types::FrmRecordReturnRouterData,
connectors: &settings::Connectors,
) -> CustomResult<String, errors::ConnectorError> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/signifyd.rs | crate: router
use common_utils::{crypto, ext_traits::ByteSliceExt, request::RequestContent};
use crate::{
configs::settings,
core::errors::{self, CustomResult},
headers,
services::{self, request, ConnectorIntegration, ConnectorSpecifications, ConnectorValidation},
types::{
self,
api::{self, ConnectorCommon, ConnectorCommonExt},
},
};
use crate::{
consts,
events::connector_api_logs::ConnectorEvent,
types::{api::fraud_check as frm_api, fraud_check as frm_types, ErrorResponse, Response},
utils::BytesExt,
};
fn get_headers(
&self,
req: &frm_types::FrmRecordReturnRouterData,
connectors: &settings::Connectors,
) -> CustomResult<Vec<(String, request::Maskable<String>)>, errors::ConnectorError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/signifyd.rs | crate: router
use transformers as signifyd;
use crate::{
configs::settings,
core::errors::{self, CustomResult},
headers,
services::{self, request, ConnectorIntegration, ConnectorSpecifications, ConnectorValidation},
types::{
self,
api::{self, ConnectorCommon, ConnectorCommonExt},
},
};
use crate::{
consts,
events::connector_api_logs::ConnectorEvent,
types::{api::fraud_check as frm_api, fraud_check as frm_types, ErrorResponse, Response},
utils::BytesExt,
};
fn handle_response(
&self,
data: &frm_types::FrmFulfillmentRouterData,
event_builder: Option<&mut ConnectorEvent>,
res: Response,
) -> CustomResult<frm_types::FrmFulfillmentRouterData, errors::ConnectorError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/signifyd.rs | crate: router
use crate::{
configs::settings,
core::errors::{self, CustomResult},
headers,
services::{self, request, ConnectorIntegration, ConnectorSpecifications, ConnectorValidation},
types::{
self,
api::{self, ConnectorCommon, ConnectorCommonExt},
},
};
use crate::{
consts,
events::connector_api_logs::ConnectorEvent,
types::{api::fraud_check as frm_api, fraud_check as frm_types, ErrorResponse, Response},
utils::BytesExt,
};
fn build_request(
&self,
req: &frm_types::FrmFulfillmentRouterData,
connectors: &settings::Connectors,
) -> CustomResult<Option<services::Request>, errors::ConnectorError> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/signifyd.rs | crate: router
use common_utils::{crypto, ext_traits::ByteSliceExt, request::RequestContent};
use transformers as signifyd;
use crate::{
configs::settings,
core::errors::{self, CustomResult},
headers,
services::{self, request, ConnectorIntegration, ConnectorSpecifications, ConnectorValidation},
types::{
self,
api::{self, ConnectorCommon, ConnectorCommonExt},
},
};
use crate::{
consts,
events::connector_api_logs::ConnectorEvent,
types::{api::fraud_check as frm_api, fraud_check as frm_types, ErrorResponse, Response},
utils::BytesExt,
};
fn get_request_body(
&self,
req: &frm_types::FrmFulfillmentRouterData,
_connectors: &settings::Connectors,
) -> CustomResult<RequestContent, errors::ConnectorError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/signifyd.rs | crate: router
use crate::{
configs::settings,
core::errors::{self, CustomResult},
headers,
services::{self, request, ConnectorIntegration, ConnectorSpecifications, ConnectorValidation},
types::{
self,
api::{self, ConnectorCommon, ConnectorCommonExt},
},
};
use crate::{
consts,
events::connector_api_logs::ConnectorEvent,
types::{api::fraud_check as frm_api, fraud_check as frm_types, ErrorResponse, Response},
utils::BytesExt,
};
fn get_url(
&self,
_req: &frm_types::FrmFulfillmentRouterData,
connectors: &settings::Connectors,
) -> CustomResult<String, errors::ConnectorError> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/signifyd.rs | crate: router
use transformers as signifyd;
use crate::{
configs::settings,
core::errors::{self, CustomResult},
headers,
services::{self, request, ConnectorIntegration, ConnectorSpecifications, ConnectorValidation},
types::{
self,
api::{self, ConnectorCommon, ConnectorCommonExt},
},
};
use crate::{
consts,
events::connector_api_logs::ConnectorEvent,
types::{api::fraud_check as frm_api, fraud_check as frm_types, ErrorResponse, Response},
utils::BytesExt,
};
fn handle_response(
&self,
data: &frm_types::FrmTransactionRouterData,
event_builder: Option<&mut ConnectorEvent>,
res: Response,
) -> CustomResult<frm_types::FrmTransactionRouterData, errors::ConnectorError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/signifyd.rs | crate: router
use crate::{
configs::settings,
core::errors::{self, CustomResult},
headers,
services::{self, request, ConnectorIntegration, ConnectorSpecifications, ConnectorValidation},
types::{
self,
api::{self, ConnectorCommon, ConnectorCommonExt},
},
};
use crate::{
consts,
events::connector_api_logs::ConnectorEvent,
types::{api::fraud_check as frm_api, fraud_check as frm_types, ErrorResponse, Response},
utils::BytesExt,
};
fn build_request(
&self,
req: &frm_types::FrmTransactionRouterData,
connectors: &settings::Connectors,
) -> CustomResult<Option<services::Request>, errors::ConnectorError> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/signifyd.rs | crate: router
use common_utils::{crypto, ext_traits::ByteSliceExt, request::RequestContent};
use transformers as signifyd;
use crate::{
configs::settings,
core::errors::{self, CustomResult},
headers,
services::{self, request, ConnectorIntegration, ConnectorSpecifications, ConnectorValidation},
types::{
self,
api::{self, ConnectorCommon, ConnectorCommonExt},
},
};
use crate::{
consts,
events::connector_api_logs::ConnectorEvent,
types::{api::fraud_check as frm_api, fraud_check as frm_types, ErrorResponse, Response},
utils::BytesExt,
};
fn get_request_body(
&self,
req: &frm_types::FrmTransactionRouterData,
_connectors: &settings::Connectors,
) -> CustomResult<RequestContent, errors::ConnectorError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/signifyd.rs | crate: router
use crate::{
configs::settings,
core::errors::{self, CustomResult},
headers,
services::{self, request, ConnectorIntegration, ConnectorSpecifications, ConnectorValidation},
types::{
self,
api::{self, ConnectorCommon, ConnectorCommonExt},
},
};
use crate::{
consts,
events::connector_api_logs::ConnectorEvent,
types::{api::fraud_check as frm_api, fraud_check as frm_types, ErrorResponse, Response},
utils::BytesExt,
};
fn get_url(
&self,
_req: &frm_types::FrmTransactionRouterData,
connectors: &settings::Connectors,
) -> CustomResult<String, errors::ConnectorError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/signifyd.rs | crate: router
use common_utils::{crypto, ext_traits::ByteSliceExt, request::RequestContent};
use crate::{
configs::settings,
core::errors::{self, CustomResult},
headers,
services::{self, request, ConnectorIntegration, ConnectorSpecifications, ConnectorValidation},
types::{
self,
api::{self, ConnectorCommon, ConnectorCommonExt},
},
};
use crate::{
consts,
events::connector_api_logs::ConnectorEvent,
types::{api::fraud_check as frm_api, fraud_check as frm_types, ErrorResponse, Response},
utils::BytesExt,
};
fn get_headers(
&self,
req: &frm_types::FrmTransactionRouterData,
connectors: &settings::Connectors,
) -> CustomResult<Vec<(String, request::Maskable<String>)>, errors::ConnectorError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/signifyd.rs | crate: router
use transformers as signifyd;
use crate::{
configs::settings,
core::errors::{self, CustomResult},
headers,
services::{self, request, ConnectorIntegration, ConnectorSpecifications, ConnectorValidation},
types::{
self,
api::{self, ConnectorCommon, ConnectorCommonExt},
},
};
use crate::{
consts,
events::connector_api_logs::ConnectorEvent,
types::{api::fraud_check as frm_api, fraud_check as frm_types, ErrorResponse, Response},
utils::BytesExt,
};
fn handle_response(
&self,
data: &frm_types::FrmCheckoutRouterData,
event_builder: Option<&mut ConnectorEvent>,
res: Response,
) -> CustomResult<frm_types::FrmCheckoutRouterData, errors::ConnectorError> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/signifyd.rs | crate: router
use crate::{
configs::settings,
core::errors::{self, CustomResult},
headers,
services::{self, request, ConnectorIntegration, ConnectorSpecifications, ConnectorValidation},
types::{
self,
api::{self, ConnectorCommon, ConnectorCommonExt},
},
};
use crate::{
consts,
events::connector_api_logs::ConnectorEvent,
types::{api::fraud_check as frm_api, fraud_check as frm_types, ErrorResponse, Response},
utils::BytesExt,
};
fn build_request(
&self,
req: &frm_types::FrmCheckoutRouterData,
connectors: &settings::Connectors,
) -> CustomResult<Option<services::Request>, errors::ConnectorError> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/signifyd.rs | crate: router
use common_utils::{crypto, ext_traits::ByteSliceExt, request::RequestContent};
use transformers as signifyd;
use crate::{
configs::settings,
core::errors::{self, CustomResult},
headers,
services::{self, request, ConnectorIntegration, ConnectorSpecifications, ConnectorValidation},
types::{
self,
api::{self, ConnectorCommon, ConnectorCommonExt},
},
};
use crate::{
consts,
events::connector_api_logs::ConnectorEvent,
types::{api::fraud_check as frm_api, fraud_check as frm_types, ErrorResponse, Response},
utils::BytesExt,
};
fn get_request_body(
&self,
req: &frm_types::FrmCheckoutRouterData,
_connectors: &settings::Connectors,
) -> CustomResult<RequestContent, errors::ConnectorError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/signifyd.rs | crate: router
use crate::{
configs::settings,
core::errors::{self, CustomResult},
headers,
services::{self, request, ConnectorIntegration, ConnectorSpecifications, ConnectorValidation},
types::{
self,
api::{self, ConnectorCommon, ConnectorCommonExt},
},
};
use crate::{
consts,
events::connector_api_logs::ConnectorEvent,
types::{api::fraud_check as frm_api, fraud_check as frm_types, ErrorResponse, Response},
utils::BytesExt,
};
fn get_url(
&self,
_req: &frm_types::FrmCheckoutRouterData,
connectors: &settings::Connectors,
) -> CustomResult<String, errors::ConnectorError> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/signifyd.rs | crate: router
use common_utils::{crypto, ext_traits::ByteSliceExt, request::RequestContent};
use crate::{
configs::settings,
core::errors::{self, CustomResult},
headers,
services::{self, request, ConnectorIntegration, ConnectorSpecifications, ConnectorValidation},
types::{
self,
api::{self, ConnectorCommon, ConnectorCommonExt},
},
};
use crate::{
consts,
events::connector_api_logs::ConnectorEvent,
types::{api::fraud_check as frm_api, fraud_check as frm_types, ErrorResponse, Response},
utils::BytesExt,
};
fn get_headers(
&self,
req: &frm_types::FrmCheckoutRouterData,
connectors: &settings::Connectors,
) -> CustomResult<Vec<(String, request::Maskable<String>)>, errors::ConnectorError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/signifyd.rs | crate: router
use transformers as signifyd;
use crate::{
configs::settings,
core::errors::{self, CustomResult},
headers,
services::{self, request, ConnectorIntegration, ConnectorSpecifications, ConnectorValidation},
types::{
self,
api::{self, ConnectorCommon, ConnectorCommonExt},
},
};
use crate::{
consts,
events::connector_api_logs::ConnectorEvent,
types::{api::fraud_check as frm_api, fraud_check as frm_types, ErrorResponse, Response},
utils::BytesExt,
};
fn handle_response(
&self,
data: &frm_types::FrmSaleRouterData,
event_builder: Option<&mut ConnectorEvent>,
res: Response,
) -> CustomResult<frm_types::FrmSaleRouterData, errors::ConnectorError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/signifyd.rs | crate: router
use crate::{
configs::settings,
core::errors::{self, CustomResult},
headers,
services::{self, request, ConnectorIntegration, ConnectorSpecifications, ConnectorValidation},
types::{
self,
api::{self, ConnectorCommon, ConnectorCommonExt},
},
};
use crate::{
consts,
events::connector_api_logs::ConnectorEvent,
types::{api::fraud_check as frm_api, fraud_check as frm_types, ErrorResponse, Response},
utils::BytesExt,
};
fn build_request(
&self,
req: &frm_types::FrmSaleRouterData,
connectors: &settings::Connectors,
) -> CustomResult<Option<services::Request>, errors::ConnectorError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/signifyd.rs | crate: router
use common_utils::{crypto, ext_traits::ByteSliceExt, request::RequestContent};
use transformers as signifyd;
use crate::{
configs::settings,
core::errors::{self, CustomResult},
headers,
services::{self, request, ConnectorIntegration, ConnectorSpecifications, ConnectorValidation},
types::{
self,
api::{self, ConnectorCommon, ConnectorCommonExt},
},
};
use crate::{
consts,
events::connector_api_logs::ConnectorEvent,
types::{api::fraud_check as frm_api, fraud_check as frm_types, ErrorResponse, Response},
utils::BytesExt,
};
fn get_request_body(
&self,
req: &frm_types::FrmSaleRouterData,
_connectors: &settings::Connectors,
) -> CustomResult<RequestContent, errors::ConnectorError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/signifyd.rs | crate: router
use crate::{
configs::settings,
core::errors::{self, CustomResult},
headers,
services::{self, request, ConnectorIntegration, ConnectorSpecifications, ConnectorValidation},
types::{
self,
api::{self, ConnectorCommon, ConnectorCommonExt},
},
};
use crate::{
consts,
events::connector_api_logs::ConnectorEvent,
types::{api::fraud_check as frm_api, fraud_check as frm_types, ErrorResponse, Response},
utils::BytesExt,
};
fn get_url(
&self,
_req: &frm_types::FrmSaleRouterData,
connectors: &settings::Connectors,
) -> CustomResult<String, errors::ConnectorError> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/signifyd.rs | crate: router
use common_utils::{crypto, ext_traits::ByteSliceExt, request::RequestContent};
use crate::{
configs::settings,
core::errors::{self, CustomResult},
headers,
services::{self, request, ConnectorIntegration, ConnectorSpecifications, ConnectorValidation},
types::{
self,
api::{self, ConnectorCommon, ConnectorCommonExt},
},
};
use crate::{
consts,
events::connector_api_logs::ConnectorEvent,
types::{api::fraud_check as frm_api, fraud_check as frm_types, ErrorResponse, Response},
utils::BytesExt,
};
fn get_headers(
&self,
req: &frm_types::FrmSaleRouterData,
connectors: &settings::Connectors,
) -> CustomResult<Vec<(String, request::Maskable<String>)>, errors::ConnectorError> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/signifyd.rs | crate: router
use crate::{
configs::settings,
core::errors::{self, CustomResult},
headers,
services::{self, request, ConnectorIntegration, ConnectorSpecifications, ConnectorValidation},
types::{
self,
api::{self, ConnectorCommon, ConnectorCommonExt},
},
};
use crate::{
consts,
events::connector_api_logs::ConnectorEvent,
types::{api::fraud_check as frm_api, fraud_check as frm_types, ErrorResponse, Response},
utils::BytesExt,
};
fn build_request(
&self,
_req: &types::RouterData<
api::SetupMandate,
types::SetupMandateRequestData,
types::PaymentsResponseData,
>,
_connectors: &settings::Connectors,
) -> CustomResult<Option<services::Request>, errors::ConnectorError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
// file: hyperswitch/crates/router/src/connector/signifyd.rs | crate: router
use transformers as signifyd;
use crate::{
configs::settings,
core::errors::{self, CustomResult},
headers,
services::{self, request, ConnectorIntegration, ConnectorSpecifications, ConnectorValidation},
types::{
self,
api::{self, ConnectorCommon, ConnectorCommonExt},
},
};
use crate::{
consts,
events::connector_api_logs::ConnectorEvent,
types::{api::fraud_check as frm_api, fraud_check as frm_types, ErrorResponse, Response},
utils::BytesExt,
};
fn build_error_response(
&self,
res: Response,
event_builder: Option<&mut ConnectorEvent>,
) -> CustomResult<ErrorResponse, errors::ConnectorError> {
let response: signifyd::SignifydErrorResponse = res
.response
.parse_struct("SignifydErrorResponse")
.change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
event_builder.map(|i| i.set_error_response_body(&response));
router_env::logger::info!(connector_response=?response);
Ok(ErrorResponse {
status_code: res.status_code,
code: consts::NO_ERROR_CODE.to_string(),
message: response.messages.join(" &"),
reason: Some(response.errors.to_string()),
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/router/src/connector/dummyconnector.rs | crate: router
fn get_headers(
&self,
req: &types::PaymentsSyncRouterData,
connectors: &settings::Connectors,
) -> CustomResult<Vec<(String, request::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: &types::PaymentsSyncRouterData,
connectors: &settings::Connectors,
) -> CustomResult<String, errors::ConnectorError> {
match req
.request
.connector_transaction_id
.get_connector_transaction_id()
{
Ok(transaction_id) => Ok(format!(
"{}/payments/{}",
self.base_url(connectors),
fn get_url(
&self,
req: &types::PaymentsSyncRouterData,
connectors: &settings::Connectors,
) -> CustomResult<String, errors::ConnectorError> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
// file: hyperswitch/crates/router/src/connector/dummyconnector.rs | crate: router
use error_stack::{report, ResultExt};
use crate::{
configs::settings,
connector::utils as connector_utils,
core::errors::{self, CustomResult},
events::connector_api_logs::ConnectorEvent,
headers,
services::{
self,
request::{self, Mask},
ConnectorIntegration, ConnectorSpecifications, ConnectorValidation,
},
types::{
self,
api::{self, ConnectorCommon, ConnectorCommonExt},
ErrorResponse, Response,
},
utils::BytesExt,
};
fn get_webhook_object_reference_id(
&self,
_request: &api::IncomingWebhookRequestDetails<'_>,
) -> CustomResult<api::webhooks::ObjectReferenceId, errors::ConnectorError> {
Err(report!(errors::ConnectorError::WebhooksNotImplemented))
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/dummyconnector.rs | crate: router
use common_utils::{consts as common_consts, request::RequestContent};
use crate::{
configs::settings,
connector::utils as connector_utils,
core::errors::{self, CustomResult},
events::connector_api_logs::ConnectorEvent,
headers,
services::{
self,
request::{self, Mask},
ConnectorIntegration, ConnectorSpecifications, ConnectorValidation,
},
types::{
self,
api::{self, ConnectorCommon, ConnectorCommonExt},
ErrorResponse, Response,
},
utils::BytesExt,
};
fn get_url(
&self,
req: &types::RefundSyncRouterData,
connectors: &settings::Connectors,
) -> CustomResult<String, errors::ConnectorError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
// file: hyperswitch/crates/router/src/connector/dummyconnector.rs | crate: router
use crate::{
configs::settings,
connector::utils as connector_utils,
core::errors::{self, CustomResult},
events::connector_api_logs::ConnectorEvent,
headers,
services::{
self,
request::{self, Mask},
ConnectorIntegration, ConnectorSpecifications, ConnectorValidation,
},
types::{
self,
api::{self, ConnectorCommon, ConnectorCommonExt},
ErrorResponse, Response,
},
utils::BytesExt,
};
fn handle_response(
&self,
data: &types::RefundsRouterData<api::Execute>,
event_builder: Option<&mut ConnectorEvent>,
res: Response,
) -> CustomResult<types::RefundsRouterData<api::Execute>, errors::ConnectorError> {
let response: transformers::RefundResponse = res
.response
.parse_struct("transformers RefundResponse")
.change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
event_builder.map(|i| i.set_response_body(&response));
router_env::logger::info!(connector_response=?response);
types::RouterData::try_from(types::ResponseRouterData {
response,
data: data.clone(),
http_code: res.status_code,
})
.change_context(errors::ConnectorError::ResponseHandlingFailed)
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/dummyconnector.rs | crate: router
use common_utils::{consts as common_consts, request::RequestContent};
use crate::{
configs::settings,
connector::utils as connector_utils,
core::errors::{self, CustomResult},
events::connector_api_logs::ConnectorEvent,
headers,
services::{
self,
request::{self, Mask},
ConnectorIntegration, ConnectorSpecifications, ConnectorValidation,
},
types::{
self,
api::{self, ConnectorCommon, ConnectorCommonExt},
ErrorResponse, Response,
},
utils::BytesExt,
};
fn get_url(
&self,
req: &types::RefundsRouterData<api::Execute>,
connectors: &settings::Connectors,
) -> CustomResult<String, errors::ConnectorError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/dummyconnector.rs | crate: router
use common_utils::{consts as common_consts, request::RequestContent};
use error_stack::{report, ResultExt};
use crate::{
configs::settings,
connector::utils as connector_utils,
core::errors::{self, CustomResult},
events::connector_api_logs::ConnectorEvent,
headers,
services::{
self,
request::{self, Mask},
ConnectorIntegration, ConnectorSpecifications, ConnectorValidation,
},
types::{
self,
api::{self, ConnectorCommon, ConnectorCommonExt},
ErrorResponse, Response,
},
utils::BytesExt,
};
fn get_url(
&self,
req: &types::PaymentsSyncRouterData,
connectors: &settings::Connectors,
) -> CustomResult<String, errors::ConnectorError> {
{
Ok(transaction_id) => Ok(format!(
"{}/payments/{}",
self.base_url(connectors),
transaction_id
)),<|fim_suffix|>
<|fim_middle|>
Err(_) => Err(error_stack::report!(
errors::ConnectorError::MissingConnectorTransactionID
)),
}
} | ast_fragments |
// file: hyperswitch/crates/router/src/connector/dummyconnector.rs | crate: router
use common_utils::{consts as common_consts, request::RequestContent};
use crate::{
configs::settings,
connector::utils as connector_utils,
core::errors::{self, CustomResult},
events::connector_api_logs::ConnectorEvent,
headers,
services::{
self,
request::{self, Mask},
ConnectorIntegration, ConnectorSpecifications, ConnectorValidation,
},
types::{
self,
api::{self, ConnectorCommon, ConnectorCommonExt},
ErrorResponse, Response,
},
utils::BytesExt,
};
fn get_request_body(
&self,
req: &types::PaymentsAuthorizeRouterData,
_connectors: &settings::Connectors,
) -> CustomResult<RequestContent, errors::ConnectorError> {
let connector_req = transformers::DummyConnectorPaymentsRequest::<T>::try_from(req)?;
Ok(RequestContent::Json(Box::new(connector_req)))
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/dummyconnector.rs | crate: router
use diesel_models::enums;
use error_stack::{report, ResultExt};
use crate::{
configs::settings,
connector::utils as connector_utils,
core::errors::{self, CustomResult},
events::connector_api_logs::ConnectorEvent,
headers,
services::{
self,
request::{self, Mask},
ConnectorIntegration, ConnectorSpecifications, ConnectorValidation,
},
types::{
self,
api::{self, ConnectorCommon, ConnectorCommonExt},
ErrorResponse, Response,
},
utils::BytesExt,
};
fn get_url(
&self,
req: &types::PaymentsAuthorizeRouterData,
connectors: &settings::Connectors,
) -> CustomResult<String, errors::ConnectorError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
// file: hyperswitch/crates/router/src/connector/payone.rs | crate: router
use router_env::{instrument, tracing};
use self::transformers as payone;
use crate::{
configs::settings,
connector::{
utils as connector_utils,
utils::{ConnectorErrorType, ConnectorErrorTypeMapping},
},
consts,
core::errors::{self, CustomResult},
events::connector_api_logs::ConnectorEvent,
headers,
services::{
request::{self, Mask},
ConnectorIntegration, ConnectorSpecifications, ConnectorValidation,
},
types::{
self,
api::{self, ConnectorCommon, ConnectorCommonExt},
ErrorResponse, Response,
},
utils::BytesExt,
};
fn build_error_response(
&self,
res: Response,
event_builder: Option<&mut ConnectorEvent>,
) -> CustomResult<ErrorResponse, errors::ConnectorError> {
let response: payone::ErrorResponse = res
.response
.parse_struct("ErrorResponse")
.change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
event_builder.map(|i| i.set_response_body(&response));
router_env::logger::info!(connector_response=?response);
let errors_list = response.errors.clone().unwrap_or_default();
let option_error_code_message =
connector_utils::get_error_code_error_message_based_on_priority(
self.clone(),
errors_list
.into_iter()
.map(|errors| errors.into())
.collect(),
);
match response.errors {
Some(errors) => Ok(ErrorResponse {
status_code: res.status_code,
code: option_error_code_message
.clone()
.map(|error_code_message| error_code_message.error_code)
.unwrap_or(consts::NO_ERROR_CODE.to_string()),
message: option_error_code_message
.clone()
.map(|error_code_message| error_code_message.error_code)
.unwrap_or(consts::NO_ERROR_CODE.to_string()),
reason: Some(
errors
.iter()
.map(|error| format!("{} : {}", error.code, error.message))
.collect::<Vec<String>>()
.join(", "),
),
attempt_status: None,
connector_transaction_id: None,
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
}),
None => Ok(ErrorResponse {
status_code: res.status_code,
code: consts::NO_ERROR_CODE.to_string(),
message: consts::NO_ERROR_MESSAGE.to_string(),
reason: None,
attempt_status: None,
connector_transaction_id: None,
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
}),
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/payone.rs | crate: router
use common_utils::request::RequestContent;
use common_utils::types::{AmountConvertor, MinorUnit, MinorUnitForConnector};
use self::transformers as payone;
use crate::get_formatted_date_time;
use crate::{
configs::settings,
connector::{
utils as connector_utils,
utils::{ConnectorErrorType, ConnectorErrorTypeMapping},
},
consts,
core::errors::{self, CustomResult},
events::connector_api_logs::ConnectorEvent,
headers,
services::{
request::{self, Mask},
ConnectorIntegration, ConnectorSpecifications, ConnectorValidation,
},
types::{
self,
api::{self, ConnectorCommon, ConnectorCommonExt},
ErrorResponse, Response,
},
utils::BytesExt,
};
fn build_headers(
&self,
req: &types::RouterData<Flow, Request, Response>,
connectors: &settings::Connectors,
) -> CustomResult<Vec<(String, request::Maskable<String>)>, errors::ConnectorError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/payone.rs | crate: router
use ring::hmac;
use self::transformers as payone;
use crate::{
configs::settings,
connector::{
utils as connector_utils,
utils::{ConnectorErrorType, ConnectorErrorTypeMapping},
},
consts,
core::errors::{self, CustomResult},
events::connector_api_logs::ConnectorEvent,
headers,
services::{
request::{self, Mask},
ConnectorIntegration, ConnectorSpecifications, ConnectorValidation,
},
types::{
self,
api::{self, ConnectorCommon, ConnectorCommonExt},
ErrorResponse, Response,
},
utils::BytesExt,
};
pub fn generate_signature(
&self,
auth: payone::PayoneAuthType,
http_method: String,
canonicalized_path: String,
content_type: String,
date_header: String,
) -> CustomResult<String, errors::ConnectorError> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/payone.rs | crate: router
Err(report!(errors::ConnectorError::WebhooksNotImplemented))
}
fn get_webhook_resource_object(
&self,
_request: &api::IncomingWebhookRequestDetails<'_>,
) -> CustomResult<Box<dyn masking::ErasedMaskSerialize>, errors::ConnectorError> {
Err(report!(errors::ConnectorError::WebhooksNotImplemented))
}
}
impl ConnectorErrorTypeMapping for Payone {
fn get_connector_error_type(
&self,
error_code: String,
_error_message: String,
) -> ConnectorErrorType {
match error_code.as_str() {
"30001101" => ConnectorErrorType::BusinessError,
"30001100" => ConnectorErrorType::BusinessError,
"30001102" => ConnectorErrorType::BusinessError,
"30001104" => ConnectorErrorType::BusinessError,
"30001105" => ConnectorErrorType::BusinessError,
"30001106" => ConnectorErrorType::TechnicalError,
"30001120" => ConnectorErrorType::BusinessError,
fn get_connector_error_type(
&self,
error_code: String,
_error_message: String,
) -> ConnectorErrorType {
{
"30001101" => ConnectorErrorType::BusinessError,<|fim_suffix|>
<|fim_middle|>
_ => ConnectorErrorType::UnknownError,
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/payone.rs | crate: router
use common_utils::types::{AmountConvertor, MinorUnit, MinorUnitForConnector};
use router_env::{instrument, tracing};
use self::transformers as payone;
use crate::{
configs::settings,
connector::{
utils as connector_utils,
utils::{ConnectorErrorType, ConnectorErrorTypeMapping},
},
consts,
core::errors::{self, CustomResult},
events::connector_api_logs::ConnectorEvent,
headers,
services::{
request::{self, Mask},
ConnectorIntegration, ConnectorSpecifications, ConnectorValidation,
},
types::{
self,
api::{self, ConnectorCommon, ConnectorCommonExt},
ErrorResponse, Response,
},
utils::BytesExt,
};
fn handle_response(
&self,
data: &types::PayoutsRouterData<api::PoFulfill>,
event_builder: Option<&mut ConnectorEvent>,
res: Response,
) -> CustomResult<types::PayoutsRouterData<api::PoFulfill>, errors::ConnectorError> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/payone.rs | crate: router
use common_utils::request::RequestContent;
use common_utils::types::{AmountConvertor, MinorUnit, MinorUnitForConnector};
use self::transformers as payone;
use crate::services;
use crate::{
configs::settings,
connector::{
utils as connector_utils,
utils::{ConnectorErrorType, ConnectorErrorTypeMapping},
},
consts,
core::errors::{self, CustomResult},
events::connector_api_logs::ConnectorEvent,
headers,
services::{
request::{self, Mask},
ConnectorIntegration, ConnectorSpecifications, ConnectorValidation,
},
types::{
self,
api::{self, ConnectorCommon, ConnectorCommonExt},
ErrorResponse, Response,
},
utils::BytesExt,
};
fn build_request(
&self,
req: &types::PayoutsRouterData<api::PoFulfill>,
connectors: &settings::Connectors,
) -> CustomResult<Option<services::Request>, errors::ConnectorError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/payone.rs | crate: router
use common_utils::types::{AmountConvertor, MinorUnit, MinorUnitForConnector};
use self::transformers as payone;
use crate::{
configs::settings,
connector::{
utils as connector_utils,
utils::{ConnectorErrorType, ConnectorErrorTypeMapping},
},
consts,
core::errors::{self, CustomResult},
events::connector_api_logs::ConnectorEvent,
headers,
services::{
request::{self, Mask},
ConnectorIntegration, ConnectorSpecifications, ConnectorValidation,
},
types::{
self,
api::{self, ConnectorCommon, ConnectorCommonExt},
ErrorResponse, Response,
},
utils::BytesExt,
};
fn get_url(
&self,
req: &types::PayoutsRouterData<api::PoFulfill>,
_connectors: &settings::Connectors,
) -> CustomResult<String, errors::ConnectorError> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
// file: hyperswitch/crates/router/src/connector/payone.rs | crate: router
use self::transformers as payone;
use crate::{
configs::settings,
connector::{
utils as connector_utils,
utils::{ConnectorErrorType, ConnectorErrorTypeMapping},
},
consts,
core::errors::{self, CustomResult},
events::connector_api_logs::ConnectorEvent,
headers,
services::{
request::{self, Mask},
ConnectorIntegration, ConnectorSpecifications, ConnectorValidation,
},
types::{
self,
api::{self, ConnectorCommon, ConnectorCommonExt},
ErrorResponse, Response,
},
utils::BytesExt,
};
fn base_url<'a>(&self, connectors: &'a settings::Connectors) -> &'a str {
connectors.payone.base_url.as_ref()
} | ast_fragments |
// file: hyperswitch/crates/router/src/connector/payone.rs | crate: router
use self::transformers as payone;
use crate::{
configs::settings,
connector::{
utils as connector_utils,
utils::{ConnectorErrorType, ConnectorErrorTypeMapping},
},
consts,
core::errors::{self, CustomResult},
events::connector_api_logs::ConnectorEvent,
headers,
services::{
request::{self, Mask},
ConnectorIntegration, ConnectorSpecifications, ConnectorValidation,
},
types::{
self,
api::{self, ConnectorCommon, ConnectorCommonExt},
ErrorResponse, Response,
},
utils::BytesExt,
};
fn id(&self) -> &'static str {
"payone"
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/riskified.rs | crate: router
use common_utils::types::{
AmountConvertor, MinorUnit, StringMajorUnit, StringMajorUnitForConnector,
};
use common_utils::{crypto, ext_traits::ByteSliceExt, request::RequestContent};
use masking::{ExposeInterface, PeekInterface, Secret};
use ring::hmac;
use super::utils::{self as connector_utils, FrmTransactionRouterDataRequest};
use crate::{
configs::settings,
core::errors::{self, CustomResult},
services::{self, ConnectorIntegration, ConnectorSpecifications, ConnectorValidation},
types::{
self,
api::{self, ConnectorCommon, ConnectorCommonExt},
},
};
use crate::{
consts,
events::connector_api_logs::ConnectorEvent,
headers,
services::request,
types::{api::fraud_check as frm_api, fraud_check as frm_types, ErrorResponse, Response},
utils::BytesExt,
};
async fn verify_webhook_source(
&self,
request: &api::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_label: &str,
) -> CustomResult<bool, errors::ConnectorError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/riskified.rs | crate: router
)?)
.attach_default_headers()
.headers(frm_types::FrmTransactionType::get_headers(
self, req, connectors,
)?)
.set_body(frm_types::FrmTransactionType::get_request_body(
self, req, connectors,
)?)
.build(),
))
}
fn handle_response(
&self,
data: &frm_types::FrmTransactionRouterData,
event_builder: Option<&mut ConnectorEvent>,
res: Response,
) -> CustomResult<frm_types::FrmTransactionRouterData, errors::ConnectorError> {
let response: riskified::RiskifiedTransactionResponse = res
.response
.parse_struct("RiskifiedPaymentsResponse Transaction")
.change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
event_builder.map(|i| i.set_response_body(&response));
router_env::logger::info!(connector_response=?response);
fn handle_response(
&self,
data: &frm_types::FrmTransactionRouterData,
event_builder: Option<&mut ConnectorEvent>,
res: Response,
) -> CustomResult<frm_types::FrmTransactionRouterData, errors::ConnectorError> {
{
riskified::RiskifiedTransactionResponse::FailedResponse(response_data) => {
<frm_types::FrmTransactionRouterData>::try_from(types::ResponseRouterData {
response: response_data,
data: data.clone(),
http_code: res.status_code,
})
}<|fim_suffix|>
<|fim_middle|>
riskified::RiskifiedTransactionResponse::SuccessResponse(response_data) => {
<frm_types::FrmTransactionRouterData>::try_from(types::ResponseRouterData {
response: response_data,
data: data.clone(),
http_code: res.status_code,
})
}
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/riskified.rs | crate: router
use super::utils::{self as connector_utils, FrmTransactionRouterDataRequest};
use crate::{
configs::settings,
core::errors::{self, CustomResult},
services::{self, ConnectorIntegration, ConnectorSpecifications, ConnectorValidation},
types::{
self,
api::{self, ConnectorCommon, ConnectorCommonExt},
},
};
use crate::{
consts,
events::connector_api_logs::ConnectorEvent,
headers,
services::request,
types::{api::fraud_check as frm_api, fraud_check as frm_types, ErrorResponse, Response},
utils::BytesExt,
};
fn get_url(
&self,
req: &frm_types::FrmTransactionRouterData,
connectors: &settings::Connectors,
) -> CustomResult<String, errors::ConnectorError> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
// file: hyperswitch/crates/router/src/connector/riskified.rs | crate: router
use common_utils::types::{
AmountConvertor, MinorUnit, StringMajorUnit, StringMajorUnitForConnector,
};
use common_utils::{crypto, ext_traits::ByteSliceExt, request::RequestContent};
use super::utils::{self as connector_utils, FrmTransactionRouterDataRequest};
use crate::{
configs::settings,
core::errors::{self, CustomResult},
services::{self, ConnectorIntegration, ConnectorSpecifications, ConnectorValidation},
types::{
self,
api::{self, ConnectorCommon, ConnectorCommonExt},
},
};
use crate::{
consts,
events::connector_api_logs::ConnectorEvent,
headers,
services::request,
types::{api::fraud_check as frm_api, fraud_check as frm_types, ErrorResponse, Response},
utils::BytesExt,
};
fn get_webhook_source_verification_message(
&self,
request: &api::IncomingWebhookRequestDetails<'_>,
_merchant_id: &common_utils::id_type::MerchantId,
_connector_webhook_secrets: &api_models::webhooks::ConnectorWebhookSecrets,
) -> CustomResult<Vec<u8>, errors::ConnectorError> {
Ok(request.body.to_vec())
} | ast_fragments |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.