text
stringlengths 70
351k
| source
stringclasses 4
values |
|---|---|
<|meta_start|><|file|> hyperswitch/crates/hyperswitch_connectors/src/connectors/dlocal/transformers.rs<|crate|> hyperswitch_connectors<|connector|> dlocal anchor=try_from kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/dlocal/transformers.rs" role="context" start="97" end="182">
fn try_from(
item: &DlocalRouterData<&types::PaymentsAuthorizeRouterData>,
) -> Result<Self, Self::Error> {
let email = item.router_data.request.email.clone();
let address = item.router_data.get_billing_address()?;
let country = address.get_country()?;
let name = get_payer_name(address);
match item.router_data.request.payment_method_data {
PaymentMethodData::Card(ref ccard) => {
let should_capture = matches!(
item.router_data.request.capture_method,
Some(enums::CaptureMethod::Automatic)
| Some(enums::CaptureMethod::SequentialAutomatic)
);
let payment_request = Self {
amount: item.amount,
currency: item.router_data.request.currency,
payment_method_id: PaymentMethodId::Card,
payment_method_flow: PaymentMethodFlow::Direct,
country: country.to_string(),
payer: Payer {
name,
email,
// [#589]: Allow securely collecting PII from customer in payments request
document: get_doc_from_currency(country.to_string()),
},
card: Some(Card {
holder_name: item
.router_data
.get_optional_billing_full_name()
.unwrap_or(Secret::new("".to_string())),
number: ccard.card_number.clone(),
cvv: ccard.card_cvc.clone(),
expiration_month: ccard.card_exp_month.clone(),
expiration_year: ccard.card_exp_year.clone(),
capture: should_capture.to_string(),
installments_id: item
.router_data
.request
.mandate_id
.as_ref()
.and_then(|ids| ids.mandate_id.clone()),
// [#595[FEATURE] Pass Mandate history information in payment flows/request]
installments: item
.router_data
.request
.mandate_id
.clone()
.map(|_| "1".to_string()),
}),
order_id: item.router_data.connector_request_reference_id.clone(),
three_dsecure: match item.router_data.auth_type {
enums::AuthenticationType::ThreeDs => {
Some(ThreeDSecureReqData { force: true })
}
enums::AuthenticationType::NoThreeDs => None,
},
callback_url: Some(item.router_data.request.get_router_return_url()?),
description: item.router_data.description.clone(),
};
Ok(payment_request)
}
PaymentMethodData::CardRedirect(_)
| PaymentMethodData::Wallet(_)
| PaymentMethodData::PayLater(_)
| PaymentMethodData::BankRedirect(_)
| PaymentMethodData::BankDebit(_)
| PaymentMethodData::BankTransfer(_)
| PaymentMethodData::Crypto(_)
| PaymentMethodData::MandatePayment
| PaymentMethodData::Reward
| PaymentMethodData::RealTimePayment(_)
| PaymentMethodData::MobilePayment(_)
| PaymentMethodData::Upi(_)
| PaymentMethodData::Voucher(_)
| PaymentMethodData::GiftCard(_)
| PaymentMethodData::OpenBanking(_)
| PaymentMethodData::CardToken(_)
| PaymentMethodData::NetworkToken(_)
| PaymentMethodData::CardDetailsForNetworkTransactionId(_) => {
Err(errors::ConnectorError::NotImplemented(
crate::utils::get_unimplemented_payment_method_error_message("Dlocal"),
))?
}
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/dlocal/transformers.rs" role="context" start="96" end="96">
use common_enums::enums;
use hyperswitch_domain_models::{
payment_method_data::PaymentMethodData,
router_data::{ConnectorAuthType, RouterData},
router_flow_types::{refunds::Execute, RSync},
router_request_types::ResponseId,
router_response_types::{PaymentsResponseData, RedirectForm, RefundsResponseData},
types,
};
use masking::{PeekInterface, Secret};
use crate::{
types::{RefundsResponseRouterData, ResponseRouterData},
utils::{AddressDetailsData, PaymentsAuthorizeRequestData, RouterData as _},
};
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/dlocal/transformers.rs" role="context" start="210" end="218">
fn try_from(item: &types::PaymentsSyncRouterData) -> Result<Self, Self::Error> {
Ok(Self {
authz_id: (item
.request
.connector_transaction_id
.get_connector_transaction_id()
.change_context(errors::ConnectorError::MissingConnectorTransactionID)?),
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/dlocal/transformers.rs" role="context" start="185" end="202">
fn get_payer_name(
address: &hyperswitch_domain_models::address::AddressDetails,
) -> Option<Secret<String>> {
let first_name = address
.first_name
.clone()
.map_or("".to_string(), |first_name| first_name.peek().to_string());
let last_name = address
.last_name
.clone()
.map_or("".to_string(), |last_name| last_name.peek().to_string());
let name: String = format!("{first_name} {last_name}").trim().to_string();
if !name.is_empty() {
Some(Secret::new(name))
} else {
None
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/dlocal/transformers.rs" role="context" start="70" end="77">
fn try_from(
(_currency_unit, _currency, amount, router_data): (&CurrencyUnit, enums::Currency, i64, T),
) -> Result<Self, Self::Error> {
Ok(Self {
amount,
router_data,
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/dlocal/transformers.rs" role="context" start="550" end="567">
fn get_doc_from_currency(country: String) -> Secret<String> {
let doc = match country.as_str() {
"BR" => "91483309223",
"ZA" => "2001014800086",
"BD" | "GT" | "HN" | "PK" | "SN" | "TH" => "1234567890001",
"CR" | "SV" | "VN" => "123456789",
"DO" | "NG" => "12345678901",
"EG" => "12345678901112",
"GH" | "ID" | "RW" | "UG" => "1234567890111123",
"IN" => "NHSTP6374G",
"CI" => "CA124356789",
"JP" | "MY" | "PH" => "123456789012",
"NI" => "1234567890111A",
"TZ" => "12345678912345678900",
_ => "12345678",
};
Secret::new(doc.to_string())
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/dlocal/transformers.rs" role="context" start="68" end="68">
type Error = error_stack::Report<errors::ConnectorError>;
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/dlocal/transformers.rs" role="context" start="62" end="65">
pub struct DlocalRouterData<T> {
pub amount: i64,
pub router_data: T,
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/globalpay/response.rs" role="context" start="186" end="189">
pub struct Mandate {
/// The reference to identify the mandate.
pub code: Option<Secret<String>>,
}
<file_sep path="hyperswitch/migrations/2022-12-05-090521_single_use_mandate_fields/up.sql" role="context" start="1" end="4">
-- Your SQL goes here
ALTER TABLE mandate
ADD IF NOT EXISTS single_use_amount INTEGER DEFAULT NULL,
ADD IF NOT EXISTS single_use_currency "Currency" DEFAULT NULL;
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch-encryption-service/src/multitenancy.rs<|crate|> src anchor=new kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch-encryption-service/src/multitenancy.rs" role="context" start="27" end="29">
pub fn new(session: Arc<SessionState>) -> Self {
Self(session)
}
<file_sep path="hyperswitch-encryption-service/src/multitenancy.rs" role="context" start="26" end="26">
use crate::{
app::{AppState, SessionState, StorageState},
consts::TENANT_HEADER,
errors::{self, ApiErrorContainer, SwitchError, ToContainerError},
};
use std::sync::Arc;
pub type MultiTenant<T> = FxHashMap<TenantId, T>;
<file_sep path="hyperswitch-encryption-service/src/multitenancy.rs" role="context" start="39" end="41">
fn deref(&self) -> &Self::Target {
&self.0
}
<file_sep path="hyperswitch-encryption-service/src/multitenancy.rs" role="context" start="31" end="33">
pub(crate) fn get_db_pool(&self) -> &StorageState {
self.db_pool()
}
<file_sep path="hyperswitch-encryption-service/src/multitenancy.rs" role="context" start="18" end="20">
pub fn new(val: String) -> Self {
Self(val)
}
<file_sep path="hyperswitch-encryption-service/src/multitenancy.rs" role="context" start="47" end="59">
async fn from_request_parts(
parts: &mut axum::http::request::Parts,
state: &Arc<AppState>,
) -> Result<Self, Self::Rejection> {
parts
.headers
.get(TENANT_HEADER)
.ok_or(error_stack::Report::new(
errors::ApplicationErrorResponse::TenantIdNotFound,
))
.and_then(|header| extract_tenant(state, header).switch())
.to_container_error()
}
<file_sep path="hyperswitch-encryption-service/src/multitenancy.rs" role="context" start="62" end="78">
fn extract_tenant(
state: &AppState,
header: &header::HeaderValue,
) -> errors::CustomResult<TenantState, errors::ParsingError> {
let tenant = header
.to_str()
.change_context(errors::ParsingError::InvalidTenantId)?
.to_string();
state
.tenant_states
.get(&TenantId::new(tenant))
.cloned()
.ok_or(error_stack::Report::new(
errors::ParsingError::TenantIdNotFound,
))
}
<file_sep path="hyperswitch-encryption-service/src/app.rs" role="context" start="51" end="57">
pub struct SessionState {
pub cache_prefix: String,
pub thread_pool: ThreadPool,
pub keymanager_client: KeyManagerClient,
db_pool: StorageState,
pub hash_client: Blake3,
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch-card-vault/src/error/container.rs<|crate|> src anchor=from kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=1<|meta_end|>
<file_sep path="hyperswitch-card-vault/src/error/container.rs" role="context" start="62" end="64">
fn from(error: error_stack::Report<T>) -> Self {
Self { error }
}
<file_sep path="hyperswitch-card-vault/src/error/container.rs" role="context" start="61" end="61">
use std::error::Error;
<file_sep path="hyperswitch-card-vault/src/error/container.rs" role="context" start="83" end="90">
fn change_error(self, error: E2) -> Result<T, ContainerError<E2>> {
match self {
Ok(value) => Ok(value),
Err(err) => Err(ContainerError {
error: error_stack::Report::from(err).change_context(error),
}),
}
}
<file_sep path="hyperswitch-card-vault/src/error/container.rs" role="context" start="54" end="58">
fn from(value: T) -> Self {
Self {
error: error_stack::Report::from(value),
}
}
<file_sep path="hyperswitch-card-vault/src/error/container.rs" role="context" start="41" end="46">
fn from(value: ContainerError<T>) -> Self {
let new_error = value.error.current_context().into();
Self {
error: value.error.change_context(new_error),
}
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/common_utils/src/types.rs<|crate|> common_utils anchor=new_unchecked kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=1<|meta_end|>
<file_sep path="hyperswitch/crates/common_utils/src/types.rs" role="context" start="1121" end="1123">
pub(crate) fn new_unchecked(input_string: String) -> Self {
Self(input_string)
}
<file_sep path="hyperswitch/crates/common_utils/src/types.rs" role="context" start="1120" end="1120">
pub use primitive_wrappers::bool_wrappers::{
AlwaysRequestExtendedAuthorization, ExtendedAuthorizationAppliedBool,
RequestExtendedAuthorizationBool,
};
use crate::{
consts::{
self, MAX_DESCRIPTION_LENGTH, MAX_STATEMENT_DESCRIPTOR_LENGTH, PUBLISHABLE_KEY_LENGTH,
},
errors::{CustomResult, ParsingError, PercentageError, ValidationError},
fp_utils::when,
};
pub use client_secret_type::ClientSecret;
<file_sep path="hyperswitch/crates/common_utils/src/types.rs" role="context" start="1144" end="1147">
fn from_sql(bytes: DB::RawValue<'_>) -> deserialize::Result<Self> {
let val = String::from_sql(bytes)?;
Ok(Self(val))
}
<file_sep path="hyperswitch/crates/common_utils/src/types.rs" role="context" start="1129" end="1135">
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: Deserializer<'de>,
{
let deserialized_string = String::deserialize(deserializer)?;
Self::from(deserialized_string.into()).map_err(serde::de::Error::custom)
}
<file_sep path="hyperswitch/crates/common_utils/src/types.rs" role="context" start="1105" end="1119">
pub fn from(input_string: Cow<'static, str>) -> Result<Self, LengthStringError> {
let trimmed_input_string = input_string.trim().to_string();
let length_of_input_string = u16::try_from(trimmed_input_string.len())
.map_err(|_| LengthStringError::MaxLengthViolated(MAX_LENGTH))?;
when(length_of_input_string > MAX_LENGTH, || {
Err(LengthStringError::MaxLengthViolated(MAX_LENGTH))
})?;
when(length_of_input_string < MIN_LENGTH, || {
Err(LengthStringError::MinLengthViolated(MIN_LENGTH))
})?;
Ok(Self(trimmed_input_string))
}
<file_sep path="hyperswitch/crates/common_utils/src/types.rs" role="context" start="1050" end="1062">
fn amount_conversion_to_string_minor_unit() {
let request_amount = MinorUnit::new(999999999);
let currency = TWO_DECIMAL_CURRENCY;
let required_conversion = StringMinorUnitForConnector;
let converted_amount = required_conversion
.convert(request_amount, currency)
.unwrap();
assert_eq!(converted_amount.0, "999999999".to_string());
let converted_back_amount = required_conversion
.convert_back(converted_amount, currency)
.unwrap();
assert_eq!(converted_back_amount, request_amount);
}
<file_sep path="hyperswitch/crates/common_utils/src/types.rs" role="context" start="1563" end="1566">
pub fn generate(env_prefix: &'static str) -> Self {
let publishable_key_string = format!("pk_{env_prefix}_{}", uuid::Uuid::now_v7().simple());
Self(LengthString::new_unchecked(publishable_key_string))
}
<file_sep path="hyperswitch/crates/common_utils/src/types.rs" role="context" start="1180" end="1182">
pub fn from_str_unchecked(input_str: &'static str) -> Self {
Self(LengthString::new_unchecked(input_str.to_owned()))
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/common_utils/src/id_type/profile.rs<|crate|> common_utils anchor=from kind=fn pack=symbol_neighborhood lang=rust role_window=k2 hops=1<|meta_end|>
<file_sep path="hyperswitch/crates/common_utils/src/id_type/profile.rs" role="context" start="38" end="40">
fn from(val: ProfileId) -> Self {
Self::from(val.0 .0 .0)
}
<file_sep path="hyperswitch/crates/common_utils/src/id_type/profile.rs" role="context" start="29" end="32">
fn from_str(s: &str) -> Result<Self, Self::Err> {
let cow_string = std::borrow::Cow::Owned(s.to_string());
Self::try_from(cow_string)
}
<file_sep path="hyperswitch/crates/common_utils/src/id_type/profile.rs" role="context" start="19" end="23">
fn get_api_event_type(&self) -> Option<crate::events::ApiEventsType> {
Some(crate::events::ApiEventsType::BusinessProfile {
profile_id: self.clone(),
})
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch-card-vault/build.rs<|crate|> build.rs anchor=main kind=fn pack=symbol_neighborhood lang=rust role_window=k2 hops=1<|meta_end|>
<file_sep path="hyperswitch-card-vault/build.rs" role="context" start="59" end="62">
fn main() {
cargo_workspace::verify_cargo_metadata_format();
cargo_workspace::set_cargo_workspace_members_env();
}
<file_sep path="hyperswitch-card-vault/build.rs" role="context" start="37" end="56">
pub fn set_cargo_workspace_members_env() {
use std::io::Write;
let metadata = cargo_metadata::MetadataCommand::new()
.exec()
.expect("Failed to obtain cargo metadata");
let workspace_members = metadata
.workspace_packages()
.iter()
.map(|package| package.name.as_str())
.collect::<Vec<_>>()
.join(",");
writeln!(
&mut std::io::stdout(),
"cargo:rustc-env=CARGO_WORKSPACE_MEMBERS={workspace_members}"
)
.expect("Failed to set `CARGO_WORKSPACE_MEMBERS` environment variable");
}
<file_sep path="hyperswitch-card-vault/build.rs" role="context" start="12" end="25">
pub fn verify_cargo_metadata_format() {
#[allow(clippy::expect_used)]
let metadata = cargo_metadata::MetadataCommand::new()
.exec()
.expect("Failed to obtain cargo metadata");
assert!(
metadata
.workspace_packages()
.iter()
.any(|package| package.name == env!("CARGO_PKG_NAME")),
"Unable to determine workspace member package names from `cargo metadata`"
);
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/hyperswitch_constraint_graph/src/graph.rs<|crate|> hyperswitch_constraint_graph anchor=get_node_id kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/hyperswitch_constraint_graph/src/graph.rs" role="context" start="603" end="605">
fn get_node_id(node_id: types::NodeId) -> String {
format!("N{}", node_id.get_id())
}
<file_sep path="hyperswitch/crates/hyperswitch_constraint_graph/src/graph.rs" role="context" start="602" end="602">
use crate::{
builder,
dense_map::DenseMap,
error::{self, AnalysisTrace, GraphError},
types::{
CheckingContext, CycleCheck, DomainId, DomainIdentifier, DomainInfo, Edge, EdgeId,
Memoization, Metadata, Node, NodeId, NodeType, NodeValue, Relation, RelationResolution,
Strength, ValueNode,
},
};
<file_sep path="hyperswitch/crates/hyperswitch_constraint_graph/src/graph.rs" role="context" start="635" end="640">
fn build_node(cg_node_id: types::NodeId, cg_node: &types::Node<V>) -> Node {
let viz_node_id = get_node_id(cg_node_id);
let viz_node_label = Self::get_node_label(cg_node);
node!(viz_node_id; attr!("label", viz_node_label))
}
<file_sep path="hyperswitch/crates/hyperswitch_constraint_graph/src/graph.rs" role="context" start="612" end="633">
fn get_node_label(node: &types::Node<V>) -> String {
let label = match &node.node_type {
types::NodeType::Value(types::NodeValue::Key(key)) => format!("any {}", key.viz()),
types::NodeType::Value(types::NodeValue::Value(val)) => {
format!("{} = {}", val.get_key().viz(), val.viz())
}
types::NodeType::AllAggregator => "&&".to_string(),
types::NodeType::AnyAggregator => "| |".to_string(),
types::NodeType::InAggregator(agg) => {
let key = if let Some(val) = agg.iter().next() {
val.get_key().viz()
} else {
return "empty in".to_string();
};
let nodes = agg.iter().map(NodeViz::viz).collect::<Vec<_>>();
format!("{key} in [{}]", nodes.join(", "))
}
};
format!("\"{label}\"")
}
<file_sep path="hyperswitch/crates/hyperswitch_constraint_graph/src/graph.rs" role="context" start="485" end="590">
pub fn combine(g1: &Self, g2: &Self) -> Result<Self, GraphError<V>> {
let mut node_builder = builder::ConstraintGraphBuilder::new();
let mut g1_old2new_id = DenseMap::<NodeId, NodeId>::new();
let mut g2_old2new_id = DenseMap::<NodeId, NodeId>::new();
let mut g1_old2new_domain_id = DenseMap::<DomainId, DomainId>::new();
let mut g2_old2new_domain_id = DenseMap::<DomainId, DomainId>::new();
let add_domain = |node_builder: &mut builder::ConstraintGraphBuilder<V>,
domain: DomainInfo|
-> Result<DomainId, GraphError<V>> {
node_builder.make_domain(
domain.domain_identifier.into_inner(),
&domain.domain_description,
)
};
let add_node = |node_builder: &mut builder::ConstraintGraphBuilder<V>,
node: &Node<V>|
-> Result<NodeId, GraphError<V>> {
match &node.node_type {
NodeType::Value(node_value) => {
Ok(node_builder.make_value_node(node_value.clone(), None, None::<()>))
}
NodeType::AllAggregator => {
Ok(node_builder.make_all_aggregator(&[], None, None::<()>, None)?)
}
NodeType::AnyAggregator => {
Ok(node_builder.make_any_aggregator(&[], None, None::<()>, None)?)
}
NodeType::InAggregator(expected) => Ok(node_builder.make_in_aggregator(
expected.iter().cloned().collect(),
None,
None::<()>,
)?),
}
};
for (_old_domain_id, domain) in g1.domain.iter() {
let new_domain_id = add_domain(&mut node_builder, domain.clone())?;
g1_old2new_domain_id.push(new_domain_id);
}
for (_old_domain_id, domain) in g2.domain.iter() {
let new_domain_id = add_domain(&mut node_builder, domain.clone())?;
g2_old2new_domain_id.push(new_domain_id);
}
for (_old_node_id, node) in g1.nodes.iter() {
let new_node_id = add_node(&mut node_builder, node)?;
g1_old2new_id.push(new_node_id);
}
for (_old_node_id, node) in g2.nodes.iter() {
let new_node_id = add_node(&mut node_builder, node)?;
g2_old2new_id.push(new_node_id);
}
for edge in g1.edges.values() {
let new_pred_id = g1_old2new_id
.get(edge.pred)
.ok_or(GraphError::NodeNotFound)?;
let new_succ_id = g1_old2new_id
.get(edge.succ)
.ok_or(GraphError::NodeNotFound)?;
let domain_ident = edge
.domain
.map(|domain_id| g1.domain.get(domain_id).ok_or(GraphError::DomainNotFound))
.transpose()?
.map(|domain| domain.domain_identifier.clone());
node_builder.make_edge(
*new_pred_id,
*new_succ_id,
edge.strength,
edge.relation,
domain_ident,
)?;
}
for edge in g2.edges.values() {
let new_pred_id = g2_old2new_id
.get(edge.pred)
.ok_or(GraphError::NodeNotFound)?;
let new_succ_id = g2_old2new_id
.get(edge.succ)
.ok_or(GraphError::NodeNotFound)?;
let domain_ident = edge
.domain
.map(|domain_id| g2.domain.get(domain_id).ok_or(GraphError::DomainNotFound))
.transpose()?
.map(|domain| domain.domain_identifier.clone());
node_builder.make_edge(
*new_pred_id,
*new_succ_id,
edge.strength,
edge.relation,
domain_ident,
)?;
}
Ok(node_builder.build())
}
<file_sep path="hyperswitch/crates/hyperswitch_constraint_graph/src/graph.rs" role="context" start="453" end="483">
fn context_analysis<C>(
&self,
node_id: NodeId,
relation: Relation,
strength: Strength,
ctx: &C,
val: &NodeValue<V>,
memo: &mut Memoization<V>,
) -> Result<(), GraphError<V>>
where
C: CheckingContext<Value = V>,
{
let in_context = ctx.check_presence(val, strength);
let relation_bool: bool = relation.into();
if in_context != relation_bool {
let err = Arc::new(AnalysisTrace::Value {
value: val.clone(),
relation,
predecessors: None,
info: self.node_info.get(node_id).copied().flatten(),
metadata: self.node_metadata.get(node_id).cloned().flatten(),
});
memo.insert((node_id, relation, strength), Err(Arc::clone(&err)));
Err(GraphError::AnalysisError(Arc::downgrade(&err)))?;
}
if !relation_bool {
memo.insert((node_id, relation, strength), Ok(()));
return Ok(());
}
Ok(())
}
<file_sep path="hyperswitch/crates/hyperswitch_constraint_graph/src/graph.rs" role="context" start="642" end="660">
fn build_edge(cg_edge: &types::Edge) -> Edge {
let pred_vertex = get_node_id(cg_edge.pred);
let succ_vertex = get_node_id(cg_edge.succ);
let arrowhead = match cg_edge.strength {
types::Strength::Weak => "onormal",
types::Strength::Normal => "normal",
types::Strength::Strong => "normalnormal",
};
let color = match cg_edge.relation {
types::Relation::Positive => "blue",
types::Relation::Negative => "red",
};
edge!(
node_id!(pred_vertex) => node_id!(succ_vertex);
attr!("arrowhead", arrowhead),
attr!("color", color)
)
}
<file_sep path="hyperswitch/crates/hyperswitch_constraint_graph/src/types.rs" role="context" start="27" end="27">
pub struct NodeId(usize);
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/euclid/src/frontend/dir.rs<|crate|> euclid anchor=new kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=1<|meta_end|>
<file_sep path="hyperswitch/crates/euclid/src/frontend/dir.rs" role="context" start="55" end="57">
pub fn new(kind: DirKeyKind, value: Option<String>) -> Self {
Self { kind, value }
}
<file_sep path="hyperswitch/crates/euclid/src/frontend/dir.rs" role="context" start="54" end="54">
pub type DirIfCondition = Vec<DirComparison>;
<file_sep path="hyperswitch/crates/euclid/src/frontend/dir.rs" role="context" start="299" end="301">
fn is_key_allowed(key: &DirKeyKind) -> bool {
Self::ALLOWED.contains(key)
}
<file_sep path="hyperswitch/crates/euclid/src/frontend/dir.rs" role="context" start="295" end="297">
fn get_allowed_keys() -> &'static [DirKeyKind] {
Self::ALLOWED
}
<file_sep path="hyperswitch/crates/euclid/src/frontend/dir.rs" role="context" start="549" end="585">
pub fn get_key(&self) -> DirKey {
let (kind, data) = match self {
Self::PaymentMethod(_) => (DirKeyKind::PaymentMethod, None),
Self::CardBin(_) => (DirKeyKind::CardBin, None),
Self::RewardType(_) => (DirKeyKind::RewardType, None),
Self::BusinessCountry(_) => (DirKeyKind::BusinessCountry, None),
Self::BillingCountry(_) => (DirKeyKind::BillingCountry, None),
Self::BankTransferType(_) => (DirKeyKind::BankTransferType, None),
Self::UpiType(_) => (DirKeyKind::UpiType, None),
Self::CardType(_) => (DirKeyKind::CardType, None),
Self::CardNetwork(_) => (DirKeyKind::CardNetwork, None),
Self::MetaData(met) => (DirKeyKind::MetaData, Some(met.key.clone())),
Self::PayLaterType(_) => (DirKeyKind::PayLaterType, None),
Self::WalletType(_) => (DirKeyKind::WalletType, None),
Self::BankRedirectType(_) => (DirKeyKind::BankRedirectType, None),
Self::CryptoType(_) => (DirKeyKind::CryptoType, None),
Self::AuthenticationType(_) => (DirKeyKind::AuthenticationType, None),
Self::CaptureMethod(_) => (DirKeyKind::CaptureMethod, None),
Self::PaymentAmount(_) => (DirKeyKind::PaymentAmount, None),
Self::PaymentCurrency(_) => (DirKeyKind::PaymentCurrency, None),
Self::Connector(_) => (DirKeyKind::Connector, None),
Self::BankDebitType(_) => (DirKeyKind::BankDebitType, None),
Self::MandateAcceptanceType(_) => (DirKeyKind::MandateAcceptanceType, None),
Self::MandateType(_) => (DirKeyKind::MandateType, None),
Self::PaymentType(_) => (DirKeyKind::PaymentType, None),
Self::BusinessLabel(_) => (DirKeyKind::BusinessLabel, None),
Self::SetupFutureUsage(_) => (DirKeyKind::SetupFutureUsage, None),
Self::CardRedirectType(_) => (DirKeyKind::CardRedirectType, None),
Self::VoucherType(_) => (DirKeyKind::VoucherType, None),
Self::GiftCardType(_) => (DirKeyKind::GiftCardType, None),
Self::RealTimePaymentType(_) => (DirKeyKind::RealTimePaymentType, None),
Self::OpenBankingType(_) => (DirKeyKind::OpenBankingType, None),
Self::MobilePaymentType(_) => (DirKeyKind::MobilePaymentType, None),
};
DirKey::new(kind, data)
}
<file_sep path="hyperswitch/crates/euclid/src/frontend/dir.rs" role="context" start="340" end="476">
pub fn get_value_set(&self) -> Option<Vec<DirValue>> {
match self {
Self::PaymentMethod => Some(
enums::PaymentMethod::iter()
.map(DirValue::PaymentMethod)
.collect(),
),
Self::CardBin => None,
Self::CardType => Some(enums::CardType::iter().map(DirValue::CardType).collect()),
Self::MandateAcceptanceType => Some(
euclid_enums::MandateAcceptanceType::iter()
.map(DirValue::MandateAcceptanceType)
.collect(),
),
Self::PaymentType => Some(
euclid_enums::PaymentType::iter()
.map(DirValue::PaymentType)
.collect(),
),
Self::MandateType => Some(
euclid_enums::MandateType::iter()
.map(DirValue::MandateType)
.collect(),
),
Self::CardNetwork => Some(
enums::CardNetwork::iter()
.map(DirValue::CardNetwork)
.collect(),
),
Self::PayLaterType => Some(
enums::PayLaterType::iter()
.map(DirValue::PayLaterType)
.collect(),
),
Self::MetaData => None,
Self::WalletType => Some(
enums::WalletType::iter()
.map(DirValue::WalletType)
.collect(),
),
Self::UpiType => Some(enums::UpiType::iter().map(DirValue::UpiType).collect()),
Self::VoucherType => Some(
enums::VoucherType::iter()
.map(DirValue::VoucherType)
.collect(),
),
Self::BankTransferType => Some(
enums::BankTransferType::iter()
.map(DirValue::BankTransferType)
.collect(),
),
Self::GiftCardType => Some(
enums::GiftCardType::iter()
.map(DirValue::GiftCardType)
.collect(),
),
Self::BankRedirectType => Some(
enums::BankRedirectType::iter()
.map(DirValue::BankRedirectType)
.collect(),
),
Self::CryptoType => Some(
enums::CryptoType::iter()
.map(DirValue::CryptoType)
.collect(),
),
Self::RewardType => Some(
enums::RewardType::iter()
.map(DirValue::RewardType)
.collect(),
),
Self::PaymentAmount => None,
Self::PaymentCurrency => Some(
enums::PaymentCurrency::iter()
.map(DirValue::PaymentCurrency)
.collect(),
),
Self::AuthenticationType => Some(
enums::AuthenticationType::iter()
.map(DirValue::AuthenticationType)
.collect(),
),
Self::CaptureMethod => Some(
enums::CaptureMethod::iter()
.map(DirValue::CaptureMethod)
.collect(),
),
Self::BankDebitType => Some(
enums::BankDebitType::iter()
.map(DirValue::BankDebitType)
.collect(),
),
Self::BusinessCountry => Some(
enums::Country::iter()
.map(DirValue::BusinessCountry)
.collect(),
),
Self::BillingCountry => Some(
enums::Country::iter()
.map(DirValue::BillingCountry)
.collect(),
),
Self::Connector => Some(
common_enums::RoutableConnectors::iter()
.map(|connector| {
DirValue::Connector(Box::new(ast::ConnectorChoice { connector }))
})
.collect(),
),
Self::BusinessLabel => None,
Self::SetupFutureUsage => Some(
enums::SetupFutureUsage::iter()
.map(DirValue::SetupFutureUsage)
.collect(),
),
Self::CardRedirectType => Some(
enums::CardRedirectType::iter()
.map(DirValue::CardRedirectType)
.collect(),
),
Self::RealTimePaymentType => Some(
enums::RealTimePaymentType::iter()
.map(DirValue::RealTimePaymentType)
.collect(),
),
Self::OpenBankingType => Some(
enums::OpenBankingType::iter()
.map(DirValue::OpenBankingType)
.collect(),
),
Self::MobilePaymentType => Some(
enums::MobilePaymentType::iter()
.map(DirValue::MobilePaymentType)
.collect(),
),
}
}
<file_sep path="hyperswitch/crates/euclid/src/frontend/dir.rs" role="context" start="74" end="288">
pub enum DirKeyKind {
#[strum(
serialize = "payment_method",
detailed_message = "Different modes of payment - eg. cards, wallets, banks",
props(Category = "Payment Methods")
)]
#[serde(rename = "payment_method")]
PaymentMethod,
#[strum(
serialize = "card_bin",
detailed_message = "First 4 to 6 digits of a payment card number",
props(Category = "Payment Methods")
)]
#[serde(rename = "card_bin")]
CardBin,
#[strum(
serialize = "card_type",
detailed_message = "Type of the payment card - eg. credit, debit",
props(Category = "Payment Methods")
)]
#[serde(rename = "card_type")]
CardType,
#[strum(
serialize = "card_network",
detailed_message = "Network that facilitates payment card transactions",
props(Category = "Payment Methods")
)]
#[serde(rename = "card_network")]
CardNetwork,
#[strum(
serialize = "pay_later",
detailed_message = "Supported types of Pay Later payment method",
props(Category = "Payment Method Types")
)]
#[serde(rename = "pay_later")]
PayLaterType,
#[strum(
serialize = "gift_card",
detailed_message = "Supported types of Gift Card payment method",
props(Category = "Payment Method Types")
)]
#[serde(rename = "gift_card")]
GiftCardType,
#[strum(
serialize = "mandate_acceptance_type",
detailed_message = "Mode of customer acceptance for mandates - online and offline",
props(Category = "Payments")
)]
#[serde(rename = "mandate_acceptance_type")]
MandateAcceptanceType,
#[strum(
serialize = "mandate_type",
detailed_message = "Type of mandate acceptance - single use and multi use",
props(Category = "Payments")
)]
#[serde(rename = "mandate_type")]
MandateType,
#[strum(
serialize = "payment_type",
detailed_message = "Indicates if a payment is mandate or non-mandate",
props(Category = "Payments")
)]
#[serde(rename = "payment_type")]
PaymentType,
#[strum(
serialize = "wallet",
detailed_message = "Supported types of Wallet payment method",
props(Category = "Payment Method Types")
)]
#[serde(rename = "wallet")]
WalletType,
#[strum(
serialize = "upi",
detailed_message = "Supported types of UPI payment method",
props(Category = "Payment Method Types")
)]
#[serde(rename = "upi")]
UpiType,
#[strum(
serialize = "voucher",
detailed_message = "Supported types of Voucher payment method",
props(Category = "Payment Method Types")
)]
#[serde(rename = "voucher")]
VoucherType,
#[strum(
serialize = "bank_transfer",
detailed_message = "Supported types of Bank Transfer payment method",
props(Category = "Payment Method Types")
)]
#[serde(rename = "bank_transfer")]
BankTransferType,
#[strum(
serialize = "bank_redirect",
detailed_message = "Supported types of Bank Redirect payment methods",
props(Category = "Payment Method Types")
)]
#[serde(rename = "bank_redirect")]
BankRedirectType,
#[strum(
serialize = "bank_debit",
detailed_message = "Supported types of Bank Debit payment method",
props(Category = "Payment Method Types")
)]
#[serde(rename = "bank_debit")]
BankDebitType,
#[strum(
serialize = "crypto",
detailed_message = "Supported types of Crypto payment method",
props(Category = "Payment Method Types")
)]
#[serde(rename = "crypto")]
CryptoType,
#[strum(
serialize = "metadata",
detailed_message = "Aribitrary Key and value pair",
props(Category = "Metadata")
)]
#[serde(rename = "metadata")]
MetaData,
#[strum(
serialize = "reward",
detailed_message = "Supported types of Reward payment method",
props(Category = "Payment Method Types")
)]
#[serde(rename = "reward")]
RewardType,
#[strum(
serialize = "amount",
detailed_message = "Value of the transaction",
props(Category = "Payments")
)]
#[serde(rename = "amount")]
PaymentAmount,
#[strum(
serialize = "currency",
detailed_message = "Currency used for the payment",
props(Category = "Payments")
)]
#[serde(rename = "currency")]
PaymentCurrency,
#[strum(
serialize = "authentication_type",
detailed_message = "Type of authentication for the payment",
props(Category = "Payments")
)]
#[serde(rename = "authentication_type")]
AuthenticationType,
#[strum(
serialize = "capture_method",
detailed_message = "Modes of capturing a payment",
props(Category = "Payments")
)]
#[serde(rename = "capture_method")]
CaptureMethod,
#[strum(
serialize = "country",
serialize = "business_country",
detailed_message = "Country of the business unit",
props(Category = "Merchant")
)]
#[serde(rename = "business_country", alias = "country")]
BusinessCountry,
#[strum(
serialize = "billing_country",
detailed_message = "Country of the billing address of the customer",
props(Category = "Customer")
)]
#[serde(rename = "billing_country")]
BillingCountry,
#[serde(skip_deserializing, rename = "connector")]
Connector,
#[strum(
serialize = "business_label",
detailed_message = "Identifier for business unit",
props(Category = "Merchant")
)]
#[serde(rename = "business_label")]
BusinessLabel,
#[strum(
serialize = "setup_future_usage",
detailed_message = "Identifier for recurring payments",
props(Category = "Payments")
)]
#[serde(rename = "setup_future_usage")]
SetupFutureUsage,
#[strum(
serialize = "card_redirect",
detailed_message = "Supported types of Card Redirect payment method",
props(Category = "Payment Method Types")
)]
#[serde(rename = "card_redirect")]
CardRedirectType,
#[serde(rename = "real_time_payment")]
#[strum(
serialize = "real_time_payment",
detailed_message = "Supported types of real time payment method",
props(Category = "Payment Method Types")
)]
RealTimePaymentType,
#[serde(rename = "open_banking")]
#[strum(
serialize = "open_banking",
detailed_message = "Supported types of open banking payment method",
props(Category = "Payment Method Types")
)]
OpenBankingType,
#[serde(rename = "mobile_payment")]
#[strum(
serialize = "mobile_payment",
detailed_message = "Supported types of mobile payment method",
props(Category = "Payment Method Types")
)]
MobilePaymentType,
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/common_utils/src/events.rs<|crate|> common_utils anchor=get_api_event_type kind=fn pack=symbol_neighborhood lang=rust role_window=k2 hops=1<|meta_end|>
<file_sep path="hyperswitch/crates/common_utils/src/events.rs" role="context" start="189" end="191">
fn get_api_event_type(&self) -> Option<ApiEventsType> {
T::get_api_event_type(self)
}
<file_sep path="hyperswitch/crates/common_utils/src/events.rs" role="context" start="159" end="161">
fn get_api_event_type(&self) -> Option<ApiEventsType> {
Some(ApiEventsType::Miscellaneous)
}
<file_sep path="hyperswitch/crates/common_utils/src/events.rs" role="context" start="149" end="154">
fn get_api_event_type(&self) -> Option<ApiEventsType> {
match self {
Ok(q) => q.get_api_event_type(),
Err(_) => None,
}
}
<file_sep path="hyperswitch/crates/common_utils/src/events.rs" role="context" start="13" end="125">
pub enum ApiEventsType {
Payout {
payout_id: String,
},
#[cfg(feature = "v1")]
Payment {
payment_id: id_type::PaymentId,
},
#[cfg(feature = "v2")]
Payment {
payment_id: id_type::GlobalPaymentId,
},
#[cfg(feature = "v1")]
Refund {
payment_id: Option<id_type::PaymentId>,
refund_id: String,
},
#[cfg(feature = "v2")]
Refund {
payment_id: id_type::GlobalPaymentId,
refund_id: id_type::GlobalRefundId,
},
#[cfg(feature = "v1")]
PaymentMethod {
payment_method_id: String,
payment_method: Option<common_enums::PaymentMethod>,
payment_method_type: Option<common_enums::PaymentMethodType>,
},
#[cfg(feature = "v2")]
PaymentMethod {
payment_method_id: id_type::GlobalPaymentMethodId,
payment_method_type: Option<common_enums::PaymentMethod>,
payment_method_subtype: Option<common_enums::PaymentMethodType>,
},
#[cfg(all(feature = "v2", feature = "payment_methods_v2"))]
PaymentMethodCreate,
#[cfg(all(feature = "v2", feature = "customer_v2"))]
Customer {
customer_id: Option<id_type::GlobalCustomerId>,
},
#[cfg(all(any(feature = "v1", feature = "v2"), not(feature = "customer_v2")))]
Customer {
customer_id: id_type::CustomerId,
},
BusinessProfile {
profile_id: id_type::ProfileId,
},
ApiKey {
key_id: id_type::ApiKeyId,
},
User {
user_id: String,
},
PaymentMethodList {
payment_id: Option<String>,
},
#[cfg(feature = "v2")]
PaymentMethodListForPaymentMethods {
payment_method_id: id_type::GlobalPaymentMethodId,
},
#[cfg(feature = "v1")]
Webhooks {
connector: String,
payment_id: Option<id_type::PaymentId>,
},
#[cfg(feature = "v2")]
Webhooks {
connector: id_type::MerchantConnectorAccountId,
payment_id: Option<id_type::GlobalPaymentId>,
},
Routing,
ResourceListAPI,
#[cfg(feature = "v1")]
PaymentRedirectionResponse {
connector: Option<String>,
payment_id: Option<id_type::PaymentId>,
},
#[cfg(feature = "v2")]
PaymentRedirectionResponse {
payment_id: id_type::GlobalPaymentId,
},
Gsm,
// TODO: This has to be removed once the corresponding apiEventTypes are created
Miscellaneous,
Keymanager,
RustLocker,
ApplePayCertificatesMigration,
FraudCheck,
Recon,
ExternalServiceAuth,
Dispute {
dispute_id: String,
},
Events {
merchant_id: id_type::MerchantId,
},
PaymentMethodCollectLink {
link_id: String,
},
Poll {
poll_id: String,
},
Analytics,
#[cfg(feature = "v2")]
ClientSecret {
key_id: id_type::ClientSecretId,
},
#[cfg(feature = "v2")]
PaymentMethodSession {
payment_method_session_id: id_type::GlobalPaymentMethodSessionId,
},
ProcessTracker,
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch-card-vault/src/error/container.rs<|crate|> src anchor=source kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch-card-vault/src/error/container.rs" role="context" start="26" end="28">
fn source(&self) -> Option<&(dyn Error + 'static)> {
Error::source(self.error.current_context())
}
<file_sep path="hyperswitch-card-vault/src/error/container.rs" role="context" start="25" end="25">
use std::error::Error;
<file_sep path="hyperswitch-card-vault/src/error/container.rs" role="context" start="54" end="58">
fn from(value: T) -> Self {
Self {
error: error_stack::Report::from(value),
}
}
<file_sep path="hyperswitch-card-vault/src/error/container.rs" role="context" start="41" end="46">
fn from(value: ContainerError<T>) -> Self {
let new_error = value.error.current_context().into();
Self {
error: value.error.change_context(new_error),
}
}
<file_sep path="hyperswitch-card-vault/src/error/container.rs" role="context" start="20" end="22">
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
<error_stack::Report<T> as std::fmt::Display>::fmt(&self.error, f)
}
<file_sep path="hyperswitch-card-vault/src/error/container.rs" role="context" start="14" end="16">
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
<error_stack::Report<T> as std::fmt::Debug>::fmt(&self.error, f)
}
<file_sep path="hyperswitch-encryption-service/src/types/core/identifier.rs" role="context" start="40" end="40">
type Error = error_stack::Report<errors::ParsingError>;
<file_sep path="hyperswitch/crates/api_models/src/payment_methods.rs" role="context" start="2478" end="2478">
type Error = error_stack::Report<errors::ValidationError>;
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/storage_impl/src/payouts/payouts.rs<|crate|> storage_impl anchor=from_storage_model kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/storage_impl/src/payouts/payouts.rs" role="context" start="1084" end="1086">
fn from_storage_model(_storage_model: Self::StorageModel) -> Self {
todo!("Reverse map should no longer be needed")
}
<file_sep path="hyperswitch/crates/storage_impl/src/payouts/payouts.rs" role="context" start="1035" end="1081">
fn to_storage_model(self) -> Self::StorageModel {
match self {
Self::Update {
amount,
destination_currency,
source_currency,
description,
recurring,
auto_fulfill,
return_url,
entity_type,
metadata,
profile_id,
status,
confirm,
payout_type,
address_id,
customer_id,
} => DieselPayoutsUpdate::Update {
amount,
destination_currency,
source_currency,
description,
recurring,
auto_fulfill,
return_url,
entity_type,
metadata,
profile_id,
status,
confirm,
payout_type,
address_id,
customer_id,
},
Self::PayoutMethodIdUpdate { payout_method_id } => {
DieselPayoutsUpdate::PayoutMethodIdUpdate { payout_method_id }
}
Self::RecurringUpdate { recurring } => {
DieselPayoutsUpdate::RecurringUpdate { recurring }
}
Self::AttemptCountUpdate { attempt_count } => {
DieselPayoutsUpdate::AttemptCountUpdate { attempt_count }
}
Self::StatusUpdate { status } => DieselPayoutsUpdate::StatusUpdate { status },
}
}
<file_sep path="hyperswitch/crates/storage_impl/src/payouts/payouts.rs" role="context" start="1004" end="1031">
fn from_storage_model(storage_model: Self::StorageModel) -> Self {
Self {
payout_id: storage_model.payout_id,
merchant_id: storage_model.merchant_id,
customer_id: storage_model.customer_id,
address_id: storage_model.address_id,
payout_type: storage_model.payout_type,
payout_method_id: storage_model.payout_method_id,
amount: storage_model.amount,
destination_currency: storage_model.destination_currency,
source_currency: storage_model.source_currency,
description: storage_model.description,
recurring: storage_model.recurring,
auto_fulfill: storage_model.auto_fulfill,
return_url: storage_model.return_url,
entity_type: storage_model.entity_type,
metadata: storage_model.metadata,
created_at: storage_model.created_at,
last_modified_at: storage_model.last_modified_at,
profile_id: storage_model.profile_id,
status: storage_model.status,
attempt_count: storage_model.attempt_count,
confirm: storage_model.confirm,
payout_link_id: storage_model.payout_link_id,
client_secret: storage_model.client_secret,
priority: storage_model.priority,
}
}
<file_sep path="hyperswitch/crates/storage_impl/src/payouts/payouts.rs" role="context" start="592" end="745">
async fn filter_payouts_and_attempts(
&self,
merchant_id: &common_utils::id_type::MerchantId,
filters: &PayoutFetchConstraints,
storage_scheme: MerchantStorageScheme,
) -> error_stack::Result<
Vec<(
Payouts,
PayoutAttempt,
Option<DieselCustomer>,
Option<DieselAddress>,
)>,
StorageError,
> {
let conn = connection::pg_connection_read(self).await?;
let conn = async_bb8_diesel::Connection::as_async_conn(&conn);
let mut query = DieselPayouts::table()
.inner_join(
diesel_models::schema::payout_attempt::table
.on(poa_dsl::payout_id.eq(po_dsl::payout_id)),
)
.left_join(
diesel_models::schema::customers::table
.on(cust_dsl::customer_id.nullable().eq(po_dsl::customer_id)),
)
.filter(cust_dsl::merchant_id.eq(merchant_id.to_owned()))
.left_outer_join(
diesel_models::schema::address::table
.on(add_dsl::address_id.nullable().eq(po_dsl::address_id)),
)
.filter(po_dsl::merchant_id.eq(merchant_id.to_owned()))
.order(po_dsl::created_at.desc())
.into_boxed();
query = match filters {
PayoutFetchConstraints::Single { payout_id } => {
query.filter(po_dsl::payout_id.eq(payout_id.to_owned()))
}
PayoutFetchConstraints::List(params) => {
if let Some(limit) = params.limit {
query = query.limit(limit.into());
}
if let Some(customer_id) = ¶ms.customer_id {
query = query.filter(po_dsl::customer_id.eq(customer_id.clone()));
}
if let Some(profile_id) = ¶ms.profile_id {
query = query.filter(po_dsl::profile_id.eq(profile_id.clone()));
}
query = match (params.starting_at, ¶ms.starting_after_id) {
(Some(starting_at), _) => query.filter(po_dsl::created_at.ge(starting_at)),
(None, Some(starting_after_id)) => {
// TODO: Fetch partial columns for this query since we only need some columns
let starting_at = self
.find_payout_by_merchant_id_payout_id(
merchant_id,
starting_after_id,
storage_scheme,
)
.await?
.created_at;
query.filter(po_dsl::created_at.ge(starting_at))
}
(None, None) => query,
};
query = match (params.ending_at, ¶ms.ending_before_id) {
(Some(ending_at), _) => query.filter(po_dsl::created_at.le(ending_at)),
(None, Some(ending_before_id)) => {
// TODO: Fetch partial columns for this query since we only need some columns
let ending_at = self
.find_payout_by_merchant_id_payout_id(
merchant_id,
ending_before_id,
storage_scheme,
)
.await?
.created_at;
query.filter(po_dsl::created_at.le(ending_at))
}
(None, None) => query,
};
query = query.offset(params.offset.into());
if let Some(currency) = ¶ms.currency {
query = query.filter(po_dsl::destination_currency.eq_any(currency.clone()));
}
let connectors = params
.connector
.as_ref()
.map(|c| c.iter().map(|c| c.to_string()).collect::<Vec<String>>());
query = match connectors {
Some(connectors) => query.filter(poa_dsl::connector.eq_any(connectors)),
None => query,
};
query = match ¶ms.status {
Some(status) => query.filter(po_dsl::status.eq_any(status.clone())),
None => query,
};
query = match ¶ms.payout_method {
Some(payout_method) => {
query.filter(po_dsl::payout_type.eq_any(payout_method.clone()))
}
None => query,
};
query
}
};
logger::debug!(filter = %diesel::debug_query::<diesel::pg::Pg,_>(&query).to_string());
query
.select((
po_all_columns,
poa_all_columns,
cust_all_columns.nullable(),
addr_all_columns.nullable(),
))
.get_results_async::<(
DieselPayouts,
DieselPayoutAttempt,
Option<DieselCustomer>,
Option<DieselAddress>,
)>(conn)
.await
.map(|results| {
results
.into_iter()
.map(|(pi, pa, c, add)| {
(
Payouts::from_storage_model(pi),
PayoutAttempt::from_storage_model(pa),
c,
add,
)
})
.collect()
})
.map_err(|er| {
StorageError::DatabaseError(
error_stack::report!(diesel_models::errors::DatabaseError::from(er))
.attach_printable("Error filtering payout records"),
)
.into()
})
}
<file_sep path="hyperswitch/crates/storage_impl/src/payouts/payouts.rs" role="context" start="160" end="221">
async fn update_payout(
&self,
this: &Payouts,
payout_update: PayoutsUpdate,
payout_attempt: &PayoutAttempt,
storage_scheme: MerchantStorageScheme,
) -> error_stack::Result<Payouts, StorageError> {
let key = PartitionKey::MerchantIdPayoutId {
merchant_id: &this.merchant_id,
payout_id: &this.payout_id,
};
let field = format!("po_{}", this.payout_id);
let storage_scheme = Box::pin(decide_storage_scheme::<_, DieselPayouts>(
self,
storage_scheme,
Op::Update(key.clone(), &field, None),
))
.await;
match storage_scheme {
MerchantStorageScheme::PostgresOnly => {
self.router_store
.update_payout(this, payout_update, payout_attempt, storage_scheme)
.await
}
MerchantStorageScheme::RedisKv => {
let key_str = key.to_string();
let diesel_payout_update = payout_update.to_storage_model();
let origin_diesel_payout = this.clone().to_storage_model();
let diesel_payout = diesel_payout_update
.clone()
.apply_changeset(origin_diesel_payout.clone());
// Check for database presence as well Maybe use a read replica here ?
let redis_value = diesel_payout
.encode_to_string_of_json()
.change_context(StorageError::SerializationFailed)?;
let redis_entry = kv::TypedSql {
op: kv::DBOperation::Update {
updatable: Box::new(kv::Updateable::PayoutsUpdate(kv::PayoutsUpdateMems {
orig: origin_diesel_payout,
update_data: diesel_payout_update,
})),
},
};
Box::pin(kv_wrapper::<(), _, _>(
self,
KvOperation::<DieselPayouts>::Hset((&field, redis_value), redis_entry),
key,
))
.await
.map_err(|err| err.to_redis_failed_response(&key_str))?
.try_into_hset()
.change_context(StorageError::KVError)?;
Ok(Payouts::from_storage_model(diesel_payout))
}
}
}
<file_sep path="hyperswitch/crates/storage_impl/src/payouts/payouts.rs" role="context" start="912" end="912">
type StorageModel = DieselPayouts;
<file_sep path="hyperswitch/postman/collection-dir/powertranz/Flow Testcases/Happy Cases/Scenario1-Create payment with confirm true/Payments - Create/event.test.js" role="context" start="61" end="78">
"INFO - Unable to assign variable {{client_secret}}, as jsonData.client_secret is undefined.",
);
}
// Response body should have value "succeeded" for "status"
if (jsonData?.status) {
pm.test(
"[POST]::/payments - Content check if value for 'status' matches 'succeeded'",
function () {
pm.expect(jsonData.status).to.eql("succeeded");
},
);
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch-card-vault/src/crypto/keymanager/internal_keymanager.rs<|crate|> src anchor=from_secret_key kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch-card-vault/src/crypto/keymanager/internal_keymanager.rs" role="context" start="57" end="59">
fn from_secret_key(key: Secret<Vec<u8>>) -> Self {
Self(GcmAes256::new(key.expose()))
}
<file_sep path="hyperswitch-card-vault/src/crypto/keymanager/internal_keymanager.rs" role="context" start="56" end="56">
use masking::{ExposeInterface, PeekInterface, Secret, StrongSecret};
use crate::{
app::TenantAppState,
crypto::{
encryption_manager::{encryption_interface::Encryption, managers::aes::GcmAes256},
keymanager::CryptoOperationsManager,
},
error::{self, ContainerError},
storage::MerchantInterface,
};
<file_sep path="hyperswitch-card-vault/src/crypto/keymanager/internal_keymanager.rs" role="context" start="68" end="77">
async fn encrypt_data(
&self,
_tenant_app_state: &TenantAppState,
decryted_data: StrongSecret<Vec<u8>>,
) -> Result<Secret<Vec<u8>>, ContainerError<error::ApiError>> {
Ok(self
.get_inner()
.encrypt(decryted_data.peek().clone())?
.into())
}
<file_sep path="hyperswitch-card-vault/src/crypto/keymanager/internal_keymanager.rs" role="context" start="61" end="63">
fn get_inner(&self) -> &GcmAes256 {
&self.0
}
<file_sep path="hyperswitch-card-vault/src/crypto/keymanager/internal_keymanager.rs" role="context" start="33" end="51">
async fn find_or_create_entity(
&self,
tenant_app_state: &TenantAppState,
entity_id: String,
) -> Result<Box<dyn CryptoOperationsManager>, ContainerError<error::ApiError>> {
let master_encryption =
GcmAes256::new(tenant_app_state.config.tenant_secrets.master_key.clone());
let entity = tenant_app_state
.db
.find_or_create_by_merchant_id(&entity_id, &master_encryption)
.await;
let response = entity
.map(|inner| InternalCryptoManager::from_secret_key(inner.enc_key))
.map(Box::new)?;
Ok(response)
}
<file_sep path="hyperswitch-card-vault/src/crypto/keymanager/internal_keymanager.rs" role="context" start="17" end="31">
async fn find_by_entity_id(
&self,
tenant_app_state: &TenantAppState,
entity_id: String,
) -> Result<Box<dyn CryptoOperationsManager>, ContainerError<error::ApiError>> {
let master_encryption =
GcmAes256::new(tenant_app_state.config.tenant_secrets.master_key.clone());
Ok(tenant_app_state
.db
.find_by_merchant_id(&entity_id, &master_encryption)
.await
.map(|inner| InternalCryptoManager::from_secret_key(inner.enc_key))
.map(Box::new)?)
}
<file_sep path="hyperswitch-encryption-service/src/crypto/aes256.rs" role="context" start="19" end="21">
pub struct GcmAes256 {
key: StrongSecret<[u8; 32]>,
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch-encryption-service/src/types/core/key.rs<|crate|> src anchor=type_check kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=1<|meta_end|>
<file_sep path="hyperswitch-encryption-service/src/types/core/key.rs" role="context" start="239" end="241">
fn type_check(typ: &ColumnType<'_>) -> Result<(), scylla::deserialize::TypeCheckError> {
i32::type_check(typ)
}
<file_sep path="hyperswitch-encryption-service/src/types/core/key.rs" role="context" start="238" end="238">
use diesel::{
backend::Backend,
deserialize::{self, FromSql},
expression::AsExpression,
serialize::ToSql,
sql_types, Queryable,
};
use charybdis::scylla::SerializeValue;
use scylla::{
deserialize::{DeserializeValue, FrameSlice},
frame::response::result::ColumnType,
};
<file_sep path="hyperswitch-encryption-service/src/types/core/key.rs" role="context" start="258" end="275">
fn test_version_deserialize() {
#[derive(Debug, serde::Serialize, Deserialize, PartialEq, Eq)]
struct Data {
version: Version,
}
let version = serde_json::json!({
"version": "v1"
});
let actual: Data = serde_json::from_value(version).expect("Failed to deserialize version");
let expected = Data {
version: Version(1),
};
assert_eq!(actual, expected)
}
<file_sep path="hyperswitch-encryption-service/src/types/core/key.rs" role="context" start="243" end="249">
fn deserialize(
typ: &'metadata ColumnType<'metadata>,
cql_val: Option<FrameSlice<'frame>>,
) -> Result<Self, scylla::deserialize::DeserializationError> {
let int = <i32 as DeserializeValue<'frame, 'metadata>>::deserialize(typ, cql_val)?;
Ok(Self::from(int))
}
<file_sep path="hyperswitch-encryption-service/src/types/core/key.rs" role="context" start="233" end="235">
fn build(row: Self::Row) -> deserialize::Result<Self> {
Ok(Self::from(row))
}
<file_sep path="hyperswitch-encryption-service/src/types/core/key.rs" role="context" start="219" end="224">
fn to_sql<'b>(
&'b self,
out: &mut diesel::serialize::Output<'b, '_, DB>,
) -> diesel::serialize::Result {
self.0.to_sql(out)
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch-encryption-service/src/types/core/key.rs<|crate|> src anchor=from_sql kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=1<|meta_end|>
<file_sep path="hyperswitch-encryption-service/src/types/core/key.rs" role="context" start="209" end="211">
fn from_sql(bytes: DB::RawValue<'_>) -> deserialize::Result<Self> {
i32::from_sql(bytes).map(Self::from)
}
<file_sep path="hyperswitch-encryption-service/src/types/core/key.rs" role="context" start="208" end="208">
use diesel::{
backend::Backend,
deserialize::{self, FromSql},
expression::AsExpression,
serialize::ToSql,
sql_types, Queryable,
};
use scylla::{
deserialize::{DeserializeValue, FrameSlice},
frame::response::result::ColumnType,
};
<file_sep path="hyperswitch-encryption-service/src/types/core/key.rs" role="context" start="233" end="235">
fn build(row: Self::Row) -> deserialize::Result<Self> {
Ok(Self::from(row))
}
<file_sep path="hyperswitch-encryption-service/src/types/core/key.rs" role="context" start="219" end="224">
fn to_sql<'b>(
&'b self,
out: &mut diesel::serialize::Output<'b, '_, DB>,
) -> diesel::serialize::Result {
self.0.to_sql(out)
}
<file_sep path="hyperswitch-encryption-service/src/types/core/key.rs" role="context" start="199" end="201">
fn from(v: i32) -> Self {
Self(v)
}
<file_sep path="hyperswitch-encryption-service/src/types/core/key.rs" role="context" start="193" end="195">
fn default() -> Self {
Self(1)
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/euclid/src/backend/interpreter/types.rs<|crate|> euclid anchor=fmt kind=fn pack=symbol_neighborhood lang=rust role_window=k2 hops=1<|meta_end|>
<file_sep path="hyperswitch/crates/euclid/src/backend/interpreter/types.rs" role="context" start="23" end="25">
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
InterpreterErrorType::fmt(&self.error_type, f)
}
<file_sep path="hyperswitch/crates/euclid/src/backend/interpreter/types.rs" role="context" start="22" end="22">
use std::{collections::HashMap, fmt, ops::Deref, string::ToString};
<file_sep path="hyperswitch/crates/euclid/src/backend/interpreter/types.rs" role="context" start="39" end="80">
fn from(input: inputs::BackendInput) -> Self {
let ctx = HashMap::<String, Option<ValueType>>::from_iter([
(
EuclidKey::PaymentMethod.to_string(),
input
.payment_method
.payment_method
.map(|pm| ValueType::EnumVariant(pm.to_string())),
),
(
EuclidKey::PaymentMethodType.to_string(),
input
.payment_method
.payment_method_type
.map(|pt| ValueType::EnumVariant(pt.to_string())),
),
(
EuclidKey::AuthenticationType.to_string(),
input
.payment
.authentication_type
.map(|at| ValueType::EnumVariant(at.to_string())),
),
(
EuclidKey::CaptureMethod.to_string(),
input
.payment
.capture_method
.map(|cm| ValueType::EnumVariant(cm.to_string())),
),
(
EuclidKey::PaymentAmount.to_string(),
Some(ValueType::Number(input.payment.amount)),
),
(
EuclidKey::PaymentCurrency.to_string(),
Some(ValueType::EnumVariant(input.payment.currency.to_string())),
),
]);
Self(ctx)
}
<file_sep path="hyperswitch/crates/euclid/src/backend/interpreter/types.rs" role="context" start="33" end="35">
fn deref(&self) -> &Self::Target {
&self.0
}
<file_sep path="hyperswitch/crates/euclid/src/backend/interpreter/types.rs" role="context" start="9" end="14">
pub enum InterpreterErrorType {
#[error("Invalid key received '{0}'")]
InvalidKey(String),
#[error("Invalid Comparison")]
InvalidComparison,
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/masking/src/cassandra.rs<|crate|> masking anchor=type_check kind=fn pack=symbol_neighborhood lang=rust role_window=k2 hops=1<|meta_end|>
<file_sep path="hyperswitch/crates/masking/src/cassandra.rs" role="context" start="30" end="32">
fn type_check(column_type: &ColumnType<'_>) -> Result<(), scylla::deserialize::TypeCheckError> {
T::type_check(column_type)
}
<file_sep path="hyperswitch/crates/masking/src/cassandra.rs" role="context" start="29" end="29">
use scylla::{
deserialize::DeserializeValue,
frame::response::result::ColumnType,
serialize::{
value::SerializeValue,
writers::{CellWriter, WrittenCellProof},
SerializationError,
},
};
<file_sep path="hyperswitch/crates/masking/src/cassandra.rs" role="context" start="34" end="39">
fn deserialize(
column_type: &'metadata ColumnType<'metadata>,
v: Option<scylla::deserialize::FrameSlice<'frame>>,
) -> Result<Self, scylla::deserialize::DeserializationError> {
Ok(Self::new(T::deserialize(column_type, v)?))
}
<file_sep path="hyperswitch/crates/masking/src/cassandra.rs" role="context" start="17" end="23">
fn serialize<'b>(
&self,
column_type: &ColumnType<'_>,
writer: CellWriter<'b>,
) -> Result<WrittenCellProof<'b>, SerializationError> {
self.peek().serialize(column_type, writer)
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/common_utils/src/id_type/global_id/refunds.rs<|crate|> common_utils anchor=from_sql kind=fn pack=symbol_neighborhood lang=rust role_window=k2 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/common_utils/src/id_type/global_id/refunds.rs" role="context" start="68" end="70">
fn from_sql(value: DB::RawValue<'_>) -> diesel::deserialize::Result<Self> {
super::GlobalId::from_sql(value).map(Self)
}
<file_sep path="hyperswitch/crates/common_utils/src/id_type/global_id/refunds.rs" role="context" start="55" end="60">
fn to_sql<'b>(
&'b self,
out: &mut diesel::serialize::Output<'b, '_, DB>,
) -> diesel::serialize::Result {
self.0.to_sql(out)
}
<file_sep path="hyperswitch/crates/common_utils/src/id_type/global_id/refunds.rs" role="context" start="38" end="46">
fn try_from(value: std::borrow::Cow<'static, str>) -> Result<Self, Self::Error> {
use error_stack::ResultExt;
let merchant_ref_id = super::GlobalId::from_string(value).change_context(
errors::ValidationError::IncorrectValueProvided {
field_name: "refund_id",
},
)?;
Ok(Self(merchant_ref_id))
}
<file_sep path="hyperswitch/crates/common_utils/src/id_type/global_id.rs" role="context" start="19" end="19">
pub(crate) struct GlobalId(LengthId<MAX_GLOBAL_ID_LENGTH, MIN_GLOBAL_ID_LENGTH>);
<file_sep path="hyperswitch/postman/collection-dir/powertranz/Flow Testcases/Happy Cases/Scenario1-Create payment with confirm true/Payments - Create/event.test.js" role="context" start="61" end="78">
"INFO - Unable to assign variable {{client_secret}}, as jsonData.client_secret is undefined.",
);
}
// Response body should have value "succeeded" for "status"
if (jsonData?.status) {
pm.test(
"[POST]::/payments - Content check if value for 'status' matches 'succeeded'",
function () {
pm.expect(jsonData.status).to.eql("succeeded");
},
);
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/common_utils/src/types.rs<|crate|> common_utils anchor=from_sql kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=1<|meta_end|>
<file_sep path="hyperswitch/crates/common_utils/src/types.rs" role="context" start="1518" end="1521">
fn from_sql(bytes: DB::RawValue<'_>) -> deserialize::Result<Self> {
let val = String::from_sql(bytes)?;
Ok(Self::from(val))
}
<file_sep path="hyperswitch/crates/common_utils/src/types.rs" role="context" start="1517" end="1517">
use diesel::{
backend::Backend,
deserialize,
deserialize::FromSql,
serialize::{Output, ToSql},
sql_types,
sql_types::Jsonb,
AsExpression, FromSqlRow, Queryable,
};
<file_sep path="hyperswitch/crates/common_utils/src/types.rs" role="context" start="1539" end="1541">
fn get_optional_connector_transaction_id(&self) -> Option<&String> {
None
}
<file_sep path="hyperswitch/crates/common_utils/src/types.rs" role="context" start="1529" end="1533">
fn to_sql<'b>(&'b self, out: &mut Output<'b, '_, DB>) -> diesel::serialize::Result {
match self {
Self::HashedData(id) | Self::TxnId(id) => id.to_sql(out),
}
}
<file_sep path="hyperswitch/crates/common_utils/src/types.rs" role="context" start="1508" end="1510">
fn build(row: Self::Row) -> deserialize::Result<Self> {
Ok(row)
}
<file_sep path="hyperswitch/crates/common_utils/src/types.rs" role="context" start="1482" end="1498">
fn from(src: String) -> Self {
// ID already hashed
if src.starts_with("hs_hash_") {
Self::HashedData(src)
// Hash connector's transaction ID
} else if src.len() > 128 {
let mut hasher = blake3::Hasher::new();
let mut output = [0u8; consts::CONNECTOR_TRANSACTION_ID_HASH_BYTES];
hasher.update(src.as_bytes());
hasher.finalize_xof().fill(&mut output);
let hash = hex::encode(output);
Self::HashedData(format!("hs_hash_{}", hash))
// Default
} else {
Self::TxnId(src)
}
}
<file_sep path="hyperswitch/crates/common_utils/src/types.rs" role="context" start="1591" end="1594">
fn from_sql(bytes: DB::RawValue<'_>) -> deserialize::Result<Self> {
let val = LengthString::<PUBLISHABLE_KEY_LENGTH, PUBLISHABLE_KEY_LENGTH>::from_sql(bytes)?;
Ok(Self(val))
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/common_utils/src/types.rs<|crate|> common_utils anchor=from_sql kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=1<|meta_end|>
<file_sep path="hyperswitch/crates/common_utils/src/types.rs" role="context" start="1350" end="1353">
fn from_sql(bytes: DB::RawValue<'_>) -> deserialize::Result<Self> {
let val = String::from_sql(bytes)?;
Ok(Self::try_from(val)?)
}
<file_sep path="hyperswitch/crates/common_utils/src/types.rs" role="context" start="1349" end="1349">
use diesel::{
backend::Backend,
deserialize,
deserialize::FromSql,
serialize::{Output, ToSql},
sql_types,
sql_types::Jsonb,
AsExpression, FromSqlRow, Queryable,
};
<file_sep path="hyperswitch/crates/common_utils/src/types.rs" role="context" start="1447" end="1451">
pub fn get_id(&self) -> &String {
match self {
Self::TxnId(id) | Self::HashedData(id) => id,
}
}
<file_sep path="hyperswitch/crates/common_utils/src/types.rs" role="context" start="1361" end="1363">
fn to_sql<'b>(&'b self, out: &mut Output<'b, '_, DB>) -> diesel::serialize::Result {
self.0.to_sql(out)
}
<file_sep path="hyperswitch/crates/common_utils/src/types.rs" role="context" start="1341" end="1343">
fn build(row: Self::Row) -> deserialize::Result<Self> {
Ok(row)
}
<file_sep path="hyperswitch/crates/common_utils/src/types.rs" role="context" start="1323" end="1331">
fn try_from(src: String) -> Result<Self, Self::Error> {
if src.len() > 1024 {
Err(report!(ValidationError::InvalidValue {
message: "unified_message's length should not exceed 1024 characters".to_string()
}))
} else {
Ok(Self(src))
}
}
<file_sep path="hyperswitch/crates/common_utils/src/types.rs" role="context" start="1591" end="1594">
fn from_sql(bytes: DB::RawValue<'_>) -> deserialize::Result<Self> {
let val = LengthString::<PUBLISHABLE_KEY_LENGTH, PUBLISHABLE_KEY_LENGTH>::from_sql(bytes)?;
Ok(Self(val))
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/common_utils/src/types.rs<|crate|> common_utils anchor=from_sql kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=1<|meta_end|>
<file_sep path="hyperswitch/crates/common_utils/src/types.rs" role="context" start="1298" end="1301">
fn from_sql(bytes: DB::RawValue<'_>) -> deserialize::Result<Self> {
let val = String::from_sql(bytes)?;
Ok(Self::try_from(val)?)
}
<file_sep path="hyperswitch/crates/common_utils/src/types.rs" role="context" start="1297" end="1297">
use diesel::{
backend::Backend,
deserialize,
deserialize::FromSql,
serialize::{Output, ToSql},
sql_types,
sql_types::Jsonb,
AsExpression, FromSqlRow, Queryable,
};
<file_sep path="hyperswitch/crates/common_utils/src/types.rs" role="context" start="1323" end="1331">
fn try_from(src: String) -> Result<Self, Self::Error> {
if src.len() > 1024 {
Err(report!(ValidationError::InvalidValue {
message: "unified_message's length should not exceed 1024 characters".to_string()
}))
} else {
Ok(Self(src))
}
}
<file_sep path="hyperswitch/crates/common_utils/src/types.rs" role="context" start="1309" end="1311">
fn to_sql<'b>(&'b self, out: &mut Output<'b, '_, DB>) -> diesel::serialize::Result {
self.0.to_sql(out)
}
<file_sep path="hyperswitch/crates/common_utils/src/types.rs" role="context" start="1289" end="1291">
fn build(row: Self::Row) -> deserialize::Result<Self> {
Ok(row)
}
<file_sep path="hyperswitch/crates/common_utils/src/types.rs" role="context" start="1271" end="1279">
fn try_from(src: String) -> Result<Self, Self::Error> {
if src.len() > 255 {
Err(report!(ValidationError::InvalidValue {
message: "unified_code's length should not exceed 255 characters".to_string()
}))
} else {
Ok(Self(src))
}
}
<file_sep path="hyperswitch/crates/common_utils/src/types.rs" role="context" start="1591" end="1594">
fn from_sql(bytes: DB::RawValue<'_>) -> deserialize::Result<Self> {
let val = LengthString::<PUBLISHABLE_KEY_LENGTH, PUBLISHABLE_KEY_LENGTH>::from_sql(bytes)?;
Ok(Self(val))
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/common_utils/src/encryption.rs<|crate|> common_utils anchor=from_sql kind=fn pack=symbol_neighborhood lang=rust role_window=k2 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/common_utils/src/encryption.rs" role="context" start="17" end="19">
fn from_sql(bytes: DB::RawValue<'_>) -> deserialize::Result<Self> {
<Secret<Vec<u8>, EncryptionStrategy>>::from_sql(bytes).map(Self::new)
}
<file_sep path="hyperswitch/crates/common_utils/src/encryption.rs" role="context" start="16" end="16">
use diesel::{
backend::Backend,
deserialize::{self, FromSql, Queryable},
expression::AsExpression,
serialize::ToSql,
sql_types,
};
use masking::Secret;
use crate::{crypto::Encryptable, pii::EncryptionStrategy};
<file_sep path="hyperswitch/crates/common_utils/src/encryption.rs" role="context" start="41" end="43">
fn build(row: Self::Row) -> deserialize::Result<Self> {
Ok(Self { inner: row })
}
<file_sep path="hyperswitch/crates/common_utils/src/encryption.rs" role="context" start="27" end="32">
fn to_sql<'b>(
&'b self,
out: &mut diesel::serialize::Output<'b, '_, DB>,
) -> diesel::serialize::Result {
self.get_inner().to_sql(out)
}
<file_sep path="hyperswitch/crates/common_utils/src/pii.rs" role="context" start="151" end="151">
pub enum EncryptionStrategy {}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/euclid/src/backend/vir_interpreter.rs<|crate|> euclid anchor=eval_condition kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/euclid/src/backend/vir_interpreter.rs" role="context" start="38" end="40">
fn eval_condition(cond: &vir::ValuedIfCondition, ctx: &types::Context) -> bool {
cond.iter().all(|comp| Self::eval_comparison(comp, ctx))
}
<file_sep path="hyperswitch/crates/euclid/src/backend/vir_interpreter.rs" role="context" start="37" end="37">
use crate::{
backend::{self, inputs, EuclidBackend},
frontend::{
ast,
dir::{self, EuclidDirFilter},
vir,
},
};
<file_sep path="hyperswitch/crates/euclid/src/backend/vir_interpreter.rs" role="context" start="54" end="58">
fn eval_rule(rule: &vir::ValuedRule<O>, ctx: &types::Context) -> bool {
rule.statements
.iter()
.any(|stmt| Self::eval_statement(stmt, ctx))
}
<file_sep path="hyperswitch/crates/euclid/src/backend/vir_interpreter.rs" role="context" start="42" end="52">
fn eval_statement(stmt: &vir::ValuedIfStatement, ctx: &types::Context) -> bool {
if Self::eval_condition(&stmt.condition, ctx) {
{
stmt.nested.as_ref().map_or(true, |nested_stmts| {
nested_stmts.iter().any(|s| Self::eval_statement(s, ctx))
})
}
} else {
false
}
}
<file_sep path="hyperswitch/crates/euclid/src/backend/vir_interpreter.rs" role="context" start="26" end="35">
fn eval_comparison(comp: &vir::ValuedComparison, ctx: &types::Context) -> bool {
match &comp.logic {
vir::ValuedComparisonLogic::PositiveDisjunction => {
comp.values.iter().any(|v| ctx.check_presence(v))
}
vir::ValuedComparisonLogic::NegativeConjunction => {
comp.values.iter().all(|v| !ctx.check_presence(v))
}
}
}
<file_sep path="hyperswitch/crates/euclid/src/backend/interpreter/types.rs" role="context" start="28" end="28">
pub struct Context(HashMap<String, Option<ValueType>>);
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/common_utils/src/request.rs<|crate|> common_utils anchor=default_request_headers kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=1<|meta_end|>
<file_sep path="hyperswitch/crates/common_utils/src/request.rs" role="context" start="27" end="31">
fn default_request_headers() -> [(String, Maskable<String>); 1] {
use http::header;
[(header::VIA.to_string(), "HyperSwitch".to_string().into())]
}
<file_sep path="hyperswitch/crates/common_utils/src/request.rs" role="context" start="26" end="26">
use masking::{Maskable, Secret};
use serde::{Deserialize, Serialize};
pub type Headers = std::collections::HashSet<(String, Maskable<String>)>;
<file_sep path="hyperswitch/crates/common_utils/src/request.rs" role="context" start="64" end="72">
pub fn get_inner_value(&self) -> Secret<String> {
match self {
Self::Json(i) => serde_json::to_string(&i).unwrap_or_default().into(),
Self::FormUrlEncoded(i) => serde_urlencoded::to_string(i).unwrap_or_default().into(),
Self::Xml(i) => quick_xml::se::to_string(&i).unwrap_or_default().into(),
Self::FormData(_) => String::new().into(),
Self::RawBytes(_) => String::new().into(),
}
}
<file_sep path="hyperswitch/crates/common_utils/src/request.rs" role="context" start="44" end="52">
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str(match self {
Self::Json(_) => "JsonRequestBody",
Self::FormUrlEncoded(_) => "FormUrlEncodedRequestBody",
Self::FormData(_) => "FormDataRequestBody",
Self::Xml(_) => "XmlRequestBody",
Self::RawBytes(_) => "RawBytesRequestBody",
})
}
<file_sep path="hyperswitch/crates/common_utils/src/request.rs" role="context" start="140" end="143">
pub fn attach_default_headers(mut self) -> Self {
self.headers.extend(default_request_headers());
self
}
<file_sep path="hyperswitch/crates/common_utils/src/request.rs" role="context" start="91" end="93">
pub fn add_default_headers(&mut self) {
self.headers.extend(default_request_headers());
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/euclid/src/backend/vir_interpreter.rs<|crate|> euclid anchor=eval_rule kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/euclid/src/backend/vir_interpreter.rs" role="context" start="54" end="58">
fn eval_rule(rule: &vir::ValuedRule<O>, ctx: &types::Context) -> bool {
rule.statements
.iter()
.any(|stmt| Self::eval_statement(stmt, ctx))
}
<file_sep path="hyperswitch/crates/euclid/src/backend/vir_interpreter.rs" role="context" start="53" end="53">
use crate::{
backend::{self, inputs, EuclidBackend},
frontend::{
ast,
dir::{self, EuclidDirFilter},
vir,
},
};
<file_sep path="hyperswitch/crates/euclid/src/backend/vir_interpreter.rs" role="context" start="87" end="97">
fn with_program(program: ast::Program<O>) -> Result<Self, Self::Error> {
let dir_program = ast::lowering::lower_program(program)
.map_err(types::VirInterpreterError::LoweringError)?;
let vir_program = dir::lowering::lower_program(dir_program)
.map_err(types::VirInterpreterError::LoweringError)?;
Ok(Self {
program: vir_program,
})
}
<file_sep path="hyperswitch/crates/euclid/src/backend/vir_interpreter.rs" role="context" start="60" end="78">
fn eval_program(
program: &vir::ValuedProgram<O>,
ctx: &types::Context,
) -> backend::BackendOutput<O> {
program
.rules
.iter()
.find(|rule| Self::eval_rule(rule, ctx))
.map_or_else(
|| backend::BackendOutput {
connector_selection: program.default_selection.clone(),
rule_name: None,
},
|rule| backend::BackendOutput {
connector_selection: rule.connector_selection.clone(),
rule_name: Some(rule.name.clone()),
},
)
}
<file_sep path="hyperswitch/crates/euclid/src/backend/vir_interpreter.rs" role="context" start="42" end="52">
fn eval_statement(stmt: &vir::ValuedIfStatement, ctx: &types::Context) -> bool {
if Self::eval_condition(&stmt.condition, ctx) {
{
stmt.nested.as_ref().map_or(true, |nested_stmts| {
nested_stmts.iter().any(|s| Self::eval_statement(s, ctx))
})
}
} else {
false
}
}
<file_sep path="hyperswitch/crates/euclid/src/backend/vir_interpreter.rs" role="context" start="38" end="40">
fn eval_condition(cond: &vir::ValuedIfCondition, ctx: &types::Context) -> bool {
cond.iter().all(|comp| Self::eval_comparison(comp, ctx))
}
<file_sep path="hyperswitch/crates/euclid/src/backend/interpreter/types.rs" role="context" start="28" end="28">
pub struct Context(HashMap<String, Option<ValueType>>);
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/hyperswitch_constraint_graph/src/dense_map.rs<|crate|> hyperswitch_constraint_graph anchor=from_iter kind=fn pack=symbol_neighborhood lang=rust role_window=k2 hops=1<|meta_end|>
<file_sep path="hyperswitch/crates/hyperswitch_constraint_graph/src/dense_map.rs" role="context" start="233" end="241">
fn from_iter<T>(iter: T) -> Self
where
T: IntoIterator<Item = V>,
{
Self {
data: Vec::from_iter(iter),
_marker: PhantomData,
}
}
<file_sep path="hyperswitch/crates/hyperswitch_constraint_graph/src/dense_map.rs" role="context" start="232" end="232">
use std::{fmt, iter, marker::PhantomData, ops, slice, vec};
<file_sep path="hyperswitch/crates/hyperswitch_constraint_graph/src/dense_map.rs" role="context" start="224" end="226">
fn into_iter(self) -> Self::IntoIter {
IntoIter::new(self.data.into_iter())
}
<file_sep path="hyperswitch/crates/hyperswitch_constraint_graph/src/dense_map.rs" role="context" start="212" end="214">
fn next(&mut self) -> Option<Self::Item> {
self.inner.next().map(|(id, val)| (K::with_id(id), val))
}
<file_sep path="hyperswitch/crates/hyperswitch_constraint_graph/src/dense_map.rs" role="context" start="135" end="135">
type Item = K;
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/euclid/src/backend/interpreter.rs<|crate|> euclid anchor=eval_rule kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/euclid/src/backend/interpreter.rs" role="context" start="139" end="144">
fn eval_rule(
rule: &ast::Rule<O>,
ctx: &types::Context,
) -> Result<bool, types::InterpreterError> {
Self::eval_rule_statements(&rule.statements, ctx)
}
<file_sep path="hyperswitch/crates/euclid/src/backend/interpreter.rs" role="context" start="138" end="138">
use common_utils::types::MinorUnit;
use crate::{
backend::{self, inputs, EuclidBackend},
frontend::ast,
};
<file_sep path="hyperswitch/crates/euclid/src/backend/interpreter.rs" role="context" start="174" end="176">
fn with_program(program: ast::Program<O>) -> Result<Self, Self::Error> {
Ok(Self { program })
}
<file_sep path="hyperswitch/crates/euclid/src/backend/interpreter.rs" role="context" start="146" end="165">
fn eval_program(
program: &ast::Program<O>,
ctx: &types::Context,
) -> Result<backend::BackendOutput<O>, types::InterpreterError> {
for rule in &program.rules {
let res = Self::eval_rule(rule, ctx)?;
if res {
return Ok(backend::BackendOutput {
connector_selection: rule.connector_selection.clone(),
rule_name: Some(rule.name.clone()),
});
}
}
Ok(backend::BackendOutput {
connector_selection: program.default_selection.clone(),
rule_name: None,
})
}
<file_sep path="hyperswitch/crates/euclid/src/backend/interpreter.rs" role="context" start="123" end="136">
fn eval_rule_statements(
statements: &[ast::IfStatement],
ctx: &types::Context,
) -> Result<bool, types::InterpreterError> {
for stmt in statements {
let res = Self::eval_if_statement(stmt, ctx)?;
if res {
return Ok(true);
}
}
Ok(false)
}
<file_sep path="hyperswitch/crates/euclid/src/backend/interpreter.rs" role="context" start="98" end="121">
fn eval_if_statement(
stmt: &ast::IfStatement,
ctx: &types::Context,
) -> Result<bool, types::InterpreterError> {
let cond_res = Self::eval_if_condition(&stmt.condition, ctx)?;
if !cond_res {
return Ok(false);
}
if let Some(ref nested) = stmt.nested {
for nested_if in nested {
let res = Self::eval_if_statement(nested_if, ctx)?;
if res {
return Ok(true);
}
}
return Ok(false);
}
Ok(true)
}
<file_sep path="hyperswitch/crates/euclid/src/frontend/ast.rs" role="context" start="141" end="146">
pub struct Rule<O> {
pub name: String,
#[serde(alias = "routingOutput")]
pub connector_selection: O,
pub statements: Vec<IfStatement>,
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/cards/src/validate.rs<|crate|> cards anchor=deserialize kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/cards/src/validate.rs" role="context" start="280" end="283">
fn deserialize<D: Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
let s = String::deserialize(d)?;
Self::from_str(&s).map_err(serde::de::Error::custom)
}
<file_sep path="hyperswitch/crates/cards/src/validate.rs" role="context" start="279" end="279">
use serde::{Deserialize, Deserializer, Serialize};
use thiserror::Error;
<file_sep path="hyperswitch/crates/cards/src/validate.rs" role="context" start="299" end="313">
fn fmt(val: &T, f: &mut fmt::Formatter<'_>) -> fmt::Result {
let val_str: &str = val.as_ref();
if val_str.len() < 15 || val_str.len() > 19 {
return WithType::fmt(val, f);
}
if let Some(value) = val_str.get(..6) {
write!(f, "{}{}", value, "*".repeat(val_str.len() - 6))
} else {
#[cfg(not(target_arch = "wasm32"))]
logger::error!("Invalid card number {val_str}");
WithType::fmt(val, f)
}
}
<file_sep path="hyperswitch/crates/cards/src/validate.rs" role="context" start="287" end="290">
fn deserialize<D: Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
let s = String::deserialize(d)?;
Self::from_str(&s).map_err(serde::de::Error::custom)
}
<file_sep path="hyperswitch/crates/cards/src/validate.rs" role="context" start="274" end="276">
fn deref(&self) -> &StrongSecret<String, CardNumberStrategy> {
&self.0
}
<file_sep path="hyperswitch/crates/cards/src/validate.rs" role="context" start="266" end="268">
fn deref(&self) -> &StrongSecret<String, CardNumberStrategy> {
&self.0
}
<file_sep path="hyperswitch/crates/cards/src/validate.rs" role="context" start="165" end="188">
fn from_str(network_token: &str) -> Result<Self, Self::Err> {
// Valid test cards for threedsecureio
let valid_test_network_tokens = vec![
"4000100511112003",
"6000100611111203",
"3000100811111072",
"9000100111111111",
];
#[cfg(not(target_arch = "wasm32"))]
let valid_test_network_tokens = match router_env_which() {
Env::Development | Env::Sandbox => valid_test_network_tokens,
Env::Production => vec![],
};
let network_token = network_token.split_whitespace().collect::<String>();
let is_network_token_valid = sanitize_card_number(&network_token)?;
if valid_test_network_tokens.contains(&network_token.as_str()) || is_network_token_valid {
Ok(Self(StrongSecret::new(network_token)))
} else {
Err(CardNumberValidationErr("network token invalid"))
}
}
<file_sep path="hyperswitch/crates/cards/src/validate.rs" role="context" start="248" end="248">
type Error = CardNumberValidationErr;
<file_sep path="hyperswitch/crates/api_models/src/payment_methods.rs" role="context" start="2478" end="2478">
type Error = error_stack::Report<errors::ValidationError>;
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/router_derive/src/macros/operation.rs<|crate|> router_derive anchor=get_conversions kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=1<|meta_end|>
<file_sep path="hyperswitch/crates/router_derive/src/macros/operation.rs" role="context" start="339" end="342">
fn get_conversions(input: syn::parse::ParseStream<'_>) -> syn::Result<Vec<Conversion>> {
let lit_str_list = input.parse::<syn::LitStr>()?;
parse_list_string(lit_str_list.value(), "operation")
}
<file_sep path="hyperswitch/crates/router_derive/src/macros/operation.rs" role="context" start="338" end="338">
use syn::{self, parse::Parse, DeriveInput};
<file_sep path="hyperswitch/crates/router_derive/src/macros/operation.rs" role="context" start="350" end="365">
fn parse(input: syn::parse::ParseStream<'_>) -> syn::Result<Self> {
let lookahead = input.lookahead1();
if lookahead.peek(operations_keyword::operations) {
let keyword = input.parse()?;
input.parse::<syn::Token![=]>()?;
let value = get_conversions(input)?;
Ok(Self::Operations { keyword, value })
} else if lookahead.peek(operations_keyword::flow) {
let keyword = input.parse()?;
input.parse::<syn::Token![=]>()?;
let value = get_derives(input)?;
Ok(Self::Flow { keyword, value })
} else {
Err(lookahead.error())
}
}
<file_sep path="hyperswitch/crates/router_derive/src/macros/operation.rs" role="context" start="344" end="347">
fn get_derives(input: syn::parse::ParseStream<'_>) -> syn::Result<Vec<Derives>> {
let lit_str_list = input.parse::<syn::LitStr>()?;
parse_list_string(lit_str_list.value(), "flow")
}
<file_sep path="hyperswitch/crates/router_derive/src/macros/operation.rs" role="context" start="317" end="337">
fn parse_list_string<T>(list_string: String, keyword: &str) -> syn::Result<Vec<T>>
where
T: FromStr + IntoEnumIterator + ToString,
{
list_string
.split(',')
.map(str::trim)
.map(T::from_str)
.map(|result| {
result.map_err(|_| {
syn::Error::new(
Span::call_site(),
format!(
"Unexpected {keyword}, possible values are {}",
helpers::get_possible_values_for_enum::<T>()
),
)
})
})
.collect()
}
<file_sep path="hyperswitch/crates/router_derive/src/macros/operation.rs" role="context" start="301" end="314">
fn parse(input: syn::parse::ParseStream<'_>) -> syn::Result<Self> {
let text = input.parse::<syn::LitStr>()?;
let value = text.value();
value.as_str().parse().map_err(|_| {
syn::Error::new_spanned(
&text,
format!(
"Unexpected value for operation: `{value}`. Possible values are `{}`",
helpers::get_possible_values_for_enum::<Self>()
),
)
})
}
<file_sep path="hyperswitch/crates/router_derive/src/macros/operation.rs" role="context" start="72" end="80">
pub enum Conversion {
ValidateRequest,
GetTracker,
Domain,
UpdateTracker,
PostUpdateTracker,
All,
Invalid(String),
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/router_derive/src/macros/operation.rs<|crate|> router_derive anchor=get_derives kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=1<|meta_end|>
<file_sep path="hyperswitch/crates/router_derive/src/macros/operation.rs" role="context" start="344" end="347">
fn get_derives(input: syn::parse::ParseStream<'_>) -> syn::Result<Vec<Derives>> {
let lit_str_list = input.parse::<syn::LitStr>()?;
parse_list_string(lit_str_list.value(), "flow")
}
<file_sep path="hyperswitch/crates/router_derive/src/macros/operation.rs" role="context" start="343" end="343">
use syn::{self, parse::Parse, DeriveInput};
<file_sep path="hyperswitch/crates/router_derive/src/macros/operation.rs" role="context" start="374" end="376">
fn get_metadata(&self) -> syn::Result<Vec<OperationsEnumMeta>> {
helpers::get_metadata_inner("operation", &self.attrs)
}
<file_sep path="hyperswitch/crates/router_derive/src/macros/operation.rs" role="context" start="350" end="365">
fn parse(input: syn::parse::ParseStream<'_>) -> syn::Result<Self> {
let lookahead = input.lookahead1();
if lookahead.peek(operations_keyword::operations) {
let keyword = input.parse()?;
input.parse::<syn::Token![=]>()?;
let value = get_conversions(input)?;
Ok(Self::Operations { keyword, value })
} else if lookahead.peek(operations_keyword::flow) {
let keyword = input.parse()?;
input.parse::<syn::Token![=]>()?;
let value = get_derives(input)?;
Ok(Self::Flow { keyword, value })
} else {
Err(lookahead.error())
}
}
<file_sep path="hyperswitch/crates/router_derive/src/macros/operation.rs" role="context" start="339" end="342">
fn get_conversions(input: syn::parse::ParseStream<'_>) -> syn::Result<Vec<Conversion>> {
let lit_str_list = input.parse::<syn::LitStr>()?;
parse_list_string(lit_str_list.value(), "operation")
}
<file_sep path="hyperswitch/crates/router_derive/src/macros/operation.rs" role="context" start="317" end="337">
fn parse_list_string<T>(list_string: String, keyword: &str) -> syn::Result<Vec<T>>
where
T: FromStr + IntoEnumIterator + ToString,
{
list_string
.split(',')
.map(str::trim)
.map(T::from_str)
.map(|result| {
result.map_err(|_| {
syn::Error::new(
Span::call_site(),
format!(
"Unexpected {keyword}, possible values are {}",
helpers::get_possible_values_for_enum::<T>()
),
)
})
})
.collect()
}
<file_sep path="hyperswitch/crates/router_derive/src/macros/operation.rs" role="context" start="12" end="36">
pub enum Derives {
Sync,
Cancel,
Reject,
Capture,
ApproveData,
Authorize,
AuthorizeData,
SyncData,
CancelData,
CaptureData,
CompleteAuthorizeData,
RejectData,
SetupMandateData,
Start,
Verify,
Session,
SessionData,
IncrementalAuthorization,
IncrementalAuthorizationData,
SdkSessionUpdate,
SdkSessionUpdateData,
PostSessionTokens,
PostSessionTokensData,
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/common_utils/src/types/keymanager.rs<|crate|> common_utils anchor=convert kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/common_utils/src/types/keymanager.rs" role="context" start="329" end="337">
fn convert(
value: &DecryptedData,
encryption: Encryption,
) -> CustomResult<Self, errors::CryptoError> {
Ok(Self::new(
Secret::new(value.clone().inner().peek().clone()),
encryption.clone().into_inner(),
))
}
<file_sep path="hyperswitch/crates/common_utils/src/types/keymanager.rs" role="context" start="328" end="328">
use masking::{ExposeInterface, PeekInterface, Secret, Strategy, StrongSecret};
use crate::{
consts::BASE64_ENGINE,
crypto::Encryptable,
encryption::Encryption,
errors::{self, CustomResult},
id_type,
transformers::{ForeignFrom, ForeignTryFrom},
};
<file_sep path="hyperswitch/crates/common_utils/src/types/keymanager.rs" role="context" start="362" end="374">
fn foreign_try_from(
(mut encrypted_data, response): (FxHashMap<String, Encryption>, BatchDecryptDataResponse),
) -> Result<Self, Self::Error> {
response
.data
.0
.into_iter()
.map(|(k, v)| match encrypted_data.remove(&k) {
Some(encrypted) => Ok((k.clone(), Encryptable::convert(&v, encrypted.clone())?)),
None => Err(errors::CryptoError::DecodingFailed)?,
})
.collect()
}
<file_sep path="hyperswitch/crates/common_utils/src/types/keymanager.rs" role="context" start="347" end="351">
fn foreign_try_from(
(encrypted_data, response): (Encryption, DecryptDataResponse),
) -> Result<Self, Self::Error> {
Self::convert(&response.data, encrypted_data)
}
<file_sep path="hyperswitch/crates/common_utils/src/types/keymanager.rs" role="context" start="313" end="323">
fn convert(
value: &DecryptedData,
encryption: Encryption,
) -> CustomResult<Self, errors::CryptoError> {
let val = serde_json::from_slice(value.clone().inner().peek()).map_err(|_err| {
#[cfg(feature = "encryption_service")]
logger::error!("Decryption error {:?}", _err);
errors::CryptoError::DecodingFailed
})?;
Ok(Self::new(Secret::new(val), encryption.clone().into_inner()))
}
<file_sep path="hyperswitch/crates/common_utils/src/types/keymanager.rs" role="context" start="297" end="307">
fn convert(
value: &DecryptedData,
encryption: Encryption,
) -> CustomResult<Self, errors::CryptoError> {
let string = String::from_utf8(value.clone().inner().peek().clone()).map_err(|_err| {
#[cfg(feature = "encryption_service")]
logger::error!("Decryption error {:?}", _err);
errors::CryptoError::DecodingFailed
})?;
Ok(Self::new(Secret::new(string), encryption.into_inner()))
}
<file_sep path="hyperswitch/crates/common_utils/src/types/keymanager.rs" role="context" start="407" end="407">
pub struct DecryptedData(StrongSecret<Vec<u8>>);
<file_sep path="hyperswitch/crates/common_utils/src/encryption.rs" role="context" start="49" end="51">
pub struct Encryption {
inner: Secret<Vec<u8>, EncryptionStrategy>,
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/router_derive/src/macros/to_encryptable.rs<|crate|> router_derive anchor=get_encryption_ty_meta kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=1<|meta_end|>
<file_sep path="hyperswitch/crates/router_derive/src/macros/to_encryptable.rs" role="context" start="28" end="35">
fn get_encryption_ty_meta(field: &Field) -> Option<FieldMeta> {
let attrs = &field.attrs;
attrs
.iter()
.flat_map(|s| s.parse_args::<FieldMeta>())
.find(|s| s._meta_type.eq("ty"))
}
<file_sep path="hyperswitch/crates/router_derive/src/macros/to_encryptable.rs" role="context" start="27" end="27">
use std::iter::Iterator;
use syn::{parse::Parse, punctuated::Punctuated, token::Comma, Field, Ident, Type as SynType};
<file_sep path="hyperswitch/crates/router_derive/src/macros/to_encryptable.rs" role="context" start="62" end="67">
fn get_inner_type_recursive(path: syn::TypePath) -> syn::Result<syn::TypePath> {
match get_inner_type(&path) {
Ok(inner_path) => get_inner_type_recursive(inner_path),
Err(_) => Ok(path),
}
}
<file_sep path="hyperswitch/crates/router_derive/src/macros/to_encryptable.rs" role="context" start="37" end="55">
fn get_inner_type(path: &syn::TypePath) -> syn::Result<syn::TypePath> {
path.path
.segments
.last()
.and_then(|segment| match &segment.arguments {
syn::PathArguments::AngleBracketed(args) => args.args.first(),
_ => None,
})
.and_then(|arg| match arg {
syn::GenericArgument::Type(SynType::Path(path)) => Some(path.clone()),
_ => None,
})
.ok_or_else(|| {
syn::Error::new(
proc_macro2::Span::call_site(),
"Only path fields are supported",
)
})
}
<file_sep path="hyperswitch/crates/router_derive/src/macros/to_encryptable.rs" role="context" start="23" end="25">
fn to_tokens(&self, tokens: &mut proc_macro2::TokenStream) {
self.value.to_tokens(tokens);
}
<file_sep path="hyperswitch/crates/router_derive/src/macros/to_encryptable.rs" role="context" start="14" end="19">
fn parse(input: syn::parse::ParseStream<'_>) -> syn::Result<Self> {
let _meta_type: Ident = input.parse()?;
input.parse::<syn::Token![=]>()?;
let value: Ident = input.parse()?;
Ok(Self { _meta_type, value })
}
<file_sep path="hyperswitch/crates/router_derive/src/macros/to_encryptable.rs" role="context" start="229" end="321">
fn generate_to_encryptable(
struct_name: Ident,
fields: Vec<Field>,
) -> syn::Result<proc_macro2::TokenStream> {
let struct_types = [
// The first two are to be used as return types we do not need to implement ToEncryptable
// on it
("Decrypted", StructType::Decrypted),
("DecryptedUpdate", StructType::DecryptedUpdate),
("FromRequestEncryptable", StructType::FromRequest),
("Encrypted", StructType::Encrypted),
("UpdateEncryptable", StructType::Updated),
];
let inner_types = get_field_and_inner_types(&fields);
let inner_type = inner_types.first().ok_or_else(|| {
syn::Error::new(
proc_macro2::Span::call_site(),
"Please use the macro with attribute #[encrypt] on the fields you want to encrypt",
)
})?;
let provided_ty = get_encryption_ty_meta(&inner_type.0)
.map(|ty| ty.value.clone())
.unwrap_or(inner_type.1.clone());
let structs = struct_types.iter().map(|(prefix, struct_type)| {
let name = format_ident!("{}{}", prefix, struct_name);
let temp_fields = struct_type.generate_struct_fields(&inner_types);
quote! {
pub struct #name {
#(#temp_fields,)*
}
}
});
// These implementations shouldn't be implemented Decrypted and DecryptedUpdate temp structs
// So skip the first two entries in the list
let impls = struct_types
.iter()
.skip(2)
.map(|(prefix, struct_type)| {
let name = format_ident!("{}{}", prefix, struct_name);
let impl_block = if *struct_type != StructType::DecryptedUpdate
|| *struct_type != StructType::Decrypted
{
let (gen1, gen2, gen3) = match struct_type {
StructType::FromRequest => {
let decrypted_name = format_ident!("Decrypted{}", struct_name);
(
quote! { #decrypted_name },
quote! { Secret<#provided_ty> },
quote! { Secret<#provided_ty> },
)
}
StructType::Encrypted => {
let decrypted_name = format_ident!("Decrypted{}", struct_name);
(
quote! { #decrypted_name },
quote! { Secret<#provided_ty> },
quote! { Encryption },
)
}
StructType::Updated => {
let decrypted_update_name = format_ident!("DecryptedUpdate{}", struct_name);
(
quote! { #decrypted_update_name },
quote! { Secret<#provided_ty> },
quote! { Secret<#provided_ty> },
)
}
//Unreachable statement
_ => (quote! {}, quote! {}, quote! {}),
};
struct_type.generate_impls(gen1, gen2, gen3, quote! { #name }, &fields)
} else {
quote! {}
};
Ok(quote! {
#impl_block
})
})
.collect::<syn::Result<Vec<_>>>()?;
Ok(quote! {
#(#structs)*
#(#impls)*
})
}
<file_sep path="hyperswitch/crates/router_derive/src/macros/to_encryptable.rs" role="context" start="127" end="161">
fn generate_struct_fields(self, fields: &[(Field, Ident)]) -> Vec<proc_macro2::TokenStream> {
fields
.iter()
.map(|(field, inner_ty)| {
let provided_ty = get_encryption_ty_meta(field);
let is_option = get_field_type(field.ty.clone())
.map(|f| f.eq("Option"))
.unwrap_or_default();
let ident = &field.ident;
let inner_ty = if let Some(ref ty) = provided_ty {
&ty.value
} else {
inner_ty
};
match (self, is_option) {
(Self::Encrypted, true) => quote! { pub #ident: Option<Encryption> },
(Self::Encrypted, false) => quote! { pub #ident: Encryption },
(Self::Decrypted, true) => {
quote! { pub #ident: Option<Encryptable<Secret<#inner_ty>>> }
}
(Self::Decrypted, false) => {
quote! { pub #ident: Encryptable<Secret<#inner_ty>> }
}
(Self::DecryptedUpdate, _) => {
quote! { pub #ident: Option<Encryptable<Secret<#inner_ty>>> }
}
(Self::FromRequest, true) => {
quote! { pub #ident: Option<Secret<#inner_ty>> }
}
(Self::FromRequest, false) => quote! { pub #ident: Secret<#inner_ty> },
(Self::Updated, _) => quote! { pub #ident: Option<Secret<#inner_ty>> },
}
})
.collect()
}
<file_sep path="hyperswitch/crates/router_derive/src/macros/to_encryptable.rs" role="context" start="8" end="11">
pub struct FieldMeta {
_meta_type: Ident,
pub value: Ident,
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/storage_impl/src/redis.rs<|crate|> storage_impl anchor=new kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=1<|meta_end|>
<file_sep path="hyperswitch/crates/storage_impl/src/redis.rs" role="context" start="26" end="32">
pub async fn new(
conf: &redis_interface::RedisSettings,
) -> error_stack::Result<Self, redis_interface::errors::RedisError> {
Ok(Self {
redis_conn: Arc::new(redis_interface::RedisConnectionPool::new(conf).await?),
})
}
<file_sep path="hyperswitch/crates/storage_impl/src/redis.rs" role="context" start="25" end="25">
use std::sync::{atomic, Arc};
<file_sep path="hyperswitch/crates/storage_impl/src/redis.rs" role="context" start="46" end="61">
fn get_redis_conn(
&self,
) -> error_stack::Result<
Arc<redis_interface::RedisConnectionPool>,
redis_interface::errors::RedisError,
> {
if self
.redis_conn
.is_redis_available
.load(atomic::Ordering::SeqCst)
{
Ok(self.redis_conn.clone())
} else {
Err(redis_interface::errors::RedisError::RedisConnectionError.into())
}
}
<file_sep path="hyperswitch/crates/storage_impl/src/redis.rs" role="context" start="34" end="42">
pub fn set_error_callback(&self, callback: tokio::sync::oneshot::Sender<()>) {
let redis_clone = self.redis_conn.clone();
let _task_handle = tokio::spawn(
async move {
redis_clone.on_error(callback).await;
}
.in_current_span(),
);
}
<file_sep path="hyperswitch/crates/storage_impl/src/redis.rs" role="context" start="18" end="22">
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("CacheStore")
.field("redis_conn", &"Redis conn doesn't implement debug")
.finish()
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/router_derive/src/macros/to_encryptable.rs<|crate|> router_derive anchor=derive_to_encryption kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/router_derive/src/macros/to_encryptable.rs" role="context" start="323" end="330">
pub fn derive_to_encryption(
input: syn::DeriveInput,
) -> Result<proc_macro2::TokenStream, syn::Error> {
let struct_name = input.ident;
let fields = get_encryptable_fields(get_struct_fields(input.data)?);
generate_to_encryptable(struct_name, fields)
}
<file_sep path="hyperswitch/crates/router_derive/src/macros/to_encryptable.rs" role="context" start="322" end="322">
use syn::{parse::Parse, punctuated::Punctuated, token::Comma, Field, Ident, Type as SynType};
use crate::macros::{helpers::get_struct_fields, misc::get_field_type};
<file_sep path="hyperswitch/crates/router_derive/src/macros/to_encryptable.rs" role="context" start="229" end="321">
fn generate_to_encryptable(
struct_name: Ident,
fields: Vec<Field>,
) -> syn::Result<proc_macro2::TokenStream> {
let struct_types = [
// The first two are to be used as return types we do not need to implement ToEncryptable
// on it
("Decrypted", StructType::Decrypted),
("DecryptedUpdate", StructType::DecryptedUpdate),
("FromRequestEncryptable", StructType::FromRequest),
("Encrypted", StructType::Encrypted),
("UpdateEncryptable", StructType::Updated),
];
let inner_types = get_field_and_inner_types(&fields);
let inner_type = inner_types.first().ok_or_else(|| {
syn::Error::new(
proc_macro2::Span::call_site(),
"Please use the macro with attribute #[encrypt] on the fields you want to encrypt",
)
})?;
let provided_ty = get_encryption_ty_meta(&inner_type.0)
.map(|ty| ty.value.clone())
.unwrap_or(inner_type.1.clone());
let structs = struct_types.iter().map(|(prefix, struct_type)| {
let name = format_ident!("{}{}", prefix, struct_name);
let temp_fields = struct_type.generate_struct_fields(&inner_types);
quote! {
pub struct #name {
#(#temp_fields,)*
}
}
});
// These implementations shouldn't be implemented Decrypted and DecryptedUpdate temp structs
// So skip the first two entries in the list
let impls = struct_types
.iter()
.skip(2)
.map(|(prefix, struct_type)| {
let name = format_ident!("{}{}", prefix, struct_name);
let impl_block = if *struct_type != StructType::DecryptedUpdate
|| *struct_type != StructType::Decrypted
{
let (gen1, gen2, gen3) = match struct_type {
StructType::FromRequest => {
let decrypted_name = format_ident!("Decrypted{}", struct_name);
(
quote! { #decrypted_name },
quote! { Secret<#provided_ty> },
quote! { Secret<#provided_ty> },
)
}
StructType::Encrypted => {
let decrypted_name = format_ident!("Decrypted{}", struct_name);
(
quote! { #decrypted_name },
quote! { Secret<#provided_ty> },
quote! { Encryption },
)
}
StructType::Updated => {
let decrypted_update_name = format_ident!("DecryptedUpdate{}", struct_name);
(
quote! { #decrypted_update_name },
quote! { Secret<#provided_ty> },
quote! { Secret<#provided_ty> },
)
}
//Unreachable statement
_ => (quote! {}, quote! {}, quote! {}),
};
struct_type.generate_impls(gen1, gen2, gen3, quote! { #name }, &fields)
} else {
quote! {}
};
Ok(quote! {
#impl_block
})
})
.collect::<syn::Result<Vec<_>>>()?;
Ok(quote! {
#(#structs)*
#(#impls)*
})
}
<file_sep path="hyperswitch/crates/router_derive/src/macros/to_encryptable.rs" role="context" start="164" end="225">
fn generate_impls(
self,
gen1: proc_macro2::TokenStream,
gen2: proc_macro2::TokenStream,
gen3: proc_macro2::TokenStream,
impl_st: proc_macro2::TokenStream,
inner: &[Field],
) -> proc_macro2::TokenStream {
let map_length = inner.len();
let to_encryptable_impl = inner.iter().flat_map(|field| {
get_field_type(field.ty.clone()).map(|field_ty| {
let is_option = field_ty.eq("Option");
let field_ident = &field.ident;
let field_ident_string = field_ident.as_ref().map(|s| s.to_string());
if is_option || self == Self::Updated {
quote! { self.#field_ident.map(|s| map.insert(#field_ident_string.to_string(), s)) }
} else {
quote! { map.insert(#field_ident_string.to_string(), self.#field_ident) }
}
})
});
let from_encryptable_impl = inner.iter().flat_map(|field| {
get_field_type(field.ty.clone()).map(|field_ty| {
let is_option = field_ty.eq("Option");
let field_ident = &field.ident;
let field_ident_string = field_ident.as_ref().map(|s| s.to_string());
if is_option || self == Self::Updated {
quote! { #field_ident: map.remove(#field_ident_string) }
} else {
quote! {
#field_ident: map.remove(#field_ident_string).ok_or(
error_stack::report!(common_utils::errors::ParsingError::EncodeError(
"Unable to convert from HashMap",
))
)?
}
}
})
});
quote! {
impl ToEncryptable<#gen1, #gen2, #gen3> for #impl_st {
fn to_encryptable(self) -> FxHashMap<String, #gen3> {
let mut map = FxHashMap::with_capacity_and_hasher(#map_length, Default::default());
#(#to_encryptable_impl;)*
map
}
fn from_encryptable(
mut map: FxHashMap<String, Encryptable<#gen2>>,
) -> CustomResult<#gen1, common_utils::errors::ParsingError> {
Ok(#gen1 {
#(#from_encryptable_impl,)*
})
}
}
}
}
<file_sep path="hyperswitch/crates/router_derive/src/macros/to_encryptable.rs" role="context" start="92" end="102">
fn get_encryptable_fields(fields: Punctuated<Field, Comma>) -> Vec<Field> {
fields
.into_iter()
.filter(|field| {
field
.attrs
.iter()
.any(|attr| attr.path().is_ident("encrypt"))
})
.collect()
}
<file_sep path="hyperswitch/crates/api_models/src/payment_methods.rs" role="context" start="2478" end="2478">
type Error = error_stack::Report<errors::ValidationError>;
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/common_utils/src/lib.rs<|crate|> common_utils anchor=test_generate_merchant_ref_id_with_default_length kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/common_utils/src/lib.rs" role="context" start="327" end="334">
fn test_generate_merchant_ref_id_with_default_length() {
let ref_id = id_type::LengthId::<
MAX_ALLOWED_MERCHANT_REFERENCE_ID_LENGTH,
MIN_REQUIRED_MERCHANT_REFERENCE_ID_LENGTH,
>::from(generate_id_with_default_len("def").into());
assert!(ref_id.is_ok())
}
<file_sep path="hyperswitch/crates/common_utils/src/lib.rs" role="context" start="321" end="324">
fn test_generate_id_with_alphanumeric_id() {
let alphanumeric_id = AlphaNumericId::from(generate_id(10, "def").into());
assert!(alphanumeric_id.is_ok())
}
<file_sep path="hyperswitch/crates/common_utils/src/lib.rs" role="context" start="287" end="298">
fn get_database_url(&self, schema: &str) -> String {
format!(
"postgres://{}:{}@{}:{}/{}?application_name={}&options=-c search_path%3D{}",
self.get_username(),
self.get_password().peek(),
self.get_host(),
self.get_port(),
self.get_dbname(),
schema,
schema,
)
}
<file_sep path="hyperswitch/crates/common_utils/src/lib.rs" role="context" start="142" end="147">
fn from(value: PrimitiveDateTime) -> Self {
Self {
inner: PhantomData,
value,
}
}
<file_sep path="hyperswitch/crates/common_utils/src/lib.rs" role="context" start="258" end="261">
pub fn generate_id_with_default_len(prefix: &str) -> String {
let len: usize = consts::ID_LENGTH;
format!("{}_{}", prefix, nanoid::nanoid!(len, &consts::ALPHABETS))
}
<file_sep path="hyperswitch/crates/common_utils/src/id_type.rs" role="context" start="117" end="117">
pub(crate) struct LengthId<const MAX_LENGTH: u8, const MIN_LENGTH: u8>(AlphaNumericId);
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/scheduler/src/utils.rs<|crate|> scheduler anchor=divide kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/scheduler/src/utils.rs" role="context" start="147" end="154">
pub fn divide(
tasks: Vec<storage::ProcessTracker>,
conf: &SchedulerSettings,
) -> Vec<ProcessTrackerBatch> {
let now = common_utils::date_time::now();
let batch_size = conf.producer.batch_size;
divide_into_batches(batch_size, tasks, now, conf)
}
<file_sep path="hyperswitch/crates/scheduler/src/utils.rs" role="context" start="146" end="146">
use common_utils::errors::CustomResult;
pub use diesel_models::process_tracker as storage;
use crate::{
configs::settings::SchedulerSettings, consumer::types::ProcessTrackerBatch, errors,
flow::SchedulerFlow, metrics, SchedulerInterface, SchedulerSessionState,
};
<file_sep path="hyperswitch/crates/scheduler/src/utils.rs" role="context" start="182" end="248">
pub async fn get_batches(
conn: &RedisConnectionPool,
stream_name: &str,
group_name: &str,
consumer_name: &str,
) -> CustomResult<Vec<ProcessTrackerBatch>, errors::ProcessTrackerError> {
let response = match conn
.stream_read_with_options(
stream_name,
RedisEntryId::UndeliveredEntryID,
// Update logic for collecting to Vec and flattening, if count > 1 is provided
Some(1),
None,
Some((group_name, consumer_name)),
)
.await
{
Ok(response) => response,
Err(error) => {
if let redis_interface::errors::RedisError::StreamEmptyOrNotAvailable =
error.current_context()
{
logger::debug!("No batches processed as stream is empty");
return Ok(Vec::new());
} else {
return Err(error.change_context(errors::ProcessTrackerError::BatchNotFound));
}
}
};
metrics::BATCHES_CONSUMED.add(1, &[]);
let (batches, entry_ids): (Vec<Vec<ProcessTrackerBatch>>, Vec<Vec<String>>) = response.into_values().map(|entries| {
entries.into_iter().try_fold(
(Vec::new(), Vec::new()),
|(mut batches, mut entry_ids), entry| {
// Redis entry ID
entry_ids.push(entry.0);
// Value HashMap
batches.push(ProcessTrackerBatch::from_redis_stream_entry(entry.1)?);
Ok((batches, entry_ids))
},
)
}).collect::<CustomResult<Vec<(Vec<ProcessTrackerBatch>, Vec<String>)>, errors::ProcessTrackerError>>()?
.into_iter()
.unzip();
// Flattening the Vec's since the count provided above is 1. This needs to be updated if a
// count greater than 1 is provided.
let batches = batches.into_iter().flatten().collect::<Vec<_>>();
let entry_ids = entry_ids.into_iter().flatten().collect::<Vec<_>>();
conn.stream_acknowledge_entries(&stream_name.into(), group_name, entry_ids.clone())
.await
.map_err(|error| {
logger::error!(?error, "Error acknowledging batch in stream");
error.change_context(errors::ProcessTrackerError::BatchUpdateFailed)
})?;
conn.stream_delete_entries(&stream_name.into(), entry_ids.clone())
.await
.map_err(|error| {
logger::error!(?error, "Error deleting batch from stream");
error.change_context(errors::ProcessTrackerError::BatchDeleteFailed)
})?;
Ok(batches)
}
<file_sep path="hyperswitch/crates/scheduler/src/utils.rs" role="context" start="156" end="180">
pub fn divide_into_batches(
batch_size: usize,
tasks: Vec<storage::ProcessTracker>,
batch_creation_time: time::PrimitiveDateTime,
conf: &SchedulerSettings,
) -> Vec<ProcessTrackerBatch> {
let batch_id = Uuid::new_v4().to_string();
tasks
.chunks(batch_size)
.fold(Vec::new(), |mut batches, item| {
let batch = ProcessTrackerBatch {
id: batch_id.clone(),
group_name: conf.consumer.consumer_group.clone(),
stream_name: conf.stream.clone(),
connection_name: String::new(),
created_time: batch_creation_time,
rule: String::new(), // is it required?
trackers: item.to_vec(),
};
batches.push(batch);
batches
})
}
<file_sep path="hyperswitch/crates/scheduler/src/utils.rs" role="context" start="43" end="145">
pub async fn update_status_and_append<T>(
state: &T,
flow: SchedulerFlow,
pt_batch: ProcessTrackerBatch,
) -> CustomResult<(), errors::ProcessTrackerError>
where
T: SchedulerInterface + Send + Sync + ?Sized,
{
let process_ids: Vec<String> = pt_batch
.trackers
.iter()
.map(|process| process.id.to_owned())
.collect();
match flow {
SchedulerFlow::Producer => state
.process_tracker_update_process_status_by_ids(
process_ids,
storage::ProcessTrackerUpdate::StatusUpdate {
status: ProcessTrackerStatus::Processing,
business_status: None,
},
)
.await
.map_or_else(
|error| {
logger::error!(?error, "Error while updating process status");
Err(error.change_context(errors::ProcessTrackerError::ProcessUpdateFailed))
},
|count| {
logger::debug!("Updated status of {count} processes");
Ok(())
},
),
SchedulerFlow::Cleaner => {
let res = state
.reinitialize_limbo_processes(process_ids, common_utils::date_time::now())
.await;
match res {
Ok(count) => {
logger::debug!("Reinitialized {count} processes");
Ok(())
}
Err(error) => {
logger::error!(?error, "Error while reinitializing processes");
Err(error.change_context(errors::ProcessTrackerError::ProcessUpdateFailed))
}
}
}
_ => {
let error = format!("Unexpected scheduler flow {flow:?}");
logger::error!(%error);
Err(report!(errors::ProcessTrackerError::UnexpectedFlow).attach_printable(error))
}
}?;
let field_value_pairs = pt_batch.to_redis_field_value_pairs()?;
match state
.stream_append_entry(
&pt_batch.stream_name,
&RedisEntryId::AutoGeneratedID,
field_value_pairs,
)
.await
.change_context(errors::ProcessTrackerError::BatchInsertionFailed)
{
Ok(x) => Ok(x),
Err(mut err) => {
let update_res = state
.process_tracker_update_process_status_by_ids(
pt_batch
.trackers
.iter()
.map(|process| process.id.clone())
.collect(),
storage::ProcessTrackerUpdate::StatusUpdate {
status: ProcessTrackerStatus::Processing,
business_status: None,
},
)
.await
.map_or_else(
|error| {
logger::error!(?error, "Error while updating process status");
Err(error.change_context(errors::ProcessTrackerError::ProcessUpdateFailed))
},
|count| {
logger::debug!("Updated status of {count} processes");
Ok(())
},
);
match update_res {
Ok(_) => (),
Err(inner_err) => {
err.extend_one(inner_err);
}
};
Err(err)
}
}
}
<file_sep path="hyperswitch/crates/scheduler/src/utils.rs" role="context" start="20" end="41">
pub async fn divide_and_append_tasks<T>(
state: &T,
flow: SchedulerFlow,
tasks: Vec<storage::ProcessTracker>,
settings: &SchedulerSettings,
) -> CustomResult<(), errors::ProcessTrackerError>
where
T: SchedulerInterface + Send + Sync + ?Sized,
{
let batches = divide(tasks, settings);
// Safety: Assuming we won't deal with more than `u64::MAX` batches at once
#[allow(clippy::as_conversions)]
metrics::BATCHES_CREATED.add(batches.len() as u64, &[]); // Metrics
for batch in batches {
let result = update_status_and_append(state, flow, batch).await;
match result {
Ok(_) => (),
Err(error) => logger::error!(?error),
}
}
Ok(())
}
<file_sep path="hyperswitch/crates/scheduler/src/configs/settings.rs" role="context" start="6" end="13">
pub struct SchedulerSettings {
pub stream: String,
pub producer: ProducerSettings,
pub consumer: ConsumerSettings,
pub loop_interval: u64,
pub graceful_shutdown_interval: u64,
pub server: Server,
}
<file_sep path="hyperswitch/migrations/2022-09-29-084920_create_initial_tables/up.sql" role="context" start="430" end="446">
created_at TIMESTAMP NOT NULL,
last_modified TIMESTAMP NOT NULL,
payment_method "PaymentMethodType" NOT NULL,
payment_method_type "PaymentMethodSubType",
payment_method_issuer VARCHAR(255),
payment_method_issuer_code "PaymentMethodIssuerCode"
);
CREATE TABLE process_tracker (
id VARCHAR(127) PRIMARY KEY,
NAME VARCHAR(255),
tag TEXT [ ] NOT NULL DEFAULT '{}'::TEXT [ ],
runner VARCHAR(255),
retry_count INTEGER NOT NULL,
schedule_time TIMESTAMP,
rule VARCHAR(255) NOT NULL,
tracking_data JSON NOT NULL,
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/euclid/src/dssa/graph.rs<|crate|> euclid anchor=assertion_from_graph_error kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/euclid/src/dssa/graph.rs" role="context" start="93" end="102">
fn assertion_from_graph_error(metadata: &Metadata, graph_error: cgraph::GraphError<V>) -> Self {
match graph_error {
cgraph::GraphError::AnalysisError(trace) => Self::AssertionTrace {
trace,
metadata: metadata.clone(),
},
other => Self::Graph(other),
}
}
<file_sep path="hyperswitch/crates/euclid/src/dssa/graph.rs" role="context" start="92" end="92">
use hyperswitch_constraint_graph as cgraph;
use crate::{
dssa::types,
frontend::dir,
types::{DataType, Metadata},
};
<file_sep path="hyperswitch/crates/euclid/src/dssa/graph.rs" role="context" start="125" end="136">
pub fn from_dir_values(vals: impl IntoIterator<Item = dir::DirValue>) -> Self {
let mut keywise_values: FxHashMap<dir::DirKey, FxHashSet<dir::DirValue>> =
FxHashMap::default();
for dir_val in vals {
let key = dir_val.get_key();
let set = keywise_values.entry(key).or_default();
set.insert(dir_val);
}
Self { keywise_values }
}
<file_sep path="hyperswitch/crates/euclid/src/dssa/graph.rs" role="context" start="104" end="116">
fn negation_from_graph_error(
metadata: Vec<&Metadata>,
graph_error: cgraph::GraphError<V>,
) -> Self {
match graph_error {
cgraph::GraphError::AnalysisError(trace) => Self::NegationTrace {
trace,
metadata: metadata.iter().map(|m| (*m).clone()).collect(),
},
other => Self::Graph(other),
}
}
<file_sep path="hyperswitch/crates/euclid/src/dssa/graph.rs" role="context" start="41" end="75">
fn viz(&self) -> String {
match self {
Self::PaymentMethod(pm) => pm.to_string(),
Self::CardBin(bin) => bin.value.clone(),
Self::CardType(ct) => ct.to_string(),
Self::CardNetwork(cn) => cn.to_string(),
Self::PayLaterType(plt) => plt.to_string(),
Self::WalletType(wt) => wt.to_string(),
Self::UpiType(ut) => ut.to_string(),
Self::BankTransferType(btt) => btt.to_string(),
Self::BankRedirectType(brt) => brt.to_string(),
Self::BankDebitType(bdt) => bdt.to_string(),
Self::CryptoType(ct) => ct.to_string(),
Self::RewardType(rt) => rt.to_string(),
Self::PaymentAmount(amt) => amt.number.to_string(),
Self::PaymentCurrency(curr) => curr.to_string(),
Self::AuthenticationType(at) => at.to_string(),
Self::CaptureMethod(cm) => cm.to_string(),
Self::BusinessCountry(bc) => bc.to_string(),
Self::BillingCountry(bc) => bc.to_string(),
Self::Connector(conn) => conn.connector.to_string(),
Self::MetaData(mv) => format!("[{} = {}]", mv.key, mv.value),
Self::MandateAcceptanceType(mat) => mat.to_string(),
Self::MandateType(mt) => mt.to_string(),
Self::PaymentType(pt) => pt.to_string(),
Self::VoucherType(vt) => vt.to_string(),
Self::GiftCardType(gct) => gct.to_string(),
Self::BusinessLabel(bl) => bl.value.to_string(),
Self::SetupFutureUsage(sfu) => sfu.to_string(),
Self::CardRedirectType(crt) => crt.to_string(),
Self::RealTimePaymentType(rtpt) => rtpt.to_string(),
Self::OpenBankingType(ob) => ob.to_string(),
Self::MobilePaymentType(mpt) => mpt.to_string(),
}
}
<file_sep path="hyperswitch/crates/euclid/src/dssa/graph.rs" role="context" start="35" end="37">
fn get_key(&self) -> Self::Key {
Self::get_key(self)
}
<file_sep path="hyperswitch/crates/euclid/src/dssa/graph.rs" role="context" start="376" end="388">
fn assertion_analysis(
&self,
positive_ctx: &[(&dir::DirValue, &Metadata)],
analysis_ctx: &AnalysisContext,
memo: &mut cgraph::Memoization<dir::DirValue>,
cycle_map: &mut cgraph::CycleCheck,
domains: Option<&[String]>,
) -> Result<(), AnalysisError<dir::DirValue>> {
positive_ctx.iter().try_for_each(|(value, metadata)| {
self.key_value_analysis((*value).clone(), analysis_ctx, memo, cycle_map, domains)
.map_err(|e| AnalysisError::assertion_from_graph_error(metadata, e))
})
}
<file_sep path="hyperswitch/crates/euclid/src/dssa/graph.rs" role="context" start="390" end="448">
fn negation_analysis(
&self,
negative_ctx: &[(&[dir::DirValue], &Metadata)],
analysis_ctx: &mut AnalysisContext,
memo: &mut cgraph::Memoization<dir::DirValue>,
cycle_map: &mut cgraph::CycleCheck,
domains: Option<&[String]>,
) -> Result<(), AnalysisError<dir::DirValue>> {
let mut keywise_metadata: FxHashMap<dir::DirKey, Vec<&Metadata>> = FxHashMap::default();
let mut keywise_negation: FxHashMap<dir::DirKey, FxHashSet<&dir::DirValue>> =
FxHashMap::default();
for (values, metadata) in negative_ctx {
let mut metadata_added = false;
for dir_value in *values {
if !metadata_added {
keywise_metadata
.entry(dir_value.get_key())
.or_default()
.push(metadata);
metadata_added = true;
}
keywise_negation
.entry(dir_value.get_key())
.or_default()
.insert(dir_value);
}
}
for (key, negation_set) in keywise_negation {
let all_metadata = keywise_metadata.remove(&key).unwrap_or_default();
let first_metadata = all_metadata.first().copied().cloned().unwrap_or_default();
self.key_analysis(key.clone(), analysis_ctx, memo, cycle_map, domains)
.map_err(|e| AnalysisError::assertion_from_graph_error(&first_metadata, e))?;
let mut value_set = if let Some(set) = key.kind.get_value_set() {
set
} else {
continue;
};
value_set.retain(|v| !negation_set.contains(v));
for value in value_set {
analysis_ctx.insert(value.clone());
self.value_analysis(value.clone(), analysis_ctx, memo, cycle_map, domains)
.map_err(|e| {
AnalysisError::negation_from_graph_error(all_metadata.clone(), e)
})?;
analysis_ctx.remove(value);
}
}
Ok(())
}
<file_sep path="hyperswitch/crates/euclid/src/dssa/graph.rs" role="context" start="80" end="90">
pub enum AnalysisError<V: cgraph::ValueNode> {
Graph(cgraph::GraphError<V>),
AssertionTrace {
trace: Weak<cgraph::AnalysisTrace<V>>,
metadata: Metadata,
},
NegationTrace {
trace: Weak<cgraph::AnalysisTrace<V>>,
metadata: Vec<Metadata>,
},
}
<file_sep path="hyperswitch/crates/euclid/src/types.rs" role="context" start="17" end="17">
pub type Metadata = std::collections::HashMap<String, serde_json::Value>;
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/hyperswitch_constraint_graph/src/graph.rs<|crate|> hyperswitch_constraint_graph anchor=build_node kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/hyperswitch_constraint_graph/src/graph.rs" role="context" start="635" end="640">
fn build_node(cg_node_id: types::NodeId, cg_node: &types::Node<V>) -> Node {
let viz_node_id = get_node_id(cg_node_id);
let viz_node_label = Self::get_node_label(cg_node);
node!(viz_node_id; attr!("label", viz_node_label))
}
<file_sep path="hyperswitch/crates/hyperswitch_constraint_graph/src/graph.rs" role="context" start="634" end="634">
use crate::{
builder,
dense_map::DenseMap,
error::{self, AnalysisTrace, GraphError},
types::{
CheckingContext, CycleCheck, DomainId, DomainIdentifier, DomainInfo, Edge, EdgeId,
Memoization, Metadata, Node, NodeId, NodeType, NodeValue, Relation, RelationResolution,
Strength, ValueNode,
},
};
<file_sep path="hyperswitch/crates/hyperswitch_constraint_graph/src/graph.rs" role="context" start="662" end="672">
pub fn get_viz_digraph(&self) -> Graph {
graph!(
strict di id!("constraint_graph"),
self.nodes
.iter()
.map(|(node_id, node)| Self::build_node(node_id, node))
.map(Stmt::Node)
.chain(self.edges.values().map(Self::build_edge).map(Stmt::Edge))
.collect::<Vec<_>>()
)
}
<file_sep path="hyperswitch/crates/hyperswitch_constraint_graph/src/graph.rs" role="context" start="642" end="660">
fn build_edge(cg_edge: &types::Edge) -> Edge {
let pred_vertex = get_node_id(cg_edge.pred);
let succ_vertex = get_node_id(cg_edge.succ);
let arrowhead = match cg_edge.strength {
types::Strength::Weak => "onormal",
types::Strength::Normal => "normal",
types::Strength::Strong => "normalnormal",
};
let color = match cg_edge.relation {
types::Relation::Positive => "blue",
types::Relation::Negative => "red",
};
edge!(
node_id!(pred_vertex) => node_id!(succ_vertex);
attr!("arrowhead", arrowhead),
attr!("color", color)
)
}
<file_sep path="hyperswitch/crates/hyperswitch_constraint_graph/src/graph.rs" role="context" start="612" end="633">
fn get_node_label(node: &types::Node<V>) -> String {
let label = match &node.node_type {
types::NodeType::Value(types::NodeValue::Key(key)) => format!("any {}", key.viz()),
types::NodeType::Value(types::NodeValue::Value(val)) => {
format!("{} = {}", val.get_key().viz(), val.viz())
}
types::NodeType::AllAggregator => "&&".to_string(),
types::NodeType::AnyAggregator => "| |".to_string(),
types::NodeType::InAggregator(agg) => {
let key = if let Some(val) = agg.iter().next() {
val.get_key().viz()
} else {
return "empty in".to_string();
};
let nodes = agg.iter().map(NodeViz::viz).collect::<Vec<_>>();
format!("{key} in [{}]", nodes.join(", "))
}
};
format!("\"{label}\"")
}
<file_sep path="hyperswitch/crates/hyperswitch_constraint_graph/src/graph.rs" role="context" start="603" end="605">
fn get_node_id(node_id: types::NodeId) -> String {
format!("N{}", node_id.get_id())
}
<file_sep path="hyperswitch/crates/hyperswitch_constraint_graph/src/types.rs" role="context" start="32" end="36">
pub struct Node<V: ValueNode> {
pub node_type: NodeType<V>,
pub preds: Vec<EdgeId>,
pub succs: Vec<EdgeId>,
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch-encryption-service/src/core/datakey.rs<|crate|> src anchor=transfer_data_key kind=fn pack=symbol_neighborhood lang=rust role_window=k2 hops=2<|meta_end|>
<file_sep path="hyperswitch-encryption-service/src/core/datakey.rs" role="context" start="73" end="82">
pub async fn transfer_data_key(
state: TenantState,
custodian: Custodian,
Json(req): Json<TransferKeyRequest>,
) -> errors::ApiResponseResult<Json<DataKeyCreateResponse>> {
transfer::transfer_data_key(state, custodian, req)
.await
.map(Json)
.to_container_error()
}
<file_sep path="hyperswitch-encryption-service/src/core/datakey.rs" role="context" start="72" end="72">
use crate::{
core::custodian::Custodian,
env::observability as logger,
errors::{self, ToContainerError},
metrics,
multitenancy::TenantState,
types::{
requests::{CreateDataKeyRequest, RotateDataKeyRequest, TransferKeyRequest},
response::DataKeyCreateResponse,
},
};
use axum::Json;
<file_sep path="hyperswitch-encryption-service/src/core/datakey.rs" role="context" start="47" end="71">
pub async fn rotate_data_key(
state: TenantState,
custodian: Custodian,
Json(req): Json<RotateDataKeyRequest>,
) -> errors::ApiResponseResult<Json<DataKeyCreateResponse>> {
let identifier = req.identifier.clone();
generate_and_rotate_data_key(state, custodian, req)
.await
.map(Json)
.map_err(|err| {
logger::error!(key_create_failure=?err);
let (data_identifier, key_identifier) = identifier.get_identifier();
metrics::KEY_ROTATE_FAILURE.add(
1,
&[
KeyValue::new("key_identifier", key_identifier),
KeyValue::new("data_identifier", data_identifier),
],
);
err
})
.to_container_error()
}
<file_sep path="hyperswitch-encryption-service/src/core/datakey.rs" role="context" start="21" end="45">
pub async fn create_data_key(
state: TenantState,
custodian: Custodian,
Json(req): Json<CreateDataKeyRequest>,
) -> errors::ApiResponseResult<Json<DataKeyCreateResponse>> {
let identifier = req.identifier.clone();
generate_and_create_data_key(state, custodian, req)
.await
.map(Json)
.map_err(|err| {
logger::error!(key_create_failure=?err);
let (data_identifier, key_identifier) = identifier.get_identifier();
metrics::KEY_CREATE_FAILURE.add(
1,
&[
KeyValue::new("key_identifier", key_identifier),
KeyValue::new("data_identifier", data_identifier),
],
);
err
})
.to_container_error()
}
<file_sep path="hyperswitch-encryption-service/src/core/crypto/custodian.rs" role="context" start="16" end="18">
pub struct Custodian {
pub keys: Option<(StrongSecret<String>, StrongSecret<String>)>,
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/euclid/src/backend/interpreter.rs<|crate|> euclid anchor=eval_rule_statements kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/euclid/src/backend/interpreter.rs" role="context" start="123" end="136">
fn eval_rule_statements(
statements: &[ast::IfStatement],
ctx: &types::Context,
) -> Result<bool, types::InterpreterError> {
for stmt in statements {
let res = Self::eval_if_statement(stmt, ctx)?;
if res {
return Ok(true);
}
}
Ok(false)
}
<file_sep path="hyperswitch/crates/euclid/src/backend/interpreter.rs" role="context" start="122" end="122">
use common_utils::types::MinorUnit;
use crate::{
backend::{self, inputs, EuclidBackend},
frontend::ast,
};
<file_sep path="hyperswitch/crates/euclid/src/backend/interpreter.rs" role="context" start="146" end="165">
fn eval_program(
program: &ast::Program<O>,
ctx: &types::Context,
) -> Result<backend::BackendOutput<O>, types::InterpreterError> {
for rule in &program.rules {
let res = Self::eval_rule(rule, ctx)?;
if res {
return Ok(backend::BackendOutput {
connector_selection: rule.connector_selection.clone(),
rule_name: Some(rule.name.clone()),
});
}
}
Ok(backend::BackendOutput {
connector_selection: program.default_selection.clone(),
rule_name: None,
})
}
<file_sep path="hyperswitch/crates/euclid/src/backend/interpreter.rs" role="context" start="139" end="144">
fn eval_rule(
rule: &ast::Rule<O>,
ctx: &types::Context,
) -> Result<bool, types::InterpreterError> {
Self::eval_rule_statements(&rule.statements, ctx)
}
<file_sep path="hyperswitch/crates/euclid/src/backend/interpreter.rs" role="context" start="98" end="121">
fn eval_if_statement(
stmt: &ast::IfStatement,
ctx: &types::Context,
) -> Result<bool, types::InterpreterError> {
let cond_res = Self::eval_if_condition(&stmt.condition, ctx)?;
if !cond_res {
return Ok(false);
}
if let Some(ref nested) = stmt.nested {
for nested_if in nested {
let res = Self::eval_if_statement(nested_if, ctx)?;
if res {
return Ok(true);
}
}
return Ok(false);
}
Ok(true)
}
<file_sep path="hyperswitch/crates/euclid/src/backend/interpreter.rs" role="context" start="83" end="96">
fn eval_if_condition(
condition: &ast::IfCondition,
ctx: &types::Context,
) -> Result<bool, types::InterpreterError> {
for comparison in condition {
let res = Self::eval_comparison(comparison, ctx)?;
if !res {
return Ok(false);
}
}
Ok(true)
}
<file_sep path="hyperswitch/crates/euclid/src/backend/interpreter/types.rs" role="context" start="28" end="28">
pub struct Context(HashMap<String, Option<ValueType>>);
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/euclid/src/backend/interpreter.rs<|crate|> euclid anchor=eval_if_condition kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/euclid/src/backend/interpreter.rs" role="context" start="83" end="96">
fn eval_if_condition(
condition: &ast::IfCondition,
ctx: &types::Context,
) -> Result<bool, types::InterpreterError> {
for comparison in condition {
let res = Self::eval_comparison(comparison, ctx)?;
if !res {
return Ok(false);
}
}
Ok(true)
}
<file_sep path="hyperswitch/crates/euclid/src/backend/interpreter.rs" role="context" start="82" end="82">
use common_utils::types::MinorUnit;
use crate::{
backend::{self, inputs, EuclidBackend},
frontend::ast,
};
<file_sep path="hyperswitch/crates/euclid/src/backend/interpreter.rs" role="context" start="123" end="136">
fn eval_rule_statements(
statements: &[ast::IfStatement],
ctx: &types::Context,
) -> Result<bool, types::InterpreterError> {
for stmt in statements {
let res = Self::eval_if_statement(stmt, ctx)?;
if res {
return Ok(true);
}
}
Ok(false)
}
<file_sep path="hyperswitch/crates/euclid/src/backend/interpreter.rs" role="context" start="98" end="121">
fn eval_if_statement(
stmt: &ast::IfStatement,
ctx: &types::Context,
) -> Result<bool, types::InterpreterError> {
let cond_res = Self::eval_if_condition(&stmt.condition, ctx)?;
if !cond_res {
return Ok(false);
}
if let Some(ref nested) = stmt.nested {
for nested_if in nested {
let res = Self::eval_if_statement(nested_if, ctx)?;
if res {
return Ok(true);
}
}
return Ok(false);
}
Ok(true)
}
<file_sep path="hyperswitch/crates/euclid/src/backend/interpreter.rs" role="context" start="41" end="81">
fn eval_comparison(
comparison: &ast::Comparison,
ctx: &types::Context,
) -> Result<bool, types::InterpreterError> {
use ast::{ComparisonType::*, ValueType::*};
let value = ctx
.get(&comparison.lhs)
.ok_or_else(|| types::InterpreterError {
error_type: types::InterpreterErrorType::InvalidKey(comparison.lhs.clone()),
metadata: comparison.metadata.clone(),
})?;
if let Some(val) = value {
match (val, &comparison.comparison, &comparison.value) {
(EnumVariant(e1), Equal, EnumVariant(e2)) => Ok(e1 == e2),
(EnumVariant(e1), NotEqual, EnumVariant(e2)) => Ok(e1 != e2),
(EnumVariant(e), Equal, EnumVariantArray(evec)) => Ok(evec.iter().any(|v| e == v)),
(EnumVariant(e), NotEqual, EnumVariantArray(evec)) => {
Ok(evec.iter().all(|v| e != v))
}
(Number(n1), Equal, Number(n2)) => Ok(n1 == n2),
(Number(n1), NotEqual, Number(n2)) => Ok(n1 != n2),
(Number(n1), LessThanEqual, Number(n2)) => Ok(n1 <= n2),
(Number(n1), GreaterThanEqual, Number(n2)) => Ok(n1 >= n2),
(Number(n1), LessThan, Number(n2)) => Ok(n1 < n2),
(Number(n1), GreaterThan, Number(n2)) => Ok(n1 > n2),
(Number(n), Equal, NumberArray(nvec)) => Ok(nvec.iter().any(|v| v == n)),
(Number(n), NotEqual, NumberArray(nvec)) => Ok(nvec.iter().all(|v| v != n)),
(Number(n), Equal, NumberComparisonArray(ncvec)) => {
Self::eval_number_comparison_array(*n, ncvec)
}
_ => Err(types::InterpreterError {
error_type: types::InterpreterErrorType::InvalidComparison,
metadata: comparison.metadata.clone(),
}),
}
} else {
Ok(false)
}
}
<file_sep path="hyperswitch/crates/euclid/src/backend/interpreter.rs" role="context" start="18" end="39">
fn eval_number_comparison_array(
num: MinorUnit,
array: &[ast::NumberComparison],
) -> Result<bool, types::InterpreterError> {
for comparison in array {
let other = comparison.number;
let res = match comparison.comparison_type {
ast::ComparisonType::GreaterThan => num > other,
ast::ComparisonType::LessThan => num < other,
ast::ComparisonType::LessThanEqual => num <= other,
ast::ComparisonType::GreaterThanEqual => num >= other,
ast::ComparisonType::Equal => num == other,
ast::ComparisonType::NotEqual => num != other,
};
if res {
return Ok(true);
}
}
Ok(false)
}
<file_sep path="hyperswitch/crates/euclid/src/backend/interpreter/types.rs" role="context" start="28" end="28">
pub struct Context(HashMap<String, Option<ValueType>>);
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/euclid_wasm/src/lib.rs<|crate|> euclid_wasm anchor=get_tax_processor_config kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/euclid_wasm/src/lib.rs" role="context" start="336" end="341">
pub fn get_tax_processor_config(key: &str) -> JsResult {
let key = api_model_enums::TaxConnectors::from_str(key)
.map_err(|_| "Invalid key received".to_string())?;
let res = connector::ConnectorConfig::get_tax_processor_config(key)?;
Ok(serde_wasm_bindgen::to_value(&res)?)
}
<file_sep path="hyperswitch/crates/euclid_wasm/src/lib.rs" role="context" start="335" end="335">
use std::{
collections::{HashMap, HashSet},
str::FromStr,
};
use api_models::{
enums as api_model_enums, routing::ConnectorSelection,
surcharge_decision_configs::SurchargeDecisionConfigs,
};
use connector_configs::{
common_config::{ConnectorApiIntegrationPayload, DashboardRequestPayload},
connector,
};
type JsResult = Result<JsValue, JsValue>;
<file_sep path="hyperswitch/crates/euclid_wasm/src/lib.rs" role="context" start="352" end="357">
pub fn get_request_payload(input: JsValue, response: JsValue) -> JsResult {
let input: DashboardRequestPayload = serde_wasm_bindgen::from_value(input)?;
let api_response: ConnectorApiIntegrationPayload = serde_wasm_bindgen::from_value(response)?;
let result = DashboardRequestPayload::create_connector_request(input, api_response);
Ok(serde_wasm_bindgen::to_value(&result)?)
}
<file_sep path="hyperswitch/crates/euclid_wasm/src/lib.rs" role="context" start="344" end="349">
pub fn get_pm_authentication_processor_config(key: &str) -> JsResult {
let key: api_model_enums::PmAuthConnectors = api_model_enums::PmAuthConnectors::from_str(key)
.map_err(|_| "Invalid key received".to_string())?;
let res = connector::ConnectorConfig::get_pm_authentication_processor_config(key)?;
Ok(serde_wasm_bindgen::to_value(&res)?)
}
<file_sep path="hyperswitch/crates/euclid_wasm/src/lib.rs" role="context" start="328" end="333">
pub fn get_authentication_connector_config(key: &str) -> JsResult {
let key = api_model_enums::AuthenticationConnectors::from_str(key)
.map_err(|_| "Invalid key received".to_string())?;
let res = connector::ConnectorConfig::get_authentication_connector_config(key)?;
Ok(serde_wasm_bindgen::to_value(&res)?)
}
<file_sep path="hyperswitch/crates/euclid_wasm/src/lib.rs" role="context" start="320" end="325">
pub fn get_payout_connector_config(key: &str) -> JsResult {
let key = api_model_enums::PayoutConnectors::from_str(key)
.map_err(|_| "Invalid key received".to_string())?;
let res = connector::ConnectorConfig::get_payout_connector_config(key)?;
Ok(serde_wasm_bindgen::to_value(&res)?)
}
<file_sep path="hyperswitch/crates/euclid_wasm/src/lib.rs" role="context" start="34" end="34">
type JsResult = Result<JsValue, JsValue>;
<file_sep path="hyperswitch/crates/api_models/src/enums.rs" role="context" start="159" end="161">
pub enum TaxConnectors {
Taxjar,
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/euclid_wasm/src/lib.rs<|crate|> euclid_wasm anchor=get_authentication_connector_config kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=1<|meta_end|>
<file_sep path="hyperswitch/crates/euclid_wasm/src/lib.rs" role="context" start="328" end="333">
pub fn get_authentication_connector_config(key: &str) -> JsResult {
let key = api_model_enums::AuthenticationConnectors::from_str(key)
.map_err(|_| "Invalid key received".to_string())?;
let res = connector::ConnectorConfig::get_authentication_connector_config(key)?;
Ok(serde_wasm_bindgen::to_value(&res)?)
}
<file_sep path="hyperswitch/crates/euclid_wasm/src/lib.rs" role="context" start="327" end="327">
use std::{
collections::{HashMap, HashSet},
str::FromStr,
};
use api_models::{
enums as api_model_enums, routing::ConnectorSelection,
surcharge_decision_configs::SurchargeDecisionConfigs,
};
use connector_configs::{
common_config::{ConnectorApiIntegrationPayload, DashboardRequestPayload},
connector,
};
type JsResult = Result<JsValue, JsValue>;
<file_sep path="hyperswitch/crates/euclid_wasm/src/lib.rs" role="context" start="344" end="349">
pub fn get_pm_authentication_processor_config(key: &str) -> JsResult {
let key: api_model_enums::PmAuthConnectors = api_model_enums::PmAuthConnectors::from_str(key)
.map_err(|_| "Invalid key received".to_string())?;
let res = connector::ConnectorConfig::get_pm_authentication_processor_config(key)?;
Ok(serde_wasm_bindgen::to_value(&res)?)
}
<file_sep path="hyperswitch/crates/euclid_wasm/src/lib.rs" role="context" start="336" end="341">
pub fn get_tax_processor_config(key: &str) -> JsResult {
let key = api_model_enums::TaxConnectors::from_str(key)
.map_err(|_| "Invalid key received".to_string())?;
let res = connector::ConnectorConfig::get_tax_processor_config(key)?;
Ok(serde_wasm_bindgen::to_value(&res)?)
}
<file_sep path="hyperswitch/crates/euclid_wasm/src/lib.rs" role="context" start="320" end="325">
pub fn get_payout_connector_config(key: &str) -> JsResult {
let key = api_model_enums::PayoutConnectors::from_str(key)
.map_err(|_| "Invalid key received".to_string())?;
let res = connector::ConnectorConfig::get_payout_connector_config(key)?;
Ok(serde_wasm_bindgen::to_value(&res)?)
}
<file_sep path="hyperswitch/crates/euclid_wasm/src/lib.rs" role="context" start="311" end="316">
pub fn get_connector_config(key: &str) -> JsResult {
let key = api_model_enums::Connector::from_str(key)
.map_err(|_| "Invalid key received".to_string())?;
let res = connector::ConnectorConfig::get_connector_config(key)?;
Ok(serde_wasm_bindgen::to_value(&res)?)
}
<file_sep path="hyperswitch/crates/euclid_wasm/src/lib.rs" role="context" start="34" end="34">
type JsResult = Result<JsValue, JsValue>;
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/euclid_wasm/src/lib.rs<|crate|> euclid_wasm anchor=get_payout_connector_config kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/euclid_wasm/src/lib.rs" role="context" start="320" end="325">
pub fn get_payout_connector_config(key: &str) -> JsResult {
let key = api_model_enums::PayoutConnectors::from_str(key)
.map_err(|_| "Invalid key received".to_string())?;
let res = connector::ConnectorConfig::get_payout_connector_config(key)?;
Ok(serde_wasm_bindgen::to_value(&res)?)
}
<file_sep path="hyperswitch/crates/euclid_wasm/src/lib.rs" role="context" start="319" end="319">
use std::{
collections::{HashMap, HashSet},
str::FromStr,
};
use api_models::{
enums as api_model_enums, routing::ConnectorSelection,
surcharge_decision_configs::SurchargeDecisionConfigs,
};
use connector_configs::{
common_config::{ConnectorApiIntegrationPayload, DashboardRequestPayload},
connector,
};
type JsResult = Result<JsValue, JsValue>;
<file_sep path="hyperswitch/crates/euclid_wasm/src/lib.rs" role="context" start="336" end="341">
pub fn get_tax_processor_config(key: &str) -> JsResult {
let key = api_model_enums::TaxConnectors::from_str(key)
.map_err(|_| "Invalid key received".to_string())?;
let res = connector::ConnectorConfig::get_tax_processor_config(key)?;
Ok(serde_wasm_bindgen::to_value(&res)?)
}
<file_sep path="hyperswitch/crates/euclid_wasm/src/lib.rs" role="context" start="328" end="333">
pub fn get_authentication_connector_config(key: &str) -> JsResult {
let key = api_model_enums::AuthenticationConnectors::from_str(key)
.map_err(|_| "Invalid key received".to_string())?;
let res = connector::ConnectorConfig::get_authentication_connector_config(key)?;
Ok(serde_wasm_bindgen::to_value(&res)?)
}
<file_sep path="hyperswitch/crates/euclid_wasm/src/lib.rs" role="context" start="311" end="316">
pub fn get_connector_config(key: &str) -> JsResult {
let key = api_model_enums::Connector::from_str(key)
.map_err(|_| "Invalid key received".to_string())?;
let res = connector::ConnectorConfig::get_connector_config(key)?;
Ok(serde_wasm_bindgen::to_value(&res)?)
}
<file_sep path="hyperswitch/crates/euclid_wasm/src/lib.rs" role="context" start="287" end="308">
pub fn get_description_category() -> JsResult {
let keys = dir::DirKeyKind::VARIANTS
.iter()
.copied()
.filter(|s| s != &"Connector")
.collect::<Vec<&'static str>>();
let mut category: HashMap<Option<&str>, Vec<types::Details<'_>>> = HashMap::new();
for key in keys {
let dir_key =
dir::DirKeyKind::from_str(key).map_err(|_| "Invalid key received".to_string())?;
let details = types::Details {
description: dir_key.get_detailed_message(),
kind: dir_key.clone(),
};
category
.entry(dir_key.get_str("Category"))
.and_modify(|val| val.push(details.clone()))
.or_insert(vec![details]);
}
Ok(serde_wasm_bindgen::to_value(&category)?)
}
<file_sep path="hyperswitch/crates/euclid_wasm/src/lib.rs" role="context" start="34" end="34">
type JsResult = Result<JsValue, JsValue>;
<file_sep path="hyperswitch/crates/api_models/src/enums.rs" role="context" start="46" end="56">
pub enum PayoutConnectors {
Adyen,
Adyenplatform,
Cybersource,
Ebanx,
Nomupay,
Payone,
Paypal,
Stripe,
Wise,
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch-card-vault/src/crypto/encryption_manager/managers/jw.rs<|crate|> src anchor=test_jwe kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=1<|meta_end|>
<file_sep path="hyperswitch-card-vault/src/crypto/encryption_manager/managers/jw.rs" role="context" start="192" end="197">
fn test_jwe() {
let jwt = encrypt_jwe("request_payload".as_bytes(), ENCRYPTION_KEY, jwe::RSA_OAEP).unwrap();
let alg = jwe::RSA_OAEP;
let payload = decrypt_jwe(&jwt, DECRYPTION_KEY, alg).unwrap();
assert_eq!("request_payload".to_string(), payload)
}
<file_sep path="hyperswitch-card-vault/src/crypto/encryption_manager/managers/jw.rs" role="context" start="191" end="191">
use josekit::{jwe, jws};
<file_sep path="hyperswitch-card-vault/src/crypto/encryption_manager/managers/jw.rs" role="context" start="200" end="204">
fn test_jws() {
let jwt = jws_sign_payload("jws payload".as_bytes(), SIGNING_KEY).unwrap();
let payload = verify_sign(jwt, SIGNATURE_VERIFICATION_KEY).unwrap();
assert_eq!("jws payload".to_string(), payload)
}
<file_sep path="hyperswitch-card-vault/src/crypto/encryption_manager/managers/jw.rs" role="context" start="166" end="173">
pub fn verify_sign(jws_body: String, key: impl AsRef<[u8]>) -> Result<String, error::CryptoError> {
let alg = jws::RS256;
let input = jws_body.as_bytes();
let verifier = alg.verifier_from_pem(key)?;
let (dst_payload, _dst_header) = jws::deserialize_compact(input, &verifier)?;
let resp = String::from_utf8(dst_payload)?;
Ok(resp)
}
<file_sep path="hyperswitch-card-vault/src/crypto/encryption_manager/managers/jw.rs" role="context" start="154" end="164">
pub fn decrypt_jwe(
jwt: &str,
private_key: impl AsRef<[u8]>,
alg: jwe::alg::rsaes::RsaesJweAlgorithm,
) -> Result<String, error::CryptoError> {
let decrypter = alg.decrypter_from_pem(private_key)?;
let (dst_payload, _dst_header) = jwe::deserialize_compact(jwt, &decrypter)?;
Ok(String::from_utf8(dst_payload)?)
}
<file_sep path="hyperswitch-card-vault/src/crypto/encryption_manager/managers/jw.rs" role="context" start="140" end="152">
pub fn encrypt_jwe(
payload: &[u8],
public_key: impl AsRef<[u8]>,
alg: jwe::alg::rsaes::RsaesJweAlgorithm,
) -> Result<String, error::CryptoError> {
let enc = "A256GCM";
let mut src_header = jwe::JweHeader::new();
src_header.set_content_encryption(enc);
src_header.set_token_type("JWT");
let encrypter = alg.encrypter_from_pem(public_key)?;
Ok(jwe::serialize_compact(payload, &src_header, &encrypter)?)
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/redis_interface/src/lib.rs<|crate|> redis_interface anchor=clone kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=1<|meta_end|>
<file_sep path="hyperswitch/crates/redis_interface/src/lib.rs" role="context" start="181" end="190">
pub fn clone(&self, key_prefix: &str) -> Self {
Self {
pool: Arc::clone(&self.pool),
key_prefix: key_prefix.to_string(),
config: Arc::clone(&self.config),
subscriber: Arc::clone(&self.subscriber),
publisher: Arc::clone(&self.publisher),
is_redis_available: Arc::clone(&self.is_redis_available),
}
}
<file_sep path="hyperswitch/crates/redis_interface/src/lib.rs" role="context" start="180" end="180">
use std::sync::{atomic, Arc};
pub use fred::interfaces::PubsubInterface;
pub use self::types::*;
<file_sep path="hyperswitch/crates/redis_interface/src/lib.rs" role="context" start="218" end="225">
pub async fn on_unresponsive(&self) {
let _ = self.pool.clients().iter().map(|client| {
client.on_unresponsive(|server| {
tracing::warn!(redis_server =?server.host, "Redis server is unresponsive");
Ok(())
})
});
}
<file_sep path="hyperswitch/crates/redis_interface/src/lib.rs" role="context" start="191" end="216">
pub async fn on_error(&self, tx: tokio::sync::oneshot::Sender<()>) {
use futures::StreamExt;
use tokio_stream::wrappers::BroadcastStream;
let error_rxs: Vec<BroadcastStream<fred::error::RedisError>> = self
.pool
.clients()
.iter()
.map(|client| BroadcastStream::new(client.error_rx()))
.collect();
let mut error_rx = futures::stream::select_all(error_rxs);
loop {
if let Some(Ok(error)) = error_rx.next().await {
tracing::error!(?error, "Redis protocol or connection error");
if self.pool.state() == fred::types::ClientState::Disconnected {
if tx.send(()).is_err() {
tracing::error!("The redis shutdown signal sender failed to signal");
}
self.is_redis_available
.store(false, atomic::Ordering::SeqCst);
break;
}
}
}
}
<file_sep path="hyperswitch/crates/redis_interface/src/lib.rs" role="context" start="102" end="180">
pub async fn new(conf: &RedisSettings) -> CustomResult<Self, errors::RedisError> {
let redis_connection_url = match conf.cluster_enabled {
// Fred relies on this format for specifying cluster where the host port is ignored & only query parameters are used for node addresses
// redis-cluster://username:password@host:port?node=bar.com:30002&node=baz.com:30003
true => format!(
"redis-cluster://{}:{}?{}",
conf.host,
conf.port,
conf.cluster_urls
.iter()
.flat_map(|url| vec!["&", url])
.skip(1)
.collect::<String>()
),
false => format!(
"redis://{}:{}", //URI Schema
conf.host, conf.port,
),
};
let mut config = fred::types::RedisConfig::from_url(&redis_connection_url)
.change_context(errors::RedisError::RedisConnectionError)?;
let perf = fred::types::PerformanceConfig {
auto_pipeline: conf.auto_pipeline,
default_command_timeout: std::time::Duration::from_secs(conf.default_command_timeout),
max_feed_count: conf.max_feed_count,
backpressure: fred::types::BackpressureConfig {
disable_auto_backpressure: conf.disable_auto_backpressure,
max_in_flight_commands: conf.max_in_flight_commands,
policy: fred::types::BackpressurePolicy::Drain,
},
};
let connection_config = fred::types::ConnectionConfig {
unresponsive_timeout: std::time::Duration::from_secs(conf.unresponsive_timeout),
..fred::types::ConnectionConfig::default()
};
if !conf.use_legacy_version {
config.version = fred::types::RespVersion::RESP3;
}
config.tracing = fred::types::TracingConfig::new(true);
config.blocking = fred::types::Blocking::Error;
let reconnect_policy = fred::types::ReconnectPolicy::new_constant(
conf.reconnect_max_attempts,
conf.reconnect_delay,
);
let subscriber =
SubscriberClient::new(config.clone(), reconnect_policy.clone(), perf.clone()).await?;
let publisher =
RedisClient::new(config.clone(), reconnect_policy.clone(), perf.clone()).await?;
let pool = fred::prelude::RedisPool::new(
config,
Some(perf),
Some(connection_config),
Some(reconnect_policy),
conf.pool_size,
)
.change_context(errors::RedisError::RedisConnectionError)?;
pool.connect();
pool.wait_for_connect()
.await
.change_context(errors::RedisError::RedisConnectionError)?;
let config = RedisConfig::from(conf);
Ok(Self {
pool: Arc::new(pool),
config: Arc::new(config),
is_redis_available: Arc::new(atomic::AtomicBool::new(true)),
subscriber: Arc::new(subscriber),
publisher: Arc::new(publisher),
key_prefix: String::default(),
})
}
<file_sep path="hyperswitch/crates/redis_interface/src/lib.rs" role="context" start="95" end="97">
fn deref(&self) -> &Self::Target {
&self.inner
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/storage_impl/src/config.rs<|crate|> storage_impl anchor=default kind=fn pack=symbol_neighborhood lang=rust role_window=k2 hops=1<|meta_end|>
<file_sep path="hyperswitch/crates/storage_impl/src/config.rs" role="context" start="62" end="75">
fn default() -> Self {
Self {
username: String::new(),
password: Secret::<String>::default(),
host: "localhost".into(),
port: 5432,
dbname: String::new(),
pool_size: 5,
connection_timeout: 10,
queue_strategy: QueueStrategy::default(),
min_idle: None,
max_lifetime: None,
}
}
<file_sep path="hyperswitch/crates/storage_impl/src/config.rs" role="context" start="61" end="61">
use masking::Secret;
<file_sep path="hyperswitch/crates/storage_impl/src/config.rs" role="context" start="53" end="58">
fn from(value: QueueStrategy) -> Self {
match value {
QueueStrategy::Fifo => Self::Fifo,
QueueStrategy::Lifo => Self::Lifo,
}
}
<file_sep path="hyperswitch/crates/storage_impl/src/config.rs" role="context" start="31" end="33">
fn get_dbname(&self) -> &str {
&self.dbname
}
<file_sep path="hyperswitch/crates/storage_impl/src/config.rs" role="context" start="46" end="50">
pub enum QueueStrategy {
#[default]
Fifo,
Lifo,
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch-encryption-service/src/crypto/vault.rs<|crate|> src anchor=new kind=fn pack=symbol_neighborhood lang=rust role_window=k2 hops=2<|meta_end|>
<file_sep path="hyperswitch-encryption-service/src/crypto/vault.rs" role="context" start="29" end="42">
pub fn new(settings: VaultSettings) -> Self {
let client = VaultClient::new(
VaultClientSettingsBuilder::default()
.address(&settings.url)
.token(settings.vault_token.peek())
.build()
.expect("Unable to build HashiCorp Vault Settings"),
)
.expect("Unable to build HashiCorp Vault client");
Self {
inner_client: client,
settings,
}
}
<file_sep path="hyperswitch-encryption-service/src/crypto/vault.rs" role="context" start="28" end="28">
use vaultrs::client::{VaultClient, VaultClientSettingsBuilder};
<file_sep path="hyperswitch-encryption-service/src/crypto/vault.rs" role="context" start="80" end="99">
fn encrypt(&self, input: StrongSecret<Vec<u8>>) -> Self::DataReturn<'_> {
let b64_text = BASE64_ENGINE.encode(input.peek());
Box::pin(async move {
Ok(transit::data::encrypt(
&self.inner_client,
&self.settings.mount_point,
&self.settings.encryption_key,
&b64_text,
None,
)
.await
.map_err(|err| {
report!(err).change_context(CryptoError::EncryptionFailed("HashiCorp Vault"))
})?
.ciphertext
.as_bytes()
.to_vec()
.into())
})
}
<file_sep path="hyperswitch-encryption-service/src/crypto/vault.rs" role="context" start="55" end="78">
async fn generate_key(
&self,
) -> CustomResult<(Source, StrongSecret<[u8; 32]>), errors::CryptoError> {
//According to Vault transit engine can genarate high entropy random bytes of different lengths.
//https://developer.hashicorp.com/vault/docs/secrets/transit
let response = transit::generate::random_bytes(
&self.inner_client,
&self.settings.mount_point,
api::transit::OutputFormat::Base64,
api::transit::requests::RandomBytesSource::All,
None,
)
.await
.map_err(|err| report!(err).change_context(errors::CryptoError::KeyGeneration))?;
let key = BASE64_ENGINE
.decode(response.random_bytes)
.map_err(|err| report!(err).change_context(CryptoError::KeyGeneration))?;
let buffer: [u8; 32] = key.try_into().map_err(|err: Vec<u8>| {
let err_bytes = format!("{:?}", err);
logger::debug!(err_bytes);
report!(CryptoError::KeyGeneration)
})?;
Ok((Source::HashicorpVault, buffer.into()))
}
<file_sep path="hyperswitch-encryption-service/src/crypto/vault.rs" role="context" start="22" end="25">
pub struct Vault {
inner_client: VaultClient,
settings: VaultSettings,
}
<file_sep path="hyperswitch-encryption-service/src/crypto/vault.rs" role="context" start="15" end="20">
pub struct VaultSettings {
pub url: String,
pub mount_point: String,
pub encryption_key: String,
pub vault_token: masking::Secret<String>,
}
<file_sep path="hyperswitch/crates/api_models/src/user/theme.rs" role="context" start="63" end="70">
struct Settings {
colors: Colors,
sidebar: Option<Sidebar>,
typography: Option<Typography>,
buttons: Buttons,
borders: Option<Borders>,
spacing: Option<Spacing>,
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch-card-vault/src/crypto/encryption_manager/managers/jw.rs<|crate|> src anchor=from_str kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=1<|meta_end|>
<file_sep path="hyperswitch-card-vault/src/crypto/encryption_manager/managers/jw.rs" role="context" start="70" end="84">
fn from_str(input: &str) -> Option<Self> {
let mut data = input.split('.');
let header = data.next()?.to_string();
let encrypted_key = data.next()?.to_string();
let iv = data.next()?.to_string();
let encrypted_payload = data.next()?.to_string();
let tag = data.next()?.to_string();
Some(Self {
header,
iv,
encrypted_payload,
tag,
encrypted_key,
})
}
<file_sep path="hyperswitch-card-vault/src/crypto/encryption_manager/managers/jw.rs" role="context" start="99" end="114">
fn encrypt(&self, input: Vec<u8>) -> Self::ReturnType<'_, JweBody> {
let payload = input;
let jws_encoded = jws_sign_payload(&payload, self.private_key.peek().as_bytes())?;
let jws_body = JwsBody::from_dotted_str(&jws_encoded).ok_or(
error::CryptoError::InvalidData("JWS encoded data is incomplete"),
)?;
let jws_payload = serde_json::to_vec(&jws_body).map_err(error::CryptoError::from)?;
let jwe_encrypted = encrypt_jwe(
&jws_payload,
self.public_key.peek().as_bytes(),
self.encryption_algo,
)?;
let jwe_body = JweBody::from_str(&jwe_encrypted)
.ok_or(error::CryptoError::InvalidData("JWE data incomplete"))?;
Ok(jwe_body)
}
<file_sep path="hyperswitch-card-vault/src/crypto/encryption_manager/managers/jw.rs" role="context" start="86" end="93">
pub fn get_dotted_jwe(self) -> String {
let header = self.header;
let encryption_key = self.encrypted_key;
let iv = self.iv;
let encryption_payload = self.encrypted_payload;
let tag = self.tag;
format!("{header}.{encryption_key}.{iv}.{encryption_payload}.{tag}")
}
<file_sep path="hyperswitch-card-vault/src/crypto/encryption_manager/managers/jw.rs" role="context" start="51" end="56">
pub fn get_dotted_jws(self) -> String {
let header = self.header;
let payload = self.payload;
let signature = self.signature;
format!("{header}.{payload}.{signature}")
}
<file_sep path="hyperswitch-card-vault/src/crypto/encryption_manager/managers/jw.rs" role="context" start="39" end="49">
fn from_dotted_str(input: &str) -> Option<Self> {
let mut data = input.split('.');
let header = data.next()?.to_string();
let payload = data.next()?.to_string();
let signature = data.next()?.to_string();
Some(Self {
header,
payload,
signature,
})
}
<file_sep path="hyperswitch-card-vault/src/crypto/encryption_manager/managers/jw.rs" role="context" start="116" end="127">
fn decrypt(&self, input: JweBody) -> Self::ReturnType<'_, Vec<u8>> {
let jwe_encoded = input.get_dotted_jwe();
let jwe_decrypted =
decrypt_jwe(&jwe_encoded, self.private_key.peek(), self.decryption_algo)?;
let jws_parsed: JwsBody = serde_json::from_str(&jwe_decrypted)
.map_err(|_| error::CryptoError::InvalidData("Failed while extracting jws body"))?;
let jws_encoded = jws_parsed.get_dotted_jws();
let output = verify_sign(jws_encoded, self.public_key.peek().as_bytes())?;
Ok(output.as_bytes().to_vec())
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/hyperswitch_connectors/src/connectors/dlocal/transformers.rs<|crate|> hyperswitch_connectors<|connector|> dlocal anchor=try_from kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/dlocal/transformers.rs" role="context" start="495" end="506">
fn try_from(
item: RefundsResponseRouterData<Execute, RefundResponse>,
) -> Result<Self, Self::Error> {
let refund_status = enums::RefundStatus::from(item.response.status);
Ok(Self {
response: Ok(RefundsResponseData {
connector_refund_id: item.response.id,
refund_status,
}),
..item.data
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/dlocal/transformers.rs" role="context" start="494" end="494">
use common_enums::enums;
use hyperswitch_domain_models::{
payment_method_data::PaymentMethodData,
router_data::{ConnectorAuthType, RouterData},
router_flow_types::{refunds::Execute, RSync},
router_request_types::ResponseId,
router_response_types::{PaymentsResponseData, RedirectForm, RefundsResponseData},
types,
};
use crate::{
types::{RefundsResponseRouterData, ResponseRouterData},
utils::{AddressDetailsData, PaymentsAuthorizeRequestData, RouterData as _},
};
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/dlocal/transformers.rs" role="context" start="529" end="540">
fn try_from(
item: RefundsResponseRouterData<RSync, RefundResponse>,
) -> Result<Self, Self::Error> {
let refund_status = enums::RefundStatus::from(item.response.status);
Ok(Self {
response: Ok(RefundsResponseData {
connector_refund_id: item.response.id,
refund_status,
}),
..item.data
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/dlocal/transformers.rs" role="context" start="516" end="524">
fn try_from(item: &types::RefundSyncRouterData) -> Result<Self, Self::Error> {
let refund_id = match item.request.connector_refund_id.clone() {
Some(val) => val,
None => item.request.refund_id.clone(),
};
Ok(Self {
refund_id: (refund_id),
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/dlocal/transformers.rs" role="context" start="475" end="482">
fn from(item: RefundStatus) -> Self {
match item {
RefundStatus::Success => Self::Success,
RefundStatus::Pending => Self::Pending,
RefundStatus::Rejected => Self::ManualReview,
RefundStatus::Cancelled => Self::Failure,
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/dlocal/transformers.rs" role="context" start="450" end="460">
fn try_from(
item: &DlocalRouterData<&types::RefundsRouterData<F>>,
) -> Result<Self, Self::Error> {
let amount_to_refund = item.router_data.request.refund_amount.to_string();
Ok(Self {
amount: amount_to_refund,
payment_id: item.router_data.request.connector_transaction_id.clone(),
currency: item.router_data.request.currency,
id: item.router_data.request.refund_id.clone(),
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/dlocal/transformers.rs" role="context" start="68" end="68">
type Error = error_stack::Report<errors::ConnectorError>;
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/dlocal/transformers.rs" role="context" start="486" end="489">
pub struct RefundResponse {
pub id: String,
pub status: RefundStatus,
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/chargebee/transformers.rs" role="context" start="193" end="198">
pub enum RefundStatus {
Succeeded,
Failed,
#[default]
Processing,
}
<file_sep path="hyperswitch/crates/api_models/src/payment_methods.rs" role="context" start="2478" end="2478">
type Error = error_stack::Report<errors::ValidationError>;
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/hyperswitch_connectors/src/connectors/dlocal/transformers.rs<|crate|> hyperswitch_connectors<|connector|> dlocal anchor=try_from kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/dlocal/transformers.rs" role="context" start="529" end="540">
fn try_from(
item: RefundsResponseRouterData<RSync, RefundResponse>,
) -> Result<Self, Self::Error> {
let refund_status = enums::RefundStatus::from(item.response.status);
Ok(Self {
response: Ok(RefundsResponseData {
connector_refund_id: item.response.id,
refund_status,
}),
..item.data
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/dlocal/transformers.rs" role="context" start="528" end="528">
use common_enums::enums;
use hyperswitch_domain_models::{
payment_method_data::PaymentMethodData,
router_data::{ConnectorAuthType, RouterData},
router_flow_types::{refunds::Execute, RSync},
router_request_types::ResponseId,
router_response_types::{PaymentsResponseData, RedirectForm, RefundsResponseData},
types,
};
use crate::{
types::{RefundsResponseRouterData, ResponseRouterData},
utils::{AddressDetailsData, PaymentsAuthorizeRequestData, RouterData as _},
};
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/dlocal/transformers.rs" role="context" start="550" end="567">
fn get_doc_from_currency(country: String) -> Secret<String> {
let doc = match country.as_str() {
"BR" => "91483309223",
"ZA" => "2001014800086",
"BD" | "GT" | "HN" | "PK" | "SN" | "TH" => "1234567890001",
"CR" | "SV" | "VN" => "123456789",
"DO" | "NG" => "12345678901",
"EG" => "12345678901112",
"GH" | "ID" | "RW" | "UG" => "1234567890111123",
"IN" => "NHSTP6374G",
"CI" => "CA124356789",
"JP" | "MY" | "PH" => "123456789012",
"NI" => "1234567890111A",
"TZ" => "12345678912345678900",
_ => "12345678",
};
Secret::new(doc.to_string())
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/dlocal/transformers.rs" role="context" start="516" end="524">
fn try_from(item: &types::RefundSyncRouterData) -> Result<Self, Self::Error> {
let refund_id = match item.request.connector_refund_id.clone() {
Some(val) => val,
None => item.request.refund_id.clone(),
};
Ok(Self {
refund_id: (refund_id),
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/dlocal/transformers.rs" role="context" start="495" end="506">
fn try_from(
item: RefundsResponseRouterData<Execute, RefundResponse>,
) -> Result<Self, Self::Error> {
let refund_status = enums::RefundStatus::from(item.response.status);
Ok(Self {
response: Ok(RefundsResponseData {
connector_refund_id: item.response.id,
refund_status,
}),
..item.data
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/dlocal/transformers.rs" role="context" start="475" end="482">
fn from(item: RefundStatus) -> Self {
match item {
RefundStatus::Success => Self::Success,
RefundStatus::Pending => Self::Pending,
RefundStatus::Rejected => Self::ManualReview,
RefundStatus::Cancelled => Self::Failure,
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/dlocal/transformers.rs" role="context" start="68" end="68">
type Error = error_stack::Report<errors::ConnectorError>;
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/dlocal/transformers.rs" role="context" start="486" end="489">
pub struct RefundResponse {
pub id: String,
pub status: RefundStatus,
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/chargebee/transformers.rs" role="context" start="193" end="198">
pub enum RefundStatus {
Succeeded,
Failed,
#[default]
Processing,
}
<file_sep path="hyperswitch/crates/api_models/src/payment_methods.rs" role="context" start="2478" end="2478">
type Error = error_stack::Report<errors::ValidationError>;
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/hyperswitch_connectors/src/connectors/dlocal/transformers.rs<|crate|> hyperswitch_connectors<|connector|> dlocal anchor=try_from kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/dlocal/transformers.rs" role="context" start="359" end="376">
fn try_from(
item: ResponseRouterData<F, DlocalPaymentsSyncResponse, T, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
Ok(Self {
status: enums::AttemptStatus::from(item.response.status),
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(item.response.id.clone()),
redirection_data: Box::new(None),
mandate_reference: Box::new(None),
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: item.response.order_id.clone(),
incremental_authorization_allowed: None,
charges: None,
}),
..item.data
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/dlocal/transformers.rs" role="context" start="358" end="358">
use common_enums::enums;
use hyperswitch_domain_models::{
payment_method_data::PaymentMethodData,
router_data::{ConnectorAuthType, RouterData},
router_flow_types::{refunds::Execute, RSync},
router_request_types::ResponseId,
router_response_types::{PaymentsResponseData, RedirectForm, RefundsResponseData},
types,
};
use crate::{
types::{RefundsResponseRouterData, ResponseRouterData},
utils::{AddressDetailsData, PaymentsAuthorizeRequestData, RouterData as _},
};
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/dlocal/transformers.rs" role="context" start="419" end="436">
fn try_from(
item: ResponseRouterData<F, DlocalPaymentsCancelResponse, T, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
Ok(Self {
status: enums::AttemptStatus::from(item.response.status),
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(item.response.order_id.clone()),
redirection_data: Box::new(None),
mandate_reference: Box::new(None),
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: Some(item.response.order_id.clone()),
incremental_authorization_allowed: None,
charges: None,
}),
..item.data
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/dlocal/transformers.rs" role="context" start="390" end="407">
fn try_from(
item: ResponseRouterData<F, DlocalPaymentsCaptureResponse, T, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
Ok(Self {
status: enums::AttemptStatus::from(item.response.status),
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(item.response.id.clone()),
redirection_data: Box::new(None),
mandate_reference: Box::new(None),
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: item.response.order_id.clone(),
incremental_authorization_allowed: None,
charges: None,
}),
..item.data
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/dlocal/transformers.rs" role="context" start="321" end="345">
fn try_from(
item: ResponseRouterData<F, DlocalPaymentsResponse, T, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
let redirection_data = item
.response
.three_dsecure
.and_then(|three_secure_data| three_secure_data.redirect_url)
.map(|redirect_url| RedirectForm::from((redirect_url, Method::Get)));
let response = PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(item.response.id.clone()),
redirection_data: Box::new(redirection_data),
mandate_reference: Box::new(None),
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: item.response.order_id.clone(),
incremental_authorization_allowed: None,
charges: None,
};
Ok(Self {
status: enums::AttemptStatus::from(item.response.status),
response: Ok(response),
..item.data
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/dlocal/transformers.rs" role="context" start="292" end="301">
fn from(item: DlocalPaymentStatus) -> Self {
match item {
DlocalPaymentStatus::Authorized => Self::Authorized,
DlocalPaymentStatus::Verified => Self::Authorized,
DlocalPaymentStatus::Paid => Self::Charged,
DlocalPaymentStatus::Pending => Self::AuthenticationPending,
DlocalPaymentStatus::Cancelled => Self::Voided,
DlocalPaymentStatus::Rejected => Self::AuthenticationFailed,
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/dlocal/transformers.rs" role="context" start="475" end="482">
fn from(item: RefundStatus) -> Self {
match item {
RefundStatus::Success => Self::Success,
RefundStatus::Pending => Self::Pending,
RefundStatus::Rejected => Self::ManualReview,
RefundStatus::Cancelled => Self::Failure,
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/dlocal/transformers.rs" role="context" start="68" end="68">
type Error = error_stack::Report<errors::ConnectorError>;
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/dlocal/transformers.rs" role="context" start="349" end="353">
pub struct DlocalPaymentsSyncResponse {
status: DlocalPaymentStatus,
id: String,
order_id: Option<String>,
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/types.rs" role="context" start="53" end="57">
pub struct ResponseRouterData<Flow, R, Request, Response> {
pub response: R,
pub data: RouterData<Flow, Request, Response>,
pub http_code: u16,
}
<file_sep path="hyperswitch/crates/api_models/src/payment_methods.rs" role="context" start="2478" end="2478">
type Error = error_stack::Report<errors::ValidationError>;
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/hyperswitch_connectors/src/connectors/dlocal/transformers.rs<|crate|> hyperswitch_connectors<|connector|> dlocal anchor=get_payer_name kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=1<|meta_end|>
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/dlocal/transformers.rs" role="context" start="185" end="202">
fn get_payer_name(
address: &hyperswitch_domain_models::address::AddressDetails,
) -> Option<Secret<String>> {
let first_name = address
.first_name
.clone()
.map_or("".to_string(), |first_name| first_name.peek().to_string());
let last_name = address
.last_name
.clone()
.map_or("".to_string(), |last_name| last_name.peek().to_string());
let name: String = format!("{first_name} {last_name}").trim().to_string();
if !name.is_empty() {
Some(Secret::new(name))
} else {
None
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/dlocal/transformers.rs" role="context" start="184" end="184">
use hyperswitch_domain_models::{
payment_method_data::PaymentMethodData,
router_data::{ConnectorAuthType, RouterData},
router_flow_types::{refunds::Execute, RSync},
router_request_types::ResponseId,
router_response_types::{PaymentsResponseData, RedirectForm, RefundsResponseData},
types,
};
use masking::{PeekInterface, Secret};
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/dlocal/transformers.rs" role="context" start="227" end="231">
fn try_from(item: &types::PaymentsCancelRouterData) -> Result<Self, Self::Error> {
Ok(Self {
cancel_id: item.request.connector_transaction_id.clone(),
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/dlocal/transformers.rs" role="context" start="210" end="218">
fn try_from(item: &types::PaymentsSyncRouterData) -> Result<Self, Self::Error> {
Ok(Self {
authz_id: (item
.request
.connector_transaction_id
.get_connector_transaction_id()
.change_context(errors::ConnectorError::MissingConnectorTransactionID)?),
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/dlocal/transformers.rs" role="context" start="97" end="182">
fn try_from(
item: &DlocalRouterData<&types::PaymentsAuthorizeRouterData>,
) -> Result<Self, Self::Error> {
let email = item.router_data.request.email.clone();
let address = item.router_data.get_billing_address()?;
let country = address.get_country()?;
let name = get_payer_name(address);
match item.router_data.request.payment_method_data {
PaymentMethodData::Card(ref ccard) => {
let should_capture = matches!(
item.router_data.request.capture_method,
Some(enums::CaptureMethod::Automatic)
| Some(enums::CaptureMethod::SequentialAutomatic)
);
let payment_request = Self {
amount: item.amount,
currency: item.router_data.request.currency,
payment_method_id: PaymentMethodId::Card,
payment_method_flow: PaymentMethodFlow::Direct,
country: country.to_string(),
payer: Payer {
name,
email,
// [#589]: Allow securely collecting PII from customer in payments request
document: get_doc_from_currency(country.to_string()),
},
card: Some(Card {
holder_name: item
.router_data
.get_optional_billing_full_name()
.unwrap_or(Secret::new("".to_string())),
number: ccard.card_number.clone(),
cvv: ccard.card_cvc.clone(),
expiration_month: ccard.card_exp_month.clone(),
expiration_year: ccard.card_exp_year.clone(),
capture: should_capture.to_string(),
installments_id: item
.router_data
.request
.mandate_id
.as_ref()
.and_then(|ids| ids.mandate_id.clone()),
// [#595[FEATURE] Pass Mandate history information in payment flows/request]
installments: item
.router_data
.request
.mandate_id
.clone()
.map(|_| "1".to_string()),
}),
order_id: item.router_data.connector_request_reference_id.clone(),
three_dsecure: match item.router_data.auth_type {
enums::AuthenticationType::ThreeDs => {
Some(ThreeDSecureReqData { force: true })
}
enums::AuthenticationType::NoThreeDs => None,
},
callback_url: Some(item.router_data.request.get_router_return_url()?),
description: item.router_data.description.clone(),
};
Ok(payment_request)
}
PaymentMethodData::CardRedirect(_)
| PaymentMethodData::Wallet(_)
| PaymentMethodData::PayLater(_)
| PaymentMethodData::BankRedirect(_)
| PaymentMethodData::BankDebit(_)
| PaymentMethodData::BankTransfer(_)
| PaymentMethodData::Crypto(_)
| PaymentMethodData::MandatePayment
| PaymentMethodData::Reward
| PaymentMethodData::RealTimePayment(_)
| PaymentMethodData::MobilePayment(_)
| PaymentMethodData::Upi(_)
| PaymentMethodData::Voucher(_)
| PaymentMethodData::GiftCard(_)
| PaymentMethodData::OpenBanking(_)
| PaymentMethodData::CardToken(_)
| PaymentMethodData::NetworkToken(_)
| PaymentMethodData::CardDetailsForNetworkTransactionId(_) => {
Err(errors::ConnectorError::NotImplemented(
crate::utils::get_unimplemented_payment_method_error_message("Dlocal"),
))?
}
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/dlocal/transformers.rs" role="context" start="70" end="77">
fn try_from(
(_currency_unit, _currency, amount, router_data): (&CurrencyUnit, enums::Currency, i64, T),
) -> Result<Self, Self::Error> {
Ok(Self {
amount,
router_data,
})
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/hyperswitch_connectors/src/connectors/dlocal/transformers.rs<|crate|> hyperswitch_connectors<|connector|> dlocal anchor=try_from kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/dlocal/transformers.rs" role="context" start="419" end="436">
fn try_from(
item: ResponseRouterData<F, DlocalPaymentsCancelResponse, T, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
Ok(Self {
status: enums::AttemptStatus::from(item.response.status),
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(item.response.order_id.clone()),
redirection_data: Box::new(None),
mandate_reference: Box::new(None),
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: Some(item.response.order_id.clone()),
incremental_authorization_allowed: None,
charges: None,
}),
..item.data
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/dlocal/transformers.rs" role="context" start="418" end="418">
use common_enums::enums;
use hyperswitch_domain_models::{
payment_method_data::PaymentMethodData,
router_data::{ConnectorAuthType, RouterData},
router_flow_types::{refunds::Execute, RSync},
router_request_types::ResponseId,
router_response_types::{PaymentsResponseData, RedirectForm, RefundsResponseData},
types,
};
use crate::{
types::{RefundsResponseRouterData, ResponseRouterData},
utils::{AddressDetailsData, PaymentsAuthorizeRequestData, RouterData as _},
};
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/dlocal/transformers.rs" role="context" start="475" end="482">
fn from(item: RefundStatus) -> Self {
match item {
RefundStatus::Success => Self::Success,
RefundStatus::Pending => Self::Pending,
RefundStatus::Rejected => Self::ManualReview,
RefundStatus::Cancelled => Self::Failure,
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/dlocal/transformers.rs" role="context" start="450" end="460">
fn try_from(
item: &DlocalRouterData<&types::RefundsRouterData<F>>,
) -> Result<Self, Self::Error> {
let amount_to_refund = item.router_data.request.refund_amount.to_string();
Ok(Self {
amount: amount_to_refund,
payment_id: item.router_data.request.connector_transaction_id.clone(),
currency: item.router_data.request.currency,
id: item.router_data.request.refund_id.clone(),
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/dlocal/transformers.rs" role="context" start="390" end="407">
fn try_from(
item: ResponseRouterData<F, DlocalPaymentsCaptureResponse, T, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
Ok(Self {
status: enums::AttemptStatus::from(item.response.status),
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(item.response.id.clone()),
redirection_data: Box::new(None),
mandate_reference: Box::new(None),
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: item.response.order_id.clone(),
incremental_authorization_allowed: None,
charges: None,
}),
..item.data
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/dlocal/transformers.rs" role="context" start="359" end="376">
fn try_from(
item: ResponseRouterData<F, DlocalPaymentsSyncResponse, T, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
Ok(Self {
status: enums::AttemptStatus::from(item.response.status),
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(item.response.id.clone()),
redirection_data: Box::new(None),
mandate_reference: Box::new(None),
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: item.response.order_id.clone(),
incremental_authorization_allowed: None,
charges: None,
}),
..item.data
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/dlocal/transformers.rs" role="context" start="68" end="68">
type Error = error_stack::Report<errors::ConnectorError>;
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/dlocal/transformers.rs" role="context" start="410" end="413">
pub struct DlocalPaymentsCancelResponse {
status: DlocalPaymentStatus,
order_id: String,
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/types.rs" role="context" start="53" end="57">
pub struct ResponseRouterData<Flow, R, Request, Response> {
pub response: R,
pub data: RouterData<Flow, Request, Response>,
pub http_code: u16,
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/hyperswitch_connectors/src/connectors/multisafepay.rs<|crate|> hyperswitch_connectors<|connector|> multisafepay anchor=get_request_body kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/multisafepay.rs" role="context" start="309" end="323">
fn get_request_body(
&self,
req: &PaymentsAuthorizeRouterData,
_connectors: &Connectors,
) -> CustomResult<RequestContent, errors::ConnectorError> {
let amount = convert_amount(
self.amount_converter,
req.request.minor_amount,
req.request.currency,
)?;
let connector_router_data = multisafepay::MultisafepayRouterData::from((amount, req));
let connector_req =
multisafepay::MultisafepayPaymentsRequest::try_from(&connector_router_data)?;
Ok(RequestContent::Json(Box::new(connector_req)))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/multisafepay.rs" role="context" start="308" end="308">
&self,
req: &PaymentsAuthorizeRouterData,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
let url = self.base_url(connectors);
let api_key = multisafepay::MultisafepayAuthType::try_from(&req.connector_auth_type)
.change_context(errors::ConnectorError::FailedToObtainAuthType)?
.api_key
.expose();
Ok(format!("{url}v1/json/orders?api_key={api_key}"))
}
fn get_request_body(
&self,
req: &PaymentsAuthorizeRouterData,
_connectors: &Connectors,
) -> CustomResult<RequestContent, errors::ConnectorError> {
let amount = convert_amount(
self.amount_converter,
req.request.minor_amount,
req.request.currency,
)?;
let connector_router_data = multisafepay::MultisafepayRouterData::from((amount, req));
let connector_req =
multisafepay::MultisafepayPaymentsRequest::try_from(&connector_router_data)?;
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/multisafepay.rs" role="context" start="347" end="367">
fn handle_response(
&self,
data: &PaymentsAuthorizeRouterData,
event_builder: Option<&mut ConnectorEvent>,
res: Response,
) -> CustomResult<PaymentsAuthorizeRouterData, errors::ConnectorError> {
let response: multisafepay::MultisafepayAuthResponse = res
.response
.parse_struct("MultisafepayPaymentsResponse")
.change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
event_builder.map(|i| i.set_response_body(&response));
router_env::logger::info!(connector_response=?response);
RouterData::try_from(ResponseRouterData {
response,
data: data.clone(),
http_code: res.status_code,
})
.change_context(errors::ConnectorError::ResponseHandlingFailed)
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/multisafepay.rs" role="context" start="325" end="345">
fn build_request(
&self,
req: &PaymentsAuthorizeRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Ok(Some(
RequestBuilder::new()
.method(Method::Post)
.url(&types::PaymentsAuthorizeType::get_url(
self, req, connectors,
)?)
.attach_default_headers()
.headers(types::PaymentsAuthorizeType::get_headers(
self, req, connectors,
)?)
.set_body(types::PaymentsAuthorizeType::get_request_body(
self, req, connectors,
)?)
.build(),
))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/multisafepay.rs" role="context" start="296" end="307">
fn get_url(
&self,
req: &PaymentsAuthorizeRouterData,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
let url = self.base_url(connectors);
let api_key = multisafepay::MultisafepayAuthType::try_from(&req.connector_auth_type)
.change_context(errors::ConnectorError::FailedToObtainAuthType)?
.api_key
.expose();
Ok(format!("{url}v1/json/orders?api_key={api_key}"))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/multisafepay.rs" role="context" start="292" end="294">
fn get_content_type(&self) -> &'static str {
self.common_get_content_type()
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/multisafepay.rs" role="context" start="57" end="61">
pub fn new() -> &'static Self {
&Self {
amount_converter: &MinorUnitForConnector,
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/multisafepay/transformers.rs" role="context" start="34" end="37">
pub struct MultisafepayRouterData<T> {
amount: MinorUnit,
router_data: T,
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/router/tests/connectors/utils.rs<|crate|> router<|connector|> utils anchor=sync_payment kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/router/tests/connectors/utils.rs" role="context" start="166" end="177">
async fn sync_payment(
&self,
payment_data: Option<types::PaymentsSyncData>,
payment_info: Option<PaymentInfo>,
) -> Result<types::PaymentsSyncRouterData, Report<ConnectorError>> {
let integration = self.get_data().connector.get_connector_integration();
let request = self.generate_data(
payment_data.unwrap_or_else(|| PaymentSyncType::default().0),
payment_info,
);
Box::pin(call_connector(request, integration)).await
}
<file_sep path="hyperswitch/crates/router/tests/connectors/utils.rs" role="context" start="165" end="165">
use error_stack::Report;
use router::{
configs::settings::Settings,
core::{errors::ConnectorError, payments},
db::StorageImpl,
routes,
services::{
self,
connector_integration_interface::{BoxedConnectorIntegrationInterface, ConnectorEnum},
},
types::{self, storage::enums, AccessToken, MinorUnit, PaymentAddress, RouterData},
};
<file_sep path="hyperswitch/crates/router/tests/connectors/utils.rs" role="context" start="200" end="215">
async fn capture_payment(
&self,
transaction_id: String,
payment_data: Option<types::PaymentsCaptureData>,
payment_info: Option<PaymentInfo>,
) -> Result<types::PaymentsCaptureRouterData, Report<ConnectorError>> {
let integration = self.get_data().connector.get_connector_integration();
let request = self.generate_data(
types::PaymentsCaptureData {
connector_transaction_id: transaction_id,
..payment_data.unwrap_or(PaymentCaptureType::default().0)
},
payment_info,
);
Box::pin(call_connector(request, integration)).await
}
<file_sep path="hyperswitch/crates/router/tests/connectors/utils.rs" role="context" start="180" end="198">
async fn psync_retry_till_status_matches(
&self,
status: enums::AttemptStatus,
payment_data: Option<types::PaymentsSyncData>,
payment_info: Option<PaymentInfo>,
) -> Result<types::PaymentsSyncRouterData, Report<ConnectorError>> {
let max_tries = 3;
for curr_try in 0..max_tries {
let sync_res = self
.sync_payment(payment_data.clone(), payment_info.clone())
.await
.unwrap();
if (sync_res.status == status) || (curr_try == max_tries - 1) {
return Ok(sync_res);
}
tokio::time::sleep(Duration::from_secs(self.get_request_interval())).await;
}
Err(ConnectorError::ProcessingStepFailed(None).into())
}
<file_sep path="hyperswitch/crates/router/tests/connectors/utils.rs" role="context" start="149" end="164">
async fn make_payment(
&self,
payment_data: Option<types::PaymentsAuthorizeData>,
payment_info: Option<PaymentInfo>,
) -> Result<types::PaymentsAuthorizeRouterData, Report<ConnectorError>> {
let integration = self.get_data().connector.get_connector_integration();
let request = self.generate_data(
types::PaymentsAuthorizeData {
confirm: true,
capture_method: Some(diesel_models::enums::CaptureMethod::Automatic),
..(payment_data.unwrap_or(PaymentAuthorizeType::default().0))
},
payment_info,
);
Box::pin(call_connector(request, integration)).await
}
<file_sep path="hyperswitch/crates/router/tests/connectors/utils.rs" role="context" start="132" end="145">
async fn create_connector_pm_token(
&self,
payment_data: Option<types::PaymentMethodTokenizationData>,
payment_info: Option<PaymentInfo>,
) -> Result<types::TokenizationRouterData, Report<ConnectorError>> {
let integration = self.get_data().connector.get_connector_integration();
let request = self.generate_data(
types::PaymentMethodTokenizationData {
..(payment_data.unwrap_or(TokenType::default().0))
},
payment_info,
);
Box::pin(call_connector(request, integration)).await
}
<file_sep path="hyperswitch/crates/router/tests/connectors/utils.rs" role="context" start="1103" end="1111">
fn default() -> Self {
let data = types::PaymentMethodTokenizationData {
payment_method_data: types::domain::PaymentMethodData::Card(CCardType::default().0),
browser_info: None,
amount: Some(100),
currency: enums::Currency::USD,
};
Self(data)
}
<file_sep path="hyperswitch/crates/router/tests/connectors/utils.rs" role="context" start="856" end="893">
async fn call_connector<
T: Debug + Clone + 'static,
ResourceCommonData: Debug
+ Clone
+ services::connector_integration_interface::RouterDataConversion<T, Req, Resp>
+ 'static,
Req: Debug + Clone + 'static,
Resp: Debug + Clone + 'static,
>(
request: RouterData<T, Req, Resp>,
integration: BoxedConnectorIntegrationInterface<T, ResourceCommonData, Req, Resp>,
) -> Result<RouterData<T, Req, Resp>, Report<ConnectorError>> {
let conf = Settings::new().unwrap();
let tx: oneshot::Sender<()> = oneshot::channel().0;
let app_state = Box::pin(routes::AppState::with_storage(
conf,
StorageImpl::PostgresqlTest,
tx,
Box::new(services::MockApiClient),
))
.await;
let state = Arc::new(app_state)
.get_session_state(
&common_utils::id_type::TenantId::try_from_string("public".to_string()).unwrap(),
None,
|| {},
)
.unwrap();
services::api::execute_connector_processing_step(
&state,
integration,
&request,
payments::CallConnectorAction::Trigger,
None,
)
.await
}
<file_sep path="hyperswitch/crates/router/tests/connectors/utils.rs" role="context" start="922" end="922">
pub struct PaymentSyncType(pub types::PaymentsSyncData);
<file_sep path="hyperswitch/crates/router/tests/connectors/utils.rs" role="context" start="61" end="72">
pub struct PaymentInfo {
pub address: Option<PaymentAddress>,
pub auth_type: Option<enums::AuthenticationType>,
pub access_token: Option<AccessToken>,
pub connector_meta_data: Option<serde_json::Value>,
pub connector_customer: Option<String>,
pub payment_method_token: Option<String>,
#[cfg(feature = "payouts")]
pub payout_method_data: Option<types::api::PayoutMethodData>,
#[cfg(feature = "payouts")]
pub currency: Option<enums::Currency>,
}
<file_sep path="hyperswitch/crates/router/src/types.rs" role="context" start="140" end="140">
pub type PaymentsSyncRouterData = RouterData<PSync, PaymentsSyncData, PaymentsResponseData>;
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/router/tests/connectors/utils.rs<|crate|> router<|connector|> utils anchor=create_connector_customer kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/router/tests/connectors/utils.rs" role="context" start="117" end="130">
async fn create_connector_customer(
&self,
payment_data: Option<types::ConnectorCustomerData>,
payment_info: Option<PaymentInfo>,
) -> Result<types::ConnectorCustomerRouterData, Report<ConnectorError>> {
let integration = self.get_data().connector.get_connector_integration();
let request = self.generate_data(
types::ConnectorCustomerData {
..(payment_data.unwrap_or(CustomerType::default().0))
},
payment_info,
);
Box::pin(call_connector(request, integration)).await
}
<file_sep path="hyperswitch/crates/router/tests/connectors/utils.rs" role="context" start="116" end="116">
use error_stack::Report;
use router::{
configs::settings::Settings,
core::{errors::ConnectorError, payments},
db::StorageImpl,
routes,
services::{
self,
connector_integration_interface::{BoxedConnectorIntegrationInterface, ConnectorEnum},
},
types::{self, storage::enums, AccessToken, MinorUnit, PaymentAddress, RouterData},
};
<file_sep path="hyperswitch/crates/router/tests/connectors/utils.rs" role="context" start="149" end="164">
async fn make_payment(
&self,
payment_data: Option<types::PaymentsAuthorizeData>,
payment_info: Option<PaymentInfo>,
) -> Result<types::PaymentsAuthorizeRouterData, Report<ConnectorError>> {
let integration = self.get_data().connector.get_connector_integration();
let request = self.generate_data(
types::PaymentsAuthorizeData {
confirm: true,
capture_method: Some(diesel_models::enums::CaptureMethod::Automatic),
..(payment_data.unwrap_or(PaymentAuthorizeType::default().0))
},
payment_info,
);
Box::pin(call_connector(request, integration)).await
}
<file_sep path="hyperswitch/crates/router/tests/connectors/utils.rs" role="context" start="132" end="145">
async fn create_connector_pm_token(
&self,
payment_data: Option<types::PaymentMethodTokenizationData>,
payment_info: Option<PaymentInfo>,
) -> Result<types::TokenizationRouterData, Report<ConnectorError>> {
let integration = self.get_data().connector.get_connector_integration();
let request = self.generate_data(
types::PaymentMethodTokenizationData {
..(payment_data.unwrap_or(TokenType::default().0))
},
payment_info,
);
Box::pin(call_connector(request, integration)).await
}
<file_sep path="hyperswitch/crates/router/tests/connectors/utils.rs" role="context" start="100" end="115">
async fn authorize_payment(
&self,
payment_data: Option<types::PaymentsAuthorizeData>,
payment_info: Option<PaymentInfo>,
) -> Result<types::PaymentsAuthorizeRouterData, Report<ConnectorError>> {
let integration = self.get_data().connector.get_connector_integration();
let request = self.generate_data(
types::PaymentsAuthorizeData {
confirm: true,
capture_method: Some(diesel_models::enums::CaptureMethod::Manual),
..(payment_data.unwrap_or(PaymentAuthorizeType::default().0))
},
payment_info,
);
Box::pin(call_connector(request, integration)).await
}
<file_sep path="hyperswitch/crates/router/tests/connectors/utils.rs" role="context" start="75" end="93">
pub fn with_default_billing_name() -> Self {
Self {
address: Some(PaymentAddress::new(
None,
None,
Some(hyperswitch_domain_models::address::Address {
address: Some(hyperswitch_domain_models::address::AddressDetails {
first_name: Some(Secret::new("John".to_string())),
last_name: Some(Secret::new("Doe".to_string())),
..Default::default()
}),
phone: None,
email: None,
}),
None,
)),
..Default::default()
}
}
<file_sep path="hyperswitch/crates/router/tests/connectors/utils.rs" role="context" start="856" end="893">
async fn call_connector<
T: Debug + Clone + 'static,
ResourceCommonData: Debug
+ Clone
+ services::connector_integration_interface::RouterDataConversion<T, Req, Resp>
+ 'static,
Req: Debug + Clone + 'static,
Resp: Debug + Clone + 'static,
>(
request: RouterData<T, Req, Resp>,
integration: BoxedConnectorIntegrationInterface<T, ResourceCommonData, Req, Resp>,
) -> Result<RouterData<T, Req, Resp>, Report<ConnectorError>> {
let conf = Settings::new().unwrap();
let tx: oneshot::Sender<()> = oneshot::channel().0;
let app_state = Box::pin(routes::AppState::with_storage(
conf,
StorageImpl::PostgresqlTest,
tx,
Box::new(services::MockApiClient),
))
.await;
let state = Arc::new(app_state)
.get_session_state(
&common_utils::id_type::TenantId::try_from_string("public".to_string()).unwrap(),
None,
|| {},
)
.unwrap();
services::api::execute_connector_processing_step(
&state,
integration,
&request,
payments::CallConnectorAction::Trigger,
None,
)
.await
}
<file_sep path="hyperswitch/crates/router/tests/connectors/utils.rs" role="context" start="1103" end="1111">
fn default() -> Self {
let data = types::PaymentMethodTokenizationData {
payment_method_data: types::domain::PaymentMethodData::Card(CCardType::default().0),
browser_info: None,
amount: Some(100),
currency: enums::Currency::USD,
};
Self(data)
}
<file_sep path="hyperswitch/crates/router/tests/connectors/utils.rs" role="context" start="926" end="926">
pub struct CustomerType(pub types::ConnectorCustomerData);
<file_sep path="hyperswitch/crates/router/tests/connectors/utils.rs" role="context" start="61" end="72">
pub struct PaymentInfo {
pub address: Option<PaymentAddress>,
pub auth_type: Option<enums::AuthenticationType>,
pub access_token: Option<AccessToken>,
pub connector_meta_data: Option<serde_json::Value>,
pub connector_customer: Option<String>,
pub payment_method_token: Option<String>,
#[cfg(feature = "payouts")]
pub payout_method_data: Option<types::api::PayoutMethodData>,
#[cfg(feature = "payouts")]
pub currency: Option<enums::Currency>,
}
<file_sep path="hyperswitch/crates/router/src/connector/utils.rs" role="context" start="1043" end="1045">
pub trait ConnectorCustomerData {
fn get_email(&self) -> Result<Email, Error>;
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/router/tests/connectors/utils.rs<|crate|> router<|connector|> utils anchor=create_connector_pm_token kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/router/tests/connectors/utils.rs" role="context" start="132" end="145">
async fn create_connector_pm_token(
&self,
payment_data: Option<types::PaymentMethodTokenizationData>,
payment_info: Option<PaymentInfo>,
) -> Result<types::TokenizationRouterData, Report<ConnectorError>> {
let integration = self.get_data().connector.get_connector_integration();
let request = self.generate_data(
types::PaymentMethodTokenizationData {
..(payment_data.unwrap_or(TokenType::default().0))
},
payment_info,
);
Box::pin(call_connector(request, integration)).await
}
<file_sep path="hyperswitch/crates/router/tests/connectors/utils.rs" role="context" start="131" end="131">
use error_stack::Report;
use router::{
configs::settings::Settings,
core::{errors::ConnectorError, payments},
db::StorageImpl,
routes,
services::{
self,
connector_integration_interface::{BoxedConnectorIntegrationInterface, ConnectorEnum},
},
types::{self, storage::enums, AccessToken, MinorUnit, PaymentAddress, RouterData},
};
<file_sep path="hyperswitch/crates/router/tests/connectors/utils.rs" role="context" start="166" end="177">
async fn sync_payment(
&self,
payment_data: Option<types::PaymentsSyncData>,
payment_info: Option<PaymentInfo>,
) -> Result<types::PaymentsSyncRouterData, Report<ConnectorError>> {
let integration = self.get_data().connector.get_connector_integration();
let request = self.generate_data(
payment_data.unwrap_or_else(|| PaymentSyncType::default().0),
payment_info,
);
Box::pin(call_connector(request, integration)).await
}
<file_sep path="hyperswitch/crates/router/tests/connectors/utils.rs" role="context" start="149" end="164">
async fn make_payment(
&self,
payment_data: Option<types::PaymentsAuthorizeData>,
payment_info: Option<PaymentInfo>,
) -> Result<types::PaymentsAuthorizeRouterData, Report<ConnectorError>> {
let integration = self.get_data().connector.get_connector_integration();
let request = self.generate_data(
types::PaymentsAuthorizeData {
confirm: true,
capture_method: Some(diesel_models::enums::CaptureMethod::Automatic),
..(payment_data.unwrap_or(PaymentAuthorizeType::default().0))
},
payment_info,
);
Box::pin(call_connector(request, integration)).await
}
<file_sep path="hyperswitch/crates/router/tests/connectors/utils.rs" role="context" start="117" end="130">
async fn create_connector_customer(
&self,
payment_data: Option<types::ConnectorCustomerData>,
payment_info: Option<PaymentInfo>,
) -> Result<types::ConnectorCustomerRouterData, Report<ConnectorError>> {
let integration = self.get_data().connector.get_connector_integration();
let request = self.generate_data(
types::ConnectorCustomerData {
..(payment_data.unwrap_or(CustomerType::default().0))
},
payment_info,
);
Box::pin(call_connector(request, integration)).await
}
<file_sep path="hyperswitch/crates/router/tests/connectors/utils.rs" role="context" start="100" end="115">
async fn authorize_payment(
&self,
payment_data: Option<types::PaymentsAuthorizeData>,
payment_info: Option<PaymentInfo>,
) -> Result<types::PaymentsAuthorizeRouterData, Report<ConnectorError>> {
let integration = self.get_data().connector.get_connector_integration();
let request = self.generate_data(
types::PaymentsAuthorizeData {
confirm: true,
capture_method: Some(diesel_models::enums::CaptureMethod::Manual),
..(payment_data.unwrap_or(PaymentAuthorizeType::default().0))
},
payment_info,
);
Box::pin(call_connector(request, integration)).await
}
<file_sep path="hyperswitch/crates/router/tests/connectors/utils.rs" role="context" start="1103" end="1111">
fn default() -> Self {
let data = types::PaymentMethodTokenizationData {
payment_method_data: types::domain::PaymentMethodData::Card(CCardType::default().0),
browser_info: None,
amount: Some(100),
currency: enums::Currency::USD,
};
Self(data)
}
<file_sep path="hyperswitch/crates/router/tests/connectors/utils.rs" role="context" start="856" end="893">
async fn call_connector<
T: Debug + Clone + 'static,
ResourceCommonData: Debug
+ Clone
+ services::connector_integration_interface::RouterDataConversion<T, Req, Resp>
+ 'static,
Req: Debug + Clone + 'static,
Resp: Debug + Clone + 'static,
>(
request: RouterData<T, Req, Resp>,
integration: BoxedConnectorIntegrationInterface<T, ResourceCommonData, Req, Resp>,
) -> Result<RouterData<T, Req, Resp>, Report<ConnectorError>> {
let conf = Settings::new().unwrap();
let tx: oneshot::Sender<()> = oneshot::channel().0;
let app_state = Box::pin(routes::AppState::with_storage(
conf,
StorageImpl::PostgresqlTest,
tx,
Box::new(services::MockApiClient),
))
.await;
let state = Arc::new(app_state)
.get_session_state(
&common_utils::id_type::TenantId::try_from_string("public".to_string()).unwrap(),
None,
|| {},
)
.unwrap();
services::api::execute_connector_processing_step(
&state,
integration,
&request,
payments::CallConnectorAction::Trigger,
None,
)
.await
}
<file_sep path="hyperswitch/crates/router/tests/connectors/utils.rs" role="context" start="927" end="927">
pub struct TokenType(pub types::PaymentMethodTokenizationData);
<file_sep path="hyperswitch/crates/router/tests/connectors/utils.rs" role="context" start="61" end="72">
pub struct PaymentInfo {
pub address: Option<PaymentAddress>,
pub auth_type: Option<enums::AuthenticationType>,
pub access_token: Option<AccessToken>,
pub connector_meta_data: Option<serde_json::Value>,
pub connector_customer: Option<String>,
pub payment_method_token: Option<String>,
#[cfg(feature = "payouts")]
pub payout_method_data: Option<types::api::PayoutMethodData>,
#[cfg(feature = "payouts")]
pub currency: Option<enums::Currency>,
}
<file_sep path="hyperswitch/crates/router/src/types.rs" role="context" start="163" end="167">
pub type TokenizationRouterData = RouterData<
router_flow_types::PaymentMethodToken,
PaymentMethodTokenizationData,
PaymentsResponseData,
>;
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/router/tests/connectors/utils.rs<|crate|> router<|connector|> utils anchor=void_payment kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/router/tests/connectors/utils.rs" role="context" start="236" end="251">
async fn void_payment(
&self,
transaction_id: String,
payment_data: Option<types::PaymentsCancelData>,
payment_info: Option<PaymentInfo>,
) -> Result<types::PaymentsCancelRouterData, Report<ConnectorError>> {
let integration = self.get_data().connector.get_connector_integration();
let request = self.generate_data(
types::PaymentsCancelData {
connector_transaction_id: transaction_id,
..payment_data.unwrap_or(PaymentCancelType::default().0)
},
payment_info,
);
Box::pin(call_connector(request, integration)).await
}
<file_sep path="hyperswitch/crates/router/tests/connectors/utils.rs" role="context" start="235" end="235">
use error_stack::Report;
use router::{
configs::settings::Settings,
core::{errors::ConnectorError, payments},
db::StorageImpl,
routes,
services::{
self,
connector_integration_interface::{BoxedConnectorIntegrationInterface, ConnectorEnum},
},
types::{self, storage::enums, AccessToken, MinorUnit, PaymentAddress, RouterData},
};
<file_sep path="hyperswitch/crates/router/tests/connectors/utils.rs" role="context" start="273" end="288">
async fn refund_payment(
&self,
transaction_id: String,
refund_data: Option<types::RefundsData>,
payment_info: Option<PaymentInfo>,
) -> Result<types::RefundExecuteRouterData, Report<ConnectorError>> {
let integration = self.get_data().connector.get_connector_integration();
let request = self.generate_data(
types::RefundsData {
connector_transaction_id: transaction_id,
..refund_data.unwrap_or(PaymentRefundType::default().0)
},
payment_info,
);
Box::pin(call_connector(request, integration)).await
}
<file_sep path="hyperswitch/crates/router/tests/connectors/utils.rs" role="context" start="253" end="271">
async fn authorize_and_void_payment(
&self,
authorize_data: Option<types::PaymentsAuthorizeData>,
void_data: Option<types::PaymentsCancelData>,
payment_info: Option<PaymentInfo>,
) -> Result<types::PaymentsCancelRouterData, Report<ConnectorError>> {
let authorize_response = self
.authorize_payment(authorize_data, payment_info.clone())
.await
.unwrap();
assert_eq!(authorize_response.status, enums::AttemptStatus::Authorized);
let txn_id = get_connector_transaction_id(authorize_response.response);
tokio::time::sleep(Duration::from_secs(self.get_request_interval())).await; // to avoid 404 error
let response = self
.void_payment(txn_id.unwrap(), void_data, payment_info)
.await
.unwrap();
return Ok(response);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/utils.rs" role="context" start="217" end="234">
async fn authorize_and_capture_payment(
&self,
authorize_data: Option<types::PaymentsAuthorizeData>,
capture_data: Option<types::PaymentsCaptureData>,
payment_info: Option<PaymentInfo>,
) -> Result<types::PaymentsCaptureRouterData, Report<ConnectorError>> {
let authorize_response = self
.authorize_payment(authorize_data, payment_info.clone())
.await
.unwrap();
assert_eq!(authorize_response.status, enums::AttemptStatus::Authorized);
let txn_id = get_connector_transaction_id(authorize_response.response);
let response = self
.capture_payment(txn_id.unwrap(), capture_data, payment_info)
.await
.unwrap();
return Ok(response);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/utils.rs" role="context" start="200" end="215">
async fn capture_payment(
&self,
transaction_id: String,
payment_data: Option<types::PaymentsCaptureData>,
payment_info: Option<PaymentInfo>,
) -> Result<types::PaymentsCaptureRouterData, Report<ConnectorError>> {
let integration = self.get_data().connector.get_connector_integration();
let request = self.generate_data(
types::PaymentsCaptureData {
connector_transaction_id: transaction_id,
..payment_data.unwrap_or(PaymentCaptureType::default().0)
},
payment_info,
);
Box::pin(call_connector(request, integration)).await
}
<file_sep path="hyperswitch/crates/router/tests/connectors/utils.rs" role="context" start="856" end="893">
async fn call_connector<
T: Debug + Clone + 'static,
ResourceCommonData: Debug
+ Clone
+ services::connector_integration_interface::RouterDataConversion<T, Req, Resp>
+ 'static,
Req: Debug + Clone + 'static,
Resp: Debug + Clone + 'static,
>(
request: RouterData<T, Req, Resp>,
integration: BoxedConnectorIntegrationInterface<T, ResourceCommonData, Req, Resp>,
) -> Result<RouterData<T, Req, Resp>, Report<ConnectorError>> {
let conf = Settings::new().unwrap();
let tx: oneshot::Sender<()> = oneshot::channel().0;
let app_state = Box::pin(routes::AppState::with_storage(
conf,
StorageImpl::PostgresqlTest,
tx,
Box::new(services::MockApiClient),
))
.await;
let state = Arc::new(app_state)
.get_session_state(
&common_utils::id_type::TenantId::try_from_string("public".to_string()).unwrap(),
None,
|| {},
)
.unwrap();
services::api::execute_connector_processing_step(
&state,
integration,
&request,
payments::CallConnectorAction::Trigger,
None,
)
.await
}
<file_sep path="hyperswitch/crates/router/tests/connectors/utils.rs" role="context" start="1103" end="1111">
fn default() -> Self {
let data = types::PaymentMethodTokenizationData {
payment_method_data: types::domain::PaymentMethodData::Card(CCardType::default().0),
browser_info: None,
amount: Some(100),
currency: enums::Currency::USD,
};
Self(data)
}
<file_sep path="hyperswitch/crates/router/tests/connectors/utils.rs" role="context" start="921" end="921">
pub struct PaymentCancelType(pub types::PaymentsCancelData);
<file_sep path="hyperswitch/crates/router/tests/connectors/utils.rs" role="context" start="61" end="72">
pub struct PaymentInfo {
pub address: Option<PaymentAddress>,
pub auth_type: Option<enums::AuthenticationType>,
pub access_token: Option<AccessToken>,
pub connector_meta_data: Option<serde_json::Value>,
pub connector_customer: Option<String>,
pub payment_method_token: Option<String>,
#[cfg(feature = "payouts")]
pub payout_method_data: Option<types::api::PayoutMethodData>,
#[cfg(feature = "payouts")]
pub currency: Option<enums::Currency>,
}
<file_sep path="hyperswitch/crates/router/src/types.rs" role="context" start="156" end="156">
pub type PaymentsCancelRouterData = RouterData<Void, PaymentsCancelData, PaymentsResponseData>;
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/router/tests/connectors/utils.rs<|crate|> router<|connector|> utils anchor=capture_payment kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/router/tests/connectors/utils.rs" role="context" start="200" end="215">
async fn capture_payment(
&self,
transaction_id: String,
payment_data: Option<types::PaymentsCaptureData>,
payment_info: Option<PaymentInfo>,
) -> Result<types::PaymentsCaptureRouterData, Report<ConnectorError>> {
let integration = self.get_data().connector.get_connector_integration();
let request = self.generate_data(
types::PaymentsCaptureData {
connector_transaction_id: transaction_id,
..payment_data.unwrap_or(PaymentCaptureType::default().0)
},
payment_info,
);
Box::pin(call_connector(request, integration)).await
}
<file_sep path="hyperswitch/crates/router/tests/connectors/utils.rs" role="context" start="199" end="199">
use error_stack::Report;
use router::{
configs::settings::Settings,
core::{errors::ConnectorError, payments},
db::StorageImpl,
routes,
services::{
self,
connector_integration_interface::{BoxedConnectorIntegrationInterface, ConnectorEnum},
},
types::{self, storage::enums, AccessToken, MinorUnit, PaymentAddress, RouterData},
};
<file_sep path="hyperswitch/crates/router/tests/connectors/utils.rs" role="context" start="236" end="251">
async fn void_payment(
&self,
transaction_id: String,
payment_data: Option<types::PaymentsCancelData>,
payment_info: Option<PaymentInfo>,
) -> Result<types::PaymentsCancelRouterData, Report<ConnectorError>> {
let integration = self.get_data().connector.get_connector_integration();
let request = self.generate_data(
types::PaymentsCancelData {
connector_transaction_id: transaction_id,
..payment_data.unwrap_or(PaymentCancelType::default().0)
},
payment_info,
);
Box::pin(call_connector(request, integration)).await
}
<file_sep path="hyperswitch/crates/router/tests/connectors/utils.rs" role="context" start="217" end="234">
async fn authorize_and_capture_payment(
&self,
authorize_data: Option<types::PaymentsAuthorizeData>,
capture_data: Option<types::PaymentsCaptureData>,
payment_info: Option<PaymentInfo>,
) -> Result<types::PaymentsCaptureRouterData, Report<ConnectorError>> {
let authorize_response = self
.authorize_payment(authorize_data, payment_info.clone())
.await
.unwrap();
assert_eq!(authorize_response.status, enums::AttemptStatus::Authorized);
let txn_id = get_connector_transaction_id(authorize_response.response);
let response = self
.capture_payment(txn_id.unwrap(), capture_data, payment_info)
.await
.unwrap();
return Ok(response);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/utils.rs" role="context" start="180" end="198">
async fn psync_retry_till_status_matches(
&self,
status: enums::AttemptStatus,
payment_data: Option<types::PaymentsSyncData>,
payment_info: Option<PaymentInfo>,
) -> Result<types::PaymentsSyncRouterData, Report<ConnectorError>> {
let max_tries = 3;
for curr_try in 0..max_tries {
let sync_res = self
.sync_payment(payment_data.clone(), payment_info.clone())
.await
.unwrap();
if (sync_res.status == status) || (curr_try == max_tries - 1) {
return Ok(sync_res);
}
tokio::time::sleep(Duration::from_secs(self.get_request_interval())).await;
}
Err(ConnectorError::ProcessingStepFailed(None).into())
}
<file_sep path="hyperswitch/crates/router/tests/connectors/utils.rs" role="context" start="166" end="177">
async fn sync_payment(
&self,
payment_data: Option<types::PaymentsSyncData>,
payment_info: Option<PaymentInfo>,
) -> Result<types::PaymentsSyncRouterData, Report<ConnectorError>> {
let integration = self.get_data().connector.get_connector_integration();
let request = self.generate_data(
payment_data.unwrap_or_else(|| PaymentSyncType::default().0),
payment_info,
);
Box::pin(call_connector(request, integration)).await
}
<file_sep path="hyperswitch/crates/router/tests/connectors/utils.rs" role="context" start="856" end="893">
async fn call_connector<
T: Debug + Clone + 'static,
ResourceCommonData: Debug
+ Clone
+ services::connector_integration_interface::RouterDataConversion<T, Req, Resp>
+ 'static,
Req: Debug + Clone + 'static,
Resp: Debug + Clone + 'static,
>(
request: RouterData<T, Req, Resp>,
integration: BoxedConnectorIntegrationInterface<T, ResourceCommonData, Req, Resp>,
) -> Result<RouterData<T, Req, Resp>, Report<ConnectorError>> {
let conf = Settings::new().unwrap();
let tx: oneshot::Sender<()> = oneshot::channel().0;
let app_state = Box::pin(routes::AppState::with_storage(
conf,
StorageImpl::PostgresqlTest,
tx,
Box::new(services::MockApiClient),
))
.await;
let state = Arc::new(app_state)
.get_session_state(
&common_utils::id_type::TenantId::try_from_string("public".to_string()).unwrap(),
None,
|| {},
)
.unwrap();
services::api::execute_connector_processing_step(
&state,
integration,
&request,
payments::CallConnectorAction::Trigger,
None,
)
.await
}
<file_sep path="hyperswitch/crates/router/tests/connectors/utils.rs" role="context" start="1103" end="1111">
fn default() -> Self {
let data = types::PaymentMethodTokenizationData {
payment_method_data: types::domain::PaymentMethodData::Card(CCardType::default().0),
browser_info: None,
amount: Some(100),
currency: enums::Currency::USD,
};
Self(data)
}
<file_sep path="hyperswitch/crates/router/tests/connectors/utils.rs" role="context" start="920" end="920">
pub struct PaymentCaptureType(pub types::PaymentsCaptureData);
<file_sep path="hyperswitch/crates/router/tests/connectors/utils.rs" role="context" start="61" end="72">
pub struct PaymentInfo {
pub address: Option<PaymentAddress>,
pub auth_type: Option<enums::AuthenticationType>,
pub access_token: Option<AccessToken>,
pub connector_meta_data: Option<serde_json::Value>,
pub connector_customer: Option<String>,
pub payment_method_token: Option<String>,
#[cfg(feature = "payouts")]
pub payout_method_data: Option<types::api::PayoutMethodData>,
#[cfg(feature = "payouts")]
pub currency: Option<enums::Currency>,
}
<file_sep path="hyperswitch/crates/router/src/types.rs" role="context" start="141" end="141">
pub type PaymentsCaptureRouterData = RouterData<Capture, PaymentsCaptureData, PaymentsResponseData>;
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/router/tests/connectors/stripe.rs<|crate|> router<|connector|> stripe anchor=should_make_payment kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=1<|meta_end|>
<file_sep path="hyperswitch/crates/router/tests/connectors/stripe.rs" role="context" start="58" end="64">
async fn should_make_payment() {
let response = Stripe {}
.make_payment(get_payment_authorize_data(), None)
.await
.unwrap();
assert_eq!(response.status, enums::AttemptStatus::Charged);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/stripe.rs" role="context" start="57" end="57">
use router::types::{self, domain, storage::enums};
<file_sep path="hyperswitch/crates/router/tests/connectors/stripe.rs" role="context" start="76" end="89">
async fn should_partially_capture_already_authorized_payment() {
let connector = Stripe {};
let response = connector
.authorize_and_capture_payment(
get_payment_authorize_data(),
Some(types::PaymentsCaptureData {
amount_to_capture: 50,
..utils::PaymentCaptureType::default().0
}),
None,
)
.await;
assert_eq!(response.unwrap().status, enums::AttemptStatus::Charged);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/stripe.rs" role="context" start="67" end="73">
async fn should_capture_already_authorized_payment() {
let connector = Stripe {};
let response = connector
.authorize_and_capture_payment(get_payment_authorize_data(), None, None)
.await;
assert_eq!(response.unwrap().status, enums::AttemptStatus::Charged);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/stripe.rs" role="context" start="49" end="55">
async fn should_only_authorize_payment() {
let response = Stripe {}
.authorize_payment(get_payment_authorize_data(), None)
.await
.unwrap();
assert_eq!(response.status, enums::AttemptStatus::Authorized);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/stripe.rs" role="context" start="38" end="46">
fn get_payment_authorize_data() -> Option<types::PaymentsAuthorizeData> {
Some(types::PaymentsAuthorizeData {
payment_method_data: domain::PaymentMethodData::Card(domain::Card {
card_number: cards::CardNumber::from_str("4242424242424242").unwrap(),
..utils::CCardType::default().0
}),
..utils::PaymentAuthorizeType::default().0
})
}
<file_sep path="hyperswitch/crates/router/tests/connectors/stripe.rs" role="context" start="11" end="11">
struct Stripe;
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/router/tests/connectors/stripe.rs<|crate|> router<|connector|> stripe anchor=should_capture_already_authorized_payment kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=1<|meta_end|>
<file_sep path="hyperswitch/crates/router/tests/connectors/stripe.rs" role="context" start="67" end="73">
async fn should_capture_already_authorized_payment() {
let connector = Stripe {};
let response = connector
.authorize_and_capture_payment(get_payment_authorize_data(), None, None)
.await;
assert_eq!(response.unwrap().status, enums::AttemptStatus::Charged);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/stripe.rs" role="context" start="66" end="66">
use router::types::{self, domain, storage::enums};
<file_sep path="hyperswitch/crates/router/tests/connectors/stripe.rs" role="context" start="92" end="113">
async fn should_sync_authorized_payment() {
let connector = Stripe {};
let authorize_response = connector
.authorize_payment(get_payment_authorize_data(), None)
.await
.unwrap();
let txn_id = utils::get_connector_transaction_id(authorize_response.response);
let response = connector
.psync_retry_till_status_matches(
enums::AttemptStatus::Authorized,
Some(types::PaymentsSyncData {
connector_transaction_id: types::ResponseId::ConnectorTransactionId(
txn_id.unwrap(),
),
..Default::default()
}),
None,
)
.await
.unwrap();
assert_eq!(response.status, enums::AttemptStatus::Authorized,);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/stripe.rs" role="context" start="76" end="89">
async fn should_partially_capture_already_authorized_payment() {
let connector = Stripe {};
let response = connector
.authorize_and_capture_payment(
get_payment_authorize_data(),
Some(types::PaymentsCaptureData {
amount_to_capture: 50,
..utils::PaymentCaptureType::default().0
}),
None,
)
.await;
assert_eq!(response.unwrap().status, enums::AttemptStatus::Charged);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/stripe.rs" role="context" start="58" end="64">
async fn should_make_payment() {
let response = Stripe {}
.make_payment(get_payment_authorize_data(), None)
.await
.unwrap();
assert_eq!(response.status, enums::AttemptStatus::Charged);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/stripe.rs" role="context" start="49" end="55">
async fn should_only_authorize_payment() {
let response = Stripe {}
.authorize_payment(get_payment_authorize_data(), None)
.await
.unwrap();
assert_eq!(response.status, enums::AttemptStatus::Authorized);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/stripe.rs" role="context" start="38" end="46">
fn get_payment_authorize_data() -> Option<types::PaymentsAuthorizeData> {
Some(types::PaymentsAuthorizeData {
payment_method_data: domain::PaymentMethodData::Card(domain::Card {
card_number: cards::CardNumber::from_str("4242424242424242").unwrap(),
..utils::CCardType::default().0
}),
..utils::PaymentAuthorizeType::default().0
})
}
<file_sep path="hyperswitch/crates/router/tests/connectors/stripe.rs" role="context" start="11" end="11">
struct Stripe;
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/router/tests/connectors/stripe.rs<|crate|> router<|connector|> stripe anchor=should_refund_succeeded_payment kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/router/tests/connectors/stripe.rs" role="context" start="278" end="288">
async fn should_refund_succeeded_payment() {
let connector = Stripe {};
let response = connector
.make_payment_and_refund(get_payment_authorize_data(), None, None)
.await
.unwrap();
assert_eq!(
response.response.unwrap().refund_status,
enums::RefundStatus::Success,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/stripe.rs" role="context" start="277" end="277">
use router::types::{self, domain, storage::enums};
<file_sep path="hyperswitch/crates/router/tests/connectors/stripe.rs" role="context" start="304" end="321">
async fn should_partially_refund_succeeded_payment() {
let connector = Stripe {};
let refund_response = connector
.make_payment_and_refund(
get_payment_authorize_data(),
Some(types::RefundsData {
refund_amount: 50,
..utils::PaymentRefundType::default().0
}),
None,
)
.await
.unwrap();
assert_eq!(
refund_response.response.unwrap().refund_status,
enums::RefundStatus::Success,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/stripe.rs" role="context" start="291" end="301">
async fn should_refund_manually_captured_payment() {
let connector = Stripe {};
let response = connector
.auth_capture_and_refund(get_payment_authorize_data(), None, None)
.await
.unwrap();
assert_eq!(
response.response.unwrap().refund_status,
enums::RefundStatus::Success,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/stripe.rs" role="context" start="263" end="275">
async fn should_fail_capture_for_invalid_payment() {
let connector = Stripe {};
let response = connector
.capture_payment("12345".to_string(), None, None)
.await
.unwrap();
let err = response.response.unwrap_err();
assert_eq!(
err.reason.unwrap(),
"No such payment_intent: '12345'".to_string()
);
assert_eq!(err.code, "resource_missing".to_string());
}
<file_sep path="hyperswitch/crates/router/tests/connectors/stripe.rs" role="context" start="240" end="260">
async fn should_fail_void_payment_for_auto_capture() {
let connector = Stripe {};
// Authorize
let authorize_response = connector
.make_payment(get_payment_authorize_data(), None)
.await
.unwrap();
assert_eq!(authorize_response.status, enums::AttemptStatus::Charged);
let txn_id = utils::get_connector_transaction_id(authorize_response.response);
assert_ne!(txn_id, None, "Empty connector transaction id");
// Void
let void_response = connector
.void_payment(txn_id.unwrap(), None, None)
.await
.unwrap();
assert_eq!(
void_response.response.unwrap_err().reason.unwrap(),
"You cannot cancel this PaymentIntent because it has a status of succeeded. Only a PaymentIntent with one of the following statuses may be canceled: requires_payment_method, requires_capture, requires_confirmation, requires_action, processing."
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/stripe.rs" role="context" start="38" end="46">
fn get_payment_authorize_data() -> Option<types::PaymentsAuthorizeData> {
Some(types::PaymentsAuthorizeData {
payment_method_data: domain::PaymentMethodData::Card(domain::Card {
card_number: cards::CardNumber::from_str("4242424242424242").unwrap(),
..utils::CCardType::default().0
}),
..utils::PaymentAuthorizeType::default().0
})
}
<file_sep path="hyperswitch/crates/router/tests/connectors/stripe.rs" role="context" start="11" end="11">
struct Stripe;
<file_sep path="hyperswitch/crates/router/src/connector/dummyconnector/transformers.rs" role="context" start="304" end="309">
pub enum RefundStatus {
Succeeded,
Failed,
#[default]
Processing,
}
<file_sep path="hyperswitch/crates/api_models/src/refunds.rs" role="context" start="378" end="384">
pub enum RefundStatus {
Succeeded,
Failed,
#[default]
Pending,
Review,
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/router/tests/connectors/stripe.rs<|crate|> router<|connector|> stripe anchor=should_refund_manually_captured_payment kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/router/tests/connectors/stripe.rs" role="context" start="291" end="301">
async fn should_refund_manually_captured_payment() {
let connector = Stripe {};
let response = connector
.auth_capture_and_refund(get_payment_authorize_data(), None, None)
.await
.unwrap();
assert_eq!(
response.response.unwrap().refund_status,
enums::RefundStatus::Success,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/stripe.rs" role="context" start="290" end="290">
use router::types::{self, domain, storage::enums};
<file_sep path="hyperswitch/crates/router/tests/connectors/stripe.rs" role="context" start="324" end="341">
async fn should_partially_refund_manually_captured_payment() {
let connector = Stripe {};
let response = connector
.auth_capture_and_refund(
get_payment_authorize_data(),
Some(types::RefundsData {
refund_amount: 50,
..utils::PaymentRefundType::default().0
}),
None,
)
.await
.unwrap();
assert_eq!(
response.response.unwrap().refund_status,
enums::RefundStatus::Success,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/stripe.rs" role="context" start="304" end="321">
async fn should_partially_refund_succeeded_payment() {
let connector = Stripe {};
let refund_response = connector
.make_payment_and_refund(
get_payment_authorize_data(),
Some(types::RefundsData {
refund_amount: 50,
..utils::PaymentRefundType::default().0
}),
None,
)
.await
.unwrap();
assert_eq!(
refund_response.response.unwrap().refund_status,
enums::RefundStatus::Success,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/stripe.rs" role="context" start="278" end="288">
async fn should_refund_succeeded_payment() {
let connector = Stripe {};
let response = connector
.make_payment_and_refund(get_payment_authorize_data(), None, None)
.await
.unwrap();
assert_eq!(
response.response.unwrap().refund_status,
enums::RefundStatus::Success,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/stripe.rs" role="context" start="263" end="275">
async fn should_fail_capture_for_invalid_payment() {
let connector = Stripe {};
let response = connector
.capture_payment("12345".to_string(), None, None)
.await
.unwrap();
let err = response.response.unwrap_err();
assert_eq!(
err.reason.unwrap(),
"No such payment_intent: '12345'".to_string()
);
assert_eq!(err.code, "resource_missing".to_string());
}
<file_sep path="hyperswitch/crates/router/tests/connectors/stripe.rs" role="context" start="38" end="46">
fn get_payment_authorize_data() -> Option<types::PaymentsAuthorizeData> {
Some(types::PaymentsAuthorizeData {
payment_method_data: domain::PaymentMethodData::Card(domain::Card {
card_number: cards::CardNumber::from_str("4242424242424242").unwrap(),
..utils::CCardType::default().0
}),
..utils::PaymentAuthorizeType::default().0
})
}
<file_sep path="hyperswitch/crates/router/tests/connectors/stripe.rs" role="context" start="11" end="11">
struct Stripe;
<file_sep path="hyperswitch/crates/router/src/connector/dummyconnector/transformers.rs" role="context" start="304" end="309">
pub enum RefundStatus {
Succeeded,
Failed,
#[default]
Processing,
}
<file_sep path="hyperswitch/crates/api_models/src/refunds.rs" role="context" start="378" end="384">
pub enum RefundStatus {
Succeeded,
Failed,
#[default]
Pending,
Review,
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/router/tests/connectors/stripe.rs<|crate|> router<|connector|> stripe anchor=should_refund_succeeded_payment_multiple_times kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/router/tests/connectors/stripe.rs" role="context" start="344" end="356">
async fn should_refund_succeeded_payment_multiple_times() {
let connector = Stripe {};
connector
.make_payment_and_multiple_refund(
get_payment_authorize_data(),
Some(types::RefundsData {
refund_amount: 50,
..utils::PaymentRefundType::default().0
}),
None,
)
.await;
}
<file_sep path="hyperswitch/crates/router/tests/connectors/stripe.rs" role="context" start="343" end="343">
use router::types::{self, domain, storage::enums};
<file_sep path="hyperswitch/crates/router/tests/connectors/stripe.rs" role="context" start="379" end="398">
async fn should_sync_refund() {
let connector = Stripe {};
let refund_response = connector
.make_payment_and_refund(get_payment_authorize_data(), None, None)
.await
.unwrap();
let response = connector
.rsync_retry_till_status_matches(
enums::RefundStatus::Success,
refund_response.response.unwrap().connector_refund_id,
None,
None,
)
.await
.unwrap();
assert_eq!(
response.response.unwrap().refund_status,
enums::RefundStatus::Success,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/stripe.rs" role="context" start="359" end="376">
async fn should_fail_refund_for_invalid_amount() {
let connector = Stripe {};
let response = connector
.make_payment_and_refund(
get_payment_authorize_data(),
Some(types::RefundsData {
refund_amount: 150,
..utils::PaymentRefundType::default().0
}),
None,
)
.await
.unwrap();
assert_eq!(
response.response.unwrap_err().reason.unwrap(),
"Refund amount ($1.50) is greater than charge amount ($1.00)",
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/stripe.rs" role="context" start="324" end="341">
async fn should_partially_refund_manually_captured_payment() {
let connector = Stripe {};
let response = connector
.auth_capture_and_refund(
get_payment_authorize_data(),
Some(types::RefundsData {
refund_amount: 50,
..utils::PaymentRefundType::default().0
}),
None,
)
.await
.unwrap();
assert_eq!(
response.response.unwrap().refund_status,
enums::RefundStatus::Success,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/stripe.rs" role="context" start="304" end="321">
async fn should_partially_refund_succeeded_payment() {
let connector = Stripe {};
let refund_response = connector
.make_payment_and_refund(
get_payment_authorize_data(),
Some(types::RefundsData {
refund_amount: 50,
..utils::PaymentRefundType::default().0
}),
None,
)
.await
.unwrap();
assert_eq!(
refund_response.response.unwrap().refund_status,
enums::RefundStatus::Success,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/stripe.rs" role="context" start="38" end="46">
fn get_payment_authorize_data() -> Option<types::PaymentsAuthorizeData> {
Some(types::PaymentsAuthorizeData {
payment_method_data: domain::PaymentMethodData::Card(domain::Card {
card_number: cards::CardNumber::from_str("4242424242424242").unwrap(),
..utils::CCardType::default().0
}),
..utils::PaymentAuthorizeType::default().0
})
}
<file_sep path="hyperswitch/crates/router/tests/connectors/stripe.rs" role="context" start="11" end="11">
struct Stripe;
<file_sep path="hyperswitch/crates/router/tests/connectors/utils.rs" role="context" start="923" end="923">
pub struct PaymentRefundType(pub types::RefundsData);
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/router/tests/connectors/stripe.rs<|crate|> router<|connector|> stripe anchor=should_partially_capture_already_authorized_payment kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/router/tests/connectors/stripe.rs" role="context" start="76" end="89">
async fn should_partially_capture_already_authorized_payment() {
let connector = Stripe {};
let response = connector
.authorize_and_capture_payment(
get_payment_authorize_data(),
Some(types::PaymentsCaptureData {
amount_to_capture: 50,
..utils::PaymentCaptureType::default().0
}),
None,
)
.await;
assert_eq!(response.unwrap().status, enums::AttemptStatus::Charged);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/stripe.rs" role="context" start="75" end="75">
use router::types::{self, domain, storage::enums};
<file_sep path="hyperswitch/crates/router/tests/connectors/stripe.rs" role="context" start="116" end="137">
async fn should_sync_payment() {
let connector = Stripe {};
let authorize_response = connector
.make_payment(get_payment_authorize_data(), None)
.await
.unwrap();
let txn_id = utils::get_connector_transaction_id(authorize_response.response);
let response = connector
.psync_retry_till_status_matches(
enums::AttemptStatus::Charged,
Some(types::PaymentsSyncData {
connector_transaction_id: types::ResponseId::ConnectorTransactionId(
txn_id.unwrap(),
),
..Default::default()
}),
None,
)
.await
.unwrap();
assert_eq!(response.status, enums::AttemptStatus::Charged,);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/stripe.rs" role="context" start="92" end="113">
async fn should_sync_authorized_payment() {
let connector = Stripe {};
let authorize_response = connector
.authorize_payment(get_payment_authorize_data(), None)
.await
.unwrap();
let txn_id = utils::get_connector_transaction_id(authorize_response.response);
let response = connector
.psync_retry_till_status_matches(
enums::AttemptStatus::Authorized,
Some(types::PaymentsSyncData {
connector_transaction_id: types::ResponseId::ConnectorTransactionId(
txn_id.unwrap(),
),
..Default::default()
}),
None,
)
.await
.unwrap();
assert_eq!(response.status, enums::AttemptStatus::Authorized,);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/stripe.rs" role="context" start="67" end="73">
async fn should_capture_already_authorized_payment() {
let connector = Stripe {};
let response = connector
.authorize_and_capture_payment(get_payment_authorize_data(), None, None)
.await;
assert_eq!(response.unwrap().status, enums::AttemptStatus::Charged);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/stripe.rs" role="context" start="58" end="64">
async fn should_make_payment() {
let response = Stripe {}
.make_payment(get_payment_authorize_data(), None)
.await
.unwrap();
assert_eq!(response.status, enums::AttemptStatus::Charged);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/stripe.rs" role="context" start="38" end="46">
fn get_payment_authorize_data() -> Option<types::PaymentsAuthorizeData> {
Some(types::PaymentsAuthorizeData {
payment_method_data: domain::PaymentMethodData::Card(domain::Card {
card_number: cards::CardNumber::from_str("4242424242424242").unwrap(),
..utils::CCardType::default().0
}),
..utils::PaymentAuthorizeType::default().0
})
}
<file_sep path="hyperswitch/crates/router/tests/connectors/stripe.rs" role="context" start="11" end="11">
struct Stripe;
<file_sep path="hyperswitch/crates/router/tests/connectors/utils.rs" role="context" start="920" end="920">
pub struct PaymentCaptureType(pub types::PaymentsCaptureData);
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/router/tests/connectors/stripe.rs<|crate|> router<|connector|> stripe anchor=should_partially_refund_manually_captured_payment kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/router/tests/connectors/stripe.rs" role="context" start="324" end="341">
async fn should_partially_refund_manually_captured_payment() {
let connector = Stripe {};
let response = connector
.auth_capture_and_refund(
get_payment_authorize_data(),
Some(types::RefundsData {
refund_amount: 50,
..utils::PaymentRefundType::default().0
}),
None,
)
.await
.unwrap();
assert_eq!(
response.response.unwrap().refund_status,
enums::RefundStatus::Success,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/stripe.rs" role="context" start="323" end="323">
use router::types::{self, domain, storage::enums};
<file_sep path="hyperswitch/crates/router/tests/connectors/stripe.rs" role="context" start="359" end="376">
async fn should_fail_refund_for_invalid_amount() {
let connector = Stripe {};
let response = connector
.make_payment_and_refund(
get_payment_authorize_data(),
Some(types::RefundsData {
refund_amount: 150,
..utils::PaymentRefundType::default().0
}),
None,
)
.await
.unwrap();
assert_eq!(
response.response.unwrap_err().reason.unwrap(),
"Refund amount ($1.50) is greater than charge amount ($1.00)",
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/stripe.rs" role="context" start="344" end="356">
async fn should_refund_succeeded_payment_multiple_times() {
let connector = Stripe {};
connector
.make_payment_and_multiple_refund(
get_payment_authorize_data(),
Some(types::RefundsData {
refund_amount: 50,
..utils::PaymentRefundType::default().0
}),
None,
)
.await;
}
<file_sep path="hyperswitch/crates/router/tests/connectors/stripe.rs" role="context" start="304" end="321">
async fn should_partially_refund_succeeded_payment() {
let connector = Stripe {};
let refund_response = connector
.make_payment_and_refund(
get_payment_authorize_data(),
Some(types::RefundsData {
refund_amount: 50,
..utils::PaymentRefundType::default().0
}),
None,
)
.await
.unwrap();
assert_eq!(
refund_response.response.unwrap().refund_status,
enums::RefundStatus::Success,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/stripe.rs" role="context" start="291" end="301">
async fn should_refund_manually_captured_payment() {
let connector = Stripe {};
let response = connector
.auth_capture_and_refund(get_payment_authorize_data(), None, None)
.await
.unwrap();
assert_eq!(
response.response.unwrap().refund_status,
enums::RefundStatus::Success,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/stripe.rs" role="context" start="38" end="46">
fn get_payment_authorize_data() -> Option<types::PaymentsAuthorizeData> {
Some(types::PaymentsAuthorizeData {
payment_method_data: domain::PaymentMethodData::Card(domain::Card {
card_number: cards::CardNumber::from_str("4242424242424242").unwrap(),
..utils::CCardType::default().0
}),
..utils::PaymentAuthorizeType::default().0
})
}
<file_sep path="hyperswitch/crates/router/tests/connectors/stripe.rs" role="context" start="11" end="11">
struct Stripe;
<file_sep path="hyperswitch/crates/router/src/connector/dummyconnector/transformers.rs" role="context" start="304" end="309">
pub enum RefundStatus {
Succeeded,
Failed,
#[default]
Processing,
}
<file_sep path="hyperswitch/crates/api_models/src/refunds.rs" role="context" start="378" end="384">
pub enum RefundStatus {
Succeeded,
Failed,
#[default]
Pending,
Review,
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/router/tests/connectors/stripe.rs<|crate|> router<|connector|> stripe anchor=should_partially_refund_succeeded_payment kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/router/tests/connectors/stripe.rs" role="context" start="304" end="321">
async fn should_partially_refund_succeeded_payment() {
let connector = Stripe {};
let refund_response = connector
.make_payment_and_refund(
get_payment_authorize_data(),
Some(types::RefundsData {
refund_amount: 50,
..utils::PaymentRefundType::default().0
}),
None,
)
.await
.unwrap();
assert_eq!(
refund_response.response.unwrap().refund_status,
enums::RefundStatus::Success,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/stripe.rs" role="context" start="303" end="303">
use router::types::{self, domain, storage::enums};
<file_sep path="hyperswitch/crates/router/tests/connectors/stripe.rs" role="context" start="344" end="356">
async fn should_refund_succeeded_payment_multiple_times() {
let connector = Stripe {};
connector
.make_payment_and_multiple_refund(
get_payment_authorize_data(),
Some(types::RefundsData {
refund_amount: 50,
..utils::PaymentRefundType::default().0
}),
None,
)
.await;
}
<file_sep path="hyperswitch/crates/router/tests/connectors/stripe.rs" role="context" start="324" end="341">
async fn should_partially_refund_manually_captured_payment() {
let connector = Stripe {};
let response = connector
.auth_capture_and_refund(
get_payment_authorize_data(),
Some(types::RefundsData {
refund_amount: 50,
..utils::PaymentRefundType::default().0
}),
None,
)
.await
.unwrap();
assert_eq!(
response.response.unwrap().refund_status,
enums::RefundStatus::Success,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/stripe.rs" role="context" start="291" end="301">
async fn should_refund_manually_captured_payment() {
let connector = Stripe {};
let response = connector
.auth_capture_and_refund(get_payment_authorize_data(), None, None)
.await
.unwrap();
assert_eq!(
response.response.unwrap().refund_status,
enums::RefundStatus::Success,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/stripe.rs" role="context" start="278" end="288">
async fn should_refund_succeeded_payment() {
let connector = Stripe {};
let response = connector
.make_payment_and_refund(get_payment_authorize_data(), None, None)
.await
.unwrap();
assert_eq!(
response.response.unwrap().refund_status,
enums::RefundStatus::Success,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/stripe.rs" role="context" start="38" end="46">
fn get_payment_authorize_data() -> Option<types::PaymentsAuthorizeData> {
Some(types::PaymentsAuthorizeData {
payment_method_data: domain::PaymentMethodData::Card(domain::Card {
card_number: cards::CardNumber::from_str("4242424242424242").unwrap(),
..utils::CCardType::default().0
}),
..utils::PaymentAuthorizeType::default().0
})
}
<file_sep path="hyperswitch/crates/router/tests/connectors/stripe.rs" role="context" start="11" end="11">
struct Stripe;
<file_sep path="hyperswitch/crates/router/src/connector/dummyconnector/transformers.rs" role="context" start="304" end="309">
pub enum RefundStatus {
Succeeded,
Failed,
#[default]
Processing,
}
<file_sep path="hyperswitch/crates/api_models/src/refunds.rs" role="context" start="378" end="384">
pub enum RefundStatus {
Succeeded,
Failed,
#[default]
Pending,
Review,
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/hyperswitch_connectors/src/connectors/nexinets.rs<|crate|> hyperswitch_connectors<|connector|> nexinets anchor=connector_transaction_id kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/nexinets.rs" role="context" start="757" end="764">
fn connector_transaction_id(
&self,
payment_attempt: PaymentAttempt,
) -> Result<Option<String>, ApiErrorResponse> {
let metadata =
Self::connector_transaction_id(self, payment_attempt.connector_metadata.as_ref());
metadata.map_err(|_| ApiErrorResponse::ResourceIdNotFound)
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/nexinets.rs" role="context" start="756" end="756">
use hyperswitch_domain_models::{
errors::api_error_response::ApiErrorResponse,
payment_method_data::PaymentMethodData,
payments::payment_attempt::PaymentAttempt,
router_data::{AccessToken, ConnectorAuthType, ErrorResponse, RouterData},
router_flow_types::{
access_token_auth::AccessTokenAuth,
payments::{Authorize, Capture, PSync, PaymentMethodToken, Session, SetupMandate, Void},
refunds::{Execute, RSync},
},
router_request_types::{
AccessTokenRequestData, PaymentMethodTokenizationData, PaymentsAuthorizeData,
PaymentsCancelData, PaymentsCaptureData, PaymentsSessionData, PaymentsSyncData,
RefundsData, SetupMandateRequestData,
},
router_response_types::{PaymentsResponseData, RefundsResponseData},
types::{
PaymentsAuthorizeRouterData, PaymentsCancelRouterData, PaymentsCaptureRouterData,
PaymentsSyncRouterData, RefundSyncRouterData, RefundsRouterData,
},
};
use hyperswitch_interfaces::{
api::{
self, ConnectorCommon, ConnectorCommonExt, ConnectorIntegration, ConnectorSpecifications,
ConnectorTransactionId, ConnectorValidation,
},
configs::Connectors,
errors,
events::connector_api_logs::ConnectorEvent,
types::{
PaymentsAuthorizeType, PaymentsCaptureType, PaymentsSyncType, PaymentsVoidType,
RefundExecuteType, RefundSyncType, Response,
},
webhooks::{IncomingWebhook, IncomingWebhookRequestDetails},
};
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/nexinets.rs" role="context" start="767" end="781">
fn connector_transaction_id(
&self,
payment_attempt: PaymentAttempt,
) -> Result<Option<String>, ApiErrorResponse> {
use hyperswitch_domain_models::errors::api_error_response::ApiErrorResponse;
let metadata = Self::connector_transaction_id(
self,
payment_attempt
.connector_metadata
.as_ref()
.map(|connector_metadata| connector_metadata.peek()),
);
metadata.map_err(|_| ApiErrorResponse::ResourceIdNotFound)
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/nexinets.rs" role="context" start="737" end="742">
fn get_webhook_resource_object(
&self,
_request: &IncomingWebhookRequestDetails<'_>,
) -> CustomResult<Box<dyn masking::ErasedMaskSerialize>, errors::ConnectorError> {
Err(report!(errors::ConnectorError::WebhooksNotImplemented))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/nexinets.rs" role="context" start="730" end="735">
fn get_webhook_event_type(
&self,
_request: &IncomingWebhookRequestDetails<'_>,
) -> CustomResult<IncomingWebhookEvent, errors::ConnectorError> {
Ok(IncomingWebhookEvent::EventNotSupported)
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/braintree/transformers.rs" role="context" start="145" end="148">
pub struct ApiErrorResponse {
pub message: String,
pub errors: ErrorsObject,
}
<file_sep path="hyperswitch/v2_compatible_migrations/2024-08-28-081721_add_v2_columns/up.sql" role="context" start="37" end="53">
ADD COLUMN frm_merchant_decision VARCHAR(64),
ADD COLUMN statement_descriptor VARCHAR(255),
ADD COLUMN enable_payment_link BOOLEAN,
ADD COLUMN apply_mit_exemption BOOLEAN,
ADD COLUMN customer_present BOOLEAN,
ADD COLUMN routing_algorithm_id VARCHAR(64),
ADD COLUMN payment_link_config JSONB;
ALTER TABLE payment_attempt
ADD COLUMN payment_method_type_v2 VARCHAR,
ADD COLUMN connector_payment_id VARCHAR(128),
ADD COLUMN payment_method_subtype VARCHAR(64),
ADD COLUMN routing_result JSONB,
ADD COLUMN authentication_applied "AuthenticationType",
ADD COLUMN external_reference_id VARCHAR(128),
ADD COLUMN tax_on_surcharge BIGINT,
ADD COLUMN payment_method_billing_address BYTEA,
<file_sep path="hyperswitch/crates/api_models/src/errors/types.rs" role="context" start="86" end="100">
pub enum ApiErrorResponse {
Unauthorized(ApiError),
ForbiddenCommonResource(ApiError),
ForbiddenPrivateResource(ApiError),
Conflict(ApiError),
Gone(ApiError),
Unprocessable(ApiError),
InternalServerError(ApiError),
NotImplemented(ApiError),
ConnectorError(ApiError, #[serde(skip_serializing)] StatusCode),
NotFound(ApiError),
MethodNotAllowed(ApiError),
BadRequest(ApiError),
DomainError(ApiError),
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/hyperswitch_connectors/src/connectors/nexinets/transformers.rs<|crate|> hyperswitch_connectors<|connector|> nexinets anchor=get_card_details kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/nexinets/transformers.rs" role="context" start="680" end="687">
fn get_card_details(req_card: &Card) -> Result<CardDetails, errors::ConnectorError> {
Ok(CardDetails {
card_number: req_card.card_number.clone(),
expiry_month: req_card.card_exp_month.clone(),
expiry_year: req_card.get_card_expiry_year_2_digit()?,
verification: req_card.card_cvc.clone(),
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/nexinets/transformers.rs" role="context" start="679" end="679">
use hyperswitch_domain_models::{
payment_method_data::{
ApplePayWalletData, BankRedirectData, Card, PaymentMethodData, WalletData,
},
router_data::{ConnectorAuthType, RouterData},
router_flow_types::{Execute, RSync},
router_request_types::ResponseId,
router_response_types::{
MandateReference, PaymentsResponseData, RedirectForm, RefundsResponseData,
},
types::{
PaymentsAuthorizeRouterData, PaymentsCancelRouterData, PaymentsCaptureRouterData,
RefundsRouterData,
},
};
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/nexinets/transformers.rs" role="context" start="738" end="747">
pub fn get_order_id(
meta: &NexinetsPaymentsMetadata,
) -> Result<String, error_stack::Report<errors::ConnectorError>> {
let order_id = meta.order_id.clone().ok_or(
errors::ConnectorError::MissingConnectorRelatedTransactionID {
id: "order_id".to_string(),
},
)?;
Ok(order_id)
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/nexinets/transformers.rs" role="context" start="689" end="736">
fn get_wallet_details(
wallet: &WalletData,
) -> Result<
(Option<NexinetsPaymentDetails>, NexinetsProduct),
error_stack::Report<errors::ConnectorError>,
> {
match wallet {
WalletData::PaypalRedirect(_) => Ok((None, NexinetsProduct::Paypal)),
WalletData::ApplePay(applepay_data) => Ok((
Some(NexinetsPaymentDetails::Wallet(Box::new(
NexinetsWalletDetails::ApplePayToken(Box::new(get_applepay_details(
wallet,
applepay_data,
)?)),
))),
NexinetsProduct::Applepay,
)),
WalletData::AliPayQr(_)
| WalletData::AliPayRedirect(_)
| WalletData::AliPayHkRedirect(_)
| WalletData::AmazonPayRedirect(_)
| WalletData::MomoRedirect(_)
| WalletData::KakaoPayRedirect(_)
| WalletData::GoPayRedirect(_)
| WalletData::GcashRedirect(_)
| WalletData::ApplePayRedirect(_)
| WalletData::ApplePayThirdPartySdk(_)
| WalletData::DanaRedirect { .. }
| WalletData::GooglePay(_)
| WalletData::GooglePayRedirect(_)
| WalletData::GooglePayThirdPartySdk(_)
| WalletData::MbWayRedirect(_)
| WalletData::MobilePayRedirect(_)
| WalletData::PaypalSdk(_)
| WalletData::Paze(_)
| WalletData::SamsungPay(_)
| WalletData::TwintRedirect { .. }
| WalletData::VippsRedirect { .. }
| WalletData::TouchNGoRedirect(_)
| WalletData::WeChatPayRedirect(_)
| WalletData::WeChatPayQr(_)
| WalletData::CashappQr(_)
| WalletData::SwishQr(_)
| WalletData::Mifinity(_) => Err(errors::ConnectorError::NotImplemented(
utils::get_unimplemented_payment_method_error_message("nexinets"),
))?,
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/nexinets/transformers.rs" role="context" start="664" end="678">
fn get_applepay_details(
wallet_data: &WalletData,
applepay_data: &ApplePayWalletData,
) -> CustomResult<ApplePayDetails, errors::ConnectorError> {
let payment_data = WalletData::get_wallet_token_as_json(wallet_data, "Apple Pay".to_string())?;
Ok(ApplePayDetails {
payment_data,
payment_method: ApplepayPaymentMethod {
display_name: applepay_data.payment_method.display_name.to_owned(),
network: applepay_data.payment_method.network.to_owned(),
token_type: applepay_data.payment_method.pm_type.to_owned(),
},
transaction_identifier: applepay_data.transaction_identifier.to_owned(),
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/nexinets/transformers.rs" role="context" start="636" end="662">
fn get_card_data(
item: &PaymentsAuthorizeRouterData,
card: &Card,
) -> Result<NexinetsPaymentDetails, errors::ConnectorError> {
let (card_data, cof_contract) = match item.request.is_mandate_payment() {
true => {
let card_data = match item.request.off_session {
Some(true) => CardDataDetails::PaymentInstrument(Box::new(PaymentInstrument {
payment_instrument_id: item.request.connector_mandate_id().map(Secret::new),
})),
_ => CardDataDetails::CardDetails(Box::new(get_card_details(card)?)),
};
let cof_contract = Some(CofContract {
recurring_type: RecurringType::Unscheduled,
});
(card_data, cof_contract)
}
false => (
CardDataDetails::CardDetails(Box::new(get_card_details(card)?)),
None,
),
};
Ok(NexinetsPaymentDetails::Card(Box::new(NexiCardDetails {
card_data,
cof_contract,
})))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/nexinets/transformers.rs" role="context" start="92" end="97">
pub struct CardDetails {
card_number: CardNumber,
expiry_month: Secret<String>,
expiry_year: Secret<String>,
verification: Secret<String>,
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/globalpay/response.rs" role="context" start="216" end="241">
pub struct Card {
/// Code generated when the card is successfully authorized.
pub authcode: Option<Secret<String>>,
/// The recommended AVS action to be taken by the agent processing the card transaction.
pub avs_action: Option<String>,
/// The result of the AVS address check.
pub avs_address_result: Option<String>,
/// The result of the AVS postal code check.
pub avs_postal_code_result: Option<String>,
/// Indicates the card brand that issued the card.
pub brand: Option<Brand>,
/// The unique reference created by the brands/schemes to uniquely identify the transaction.
pub brand_reference: Option<Secret<String>>,
/// The time returned by the card brand indicating when the transaction was processed on
/// their system.
pub brand_time_reference: Option<String>,
/// The result of the CVV check.
pub cvv_result: Option<String>,
/// Masked card number with last 4 digits showing.
pub masked_number_last4: Option<String>,
/// The result codes directly from the card issuer.
pub provider: Option<ProviderClass>,
/// The card EMV tag response data from the card issuer for a contactless or chip card
/// transaction.
pub tag_response: Option<Secret<String>>,
}
<file_sep path="hyperswitch/crates/api_models/src/payment_methods.rs" role="context" start="1075" end="1083">
pub struct Card {
pub card_number: CardNumber,
pub name_on_card: Option<masking::Secret<String>>,
pub card_exp_month: masking::Secret<String>,
pub card_exp_year: masking::Secret<String>,
pub card_brand: Option<String>,
pub card_isin: Option<String>,
pub nick_name: Option<String>,
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/hyperswitch_connectors/src/connectors/bambora/transformers.rs<|crate|> hyperswitch_connectors<|connector|> bambora anchor=get_browser_info kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/bambora/transformers.rs" role="context" start="100" end="124">
fn get_browser_info(
item: &types::PaymentsAuthorizeRouterData,
) -> Result<Option<BamboraBrowserInfo>, error_stack::Report<errors::ConnectorError>> {
if matches!(item.auth_type, enums::AuthenticationType::ThreeDs) {
item.request
.browser_info
.as_ref()
.map(|info| {
Ok(BamboraBrowserInfo {
accept_header: info.get_accept_header()?,
java_enabled: info.get_java_enabled()?,
language: info.get_language()?,
screen_height: info.get_screen_height()?,
screen_width: info.get_screen_width()?,
color_depth: info.get_color_depth()?,
user_agent: info.get_user_agent()?,
time_zone: info.get_time_zone()?,
javascript_enabled: info.get_java_script_enabled()?,
})
})
.transpose()
} else {
Ok(None)
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/bambora/transformers.rs" role="context" start="99" end="99">
use common_enums::enums;
use error_stack::ResultExt;
use hyperswitch_domain_models::{
payment_method_data::PaymentMethodData,
router_data::{ConnectorAuthType, RouterData},
router_flow_types::refunds::{Execute, RSync},
router_request_types::{
CompleteAuthorizeData, PaymentsAuthorizeData, PaymentsCancelData, PaymentsCaptureData,
PaymentsSyncData, ResponseId,
},
router_response_types::{PaymentsResponseData, RedirectForm, RefundsResponseData},
types,
};
use crate::{
types::{RefundsResponseRouterData, ResponseRouterData},
utils::{
self, AddressDetailsData, BrowserInformationData, CardData as _,
PaymentsAuthorizeRequestData, PaymentsCompleteAuthorizeRequestData,
PaymentsSyncRequestData, RouterData as _,
},
};
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/bambora/transformers.rs" role="context" start="148" end="236">
fn try_from(
item: BamboraRouterData<&types::PaymentsAuthorizeRouterData>,
) -> Result<Self, Self::Error> {
match item.router_data.request.payment_method_data.clone() {
PaymentMethodData::Card(req_card) => {
let (three_ds, customer_ip) = match item.router_data.auth_type {
enums::AuthenticationType::ThreeDs => (
Some(ThreeDSecure {
enabled: true,
browser: get_browser_info(item.router_data)?,
version: Some(2),
auth_required: Some(true),
}),
Some(
item.router_data
.request
.get_browser_info()?
.get_ip_address()?,
),
),
enums::AuthenticationType::NoThreeDs => (None, None),
};
let card = BamboraCard {
name: item.router_data.get_billing_address()?.get_full_name()?,
expiry_year: req_card.get_card_expiry_year_2_digit()?,
number: req_card.card_number,
expiry_month: req_card.card_exp_month,
cvd: req_card.card_cvc,
three_d_secure: three_ds,
complete: item.router_data.request.is_auto_capture()?,
};
let (country, province) = match (
item.router_data.get_optional_billing_country(),
item.router_data.get_optional_billing_state_2_digit(),
) {
(Some(billing_country), Some(billing_state)) => {
(Some(billing_country), Some(billing_state))
}
_ => (None, None),
};
let billing = AddressData {
name: item.router_data.get_optional_billing_full_name(),
address_line1: item.router_data.get_optional_billing_line1(),
address_line2: item.router_data.get_optional_billing_line2(),
city: item.router_data.get_optional_billing_city(),
province,
country,
postal_code: item.router_data.get_optional_billing_zip(),
phone_number: item.router_data.get_optional_billing_phone_number(),
email_address: item.router_data.get_optional_billing_email(),
};
Ok(Self {
order_number: item.router_data.connector_request_reference_id.clone(),
amount: item.amount,
payment_method: PaymentMethod::Card,
card,
customer_ip,
term_url: item.router_data.request.complete_authorize_url.clone(),
billing,
})
}
PaymentMethodData::CardRedirect(_)
| PaymentMethodData::Wallet(_)
| PaymentMethodData::PayLater(_)
| PaymentMethodData::BankRedirect(_)
| PaymentMethodData::BankDebit(_)
| PaymentMethodData::BankTransfer(_)
| PaymentMethodData::Crypto(_)
| PaymentMethodData::MandatePayment
| PaymentMethodData::Reward
| PaymentMethodData::RealTimePayment(_)
| PaymentMethodData::Upi(_)
| PaymentMethodData::Voucher(_)
| PaymentMethodData::MobilePayment(_)
| PaymentMethodData::GiftCard(_)
| PaymentMethodData::OpenBanking(_)
| PaymentMethodData::CardToken(_)
| PaymentMethodData::NetworkToken(_)
| PaymentMethodData::CardDetailsForNetworkTransactionId(_) => {
Err(errors::ConnectorError::NotImplemented(
utils::get_unimplemented_payment_method_error_message("bambora"),
)
.into())
}
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/bambora/transformers.rs" role="context" start="128" end="143">
fn try_from(value: &CompleteAuthorizeData) -> Result<Self, Self::Error> {
let card_response: CardResponse = value
.redirect_response
.as_ref()
.and_then(|f| f.payload.to_owned())
.ok_or(errors::ConnectorError::MissingRequiredField {
field_name: "redirect_response.payload",
})?
.parse_value("CardResponse")
.change_context(errors::ConnectorError::ParsingFailed)?;
let bambora_req = Self {
payment_method: "credit_card".to_string(),
card_response,
};
Ok(bambora_req)
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/bambora/transformers.rs" role="context" start="39" end="47">
fn try_from(
(currency_unit, currency, amount, item): (&api::CurrencyUnit, enums::Currency, i64, T),
) -> Result<Self, Self::Error> {
let amount = utils::get_amount_as_f64(currency_unit, amount, currency)?;
Ok(Self {
amount,
router_data: item,
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/bambora/transformers.rs" role="context" start="72" end="82">
pub struct BamboraBrowserInfo {
accept_header: String,
java_enabled: bool,
language: String,
color_depth: u8,
screen_height: u32,
screen_width: u32,
time_zone: i32,
user_agent: String,
javascript_enabled: bool,
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/payme/transformers.rs" role="context" start="144" end="147">
pub struct ThreeDs {
name: ThreeDsType,
settings: ThreeDsSettings,
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/hyperswitch_connectors/src/connectors/bambora/transformers.rs<|crate|> hyperswitch_connectors<|connector|> bambora anchor=try_from kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/bambora/transformers.rs" role="context" start="148" end="236">
fn try_from(
item: BamboraRouterData<&types::PaymentsAuthorizeRouterData>,
) -> Result<Self, Self::Error> {
match item.router_data.request.payment_method_data.clone() {
PaymentMethodData::Card(req_card) => {
let (three_ds, customer_ip) = match item.router_data.auth_type {
enums::AuthenticationType::ThreeDs => (
Some(ThreeDSecure {
enabled: true,
browser: get_browser_info(item.router_data)?,
version: Some(2),
auth_required: Some(true),
}),
Some(
item.router_data
.request
.get_browser_info()?
.get_ip_address()?,
),
),
enums::AuthenticationType::NoThreeDs => (None, None),
};
let card = BamboraCard {
name: item.router_data.get_billing_address()?.get_full_name()?,
expiry_year: req_card.get_card_expiry_year_2_digit()?,
number: req_card.card_number,
expiry_month: req_card.card_exp_month,
cvd: req_card.card_cvc,
three_d_secure: three_ds,
complete: item.router_data.request.is_auto_capture()?,
};
let (country, province) = match (
item.router_data.get_optional_billing_country(),
item.router_data.get_optional_billing_state_2_digit(),
) {
(Some(billing_country), Some(billing_state)) => {
(Some(billing_country), Some(billing_state))
}
_ => (None, None),
};
let billing = AddressData {
name: item.router_data.get_optional_billing_full_name(),
address_line1: item.router_data.get_optional_billing_line1(),
address_line2: item.router_data.get_optional_billing_line2(),
city: item.router_data.get_optional_billing_city(),
province,
country,
postal_code: item.router_data.get_optional_billing_zip(),
phone_number: item.router_data.get_optional_billing_phone_number(),
email_address: item.router_data.get_optional_billing_email(),
};
Ok(Self {
order_number: item.router_data.connector_request_reference_id.clone(),
amount: item.amount,
payment_method: PaymentMethod::Card,
card,
customer_ip,
term_url: item.router_data.request.complete_authorize_url.clone(),
billing,
})
}
PaymentMethodData::CardRedirect(_)
| PaymentMethodData::Wallet(_)
| PaymentMethodData::PayLater(_)
| PaymentMethodData::BankRedirect(_)
| PaymentMethodData::BankDebit(_)
| PaymentMethodData::BankTransfer(_)
| PaymentMethodData::Crypto(_)
| PaymentMethodData::MandatePayment
| PaymentMethodData::Reward
| PaymentMethodData::RealTimePayment(_)
| PaymentMethodData::Upi(_)
| PaymentMethodData::Voucher(_)
| PaymentMethodData::MobilePayment(_)
| PaymentMethodData::GiftCard(_)
| PaymentMethodData::OpenBanking(_)
| PaymentMethodData::CardToken(_)
| PaymentMethodData::NetworkToken(_)
| PaymentMethodData::CardDetailsForNetworkTransactionId(_) => {
Err(errors::ConnectorError::NotImplemented(
utils::get_unimplemented_payment_method_error_message("bambora"),
)
.into())
}
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/bambora/transformers.rs" role="context" start="147" end="147">
use common_enums::enums;
use hyperswitch_domain_models::{
payment_method_data::PaymentMethodData,
router_data::{ConnectorAuthType, RouterData},
router_flow_types::refunds::{Execute, RSync},
router_request_types::{
CompleteAuthorizeData, PaymentsAuthorizeData, PaymentsCancelData, PaymentsCaptureData,
PaymentsSyncData, ResponseId,
},
router_response_types::{PaymentsResponseData, RedirectForm, RefundsResponseData},
types,
};
use crate::{
types::{RefundsResponseRouterData, ResponseRouterData},
utils::{
self, AddressDetailsData, BrowserInformationData, CardData as _,
PaymentsAuthorizeRequestData, PaymentsCompleteAuthorizeRequestData,
PaymentsSyncRequestData, RouterData as _,
},
};
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/bambora/transformers.rs" role="context" start="256" end="269">
fn try_from(auth_type: &ConnectorAuthType) -> Result<Self, Self::Error> {
if let ConnectorAuthType::BodyKey { api_key, key1 } = auth_type {
let auth_key = format!("{}:{}", key1.peek(), api_key.peek());
let auth_header = format!(
"Passcode {}",
common_utils::consts::BASE64_ENGINE.encode(auth_key)
);
Ok(Self {
api_key: Secret::new(auth_header),
})
} else {
Err(errors::ConnectorError::FailedToObtainAuthType)?
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/bambora/transformers.rs" role="context" start="241" end="247">
fn try_from(
item: BamboraRouterData<&types::PaymentsCancelRouterData>,
) -> Result<Self, Self::Error> {
Ok(Self {
amount: item.amount,
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/bambora/transformers.rs" role="context" start="128" end="143">
fn try_from(value: &CompleteAuthorizeData) -> Result<Self, Self::Error> {
let card_response: CardResponse = value
.redirect_response
.as_ref()
.and_then(|f| f.payload.to_owned())
.ok_or(errors::ConnectorError::MissingRequiredField {
field_name: "redirect_response.payload",
})?
.parse_value("CardResponse")
.change_context(errors::ConnectorError::ParsingFailed)?;
let bambora_req = Self {
payment_method: "credit_card".to_string(),
card_response,
};
Ok(bambora_req)
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/bambora/transformers.rs" role="context" start="100" end="124">
fn get_browser_info(
item: &types::PaymentsAuthorizeRouterData,
) -> Result<Option<BamboraBrowserInfo>, error_stack::Report<errors::ConnectorError>> {
if matches!(item.auth_type, enums::AuthenticationType::ThreeDs) {
item.request
.browser_info
.as_ref()
.map(|info| {
Ok(BamboraBrowserInfo {
accept_header: info.get_accept_header()?,
java_enabled: info.get_java_enabled()?,
language: info.get_language()?,
screen_height: info.get_screen_height()?,
screen_width: info.get_screen_width()?,
color_depth: info.get_color_depth()?,
user_agent: info.get_user_agent()?,
time_zone: info.get_time_zone()?,
javascript_enabled: info.get_java_script_enabled()?,
})
})
.transpose()
} else {
Ok(None)
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/bambora/transformers.rs" role="context" start="38" end="38">
type Error = error_stack::Report<errors::ConnectorError>;
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/bambora/transformers.rs" role="context" start="417" end="430">
pub enum PaymentMethod {
#[default]
Card,
Token,
PaymentProfile,
Cash,
Cheque,
Interac,
ApplePay,
AndroidPay,
#[serde(rename = "3d_secure")]
ThreeDSecure,
ProcessorToken,
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/globalpay/requests.rs" role="context" start="203" end="208">
pub enum PaymentMethodData {
Card(Card),
Apm(Apm),
BankTransfer(BankTransfer),
DigitalWallet(DigitalWallet),
}
<file_sep path="hyperswitch/v2_compatible_migrations/2024-08-28-081721_add_v2_columns/up.sql" role="context" start="54" end="70">
ADD COLUMN redirection_data JSONB,
ADD COLUMN connector_payment_data TEXT,
ADD COLUMN connector_token_details JSONB;
-- Change the type of the column from JSON to JSONB
ALTER TABLE merchant_connector_account
ADD COLUMN IF NOT EXISTS feature_metadata JSONB;
ALTER TABLE payment_methods
ADD COLUMN IF NOT EXISTS locker_fingerprint_id VARCHAR(64),
ADD COLUMN IF NOT EXISTS payment_method_type_v2 VARCHAR(64),
ADD COLUMN IF NOT EXISTS payment_method_subtype VARCHAR(64);
ALTER TABLE refund
ADD COLUMN IF NOT EXISTS id VARCHAR(64),
ADD COLUMN IF NOT EXISTS merchant_reference_id VARCHAR(64),
ADD COLUMN IF NOT EXISTS connector_id VARCHAR(64);
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/router/tests/connectors/bambora.rs<|crate|> router<|connector|> bambora anchor=should_make_payment kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=1<|meta_end|>
<file_sep path="hyperswitch/crates/router/tests/connectors/bambora.rs" role="context" start="202" end="208">
async fn should_make_payment() {
let authorize_response = CONNECTOR
.make_payment(get_default_payment_authorize_data(), None)
.await
.unwrap();
assert_eq!(authorize_response.status, enums::AttemptStatus::Charged);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/bambora.rs" role="context" start="201" end="201">
use router::types::{self, domain, storage::enums};
<file_sep path="hyperswitch/crates/router/tests/connectors/bambora.rs" role="context" start="248" end="257">
async fn should_refund_auto_captured_payment() {
let response = CONNECTOR
.make_payment_and_refund(get_default_payment_authorize_data(), None, None)
.await
.unwrap();
assert_eq!(
response.response.unwrap().refund_status,
enums::RefundStatus::Success,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/bambora.rs" role="context" start="212" end="244">
async fn should_sync_auto_captured_payment() {
let authorize_response = CONNECTOR
.make_payment(get_default_payment_authorize_data(), None)
.await
.unwrap();
assert_eq!(authorize_response.status, enums::AttemptStatus::Charged);
let txn_id = utils::get_connector_transaction_id(authorize_response.response);
assert_ne!(txn_id, None, "Empty connector transaction id");
let response = CONNECTOR
.psync_retry_till_status_matches(
enums::AttemptStatus::Charged,
Some(types::PaymentsSyncData {
mandate_id: None,
connector_transaction_id: types::ResponseId::ConnectorTransactionId(
txn_id.unwrap(),
),
encoded_data: None,
capture_method: Some(enums::CaptureMethod::Automatic),
sync_type: types::SyncRequestType::SinglePaymentSync,
connector_meta: None,
payment_method_type: None,
currency: enums::Currency::USD,
payment_experience: None,
integrity_object: None,
amount: MinorUnit::new(100),
..Default::default()
}),
None,
)
.await
.unwrap();
assert_eq!(response.status, enums::AttemptStatus::Charged,);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/bambora.rs" role="context" start="180" end="198">
async fn should_sync_manually_captured_refund() {
let refund_response = CONNECTOR
.capture_payment_and_refund(get_default_payment_authorize_data(), None, None, None)
.await
.unwrap();
let response = CONNECTOR
.rsync_retry_till_status_matches(
enums::RefundStatus::Success,
refund_response.response.unwrap().connector_refund_id,
None,
None,
)
.await
.unwrap();
assert_eq!(
response.response.unwrap().refund_status,
enums::RefundStatus::Success,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/bambora.rs" role="context" start="159" end="176">
async fn should_partially_refund_manually_captured_payment() {
let response = CONNECTOR
.capture_payment_and_refund(
get_default_payment_authorize_data(),
None,
Some(types::RefundsData {
refund_amount: 50,
..utils::PaymentRefundType::default().0
}),
None,
)
.await
.unwrap();
assert_eq!(
response.response.unwrap().refund_status,
enums::RefundStatus::Success,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/bambora.rs" role="context" start="42" end="52">
fn get_default_payment_authorize_data() -> Option<types::PaymentsAuthorizeData> {
Some(types::PaymentsAuthorizeData {
payment_method_data: domain::PaymentMethodData::Card(domain::Card {
card_number: cards::CardNumber::from_str("4030000010001234").unwrap(),
card_exp_year: Secret::new("25".to_string()),
card_cvc: Secret::new("123".to_string()),
..utils::CCardType::default().0
}),
..utils::PaymentAuthorizeType::default().0
})
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/router/tests/connectors/bambora.rs<|crate|> router<|connector|> bambora anchor=should_only_authorize_payment kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=1<|meta_end|>
<file_sep path="hyperswitch/crates/router/tests/connectors/bambora.rs" role="context" start="57" end="63">
async fn should_only_authorize_payment() {
let response = CONNECTOR
.authorize_payment(get_default_payment_authorize_data(), None)
.await
.expect("Authorize payment response");
assert_eq!(response.status, enums::AttemptStatus::Authorized);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/bambora.rs" role="context" start="56" end="56">
use router::types::{self, domain, storage::enums};
<file_sep path="hyperswitch/crates/router/tests/connectors/bambora.rs" role="context" start="77" end="90">
async fn should_partially_capture_authorized_payment() {
let response = CONNECTOR
.authorize_and_capture_payment(
get_default_payment_authorize_data(),
Some(types::PaymentsCaptureData {
amount_to_capture: 50,
..utils::PaymentCaptureType::default().0
}),
None,
)
.await
.expect("Capture payment response");
assert_eq!(response.status, enums::AttemptStatus::Charged);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/bambora.rs" role="context" start="67" end="73">
async fn should_capture_authorized_payment() {
let response = CONNECTOR
.authorize_and_capture_payment(get_default_payment_authorize_data(), None, None)
.await
.expect("Capture payment response");
assert_eq!(response.status, enums::AttemptStatus::Charged);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/bambora.rs" role="context" start="42" end="52">
fn get_default_payment_authorize_data() -> Option<types::PaymentsAuthorizeData> {
Some(types::PaymentsAuthorizeData {
payment_method_data: domain::PaymentMethodData::Card(domain::Card {
card_number: cards::CardNumber::from_str("4030000010001234").unwrap(),
card_exp_year: Secret::new("25".to_string()),
card_cvc: Secret::new("123".to_string()),
..utils::CCardType::default().0
}),
..utils::PaymentAuthorizeType::default().0
})
}
<file_sep path="hyperswitch/crates/router/tests/connectors/bambora.rs" role="context" start="35" end="37">
fn get_name(&self) -> String {
"bambora".to_string()
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/router/tests/connectors/bambora.rs<|crate|> router<|connector|> bambora anchor=should_capture_authorized_payment kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/router/tests/connectors/bambora.rs" role="context" start="67" end="73">
async fn should_capture_authorized_payment() {
let response = CONNECTOR
.authorize_and_capture_payment(get_default_payment_authorize_data(), None, None)
.await
.expect("Capture payment response");
assert_eq!(response.status, enums::AttemptStatus::Charged);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/bambora.rs" role="context" start="66" end="66">
use router::types::{self, domain, storage::enums};
<file_sep path="hyperswitch/crates/router/tests/connectors/bambora.rs" role="context" start="94" end="124">
async fn should_sync_authorized_payment() {
let authorize_response = CONNECTOR
.authorize_payment(get_default_payment_authorize_data(), None)
.await
.expect("Authorize payment response");
let txn_id = utils::get_connector_transaction_id(authorize_response.response);
let response = CONNECTOR
.psync_retry_till_status_matches(
enums::AttemptStatus::Authorized,
Some(types::PaymentsSyncData {
mandate_id: None,
connector_transaction_id: types::ResponseId::ConnectorTransactionId(
txn_id.unwrap(),
),
encoded_data: None,
capture_method: Some(diesel_models::enums::CaptureMethod::Manual),
sync_type: types::SyncRequestType::SinglePaymentSync,
connector_meta: None,
payment_method_type: None,
currency: enums::Currency::USD,
payment_experience: None,
integrity_object: None,
amount: MinorUnit::new(100),
..Default::default()
}),
None,
)
.await
.expect("PSync response");
assert_eq!(response.status, enums::AttemptStatus::Authorized,);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/bambora.rs" role="context" start="77" end="90">
async fn should_partially_capture_authorized_payment() {
let response = CONNECTOR
.authorize_and_capture_payment(
get_default_payment_authorize_data(),
Some(types::PaymentsCaptureData {
amount_to_capture: 50,
..utils::PaymentCaptureType::default().0
}),
None,
)
.await
.expect("Capture payment response");
assert_eq!(response.status, enums::AttemptStatus::Charged);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/bambora.rs" role="context" start="57" end="63">
async fn should_only_authorize_payment() {
let response = CONNECTOR
.authorize_payment(get_default_payment_authorize_data(), None)
.await
.expect("Authorize payment response");
assert_eq!(response.status, enums::AttemptStatus::Authorized);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/bambora.rs" role="context" start="42" end="52">
fn get_default_payment_authorize_data() -> Option<types::PaymentsAuthorizeData> {
Some(types::PaymentsAuthorizeData {
payment_method_data: domain::PaymentMethodData::Card(domain::Card {
card_number: cards::CardNumber::from_str("4030000010001234").unwrap(),
card_exp_year: Secret::new("25".to_string()),
card_cvc: Secret::new("123".to_string()),
..utils::CCardType::default().0
}),
..utils::PaymentAuthorizeType::default().0
})
}
<file_sep path="hyperswitch/migrations/2023-07-07-091223_create_captures_table/up.sql" role="context" start="1" end="17">
CREATE TYPE "CaptureStatus" AS ENUM (
'started',
'charged',
'pending',
'failed'
);
ALTER TYPE "IntentStatus" ADD VALUE If NOT EXISTS 'partially_captured' AFTER 'requires_capture';
CREATE TABLE captures(
capture_id VARCHAR(64) NOT NULL PRIMARY KEY,
payment_id VARCHAR(64) NOT NULL,
merchant_id VARCHAR(64) NOT NULL,
status "CaptureStatus" NOT NULL,
amount BIGINT NOT NULL,
currency "Currency",
connector VARCHAR(255),
error_message VARCHAR(255),
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/router/tests/connectors/bambora.rs<|crate|> router<|connector|> bambora anchor=should_refund_auto_captured_payment kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/router/tests/connectors/bambora.rs" role="context" start="248" end="257">
async fn should_refund_auto_captured_payment() {
let response = CONNECTOR
.make_payment_and_refund(get_default_payment_authorize_data(), None, None)
.await
.unwrap();
assert_eq!(
response.response.unwrap().refund_status,
enums::RefundStatus::Success,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/bambora.rs" role="context" start="247" end="247">
use router::types::{self, domain, storage::enums};
<file_sep path="hyperswitch/crates/router/tests/connectors/bambora.rs" role="context" start="281" end="299">
async fn should_sync_refund() {
let refund_response = CONNECTOR
.make_payment_and_refund(get_default_payment_authorize_data(), None, None)
.await
.unwrap();
let response = CONNECTOR
.rsync_retry_till_status_matches(
enums::RefundStatus::Success,
refund_response.response.unwrap().connector_refund_id,
None,
None,
)
.await
.unwrap();
assert_eq!(
response.response.unwrap().refund_status,
enums::RefundStatus::Success,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/bambora.rs" role="context" start="261" end="277">
async fn should_partially_refund_succeeded_payment() {
let refund_response = CONNECTOR
.make_payment_and_refund(
get_default_payment_authorize_data(),
Some(types::RefundsData {
refund_amount: 50,
..utils::PaymentRefundType::default().0
}),
None,
)
.await
.unwrap();
assert_eq!(
refund_response.response.unwrap().refund_status,
enums::RefundStatus::Success,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/bambora.rs" role="context" start="212" end="244">
async fn should_sync_auto_captured_payment() {
let authorize_response = CONNECTOR
.make_payment(get_default_payment_authorize_data(), None)
.await
.unwrap();
assert_eq!(authorize_response.status, enums::AttemptStatus::Charged);
let txn_id = utils::get_connector_transaction_id(authorize_response.response);
assert_ne!(txn_id, None, "Empty connector transaction id");
let response = CONNECTOR
.psync_retry_till_status_matches(
enums::AttemptStatus::Charged,
Some(types::PaymentsSyncData {
mandate_id: None,
connector_transaction_id: types::ResponseId::ConnectorTransactionId(
txn_id.unwrap(),
),
encoded_data: None,
capture_method: Some(enums::CaptureMethod::Automatic),
sync_type: types::SyncRequestType::SinglePaymentSync,
connector_meta: None,
payment_method_type: None,
currency: enums::Currency::USD,
payment_experience: None,
integrity_object: None,
amount: MinorUnit::new(100),
..Default::default()
}),
None,
)
.await
.unwrap();
assert_eq!(response.status, enums::AttemptStatus::Charged,);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/bambora.rs" role="context" start="202" end="208">
async fn should_make_payment() {
let authorize_response = CONNECTOR
.make_payment(get_default_payment_authorize_data(), None)
.await
.unwrap();
assert_eq!(authorize_response.status, enums::AttemptStatus::Charged);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/bambora.rs" role="context" start="42" end="52">
fn get_default_payment_authorize_data() -> Option<types::PaymentsAuthorizeData> {
Some(types::PaymentsAuthorizeData {
payment_method_data: domain::PaymentMethodData::Card(domain::Card {
card_number: cards::CardNumber::from_str("4030000010001234").unwrap(),
card_exp_year: Secret::new("25".to_string()),
card_cvc: Secret::new("123".to_string()),
..utils::CCardType::default().0
}),
..utils::PaymentAuthorizeType::default().0
})
}
<file_sep path="hyperswitch/crates/router/src/connector/dummyconnector/transformers.rs" role="context" start="304" end="309">
pub enum RefundStatus {
Succeeded,
Failed,
#[default]
Processing,
}
<file_sep path="hyperswitch/crates/api_models/src/refunds.rs" role="context" start="378" end="384">
pub enum RefundStatus {
Succeeded,
Failed,
#[default]
Pending,
Review,
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/router/tests/connectors/bambora.rs<|crate|> router<|connector|> bambora anchor=should_refund_manually_captured_payment kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/router/tests/connectors/bambora.rs" role="context" start="146" end="155">
async fn should_refund_manually_captured_payment() {
let response = CONNECTOR
.capture_payment_and_refund(get_default_payment_authorize_data(), None, None, None)
.await
.unwrap();
assert_eq!(
response.response.unwrap().refund_status,
enums::RefundStatus::Success,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/bambora.rs" role="context" start="145" end="145">
use router::types::{self, domain, storage::enums};
<file_sep path="hyperswitch/crates/router/tests/connectors/bambora.rs" role="context" start="180" end="198">
async fn should_sync_manually_captured_refund() {
let refund_response = CONNECTOR
.capture_payment_and_refund(get_default_payment_authorize_data(), None, None, None)
.await
.unwrap();
let response = CONNECTOR
.rsync_retry_till_status_matches(
enums::RefundStatus::Success,
refund_response.response.unwrap().connector_refund_id,
None,
None,
)
.await
.unwrap();
assert_eq!(
response.response.unwrap().refund_status,
enums::RefundStatus::Success,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/bambora.rs" role="context" start="159" end="176">
async fn should_partially_refund_manually_captured_payment() {
let response = CONNECTOR
.capture_payment_and_refund(
get_default_payment_authorize_data(),
None,
Some(types::RefundsData {
refund_amount: 50,
..utils::PaymentRefundType::default().0
}),
None,
)
.await
.unwrap();
assert_eq!(
response.response.unwrap().refund_status,
enums::RefundStatus::Success,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/bambora.rs" role="context" start="128" end="142">
async fn should_void_authorized_payment() {
let response = CONNECTOR
.authorize_and_void_payment(
get_default_payment_authorize_data(),
Some(types::PaymentsCancelData {
connector_transaction_id: String::from(""),
cancellation_reason: Some("requested_by_customer".to_string()),
..Default::default()
}),
None,
)
.await
.expect("Void payment response");
assert_eq!(response.status, enums::AttemptStatus::Voided);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/bambora.rs" role="context" start="94" end="124">
async fn should_sync_authorized_payment() {
let authorize_response = CONNECTOR
.authorize_payment(get_default_payment_authorize_data(), None)
.await
.expect("Authorize payment response");
let txn_id = utils::get_connector_transaction_id(authorize_response.response);
let response = CONNECTOR
.psync_retry_till_status_matches(
enums::AttemptStatus::Authorized,
Some(types::PaymentsSyncData {
mandate_id: None,
connector_transaction_id: types::ResponseId::ConnectorTransactionId(
txn_id.unwrap(),
),
encoded_data: None,
capture_method: Some(diesel_models::enums::CaptureMethod::Manual),
sync_type: types::SyncRequestType::SinglePaymentSync,
connector_meta: None,
payment_method_type: None,
currency: enums::Currency::USD,
payment_experience: None,
integrity_object: None,
amount: MinorUnit::new(100),
..Default::default()
}),
None,
)
.await
.expect("PSync response");
assert_eq!(response.status, enums::AttemptStatus::Authorized,);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/bambora.rs" role="context" start="42" end="52">
fn get_default_payment_authorize_data() -> Option<types::PaymentsAuthorizeData> {
Some(types::PaymentsAuthorizeData {
payment_method_data: domain::PaymentMethodData::Card(domain::Card {
card_number: cards::CardNumber::from_str("4030000010001234").unwrap(),
card_exp_year: Secret::new("25".to_string()),
card_cvc: Secret::new("123".to_string()),
..utils::CCardType::default().0
}),
..utils::PaymentAuthorizeType::default().0
})
}
<file_sep path="hyperswitch/crates/router/src/connector/dummyconnector/transformers.rs" role="context" start="304" end="309">
pub enum RefundStatus {
Succeeded,
Failed,
#[default]
Processing,
}
<file_sep path="hyperswitch/crates/api_models/src/refunds.rs" role="context" start="378" end="384">
pub enum RefundStatus {
Succeeded,
Failed,
#[default]
Pending,
Review,
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/router/tests/connectors/nmi.rs<|crate|> router<|connector|> nmi anchor=should_make_payment kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=1<|meta_end|>
<file_sep path="hyperswitch/crates/router/tests/connectors/nmi.rs" role="context" start="393" end="416">
async fn should_make_payment() {
let response = CONNECTOR
.make_payment(get_payment_authorize_data(), None)
.await
.unwrap();
assert_eq!(response.status, enums::AttemptStatus::CaptureInitiated);
let transaction_id = utils::get_connector_transaction_id(response.response.to_owned()).unwrap();
let sync_response = CONNECTOR
.psync_retry_till_status_matches(
enums::AttemptStatus::Pending,
Some(types::PaymentsSyncData {
connector_transaction_id: types::ResponseId::ConnectorTransactionId(
transaction_id.clone(),
),
capture_method: Some(enums::CaptureMethod::Automatic),
..Default::default()
}),
None,
)
.await
.unwrap();
assert_eq!(sync_response.status, enums::AttemptStatus::Pending);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/nmi.rs" role="context" start="392" end="392">
use router::types::{self, domain, storage::enums};
<file_sep path="hyperswitch/crates/router/tests/connectors/nmi.rs" role="context" start="466" end="515">
async fn should_partially_refund_succeeded_payment() {
let response = CONNECTOR
.make_payment(get_payment_authorize_data(), None)
.await
.unwrap();
assert_eq!(response.status, enums::AttemptStatus::CaptureInitiated);
let transaction_id = utils::get_connector_transaction_id(response.response.to_owned()).unwrap();
let sync_response = CONNECTOR
.psync_retry_till_status_matches(
enums::AttemptStatus::Pending,
Some(types::PaymentsSyncData {
connector_transaction_id: types::ResponseId::ConnectorTransactionId(
transaction_id.clone(),
),
capture_method: Some(enums::CaptureMethod::Automatic),
..Default::default()
}),
None,
)
.await
.unwrap();
assert_eq!(sync_response.status, enums::AttemptStatus::Pending);
let refund_response = CONNECTOR
.refund_payment(
transaction_id.clone(),
Some(types::RefundsData {
refund_amount: 1000,
..utils::PaymentRefundType::default().0
}),
None,
)
.await
.unwrap();
assert_eq!(refund_response.status, enums::AttemptStatus::Pending);
let sync_response = CONNECTOR
.rsync_retry_till_status_matches(
enums::RefundStatus::Pending,
refund_response.response.unwrap().connector_refund_id,
None,
None,
)
.await
.unwrap();
assert_eq!(
sync_response.response.unwrap().refund_status,
enums::RefundStatus::Pending
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/nmi.rs" role="context" start="420" end="462">
async fn should_refund_auto_captured_payment() {
let response = CONNECTOR
.make_payment(get_payment_authorize_data(), None)
.await
.unwrap();
assert_eq!(response.status, enums::AttemptStatus::CaptureInitiated);
let transaction_id = utils::get_connector_transaction_id(response.response.to_owned()).unwrap();
let sync_response = CONNECTOR
.psync_retry_till_status_matches(
enums::AttemptStatus::Pending,
Some(types::PaymentsSyncData {
connector_transaction_id: types::ResponseId::ConnectorTransactionId(
transaction_id.clone(),
),
capture_method: Some(enums::CaptureMethod::Automatic),
..Default::default()
}),
None,
)
.await
.unwrap();
assert_eq!(sync_response.status, enums::AttemptStatus::Pending);
let refund_response = CONNECTOR
.refund_payment(transaction_id.clone(), None, None)
.await
.unwrap();
assert_eq!(refund_response.status, enums::AttemptStatus::Pending);
let sync_response = CONNECTOR
.rsync_retry_till_status_matches(
enums::RefundStatus::Pending,
refund_response.response.unwrap().connector_refund_id,
None,
None,
)
.await
.unwrap();
assert_eq!(
sync_response.response.unwrap().refund_status,
enums::RefundStatus::Pending
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/nmi.rs" role="context" start="310" end="389">
async fn should_partially_refund_manually_captured_payment() {
let response = CONNECTOR
.authorize_payment(get_payment_authorize_data(), None)
.await
.unwrap();
assert_eq!(response.status, enums::AttemptStatus::Authorizing);
let transaction_id = utils::get_connector_transaction_id(response.response.to_owned()).unwrap();
let sync_response = CONNECTOR
.psync_retry_till_status_matches(
enums::AttemptStatus::Authorized,
Some(types::PaymentsSyncData {
connector_transaction_id: types::ResponseId::ConnectorTransactionId(
transaction_id.clone(),
),
capture_method: Some(enums::CaptureMethod::Manual),
..Default::default()
}),
None,
)
.await
.unwrap();
assert_eq!(sync_response.status, enums::AttemptStatus::Authorized);
let capture_response = CONNECTOR
.capture_payment(
transaction_id.clone(),
Some(types::PaymentsCaptureData {
amount_to_capture: 2023,
..utils::PaymentCaptureType::default().0
}),
None,
)
.await
.unwrap();
assert_eq!(
capture_response.status,
enums::AttemptStatus::CaptureInitiated
);
let sync_response = CONNECTOR
.psync_retry_till_status_matches(
enums::AttemptStatus::Pending,
Some(types::PaymentsSyncData {
connector_transaction_id: types::ResponseId::ConnectorTransactionId(
transaction_id.clone(),
),
capture_method: Some(enums::CaptureMethod::Manual),
..Default::default()
}),
None,
)
.await
.unwrap();
assert_eq!(sync_response.status, enums::AttemptStatus::Pending);
let refund_response = CONNECTOR
.refund_payment(
transaction_id.clone(),
Some(types::RefundsData {
refund_amount: 1023,
..utils::PaymentRefundType::default().0
}),
None,
)
.await
.unwrap();
assert_eq!(refund_response.status, enums::AttemptStatus::Pending);
let sync_response = CONNECTOR
.rsync_retry_till_status_matches(
enums::RefundStatus::Pending,
refund_response.response.unwrap().connector_refund_id,
None,
None,
)
.await
.unwrap();
assert_eq!(
sync_response.response.unwrap().refund_status,
enums::RefundStatus::Pending
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/nmi.rs" role="context" start="241" end="306">
async fn should_refund_manually_captured_payment() {
let response = CONNECTOR
.authorize_payment(get_payment_authorize_data(), None)
.await
.unwrap();
assert_eq!(response.status, enums::AttemptStatus::Authorizing);
let transaction_id = utils::get_connector_transaction_id(response.response.to_owned()).unwrap();
let sync_response = CONNECTOR
.psync_retry_till_status_matches(
enums::AttemptStatus::Authorized,
Some(types::PaymentsSyncData {
connector_transaction_id: types::ResponseId::ConnectorTransactionId(
transaction_id.clone(),
),
capture_method: Some(enums::CaptureMethod::Manual),
..Default::default()
}),
None,
)
.await
.unwrap();
assert_eq!(sync_response.status, enums::AttemptStatus::Authorized);
let capture_response = CONNECTOR
.capture_payment(transaction_id.clone(), None, None)
.await
.unwrap();
assert_eq!(
capture_response.status,
enums::AttemptStatus::CaptureInitiated
);
let sync_response = CONNECTOR
.psync_retry_till_status_matches(
enums::AttemptStatus::Pending,
Some(types::PaymentsSyncData {
connector_transaction_id: types::ResponseId::ConnectorTransactionId(
transaction_id.clone(),
),
capture_method: Some(enums::CaptureMethod::Manual),
..Default::default()
}),
None,
)
.await
.unwrap();
assert_eq!(sync_response.status, enums::AttemptStatus::Pending);
let refund_response = CONNECTOR
.refund_payment(transaction_id.clone(), None, None)
.await
.unwrap();
assert_eq!(refund_response.status, enums::AttemptStatus::Pending);
let sync_response = CONNECTOR
.rsync_retry_till_status_matches(
enums::RefundStatus::Pending,
refund_response.response.unwrap().connector_refund_id,
None,
None,
)
.await
.unwrap();
assert_eq!(
sync_response.response.unwrap().refund_status,
enums::RefundStatus::Pending
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/nmi.rs" role="context" start="39" end="48">
fn get_payment_authorize_data() -> Option<types::PaymentsAuthorizeData> {
Some(types::PaymentsAuthorizeData {
payment_method_data: domain::PaymentMethodData::Card(domain::Card {
card_number: cards::CardNumber::from_str("4111111111111111").unwrap(),
..utils::CCardType::default().0
}),
amount: 2023,
..utils::PaymentAuthorizeType::default().0
})
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/router/tests/connectors/nmi.rs<|crate|> router<|connector|> nmi anchor=should_only_authorize_payment kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=1<|meta_end|>
<file_sep path="hyperswitch/crates/router/tests/connectors/nmi.rs" role="context" start="53" end="75">
async fn should_only_authorize_payment() {
let response = CONNECTOR
.authorize_payment(get_payment_authorize_data(), None)
.await
.expect("Authorize payment response");
let transaction_id = utils::get_connector_transaction_id(response.response).unwrap();
let sync_response = CONNECTOR
.psync_retry_till_status_matches(
enums::AttemptStatus::Authorized,
Some(types::PaymentsSyncData {
connector_transaction_id: types::ResponseId::ConnectorTransactionId(
transaction_id.clone(),
),
capture_method: Some(enums::CaptureMethod::Manual),
..Default::default()
}),
None,
)
.await
.unwrap();
// Assert the sync response, it will be authorized in case of manual capture, for automatic it will be Completed Success
assert_eq!(sync_response.status, enums::AttemptStatus::Authorized);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/nmi.rs" role="context" start="52" end="52">
use router::types::{self, domain, storage::enums};
<file_sep path="hyperswitch/crates/router/tests/connectors/nmi.rs" role="context" start="128" end="181">
async fn should_partially_capture_authorized_payment() {
let response = CONNECTOR
.authorize_payment(get_payment_authorize_data(), None)
.await
.unwrap();
assert_eq!(response.status, enums::AttemptStatus::Authorizing);
let transaction_id = utils::get_connector_transaction_id(response.response.to_owned()).unwrap();
let sync_response = CONNECTOR
.psync_retry_till_status_matches(
enums::AttemptStatus::Authorized,
Some(types::PaymentsSyncData {
connector_transaction_id: types::ResponseId::ConnectorTransactionId(
transaction_id.clone(),
),
capture_method: Some(enums::CaptureMethod::Manual),
..Default::default()
}),
None,
)
.await
.unwrap();
assert_eq!(sync_response.status, enums::AttemptStatus::Authorized);
let capture_response = CONNECTOR
.capture_payment(
transaction_id.clone(),
Some(types::PaymentsCaptureData {
amount_to_capture: 1000,
..utils::PaymentCaptureType::default().0
}),
None,
)
.await
.unwrap();
assert_eq!(
capture_response.status,
enums::AttemptStatus::CaptureInitiated
);
let sync_response = CONNECTOR
.psync_retry_till_status_matches(
enums::AttemptStatus::Pending,
Some(types::PaymentsSyncData {
connector_transaction_id: types::ResponseId::ConnectorTransactionId(
transaction_id.clone(),
),
capture_method: Some(enums::CaptureMethod::Manual),
..Default::default()
}),
None,
)
.await
.unwrap();
assert_eq!(sync_response.status, enums::AttemptStatus::Pending);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/nmi.rs" role="context" start="79" end="124">
async fn should_capture_authorized_payment() {
let response = CONNECTOR
.authorize_payment(get_payment_authorize_data(), None)
.await
.unwrap();
assert_eq!(response.status, enums::AttemptStatus::Authorizing);
let transaction_id = utils::get_connector_transaction_id(response.response.to_owned()).unwrap();
let sync_response = CONNECTOR
.psync_retry_till_status_matches(
enums::AttemptStatus::Authorized,
Some(types::PaymentsSyncData {
connector_transaction_id: types::ResponseId::ConnectorTransactionId(
transaction_id.clone(),
),
capture_method: Some(enums::CaptureMethod::Manual),
..Default::default()
}),
None,
)
.await
.unwrap();
assert_eq!(sync_response.status, enums::AttemptStatus::Authorized);
let capture_response = CONNECTOR
.capture_payment(transaction_id.clone(), None, None)
.await
.unwrap();
assert_eq!(
capture_response.status,
enums::AttemptStatus::CaptureInitiated
);
let sync_response = CONNECTOR
.psync_retry_till_status_matches(
enums::AttemptStatus::Pending,
Some(types::PaymentsSyncData {
connector_transaction_id: types::ResponseId::ConnectorTransactionId(
transaction_id.clone(),
),
capture_method: Some(enums::CaptureMethod::Manual),
..Default::default()
}),
None,
)
.await
.unwrap();
assert_eq!(sync_response.status, enums::AttemptStatus::Pending);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/nmi.rs" role="context" start="39" end="48">
fn get_payment_authorize_data() -> Option<types::PaymentsAuthorizeData> {
Some(types::PaymentsAuthorizeData {
payment_method_data: domain::PaymentMethodData::Card(domain::Card {
card_number: cards::CardNumber::from_str("4111111111111111").unwrap(),
..utils::CCardType::default().0
}),
amount: 2023,
..utils::PaymentAuthorizeType::default().0
})
}
<file_sep path="hyperswitch/crates/router/tests/connectors/nmi.rs" role="context" start="32" end="34">
fn get_name(&self) -> String {
"nmi".to_string()
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/router/tests/connectors/nmi.rs<|crate|> router<|connector|> nmi anchor=should_fail_void_payment_for_auto_capture kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=1<|meta_end|>
<file_sep path="hyperswitch/crates/router/tests/connectors/nmi.rs" role="context" start="591" end="620">
async fn should_fail_void_payment_for_auto_capture() {
let response = CONNECTOR
.make_payment(get_payment_authorize_data(), None)
.await
.unwrap();
assert_eq!(response.status, enums::AttemptStatus::CaptureInitiated);
let transaction_id = utils::get_connector_transaction_id(response.response.to_owned()).unwrap();
let sync_response = CONNECTOR
.psync_retry_till_status_matches(
enums::AttemptStatus::Pending,
Some(types::PaymentsSyncData {
connector_transaction_id: types::ResponseId::ConnectorTransactionId(
transaction_id.clone(),
),
capture_method: Some(enums::CaptureMethod::Automatic),
..Default::default()
}),
None,
)
.await
.unwrap();
assert_eq!(sync_response.status, enums::AttemptStatus::Pending);
let void_response = CONNECTOR
.void_payment(transaction_id.clone(), None, None)
.await
.unwrap();
assert_eq!(void_response.status, enums::AttemptStatus::VoidFailed);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/nmi.rs" role="context" start="590" end="590">
use router::types::{self, domain, storage::enums};
<file_sep path="hyperswitch/crates/router/tests/connectors/nmi.rs" role="context" start="656" end="694">
async fn should_fail_for_refund_amount_higher_than_payment_amount() {
let response = CONNECTOR
.make_payment(get_payment_authorize_data(), None)
.await
.unwrap();
assert_eq!(response.status, enums::AttemptStatus::CaptureInitiated);
let transaction_id = utils::get_connector_transaction_id(response.response.to_owned()).unwrap();
let sync_response = CONNECTOR
.psync_retry_till_status_matches(
enums::AttemptStatus::Pending,
Some(types::PaymentsSyncData {
connector_transaction_id: types::ResponseId::ConnectorTransactionId(
transaction_id.clone(),
),
capture_method: Some(enums::CaptureMethod::Automatic),
..Default::default()
}),
None,
)
.await
.unwrap();
assert_eq!(sync_response.status, enums::AttemptStatus::Pending);
let refund_response = CONNECTOR
.refund_payment(
transaction_id,
Some(types::RefundsData {
refund_amount: 3024,
..utils::PaymentRefundType::default().0
}),
None,
)
.await
.unwrap();
assert_eq!(
refund_response.response.unwrap().refund_status,
enums::RefundStatus::Failure
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/nmi.rs" role="context" start="624" end="652">
async fn should_fail_capture_for_invalid_payment() {
let response = CONNECTOR
.authorize_payment(get_payment_authorize_data(), None)
.await
.unwrap();
assert_eq!(response.status, enums::AttemptStatus::Authorizing);
let transaction_id = utils::get_connector_transaction_id(response.response.to_owned()).unwrap();
let sync_response = CONNECTOR
.psync_retry_till_status_matches(
enums::AttemptStatus::Authorized,
Some(types::PaymentsSyncData {
connector_transaction_id: types::ResponseId::ConnectorTransactionId(
transaction_id.clone(),
),
capture_method: Some(enums::CaptureMethod::Manual),
..Default::default()
}),
None,
)
.await
.unwrap();
assert_eq!(sync_response.status, enums::AttemptStatus::Authorized);
let capture_response = CONNECTOR
.capture_payment("9123456789".to_string(), None, None)
.await
.unwrap();
assert_eq!(capture_response.status, enums::AttemptStatus::CaptureFailed);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/nmi.rs" role="context" start="587" end="587">
async fn should_fail_payment_for_incorrect_expiry_year() {}
<file_sep path="hyperswitch/crates/router/tests/connectors/nmi.rs" role="context" start="582" end="582">
async fn should_fail_payment_for_invalid_exp_month() {}
<file_sep path="hyperswitch/crates/router/tests/connectors/nmi.rs" role="context" start="39" end="48">
fn get_payment_authorize_data() -> Option<types::PaymentsAuthorizeData> {
Some(types::PaymentsAuthorizeData {
payment_method_data: domain::PaymentMethodData::Card(domain::Card {
card_number: cards::CardNumber::from_str("4111111111111111").unwrap(),
..utils::CCardType::default().0
}),
amount: 2023,
..utils::PaymentAuthorizeType::default().0
})
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/router/tests/connectors/nmi.rs<|crate|> router<|connector|> nmi anchor=should_fail_for_refund_amount_higher_than_payment_amount kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/router/tests/connectors/nmi.rs" role="context" start="656" end="694">
async fn should_fail_for_refund_amount_higher_than_payment_amount() {
let response = CONNECTOR
.make_payment(get_payment_authorize_data(), None)
.await
.unwrap();
assert_eq!(response.status, enums::AttemptStatus::CaptureInitiated);
let transaction_id = utils::get_connector_transaction_id(response.response.to_owned()).unwrap();
let sync_response = CONNECTOR
.psync_retry_till_status_matches(
enums::AttemptStatus::Pending,
Some(types::PaymentsSyncData {
connector_transaction_id: types::ResponseId::ConnectorTransactionId(
transaction_id.clone(),
),
capture_method: Some(enums::CaptureMethod::Automatic),
..Default::default()
}),
None,
)
.await
.unwrap();
assert_eq!(sync_response.status, enums::AttemptStatus::Pending);
let refund_response = CONNECTOR
.refund_payment(
transaction_id,
Some(types::RefundsData {
refund_amount: 3024,
..utils::PaymentRefundType::default().0
}),
None,
)
.await
.unwrap();
assert_eq!(
refund_response.response.unwrap().refund_status,
enums::RefundStatus::Failure
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/nmi.rs" role="context" start="655" end="655">
use router::types::{self, domain, storage::enums};
<file_sep path="hyperswitch/crates/router/tests/connectors/nmi.rs" role="context" start="624" end="652">
async fn should_fail_capture_for_invalid_payment() {
let response = CONNECTOR
.authorize_payment(get_payment_authorize_data(), None)
.await
.unwrap();
assert_eq!(response.status, enums::AttemptStatus::Authorizing);
let transaction_id = utils::get_connector_transaction_id(response.response.to_owned()).unwrap();
let sync_response = CONNECTOR
.psync_retry_till_status_matches(
enums::AttemptStatus::Authorized,
Some(types::PaymentsSyncData {
connector_transaction_id: types::ResponseId::ConnectorTransactionId(
transaction_id.clone(),
),
capture_method: Some(enums::CaptureMethod::Manual),
..Default::default()
}),
None,
)
.await
.unwrap();
assert_eq!(sync_response.status, enums::AttemptStatus::Authorized);
let capture_response = CONNECTOR
.capture_payment("9123456789".to_string(), None, None)
.await
.unwrap();
assert_eq!(capture_response.status, enums::AttemptStatus::CaptureFailed);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/nmi.rs" role="context" start="591" end="620">
async fn should_fail_void_payment_for_auto_capture() {
let response = CONNECTOR
.make_payment(get_payment_authorize_data(), None)
.await
.unwrap();
assert_eq!(response.status, enums::AttemptStatus::CaptureInitiated);
let transaction_id = utils::get_connector_transaction_id(response.response.to_owned()).unwrap();
let sync_response = CONNECTOR
.psync_retry_till_status_matches(
enums::AttemptStatus::Pending,
Some(types::PaymentsSyncData {
connector_transaction_id: types::ResponseId::ConnectorTransactionId(
transaction_id.clone(),
),
capture_method: Some(enums::CaptureMethod::Automatic),
..Default::default()
}),
None,
)
.await
.unwrap();
assert_eq!(sync_response.status, enums::AttemptStatus::Pending);
let void_response = CONNECTOR
.void_payment(transaction_id.clone(), None, None)
.await
.unwrap();
assert_eq!(void_response.status, enums::AttemptStatus::VoidFailed);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/nmi.rs" role="context" start="39" end="48">
fn get_payment_authorize_data() -> Option<types::PaymentsAuthorizeData> {
Some(types::PaymentsAuthorizeData {
payment_method_data: domain::PaymentMethodData::Card(domain::Card {
card_number: cards::CardNumber::from_str("4111111111111111").unwrap(),
..utils::CCardType::default().0
}),
amount: 2023,
..utils::PaymentAuthorizeType::default().0
})
}
<file_sep path="hyperswitch/crates/router/src/connector/dummyconnector/transformers.rs" role="context" start="304" end="309">
pub enum RefundStatus {
Succeeded,
Failed,
#[default]
Processing,
}
<file_sep path="hyperswitch/crates/api_models/src/refunds.rs" role="context" start="378" end="384">
pub enum RefundStatus {
Succeeded,
Failed,
#[default]
Pending,
Review,
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/router/tests/connectors/nmi.rs<|crate|> router<|connector|> nmi anchor=should_refund_auto_captured_payment kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/router/tests/connectors/nmi.rs" role="context" start="420" end="462">
async fn should_refund_auto_captured_payment() {
let response = CONNECTOR
.make_payment(get_payment_authorize_data(), None)
.await
.unwrap();
assert_eq!(response.status, enums::AttemptStatus::CaptureInitiated);
let transaction_id = utils::get_connector_transaction_id(response.response.to_owned()).unwrap();
let sync_response = CONNECTOR
.psync_retry_till_status_matches(
enums::AttemptStatus::Pending,
Some(types::PaymentsSyncData {
connector_transaction_id: types::ResponseId::ConnectorTransactionId(
transaction_id.clone(),
),
capture_method: Some(enums::CaptureMethod::Automatic),
..Default::default()
}),
None,
)
.await
.unwrap();
assert_eq!(sync_response.status, enums::AttemptStatus::Pending);
let refund_response = CONNECTOR
.refund_payment(transaction_id.clone(), None, None)
.await
.unwrap();
assert_eq!(refund_response.status, enums::AttemptStatus::Pending);
let sync_response = CONNECTOR
.rsync_retry_till_status_matches(
enums::RefundStatus::Pending,
refund_response.response.unwrap().connector_refund_id,
None,
None,
)
.await
.unwrap();
assert_eq!(
sync_response.response.unwrap().refund_status,
enums::RefundStatus::Pending
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/nmi.rs" role="context" start="419" end="419">
use router::types::{self, domain, storage::enums};
<file_sep path="hyperswitch/crates/router/tests/connectors/nmi.rs" role="context" start="519" end="572">
async fn should_refund_succeeded_payment_multiple_times() {
let response = CONNECTOR
.make_payment(get_payment_authorize_data(), None)
.await
.unwrap();
assert_eq!(response.status, enums::AttemptStatus::CaptureInitiated);
let transaction_id = utils::get_connector_transaction_id(response.response.to_owned()).unwrap();
let sync_response = CONNECTOR
.psync_retry_till_status_matches(
enums::AttemptStatus::Pending,
Some(types::PaymentsSyncData {
connector_transaction_id: types::ResponseId::ConnectorTransactionId(
transaction_id.clone(),
),
capture_method: Some(enums::CaptureMethod::Automatic),
..Default::default()
}),
None,
)
.await
.unwrap();
assert_eq!(sync_response.status, enums::AttemptStatus::Pending);
//try refund for previous payment
let transaction_id = utils::get_connector_transaction_id(response.response).unwrap();
for _x in 0..2 {
tokio::time::sleep(Duration::from_secs(5)).await; // to avoid 404 error
let refund_response = CONNECTOR
.refund_payment(
transaction_id.clone(),
Some(types::RefundsData {
refund_amount: 50,
..utils::PaymentRefundType::default().0
}),
None,
)
.await
.unwrap();
let sync_response = CONNECTOR
.rsync_retry_till_status_matches(
enums::RefundStatus::Pending,
refund_response.response.unwrap().connector_refund_id,
None,
None,
)
.await
.unwrap();
assert_eq!(
sync_response.response.unwrap().refund_status,
enums::RefundStatus::Pending,
);
}
}
<file_sep path="hyperswitch/crates/router/tests/connectors/nmi.rs" role="context" start="466" end="515">
async fn should_partially_refund_succeeded_payment() {
let response = CONNECTOR
.make_payment(get_payment_authorize_data(), None)
.await
.unwrap();
assert_eq!(response.status, enums::AttemptStatus::CaptureInitiated);
let transaction_id = utils::get_connector_transaction_id(response.response.to_owned()).unwrap();
let sync_response = CONNECTOR
.psync_retry_till_status_matches(
enums::AttemptStatus::Pending,
Some(types::PaymentsSyncData {
connector_transaction_id: types::ResponseId::ConnectorTransactionId(
transaction_id.clone(),
),
capture_method: Some(enums::CaptureMethod::Automatic),
..Default::default()
}),
None,
)
.await
.unwrap();
assert_eq!(sync_response.status, enums::AttemptStatus::Pending);
let refund_response = CONNECTOR
.refund_payment(
transaction_id.clone(),
Some(types::RefundsData {
refund_amount: 1000,
..utils::PaymentRefundType::default().0
}),
None,
)
.await
.unwrap();
assert_eq!(refund_response.status, enums::AttemptStatus::Pending);
let sync_response = CONNECTOR
.rsync_retry_till_status_matches(
enums::RefundStatus::Pending,
refund_response.response.unwrap().connector_refund_id,
None,
None,
)
.await
.unwrap();
assert_eq!(
sync_response.response.unwrap().refund_status,
enums::RefundStatus::Pending
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/nmi.rs" role="context" start="393" end="416">
async fn should_make_payment() {
let response = CONNECTOR
.make_payment(get_payment_authorize_data(), None)
.await
.unwrap();
assert_eq!(response.status, enums::AttemptStatus::CaptureInitiated);
let transaction_id = utils::get_connector_transaction_id(response.response.to_owned()).unwrap();
let sync_response = CONNECTOR
.psync_retry_till_status_matches(
enums::AttemptStatus::Pending,
Some(types::PaymentsSyncData {
connector_transaction_id: types::ResponseId::ConnectorTransactionId(
transaction_id.clone(),
),
capture_method: Some(enums::CaptureMethod::Automatic),
..Default::default()
}),
None,
)
.await
.unwrap();
assert_eq!(sync_response.status, enums::AttemptStatus::Pending);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/nmi.rs" role="context" start="310" end="389">
async fn should_partially_refund_manually_captured_payment() {
let response = CONNECTOR
.authorize_payment(get_payment_authorize_data(), None)
.await
.unwrap();
assert_eq!(response.status, enums::AttemptStatus::Authorizing);
let transaction_id = utils::get_connector_transaction_id(response.response.to_owned()).unwrap();
let sync_response = CONNECTOR
.psync_retry_till_status_matches(
enums::AttemptStatus::Authorized,
Some(types::PaymentsSyncData {
connector_transaction_id: types::ResponseId::ConnectorTransactionId(
transaction_id.clone(),
),
capture_method: Some(enums::CaptureMethod::Manual),
..Default::default()
}),
None,
)
.await
.unwrap();
assert_eq!(sync_response.status, enums::AttemptStatus::Authorized);
let capture_response = CONNECTOR
.capture_payment(
transaction_id.clone(),
Some(types::PaymentsCaptureData {
amount_to_capture: 2023,
..utils::PaymentCaptureType::default().0
}),
None,
)
.await
.unwrap();
assert_eq!(
capture_response.status,
enums::AttemptStatus::CaptureInitiated
);
let sync_response = CONNECTOR
.psync_retry_till_status_matches(
enums::AttemptStatus::Pending,
Some(types::PaymentsSyncData {
connector_transaction_id: types::ResponseId::ConnectorTransactionId(
transaction_id.clone(),
),
capture_method: Some(enums::CaptureMethod::Manual),
..Default::default()
}),
None,
)
.await
.unwrap();
assert_eq!(sync_response.status, enums::AttemptStatus::Pending);
let refund_response = CONNECTOR
.refund_payment(
transaction_id.clone(),
Some(types::RefundsData {
refund_amount: 1023,
..utils::PaymentRefundType::default().0
}),
None,
)
.await
.unwrap();
assert_eq!(refund_response.status, enums::AttemptStatus::Pending);
let sync_response = CONNECTOR
.rsync_retry_till_status_matches(
enums::RefundStatus::Pending,
refund_response.response.unwrap().connector_refund_id,
None,
None,
)
.await
.unwrap();
assert_eq!(
sync_response.response.unwrap().refund_status,
enums::RefundStatus::Pending
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/nmi.rs" role="context" start="39" end="48">
fn get_payment_authorize_data() -> Option<types::PaymentsAuthorizeData> {
Some(types::PaymentsAuthorizeData {
payment_method_data: domain::PaymentMethodData::Card(domain::Card {
card_number: cards::CardNumber::from_str("4111111111111111").unwrap(),
..utils::CCardType::default().0
}),
amount: 2023,
..utils::PaymentAuthorizeType::default().0
})
}
<file_sep path="hyperswitch/crates/router/src/connector/dummyconnector/transformers.rs" role="context" start="304" end="309">
pub enum RefundStatus {
Succeeded,
Failed,
#[default]
Processing,
}
<file_sep path="hyperswitch/crates/api_models/src/refunds.rs" role="context" start="378" end="384">
pub enum RefundStatus {
Succeeded,
Failed,
#[default]
Pending,
Review,
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/router/tests/connectors/nmi.rs<|crate|> router<|connector|> nmi anchor=should_capture_authorized_payment kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=1<|meta_end|>
<file_sep path="hyperswitch/crates/router/tests/connectors/nmi.rs" role="context" start="79" end="124">
async fn should_capture_authorized_payment() {
let response = CONNECTOR
.authorize_payment(get_payment_authorize_data(), None)
.await
.unwrap();
assert_eq!(response.status, enums::AttemptStatus::Authorizing);
let transaction_id = utils::get_connector_transaction_id(response.response.to_owned()).unwrap();
let sync_response = CONNECTOR
.psync_retry_till_status_matches(
enums::AttemptStatus::Authorized,
Some(types::PaymentsSyncData {
connector_transaction_id: types::ResponseId::ConnectorTransactionId(
transaction_id.clone(),
),
capture_method: Some(enums::CaptureMethod::Manual),
..Default::default()
}),
None,
)
.await
.unwrap();
assert_eq!(sync_response.status, enums::AttemptStatus::Authorized);
let capture_response = CONNECTOR
.capture_payment(transaction_id.clone(), None, None)
.await
.unwrap();
assert_eq!(
capture_response.status,
enums::AttemptStatus::CaptureInitiated
);
let sync_response = CONNECTOR
.psync_retry_till_status_matches(
enums::AttemptStatus::Pending,
Some(types::PaymentsSyncData {
connector_transaction_id: types::ResponseId::ConnectorTransactionId(
transaction_id.clone(),
),
capture_method: Some(enums::CaptureMethod::Manual),
..Default::default()
}),
None,
)
.await
.unwrap();
assert_eq!(sync_response.status, enums::AttemptStatus::Pending);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/nmi.rs" role="context" start="78" end="78">
use router::types::{self, domain, storage::enums};
<file_sep path="hyperswitch/crates/router/tests/connectors/nmi.rs" role="context" start="185" end="237">
async fn should_void_authorized_payment() {
let response = CONNECTOR
.authorize_payment(get_payment_authorize_data(), None)
.await
.unwrap();
assert_eq!(response.status, enums::AttemptStatus::Authorizing);
let transaction_id = utils::get_connector_transaction_id(response.response.to_owned()).unwrap();
let sync_response = CONNECTOR
.psync_retry_till_status_matches(
enums::AttemptStatus::Authorized,
Some(types::PaymentsSyncData {
connector_transaction_id: types::ResponseId::ConnectorTransactionId(
transaction_id.clone(),
),
capture_method: Some(enums::CaptureMethod::Manual),
..Default::default()
}),
None,
)
.await
.unwrap();
assert_eq!(sync_response.status, enums::AttemptStatus::Authorized);
let void_response = CONNECTOR
.void_payment(
transaction_id.clone(),
Some(types::PaymentsCancelData {
connector_transaction_id: String::from(""),
cancellation_reason: Some("user_cancel".to_string()),
..Default::default()
}),
None,
)
.await
.unwrap();
assert_eq!(void_response.status, enums::AttemptStatus::VoidInitiated);
let sync_response = CONNECTOR
.psync_retry_till_status_matches(
enums::AttemptStatus::Voided,
Some(types::PaymentsSyncData {
connector_transaction_id: types::ResponseId::ConnectorTransactionId(
transaction_id.clone(),
),
capture_method: Some(enums::CaptureMethod::Manual),
..Default::default()
}),
None,
)
.await
.unwrap();
assert_eq!(sync_response.status, enums::AttemptStatus::Voided);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/nmi.rs" role="context" start="128" end="181">
async fn should_partially_capture_authorized_payment() {
let response = CONNECTOR
.authorize_payment(get_payment_authorize_data(), None)
.await
.unwrap();
assert_eq!(response.status, enums::AttemptStatus::Authorizing);
let transaction_id = utils::get_connector_transaction_id(response.response.to_owned()).unwrap();
let sync_response = CONNECTOR
.psync_retry_till_status_matches(
enums::AttemptStatus::Authorized,
Some(types::PaymentsSyncData {
connector_transaction_id: types::ResponseId::ConnectorTransactionId(
transaction_id.clone(),
),
capture_method: Some(enums::CaptureMethod::Manual),
..Default::default()
}),
None,
)
.await
.unwrap();
assert_eq!(sync_response.status, enums::AttemptStatus::Authorized);
let capture_response = CONNECTOR
.capture_payment(
transaction_id.clone(),
Some(types::PaymentsCaptureData {
amount_to_capture: 1000,
..utils::PaymentCaptureType::default().0
}),
None,
)
.await
.unwrap();
assert_eq!(
capture_response.status,
enums::AttemptStatus::CaptureInitiated
);
let sync_response = CONNECTOR
.psync_retry_till_status_matches(
enums::AttemptStatus::Pending,
Some(types::PaymentsSyncData {
connector_transaction_id: types::ResponseId::ConnectorTransactionId(
transaction_id.clone(),
),
capture_method: Some(enums::CaptureMethod::Manual),
..Default::default()
}),
None,
)
.await
.unwrap();
assert_eq!(sync_response.status, enums::AttemptStatus::Pending);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/nmi.rs" role="context" start="53" end="75">
async fn should_only_authorize_payment() {
let response = CONNECTOR
.authorize_payment(get_payment_authorize_data(), None)
.await
.expect("Authorize payment response");
let transaction_id = utils::get_connector_transaction_id(response.response).unwrap();
let sync_response = CONNECTOR
.psync_retry_till_status_matches(
enums::AttemptStatus::Authorized,
Some(types::PaymentsSyncData {
connector_transaction_id: types::ResponseId::ConnectorTransactionId(
transaction_id.clone(),
),
capture_method: Some(enums::CaptureMethod::Manual),
..Default::default()
}),
None,
)
.await
.unwrap();
// Assert the sync response, it will be authorized in case of manual capture, for automatic it will be Completed Success
assert_eq!(sync_response.status, enums::AttemptStatus::Authorized);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/nmi.rs" role="context" start="39" end="48">
fn get_payment_authorize_data() -> Option<types::PaymentsAuthorizeData> {
Some(types::PaymentsAuthorizeData {
payment_method_data: domain::PaymentMethodData::Card(domain::Card {
card_number: cards::CardNumber::from_str("4111111111111111").unwrap(),
..utils::CCardType::default().0
}),
amount: 2023,
..utils::PaymentAuthorizeType::default().0
})
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/router/tests/connectors/nmi.rs<|crate|> router<|connector|> nmi anchor=should_partially_refund_succeeded_payment kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/router/tests/connectors/nmi.rs" role="context" start="466" end="515">
async fn should_partially_refund_succeeded_payment() {
let response = CONNECTOR
.make_payment(get_payment_authorize_data(), None)
.await
.unwrap();
assert_eq!(response.status, enums::AttemptStatus::CaptureInitiated);
let transaction_id = utils::get_connector_transaction_id(response.response.to_owned()).unwrap();
let sync_response = CONNECTOR
.psync_retry_till_status_matches(
enums::AttemptStatus::Pending,
Some(types::PaymentsSyncData {
connector_transaction_id: types::ResponseId::ConnectorTransactionId(
transaction_id.clone(),
),
capture_method: Some(enums::CaptureMethod::Automatic),
..Default::default()
}),
None,
)
.await
.unwrap();
assert_eq!(sync_response.status, enums::AttemptStatus::Pending);
let refund_response = CONNECTOR
.refund_payment(
transaction_id.clone(),
Some(types::RefundsData {
refund_amount: 1000,
..utils::PaymentRefundType::default().0
}),
None,
)
.await
.unwrap();
assert_eq!(refund_response.status, enums::AttemptStatus::Pending);
let sync_response = CONNECTOR
.rsync_retry_till_status_matches(
enums::RefundStatus::Pending,
refund_response.response.unwrap().connector_refund_id,
None,
None,
)
.await
.unwrap();
assert_eq!(
sync_response.response.unwrap().refund_status,
enums::RefundStatus::Pending
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/nmi.rs" role="context" start="465" end="465">
use router::types::{self, domain, storage::enums};
<file_sep path="hyperswitch/crates/router/tests/connectors/nmi.rs" role="context" start="577" end="577">
async fn should_fail_payment_for_incorrect_cvc() {}
<file_sep path="hyperswitch/crates/router/tests/connectors/nmi.rs" role="context" start="519" end="572">
async fn should_refund_succeeded_payment_multiple_times() {
let response = CONNECTOR
.make_payment(get_payment_authorize_data(), None)
.await
.unwrap();
assert_eq!(response.status, enums::AttemptStatus::CaptureInitiated);
let transaction_id = utils::get_connector_transaction_id(response.response.to_owned()).unwrap();
let sync_response = CONNECTOR
.psync_retry_till_status_matches(
enums::AttemptStatus::Pending,
Some(types::PaymentsSyncData {
connector_transaction_id: types::ResponseId::ConnectorTransactionId(
transaction_id.clone(),
),
capture_method: Some(enums::CaptureMethod::Automatic),
..Default::default()
}),
None,
)
.await
.unwrap();
assert_eq!(sync_response.status, enums::AttemptStatus::Pending);
//try refund for previous payment
let transaction_id = utils::get_connector_transaction_id(response.response).unwrap();
for _x in 0..2 {
tokio::time::sleep(Duration::from_secs(5)).await; // to avoid 404 error
let refund_response = CONNECTOR
.refund_payment(
transaction_id.clone(),
Some(types::RefundsData {
refund_amount: 50,
..utils::PaymentRefundType::default().0
}),
None,
)
.await
.unwrap();
let sync_response = CONNECTOR
.rsync_retry_till_status_matches(
enums::RefundStatus::Pending,
refund_response.response.unwrap().connector_refund_id,
None,
None,
)
.await
.unwrap();
assert_eq!(
sync_response.response.unwrap().refund_status,
enums::RefundStatus::Pending,
);
}
}
<file_sep path="hyperswitch/crates/router/tests/connectors/nmi.rs" role="context" start="420" end="462">
async fn should_refund_auto_captured_payment() {
let response = CONNECTOR
.make_payment(get_payment_authorize_data(), None)
.await
.unwrap();
assert_eq!(response.status, enums::AttemptStatus::CaptureInitiated);
let transaction_id = utils::get_connector_transaction_id(response.response.to_owned()).unwrap();
let sync_response = CONNECTOR
.psync_retry_till_status_matches(
enums::AttemptStatus::Pending,
Some(types::PaymentsSyncData {
connector_transaction_id: types::ResponseId::ConnectorTransactionId(
transaction_id.clone(),
),
capture_method: Some(enums::CaptureMethod::Automatic),
..Default::default()
}),
None,
)
.await
.unwrap();
assert_eq!(sync_response.status, enums::AttemptStatus::Pending);
let refund_response = CONNECTOR
.refund_payment(transaction_id.clone(), None, None)
.await
.unwrap();
assert_eq!(refund_response.status, enums::AttemptStatus::Pending);
let sync_response = CONNECTOR
.rsync_retry_till_status_matches(
enums::RefundStatus::Pending,
refund_response.response.unwrap().connector_refund_id,
None,
None,
)
.await
.unwrap();
assert_eq!(
sync_response.response.unwrap().refund_status,
enums::RefundStatus::Pending
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/nmi.rs" role="context" start="393" end="416">
async fn should_make_payment() {
let response = CONNECTOR
.make_payment(get_payment_authorize_data(), None)
.await
.unwrap();
assert_eq!(response.status, enums::AttemptStatus::CaptureInitiated);
let transaction_id = utils::get_connector_transaction_id(response.response.to_owned()).unwrap();
let sync_response = CONNECTOR
.psync_retry_till_status_matches(
enums::AttemptStatus::Pending,
Some(types::PaymentsSyncData {
connector_transaction_id: types::ResponseId::ConnectorTransactionId(
transaction_id.clone(),
),
capture_method: Some(enums::CaptureMethod::Automatic),
..Default::default()
}),
None,
)
.await
.unwrap();
assert_eq!(sync_response.status, enums::AttemptStatus::Pending);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/nmi.rs" role="context" start="39" end="48">
fn get_payment_authorize_data() -> Option<types::PaymentsAuthorizeData> {
Some(types::PaymentsAuthorizeData {
payment_method_data: domain::PaymentMethodData::Card(domain::Card {
card_number: cards::CardNumber::from_str("4111111111111111").unwrap(),
..utils::CCardType::default().0
}),
amount: 2023,
..utils::PaymentAuthorizeType::default().0
})
}
<file_sep path="hyperswitch/crates/router/src/connector/dummyconnector/transformers.rs" role="context" start="304" end="309">
pub enum RefundStatus {
Succeeded,
Failed,
#[default]
Processing,
}
<file_sep path="hyperswitch/crates/api_models/src/refunds.rs" role="context" start="378" end="384">
pub enum RefundStatus {
Succeeded,
Failed,
#[default]
Pending,
Review,
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/router/tests/connectors/nmi.rs<|crate|> router<|connector|> nmi anchor=should_partially_capture_authorized_payment kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/router/tests/connectors/nmi.rs" role="context" start="128" end="181">
async fn should_partially_capture_authorized_payment() {
let response = CONNECTOR
.authorize_payment(get_payment_authorize_data(), None)
.await
.unwrap();
assert_eq!(response.status, enums::AttemptStatus::Authorizing);
let transaction_id = utils::get_connector_transaction_id(response.response.to_owned()).unwrap();
let sync_response = CONNECTOR
.psync_retry_till_status_matches(
enums::AttemptStatus::Authorized,
Some(types::PaymentsSyncData {
connector_transaction_id: types::ResponseId::ConnectorTransactionId(
transaction_id.clone(),
),
capture_method: Some(enums::CaptureMethod::Manual),
..Default::default()
}),
None,
)
.await
.unwrap();
assert_eq!(sync_response.status, enums::AttemptStatus::Authorized);
let capture_response = CONNECTOR
.capture_payment(
transaction_id.clone(),
Some(types::PaymentsCaptureData {
amount_to_capture: 1000,
..utils::PaymentCaptureType::default().0
}),
None,
)
.await
.unwrap();
assert_eq!(
capture_response.status,
enums::AttemptStatus::CaptureInitiated
);
let sync_response = CONNECTOR
.psync_retry_till_status_matches(
enums::AttemptStatus::Pending,
Some(types::PaymentsSyncData {
connector_transaction_id: types::ResponseId::ConnectorTransactionId(
transaction_id.clone(),
),
capture_method: Some(enums::CaptureMethod::Manual),
..Default::default()
}),
None,
)
.await
.unwrap();
assert_eq!(sync_response.status, enums::AttemptStatus::Pending);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/nmi.rs" role="context" start="127" end="127">
use router::types::{self, domain, storage::enums};
<file_sep path="hyperswitch/crates/router/tests/connectors/nmi.rs" role="context" start="241" end="306">
async fn should_refund_manually_captured_payment() {
let response = CONNECTOR
.authorize_payment(get_payment_authorize_data(), None)
.await
.unwrap();
assert_eq!(response.status, enums::AttemptStatus::Authorizing);
let transaction_id = utils::get_connector_transaction_id(response.response.to_owned()).unwrap();
let sync_response = CONNECTOR
.psync_retry_till_status_matches(
enums::AttemptStatus::Authorized,
Some(types::PaymentsSyncData {
connector_transaction_id: types::ResponseId::ConnectorTransactionId(
transaction_id.clone(),
),
capture_method: Some(enums::CaptureMethod::Manual),
..Default::default()
}),
None,
)
.await
.unwrap();
assert_eq!(sync_response.status, enums::AttemptStatus::Authorized);
let capture_response = CONNECTOR
.capture_payment(transaction_id.clone(), None, None)
.await
.unwrap();
assert_eq!(
capture_response.status,
enums::AttemptStatus::CaptureInitiated
);
let sync_response = CONNECTOR
.psync_retry_till_status_matches(
enums::AttemptStatus::Pending,
Some(types::PaymentsSyncData {
connector_transaction_id: types::ResponseId::ConnectorTransactionId(
transaction_id.clone(),
),
capture_method: Some(enums::CaptureMethod::Manual),
..Default::default()
}),
None,
)
.await
.unwrap();
assert_eq!(sync_response.status, enums::AttemptStatus::Pending);
let refund_response = CONNECTOR
.refund_payment(transaction_id.clone(), None, None)
.await
.unwrap();
assert_eq!(refund_response.status, enums::AttemptStatus::Pending);
let sync_response = CONNECTOR
.rsync_retry_till_status_matches(
enums::RefundStatus::Pending,
refund_response.response.unwrap().connector_refund_id,
None,
None,
)
.await
.unwrap();
assert_eq!(
sync_response.response.unwrap().refund_status,
enums::RefundStatus::Pending
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/nmi.rs" role="context" start="185" end="237">
async fn should_void_authorized_payment() {
let response = CONNECTOR
.authorize_payment(get_payment_authorize_data(), None)
.await
.unwrap();
assert_eq!(response.status, enums::AttemptStatus::Authorizing);
let transaction_id = utils::get_connector_transaction_id(response.response.to_owned()).unwrap();
let sync_response = CONNECTOR
.psync_retry_till_status_matches(
enums::AttemptStatus::Authorized,
Some(types::PaymentsSyncData {
connector_transaction_id: types::ResponseId::ConnectorTransactionId(
transaction_id.clone(),
),
capture_method: Some(enums::CaptureMethod::Manual),
..Default::default()
}),
None,
)
.await
.unwrap();
assert_eq!(sync_response.status, enums::AttemptStatus::Authorized);
let void_response = CONNECTOR
.void_payment(
transaction_id.clone(),
Some(types::PaymentsCancelData {
connector_transaction_id: String::from(""),
cancellation_reason: Some("user_cancel".to_string()),
..Default::default()
}),
None,
)
.await
.unwrap();
assert_eq!(void_response.status, enums::AttemptStatus::VoidInitiated);
let sync_response = CONNECTOR
.psync_retry_till_status_matches(
enums::AttemptStatus::Voided,
Some(types::PaymentsSyncData {
connector_transaction_id: types::ResponseId::ConnectorTransactionId(
transaction_id.clone(),
),
capture_method: Some(enums::CaptureMethod::Manual),
..Default::default()
}),
None,
)
.await
.unwrap();
assert_eq!(sync_response.status, enums::AttemptStatus::Voided);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/nmi.rs" role="context" start="79" end="124">
async fn should_capture_authorized_payment() {
let response = CONNECTOR
.authorize_payment(get_payment_authorize_data(), None)
.await
.unwrap();
assert_eq!(response.status, enums::AttemptStatus::Authorizing);
let transaction_id = utils::get_connector_transaction_id(response.response.to_owned()).unwrap();
let sync_response = CONNECTOR
.psync_retry_till_status_matches(
enums::AttemptStatus::Authorized,
Some(types::PaymentsSyncData {
connector_transaction_id: types::ResponseId::ConnectorTransactionId(
transaction_id.clone(),
),
capture_method: Some(enums::CaptureMethod::Manual),
..Default::default()
}),
None,
)
.await
.unwrap();
assert_eq!(sync_response.status, enums::AttemptStatus::Authorized);
let capture_response = CONNECTOR
.capture_payment(transaction_id.clone(), None, None)
.await
.unwrap();
assert_eq!(
capture_response.status,
enums::AttemptStatus::CaptureInitiated
);
let sync_response = CONNECTOR
.psync_retry_till_status_matches(
enums::AttemptStatus::Pending,
Some(types::PaymentsSyncData {
connector_transaction_id: types::ResponseId::ConnectorTransactionId(
transaction_id.clone(),
),
capture_method: Some(enums::CaptureMethod::Manual),
..Default::default()
}),
None,
)
.await
.unwrap();
assert_eq!(sync_response.status, enums::AttemptStatus::Pending);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/nmi.rs" role="context" start="53" end="75">
async fn should_only_authorize_payment() {
let response = CONNECTOR
.authorize_payment(get_payment_authorize_data(), None)
.await
.expect("Authorize payment response");
let transaction_id = utils::get_connector_transaction_id(response.response).unwrap();
let sync_response = CONNECTOR
.psync_retry_till_status_matches(
enums::AttemptStatus::Authorized,
Some(types::PaymentsSyncData {
connector_transaction_id: types::ResponseId::ConnectorTransactionId(
transaction_id.clone(),
),
capture_method: Some(enums::CaptureMethod::Manual),
..Default::default()
}),
None,
)
.await
.unwrap();
// Assert the sync response, it will be authorized in case of manual capture, for automatic it will be Completed Success
assert_eq!(sync_response.status, enums::AttemptStatus::Authorized);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/nmi.rs" role="context" start="39" end="48">
fn get_payment_authorize_data() -> Option<types::PaymentsAuthorizeData> {
Some(types::PaymentsAuthorizeData {
payment_method_data: domain::PaymentMethodData::Card(domain::Card {
card_number: cards::CardNumber::from_str("4111111111111111").unwrap(),
..utils::CCardType::default().0
}),
amount: 2023,
..utils::PaymentAuthorizeType::default().0
})
}
<file_sep path="hyperswitch/crates/router/tests/connectors/utils.rs" role="context" start="920" end="920">
pub struct PaymentCaptureType(pub types::PaymentsCaptureData);
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/hyperswitch_connectors/src/connectors/rapyd.rs<|crate|> hyperswitch_connectors<|connector|> rapyd anchor=common_get_content_type kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=1<|meta_end|>
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/rapyd.rs" role="context" start="107" end="109">
fn common_get_content_type(&self) -> &'static str {
"application/json"
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/rapyd.rs" role="context" start="106" end="106">
use hyperswitch_interfaces::{
api::{
self, ConnectorCommon, ConnectorIntegration, ConnectorSpecifications, ConnectorValidation,
},
configs::Connectors,
disputes::DisputePayload,
errors,
events::connector_api_logs::ConnectorEvent,
types::{self, Response},
webhooks::{IncomingWebhook, IncomingWebhookRequestDetails},
};
use crate::{
constants::headers,
types::ResponseRouterData,
utils::{self, convert_amount, get_header_key_value},
};
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/rapyd.rs" role="context" start="115" end="120">
fn get_auth_header(
&self,
_auth_type: &ConnectorAuthType,
) -> CustomResult<Vec<(String, masking::Maskable<String>)>, errors::ConnectorError> {
Ok(vec![])
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/rapyd.rs" role="context" start="111" end="113">
fn base_url<'a>(&self, connectors: &'a Connectors) -> &'a str {
connectors.rapyd.base_url.as_ref()
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/rapyd.rs" role="context" start="103" end="105">
fn get_currency_unit(&self) -> api::CurrencyUnit {
api::CurrencyUnit::Base
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/rapyd.rs" role="context" start="99" end="101">
fn id(&self) -> &'static str {
"rapyd"
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/rapyd.rs" role="context" start="620" end="622">
fn get_content_type(&self) -> &'static str {
ConnectorCommon::common_get_content_type(self)
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/hyperswitch_connectors/src/connectors/rapyd.rs<|crate|> hyperswitch_connectors<|connector|> rapyd anchor=get_webhook_source_verification_algorithm kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=1<|meta_end|>
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/rapyd.rs" role="context" start="733" end="738">
fn get_webhook_source_verification_algorithm(
&self,
_request: &IncomingWebhookRequestDetails<'_>,
) -> CustomResult<Box<dyn crypto::VerifySignature + Send>, errors::ConnectorError> {
Ok(Box::new(crypto::HmacSha256))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/rapyd.rs" role="context" start="732" end="732">
use common_utils::{
consts::BASE64_ENGINE_URL_SAFE,
crypto, date_time,
errors::CustomResult,
ext_traits::{ByteSliceExt, BytesExt, Encode, StringExt},
request::{Method, Request, RequestBuilder, RequestContent},
types::{AmountConvertor, FloatMajorUnit, FloatMajorUnitForConnector},
};
use hyperswitch_interfaces::{
api::{
self, ConnectorCommon, ConnectorIntegration, ConnectorSpecifications, ConnectorValidation,
},
configs::Connectors,
disputes::DisputePayload,
errors,
events::connector_api_logs::ConnectorEvent,
types::{self, Response},
webhooks::{IncomingWebhook, IncomingWebhookRequestDetails},
};
use crate::{
constants::headers,
types::ResponseRouterData,
utils::{self, convert_amount, get_header_key_value},
};
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/rapyd.rs" role="context" start="752" end="784">
fn get_webhook_source_verification_message(
&self,
request: &IncomingWebhookRequestDetails<'_>,
merchant_id: &common_utils::id_type::MerchantId,
connector_webhook_secrets: &api_models::webhooks::ConnectorWebhookSecrets,
) -> CustomResult<Vec<u8>, errors::ConnectorError> {
let host = get_header_key_value("host", request.headers)?;
let connector = self.id();
let url_path = format!(
"https://{host}/webhooks/{}/{connector}",
merchant_id.get_string_repr()
);
let salt = get_header_key_value("salt", request.headers)?;
let timestamp = get_header_key_value("timestamp", request.headers)?;
let stringify_auth = String::from_utf8(connector_webhook_secrets.secret.to_vec())
.change_context(errors::ConnectorError::WebhookSourceVerificationFailed)
.attach_printable("Could not convert secret to UTF-8")?;
let auth: transformers::RapydAuthType = stringify_auth
.parse_struct("RapydAuthType")
.change_context(errors::ConnectorError::WebhookSourceVerificationFailed)?;
let access_key = auth.access_key;
let secret_key = auth.secret_key;
let body_string = String::from_utf8(request.body.to_vec())
.change_context(errors::ConnectorError::WebhookSourceVerificationFailed)
.attach_printable("Could not convert body to UTF-8")?;
let to_sign = format!(
"{url_path}{salt}{timestamp}{}{}{body_string}",
access_key.peek(),
secret_key.peek()
);
Ok(to_sign.into_bytes())
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/rapyd.rs" role="context" start="740" end="750">
fn get_webhook_source_verification_signature(
&self,
request: &IncomingWebhookRequestDetails<'_>,
_connector_webhook_secrets: &api_models::webhooks::ConnectorWebhookSecrets,
) -> CustomResult<Vec<u8>, errors::ConnectorError> {
let base64_signature = get_header_key_value("signature", request.headers)?;
let signature = BASE64_ENGINE_URL_SAFE
.decode(base64_signature.as_bytes())
.change_context(errors::ConnectorError::WebhookSourceVerificationFailed)?;
Ok(signature)
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/rapyd.rs" role="context" start="710" end="728">
fn handle_response(
&self,
data: &RefundSyncRouterData,
event_builder: Option<&mut ConnectorEvent>,
res: Response,
) -> CustomResult<RefundSyncRouterData, errors::ConnectorError> {
let response: rapyd::RefundResponse = res
.response
.parse_struct("rapyd RefundResponse")
.change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
event_builder.map(|i| i.set_response_body(&response));
router_env::logger::info!(connector_response=?response);
RouterData::try_from(ResponseRouterData {
response,
data: data.clone(),
http_code: res.status_code,
})
.change_context(errors::ConnectorError::ResponseHandlingFailed)
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/rapyd.rs" role="context" start="699" end="705">
fn get_error_response(
&self,
res: Response,
event_builder: Option<&mut ConnectorEvent>,
) -> CustomResult<ErrorResponse, errors::ConnectorError> {
self.build_error_response(res, event_builder)
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/rapyd.rs" role="context" start="65" end="69">
pub fn new() -> &'static Self {
&Self {
amount_converter: &FloatMajorUnitForConnector,
}
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/router/tests/connectors/payeezy.rs<|crate|> router<|connector|> payeezy anchor=should_refund_manually_captured_payment kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/router/tests/connectors/payeezy.rs" role="context" start="174" end="214">
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,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/payeezy.rs" role="context" start="173" end="173">
use router::{
core::errors,
types::{self, storage::enums, PaymentsAuthorizeData},
};
<file_sep path="hyperswitch/crates/router/tests/connectors/payeezy.rs" role="context" start="264" end="264">
async fn should_sync_manually_captured_refund() {}
<file_sep path="hyperswitch/crates/router/tests/connectors/payeezy.rs" role="context" start="218" end="259">
async fn should_partially_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 {
refund_amount: 50,
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,
);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/payeezy.rs" role="context" start="142" end="170">
async fn should_void_authorized_payment() {
let response = CONNECTOR
.authorize_payment(PayeezyTest::get_payment_data(), None)
.await
.unwrap();
assert_eq!(response.status, enums::AttemptStatus::Authorized);
let connector_payment_id =
utils::get_connector_transaction_id(response.response.clone()).unwrap_or_default();
let connector_meta = utils::get_connector_metadata(response.response);
tokio::time::sleep(std::time::Duration::from_secs(
CONNECTOR.get_request_interval(),
))
.await; // to avoid 404 error
let response = CONNECTOR
.void_payment(
connector_payment_id,
Some(types::PaymentsCancelData {
connector_meta,
amount: Some(100),
currency: Some(diesel_models::enums::Currency::USD),
..utils::PaymentCancelType::default().0
}),
None,
)
.await
.unwrap();
assert_eq!(response.status, enums::AttemptStatus::Voided);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/payeezy.rs" role="context" start="138" end="138">
async fn should_sync_authorized_payment() {}
<file_sep path="hyperswitch/crates/router/tests/connectors/payeezy.rs" role="context" start="57" end="73">
fn get_payment_info() -> Option<PaymentInfo> {
Some(PaymentInfo {
address: Some(types::PaymentAddress::new(
None,
Some(Address {
address: Some(AddressDetails {
..Default::default()
}),
phone: None,
email: None,
}),
None,
None,
)),
..Default::default()
})
}
<file_sep path="hyperswitch/crates/router/tests/connectors/payeezy.rs" role="context" start="47" end="55">
fn get_payment_data() -> Option<PaymentsAuthorizeData> {
Some(PaymentsAuthorizeData {
payment_method_data: types::domain::PaymentMethodData::Card(types::domain::Card {
card_number: CardNumber::from_str("4012000033330026").unwrap(),
..utils::CCardType::default().0
}),
..utils::PaymentAuthorizeType::default().0
})
}
<file_sep path="hyperswitch/crates/router/tests/connectors/payeezy.rs" role="context" start="17" end="17">
struct PayeezyTest;
<file_sep path="hyperswitch/crates/router/src/connector/dummyconnector/transformers.rs" role="context" start="304" end="309">
pub enum RefundStatus {
Succeeded,
Failed,
#[default]
Processing,
}
<file_sep path="hyperswitch/migrations/2023-07-07-091223_create_captures_table/up.sql" role="context" start="1" end="17">
CREATE TYPE "CaptureStatus" AS ENUM (
'started',
'charged',
'pending',
'failed'
);
ALTER TYPE "IntentStatus" ADD VALUE If NOT EXISTS 'partially_captured' AFTER 'requires_capture';
CREATE TABLE captures(
capture_id VARCHAR(64) NOT NULL PRIMARY KEY,
payment_id VARCHAR(64) NOT NULL,
merchant_id VARCHAR(64) NOT NULL,
status "CaptureStatus" NOT NULL,
amount BIGINT NOT NULL,
currency "Currency",
connector VARCHAR(255),
error_message VARCHAR(255),
<file_sep path="hyperswitch/crates/api_models/src/refunds.rs" role="context" start="378" end="384">
pub enum RefundStatus {
Succeeded,
Failed,
#[default]
Pending,
Review,
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/hyperswitch_connectors/src/connectors/payeezy/transformers.rs<|crate|> hyperswitch_connectors<|connector|> payeezy anchor=construct_payeezy_payments_metadata kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=1<|meta_end|>
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/payeezy/transformers.rs" role="context" start="579" end="581">
fn construct_payeezy_payments_metadata(transaction_tag: String) -> PayeezyPaymentsMetadata {
PayeezyPaymentsMetadata { transaction_tag }
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/payeezy/transformers.rs" role="context" start="548" end="558">
fn try_from(
item: RefundsResponseRouterData<Execute, RefundResponse>,
) -> Result<Self, Self::Error> {
Ok(Self {
response: Ok(RefundsResponseData {
connector_refund_id: item.response.transaction_id,
refund_status: enums::RefundStatus::from(item.response.transaction_status),
}),
..item.data
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/payeezy/transformers.rs" role="context" start="520" end="526">
fn from(item: RefundStatus) -> Self {
match item {
RefundStatus::Approved => Self::Success,
RefundStatus::Declined => Self::Failure,
RefundStatus::NotProcessed => Self::Pending,
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/payeezy/transformers.rs" role="context" start="409" end="454">
fn try_from(
item: ResponseRouterData<F, PayeezyPaymentsResponse, T, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
let metadata = item
.response
.transaction_tag
.map(|txn_tag| construct_payeezy_payments_metadata(txn_tag).encode_to_value())
.transpose()
.change_context(ConnectorError::ResponseHandlingFailed)?;
let mandate_reference = item
.response
.stored_credentials
.map(|credentials| credentials.cardbrand_original_transaction_id)
.map(|id| MandateReference {
connector_mandate_id: Some(id.expose()),
payment_method_id: None,
mandate_metadata: None,
connector_mandate_request_reference_id: None,
});
let status = get_status(
item.response.transaction_status,
item.response.transaction_type,
);
Ok(Self {
status,
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(
item.response.transaction_id.clone(),
),
redirection_data: Box::new(None),
mandate_reference: Box::new(mandate_reference),
connector_metadata: metadata,
network_txn_id: None,
connector_response_reference_id: Some(
item.response
.reference
.unwrap_or(item.response.transaction_id),
),
incremental_authorization_allowed: None,
charges: None,
}),
..item.data
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/payeezy/transformers.rs" role="context" start="401" end="403">
pub struct PayeezyPaymentsMetadata {
transaction_tag: String,
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/hyperswitch_connectors/src/connectors/cryptopay.rs<|crate|> hyperswitch_connectors<|connector|> cryptopay anchor=get_webhook_source_verification_algorithm kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=1<|meta_end|>
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/cryptopay.rs" role="context" start="421" end="426">
fn get_webhook_source_verification_algorithm(
&self,
_request: &webhooks::IncomingWebhookRequestDetails<'_>,
) -> CustomResult<Box<dyn crypto::VerifySignature + Send>, errors::ConnectorError> {
Ok(Box::new(crypto::HmacSha256))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/cryptopay.rs" role="context" start="420" end="420">
use common_utils::{
crypto::{self, GenerateDigest, SignMessage},
date_time,
errors::CustomResult,
ext_traits::ByteSliceExt,
request::{Method, Request, RequestBuilder, RequestContent},
types::{AmountConvertor, StringMajorUnit, StringMajorUnitForConnector},
};
use hyperswitch_interfaces::{
api::{
self, ConnectorCommon, ConnectorCommonExt, ConnectorIntegration, ConnectorSpecifications,
ConnectorValidation,
},
configs::Connectors,
errors,
events::connector_api_logs::ConnectorEvent,
types::{PaymentsAuthorizeType, PaymentsSyncType, Response},
webhooks,
};
use crate::{
constants::headers,
types::ResponseRouterData,
utils::{self, ForeignTryFrom},
};
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/cryptopay.rs" role="context" start="439" end="448">
fn get_webhook_source_verification_message(
&self,
request: &webhooks::IncomingWebhookRequestDetails<'_>,
_merchant_id: &common_utils::id_type::MerchantId,
_connector_webhook_secrets: &api_models::webhooks::ConnectorWebhookSecrets,
) -> CustomResult<Vec<u8>, errors::ConnectorError> {
let message = std::str::from_utf8(request.body)
.change_context(errors::ConnectorError::WebhookSourceVerificationFailed)?;
Ok(message.to_string().into_bytes())
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/cryptopay.rs" role="context" start="428" end="437">
fn get_webhook_source_verification_signature(
&self,
request: &webhooks::IncomingWebhookRequestDetails<'_>,
_connector_webhook_secrets: &api_models::webhooks::ConnectorWebhookSecrets,
) -> CustomResult<Vec<u8>, errors::ConnectorError> {
let base64_signature =
utils::get_header_key_value("X-Cryptopay-Signature", request.headers)?;
hex::decode(base64_signature)
.change_context(errors::ConnectorError::WebhookSourceVerificationFailed)
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/cryptopay.rs" role="context" start="402" end="408">
fn get_error_response(
&self,
res: Response,
event_builder: Option<&mut ConnectorEvent>,
) -> CustomResult<ErrorResponse, errors::ConnectorError> {
self.build_error_response(res, event_builder)
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/cryptopay.rs" role="context" start="372" end="400">
fn handle_response(
&self,
data: &PaymentsSyncRouterData,
event_builder: Option<&mut ConnectorEvent>,
res: Response,
) -> CustomResult<PaymentsSyncRouterData, errors::ConnectorError> {
let response: cryptopay::CryptopayPaymentsResponse = res
.response
.parse_struct("cryptopay PaymentsSyncResponse")
.change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
event_builder.map(|i| i.set_response_body(&response));
router_env::logger::info!(connector_response=?response);
let capture_amount_in_minor_units = match response.data.price_amount {
Some(ref amount) => Some(utils::convert_back_amount_to_minor_units(
self.amount_converter,
amount.clone(),
data.request.currency,
)?),
None => None,
};
RouterData::foreign_try_from((
ResponseRouterData {
response,
data: data.clone(),
http_code: res.status_code,
},
capture_amount_in_minor_units,
))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/cryptopay.rs" role="context" start="56" end="60">
pub fn new() -> &'static Self {
&Self {
amount_converter: &StringMajorUnitForConnector,
}
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/hyperswitch_connectors/src/connectors/cryptopay.rs<|crate|> hyperswitch_connectors<|connector|> cryptopay anchor=get_webhook_resource_object kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/cryptopay.rs" role="context" start="492" end="503">
fn get_webhook_resource_object(
&self,
request: &webhooks::IncomingWebhookRequestDetails<'_>,
) -> CustomResult<Box<dyn masking::ErasedMaskSerialize>, errors::ConnectorError> {
let notif: CryptopayWebhookDetails =
request
.body
.parse_struct("CryptopayWebhookDetails")
.change_context(errors::ConnectorError::WebhookBodyDecodingFailed)?;
Ok(Box::new(notif))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/cryptopay.rs" role="context" start="491" end="491">
use common_utils::{
crypto::{self, GenerateDigest, SignMessage},
date_time,
errors::CustomResult,
ext_traits::ByteSliceExt,
request::{Method, Request, RequestBuilder, RequestContent},
types::{AmountConvertor, StringMajorUnit, StringMajorUnitForConnector},
};
use hyperswitch_interfaces::{
api::{
self, ConnectorCommon, ConnectorCommonExt, ConnectorIntegration, ConnectorSpecifications,
ConnectorValidation,
},
configs::Connectors,
errors,
events::connector_api_logs::ConnectorEvent,
types::{PaymentsAuthorizeType, PaymentsSyncType, Response},
webhooks,
};
use masking::{Mask, PeekInterface};
use self::cryptopay::CryptopayWebhookDetails;
use crate::{
constants::headers,
types::ResponseRouterData,
utils::{self, ForeignTryFrom},
};
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/cryptopay.rs" role="context" start="469" end="490">
fn get_webhook_event_type(
&self,
request: &webhooks::IncomingWebhookRequestDetails<'_>,
) -> CustomResult<api_models::webhooks::IncomingWebhookEvent, errors::ConnectorError> {
let notif: CryptopayWebhookDetails =
request
.body
.parse_struct("CryptopayWebhookDetails")
.change_context(errors::ConnectorError::WebhookEventTypeNotFound)?;
match notif.data.status {
cryptopay::CryptopayPaymentStatus::Completed => {
Ok(api_models::webhooks::IncomingWebhookEvent::PaymentIntentSuccess)
}
cryptopay::CryptopayPaymentStatus::Unresolved => {
Ok(api_models::webhooks::IncomingWebhookEvent::PaymentActionRequired)
}
cryptopay::CryptopayPaymentStatus::Cancelled => {
Ok(api_models::webhooks::IncomingWebhookEvent::PaymentIntentFailure)
}
_ => Ok(api_models::webhooks::IncomingWebhookEvent::EventNotSupported),
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/cryptopay.rs" role="context" start="450" end="467">
fn get_webhook_object_reference_id(
&self,
request: &webhooks::IncomingWebhookRequestDetails<'_>,
) -> CustomResult<api_models::webhooks::ObjectReferenceId, errors::ConnectorError> {
let notif: CryptopayWebhookDetails =
request
.body
.parse_struct("CryptopayWebhookDetails")
.change_context(errors::ConnectorError::WebhookReferenceIdNotFound)?;
match notif.data.custom_id {
Some(custom_id) => Ok(api_models::webhooks::ObjectReferenceId::PaymentId(
api_models::payments::PaymentIdType::PaymentAttemptId(custom_id),
)),
None => Ok(api_models::webhooks::ObjectReferenceId::PaymentId(
api_models::payments::PaymentIdType::ConnectorTransactionId(notif.data.id),
)),
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/cryptopay.rs" role="context" start="56" end="60">
pub fn new() -> &'static Self {
&Self {
amount_converter: &StringMajorUnitForConnector,
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/cryptopay/transformers.rs" role="context" start="262" end="267">
pub struct CryptopayWebhookDetails {
#[serde(rename = "type")]
pub service_type: String,
pub event: WebhookEvent,
pub data: CryptopayPaymentResponseData,
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/hyperswitch_connectors/src/connectors/cryptopay/transformers.rs<|crate|> hyperswitch_connectors<|connector|> cryptopay anchor=from kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=1<|meta_end|>
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/cryptopay/transformers.rs" role="context" start="132" end="141">
fn from(item: CryptopayPaymentStatus) -> Self {
match item {
CryptopayPaymentStatus::New => Self::AuthenticationPending,
CryptopayPaymentStatus::Completed => Self::Charged,
CryptopayPaymentStatus::Cancelled => Self::Failure,
CryptopayPaymentStatus::Unresolved | CryptopayPaymentStatus::Refunded => {
Self::Unresolved
} //mapped refunded to Unresolved because refund api is not available, also merchant has done the action on the connector dashboard.
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/cryptopay/transformers.rs" role="context" start="156" end="220">
fn foreign_try_from(
(item, amount_captured_in_minor_units): (
ResponseRouterData<F, CryptopayPaymentsResponse, T, PaymentsResponseData>,
Option<MinorUnit>,
),
) -> Result<Self, Self::Error> {
let status = enums::AttemptStatus::from(item.response.data.status.clone());
let response = if utils::is_payment_failure(status) {
let payment_response = &item.response.data;
Err(ErrorResponse {
code: payment_response
.name
.clone()
.unwrap_or(consts::NO_ERROR_CODE.to_string()),
message: payment_response
.status_context
.clone()
.unwrap_or(consts::NO_ERROR_MESSAGE.to_string()),
reason: payment_response.status_context.clone(),
status_code: item.http_code,
attempt_status: None,
connector_transaction_id: Some(payment_response.id.clone()),
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
})
} else {
let redirection_data = item
.response
.data
.hosted_page_url
.map(|x| RedirectForm::from((x, common_utils::request::Method::Get)));
Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(item.response.data.id.clone()),
redirection_data: Box::new(redirection_data),
mandate_reference: Box::new(None),
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: item
.response
.data
.custom_id
.or(Some(item.response.data.id)),
incremental_authorization_allowed: None,
charges: None,
})
};
match amount_captured_in_minor_units {
Some(minor_amount) => {
let amount_captured = Some(minor_amount.get_amount_as_i64());
Ok(Self {
status,
response,
amount_captured,
minor_amount_captured: amount_captured_in_minor_units,
..item.data
})
}
None => Ok(Self {
status,
response,
..item.data
}),
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/cryptopay/transformers.rs" role="context" start="109" end="118">
fn try_from(auth_type: &ConnectorAuthType) -> Result<Self, Self::Error> {
if let ConnectorAuthType::BodyKey { api_key, key1 } = auth_type {
Ok(Self {
api_key: api_key.to_owned(),
api_secret: key1.to_owned(),
})
} else {
Err(errors::ConnectorError::FailedToObtainAuthType.into())
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/cryptopay/transformers.rs" role="context" start="56" end="98">
fn try_from(
item: &CryptopayRouterData<&types::PaymentsAuthorizeRouterData>,
) -> Result<Self, Self::Error> {
let cryptopay_request = match item.router_data.request.payment_method_data {
PaymentMethodData::Crypto(ref cryptodata) => {
let pay_currency = cryptodata.get_pay_currency()?;
Ok(Self {
price_amount: item.amount.clone(),
price_currency: item.router_data.request.currency,
pay_currency,
network: cryptodata.network.to_owned(),
success_redirect_url: item.router_data.request.router_return_url.clone(),
unsuccess_redirect_url: item.router_data.request.router_return_url.clone(),
//Cryptopay only accepts metadata as Object. If any other type, payment will fail with error.
metadata: item.router_data.request.get_metadata_as_object(),
custom_id: item.router_data.connector_request_reference_id.clone(),
})
}
PaymentMethodData::Card(_)
| PaymentMethodData::CardRedirect(_)
| PaymentMethodData::Wallet(_)
| PaymentMethodData::PayLater(_)
| PaymentMethodData::BankRedirect(_)
| PaymentMethodData::BankDebit(_)
| PaymentMethodData::BankTransfer(_)
| PaymentMethodData::MandatePayment
| PaymentMethodData::Reward
| PaymentMethodData::RealTimePayment(_)
| PaymentMethodData::Upi(_)
| PaymentMethodData::MobilePayment(_)
| PaymentMethodData::Voucher(_)
| PaymentMethodData::GiftCard(_)
| PaymentMethodData::OpenBanking(_)
| PaymentMethodData::CardToken(_)
| PaymentMethodData::NetworkToken(_)
| PaymentMethodData::CardDetailsForNetworkTransactionId(_) => {
Err(errors::ConnectorError::NotImplemented(
utils::get_unimplemented_payment_method_error_message("CryptoPay"),
))
}
}?;
Ok(cryptopay_request)
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/cryptopay/transformers.rs" role="context" start="123" end="129">
pub enum CryptopayPaymentStatus {
New,
Completed,
Unresolved,
Refunded,
Cancelled,
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/hyperswitch_connectors/src/connectors/cryptopay/transformers.rs<|crate|> hyperswitch_connectors<|connector|> cryptopay anchor=foreign_try_from kind=fn pack=symbol_neighborhood lang=rust role_window=k2 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/cryptopay/transformers.rs" role="context" start="156" end="220">
fn foreign_try_from(
(item, amount_captured_in_minor_units): (
ResponseRouterData<F, CryptopayPaymentsResponse, T, PaymentsResponseData>,
Option<MinorUnit>,
),
) -> Result<Self, Self::Error> {
let status = enums::AttemptStatus::from(item.response.data.status.clone());
let response = if utils::is_payment_failure(status) {
let payment_response = &item.response.data;
Err(ErrorResponse {
code: payment_response
.name
.clone()
.unwrap_or(consts::NO_ERROR_CODE.to_string()),
message: payment_response
.status_context
.clone()
.unwrap_or(consts::NO_ERROR_MESSAGE.to_string()),
reason: payment_response.status_context.clone(),
status_code: item.http_code,
attempt_status: None,
connector_transaction_id: Some(payment_response.id.clone()),
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
})
} else {
let redirection_data = item
.response
.data
.hosted_page_url
.map(|x| RedirectForm::from((x, common_utils::request::Method::Get)));
Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(item.response.data.id.clone()),
redirection_data: Box::new(redirection_data),
mandate_reference: Box::new(None),
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: item
.response
.data
.custom_id
.or(Some(item.response.data.id)),
incremental_authorization_allowed: None,
charges: None,
})
};
match amount_captured_in_minor_units {
Some(minor_amount) => {
let amount_captured = Some(minor_amount.get_amount_as_i64());
Ok(Self {
status,
response,
amount_captured,
minor_amount_captured: amount_captured_in_minor_units,
..item.data
})
}
None => Ok(Self {
status,
response,
..item.data
}),
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/cryptopay/transformers.rs" role="context" start="155" end="155">
use common_enums::enums;
use common_utils::{
pii,
types::{MinorUnit, StringMajorUnit},
};
use hyperswitch_domain_models::{
payment_method_data::PaymentMethodData,
router_data::{ConnectorAuthType, ErrorResponse, RouterData},
router_request_types::ResponseId,
router_response_types::{PaymentsResponseData, RedirectForm},
types,
};
use crate::{
types::ResponseRouterData,
utils::{self, CryptoData, ForeignTryFrom, PaymentsAuthorizeRequestData},
};
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/cryptopay/transformers.rs" role="context" start="132" end="141">
fn from(item: CryptopayPaymentStatus) -> Self {
match item {
CryptopayPaymentStatus::New => Self::AuthenticationPending,
CryptopayPaymentStatus::Completed => Self::Charged,
CryptopayPaymentStatus::Cancelled => Self::Failure,
CryptopayPaymentStatus::Unresolved | CryptopayPaymentStatus::Refunded => {
Self::Unresolved
} //mapped refunded to Unresolved because refund api is not available, also merchant has done the action on the connector dashboard.
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/cryptopay/transformers.rs" role="context" start="109" end="118">
fn try_from(auth_type: &ConnectorAuthType) -> Result<Self, Self::Error> {
if let ConnectorAuthType::BodyKey { api_key, key1 } = auth_type {
Ok(Self {
api_key: api_key.to_owned(),
api_secret: key1.to_owned(),
})
} else {
Err(errors::ConnectorError::FailedToObtainAuthType.into())
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/cryptopay/transformers.rs" role="context" start="55" end="55">
type Error = error_stack::Report<errors::ConnectorError>;
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/cryptopay/transformers.rs" role="context" start="145" end="147">
pub struct CryptopayPaymentsResponse {
pub data: CryptopayPaymentResponseData,
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/aci/transformers.rs" role="context" start="642" end="642">
type Err = error_stack::Report<errors::ConnectorError>;
<file_sep path="hyperswitch/crates/api_models/src/payment_methods.rs" role="context" start="2478" end="2478">
type Error = error_stack::Report<errors::ValidationError>;
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/hyperswitch_connectors/src/connectors/coinbase/transformers.rs<|crate|> hyperswitch_connectors<|connector|> coinbase anchor=try_from kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/coinbase/transformers.rs" role="context" start="48" end="50">
fn try_from(item: &types::PaymentsAuthorizeRouterData) -> Result<Self, Self::Error> {
get_crypto_specific_payment_data(item)
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/coinbase/transformers.rs" role="context" start="47" end="47">
use hyperswitch_domain_models::{
router_data::{ConnectorAuthType, RouterData},
router_flow_types::refunds::{Execute, RSync},
router_request_types::ResponseId,
router_response_types::{PaymentsResponseData, RedirectForm},
types,
};
use crate::{
types::{RefundsResponseRouterData, ResponseRouterData},
utils::{
self, AddressDetailsData, PaymentsAuthorizeRequestData, RouterData as OtherRouterData,
},
};
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/coinbase/transformers.rs" role="context" start="88" end="97">
fn from(item: CoinbasePaymentStatus) -> Self {
match item {
CoinbasePaymentStatus::Completed | CoinbasePaymentStatus::Resolved => Self::Charged,
CoinbasePaymentStatus::Expired => Self::Failure,
CoinbasePaymentStatus::New => Self::AuthenticationPending,
CoinbasePaymentStatus::Unresolved => Self::Unresolved,
CoinbasePaymentStatus::Canceled => Self::Voided,
_ => Self::Pending,
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/coinbase/transformers.rs" role="context" start="60" end="68">
fn try_from(_auth_type: &ConnectorAuthType) -> Result<Self, Self::Error> {
if let ConnectorAuthType::HeaderKey { api_key } = _auth_type {
Ok(Self {
api_key: api_key.to_owned(),
})
} else {
Err(errors::ConnectorError::FailedToObtainAuthType.into())
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/coinbase/transformers.rs" role="context" start="265" end="292">
fn get_crypto_specific_payment_data(
item: &types::PaymentsAuthorizeRouterData,
) -> Result<CoinbasePaymentsRequest, error_stack::Report<errors::ConnectorError>> {
let billing_address = item
.get_billing()
.ok()
.and_then(|billing_address| billing_address.address.as_ref());
let name =
billing_address.and_then(|add| add.get_first_name().ok().map(|name| name.to_owned()));
let description = item.get_description().ok();
let connector_meta = CoinbaseConnectorMeta::try_from(&item.connector_meta_data)
.change_context(errors::ConnectorError::InvalidConnectorConfig {
config: "Merchant connector account metadata",
})?;
let pricing_type = connector_meta.pricing_type;
let local_price = get_local_price(item);
let redirect_url = item.request.get_router_return_url()?;
let cancel_url = item.request.get_router_return_url()?;
Ok(CoinbasePaymentsRequest {
name,
description,
pricing_type,
local_price,
redirect_url,
cancel_url,
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/coinbase/transformers.rs" role="context" start="47" end="47">
type Error = error_stack::Report<errors::ConnectorError>;
<file_sep path="hyperswitch/crates/api_models/src/payment_methods.rs" role="context" start="2478" end="2478">
type Error = error_stack::Report<errors::ValidationError>;
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/hyperswitch_connectors/src/connectors/coinbase/transformers.rs<|crate|> hyperswitch_connectors<|connector|> coinbase anchor=get_local_price kind=fn pack=symbol_neighborhood lang=rust role_window=k2 hops=1<|meta_end|>
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/coinbase/transformers.rs" role="context" start="294" end="299">
fn get_local_price(item: &types::PaymentsAuthorizeRouterData) -> LocalPrice {
LocalPrice {
amount: format!("{:?}", item.request.amount),
currency: item.request.currency.to_string(),
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/coinbase/transformers.rs" role="context" start="293" end="293">
use hyperswitch_domain_models::{
router_data::{ConnectorAuthType, RouterData},
router_flow_types::refunds::{Execute, RSync},
router_request_types::ResponseId,
router_response_types::{PaymentsResponseData, RedirectForm},
types,
};
use crate::{
types::{RefundsResponseRouterData, ResponseRouterData},
utils::{
self, AddressDetailsData, PaymentsAuthorizeRequestData, RouterData as OtherRouterData,
},
};
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/coinbase/transformers.rs" role="context" start="265" end="292">
fn get_crypto_specific_payment_data(
item: &types::PaymentsAuthorizeRouterData,
) -> Result<CoinbasePaymentsRequest, error_stack::Report<errors::ConnectorError>> {
let billing_address = item
.get_billing()
.ok()
.and_then(|billing_address| billing_address.address.as_ref());
let name =
billing_address.and_then(|add| add.get_first_name().ok().map(|name| name.to_owned()));
let description = item.get_description().ok();
let connector_meta = CoinbaseConnectorMeta::try_from(&item.connector_meta_data)
.change_context(errors::ConnectorError::InvalidConnectorConfig {
config: "Merchant connector account metadata",
})?;
let pricing_type = connector_meta.pricing_type;
let local_price = get_local_price(item);
let redirect_url = item.request.get_router_return_url()?;
let cancel_url = item.request.get_router_return_url()?;
Ok(CoinbasePaymentsRequest {
name,
description,
pricing_type,
local_price,
redirect_url,
cancel_url,
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/coinbase/transformers.rs" role="context" start="259" end="262">
fn try_from(meta_data: &Option<pii::SecretSerdeValue>) -> Result<Self, Self::Error> {
utils::to_connector_meta_from_secret(meta_data.clone())
.change_context(errors::ConnectorError::InvalidConnectorConfig { config: "metadata" })
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/coinbase/transformers.rs" role="context" start="25" end="28">
pub struct LocalPrice {
pub amount: String,
pub currency: String,
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/hyperswitch_connectors/src/connectors/coinbase/transformers.rs<|crate|> hyperswitch_connectors<|connector|> coinbase anchor=from kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/coinbase/transformers.rs" role="context" start="201" end="207">
fn from(item: RefundStatus) -> Self {
match item {
RefundStatus::Succeeded => Self::Success,
RefundStatus::Failed => Self::Failure,
RefundStatus::Processing => Self::Pending,
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/coinbase/transformers.rs" role="context" start="229" end="236">
fn try_from(
_item: RefundsResponseRouterData<RSync, RefundResponse>,
) -> Result<Self, Self::Error> {
Err(errors::ConnectorError::NotImplemented(
"try_from RefundsResponseRouterData".to_string(),
)
.into())
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/coinbase/transformers.rs" role="context" start="217" end="224">
fn try_from(
_item: RefundsResponseRouterData<Execute, RefundResponse>,
) -> Result<Self, Self::Error> {
Err(errors::ConnectorError::NotImplemented(
"try_from RefundsResponseRouterData".to_string(),
)
.into())
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/coinbase/transformers.rs" role="context" start="184" end="186">
fn try_from(_item: &types::RefundsRouterData<F>) -> Result<Self, Self::Error> {
Err(errors::ConnectorError::NotImplemented("try_from RefundsRouterData".to_string()).into())
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/coinbase/transformers.rs" role="context" start="128" end="174">
fn try_from(
item: ResponseRouterData<F, CoinbasePaymentsResponse, T, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
let form_fields = HashMap::new();
let redirection_data = RedirectForm::Form {
endpoint: item.response.data.hosted_url.to_string(),
method: Method::Get,
form_fields,
};
let timeline = item
.response
.data
.timeline
.last()
.ok_or(errors::ConnectorError::ResponseHandlingFailed)?
.clone();
let connector_id = ResponseId::ConnectorTransactionId(item.response.data.id.clone());
let attempt_status = timeline.status.clone();
let response_data = timeline.context.map_or(
Ok(PaymentsResponseData::TransactionResponse {
resource_id: connector_id.clone(),
redirection_data: Box::new(Some(redirection_data)),
mandate_reference: Box::new(None),
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: Some(item.response.data.id.clone()),
incremental_authorization_allowed: None,
charges: None,
}),
|context| {
Ok(PaymentsResponseData::TransactionUnresolvedResponse{
resource_id: connector_id,
reason: Some(api_models::enums::UnresolvedResponseReason {
code: context.to_string(),
message: "Please check the transaction in coinbase dashboard and resolve manually"
.to_string(),
}),
connector_response_reference_id: Some(item.response.data.id),
})
},
);
Ok(Self {
status: enums::AttemptStatus::from(attempt_status),
response: response_data,
..item.data
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/coinbase/transformers.rs" role="context" start="193" end="198">
pub enum RefundStatus {
Succeeded,
Failed,
#[default]
Processing,
}
<file_sep path="hyperswitch/crates/api_models/src/refunds.rs" role="context" start="378" end="384">
pub enum RefundStatus {
Succeeded,
Failed,
#[default]
Pending,
Review,
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/hyperswitch_connectors/src/connectors/coinbase.rs<|crate|> hyperswitch_connectors<|connector|> coinbase anchor=get_request_body kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/coinbase.rs" role="context" start="195" end="202">
fn get_request_body(
&self,
req: &PaymentsAuthorizeRouterData,
_connectors: &Connectors,
) -> CustomResult<RequestContent, errors::ConnectorError> {
let connector_req = coinbase::CoinbasePaymentsRequest::try_from(req)?;
Ok(RequestContent::Json(Box::new(connector_req)))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/coinbase.rs" role="context" start="194" end="194">
fn get_content_type(&self) -> &'static str {
self.common_get_content_type()
}
fn get_url(
&self,
_req: &PaymentsAuthorizeRouterData,
_connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
Ok(format!("{}/charges", self.base_url(_connectors)))
}
fn get_request_body(
&self,
req: &PaymentsAuthorizeRouterData,
_connectors: &Connectors,
) -> CustomResult<RequestContent, errors::ConnectorError> {
let connector_req = coinbase::CoinbasePaymentsRequest::try_from(req)?;
Ok(RequestContent::Json(Box::new(connector_req)))
}
fn build_request(
&self,
req: &PaymentsAuthorizeRouterData,
connectors: &Connectors,
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/coinbase.rs" role="context" start="221" end="239">
fn handle_response(
&self,
data: &PaymentsAuthorizeRouterData,
event_builder: Option<&mut ConnectorEvent>,
res: Response,
) -> CustomResult<PaymentsAuthorizeRouterData, errors::ConnectorError> {
let response: coinbase::CoinbasePaymentsResponse = res
.response
.parse_struct("Coinbase PaymentsAuthorizeResponse")
.change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
event_builder.map(|i| i.set_response_body(&response));
router_env::logger::info!(connector_response=?response);
RouterData::try_from(ResponseRouterData {
response,
data: data.clone(),
http_code: res.status_code,
})
.change_context(errors::ConnectorError::ResponseHandlingFailed)
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/coinbase.rs" role="context" start="204" end="219">
fn build_request(
&self,
req: &PaymentsAuthorizeRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Ok(Some(
RequestBuilder::new()
.method(Method::Post)
.url(&PaymentsAuthorizeType::get_url(self, req, connectors)?)
.headers(PaymentsAuthorizeType::get_headers(self, req, connectors)?)
.set_body(PaymentsAuthorizeType::get_request_body(
self, req, connectors,
)?)
.build(),
))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/coinbase.rs" role="context" start="187" end="193">
fn get_url(
&self,
_req: &PaymentsAuthorizeRouterData,
_connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
Ok(format!("{}/charges", self.base_url(_connectors)))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/coinbase.rs" role="context" start="183" end="185">
fn get_content_type(&self) -> &'static str {
self.common_get_content_type()
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/coinbase/transformers.rs" role="context" start="37" end="44">
pub struct CoinbasePaymentsRequest {
pub name: Option<Secret<String>>,
pub description: Option<String>,
pub pricing_type: String,
pub local_price: LocalPrice,
pub redirect_url: String,
pub cancel_url: String,
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/hyperswitch_connectors/src/connectors/coinbase/transformers.rs<|crate|> hyperswitch_connectors<|connector|> coinbase anchor=try_from kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/coinbase/transformers.rs" role="context" start="128" end="174">
fn try_from(
item: ResponseRouterData<F, CoinbasePaymentsResponse, T, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
let form_fields = HashMap::new();
let redirection_data = RedirectForm::Form {
endpoint: item.response.data.hosted_url.to_string(),
method: Method::Get,
form_fields,
};
let timeline = item
.response
.data
.timeline
.last()
.ok_or(errors::ConnectorError::ResponseHandlingFailed)?
.clone();
let connector_id = ResponseId::ConnectorTransactionId(item.response.data.id.clone());
let attempt_status = timeline.status.clone();
let response_data = timeline.context.map_or(
Ok(PaymentsResponseData::TransactionResponse {
resource_id: connector_id.clone(),
redirection_data: Box::new(Some(redirection_data)),
mandate_reference: Box::new(None),
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: Some(item.response.data.id.clone()),
incremental_authorization_allowed: None,
charges: None,
}),
|context| {
Ok(PaymentsResponseData::TransactionUnresolvedResponse{
resource_id: connector_id,
reason: Some(api_models::enums::UnresolvedResponseReason {
code: context.to_string(),
message: "Please check the transaction in coinbase dashboard and resolve manually"
.to_string(),
}),
connector_response_reference_id: Some(item.response.data.id),
})
},
);
Ok(Self {
status: enums::AttemptStatus::from(attempt_status),
response: response_data,
..item.data
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/coinbase/transformers.rs" role="context" start="127" end="127">
use common_enums::enums;
use hyperswitch_domain_models::{
router_data::{ConnectorAuthType, RouterData},
router_flow_types::refunds::{Execute, RSync},
router_request_types::ResponseId,
router_response_types::{PaymentsResponseData, RedirectForm},
types,
};
use crate::{
types::{RefundsResponseRouterData, ResponseRouterData},
utils::{
self, AddressDetailsData, PaymentsAuthorizeRequestData, RouterData as OtherRouterData,
},
};
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/coinbase/transformers.rs" role="context" start="201" end="207">
fn from(item: RefundStatus) -> Self {
match item {
RefundStatus::Succeeded => Self::Success,
RefundStatus::Failed => Self::Failure,
RefundStatus::Processing => Self::Pending,
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/coinbase/transformers.rs" role="context" start="184" end="186">
fn try_from(_item: &types::RefundsRouterData<F>) -> Result<Self, Self::Error> {
Err(errors::ConnectorError::NotImplemented("try_from RefundsRouterData".to_string()).into())
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/coinbase/transformers.rs" role="context" start="88" end="97">
fn from(item: CoinbasePaymentStatus) -> Self {
match item {
CoinbasePaymentStatus::Completed | CoinbasePaymentStatus::Resolved => Self::Charged,
CoinbasePaymentStatus::Expired => Self::Failure,
CoinbasePaymentStatus::New => Self::AuthenticationPending,
CoinbasePaymentStatus::Unresolved => Self::Unresolved,
CoinbasePaymentStatus::Canceled => Self::Voided,
_ => Self::Pending,
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/coinbase/transformers.rs" role="context" start="60" end="68">
fn try_from(_auth_type: &ConnectorAuthType) -> Result<Self, Self::Error> {
if let ConnectorAuthType::HeaderKey { api_key } = _auth_type {
Ok(Self {
api_key: api_key.to_owned(),
})
} else {
Err(errors::ConnectorError::FailedToObtainAuthType.into())
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/coinbase/transformers.rs" role="context" start="47" end="47">
type Error = error_stack::Report<errors::ConnectorError>;
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/coinbase/transformers.rs" role="context" start="118" end="122">
pub struct CoinbasePaymentsResponse {
// status: CoinbasePaymentStatus,
// id: String,
data: CoinbasePaymentResponseData,
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/globalpay/requests.rs" role="context" start="685" end="688">
pub enum Method {
Ksn,
Ktb,
}
<file_sep path="hyperswitch/crates/api_models/src/payment_methods.rs" role="context" start="2478" end="2478">
type Error = error_stack::Report<errors::ValidationError>;
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/router/tests/connectors/coinbase.rs<|crate|> router<|connector|> coinbase anchor=should_sync_expired_payment kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=1<|meta_end|>
<file_sep path="hyperswitch/crates/router/tests/connectors/coinbase.rs" role="context" start="168" end="183">
async fn should_sync_expired_payment() {
let response = CONNECTOR
.psync_retry_till_status_matches(
enums::AttemptStatus::Authorized,
Some(types::PaymentsSyncData {
connector_transaction_id: types::ResponseId::ConnectorTransactionId(
"FZ89KDDB".to_string(),
),
..Default::default()
}),
get_default_payment_info(),
)
.await
.expect("PSync response");
assert_eq!(response.status, enums::AttemptStatus::Failure);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/coinbase.rs" role="context" start="167" end="167">
use router::types::{self, api, domain, storage::enums, PaymentAddress};
<file_sep path="hyperswitch/crates/router/tests/connectors/coinbase.rs" role="context" start="187" end="202">
async fn should_sync_cancelled_payment() {
let response = CONNECTOR
.psync_retry_till_status_matches(
enums::AttemptStatus::Authorized,
Some(types::PaymentsSyncData {
connector_transaction_id: types::ResponseId::ConnectorTransactionId(
"C35AAXKF".to_string(),
),
..Default::default()
}),
get_default_payment_info(),
)
.await
.expect("PSync response");
assert_eq!(response.status, enums::AttemptStatus::Voided);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/coinbase.rs" role="context" start="149" end="164">
async fn should_sync_unresolved_payment() {
let response = CONNECTOR
.psync_retry_till_status_matches(
enums::AttemptStatus::Authorized,
Some(types::PaymentsSyncData {
connector_transaction_id: types::ResponseId::ConnectorTransactionId(
"YJ6RFZXZ".to_string(),
),
..Default::default()
}),
get_default_payment_info(),
)
.await
.expect("PSync response");
assert_eq!(response.status, enums::AttemptStatus::Unresolved);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/coinbase.rs" role="context" start="130" end="145">
async fn should_sync_authorized_payment() {
let response = CONNECTOR
.psync_retry_till_status_matches(
enums::AttemptStatus::Authorized,
Some(types::PaymentsSyncData {
connector_transaction_id: types::ResponseId::ConnectorTransactionId(
"ADFY3789".to_string(),
),
..Default::default()
}),
get_default_payment_info(),
)
.await
.expect("PSync response");
assert_eq!(response.status, enums::AttemptStatus::Charged);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/coinbase.rs" role="context" start="41" end="68">
fn get_default_payment_info() -> Option<utils::PaymentInfo> {
Some(utils::PaymentInfo {
address: Some(PaymentAddress::new(
None,
Some(Address {
address: Some(AddressDetails {
first_name: Some(Secret::new("first".to_string())),
last_name: Some(Secret::new("last".to_string())),
line1: Some(Secret::new("line1".to_string())),
line2: Some(Secret::new("line2".to_string())),
city: Some("city".to_string()),
zip: Some(Secret::new("zip".to_string())),
country: Some(api_models::enums::CountryAlpha2::IN),
..Default::default()
}),
phone: Some(PhoneDetails {
number: Some(Secret::new("9123456789".to_string())),
country_code: Some("+91".to_string()),
}),
email: None,
}),
None,
None,
)),
connector_meta_data: Some(json!({"pricing_type": "fixed_price"})),
..Default::default()
})
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/router/tests/connectors/bitpay.rs<|crate|> router<|connector|> bitpay anchor=should_only_authorize_payment kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=1<|meta_end|>
<file_sep path="hyperswitch/crates/router/tests/connectors/bitpay.rs" role="context" start="110" end="124">
async fn should_only_authorize_payment() {
let response = CONNECTOR
.authorize_payment(payment_method_details(), get_default_payment_info())
.await
.expect("Authorize payment response");
let resp = response.clone().response.ok().unwrap();
assert_eq!(response.status, enums::AttemptStatus::AuthenticationPending);
let endpoint = match resp {
types::PaymentsResponseData::TransactionResponse {
redirection_data, ..
} => Some(redirection_data),
_ => None,
};
assert!(endpoint.is_some())
}
<file_sep path="hyperswitch/crates/router/tests/connectors/bitpay.rs" role="context" start="109" end="109">
use router::types::{self, api, domain, storage::enums, PaymentAddress};
<file_sep path="hyperswitch/crates/router/tests/connectors/bitpay.rs" role="context" start="147" end="162">
async fn should_sync_expired_payment() {
let response = CONNECTOR
.psync_retry_till_status_matches(
enums::AttemptStatus::Authorized,
Some(types::PaymentsSyncData {
connector_transaction_id: types::ResponseId::ConnectorTransactionId(
"bUsFf4RjQEahjbjGcETRS".to_string(),
),
..Default::default()
}),
get_default_payment_info(),
)
.await
.expect("PSync response");
assert_eq!(response.status, enums::AttemptStatus::Failure);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/bitpay.rs" role="context" start="128" end="143">
async fn should_sync_authorized_payment() {
let response = CONNECTOR
.psync_retry_till_status_matches(
enums::AttemptStatus::Authorized,
Some(types::PaymentsSyncData {
connector_transaction_id: types::ResponseId::ConnectorTransactionId(
"NPf27TDfyU5mhcTCw2oaq4".to_string(),
),
..Default::default()
}),
get_default_payment_info(),
)
.await
.expect("PSync response");
assert_eq!(response.status, enums::AttemptStatus::Charged);
}
<file_sep path="hyperswitch/crates/router/tests/connectors/bitpay.rs" role="context" start="68" end="106">
fn payment_method_details() -> Option<types::PaymentsAuthorizeData> {
Some(types::PaymentsAuthorizeData {
amount: 1,
currency: enums::Currency::USD,
payment_method_data: domain::PaymentMethodData::Crypto(domain::CryptoData {
pay_currency: None,
network: None,
}),
confirm: true,
statement_descriptor_suffix: None,
statement_descriptor: None,
setup_future_usage: None,
mandate_id: None,
off_session: None,
setup_mandate_details: None,
// capture_method: Some(capture_method),
browser_info: None,
order_details: None,
order_category: None,
email: None,
customer_name: None,
payment_experience: None,
payment_method_type: None,
session_token: None,
enrolled_for_3ds: false,
related_transaction_id: None,
router_return_url: Some(String::from("https://google.com/")),
webhook_url: Some(String::from("https://google.com/")),
complete_authorize_url: None,
capture_method: None,
customer_id: None,
surcharge_details: None,
request_incremental_authorization: false,
metadata: None,
authentication_data: None,
customer_acceptance: None,
..utils::PaymentAuthorizeType::default().0
})
}
<file_sep path="hyperswitch/crates/router/tests/connectors/bitpay.rs" role="context" start="40" end="66">
fn get_default_payment_info() -> Option<utils::PaymentInfo> {
Some(utils::PaymentInfo {
address: Some(PaymentAddress::new(
None,
Some(Address {
address: Some(AddressDetails {
first_name: Some(Secret::new("first".to_string())),
last_name: Some(Secret::new("last".to_string())),
line1: Some(Secret::new("line1".to_string())),
line2: Some(Secret::new("line2".to_string())),
city: Some("city".to_string()),
zip: Some(Secret::new("zip".to_string())),
country: Some(api_models::enums::CountryAlpha2::IN),
..Default::default()
}),
phone: Some(PhoneDetails {
number: Some(Secret::new("9123456789".to_string())),
country_code: Some("+91".to_string()),
}),
email: None,
}),
None,
None,
)),
..Default::default()
})
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/hyperswitch_connectors/src/connectors/bitpay/transformers.rs<|crate|> hyperswitch_connectors<|connector|> bitpay anchor=try_from kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=1<|meta_end|>
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/bitpay/transformers.rs" role="context" start="59" end="63">
fn try_from(
item: &BitpayRouterData<&types::PaymentsAuthorizeRouterData>,
) -> Result<Self, Self::Error> {
get_crypto_specific_payment_data(item)
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/bitpay/transformers.rs" role="context" start="58" end="58">
use common_utils::{request::Method, types::FloatMajorUnit};
use hyperswitch_domain_models::{
router_data::{ConnectorAuthType, RouterData},
router_flow_types::refunds::{Execute, RSync},
router_request_types::ResponseId,
router_response_types::{PaymentsResponseData, RedirectForm, RefundsResponseData},
types,
};
use crate::{
types::{RefundsResponseRouterData, ResponseRouterData},
utils::PaymentsAuthorizeRequestData,
};
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/bitpay/transformers.rs" role="context" start="96" end="103">
fn from(item: BitpayPaymentStatus) -> Self {
match item {
BitpayPaymentStatus::New => Self::AuthenticationPending,
BitpayPaymentStatus::Complete | BitpayPaymentStatus::Confirmed => Self::Charged,
BitpayPaymentStatus::Expired => Self::Failure,
_ => Self::Pending,
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/bitpay/transformers.rs" role="context" start="73" end="80">
fn try_from(auth_type: &ConnectorAuthType) -> Result<Self, Self::Error> {
match auth_type {
ConnectorAuthType::HeaderKey { api_key } => Ok(Self {
api_key: api_key.to_owned(),
}),
_ => Err(errors::ConnectorError::FailedToObtainAuthType.into()),
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/bitpay/transformers.rs" role="context" start="26" end="31">
fn from((amount, router_data): (FloatMajorUnit, T)) -> Self {
Self {
amount,
router_data,
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/bitpay/transformers.rs" role="context" start="265" end="289">
fn get_crypto_specific_payment_data(
item: &BitpayRouterData<&types::PaymentsAuthorizeRouterData>,
) -> Result<BitpayPaymentsRequest, error_stack::Report<errors::ConnectorError>> {
let price = item.amount;
let currency = item.router_data.request.currency.to_string();
let redirect_url = item.router_data.request.get_router_return_url()?;
let notification_url = item.router_data.request.get_webhook_url()?;
let transaction_speed = TransactionSpeed::Medium;
let auth_type = item.router_data.connector_auth_type.clone();
let token = match auth_type {
ConnectorAuthType::HeaderKey { api_key } => api_key,
_ => String::default().into(),
};
let order_id = item.router_data.connector_request_reference_id.clone();
Ok(BitpayPaymentsRequest {
price,
currency,
redirect_url,
notification_url,
transaction_speed,
token,
order_id,
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/bitpay/transformers.rs" role="context" start="58" end="58">
type Error = error_stack::Report<errors::ConnectorError>;
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/bitpay/transformers.rs" role="context" start="20" end="23">
pub struct BitpayRouterData<T> {
pub amount: FloatMajorUnit,
pub router_data: T,
}
|
symbol_neighborhood
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.