refactor: resolve comments

Author: Sakilmostak

crates/router/src/core/payments.rs

@@ -13,6 +13,8 @@ pub mod session_operation;
 pub mod tokenization;
 pub mod transformers;
 pub mod types;
+#[cfg(feature = "v2")]
+pub mod vault_session;
 #[cfg(feature = "olap")]
 use std::collections::HashMap;
 use std::{

crates/router/src/core/payments/operations/payment_session_intent.rs

@@ -179,9 +179,6 @@ impl<F: Clone + Sync> UpdateTracker<F, payments::PaymentIntentData<F>, PaymentsS
     where
         F: 'b + Send,
     {
-        let db = &*state.store;
-        let key_manager_state = &state.into();
-
         let prerouting_algorithm = payment_data.payment_intent.prerouting_algorithm.clone();
         payment_data.payment_intent = match prerouting_algorithm {
             Some(prerouting_algorithm) => state
@@ -201,25 +198,6 @@ impl<F: Clone + Sync> UpdateTracker<F, payments::PaymentIntentData<F>, PaymentsS
             None => payment_data.payment_intent,
         };
 
-        if let Some((customer, updated_customer)) = customer.zip(updated_customer) {
-            let customer_id = customer.get_id().clone();
-            let customer_merchant_id = customer.merchant_id.clone();
-
-            let _updated_customer = db
-                .update_customer_by_global_id(
-                    key_manager_state,
-                    &customer_id,
-                    customer,
-                    &customer_merchant_id,
-                    updated_customer,
-                    key_store,
-                    storage_scheme,
-                )
-                .await
-                .change_context(errors::ApiErrorResponse::InternalServerError)
-                .attach_printable("Failed to update customer during `update_trackers`")?;
-        }
-
         Ok((Box::new(self), payment_data))
     }
 }

crates/router/src/core/payments/session_operation.rs

@@ -24,11 +24,11 @@ use crate::{
     core::{
         errors::{self, utils::StorageErrorExt, RouterResult},
         payments::{
-            self as payments_core, call_multiple_connectors_service, customers,
+            self as payments_core, call_multiple_connectors_service,
             flows::{ConstructFlowSpecificData, Feature},
             helpers, helpers as payment_helpers, operations,
             operations::{BoxedOperation, Operation},
-            transformers, OperationSessionGetters, OperationSessionSetters,
+            transformers, vault_session, OperationSessionGetters, OperationSessionSetters,
         },
         utils as core_utils,
     },
@@ -158,7 +158,7 @@ where
         .to_not_found_response(errors::ApiErrorResponse::CustomerNotFound)
         .attach_printable("Failed while fetching/creating customer")?;
 
-    populate_vault_session_details(
+    vault_session::populate_vault_session_details(
         state,
         req_state.clone(),
         &customer,
@@ -220,321 +220,3 @@ where
 
     Ok((payment_data, req, customer, None, None))
 }
-
-#[cfg(feature = "v2")]
-#[allow(clippy::too_many_arguments)]
-pub async fn populate_vault_session_details<F, RouterDReq, ApiRequest, D>(
-    state: &SessionState,
-    req_state: ReqState,
-    customer: &Option<domain::Customer>,
-    merchant_context: &domain::MerchantContext,
-    operation: &BoxedOperation<'_, F, ApiRequest, D>,
-    profile: &domain::Profile,
-    payment_data: &mut D,
-    header_payload: HeaderPayload,
-) -> RouterResult<()>
-where
-    F: Send + Clone + Sync,
-    RouterDReq: Send + Sync,
-
-    // To create connector flow specific interface data
-    D: OperationSessionGetters<F> + OperationSessionSetters<F> + Send + Sync + Clone,
-    D: ConstructFlowSpecificData<F, RouterDReq, router_types::PaymentsResponseData>,
-    RouterData<F, RouterDReq, router_types::PaymentsResponseData>: Feature<F, RouterDReq> + Send,
-    // To construct connector flow specific api
-    dyn api::Connector:
-        services::api::ConnectorIntegration<F, RouterDReq, router_types::PaymentsResponseData>,
-{
-    let is_external_vault_sdk_enabled = profile.is_vault_sdk_enabled();
-
-    if is_external_vault_sdk_enabled {
-        let external_vault_source = profile
-            .external_vault_connector_details
-            .as_ref()
-            .map(|details| &details.vault_connector_id);
-
-        let merchant_connector_account = helpers::get_merchant_connector_account(
-            state,
-            merchant_context.get_merchant_account().get_id(),
-            None,
-            merchant_context.get_merchant_key_store(),
-            profile.get_id(),
-            "", // This is a placeholder for the connector name, which is not used in this context
-            external_vault_source,
-        )
-        .await?;
-
-        let updated_customer = call_create_connector_customer_if_required(
-            state,
-            customer,
-            merchant_context,
-            &merchant_connector_account,
-            payment_data,
-        )
-        .await?;
-
-        (_, *payment_data) = operation
-            .to_update_tracker()?
-            .update_trackers(
-                state,
-                req_state,
-                payment_data.clone(),
-                customer.clone(),
-                merchant_context.get_merchant_account().storage_scheme,
-                updated_customer,
-                merchant_context.get_merchant_key_store(),
-                None,
-                header_payload.clone(),
-            )
-            .await?;
-
-        let vault_session_details = generate_vault_session_details(
-            state,
-            merchant_context,
-            &merchant_connector_account,
-            profile,
-            payment_data.get_connector_customer_id(),
-        )
-        .await?;
-
-        payment_data.set_vault_session_details(vault_session_details);
-    }
-    Ok(())
-}
-
-#[cfg(feature = "v2")]
-pub async fn call_create_connector_customer_if_required<F, Req, D>(
-    state: &SessionState,
-    customer: &Option<domain::Customer>,
-    merchant_context: &domain::MerchantContext,
-    merchant_connector_account_type: &payment_helpers::MerchantConnectorAccountType,
-    payment_data: &mut D,
-) -> RouterResult<Option<storage::CustomerUpdate>>
-where
-    F: Send + Clone + Sync,
-    Req: Send + Sync,
-
-    // To create connector flow specific interface data
-    D: OperationSessionGetters<F> + OperationSessionSetters<F> + Send + Sync + Clone,
-    D: ConstructFlowSpecificData<F, Req, router_types::PaymentsResponseData>,
-    RouterData<F, Req, router_types::PaymentsResponseData>: Feature<F, Req> + Send,
-
-    // To construct connector flow specific api
-    dyn api::Connector:
-        services::api::ConnectorIntegration<F, Req, router_types::PaymentsResponseData>,
-{
-    let db_merchant_connector_account =
-        merchant_connector_account_type.get_inner_db_merchant_connector_account();
-
-    match db_merchant_connector_account {
-        Some(merchant_connector_account) => {
-            let connector_name = merchant_connector_account.get_connector_name_as_string();
-            let merchant_connector_id = merchant_connector_account.get_id();
-
-            let connector = api::ConnectorData::get_connector_by_name(
-                &state.conf.connectors,
-                &connector_name,
-                api::GetToken::Connector,
-                Some(merchant_connector_id.clone()),
-            )?;
-
-            let (should_call_connector, existing_connector_customer_id) =
-                customers::should_call_connector_create_customer(
-                    state,
-                    &connector,
-                    customer,
-                    &merchant_connector_id,
-                );
-
-            if should_call_connector {
-                // Create customer at connector and update the customer table to store this data
-                let router_data = payment_data
-                    .construct_router_data(
-                        state,
-                        connector.connector.id(),
-                        merchant_context,
-                        customer,
-                        merchant_connector_account,
-                        None,
-                        None,
-                    )
-                    .await?;
-
-                let connector_customer_id = router_data
-                    .create_connector_customer(state, &connector)
-                    .await?;
-
-                let customer_update = customers::update_connector_customer_in_customers(
-                    merchant_connector_id,
-                    customer.as_ref(),
-                    connector_customer_id.clone(),
-                )
-                .await;
-
-                payment_data.set_connector_customer_id(connector_customer_id);
-                Ok(customer_update)
-            } else {
-                // Customer already created in previous calls use the same value, no need to update
-                payment_data.set_connector_customer_id(
-                    existing_connector_customer_id.map(ToOwned::to_owned),
-                );
-                Ok(None)
-            }
-        }
-        None => {
-            router_env::logger::warn!(
-                "merchant_connector_account is missing, skipping customer creation"
-            );
-            Ok(None)
-        }
-    }
-}
-
-#[cfg(feature = "v2")]
-pub async fn generate_vault_session_details(
-    state: &SessionState,
-    merchant_context: &domain::MerchantContext,
-    merchant_connector_account_type: &payment_helpers::MerchantConnectorAccountType,
-    profile: &domain::Profile,
-    connector_customer_id: Option<String>,
-) -> RouterResult<Option<api::VaultSessionDetails>> {
-    let connector_name = merchant_connector_account_type
-        .get_connector_name()
-        .map(|name| name.to_string())
-        .unwrap_or_default(); // should not panic since we should always have a connector name
-    let connector = api_enums::VaultConnectors::from_str(&connector_name)
-        .map_err(|_| errors::ApiErrorResponse::InternalServerError)?;
-    let connector_auth_type: router_types::ConnectorAuthType = merchant_connector_account_type
-        .get_connector_account_details()
-        .parse_value("ConnectorAuthType")
-        .change_context(errors::ApiErrorResponse::InternalServerError)?;
-
-    match (connector, connector_auth_type) {
-        // create session for vgs vault
-        (
-            api_enums::VaultConnectors::Vgs,
-            router_types::ConnectorAuthType::SignatureKey { api_secret, .. },
-        ) => {
-            let sdk_env = match state.conf.env {
-                Env::Sandbox | Env::Development => "sandbox",
-                Env::Production => "live",
-            }
-            .to_string();
-            Ok(Some(api::VaultSessionDetails::Vgs(
-                api::VgsSessionDetails {
-                    external_vault_id: api_secret,
-                    sdk_env,
-                },
-            )))
-        }
-        // create session for hyperswitch vault
-        (
-            api_enums::VaultConnectors::HyperswitchVault,
-            router_types::ConnectorAuthType::SignatureKey {
-                key1, api_secret, ..
-            },
-        ) => {
-            let connector_data: api::ConnectorData = api::ConnectorData::get_connector_by_name(
-                &state.conf.connectors,
-                &connector_name,
-                api::GetToken::Connector,
-                merchant_connector_account_type.get_mca_id(),
-            )?;
-
-            let connector_response = call_external_vault_create(
-                state,
-                merchant_context,
-                &connector_data,
-                merchant_connector_account_type,
-                connector_customer_id,
-            )
-            .await?;
-
-            match connector_response.response {
-                Ok(router_types::VaultResponseData::ExternalVaultCreateResponse {
-                    session_id,
-                    client_secret,
-                }) => Ok(Some(api::VaultSessionDetails::HyperswitchVault(
-                    api::HyperswitchVaultSessionDetails {
-                        payment_method_session_id: session_id,
-                        client_secret,
-                        publishable_key: key1,
-                        profile_id: api_secret,
-                    },
-                ))),
-                Ok(res) => {
-                    router_env::logger::warn!("Unexpected response from external vault create API");
-                    Ok(None)
-                }
-                Err(_) => {
-                    router_env::logger::error!(
-                        "Failed to create external vault session for connector: {}",
-                        connector_name
-                    );
-                    Err(errors::ApiErrorResponse::InternalServerError.into())
-                }
-            }
-        }
-        _ => {
-            router_env::logger::warn!(
-                "External vault session creation is not supported for connector: {}",
-                connector_name
-            );
-            Ok(None)
-        }
-    }
-}
-
-#[cfg(feature = "v2")]
-async fn call_external_vault_create(
-    state: &SessionState,
-    merchant_context: &domain::MerchantContext,
-    connector_data: &api::ConnectorData,
-    merchant_connector_account_type: &payment_helpers::MerchantConnectorAccountType,
-    connector_customer_id: Option<String>,
-) -> RouterResult<VaultRouterData<ExternalVaultCreateFlow>>
-where
-    dyn ConnectorTrait + Sync: services::api::ConnectorIntegration<
-        ExternalVaultCreateFlow,
-        router_types::VaultRequestData,
-        router_types::VaultResponseData,
-    >,
-    dyn ConnectorV2 + Sync: ConnectorIntegrationV2<
-        ExternalVaultCreateFlow,
-        VaultConnectorFlowData,
-        router_types::VaultRequestData,
-        router_types::VaultResponseData,
-    >,
-{
-    let mut router_data = core_utils::construct_vault_router_data(
-        state,
-        merchant_context.get_merchant_account(),
-        merchant_connector_account_type,
-        None,
-        None,
-        connector_customer_id,
-    )
-    .await?;
-
-    let mut old_router_data = VaultConnectorFlowData::to_old_router_data(router_data)
-        .change_context(errors::ApiErrorResponse::InternalServerError)
-        .attach_printable(
-            "Cannot construct router data for making the external vault create api call",
-        )?;
-
-    let connector_integration: services::BoxedVaultConnectorIntegrationInterface<
-        ExternalVaultCreateFlow,
-        router_types::VaultRequestData,
-        router_types::VaultResponseData,
-    > = connector_data.connector.get_connector_integration();
-    services::execute_connector_processing_step(
-        state,
-        connector_integration,
-        &old_router_data,
-        CallConnectorAction::Trigger,
-        None,
-        None,
-    )
-    .await
-    .to_vault_failed_response()
-}