text stringlengths 70 351k | source stringclasses 4 values |
|---|---|
// file: hyperswitch/crates/router/tests/connectors/elavon.rs | crate: router | connector: elavon
use masking::Secret;
use router::types::{self, api, storage::enums};
use crate::utils::{self, ConnectorActions};
fn get_data(&self) -> api::ConnectorData {
use router::connector::Elavon;
utils::construct_connector_data_old(
Box::new(Elavon::new()),
types::Connector::Plaid,
api::GetToken::Connector,
None,
)
// api::ConnectorData {
// connector: Box::new(Elavon::new()),
// connector_name: types::Connector::Elavon,
// get_token: types::api::GetToken::Connector,
// merchant_connector_id: None,
// }
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/tests/connectors/authorizedotnet.rs | crate: router | connector: authorizedotnet
use router::types::{self, domain, storage::enums};
async fn should_fail_payment_for_empty_card_number() {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/tests/connectors/authorizedotnet.rs | crate: router | connector: authorizedotnet
use masking::Secret;
use router::types::{self, domain, storage::enums};
fn get_payment_method_data() -> domain::Card {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
// file: hyperswitch/crates/router/tests/connectors/payeezy.rs | crate: router | connector: payeezy | op: capture
use router::{
core::errors,
types::{self, storage::enums, PaymentsAuthorizeData},
};
async fn should_refund_manually_captured_payment() {
let authorize_response = CONNECTOR
.authorize_payment(
PayeezyTest::get_payment_data(),
PayeezyTest::get_payment_info(),
)
.await
.expect("Authorize payment response");
let txn_id = utils::get_connector_transaction_id(authorize_response.response.clone()).unwrap();
let capture_connector_meta = utils::get_connector_metadata(authorize_response.response);
let capture_response = CONNECTOR
.capture_payment(
txn_id.clone(),
Some(types::PaymentsCaptureData {
connector_meta: capture_connector_meta,
..utils::PaymentCaptureType::default().0
}),
PayeezyTest::get_payment_info(),
)
.await
.expect("Capture payment response");
let capture_txn_id =
utils::get_connector_transaction_id(capture_response.response.clone()).unwrap();
let refund_connector_metadata = utils::get_connector_metadata(capture_response.response);
let response = CONNECTOR
.refund_payment(
capture_txn_id.clone(),
Some(types::RefundsData {
connector_transaction_id: capture_txn_id,
connector_metadata: refund_connector_metadata,
..utils::PaymentRefundType::default().0
}),
PayeezyTest::get_payment_info(),
)
.await
.unwrap();
assert_eq!(
response.response.unwrap().refund_status,
enums::RefundStatus::Success,
);
} | ast_fragments |
// file: hyperswitch/crates/router/tests/connectors/payeezy.rs | crate: router | connector: payeezy | op: refund
use router::{
core::errors,
types::{self, storage::enums, PaymentsAuthorizeData},
};
async fn should_fail_for_refund_amount_higher_than_payment_amount() {
let captured_response = CONNECTOR.make_payment(None, None).await.unwrap();
assert_eq!(captured_response.status, enums::AttemptStatus::Charged);
let txn_id = utils::get_connector_transaction_id(captured_response.response.clone());
let connector_meta = utils::get_connector_metadata(captured_response.response);
let response = CONNECTOR
.refund_payment(
txn_id.clone().unwrap(),
Some(types::RefundsData {
refund_amount: 1500,
connector_transaction_id: txn_id.unwrap(),
connector_metadata: connector_meta,
..utils::PaymentRefundType::default().0
}),
PayeezyTest::get_payment_info(),
)
.await
.unwrap();
assert_eq!(
response.response.unwrap_err().message,
String::from("Bad Request (64) - Invalid Refund"),
);
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/tests/connectors/payeezy.rs | crate: router | connector: payeezy
use router::{
core::errors,
types::{self, storage::enums, PaymentsAuthorizeData},
};
fn get_request_interval(self) -> u64 {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/tests/connectors/payeezy.rs | crate: router | connector: payeezy
use router::{
core::errors,
types::{self, storage::enums, PaymentsAuthorizeData},
};
fn get_payment_data() -> Option<PaymentsAuthorizeData> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
// file: hyperswitch/crates/router/tests/connectors/wise.rs | crate: router | connector: wise | op: payout
use hyperswitch_domain_models::address::{Address, AddressDetails};
use masking::Secret;
use router::{
types,
types::{api, storage::enums, PaymentAddress},
};
fn get_payout_info() -> Option<PaymentInfo> {
Some(PaymentInfo {
currency: Some(enums::Currency::GBP),
address: Some(PaymentAddress::new(
None,
Some(Address {
address: Some(AddressDetails {
country: Some(api_models::enums::CountryAlpha2::GB),
city: Some("London".to_string()),
zip: Some(Secret::new("10025".to_string())),
line1: Some(Secret::new("50 Branson Ave".to_string())),
..Default::default()
}),
phone: None,
email: None,
}),
None,
None,
)),
payout_method_data: Some(api::PayoutMethodData::Bank(api::payouts::BankPayout::Bacs(
api::BacsBankTransfer {
bank_sort_code: "231470".to_string().into(),
bank_account_number: "28821822".to_string().into(),
bank_name: Some("Deutsche Bank".to_string()),
bank_country_code: Some(enums::CountryAlpha2::NL),
bank_city: Some("Amsterdam".to_string()),
},
))),
..Default::default()
})
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/tests/connectors/wise.rs | crate: router | connector: wise | op: payout
use router::{
types,
types::{api, storage::enums, PaymentAddress},
};
async fn should_create_bacs_payout() {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/tests/connectors/wise.rs | crate: router | connector: wise | op: payout
use masking::Secret;
use router::{
types,
types::{api, storage::enums, PaymentAddress},
};
use crate::{
connector_auth,
utils::{self, ConnectorActions, PaymentInfo},
};
fn get_payout_data(&self) -> Option<api::ConnectorData> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/tests/connectors/trustpay.rs | crate: router | connector: trustpay
use router::types::{self, api, domain, storage::enums, BrowserInformation};
fn get_default_browser_info() -> BrowserInformation {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
// file: hyperswitch/crates/router/tests/connectors/nexixpay.rs | crate: router | connector: nexixpay
use hyperswitch_domain_models::payment_method_data::{Card, PaymentMethodData};
use masking::Secret;
use router::types::{self, api, storage::enums};
async fn should_fail_payment_for_invalid_exp_month() {
let response = CONNECTOR
.make_payment(
Some(types::PaymentsAuthorizeData {
payment_method_data: PaymentMethodData::Card(Card {
card_exp_month: Secret::new("20".to_string()),
..utils::CCardType::default().0
}),
..utils::PaymentAuthorizeType::default().0
}),
get_default_payment_info(),
)
.await
.unwrap();
assert_eq!(
response.response.unwrap_err().message,
"Your card's expiration month is invalid.".to_string(),
);
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/cors.rs | crate: router
use crate::configs::settings;
pub fn cors(config: settings::CorsSettings) -> actix_cors::Cors {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/db.rs | crate: router
use common_utils::id_type;
use diesel_models::{
fraud_check::{FraudCheck, FraudCheckUpdate},
organization::{Organization, OrganizationNew, OrganizationUpdate},
};
use storage_impl::{errors::StorageError, redis::kv_store::RedisConnInterface, MockDb};
pub use self::kafka_store::KafkaStore;
use self::{fraud_check::FraudCheckInterface, organization::OrganizationInterface};
pub use crate::{
core::errors::{self, ProcessTrackerError},
errors::CustomResult,
services::{
kafka::{KafkaError, KafkaProducer, MQResult},
Store,
},
types::{
domain,
storage::{self},
AccessToken,
},
};
async fn update_organization_by_org_id(
&self,
org_id: &id_type::OrganizationId,
update: OrganizationUpdate,
) -> CustomResult<Organization, StorageError> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/db.rs | crate: router
use common_utils::id_type;
use diesel_models::{
fraud_check::{FraudCheck, FraudCheckUpdate},
organization::{Organization, OrganizationNew, OrganizationUpdate},
};
use storage_impl::{errors::StorageError, redis::kv_store::RedisConnInterface, MockDb};
pub use self::kafka_store::KafkaStore;
use self::{fraud_check::FraudCheckInterface, organization::OrganizationInterface};
pub use crate::{
core::errors::{self, ProcessTrackerError},
errors::CustomResult,
services::{
kafka::{KafkaError, KafkaProducer, MQResult},
Store,
},
types::{
domain,
storage::{self},
AccessToken,
},
};
async fn find_organization_by_org_id(
&self,
org_id: &id_type::OrganizationId,
) -> CustomResult<Organization, StorageError> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/db.rs | crate: router
use diesel_models::{
fraud_check::{FraudCheck, FraudCheckUpdate},
organization::{Organization, OrganizationNew, OrganizationUpdate},
};
use storage_impl::{errors::StorageError, redis::kv_store::RedisConnInterface, MockDb};
pub use self::kafka_store::KafkaStore;
use self::{fraud_check::FraudCheckInterface, organization::OrganizationInterface};
pub use crate::{
core::errors::{self, ProcessTrackerError},
errors::CustomResult,
services::{
kafka::{KafkaError, KafkaProducer, MQResult},
Store,
},
types::{
domain,
storage::{self},
AccessToken,
},
};
async fn insert_organization(
&self,
organization: OrganizationNew,
) -> CustomResult<Organization, StorageError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/db.rs | crate: router
use common_utils::id_type;
use diesel_models::{
fraud_check::{FraudCheck, FraudCheckUpdate},
organization::{Organization, OrganizationNew, OrganizationUpdate},
};
use router_env::logger;
use storage_impl::{errors::StorageError, redis::kv_store::RedisConnInterface, MockDb};
pub use self::kafka_store::KafkaStore;
use self::{fraud_check::FraudCheckInterface, organization::OrganizationInterface};
pub use crate::{
core::errors::{self, ProcessTrackerError},
errors::CustomResult,
services::{
kafka::{KafkaError, KafkaProducer, MQResult},
Store,
},
types::{
domain,
storage::{self},
AccessToken,
},
};
async fn find_fraud_check_by_payment_id_if_present(
&self,
payment_id: id_type::PaymentId,
merchant_id: id_type::MerchantId,
) -> CustomResult<Option<FraudCheck>, StorageError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/db.rs | crate: router
use common_utils::id_type;
use diesel_models::{
fraud_check::{FraudCheck, FraudCheckUpdate},
organization::{Organization, OrganizationNew, OrganizationUpdate},
};
use router_env::logger;
use storage_impl::{errors::StorageError, redis::kv_store::RedisConnInterface, MockDb};
pub use self::kafka_store::KafkaStore;
use self::{fraud_check::FraudCheckInterface, organization::OrganizationInterface};
pub use crate::{
core::errors::{self, ProcessTrackerError},
errors::CustomResult,
services::{
kafka::{KafkaError, KafkaProducer, MQResult},
Store,
},
types::{
domain,
storage::{self},
AccessToken,
},
};
async fn find_fraud_check_by_payment_id(
&self,
payment_id: id_type::PaymentId,
merchant_id: id_type::MerchantId,
) -> CustomResult<FraudCheck, StorageError> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/db.rs | crate: router
use diesel_models::{
fraud_check::{FraudCheck, FraudCheckUpdate},
organization::{Organization, OrganizationNew, OrganizationUpdate},
};
use router_env::logger;
use storage_impl::{errors::StorageError, redis::kv_store::RedisConnInterface, MockDb};
pub use self::kafka_store::KafkaStore;
use self::{fraud_check::FraudCheckInterface, organization::OrganizationInterface};
pub use crate::{
core::errors::{self, ProcessTrackerError},
errors::CustomResult,
services::{
kafka::{KafkaError, KafkaProducer, MQResult},
Store,
},
types::{
domain,
storage::{self},
AccessToken,
},
};
async fn update_fraud_check_response_with_attempt_id(
&self,
this: FraudCheck,
fraud_check: FraudCheckUpdate,
) -> CustomResult<FraudCheck, StorageError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/db.rs | crate: router
use diesel_models::{
fraud_check::{FraudCheck, FraudCheckUpdate},
organization::{Organization, OrganizationNew, OrganizationUpdate},
};
use router_env::logger;
use storage_impl::{errors::StorageError, redis::kv_store::RedisConnInterface, MockDb};
pub use self::kafka_store::KafkaStore;
use self::{fraud_check::FraudCheckInterface, organization::OrganizationInterface};
pub use crate::{
core::errors::{self, ProcessTrackerError},
errors::CustomResult,
services::{
kafka::{KafkaError, KafkaProducer, MQResult},
Store,
},
types::{
domain,
storage::{self},
AccessToken,
},
};
async fn insert_fraud_check_response(
&self,
new: storage::FraudCheckNew,
) -> CustomResult<FraudCheck, StorageError> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
// file: hyperswitch/crates/router/src/db.rs | crate: router
pub use self::kafka_store::KafkaStore;
use self::{fraud_check::FraudCheckInterface, organization::OrganizationInterface};
pub use crate::{
core::errors::{self, ProcessTrackerError},
errors::CustomResult,
services::{
kafka::{KafkaError, KafkaProducer, MQResult},
Store,
},
types::{
domain,
storage::{self},
AccessToken,
},
};
fn add_request_id(&mut self, request_id: String) {
self.diesel_store.add_request_id(request_id)
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/db.rs | crate: router
use ::payment_methods::state::PaymentMethodsStorageInterface;
use common_utils::id_type;
use diesel_models::{
fraud_check::{FraudCheck, FraudCheckUpdate},
organization::{Organization, OrganizationNew, OrganizationUpdate},
};
use error_stack::ResultExt;
use hyperswitch_domain_models::payouts::{
payout_attempt::PayoutAttemptInterface, payouts::PayoutsInterface,
};
use hyperswitch_domain_models::{
payment_methods::PaymentMethodInterface,
payments::{payment_attempt::PaymentAttemptInterface, payment_intent::PaymentIntentInterface},
};
use hyperswitch_domain_models::{PayoutAttemptInterface, PayoutsInterface};
use masking::PeekInterface;
use redis_interface::errors::RedisError;
use router_env::logger;
use storage_impl::{errors::StorageError, redis::kv_store::RedisConnInterface, MockDb};
pub use self::kafka_store::KafkaStore;
use self::{fraud_check::FraudCheckInterface, organization::OrganizationInterface};
pub use crate::{
core::errors::{self, ProcessTrackerError},
errors::CustomResult,
services::{
kafka::{KafkaError, KafkaProducer, MQResult},
Store,
},
types::{
domain,
storage::{self},
AccessToken,
},
};
pub async fn get_and_deserialize_key<T>(
db: &dyn StorageInterface,
key: &str,
type_name: &'static str,
) -> CustomResult<T, RedisError>
where
T: serde::de::DeserializeOwned,
{
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/db.rs | crate: router
pub use self::kafka_store::KafkaStore;
use self::{fraud_check::FraudCheckInterface, organization::OrganizationInterface};
pub use crate::{
core::errors::{self, ProcessTrackerError},
errors::CustomResult,
services::{
kafka::{KafkaError, KafkaProducer, MQResult},
Store,
},
types::{
domain,
storage::{self},
AccessToken,
},
};
fn get_request_id(&self) -> Option<String> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/db.rs | crate: router
pub use self::kafka_store::KafkaStore;
use self::{fraud_check::FraudCheckInterface, organization::OrganizationInterface};
pub use crate::{
core::errors::{self, ProcessTrackerError},
errors::CustomResult,
services::{
kafka::{KafkaError, KafkaProducer, MQResult},
Store,
},
types::{
domain,
storage::{self},
AccessToken,
},
};
fn add_request_id(&mut self, request_id: String) {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/db.rs | crate: router
pub use self::kafka_store::KafkaStore;
use self::{fraud_check::FraudCheckInterface, organization::OrganizationInterface};
pub use crate::{
core::errors::{self, ProcessTrackerError},
errors::CustomResult,
services::{
kafka::{KafkaError, KafkaProducer, MQResult},
Store,
},
types::{
domain,
storage::{self},
AccessToken,
},
};
fn add_request_id(&mut self, _request_id: String) {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/db.rs | crate: router
pub use self::kafka_store::KafkaStore;
use self::{fraud_check::FraudCheckInterface, organization::OrganizationInterface};
pub use crate::{
core::errors::{self, ProcessTrackerError},
errors::CustomResult,
services::{
kafka::{KafkaError, KafkaProducer, MQResult},
Store,
},
types::{
domain,
storage::{self},
AccessToken,
},
};
fn get_accounts_storage_interface(&self) -> Box<dyn AccountsStorageInterface> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/db.rs | crate: router
pub use self::kafka_store::KafkaStore;
use self::{fraud_check::FraudCheckInterface, organization::OrganizationInterface};
pub use crate::{
core::errors::{self, ProcessTrackerError},
errors::CustomResult,
services::{
kafka::{KafkaError, KafkaProducer, MQResult},
Store,
},
types::{
domain,
storage::{self},
AccessToken,
},
};
fn get_storage_interface(&self) -> Box<dyn StorageInterface> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
// file: hyperswitch/crates/router/src/db.rs | crate: router
use storage_impl::{errors::StorageError, redis::kv_store::RedisConnInterface, MockDb};
pub use self::kafka_store::KafkaStore;
use self::{fraud_check::FraudCheckInterface, organization::OrganizationInterface};
pub use crate::{
core::errors::{self, ProcessTrackerError},
errors::CustomResult,
services::{
kafka::{KafkaError, KafkaProducer, MQResult},
Store,
},
types::{
domain,
storage::{self},
AccessToken,
},
};
fn get_cache_store(&self) -> Box<(dyn RedisConnInterface + Send + Sync + 'static)> {
Box::new(self.clone())
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/db.rs | crate: router
pub use self::kafka_store::KafkaStore;
use self::{fraud_check::FraudCheckInterface, organization::OrganizationInterface};
pub use crate::{
core::errors::{self, ProcessTrackerError},
errors::CustomResult,
services::{
kafka::{KafkaError, KafkaProducer, MQResult},
Store,
},
types::{
domain,
storage::{self},
AccessToken,
},
};
fn get_scheduler_db(&self) -> Box<dyn scheduler::SchedulerInterface> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/db.rs | crate: router
use storage_impl::{errors::StorageError, redis::kv_store::RedisConnInterface, MockDb};
pub use self::kafka_store::KafkaStore;
use self::{fraud_check::FraudCheckInterface, organization::OrganizationInterface};
pub use crate::{
core::errors::{self, ProcessTrackerError},
errors::CustomResult,
services::{
kafka::{KafkaError, KafkaProducer, MQResult},
Store,
},
types::{
domain,
storage::{self},
AccessToken,
},
};
fn get_cache_store(&self) -> Box<(dyn RedisConnInterface + Send + Sync + 'static)> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/db.rs | crate: router
pub use self::kafka_store::KafkaStore;
use self::{fraud_check::FraudCheckInterface, organization::OrganizationInterface};
pub use crate::{
core::errors::{self, ProcessTrackerError},
errors::CustomResult,
services::{
kafka::{KafkaError, KafkaProducer, MQResult},
Store,
},
types::{
domain,
storage::{self},
AccessToken,
},
};
fn get_master_key(&self) -> &[u8] {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/analytics_validator.rs | crate: router
use analytics::errors::AnalyticsError;
use api_models::analytics::AnalyticsRequest;
use common_utils::errors::CustomResult;
use currency_conversion::types::ExchangeRates;
use router_env::logger;
use crate::core::currency::get_forex_exchange_rates;
pub async fn request_validator(
req_type: AnalyticsRequest,
state: &crate::routes::SessionState,
) -> CustomResult<Option<ExchangeRates>, AnalyticsError> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connection.rs | crate: router
use bb8::PooledConnection;
use diesel::PgConnection;
use storage_impl::errors as storage_errors;
use crate::errors;
pub type PgPool = bb8::Pool<async_bb8_diesel::ConnectionManager<PgConnection>>;
pub type PgPooledConn = async_bb8_diesel::Connection<PgConnection>;
pub async fn pg_accounts_connection_write<T: storage_impl::DatabaseStore>(
store: &T,
) -> errors::CustomResult<
PooledConnection<'_, async_bb8_diesel::ConnectionManager<PgConnection>>,
storage_errors::StorageError,
> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connection.rs | crate: router
use bb8::PooledConnection;
use diesel::PgConnection;
use storage_impl::errors as storage_errors;
use crate::errors;
pub type PgPool = bb8::Pool<async_bb8_diesel::ConnectionManager<PgConnection>>;
pub type PgPooledConn = async_bb8_diesel::Connection<PgConnection>;
pub async fn pg_connection_write<T: storage_impl::DatabaseStore>(
store: &T,
) -> errors::CustomResult<
PooledConnection<'_, async_bb8_diesel::ConnectionManager<PgConnection>>,
storage_errors::StorageError,
> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connection.rs | crate: router
use bb8::PooledConnection;
use diesel::PgConnection;
use storage_impl::errors as storage_errors;
use crate::errors;
pub type PgPool = bb8::Pool<async_bb8_diesel::ConnectionManager<PgConnection>>;
pub type PgPooledConn = async_bb8_diesel::Connection<PgConnection>;
pub async fn pg_accounts_connection_read<T: storage_impl::DatabaseStore>(
store: &T,
) -> errors::CustomResult<
PooledConnection<'_, async_bb8_diesel::ConnectionManager<PgConnection>>,
storage_errors::StorageError,
> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connection.rs | crate: router
use bb8::PooledConnection;
use diesel::PgConnection;
use storage_impl::errors as storage_errors;
use crate::errors;
pub type PgPool = bb8::Pool<async_bb8_diesel::ConnectionManager<PgConnection>>;
pub type PgPooledConn = async_bb8_diesel::Connection<PgConnection>;
pub async fn pg_connection_read<T: storage_impl::DatabaseStore>(
store: &T,
) -> errors::CustomResult<
PooledConnection<'_, async_bb8_diesel::ConnectionManager<PgConnection>>,
storage_errors::StorageError,
> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connection.rs | crate: router
use crate::errors;
pub type PgPool = bb8::Pool<async_bb8_diesel::ConnectionManager<PgConnection>>;
pub type PgPooledConn = async_bb8_diesel::Connection<PgConnection>;
pub async fn redis_connection(
conf: &crate::configs::Settings,
) -> redis_interface::RedisConnectionPool {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/compatibility/stripe.rs | crate: router
use actix_web::{web, Scope};
use crate::routes;
pub fn server(state: routes::AppState) -> Scope {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/compatibility/stripe/app.rs | crate: router
use actix_web::{web, Scope};
use crate::routes::{self, mandates, webhooks};
pub fn server(config: routes::AppState) -> Scope {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
// file: hyperswitch/crates/router/src/compatibility/stripe/app.rs | crate: router
use actix_web::{web, Scope};
use super::{payment_intents::*, setup_intents::*};
use crate::routes::{self, mandates, webhooks};
pub fn server(state: routes::AppState) -> Scope {
web::scope("/setup_intents")
.app_data(web::Data::new(state))
.service(web::resource("").route(web::post().to(setup_intents_create)))
.service(
web::resource("/{setup_id}")
.route(web::get().to(setup_intents_retrieve))
.route(web::post().to(setup_intents_update)),
)
.service(
web::resource("/{setup_id}/confirm").route(web::post().to(setup_intents_confirm)),
)
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/compatibility/stripe/customers/types.rs | crate: router
use api_models::payment_methods as api_types;
fn from(item: api_types::CardDetailFromLocker) -> Self {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/compatibility/stripe/customers/types.rs | crate: router
use std::{convert::From, default::Default};
use api_models::payment_methods as api_types;
fn from(item: api_types::CustomerPaymentMethod) -> Self {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/compatibility/stripe/customers/types.rs | crate: router
use std::{convert::From, default::Default};
use crate::types::{api, api::enums as api_enums};
fn from(item: api::CustomerPaymentMethodsListResponse) -> Self {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/compatibility/stripe/customers/types.rs | crate: router
use crate::types::{api, api::enums as api_enums};
fn from(cust: api::CustomerDeleteResponse) -> Self {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/compatibility/stripe/customers/types.rs | crate: router
use common_utils::{crypto::Encryptable, date_time};
use crate::logger;
use crate::types::{api, api::enums as api_enums};
fn from(cust: api::CustomerResponse) -> Self {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/compatibility/stripe/customers/types.rs | crate: router
use std::{convert::From, default::Default};
fn from(req: CustomerUpdateRequest) -> Self {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/compatibility/stripe/customers/types.rs | crate: router
use std::{convert::From, default::Default};
use common_utils::{crypto::Encryptable, date_time};
use common_utils::{
id_type,
pii::{self, Email},
types::Description,
};
fn from(req: CreateCustomerRequest) -> Self {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/compatibility/stripe/customers/types.rs | crate: router
fn from(address: StripeAddressDetails) -> Self {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/types/payment_methods.rs | crate: router
use crate::{
consts,
types::{api, domain, storage},
};
fn get_vaulting_flow_name() -> &'static str {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/types/payment_methods.rs | crate: router
use crate::{
consts,
types::{api, domain, storage},
};
fn get_vaulting_request_url() -> &'static str {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
// file: hyperswitch/crates/router/src/types/payment_methods.rs | crate: router
use crate::{
consts,
types::{api, domain, storage},
};
fn get_vaulting_flow_name() -> &'static str {
consts::VAULT_ADD_FLOW_TYPE
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/types/storage/payment_attempt.rs | crate: router
use common_utils::types::MinorUnit;
use diesel_models::{capture::CaptureNew, enums};
pub use hyperswitch_domain_models::payments::payment_attempt::{
PaymentAttempt, PaymentAttemptUpdate,
};
use crate::{
core::errors, errors::RouterResult, types::transformers::ForeignFrom, utils::OptionExt,
};
async fn test_payment_attempt_insert() {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/types/storage/payment_attempt.rs | crate: router
use common_utils::types::MinorUnit;
use diesel_models::{capture::CaptureNew, enums};
pub use hyperswitch_domain_models::payments::payment_attempt::{
PaymentAttempt, PaymentAttemptUpdate,
};
use crate::{
core::errors, errors::RouterResult, types::transformers::ForeignFrom, utils::OptionExt,
};
fn make_new_capture(
&self,
capture_amount: MinorUnit,
capture_status: enums::CaptureStatus,
) -> RouterResult<CaptureNew> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/types/storage/payment_attempt.rs | crate: router
async fn create_single_connection_test_transaction_pool() -> routes::AppState {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/types/storage/payment_attempt.rs | crate: router
use diesel_models::{capture::CaptureNew, enums};
fn maps_to_intent_status(self, intent_status: enums::IntentStatus) -> bool {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/types/storage/payment_attempt.rs | crate: router
use common_utils::types::MinorUnit;
fn get_total_amount(&self) -> MinorUnit {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/types/storage/payment_attempt.rs | crate: router
pub use hyperswitch_domain_models::payments::payment_attempt::{
PaymentAttempt, PaymentAttemptUpdate,
};
fn get_surcharge_details(&self) -> Option<api_models::payments::RequestSurchargeDetails> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/types/storage/payment_attempt.rs | crate: router
fn get_next_capture_id(&self) -> String {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/types/storage/payment_attempt.rs | crate: router
use common_utils::types::MinorUnit;
use diesel_models::{capture::CaptureNew, enums};
pub use hyperswitch_domain_models::payments::payment_attempt::{
PaymentAttempt, PaymentAttemptUpdate,
};
use crate::{
core::errors, errors::RouterResult, types::transformers::ForeignFrom, utils::OptionExt,
};
/// Example of unit test
/// Kind of test: state-based testing
async fn test_payment_attempt_mandate_field() {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/types/storage/payment_attempt.rs | crate: router
use common_utils::types::MinorUnit;
use diesel_models::{capture::CaptureNew, enums};
pub use hyperswitch_domain_models::payments::payment_attempt::{
PaymentAttempt, PaymentAttemptUpdate,
};
use crate::{
core::errors, errors::RouterResult, types::transformers::ForeignFrom, utils::OptionExt,
};
/// Example of unit test
/// Kind of test: state-based testing
async fn test_find_payment_attempt() {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/types/storage/ephemeral_key.rs | crate: router
pub use diesel_models::ephemeral_key::{ClientSecretType, ClientSecretTypeNew};
pub use diesel_models::ephemeral_key::{EphemeralKey, EphemeralKeyNew};
use crate::db::errors;
use crate::types::transformers::ForeignTryFrom;
fn foreign_try_from(from: ClientSecretType) -> Result<Self, errors::ApiErrorResponse> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/types/api/payment_methods.rs | crate: router
use error_stack::report;
use crate::core::{
errors::{self, RouterResult},
payments::helpers::validate_payment_method_type_against_payment_method,
};
fn validate(&self) -> RouterResult<()> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/types/api/fraud_check.rs | crate: router
use api_models::enums;
use common_utils::errors::CustomResult;
use crate::{connector, core::errors, services::connector_integration_interface::ConnectorEnum};
fn convert_connector(
connector_name: enums::FrmConnectors,
) -> CustomResult<ConnectorEnum, errors::ApiErrorResponse> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/types/api/payment_link.rs | crate: router
use crate::{
consts::DEFAULT_SESSION_EXPIRY,
core::{errors::RouterResult, payment_link},
types::storage::{self},
};
async fn from_db_payment_link(payment_link: storage::PaymentLink) -> RouterResult<Self> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/types/api/customers.rs | crate: router
use api_models::customers;
pub use api_models::customers::{
CustomerDeleteResponse, CustomerListRequest, CustomerRequest, CustomerUpdateRequest,
CustomerUpdateRequestInternal,
};
use crate::{
newtype,
types::{domain, ForeignFrom},
};
fn foreign_from(cust: domain::Customer) -> Self {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/types/api/customers.rs | crate: router
use api_models::customers;
pub use api_models::customers::{
CustomerDeleteResponse, CustomerListRequest, CustomerRequest, CustomerUpdateRequest,
CustomerUpdateRequestInternal,
};
use super::payments;
use crate::{
newtype,
types::{domain, ForeignFrom},
};
fn foreign_from((cust, address): (domain::Customer, Option<payments::AddressDetails>)) -> Self {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/types/api/mandates.rs | crate: router
use api_models::mandates;
pub use api_models::mandates::{MandateId, MandateResponse, MandateRevokedResponse};
use crate::{
core::{
errors::{self, RouterResult, StorageErrorExt},
payment_methods,
},
newtype,
routes::SessionState,
types::{
api, domain,
storage::{self, enums as storage_enums},
},
};
fn from(card_details_from_locker: api::payment_methods::CardDetailFromLocker) -> Self {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/types/api/mandates.rs | crate: router
use crate::{
core::{
errors::{self, RouterResult, StorageErrorExt},
payment_methods,
},
newtype,
routes::SessionState,
types::{
api, domain,
storage::{self, enums as storage_enums},
},
};
async fn from_db_mandate(
state: &SessionState,
key_store: domain::MerchantKeyStore,
mandate: storage::Mandate,
storage_scheme: storage_enums::MerchantStorageScheme,
) -> RouterResult<Self> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/types/domain/types.rs | crate: router
fn from(state: &crate::SessionState) -> Self {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/types/domain/address.rs | crate: router
use common_utils::{
crypto::{self, Encryptable},
date_time,
encryption::Encryption,
errors::{CustomResult, ValidationError},
id_type, pii, type_name,
types::keymanager::{Identifier, KeyManagerState, ToEncryptable},
};
use time::{OffsetDateTime, PrimitiveDateTime};
fn from(address_update: AddressUpdate) -> Self {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/types/domain/address.rs | crate: router
use common_utils::{
crypto::{self, Encryptable},
date_time,
encryption::Encryption,
errors::{CustomResult, ValidationError},
id_type, pii, type_name,
types::keymanager::{Identifier, KeyManagerState, ToEncryptable},
};
use diesel_models::{address::AddressUpdateInternal, enums};
use masking::{PeekInterface, Secret, SwitchStrategy};
async fn convert_back(
state: &KeyManagerState,
other: Self::DstType,
key: &Secret<Vec<u8>>,
key_manager_identifier: Identifier,
) -> CustomResult<Self, ValidationError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/workflows/tokenized_data.rs | crate: router
use crate::{errors, logger::error, routes::SessionState, types::storage};
async fn error_handler<'a>(
&'a self,
_state: &'a SessionState,
process: storage::ProcessTracker,
_error: errors::ProcessTrackerError,
) -> errors::CustomResult<(), errors::ProcessTrackerError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/workflows/tokenized_data.rs | crate: router
use crate::{errors, logger::error, routes::SessionState, types::storage};
async fn execute_workflow<'a>(
&'a self,
_state: &'a SessionState,
_process: storage::ProcessTracker,
) -> Result<(), errors::ProcessTrackerError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/workflows/attach_payout_account_workflow.rs | crate: router
use scheduler::{
consumer::{self, workflows::ProcessTrackerWorkflow},
errors,
};
use crate::{
core::payouts,
errors as core_errors,
routes::SessionState,
types::{api, storage},
};
async fn error_handler<'a>(
&'a self,
state: &'a SessionState,
process: storage::ProcessTracker,
error: errors::ProcessTrackerError,
) -> core_errors::CustomResult<(), errors::ProcessTrackerError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
// file: hyperswitch/crates/router/src/workflows/refund_router.rs | crate: router
use crate::{errors, logger::error, routes::SessionState, types::storage};
async fn error_handler<'a>(
&'a self,
_state: &'a SessionState,
process: storage::ProcessTracker,
_error: errors::ProcessTrackerError,
) -> errors::CustomResult<(), errors::ProcessTrackerError> {
error!(%process.id, "Failed while executing workflow");
Ok(())
} | ast_fragments |
// file: hyperswitch/crates/router/src/workflows/refund_router.rs | crate: router
use crate::core::refunds as refund_flow;
use crate::{errors, logger::error, routes::SessionState, types::storage};
async fn execute_workflow<'a>(
&'a self,
state: &'a SessionState,
process: storage::ProcessTracker,
) -> Result<(), errors::ProcessTrackerError> {
Ok(Box::pin(refund_flow::start_refund_workflow(state, &process)).await?)
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/utils/connector_onboarding/paypal.rs | crate: router
use common_utils::request::{Method, Request, RequestBuilder, RequestContent};
use http::header;
use crate::{
connector,
core::errors::{ApiErrorResponse, RouterResult},
routes::SessionState,
types,
types::api::{
enums,
verify_connector::{self as verify_connector_types, VerifyConnector},
},
utils::verify_connector as verify_connector_utils,
};
pub fn build_paypal_get_request(url: String, access_token: String) -> RouterResult<Request> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/utils/connector_onboarding/paypal.rs | crate: router
use common_utils::request::{Method, Request, RequestBuilder, RequestContent};
use http::header;
use crate::{
connector,
core::errors::{ApiErrorResponse, RouterResult},
routes::SessionState,
types,
types::api::{
enums,
verify_connector::{self as verify_connector_types, VerifyConnector},
},
utils::verify_connector as verify_connector_utils,
};
pub fn build_paypal_post_request<T>(
url: String,
body: T,
access_token: String,
) -> RouterResult<Request>
where
T: serde::Serialize + Send + 'static,
{
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/utils/connector_onboarding/paypal.rs | crate: router
use crate::{
connector,
core::errors::{ApiErrorResponse, RouterResult},
routes::SessionState,
types,
types::api::{
enums,
verify_connector::{self as verify_connector_types, VerifyConnector},
},
utils::verify_connector as verify_connector_utils,
};
pub async fn generate_access_token(state: SessionState) -> RouterResult<types::AccessToken> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
// file: hyperswitch/crates/router/src/configs/validations.rs | crate: router
use common_utils::ext_traits::ConfigExt;
use masking::PeekInterface;
use storage_impl::errors::ApplicationError;
pub fn validate(&self) -> Result<(), ApplicationError> {
use common_utils::fp_utils::when;
when(self.redis_lock_expiry_seconds.is_default_or_empty(), || {
Err(ApplicationError::InvalidConfigurationValueError(
"redis_lock_expiry_seconds must not be empty or 0".into(),
))
})?;
when(
self.delay_between_retries_in_milliseconds
.is_default_or_empty(),
|| {
Err(ApplicationError::InvalidConfigurationValueError(
"delay_between_retries_in_milliseconds must not be empty or 0".into(),
))
},
)?;
when(self.lock_retries.is_default_or_empty(), || {
Err(ApplicationError::InvalidConfigurationValueError(
"lock_retries must not be empty or 0".into(),
))
})
} | ast_fragments |
// file: hyperswitch/crates/router/src/connector/adyenplatform.rs | crate: router
use api_models::{self, webhooks::IncomingWebhookEvent};
use common_utils::request::RequestContent;
use common_utils::types::MinorUnitForConnector;
use common_utils::types::{AmountConvertor, MinorUnit};
use masking::Secret;
use ring::hmac;
use self::transformers as adyenplatform;
use crate::{
configs::settings,
core::errors::{self, CustomResult},
headers,
services::{self, request::Mask, ConnectorSpecifications, ConnectorValidation},
types::{
self,
api::{self, ConnectorCommon},
},
};
use crate::{
consts,
events::connector_api_logs::ConnectorEvent,
types::transformers::ForeignFrom,
utils::{crypto, ByteSliceExt, 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> {
let connector_webhook_secrets = self
.get_webhook_source_verification_merchant_secret(
merchant_id,
connector_label,
connector_webhook_details,
)
.await
.change_context(errors::ConnectorError::WebhookSourceVerificationFailed)?;
let signature = self
.get_webhook_source_verification_signature(request, &connector_webhook_secrets)
.change_context(errors::ConnectorError::WebhookSourceVerificationFailed)?;
let message = self
.get_webhook_source_verification_message(
request,
merchant_id,
&connector_webhook_secrets,
)
.change_context(errors::ConnectorError::WebhookSourceVerificationFailed)?;
let raw_key = hex::decode(connector_webhook_secrets.secret)
.change_context(errors::ConnectorError::WebhookVerificationSecretInvalid)?;
let signing_key = hmac::Key::new(hmac::HMAC_SHA256, &raw_key);
let signed_messaged = hmac::sign(&signing_key, &message);
let payload_sign = consts::BASE64_ENGINE.encode(signed_messaged.as_ref());
Ok(payload_sign.as_bytes().eq(&signature))
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/adyenplatform.rs | crate: router
use api_models::{self, webhooks::IncomingWebhookEvent};
use common_utils::request::RequestContent;
use error_stack::report;
use masking::Maskable;
use masking::Secret;
use self::transformers as adyenplatform;
use crate::{
configs::settings,
core::errors::{self, CustomResult},
headers,
services::{self, request::Mask, ConnectorSpecifications, ConnectorValidation},
types::{
self,
api::{self, ConnectorCommon},
},
};
fn get_webhook_resource_object(
&self,
#[cfg(feature = "payouts")] request: &api::IncomingWebhookRequestDetails<'_>,
#[cfg(not(feature = "payouts"))] _request: &api::IncomingWebhookRequestDetails<'_>,
) -> CustomResult<Box<dyn masking::ErasedMaskSerialize>, errors::ConnectorError> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/adyenplatform.rs | crate: router
use api_models::{self, webhooks::IncomingWebhookEvent};
use common_utils::request::RequestContent;
use error_stack::report;
use self::transformers as adyenplatform;
use crate::{
configs::settings,
core::errors::{self, CustomResult},
headers,
services::{self, request::Mask, ConnectorSpecifications, ConnectorValidation},
types::{
self,
api::{self, ConnectorCommon},
},
};
fn get_webhook_event_type(
&self,
#[cfg(feature = "payouts")] request: &api::IncomingWebhookRequestDetails<'_>,
#[cfg(not(feature = "payouts"))] _request: &api::IncomingWebhookRequestDetails<'_>,
) -> CustomResult<IncomingWebhookEvent, errors::ConnectorError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/adyenplatform.rs | crate: router
use api_models::{self, webhooks::IncomingWebhookEvent};
use http::HeaderName;
use hyperswitch_interfaces::webhooks::IncomingWebhookFlowError;
use masking::Maskable;
use masking::Secret;
use self::transformers as adyenplatform;
use crate::{
configs::settings,
core::errors::{self, CustomResult},
headers,
services::{self, request::Mask, ConnectorSpecifications, ConnectorValidation},
types::{
self,
api::{self, ConnectorCommon},
},
};
fn get_webhook_api_response(
&self,
_request: &api::IncomingWebhookRequestDetails<'_>,
error_kind: Option<IncomingWebhookFlowError>,
) -> CustomResult<services::api::ApplicationResponse<serde_json::Value>, errors::ConnectorError>
{
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/adyenplatform.rs | crate: router
use api_models::{self, webhooks::IncomingWebhookEvent};
use common_utils::request::RequestContent;
use error_stack::report;
use hyperswitch_interfaces::webhooks::IncomingWebhookFlowError;
use self::transformers as adyenplatform;
use crate::{
configs::settings,
core::errors::{self, CustomResult},
headers,
services::{self, request::Mask, ConnectorSpecifications, ConnectorValidation},
types::{
self,
api::{self, ConnectorCommon},
},
};
fn get_webhook_object_reference_id(
&self,
#[cfg(feature = "payouts")] request: &api::IncomingWebhookRequestDetails<'_>,
#[cfg(not(feature = "payouts"))] _request: &api::IncomingWebhookRequestDetails<'_>,
) -> CustomResult<api_models::webhooks::ObjectReferenceId, errors::ConnectorError> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/adyenplatform.rs | crate: router
use api_models::{self, webhooks::IncomingWebhookEvent};
use common_utils::request::RequestContent;
use common_utils::types::MinorUnitForConnector;
use common_utils::types::{AmountConvertor, MinorUnit};
use hyperswitch_interfaces::webhooks::IncomingWebhookFlowError;
use self::transformers as adyenplatform;
use crate::{
configs::settings,
core::errors::{self, CustomResult},
headers,
services::{self, request::Mask, ConnectorSpecifications, ConnectorValidation},
types::{
self,
api::{self, ConnectorCommon},
},
};
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> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/adyenplatform.rs | crate: router
use api_models::{self, webhooks::IncomingWebhookEvent};
use common_utils::types::MinorUnitForConnector;
use common_utils::types::{AmountConvertor, MinorUnit};
use self::transformers as adyenplatform;
use crate::{
configs::settings,
core::errors::{self, CustomResult},
headers,
services::{self, request::Mask, ConnectorSpecifications, ConnectorValidation},
types::{
self,
api::{self, ConnectorCommon},
},
};
use crate::{
consts,
events::connector_api_logs::ConnectorEvent,
types::transformers::ForeignFrom,
utils::{crypto, ByteSliceExt, BytesExt},
};
fn get_error_response(
&self,
res: types::Response,
event_builder: Option<&mut ConnectorEvent>,
) -> CustomResult<types::ErrorResponse, errors::ConnectorError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
// file: hyperswitch/crates/router/src/connector/adyenplatform.rs | crate: router
use api_models::{self, webhooks::IncomingWebhookEvent};
use common_utils::types::MinorUnitForConnector;
use common_utils::types::{AmountConvertor, MinorUnit};
use router_env::{instrument, tracing};
use self::transformers as adyenplatform;
use crate::{
configs::settings,
core::errors::{self, CustomResult},
headers,
services::{self, request::Mask, ConnectorSpecifications, ConnectorValidation},
types::{
self,
api::{self, ConnectorCommon},
},
};
use crate::{
consts,
events::connector_api_logs::ConnectorEvent,
types::transformers::ForeignFrom,
utils::{crypto, ByteSliceExt, BytesExt},
};
fn handle_response(
&self,
data: &types::PayoutsRouterData<api::PoFulfill>,
event_builder: Option<&mut ConnectorEvent>,
res: types::Response,
) -> CustomResult<types::PayoutsRouterData<api::PoFulfill>, errors::ConnectorError> {
let response: adyenplatform::AdyenTransferResponse = res
.response
.parse_struct("AdyenTransferResponse")
.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,
})
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/adyenplatform.rs | crate: router
use api_models::{self, webhooks::IncomingWebhookEvent};
use common_utils::types::MinorUnitForConnector;
use common_utils::types::{AmountConvertor, MinorUnit};
use masking::Maskable;
use self::transformers as adyenplatform;
use crate::{
configs::settings,
core::errors::{self, CustomResult},
headers,
services::{self, request::Mask, ConnectorSpecifications, ConnectorValidation},
types::{
self,
api::{self, ConnectorCommon},
},
};
use crate::{
consts,
events::connector_api_logs::ConnectorEvent,
types::transformers::ForeignFrom,
utils::{crypto, ByteSliceExt, BytesExt},
};
fn get_headers(
&self,
req: &types::PayoutsRouterData<api::PoFulfill>,
_connectors: &settings::Connectors,
) -> CustomResult<Vec<(String, Maskable<String>)>, errors::ConnectorError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/adyenplatform.rs | crate: router
use api_models::{self, webhooks::IncomingWebhookEvent};
use common_utils::types::MinorUnitForConnector;
use common_utils::types::{AmountConvertor, MinorUnit};
use router_env::{instrument, tracing};
use self::transformers as adyenplatform;
use crate::{
configs::settings,
core::errors::{self, CustomResult},
headers,
services::{self, request::Mask, ConnectorSpecifications, ConnectorValidation},
types::{
self,
api::{self, ConnectorCommon},
},
};
use crate::{
consts,
events::connector_api_logs::ConnectorEvent,
types::transformers::ForeignFrom,
utils::{crypto, ByteSliceExt, BytesExt},
};
fn build_error_response(
&self,
res: types::Response,
event_builder: Option<&mut ConnectorEvent>,
) -> CustomResult<types::ErrorResponse, errors::ConnectorError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/adyenplatform.rs | crate: router
use api_models::{self, webhooks::IncomingWebhookEvent};
use common_utils::types::MinorUnitForConnector;
use common_utils::types::{AmountConvertor, MinorUnit};
use masking::Maskable;
use self::transformers as adyenplatform;
use crate::{
configs::settings,
core::errors::{self, CustomResult},
headers,
services::{self, request::Mask, ConnectorSpecifications, ConnectorValidation},
types::{
self,
api::{self, ConnectorCommon},
},
};
use crate::{
consts,
events::connector_api_logs::ConnectorEvent,
types::transformers::ForeignFrom,
utils::{crypto, ByteSliceExt, BytesExt},
};
fn get_auth_header(
&self,
auth_type: &types::ConnectorAuthType,
) -> CustomResult<Vec<(String, Maskable<String>)>, errors::ConnectorError> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/netcetera.rs | crate: router
use hyperswitch_interfaces::authentication::ExternalAuthenticationPayload;
use transformers as netcetera;
use crate::{
configs::settings,
core::errors::{self, CustomResult},
events::connector_api_logs::ConnectorEvent,
headers,
services::{self, request, ConnectorIntegration, ConnectorSpecifications, ConnectorValidation},
types::{
self,
api::{self, ConnectorCommon, ConnectorCommonExt},
ErrorResponse, Response,
},
utils::BytesExt,
};
fn build_request(
&self,
req: &types::authentication::ConnectorAuthenticationRouterData,
connectors: &settings::Connectors,
) -> CustomResult<Option<services::Request>, errors::ConnectorError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/netcetera.rs | crate: router
use hyperswitch_interfaces::authentication::ExternalAuthenticationPayload;
use transformers as netcetera;
use crate::{
configs::settings,
core::errors::{self, CustomResult},
events::connector_api_logs::ConnectorEvent,
headers,
services::{self, request, ConnectorIntegration, ConnectorSpecifications, ConnectorValidation},
types::{
self,
api::{self, ConnectorCommon, ConnectorCommonExt},
ErrorResponse, Response,
},
utils::BytesExt,
};
fn handle_response(
&self,
data: &types::authentication::ConnectorAuthenticationRouterData,
event_builder: Option<&mut ConnectorEvent>,
res: Response,
) -> CustomResult<
types::authentication::ConnectorAuthenticationRouterData,
errors::ConnectorError,
> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/netcetera.rs | crate: router
use hyperswitch_interfaces::authentication::ExternalAuthenticationPayload;
use crate::{
configs::settings,
core::errors::{self, CustomResult},
events::connector_api_logs::ConnectorEvent,
headers,
services::{self, request, ConnectorIntegration, ConnectorSpecifications, ConnectorValidation},
types::{
self,
api::{self, ConnectorCommon, ConnectorCommonExt},
ErrorResponse, Response,
},
utils::BytesExt,
};
fn get_url(
&self,
req: &types::authentication::ConnectorAuthenticationRouterData,
connectors: &settings::Connectors,
) -> CustomResult<String, errors::ConnectorError> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/netcetera.rs | crate: router
use common_utils::{ext_traits::ByteSliceExt, request::RequestContent};
use hyperswitch_interfaces::authentication::ExternalAuthenticationPayload;
use crate::{
configs::settings,
core::errors::{self, CustomResult},
events::connector_api_logs::ConnectorEvent,
headers,
services::{self, request, ConnectorIntegration, ConnectorSpecifications, ConnectorValidation},
types::{
self,
api::{self, ConnectorCommon, ConnectorCommonExt},
ErrorResponse, Response,
},
utils::BytesExt,
};
fn get_headers(
&self,
req: &types::authentication::ConnectorAuthenticationRouterData,
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/netcetera.rs | crate: router
use common_utils::{ext_traits::ByteSliceExt, request::RequestContent};
use hyperswitch_interfaces::authentication::ExternalAuthenticationPayload;
use transformers as netcetera;
use crate::{
configs::settings,
core::errors::{self, CustomResult},
events::connector_api_logs::ConnectorEvent,
headers,
services::{self, request, ConnectorIntegration, ConnectorSpecifications, ConnectorValidation},
types::{
self,
api::{self, ConnectorCommon, ConnectorCommonExt},
ErrorResponse, Response,
},
utils::BytesExt,
};
fn get_request_body(
&self,
req: &types::authentication::PreAuthNRouterData,
_connectors: &settings::Connectors,
) -> CustomResult<RequestContent, errors::ConnectorError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/netcetera.rs | crate: router
use hyperswitch_interfaces::authentication::ExternalAuthenticationPayload;
use crate::{
configs::settings,
core::errors::{self, CustomResult},
events::connector_api_logs::ConnectorEvent,
headers,
services::{self, request, ConnectorIntegration, ConnectorSpecifications, ConnectorValidation},
types::{
self,
api::{self, ConnectorCommon, ConnectorCommonExt},
ErrorResponse, Response,
},
utils::BytesExt,
};
fn get_url(
&self,
req: &types::authentication::PreAuthNRouterData,
connectors: &settings::Connectors,
) -> CustomResult<String, errors::ConnectorError> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/netcetera.rs | crate: router
use common_utils::{ext_traits::ByteSliceExt, request::RequestContent};
use hyperswitch_interfaces::authentication::ExternalAuthenticationPayload;
use crate::{
configs::settings,
core::errors::{self, CustomResult},
events::connector_api_logs::ConnectorEvent,
headers,
services::{self, request, ConnectorIntegration, ConnectorSpecifications, ConnectorValidation},
types::{
self,
api::{self, ConnectorCommon, ConnectorCommonExt},
ErrorResponse, Response,
},
utils::BytesExt,
};
fn get_headers(
&self,
req: &types::authentication::PreAuthNRouterData,
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/netcetera.rs | crate: router
use common_utils::{ext_traits::ByteSliceExt, request::RequestContent};
use transformers as netcetera;
use crate::{
configs::settings,
core::errors::{self, CustomResult},
events::connector_api_logs::ConnectorEvent,
headers,
services::{self, request, ConnectorIntegration, ConnectorSpecifications, ConnectorValidation},
types::{
self,
api::{self, ConnectorCommon, ConnectorCommonExt},
ErrorResponse, Response,
},
utils::BytesExt,
};
fn build_endpoint(
base_url: &str,
connector_metadata: &Option<common_utils::pii::SecretSerdeValue>,
) -> CustomResult<String, errors::ConnectorError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/netcetera.rs | crate: router
use common_utils::{ext_traits::ByteSliceExt, request::RequestContent};
use hyperswitch_interfaces::authentication::ExternalAuthenticationPayload;
use transformers as netcetera;
use crate::{
configs::settings,
core::errors::{self, CustomResult},
events::connector_api_logs::ConnectorEvent,
headers,
services::{self, request, ConnectorIntegration, ConnectorSpecifications, ConnectorValidation},
types::{
self,
api::{self, ConnectorCommon, ConnectorCommonExt},
ErrorResponse, Response,
},
utils::BytesExt,
};
fn get_external_authentication_details(
&self,
request: &api::IncomingWebhookRequestDetails<'_>,
) -> CustomResult<ExternalAuthenticationPayload, errors::ConnectorError> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.