chore: run formatter

Author: hyperswitch-bot[bot]

Diff for: crates/router/src/consts.rs

@@ -240,4 +240,4 @@ pub const IRRELEVANT_PAYMENT_INTENT_ID: &str = "irrelevant_payment_intent_id";
 pub const IRRELEVANT_PAYMENT_ATTEMPT_ID: &str = "irrelevant_payment_attempt_id";
 
 // Default payment method storing TTL in redis in seconds
-pub const DEFAULT_PAYMENT_METHOD_STORE_TTL: i64 = 86400; // 1 day
+pub const DEFAULT_PAYMENT_METHOD_STORE_TTL: i64 = 86400; // 1 day

Diff for: crates/router/src/core/payment_methods.rs

@@ -34,10 +34,10 @@ use common_utils::{consts::DEFAULT_LOCALE, id_type};
 #[cfg(all(feature = "v2", feature = "payment_methods_v2"))]
 use common_utils::{
     crypto::Encryptable,
+    errors,
     ext_traits::{AsyncExt, Encode, ValueExt},
     fp_utils::when,
     generate_id, types as util_types,
-    errors,
 };
 use diesel_models::{
     enums, GenericLinkNew, PaymentMethodCollectLink, PaymentMethodCollectLinkData,
@@ -1890,11 +1890,12 @@ pub async fn retrieve_payment_method(
         )
         .await
         .to_not_found_response(errors::ApiErrorResponse::PaymentMethodNotFound)?;
-    
+
     let payment_method_in_cache = get_single_use_token_from_store(
         &state.clone(),
-        payment_method_data::SingleUseTokenKey::store_key(pm_id.clone().get_string_repr())
-    ).await
+        payment_method_data::SingleUseTokenKey::store_key(pm_id.clone().get_string_repr()),
+    )
+    .await
     .to_not_found_response(errors::ApiErrorResponse::GenericNotFoundError {
         message: "payment methods session does not exist or has expired".to_string(),
     })
@@ -2690,11 +2691,12 @@ async fn create_single_use_tokenization_flow(
     payment_method_session: &domain::payment_methods::PaymentMethodSession,
 ) -> RouterResult<()> {
     let customer_id = payment_method_create_request.customer_id.to_owned();
-    let connector_id = payment_method_create_request.get_tokenize_connector_id()
-    .change_context(errors::ApiErrorResponse::MissingRequiredField {
-        field_name: "psp_tokenization.connector_id",
-    })
-    .attach_printable("Failed to get tokenize connector id")?;
+    let connector_id = payment_method_create_request
+        .get_tokenize_connector_id()
+        .change_context(errors::ApiErrorResponse::MissingRequiredField {
+            field_name: "psp_tokenization.connector_id",
+        })
+        .attach_printable("Failed to get tokenize connector id")?;
 
     let db = &state.store;
 
@@ -2717,7 +2719,9 @@ async fn create_single_use_tokenization_flow(
         .change_context(errors::ApiErrorResponse::MissingRequiredField {
             field_name: "card_cvc",
         })
-        .attach_printable("Failed to convert type from Payment Method Create Data to Payment Method Data")?,
+        .attach_printable(
+            "Failed to convert type from Payment Method Create Data to Payment Method Data",
+        )?,
         browser_info: None,
         currency: api_models::enums::Currency::default(),
         amount: None,
@@ -2807,17 +2811,17 @@ async fn create_single_use_tokenization_flow(
             reason: err.reason,
         })?;
 
-    let token = token_response
-                            .ok_or(errors::ApiErrorResponse::GenericNotFoundError {
-                                message: "No token recevied from the PSP".to_string(),
-                            })?;
+    let token = token_response.ok_or(errors::ApiErrorResponse::GenericNotFoundError {
+        message: "No token recevied from the PSP".to_string(),
+    })?;
 
     let value = payment_method_data::PaymentMethodTokenSingleUse::get_single_use_token_from_payment_method_token(
                                                        token.clone(),
                                                 connector_id.clone()
                                             );
 
-    let key = payment_method_data::SingleUseTokenKey::store_key(payment_method.id.get_string_repr());
+    let key =
+        payment_method_data::SingleUseTokenKey::store_key(payment_method.id.get_string_repr());
 
     add_single_use_token_to_store(&state, key, value).await?;
 
@@ -2852,10 +2856,7 @@ async fn add_single_use_token_to_store(
 async fn get_single_use_token_from_store(
     state: &SessionState,
     key: payment_method_data::SingleUseTokenKey,
-) -> CustomResult<
-                    payment_method_data::PaymentMethodTokenSingleUse, 
-                    errors::StorageError,
-                >{
+) -> CustomResult<payment_method_data::PaymentMethodTokenSingleUse, errors::StorageError> {
     let redis_connection = state
         .store
         .get_redis_conn()
@@ -2865,9 +2866,9 @@ async fn get_single_use_token_from_store(
     redis_connection
         .get_and_deserialize_key::<payment_method_data::PaymentMethodTokenSingleUse>(
             &payment_method_data::SingleUseTokenKey::get_store_key(&key).into(),
-            "PaymentMethodTokenSingleUse"
+            "PaymentMethodTokenSingleUse",
         )
         .await
         .change_context(errors::StorageError::KVError)
         .attach_printable("Failed to get payment method token from redis")
-}
+}

Diff for: crates/router/src/core/payment_methods/transformers.rs

@@ -6,6 +6,8 @@ use common_utils::{
     request::RequestContent,
 };
 use error_stack::ResultExt;
+#[cfg(all(feature = "v2", feature = "payment_methods_v2"))]
+use hyperswitch_domain_models::payment_method_data;
 use josekit::jwe;
 use router_env::tracing_actix_web::RequestId;
 use serde::{Deserialize, Serialize};
@@ -21,8 +23,6 @@ use crate::{
     types::{api, domain},
     utils::OptionExt,
 };
-#[cfg(all(feature = "v2", feature = "payment_methods_v2"))]
-use hyperswitch_domain_models::payment_method_data;
 
 #[derive(Debug, Serialize)]
 #[serde(untagged)]
@@ -574,11 +574,11 @@ pub fn generate_payment_method_response(
                 .map(transformers::ForeignFrom::foreign_from)
                 .collect::<Vec<_>>()
         });
-    
+
     if let Some(token) = single_use_token {
-            connector_tokens.append(transformers::ForeignFrom::foreign_from(token.clone()));
-        }
-    
+        connector_tokens.append(transformers::ForeignFrom::foreign_from(token.clone()));
+    }
+
     let network_token_pmd = payment_method
         .network_token_payment_method_data
         .clone()
@@ -1123,7 +1123,9 @@ impl
 }
 
 #[cfg(feature = "v2")]
-impl transformers::ForeignFrom<payment_method_data::PaymentMethodTokenSingleUse> for api_models::payment_methods::ConnectorTokenDetails {
+impl transformers::ForeignFrom<payment_method_data::PaymentMethodTokenSingleUse>
+    for api_models::payment_methods::ConnectorTokenDetails
+{
     fn foreign_from(token: payment_method_data::PaymentMethodTokenSingleUse) -> Self {
         Self {
             connector_id: token.merchant_connector_id,
@@ -1136,4 +1138,4 @@ impl transformers::ForeignFrom<payment_method_data::PaymentMethodTokenSingleUse>
             token: Secret::new(token.token),
         }
     }
-} 
+}

Diff for: crates/router/src/core/payments/tokenization.rs

@@ -1355,9 +1355,7 @@ pub async fn add_token_for_payment_method(
     state: SessionState,
     merchant_connector_account_details: &hyperswitch_domain_models::merchant_connector_account::MerchantConnectorAccount,
 ) -> RouterResult<types::PaymentMethodTokenResult> {
-    let connector_id = merchant_connector_account_details
-                        .id
-                        .clone();
+    let connector_id = merchant_connector_account_details.id.clone();
     let connector_data = api::ConnectorData::get_connector_by_name(
         &(state.conf.connectors),
         &merchant_connector_account_details