From 2216a88d25c42ede9862f6d036e7b0586a2e7c28 Mon Sep 17 00:00:00 2001 From: Chethan Rao <70657455+Chethan-rao@users.noreply.github.com> Date: Tue, 7 May 2024 16:05:32 +0530 Subject: [PATCH] chore: address Rust 1.78 clippy lints (#4545) Co-authored-by: hyperswitch-bot[bot] <148525504+hyperswitch-bot[bot]@users.noreply.github.com> --- crates/analytics/src/clickhouse.rs | 4 +- crates/analytics/src/lib.rs | 10 +- crates/analytics/src/payments/accumulator.rs | 10 +- crates/analytics/src/query.rs | 16 +-- crates/analytics/src/refunds.rs | 1 - crates/analytics/src/sdk_events.rs | 5 - crates/analytics/src/sqlx.rs | 4 +- crates/analytics/src/types.rs | 5 - crates/api_models/src/admin.rs | 6 +- crates/api_models/src/api_keys.rs | 4 +- crates/api_models/src/payments.rs | 18 ++- crates/api_models/src/routing.rs | 10 +- .../api_models/src/user/dashboard_metadata.rs | 2 +- crates/common_utils/src/crypto.rs | 20 ++-- crates/common_utils/src/ext_traits.rs | 4 +- crates/common_utils/src/pii.rs | 12 +- crates/common_utils/src/static_cache.rs | 2 + crates/connector_configs/src/transformer.rs | 33 +++--- crates/diesel_models/src/encryption.rs | 4 +- .../src/query/payment_attempt.rs | 6 +- .../diesel_models/src/query/payout_attempt.rs | 10 +- crates/drainer/src/handler.rs | 2 +- crates/drainer/src/lib.rs | 2 +- crates/euclid/src/dssa/graph.rs | 6 +- crates/euclid/src/frontend/ast/parser.rs | 6 +- crates/euclid_macros/src/inner/knowledge.rs | 42 ++++--- crates/euclid_wasm/src/lib.rs | 4 +- .../hyperswitch_domain_models/src/mandates.rs | 3 +- crates/masking/src/diesel.rs | 4 +- crates/openapi/src/openapi.rs | 2 + crates/pm_auth/src/types.rs | 6 +- crates/router/src/analytics.rs | 4 +- crates/router/src/bin/scheduler.rs | 4 +- .../stripe/payment_intents/types.rs | 4 +- crates/router/src/configs/settings.rs | 26 ++--- .../router/src/connector/aci/transformers.rs | 11 +- .../src/connector/adyen/transformers.rs | 8 +- crates/router/src/connector/airwallex.rs | 18 +-- .../src/connector/airwallex/transformers.rs | 13 +-- .../router/src/connector/authorizedotnet.rs | 3 +- .../connector/authorizedotnet/transformers.rs | 16 +-- .../src/connector/bambora/transformers.rs | 16 +-- crates/router/src/connector/bankofamerica.rs | 3 +- .../connector/bankofamerica/transformers.rs | 18 +-- .../src/connector/billwerk/transformers.rs | 16 +-- .../src/connector/bitpay/transformers.rs | 15 +-- .../src/connector/bluesnap/transformers.rs | 64 ++++------ .../router/src/connector/boku/transformers.rs | 2 +- crates/router/src/connector/braintree.rs | 6 +- .../braintree_graphql_transformers.rs | 18 +-- .../src/connector/braintree/transformers.rs | 4 +- .../src/connector/cashtocode/transformers.rs | 4 +- .../src/connector/checkout/transformers.rs | 16 +-- crates/router/src/connector/coinbase.rs | 3 +- .../src/connector/cryptopay/transformers.rs | 11 +- crates/router/src/connector/cybersource.rs | 12 +- .../src/connector/cybersource/transformers.rs | 24 +--- crates/router/src/connector/dlocal.rs | 3 +- .../src/connector/dlocal/transformers.rs | 13 +-- .../src/connector/fiserv/transformers.rs | 13 +-- .../src/connector/globalpay/transformers.rs | 6 +- .../src/connector/gocardless/transformers.rs | 20 +--- .../src/connector/helcim/transformers.rs | 22 +--- .../src/connector/iatapay/transformers.rs | 20 +--- .../src/connector/klarna/transformers.rs | 11 +- .../connector/multisafepay/transformers.rs | 21 +--- .../src/connector/netcetera/transformers.rs | 11 +- crates/router/src/connector/nexinets.rs | 2 +- .../router/src/connector/nmi/transformers.rs | 17 +-- crates/router/src/connector/nuvei.rs | 18 +-- .../src/connector/opennode/transformers.rs | 13 +-- .../src/connector/payeezy/transformers.rs | 13 +-- .../src/connector/payme/transformers.rs | 110 ++++++++---------- crates/router/src/connector/paypal.rs | 9 +- .../src/connector/paypal/transformers.rs | 27 ++--- .../src/connector/placetopay/transformers.rs | 11 +- .../src/connector/prophetpay/transformers.rs | 18 +-- crates/router/src/connector/rapyd.rs | 2 +- .../src/connector/rapyd/transformers.rs | 16 +-- crates/router/src/connector/shift4.rs | 4 +- .../src/connector/shift4/transformers.rs | 6 +- crates/router/src/connector/signifyd.rs | 2 +- .../src/connector/square/transformers.rs | 7 +- crates/router/src/connector/stax.rs | 32 +++-- .../router/src/connector/stax/transformers.rs | 16 +-- crates/router/src/connector/stripe.rs | 2 +- .../src/connector/stripe/transformers.rs | 32 +++-- .../connector/threedsecureio/transformers.rs | 15 +-- .../src/connector/trustpay/transformers.rs | 13 +-- .../router/src/connector/tsys/transformers.rs | 7 +- crates/router/src/connector/utils.rs | 75 ++++++------ .../router/src/connector/volt/transformers.rs | 11 +- .../src/connector/worldline/transformers.rs | 24 +--- crates/router/src/connector/worldpay.rs | 4 +- .../src/connector/worldpay/transformers.rs | 2 +- .../router/src/connector/zen/transformers.rs | 16 +-- .../router/src/connector/zsl/transformers.rs | 11 +- crates/router/src/core/admin.rs | 20 ++-- crates/router/src/core/api_keys.rs | 4 +- crates/router/src/core/authentication.rs | 22 ++-- .../src/core/authentication/transformers.rs | 8 +- crates/router/src/core/customers.rs | 2 +- crates/router/src/core/errors.rs | 2 +- crates/router/src/core/files.rs | 8 +- crates/router/src/core/fraud_check.rs | 6 +- crates/router/src/core/mandate.rs | 6 +- crates/router/src/core/payment_link.rs | 4 +- .../router/src/core/payment_methods/cards.rs | 31 +++-- .../src/core/payment_methods/transformers.rs | 2 +- crates/router/src/core/payments.rs | 82 ++++++------- .../router/src/core/payments/access_token.rs | 2 +- .../src/core/payments/flows/authorize_flow.rs | 13 +-- .../payments/flows/complete_authorize_flow.rs | 15 ++- crates/router/src/core/payments/helpers.rs | 2 +- .../payments/operations/payment_approve.rs | 5 +- .../payments/operations/payment_cancel.rs | 4 +- .../payments/operations/payment_create.rs | 5 +- .../payments/operations/payment_response.rs | 26 ++--- .../payments/operations/payment_status.rs | 2 +- .../payments/operations/payment_update.rs | 6 +- .../router/src/core/payments/tokenization.rs | 33 +++--- .../router/src/core/payments/transformers.rs | 4 +- crates/router/src/core/payouts/helpers.rs | 6 +- crates/router/src/core/payouts/retry.rs | 2 +- crates/router/src/core/pm_auth.rs | 31 +++-- .../src/core/user/dashboard_metadata.rs | 8 +- crates/router/src/core/utils.rs | 12 +- crates/router/src/core/verification.rs | 4 +- crates/router/src/core/webhooks.rs | 26 ++--- crates/router/src/core/webhooks/utils.rs | 4 +- crates/router/src/db.rs | 2 +- crates/router/src/db/business_profile.rs | 19 ++- crates/router/src/db/cache.rs | 2 +- crates/router/src/db/dispute.rs | 8 +- crates/router/src/db/user_role.rs | 4 +- crates/router/src/lib.rs | 2 +- crates/router/src/routes/api_keys.rs | 2 +- crates/router/src/routes/metrics/request.rs | 8 +- crates/router/src/routes/payments.rs | 16 ++- crates/router/src/routes/recon.rs | 3 +- crates/router/src/routes/user.rs | 7 +- crates/router/src/routes/webhooks.rs | 16 --- crates/router/src/services/api.rs | 13 +-- crates/router/src/services/api/client.rs | 2 +- crates/router/src/services/authentication.rs | 4 +- crates/router/src/services/pm_auth.rs | 14 +-- crates/router/src/types/api/customers.rs | 6 +- crates/router/src/types/api/payments.rs | 14 --- .../router/src/types/api/verify_connector.rs | 10 +- crates/router/src/types/domain/customer.rs | 4 +- .../domain/merchant_connector_account.rs | 2 +- crates/router/src/types/transformers.rs | 89 +++++++------- crates/router/src/utils.rs | 10 +- crates/router/src/utils/currency.rs | 4 +- crates/router/src/utils/user.rs | 4 +- crates/router/tests/connectors/aci.rs | 4 +- crates/router/tests/connectors/adyen.rs | 2 +- crates/router/tests/connectors/airwallex.rs | 16 +-- .../tests/connectors/authorizedotnet.rs | 66 ++++------- crates/router/tests/connectors/bambora.rs | 14 +-- .../router/tests/connectors/bankofamerica.rs | 10 +- crates/router/tests/connectors/billwerk.rs | 4 +- crates/router/tests/connectors/bitpay.rs | 12 +- crates/router/tests/connectors/bluesnap.rs | 10 +- crates/router/tests/connectors/boku.rs | 10 +- crates/router/tests/connectors/cashtocode.rs | 2 +- crates/router/tests/connectors/checkout.rs | 10 +- crates/router/tests/connectors/coinbase.rs | 16 +-- crates/router/tests/connectors/cryptopay.rs | 12 +- crates/router/tests/connectors/cybersource.rs | 21 ++-- crates/router/tests/connectors/dlocal.rs | 18 +-- .../router/tests/connectors/dummyconnector.rs | 12 +- crates/router/tests/connectors/ebanx.rs | 4 +- crates/router/tests/connectors/fiserv.rs | 16 +-- crates/router/tests/connectors/forte.rs | 20 ++-- crates/router/tests/connectors/globalpay.rs | 18 +-- crates/router/tests/connectors/globepay.rs | 10 +- crates/router/tests/connectors/gocardless.rs | 10 +- crates/router/tests/connectors/helcim.rs | 10 +- crates/router/tests/connectors/iatapay.rs | 8 +- crates/router/tests/connectors/main.rs | 1 + crates/router/tests/connectors/mollie.rs | 1 + .../router/tests/connectors/multisafepay.rs | 12 +- crates/router/tests/connectors/netcetera.rs | 4 +- crates/router/tests/connectors/nexinets.rs | 12 +- crates/router/tests/connectors/nmi.rs | 74 ++++++------ crates/router/tests/connectors/noon.rs | 11 +- crates/router/tests/connectors/nuvei.rs | 13 +-- crates/router/tests/connectors/opayo.rs | 12 +- crates/router/tests/connectors/opennode.rs | 14 +-- crates/router/tests/connectors/payme.rs | 18 +-- crates/router/tests/connectors/paypal.rs | 12 +- crates/router/tests/connectors/payu.rs | 16 +-- crates/router/tests/connectors/placetopay.rs | 10 +- crates/router/tests/connectors/powertranz.rs | 10 +- crates/router/tests/connectors/prophetpay.rs | 10 +- crates/router/tests/connectors/rapyd.rs | 10 +- crates/router/tests/connectors/shift4.rs | 12 +- crates/router/tests/connectors/square.rs | 18 ++- crates/router/tests/connectors/stax.rs | 12 +- crates/router/tests/connectors/stripe.rs | 14 +-- crates/router/tests/connectors/trustpay.rs | 14 +-- crates/router/tests/connectors/tsys.rs | 12 +- crates/router/tests/connectors/utils.rs | 12 +- crates/router/tests/connectors/volt.rs | 10 +- crates/router/tests/connectors/wise.rs | 36 +++--- crates/router/tests/connectors/worldline.rs | 6 +- crates/router/tests/connectors/worldpay.rs | 6 +- crates/router/tests/connectors/zen.rs | 12 +- crates/router/tests/payments.rs | 6 +- crates/router/tests/payments2.rs | 8 +- .../src/macros/api_error/helpers.rs | 6 +- crates/router_derive/src/macros/helpers.rs | 2 +- .../router_derive/src/macros/try_get_enum.rs | 2 +- crates/router_env/src/logger/setup.rs | 2 +- crates/scheduler/src/producer.rs | 7 +- crates/scheduler/src/utils.rs | 4 +- crates/storage_impl/src/errors.rs | 18 ++- crates/storage_impl/src/lib.rs | 2 +- crates/storage_impl/src/mock_db.rs | 6 +- .../src/payments/payment_intent.rs | 14 +-- crates/test_utils/src/newman_runner.rs | 4 +- 222 files changed, 1138 insertions(+), 1631 deletions(-) diff --git a/crates/analytics/src/clickhouse.rs b/crates/analytics/src/clickhouse.rs index 4d01c20972..8f0d00cd79 100644 --- a/crates/analytics/src/clickhouse.rs +++ b/crates/analytics/src/clickhouse.rs @@ -453,7 +453,7 @@ where |(order_column, order)| format!( " order by {} {}", order_column.to_owned(), - order.to_string() + order ) ), alias.map_or_else(|| "".to_owned(), |alias| format!(" as {}", alias)) @@ -476,7 +476,7 @@ where |(order_column, order)| format!( " order by {} {}", order_column.to_owned(), - order.to_string() + order ) ), alias.map_or_else(|| "".to_owned(), |alias| format!(" as {}", alias)) diff --git a/crates/analytics/src/lib.rs b/crates/analytics/src/lib.rs index 2a7075a0f2..ae10fc9889 100644 --- a/crates/analytics/src/lib.rs +++ b/crates/analytics/src/lib.rs @@ -78,14 +78,16 @@ impl Default for AnalyticsProvider { } } -impl ToString for AnalyticsProvider { - fn to_string(&self) -> String { - String::from(match self { +impl std::fmt::Display for AnalyticsProvider { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + let analytics_provider = match self { Self::Clickhouse(_) => "Clickhouse", Self::Sqlx(_) => "Sqlx", Self::CombinedCkh(_, _) => "CombinedCkh", Self::CombinedSqlx(_, _) => "CombinedSqlx", - }) + }; + + write!(f, "{}", analytics_provider) } } diff --git a/crates/analytics/src/payments/accumulator.rs b/crates/analytics/src/payments/accumulator.rs index c340f2888f..efc8aaf698 100644 --- a/crates/analytics/src/payments/accumulator.rs +++ b/crates/analytics/src/payments/accumulator.rs @@ -153,10 +153,7 @@ impl PaymentMetricAccumulator for SumAccumulator { fn add_metrics_bucket(&mut self, metrics: &PaymentMetricRow) { self.total = match ( self.total, - metrics - .total - .as_ref() - .and_then(bigdecimal::ToPrimitive::to_i64), + metrics.total.as_ref().and_then(ToPrimitive::to_i64), ) { (None, None) => None, (None, i @ Some(_)) | (i @ Some(_), None) => i, @@ -173,10 +170,7 @@ impl PaymentMetricAccumulator for AverageAccumulator { type MetricOutput = Option; fn add_metrics_bucket(&mut self, metrics: &PaymentMetricRow) { - let total = metrics - .total - .as_ref() - .and_then(bigdecimal::ToPrimitive::to_u32); + let total = metrics.total.as_ref().and_then(ToPrimitive::to_u32); let count = metrics.count.and_then(|total| u32::try_from(total).ok()); match (total, count) { diff --git a/crates/analytics/src/query.rs b/crates/analytics/src/query.rs index d529615207..525bc0f846 100644 --- a/crates/analytics/src/query.rs +++ b/crates/analytics/src/query.rs @@ -286,12 +286,12 @@ pub enum Order { Descending, } -impl ToString for Order { - fn to_string(&self) -> String { - String::from(match self { - Self::Ascending => "asc", - Self::Descending => "desc", - }) +impl std::fmt::Display for Order { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + match self { + Self::Ascending => write!(f, "asc"), + Self::Descending => write!(f, "desc"), + } } } @@ -709,12 +709,12 @@ where Ok(query) } - pub async fn execute_query( + pub async fn execute_query( &mut self, store: &P, ) -> CustomResult, QueryExecutionError>, QueryBuildingError> where - P: LoadRow, + P: LoadRow + AnalyticsDataSource, Aggregate<&'static str>: ToSql, Window<&'static str>: ToSql, { diff --git a/crates/analytics/src/refunds.rs b/crates/analytics/src/refunds.rs index 53481e2328..590dc148eb 100644 --- a/crates/analytics/src/refunds.rs +++ b/crates/analytics/src/refunds.rs @@ -6,5 +6,4 @@ pub mod metrics; pub mod types; pub use accumulator::{RefundMetricAccumulator, RefundMetricsAccumulator}; -pub trait RefundAnalytics: metrics::RefundMetricAnalytics {} pub use self::core::{get_filters, get_metrics}; diff --git a/crates/analytics/src/sdk_events.rs b/crates/analytics/src/sdk_events.rs index fe8af7cfe2..a02de4cbbe 100644 --- a/crates/analytics/src/sdk_events.rs +++ b/crates/analytics/src/sdk_events.rs @@ -5,10 +5,5 @@ pub mod filters; pub mod metrics; pub mod types; pub use accumulator::{SdkEventMetricAccumulator, SdkEventMetricsAccumulator}; -pub trait SDKEventAnalytics: events::SdkEventsFilterAnalytics {} -pub trait SdkEventAnalytics: - metrics::SdkEventMetricAnalytics + filters::SdkEventFilterAnalytics -{ -} pub use self::core::{get_filters, get_metrics, sdk_events_core}; diff --git a/crates/analytics/src/sqlx.rs b/crates/analytics/src/sqlx.rs index 86782c5f75..133e959d63 100644 --- a/crates/analytics/src/sqlx.rs +++ b/crates/analytics/src/sqlx.rs @@ -593,7 +593,7 @@ where |(order_column, order)| format!( " order by {} {}", order_column.to_owned(), - order.to_string() + order ) ), alias.map_or_else(|| "".to_owned(), |alias| format!(" as {}", alias)) @@ -616,7 +616,7 @@ where |(order_column, order)| format!( " order by {} {}", order_column.to_owned(), - order.to_string() + order ) ), alias.map_or_else(|| "".to_owned(), |alias| format!(" as {}", alias)) diff --git a/crates/analytics/src/types.rs b/crates/analytics/src/types.rs index 356d11bb77..d0c1d74bc1 100644 --- a/crates/analytics/src/types.rs +++ b/crates/analytics/src/types.rs @@ -63,11 +63,6 @@ where } } -// Analytics Framework - -pub trait RefundAnalytics {} -pub trait SdkEventAnalytics {} - #[async_trait::async_trait] pub trait AnalyticsDataSource where diff --git a/crates/api_models/src/admin.rs b/crates/api_models/src/admin.rs index 75bd2a31d8..e845317b69 100644 --- a/crates/api_models/src/admin.rs +++ b/crates/api_models/src/admin.rs @@ -456,7 +456,7 @@ pub struct MerchantConnectorCreate { pub disabled: Option, /// Contains the frm configs for the merchant connector - #[schema(example = json!(common_utils::consts::FRM_CONFIGS_EG))] + #[schema(example = json!(consts::FRM_CONFIGS_EG))] pub frm_configs: Option>, /// The business country to which the connector account is attached. To be deprecated soon. Use the 'profile_id' instead @@ -609,7 +609,7 @@ pub struct MerchantConnectorResponse { pub disabled: Option, /// Contains the frm configs for the merchant connector - #[schema(example = json!(common_utils::consts::FRM_CONFIGS_EG))] + #[schema(example = json!(consts::FRM_CONFIGS_EG))] pub frm_configs: Option>, /// The business country to which the connector account is attached. To be deprecated soon. Use the 'profile_id' instead @@ -702,7 +702,7 @@ pub struct MerchantConnectorUpdate { pub disabled: Option, /// Contains the frm configs for the merchant connector - #[schema(example = json!(common_utils::consts::FRM_CONFIGS_EG))] + #[schema(example = json!(consts::FRM_CONFIGS_EG))] pub frm_configs: Option>, pub pm_auth_config: Option, diff --git a/crates/api_models/src/api_keys.rs b/crates/api_models/src/api_keys.rs index 805c5616c2..801bbc63f5 100644 --- a/crates/api_models/src/api_keys.rs +++ b/crates/api_models/src/api_keys.rs @@ -270,7 +270,7 @@ mod api_key_expiration_tests { let date = time::Date::from_calendar_date(2022, time::Month::September, 10).unwrap(); let time = time::Time::from_hms(11, 12, 13).unwrap(); assert_eq!( - serde_json::to_string(&ApiKeyExpiration::DateTime(time::PrimitiveDateTime::new( + serde_json::to_string(&ApiKeyExpiration::DateTime(PrimitiveDateTime::new( date, time ))) .unwrap(), @@ -289,7 +289,7 @@ mod api_key_expiration_tests { let time = time::Time::from_hms(11, 12, 13).unwrap(); assert_eq!( serde_json::from_str::(r#""2022-09-10T11:12:13.000Z""#).unwrap(), - ApiKeyExpiration::DateTime(time::PrimitiveDateTime::new(date, time)) + ApiKeyExpiration::DateTime(PrimitiveDateTime::new(date, time)) ); } diff --git a/crates/api_models/src/payments.rs b/crates/api_models/src/payments.rs index 8270ddaf3f..0e46eb1993 100644 --- a/crates/api_models/src/payments.rs +++ b/crates/api_models/src/payments.rs @@ -682,7 +682,7 @@ impl PaymentsRequest { .as_ref() .map(|od| { od.iter() - .map(|order| order.encode_to_value().map(masking::Secret::new)) + .map(|order| order.encode_to_value().map(Secret::new)) .collect::, _>>() }) .transpose() @@ -1304,9 +1304,7 @@ mod payment_method_data_serde { match deserialize_to_inner { __Inner::OptionalPaymentMethod(value) => { let parsed_value = serde_json::from_value::<__InnerPaymentMethodData>(value) - .map_err(|serde_json_error| { - serde::de::Error::custom(serde_json_error.to_string()) - })?; + .map_err(|serde_json_error| de::Error::custom(serde_json_error.to_string()))?; let payment_method_data = if let Some(payment_method_data_value) = parsed_value.payment_method_data @@ -1321,14 +1319,12 @@ mod payment_method_data_serde { payment_method_data_value, ) .map_err(|serde_json_error| { - serde::de::Error::custom(serde_json_error.to_string()) + de::Error::custom(serde_json_error.to_string()) })?, ) } } else { - Err(serde::de::Error::custom( - "Expected a map for payment_method_data", - ))? + Err(de::Error::custom("Expected a map for payment_method_data"))? } } else { None @@ -1342,7 +1338,7 @@ mod payment_method_data_serde { __Inner::RewardString(inner_string) => { let payment_method_data = match inner_string.as_str() { "reward" => PaymentMethodData::Reward, - _ => Err(serde::de::Error::custom("Invalid Variant"))?, + _ => Err(de::Error::custom("Invalid Variant"))?, }; Ok(Some(PaymentMethodDataRequest { @@ -2686,8 +2682,8 @@ pub enum PaymentIdType { PreprocessingId(String), } -impl std::fmt::Display for PaymentIdType { - fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { +impl fmt::Display for PaymentIdType { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { match self { Self::PaymentIntentId(payment_id) => { write!(f, "payment_intent_id = \"{payment_id}\"") diff --git a/crates/api_models/src/routing.rs b/crates/api_models/src/routing.rs index f3d966f3d9..a7c4ed2447 100644 --- a/crates/api_models/src/routing.rs +++ b/crates/api_models/src/routing.rs @@ -203,8 +203,8 @@ pub struct RoutableConnectorChoice { pub sub_label: Option, } -impl ToString for RoutableConnectorChoice { - fn to_string(&self) -> String { +impl std::fmt::Display for RoutableConnectorChoice { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { #[cfg(feature = "connector_choice_mca_id")] let base = self.connector.to_string(); @@ -219,7 +219,7 @@ impl ToString for RoutableConnectorChoice { sub_base }; - base + write!(f, "{}", base) } } @@ -329,7 +329,7 @@ pub enum RoutingAlgorithm { Priority(Vec), VolumeSplit(Vec), #[schema(value_type=ProgramConnectorSelection)] - Advanced(euclid::frontend::ast::Program), + Advanced(ast::Program), } #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)] @@ -338,7 +338,7 @@ pub enum RoutingAlgorithmSerde { Single(Box), Priority(Vec), VolumeSplit(Vec), - Advanced(euclid::frontend::ast::Program), + Advanced(ast::Program), } impl TryFrom for RoutingAlgorithm { diff --git a/crates/api_models/src/user/dashboard_metadata.rs b/crates/api_models/src/user/dashboard_metadata.rs index b547a61d45..d8a437e31a 100644 --- a/crates/api_models/src/user/dashboard_metadata.rs +++ b/crates/api_models/src/user/dashboard_metadata.rs @@ -33,7 +33,7 @@ pub enum SetMetaDataRequest { pub struct ProductionAgreementRequest { pub version: String, #[serde(skip_deserializing)] - pub ip_address: Option>, + pub ip_address: Option>, } #[derive(Debug, serde::Deserialize, serde::Serialize)] diff --git a/crates/common_utils/src/crypto.rs b/crates/common_utils/src/crypto.rs index 46904535f0..7901dec6db 100644 --- a/crates/common_utils/src/crypto.rs +++ b/crates/common_utils/src/crypto.rs @@ -38,14 +38,14 @@ impl NonceSequence { } /// Returns the current nonce value as bytes. - fn current(&self) -> [u8; ring::aead::NONCE_LEN] { - let mut nonce = [0_u8; ring::aead::NONCE_LEN]; + fn current(&self) -> [u8; aead::NONCE_LEN] { + let mut nonce = [0_u8; aead::NONCE_LEN]; nonce.copy_from_slice(&self.0.to_be_bytes()[Self::SEQUENCE_NUMBER_START_INDEX..]); nonce } /// Constructs a nonce sequence from bytes - fn from_bytes(bytes: [u8; ring::aead::NONCE_LEN]) -> Self { + fn from_bytes(bytes: [u8; aead::NONCE_LEN]) -> Self { let mut sequence_number = [0_u8; 128 / 8]; sequence_number[Self::SEQUENCE_NUMBER_START_INDEX..].copy_from_slice(&bytes); let sequence_number = u128::from_be_bytes(sequence_number); @@ -53,16 +53,16 @@ impl NonceSequence { } } -impl ring::aead::NonceSequence for NonceSequence { - fn advance(&mut self) -> Result { - let mut nonce = [0_u8; ring::aead::NONCE_LEN]; +impl aead::NonceSequence for NonceSequence { + fn advance(&mut self) -> Result { + let mut nonce = [0_u8; aead::NONCE_LEN]; nonce.copy_from_slice(&self.0.to_be_bytes()[Self::SEQUENCE_NUMBER_START_INDEX..]); // Increment sequence number self.0 = self.0.wrapping_add(1); // Return previous sequence number as bytes - Ok(ring::aead::Nonce::assume_unique_for_key(nonce)) + Ok(aead::Nonce::assume_unique_for_key(nonce)) } } @@ -275,8 +275,8 @@ impl DecodeMessage for GcmAes256 { .change_context(errors::CryptoError::DecodingFailed)?; let nonce_sequence = NonceSequence::from_bytes( - <[u8; ring::aead::NONCE_LEN]>::try_from( - msg.get(..ring::aead::NONCE_LEN) + <[u8; aead::NONCE_LEN]>::try_from( + msg.get(..aead::NONCE_LEN) .ok_or(errors::CryptoError::DecodingFailed) .attach_printable("Failed to read the nonce form the encrypted ciphertext")?, ) @@ -288,7 +288,7 @@ impl DecodeMessage for GcmAes256 { let output = binding.as_mut_slice(); let result = key - .open_within(aead::Aad::empty(), output, ring::aead::NONCE_LEN..) + .open_within(aead::Aad::empty(), output, aead::NONCE_LEN..) .change_context(errors::CryptoError::DecodingFailed)?; Ok(result.to_vec()) diff --git a/crates/common_utils/src/ext_traits.rs b/crates/common_utils/src/ext_traits.rs index f71e098a99..5ad53ec853 100644 --- a/crates/common_utils/src/ext_traits.rs +++ b/crates/common_utils/src/ext_traits.rs @@ -472,13 +472,13 @@ pub trait XmlExt { /// /// Deserialize an XML string into the specified type ``. /// - fn parse_xml(self) -> Result + fn parse_xml(self) -> Result where T: serde::de::DeserializeOwned; } impl XmlExt for &str { - fn parse_xml(self) -> Result + fn parse_xml(self) -> Result where T: serde::de::DeserializeOwned, { diff --git a/crates/common_utils/src/pii.rs b/crates/common_utils/src/pii.rs index c1f9d716e4..9c70c572fe 100644 --- a/crates/common_utils/src/pii.rs +++ b/crates/common_utils/src/pii.rs @@ -38,7 +38,7 @@ pub struct PhoneNumber(Secret); impl Strategy for PhoneNumberStrategy where - T: AsRef + std::fmt::Debug, + T: AsRef + fmt::Debug, { fn fmt(val: &T, f: &mut fmt::Formatter<'_>) -> fmt::Result { let val_str: &str = val.as_ref(); @@ -85,7 +85,7 @@ impl ops::DerefMut for PhoneNumber { } } -impl Queryable for PhoneNumber +impl Queryable for PhoneNumber where DB: Backend, Self: FromSql, @@ -210,7 +210,7 @@ pub enum EmailStrategy {} impl Strategy for EmailStrategy where - T: AsRef + std::fmt::Debug, + T: AsRef + fmt::Debug, { fn fmt(val: &T, f: &mut fmt::Formatter<'_>) -> fmt::Result { let val_str: &str = val.as_ref(); @@ -224,7 +224,7 @@ where #[derive( serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, Default, AsExpression, )] -#[diesel(sql_type = diesel::sql_types::Text)] +#[diesel(sql_type = sql_types::Text)] #[serde(try_from = "String")] pub struct Email(Secret); @@ -262,7 +262,7 @@ impl ops::DerefMut for Email { } } -impl Queryable for Email +impl Queryable for Email where DB: Backend, Self: FromSql, @@ -353,7 +353,7 @@ pub enum UpiVpaMaskingStrategy {} impl Strategy for UpiVpaMaskingStrategy where - T: AsRef + std::fmt::Debug, + T: AsRef + fmt::Debug, { fn fmt(val: &T, f: &mut fmt::Formatter<'_>) -> fmt::Result { let vpa_str: &str = val.as_ref(); diff --git a/crates/common_utils/src/static_cache.rs b/crates/common_utils/src/static_cache.rs index ca608fa9a3..37705c892c 100644 --- a/crates/common_utils/src/static_cache.rs +++ b/crates/common_utils/src/static_cache.rs @@ -26,6 +26,8 @@ impl StaticCache where T: Send, { + // Cannot have default impl as it cannot be called during instantiation of static item + #[allow(clippy::new_without_default)] pub const fn new() -> Self { Self { data: Lazy::new(|| RwLock::new(FxHashMap::default())), diff --git a/crates/connector_configs/src/transformer.rs b/crates/connector_configs/src/transformer.rs index 203e48ac50..f89c2e5921 100644 --- a/crates/connector_configs/src/transformer.rs +++ b/crates/connector_configs/src/transformer.rs @@ -98,12 +98,11 @@ impl DashboardRequestPayload { if let Some(payment_methods_enabled) = request.payment_methods_enabled.clone() { for payload in payment_methods_enabled { match payload.payment_method { - api_models::enums::PaymentMethod::Card => { + PaymentMethod::Card => { if let Some(card_provider) = payload.card_provider { - let payment_type = api_models::enums::PaymentMethodType::from_str( - &payload.payment_method_type, - ) - .map_err(|_| "Invalid key received".to_string()); + let payment_type = + PaymentMethodType::from_str(&payload.payment_method_type) + .map_err(|_| "Invalid key received".to_string()); if let Ok(payment_type) = payment_type { for method in card_provider { @@ -124,17 +123,17 @@ impl DashboardRequestPayload { } } - api_models::enums::PaymentMethod::Wallet - | api_models::enums::PaymentMethod::BankRedirect - | api_models::enums::PaymentMethod::PayLater - | api_models::enums::PaymentMethod::BankTransfer - | api_models::enums::PaymentMethod::Crypto - | api_models::enums::PaymentMethod::BankDebit - | api_models::enums::PaymentMethod::Reward - | api_models::enums::PaymentMethod::Upi - | api_models::enums::PaymentMethod::Voucher - | api_models::enums::PaymentMethod::GiftCard - | api_models::enums::PaymentMethod::CardRedirect => { + PaymentMethod::Wallet + | PaymentMethod::BankRedirect + | PaymentMethod::PayLater + | PaymentMethod::BankTransfer + | PaymentMethod::Crypto + | PaymentMethod::BankDebit + | PaymentMethod::Reward + | PaymentMethod::Upi + | PaymentMethod::Voucher + | PaymentMethod::GiftCard + | PaymentMethod::CardRedirect => { if let Some(provider) = payload.provider { let val = Self::transform_payment_method( request.connector, @@ -154,7 +153,7 @@ impl DashboardRequestPayload { } if !card_payment_method_types.is_empty() { let card = PaymentMethodsEnabled { - payment_method: api_models::enums::PaymentMethod::Card, + payment_method: PaymentMethod::Card, payment_method_types: Some(card_payment_method_types), }; payment_method_enabled.push(card); diff --git a/crates/diesel_models/src/encryption.rs b/crates/diesel_models/src/encryption.rs index 375259491c..6c6063c160 100644 --- a/crates/diesel_models/src/encryption.rs +++ b/crates/diesel_models/src/encryption.rs @@ -8,7 +8,7 @@ use diesel::{ use masking::Secret; #[derive(Debug, AsExpression, Clone, serde::Serialize, serde::Deserialize, Eq, PartialEq)] -#[diesel(sql_type = diesel::sql_types::Binary)] +#[diesel(sql_type = sql_types::Binary)] #[repr(transparent)] pub struct Encryption { inner: Secret, EncryptionStrategy>, @@ -41,7 +41,7 @@ where DB: Backend, Secret, EncryptionStrategy>: FromSql, { - fn from_sql(bytes: DB::RawValue<'_>) -> diesel::deserialize::Result { + fn from_sql(bytes: DB::RawValue<'_>) -> deserialize::Result { , EncryptionStrategy>>::from_sql(bytes).map(Self::new) } } diff --git a/crates/diesel_models/src/query/payment_attempt.rs b/crates/diesel_models/src/query/payment_attempt.rs index f23c231889..4e5773800a 100644 --- a/crates/diesel_models/src/query/payment_attempt.rs +++ b/crates/diesel_models/src/query/payment_attempt.rs @@ -10,7 +10,7 @@ use error_stack::{report, ResultExt}; use super::generics; use crate::{ enums::{self, IntentStatus}, - errors::{self, DatabaseError}, + errors::DatabaseError, payment_attempt::{ PaymentAttempt, PaymentAttemptNew, PaymentAttemptUpdate, PaymentAttemptUpdateInternal, }, @@ -246,7 +246,7 @@ impl PaymentAttempt { .distinct() .get_results_async::>(conn) .await - .change_context(errors::DatabaseError::Others) + .change_context(DatabaseError::Others) .attach_printable("Error filtering records by connector")? .into_iter() .flatten() @@ -350,7 +350,7 @@ impl PaymentAttempt { db_metrics::DatabaseOperation::Filter, ) .await - .change_context(errors::DatabaseError::Others) + .change_context(DatabaseError::Others) .attach_printable("Error filtering count of payments") } } diff --git a/crates/diesel_models/src/query/payout_attempt.rs b/crates/diesel_models/src/query/payout_attempt.rs index ac34ee695a..4f95877bd7 100644 --- a/crates/diesel_models/src/query/payout_attempt.rs +++ b/crates/diesel_models/src/query/payout_attempt.rs @@ -11,7 +11,7 @@ use error_stack::{report, ResultExt}; use super::generics; use crate::{ enums, - errors::{self, DatabaseError}, + errors::DatabaseError, payout_attempt::{ PayoutAttempt, PayoutAttemptNew, PayoutAttemptUpdate, PayoutAttemptUpdateInternal, }, @@ -46,7 +46,7 @@ impl PayoutAttempt { .await { Err(error) => match error.current_context() { - errors::DatabaseError::NoFieldsToUpdate => Ok(self), + DatabaseError::NoFieldsToUpdate => Ok(self), _ => Err(error), }, result => result, @@ -98,7 +98,7 @@ impl PayoutAttempt { .first() .cloned() .ok_or_else(|| { - report!(errors::DatabaseError::NotFound).attach_printable("Error while updating payout") + report!(DatabaseError::NotFound).attach_printable("Error while updating payout") }) } @@ -119,7 +119,7 @@ impl PayoutAttempt { .first() .cloned() .ok_or_else(|| { - report!(errors::DatabaseError::NotFound).attach_printable("Error while updating payout") + report!(DatabaseError::NotFound).attach_printable("Error while updating payout") }) } @@ -161,7 +161,7 @@ impl PayoutAttempt { .distinct() .get_results_async::>(conn) .await - .change_context(errors::DatabaseError::Others) + .change_context(DatabaseError::Others) .attach_printable("Error filtering records by connector")? .into_iter() .flatten() diff --git a/crates/drainer/src/handler.rs b/crates/drainer/src/handler.rs index 47b60db80d..35ad467d5f 100644 --- a/crates/drainer/src/handler.rs +++ b/crates/drainer/src/handler.rs @@ -95,7 +95,7 @@ impl Handler { while let Some(_c) = rx.recv().await { logger::info!("Awaiting shutdown!"); metrics::SHUTDOWN_SIGNAL_RECEIVED.add(&metrics::CONTEXT, 1, &[]); - let shutdown_started = tokio::time::Instant::now(); + let shutdown_started = time::Instant::now(); rx.close(); //Check until the active tasks are zero. This does not include the tasks in the stream. diff --git a/crates/drainer/src/lib.rs b/crates/drainer/src/lib.rs index 56f2db0907..cb2b55d202 100644 --- a/crates/drainer/src/lib.rs +++ b/crates/drainer/src/lib.rs @@ -24,7 +24,7 @@ use router_env::{ }; use tokio::sync::mpsc; -pub(crate) type Settings = crate::settings::Settings; +pub(crate) type Settings = settings::Settings; use crate::{ connection::pg_connection, services::Store, settings::DrainerSettings, types::StreamData, diff --git a/crates/euclid/src/dssa/graph.rs b/crates/euclid/src/dssa/graph.rs index 526248a381..0ffafe4d48 100644 --- a/crates/euclid/src/dssa/graph.rs +++ b/crates/euclid/src/dssa/graph.rs @@ -838,7 +838,7 @@ mod test { None::<()>, ); let mut memo = cgraph::Memoization::new(); - let mut cycle_map = cgraph::CycleCheck::new(); + let mut cycle_map = CycleCheck::new(); let _edge_1 = builder .make_edge( _node_1, @@ -894,7 +894,7 @@ mod test { None::<()>, ); let mut memo = cgraph::Memoization::new(); - let mut cycle_map = cgraph::CycleCheck::new(); + let mut cycle_map = CycleCheck::new(); let _edge_1 = builder .make_edge( @@ -986,7 +986,7 @@ mod test { ); let mut memo = cgraph::Memoization::new(); - let mut cycle_map = cgraph::CycleCheck::new(); + let mut cycle_map = CycleCheck::new(); let _edge_1 = builder .make_edge( diff --git a/crates/euclid/src/frontend/ast/parser.rs b/crates/euclid/src/frontend/ast/parser.rs index 8b2f717a86..cbfc21c96a 100644 --- a/crates/euclid/src/frontend/ast/parser.rs +++ b/crates/euclid/src/frontend/ast/parser.rs @@ -3,7 +3,7 @@ use nom::{ }; use crate::{frontend::ast, types::DummyOutput}; -pub type ParseResult = nom::IResult>; +pub type ParseResult = nom::IResult>; pub enum EuclidError { InvalidPercentage(String), @@ -50,9 +50,9 @@ impl EuclidParsable for DummyOutput { )(input) } } -pub fn skip_ws<'a, F: 'a, O>(inner: F) -> impl FnMut(&'a str) -> ParseResult<&str, O> +pub fn skip_ws<'a, F, O>(inner: F) -> impl FnMut(&'a str) -> ParseResult<&str, O> where - F: FnMut(&'a str) -> ParseResult<&str, O>, + F: FnMut(&'a str) -> ParseResult<&str, O> + 'a, { sequence::preceded(pchar::multispace0, inner) } diff --git a/crates/euclid_macros/src/inner/knowledge.rs b/crates/euclid_macros/src/inner/knowledge.rs index a9c453b42c..baef55338f 100644 --- a/crates/euclid_macros/src/inner/knowledge.rs +++ b/crates/euclid_macros/src/inner/knowledge.rs @@ -1,4 +1,8 @@ -use std::{hash::Hash, rc::Rc}; +use std::{ + fmt::{Display, Formatter}, + hash::Hash, + rc::Rc, +}; use proc_macro2::{Span, TokenStream}; use quote::{format_ident, quote}; @@ -24,15 +28,16 @@ enum Comparison { LessThanEqual, } -impl ToString for Comparison { - fn to_string(&self) -> String { - match self { - Self::LessThan => "< ".to_string(), - Self::Equal => String::new(), - Self::GreaterThanEqual => ">= ".to_string(), - Self::LessThanEqual => "<= ".to_string(), - Self::GreaterThan => "> ".to_string(), - } +impl Display for Comparison { + fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { + let symbol = match self { + Self::LessThan => "< ", + Self::Equal => return Ok(()), + Self::GreaterThanEqual => ">= ", + Self::LessThanEqual => "<= ", + Self::GreaterThan => "> ", + }; + write!(f, "{}", symbol) } } @@ -69,7 +74,7 @@ impl ValueType { Self::Any => format!("{key}(any)"), Self::EnumVariant(s) => format!("{key}({s})"), Self::Number { number, comparison } => { - format!("{}({}{})", key, comparison.to_string(), number) + format!("{}({}{})", key, comparison, number) } } } @@ -104,9 +109,9 @@ struct Atom { value: ValueType, } -impl ToString for Atom { - fn to_string(&self) -> String { - self.value.to_string(&self.key) +impl Display for Atom { + fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { + write!(f, "{}", self.value.to_string(&self.key)) } } @@ -317,15 +322,14 @@ impl Parse for Scope { } } -impl ToString for Scope { - fn to_string(&self) -> String { +impl Display for Scope { + fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { match self { - Self::Crate => "crate".to_string(), - Self::Extern => "euclid".to_string(), + Self::Crate => write!(f, "crate"), + Self::Extern => write!(f, "euclid"), } } } - #[derive(Clone)] struct Program { rules: Vec>, diff --git a/crates/euclid_wasm/src/lib.rs b/crates/euclid_wasm/src/lib.rs index 4920243bcc..3668130608 100644 --- a/crates/euclid_wasm/src/lib.rs +++ b/crates/euclid_wasm/src/lib.rs @@ -193,9 +193,7 @@ pub fn run_program(program: JsValue, input: JsValue) -> JsResult { #[wasm_bindgen(js_name = getAllConnectors)] pub fn get_all_connectors() -> JsResult { - Ok(serde_wasm_bindgen::to_value( - common_enums::RoutableConnectors::VARIANTS, - )?) + Ok(serde_wasm_bindgen::to_value(RoutableConnectors::VARIANTS)?) } #[wasm_bindgen(js_name = getAllKeys)] diff --git a/crates/hyperswitch_domain_models/src/mandates.rs b/crates/hyperswitch_domain_models/src/mandates.rs index 912ddc6705..180f733cfe 100644 --- a/crates/hyperswitch_domain_models/src/mandates.rs +++ b/crates/hyperswitch_domain_models/src/mandates.rs @@ -169,8 +169,7 @@ impl CustomerAcceptance { } pub fn get_accepted_at(&self) -> PrimitiveDateTime { - self.accepted_at - .unwrap_or_else(common_utils::date_time::now) + self.accepted_at.unwrap_or_else(date_time::now) } } diff --git a/crates/masking/src/diesel.rs b/crates/masking/src/diesel.rs index f3576298bd..ea60a861c9 100644 --- a/crates/masking/src/diesel.rs +++ b/crates/masking/src/diesel.rs @@ -52,7 +52,7 @@ where S: FromSql, I: Strategy, { - fn from_sql(bytes: DB::RawValue<'_>) -> diesel::deserialize::Result { + fn from_sql(bytes: DB::RawValue<'_>) -> deserialize::Result { S::from_sql(bytes).map(|raw| raw.into()) } } @@ -122,7 +122,7 @@ where S: FromSql + ZeroizableSecret, I: Strategy, { - fn from_sql(bytes: DB::RawValue<'_>) -> diesel::deserialize::Result { + fn from_sql(bytes: DB::RawValue<'_>) -> deserialize::Result { S::from_sql(bytes).map(|raw| raw.into()) } } diff --git a/crates/openapi/src/openapi.rs b/crates/openapi/src/openapi.rs index 1e38440839..7abbc3b77e 100644 --- a/crates/openapi/src/openapi.rs +++ b/crates/openapi/src/openapi.rs @@ -514,6 +514,8 @@ Never share your secret api keys. Keep them guarded and secure. )), modifiers(&SecurityAddon) )] +// Bypass clippy lint for not being constructed +#[allow(dead_code)] pub struct ApiDoc; struct SecurityAddon; diff --git a/crates/pm_auth/src/types.rs b/crates/pm_auth/src/types.rs index 51fd796072..d5c66b9c64 100644 --- a/crates/pm_auth/src/types.rs +++ b/crates/pm_auth/src/types.rs @@ -110,12 +110,12 @@ pub type BankDetailsRouterData = PaymentAuthRouterData< >; pub type PaymentAuthLinkTokenType = - dyn self::api::ConnectorIntegration; + dyn api::ConnectorIntegration; pub type PaymentAuthExchangeTokenType = - dyn self::api::ConnectorIntegration; + dyn api::ConnectorIntegration; -pub type PaymentAuthBankAccountDetailsType = dyn self::api::ConnectorIntegration< +pub type PaymentAuthBankAccountDetailsType = dyn api::ConnectorIntegration< BankAccountCredentials, BankAccountCredentialsRequest, BankAccountCredentialsResponse, diff --git a/crates/router/src/analytics.rs b/crates/router/src/analytics.rs index d509cf03d3..8eb94a2912 100644 --- a/crates/router/src/analytics.rs +++ b/crates/router/src/analytics.rs @@ -114,7 +114,7 @@ pub mod routes { pub async fn get_info( state: web::Data, req: actix_web::HttpRequest, - domain: actix_web::web::Path, + domain: web::Path, ) -> impl Responder { let flow = AnalyticsFlow::GetInfo; Box::pin(api::server_wrap( @@ -631,7 +631,7 @@ pub mod routes { state: web::Data, req: actix_web::HttpRequest, json_payload: web::Json, - index: actix_web::web::Path, + index: web::Path, ) -> impl Responder { let flow = AnalyticsFlow::GetSearchResults; let indexed_req = GetSearchRequestWithIndex { diff --git a/crates/router/src/bin/scheduler.rs b/crates/router/src/bin/scheduler.rs index 47f41d8700..5341a1b09c 100644 --- a/crates/router/src/bin/scheduler.rs +++ b/crates/router/src/bin/scheduler.rs @@ -40,7 +40,7 @@ async fn main() -> CustomResult<(), ProcessTrackerError> { conf.proxy.clone(), services::proxy_bypass_urls(&conf.locker), ) - .change_context(errors::ProcessTrackerError::ConfigurationError)?, + .change_context(ProcessTrackerError::ConfigurationError)?, ); // channel for listening to redis disconnect events let (redis_shutdown_signal_tx, redis_shutdown_signal_rx) = oneshot::channel(); @@ -320,7 +320,7 @@ async fn start_scheduler( .conf .scheduler .clone() - .ok_or(errors::ProcessTrackerError::ConfigurationError)?; + .ok_or(ProcessTrackerError::ConfigurationError)?; scheduler::start_process_tracker( state, scheduler_flow, diff --git a/crates/router/src/compatibility/stripe/payment_intents/types.rs b/crates/router/src/compatibility/stripe/payment_intents/types.rs index eed80a1128..3d5264ddbe 100644 --- a/crates/router/src/compatibility/stripe/payment_intents/types.rs +++ b/crates/router/src/compatibility/stripe/payment_intents/types.rs @@ -649,7 +649,7 @@ fn from_timestamp_to_datetime( } })?; - Ok(Some(time::PrimitiveDateTime::new(time.date(), time.time()))) + Ok(Some(PrimitiveDateTime::new(time.date(), time.time()))) } else { Ok(None) } @@ -744,7 +744,7 @@ impl ForeignTryFrom<(Option, Option)> for Option Some(api_models::payments::MandateType::MultiUse(Some( + None => Some(payments::MandateType::MultiUse(Some( payments::MandateAmountData { amount: mandate.amount.unwrap_or_default(), currency, diff --git a/crates/router/src/configs/settings.rs b/crates/router/src/configs/settings.rs index adc09fb55a..5b55ca8b0e 100644 --- a/crates/router/src/configs/settings.rs +++ b/crates/router/src/configs/settings.rs @@ -200,7 +200,7 @@ pub struct ApplepayMerchantConfigs { #[derive(Debug, Deserialize, Clone, Default)] pub struct MultipleApiVersionSupportedConnectors { #[serde(deserialize_with = "deserialize_hashset")] - pub supported_connectors: HashSet, + pub supported_connectors: HashSet, } #[derive(Debug, Deserialize, Clone, Default)] @@ -214,10 +214,10 @@ pub struct TempLockerEnableConfig(pub HashMap, + pub connector_list: HashSet, #[cfg(feature = "payouts")] #[serde(deserialize_with = "deserialize_hashset")] - pub payout_connector_list: HashSet, + pub payout_connector_list: HashSet, } #[cfg(feature = "dummy_connector")] @@ -263,7 +263,7 @@ pub struct Mandates { #[derive(Debug, Deserialize, Clone, Default)] pub struct NetworkTransactionIdSupportedConnectors { #[serde(deserialize_with = "deserialize_hashset")] - pub connector_list: HashSet, + pub connector_list: HashSet, } #[derive(Debug, Deserialize, Clone)] @@ -279,7 +279,7 @@ pub struct SupportedPaymentMethodTypesForMandate( #[derive(Debug, Deserialize, Clone)] pub struct SupportedConnectorsForMandate { #[serde(deserialize_with = "deserialize_hashset")] - pub connector_list: HashSet, + pub connector_list: HashSet, } #[derive(Debug, Deserialize, Clone, Default)] @@ -322,9 +322,7 @@ pub enum PaymentMethodTypeTokenFilter { } #[derive(Debug, Deserialize, Clone, Default)] -pub struct BankRedirectConfig( - pub HashMap, -); +pub struct BankRedirectConfig(pub HashMap); #[derive(Debug, Deserialize, Clone)] pub struct ConnectorBankNames(pub HashMap); @@ -345,17 +343,17 @@ pub struct PaymentMethodFilters(pub HashMap>, + pub currency: Option>, #[serde(deserialize_with = "deserialize_optional_hashset")] - pub country: Option>, + pub country: Option>, pub not_available_flows: Option, } @@ -628,13 +626,13 @@ pub struct ApiKeys { #[derive(Debug, Deserialize, Clone, Default)] pub struct DelayedSessionConfig { #[serde(deserialize_with = "deserialize_hashset")] - pub connectors_with_delayed_session_response: HashSet, + pub connectors_with_delayed_session_response: HashSet, } #[derive(Debug, Deserialize, Clone, Default)] pub struct WebhookSourceVerificationCall { #[serde(deserialize_with = "deserialize_hashset")] - pub connectors_with_webhook_source_verification_call: HashSet, + pub connectors_with_webhook_source_verification_call: HashSet, } #[derive(Debug, Deserialize, Clone, Default)] diff --git a/crates/router/src/connector/aci/transformers.rs b/crates/router/src/connector/aci/transformers.rs index 23288e3819..9353b848bd 100644 --- a/crates/router/src/connector/aci/transformers.rs +++ b/crates/router/src/connector/aci/transformers.rs @@ -22,20 +22,13 @@ pub struct AciRouterData { router_data: T, } -impl - TryFrom<( - &types::api::CurrencyUnit, - types::storage::enums::Currency, - i64, - T, - )> for AciRouterData -{ +impl TryFrom<(&types::api::CurrencyUnit, enums::Currency, i64, T)> for AciRouterData { type Error = error_stack::Report; fn try_from( (currency_unit, currency, amount, item): ( &types::api::CurrencyUnit, - types::storage::enums::Currency, + enums::Currency, i64, T, ), diff --git a/crates/router/src/connector/adyen/transformers.rs b/crates/router/src/connector/adyen/transformers.rs index 6dfe899f2d..77abaacf40 100644 --- a/crates/router/src/connector/adyen/transformers.rs +++ b/crates/router/src/connector/adyen/transformers.rs @@ -1720,7 +1720,7 @@ fn get_amount_data(item: &AdyenRouterData<&types::PaymentsAuthorizeRouterData>) } fn get_address_info( - address: Option<&api_models::payments::Address>, + address: Option<&payments::Address>, ) -> Option>> { address.and_then(|add| { add.address.as_ref().map( @@ -1783,7 +1783,7 @@ fn get_telephone_number(item: &types::PaymentsAuthorizeRouterData) -> Option) -> Option { +fn get_shopper_name(address: Option<&payments::Address>) -> Option { let billing = address.and_then(|billing| billing.address.as_ref()); Some(ShopperName { first_name: billing.and_then(|a| a.first_name.clone()), @@ -1791,9 +1791,7 @@ fn get_shopper_name(address: Option<&api_models::payments::Address>) -> Option, -) -> Option { +fn get_country_code(address: Option<&payments::Address>) -> Option { address.and_then(|billing| billing.address.as_ref().and_then(|address| address.country)) } diff --git a/crates/router/src/connector/airwallex.rs b/crates/router/src/connector/airwallex.rs index 91a27fc3df..bdd842bf95 100644 --- a/crates/router/src/connector/airwallex.rs +++ b/crates/router/src/connector/airwallex.rs @@ -223,7 +223,7 @@ impl ConnectorIntegration { pub router_data: T, } -impl - TryFrom<( - &types::api::CurrencyUnit, - types::storage::enums::Currency, - i64, - T, - )> for AirwallexRouterData -{ +impl TryFrom<(&api::CurrencyUnit, enums::Currency, i64, T)> for AirwallexRouterData { type Error = error_stack::Report; fn try_from( (currency_unit, currency, amount, router_data): ( - &types::api::CurrencyUnit, - types::storage::enums::Currency, + &api::CurrencyUnit, + enums::Currency, i64, T, ), diff --git a/crates/router/src/connector/authorizedotnet.rs b/crates/router/src/connector/authorizedotnet.rs index 7f9cdc376e..2ca78e630f 100644 --- a/crates/router/src/connector/authorizedotnet.rs +++ b/crates/router/src/connector/authorizedotnet.rs @@ -39,8 +39,7 @@ where &self, _req: &types::RouterData, _connectors: &settings::Connectors, - ) -> CustomResult)>, errors::ConnectorError> - { + ) -> CustomResult)>, errors::ConnectorError> { Ok(vec![( headers::CONTENT_TYPE.to_string(), self.get_content_type().to_string().into(), diff --git a/crates/router/src/connector/authorizedotnet/transformers.rs b/crates/router/src/connector/authorizedotnet/transformers.rs index a072fcf321..ca8b13298b 100644 --- a/crates/router/src/connector/authorizedotnet/transformers.rs +++ b/crates/router/src/connector/authorizedotnet/transformers.rs @@ -46,22 +46,10 @@ pub struct AuthorizedotnetRouterData { pub router_data: T, } -impl - TryFrom<( - &types::api::CurrencyUnit, - types::storage::enums::Currency, - i64, - T, - )> for AuthorizedotnetRouterData -{ +impl TryFrom<(&api::CurrencyUnit, enums::Currency, i64, T)> for AuthorizedotnetRouterData { type Error = error_stack::Report; fn try_from( - (currency_unit, currency, amount, item): ( - &types::api::CurrencyUnit, - types::storage::enums::Currency, - i64, - T, - ), + (currency_unit, currency, amount, item): (&api::CurrencyUnit, enums::Currency, i64, T), ) -> Result { let amount = utils::get_amount_as_f64(currency_unit, amount, currency)?; Ok(Self { diff --git a/crates/router/src/connector/bambora/transformers.rs b/crates/router/src/connector/bambora/transformers.rs index dbb655c6ca..77c91af709 100644 --- a/crates/router/src/connector/bambora/transformers.rs +++ b/crates/router/src/connector/bambora/transformers.rs @@ -20,22 +20,10 @@ pub struct BamboraRouterData { pub router_data: T, } -impl - TryFrom<( - &types::api::CurrencyUnit, - types::storage::enums::Currency, - i64, - T, - )> for BamboraRouterData -{ +impl TryFrom<(&api::CurrencyUnit, enums::Currency, i64, T)> for BamboraRouterData { type Error = error_stack::Report; fn try_from( - (currency_unit, currency, amount, item): ( - &types::api::CurrencyUnit, - types::storage::enums::Currency, - i64, - T, - ), + (currency_unit, currency, amount, item): (&api::CurrencyUnit, enums::Currency, i64, T), ) -> Result { let amount = crate::connector::utils::get_amount_as_f64(currency_unit, amount, currency)?; Ok(Self { diff --git a/crates/router/src/connector/bankofamerica.rs b/crates/router/src/connector/bankofamerica.rs index 0c01facf38..e5ddd3743b 100644 --- a/crates/router/src/connector/bankofamerica.rs +++ b/crates/router/src/connector/bankofamerica.rs @@ -120,8 +120,7 @@ where &self, req: &types::RouterData, connectors: &settings::Connectors, - ) -> CustomResult)>, errors::ConnectorError> - { + ) -> CustomResult)>, errors::ConnectorError> { let date = OffsetDateTime::now_utc(); let boa_req = self.get_request_body(req, connectors)?; let http_method = self.get_http_method(); diff --git a/crates/router/src/connector/bankofamerica/transformers.rs b/crates/router/src/connector/bankofamerica/transformers.rs index efece7f61f..2d7b230703 100644 --- a/crates/router/src/connector/bankofamerica/transformers.rs +++ b/crates/router/src/connector/bankofamerica/transformers.rs @@ -58,22 +58,10 @@ pub struct BankOfAmericaRouterData { pub router_data: T, } -impl - TryFrom<( - &types::api::CurrencyUnit, - types::storage::enums::Currency, - i64, - T, - )> for BankOfAmericaRouterData -{ +impl TryFrom<(&api::CurrencyUnit, enums::Currency, i64, T)> for BankOfAmericaRouterData { type Error = error_stack::Report; fn try_from( - (currency_unit, currency, amount, item): ( - &types::api::CurrencyUnit, - types::storage::enums::Currency, - i64, - T, - ), + (currency_unit, currency, amount, item): (&api::CurrencyUnit, enums::Currency, i64, T), ) -> Result { let amount = utils::get_amount_as_string(currency_unit, amount, currency)?; Ok(Self { @@ -602,7 +590,7 @@ impl merchant_intitiated_transaction: Some(MerchantInitiatedTransaction { reason: None, original_authorized_amount: Some(utils::get_amount_as_string( - &types::api::CurrencyUnit::Base, + &api::CurrencyUnit::Base, original_amount, original_currency, )?), diff --git a/crates/router/src/connector/billwerk/transformers.rs b/crates/router/src/connector/billwerk/transformers.rs index 4e91a2c9ff..3e5e53286e 100644 --- a/crates/router/src/connector/billwerk/transformers.rs +++ b/crates/router/src/connector/billwerk/transformers.rs @@ -14,22 +14,10 @@ pub struct BillwerkRouterData { pub router_data: T, } -impl - TryFrom<( - &types::api::CurrencyUnit, - types::storage::enums::Currency, - i64, - T, - )> for BillwerkRouterData -{ +impl TryFrom<(&api::CurrencyUnit, enums::Currency, i64, T)> for BillwerkRouterData { type Error = error_stack::Report; fn try_from( - (_currency_unit, _currency, amount, item): ( - &types::api::CurrencyUnit, - types::storage::enums::Currency, - i64, - T, - ), + (_currency_unit, _currency, amount, item): (&api::CurrencyUnit, enums::Currency, i64, T), ) -> Result { Ok(Self { amount, diff --git a/crates/router/src/connector/bitpay/transformers.rs b/crates/router/src/connector/bitpay/transformers.rs index 74fa0b5c59..a70c4ba3ac 100644 --- a/crates/router/src/connector/bitpay/transformers.rs +++ b/crates/router/src/connector/bitpay/transformers.rs @@ -15,20 +15,13 @@ pub struct BitpayRouterData { pub router_data: T, } -impl - TryFrom<( - &types::api::CurrencyUnit, - types::storage::enums::Currency, - i64, - T, - )> for BitpayRouterData -{ +impl TryFrom<(&api::CurrencyUnit, enums::Currency, i64, T)> for BitpayRouterData { type Error = error_stack::Report; fn try_from( (_currency_unit, _currency, amount, router_data): ( - &types::api::CurrencyUnit, - types::storage::enums::Currency, + &api::CurrencyUnit, + enums::Currency, i64, T, ), @@ -81,7 +74,7 @@ impl TryFrom<&ConnectorAuthType> for BitpayAuthType { type Error = error_stack::Report; fn try_from(auth_type: &ConnectorAuthType) -> Result { match auth_type { - types::ConnectorAuthType::HeaderKey { api_key } => Ok(Self { + ConnectorAuthType::HeaderKey { api_key } => Ok(Self { api_key: api_key.to_owned(), }), _ => Err(errors::ConnectorError::FailedToObtainAuthType.into()), diff --git a/crates/router/src/connector/bluesnap/transformers.rs b/crates/router/src/connector/bluesnap/transformers.rs index 2a572a2231..0630fef274 100644 --- a/crates/router/src/connector/bluesnap/transformers.rs +++ b/crates/router/src/connector/bluesnap/transformers.rs @@ -36,22 +36,10 @@ pub struct BluesnapRouterData { pub router_data: T, } -impl - TryFrom<( - &types::api::CurrencyUnit, - types::storage::enums::Currency, - i64, - T, - )> for BluesnapRouterData -{ +impl TryFrom<(&api::CurrencyUnit, enums::Currency, i64, T)> for BluesnapRouterData { type Error = error_stack::Report; fn try_from( - (currency_unit, currency, amount, item): ( - &types::api::CurrencyUnit, - types::storage::enums::Currency, - i64, - T, - ), + (currency_unit, currency, amount, item): (&api::CurrencyUnit, enums::Currency, i64, T), ) -> Result { let amount = utils::get_amount_as_string(currency_unit, amount, currency)?; Ok(Self { @@ -150,7 +138,7 @@ pub struct BluesnapGooglePayObject { #[derive(Debug, Serialize)] #[serde(rename_all = "camelCase")] pub struct BluesnapApplePayObject { - token: api_models::payments::ApplePayWalletData, + token: payments::ApplePayWalletData, } #[derive(Debug, Serialize)] @@ -447,23 +435,19 @@ impl TryFrom<&types::PaymentsSessionRouterData> for BluesnapCreateWalletToken { let apple_pay_metadata = item.get_connector_meta()?.expose(); let applepay_metadata = apple_pay_metadata .clone() - .parse_value::( + .parse_value::( "ApplepayCombinedSessionTokenData", ) .map(|combined_metadata| { - api_models::payments::ApplepaySessionTokenMetadata::ApplePayCombined( + payments::ApplepaySessionTokenMetadata::ApplePayCombined( combined_metadata.apple_pay_combined, ) }) .or_else(|_| { apple_pay_metadata - .parse_value::( - "ApplepaySessionTokenData", - ) + .parse_value::("ApplepaySessionTokenData") .map(|old_metadata| { - api_models::payments::ApplepaySessionTokenMetadata::ApplePay( - old_metadata.apple_pay, - ) + payments::ApplepaySessionTokenMetadata::ApplePay(old_metadata.apple_pay) }) }) .change_context(errors::ConnectorError::ParsingFailed)?; @@ -500,31 +484,26 @@ impl TryFrom( + .parse_value::( "ApplepayCombinedSessionTokenData", ) .map(|combined_metadata| { - api_models::payments::ApplepaySessionTokenMetadata::ApplePayCombined( + payments::ApplepaySessionTokenMetadata::ApplePayCombined( combined_metadata.apple_pay_combined, ) }) .or_else(|_| { metadata - .parse_value::( - "ApplepaySessionTokenData", - ) + .parse_value::("ApplepaySessionTokenData") .map(|old_metadata| { - api_models::payments::ApplepaySessionTokenMetadata::ApplePay( - old_metadata.apple_pay, - ) + payments::ApplepaySessionTokenMetadata::ApplePay(old_metadata.apple_pay) }) }) .change_context(errors::ConnectorError::ParsingFailed)?; @@ -543,16 +522,15 @@ impl TryFrom Ok(hosted_value .redirect_url - .map(|url| services::RedirectForm::from((url, services::Method::Get)))), + .map(|url| RedirectForm::from((url, services::Method::Get)))), None => Err(errors::ConnectorError::MissingConnectorRedirectionPayload { field_name: "redirect_url", }), diff --git a/crates/router/src/connector/braintree.rs b/crates/router/src/connector/braintree.rs index 1b55f12cab..f7e142a9af 100644 --- a/crates/router/src/connector/braintree.rs +++ b/crates/router/src/connector/braintree.rs @@ -1467,10 +1467,8 @@ impl api::IncomingWebhook for Braintree { match response.dispute { Some(dispute_data) => { - let currency = diesel_models::enums::Currency::from_str( - dispute_data.currency_iso_code.as_str(), - ) - .change_context(errors::ConnectorError::WebhookBodyDecodingFailed)?; + let currency = enums::Currency::from_str(dispute_data.currency_iso_code.as_str()) + .change_context(errors::ConnectorError::WebhookBodyDecodingFailed)?; Ok(api::disputes::DisputePayload { amount: connector_utils::to_currency_lower_unit( dispute_data.amount_disputed.to_string(), diff --git a/crates/router/src/connector/braintree/braintree_graphql_transformers.rs b/crates/router/src/connector/braintree/braintree_graphql_transformers.rs index 480867c6cb..bd860e7290 100644 --- a/crates/router/src/connector/braintree/braintree_graphql_transformers.rs +++ b/crates/router/src/connector/braintree/braintree_graphql_transformers.rs @@ -27,22 +27,10 @@ pub struct BraintreeRouterData { pub router_data: T, } -impl - TryFrom<( - &types::api::CurrencyUnit, - types::storage::enums::Currency, - i64, - T, - )> for BraintreeRouterData -{ +impl TryFrom<(&api::CurrencyUnit, enums::Currency, i64, T)> for BraintreeRouterData { type Error = error_stack::Report; fn try_from( - (currency_unit, currency, amount, item): ( - &types::api::CurrencyUnit, - types::storage::enums::Currency, - i64, - T, - ), + (currency_unit, currency, amount, item): (&api::CurrencyUnit, enums::Currency, i64, T), ) -> Result { let amount = utils::get_amount_as_string(currency_unit, amount, currency)?; Ok(Self { @@ -80,7 +68,7 @@ pub enum BraintreePaymentsRequest { #[derive(Debug, Deserialize)] pub struct BraintreeMeta { merchant_account_id: Secret, - merchant_config_currency: types::storage::enums::Currency, + merchant_config_currency: enums::Currency, } impl TryFrom<&Option> for BraintreeMeta { diff --git a/crates/router/src/connector/braintree/transformers.rs b/crates/router/src/connector/braintree/transformers.rs index ef111a2588..e278ff40b4 100644 --- a/crates/router/src/connector/braintree/transformers.rs +++ b/crates/router/src/connector/braintree/transformers.rs @@ -21,7 +21,7 @@ pub struct PaymentOptions { #[derive(Debug, Deserialize)] pub struct BraintreeMeta { merchant_account_id: Option>, - merchant_config_currency: Option, + merchant_config_currency: Option, } #[derive(Debug, Serialize, Eq, PartialEq)] @@ -304,7 +304,7 @@ impl ) -> Result { Ok(Self { response: Ok(types::PaymentsResponseData::SessionResponse { - session_token: types::api::SessionToken::Paypal(Box::new( + session_token: api::SessionToken::Paypal(Box::new( payments::PaypalSessionTokenResponse { session_token: item.response.client_token.value.expose(), }, diff --git a/crates/router/src/connector/cashtocode/transformers.rs b/crates/router/src/connector/cashtocode/transformers.rs index 525b19df00..f8c275df33 100644 --- a/crates/router/src/connector/cashtocode/transformers.rs +++ b/crates/router/src/connector/cashtocode/transformers.rs @@ -203,13 +203,13 @@ fn get_redirect_form_data( enums::PaymentMethodType::ClassicReward => Ok(services::RedirectForm::Form { //redirect form is manually constructed because the connector for this pm type expects query params in the url endpoint: response_data.pay_url.to_string(), - method: services::Method::Post, + method: Method::Post, form_fields: Default::default(), }), enums::PaymentMethodType::Evoucher => Ok(services::RedirectForm::from(( //here the pay url gets parsed, and query params are sent as formfields as the connector expects response_data.pay_url, - services::Method::Get, + Method::Get, ))), _ => Err(errors::ConnectorError::NotImplemented( utils::get_unimplemented_payment_method_error_message("CashToCode"), diff --git a/crates/router/src/connector/checkout/transformers.rs b/crates/router/src/connector/checkout/transformers.rs index 3fff6d940d..cc937c0ef6 100644 --- a/crates/router/src/connector/checkout/transformers.rs +++ b/crates/router/src/connector/checkout/transformers.rs @@ -23,22 +23,10 @@ pub struct CheckoutRouterData { pub router_data: T, } -impl - TryFrom<( - &types::api::CurrencyUnit, - types::storage::enums::Currency, - i64, - T, - )> for CheckoutRouterData -{ +impl TryFrom<(&api::CurrencyUnit, enums::Currency, i64, T)> for CheckoutRouterData { type Error = error_stack::Report; fn try_from( - (_currency_unit, _currency, amount, item): ( - &types::api::CurrencyUnit, - types::storage::enums::Currency, - i64, - T, - ), + (_currency_unit, _currency, amount, item): (&api::CurrencyUnit, enums::Currency, i64, T), ) -> Result { Ok(Self { amount, diff --git a/crates/router/src/connector/coinbase.rs b/crates/router/src/connector/coinbase.rs index 8bfbe8b695..497cf81918 100644 --- a/crates/router/src/connector/coinbase.rs +++ b/crates/router/src/connector/coinbase.rs @@ -52,8 +52,7 @@ where &self, req: &types::RouterData, _connectors: &settings::Connectors, - ) -> CustomResult)>, errors::ConnectorError> - { + ) -> CustomResult)>, errors::ConnectorError> { let mut header = vec![ ( headers::CONTENT_TYPE.to_string(), diff --git a/crates/router/src/connector/cryptopay/transformers.rs b/crates/router/src/connector/cryptopay/transformers.rs index b8f398a0d9..baea07faa6 100644 --- a/crates/router/src/connector/cryptopay/transformers.rs +++ b/crates/router/src/connector/cryptopay/transformers.rs @@ -19,19 +19,12 @@ pub struct CryptopayRouterData { pub router_data: T, } -impl - TryFrom<( - &types::api::CurrencyUnit, - types::storage::enums::Currency, - i64, - T, - )> for CryptopayRouterData -{ +impl TryFrom<(&types::api::CurrencyUnit, enums::Currency, i64, T)> for CryptopayRouterData { type Error = error_stack::Report; fn try_from( (currency_unit, currency, amount, item): ( &types::api::CurrencyUnit, - types::storage::enums::Currency, + enums::Currency, i64, T, ), diff --git a/crates/router/src/connector/cybersource.rs b/crates/router/src/connector/cybersource.rs index d93a9405ae..1a85498ad0 100644 --- a/crates/router/src/connector/cybersource.rs +++ b/crates/router/src/connector/cybersource.rs @@ -233,8 +233,7 @@ where &self, req: &types::RouterData, connectors: &settings::Connectors, - ) -> CustomResult)>, errors::ConnectorError> - { + ) -> CustomResult)>, errors::ConnectorError> { let date = OffsetDateTime::now_utc(); let cybersource_req = self.get_request_body(req, connectors)?; let auth = cybersource::CybersourceAuthType::try_from(&req.connector_auth_type)?; @@ -740,8 +739,7 @@ impl ConnectorIntegration CustomResult)>, errors::ConnectorError> - { + ) -> CustomResult)>, errors::ConnectorError> { self.build_headers(req, connectors) } @@ -837,12 +835,12 @@ impl ConnectorIntegration CustomResult { Ok(format!( "{}pts/v2/payments/", - api::ConnectorCommon::base_url(self, connectors) + ConnectorCommon::base_url(self, connectors) )) } fn get_request_body( diff --git a/crates/router/src/connector/cybersource/transformers.rs b/crates/router/src/connector/cybersource/transformers.rs index 8251de8ca3..545ee672ed 100644 --- a/crates/router/src/connector/cybersource/transformers.rs +++ b/crates/router/src/connector/cybersource/transformers.rs @@ -38,22 +38,10 @@ pub struct CybersourceRouterData { pub router_data: T, } -impl - TryFrom<( - &types::api::CurrencyUnit, - types::storage::enums::Currency, - i64, - T, - )> for CybersourceRouterData -{ +impl TryFrom<(&api::CurrencyUnit, enums::Currency, i64, T)> for CybersourceRouterData { type Error = error_stack::Report; fn try_from( - (currency_unit, currency, amount, item): ( - &types::api::CurrencyUnit, - types::storage::enums::Currency, - i64, - T, - ), + (currency_unit, currency, amount, item): (&api::CurrencyUnit, enums::Currency, i64, T), ) -> Result { // This conversion function is used at different places in the file, if updating this, keep a check for those let amount = utils::get_amount_as_string(currency_unit, amount, currency)?; @@ -570,7 +558,7 @@ impl .clone() .and_then(|mandate_id| mandate_id.mandate_reference_id) { - Some(api_models::payments::MandateReferenceId::ConnectorMandateId(_)) => { + Some(payments::MandateReferenceId::ConnectorMandateId(_)) => { let original_amount = item .router_data .get_recurring_mandate_payment_data()? @@ -587,7 +575,7 @@ impl merchant_intitiated_transaction: Some(MerchantInitiatedTransaction { reason: None, original_authorized_amount: Some(utils::get_amount_as_string( - &types::api::CurrencyUnit::Base, + &api::CurrencyUnit::Base, original_amount, original_currency, )?), @@ -596,9 +584,7 @@ impl }), ) } - Some(api_models::payments::MandateReferenceId::NetworkMandateId( - network_transaction_id, - )) => { + Some(payments::MandateReferenceId::NetworkMandateId(network_transaction_id)) => { let (original_amount, original_currency) = match network .clone() .map(|network| network.to_lowercase()) diff --git a/crates/router/src/connector/dlocal.rs b/crates/router/src/connector/dlocal.rs index c92c6b8b85..dc99619e9d 100644 --- a/crates/router/src/connector/dlocal.rs +++ b/crates/router/src/connector/dlocal.rs @@ -56,8 +56,7 @@ where &self, req: &types::RouterData, connectors: &settings::Connectors, - ) -> CustomResult)>, errors::ConnectorError> - { + ) -> CustomResult)>, errors::ConnectorError> { let dlocal_req = self.get_request_body(req, connectors)?; let date = date_time::date_as_yyyymmddthhmmssmmmz() diff --git a/crates/router/src/connector/dlocal/transformers.rs b/crates/router/src/connector/dlocal/transformers.rs index 14337ca076..c073dc03cc 100644 --- a/crates/router/src/connector/dlocal/transformers.rs +++ b/crates/router/src/connector/dlocal/transformers.rs @@ -57,20 +57,13 @@ pub struct DlocalRouterData { pub router_data: T, } -impl - TryFrom<( - &types::api::CurrencyUnit, - types::storage::enums::Currency, - i64, - T, - )> for DlocalRouterData -{ +impl TryFrom<(&api::CurrencyUnit, enums::Currency, i64, T)> for DlocalRouterData { type Error = error_stack::Report; fn try_from( (_currency_unit, _currency, amount, router_data): ( - &types::api::CurrencyUnit, - types::storage::enums::Currency, + &api::CurrencyUnit, + enums::Currency, i64, T, ), diff --git a/crates/router/src/connector/fiserv/transformers.rs b/crates/router/src/connector/fiserv/transformers.rs index fcb808c670..3d40876c35 100644 --- a/crates/router/src/connector/fiserv/transformers.rs +++ b/crates/router/src/connector/fiserv/transformers.rs @@ -18,20 +18,13 @@ pub struct FiservRouterData { pub router_data: T, } -impl - TryFrom<( - &types::api::CurrencyUnit, - types::storage::enums::Currency, - i64, - T, - )> for FiservRouterData -{ +impl TryFrom<(&api::CurrencyUnit, enums::Currency, i64, T)> for FiservRouterData { type Error = error_stack::Report; fn try_from( (currency_unit, currency, amount, router_data): ( - &types::api::CurrencyUnit, - types::storage::enums::Currency, + &api::CurrencyUnit, + enums::Currency, i64, T, ), diff --git a/crates/router/src/connector/globalpay/transformers.rs b/crates/router/src/connector/globalpay/transformers.rs index cfb822715b..478da2cf90 100644 --- a/crates/router/src/connector/globalpay/transformers.rs +++ b/crates/router/src/connector/globalpay/transformers.rs @@ -269,7 +269,7 @@ impl }) .transpose()?; let redirection_data = - redirect_url.map(|url| services::RedirectForm::from((url, services::Method::Get))); + redirect_url.map(|url| RedirectForm::from((url, services::Method::Get))); Ok(Self { status, response: get_payment_response(status, item.response, redirection_data), @@ -434,8 +434,8 @@ fn get_mandate_details(item: &types::PaymentsAuthorizeRouterData) -> Result requests::Sequence::Subsequent, - false => requests::Sequence::First, + true => Sequence::Subsequent, + false => Sequence::First, }), }), connector_mandate_id, diff --git a/crates/router/src/connector/gocardless/transformers.rs b/crates/router/src/connector/gocardless/transformers.rs index 59177307f2..e05f1b469a 100644 --- a/crates/router/src/connector/gocardless/transformers.rs +++ b/crates/router/src/connector/gocardless/transformers.rs @@ -24,22 +24,10 @@ pub struct GocardlessRouterData { pub router_data: T, } -impl - TryFrom<( - &types::api::CurrencyUnit, - types::storage::enums::Currency, - i64, - T, - )> for GocardlessRouterData -{ +impl TryFrom<(&api::CurrencyUnit, enums::Currency, i64, T)> for GocardlessRouterData { type Error = error_stack::Report; fn try_from( - (_currency_unit, _currency, amount, item): ( - &types::api::CurrencyUnit, - types::storage::enums::Currency, - i64, - T, - ), + (_currency_unit, _currency, amount, item): (&api::CurrencyUnit, enums::Currency, i64, T), ) -> Result { Ok(Self { amount, @@ -736,7 +724,7 @@ impl Ok(Self { status: enums::AttemptStatus::from(item.response.payments.status), response: Ok(types::PaymentsResponseData::TransactionResponse { - resource_id: types::ResponseId::ConnectorTransactionId(item.response.payments.id), + resource_id: ResponseId::ConnectorTransactionId(item.response.payments.id), redirection_data: None, mandate_reference: Some(mandate_reference), connector_metadata: None, @@ -771,7 +759,7 @@ impl Ok(Self { status: enums::AttemptStatus::from(item.response.payments.status), response: Ok(types::PaymentsResponseData::TransactionResponse { - resource_id: types::ResponseId::ConnectorTransactionId(item.response.payments.id), + resource_id: ResponseId::ConnectorTransactionId(item.response.payments.id), redirection_data: None, mandate_reference: None, connector_metadata: None, diff --git a/crates/router/src/connector/helcim/transformers.rs b/crates/router/src/connector/helcim/transformers.rs index 2dc44c8a19..655d8a8663 100644 --- a/crates/router/src/connector/helcim/transformers.rs +++ b/crates/router/src/connector/helcim/transformers.rs @@ -19,22 +19,10 @@ pub struct HelcimRouterData { pub router_data: T, } -impl - TryFrom<( - &types::api::CurrencyUnit, - types::storage::enums::Currency, - i64, - T, - )> for HelcimRouterData -{ +impl TryFrom<(&api::CurrencyUnit, enums::Currency, i64, T)> for HelcimRouterData { type Error = error_stack::Report; fn try_from( - (currency_unit, currency, amount, item): ( - &types::api::CurrencyUnit, - types::storage::enums::Currency, - i64, - T, - ), + (currency_unit, currency, amount, item): (&api::CurrencyUnit, enums::Currency, i64, T), ) -> Result { let amount = utils::get_amount_as_f64(currency_unit, amount, currency)?; Ok(Self { @@ -45,9 +33,9 @@ impl } pub fn check_currency( - currency: types::storage::enums::Currency, -) -> Result { - if currency == types::storage::enums::Currency::USD { + currency: enums::Currency, +) -> Result { + if currency == enums::Currency::USD { Ok(currency) } else { Err(errors::ConnectorError::NotSupported { diff --git a/crates/router/src/connector/iatapay/transformers.rs b/crates/router/src/connector/iatapay/transformers.rs index 8e45b96e69..bce25a7642 100644 --- a/crates/router/src/connector/iatapay/transformers.rs +++ b/crates/router/src/connector/iatapay/transformers.rs @@ -37,22 +37,10 @@ pub struct IatapayRouterData { amount: f64, router_data: T, } -impl - TryFrom<( - &types::api::CurrencyUnit, - types::storage::enums::Currency, - i64, - T, - )> for IatapayRouterData -{ +impl TryFrom<(&api::CurrencyUnit, enums::Currency, i64, T)> for IatapayRouterData { type Error = error_stack::Report; fn try_from( - (currency_unit, currency, amount, item): ( - &types::api::CurrencyUnit, - types::storage::enums::Currency, - i64, - T, - ), + (currency_unit, currency, amount, item): (&api::CurrencyUnit, enums::Currency, i64, T), ) -> Result { Ok(Self { amount: connector_util::get_amount_as_f64(currency_unit, amount, currency)?, @@ -114,7 +102,7 @@ impl TryFrom< &IatapayRouterData< &types::RouterData< - types::api::payments::Authorize, + api::payments::Authorize, PaymentsAuthorizeData, types::PaymentsResponseData, >, @@ -126,7 +114,7 @@ impl fn try_from( item: &IatapayRouterData< &types::RouterData< - types::api::payments::Authorize, + api::payments::Authorize, PaymentsAuthorizeData, types::PaymentsResponseData, >, diff --git a/crates/router/src/connector/klarna/transformers.rs b/crates/router/src/connector/klarna/transformers.rs index 29dccfbf32..db77b9c30c 100644 --- a/crates/router/src/connector/klarna/transformers.rs +++ b/crates/router/src/connector/klarna/transformers.rs @@ -14,20 +14,13 @@ pub struct KlarnaRouterData { router_data: T, } -impl - TryFrom<( - &types::api::CurrencyUnit, - types::storage::enums::Currency, - i64, - T, - )> for KlarnaRouterData -{ +impl TryFrom<(&types::api::CurrencyUnit, enums::Currency, i64, T)> for KlarnaRouterData { type Error = error_stack::Report; fn try_from( (_currency_unit, _currency, amount, router_data): ( &types::api::CurrencyUnit, - types::storage::enums::Currency, + enums::Currency, i64, T, ), diff --git a/crates/router/src/connector/multisafepay/transformers.rs b/crates/router/src/connector/multisafepay/transformers.rs index 850bd058e4..f993928d94 100644 --- a/crates/router/src/connector/multisafepay/transformers.rs +++ b/crates/router/src/connector/multisafepay/transformers.rs @@ -20,23 +20,11 @@ pub struct MultisafepayRouterData { router_data: T, } -impl - TryFrom<( - &types::api::CurrencyUnit, - types::storage::enums::Currency, - i64, - T, - )> for MultisafepayRouterData -{ +impl TryFrom<(&api::CurrencyUnit, enums::Currency, i64, T)> for MultisafepayRouterData { type Error = error_stack::Report; fn try_from( - (_currency_unit, _currency, amount, item): ( - &types::api::CurrencyUnit, - types::storage::enums::Currency, - i64, - T, - ), + (_currency_unit, _currency, amount, item): (&api::CurrencyUnit, enums::Currency, i64, T), ) -> Result { Ok(Self { amount, @@ -677,9 +665,8 @@ impl MultisafepayPaymentStatus::Declined }; - let status = enums::AttemptStatus::from( - payment_response.data.status.unwrap_or(default_status), - ); + let status = + AttemptStatus::from(payment_response.data.status.unwrap_or(default_status)); Ok(Self { status, diff --git a/crates/router/src/connector/netcetera/transformers.rs b/crates/router/src/connector/netcetera/transformers.rs index 7c95578bfd..4bf61ce1ca 100644 --- a/crates/router/src/connector/netcetera/transformers.rs +++ b/crates/router/src/connector/netcetera/transformers.rs @@ -16,18 +16,13 @@ pub struct NetceteraRouterData { pub router_data: T, } -impl - TryFrom<( - &types::api::CurrencyUnit, - types::storage::enums::Currency, - i64, - T, - )> for NetceteraRouterData +impl TryFrom<(&api::CurrencyUnit, types::storage::enums::Currency, i64, T)> + for NetceteraRouterData { type Error = error_stack::Report; fn try_from( (_currency_unit, _currency, amount, item): ( - &types::api::CurrencyUnit, + &api::CurrencyUnit, types::storage::enums::Currency, i64, T, diff --git a/crates/router/src/connector/nexinets.rs b/crates/router/src/connector/nexinets.rs index 1370fcf11c..88aa149a26 100644 --- a/crates/router/src/connector/nexinets.rs +++ b/crates/router/src/connector/nexinets.rs @@ -120,7 +120,7 @@ impl ConnectorCommon for Nexinets { if !field.is_empty() { msg.push_str(format!("{} : {}", field, error.message).as_str()); } else { - msg = error.message.to_owned(); + error.message.clone_into(&mut msg) } if message.is_empty() { message.push_str(&msg); diff --git a/crates/router/src/connector/nmi/transformers.rs b/crates/router/src/connector/nmi/transformers.rs index ea61782d49..fdc65963fe 100644 --- a/crates/router/src/connector/nmi/transformers.rs +++ b/crates/router/src/connector/nmi/transformers.rs @@ -42,11 +42,11 @@ impl TryFrom<&ConnectorAuthType> for NmiAuthType { type Error = Error; fn try_from(auth_type: &ConnectorAuthType) -> Result { match auth_type { - types::ConnectorAuthType::HeaderKey { api_key } => Ok(Self { + ConnectorAuthType::HeaderKey { api_key } => Ok(Self { api_key: api_key.to_owned(), public_key: None, }), - types::ConnectorAuthType::BodyKey { api_key, key1 } => Ok(Self { + ConnectorAuthType::BodyKey { api_key, key1 } => Ok(Self { api_key: api_key.to_owned(), public_key: Some(key1.to_owned()), }), @@ -61,20 +61,13 @@ pub struct NmiRouterData { pub router_data: T, } -impl - TryFrom<( - &types::api::CurrencyUnit, - types::storage::enums::Currency, - i64, - T, - )> for NmiRouterData -{ +impl TryFrom<(&api::CurrencyUnit, enums::Currency, i64, T)> for NmiRouterData { type Error = Report; fn try_from( (_currency_unit, currency, amount, router_data): ( - &types::api::CurrencyUnit, - types::storage::enums::Currency, + &api::CurrencyUnit, + enums::Currency, i64, T, ), diff --git a/crates/router/src/connector/nuvei.rs b/crates/router/src/connector/nuvei.rs index aa4157a68d..d08820266c 100644 --- a/crates/router/src/connector/nuvei.rs +++ b/crates/router/src/connector/nuvei.rs @@ -161,7 +161,7 @@ impl ) -> CustomResult { Ok(format!( "{}ppp/api/v1/payment.do", - api::ConnectorCommon::base_url(self, connectors) + ConnectorCommon::base_url(self, connectors) )) } fn get_request_body( @@ -248,7 +248,7 @@ impl ConnectorIntegration CustomResult { Ok(format!( "{}ppp/api/v1/voidTransaction.do", - api::ConnectorCommon::base_url(self, connectors) + ConnectorCommon::base_url(self, connectors) )) } @@ -334,7 +334,7 @@ impl ConnectorIntegration CustomResult { Ok(format!( "{}ppp/api/v1/getPaymentStatus.do", - api::ConnectorCommon::base_url(self, connectors) + ConnectorCommon::base_url(self, connectors) )) } @@ -417,7 +417,7 @@ impl ConnectorIntegration CustomResult { Ok(format!( "{}ppp/api/v1/settleTransaction.do", - api::ConnectorCommon::base_url(self, connectors) + ConnectorCommon::base_url(self, connectors) )) } @@ -509,7 +509,7 @@ impl ConnectorIntegration CustomResult { Ok(format!( "{}ppp/api/v1/payment.do", - api::ConnectorCommon::base_url(self, connectors) + ConnectorCommon::base_url(self, connectors) )) } @@ -671,7 +671,7 @@ impl ) -> CustomResult { Ok(format!( "{}ppp/api/v1/getSessionToken.do", - api::ConnectorCommon::base_url(self, connectors) + ConnectorCommon::base_url(self, connectors) )) } @@ -756,7 +756,7 @@ impl ConnectorIntegration CustomResult { Ok(format!( "{}ppp/api/v1/initPayment.do", - api::ConnectorCommon::base_url(self, connectors) + ConnectorCommon::base_url(self, connectors) )) } @@ -839,7 +839,7 @@ impl ConnectorIntegration CustomResult { Ok(format!( "{}ppp/api/v1/refundTransaction.do", - api::ConnectorCommon::base_url(self, connectors) + ConnectorCommon::base_url(self, connectors) )) } @@ -954,7 +954,7 @@ impl api::IncomingWebhook for Nuvei { serde_urlencoded::from_str::(&request.query_params) .change_context(errors::ConnectorError::WebhookBodyDecodingFailed)?; Ok(api_models::webhooks::ObjectReferenceId::PaymentId( - types::api::PaymentIdType::ConnectorTransactionId(body.ppp_transaction_id), + api::PaymentIdType::ConnectorTransactionId(body.ppp_transaction_id), )) } diff --git a/crates/router/src/connector/opennode/transformers.rs b/crates/router/src/connector/opennode/transformers.rs index 3267caf60d..09da5fc8f9 100644 --- a/crates/router/src/connector/opennode/transformers.rs +++ b/crates/router/src/connector/opennode/transformers.rs @@ -16,20 +16,13 @@ pub struct OpennodeRouterData { pub router_data: T, } -impl - TryFrom<( - &types::api::CurrencyUnit, - types::storage::enums::Currency, - i64, - T, - )> for OpennodeRouterData -{ +impl TryFrom<(&api::CurrencyUnit, enums::Currency, i64, T)> for OpennodeRouterData { type Error = error_stack::Report; fn try_from( (_currency_unit, _currency, amount, router_data): ( - &types::api::CurrencyUnit, - types::storage::enums::Currency, + &api::CurrencyUnit, + enums::Currency, i64, T, ), diff --git a/crates/router/src/connector/payeezy/transformers.rs b/crates/router/src/connector/payeezy/transformers.rs index 0ceed1390b..a8442f7ea8 100644 --- a/crates/router/src/connector/payeezy/transformers.rs +++ b/crates/router/src/connector/payeezy/transformers.rs @@ -15,20 +15,13 @@ pub struct PayeezyRouterData { pub router_data: T, } -impl - TryFrom<( - &types::api::CurrencyUnit, - types::storage::enums::Currency, - i64, - T, - )> for PayeezyRouterData -{ +impl TryFrom<(&api::CurrencyUnit, enums::Currency, i64, T)> for PayeezyRouterData { type Error = error_stack::Report; fn try_from( (currency_unit, currency, amount, router_data): ( - &types::api::CurrencyUnit, - types::storage::enums::Currency, + &api::CurrencyUnit, + enums::Currency, i64, T, ), diff --git a/crates/router/src/connector/payme/transformers.rs b/crates/router/src/connector/payme/transformers.rs index 7f5e30402d..0b3f4fb48c 100644 --- a/crates/router/src/connector/payme/transformers.rs +++ b/crates/router/src/connector/payme/transformers.rs @@ -29,22 +29,10 @@ pub struct PaymeRouterData { pub router_data: T, } -impl - TryFrom<( - &types::api::CurrencyUnit, - types::storage::enums::Currency, - i64, - T, - )> for PaymeRouterData -{ +impl TryFrom<(&api::CurrencyUnit, enums::Currency, i64, T)> for PaymeRouterData { type Error = error_stack::Report; fn try_from( - (_currency_unit, _currency, amount, item): ( - &types::api::CurrencyUnit, - types::storage::enums::Currency, - i64, - T, - ), + (_currency_unit, _currency, amount, item): (&api::CurrencyUnit, enums::Currency, i64, T), ) -> Result { Ok(Self { amount, @@ -630,7 +618,7 @@ impl TryFrom<&types::PaymentsAuthorizeRouterData> for PayRequest { type Error = error_stack::Report; fn try_from(item: &types::PaymentsAuthorizeRouterData) -> Result { match item.request.payment_method_data.clone() { - domain::PaymentMethodData::Card(req_card) => { + PaymentMethodData::Card(req_card) => { let card = PaymeCard { credit_card_cvv: req_card.card_cvc.clone(), credit_card_exp: req_card @@ -652,23 +640,21 @@ impl TryFrom<&types::PaymentsAuthorizeRouterData> for PayRequest { language: LANGUAGE.to_string(), }) } - domain::PaymentMethodData::CardRedirect(_) - | domain::PaymentMethodData::Wallet(_) - | domain::PaymentMethodData::PayLater(_) - | domain::PaymentMethodData::BankRedirect(_) - | domain::PaymentMethodData::BankDebit(_) - | domain::PaymentMethodData::BankTransfer(_) - | domain::PaymentMethodData::Crypto(_) - | domain::PaymentMethodData::MandatePayment - | domain::PaymentMethodData::Reward - | domain::PaymentMethodData::Upi(_) - | domain::PaymentMethodData::Voucher(_) - | domain::PaymentMethodData::GiftCard(_) - | domain::PaymentMethodData::CardToken(_) => { - Err(errors::ConnectorError::NotImplemented( - utils::get_unimplemented_payment_method_error_message("payme"), - ))? - } + PaymentMethodData::CardRedirect(_) + | PaymentMethodData::Wallet(_) + | PaymentMethodData::PayLater(_) + | PaymentMethodData::BankRedirect(_) + | PaymentMethodData::BankDebit(_) + | PaymentMethodData::BankTransfer(_) + | PaymentMethodData::Crypto(_) + | PaymentMethodData::MandatePayment + | PaymentMethodData::Reward + | PaymentMethodData::Upi(_) + | PaymentMethodData::Voucher(_) + | PaymentMethodData::GiftCard(_) + | PaymentMethodData::CardToken(_) => Err(errors::ConnectorError::NotImplemented( + utils::get_unimplemented_payment_method_error_message("payme"), + ))?, } } } @@ -681,7 +667,7 @@ impl TryFrom<&types::PaymentsCompleteAuthorizeRouterData> for Pay3dsRequest { type Error = error_stack::Report; fn try_from(item: &types::PaymentsCompleteAuthorizeRouterData) -> Result { match item.request.payment_method_data.clone() { - Some(domain::PaymentMethodData::Card(_)) => { + Some(PaymentMethodData::Card(_)) => { let buyer_email = item.request.get_email()?; let buyer_name = item.get_billing_address()?.get_full_name()?; @@ -712,19 +698,19 @@ impl TryFrom<&types::PaymentsCompleteAuthorizeRouterData> for Pay3dsRequest { meta_data_jwt: Secret::new(jwt_data.meta_data), }) } - Some(domain::PaymentMethodData::CardRedirect(_)) - | Some(domain::PaymentMethodData::Wallet(_)) - | Some(domain::PaymentMethodData::PayLater(_)) - | Some(domain::PaymentMethodData::BankRedirect(_)) - | Some(domain::PaymentMethodData::BankDebit(_)) - | Some(domain::PaymentMethodData::BankTransfer(_)) - | Some(domain::PaymentMethodData::Crypto(_)) - | Some(domain::PaymentMethodData::MandatePayment) - | Some(domain::PaymentMethodData::Reward) - | Some(domain::PaymentMethodData::Upi(_)) - | Some(domain::PaymentMethodData::Voucher(_)) - | Some(domain::PaymentMethodData::GiftCard(_)) - | Some(domain::PaymentMethodData::CardToken(_)) + Some(PaymentMethodData::CardRedirect(_)) + | Some(PaymentMethodData::Wallet(_)) + | Some(PaymentMethodData::PayLater(_)) + | Some(PaymentMethodData::BankRedirect(_)) + | Some(PaymentMethodData::BankDebit(_)) + | Some(PaymentMethodData::BankTransfer(_)) + | Some(PaymentMethodData::Crypto(_)) + | Some(PaymentMethodData::MandatePayment) + | Some(PaymentMethodData::Reward) + | Some(PaymentMethodData::Upi(_)) + | Some(PaymentMethodData::Voucher(_)) + | Some(PaymentMethodData::GiftCard(_)) + | Some(PaymentMethodData::CardToken(_)) | None => { Err(errors::ConnectorError::NotImplemented("Tokenize Flow".to_string()).into()) } @@ -736,7 +722,7 @@ impl TryFrom<&types::TokenizationRouterData> for CaptureBuyerRequest { type Error = error_stack::Report; fn try_from(item: &types::TokenizationRouterData) -> Result { match item.request.payment_method_data.clone() { - domain::PaymentMethodData::Card(req_card) => { + PaymentMethodData::Card(req_card) => { let seller_payme_id = PaymeAuthType::try_from(&item.connector_auth_type)?.seller_payme_id; let card = PaymeCard { @@ -750,19 +736,19 @@ impl TryFrom<&types::TokenizationRouterData> for CaptureBuyerRequest { seller_payme_id, }) } - domain::PaymentMethodData::Wallet(_) - | domain::PaymentMethodData::CardRedirect(_) - | domain::PaymentMethodData::PayLater(_) - | domain::PaymentMethodData::BankRedirect(_) - | domain::PaymentMethodData::BankDebit(_) - | domain::PaymentMethodData::BankTransfer(_) - | domain::PaymentMethodData::Crypto(_) - | domain::PaymentMethodData::MandatePayment - | domain::PaymentMethodData::Reward - | domain::PaymentMethodData::Upi(_) - | domain::PaymentMethodData::Voucher(_) - | domain::PaymentMethodData::GiftCard(_) - | domain::PaymentMethodData::CardToken(_) => { + PaymentMethodData::Wallet(_) + | PaymentMethodData::CardRedirect(_) + | PaymentMethodData::PayLater(_) + | PaymentMethodData::BankRedirect(_) + | PaymentMethodData::BankDebit(_) + | PaymentMethodData::BankTransfer(_) + | PaymentMethodData::Crypto(_) + | PaymentMethodData::MandatePayment + | PaymentMethodData::Reward + | PaymentMethodData::Upi(_) + | PaymentMethodData::Voucher(_) + | PaymentMethodData::GiftCard(_) + | PaymentMethodData::CardToken(_) => { Err(errors::ConnectorError::NotImplemented("Tokenize Flow".to_string()).into()) } } @@ -1151,14 +1137,14 @@ impl fn get_services(item: &types::PaymentsPreProcessingRouterData) -> Option { match item.auth_type { - api_models::enums::AuthenticationType::ThreeDs => { + AuthenticationType::ThreeDs => { let settings = ThreeDsSettings { active: true }; Some(ThreeDs { name: ThreeDsType::ThreeDs, settings, }) } - api_models::enums::AuthenticationType::NoThreeDs => None, + AuthenticationType::NoThreeDs => None, } } diff --git a/crates/router/src/connector/paypal.rs b/crates/router/src/connector/paypal.rs index 6391239178..cf81fec634 100644 --- a/crates/router/src/connector/paypal.rs +++ b/crates/router/src/connector/paypal.rs @@ -960,8 +960,7 @@ impl ConnectorIntegration CustomResult { let paypal_meta: PaypalMeta = to_connector_meta(req.request.connector_meta.clone())?; match req.payment_method { - diesel_models::enums::PaymentMethod::Wallet - | diesel_models::enums::PaymentMethod::BankRedirect => Ok(format!( + enums::PaymentMethod::Wallet | enums::PaymentMethod::BankRedirect => Ok(format!( "{}v2/checkout/orders/{}", self.base_url(connectors), req.request @@ -1633,9 +1632,9 @@ impl services::ConnectorRedirectResponse for Paypal { action: PaymentAction, ) -> CustomResult { match action { - services::PaymentAction::PSync - | services::PaymentAction::CompleteAuthorize - | services::PaymentAction::PaymentAuthenticateCompleteAuthorize => { + PaymentAction::PSync + | PaymentAction::CompleteAuthorize + | PaymentAction::PaymentAuthenticateCompleteAuthorize => { Ok(payments::CallConnectorAction::Trigger) } } diff --git a/crates/router/src/connector/paypal/transformers.rs b/crates/router/src/connector/paypal/transformers.rs index 21b0f04af8..338b8c5ba4 100644 --- a/crates/router/src/connector/paypal/transformers.rs +++ b/crates/router/src/connector/paypal/transformers.rs @@ -29,18 +29,13 @@ pub struct PaypalRouterData { pub router_data: T, } -impl - TryFrom<( - &types::api::CurrencyUnit, - types::storage::enums::Currency, - i64, - T, - )> for PaypalRouterData +impl TryFrom<(&api::CurrencyUnit, types::storage::enums::Currency, i64, T)> + for PaypalRouterData { type Error = error_stack::Report; fn try_from( (currency_unit, currency, amount, item): ( - &types::api::CurrencyUnit, + &api::CurrencyUnit, types::storage::enums::Currency, i64, T, @@ -153,7 +148,7 @@ impl From<&PaypalRouterData<&types::PaymentsAuthorizeRouterData>> for ItemDetail pub struct Address { address_line_1: Option>, postal_code: Option>, - country_code: api_models::enums::CountryAlpha2, + country_code: enums::CountryAlpha2, admin_area_2: Option, } @@ -216,7 +211,7 @@ pub enum ThreeDsType { #[derive(Debug, Serialize)] pub struct RedirectRequest { name: Secret, - country_code: api_models::enums::CountryAlpha2, + country_code: enums::CountryAlpha2, experience_context: ContextStruct, } @@ -454,12 +449,12 @@ impl TryFrom<&PaypalRouterData<&types::PaymentsAuthorizeRouterData>> for PaypalP let expiry = Some(card.get_expiry_date_as_yyyymm("-")); let attributes = match item.router_data.auth_type { - api_models::enums::AuthenticationType::ThreeDs => Some(ThreeDsSetting { + enums::AuthenticationType::ThreeDs => Some(ThreeDsSetting { verification: ThreeDsMethod { method: ThreeDsType::ScaAlways, }, }), - api_models::enums::AuthenticationType::NoThreeDs => None, + enums::AuthenticationType::NoThreeDs => None, }; let payment_source = Some(PaymentSourceItem::Card(CardRequest { @@ -858,13 +853,13 @@ impl TryFrom<&ConnectorAuthType> for PaypalAuthType { type Error = error_stack::Report; fn try_from(auth_type: &ConnectorAuthType) -> Result { match auth_type { - types::ConnectorAuthType::BodyKey { api_key, key1 } => Ok(Self::AuthWithDetails( + ConnectorAuthType::BodyKey { api_key, key1 } => Ok(Self::AuthWithDetails( PaypalConnectorCredentials::StandardIntegration(StandardFlowCredentials { client_id: key1.to_owned(), client_secret: api_key.to_owned(), }), )), - types::ConnectorAuthType::SignatureKey { + ConnectorAuthType::SignatureKey { api_key, key1, api_secret, @@ -875,7 +870,7 @@ impl TryFrom<&ConnectorAuthType> for PaypalAuthType { payer_id: api_secret.to_owned(), }), )), - types::ConnectorAuthType::TemporaryAuth => Ok(Self::TemporaryAuth), + ConnectorAuthType::TemporaryAuth => Ok(Self::TemporaryAuth), _ => Err(errors::ConnectorError::FailedToObtainAuthType)?, } } @@ -1216,7 +1211,7 @@ fn get_redirect_url( let mut link: Option = None; for item2 in link_vec.iter() { if item2.rel == "payer-action" { - link = item2.href.clone(); + link.clone_from(&item2.href) } } Ok(link) diff --git a/crates/router/src/connector/placetopay/transformers.rs b/crates/router/src/connector/placetopay/transformers.rs index 6ad3d3c203..e400dc9b39 100644 --- a/crates/router/src/connector/placetopay/transformers.rs +++ b/crates/router/src/connector/placetopay/transformers.rs @@ -20,18 +20,13 @@ pub struct PlacetopayRouterData { pub router_data: T, } -impl - TryFrom<( - &types::api::CurrencyUnit, - types::storage::enums::Currency, - i64, - T, - )> for PlacetopayRouterData +impl TryFrom<(&api::CurrencyUnit, types::storage::enums::Currency, i64, T)> + for PlacetopayRouterData { type Error = error_stack::Report; fn try_from( (_currency_unit, _currency, amount, item): ( - &types::api::CurrencyUnit, + &api::CurrencyUnit, types::storage::enums::Currency, i64, T, diff --git a/crates/router/src/connector/prophetpay/transformers.rs b/crates/router/src/connector/prophetpay/transformers.rs index 570bf8d2b3..7a8cd6e14d 100644 --- a/crates/router/src/connector/prophetpay/transformers.rs +++ b/crates/router/src/connector/prophetpay/transformers.rs @@ -19,22 +19,10 @@ pub struct ProphetpayRouterData { pub router_data: T, } -impl - TryFrom<( - &types::api::CurrencyUnit, - types::storage::enums::Currency, - i64, - T, - )> for ProphetpayRouterData -{ +impl TryFrom<(&api::CurrencyUnit, enums::Currency, i64, T)> for ProphetpayRouterData { type Error = error_stack::Report; fn try_from( - (currency_unit, currency, amount, item): ( - &types::api::CurrencyUnit, - types::storage::enums::Currency, - i64, - T, - ), + (currency_unit, currency, amount, item): (&api::CurrencyUnit, enums::Currency, i64, T), ) -> Result { let amount = utils::get_amount_as_f64(currency_unit, amount, currency)?; Ok(Self { @@ -229,7 +217,7 @@ fn get_redirect_url_form( mut redirect_url: Url, complete_auth_url: Option, ) -> CustomResult { - let mut form_fields = std::collections::HashMap::::new(); + let mut form_fields = HashMap::::new(); form_fields.insert( String::from("redirectUrl"), diff --git a/crates/router/src/connector/rapyd.rs b/crates/router/src/connector/rapyd.rs index c5f92c20f5..5d4579fffa 100644 --- a/crates/router/src/connector/rapyd.rs +++ b/crates/router/src/connector/rapyd.rs @@ -652,7 +652,7 @@ impl services::ConnectorIntegration &'static str { - api::ConnectorCommon::common_get_content_type(self) + ConnectorCommon::common_get_content_type(self) } fn get_url( diff --git a/crates/router/src/connector/rapyd/transformers.rs b/crates/router/src/connector/rapyd/transformers.rs index 04dc4496b6..22e1074802 100644 --- a/crates/router/src/connector/rapyd/transformers.rs +++ b/crates/router/src/connector/rapyd/transformers.rs @@ -19,22 +19,10 @@ pub struct RapydRouterData { pub router_data: T, } -impl - TryFrom<( - &types::api::CurrencyUnit, - types::storage::enums::Currency, - i64, - T, - )> for RapydRouterData -{ +impl TryFrom<(&api::CurrencyUnit, enums::Currency, i64, T)> for RapydRouterData { type Error = error_stack::Report; fn try_from( - (_currency_unit, _currency, amount, item): ( - &types::api::CurrencyUnit, - types::storage::enums::Currency, - i64, - T, - ), + (_currency_unit, _currency, amount, item): (&api::CurrencyUnit, enums::Currency, i64, T), ) -> Result { Ok(Self { amount, diff --git a/crates/router/src/connector/shift4.rs b/crates/router/src/connector/shift4.rs index e11a79cb02..e7487e795b 100644 --- a/crates/router/src/connector/shift4.rs +++ b/crates/router/src/connector/shift4.rs @@ -217,8 +217,8 @@ impl ConnectorIntegration CustomResult<(), errors::ConnectorError> { - if router_data.auth_type == diesel_models::enums::AuthenticationType::ThreeDs - && router_data.payment_method == diesel_models::enums::PaymentMethod::Card + if router_data.auth_type == enums::AuthenticationType::ThreeDs + && router_data.payment_method == enums::PaymentMethod::Card { let integ: Box< &(dyn ConnectorIntegration< diff --git a/crates/router/src/connector/shift4/transformers.rs b/crates/router/src/connector/shift4/transformers.rs index 92a72f42d1..30f327c700 100644 --- a/crates/router/src/connector/shift4/transformers.rs +++ b/crates/router/src/connector/shift4/transformers.rs @@ -747,9 +747,9 @@ impl TryFrom<&types::RefundsRouterData> for Shift4RefundRequest { impl From for enums::RefundStatus { fn from(item: Shift4RefundStatus) -> Self { match item { - self::Shift4RefundStatus::Successful => Self::Success, - self::Shift4RefundStatus::Failed => Self::Failure, - self::Shift4RefundStatus::Processing => Self::Pending, + Shift4RefundStatus::Successful => Self::Success, + Shift4RefundStatus::Failed => Self::Failure, + Shift4RefundStatus::Processing => Self::Pending, } } } diff --git a/crates/router/src/connector/signifyd.rs b/crates/router/src/connector/signifyd.rs index 550e1ae30a..1c045b8da0 100644 --- a/crates/router/src/connector/signifyd.rs +++ b/crates/router/src/connector/signifyd.rs @@ -94,7 +94,7 @@ impl ConnectorCommon for Signifyd { Ok(ErrorResponse { status_code: res.status_code, - code: crate::consts::NO_ERROR_CODE.to_string(), + code: consts::NO_ERROR_CODE.to_string(), message: response.messages.join(" &"), reason: Some(response.errors.to_string()), attempt_status: None, diff --git a/crates/router/src/connector/square/transformers.rs b/crates/router/src/connector/square/transformers.rs index 318e33978c..c980a4e749 100644 --- a/crates/router/src/connector/square/transformers.rs +++ b/crates/router/src/connector/square/transformers.rs @@ -5,10 +5,7 @@ use serde::{Deserialize, Serialize}; use crate::{ connector::utils::{self, CardData, PaymentsAuthorizeRequestData, RouterData}, core::errors, - types::{ - self, api, domain, - storage::{self, enums}, - }, + types::{self, api, domain, storage::enums}, unimplemented_payment_method, }; @@ -199,7 +196,7 @@ impl item: types::ResponseRouterData, ) -> Result { Ok(Self { - status: storage::enums::AttemptStatus::Pending, + status: enums::AttemptStatus::Pending, session_token: Some(item.response.session_id.clone().expose()), response: Ok(types::PaymentsResponseData::SessionTokenResponse { session_token: item.response.session_id.expose(), diff --git a/crates/router/src/connector/stax.rs b/crates/router/src/connector/stax.rs index c923ca0577..4604e9da87 100644 --- a/crates/router/src/connector/stax.rs +++ b/crates/router/src/connector/stax.rs @@ -869,29 +869,25 @@ impl api::IncomingWebhook for Stax { .change_context(errors::ConnectorError::WebhookReferenceIdNotFound)?; match webhook_body.transaction_type { - stax::StaxWebhookEventType::Refund => { - Ok(api_models::webhooks::ObjectReferenceId::RefundId( - api_models::webhooks::RefundIdType::ConnectorRefundId(webhook_body.id), - )) - } - stax::StaxWebhookEventType::Unknown => { + StaxWebhookEventType::Refund => Ok(api_models::webhooks::ObjectReferenceId::RefundId( + api_models::webhooks::RefundIdType::ConnectorRefundId(webhook_body.id), + )), + StaxWebhookEventType::Unknown => { Err(errors::ConnectorError::WebhookEventTypeNotFound.into()) } - stax::StaxWebhookEventType::PreAuth - | stax::StaxWebhookEventType::Capture - | stax::StaxWebhookEventType::Charge - | stax::StaxWebhookEventType::Void => { - Ok(api_models::webhooks::ObjectReferenceId::PaymentId( - api_models::payments::PaymentIdType::ConnectorTransactionId(match webhook_body - .transaction_type - { - stax::StaxWebhookEventType::Capture => webhook_body + StaxWebhookEventType::PreAuth + | StaxWebhookEventType::Capture + | StaxWebhookEventType::Charge + | StaxWebhookEventType::Void => Ok(api_models::webhooks::ObjectReferenceId::PaymentId( + api_models::payments::PaymentIdType::ConnectorTransactionId( + match webhook_body.transaction_type { + StaxWebhookEventType::Capture => webhook_body .auth_id .ok_or(errors::ConnectorError::WebhookReferenceIdNotFound)?, _ => webhook_body.id, - }), - )) - } + }, + ), + )), } } diff --git a/crates/router/src/connector/stax/transformers.rs b/crates/router/src/connector/stax/transformers.rs index 1d097c40e7..d48a2b1e82 100644 --- a/crates/router/src/connector/stax/transformers.rs +++ b/crates/router/src/connector/stax/transformers.rs @@ -18,22 +18,10 @@ pub struct StaxRouterData { pub router_data: T, } -impl - TryFrom<( - &types::api::CurrencyUnit, - types::storage::enums::Currency, - i64, - T, - )> for StaxRouterData -{ +impl TryFrom<(&api::CurrencyUnit, enums::Currency, i64, T)> for StaxRouterData { type Error = error_stack::Report; fn try_from( - (currency_unit, currency, amount, item): ( - &types::api::CurrencyUnit, - types::storage::enums::Currency, - i64, - T, - ), + (currency_unit, currency, amount, item): (&api::CurrencyUnit, enums::Currency, i64, T), ) -> Result { let amount = utils::get_amount_as_f64(currency_unit, amount, currency)?; Ok(Self { diff --git a/crates/router/src/connector/stripe.rs b/crates/router/src/connector/stripe.rs index 64789e176f..724a0ea6f7 100644 --- a/crates/router/src/connector/stripe.rs +++ b/crates/router/src/connector/stripe.rs @@ -2274,7 +2274,7 @@ impl services::ConnectorRedirectResponse for Stripe { _query_params: &str, _json_payload: Option, action: services::PaymentAction, - ) -> CustomResult { + ) -> CustomResult { match action { services::PaymentAction::PSync | services::PaymentAction::CompleteAuthorize diff --git a/crates/router/src/connector/stripe/transformers.rs b/crates/router/src/connector/stripe/transformers.rs index 6932f6b749..6b82c87b5d 100644 --- a/crates/router/src/connector/stripe/transformers.rs +++ b/crates/router/src/connector/stripe/transformers.rs @@ -1107,9 +1107,7 @@ impl TryFrom<(&domain::BankRedirectData, Option)> for StripeBillingAddress }, )?; Self { - name: Some(connector_util::BankRedirectBillingData::get_billing_name( - &billing_data, - )?), + name: Some(BankRedirectBillingData::get_billing_name(&billing_data)?), ..Self::default() } }), @@ -2859,16 +2857,14 @@ impl Serialize for StripeNextActionResponse { { match *self { Self::CashappHandleRedirectOrDisplayQrCode(ref i) => { - serde::Serialize::serialize(i, serializer) + Serialize::serialize(i, serializer) } - Self::RedirectToUrl(ref i) => serde::Serialize::serialize(i, serializer), - Self::AlipayHandleRedirect(ref i) => serde::Serialize::serialize(i, serializer), - Self::VerifyWithMicrodeposits(ref i) => serde::Serialize::serialize(i, serializer), - Self::WechatPayDisplayQrCode(ref i) => serde::Serialize::serialize(i, serializer), - Self::DisplayBankTransferInstructions(ref i) => { - serde::Serialize::serialize(i, serializer) - } - Self::NoNextActionBody => serde::Serialize::serialize("NoNextActionBody", serializer), + Self::RedirectToUrl(ref i) => Serialize::serialize(i, serializer), + Self::AlipayHandleRedirect(ref i) => Serialize::serialize(i, serializer), + Self::VerifyWithMicrodeposits(ref i) => Serialize::serialize(i, serializer), + Self::WechatPayDisplayQrCode(ref i) => Serialize::serialize(i, serializer), + Self::DisplayBankTransferInstructions(ref i) => Serialize::serialize(i, serializer), + Self::NoNextActionBody => Serialize::serialize("NoNextActionBody", serializer), } } } @@ -2984,10 +2980,10 @@ pub enum RefundStatus { impl From for enums::RefundStatus { fn from(item: RefundStatus) -> Self { match item { - self::RefundStatus::Succeeded => Self::Success, - self::RefundStatus::Failed => Self::Failure, - self::RefundStatus::Pending => Self::Pending, - self::RefundStatus::RequiresAction => Self::ManualReview, + RefundStatus::Succeeded => Self::Success, + RefundStatus::Failed => Self::Failure, + RefundStatus::Pending => Self::Pending, + RefundStatus::RequiresAction => Self::ManualReview, } } } @@ -3382,12 +3378,12 @@ impl TryFrom { pub router_data: T, } -impl - TryFrom<( - &types::api::CurrencyUnit, - types::storage::enums::Currency, - i64, - T, - )> for ThreedsecureioRouterData +impl TryFrom<(&api::CurrencyUnit, types::storage::enums::Currency, i64, T)> + for ThreedsecureioRouterData { type Error = error_stack::Report; fn try_from( (_currency_unit, _currency, amount, item): ( - &types::api::CurrencyUnit, + &api::CurrencyUnit, types::storage::enums::Currency, i64, T, @@ -168,7 +163,7 @@ impl let creq_str = to_string(&creq) .change_context(errors::ConnectorError::ResponseDeserializationFailed) .attach_printable("error while constructing creq_str")?; - let creq_base64 = base64::Engine::encode(&BASE64_ENGINE, creq_str) + let creq_base64 = Engine::encode(&BASE64_ENGINE, creq_str) .trim_end_matches('=') .to_owned(); Ok( @@ -270,7 +265,7 @@ impl TryFrom<&ThreedsecureioRouterData<&types::authentication::ConnectorAuthenti .map(|currency| currency.to_string()) .ok_or(errors::ConnectorError::RequestEncodingFailed) .attach_printable("missing field currency")?; - let purchase_currency: Currency = iso_currency::Currency::from_code(¤cy) + let purchase_currency: Currency = Currency::from_code(¤cy) .ok_or(errors::ConnectorError::RequestEncodingFailed) .attach_printable("error while parsing Currency")?; let billing_address = request.billing_address.address.clone().ok_or( diff --git a/crates/router/src/connector/trustpay/transformers.rs b/crates/router/src/connector/trustpay/transformers.rs index c40435c01b..5a318e5e44 100644 --- a/crates/router/src/connector/trustpay/transformers.rs +++ b/crates/router/src/connector/trustpay/transformers.rs @@ -28,19 +28,12 @@ pub struct TrustpayRouterData { pub router_data: T, } -impl - TryFrom<( - &types::api::CurrencyUnit, - types::storage::enums::Currency, - i64, - T, - )> for TrustpayRouterData -{ +impl TryFrom<(&types::api::CurrencyUnit, enums::Currency, i64, T)> for TrustpayRouterData { type Error = error_stack::Report; fn try_from( (currency_unit, currency, amount, item): ( &types::api::CurrencyUnit, - types::storage::enums::Currency, + enums::Currency, i64, T, ), @@ -1179,7 +1172,7 @@ impl let create_intent_response = item.response.init_result_data.to_owned(); let secrets = item.response.secrets.to_owned(); let instance_id = item.response.instance_id.to_owned(); - let pmt = utils::PaymentsPreProcessingData::get_payment_method_type(&item.data.request)?; + let pmt = PaymentsPreProcessingData::get_payment_method_type(&item.data.request)?; match (pmt, create_intent_response) { ( diff --git a/crates/router/src/connector/tsys/transformers.rs b/crates/router/src/connector/tsys/transformers.rs index 6ffe1f1ed7..dfc7e61c00 100644 --- a/crates/router/src/connector/tsys/transformers.rs +++ b/crates/router/src/connector/tsys/transformers.rs @@ -5,10 +5,7 @@ use serde::{Deserialize, Serialize}; use crate::{ connector::utils::{self, CardData, PaymentsAuthorizeRequestData, RefundsRequestData}, core::errors, - types::{ - self, api, domain, - storage::{self, enums}, - }, + types::{self, api, domain, storage::enums}, }; #[derive(Debug, Serialize)] @@ -25,7 +22,7 @@ pub struct TsysPaymentAuthSaleRequest { transaction_key: Secret, card_data_source: String, transaction_amount: String, - currency_code: storage::enums::Currency, + currency_code: enums::Currency, card_number: cards::CardNumber, expiration_date: Secret, cvv2: Secret, diff --git a/crates/router/src/connector/utils.rs b/crates/router/src/connector/utils.rs index bb52d4885f..5a5b124261 100644 --- a/crates/router/src/connector/utils.rs +++ b/crates/router/src/connector/utils.rs @@ -363,10 +363,7 @@ impl RouterData for types::RouterData bool { - matches!( - self.auth_type, - diesel_models::enums::AuthenticationType::ThreeDs - ) + matches!(self.auth_type, enums::AuthenticationType::ThreeDs) } fn get_shipping_address(&self) -> Result<&api::AddressDetails, Error> { @@ -430,8 +427,8 @@ impl RouterData for types::RouterData Result; - fn get_payment_method_type(&self) -> Result; - fn get_currency(&self) -> Result; + fn get_payment_method_type(&self) -> Result; + fn get_currency(&self) -> Result; fn get_amount(&self) -> Result; fn is_auto_capture(&self) -> Result; fn get_order_details(&self) -> Result, Error>; @@ -445,12 +442,12 @@ impl PaymentsPreProcessingData for types::PaymentsPreProcessingData { fn get_email(&self) -> Result { self.email.clone().ok_or_else(missing_field_err("email")) } - fn get_payment_method_type(&self) -> Result { + fn get_payment_method_type(&self) -> Result { self.payment_method_type .to_owned() .ok_or_else(missing_field_err("payment_method_type")) } - fn get_currency(&self) -> Result { + fn get_currency(&self) -> Result { self.currency.ok_or_else(missing_field_err("currency")) } fn get_amount(&self) -> Result { @@ -458,8 +455,8 @@ impl PaymentsPreProcessingData for types::PaymentsPreProcessingData { } fn is_auto_capture(&self) -> Result { match self.capture_method { - Some(diesel_models::enums::CaptureMethod::Automatic) | None => Ok(true), - Some(diesel_models::enums::CaptureMethod::Manual) => Ok(false), + Some(enums::CaptureMethod::Automatic) | None => Ok(true), + Some(enums::CaptureMethod::Manual) => Ok(false), Some(_) => Err(errors::ConnectorError::CaptureMethodNotSupported.into()), } } @@ -551,7 +548,7 @@ pub trait PaymentsAuthorizeRequestData { fn get_router_return_url(&self) -> Result; fn is_wallet(&self) -> bool; fn is_card(&self) -> bool; - fn get_payment_method_type(&self) -> Result; + fn get_payment_method_type(&self) -> Result; fn get_connector_mandate_id(&self) -> Result; fn get_complete_authorize_url(&self) -> Result; fn get_ip_address_as_optional(&self) -> Option>; @@ -578,8 +575,8 @@ impl PaymentMethodTokenizationRequestData for types::PaymentMethodTokenizationDa impl PaymentsAuthorizeRequestData for types::PaymentsAuthorizeData { fn is_auto_capture(&self) -> Result { match self.capture_method { - Some(diesel_models::enums::CaptureMethod::Automatic) | None => Ok(true), - Some(diesel_models::enums::CaptureMethod::Manual) => Ok(false), + Some(enums::CaptureMethod::Automatic) | None => Ok(true), + Some(enums::CaptureMethod::Manual) => Ok(false), Some(_) => Err(errors::ConnectorError::CaptureMethodNotSupported.into()), } } @@ -619,9 +616,9 @@ impl PaymentsAuthorizeRequestData for types::PaymentsAuthorizeData { self.mandate_id .as_ref() .and_then(|mandate_ids| match &mandate_ids.mandate_reference_id { - Some(api_models::payments::MandateReferenceId::ConnectorMandateId( - connector_mandate_ids, - )) => connector_mandate_ids.connector_mandate_id.clone(), + Some(payments::MandateReferenceId::ConnectorMandateId(connector_mandate_ids)) => { + connector_mandate_ids.connector_mandate_id.clone() + } _ => None, }) } @@ -653,7 +650,7 @@ impl PaymentsAuthorizeRequestData for types::PaymentsAuthorizeData { matches!(self.payment_method_data, domain::PaymentMethodData::Card(_)) } - fn get_payment_method_type(&self) -> Result { + fn get_payment_method_type(&self) -> Result { self.payment_method_type .to_owned() .ok_or_else(missing_field_err("payment_method_type")) @@ -797,8 +794,8 @@ pub trait PaymentsCompleteAuthorizeRequestData { impl PaymentsCompleteAuthorizeRequestData for types::CompleteAuthorizeData { fn is_auto_capture(&self) -> Result { match self.capture_method { - Some(diesel_models::enums::CaptureMethod::Automatic) | None => Ok(true), - Some(diesel_models::enums::CaptureMethod::Manual) => Ok(false), + Some(enums::CaptureMethod::Automatic) | None => Ok(true), + Some(enums::CaptureMethod::Manual) => Ok(false), Some(_) => Err(errors::ConnectorError::CaptureMethodNotSupported.into()), } } @@ -831,8 +828,8 @@ pub trait PaymentsSyncRequestData { impl PaymentsSyncRequestData for types::PaymentsSyncData { fn is_auto_capture(&self) -> Result { match self.capture_method { - Some(diesel_models::enums::CaptureMethod::Automatic) | None => Ok(true), - Some(diesel_models::enums::CaptureMethod::Manual) => Ok(false), + Some(enums::CaptureMethod::Automatic) | None => Ok(true), + Some(enums::CaptureMethod::Manual) => Ok(false), Some(_) => Err(errors::ConnectorError::CaptureMethodNotSupported.into()), } } @@ -910,7 +907,7 @@ impl CustomerDetails for types::CustomerDetails { pub trait PaymentsCancelRequestData { fn get_amount(&self) -> Result; - fn get_currency(&self) -> Result; + fn get_currency(&self) -> Result; fn get_cancellation_reason(&self) -> Result; fn get_browser_info(&self) -> Result; } @@ -919,7 +916,7 @@ impl PaymentsCancelRequestData for PaymentsCancelData { fn get_amount(&self) -> Result { self.amount.ok_or_else(missing_field_err("amount")) } - fn get_currency(&self) -> Result { + fn get_currency(&self) -> Result { self.currency.ok_or_else(missing_field_err("currency")) } fn get_cancellation_reason(&self) -> Result { @@ -1540,7 +1537,7 @@ impl MandateData for payments::MandateAmountData { pub trait RecurringMandateData { fn get_original_payment_amount(&self) -> Result; - fn get_original_payment_currency(&self) -> Result; + fn get_original_payment_currency(&self) -> Result; } impl RecurringMandateData for RecurringMandatePaymentData { @@ -1548,7 +1545,7 @@ impl RecurringMandateData for RecurringMandatePaymentData { self.original_payment_authorized_amount .ok_or_else(missing_field_err("original_payment_authorized_amount")) } - fn get_original_payment_currency(&self) -> Result { + fn get_original_payment_currency(&self) -> Result { self.original_payment_authorized_currency .ok_or_else(missing_field_err("original_payment_authorized_currency")) } @@ -1558,7 +1555,7 @@ pub trait MandateReferenceData { fn get_connector_mandate_id(&self) -> Result; } -impl MandateReferenceData for api_models::payments::ConnectorMandateReferenceId { +impl MandateReferenceData for payments::ConnectorMandateReferenceId { fn get_connector_mandate_id(&self) -> Result { self.connector_mandate_id .clone() @@ -1645,7 +1642,7 @@ pub fn base64_decode(data: String) -> Result, Error> { pub fn to_currency_base_unit_from_optional_amount( amount: Option, - currency: diesel_models::enums::Currency, + currency: enums::Currency, ) -> Result> { match amount { Some(a) => to_currency_base_unit(a, currency), @@ -1657,25 +1654,25 @@ pub fn to_currency_base_unit_from_optional_amount( } pub fn get_amount_as_string( - currency_unit: &types::api::CurrencyUnit, + currency_unit: &api::CurrencyUnit, amount: i64, - currency: diesel_models::enums::Currency, + currency: enums::Currency, ) -> Result> { let amount = match currency_unit { - types::api::CurrencyUnit::Minor => amount.to_string(), - types::api::CurrencyUnit::Base => to_currency_base_unit(amount, currency)?, + api::CurrencyUnit::Minor => amount.to_string(), + api::CurrencyUnit::Base => to_currency_base_unit(amount, currency)?, }; Ok(amount) } pub fn get_amount_as_f64( - currency_unit: &types::api::CurrencyUnit, + currency_unit: &api::CurrencyUnit, amount: i64, - currency: diesel_models::enums::Currency, + currency: enums::Currency, ) -> Result> { let amount = match currency_unit { - types::api::CurrencyUnit::Base => to_currency_base_unit_asf64(amount, currency)?, - types::api::CurrencyUnit::Minor => u32::try_from(amount) + api::CurrencyUnit::Base => to_currency_base_unit_asf64(amount, currency)?, + api::CurrencyUnit::Minor => u32::try_from(amount) .change_context(errors::ConnectorError::ParsingFailed)? .into(), }; @@ -1684,7 +1681,7 @@ pub fn get_amount_as_f64( pub fn to_currency_base_unit( amount: i64, - currency: diesel_models::enums::Currency, + currency: enums::Currency, ) -> Result> { currency .to_currency_base_unit(amount) @@ -1693,7 +1690,7 @@ pub fn to_currency_base_unit( pub fn to_currency_lower_unit( amount: String, - currency: diesel_models::enums::Currency, + currency: enums::Currency, ) -> Result> { currency .to_currency_lower_unit(amount) @@ -1721,7 +1718,7 @@ pub fn construct_not_supported_error_report( pub fn to_currency_base_unit_with_zero_decimal_check( amount: i64, - currency: diesel_models::enums::Currency, + currency: enums::Currency, ) -> Result> { currency .to_currency_base_unit_with_zero_decimal_check(amount) @@ -1730,7 +1727,7 @@ pub fn to_currency_base_unit_with_zero_decimal_check( pub fn to_currency_base_unit_asf64( amount: i64, - currency: diesel_models::enums::Currency, + currency: enums::Currency, ) -> Result> { currency .to_currency_base_unit_asf64(amount) diff --git a/crates/router/src/connector/volt/transformers.rs b/crates/router/src/connector/volt/transformers.rs index d3913296c0..814eefaf5f 100644 --- a/crates/router/src/connector/volt/transformers.rs +++ b/crates/router/src/connector/volt/transformers.rs @@ -18,18 +18,13 @@ pub struct VoltRouterData { pub router_data: T, } -impl - TryFrom<( - &types::api::CurrencyUnit, - types::storage::enums::Currency, - i64, - T, - )> for VoltRouterData +impl TryFrom<(&api::CurrencyUnit, types::storage::enums::Currency, i64, T)> + for VoltRouterData { type Error = error_stack::Report; fn try_from( (_currency_unit, _currency, amount, item): ( - &types::api::CurrencyUnit, + &api::CurrencyUnit, types::storage::enums::Currency, i64, T, diff --git a/crates/router/src/connector/worldline/transformers.rs b/crates/router/src/connector/worldline/transformers.rs index 3dba5ea24e..795133f602 100644 --- a/crates/router/src/connector/worldline/transformers.rs +++ b/crates/router/src/connector/worldline/transformers.rs @@ -190,22 +190,10 @@ pub struct WorldlineRouterData { amount: i64, router_data: T, } -impl - TryFrom<( - &types::api::CurrencyUnit, - types::storage::enums::Currency, - i64, - T, - )> for WorldlineRouterData -{ +impl TryFrom<(&api::CurrencyUnit, enums::Currency, i64, T)> for WorldlineRouterData { type Error = error_stack::Report; fn try_from( - (_currency_unit, _currency, amount, item): ( - &types::api::CurrencyUnit, - types::storage::enums::Currency, - i64, - T, - ), + (_currency_unit, _currency, amount, item): (&api::CurrencyUnit, enums::Currency, i64, T), ) -> Result { Ok(Self { amount, @@ -218,7 +206,7 @@ impl TryFrom< &WorldlineRouterData< &types::RouterData< - types::api::payments::Authorize, + api::payments::Authorize, PaymentsAuthorizeData, PaymentsResponseData, >, @@ -230,7 +218,7 @@ impl fn try_from( item: &WorldlineRouterData< &types::RouterData< - types::api::payments::Authorize, + api::payments::Authorize, PaymentsAuthorizeData, PaymentsResponseData, >, @@ -593,7 +581,7 @@ impl TryFrom TryFrom> })?, }, description: item.response.description, - response: Ok(types::PaymentsResponseData::TransactionResponse { + response: Ok(PaymentsResponseData::TransactionResponse { resource_id: types::ResponseId::try_from(item.response.links)?, redirection_data: None, mandate_reference: None, diff --git a/crates/router/src/connector/zen/transformers.rs b/crates/router/src/connector/zen/transformers.rs index ead716af72..67538b819d 100644 --- a/crates/router/src/connector/zen/transformers.rs +++ b/crates/router/src/connector/zen/transformers.rs @@ -23,22 +23,10 @@ pub struct ZenRouterData { pub router_data: T, } -impl - TryFrom<( - &types::api::CurrencyUnit, - types::storage::enums::Currency, - i64, - T, - )> for ZenRouterData -{ +impl TryFrom<(&api::CurrencyUnit, enums::Currency, i64, T)> for ZenRouterData { type Error = error_stack::Report; fn try_from( - (currency_unit, currency, amount, item): ( - &types::api::CurrencyUnit, - types::storage::enums::Currency, - i64, - T, - ), + (currency_unit, currency, amount, item): (&api::CurrencyUnit, enums::Currency, i64, T), ) -> Result { let amount = utils::get_amount_as_string(currency_unit, amount, currency)?; Ok(Self { diff --git a/crates/router/src/connector/zsl/transformers.rs b/crates/router/src/connector/zsl/transformers.rs index 3ffd5b2cce..58ff6ab2fa 100644 --- a/crates/router/src/connector/zsl/transformers.rs +++ b/crates/router/src/connector/zsl/transformers.rs @@ -27,19 +27,12 @@ pub struct ZslRouterData { pub router_data: T, } -impl - TryFrom<( - &types::api::CurrencyUnit, - types::storage::enums::Currency, - i64, - T, - )> for ZslRouterData -{ +impl TryFrom<(&types::api::CurrencyUnit, enums::Currency, i64, T)> for ZslRouterData { type Error = error_stack::Report; fn try_from( (currency_unit, currency, txn_amount, item): ( &types::api::CurrencyUnit, - types::storage::enums::Currency, + enums::Currency, i64, T, ), diff --git a/crates/router/src/core/admin.rs b/crates/router/src/core/admin.rs index 0b8d52332d..ee06097a59 100644 --- a/crates/router/src/core/admin.rs +++ b/crates/router/src/core/admin.rs @@ -268,7 +268,7 @@ pub async fn create_merchant_account( .await .to_duplicate_response(errors::ApiErrorResponse::DuplicateMerchantAccount)?; - db.insert_config(diesel_models::configs::ConfigNew { + db.insert_config(configs::ConfigNew { key: format!("{}_requires_cvv", merchant_account.merchant_id), config: "true".to_string(), }) @@ -545,7 +545,7 @@ pub async fn merchant_account_update( let updated_merchant_account = storage::MerchantAccountUpdate::Update { merchant_name: req .merchant_name - .map(masking::Secret::new) + .map(Secret::new) .async_lift(|inner| domain_types::encrypt_optional(inner, key)) .await .change_context(errors::ApiErrorResponse::InternalServerError) @@ -554,11 +554,11 @@ pub async fn merchant_account_update( merchant_details: req .merchant_details .as_ref() - .map(utils::Encode::encode_to_value) + .map(Encode::encode_to_value) .transpose() .change_context(errors::ApiErrorResponse::InternalServerError) .attach_printable("Unable to convert merchant_details to a value")? - .map(masking::Secret::new) + .map(Secret::new) .async_lift(|inner| domain_types::encrypt_optional(inner, key)) .await .change_context(errors::ApiErrorResponse::InternalServerError) @@ -569,7 +569,7 @@ pub async fn merchant_account_update( webhook_details: req .webhook_details .as_ref() - .map(utils::Encode::encode_to_value) + .map(Encode::encode_to_value) .transpose() .change_context(errors::ApiErrorResponse::InternalServerError)?, @@ -941,8 +941,8 @@ pub async fn create_payment_connector( business_country: req.business_country, business_label: req.business_label.clone(), business_sub_label: req.business_sub_label.clone(), - created_at: common_utils::date_time::now(), - modified_at: common_utils::date_time::now(), + created_at: date_time::now(), + modified_at: date_time::now(), id: None, connector_webhook_details: match req.connector_webhook_details { Some(connector_webhook_details) => { @@ -951,7 +951,7 @@ pub async fn create_payment_connector( .change_context(errors::ApiErrorResponse::InternalServerError) .attach_printable(format!("Failed to serialize api_models::admin::MerchantConnectorWebhookDetails for Merchant: {}", merchant_id)) .map(Some)? - .map(masking::Secret::new) + .map(Secret::new) } None => None, }, @@ -1278,7 +1278,7 @@ pub async fn update_payment_connector( .encode_to_value() .change_context(errors::ApiErrorResponse::InternalServerError) .map(Some)? - .map(masking::Secret::new), + .map(Secret::new), None => None, }, applepay_verified_domains: None, @@ -1458,7 +1458,7 @@ pub fn get_frm_config_as_secret( config .encode_to_value() .change_context(errors::ApiErrorResponse::ConfigNotFound) - .map(masking::Secret::new) + .map(Secret::new) }) .collect::, _>>() .ok()?; diff --git a/crates/router/src/core/api_keys.rs b/crates/router/src/core/api_keys.rs index f75ed01168..7f2b343b96 100644 --- a/crates/router/src/core/api_keys.rs +++ b/crates/router/src/core/api_keys.rs @@ -184,7 +184,7 @@ pub async fn add_api_key_expiry_task( api_key: &ApiKey, expiry_reminder_days: Vec, ) -> Result<(), errors::ProcessTrackerError> { - let current_time = common_utils::date_time::now(); + let current_time = date_time::now(); let schedule_time = expiry_reminder_days .first() @@ -341,7 +341,7 @@ pub async fn update_api_key_expiry_task( api_key: &ApiKey, expiry_reminder_days: Vec, ) -> Result<(), errors::ProcessTrackerError> { - let current_time = common_utils::date_time::now(); + let current_time = date_time::now(); let schedule_time = expiry_reminder_days .first() diff --git a/crates/router/src/core/authentication.rs b/crates/router/src/core/authentication.rs index 36ee3c2041..e2f605304a 100644 --- a/crates/router/src/core/authentication.rs +++ b/crates/router/src/core/authentication.rs @@ -9,7 +9,7 @@ use common_utils::errors::CustomResult; use error_stack::ResultExt; use masking::ExposeInterface; -use super::errors::{self, StorageErrorExt}; +use super::errors::StorageErrorExt; use crate::{ core::{errors::ApiErrorResponse, payments as payments_core}, routes::AppState, @@ -23,10 +23,10 @@ pub async fn perform_authentication( authentication_connector: String, payment_method_data: payments::PaymentMethodData, payment_method: common_enums::PaymentMethod, - billing_address: api_models::payments::Address, - shipping_address: Option, + billing_address: payments::Address, + shipping_address: Option, browser_details: Option, - business_profile: core_types::storage::BusinessProfile, + business_profile: storage::BusinessProfile, merchant_connector_account: payments_core::helpers::MerchantConnectorAccountType, amount: Option, currency: Option, @@ -35,10 +35,10 @@ pub async fn perform_authentication( authentication_data: storage::Authentication, return_url: Option, sdk_information: Option, - threeds_method_comp_ind: api_models::payments::ThreeDsCompletionIndicator, + threeds_method_comp_ind: payments::ThreeDsCompletionIndicator, email: Option, webhook_url: String, -) -> CustomResult { +) -> CustomResult { let router_data = transformers::construct_authentication_router_data( authentication_connector.clone(), payment_method_data, @@ -72,13 +72,13 @@ pub async fn perform_authentication( status_code: err.status_code, reason: err.reason, })?; - core_types::api::authentication::AuthenticationResponse::try_from(authentication) + api::authentication::AuthenticationResponse::try_from(authentication) } pub async fn perform_post_authentication( state: &AppState, key_store: &domain::MerchantKeyStore, - business_profile: core_types::storage::BusinessProfile, + business_profile: storage::BusinessProfile, authentication_id: String, ) -> CustomResult { let (authentication_connector, three_ds_connector_account) = @@ -96,7 +96,7 @@ pub async fn perform_post_authentication( authentication_id.clone(), ) .await - .to_not_found_response(errors::ApiErrorResponse::InternalServerError) + .to_not_found_response(ApiErrorResponse::InternalServerError) .attach_printable_lazy(|| format!("Error while fetching authentication record with authentication_id {authentication_id}"))?; if !authentication.authentication_status.is_terminal_status() && is_pull_mechanism_enabled { let router_data = transformers::construct_post_authentication_router_data( @@ -119,7 +119,7 @@ pub async fn perform_pre_authentication( key_store: &domain::MerchantKeyStore, card_number: cards::CardNumber, token: String, - business_profile: &core_types::storage::BusinessProfile, + business_profile: &storage::BusinessProfile, acquirer_details: Option, payment_id: Option, ) -> CustomResult { @@ -135,7 +135,7 @@ pub async fn perform_pre_authentication( payment_id, three_ds_connector_account .get_mca_id() - .ok_or(errors::ApiErrorResponse::InternalServerError) + .ok_or(ApiErrorResponse::InternalServerError) .attach_printable("Error while finding mca_id from merchant_connector_account")?, ) .await?; diff --git a/crates/router/src/core/authentication/transformers.rs b/crates/router/src/core/authentication/transformers.rs index d4cad2fbed..9e00dfe70c 100644 --- a/crates/router/src/core/authentication/transformers.rs +++ b/crates/router/src/core/authentication/transformers.rs @@ -29,8 +29,8 @@ pub fn construct_authentication_router_data( authentication_connector: String, payment_method_data: payments::PaymentMethodData, payment_method: PaymentMethod, - billing_address: api_models::payments::Address, - shipping_address: Option, + billing_address: payments::Address, + shipping_address: Option, browser_details: Option, amount: Option, currency: Option, @@ -40,8 +40,8 @@ pub fn construct_authentication_router_data( merchant_connector_account: payments_helpers::MerchantConnectorAccountType, authentication_data: storage::Authentication, return_url: Option, - sdk_information: Option, - threeds_method_comp_ind: api_models::payments::ThreeDsCompletionIndicator, + sdk_information: Option, + threeds_method_comp_ind: payments::ThreeDsCompletionIndicator, email: Option, webhook_url: String, ) -> RouterResult { diff --git a/crates/router/src/core/customers.rs b/crates/router/src/core/customers.rs index af97c500f3..3b10b408f9 100644 --- a/crates/router/src/core/customers.rs +++ b/crates/router/src/core/customers.rs @@ -37,7 +37,7 @@ pub async fn create_customer( let db = state.store.as_ref(); let customer_id = &customer_data.customer_id; let merchant_id = &merchant_account.merchant_id; - customer_data.merchant_id = merchant_id.to_owned(); + merchant_id.clone_into(&mut customer_data.merchant_id); // We first need to validate whether the customer with the given customer id already exists // this may seem like a redundant db call, as the insert_customer will anyway return this error diff --git a/crates/router/src/core/errors.rs b/crates/router/src/core/errors.rs index d80d86460b..a70a97e7bf 100644 --- a/crates/router/src/core/errors.rs +++ b/crates/router/src/core/errors.rs @@ -105,7 +105,7 @@ impl From for EncryptionError { pub fn http_not_implemented() -> actix_web::HttpResponse { ApiErrorResponse::NotImplemented { - message: api_error_response::NotImplementedMessage::Default, + message: NotImplementedMessage::Default, } .error_response() } diff --git a/crates/router/src/core/files.rs b/crates/router/src/core/files.rs index e2ce5b42c3..5dedcb1486 100644 --- a/crates/router/src/core/files.rs +++ b/crates/router/src/core/files.rs @@ -7,7 +7,7 @@ use super::errors::{self, RouterResponse}; use crate::{ consts, routes::AppState, - services::{self, ApplicationResponse}, + services::ApplicationResponse, types::{api, domain}, }; @@ -72,9 +72,9 @@ pub async fn files_create_core( .attach_printable_lazy(|| { format!("Unable to update file_metadata with file_id: {}", file_id) })?; - Ok(services::api::ApplicationResponse::Json( - files::CreateFileResponse { file_id }, - )) + Ok(ApplicationResponse::Json(files::CreateFileResponse { + file_id, + })) } pub async fn files_delete_core( diff --git a/crates/router/src/core/fraud_check.rs b/crates/router/src/core/fraud_check.rs index 5e03033977..e26d5d0b46 100644 --- a/crates/router/src/core/fraud_check.rs +++ b/crates/router/src/core/fraud_check.rs @@ -81,10 +81,10 @@ where ) .await?; - frm_data.payment_attempt.connector_transaction_id = payment_data + frm_data .payment_attempt .connector_transaction_id - .clone(); + .clone_from(&payment_data.payment_attempt.connector_transaction_id); let mut router_data = frm_data .construct_router_data( @@ -676,7 +676,7 @@ where if matches!(fraud_capture_method, Some(Some(CaptureMethod::Manual))) && matches!( payment_data.payment_attempt.status, - api_models::enums::AttemptStatus::Unresolved + AttemptStatus::Unresolved ) { if let Some(info) = frm_info { diff --git a/crates/router/src/core/mandate.rs b/crates/router/src/core/mandate.rs index 939367bd4d..7a1e294f9d 100644 --- a/crates/router/src/core/mandate.rs +++ b/crates/router/src/core/mandate.rs @@ -512,11 +512,11 @@ impl ForeignFrom> pub trait MandateBehaviour { fn get_amount(&self) -> i64; fn get_setup_future_usage(&self) -> Option; - fn get_mandate_id(&self) -> Option<&api_models::payments::MandateIds>; - fn set_mandate_id(&mut self, new_mandate_id: Option); + fn get_mandate_id(&self) -> Option<&payments::MandateIds>; + fn set_mandate_id(&mut self, new_mandate_id: Option); fn get_payment_method_data(&self) -> domain::payments::PaymentMethodData; fn get_setup_mandate_details( &self, ) -> Option<&hyperswitch_domain_models::mandates::MandateData>; - fn get_customer_acceptance(&self) -> Option; + fn get_customer_acceptance(&self) -> Option; } diff --git a/crates/router/src/core/payment_link.rs b/crates/router/src/core/payment_link.rs index 3f9f5f017a..11c53a77b1 100644 --- a/crates/router/src/core/payment_link.rs +++ b/crates/router/src/core/payment_link.rs @@ -350,7 +350,9 @@ fn validate_order_details( order_details_amount_string.product_img_link = Some(DEFAULT_PRODUCT_IMG.to_string()) } else { - order_details_amount_string.product_img_link = order.product_img_link.clone() + order_details_amount_string + .product_img_link + .clone_from(&order.product_img_link) }; order_details_amount_string.amount = currency diff --git a/crates/router/src/core/payment_methods/cards.rs b/crates/router/src/core/payment_methods/cards.rs index d3f6aeea24..9ae327269c 100644 --- a/crates/router/src/core/payment_methods/cards.rs +++ b/crates/router/src/core/payment_methods/cards.rs @@ -115,10 +115,10 @@ pub async fn create_payment_method( payment_method_type: req.payment_method_type, payment_method_issuer: req.payment_method_issuer.clone(), scheme: req.card_network.clone(), - metadata: pm_metadata.map(masking::Secret::new), + metadata: pm_metadata.map(Secret::new), payment_method_data, connector_mandate_details, - customer_acceptance: customer_acceptance.map(masking::Secret::new), + customer_acceptance: customer_acceptance.map(Secret::new), client_secret: Some(client_secret), status: status.unwrap_or(enums::PaymentMethodStatus::Active), network_transaction_id: network_transaction_id.to_owned(), @@ -201,7 +201,7 @@ pub async fn get_or_insert_payment_method( .await; match &existing_pm_by_locker_id { - Ok(pm) => payment_method_id = pm.payment_method_id.clone(), + Ok(pm) => payment_method_id.clone_from(&pm.payment_method_id), Err(_) => payment_method_id = generate_id(consts::ID_LENGTH, "pm"), }; existing_pm_by_locker_id @@ -212,7 +212,7 @@ pub async fn get_or_insert_payment_method( existing_pm_by_pmid } }; - resp.payment_method_id = payment_method_id.to_owned(); + payment_method_id.clone_into(&mut resp.payment_method_id); match payment_method { Ok(pm) => Ok(pm), @@ -405,7 +405,7 @@ pub async fn add_payment_method_data( return Ok(services::ApplicationResponse::Json(pm_resp)); } else { let locker_id = pm_resp.payment_method_id.clone(); - pm_resp.payment_method_id = pm_id.clone(); + pm_resp.payment_method_id.clone_from(&pm_id); pm_resp.client_secret = Some(client_secret.clone()); let card_isin = card.card_number.clone().get_card_isin(); @@ -898,7 +898,9 @@ pub async fn update_customer_payment_method( payment_method_data: pm_data_encrypted, }; - add_card_resp.payment_method_id = pm.payment_method_id.clone(); + add_card_resp + .payment_method_id + .clone_from(&pm.payment_method_id); db.update_payment_method(pm, pm_update, merchant_account.storage_scheme) .await @@ -1191,7 +1193,7 @@ pub async fn add_card_hs( card_exp_year: card.card_exp_year.to_owned(), card_brand: card.card_network.as_ref().map(ToString::to_string), card_isin: None, - nick_name: card.nick_name.as_ref().map(masking::Secret::peek).cloned(), + nick_name: card.nick_name.as_ref().map(Secret::peek).cloned(), }, }); @@ -2912,7 +2914,7 @@ fn filter_pm_based_on_supported_payments_for_mandate( } fn filter_pm_based_on_config<'a>( - config: &'a crate::configs::settings::ConnectorFilters, + config: &'a settings::ConnectorFilters, connector: &'a str, payment_method_type: &'a api_enums::PaymentMethodType, payment_attempt: Option<&storage::PaymentAttempt>, @@ -3615,7 +3617,7 @@ pub async fn get_card_details_with_locker_fallback( Ok(if let Some(mut crd) = card_decrypted { if crd.saved_to_locker { - crd.scheme = pm.scheme.clone(); + crd.scheme.clone_from(&pm.scheme); Some(crd) } else { None @@ -3645,7 +3647,7 @@ pub async fn get_card_details_without_locker_fallback( }); Ok(if let Some(mut crd) = card_decrypted { - crd.scheme = pm.scheme.clone(); + crd.scheme.clone_from(&pm.scheme); crd } else { get_card_details_from_locker(state, pm).await? @@ -4005,10 +4007,7 @@ impl TempLockerCardSupport { metrics::TASKS_ADDED_COUNT.add( &metrics::CONTEXT, 1, - &[metrics::request::add_attributes( - "flow", - "DeleteTokenizeData", - )], + &[request::add_attributes("flow", "DeleteTokenizeData")], ); Ok(card) } @@ -4171,7 +4170,7 @@ pub async fn create_encrypted_payment_method_data( let pm_data_encrypted: Option = pm_data .as_ref() - .map(utils::Encode::encode_to_value) + .map(Encode::encode_to_value) .transpose() .change_context(errors::StorageError::SerializationFailed) .attach_printable("Unable to convert payment method data to a value") @@ -4179,7 +4178,7 @@ pub async fn create_encrypted_payment_method_data( logger::error!(err=?err); None }) - .map(masking::Secret::<_, masking::WithType>::new) + .map(Secret::<_, masking::WithType>::new) .async_lift(|inner| encrypt_optional(inner, key)) .await .change_context(errors::StorageError::EncryptionError) diff --git a/crates/router/src/core/payment_methods/transformers.rs b/crates/router/src/core/payment_methods/transformers.rs index 9c53642f4d..009e9e5446 100644 --- a/crates/router/src/core/payment_methods/transformers.rs +++ b/crates/router/src/core/payment_methods/transformers.rs @@ -563,7 +563,7 @@ pub fn get_card_detail( card_token: None, card_fingerprint: None, card_holder_name: response.name_on_card, - nick_name: response.nick_name.map(masking::Secret::new), + nick_name: response.nick_name.map(Secret::new), card_isin: None, card_issuer: None, card_network: None, diff --git a/crates/router/src/core/payments.rs b/crates/router/src/core/payments.rs index 07bceefb0f..0e10c2a541 100644 --- a/crates/router/src/core/payments.rs +++ b/crates/router/src/core/payments.rs @@ -12,8 +12,10 @@ pub mod transformers; pub mod types; #[cfg(feature = "olap")] -use std::collections::{HashMap, HashSet}; -use std::{fmt::Debug, marker::PhantomData, ops::Deref, time::Instant, vec::IntoIter}; +use std::collections::HashMap; +use std::{ + collections::HashSet, fmt::Debug, marker::PhantomData, ops::Deref, time::Instant, vec::IntoIter, +}; #[cfg(feature = "olap")] use api_models::admin::MerchantConnectorInfo; @@ -119,7 +121,7 @@ where router_types::RouterData: Feature, // To construct connector flow specific api - dyn router_types::api::Connector: + dyn api::Connector: services::api::ConnectorIntegration, // To perform router related operation for PaymentResponse @@ -265,7 +267,7 @@ where _ => (), }; payment_data = match connector_details { - api::ConnectorCallType::PreDetermined(connector) => { + ConnectorCallType::PreDetermined(connector) => { let schedule_time = if should_add_task_to_process_tracker { payment_sync::get_sync_process_schedule_time( &*state.store, @@ -330,7 +332,7 @@ where .await? } - api::ConnectorCallType::Retryable(connectors) => { + ConnectorCallType::Retryable(connectors) => { let mut connectors = connectors.into_iter(); let connector_data = get_connector_data(&mut connectors)?; @@ -432,7 +434,7 @@ where .await? } - api::ConnectorCallType::SessionMultiple(connectors) => { + ConnectorCallType::SessionMultiple(connectors) => { let session_surcharge_details = call_surcharge_decision_management_for_session_flow( state, @@ -741,7 +743,7 @@ pub async fn payments_core( req: Req, auth_flow: services::AuthFlow, call_connector_action: CallConnectorAction, - eligible_connectors: Option>, + eligible_connectors: Option>, header_payload: HeaderPayload, ) -> RouterResponse where @@ -756,7 +758,7 @@ where Ctx: PaymentMethodRetrieve, // To construct connector flow specific api - dyn router_types::api::Connector: + dyn api::Connector: services::api::ConnectorIntegration, // To perform router related operation for PaymentResponse @@ -994,7 +996,7 @@ impl PaymentRedirectFlow for PaymentRedirectCom // If the status is requires customer action, then send the startpay url again // The redirection data must have been provided and updated by the connector let redirection_response = match payments_response.status { - api_models::enums::IntentStatus::RequiresCustomerAction => { + enums::IntentStatus::RequiresCustomerAction => { let startpay_url = payments_response .next_action .clone() @@ -1021,9 +1023,9 @@ impl PaymentRedirectFlow for PaymentRedirectCom }) } // If the status is terminal status, then redirect to merchant return url to provide status - api_models::enums::IntentStatus::Succeeded - | api_models::enums::IntentStatus::Failed - | api_models::enums::IntentStatus::Cancelled | api_models::enums::IntentStatus::RequiresCapture| api_models::enums::IntentStatus::Processing=> helpers::get_handle_response_url( + enums::IntentStatus::Succeeded + | enums::IntentStatus::Failed + | enums::IntentStatus::Cancelled | enums::IntentStatus::RequiresCapture| enums::IntentStatus::Processing=> helpers::get_handle_response_url( payment_id, &payment_flow_response.business_profile, payments_response, @@ -1293,9 +1295,8 @@ impl PaymentRedirectFlow for PaymentAuthenticat }?; // When intent status is RequiresCustomerAction, Set poll_id in redis to allow the fetch status of poll through retrieve_poll_status api from client if payments_response.status == common_enums::IntentStatus::RequiresCustomerAction { - let req_poll_id = - super::utils::get_external_authentication_request_poll_id(&payment_id); - let poll_id = super::utils::get_poll_id(merchant_id.clone(), req_poll_id.clone()); + let req_poll_id = utils::get_external_authentication_request_poll_id(&payment_id); + let poll_id = utils::get_poll_id(merchant_id.clone(), req_poll_id.clone()); let redis_conn = state .store .get_redis_conn() @@ -1797,7 +1798,7 @@ where merchant_connector_account.get_mca_id(), )?; - let connector_label = super::utils::get_connector_label( + let connector_label = utils::get_connector_label( payment_data.payment_intent.business_country, payment_data.payment_intent.business_label.as_ref(), payment_data.payment_attempt.business_sub_label.as_ref(), @@ -2087,13 +2088,11 @@ fn is_apple_pay_pre_decrypt_type_connector_tokenization( } fn decide_apple_pay_flow( - payment_method_type: &Option, + payment_method_type: &Option, merchant_connector_account: Option<&helpers::MerchantConnectorAccountType>, ) -> Option { payment_method_type.and_then(|pmt| match pmt { - api_models::enums::PaymentMethodType::ApplePay => { - check_apple_pay_metadata(merchant_connector_account) - } + enums::PaymentMethodType::ApplePay => check_apple_pay_metadata(merchant_connector_account), _ => None, }) } @@ -3032,7 +3031,7 @@ pub async fn get_connector_choice( business_profile: &storage::business_profile::BusinessProfile, key_store: &domain::MerchantKeyStore, payment_data: &mut PaymentData, - eligible_connectors: Option>, + eligible_connectors: Option>, mandate_type: Option, ) -> RouterResult> where @@ -3061,7 +3060,7 @@ where connectors, ) .await?; - api::ConnectorCallType::SessionMultiple(routing_output) + ConnectorCallType::SessionMultiple(routing_output) } api::ConnectorChoice::StraightThrough(straight_through) => { @@ -3112,7 +3111,7 @@ pub async fn connector_selection( key_store: &domain::MerchantKeyStore, payment_data: &mut PaymentData, request_straight_through: Option, - eligible_connectors: Option>, + eligible_connectors: Option>, mandate_type: Option, ) -> RouterResult where @@ -3188,7 +3187,7 @@ pub async fn decide_connector( payment_data: &mut PaymentData, request_straight_through: Option, routing_data: &mut storage::RoutingData, - eligible_connectors: Option>, + eligible_connectors: Option>, mandate_type: Option, ) -> RouterResult where @@ -3209,7 +3208,7 @@ where .attach_printable("Invalid connector name received in 'routed_through'")?; routing_data.routed_through = Some(connector_name.clone()); - return Ok(api::ConnectorCallType::PreDetermined(connector_data)); + return Ok(ConnectorCallType::PreDetermined(connector_data)); } if let Some(mandate_connector_details) = payment_data.mandate_connector.as_ref() { @@ -3228,10 +3227,11 @@ where routing_data.routed_through = Some(mandate_connector_details.connector.clone()); #[cfg(feature = "connector_choice_mca_id")] { - routing_data.merchant_connector_id = - mandate_connector_details.merchant_connector_id.clone(); + routing_data + .merchant_connector_id + .clone_from(&mandate_connector_details.merchant_connector_id); } - return Ok(api::ConnectorCallType::PreDetermined(connector_data)); + return Ok(ConnectorCallType::PreDetermined(connector_data)); } if let Some((pre_routing_results, storage_pm_type)) = routing_data @@ -3259,13 +3259,15 @@ where routing_data.routed_through = Some(choice.connector.to_string()); #[cfg(feature = "connector_choice_mca_id")] { - routing_data.merchant_connector_id = choice.merchant_connector_id.clone(); + routing_data + .merchant_connector_id + .clone_from(&choice.merchant_connector_id); } #[cfg(not(feature = "connector_choice_mca_id"))] { routing_data.business_sub_label = choice.sub_label.clone(); } - return Ok(api::ConnectorCallType::PreDetermined(connector_data)); + return Ok(ConnectorCallType::PreDetermined(connector_data)); } } @@ -3540,14 +3542,16 @@ pub async fn decide_multiplex_connector_for_normal_or_recurring_payment { let first_choice = connectors @@ -3570,7 +3574,7 @@ pub async fn decide_multiplex_connector_for_normal_or_recurring_payment( key_store: &domain::MerchantKeyStore, transaction_data: TransactionData<'_, F>, routing_data: &mut storage::RoutingData, - eligible_connectors: Option>, + eligible_connectors: Option>, mandate_type: Option, ) -> RouterResult where @@ -4015,7 +4019,7 @@ pub async fn payment_external_authentication( return_url, req.sdk_information, req.threeds_method_comp_ind, - optional_customer.and_then(|customer| customer.email.map(common_utils::pii::Email::from)), + optional_customer.and_then(|customer| customer.email.map(pii::Email::from)), webhook_url, )) .await?; diff --git a/crates/router/src/core/payments/access_token.rs b/crates/router/src/core/payments/access_token.rs index 1de9cb60ca..f7fe5b7844 100644 --- a/crates/router/src/core/payments/access_token.rs +++ b/crates/router/src/core/payments/access_token.rs @@ -35,7 +35,7 @@ pub fn update_router_data_with_access_token_result( if should_update_router_data { match add_access_token_result.access_token_result.as_ref() { Ok(access_token) => { - router_data.access_token = access_token.clone(); + router_data.access_token.clone_from(access_token); true } Err(connector_error) => { diff --git a/crates/router/src/core/payments/flows/authorize_flow.rs b/crates/router/src/core/payments/flows/authorize_flow.rs index 6b64dc0404..09b9628454 100644 --- a/crates/router/src/core/payments/flows/authorize_flow.rs +++ b/crates/router/src/core/payments/flows/authorize_flow.rs @@ -266,7 +266,7 @@ pub async fn authorize_preprocessing_steps( Err(types::ErrorResponse::default()); let preprocessing_router_data = - payments::helpers::router_data_type_conversion::<_, api::PreProcessing, _, _, _, _>( + helpers::router_data_type_conversion::<_, api::PreProcessing, _, _, _, _>( router_data.clone(), preprocessing_request_data, preprocessing_response_data, @@ -303,12 +303,11 @@ pub async fn authorize_preprocessing_steps( ], ); - let authorize_router_data = - payments::helpers::router_data_type_conversion::<_, F, _, _, _, _>( - resp.clone(), - router_data.request.to_owned(), - resp.response, - ); + let authorize_router_data = helpers::router_data_type_conversion::<_, F, _, _, _, _>( + resp.clone(), + router_data.request.to_owned(), + resp.response, + ); Ok(authorize_router_data) } else { diff --git a/crates/router/src/core/payments/flows/complete_authorize_flow.rs b/crates/router/src/core/payments/flows/complete_authorize_flow.rs index baf4190395..667fa3feed 100644 --- a/crates/router/src/core/payments/flows/complete_authorize_flow.rs +++ b/crates/router/src/core/payments/flows/complete_authorize_flow.rs @@ -172,7 +172,7 @@ pub async fn complete_authorize_preprocessing_steps( Err(types::ErrorResponse::default()); let preprocessing_router_data = - payments::helpers::router_data_type_conversion::<_, api::PreProcessing, _, _, _, _>( + helpers::router_data_type_conversion::<_, api::PreProcessing, _, _, _, _>( router_data.clone(), preprocessing_request_data, preprocessing_response_data, @@ -206,15 +206,14 @@ pub async fn complete_authorize_preprocessing_steps( connector_metadata, .. }) = &resp.response { - router_data_request.connector_meta = connector_metadata.to_owned(); + connector_metadata.clone_into(&mut router_data_request.connector_meta); }; - let authorize_router_data = - payments::helpers::router_data_type_conversion::<_, F, _, _, _, _>( - resp.clone(), - router_data_request, - resp.response, - ); + let authorize_router_data = helpers::router_data_type_conversion::<_, F, _, _, _, _>( + resp.clone(), + router_data_request, + resp.response, + ); Ok(authorize_router_data) } else { diff --git a/crates/router/src/core/payments/helpers.rs b/crates/router/src/core/payments/helpers.rs index f17a7075d4..e4c4540cac 100644 --- a/crates/router/src/core/payments/helpers.rs +++ b/crates/router/src/core/payments/helpers.rs @@ -636,7 +636,7 @@ pub async fn get_token_for_recurring_mandate( merchant_connector_id: mandate.merchant_connector_id, }; - if let Some(diesel_models::enums::PaymentMethod::Card) = payment_method.payment_method { + if let Some(enums::PaymentMethod::Card) = payment_method.payment_method { if state.conf.locker.locker_enabled { let _ = cards::get_lookup_key_from_locker( state, diff --git a/crates/router/src/core/payments/operations/payment_approve.rs b/crates/router/src/core/payments/operations/payment_approve.rs index 87943b4cf2..8dffd8eaec 100644 --- a/crates/router/src/core/payments/operations/payment_approve.rs +++ b/crates/router/src/core/payments/operations/payment_approve.rs @@ -59,10 +59,7 @@ impl helpers::validate_payment_status_against_not_allowed_statuses( &payment_intent.status, - &[ - storage_enums::IntentStatus::Failed, - storage_enums::IntentStatus::Succeeded, - ], + &[IntentStatus::Failed, IntentStatus::Succeeded], "approve", )?; diff --git a/crates/router/src/core/payments/operations/payment_cancel.rs b/crates/router/src/core/payments/operations/payment_cancel.rs index 3e53128083..32035391fb 100644 --- a/crates/router/src/core/payments/operations/payment_cancel.rs +++ b/crates/router/src/core/payments/operations/payment_cancel.rs @@ -112,7 +112,9 @@ impl let currency = payment_attempt.currency.get_required_value("currency")?; let amount = payment_attempt.get_total_amount().into(); - payment_attempt.cancellation_reason = request.cancellation_reason.clone(); + payment_attempt + .cancellation_reason + .clone_from(&request.cancellation_reason); let creds_identifier = request .merchant_connector_details diff --git a/crates/router/src/core/payments/operations/payment_create.rs b/crates/router/src/core/payments/operations/payment_create.rs index e770da7074..0d24120220 100644 --- a/crates/router/src/core/payments/operations/payment_create.rs +++ b/crates/router/src/core/payments/operations/payment_create.rs @@ -31,7 +31,6 @@ use crate::{ routes::{app::ReqState, AppState}, services, types::{ - self, api::{self, PaymentIdTypeExt}, domain, storage::{ @@ -949,7 +948,7 @@ impl PaymentCreate { #[allow(clippy::too_many_arguments)] async fn make_payment_intent( payment_id: &str, - merchant_account: &types::domain::MerchantAccount, + merchant_account: &domain::MerchantAccount, money: (api::Amount, enums::Currency), request: &api::PaymentsRequest, shipping_address_id: Option, @@ -971,7 +970,7 @@ impl PaymentCreate { request.confirm, ); let client_secret = - crate::utils::generate_id(consts::ID_LENGTH, format!("{payment_id}_secret").as_str()); + utils::generate_id(consts::ID_LENGTH, format!("{payment_id}_secret").as_str()); let (amount, currency) = (money.0, Some(money.1)); let order_details = request diff --git a/crates/router/src/core/payments/operations/payment_response.rs b/crates/router/src/core/payments/operations/payment_response.rs index b40ee8e5c9..c3ef748c03 100644 --- a/crates/router/src/core/payments/operations/payment_response.rs +++ b/crates/router/src/core/payments/operations/payment_response.rs @@ -19,7 +19,6 @@ use crate::{ mandate, payment_methods::{self, PaymentMethodRetrieve}, payments::{ - self, helpers::{ self as payments_helpers, update_additional_payment_data_with_connector_response_pm_data, @@ -727,8 +726,8 @@ async fn payment_response_update_tracker( Some(multiple_capture_data) => { let capture_update = storage::CaptureUpdate::ErrorUpdate { status: match err.status_code { - 500..=511 => storage::enums::CaptureStatus::Pending, - _ => storage::enums::CaptureStatus::Failed, + 500..=511 => enums::CaptureStatus::Pending, + _ => enums::CaptureStatus::Failed, }, error_code: Some(err.code), error_message: Some(err.message), @@ -761,20 +760,20 @@ async fn payment_response_update_tracker( if flow_name == "PSync" { match err.status_code { // marking failure for 2xx because this is genuine payment failure - 200..=299 => storage::enums::AttemptStatus::Failure, + 200..=299 => enums::AttemptStatus::Failure, _ => router_data.status, } } else if flow_name == "Capture" { match err.status_code { - 500..=511 => storage::enums::AttemptStatus::Pending, + 500..=511 => enums::AttemptStatus::Pending, // don't update the status for 429 error status 429 => router_data.status, - _ => storage::enums::AttemptStatus::Failure, + _ => enums::AttemptStatus::Failure, } } else { match err.status_code { - 500..=511 => storage::enums::AttemptStatus::Pending, - _ => storage::enums::AttemptStatus::Failure, + 500..=511 => enums::AttemptStatus::Pending, + _ => enums::AttemptStatus::Failure, } } } @@ -896,8 +895,10 @@ async fn payment_response_update_tracker( }; if router_data.status == enums::AttemptStatus::Charged { - payment_data.payment_intent.fingerprint_id = - payment_data.payment_attempt.fingerprint_id.clone(); + payment_data + .payment_intent + .fingerprint_id + .clone_from(&payment_data.payment_attempt.fingerprint_id); metrics::SUCCESSFUL_PAYMENT.add(&metrics::CONTEXT, 1, &[]); } @@ -1075,8 +1076,7 @@ async fn payment_response_update_tracker( payment_data.authentication = match payment_data.authentication { Some(authentication) => { let authentication_update = storage::AuthenticationUpdate::PostAuthorizationUpdate { - authentication_lifecycle_status: - storage::enums::AuthenticationLifecycleStatus::Used, + authentication_lifecycle_status: enums::AuthenticationLifecycleStatus::Used, }; let updated_authentication = state .store @@ -1159,7 +1159,7 @@ async fn payment_response_update_tracker( }; if let Some(payment_method) = payment_data.payment_method_info.clone() { let connector_mandate_details = - payments::tokenization::update_connector_mandate_details_in_payment_method( + tokenization::update_connector_mandate_details_in_payment_method( payment_method.clone(), payment_method.payment_method_type, Some(payment_data.payment_attempt.amount), diff --git a/crates/router/src/core/payments/operations/payment_status.rs b/crates/router/src/core/payments/operations/payment_status.rs index 4c0359c28f..06ad57346f 100644 --- a/crates/router/src/core/payments/operations/payment_status.rs +++ b/crates/router/src/core/payments/operations/payment_status.rs @@ -289,7 +289,7 @@ async fn get_tracker_for_sync< ) .await?; - payment_attempt.encoded_data = request.param.clone(); + payment_attempt.encoded_data.clone_from(&request.param); let attempts = match request.expand_attempts { Some(true) => { diff --git a/crates/router/src/core/payments/operations/payment_update.rs b/crates/router/src/core/payments/operations/payment_update.rs index 0aaa600605..de83b935ff 100644 --- a/crates/router/src/core/payments/operations/payment_update.rs +++ b/crates/router/src/core/payments/operations/payment_update.rs @@ -727,8 +727,6 @@ impl .await .to_not_found_response(errors::ApiErrorResponse::PaymentNotFound)?; - payment_data.mandate_id = payment_data.mandate_id.clone(); - Ok(( payments::is_confirm(self, payment_data.confirm), payment_data, @@ -832,7 +830,9 @@ impl PaymentUpdate { payment_intent.business_country = request.business_country; - payment_intent.business_label = request.business_label.clone(); + payment_intent + .business_label + .clone_from(&request.business_label); request .description diff --git a/crates/router/src/core/payments/tokenization.rs b/crates/router/src/core/payments/tokenization.rs index 958c3f4362..e7bb8f86d5 100644 --- a/crates/router/src/core/payments/tokenization.rs +++ b/crates/router/src/core/payments/tokenization.rs @@ -205,9 +205,7 @@ where }; let pm_card_details = resp.card.as_ref().map(|card| { - api::payment_methods::PaymentMethodsData::Card(CardDetailsPaymentMethod::from( - card.clone(), - )) + PaymentMethodsData::Card(CardDetailsPaymentMethod::from(card.clone())) }); let pm_data_encrypted = @@ -243,7 +241,7 @@ where match &existing_pm_by_locker_id { Ok(pm) => { - payment_method_id = pm.payment_method_id.clone() + payment_method_id.clone_from(&pm.payment_method_id); } Err(_) => { payment_method_id = @@ -351,7 +349,8 @@ where match &existing_pm_by_locker_id { Ok(pm) => { - payment_method_id = pm.payment_method_id.clone() + payment_method_id + .clone_from(&pm.payment_method_id); } Err(_) => { payment_method_id = @@ -564,7 +563,7 @@ async fn skip_saving_card_in_locker( .customer_id .clone() .get_required_value("customer_id")?; - let payment_method_id = common_utils::generate_id(crate::consts::ID_LENGTH, "pm"); + let payment_method_id = common_utils::generate_id(consts::ID_LENGTH, "pm"); let last4_digits = payment_method_request .card @@ -616,7 +615,7 @@ async fn skip_saving_card_in_locker( Ok((pm_resp, None)) } None => { - let pm_id = common_utils::generate_id(crate::consts::ID_LENGTH, "pm"); + let pm_id = common_utils::generate_id(consts::ID_LENGTH, "pm"); let payment_method_response = api::PaymentMethodResponse { merchant_id: merchant_id.to_string(), customer_id: Some(customer_id), @@ -666,7 +665,7 @@ pub async fn save_in_locker( .change_context(errors::ApiErrorResponse::InternalServerError) .attach_printable("Add Card Failed"), None => { - let pm_id = common_utils::generate_id(crate::consts::ID_LENGTH, "pm"); + let pm_id = common_utils::generate_id(consts::ID_LENGTH, "pm"); let payment_method_response = api::PaymentMethodResponse { merchant_id: merchant_id.to_string(), customer_id: Some(customer_id), @@ -732,18 +731,12 @@ pub async fn add_payment_method_token( let pm_token_response_data: Result = Err(types::ErrorResponse::default()); - let mut pm_token_router_data = payments::helpers::router_data_type_conversion::< - _, - api::PaymentMethodToken, - _, - _, - _, - _, - >( - router_data.clone(), - pm_token_request_data, - pm_token_response_data, - ); + let mut pm_token_router_data = + helpers::router_data_type_conversion::<_, api::PaymentMethodToken, _, _, _, _>( + router_data.clone(), + pm_token_request_data, + pm_token_response_data, + ); connector_integration .execute_pretasks(&mut pm_token_router_data, state) diff --git a/crates/router/src/core/payments/transformers.rs b/crates/router/src/core/payments/transformers.rs index 56874e5a9f..2b7ba070d2 100644 --- a/crates/router/src/core/payments/transformers.rs +++ b/crates/router/src/core/payments/transformers.rs @@ -1547,8 +1547,8 @@ impl TryFrom for storage::CaptureUpdate { .. } => Ok(Self::ErrorUpdate { status: match status_code { - 500..=511 => storage::enums::CaptureStatus::Pending, - _ => storage::enums::CaptureStatus::Failed, + 500..=511 => enums::CaptureStatus::Pending, + _ => enums::CaptureStatus::Failed, }, error_code: Some(code), error_message: Some(message), diff --git a/crates/router/src/core/payouts/helpers.rs b/crates/router/src/core/payouts/helpers.rs index e521fac9a8..790cb25c47 100644 --- a/crates/router/src/core/payouts/helpers.rs +++ b/crates/router/src/core/payouts/helpers.rs @@ -403,7 +403,9 @@ pub async fn save_payout_data_to_locker( .await .flatten() .map(|card_info| { - payment_method.payment_method_issuer = card_info.card_issuer.clone(); + payment_method + .payment_method_issuer + .clone_from(&card_info.card_issuer); payment_method.card_network = card_info.card_network.clone().map(|cn| cn.to_string()); api::payment_methods::PaymentMethodsData::Card( @@ -641,7 +643,7 @@ pub async fn decide_payout_connector( request_straight_through: Option, routing_data: &mut storage::RoutingData, payout_data: &mut PayoutData, - eligible_connectors: Option>, + eligible_connectors: Option>, ) -> RouterResult { // 1. For existing attempts, use stored connector let payout_attempt = &payout_data.payout_attempt; diff --git a/crates/router/src/core/payouts/retry.rs b/crates/router/src/core/payouts/retry.rs index 6bbee9a4ce..a7dcfa864a 100644 --- a/crates/router/src/core/payouts/retry.rs +++ b/crates/router/src/core/payouts/retry.rs @@ -114,7 +114,7 @@ pub async fn do_gsm_single_connector_actions( if let Ordering::Equal = gsm.cmp(&previous_gsm) { break; } - previous_gsm = gsm.clone(); + previous_gsm.clone_from(&gsm); match get_gsm_decision(gsm) { api_models::gsm::GsmDecision::Retry => { diff --git a/crates/router/src/core/pm_auth.rs b/crates/router/src/core/pm_auth.rs index 09ea935ea7..88138d7909 100644 --- a/crates/router/src/core/pm_auth.rs +++ b/crates/router/src/core/pm_auth.rs @@ -64,7 +64,7 @@ pub async fn create_link_token( let redis_conn = db .get_redis_conn() - .change_context(errors::ApiErrorResponse::InternalServerError) + .change_context(ApiErrorResponse::InternalServerError) .attach_printable("Failed to get redis connection")?; let pm_auth_key = format!("pm_auth_{}", payload.payment_id); @@ -75,7 +75,7 @@ pub async fn create_link_token( "Vec", ) .await - .change_context(errors::ApiErrorResponse::InternalServerError) + .change_context(ApiErrorResponse::InternalServerError) .attach_printable("Failed to get payment method auth choices from redis")?; let selected_config = pm_auth_configs @@ -132,7 +132,7 @@ pub async fn create_link_token( &key_store, ) .await - .change_context(errors::ApiErrorResponse::MerchantConnectorAccountNotFound { + .change_context(ApiErrorResponse::MerchantConnectorAccountNotFound { id: merchant_account.merchant_id.clone(), })?; @@ -145,7 +145,7 @@ pub async fn create_link_token( request: pm_auth_types::LinkTokenRequest { client_name: "HyperSwitch".to_string(), country_codes: Some(vec![billing_country.ok_or( - errors::ApiErrorResponse::MissingRequiredField { + ApiErrorResponse::MissingRequiredField { field_name: "billing_country", }, )?]), @@ -216,8 +216,7 @@ pub async fn exchange_token_core( let connector_name = config.connector_name.as_str(); - let connector = - pm_auth_types::api::PaymentAuthConnectorData::get_connector_by_name(connector_name)?; + let connector = PaymentAuthConnectorData::get_connector_by_name(connector_name)?; let merchant_connector_account = state .store @@ -227,7 +226,7 @@ pub async fn exchange_token_core( &key_store, ) .await - .change_context(errors::ApiErrorResponse::MerchantConnectorAccountNotFound { + .change_context(ApiErrorResponse::MerchantConnectorAccountNotFound { id: merchant_account.merchant_id.clone(), })?; @@ -405,9 +404,7 @@ async fn store_bank_details_in_payment_methods( connector_details: vec![payment_methods::BankAccountConnectorDetails { connector: connector_name.to_string(), mca_id: mca_id.clone(), - access_token: payment_methods::BankAccountAccessCreds::AccessToken( - access_token.clone(), - ), + access_token: BankAccountAccessCreds::AccessToken(access_token.clone()), account_id: creds.account_id, }], }; @@ -612,7 +609,7 @@ async fn get_selected_config_from_redis( ) -> RouterResult { let redis_conn = db .get_redis_conn() - .change_context(errors::ApiErrorResponse::InternalServerError) + .change_context(ApiErrorResponse::InternalServerError) .attach_printable("Failed to get redis connection")?; let pm_auth_key = format!("pm_auth_{}", payload.payment_id); @@ -623,7 +620,7 @@ async fn get_selected_config_from_redis( "Vec", ) .await - .change_context(errors::ApiErrorResponse::GenericNotFoundError { + .change_context(ApiErrorResponse::GenericNotFoundError { message: "payment method auth connector name not found".to_string(), }) .attach_printable("Failed to get payment method auth choices from redis")?; @@ -651,14 +648,14 @@ pub async fn retrieve_payment_method_from_auth_service( ) -> RouterResult> { let db = state.store.as_ref(); - let connector = pm_auth_types::api::PaymentAuthConnectorData::get_connector_by_name( + let connector = PaymentAuthConnectorData::get_connector_by_name( auth_token.connector_details.connector.as_str(), )?; let merchant_account = db .find_merchant_account_by_merchant_id(&payment_intent.merchant_id, key_store) .await - .to_not_found_response(errors::ApiErrorResponse::MerchantAccountNotFound)?; + .to_not_found_response(ApiErrorResponse::MerchantAccountNotFound)?; let mca = db .find_by_merchant_connector_account_merchant_id_merchant_connector_id( @@ -667,7 +664,7 @@ pub async fn retrieve_payment_method_from_auth_service( key_store, ) .await - .to_not_found_response(errors::ApiErrorResponse::MerchantConnectorAccountNotFound { + .to_not_found_response(ApiErrorResponse::MerchantConnectorAccountNotFound { id: auth_token.connector_details.mca_id.clone(), }) .attach_printable( @@ -697,7 +694,7 @@ pub async fn retrieve_payment_method_from_auth_service( acc.payment_method_type == auth_token.payment_method_type && acc.payment_method == auth_token.payment_method }) - .ok_or(errors::ApiErrorResponse::InternalServerError) + .ok_or(ApiErrorResponse::InternalServerError) .attach_printable("Bank account details not found")?; let mut bank_type = None; @@ -720,7 +717,7 @@ pub async fn retrieve_payment_method_from_auth_service( let name = address .as_ref() .and_then(|addr| addr.first_name.clone().map(|name| name.into_inner())) - .ok_or(errors::ApiErrorResponse::GenericNotFoundError { + .ok_or(ApiErrorResponse::GenericNotFoundError { message: "billing_first_name not found".to_string(), }) .attach_printable("billing_first_name not found")?; diff --git a/crates/router/src/core/user/dashboard_metadata.rs b/crates/router/src/core/user/dashboard_metadata.rs index c3512c32f4..ee1693b0c9 100644 --- a/crates/router/src/core/user/dashboard_metadata.rs +++ b/crates/router/src/core/user/dashboard_metadata.rs @@ -8,15 +8,15 @@ use masking::ExposeInterface; #[cfg(feature = "email")] use router_env::logger; +#[cfg(feature = "email")] +use crate::services::email::types as email_types; use crate::{ core::errors::{UserErrors, UserResponse, UserResult}, routes::{app::ReqState, AppState}, services::{authentication::UserFromToken, ApplicationResponse}, - types::domain::{user::dashboard_metadata as types, MerchantKeyStore}, + types::domain::{self, user::dashboard_metadata as types, MerchantKeyStore}, utils::user::dashboard_metadata as utils, }; -#[cfg(feature = "email")] -use crate::{services::email::types as email_types, types::domain}; pub async fn set_metadata( state: AppState, @@ -709,7 +709,7 @@ pub async fn get_merchant_connector_account_by_name( merchant_id: &str, connector_name: &str, key_store: &MerchantKeyStore, -) -> UserResult> { +) -> UserResult> { state .store .find_merchant_connector_account_by_merchant_id_connector_name( diff --git a/crates/router/src/core/utils.rs b/crates/router/src/core/utils.rs index 3923663f5d..ac546ef5e4 100644 --- a/crates/router/src/core/utils.rs +++ b/crates/router/src/core/utils.rs @@ -564,7 +564,7 @@ pub async fn construct_accept_dispute_router_data<'a>( dispute_id: dispute.dispute_id.clone(), connector_dispute_id: dispute.connector_dispute_id.clone(), }, - response: Err(types::ErrorResponse::default()), + response: Err(ErrorResponse::default()), access_token: None, session_token: None, reference_id: None, @@ -654,7 +654,7 @@ pub async fn construct_submit_evidence_router_data<'a>( connector_meta_data: merchant_connector_account.get_metadata(), amount_captured: payment_intent.amount_captured, request: submit_evidence_request_data, - response: Err(types::ErrorResponse::default()), + response: Err(ErrorResponse::default()), access_token: None, session_token: None, reference_id: None, @@ -752,7 +752,7 @@ pub async fn construct_upload_file_router_data<'a>( file_type: create_file_request.file_type.clone(), file_size: create_file_request.file_size, }, - response: Err(types::ErrorResponse::default()), + response: Err(ErrorResponse::default()), access_token: None, session_token: None, reference_id: None, @@ -936,7 +936,7 @@ pub async fn construct_retrieve_file_router_data<'a>( .ok_or(errors::ApiErrorResponse::InternalServerError) .attach_printable("Missing provider file id")?, }, - response: Err(types::ErrorResponse::default()), + response: Err(ErrorResponse::default()), access_token: None, session_token: None, reference_id: None, @@ -1225,9 +1225,7 @@ pub fn get_incremental_authorization_allowed_value( incremental_authorization_allowed: Option, request_incremental_authorization: Option, ) -> Option { - if request_incremental_authorization - == Some(common_enums::RequestIncrementalAuthorization::False) - { + if request_incremental_authorization == Some(RequestIncrementalAuthorization::False) { Some(false) } else { incremental_authorization_allowed diff --git a/crates/router/src/core/verification.rs b/crates/router/src/core/verification.rs index 8782126b0b..fe3d752497 100644 --- a/crates/router/src/core/verification.rs +++ b/crates/router/src/core/verification.rs @@ -89,7 +89,7 @@ pub async fn get_verified_apple_domains_with_mid_mca_id( merchant_id: String, merchant_connector_id: String, ) -> CustomResult< - services::ApplicationResponse, + services::ApplicationResponse, api_error_response::ApiErrorResponse, > { let db = state.store.as_ref(); @@ -110,6 +110,6 @@ pub async fn get_verified_apple_domains_with_mid_mca_id( .unwrap_or_default(); Ok(services::api::ApplicationResponse::Json( - api_models::verifications::ApplepayVerifiedDomainsResponse { verified_domains }, + verifications::ApplepayVerifiedDomainsResponse { verified_domains }, )) } diff --git a/crates/router/src/core/webhooks.rs b/crates/router/src/core/webhooks.rs index 6647549e39..3c04fdb7e4 100644 --- a/crates/router/src/core/webhooks.rs +++ b/crates/router/src/core/webhooks.rs @@ -74,7 +74,7 @@ pub async fn payments_incoming_webhook_flow( payments::CallConnectorAction::Trigger }; let payments_response = match webhook_details.object_reference_id { - api_models::webhooks::ObjectReferenceId::PaymentId(id) => { + webhooks::ObjectReferenceId::PaymentId(id) => { let payment_id = get_payment_id( state.store.as_ref(), &id, @@ -84,7 +84,7 @@ pub async fn payments_incoming_webhook_flow( .await?; let lock_action = api_locking::LockAction::Hold { - input: super::api_locking::LockingInput { + input: api_locking::LockingInput { unique_locking_key: payment_id, api_identifier: lock_utils::ApiIdentifier::Payments, override_lock_retries: None, @@ -213,13 +213,13 @@ pub async fn refunds_incoming_webhook_flow( webhook_details: api::IncomingWebhookDetails, connector_name: &str, source_verified: bool, - event_type: api_models::webhooks::IncomingWebhookEvent, + event_type: webhooks::IncomingWebhookEvent, ) -> CustomResult { let db = &*state.store; //find refund by connector refund id let refund = match webhook_details.object_reference_id { - api_models::webhooks::ObjectReferenceId::RefundId(refund_id_type) => match refund_id_type { - api_models::webhooks::RefundIdType::RefundId(id) => db + webhooks::ObjectReferenceId::RefundId(refund_id_type) => match refund_id_type { + webhooks::RefundIdType::RefundId(id) => db .find_refund_by_merchant_id_refund_id( &merchant_account.merchant_id, &id, @@ -228,7 +228,7 @@ pub async fn refunds_incoming_webhook_flow( .await .change_context(errors::ApiErrorResponse::WebhookResourceNotFound) .attach_printable("Failed to fetch the refund")?, - api_models::webhooks::RefundIdType::ConnectorRefundId(id) => db + webhooks::RefundIdType::ConnectorRefundId(id) => db .find_refund_by_merchant_id_connector_refund_id_connector( &merchant_account.merchant_id, &id, @@ -305,7 +305,7 @@ pub async fn refunds_incoming_webhook_flow( pub async fn get_payment_attempt_from_object_reference_id( state: &AppState, - object_reference_id: api_models::webhooks::ObjectReferenceId, + object_reference_id: webhooks::ObjectReferenceId, merchant_account: &domain::MerchantAccount, ) -> CustomResult< hyperswitch_domain_models::payments::payment_attempt::PaymentAttempt, @@ -349,7 +349,7 @@ pub async fn get_or_update_dispute_object( dispute_details: api::disputes::DisputePayload, merchant_id: &str, payment_attempt: &hyperswitch_domain_models::payments::payment_attempt::PaymentAttempt, - event_type: api_models::webhooks::IncomingWebhookEvent, + event_type: webhooks::IncomingWebhookEvent, business_profile: &diesel_models::business_profile::BusinessProfile, connector_name: &str, ) -> CustomResult { @@ -425,7 +425,7 @@ pub async fn external_authentication_incoming_webhook_flow, connector: &(dyn api::Connector + Sync), object_ref_id: api::ObjectReferenceId, @@ -601,7 +601,7 @@ pub async fn mandates_incoming_webhook_flow( key_store: domain::MerchantKeyStore, webhook_details: api::IncomingWebhookDetails, source_verified: bool, - event_type: api_models::webhooks::IncomingWebhookEvent, + event_type: webhooks::IncomingWebhookEvent, ) -> CustomResult { if source_verified { let db = &*state.store; @@ -691,7 +691,7 @@ pub async fn disputes_incoming_webhook_flow( source_verified: bool, connector: &(dyn api::Connector + Sync), request_details: &api::IncomingWebhookRequestDetails<'_>, - event_type: api_models::webhooks::IncomingWebhookEvent, + event_type: webhooks::IncomingWebhookEvent, ) -> CustomResult { metrics::INCOMING_DISPUTE_WEBHOOK_METRIC.add(&metrics::CONTEXT, 1, &[]); if source_verified { @@ -1612,7 +1612,7 @@ pub async fn webhooks_core( outgoing_webhook, payment_response_hash_key ), - _ => get_outgoing_webhook_request_inner::( + _ => get_outgoing_webhook_request_inner::( outgoing_webhook, payment_response_hash_key, ), diff --git a/crates/router/src/core/webhooks/utils.rs b/crates/router/src/core/webhooks/utils.rs index 3bf8c7c7f2..ad1aafd312 100644 --- a/crates/router/src/core/webhooks/utils.rs +++ b/crates/router/src/core/webhooks/utils.rs @@ -124,8 +124,8 @@ pub async fn construct_webhook_router_data<'a>( #[inline] pub(crate) fn get_idempotent_event_id( primary_object_id: &str, - event_type: crate::types::storage::enums::EventType, - delivery_attempt: crate::types::storage::enums::WebhookDeliveryAttempt, + event_type: types::storage::enums::EventType, + delivery_attempt: types::storage::enums::WebhookDeliveryAttempt, ) -> String { use crate::types::storage::enums::WebhookDeliveryAttempt; diff --git a/crates/router/src/db.rs b/crates/router/src/db.rs index 9b222486d1..ca9432fcba 100644 --- a/crates/router/src/db.rs +++ b/crates/router/src/db.rs @@ -190,7 +190,7 @@ where let bytes = db.get_key(key).await?; bytes .parse_struct(type_name) - .change_context(redis_interface::errors::RedisError::JsonDeserializationFailed) + .change_context(RedisError::JsonDeserializationFailed) } dyn_clone::clone_trait_object!(StorageInterface); diff --git a/crates/router/src/db/business_profile.rs b/crates/router/src/db/business_profile.rs index 7b5ade8c96..5e7c9bd0b2 100644 --- a/crates/router/src/db/business_profile.rs +++ b/crates/router/src/db/business_profile.rs @@ -6,7 +6,7 @@ use crate::{ connection, core::errors::{self, CustomResult}, db::MockDb, - types::storage::{self, business_profile}, + types::storage::business_profile, }; #[async_trait::async_trait] @@ -65,7 +65,7 @@ impl BusinessProfileInterface for Store { profile_id: &str, ) -> CustomResult { let conn = connection::pg_connection_read(self).await?; - storage::business_profile::BusinessProfile::find_by_profile_id(&conn, profile_id) + business_profile::BusinessProfile::find_by_profile_id(&conn, profile_id) .await .map_err(|error| report!(errors::StorageError::from(error))) } @@ -77,7 +77,7 @@ impl BusinessProfileInterface for Store { merchant_id: &str, ) -> CustomResult { let conn = connection::pg_connection_read(self).await?; - storage::business_profile::BusinessProfile::find_by_profile_name_merchant_id( + business_profile::BusinessProfile::find_by_profile_name_merchant_id( &conn, profile_name, merchant_id, @@ -93,7 +93,7 @@ impl BusinessProfileInterface for Store { business_profile_update: business_profile::BusinessProfileUpdate, ) -> CustomResult { let conn = connection::pg_connection_write(self).await?; - storage::business_profile::BusinessProfile::update_by_profile_id( + business_profile::BusinessProfile::update_by_profile_id( current_state, &conn, business_profile_update, @@ -109,7 +109,7 @@ impl BusinessProfileInterface for Store { merchant_id: &str, ) -> CustomResult { let conn = connection::pg_connection_write(self).await?; - storage::business_profile::BusinessProfile::delete_by_profile_id_merchant_id( + business_profile::BusinessProfile::delete_by_profile_id_merchant_id( &conn, profile_id, merchant_id, @@ -124,12 +124,9 @@ impl BusinessProfileInterface for Store { merchant_id: &str, ) -> CustomResult, errors::StorageError> { let conn = connection::pg_connection_read(self).await?; - storage::business_profile::BusinessProfile::list_business_profile_by_merchant_id( - &conn, - merchant_id, - ) - .await - .map_err(|error| report!(errors::StorageError::from(error))) + business_profile::BusinessProfile::list_business_profile_by_merchant_id(&conn, merchant_id) + .await + .map_err(|error| report!(errors::StorageError::from(error))) } } diff --git a/crates/router/src/db/cache.rs b/crates/router/src/db/cache.rs index 7f2462b3fc..d9db13dde8 100644 --- a/crates/router/src/db/cache.rs +++ b/crates/router/src/db/cache.rs @@ -43,7 +43,7 @@ where }; match redis_val { Err(err) => match err.current_context() { - errors::RedisError::NotFound | errors::RedisError::JsonDeserializationFailed => { + RedisError::NotFound | RedisError::JsonDeserializationFailed => { get_data_set_redis().await } _ => Err(err diff --git a/crates/router/src/db/dispute.rs b/crates/router/src/db/dispute.rs index 0fe5f3d766..097ad9beab 100644 --- a/crates/router/src/db/dispute.rs +++ b/crates/router/src/db/dispute.rs @@ -444,7 +444,7 @@ mod tests { #[tokio::test] async fn test_find_by_merchant_id_payment_id_connector_dispute_id() { #[allow(clippy::expect_used)] - let mockdb = MockDb::new(&redis_interface::RedisSettings::default()) + let mockdb = MockDb::new(&RedisSettings::default()) .await .expect("Failed to create Mock store"); @@ -487,7 +487,7 @@ mod tests { #[tokio::test] async fn test_find_dispute_by_merchant_id_dispute_id() { #[allow(clippy::expect_used)] - let mockdb = MockDb::new(&redis_interface::RedisSettings::default()) + let mockdb = MockDb::new(&RedisSettings::default()) .await .expect("Failed to create Mock store"); @@ -524,7 +524,7 @@ mod tests { #[tokio::test] async fn test_find_disputes_by_merchant_id() { #[allow(clippy::expect_used)] - let mockdb = MockDb::new(&redis_interface::RedisSettings::default()) + let mockdb = MockDb::new(&RedisSettings::default()) .await .expect("Failed to create Mock store"); @@ -578,7 +578,7 @@ mod tests { #[tokio::test] async fn test_find_disputes_by_merchant_id_payment_id() { #[allow(clippy::expect_used)] - let mockdb = MockDb::new(&redis_interface::RedisSettings::default()) + let mockdb = MockDb::new(&RedisSettings::default()) .await .expect("Failed to create Mock store"); diff --git a/crates/router/src/db/user_role.rs b/crates/router/src/db/user_role.rs index e31a266335..fff82334be 100644 --- a/crates/router/src/db/user_role.rs +++ b/crates/router/src/db/user_role.rs @@ -377,8 +377,8 @@ impl UserRoleInterface for MockDb { status, modified_by, } => { - user_role.status = status.to_owned(); - user_role.last_modified_by = modified_by.to_owned(); + status.clone_into(&mut user_role.status); + modified_by.clone_into(&mut user_role.last_modified_by); } } updated_user_roles.push(user_role.to_owned()); diff --git a/crates/router/src/lib.rs b/crates/router/src/lib.rs index fdabd07fa0..d11e5cf997 100644 --- a/crates/router/src/lib.rs +++ b/crates/router/src/lib.rs @@ -188,7 +188,7 @@ pub async fn start_server(conf: settings::Settings) -> Applicatio errors::ApplicationError::ApiClientError(error.current_context().clone()) })?, ); - let state = Box::pin(routes::AppState::new(conf, tx, api_client)).await; + let state = Box::pin(AppState::new(conf, tx, api_client)).await; let request_body_limit = server.request_body_limit; let server = actix_web::HttpServer::new(move || mk_app(state.clone(), request_body_limit)) .bind((server.host.as_str(), server.port))? diff --git a/crates/router/src/routes/api_keys.rs b/crates/router/src/routes/api_keys.rs index 5595958915..f1170f0f0b 100644 --- a/crates/router/src/routes/api_keys.rs +++ b/crates/router/src/routes/api_keys.rs @@ -131,7 +131,7 @@ pub async fn api_key_update( let (merchant_id, key_id) = path.into_inner(); let mut payload = json_payload.into_inner(); payload.key_id = key_id; - payload.merchant_id = merchant_id.clone(); + payload.merchant_id.clone_from(&merchant_id); api::server_wrap( flow, diff --git a/crates/router/src/routes/metrics/request.rs b/crates/router/src/routes/metrics/request.rs index 029c1c61f2..ef53ad83f2 100644 --- a/crates/router/src/routes/metrics/request.rs +++ b/crates/router/src/routes/metrics/request.rs @@ -24,7 +24,7 @@ where #[inline] pub async fn record_operation_time( future: F, - metric: &once_cell::sync::Lazy>, + metric: &once_cell::sync::Lazy>, key_value: &[opentelemetry::KeyValue], ) -> R where @@ -35,11 +35,11 @@ where result } -pub fn add_attributes>( +pub fn add_attributes>( key: &'static str, value: T, -) -> router_env::opentelemetry::KeyValue { - router_env::opentelemetry::KeyValue::new(key, value) +) -> opentelemetry::KeyValue { + opentelemetry::KeyValue::new(key, value) } pub fn status_code_metrics(status_code: i64, flow: String, merchant_id: String) { diff --git a/crates/router/src/routes/payments.rs b/crates/router/src/routes/payments.rs index c9e1cf14ce..70112e2703 100644 --- a/crates/router/src/routes/payments.rs +++ b/crates/router/src/routes/payments.rs @@ -131,7 +131,7 @@ pub async fn payments_create( req_state, auth.merchant_account, auth.key_store, - payment_types::HeaderPayload::default(), + HeaderPayload::default(), req, api::AuthFlow::Merchant, ) @@ -420,7 +420,7 @@ pub async fn payments_update( req_state, auth.merchant_account, auth.key_store, - payment_types::HeaderPayload::default(), + HeaderPayload::default(), req, auth_flow, ) @@ -471,7 +471,7 @@ pub async fn payments_confirm( tracing::Span::current().record("payment_id", &payment_id); payload.payment_id = Some(payment_types::PaymentIdType::PaymentIntentId(payment_id)); payload.confirm = Some(true); - let header_payload = match payment_types::HeaderPayload::foreign_try_from(req.headers()) { + let header_payload = match HeaderPayload::foreign_try_from(req.headers()) { Ok(headers) => headers, Err(err) => { return api::log_and_return_error_response(err); @@ -1019,7 +1019,7 @@ pub async fn payments_approve( api::AuthFlow::Merchant, payments::CallConnectorAction::Trigger, None, - payment_types::HeaderPayload::default(), + HeaderPayload::default(), ) }, match env::which() { @@ -1081,7 +1081,7 @@ pub async fn payments_reject( api::AuthFlow::Merchant, payments::CallConnectorAction::Trigger, None, - payment_types::HeaderPayload::default(), + HeaderPayload::default(), ) }, match env::which() { @@ -1107,7 +1107,7 @@ async fn authorize_verify_select( header_payload: HeaderPayload, req: api_models::payments::PaymentsRequest, auth_flow: api::AuthFlow, -) -> app::core::errors::RouterResponse +) -> errors::RouterResponse where Ctx: PaymentMethodRetrieve, Op: Sync @@ -1530,8 +1530,10 @@ impl GetLockingInput for payment_types::PaymentsCaptureRequest { } } +#[cfg(feature = "oltp")] struct FPaymentsApproveRequest<'a>(&'a payment_types::PaymentsApproveRequest); +#[cfg(feature = "oltp")] impl<'a> GetLockingInput for FPaymentsApproveRequest<'a> { fn get_locking_input(&self, flow: F) -> api_locking::LockAction where @@ -1548,8 +1550,10 @@ impl<'a> GetLockingInput for FPaymentsApproveRequest<'a> { } } +#[cfg(feature = "oltp")] struct FPaymentsRejectRequest<'a>(&'a payment_types::PaymentsRejectRequest); +#[cfg(feature = "oltp")] impl<'a> GetLockingInput for FPaymentsRejectRequest<'a> { fn get_locking_input(&self, flow: F) -> api_locking::LockAction where diff --git a/crates/router/src/routes/recon.rs b/crates/router/src/routes/recon.rs index 7845f52c92..fc0794ff9e 100644 --- a/crates/router/src/routes/recon.rs +++ b/crates/router/src/routes/recon.rs @@ -1,6 +1,5 @@ use actix_web::{web, HttpRequest, HttpResponse}; use api_models::recon as recon_api; -use common_enums::ReconStatus; use error_stack::ResultExt; use masking::{ExposeInterface, PeekInterface, Secret}; use router_env::Flow; @@ -195,7 +194,7 @@ pub async fn recon_merchant_account_update( subject: "Approval of Recon Request - Access Granted to Recon Dashboard", }; - if req.recon_status == ReconStatus::Active { + if req.recon_status == enums::ReconStatus::Active { let _is_email_sent = state .email_client .compose_and_send_email( diff --git a/crates/router/src/routes/user.rs b/crates/router/src/routes/user.rs index a3f1816850..1ffb4dc8d1 100644 --- a/crates/router/src/routes/user.rs +++ b/crates/router/src/routes/user.rs @@ -167,9 +167,10 @@ pub async fn set_dashboard_metadata( let flow = Flow::SetDashboardMetadata; let mut payload = json_payload.into_inner(); - if let Err(e) = common_utils::errors::ReportSwitchExt::<(), ApiErrorResponse>::switch( - set_ip_address_if_required(&mut payload, req.headers()), - ) { + if let Err(e) = ReportSwitchExt::<(), ApiErrorResponse>::switch(set_ip_address_if_required( + &mut payload, + req.headers(), + )) { return api::log_and_return_error_response(e); } diff --git a/crates/router/src/routes/webhooks.rs b/crates/router/src/routes/webhooks.rs index 073b1c5700..cdf680548a 100644 --- a/crates/router/src/routes/webhooks.rs +++ b/crates/router/src/routes/webhooks.rs @@ -43,19 +43,3 @@ pub async fn receive_incoming_webhook( )) .await } - -#[derive(Debug)] -struct WebhookBytes(web::Bytes); - -impl serde::Serialize for WebhookBytes { - fn serialize(&self, serializer: S) -> Result { - let payload: serde_json::Value = serde_json::from_slice(&self.0).unwrap_or_default(); - payload.serialize(serializer) - } -} - -impl common_utils::events::ApiEventMetric for WebhookBytes { - fn get_api_event_type(&self) -> Option { - Some(common_utils::events::ApiEventsType::Miscellaneous) - } -} diff --git a/crates/router/src/services/api.rs b/crates/router/src/services/api.rs index 30c3ce164e..cfe4fea11b 100644 --- a/crates/router/src/services/api.rs +++ b/crates/router/src/services/api.rs @@ -273,7 +273,7 @@ pub enum CaptureSyncMethod { pub async fn execute_connector_processing_step< 'b, 'a, - T: 'static, + T, Req: Debug + Clone + 'static, Resp: Debug + Clone + 'static, >( @@ -284,7 +284,7 @@ pub async fn execute_connector_processing_step< connector_request: Option, ) -> CustomResult, errors::ConnectorError> where - T: Clone + Debug, + T: Clone + Debug + 'static, // BoxedConnectorIntegration: 'b, { // If needed add an error stack as follows @@ -651,7 +651,7 @@ pub async fn send_request( } .add_headers(headers) .timeout(Duration::from_secs( - option_timeout_secs.unwrap_or(crate::consts::REQUEST_TIME_OUT), + option_timeout_secs.unwrap_or(consts::REQUEST_TIME_OUT), )) }; @@ -920,7 +920,7 @@ pub enum RedirectForm { impl From<(url::Url, Method)> for RedirectForm { fn from((mut redirect_url, method): (url::Url, Method)) -> Self { - let form_fields = std::collections::HashMap::from_iter( + let form_fields = HashMap::from_iter( redirect_url .query_pairs() .map(|(key, value)| (key.to_string(), value.to_string())), @@ -1127,10 +1127,7 @@ where if unmasked_incoming_header_keys.contains(&key.as_str().to_lowercase()) { acc.insert(key.clone(), value.clone()); } else { - acc.insert( - key.clone(), - http::header::HeaderValue::from_static("**MASKED**"), - ); + acc.insert(key.clone(), HeaderValue::from_static("**MASKED**")); } acc }); diff --git a/crates/router/src/services/api/client.rs b/crates/router/src/services/api/client.rs index 09b4d25d0b..ae45a2a7fc 100644 --- a/crates/router/src/services/api/client.rs +++ b/crates/router/src/services/api/client.rs @@ -27,7 +27,7 @@ fn get_client_builder( ) -> CustomResult { let mut client_builder = reqwest::Client::builder() .redirect(reqwest::redirect::Policy::none()) - .pool_idle_timeout(std::time::Duration::from_secs( + .pool_idle_timeout(Duration::from_secs( proxy_config .idle_pool_connection_timeout .unwrap_or_default(), diff --git a/crates/router/src/services/authentication.rs b/crates/router/src/services/authentication.rs index 5f15474115..9aac92acd2 100644 --- a/crates/router/src/services/authentication.rs +++ b/crates/router/src/services/authentication.rs @@ -876,13 +876,13 @@ impl ClientSecretFetch for api_models::cards_info::CardsInfoRequest { } } -impl ClientSecretFetch for api_models::payments::PaymentsRetrieveRequest { +impl ClientSecretFetch for payments::PaymentsRetrieveRequest { fn get_client_secret(&self) -> Option<&String> { self.client_secret.as_ref() } } -impl ClientSecretFetch for api_models::payments::RetrievePaymentLinkRequest { +impl ClientSecretFetch for payments::RetrievePaymentLinkRequest { fn get_client_secret(&self) -> Option<&String> { self.client_secret.as_ref() } diff --git a/crates/router/src/services/pm_auth.rs b/crates/router/src/services/pm_auth.rs index 91b752aaf1..a54ba88199 100644 --- a/crates/router/src/services/pm_auth.rs +++ b/crates/router/src/services/pm_auth.rs @@ -11,22 +11,16 @@ use crate::{ services::{self}, }; -pub async fn execute_connector_processing_step< - 'b, - 'a, - T: 'static, - Req: Clone + 'static, - Resp: Clone + 'static, ->( +pub async fn execute_connector_processing_step<'b, 'a, T, Req, Resp>( state: &'b AppState, connector_integration: BoxedConnectorIntegration<'a, T, Req, Resp>, req: &'b PaymentAuthRouterData, connector: &pm_auth_types::PaymentMethodAuthConnectors, ) -> errors::CustomResult, ConnectorError> where - T: Clone, - Req: Clone, - Resp: Clone, + T: Clone + 'static, + Req: Clone + 'static, + Resp: Clone + 'static, { let mut router_data = req.clone(); diff --git a/crates/router/src/types/api/customers.rs b/crates/router/src/types/api/customers.rs index 6f08a7fd7e..e0ef95bcb0 100644 --- a/crates/router/src/types/api/customers.rs +++ b/crates/router/src/types/api/customers.rs @@ -3,7 +3,7 @@ pub use api_models::customers::{CustomerDeleteResponse, CustomerId, CustomerRequ use serde::Serialize; use super::payments; -use crate::{core::errors::RouterResult, newtype, types::domain}; +use crate::{newtype, types::domain}; newtype!( pub CustomerResponse = customers::CustomerResponse, @@ -16,10 +16,6 @@ impl common_utils::events::ApiEventMetric for CustomerResponse { } } -pub(crate) trait CustomerRequestExt: Sized { - fn validate(self) -> RouterResult; -} - impl From<(domain::Customer, Option)> for CustomerResponse { fn from((cust, address): (domain::Customer, Option)) -> Self { customers::CustomerResponse { diff --git a/crates/router/src/types/api/payments.rs b/crates/router/src/types/api/payments.rs index e36c68c27d..9f68cac98c 100644 --- a/crates/router/src/types/api/payments.rs +++ b/crates/router/src/types/api/payments.rs @@ -21,20 +21,6 @@ use crate::{ types::{self, api as api_types}, }; -pub(crate) trait PaymentsRequestExt { - fn is_mandate(&self) -> Option; -} - -impl PaymentsRequestExt for PaymentsRequest { - fn is_mandate(&self) -> Option { - match (&self.mandate_data, &self.mandate_id) { - (None, None) => None, - (_, Some(_)) => Some(MandateTransactionType::RecurringMandateTransaction), - (Some(_), _) => Some(MandateTransactionType::NewMandateTransaction), - } - } -} - impl super::Router for PaymentsRequest {} // Core related api layer. diff --git a/crates/router/src/types/api/verify_connector.rs b/crates/router/src/types/api/verify_connector.rs index 39891a7075..af7cb9160b 100644 --- a/crates/router/src/types/api/verify_connector.rs +++ b/crates/router/src/types/api/verify_connector.rs @@ -14,7 +14,7 @@ use crate::{ #[derive(Clone, Debug)] pub struct VerifyConnectorData { - pub connector: &'static (dyn types::api::Connector + Sync), + pub connector: &'static (dyn api::Connector + Sync), pub connector_auth: types::ConnectorAuthType, pub card_details: domain::Card, } @@ -155,11 +155,11 @@ pub trait VerifyConnector { } async fn handle_payment_error_response( - connector: &(dyn types::api::Connector + Sync), + connector: &(dyn api::Connector + Sync), error_response: types::Response, ) -> errors::RouterResponse<()> where - dyn types::api::Connector + Sync: ConnectorIntegration, + dyn api::Connector + Sync: ConnectorIntegration, { let error = connector .get_error_response(error_response, None) @@ -171,11 +171,11 @@ pub trait VerifyConnector { } async fn handle_access_token_error_response( - connector: &(dyn types::api::Connector + Sync), + connector: &(dyn api::Connector + Sync), error_response: types::Response, ) -> errors::RouterResult> where - dyn types::api::Connector + Sync: ConnectorIntegration, + dyn api::Connector + Sync: ConnectorIntegration, { let error = connector .get_error_response(error_response, None) diff --git a/crates/router/src/types/domain/customer.rs b/crates/router/src/types/domain/customer.rs index de95251d9d..139cd10577 100644 --- a/crates/router/src/types/domain/customer.rs +++ b/crates/router/src/types/domain/customer.rs @@ -148,14 +148,14 @@ impl From for CustomerUpdateInternal { }, CustomerUpdate::ConnectorCustomer { connector_customer } => Self { connector_customer, - modified_at: Some(common_utils::date_time::now()), + modified_at: Some(date_time::now()), ..Default::default() }, CustomerUpdate::UpdateDefaultPaymentMethod { default_payment_method_id, } => Self { default_payment_method_id, - modified_at: Some(common_utils::date_time::now()), + modified_at: Some(date_time::now()), ..Default::default() }, } diff --git a/crates/router/src/types/domain/merchant_connector_account.rs b/crates/router/src/types/domain/merchant_connector_account.rs index c84abbefc3..0e7f5b081c 100644 --- a/crates/router/src/types/domain/merchant_connector_account.rs +++ b/crates/router/src/types/domain/merchant_connector_account.rs @@ -195,7 +195,7 @@ impl From for MerchantConnectorAccountUpdateInte metadata, frm_configs: None, frm_config: frm_configs, - modified_at: Some(common_utils::date_time::now()), + modified_at: Some(date_time::now()), connector_webhook_details, applepay_verified_domains, pm_auth_config, diff --git a/crates/router/src/types/transformers.rs b/crates/router/src/types/transformers.rs index ef12e32d57..ce11251b83 100644 --- a/crates/router/src/types/transformers.rs +++ b/crates/router/src/types/transformers.rs @@ -176,20 +176,18 @@ impl ForeignTryFrom for storage_enums::CaptureStat } } -impl ForeignFrom for storage_enums::MandateDataType { - fn foreign_from(from: api_models::payments::MandateType) -> Self { +impl ForeignFrom for storage_enums::MandateDataType { + fn foreign_from(from: payments::MandateType) -> Self { match from { - api_models::payments::MandateType::SingleUse(inner) => { - Self::SingleUse(inner.foreign_into()) - } - api_models::payments::MandateType::MultiUse(inner) => { + payments::MandateType::SingleUse(inner) => Self::SingleUse(inner.foreign_into()), + payments::MandateType::MultiUse(inner) => { Self::MultiUse(inner.map(ForeignInto::foreign_into)) } } } } -impl ForeignFrom for api_models::payments::MandateType { +impl ForeignFrom for payments::MandateType { fn foreign_from(from: storage_enums::MandateDataType) -> Self { match from { storage_enums::MandateDataType::SingleUse(inner) => { @@ -302,7 +300,7 @@ impl ForeignTryFrom for common_enums::RoutableConnectors { } } -impl ForeignFrom for api_models::payments::MandateAmountData { +impl ForeignFrom for payments::MandateAmountData { fn foreign_from(from: storage_enums::MandateAmountData) -> Self { Self { amount: from.amount, @@ -315,18 +313,16 @@ impl ForeignFrom for api_models::payments::Man } // TODO: remove foreign from since this conversion won't be needed in the router crate once data models is treated as a single & primary source of truth for structure information -impl ForeignFrom - for hyperswitch_domain_models::mandates::MandateData -{ - fn foreign_from(d: api_models::payments::MandateData) -> Self { +impl ForeignFrom for hyperswitch_domain_models::mandates::MandateData { + fn foreign_from(d: payments::MandateData) -> Self { Self { customer_acceptance: d.customer_acceptance.map(|d| { hyperswitch_domain_models::mandates::CustomerAcceptance { acceptance_type: match d.acceptance_type { - api_models::payments::AcceptanceType::Online => { + payments::AcceptanceType::Online => { hyperswitch_domain_models::mandates::AcceptanceType::Online } - api_models::payments::AcceptanceType::Offline => { + payments::AcceptanceType::Offline => { hyperswitch_domain_models::mandates::AcceptanceType::Offline } }, @@ -340,7 +336,7 @@ impl ForeignFrom } }), mandate_type: d.mandate_type.map(|d| match d { - api_models::payments::MandateType::MultiUse(Some(i)) => { + payments::MandateType::MultiUse(Some(i)) => { hyperswitch_domain_models::mandates::MandateDataType::MultiUse(Some( hyperswitch_domain_models::mandates::MandateAmountData { amount: i.amount, @@ -351,7 +347,7 @@ impl ForeignFrom }, )) } - api_models::payments::MandateType::SingleUse(i) => { + payments::MandateType::SingleUse(i) => { hyperswitch_domain_models::mandates::MandateDataType::SingleUse( hyperswitch_domain_models::mandates::MandateAmountData { amount: i.amount, @@ -362,7 +358,7 @@ impl ForeignFrom }, ) } - api_models::payments::MandateType::MultiUse(None) => { + payments::MandateType::MultiUse(None) => { hyperswitch_domain_models::mandates::MandateDataType::MultiUse(None) } }), @@ -371,8 +367,8 @@ impl ForeignFrom } } -impl ForeignFrom for storage_enums::MandateAmountData { - fn foreign_from(from: api_models::payments::MandateAmountData) -> Self { +impl ForeignFrom for storage_enums::MandateAmountData { + fn foreign_from(from: payments::MandateAmountData) -> Self { Self { amount: from.amount, currency: from.currency, @@ -503,26 +499,27 @@ impl ForeignFrom for api_enums::PaymentMethod { } } -impl ForeignTryFrom for api_enums::PaymentMethod { +impl ForeignTryFrom for api_enums::PaymentMethod { type Error = errors::ApiErrorResponse; fn foreign_try_from( - payment_method_data: api_models::payments::PaymentMethodData, + payment_method_data: payments::PaymentMethodData, ) -> Result { match payment_method_data { - api_models::payments::PaymentMethodData::Card(..) - | api_models::payments::PaymentMethodData::CardToken(..) => Ok(Self::Card), - api_models::payments::PaymentMethodData::Wallet(..) => Ok(Self::Wallet), - api_models::payments::PaymentMethodData::PayLater(..) => Ok(Self::PayLater), - api_models::payments::PaymentMethodData::BankRedirect(..) => Ok(Self::BankRedirect), - api_models::payments::PaymentMethodData::BankDebit(..) => Ok(Self::BankDebit), - api_models::payments::PaymentMethodData::BankTransfer(..) => Ok(Self::BankTransfer), - api_models::payments::PaymentMethodData::Crypto(..) => Ok(Self::Crypto), - api_models::payments::PaymentMethodData::Reward => Ok(Self::Reward), - api_models::payments::PaymentMethodData::Upi(..) => Ok(Self::Upi), - api_models::payments::PaymentMethodData::Voucher(..) => Ok(Self::Voucher), - api_models::payments::PaymentMethodData::GiftCard(..) => Ok(Self::GiftCard), - api_models::payments::PaymentMethodData::CardRedirect(..) => Ok(Self::CardRedirect), - api_models::payments::PaymentMethodData::MandatePayment => { + payments::PaymentMethodData::Card(..) | payments::PaymentMethodData::CardToken(..) => { + Ok(Self::Card) + } + payments::PaymentMethodData::Wallet(..) => Ok(Self::Wallet), + payments::PaymentMethodData::PayLater(..) => Ok(Self::PayLater), + payments::PaymentMethodData::BankRedirect(..) => Ok(Self::BankRedirect), + payments::PaymentMethodData::BankDebit(..) => Ok(Self::BankDebit), + payments::PaymentMethodData::BankTransfer(..) => Ok(Self::BankTransfer), + payments::PaymentMethodData::Crypto(..) => Ok(Self::Crypto), + payments::PaymentMethodData::Reward => Ok(Self::Reward), + payments::PaymentMethodData::Upi(..) => Ok(Self::Upi), + payments::PaymentMethodData::Voucher(..) => Ok(Self::Voucher), + payments::PaymentMethodData::GiftCard(..) => Ok(Self::GiftCard), + payments::PaymentMethodData::CardRedirect(..) => Ok(Self::CardRedirect), + payments::PaymentMethodData::MandatePayment => { Err(errors::ApiErrorResponse::InvalidRequestData { message: ("Mandate payments cannot have payment_method_data field".to_string()), }) @@ -902,7 +899,7 @@ impl TryFrom for api_models::admin::MerchantCo } } -impl ForeignFrom for api_models::payments::PaymentAttemptResponse { +impl ForeignFrom for payments::PaymentAttemptResponse { fn foreign_from(payment_attempt: storage::PaymentAttempt) -> Self { Self { attempt_id: payment_attempt.attempt_id, @@ -929,7 +926,7 @@ impl ForeignFrom for api_models::payments::PaymentAttem } } -impl ForeignFrom for api_models::payments::CaptureResponse { +impl ForeignFrom for payments::CaptureResponse { fn foreign_from(capture: storage::Capture) -> Self { Self { capture_id: capture.capture_id, @@ -1003,7 +1000,7 @@ impl ForeignFrom for api_enums::PaymentMethod { } } -impl ForeignTryFrom<&HeaderMap> for api_models::payments::HeaderPayload { +impl ForeignTryFrom<&HeaderMap> for payments::HeaderPayload { type Error = error_stack::Report; fn foreign_try_from(headers: &HeaderMap) -> Result { let payment_confirm_source: Option = @@ -1047,7 +1044,7 @@ impl Option<&domain::Address>, Option<&domain::Address>, Option<&domain::Customer>, - )> for api_models::payments::PaymentsRequest + )> for payments::PaymentsRequest { fn foreign_from( value: ( @@ -1072,17 +1069,11 @@ impl } } -impl - ForeignFrom<( - storage::PaymentLink, - api_models::payments::PaymentLinkStatus, - )> for api_models::payments::RetrievePaymentLinkResponse +impl ForeignFrom<(storage::PaymentLink, payments::PaymentLinkStatus)> + for payments::RetrievePaymentLinkResponse { fn foreign_from( - (payment_link_config, status): ( - storage::PaymentLink, - api_models::payments::PaymentLinkStatus, - ), + (payment_link_config, status): (storage::PaymentLink, payments::PaymentLinkStatus), ) -> Self { Self { payment_link_id: payment_link_config.payment_link_id, @@ -1171,7 +1162,7 @@ impl ForeignFrom for gsm_api_types::GsmResponse { } } -impl ForeignFrom<&domain::Customer> for api_models::payments::CustomerDetails { +impl ForeignFrom<&domain::Customer> for payments::CustomerDetails { fn foreign_from(customer: &domain::Customer) -> Self { Self { id: customer.customer_id.clone(), diff --git a/crates/router/src/utils.rs b/crates/router/src/utils.rs index 341c560e4d..51854978b9 100644 --- a/crates/router/src/utils.rs +++ b/crates/router/src/utils.rs @@ -99,7 +99,7 @@ pub mod error_parser { } pub fn custom_json_error_handler(err: JsonPayloadError, _req: &HttpRequest) -> Error { - actix_web::error::Error::from(CustomJsonError { err }) + Error::from(CustomJsonError { err }) } } @@ -565,14 +565,14 @@ pub fn add_connector_http_status_code_metrics(option_status_code: Option) { pub trait CustomerAddress { async fn get_address_update( &self, - address_details: api_models::payments::AddressDetails, + address_details: payments::AddressDetails, key: &[u8], storage_scheme: storage::enums::MerchantStorageScheme, ) -> CustomResult; async fn get_domain_address( &self, - address_details: api_models::payments::AddressDetails, + address_details: payments::AddressDetails, merchant_id: &str, customer_id: &str, key: &[u8], @@ -584,7 +584,7 @@ pub trait CustomerAddress { impl CustomerAddress for api_models::customers::CustomerRequest { async fn get_address_update( &self, - address_details: api_models::payments::AddressDetails, + address_details: payments::AddressDetails, key: &[u8], storage_scheme: storage::enums::MerchantStorageScheme, ) -> CustomResult { @@ -640,7 +640,7 @@ impl CustomerAddress for api_models::customers::CustomerRequest { async fn get_domain_address( &self, - address_details: api_models::payments::AddressDetails, + address_details: payments::AddressDetails, merchant_id: &str, customer_id: &str, key: &[u8], diff --git a/crates/router/src/utils/currency.rs b/crates/router/src/utils/currency.rs index 912f8fce94..5cf68635c4 100644 --- a/crates/router/src/utils/currency.rs +++ b/crates/router/src/utils/currency.rs @@ -525,10 +525,10 @@ pub async fn convert_currency( .await .change_context(ForexCacheError::ApiError)?; - let to_currency = api_models::enums::Currency::from_str(to_currency.as_str()) + let to_currency = enums::Currency::from_str(to_currency.as_str()) .change_context(ForexCacheError::CurrencyNotAcceptable)?; - let from_currency = api_models::enums::Currency::from_str(from_currency.as_str()) + let from_currency = enums::Currency::from_str(from_currency.as_str()) .change_context(ForexCacheError::CurrencyNotAcceptable)?; let converted_amount = diff --git a/crates/router/src/utils/user.rs b/crates/router/src/utils/user.rs index bde0fb72bd..33e9aa6769 100644 --- a/crates/router/src/utils/user.rs +++ b/crates/router/src/utils/user.rs @@ -11,7 +11,7 @@ use crate::{ routes::AppState, services::{ authentication::{AuthToken, UserFromToken}, - authorization::roles::{self, RoleInfo}, + authorization::roles::RoleInfo, }, types::domain::{self, MerchantAccount, UserFromStorage}, }; @@ -64,7 +64,7 @@ impl UserFromToken { } pub async fn get_role_info_from_db(&self, state: &AppState) -> UserResult { - roles::RoleInfo::from_role_id(state, &self.role_id, &self.merchant_id, &self.org_id) + RoleInfo::from_role_id(state, &self.role_id, &self.merchant_id, &self.org_id) .await .change_context(UserErrors::InternalServerError) } diff --git a/crates/router/tests/connectors/aci.rs b/crates/router/tests/connectors/aci.rs index 710d90a4ea..2e5e8748f4 100644 --- a/crates/router/tests/connectors/aci.rs +++ b/crates/router/tests/connectors/aci.rs @@ -46,7 +46,7 @@ fn construct_payment_router_data() -> types::PaymentsAuthorizeRouterData { card_type: None, card_issuing_country: None, bank_code: None, - nick_name: Some(masking::Secret::new("nick_name".into())), + nick_name: Some(Secret::new("nick_name".into())), }), confirm: true, statement_descriptor_suffix: None, @@ -263,7 +263,7 @@ async fn payments_create_failure() { card_type: None, card_issuing_country: None, bank_code: None, - nick_name: Some(masking::Secret::new("nick_name".into())), + nick_name: Some(Secret::new("nick_name".into())), }); let response = services::api::execute_connector_processing_step( diff --git a/crates/router/tests/connectors/adyen.rs b/crates/router/tests/connectors/adyen.rs index 468834ca49..d19fff2900 100644 --- a/crates/router/tests/connectors/adyen.rs +++ b/crates/router/tests/connectors/adyen.rs @@ -151,7 +151,7 @@ impl AdyenTest { card_type: None, card_issuing_country: None, bank_code: None, - nick_name: Some(masking::Secret::new("nick_name".into())), + nick_name: Some(Secret::new("nick_name".into())), }), confirm: true, statement_descriptor_suffix: None, diff --git a/crates/router/tests/connectors/airwallex.rs b/crates/router/tests/connectors/airwallex.rs index 95b07162ac..2ef61099ca 100644 --- a/crates/router/tests/connectors/airwallex.rs +++ b/crates/router/tests/connectors/airwallex.rs @@ -70,7 +70,7 @@ fn get_default_payment_info() -> Option { } fn payment_method_details() -> Option { Some(types::PaymentsAuthorizeData { - payment_method_data: types::domain::PaymentMethodData::Card(domain::Card { + payment_method_data: domain::PaymentMethodData::Card(domain::Card { card_number: cards::CardNumber::from_str("4035501000000008").unwrap(), card_exp_month: Secret::new("02".to_string()), card_exp_year: Secret::new("2035".to_string()), @@ -80,7 +80,7 @@ fn payment_method_details() -> Option { card_type: None, card_issuing_country: None, bank_code: None, - nick_name: Some(masking::Secret::new("nick_name".into())), + nick_name: Some(Secret::new("nick_name".into())), }), capture_method: Some(diesel_models::enums::CaptureMethod::Manual), router_return_url: Some("https://google.com".to_string()), @@ -143,7 +143,7 @@ async fn should_sync_authorized_payment() { .psync_retry_till_status_matches( enums::AttemptStatus::Authorized, Some(types::PaymentsSyncData { - connector_transaction_id: router::types::ResponseId::ConnectorTransactionId( + connector_transaction_id: types::ResponseId::ConnectorTransactionId( txn_id.unwrap(), ), ..Default::default() @@ -272,7 +272,7 @@ async fn should_sync_auto_captured_payment() { .psync_retry_till_status_matches( enums::AttemptStatus::Charged, Some(types::PaymentsSyncData { - connector_transaction_id: router::types::ResponseId::ConnectorTransactionId( + connector_transaction_id: types::ResponseId::ConnectorTransactionId( txn_id.unwrap(), ), ..Default::default() @@ -370,7 +370,7 @@ async fn should_fail_payment_for_incorrect_card_number() { let response = CONNECTOR .make_payment( Some(types::PaymentsAuthorizeData { - payment_method_data: types::domain::PaymentMethodData::Card(domain::Card { + payment_method_data: domain::PaymentMethodData::Card(domain::Card { card_number: cards::CardNumber::from_str("1234567891011").unwrap(), ..utils::CCardType::default().0 }), @@ -393,7 +393,7 @@ async fn should_fail_payment_for_incorrect_cvc() { let response = CONNECTOR .make_payment( Some(types::PaymentsAuthorizeData { - payment_method_data: types::domain::PaymentMethodData::Card(domain::Card { + payment_method_data: domain::PaymentMethodData::Card(domain::Card { card_cvc: Secret::new("12345".to_string()), ..utils::CCardType::default().0 }), @@ -416,7 +416,7 @@ async fn should_fail_payment_for_invalid_exp_month() { let response = CONNECTOR .make_payment( Some(types::PaymentsAuthorizeData { - payment_method_data: types::domain::PaymentMethodData::Card(domain::Card { + payment_method_data: domain::PaymentMethodData::Card(domain::Card { card_exp_month: Secret::new("20".to_string()), ..utils::CCardType::default().0 }), @@ -439,7 +439,7 @@ async fn should_fail_payment_for_incorrect_expiry_year() { let response = CONNECTOR .make_payment( Some(types::PaymentsAuthorizeData { - payment_method_data: types::domain::PaymentMethodData::Card(domain::Card { + payment_method_data: domain::PaymentMethodData::Card(domain::Card { card_exp_year: Secret::new("2000".to_string()), ..utils::CCardType::default().0 }), diff --git a/crates/router/tests/connectors/authorizedotnet.rs b/crates/router/tests/connectors/authorizedotnet.rs index 2b9a79b0b7..4c724f368d 100644 --- a/crates/router/tests/connectors/authorizedotnet.rs +++ b/crates/router/tests/connectors/authorizedotnet.rs @@ -55,9 +55,7 @@ async fn should_only_authorize_payment() { .authorize_payment( Some(types::PaymentsAuthorizeData { amount: 300, - payment_method_data: types::domain::PaymentMethodData::Card( - get_payment_method_data(), - ), + payment_method_data: domain::PaymentMethodData::Card(get_payment_method_data()), capture_method: Some(diesel_models::enums::CaptureMethod::Manual), ..utils::PaymentAuthorizeType::default().0 }), @@ -72,7 +70,7 @@ async fn should_only_authorize_payment() { .psync_retry_till_status_matches( enums::AttemptStatus::Authorized, Some(types::PaymentsSyncData { - connector_transaction_id: router::types::ResponseId::ConnectorTransactionId(txn_id), + connector_transaction_id: types::ResponseId::ConnectorTransactionId(txn_id), encoded_data: None, capture_method: None, ..Default::default() @@ -92,9 +90,7 @@ async fn should_capture_authorized_payment() { .authorize_payment( Some(types::PaymentsAuthorizeData { amount: 301, - payment_method_data: types::domain::PaymentMethodData::Card( - get_payment_method_data(), - ), + payment_method_data: domain::PaymentMethodData::Card(get_payment_method_data()), capture_method: Some(diesel_models::enums::CaptureMethod::Manual), ..utils::PaymentAuthorizeType::default().0 }), @@ -109,9 +105,7 @@ async fn should_capture_authorized_payment() { .psync_retry_till_status_matches( enums::AttemptStatus::Authorized, Some(types::PaymentsSyncData { - connector_transaction_id: router::types::ResponseId::ConnectorTransactionId( - txn_id.clone(), - ), + connector_transaction_id: types::ResponseId::ConnectorTransactionId(txn_id.clone()), encoded_data: None, capture_method: None, ..Default::default() @@ -137,7 +131,7 @@ async fn should_capture_authorized_payment() { .psync_retry_till_status_matches( enums::AttemptStatus::CaptureInitiated, Some(types::PaymentsSyncData { - connector_transaction_id: router::types::ResponseId::ConnectorTransactionId(txn_id), + connector_transaction_id: types::ResponseId::ConnectorTransactionId(txn_id), encoded_data: None, capture_method: None, ..Default::default() @@ -156,9 +150,7 @@ async fn should_partially_capture_authorized_payment() { .authorize_payment( Some(types::PaymentsAuthorizeData { amount: 302, - payment_method_data: types::domain::PaymentMethodData::Card( - get_payment_method_data(), - ), + payment_method_data: domain::PaymentMethodData::Card(get_payment_method_data()), capture_method: Some(diesel_models::enums::CaptureMethod::Manual), ..utils::PaymentAuthorizeType::default().0 }), @@ -173,9 +165,7 @@ async fn should_partially_capture_authorized_payment() { .psync_retry_till_status_matches( enums::AttemptStatus::Authorized, Some(types::PaymentsSyncData { - connector_transaction_id: router::types::ResponseId::ConnectorTransactionId( - txn_id.clone(), - ), + connector_transaction_id: types::ResponseId::ConnectorTransactionId(txn_id.clone()), encoded_data: None, capture_method: None, ..Default::default() @@ -201,7 +191,7 @@ async fn should_partially_capture_authorized_payment() { .psync_retry_till_status_matches( enums::AttemptStatus::CaptureInitiated, Some(types::PaymentsSyncData { - connector_transaction_id: router::types::ResponseId::ConnectorTransactionId(txn_id), + connector_transaction_id: types::ResponseId::ConnectorTransactionId(txn_id), encoded_data: None, capture_method: None, ..Default::default() @@ -220,9 +210,7 @@ async fn should_sync_authorized_payment() { .authorize_payment( Some(types::PaymentsAuthorizeData { amount: 303, - payment_method_data: types::domain::PaymentMethodData::Card( - get_payment_method_data(), - ), + payment_method_data: domain::PaymentMethodData::Card(get_payment_method_data()), capture_method: Some(diesel_models::enums::CaptureMethod::Manual), ..utils::PaymentAuthorizeType::default().0 }), @@ -237,7 +225,7 @@ async fn should_sync_authorized_payment() { .psync_retry_till_status_matches( enums::AttemptStatus::Authorized, Some(types::PaymentsSyncData { - connector_transaction_id: router::types::ResponseId::ConnectorTransactionId(txn_id), + connector_transaction_id: types::ResponseId::ConnectorTransactionId(txn_id), encoded_data: None, capture_method: None, ..Default::default() @@ -256,9 +244,7 @@ async fn should_void_authorized_payment() { .authorize_payment( Some(types::PaymentsAuthorizeData { amount: 304, - payment_method_data: types::domain::PaymentMethodData::Card( - get_payment_method_data(), - ), + payment_method_data: domain::PaymentMethodData::Card(get_payment_method_data()), capture_method: Some(diesel_models::enums::CaptureMethod::Manual), ..utils::PaymentAuthorizeType::default().0 }), @@ -273,9 +259,7 @@ async fn should_void_authorized_payment() { .psync_retry_till_status_matches( enums::AttemptStatus::Authorized, Some(types::PaymentsSyncData { - connector_transaction_id: router::types::ResponseId::ConnectorTransactionId( - txn_id.clone(), - ), + connector_transaction_id: types::ResponseId::ConnectorTransactionId(txn_id.clone()), encoded_data: None, capture_method: None, ..Default::default() @@ -307,9 +291,7 @@ async fn should_make_payment() { .make_payment( Some(types::PaymentsAuthorizeData { amount: 310, - payment_method_data: types::domain::PaymentMethodData::Card( - get_payment_method_data(), - ), + payment_method_data: domain::PaymentMethodData::Card(get_payment_method_data()), capture_method: Some(diesel_models::enums::CaptureMethod::Manual), ..utils::PaymentAuthorizeType::default().0 }), @@ -323,9 +305,7 @@ async fn should_make_payment() { .psync_retry_till_status_matches( enums::AttemptStatus::CaptureInitiated, Some(types::PaymentsSyncData { - connector_transaction_id: router::types::ResponseId::ConnectorTransactionId( - txn_id.clone(), - ), + connector_transaction_id: types::ResponseId::ConnectorTransactionId(txn_id.clone()), encoded_data: None, capture_method: None, ..Default::default() @@ -347,9 +327,7 @@ async fn should_sync_auto_captured_payment() { .make_payment( Some(types::PaymentsAuthorizeData { amount: 311, - payment_method_data: types::domain::PaymentMethodData::Card( - get_payment_method_data(), - ), + payment_method_data: domain::PaymentMethodData::Card(get_payment_method_data()), capture_method: Some(diesel_models::enums::CaptureMethod::Manual), ..utils::PaymentAuthorizeType::default().0 }), @@ -364,7 +342,7 @@ async fn should_sync_auto_captured_payment() { .psync_retry_till_status_matches( enums::AttemptStatus::Pending, Some(types::PaymentsSyncData { - connector_transaction_id: router::types::ResponseId::ConnectorTransactionId( + connector_transaction_id: types::ResponseId::ConnectorTransactionId( txn_id.unwrap(), ), encoded_data: None, @@ -402,7 +380,7 @@ async fn should_fail_payment_for_empty_card_number() { let response = CONNECTOR .make_payment( Some(types::PaymentsAuthorizeData { - payment_method_data: types::domain::PaymentMethodData::Card(domain::Card { + payment_method_data: domain::PaymentMethodData::Card(domain::Card { card_number: cards::CardNumber::from_str("").unwrap(), ..utils::CCardType::default().0 }), @@ -425,7 +403,7 @@ async fn should_fail_payment_for_incorrect_cvc() { let response = CONNECTOR .make_payment( Some(types::PaymentsAuthorizeData { - payment_method_data: types::domain::PaymentMethodData::Card(domain::Card { + payment_method_data: domain::PaymentMethodData::Card(domain::Card { card_cvc: Secret::new("12345".to_string()), ..utils::CCardType::default().0 }), @@ -448,7 +426,7 @@ async fn should_fail_payment_for_invalid_exp_month() { let response = CONNECTOR .make_payment( Some(types::PaymentsAuthorizeData { - payment_method_data: types::domain::PaymentMethodData::Card(domain::Card { + payment_method_data: domain::PaymentMethodData::Card(domain::Card { card_exp_month: Secret::new("20".to_string()), ..utils::CCardType::default().0 }), @@ -470,7 +448,7 @@ async fn should_fail_payment_for_incorrect_expiry_year() { let response = CONNECTOR .make_payment( Some(types::PaymentsAuthorizeData { - payment_method_data: types::domain::PaymentMethodData::Card(domain::Card { + payment_method_data: domain::PaymentMethodData::Card(domain::Card { card_exp_year: Secret::new("2000".to_string()), ..utils::CCardType::default().0 }), @@ -493,9 +471,7 @@ async fn should_fail_void_payment_for_auto_capture() { .make_payment( Some(types::PaymentsAuthorizeData { amount: 307, - payment_method_data: types::domain::PaymentMethodData::Card( - get_payment_method_data(), - ), + payment_method_data: domain::PaymentMethodData::Card(get_payment_method_data()), capture_method: Some(diesel_models::enums::CaptureMethod::Manual), ..utils::PaymentAuthorizeType::default().0 }), diff --git a/crates/router/tests/connectors/bambora.rs b/crates/router/tests/connectors/bambora.rs index 5cd82d097a..3115c1143d 100644 --- a/crates/router/tests/connectors/bambora.rs +++ b/crates/router/tests/connectors/bambora.rs @@ -40,7 +40,7 @@ static CONNECTOR: BamboraTest = BamboraTest {}; fn get_default_payment_authorize_data() -> Option { Some(types::PaymentsAuthorizeData { - payment_method_data: types::domain::PaymentMethodData::Card(domain::Card { + 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()), @@ -101,7 +101,7 @@ async fn should_sync_authorized_payment() { enums::AttemptStatus::Authorized, Some(types::PaymentsSyncData { mandate_id: None, - connector_transaction_id: router::types::ResponseId::ConnectorTransactionId( + connector_transaction_id: types::ResponseId::ConnectorTransactionId( txn_id.unwrap(), ), encoded_data: None, @@ -217,7 +217,7 @@ async fn should_sync_auto_captured_payment() { enums::AttemptStatus::Charged, Some(types::PaymentsSyncData { mandate_id: None, - connector_transaction_id: router::types::ResponseId::ConnectorTransactionId( + connector_transaction_id: types::ResponseId::ConnectorTransactionId( txn_id.unwrap(), ), encoded_data: None, @@ -296,7 +296,7 @@ async fn should_fail_payment_for_incorrect_card_number() { let response = CONNECTOR .make_payment( Some(types::PaymentsAuthorizeData { - payment_method_data: types::domain::PaymentMethodData::Card(domain::Card { + payment_method_data: domain::PaymentMethodData::Card(domain::Card { card_number: cards::CardNumber::from_str("1234567891011").unwrap(), card_exp_year: Secret::new("25".to_string()), ..utils::CCardType::default().0 @@ -319,7 +319,7 @@ async fn should_fail_payment_for_incorrect_cvc() { let response = CONNECTOR .make_payment( Some(types::PaymentsAuthorizeData { - payment_method_data: types::domain::PaymentMethodData::Card(domain::Card { + payment_method_data: domain::PaymentMethodData::Card(domain::Card { card_exp_year: Secret::new("25".to_string()), card_cvc: Secret::new("12345".to_string()), ..utils::CCardType::default().0 @@ -342,7 +342,7 @@ async fn should_fail_payment_for_invalid_exp_month() { let response = CONNECTOR .make_payment( Some(types::PaymentsAuthorizeData { - payment_method_data: types::domain::PaymentMethodData::Card(domain::Card { + payment_method_data: domain::PaymentMethodData::Card(domain::Card { card_exp_month: Secret::new("20".to_string()), card_number: cards::CardNumber::from_str("4030000010001234").unwrap(), card_exp_year: Secret::new("25".to_string()), @@ -367,7 +367,7 @@ async fn should_fail_payment_for_incorrect_expiry_year() { let response = CONNECTOR .make_payment( Some(types::PaymentsAuthorizeData { - payment_method_data: types::domain::PaymentMethodData::Card(domain::Card { + payment_method_data: domain::PaymentMethodData::Card(domain::Card { card_exp_year: Secret::new("2000".to_string()), card_number: cards::CardNumber::from_str("4030000010001234").unwrap(), card_cvc: Secret::new("123".to_string()), diff --git a/crates/router/tests/connectors/bankofamerica.rs b/crates/router/tests/connectors/bankofamerica.rs index ca54e9c97b..77085216dd 100644 --- a/crates/router/tests/connectors/bankofamerica.rs +++ b/crates/router/tests/connectors/bankofamerica.rs @@ -93,7 +93,7 @@ async fn should_sync_authorized_payment() { .psync_retry_till_status_matches( enums::AttemptStatus::Authorized, Some(types::PaymentsSyncData { - connector_transaction_id: router::types::ResponseId::ConnectorTransactionId( + connector_transaction_id: types::ResponseId::ConnectorTransactionId( txn_id.unwrap(), ), ..Default::default() @@ -213,7 +213,7 @@ async fn should_sync_auto_captured_payment() { .psync_retry_till_status_matches( enums::AttemptStatus::Charged, Some(types::PaymentsSyncData { - connector_transaction_id: router::types::ResponseId::ConnectorTransactionId( + connector_transaction_id: types::ResponseId::ConnectorTransactionId( txn_id.unwrap(), ), capture_method: Some(enums::CaptureMethod::Automatic), @@ -303,7 +303,7 @@ async fn should_fail_payment_for_incorrect_cvc() { let response = CONNECTOR .make_payment( Some(types::PaymentsAuthorizeData { - payment_method_data: types::domain::PaymentMethodData::Card(domain::Card { + payment_method_data: domain::PaymentMethodData::Card(domain::Card { card_cvc: Secret::new("12345".to_string()), ..utils::CCardType::default().0 }), @@ -325,7 +325,7 @@ async fn should_fail_payment_for_invalid_exp_month() { let response = CONNECTOR .make_payment( Some(types::PaymentsAuthorizeData { - payment_method_data: types::domain::PaymentMethodData::Card(domain::Card { + payment_method_data: domain::PaymentMethodData::Card(domain::Card { card_exp_month: Secret::new("20".to_string()), ..utils::CCardType::default().0 }), @@ -347,7 +347,7 @@ async fn should_fail_payment_for_incorrect_expiry_year() { let response = CONNECTOR .make_payment( Some(types::PaymentsAuthorizeData { - payment_method_data: types::domain::PaymentMethodData::Card(domain::Card { + payment_method_data: domain::PaymentMethodData::Card(domain::Card { card_exp_year: Secret::new("2000".to_string()), ..utils::CCardType::default().0 }), diff --git a/crates/router/tests/connectors/billwerk.rs b/crates/router/tests/connectors/billwerk.rs index 6795aa4011..4c992ef3d9 100644 --- a/crates/router/tests/connectors/billwerk.rs +++ b/crates/router/tests/connectors/billwerk.rs @@ -93,7 +93,7 @@ async fn should_sync_authorized_payment() { .psync_retry_till_status_matches( enums::AttemptStatus::Authorized, Some(types::PaymentsSyncData { - connector_transaction_id: router::types::ResponseId::ConnectorTransactionId( + connector_transaction_id: types::ResponseId::ConnectorTransactionId( txn_id.unwrap(), ), ..Default::default() @@ -213,7 +213,7 @@ async fn should_sync_auto_captured_payment() { .psync_retry_till_status_matches( enums::AttemptStatus::Charged, Some(types::PaymentsSyncData { - connector_transaction_id: router::types::ResponseId::ConnectorTransactionId( + connector_transaction_id: types::ResponseId::ConnectorTransactionId( txn_id.unwrap(), ), capture_method: Some(enums::CaptureMethod::Automatic), diff --git a/crates/router/tests/connectors/bitpay.rs b/crates/router/tests/connectors/bitpay.rs index df82775d6c..85b388f2fd 100644 --- a/crates/router/tests/connectors/bitpay.rs +++ b/crates/router/tests/connectors/bitpay.rs @@ -10,12 +10,12 @@ use crate::{ struct BitpayTest; impl ConnectorActions for BitpayTest {} impl utils::Connector for BitpayTest { - fn get_data(&self) -> types::api::ConnectorData { + fn get_data(&self) -> api::ConnectorData { use router::connector::Bitpay; - types::api::ConnectorData { + api::ConnectorData { connector: Box::new(&Bitpay), connector_name: types::Connector::Bitpay, - get_token: types::api::GetToken::Connector, + get_token: api::GetToken::Connector, merchant_connector_id: None, } } @@ -67,7 +67,7 @@ fn payment_method_details() -> Option { Some(types::PaymentsAuthorizeData { amount: 1, currency: enums::Currency::USD, - payment_method_data: types::domain::PaymentMethodData::Crypto(domain::CryptoData { + payment_method_data: domain::PaymentMethodData::Crypto(domain::CryptoData { pay_currency: None, }), confirm: true, @@ -126,7 +126,7 @@ async fn should_sync_authorized_payment() { .psync_retry_till_status_matches( enums::AttemptStatus::Authorized, Some(types::PaymentsSyncData { - connector_transaction_id: router::types::ResponseId::ConnectorTransactionId( + connector_transaction_id: types::ResponseId::ConnectorTransactionId( "NPf27TDfyU5mhcTCw2oaq4".to_string(), ), ..Default::default() @@ -145,7 +145,7 @@ async fn should_sync_expired_payment() { .psync_retry_till_status_matches( enums::AttemptStatus::Authorized, Some(types::PaymentsSyncData { - connector_transaction_id: router::types::ResponseId::ConnectorTransactionId( + connector_transaction_id: types::ResponseId::ConnectorTransactionId( "bUsFf4RjQEahjbjGcETRS".to_string(), ), ..Default::default() diff --git a/crates/router/tests/connectors/bluesnap.rs b/crates/router/tests/connectors/bluesnap.rs index 2e02f25934..3a654eda83 100644 --- a/crates/router/tests/connectors/bluesnap.rs +++ b/crates/router/tests/connectors/bluesnap.rs @@ -121,7 +121,7 @@ async fn should_sync_authorized_payment() { .psync_retry_till_status_matches( enums::AttemptStatus::Authorized, Some(types::PaymentsSyncData { - connector_transaction_id: router::types::ResponseId::ConnectorTransactionId( + connector_transaction_id: types::ResponseId::ConnectorTransactionId( txn_id.unwrap(), ), ..Default::default() @@ -261,7 +261,7 @@ async fn should_sync_auto_captured_payment() { .psync_retry_till_status_matches( enums::AttemptStatus::Charged, Some(types::PaymentsSyncData { - connector_transaction_id: router::types::ResponseId::ConnectorTransactionId( + connector_transaction_id: types::ResponseId::ConnectorTransactionId( txn_id.unwrap(), ), ..Default::default() @@ -401,7 +401,7 @@ async fn should_fail_payment_for_incorrect_cvc() { .make_payment( Some(types::PaymentsAuthorizeData { email: Some(Email::from_str("test@gmail.com").unwrap()), - payment_method_data: types::domain::PaymentMethodData::Card(domain::Card { + payment_method_data: domain::PaymentMethodData::Card(domain::Card { card_cvc: Secret::new("12345".to_string()), ..utils::CCardType::default().0 }), @@ -426,7 +426,7 @@ async fn should_fail_payment_for_invalid_exp_month() { .make_payment( Some(types::PaymentsAuthorizeData { email: Some(Email::from_str("test@gmail.com").unwrap()), - payment_method_data: types::domain::PaymentMethodData::Card(domain::Card { + payment_method_data: domain::PaymentMethodData::Card(domain::Card { card_exp_month: Secret::new("20".to_string()), ..utils::CCardType::default().0 }), @@ -451,7 +451,7 @@ async fn should_fail_payment_for_incorrect_expiry_year() { .make_payment( Some(types::PaymentsAuthorizeData { email: Some(Email::from_str("test@gmail.com").unwrap()), - payment_method_data: types::domain::PaymentMethodData::Card(domain::Card { + payment_method_data: domain::PaymentMethodData::Card(domain::Card { card_exp_year: Secret::new("2000".to_string()), ..utils::CCardType::default().0 }), diff --git a/crates/router/tests/connectors/boku.rs b/crates/router/tests/connectors/boku.rs index 2f496562e1..f361a2365d 100644 --- a/crates/router/tests/connectors/boku.rs +++ b/crates/router/tests/connectors/boku.rs @@ -92,7 +92,7 @@ async fn should_sync_authorized_payment() { .psync_retry_till_status_matches( enums::AttemptStatus::Authorized, Some(types::PaymentsSyncData { - connector_transaction_id: router::types::ResponseId::ConnectorTransactionId( + connector_transaction_id: types::ResponseId::ConnectorTransactionId( txn_id.unwrap(), ), ..Default::default() @@ -212,7 +212,7 @@ async fn should_sync_auto_captured_payment() { .psync_retry_till_status_matches( enums::AttemptStatus::Charged, Some(types::PaymentsSyncData { - connector_transaction_id: router::types::ResponseId::ConnectorTransactionId( + connector_transaction_id: types::ResponseId::ConnectorTransactionId( txn_id.unwrap(), ), capture_method: Some(enums::CaptureMethod::Automatic), @@ -302,7 +302,7 @@ async fn should_fail_payment_for_incorrect_cvc() { let response = CONNECTOR .make_payment( Some(types::PaymentsAuthorizeData { - payment_method_data: types::domain::PaymentMethodData::Card(domain::Card { + payment_method_data: domain::PaymentMethodData::Card(domain::Card { card_cvc: Secret::new("12345".to_string()), ..utils::CCardType::default().0 }), @@ -324,7 +324,7 @@ async fn should_fail_payment_for_invalid_exp_month() { let response = CONNECTOR .make_payment( Some(types::PaymentsAuthorizeData { - payment_method_data: types::domain::PaymentMethodData::Card(domain::Card { + payment_method_data: domain::PaymentMethodData::Card(domain::Card { card_exp_month: Secret::new("20".to_string()), ..utils::CCardType::default().0 }), @@ -346,7 +346,7 @@ async fn should_fail_payment_for_incorrect_expiry_year() { let response = CONNECTOR .make_payment( Some(types::PaymentsAuthorizeData { - payment_method_data: types::domain::PaymentMethodData::Card(domain::Card { + payment_method_data: domain::PaymentMethodData::Card(domain::Card { card_exp_year: Secret::new("2000".to_string()), ..utils::CCardType::default().0 }), diff --git a/crates/router/tests/connectors/cashtocode.rs b/crates/router/tests/connectors/cashtocode.rs index 616a080699..025d9cdac6 100644 --- a/crates/router/tests/connectors/cashtocode.rs +++ b/crates/router/tests/connectors/cashtocode.rs @@ -39,7 +39,7 @@ static CONNECTOR: CashtocodeTest = CashtocodeTest {}; impl CashtocodeTest { fn get_payment_authorize_data( payment_method_type: Option, - payment_method_data: types::domain::PaymentMethodData, + payment_method_data: domain::PaymentMethodData, ) -> Option { Some(types::PaymentsAuthorizeData { amount: 1000, diff --git a/crates/router/tests/connectors/checkout.rs b/crates/router/tests/connectors/checkout.rs index 85b55afc8e..886239878f 100644 --- a/crates/router/tests/connectors/checkout.rs +++ b/crates/router/tests/connectors/checkout.rs @@ -97,7 +97,7 @@ async fn should_sync_authorized_payment() { .psync_retry_till_status_matches( enums::AttemptStatus::Authorized, Some(types::PaymentsSyncData { - connector_transaction_id: router::types::ResponseId::ConnectorTransactionId( + connector_transaction_id: types::ResponseId::ConnectorTransactionId( txn_id.unwrap(), ), ..Default::default() @@ -223,7 +223,7 @@ async fn should_sync_auto_captured_payment() { .psync_retry_till_status_matches( enums::AttemptStatus::Charged, Some(types::PaymentsSyncData { - connector_transaction_id: router::types::ResponseId::ConnectorTransactionId( + connector_transaction_id: types::ResponseId::ConnectorTransactionId( txn_id.unwrap(), ), capture_method: Some(enums::CaptureMethod::Automatic), @@ -320,7 +320,7 @@ async fn should_fail_payment_for_incorrect_cvc() { let response = CONNECTOR .make_payment( Some(types::PaymentsAuthorizeData { - payment_method_data: types::domain::PaymentMethodData::Card(domain::Card { + payment_method_data: domain::PaymentMethodData::Card(domain::Card { card_cvc: Secret::new("12345".to_string()), ..utils::CCardType::default().0 }), @@ -343,7 +343,7 @@ async fn should_fail_payment_for_invalid_exp_month() { let response = CONNECTOR .make_payment( Some(types::PaymentsAuthorizeData { - payment_method_data: types::domain::PaymentMethodData::Card(domain::Card { + payment_method_data: domain::PaymentMethodData::Card(domain::Card { card_exp_month: Secret::new("20".to_string()), ..utils::CCardType::default().0 }), @@ -366,7 +366,7 @@ async fn should_fail_payment_for_incorrect_expiry_year() { let response = CONNECTOR .make_payment( Some(types::PaymentsAuthorizeData { - payment_method_data: types::domain::PaymentMethodData::Card(domain::Card { + payment_method_data: domain::PaymentMethodData::Card(domain::Card { card_exp_year: Secret::new("2000".to_string()), ..utils::CCardType::default().0 }), diff --git a/crates/router/tests/connectors/coinbase.rs b/crates/router/tests/connectors/coinbase.rs index 0136284c82..0bcb3c705a 100644 --- a/crates/router/tests/connectors/coinbase.rs +++ b/crates/router/tests/connectors/coinbase.rs @@ -11,12 +11,12 @@ use crate::{ struct CoinbaseTest; impl ConnectorActions for CoinbaseTest {} impl utils::Connector for CoinbaseTest { - fn get_data(&self) -> types::api::ConnectorData { + fn get_data(&self) -> api::ConnectorData { use router::connector::Coinbase; - types::api::ConnectorData { + api::ConnectorData { connector: Box::new(&Coinbase), connector_name: types::Connector::Coinbase, - get_token: types::api::GetToken::Connector, + get_token: api::GetToken::Connector, merchant_connector_id: None, } } @@ -69,7 +69,7 @@ fn payment_method_details() -> Option { Some(types::PaymentsAuthorizeData { amount: 1, currency: enums::Currency::USD, - payment_method_data: types::domain::PaymentMethodData::Crypto(domain::CryptoData { + payment_method_data: domain::PaymentMethodData::Crypto(domain::CryptoData { pay_currency: None, }), confirm: true, @@ -128,7 +128,7 @@ async fn should_sync_authorized_payment() { .psync_retry_till_status_matches( enums::AttemptStatus::Authorized, Some(types::PaymentsSyncData { - connector_transaction_id: router::types::ResponseId::ConnectorTransactionId( + connector_transaction_id: types::ResponseId::ConnectorTransactionId( "ADFY3789".to_string(), ), ..Default::default() @@ -147,7 +147,7 @@ async fn should_sync_unresolved_payment() { .psync_retry_till_status_matches( enums::AttemptStatus::Authorized, Some(types::PaymentsSyncData { - connector_transaction_id: router::types::ResponseId::ConnectorTransactionId( + connector_transaction_id: types::ResponseId::ConnectorTransactionId( "YJ6RFZXZ".to_string(), ), ..Default::default() @@ -166,7 +166,7 @@ async fn should_sync_expired_payment() { .psync_retry_till_status_matches( enums::AttemptStatus::Authorized, Some(types::PaymentsSyncData { - connector_transaction_id: router::types::ResponseId::ConnectorTransactionId( + connector_transaction_id: types::ResponseId::ConnectorTransactionId( "FZ89KDDB".to_string(), ), ..Default::default() @@ -185,7 +185,7 @@ async fn should_sync_cancelled_payment() { .psync_retry_till_status_matches( enums::AttemptStatus::Authorized, Some(types::PaymentsSyncData { - connector_transaction_id: router::types::ResponseId::ConnectorTransactionId( + connector_transaction_id: types::ResponseId::ConnectorTransactionId( "C35AAXKF".to_string(), ), ..Default::default() diff --git a/crates/router/tests/connectors/cryptopay.rs b/crates/router/tests/connectors/cryptopay.rs index 56c0e29f62..626c05fe11 100644 --- a/crates/router/tests/connectors/cryptopay.rs +++ b/crates/router/tests/connectors/cryptopay.rs @@ -10,12 +10,12 @@ use crate::{ struct CryptopayTest; impl ConnectorActions for CryptopayTest {} impl utils::Connector for CryptopayTest { - fn get_data(&self) -> types::api::ConnectorData { + fn get_data(&self) -> api::ConnectorData { use router::connector::Cryptopay; - types::api::ConnectorData { + api::ConnectorData { connector: Box::new(&Cryptopay), connector_name: types::Connector::Cryptopay, - get_token: types::api::GetToken::Connector, + get_token: api::GetToken::Connector, merchant_connector_id: None, } } @@ -68,7 +68,7 @@ fn payment_method_details() -> Option { Some(types::PaymentsAuthorizeData { amount: 1, currency: enums::Currency::USD, - payment_method_data: types::domain::PaymentMethodData::Crypto(domain::CryptoData { + payment_method_data: domain::PaymentMethodData::Crypto(domain::CryptoData { pay_currency: Some("XRP".to_string()), }), confirm: true, @@ -126,7 +126,7 @@ async fn should_sync_authorized_payment() { .psync_retry_till_status_matches( enums::AttemptStatus::Authorized, Some(types::PaymentsSyncData { - connector_transaction_id: router::types::ResponseId::ConnectorTransactionId( + connector_transaction_id: types::ResponseId::ConnectorTransactionId( "ea684036-2b54-44fa-bffe-8256650dce7c".to_string(), ), ..Default::default() @@ -145,7 +145,7 @@ async fn should_sync_unresolved_payment() { .psync_retry_till_status_matches( enums::AttemptStatus::Authorized, Some(types::PaymentsSyncData { - connector_transaction_id: router::types::ResponseId::ConnectorTransactionId( + connector_transaction_id: types::ResponseId::ConnectorTransactionId( "7993d4c2-efbc-4360-b8ce-d1e957e6f827".to_string(), ), ..Default::default() diff --git a/crates/router/tests/connectors/cybersource.rs b/crates/router/tests/connectors/cybersource.rs index 98ec44abd8..700e9a2d94 100644 --- a/crates/router/tests/connectors/cybersource.rs +++ b/crates/router/tests/connectors/cybersource.rs @@ -2,10 +2,7 @@ use std::str::FromStr; use common_utils::pii::Email; use masking::Secret; -use router::types::{ - self, api, domain, - storage::{self, enums}, -}; +use router::types::{self, api, domain, storage::enums}; use crate::{ connector_auth, @@ -14,12 +11,12 @@ use crate::{ struct Cybersource; impl ConnectorActions for Cybersource {} impl utils::Connector for Cybersource { - fn get_data(&self) -> types::api::ConnectorData { + fn get_data(&self) -> api::ConnectorData { use router::connector::Cybersource; - types::api::ConnectorData { + api::ConnectorData { connector: Box::new(&Cybersource), connector_name: types::Connector::Cybersource, - get_token: types::api::GetToken::Connector, + get_token: api::GetToken::Connector, merchant_connector_id: None, } } @@ -64,7 +61,7 @@ fn get_default_payment_info() -> Option { } fn get_default_payment_authorize_data() -> Option { Some(types::PaymentsAuthorizeData { - currency: storage::enums::Currency::USD, + currency: enums::Currency::USD, email: Some(Email::from_str("abc@gmail.com").unwrap()), ..PaymentAuthorizeType::default().0 }) @@ -127,7 +124,7 @@ async fn should_sync_payment() { .psync_retry_till_status_matches( enums::AttemptStatus::Charged, Some(types::PaymentsSyncData { - connector_transaction_id: router::types::ResponseId::ConnectorTransactionId( + connector_transaction_id: types::ResponseId::ConnectorTransactionId( "6699597903496176903954".to_string(), ), ..Default::default() @@ -160,7 +157,7 @@ async fn should_fail_payment_for_invalid_exp_month() { let response = Cybersource {} .make_payment( Some(types::PaymentsAuthorizeData { - payment_method_data: types::domain::PaymentMethodData::Card(domain::Card { + payment_method_data: domain::PaymentMethodData::Card(domain::Card { card_exp_month: Secret::new("13".to_string()), ..utils::CCardType::default().0 }), @@ -185,7 +182,7 @@ async fn should_fail_payment_for_invalid_exp_year() { let response = Cybersource {} .make_payment( Some(types::PaymentsAuthorizeData { - payment_method_data: types::domain::PaymentMethodData::Card(domain::Card { + payment_method_data: domain::PaymentMethodData::Card(domain::Card { card_exp_year: Secret::new("2022".to_string()), ..utils::CCardType::default().0 }), @@ -203,7 +200,7 @@ async fn should_fail_payment_for_invalid_card_cvc() { let response = Cybersource {} .make_payment( Some(types::PaymentsAuthorizeData { - payment_method_data: types::domain::PaymentMethodData::Card(domain::Card { + payment_method_data: domain::PaymentMethodData::Card(domain::Card { card_cvc: Secret::new("2131233213".to_string()), ..utils::CCardType::default().0 }), diff --git a/crates/router/tests/connectors/dlocal.rs b/crates/router/tests/connectors/dlocal.rs index edb24646bc..b715e20fec 100644 --- a/crates/router/tests/connectors/dlocal.rs +++ b/crates/router/tests/connectors/dlocal.rs @@ -13,12 +13,12 @@ use crate::{ struct DlocalTest; impl ConnectorActions for DlocalTest {} impl utils::Connector for DlocalTest { - fn get_data(&self) -> types::api::ConnectorData { + fn get_data(&self) -> api::ConnectorData { use router::connector::Dlocal; - types::api::ConnectorData { + api::ConnectorData { connector: Box::new(&Dlocal), connector_name: types::Connector::Dlocal, - get_token: types::api::GetToken::Connector, + get_token: api::GetToken::Connector, merchant_connector_id: None, } } @@ -89,7 +89,7 @@ async fn should_sync_authorized_payment() { .psync_retry_till_status_matches( enums::AttemptStatus::Authorized, Some(types::PaymentsSyncData { - connector_transaction_id: router::types::ResponseId::ConnectorTransactionId( + connector_transaction_id: types::ResponseId::ConnectorTransactionId( txn_id.unwrap(), ), ..Default::default() @@ -200,7 +200,7 @@ async fn should_sync_auto_captured_payment() { .psync_retry_till_status_matches( enums::AttemptStatus::Charged, Some(types::PaymentsSyncData { - connector_transaction_id: router::types::ResponseId::ConnectorTransactionId( + connector_transaction_id: types::ResponseId::ConnectorTransactionId( txn_id.unwrap(), ), ..Default::default() @@ -289,7 +289,7 @@ async fn should_fail_payment_for_incorrect_card_number() { let response = CONNECTOR .make_payment( Some(types::PaymentsAuthorizeData { - payment_method_data: types::domain::PaymentMethodData::Card(domain::Card { + payment_method_data: domain::PaymentMethodData::Card(domain::Card { card_number: cards::CardNumber::from_str("1891011").unwrap(), ..utils::CCardType::default().0 }), @@ -310,7 +310,7 @@ async fn should_fail_payment_for_incorrect_cvc() { let response = CONNECTOR .make_payment( Some(types::PaymentsAuthorizeData { - payment_method_data: types::domain::PaymentMethodData::Card(domain::Card { + payment_method_data: domain::PaymentMethodData::Card(domain::Card { card_cvc: Secret::new("1ad2345".to_string()), ..utils::CCardType::default().0 }), @@ -331,7 +331,7 @@ async fn should_fail_payment_for_invalid_exp_month() { let response = CONNECTOR .make_payment( Some(types::PaymentsAuthorizeData { - payment_method_data: types::domain::PaymentMethodData::Card(domain::Card { + payment_method_data: domain::PaymentMethodData::Card(domain::Card { card_exp_month: Secret::new("201".to_string()), ..utils::CCardType::default().0 }), @@ -352,7 +352,7 @@ async fn should_fail_payment_for_incorrect_expiry_year() { let response = CONNECTOR .make_payment( Some(types::PaymentsAuthorizeData { - payment_method_data: types::domain::PaymentMethodData::Card(domain::Card { + payment_method_data: domain::PaymentMethodData::Card(domain::Card { card_exp_year: Secret::new("20001".to_string()), ..utils::CCardType::default().0 }), diff --git a/crates/router/tests/connectors/dummyconnector.rs b/crates/router/tests/connectors/dummyconnector.rs index 76f72b6490..e357eda94c 100644 --- a/crates/router/tests/connectors/dummyconnector.rs +++ b/crates/router/tests/connectors/dummyconnector.rs @@ -95,7 +95,7 @@ async fn should_sync_authorized_payment() { .psync_retry_till_status_matches( enums::AttemptStatus::Authorized, Some(types::PaymentsSyncData { - connector_transaction_id: router::types::ResponseId::ConnectorTransactionId( + connector_transaction_id: types::ResponseId::ConnectorTransactionId( txn_id.unwrap(), ), ..Default::default() @@ -215,7 +215,7 @@ async fn should_sync_auto_captured_payment() { .psync_retry_till_status_matches( enums::AttemptStatus::Charged, Some(types::PaymentsSyncData { - connector_transaction_id: router::types::ResponseId::ConnectorTransactionId( + connector_transaction_id: types::ResponseId::ConnectorTransactionId( txn_id.unwrap(), ), capture_method: Some(enums::CaptureMethod::Automatic), @@ -305,7 +305,7 @@ async fn should_fail_payment_for_incorrect_card_number() { let response = CONNECTOR .make_payment( Some(types::PaymentsAuthorizeData { - payment_method_data: types::domain::PaymentMethodData::Card(domain::Card { + payment_method_data: domain::PaymentMethodData::Card(domain::Card { card_number: CardNumber::from_str("1234567891011").unwrap(), ..utils::CCardType::default().0 }), @@ -327,7 +327,7 @@ async fn should_fail_payment_for_incorrect_cvc() { let response = CONNECTOR .make_payment( Some(types::PaymentsAuthorizeData { - payment_method_data: types::domain::PaymentMethodData::Card(domain::Card { + payment_method_data: domain::PaymentMethodData::Card(domain::Card { card_cvc: Secret::new("12345".to_string()), ..utils::CCardType::default().0 }), @@ -349,7 +349,7 @@ async fn should_fail_payment_for_invalid_exp_month() { let response = CONNECTOR .make_payment( Some(types::PaymentsAuthorizeData { - payment_method_data: types::domain::PaymentMethodData::Card(domain::Card { + payment_method_data: domain::PaymentMethodData::Card(domain::Card { card_exp_month: Secret::new("20".to_string()), ..utils::CCardType::default().0 }), @@ -371,7 +371,7 @@ async fn should_fail_payment_for_incorrect_expiry_year() { let response = CONNECTOR .make_payment( Some(types::PaymentsAuthorizeData { - payment_method_data: types::domain::PaymentMethodData::Card(domain::Card { + payment_method_data: domain::PaymentMethodData::Card(domain::Card { card_exp_year: Secret::new("2000".to_string()), ..utils::CCardType::default().0 }), diff --git a/crates/router/tests/connectors/ebanx.rs b/crates/router/tests/connectors/ebanx.rs index 8571ed1e3f..6f02c80ebd 100644 --- a/crates/router/tests/connectors/ebanx.rs +++ b/crates/router/tests/connectors/ebanx.rs @@ -92,7 +92,7 @@ async fn should_sync_authorized_payment() { .psync_retry_till_status_matches( enums::AttemptStatus::Authorized, Some(types::PaymentsSyncData { - connector_transaction_id: router::types::ResponseId::ConnectorTransactionId( + connector_transaction_id: types::ResponseId::ConnectorTransactionId( txn_id.unwrap(), ), ..Default::default() @@ -212,7 +212,7 @@ async fn should_sync_auto_captured_payment() { .psync_retry_till_status_matches( enums::AttemptStatus::Charged, Some(types::PaymentsSyncData { - connector_transaction_id: router::types::ResponseId::ConnectorTransactionId( + connector_transaction_id: types::ResponseId::ConnectorTransactionId( txn_id.unwrap(), ), capture_method: Some(enums::CaptureMethod::Automatic), diff --git a/crates/router/tests/connectors/fiserv.rs b/crates/router/tests/connectors/fiserv.rs index 050d6a5406..f95c0d276e 100644 --- a/crates/router/tests/connectors/fiserv.rs +++ b/crates/router/tests/connectors/fiserv.rs @@ -42,7 +42,7 @@ impl utils::Connector for FiservTest { fn payment_method_details() -> Option { Some(types::PaymentsAuthorizeData { - payment_method_data: types::domain::PaymentMethodData::Card(domain::Card { + payment_method_data: domain::PaymentMethodData::Card(domain::Card { card_number: cards::CardNumber::from_str("4005550000000019").unwrap(), card_exp_month: Secret::new("02".to_string()), card_exp_year: Secret::new("2035".to_string()), @@ -52,7 +52,7 @@ fn payment_method_details() -> Option { card_type: None, card_issuing_country: None, bank_code: None, - nick_name: Some(masking::Secret::new("nick_name".into())), + nick_name: Some(Secret::new("nick_name".into())), }), capture_method: Some(diesel_models::enums::CaptureMethod::Manual), ..utils::PaymentAuthorizeType::default().0 @@ -123,7 +123,7 @@ async fn should_sync_authorized_payment() { .psync_retry_till_status_matches( enums::AttemptStatus::Authorized, Some(types::PaymentsSyncData { - connector_transaction_id: router::types::ResponseId::ConnectorTransactionId( + connector_transaction_id: types::ResponseId::ConnectorTransactionId( txn_id.unwrap(), ), ..Default::default() @@ -252,7 +252,7 @@ async fn should_sync_auto_captured_payment() { .psync_retry_till_status_matches( enums::AttemptStatus::Charged, Some(types::PaymentsSyncData { - connector_transaction_id: router::types::ResponseId::ConnectorTransactionId( + connector_transaction_id: types::ResponseId::ConnectorTransactionId( txn_id.unwrap(), ), ..Default::default() @@ -347,7 +347,7 @@ async fn should_fail_payment_for_incorrect_card_number() { let response = CONNECTOR .make_payment( Some(types::PaymentsAuthorizeData { - payment_method_data: types::domain::PaymentMethodData::Card(domain::Card { + payment_method_data: domain::PaymentMethodData::Card(domain::Card { card_number: cards::CardNumber::from_str("1234567891011").unwrap(), ..utils::CCardType::default().0 }), @@ -370,7 +370,7 @@ async fn should_fail_payment_for_incorrect_cvc() { let response = CONNECTOR .make_payment( Some(types::PaymentsAuthorizeData { - payment_method_data: types::domain::PaymentMethodData::Card(domain::Card { + payment_method_data: domain::PaymentMethodData::Card(domain::Card { card_cvc: Secret::new("12345".to_string()), ..utils::CCardType::default().0 }), @@ -393,7 +393,7 @@ async fn should_fail_payment_for_invalid_exp_month() { let response = CONNECTOR .make_payment( Some(types::PaymentsAuthorizeData { - payment_method_data: types::domain::PaymentMethodData::Card(domain::Card { + payment_method_data: domain::PaymentMethodData::Card(domain::Card { card_exp_month: Secret::new("20".to_string()), ..utils::CCardType::default().0 }), @@ -416,7 +416,7 @@ async fn should_fail_payment_for_incorrect_expiry_year() { let response = CONNECTOR .make_payment( Some(types::PaymentsAuthorizeData { - payment_method_data: types::domain::PaymentMethodData::Card(domain::Card { + payment_method_data: domain::PaymentMethodData::Card(domain::Card { card_exp_year: Secret::new("2000".to_string()), ..utils::CCardType::default().0 }), diff --git a/crates/router/tests/connectors/forte.rs b/crates/router/tests/connectors/forte.rs index c58cab38a2..1c99c2ff7b 100644 --- a/crates/router/tests/connectors/forte.rs +++ b/crates/router/tests/connectors/forte.rs @@ -13,12 +13,12 @@ use crate::{ struct ForteTest; impl ConnectorActions for ForteTest {} impl utils::Connector for ForteTest { - fn get_data(&self) -> types::api::ConnectorData { + fn get_data(&self) -> api::ConnectorData { use router::connector::Forte; - types::api::ConnectorData { + api::ConnectorData { connector: Box::new(&Forte), connector_name: types::Connector::Forte, - get_token: types::api::GetToken::Connector, + get_token: api::GetToken::Connector, merchant_connector_id: None, } } @@ -41,7 +41,7 @@ static CONNECTOR: ForteTest = ForteTest {}; fn get_payment_data() -> Option { Some(types::PaymentsAuthorizeData { - payment_method_data: types::domain::PaymentMethodData::Card(domain::Card { + payment_method_data: domain::PaymentMethodData::Card(domain::Card { card_number: CardNumber::from_str("4111111111111111").unwrap(), ..utils::CCardType::default().0 }), @@ -148,7 +148,7 @@ async fn should_sync_authorized_payment() { .psync_retry_till_status_matches( enums::AttemptStatus::Authorized, Some(types::PaymentsSyncData { - connector_transaction_id: router::types::ResponseId::ConnectorTransactionId( + connector_transaction_id: types::ResponseId::ConnectorTransactionId( txn_id.unwrap(), ), encoded_data: None, @@ -319,7 +319,7 @@ async fn should_sync_auto_captured_payment() { .psync_retry_till_status_matches( enums::AttemptStatus::Charged, Some(types::PaymentsSyncData { - connector_transaction_id: router::types::ResponseId::ConnectorTransactionId( + connector_transaction_id: types::ResponseId::ConnectorTransactionId( txn_id.unwrap(), ), encoded_data: None, @@ -467,7 +467,7 @@ async fn should_fail_payment_for_incorrect_cvc() { let response = CONNECTOR .make_payment( Some(types::PaymentsAuthorizeData { - payment_method_data: types::domain::PaymentMethodData::Card(domain::Card { + payment_method_data: domain::PaymentMethodData::Card(domain::Card { card_cvc: Secret::new("12345".to_string()), ..utils::CCardType::default().0 }), @@ -489,7 +489,7 @@ async fn should_fail_payment_for_invalid_exp_month() { let response = CONNECTOR .make_payment( Some(types::PaymentsAuthorizeData { - payment_method_data: types::domain::PaymentMethodData::Card(domain::Card { + payment_method_data: domain::PaymentMethodData::Card(domain::Card { card_exp_month: Secret::new("20".to_string()), ..utils::CCardType::default().0 }), @@ -512,7 +512,7 @@ async fn should_fail_payment_for_incorrect_expiry_year() { let response = CONNECTOR .make_payment( Some(types::PaymentsAuthorizeData { - payment_method_data: types::domain::PaymentMethodData::Card(domain::Card { + payment_method_data: domain::PaymentMethodData::Card(domain::Card { card_exp_year: Secret::new("2000".to_string()), ..utils::CCardType::default().0 }), @@ -630,7 +630,7 @@ async fn should_fail_for_refund_amount_higher_than_payment_amount() { #[actix_web::test] async fn should_throw_not_implemented_for_unsupported_issuer() { let authorize_data = Some(types::PaymentsAuthorizeData { - payment_method_data: types::domain::PaymentMethodData::Card(domain::Card { + payment_method_data: domain::PaymentMethodData::Card(domain::Card { card_number: CardNumber::from_str("6759649826438453").unwrap(), ..utils::CCardType::default().0 }), diff --git a/crates/router/tests/connectors/globalpay.rs b/crates/router/tests/connectors/globalpay.rs index e2ca19869f..8ca4d6f1ae 100644 --- a/crates/router/tests/connectors/globalpay.rs +++ b/crates/router/tests/connectors/globalpay.rs @@ -13,12 +13,12 @@ struct Globalpay; impl ConnectorActions for Globalpay {} static CONNECTOR: Globalpay = Globalpay {}; impl Connector for Globalpay { - fn get_data(&self) -> types::api::ConnectorData { + fn get_data(&self) -> api::ConnectorData { use router::connector::Globalpay; - types::api::ConnectorData { + api::ConnectorData { connector: Box::new(&Globalpay), connector_name: types::Connector::Globalpay, - get_token: types::api::GetToken::Connector, + get_token: api::GetToken::Connector, merchant_connector_id: None, } } @@ -42,7 +42,7 @@ impl Connector for Globalpay { } fn get_access_token() -> Option { - match utils::Connector::get_auth_token(&CONNECTOR) { + match Connector::get_auth_token(&CONNECTOR) { ConnectorAuthType::BodyKey { api_key, key1: _ } => Some(AccessToken { token: api_key, expires: 18600, @@ -120,7 +120,7 @@ async fn should_sync_auto_captured_payment() { .psync_retry_till_status_matches( enums::AttemptStatus::Authorized, Some(types::PaymentsSyncData { - connector_transaction_id: router::types::ResponseId::ConnectorTransactionId( + connector_transaction_id: types::ResponseId::ConnectorTransactionId( txn_id.unwrap(), ), ..Default::default() @@ -137,7 +137,7 @@ async fn should_fail_payment_for_incorrect_cvc() { let response = CONNECTOR .make_payment( Some(types::PaymentsAuthorizeData { - payment_method_data: types::domain::PaymentMethodData::Card(domain::Card { + payment_method_data: domain::PaymentMethodData::Card(domain::Card { card_number: cards::CardNumber::from_str("4024007134364842").unwrap(), ..utils::CCardType::default().0 }), @@ -345,7 +345,7 @@ async fn should_fail_payment_for_incorrect_expiry_year() { let response = CONNECTOR .make_payment( Some(types::PaymentsAuthorizeData { - payment_method_data: types::domain::PaymentMethodData::Card(domain::Card { + payment_method_data: domain::PaymentMethodData::Card(domain::Card { card_exp_year: Secret::new("2000".to_string()), ..utils::CCardType::default().0 }), @@ -367,7 +367,7 @@ async fn should_fail_payment_for_invalid_exp_month() { let response = CONNECTOR .make_payment( Some(types::PaymentsAuthorizeData { - payment_method_data: types::domain::PaymentMethodData::Card(domain::Card { + payment_method_data: domain::PaymentMethodData::Card(domain::Card { card_exp_month: Secret::new("20".to_string()), ..utils::CCardType::default().0 }), @@ -410,7 +410,7 @@ async fn should_sync_authorized_payment() { .psync_retry_till_status_matches( enums::AttemptStatus::Authorized, Some(types::PaymentsSyncData { - connector_transaction_id: router::types::ResponseId::ConnectorTransactionId( + connector_transaction_id: types::ResponseId::ConnectorTransactionId( txn_id.unwrap(), ), ..Default::default() diff --git a/crates/router/tests/connectors/globepay.rs b/crates/router/tests/connectors/globepay.rs index 7016797021..34a2ecb4c8 100644 --- a/crates/router/tests/connectors/globepay.rs +++ b/crates/router/tests/connectors/globepay.rs @@ -94,7 +94,7 @@ async fn should_sync_authorized_payment() { .psync_retry_till_status_matches( enums::AttemptStatus::Authorized, Some(types::PaymentsSyncData { - connector_transaction_id: router::types::ResponseId::ConnectorTransactionId( + connector_transaction_id: types::ResponseId::ConnectorTransactionId( txn_id.unwrap(), ), ..Default::default() @@ -214,7 +214,7 @@ async fn should_sync_auto_captured_payment() { .psync_retry_till_status_matches( enums::AttemptStatus::Charged, Some(types::PaymentsSyncData { - connector_transaction_id: router::types::ResponseId::ConnectorTransactionId( + connector_transaction_id: types::ResponseId::ConnectorTransactionId( txn_id.unwrap(), ), capture_method: Some(enums::CaptureMethod::Automatic), @@ -304,7 +304,7 @@ async fn should_fail_payment_for_incorrect_cvc() { let response = CONNECTOR .make_payment( Some(types::PaymentsAuthorizeData { - payment_method_data: types::domain::PaymentMethodData::Card(domain::Card { + payment_method_data: domain::PaymentMethodData::Card(domain::Card { card_cvc: Secret::new("12345".to_string()), ..utils::CCardType::default().0 }), @@ -326,7 +326,7 @@ async fn should_fail_payment_for_invalid_exp_month() { let response = CONNECTOR .make_payment( Some(types::PaymentsAuthorizeData { - payment_method_data: types::domain::PaymentMethodData::Card(domain::Card { + payment_method_data: domain::PaymentMethodData::Card(domain::Card { card_exp_month: Secret::new("20".to_string()), ..utils::CCardType::default().0 }), @@ -348,7 +348,7 @@ async fn should_fail_payment_for_incorrect_expiry_year() { let response = CONNECTOR .make_payment( Some(types::PaymentsAuthorizeData { - payment_method_data: types::domain::PaymentMethodData::Card(domain::Card { + payment_method_data: domain::PaymentMethodData::Card(domain::Card { card_exp_year: Secret::new("2000".to_string()), ..utils::CCardType::default().0 }), diff --git a/crates/router/tests/connectors/gocardless.rs b/crates/router/tests/connectors/gocardless.rs index 0564ea7da6..f7f2ed864b 100644 --- a/crates/router/tests/connectors/gocardless.rs +++ b/crates/router/tests/connectors/gocardless.rs @@ -92,7 +92,7 @@ async fn should_sync_authorized_payment() { .psync_retry_till_status_matches( enums::AttemptStatus::Authorized, Some(types::PaymentsSyncData { - connector_transaction_id: router::types::ResponseId::ConnectorTransactionId( + connector_transaction_id: types::ResponseId::ConnectorTransactionId( txn_id.unwrap(), ), ..Default::default() @@ -212,7 +212,7 @@ async fn should_sync_auto_captured_payment() { .psync_retry_till_status_matches( enums::AttemptStatus::Charged, Some(types::PaymentsSyncData { - connector_transaction_id: router::types::ResponseId::ConnectorTransactionId( + connector_transaction_id: types::ResponseId::ConnectorTransactionId( txn_id.unwrap(), ), capture_method: Some(enums::CaptureMethod::Automatic), @@ -302,7 +302,7 @@ async fn should_fail_payment_for_incorrect_cvc() { let response = CONNECTOR .make_payment( Some(types::PaymentsAuthorizeData { - payment_method_data: types::domain::PaymentMethodData::Card(domain::Card { + payment_method_data: domain::PaymentMethodData::Card(domain::Card { card_cvc: Secret::new("12345".to_string()), ..utils::CCardType::default().0 }), @@ -324,7 +324,7 @@ async fn should_fail_payment_for_invalid_exp_month() { let response = CONNECTOR .make_payment( Some(types::PaymentsAuthorizeData { - payment_method_data: types::domain::PaymentMethodData::Card(domain::Card { + payment_method_data: domain::PaymentMethodData::Card(domain::Card { card_exp_month: Secret::new("20".to_string()), ..utils::CCardType::default().0 }), @@ -346,7 +346,7 @@ async fn should_fail_payment_for_incorrect_expiry_year() { let response = CONNECTOR .make_payment( Some(types::PaymentsAuthorizeData { - payment_method_data: types::domain::PaymentMethodData::Card(domain::Card { + payment_method_data: domain::PaymentMethodData::Card(domain::Card { card_exp_year: Secret::new("2000".to_string()), ..utils::CCardType::default().0 }), diff --git a/crates/router/tests/connectors/helcim.rs b/crates/router/tests/connectors/helcim.rs index dc3bb4d47e..7bb4b9ab78 100644 --- a/crates/router/tests/connectors/helcim.rs +++ b/crates/router/tests/connectors/helcim.rs @@ -92,7 +92,7 @@ async fn should_sync_authorized_payment() { .psync_retry_till_status_matches( enums::AttemptStatus::Authorized, Some(types::PaymentsSyncData { - connector_transaction_id: router::types::ResponseId::ConnectorTransactionId( + connector_transaction_id: types::ResponseId::ConnectorTransactionId( txn_id.unwrap(), ), ..Default::default() @@ -212,7 +212,7 @@ async fn should_sync_auto_captured_payment() { .psync_retry_till_status_matches( enums::AttemptStatus::Charged, Some(types::PaymentsSyncData { - connector_transaction_id: router::types::ResponseId::ConnectorTransactionId( + connector_transaction_id: types::ResponseId::ConnectorTransactionId( txn_id.unwrap(), ), capture_method: Some(enums::CaptureMethod::Automatic), @@ -302,7 +302,7 @@ async fn should_fail_payment_for_incorrect_cvc() { let response = CONNECTOR .make_payment( Some(types::PaymentsAuthorizeData { - payment_method_data: types::domain::PaymentMethodData::Card(domain::Card { + payment_method_data: domain::PaymentMethodData::Card(domain::Card { card_cvc: Secret::new("12345".to_string()), ..utils::CCardType::default().0 }), @@ -324,7 +324,7 @@ async fn should_fail_payment_for_invalid_exp_month() { let response = CONNECTOR .make_payment( Some(types::PaymentsAuthorizeData { - payment_method_data: types::domain::PaymentMethodData::Card(domain::Card { + payment_method_data: domain::PaymentMethodData::Card(domain::Card { card_exp_month: Secret::new("20".to_string()), ..utils::CCardType::default().0 }), @@ -346,7 +346,7 @@ async fn should_fail_payment_for_incorrect_expiry_year() { let response = CONNECTOR .make_payment( Some(types::PaymentsAuthorizeData { - payment_method_data: types::domain::PaymentMethodData::Card(domain::Card { + payment_method_data: domain::PaymentMethodData::Card(domain::Card { card_exp_year: Secret::new("2000".to_string()), ..utils::CCardType::default().0 }), diff --git a/crates/router/tests/connectors/iatapay.rs b/crates/router/tests/connectors/iatapay.rs index d685756094..dfb8e097be 100644 --- a/crates/router/tests/connectors/iatapay.rs +++ b/crates/router/tests/connectors/iatapay.rs @@ -12,12 +12,12 @@ use crate::{ struct IatapayTest; impl ConnectorActions for IatapayTest {} impl Connector for IatapayTest { - fn get_data(&self) -> types::api::ConnectorData { + fn get_data(&self) -> api::ConnectorData { use router::connector::Iatapay; - types::api::ConnectorData { + api::ConnectorData { connector: Box::new(&Iatapay), connector_name: types::Connector::Iatapay, - get_token: types::api::GetToken::Connector, + get_token: api::GetToken::Connector, merchant_connector_id: None, } } @@ -155,7 +155,7 @@ async fn should_sync_payment() { .psync_retry_till_status_matches( enums::AttemptStatus::Charged, Some(types::PaymentsSyncData { - connector_transaction_id: router::types::ResponseId::ConnectorTransactionId( + connector_transaction_id: types::ResponseId::ConnectorTransactionId( "PE9OTYNP639XW".to_string(), ), ..Default::default() diff --git a/crates/router/tests/connectors/main.rs b/crates/router/tests/connectors/main.rs index eb1c00a227..78e67b7670 100644 --- a/crates/router/tests/connectors/main.rs +++ b/crates/router/tests/connectors/main.rs @@ -62,6 +62,7 @@ mod trustpay; mod tsys; mod utils; mod volt; +#[cfg(feature = "payouts")] mod wise; mod worldline; mod worldpay; diff --git a/crates/router/tests/connectors/mollie.rs b/crates/router/tests/connectors/mollie.rs index 14c77e2a9f..be0b5d1c1d 100644 --- a/crates/router/tests/connectors/mollie.rs +++ b/crates/router/tests/connectors/mollie.rs @@ -5,6 +5,7 @@ use crate::{ utils::{self, ConnectorActions}, }; +#[allow(dead_code)] #[derive(Clone, Copy)] struct MollieTest; impl ConnectorActions for MollieTest {} diff --git a/crates/router/tests/connectors/multisafepay.rs b/crates/router/tests/connectors/multisafepay.rs index f35fe05bf3..606b60b249 100644 --- a/crates/router/tests/connectors/multisafepay.rs +++ b/crates/router/tests/connectors/multisafepay.rs @@ -59,7 +59,7 @@ fn get_default_payment_info() -> Option { )); Some(PaymentInfo { address, - ..utils::PaymentInfo::default() + ..PaymentInfo::default() }) } @@ -121,7 +121,7 @@ async fn should_sync_authorized_payment() { .psync_retry_till_status_matches( enums::AttemptStatus::Authorized, Some(types::PaymentsSyncData { - connector_transaction_id: router::types::ResponseId::ConnectorTransactionId( + connector_transaction_id: types::ResponseId::ConnectorTransactionId( txn_id.unwrap(), ), ..Default::default() @@ -237,7 +237,7 @@ async fn should_sync_auto_captured_payment() { .psync_retry_till_status_matches( enums::AttemptStatus::Charged, Some(types::PaymentsSyncData { - connector_transaction_id: router::types::ResponseId::ConnectorTransactionId( + connector_transaction_id: types::ResponseId::ConnectorTransactionId( txn_id.unwrap(), ), ..Default::default() @@ -331,7 +331,7 @@ async fn should_fail_payment_for_incorrect_cvc() { let response = CONNECTOR .make_payment( Some(types::PaymentsAuthorizeData { - payment_method_data: types::domain::PaymentMethodData::Card(domain::Card { + payment_method_data: domain::PaymentMethodData::Card(domain::Card { card_cvc: Secret::new("123498765".to_string()), ..utils::CCardType::default().0 }), @@ -350,7 +350,7 @@ async fn should_fail_payment_for_invalid_exp_month() { let response = CONNECTOR .make_payment( Some(types::PaymentsAuthorizeData { - payment_method_data: types::domain::PaymentMethodData::Card(domain::Card { + payment_method_data: domain::PaymentMethodData::Card(domain::Card { card_exp_month: Secret::new("20".to_string()), ..utils::CCardType::default().0 }), @@ -369,7 +369,7 @@ async fn should_fail_payment_for_incorrect_expiry_year() { let response = CONNECTOR .make_payment( Some(types::PaymentsAuthorizeData { - payment_method_data: types::domain::PaymentMethodData::Card(domain::Card { + payment_method_data: domain::PaymentMethodData::Card(domain::Card { card_exp_year: Secret::new("2000".to_string()), ..utils::CCardType::default().0 }), diff --git a/crates/router/tests/connectors/netcetera.rs b/crates/router/tests/connectors/netcetera.rs index f06e2a0f5d..d7fceca9c5 100644 --- a/crates/router/tests/connectors/netcetera.rs +++ b/crates/router/tests/connectors/netcetera.rs @@ -91,7 +91,7 @@ async fn should_sync_authorized_payment() { .psync_retry_till_status_matches( enums::AttemptStatus::Authorized, Some(types::PaymentsSyncData { - connector_transaction_id: router::types::ResponseId::ConnectorTransactionId( + connector_transaction_id: types::ResponseId::ConnectorTransactionId( txn_id.unwrap(), ), ..Default::default() @@ -211,7 +211,7 @@ async fn should_sync_auto_captured_payment() { .psync_retry_till_status_matches( enums::AttemptStatus::Charged, Some(types::PaymentsSyncData { - connector_transaction_id: router::types::ResponseId::ConnectorTransactionId( + connector_transaction_id: types::ResponseId::ConnectorTransactionId( txn_id.unwrap(), ), capture_method: Some(enums::CaptureMethod::Automatic), diff --git a/crates/router/tests/connectors/nexinets.rs b/crates/router/tests/connectors/nexinets.rs index 5948855ae8..cdf94113c5 100644 --- a/crates/router/tests/connectors/nexinets.rs +++ b/crates/router/tests/connectors/nexinets.rs @@ -41,7 +41,7 @@ impl utils::Connector for NexinetsTest { fn payment_method_details() -> Option { Some(PaymentsAuthorizeData { currency: diesel_models::enums::Currency::EUR, - payment_method_data: types::domain::PaymentMethodData::Card(domain::Card { + payment_method_data: domain::PaymentMethodData::Card(domain::Card { card_number: CardNumber::from_str("374111111111111").unwrap(), ..utils::CCardType::default().0 }), @@ -118,7 +118,7 @@ async fn should_sync_authorized_payment() { .psync_retry_till_status_matches( enums::AttemptStatus::Authorized, Some(types::PaymentsSyncData { - connector_transaction_id: router::types::ResponseId::ConnectorTransactionId(txn_id), + connector_transaction_id: types::ResponseId::ConnectorTransactionId(txn_id), encoded_data: None, capture_method: None, sync_type: types::SyncRequestType::SinglePaymentSync, @@ -341,7 +341,7 @@ async fn should_sync_auto_captured_payment() { .psync_retry_till_status_matches( enums::AttemptStatus::Charged, Some(types::PaymentsSyncData { - connector_transaction_id: router::types::ResponseId::ConnectorTransactionId(txn_id), + connector_transaction_id: types::ResponseId::ConnectorTransactionId(txn_id), capture_method: Some(enums::CaptureMethod::Automatic), connector_meta, ..Default::default() @@ -506,7 +506,7 @@ async fn should_fail_payment_for_incorrect_cvc() { let response = CONNECTOR .make_payment( Some(PaymentsAuthorizeData { - payment_method_data: types::domain::PaymentMethodData::Card(domain::Card { + payment_method_data: domain::PaymentMethodData::Card(domain::Card { card_cvc: Secret::new("12345".to_string()), ..utils::CCardType::default().0 }), @@ -528,7 +528,7 @@ async fn should_fail_payment_for_invalid_exp_month() { let response = CONNECTOR .make_payment( Some(PaymentsAuthorizeData { - payment_method_data: types::domain::PaymentMethodData::Card(domain::Card { + payment_method_data: domain::PaymentMethodData::Card(domain::Card { card_exp_month: Secret::new("20".to_string()), ..utils::CCardType::default().0 }), @@ -550,7 +550,7 @@ async fn should_fail_payment_for_incorrect_expiry_year() { let response = CONNECTOR .make_payment( Some(PaymentsAuthorizeData { - payment_method_data: types::domain::PaymentMethodData::Card(domain::Card { + payment_method_data: domain::PaymentMethodData::Card(domain::Card { card_exp_year: Secret::new("2000".to_string()), ..utils::CCardType::default().0 }), diff --git a/crates/router/tests/connectors/nmi.rs b/crates/router/tests/connectors/nmi.rs index 5b569fa497..1d719e052a 100644 --- a/crates/router/tests/connectors/nmi.rs +++ b/crates/router/tests/connectors/nmi.rs @@ -38,7 +38,7 @@ static CONNECTOR: NmiTest = NmiTest {}; fn get_payment_authorize_data() -> Option { Some(types::PaymentsAuthorizeData { - payment_method_data: types::domain::PaymentMethodData::Card(domain::Card { + payment_method_data: domain::PaymentMethodData::Card(domain::Card { card_number: cards::CardNumber::from_str("4111111111111111").unwrap(), ..utils::CCardType::default().0 }), @@ -60,10 +60,10 @@ async fn should_only_authorize_payment() { .psync_retry_till_status_matches( enums::AttemptStatus::Authorized, Some(types::PaymentsSyncData { - connector_transaction_id: router::types::ResponseId::ConnectorTransactionId( + connector_transaction_id: types::ResponseId::ConnectorTransactionId( transaction_id.clone(), ), - capture_method: Some(types::storage::enums::CaptureMethod::Manual), + capture_method: Some(enums::CaptureMethod::Manual), ..Default::default() }), None, @@ -87,10 +87,10 @@ async fn should_capture_authorized_payment() { .psync_retry_till_status_matches( enums::AttemptStatus::Authorized, Some(types::PaymentsSyncData { - connector_transaction_id: router::types::ResponseId::ConnectorTransactionId( + connector_transaction_id: types::ResponseId::ConnectorTransactionId( transaction_id.clone(), ), - capture_method: Some(types::storage::enums::CaptureMethod::Manual), + capture_method: Some(enums::CaptureMethod::Manual), ..Default::default() }), None, @@ -110,10 +110,10 @@ async fn should_capture_authorized_payment() { .psync_retry_till_status_matches( enums::AttemptStatus::Pending, Some(types::PaymentsSyncData { - connector_transaction_id: router::types::ResponseId::ConnectorTransactionId( + connector_transaction_id: types::ResponseId::ConnectorTransactionId( transaction_id.clone(), ), - capture_method: Some(types::storage::enums::CaptureMethod::Manual), + capture_method: Some(enums::CaptureMethod::Manual), ..Default::default() }), None, @@ -136,10 +136,10 @@ async fn should_partially_capture_authorized_payment() { .psync_retry_till_status_matches( enums::AttemptStatus::Authorized, Some(types::PaymentsSyncData { - connector_transaction_id: router::types::ResponseId::ConnectorTransactionId( + connector_transaction_id: types::ResponseId::ConnectorTransactionId( transaction_id.clone(), ), - capture_method: Some(types::storage::enums::CaptureMethod::Manual), + capture_method: Some(enums::CaptureMethod::Manual), ..Default::default() }), None, @@ -167,10 +167,10 @@ async fn should_partially_capture_authorized_payment() { .psync_retry_till_status_matches( enums::AttemptStatus::Pending, Some(types::PaymentsSyncData { - connector_transaction_id: router::types::ResponseId::ConnectorTransactionId( + connector_transaction_id: types::ResponseId::ConnectorTransactionId( transaction_id.clone(), ), - capture_method: Some(types::storage::enums::CaptureMethod::Manual), + capture_method: Some(enums::CaptureMethod::Manual), ..Default::default() }), None, @@ -194,10 +194,10 @@ async fn should_void_authorized_payment() { .psync_retry_till_status_matches( enums::AttemptStatus::Authorized, Some(types::PaymentsSyncData { - connector_transaction_id: router::types::ResponseId::ConnectorTransactionId( + connector_transaction_id: types::ResponseId::ConnectorTransactionId( transaction_id.clone(), ), - capture_method: Some(types::storage::enums::CaptureMethod::Manual), + capture_method: Some(enums::CaptureMethod::Manual), ..Default::default() }), None, @@ -223,10 +223,10 @@ async fn should_void_authorized_payment() { .psync_retry_till_status_matches( enums::AttemptStatus::Voided, Some(types::PaymentsSyncData { - connector_transaction_id: router::types::ResponseId::ConnectorTransactionId( + connector_transaction_id: types::ResponseId::ConnectorTransactionId( transaction_id.clone(), ), - capture_method: Some(types::storage::enums::CaptureMethod::Manual), + capture_method: Some(enums::CaptureMethod::Manual), ..Default::default() }), None, @@ -250,10 +250,10 @@ async fn should_refund_manually_captured_payment() { .psync_retry_till_status_matches( enums::AttemptStatus::Authorized, Some(types::PaymentsSyncData { - connector_transaction_id: router::types::ResponseId::ConnectorTransactionId( + connector_transaction_id: types::ResponseId::ConnectorTransactionId( transaction_id.clone(), ), - capture_method: Some(types::storage::enums::CaptureMethod::Manual), + capture_method: Some(enums::CaptureMethod::Manual), ..Default::default() }), None, @@ -273,10 +273,10 @@ async fn should_refund_manually_captured_payment() { .psync_retry_till_status_matches( enums::AttemptStatus::Pending, Some(types::PaymentsSyncData { - connector_transaction_id: router::types::ResponseId::ConnectorTransactionId( + connector_transaction_id: types::ResponseId::ConnectorTransactionId( transaction_id.clone(), ), - capture_method: Some(types::storage::enums::CaptureMethod::Manual), + capture_method: Some(enums::CaptureMethod::Manual), ..Default::default() }), None, @@ -319,10 +319,10 @@ async fn should_partially_refund_manually_captured_payment() { .psync_retry_till_status_matches( enums::AttemptStatus::Authorized, Some(types::PaymentsSyncData { - connector_transaction_id: router::types::ResponseId::ConnectorTransactionId( + connector_transaction_id: types::ResponseId::ConnectorTransactionId( transaction_id.clone(), ), - capture_method: Some(types::storage::enums::CaptureMethod::Manual), + capture_method: Some(enums::CaptureMethod::Manual), ..Default::default() }), None, @@ -349,10 +349,10 @@ async fn should_partially_refund_manually_captured_payment() { .psync_retry_till_status_matches( enums::AttemptStatus::Pending, Some(types::PaymentsSyncData { - connector_transaction_id: router::types::ResponseId::ConnectorTransactionId( + connector_transaction_id: types::ResponseId::ConnectorTransactionId( transaction_id.clone(), ), - capture_method: Some(types::storage::enums::CaptureMethod::Manual), + capture_method: Some(enums::CaptureMethod::Manual), ..Default::default() }), None, @@ -402,10 +402,10 @@ async fn should_make_payment() { .psync_retry_till_status_matches( enums::AttemptStatus::Pending, Some(types::PaymentsSyncData { - connector_transaction_id: router::types::ResponseId::ConnectorTransactionId( + connector_transaction_id: types::ResponseId::ConnectorTransactionId( transaction_id.clone(), ), - capture_method: Some(types::storage::enums::CaptureMethod::Automatic), + capture_method: Some(enums::CaptureMethod::Automatic), ..Default::default() }), None, @@ -429,10 +429,10 @@ async fn should_refund_auto_captured_payment() { .psync_retry_till_status_matches( enums::AttemptStatus::Pending, Some(types::PaymentsSyncData { - connector_transaction_id: router::types::ResponseId::ConnectorTransactionId( + connector_transaction_id: types::ResponseId::ConnectorTransactionId( transaction_id.clone(), ), - capture_method: Some(types::storage::enums::CaptureMethod::Automatic), + capture_method: Some(enums::CaptureMethod::Automatic), ..Default::default() }), None, @@ -475,10 +475,10 @@ async fn should_partially_refund_succeeded_payment() { .psync_retry_till_status_matches( enums::AttemptStatus::Pending, Some(types::PaymentsSyncData { - connector_transaction_id: router::types::ResponseId::ConnectorTransactionId( + connector_transaction_id: types::ResponseId::ConnectorTransactionId( transaction_id.clone(), ), - capture_method: Some(types::storage::enums::CaptureMethod::Automatic), + capture_method: Some(enums::CaptureMethod::Automatic), ..Default::default() }), None, @@ -528,10 +528,10 @@ async fn should_refund_succeeded_payment_multiple_times() { .psync_retry_till_status_matches( enums::AttemptStatus::Pending, Some(types::PaymentsSyncData { - connector_transaction_id: router::types::ResponseId::ConnectorTransactionId( + connector_transaction_id: types::ResponseId::ConnectorTransactionId( transaction_id.clone(), ), - capture_method: Some(types::storage::enums::CaptureMethod::Automatic), + capture_method: Some(enums::CaptureMethod::Automatic), ..Default::default() }), None, @@ -600,10 +600,10 @@ async fn should_fail_void_payment_for_auto_capture() { .psync_retry_till_status_matches( enums::AttemptStatus::Pending, Some(types::PaymentsSyncData { - connector_transaction_id: router::types::ResponseId::ConnectorTransactionId( + connector_transaction_id: types::ResponseId::ConnectorTransactionId( transaction_id.clone(), ), - capture_method: Some(types::storage::enums::CaptureMethod::Automatic), + capture_method: Some(enums::CaptureMethod::Automatic), ..Default::default() }), None, @@ -633,10 +633,10 @@ async fn should_fail_capture_for_invalid_payment() { .psync_retry_till_status_matches( enums::AttemptStatus::Authorized, Some(types::PaymentsSyncData { - connector_transaction_id: router::types::ResponseId::ConnectorTransactionId( + connector_transaction_id: types::ResponseId::ConnectorTransactionId( transaction_id.clone(), ), - capture_method: Some(types::storage::enums::CaptureMethod::Manual), + capture_method: Some(enums::CaptureMethod::Manual), ..Default::default() }), None, @@ -665,10 +665,10 @@ async fn should_fail_for_refund_amount_higher_than_payment_amount() { .psync_retry_till_status_matches( enums::AttemptStatus::Pending, Some(types::PaymentsSyncData { - connector_transaction_id: router::types::ResponseId::ConnectorTransactionId( + connector_transaction_id: types::ResponseId::ConnectorTransactionId( transaction_id.clone(), ), - capture_method: Some(types::storage::enums::CaptureMethod::Automatic), + capture_method: Some(enums::CaptureMethod::Automatic), ..Default::default() }), None, diff --git a/crates/router/tests/connectors/noon.rs b/crates/router/tests/connectors/noon.rs index 7e0bb954c6..47e76d5ec7 100644 --- a/crates/router/tests/connectors/noon.rs +++ b/crates/router/tests/connectors/noon.rs @@ -1,10 +1,7 @@ use std::str::FromStr; use masking::Secret; -use router::types::{ - self, - storage::{self, enums}, -}; +use router::types::{self, storage::enums}; use crate::{ connector_auth, @@ -47,7 +44,7 @@ fn get_default_payment_info() -> Option { fn payment_method_details() -> Option { Some(types::PaymentsAuthorizeData { - currency: storage::enums::Currency::AED, + currency: enums::Currency::AED, ..utils::PaymentAuthorizeType::default().0 }) } @@ -102,7 +99,7 @@ async fn should_sync_authorized_payment() { .psync_retry_till_status_matches( enums::AttemptStatus::Authorized, Some(types::PaymentsSyncData { - connector_transaction_id: router::types::ResponseId::ConnectorTransactionId( + connector_transaction_id: types::ResponseId::ConnectorTransactionId( txn_id.unwrap(), ), ..Default::default() @@ -222,7 +219,7 @@ async fn should_sync_auto_captured_payment() { .psync_retry_till_status_matches( enums::AttemptStatus::Charged, Some(types::PaymentsSyncData { - connector_transaction_id: router::types::ResponseId::ConnectorTransactionId( + connector_transaction_id: types::ResponseId::ConnectorTransactionId( txn_id.unwrap(), ), capture_method: Some(enums::CaptureMethod::Automatic), diff --git a/crates/router/tests/connectors/nuvei.rs b/crates/router/tests/connectors/nuvei.rs index 04a83b3a60..55a8f23421 100644 --- a/crates/router/tests/connectors/nuvei.rs +++ b/crates/router/tests/connectors/nuvei.rs @@ -1,10 +1,7 @@ use std::str::FromStr; use masking::Secret; -use router::types::{ - self, - storage::{self, enums}, -}; +use router::types::{self, storage::enums}; use serde_json::json; use crate::{ @@ -102,7 +99,7 @@ async fn should_sync_authorized_payment() { .psync_retry_till_status_matches( enums::AttemptStatus::Authorized, Some(types::PaymentsSyncData { - connector_transaction_id: router::types::ResponseId::ConnectorTransactionId( + connector_transaction_id: types::ResponseId::ConnectorTransactionId( txn_id.unwrap(), ), connector_meta: Some(json!({ @@ -126,7 +123,7 @@ async fn should_void_authorized_payment() { Some(types::PaymentsCancelData { cancellation_reason: Some("requested_by_customer".to_string()), amount: Some(100), - currency: Some(storage::enums::Currency::USD), + currency: Some(enums::Currency::USD), ..Default::default() }), None, @@ -194,7 +191,7 @@ async fn should_sync_auto_captured_payment() { .psync_retry_till_status_matches( enums::AttemptStatus::Charged, Some(types::PaymentsSyncData { - connector_transaction_id: router::types::ResponseId::ConnectorTransactionId( + connector_transaction_id: types::ResponseId::ConnectorTransactionId( txn_id.unwrap(), ), connector_meta: Some(json!({ @@ -345,7 +342,7 @@ async fn should_fail_void_payment_for_auto_capture() { Some(types::PaymentsCancelData { cancellation_reason: Some("requested_by_customer".to_string()), amount: Some(100), - currency: Some(storage::enums::Currency::USD), + currency: Some(enums::Currency::USD), ..Default::default() }), None, diff --git a/crates/router/tests/connectors/opayo.rs b/crates/router/tests/connectors/opayo.rs index f4badf9b11..b383a2e1b0 100644 --- a/crates/router/tests/connectors/opayo.rs +++ b/crates/router/tests/connectors/opayo.rs @@ -97,7 +97,7 @@ async fn should_sync_authorized_payment() { .psync_retry_till_status_matches( enums::AttemptStatus::Authorized, Some(types::PaymentsSyncData { - connector_transaction_id: router::types::ResponseId::ConnectorTransactionId( + connector_transaction_id: types::ResponseId::ConnectorTransactionId( txn_id.unwrap(), ), ..Default::default() @@ -217,7 +217,7 @@ async fn should_sync_auto_captured_payment() { .psync_retry_till_status_matches( enums::AttemptStatus::Charged, Some(types::PaymentsSyncData { - connector_transaction_id: router::types::ResponseId::ConnectorTransactionId( + connector_transaction_id: types::ResponseId::ConnectorTransactionId( txn_id.unwrap(), ), capture_method: Some(enums::CaptureMethod::Automatic), @@ -307,7 +307,7 @@ async fn should_fail_payment_for_incorrect_card_number() { let response = CONNECTOR .make_payment( Some(types::PaymentsAuthorizeData { - payment_method_data: types::domain::PaymentMethodData::Card(domain::Card { + payment_method_data: domain::PaymentMethodData::Card(domain::Card { card_number: cards::CardNumber::from_str("1234567891011").unwrap(), ..utils::CCardType::default().0 }), @@ -329,7 +329,7 @@ async fn should_fail_payment_for_incorrect_cvc() { let response = CONNECTOR .make_payment( Some(types::PaymentsAuthorizeData { - payment_method_data: types::domain::PaymentMethodData::Card(domain::Card { + payment_method_data: domain::PaymentMethodData::Card(domain::Card { card_cvc: Secret::new("12345".to_string()), ..utils::CCardType::default().0 }), @@ -351,7 +351,7 @@ async fn should_fail_payment_for_invalid_exp_month() { let response = CONNECTOR .make_payment( Some(types::PaymentsAuthorizeData { - payment_method_data: types::domain::PaymentMethodData::Card(domain::Card { + payment_method_data: domain::PaymentMethodData::Card(domain::Card { card_exp_month: Secret::new("20".to_string()), ..utils::CCardType::default().0 }), @@ -373,7 +373,7 @@ async fn should_fail_payment_for_incorrect_expiry_year() { let response = CONNECTOR .make_payment( Some(types::PaymentsAuthorizeData { - payment_method_data: types::domain::PaymentMethodData::Card(domain::Card { + payment_method_data: domain::PaymentMethodData::Card(domain::Card { card_exp_year: Secret::new("2000".to_string()), ..utils::CCardType::default().0 }), diff --git a/crates/router/tests/connectors/opennode.rs b/crates/router/tests/connectors/opennode.rs index e4d347c26d..c91126953d 100644 --- a/crates/router/tests/connectors/opennode.rs +++ b/crates/router/tests/connectors/opennode.rs @@ -10,12 +10,12 @@ use crate::{ struct OpennodeTest; impl ConnectorActions for OpennodeTest {} impl utils::Connector for OpennodeTest { - fn get_data(&self) -> types::api::ConnectorData { + fn get_data(&self) -> api::ConnectorData { use router::connector::Opennode; - types::api::ConnectorData { + api::ConnectorData { connector: Box::new(&Opennode), connector_name: types::Connector::Opennode, - get_token: types::api::GetToken::Connector, + get_token: api::GetToken::Connector, merchant_connector_id: None, } } @@ -68,7 +68,7 @@ fn payment_method_details() -> Option { Some(types::PaymentsAuthorizeData { amount: 1, currency: enums::Currency::USD, - payment_method_data: types::domain::PaymentMethodData::Crypto(domain::CryptoData { + payment_method_data: domain::PaymentMethodData::Crypto(domain::CryptoData { pay_currency: None, }), confirm: true, @@ -127,7 +127,7 @@ async fn should_sync_authorized_payment() { .psync_retry_till_status_matches( enums::AttemptStatus::Authorized, Some(types::PaymentsSyncData { - connector_transaction_id: router::types::ResponseId::ConnectorTransactionId( + connector_transaction_id: types::ResponseId::ConnectorTransactionId( "5adebfb1-802e-432b-8b42-5db4b754b2eb".to_string(), ), ..Default::default() @@ -146,7 +146,7 @@ async fn should_sync_unresolved_payment() { .psync_retry_till_status_matches( enums::AttemptStatus::Authorized, Some(types::PaymentsSyncData { - connector_transaction_id: router::types::ResponseId::ConnectorTransactionId( + connector_transaction_id: types::ResponseId::ConnectorTransactionId( "4cf63e6b-5135-49cb-997f-6e0b30fecebc".to_string(), ), ..Default::default() @@ -165,7 +165,7 @@ async fn should_sync_expired_payment() { .psync_retry_till_status_matches( enums::AttemptStatus::Authorized, Some(types::PaymentsSyncData { - connector_transaction_id: router::types::ResponseId::ConnectorTransactionId( + connector_transaction_id: types::ResponseId::ConnectorTransactionId( "c36a097a-5091-4317-8749-80343a71c1c4".to_string(), ), ..Default::default() diff --git a/crates/router/tests/connectors/payme.rs b/crates/router/tests/connectors/payme.rs index a168200148..234f3a0eeb 100644 --- a/crates/router/tests/connectors/payme.rs +++ b/crates/router/tests/connectors/payme.rs @@ -91,7 +91,7 @@ fn payment_method_details() -> Option { router_return_url: Some("https://hyperswitch.io".to_string()), webhook_url: Some("https://hyperswitch.io".to_string()), email: Some(Email::from_str("test@gmail.com").unwrap()), - payment_method_data: types::domain::PaymentMethodData::Card(domain::Card { + payment_method_data: domain::PaymentMethodData::Card(domain::Card { card_number: cards::CardNumber::from_str("4111111111111111").unwrap(), card_cvc: Secret::new("123".to_string()), card_exp_month: Secret::new("10".to_string()), @@ -155,7 +155,7 @@ async fn should_sync_authorized_payment() { .psync_retry_till_status_matches( enums::AttemptStatus::Authorized, Some(types::PaymentsSyncData { - connector_transaction_id: router::types::ResponseId::ConnectorTransactionId( + connector_transaction_id: types::ResponseId::ConnectorTransactionId( txn_id.unwrap(), ), ..Default::default() @@ -280,7 +280,7 @@ async fn should_sync_auto_captured_payment() { .psync_retry_till_status_matches( enums::AttemptStatus::Charged, Some(types::PaymentsSyncData { - connector_transaction_id: router::types::ResponseId::ConnectorTransactionId( + connector_transaction_id: types::ResponseId::ConnectorTransactionId( txn_id.unwrap(), ), capture_method: Some(enums::CaptureMethod::Automatic), @@ -372,7 +372,7 @@ async fn should_fail_payment_for_incorrect_cvc() { Some(types::PaymentsAuthorizeData { amount: 100, currency: enums::Currency::ILS, - payment_method_data: types::domain::PaymentMethodData::Card(domain::Card { + payment_method_data: domain::PaymentMethodData::Card(domain::Card { card_cvc: Secret::new("12345".to_string()), ..utils::CCardType::default().0 }), @@ -391,7 +391,7 @@ async fn should_fail_payment_for_incorrect_cvc() { router_return_url: Some("https://hyperswitch.io".to_string()), webhook_url: Some("https://hyperswitch.io".to_string()), email: Some(Email::from_str("test@gmail.com").unwrap()), - ..utils::PaymentAuthorizeType::default().0 + ..PaymentAuthorizeType::default().0 }), get_default_payment_info(), ) @@ -411,7 +411,7 @@ async fn should_fail_payment_for_invalid_exp_month() { Some(types::PaymentsAuthorizeData { amount: 100, currency: enums::Currency::ILS, - payment_method_data: types::domain::PaymentMethodData::Card(domain::Card { + payment_method_data: domain::PaymentMethodData::Card(domain::Card { card_exp_month: Secret::new("20".to_string()), ..utils::CCardType::default().0 }), @@ -430,7 +430,7 @@ async fn should_fail_payment_for_invalid_exp_month() { router_return_url: Some("https://hyperswitch.io".to_string()), webhook_url: Some("https://hyperswitch.io".to_string()), email: Some(Email::from_str("test@gmail.com").unwrap()), - ..utils::PaymentAuthorizeType::default().0 + ..PaymentAuthorizeType::default().0 }), get_default_payment_info(), ) @@ -450,7 +450,7 @@ async fn should_fail_payment_for_incorrect_expiry_year() { Some(types::PaymentsAuthorizeData { amount: 100, currency: enums::Currency::ILS, - payment_method_data: types::domain::PaymentMethodData::Card(domain::Card { + payment_method_data: domain::PaymentMethodData::Card(domain::Card { card_exp_year: Secret::new("2012".to_string()), ..utils::CCardType::default().0 }), @@ -469,7 +469,7 @@ async fn should_fail_payment_for_incorrect_expiry_year() { router_return_url: Some("https://hyperswitch.io".to_string()), webhook_url: Some("https://hyperswitch.io".to_string()), email: Some(Email::from_str("test@gmail.com").unwrap()), - ..utils::PaymentAuthorizeType::default().0 + ..PaymentAuthorizeType::default().0 }), get_default_payment_info(), ) diff --git a/crates/router/tests/connectors/paypal.rs b/crates/router/tests/connectors/paypal.rs index bded135f45..704aeca593 100644 --- a/crates/router/tests/connectors/paypal.rs +++ b/crates/router/tests/connectors/paypal.rs @@ -56,7 +56,7 @@ fn get_default_payment_info() -> Option { fn get_payment_data() -> Option { Some(types::PaymentsAuthorizeData { - payment_method_data: types::domain::PaymentMethodData::Card(domain::Card { + payment_method_data: domain::PaymentMethodData::Card(domain::Card { card_number: cards::CardNumber::from_str("4000020000000000").unwrap(), ..utils::CCardType::default().0 }), @@ -136,7 +136,7 @@ async fn should_sync_authorized_payment() { enums::AttemptStatus::Authorized, Some(types::PaymentsSyncData { mandate_id: None, - connector_transaction_id: router::types::ResponseId::ConnectorTransactionId(txn_id), + connector_transaction_id: types::ResponseId::ConnectorTransactionId(txn_id), encoded_data: None, capture_method: None, sync_type: types::SyncRequestType::SinglePaymentSync, @@ -332,7 +332,7 @@ async fn should_sync_auto_captured_payment() { enums::AttemptStatus::Charged, Some(types::PaymentsSyncData { mandate_id: None, - connector_transaction_id: router::types::ResponseId::ConnectorTransactionId( + connector_transaction_id: types::ResponseId::ConnectorTransactionId( txn_id.unwrap(), ), encoded_data: None, @@ -450,7 +450,7 @@ async fn should_fail_payment_for_incorrect_cvc() { let response = CONNECTOR .make_payment( Some(types::PaymentsAuthorizeData { - payment_method_data: types::domain::PaymentMethodData::Card(domain::Card { + payment_method_data: domain::PaymentMethodData::Card(domain::Card { card_cvc: Secret::new("12345".to_string()), ..utils::CCardType::default().0 }), @@ -476,7 +476,7 @@ async fn should_fail_payment_for_invalid_exp_month() { let response = CONNECTOR .make_payment( Some(types::PaymentsAuthorizeData { - payment_method_data: types::domain::PaymentMethodData::Card(domain::Card { + payment_method_data: domain::PaymentMethodData::Card(domain::Card { card_exp_month: Secret::new("20".to_string()), ..utils::CCardType::default().0 }), @@ -502,7 +502,7 @@ async fn should_fail_payment_for_incorrect_expiry_year() { let response = CONNECTOR .make_payment( Some(types::PaymentsAuthorizeData { - payment_method_data: types::domain::PaymentMethodData::Card(domain::Card { + payment_method_data: domain::PaymentMethodData::Card(domain::Card { card_exp_year: Secret::new("2000".to_string()), ..utils::CCardType::default().0 }), diff --git a/crates/router/tests/connectors/payu.rs b/crates/router/tests/connectors/payu.rs index fc916e3367..2f6ebcefe6 100644 --- a/crates/router/tests/connectors/payu.rs +++ b/crates/router/tests/connectors/payu.rs @@ -70,7 +70,7 @@ async fn should_authorize_card_payment() { .psync_retry_till_status_matches( enums::AttemptStatus::Authorized, Some(types::PaymentsSyncData { - connector_transaction_id: router::types::ResponseId::ConnectorTransactionId( + connector_transaction_id: types::ResponseId::ConnectorTransactionId( transaction_id.clone(), ), ..Default::default() @@ -115,7 +115,7 @@ async fn should_authorize_gpay_payment() { let sync_response = Payu {} .sync_payment( Some(types::PaymentsSyncData { - connector_transaction_id: router::types::ResponseId::ConnectorTransactionId( + connector_transaction_id: types::ResponseId::ConnectorTransactionId( transaction_id.clone(), ), ..Default::default() @@ -148,7 +148,7 @@ async fn should_capture_already_authorized_payment() { .psync_retry_till_status_matches( enums::AttemptStatus::Authorized, Some(types::PaymentsSyncData { - connector_transaction_id: router::types::ResponseId::ConnectorTransactionId( + connector_transaction_id: types::ResponseId::ConnectorTransactionId( transaction_id.clone(), ), ..Default::default() @@ -167,7 +167,7 @@ async fn should_capture_already_authorized_payment() { .psync_retry_till_status_matches( enums::AttemptStatus::Charged, Some(types::PaymentsSyncData { - connector_transaction_id: router::types::ResponseId::ConnectorTransactionId( + connector_transaction_id: types::ResponseId::ConnectorTransactionId( transaction_id, ), ..Default::default() @@ -203,7 +203,7 @@ async fn should_sync_payment() { .psync_retry_till_status_matches( enums::AttemptStatus::Authorized, Some(types::PaymentsSyncData { - connector_transaction_id: router::types::ResponseId::ConnectorTransactionId( + connector_transaction_id: types::ResponseId::ConnectorTransactionId( transaction_id, ), ..Default::default() @@ -246,7 +246,7 @@ async fn should_void_already_authorized_payment() { .psync_retry_till_status_matches( enums::AttemptStatus::Voided, Some(types::PaymentsSyncData { - connector_transaction_id: router::types::ResponseId::ConnectorTransactionId( + connector_transaction_id: types::ResponseId::ConnectorTransactionId( transaction_id, ), ..Default::default() @@ -280,7 +280,7 @@ async fn should_refund_succeeded_payment() { .psync_retry_till_status_matches( enums::AttemptStatus::Authorized, Some(types::PaymentsSyncData { - connector_transaction_id: router::types::ResponseId::ConnectorTransactionId( + connector_transaction_id: types::ResponseId::ConnectorTransactionId( transaction_id.clone(), ), ..Default::default() @@ -301,7 +301,7 @@ async fn should_refund_succeeded_payment() { .psync_retry_till_status_matches( enums::AttemptStatus::Charged, Some(types::PaymentsSyncData { - connector_transaction_id: router::types::ResponseId::ConnectorTransactionId( + connector_transaction_id: types::ResponseId::ConnectorTransactionId( transaction_id.clone(), ), ..Default::default() diff --git a/crates/router/tests/connectors/placetopay.rs b/crates/router/tests/connectors/placetopay.rs index 41675b9751..d9b75cbe0e 100644 --- a/crates/router/tests/connectors/placetopay.rs +++ b/crates/router/tests/connectors/placetopay.rs @@ -92,7 +92,7 @@ async fn should_sync_authorized_payment() { .psync_retry_till_status_matches( enums::AttemptStatus::Authorized, Some(types::PaymentsSyncData { - connector_transaction_id: router::types::ResponseId::ConnectorTransactionId( + connector_transaction_id: types::ResponseId::ConnectorTransactionId( txn_id.unwrap(), ), ..Default::default() @@ -212,7 +212,7 @@ async fn should_sync_auto_captured_payment() { .psync_retry_till_status_matches( enums::AttemptStatus::Charged, Some(types::PaymentsSyncData { - connector_transaction_id: router::types::ResponseId::ConnectorTransactionId( + connector_transaction_id: types::ResponseId::ConnectorTransactionId( txn_id.unwrap(), ), capture_method: Some(enums::CaptureMethod::Automatic), @@ -302,7 +302,7 @@ async fn should_fail_payment_for_incorrect_cvc() { let response = CONNECTOR .make_payment( Some(types::PaymentsAuthorizeData { - payment_method_data: types::domain::PaymentMethodData::Card(domain::Card { + payment_method_data: domain::PaymentMethodData::Card(domain::Card { card_cvc: Secret::new("12345".to_string()), ..utils::CCardType::default().0 }), @@ -324,7 +324,7 @@ async fn should_fail_payment_for_invalid_exp_month() { let response = CONNECTOR .make_payment( Some(types::PaymentsAuthorizeData { - payment_method_data: types::domain::PaymentMethodData::Card(domain::Card { + payment_method_data: domain::PaymentMethodData::Card(domain::Card { card_exp_month: Secret::new("20".to_string()), ..utils::CCardType::default().0 }), @@ -346,7 +346,7 @@ async fn should_fail_payment_for_incorrect_expiry_year() { let response = CONNECTOR .make_payment( Some(types::PaymentsAuthorizeData { - payment_method_data: types::domain::PaymentMethodData::Card(domain::Card { + payment_method_data: domain::PaymentMethodData::Card(domain::Card { card_exp_year: Secret::new("2000".to_string()), ..utils::CCardType::default().0 }), diff --git a/crates/router/tests/connectors/powertranz.rs b/crates/router/tests/connectors/powertranz.rs index 0701ec006d..7f1e1937e0 100644 --- a/crates/router/tests/connectors/powertranz.rs +++ b/crates/router/tests/connectors/powertranz.rs @@ -96,7 +96,7 @@ async fn should_sync_authorized_payment() { .psync_retry_till_status_matches( enums::AttemptStatus::Authorized, Some(types::PaymentsSyncData { - connector_transaction_id: router::types::ResponseId::ConnectorTransactionId( + connector_transaction_id: types::ResponseId::ConnectorTransactionId( txn_id.unwrap(), ), ..Default::default() @@ -218,7 +218,7 @@ async fn should_sync_auto_captured_payment() { .psync_retry_till_status_matches( enums::AttemptStatus::Charged, Some(types::PaymentsSyncData { - connector_transaction_id: router::types::ResponseId::ConnectorTransactionId( + connector_transaction_id: types::ResponseId::ConnectorTransactionId( txn_id.unwrap(), ), capture_method: Some(enums::CaptureMethod::Automatic), @@ -310,7 +310,7 @@ async fn should_fail_payment_for_incorrect_cvc() { let response = CONNECTOR .make_payment( Some(types::PaymentsAuthorizeData { - payment_method_data: types::domain::PaymentMethodData::Card(domain::Card { + payment_method_data: domain::PaymentMethodData::Card(domain::Card { card_cvc: Secret::new("12345".to_string()), ..utils::CCardType::default().0 }), @@ -332,7 +332,7 @@ async fn should_fail_payment_for_invalid_exp_month() { let response = CONNECTOR .make_payment( Some(types::PaymentsAuthorizeData { - payment_method_data: types::domain::PaymentMethodData::Card(domain::Card { + payment_method_data: domain::PaymentMethodData::Card(domain::Card { card_exp_month: Secret::new("20".to_string()), ..utils::CCardType::default().0 }), @@ -354,7 +354,7 @@ async fn should_fail_payment_for_incorrect_expiry_year() { let response = CONNECTOR .make_payment( Some(types::PaymentsAuthorizeData { - payment_method_data: types::domain::PaymentMethodData::Card(domain::Card { + payment_method_data: domain::PaymentMethodData::Card(domain::Card { card_exp_year: Secret::new("2000".to_string()), ..utils::CCardType::default().0 }), diff --git a/crates/router/tests/connectors/prophetpay.rs b/crates/router/tests/connectors/prophetpay.rs index 9a0e2dbfa0..5e326c0bcd 100644 --- a/crates/router/tests/connectors/prophetpay.rs +++ b/crates/router/tests/connectors/prophetpay.rs @@ -92,7 +92,7 @@ async fn should_sync_authorized_payment() { .psync_retry_till_status_matches( enums::AttemptStatus::Authorized, Some(types::PaymentsSyncData { - connector_transaction_id: router::types::ResponseId::ConnectorTransactionId( + connector_transaction_id: types::ResponseId::ConnectorTransactionId( txn_id.unwrap(), ), ..Default::default() @@ -212,7 +212,7 @@ async fn should_sync_auto_captured_payment() { .psync_retry_till_status_matches( enums::AttemptStatus::Charged, Some(types::PaymentsSyncData { - connector_transaction_id: router::types::ResponseId::ConnectorTransactionId( + connector_transaction_id: types::ResponseId::ConnectorTransactionId( txn_id.unwrap(), ), capture_method: Some(enums::CaptureMethod::Automatic), @@ -302,7 +302,7 @@ async fn should_fail_payment_for_incorrect_cvc() { let response = CONNECTOR .make_payment( Some(types::PaymentsAuthorizeData { - payment_method_data: types::domain::PaymentMethodData::Card(domain::Card { + payment_method_data: domain::PaymentMethodData::Card(domain::Card { card_cvc: Secret::new("12345".to_string()), ..utils::CCardType::default().0 }), @@ -324,7 +324,7 @@ async fn should_fail_payment_for_invalid_exp_month() { let response = CONNECTOR .make_payment( Some(types::PaymentsAuthorizeData { - payment_method_data: types::domain::PaymentMethodData::Card(domain::Card { + payment_method_data: domain::PaymentMethodData::Card(domain::Card { card_exp_month: Secret::new("20".to_string()), ..utils::CCardType::default().0 }), @@ -346,7 +346,7 @@ async fn should_fail_payment_for_incorrect_expiry_year() { let response = CONNECTOR .make_payment( Some(types::PaymentsAuthorizeData { - payment_method_data: types::domain::PaymentMethodData::Card(domain::Card { + payment_method_data: domain::PaymentMethodData::Card(domain::Card { card_exp_year: Secret::new("2000".to_string()), ..utils::CCardType::default().0 }), diff --git a/crates/router/tests/connectors/rapyd.rs b/crates/router/tests/connectors/rapyd.rs index 61bc7ccdf1..4b5357c51e 100644 --- a/crates/router/tests/connectors/rapyd.rs +++ b/crates/router/tests/connectors/rapyd.rs @@ -42,7 +42,7 @@ async fn should_only_authorize_payment() { let response = Rapyd {} .authorize_payment( Some(types::PaymentsAuthorizeData { - payment_method_data: types::domain::PaymentMethodData::Card(domain::Card { + payment_method_data: domain::PaymentMethodData::Card(domain::Card { card_number: cards::CardNumber::from_str("4111111111111111").unwrap(), card_exp_month: Secret::new("02".to_string()), card_exp_year: Secret::new("2024".to_string()), @@ -52,7 +52,7 @@ async fn should_only_authorize_payment() { card_type: None, card_issuing_country: None, bank_code: None, - nick_name: Some(masking::Secret::new("nick_name".into())), + nick_name: Some(Secret::new("nick_name".into())), }), capture_method: Some(diesel_models::enums::CaptureMethod::Manual), ..utils::PaymentAuthorizeType::default().0 @@ -69,7 +69,7 @@ async fn should_authorize_and_capture_payment() { let response = Rapyd {} .make_payment( Some(types::PaymentsAuthorizeData { - payment_method_data: types::domain::PaymentMethodData::Card(domain::Card { + payment_method_data: domain::PaymentMethodData::Card(domain::Card { card_number: cards::CardNumber::from_str("4111111111111111").unwrap(), card_exp_month: Secret::new("02".to_string()), card_exp_year: Secret::new("2024".to_string()), @@ -79,7 +79,7 @@ async fn should_authorize_and_capture_payment() { card_type: None, card_issuing_country: None, bank_code: None, - nick_name: Some(masking::Secret::new("nick_name".into())), + nick_name: Some(Secret::new("nick_name".into())), }), ..utils::PaymentAuthorizeType::default().0 }), @@ -157,7 +157,7 @@ async fn should_fail_payment_for_incorrect_card_number() { let response = Rapyd {} .make_payment( Some(types::PaymentsAuthorizeData { - payment_method_data: types::domain::PaymentMethodData::Card(domain::Card { + payment_method_data: domain::PaymentMethodData::Card(domain::Card { card_number: cards::CardNumber::from_str("0000000000000000").unwrap(), ..utils::CCardType::default().0 }), diff --git a/crates/router/tests/connectors/shift4.rs b/crates/router/tests/connectors/shift4.rs index 8f11fbfa1d..632e538935 100644 --- a/crates/router/tests/connectors/shift4.rs +++ b/crates/router/tests/connectors/shift4.rs @@ -90,7 +90,7 @@ async fn should_sync_authorized_payment() { .psync_retry_till_status_matches( enums::AttemptStatus::Authorized, Some(types::PaymentsSyncData { - connector_transaction_id: router::types::ResponseId::ConnectorTransactionId( + connector_transaction_id: types::ResponseId::ConnectorTransactionId( txn_id.unwrap(), ), ..Default::default() @@ -114,7 +114,7 @@ async fn should_sync_auto_captured_payment() { .psync_retry_till_status_matches( enums::AttemptStatus::Charged, Some(types::PaymentsSyncData { - connector_transaction_id: router::types::ResponseId::ConnectorTransactionId( + connector_transaction_id: types::ResponseId::ConnectorTransactionId( txn_id.unwrap(), ), ..Default::default() @@ -151,7 +151,7 @@ async fn should_fail_payment_for_incorrect_card_number() { let response = CONNECTOR .make_payment( Some(types::PaymentsAuthorizeData { - payment_method_data: types::domain::PaymentMethodData::Card(domain::Card { + payment_method_data: domain::PaymentMethodData::Card(domain::Card { card_number: cards::CardNumber::from_str("4024007134364842").unwrap(), ..utils::CCardType::default().0 }), @@ -173,7 +173,7 @@ async fn should_succeed_payment_for_incorrect_cvc() { let response = CONNECTOR .make_payment( Some(types::PaymentsAuthorizeData { - payment_method_data: types::domain::PaymentMethodData::Card(domain::Card { + payment_method_data: domain::PaymentMethodData::Card(domain::Card { card_cvc: Secret::new("asdasd".to_string()), //shift4 accept invalid CVV as it doesn't accept CVV ..utils::CCardType::default().0 }), @@ -192,7 +192,7 @@ async fn should_fail_payment_for_invalid_exp_month() { let response = CONNECTOR .make_payment( Some(types::PaymentsAuthorizeData { - payment_method_data: types::domain::PaymentMethodData::Card(domain::Card { + payment_method_data: domain::PaymentMethodData::Card(domain::Card { card_exp_month: Secret::new("20".to_string()), ..utils::CCardType::default().0 }), @@ -214,7 +214,7 @@ async fn should_fail_payment_for_incorrect_expiry_year() { let response = CONNECTOR .make_payment( Some(types::PaymentsAuthorizeData { - payment_method_data: types::domain::PaymentMethodData::Card(domain::Card { + payment_method_data: domain::PaymentMethodData::Card(domain::Card { card_exp_year: Secret::new("2000".to_string()), ..utils::CCardType::default().0 }), diff --git a/crates/router/tests/connectors/square.rs b/crates/router/tests/connectors/square.rs index 01d90c73c4..2dcd93cc10 100644 --- a/crates/router/tests/connectors/square.rs +++ b/crates/router/tests/connectors/square.rs @@ -1,11 +1,7 @@ use std::{str::FromStr, time::Duration}; use masking::Secret; -use router::types::{ - self, - storage::{self, enums}, - PaymentsResponseData, -}; +use router::types::{self, storage::enums, PaymentsResponseData}; use test_utils::connector_auth::ConnectorAuthentication; use crate::utils::{self, get_connector_transaction_id, Connector, ConnectorActions}; @@ -71,7 +67,7 @@ fn token_details() -> Option { }), browser_info: None, amount: None, - currency: storage::enums::Currency::USD, + currency: enums::Currency::USD, }) } @@ -147,7 +143,7 @@ async fn should_sync_authorized_payment() { .psync_retry_till_status_matches( enums::AttemptStatus::Authorized, Some(types::PaymentsSyncData { - connector_transaction_id: router::types::ResponseId::ConnectorTransactionId( + connector_transaction_id: types::ResponseId::ConnectorTransactionId( txn_id.unwrap(), ), ..Default::default() @@ -291,7 +287,7 @@ async fn should_sync_auto_captured_payment() { .psync_retry_till_status_matches( enums::AttemptStatus::Charged, Some(types::PaymentsSyncData { - connector_transaction_id: router::types::ResponseId::ConnectorTransactionId( + connector_transaction_id: types::ResponseId::ConnectorTransactionId( txn_id.unwrap(), ), capture_method: Some(enums::CaptureMethod::Automatic), @@ -444,7 +440,7 @@ async fn should_fail_payment_for_incorrect_cvc() { }), browser_info: None, amount: None, - currency: storage::enums::Currency::USD, + currency: enums::Currency::USD, }), get_default_payment_info(None), ) @@ -475,7 +471,7 @@ async fn should_fail_payment_for_invalid_exp_month() { }), browser_info: None, amount: None, - currency: storage::enums::Currency::USD, + currency: enums::Currency::USD, }), get_default_payment_info(None), ) @@ -506,7 +502,7 @@ async fn should_fail_payment_for_incorrect_expiry_year() { }), browser_info: None, amount: None, - currency: storage::enums::Currency::USD, + currency: enums::Currency::USD, }), get_default_payment_info(None), ) diff --git a/crates/router/tests/connectors/stax.rs b/crates/router/tests/connectors/stax.rs index d16f209a49..421ad9524c 100644 --- a/crates/router/tests/connectors/stax.rs +++ b/crates/router/tests/connectors/stax.rs @@ -63,7 +63,7 @@ fn customer_details() -> Option { fn token_details() -> Option { Some(types::PaymentMethodTokenizationData { - payment_method_data: types::domain::PaymentMethodData::Card(domain::Card { + payment_method_data: domain::PaymentMethodData::Card(domain::Card { card_number: cards::CardNumber::from_str("4111111111111111").unwrap(), card_exp_month: Secret::new("04".to_string()), card_exp_year: Secret::new("2027".to_string()), @@ -167,7 +167,7 @@ async fn should_sync_authorized_payment() { .psync_retry_till_status_matches( enums::AttemptStatus::Authorized, Some(types::PaymentsSyncData { - connector_transaction_id: router::types::ResponseId::ConnectorTransactionId( + connector_transaction_id: types::ResponseId::ConnectorTransactionId( txn_id.unwrap(), ), ..Default::default() @@ -344,7 +344,7 @@ async fn should_sync_auto_captured_payment() { .psync_retry_till_status_matches( enums::AttemptStatus::Charged, Some(types::PaymentsSyncData { - connector_transaction_id: router::types::ResponseId::ConnectorTransactionId( + connector_transaction_id: types::ResponseId::ConnectorTransactionId( txn_id.unwrap(), ), capture_method: Some(enums::CaptureMethod::Automatic), @@ -473,7 +473,7 @@ async fn should_fail_payment_for_incorrect_cvc() { let token_response = CONNECTOR .create_connector_pm_token( Some(types::PaymentMethodTokenizationData { - payment_method_data: types::domain::PaymentMethodData::Card(domain::Card { + payment_method_data: domain::PaymentMethodData::Card(domain::Card { card_number: cards::CardNumber::from_str("4111111111111111").unwrap(), card_exp_month: Secret::new("11".to_string()), card_exp_year: Secret::new("2027".to_string()), @@ -511,7 +511,7 @@ async fn should_fail_payment_for_invalid_exp_month() { let token_response = CONNECTOR .create_connector_pm_token( Some(types::PaymentMethodTokenizationData { - payment_method_data: types::domain::PaymentMethodData::Card(domain::Card { + payment_method_data: domain::PaymentMethodData::Card(domain::Card { card_number: cards::CardNumber::from_str("4111111111111111").unwrap(), card_exp_month: Secret::new("20".to_string()), card_exp_year: Secret::new("2027".to_string()), @@ -549,7 +549,7 @@ async fn should_fail_payment_for_incorrect_expiry_year() { let token_response = CONNECTOR .create_connector_pm_token( Some(types::PaymentMethodTokenizationData { - payment_method_data: types::domain::PaymentMethodData::Card(domain::Card { + payment_method_data: domain::PaymentMethodData::Card(domain::Card { card_number: cards::CardNumber::from_str("4111111111111111").unwrap(), card_exp_month: Secret::new("04".to_string()), card_exp_year: Secret::new("2000".to_string()), diff --git a/crates/router/tests/connectors/stripe.rs b/crates/router/tests/connectors/stripe.rs index 3dcaeba45b..2d6b3e0cfd 100644 --- a/crates/router/tests/connectors/stripe.rs +++ b/crates/router/tests/connectors/stripe.rs @@ -37,7 +37,7 @@ impl utils::Connector for Stripe { fn get_payment_authorize_data() -> Option { Some(types::PaymentsAuthorizeData { - payment_method_data: types::domain::PaymentMethodData::Card(domain::Card { + payment_method_data: domain::PaymentMethodData::Card(domain::Card { card_number: cards::CardNumber::from_str("4242424242424242").unwrap(), ..utils::CCardType::default().0 }), @@ -100,7 +100,7 @@ async fn should_sync_authorized_payment() { .psync_retry_till_status_matches( enums::AttemptStatus::Authorized, Some(types::PaymentsSyncData { - connector_transaction_id: router::types::ResponseId::ConnectorTransactionId( + connector_transaction_id: types::ResponseId::ConnectorTransactionId( txn_id.unwrap(), ), ..Default::default() @@ -124,7 +124,7 @@ async fn should_sync_payment() { .psync_retry_till_status_matches( enums::AttemptStatus::Charged, Some(types::PaymentsSyncData { - connector_transaction_id: router::types::ResponseId::ConnectorTransactionId( + connector_transaction_id: types::ResponseId::ConnectorTransactionId( txn_id.unwrap(), ), ..Default::default() @@ -158,7 +158,7 @@ async fn should_fail_payment_for_incorrect_card_number() { let response = Stripe {} .make_payment( Some(types::PaymentsAuthorizeData { - payment_method_data: types::domain::PaymentMethodData::Card(domain::Card { + payment_method_data: domain::PaymentMethodData::Card(domain::Card { card_number: cards::CardNumber::from_str("4024007134364842").unwrap(), ..utils::CCardType::default().0 }), @@ -180,7 +180,7 @@ async fn should_fail_payment_for_invalid_exp_month() { let response = Stripe {} .make_payment( Some(types::PaymentsAuthorizeData { - payment_method_data: types::domain::PaymentMethodData::Card(domain::Card { + payment_method_data: domain::PaymentMethodData::Card(domain::Card { card_exp_month: Secret::new("13".to_string()), ..utils::CCardType::default().0 }), @@ -202,7 +202,7 @@ async fn should_fail_payment_for_invalid_exp_year() { let response = Stripe {} .make_payment( Some(types::PaymentsAuthorizeData { - payment_method_data: types::domain::PaymentMethodData::Card(domain::Card { + payment_method_data: domain::PaymentMethodData::Card(domain::Card { card_exp_year: Secret::new("2022".to_string()), ..utils::CCardType::default().0 }), @@ -221,7 +221,7 @@ async fn should_fail_payment_for_invalid_card_cvc() { let response = Stripe {} .make_payment( Some(types::PaymentsAuthorizeData { - payment_method_data: types::domain::PaymentMethodData::Card(domain::Card { + payment_method_data: domain::PaymentMethodData::Card(domain::Card { card_cvc: Secret::new("12".to_string()), ..utils::CCardType::default().0 }), diff --git a/crates/router/tests/connectors/trustpay.rs b/crates/router/tests/connectors/trustpay.rs index 48cd165767..fba612863b 100644 --- a/crates/router/tests/connectors/trustpay.rs +++ b/crates/router/tests/connectors/trustpay.rs @@ -12,12 +12,12 @@ use crate::{ struct TrustpayTest; impl ConnectorActions for TrustpayTest {} impl utils::Connector for TrustpayTest { - fn get_data(&self) -> types::api::ConnectorData { + fn get_data(&self) -> api::ConnectorData { use router::connector::Trustpay; - types::api::ConnectorData { + api::ConnectorData { connector: Box::new(&Trustpay), connector_name: types::Connector::Trustpay, - get_token: types::api::GetToken::Connector, + get_token: api::GetToken::Connector, merchant_connector_id: None, } } @@ -53,7 +53,7 @@ fn get_default_browser_info() -> BrowserInformation { fn get_default_payment_authorize_data() -> Option { Some(types::PaymentsAuthorizeData { - payment_method_data: types::domain::PaymentMethodData::Card(domain::Card { + payment_method_data: domain::PaymentMethodData::Card(domain::Card { card_number: cards::CardNumber::from_str("4200000000000000").unwrap(), card_exp_year: Secret::new("25".to_string()), card_cvc: Secret::new("123".to_string()), @@ -122,7 +122,7 @@ async fn should_sync_auto_captured_payment() { .psync_retry_till_status_matches( enums::AttemptStatus::Charged, Some(types::PaymentsSyncData { - connector_transaction_id: router::types::ResponseId::ConnectorTransactionId( + connector_transaction_id: types::ResponseId::ConnectorTransactionId( txn_id.unwrap(), ), ..Default::default() @@ -182,7 +182,7 @@ async fn should_sync_refund() { #[actix_web::test] async fn should_fail_payment_for_incorrect_card_number() { let payment_authorize_data = types::PaymentsAuthorizeData { - payment_method_data: types::domain::PaymentMethodData::Card(domain::Card { + payment_method_data: domain::PaymentMethodData::Card(domain::Card { card_number: cards::CardNumber::from_str("1234567891011").unwrap(), card_exp_year: Secret::new("25".to_string()), card_cvc: Secret::new("123".to_string()), @@ -205,7 +205,7 @@ async fn should_fail_payment_for_incorrect_card_number() { #[actix_web::test] async fn should_fail_payment_for_incorrect_expiry_year() { let payment_authorize_data = Some(types::PaymentsAuthorizeData { - payment_method_data: types::domain::PaymentMethodData::Card(domain::Card { + payment_method_data: domain::PaymentMethodData::Card(domain::Card { card_number: cards::CardNumber::from_str("4200000000000000").unwrap(), card_exp_year: Secret::new("22".to_string()), card_cvc: Secret::new("123".to_string()), diff --git a/crates/router/tests/connectors/tsys.rs b/crates/router/tests/connectors/tsys.rs index d7a688bd12..ef4f576ad9 100644 --- a/crates/router/tests/connectors/tsys.rs +++ b/crates/router/tests/connectors/tsys.rs @@ -46,7 +46,7 @@ fn get_default_payment_info() -> Option { fn payment_method_details(amount: i64) -> Option { Some(types::PaymentsAuthorizeData { amount, - payment_method_data: types::domain::PaymentMethodData::Card(domain::Card { + payment_method_data: domain::PaymentMethodData::Card(domain::Card { card_number: CardNumber::from_str("4111111111111111").unwrap(), ..utils::CCardType::default().0 }), @@ -108,7 +108,7 @@ async fn should_sync_authorized_payment() { .psync_retry_till_status_matches( enums::AttemptStatus::Authorized, Some(types::PaymentsSyncData { - connector_transaction_id: router::types::ResponseId::ConnectorTransactionId( + connector_transaction_id: types::ResponseId::ConnectorTransactionId( txn_id.unwrap(), ), ..Default::default() @@ -244,7 +244,7 @@ async fn should_sync_auto_captured_payment() { .psync_retry_till_status_matches( enums::AttemptStatus::Charged, Some(types::PaymentsSyncData { - connector_transaction_id: router::types::ResponseId::ConnectorTransactionId( + connector_transaction_id: types::ResponseId::ConnectorTransactionId( txn_id.unwrap(), ), capture_method: Some(enums::CaptureMethod::Automatic), @@ -346,7 +346,7 @@ async fn should_fail_payment_for_incorrect_cvc() { let response = CONNECTOR .make_payment( Some(types::PaymentsAuthorizeData { - payment_method_data: types::domain::PaymentMethodData::Card(domain::Card { + payment_method_data: domain::PaymentMethodData::Card(domain::Card { card_cvc: Secret::new("".to_string()), ..utils::CCardType::default().0 }), @@ -368,7 +368,7 @@ async fn should_fail_payment_for_invalid_exp_month() { let response = CONNECTOR .make_payment( Some(types::PaymentsAuthorizeData { - payment_method_data: types::domain::PaymentMethodData::Card(domain::Card { + payment_method_data: domain::PaymentMethodData::Card(domain::Card { card_exp_month: Secret::new("20".to_string()), ..utils::CCardType::default().0 }), @@ -390,7 +390,7 @@ async fn should_fail_payment_for_incorrect_expiry_year() { let response = CONNECTOR .make_payment( Some(types::PaymentsAuthorizeData { - payment_method_data: types::domain::PaymentMethodData::Card(domain::Card { + payment_method_data: domain::PaymentMethodData::Card(domain::Card { card_exp_year: Secret::new("abcd".to_string()), ..utils::CCardType::default().0 }), diff --git a/crates/router/tests/connectors/utils.rs b/crates/router/tests/connectors/utils.rs index 9678eca73f..3196c4c763 100644 --- a/crates/router/tests/connectors/utils.rs +++ b/crates/router/tests/connectors/utils.rs @@ -8,7 +8,7 @@ use masking::Secret; use router::core::utils as core_utils; use router::{ configs::settings::Settings, - core::{errors, errors::ConnectorError, payments}, + core::{errors::ConnectorError, payments}, db::StorageImpl, routes, services, types::{self, storage::enums, AccessToken, PaymentAddress, RouterData}, @@ -57,7 +57,7 @@ pub struct PaymentInfo { impl PaymentInfo { pub fn with_default_billing_name() -> Self { Self { - address: Some(types::PaymentAddress::new( + address: Some(PaymentAddress::new( None, None, Some(types::api::Address { @@ -215,7 +215,7 @@ pub trait ConnectorActions: Connector { } tokio::time::sleep(Duration::from_secs(self.get_request_interval())).await; } - Err(errors::ConnectorError::ProcessingStepFailed(None).into()) + Err(ConnectorError::ProcessingStepFailed(None).into()) } async fn capture_payment( @@ -453,7 +453,7 @@ pub trait ConnectorActions: Connector { } tokio::time::sleep(Duration::from_secs(self.get_request_interval())).await; } - Err(errors::ConnectorError::ProcessingStepFailed(None).into()) + Err(ConnectorError::ProcessingStepFailed(None).into()) } #[cfg(feature = "payouts")] @@ -523,7 +523,7 @@ pub trait ConnectorActions: Connector { .unwrap(), connector_meta_data: info .clone() - .and_then(|a| a.connector_meta_data.map(masking::Secret::new)), + .and_then(|a| a.connector_meta_data.map(Secret::new)), amount_captured: None, access_token: info.clone().and_then(|a| a.access_token), session_token: None, @@ -902,7 +902,7 @@ impl Default for CCardType { card_type: None, card_issuing_country: None, bank_code: None, - nick_name: Some(masking::Secret::new("nick_name".into())), + nick_name: Some(Secret::new("nick_name".into())), }) } } diff --git a/crates/router/tests/connectors/volt.rs b/crates/router/tests/connectors/volt.rs index 7bcdf63d91..efe6d603e7 100644 --- a/crates/router/tests/connectors/volt.rs +++ b/crates/router/tests/connectors/volt.rs @@ -92,7 +92,7 @@ async fn should_sync_authorized_payment() { .psync_retry_till_status_matches( enums::AttemptStatus::Authorized, Some(types::PaymentsSyncData { - connector_transaction_id: router::types::ResponseId::ConnectorTransactionId( + connector_transaction_id: types::ResponseId::ConnectorTransactionId( txn_id.unwrap(), ), ..Default::default() @@ -212,7 +212,7 @@ async fn should_sync_auto_captured_payment() { .psync_retry_till_status_matches( enums::AttemptStatus::Charged, Some(types::PaymentsSyncData { - connector_transaction_id: router::types::ResponseId::ConnectorTransactionId( + connector_transaction_id: types::ResponseId::ConnectorTransactionId( txn_id.unwrap(), ), capture_method: Some(enums::CaptureMethod::Automatic), @@ -302,7 +302,7 @@ async fn should_fail_payment_for_incorrect_cvc() { let response = CONNECTOR .make_payment( Some(types::PaymentsAuthorizeData { - payment_method_data: types::domain::PaymentMethodData::Card(domain::Card { + payment_method_data: domain::PaymentMethodData::Card(domain::Card { card_cvc: Secret::new("12345".to_string()), ..utils::CCardType::default().0 }), @@ -324,7 +324,7 @@ async fn should_fail_payment_for_invalid_exp_month() { let response = CONNECTOR .make_payment( Some(types::PaymentsAuthorizeData { - payment_method_data: types::domain::PaymentMethodData::Card(domain::Card { + payment_method_data: domain::PaymentMethodData::Card(domain::Card { card_exp_month: Secret::new("20".to_string()), ..utils::CCardType::default().0 }), @@ -346,7 +346,7 @@ async fn should_fail_payment_for_incorrect_expiry_year() { let response = CONNECTOR .make_payment( Some(types::PaymentsAuthorizeData { - payment_method_data: types::domain::PaymentMethodData::Card(domain::Card { + payment_method_data: domain::PaymentMethodData::Card(domain::Card { card_exp_year: Secret::new("2000".to_string()), ..utils::CCardType::default().0 }), diff --git a/crates/router/tests/connectors/wise.rs b/crates/router/tests/connectors/wise.rs index b85fb4f1c9..fd5bbc109d 100644 --- a/crates/router/tests/connectors/wise.rs +++ b/crates/router/tests/connectors/wise.rs @@ -1,38 +1,36 @@ -#[cfg(feature = "payouts")] use api_models::payments::{Address, AddressDetails}; -#[cfg(feature = "payouts")] use masking::Secret; -use router::types; -#[cfg(feature = "payouts")] -use router::types::{api, storage::enums, PaymentAddress}; +use router::{ + types, + types::{api, storage::enums, PaymentAddress}, +}; -#[cfg(feature = "payouts")] -use crate::utils::PaymentInfo; use crate::{ connector_auth, - utils::{self, ConnectorActions}, + utils::{self, ConnectorActions, PaymentInfo}, }; struct WiseTest; + impl ConnectorActions for WiseTest {} + impl utils::Connector for WiseTest { - fn get_data(&self) -> types::api::ConnectorData { + fn get_data(&self) -> api::ConnectorData { use router::connector::Adyen; - types::api::ConnectorData { + api::ConnectorData { connector: Box::new(&Adyen), connector_name: types::Connector::Adyen, - get_token: types::api::GetToken::Connector, + get_token: api::GetToken::Connector, merchant_connector_id: None, } } - #[cfg(feature = "payouts")] - fn get_payout_data(&self) -> Option { + fn get_payout_data(&self) -> Option { use router::connector::Wise; - Some(types::api::ConnectorData { + Some(api::ConnectorData { connector: Box::new(&Wise), connector_name: types::Connector::Wise, - get_token: types::api::GetToken::Connector, + get_token: api::GetToken::Connector, merchant_connector_id: None, }) } @@ -52,7 +50,6 @@ impl utils::Connector for WiseTest { } impl WiseTest { - #[cfg(feature = "payouts")] fn get_payout_info() -> Option { Some(PaymentInfo { country: Some(api_models::enums::CountryAlpha2::NL), @@ -86,12 +83,11 @@ impl WiseTest { } } -#[cfg(feature = "payouts")] static CONNECTOR: WiseTest = WiseTest {}; /******************** Payouts test cases ********************/ // Creates a recipient at connector's end -#[cfg(feature = "payouts")] + #[actix_web::test] async fn should_create_payout_recipient() { let payout_type = enums::PayoutType::Bank; @@ -107,7 +103,7 @@ async fn should_create_payout_recipient() { } // Create BACS payout -#[cfg(feature = "payouts")] + #[actix_web::test] async fn should_create_bacs_payout() { let payout_type = enums::PayoutType::Bank; @@ -138,7 +134,7 @@ async fn should_create_bacs_payout() { } // Create and fulfill BACS payout -#[cfg(feature = "payouts")] + #[actix_web::test] async fn should_create_and_fulfill_bacs_payout() { let payout_type = enums::PayoutType::Bank; diff --git a/crates/router/tests/connectors/worldline.rs b/crates/router/tests/connectors/worldline.rs index 21a5a57412..4f8119bfc5 100644 --- a/crates/router/tests/connectors/worldline.rs +++ b/crates/router/tests/connectors/worldline.rs @@ -81,7 +81,7 @@ impl WorldlineTest { card_type: None, card_issuing_country: None, bank_code: None, - nick_name: Some(masking::Secret::new("nick_name".into())), + nick_name: Some(Secret::new("nick_name".into())), }), confirm: true, statement_descriptor_suffix: None, @@ -231,7 +231,7 @@ async fn should_sync_manual_auth_payment() { let sync_response = connector .sync_payment( Some(types::PaymentsSyncData { - connector_transaction_id: router::types::ResponseId::ConnectorTransactionId( + connector_transaction_id: types::ResponseId::ConnectorTransactionId( connector_payment_id, ), capture_method: Some(enums::CaptureMethod::Manual), @@ -264,7 +264,7 @@ async fn should_sync_auto_auth_payment() { let sync_response = connector .sync_payment( Some(types::PaymentsSyncData { - connector_transaction_id: router::types::ResponseId::ConnectorTransactionId( + connector_transaction_id: types::ResponseId::ConnectorTransactionId( connector_payment_id, ), capture_method: Some(enums::CaptureMethod::Automatic), diff --git a/crates/router/tests/connectors/worldpay.rs b/crates/router/tests/connectors/worldpay.rs index 649b1bebbb..571de7d959 100644 --- a/crates/router/tests/connectors/worldpay.rs +++ b/crates/router/tests/connectors/worldpay.rs @@ -62,7 +62,7 @@ async fn should_authorize_gpay_payment() { let response = conn .authorize_payment( Some(types::PaymentsAuthorizeData { - payment_method_data: types::domain::PaymentMethodData::Wallet( + payment_method_data: domain::PaymentMethodData::Wallet( domain::WalletData::GooglePay(domain::GooglePayWalletData { pm_type: "CARD".to_string(), description: "Visa1234567890".to_string(), @@ -97,7 +97,7 @@ async fn should_authorize_applepay_payment() { let response = conn .authorize_payment( Some(types::PaymentsAuthorizeData { - payment_method_data: types::domain::PaymentMethodData::Wallet( + payment_method_data: domain::PaymentMethodData::Wallet( domain::WalletData::ApplePay(domain::ApplePayWalletData { payment_data: "someData".to_string(), transaction_identifier: "someId".to_string(), @@ -149,7 +149,7 @@ async fn should_sync_payment() { let response = connector .sync_payment( Some(types::PaymentsSyncData { - connector_transaction_id: router::types::ResponseId::ConnectorTransactionId( + connector_transaction_id: types::ResponseId::ConnectorTransactionId( "112233".to_string(), ), ..Default::default() diff --git a/crates/router/tests/connectors/zen.rs b/crates/router/tests/connectors/zen.rs index e076aee42c..b11b78025d 100644 --- a/crates/router/tests/connectors/zen.rs +++ b/crates/router/tests/connectors/zen.rs @@ -95,7 +95,7 @@ async fn should_sync_authorized_payment() { .psync_retry_till_status_matches( enums::AttemptStatus::Authorized, Some(types::PaymentsSyncData { - connector_transaction_id: router::types::ResponseId::ConnectorTransactionId( + connector_transaction_id: types::ResponseId::ConnectorTransactionId( txn_id.unwrap(), ), encoded_data: None, @@ -211,7 +211,7 @@ async fn should_sync_auto_captured_payment() { .psync_retry_till_status_matches( enums::AttemptStatus::Charged, Some(types::PaymentsSyncData { - connector_transaction_id: router::types::ResponseId::ConnectorTransactionId( + connector_transaction_id: types::ResponseId::ConnectorTransactionId( txn_id.unwrap(), ), encoded_data: None, @@ -310,7 +310,7 @@ async fn should_fail_payment_for_incorrect_card_number() { let response = CONNECTOR .make_payment( Some(types::PaymentsAuthorizeData { - payment_method_data: types::domain::PaymentMethodData::Card(domain::Card { + payment_method_data: domain::PaymentMethodData::Card(domain::Card { card_number: CardNumber::from_str("1234567891011").unwrap(), ..utils::CCardType::default().0 }), @@ -352,7 +352,7 @@ async fn should_fail_payment_for_incorrect_cvc() { let response = CONNECTOR .make_payment( Some(types::PaymentsAuthorizeData { - payment_method_data: types::domain::PaymentMethodData::Card(domain::Card { + payment_method_data: domain::PaymentMethodData::Card(domain::Card { card_cvc: Secret::new("12345".to_string()), ..utils::CCardType::default().0 }), @@ -394,7 +394,7 @@ async fn should_fail_payment_for_invalid_exp_month() { let response = CONNECTOR .make_payment( Some(types::PaymentsAuthorizeData { - payment_method_data: types::domain::PaymentMethodData::Card(domain::Card { + payment_method_data: domain::PaymentMethodData::Card(domain::Card { card_exp_month: Secret::new("20".to_string()), ..utils::CCardType::default().0 }), @@ -436,7 +436,7 @@ async fn should_fail_payment_for_incorrect_expiry_year() { let response = CONNECTOR .make_payment( Some(types::PaymentsAuthorizeData { - payment_method_data: types::domain::PaymentMethodData::Card(domain::Card { + payment_method_data: domain::PaymentMethodData::Card(domain::Card { card_exp_year: Secret::new("2000".to_string()), ..utils::CCardType::default().0 }), diff --git a/crates/router/tests/payments.rs b/crates/router/tests/payments.rs index 646a11d4cd..f4325d01b9 100644 --- a/crates/router/tests/payments.rs +++ b/crates/router/tests/payments.rs @@ -26,7 +26,7 @@ use uuid::Uuid; async fn payments_create_stripe() { Box::pin(utils::setup()).await; - let payment_id = format!("test_{}", uuid::Uuid::new_v4()); + let payment_id = format!("test_{}", Uuid::new_v4()); let api_key = ("API-KEY", "MySecretApiKey"); let request = serde_json::json!({ @@ -95,7 +95,7 @@ async fn payments_create_stripe() { async fn payments_create_adyen() { Box::pin(utils::setup()).await; - let payment_id = format!("test_{}", uuid::Uuid::new_v4()); + let payment_id = format!("test_{}", Uuid::new_v4()); let api_key = ("API-KEY", "321"); let request = serde_json::json!({ @@ -164,7 +164,7 @@ async fn payments_create_adyen() { async fn payments_create_fail() { Box::pin(utils::setup()).await; - let payment_id = format!("test_{}", uuid::Uuid::new_v4()); + let payment_id = format!("test_{}", Uuid::new_v4()); let api_key = ("API-KEY", "MySecretApiKey"); let invalid_request = serde_json::json!({ diff --git a/crates/router/tests/payments2.rs b/crates/router/tests/payments2.rs index 9b622d11fd..56ab453a0f 100644 --- a/crates/router/tests/payments2.rs +++ b/crates/router/tests/payments2.rs @@ -14,7 +14,7 @@ use uuid::Uuid; #[test] fn connector_list() { - let connector_list = router::types::ConnectorsList { + let connector_list = types::ConnectorsList { connectors: vec![String::from("stripe"), "adyen".to_string()], }; @@ -22,7 +22,7 @@ fn connector_list() { println!("{}", &json); - let newlist: router::types::ConnectorsList = serde_json::from_str(&json).unwrap(); + let newlist: types::ConnectorsList = serde_json::from_str(&json).unwrap(); println!("{newlist:#?}"); assert_eq!(true, true); @@ -125,7 +125,7 @@ async fn payments_create_core() { }; let expected_response = services::ApplicationResponse::JsonWithHeaders((expected_response, vec![])); - let actual_response = Box::pin(router::core::payments::payments_core::< + let actual_response = Box::pin(payments::payments_core::< api::Authorize, api::PaymentsResponse, _, @@ -316,7 +316,7 @@ async fn payments_create_core_adyen_no_redirect() { }, vec![], )); - let actual_response = Box::pin(router::core::payments::payments_core::< + let actual_response = Box::pin(payments::payments_core::< api::Authorize, api::PaymentsResponse, _, diff --git a/crates/router_derive/src/macros/api_error/helpers.rs b/crates/router_derive/src/macros/api_error/helpers.rs index 5781d786ee..deb1b349cb 100644 --- a/crates/router_derive/src/macros/api_error/helpers.rs +++ b/crates/router_derive/src/macros/api_error/helpers.rs @@ -260,9 +260,9 @@ pub(super) fn get_unused_fields( ignore: &std::collections::HashSet, ) -> Vec { let fields = match fields { - syn::Fields::Unit => Vec::new(), - syn::Fields::Unnamed(_) => Vec::new(), - syn::Fields::Named(fields) => fields.named.iter().cloned().collect(), + Fields::Unit => Vec::new(), + Fields::Unnamed(_) => Vec::new(), + Fields::Named(fields) => fields.named.iter().cloned().collect(), }; fields .iter() diff --git a/crates/router_derive/src/macros/helpers.rs b/crates/router_derive/src/macros/helpers.rs index b6490c4d62..1cb7e21bb9 100644 --- a/crates/router_derive/src/macros/helpers.rs +++ b/crates/router_derive/src/macros/helpers.rs @@ -58,7 +58,7 @@ pub(super) fn get_struct_fields( Ok(named.to_owned()) } else { Err(syn::Error::new( - proc_macro2::Span::call_site(), + Span::call_site(), "This macro cannot be used on structs with no fields", )) } diff --git a/crates/router_derive/src/macros/try_get_enum.rs b/crates/router_derive/src/macros/try_get_enum.rs index f607b7f06c..bdfbdb6693 100644 --- a/crates/router_derive/src/macros/try_get_enum.rs +++ b/crates/router_derive/src/macros/try_get_enum.rs @@ -68,7 +68,7 @@ pub fn try_get_enum_variant( let try_into_fn = syn::Ident::new( &format!("try_into_{}", variant_name.to_string().to_lowercase()), - proc_macro2::Span::call_site(), + Span::call_site(), ); Ok(quote::quote! { diff --git a/crates/router_env/src/logger/setup.rs b/crates/router_env/src/logger/setup.rs index af77991e80..3a9e719db1 100644 --- a/crates/router_env/src/logger/setup.rs +++ b/crates/router_env/src/logger/setup.rs @@ -265,7 +265,7 @@ fn setup_tracing_pipeline( .with_exporter(get_opentelemetry_exporter(config)) .with_batch_config(batch_config) .with_trace_config(trace_config) - .install_batch(opentelemetry::runtime::TokioCurrentThread) + .install_batch(runtime::TokioCurrentThread) .map(|tracer| tracing_opentelemetry::layer().with_tracer(tracer)); if config.ignore_errors { diff --git a/crates/scheduler/src/producer.rs b/crates/scheduler/src/producer.rs index fd2b9b654a..397aab84e9 100644 --- a/crates/scheduler/src/producer.rs +++ b/crates/scheduler/src/producer.rs @@ -43,11 +43,10 @@ where tokio::time::sleep(Duration::from_millis(timeout.sample(&mut rng))).await; - let mut interval = tokio::time::interval(std::time::Duration::from_millis( - scheduler_settings.loop_interval, - )); + let mut interval = + tokio::time::interval(Duration::from_millis(scheduler_settings.loop_interval)); - let mut shutdown_interval = tokio::time::interval(std::time::Duration::from_millis( + let mut shutdown_interval = tokio::time::interval(Duration::from_millis( scheduler_settings.graceful_shutdown_interval, )); diff --git a/crates/scheduler/src/utils.rs b/crates/scheduler/src/utils.rs index 11924dd1be..8b80b7c72c 100644 --- a/crates/scheduler/src/utils.rs +++ b/crates/scheduler/src/utils.rs @@ -254,7 +254,7 @@ pub fn get_time_from_delta(delta: Option) -> Option( +pub async fn consumer_operation_handler( state: T, settings: sync::Arc, error_handler_fun: E, @@ -263,7 +263,7 @@ pub async fn consumer_operation_handler( ) where // Error handler function E: FnOnce(error_stack::Report), - T: SchedulerAppState, + T: SchedulerAppState + Send + Sync + 'static, { consumer_operation_counter.fetch_add(1, atomic::Ordering::SeqCst); let start_time = std_time::Instant::now(); diff --git a/crates/storage_impl/src/errors.rs b/crates/storage_impl/src/errors.rs index 41099bea75..4356b6b799 100644 --- a/crates/storage_impl/src/errors.rs +++ b/crates/storage_impl/src/errors.rs @@ -8,7 +8,7 @@ use hyperswitch_domain_models::errors::StorageError as DataStorageError; pub use redis_interface::errors::RedisError; use router_env::opentelemetry::metrics::MetricsError; -use crate::{errors as storage_errors, store::errors::DatabaseError}; +use crate::store::errors::DatabaseError; pub type ApplicationResult = Result; @@ -56,20 +56,16 @@ impl Into for &StorageError { fn into(self) -> DataStorageError { match self { StorageError::DatabaseError(i) => match i.current_context() { - storage_errors::DatabaseError::DatabaseConnectionError => { - DataStorageError::DatabaseConnectionError - } + DatabaseError::DatabaseConnectionError => DataStorageError::DatabaseConnectionError, // TODO: Update this error type to encompass & propagate the missing type (instead of generic `db value not found`) - storage_errors::DatabaseError::NotFound => { + DatabaseError::NotFound => { DataStorageError::ValueNotFound(String::from("db value not found")) } // TODO: Update this error type to encompass & propagate the duplicate type (instead of generic `db value not found`) - storage_errors::DatabaseError::UniqueViolation => { - DataStorageError::DuplicateValue { - entity: "db entity", - key: None, - } - } + DatabaseError::UniqueViolation => DataStorageError::DuplicateValue { + entity: "db entity", + key: None, + }, err => DataStorageError::DatabaseError(error_stack::report!(*err)), }, StorageError::ValueNotFound(i) => DataStorageError::ValueNotFound(i.clone()), diff --git a/crates/storage_impl/src/lib.rs b/crates/storage_impl/src/lib.rs index e35d1f4151..7a3ef30bef 100644 --- a/crates/storage_impl/src/lib.rs +++ b/crates/storage_impl/src/lib.rs @@ -217,7 +217,7 @@ impl KVRouterStore { partition_key: redis::kv_store::PartitionKey<'_>, ) -> error_stack::Result<(), RedisError> where - R: crate::redis::kv_store::KvStorePartition, + R: redis::kv_store::KvStorePartition, { let global_id = format!("{}", partition_key); let request_id = self.request_id.clone().unwrap_or_default(); diff --git a/crates/storage_impl/src/mock_db.rs b/crates/storage_impl/src/mock_db.rs index 5cf0123eb7..3657201f87 100644 --- a/crates/storage_impl/src/mock_db.rs +++ b/crates/storage_impl/src/mock_db.rs @@ -41,9 +41,9 @@ pub struct MockDb { pub disputes: Arc>>, pub lockers: Arc>>, pub mandates: Arc>>, - pub captures: Arc>>, - pub merchant_key_store: Arc>>, - pub business_profiles: Arc>>, + pub captures: Arc>>, + pub merchant_key_store: Arc>>, + pub business_profiles: Arc>>, pub reverse_lookups: Arc>>, pub payment_link: Arc>>, pub organizations: Arc>>, diff --git a/crates/storage_impl/src/payments/payment_intent.rs b/crates/storage_impl/src/payments/payment_intent.rs index fcc4ec63ff..2cbcbaaf01 100644 --- a/crates/storage_impl/src/payments/payment_intent.rs +++ b/crates/storage_impl/src/payments/payment_intent.rs @@ -257,7 +257,7 @@ impl PaymentIntentInterface for KVRouterStore { _storage_scheme: MerchantStorageScheme, ) -> error_stack::Result { match payment.active_attempt.clone() { - hyperswitch_domain_models::RemoteStorageObject::ForeignID(attempt_id) => { + RemoteStorageObject::ForeignID(attempt_id) => { let conn = pg_connection_read(self).await?; let pa = DieselPaymentAttempt::find_by_merchant_id_attempt_id( @@ -271,11 +271,10 @@ impl PaymentIntentInterface for KVRouterStore { er.change_context(new_err) }) .map(PaymentAttempt::from_storage_model)?; - payment.active_attempt = - hyperswitch_domain_models::RemoteStorageObject::Object(pa.clone()); + payment.active_attempt = RemoteStorageObject::Object(pa.clone()); Ok(pa) } - hyperswitch_domain_models::RemoteStorageObject::Object(pa) => Ok(pa.clone()), + RemoteStorageObject::Object(pa) => Ok(pa.clone()), } } @@ -397,7 +396,7 @@ impl PaymentIntentInterface for crate::RouterStore { _storage_scheme: MerchantStorageScheme, ) -> error_stack::Result { match &payment.active_attempt { - hyperswitch_domain_models::RemoteStorageObject::ForeignID(attempt_id) => { + RemoteStorageObject::ForeignID(attempt_id) => { let conn = pg_connection_read(self).await?; let pa = DieselPaymentAttempt::find_by_merchant_id_attempt_id( @@ -411,11 +410,10 @@ impl PaymentIntentInterface for crate::RouterStore { er.change_context(new_err) }) .map(PaymentAttempt::from_storage_model)?; - payment.active_attempt = - hyperswitch_domain_models::RemoteStorageObject::Object(pa.clone()); + payment.active_attempt = RemoteStorageObject::Object(pa.clone()); Ok(pa) } - hyperswitch_domain_models::RemoteStorageObject::Object(pa) => Ok(pa.clone()), + RemoteStorageObject::Object(pa) => Ok(pa.clone()), } } diff --git a/crates/test_utils/src/newman_runner.rs b/crates/test_utils/src/newman_runner.rs index e70c630cff..c90292683f 100644 --- a/crates/test_utils/src/newman_runner.rs +++ b/crates/test_utils/src/newman_runner.rs @@ -63,7 +63,7 @@ fn get_dir_path(name: impl AsRef) -> String { // This function currently allows you to add only custom headers. // In future, as we scale, this can be modified based on the need -fn insert_content(dir: T, content_to_insert: U) -> std::io::Result<()> +fn insert_content(dir: T, content_to_insert: U) -> io::Result<()> where T: AsRef, U: AsRef, @@ -72,7 +72,7 @@ where let file_path = dir.as_ref().join(file_name); // Open the file in write mode or create it if it doesn't exist - let mut file = std::fs::OpenOptions::new() + let mut file = OpenOptions::new() .append(true) .create(true) .open(file_path)?;