feat(core): store customer_acceptance in the payment_methods table (#3885)

Author: Aprabhat19

crates/api_models/src/payments.rs

@@ -348,9 +348,12 @@ pub struct PaymentsRequest {
     #[remove_in(PaymentsUpdateRequest, PaymentsCreateRequest)]
     pub client_secret: Option<String>,
 
-    /// Passing this object during payments creates a mandate. The mandate_type sub object is passed by the server usually and the customer_acceptance sub object is usually passed by the SDK or client
+    /// Passing this object during payments creates a mandate. The mandate_type sub object is passed by the server.
     pub mandate_data: Option<MandateData>,
 
+    /// Passing this object during payments confirm . The customer_acceptance sub object is usually passed by the SDK or client
+    pub customer_acceptance: Option<CustomerAcceptance>,
+
     /// A unique identifier to link the payment to a mandate. To do Recurring payments after a mandate has been created, pass the mandate_id instead of payment_method_data
     #[schema(max_length = 255, example = "mandate_iwer89rnjef349dni3")]
     #[remove_in(PaymentsUpdateRequest)]

crates/common_enums/src/enums.rs

@@ -1145,8 +1145,8 @@ pub enum IntentStatus {
 #[serde(rename_all = "snake_case")]
 #[strum(serialize_all = "snake_case")]
 pub enum FutureUsage {
-    #[default]
     OffSession,
+    #[default]
     OnSession,
 }
 

crates/data_models/src/mandates.rs

@@ -113,6 +113,16 @@ impl From<ApiCustomerAcceptance> for CustomerAcceptance {
     }
 }
 
+impl From<CustomerAcceptance> for ApiCustomerAcceptance {
+    fn from(value: CustomerAcceptance) -> Self {
+        Self {
+            acceptance_type: value.acceptance_type.into(),
+            accepted_at: value.accepted_at,
+            online: value.online.map(|d| d.into()),
+        }
+    }
+}
+
 impl From<ApiAcceptanceType> for AcceptanceType {
     fn from(value: ApiAcceptanceType) -> Self {
         match value {
@@ -121,6 +131,14 @@ impl From<ApiAcceptanceType> for AcceptanceType {
         }
     }
 }
+impl From<AcceptanceType> for ApiAcceptanceType {
+    fn from(value: AcceptanceType) -> Self {
+        match value {
+            AcceptanceType::Online => Self::Online,
+            AcceptanceType::Offline => Self::Offline,
+        }
+    }
+}
 
 impl From<ApiOnlineMandate> for OnlineMandate {
     fn from(value: ApiOnlineMandate) -> Self {
@@ -130,6 +148,14 @@ impl From<ApiOnlineMandate> for OnlineMandate {
         }
     }
 }
+impl From<OnlineMandate> for ApiOnlineMandate {
+    fn from(value: OnlineMandate) -> Self {
+        Self {
+            ip_address: value.ip_address,
+            user_agent: value.user_agent,
+        }
+    }
+}
 
 impl CustomerAcceptance {
     pub fn get_ip_address(&self) -> Option<String> {

crates/router/src/core/mandate.rs

@@ -495,4 +495,5 @@ pub trait MandateBehaviour {
     fn set_mandate_id(&mut self, new_mandate_id: Option<api_models::payments::MandateIds>);
     fn get_payment_method_data(&self) -> api_models::payments::PaymentMethodData;
     fn get_setup_mandate_details(&self) -> Option<&data_models::mandates::MandateData>;
+    fn get_customer_acceptance(&self) -> Option<api_models::payments::CustomerAcceptance>;
 }

crates/router/src/core/payment_methods/cards.rs

@@ -81,6 +81,7 @@ pub async fn create_payment_method(
     locker_id: Option<String>,
     merchant_id: &str,
     pm_metadata: Option<serde_json::Value>,
+    customer_acceptance: Option<serde_json::Value>,
     payment_method_data: Option<Encryption>,
     key_store: &domain::MerchantKeyStore,
 ) -> errors::CustomResult<storage::PaymentMethod, errors::ApiErrorResponse> {
@@ -100,6 +101,7 @@ pub async fn create_payment_method(
             scheme: req.card_network.clone(),
             metadata: pm_metadata.map(masking::Secret::new),
             payment_method_data,
+            customer_acceptance: customer_acceptance.map(masking::Secret::new),
             ..storage::PaymentMethodNew::default()
         })
         .await
@@ -183,6 +185,7 @@ pub async fn get_or_insert_payment_method(
                     &merchant_account.merchant_id,
                     customer_id,
                     resp.metadata.clone().map(|val| val.expose()),
+                    None,
                     locker_id,
                 )
                 .await
@@ -367,6 +370,7 @@ pub async fn add_payment_method(
                 merchant_id,
                 &customer_id,
                 pm_metadata.cloned(),
+                None,
                 locker_id,
             )
             .await?;
@@ -385,6 +389,7 @@ pub async fn insert_payment_method(
     merchant_id: &str,
     customer_id: &str,
     pm_metadata: Option<serde_json::Value>,
+    customer_acceptance: Option<serde_json::Value>,
     locker_id: Option<String>,
 ) -> errors::RouterResult<diesel_models::PaymentMethod> {
     let pm_card_details = resp
@@ -400,6 +405,7 @@ pub async fn insert_payment_method(
         locker_id,
         merchant_id,
         pm_metadata,
+        customer_acceptance,
         pm_data_encrypted,
         key_store,
     )

crates/router/src/core/payments.rs

@@ -15,7 +15,7 @@ use std::{fmt::Debug, marker::PhantomData, ops::Deref, time::Instant, vec::IntoI
 
 use api_models::{self, enums, payments::HeaderPayload};
 use common_utils::{ext_traits::AsyncExt, pii, types::Surcharge};
-use data_models::mandates::MandateData;
+use data_models::mandates::{CustomerAcceptance, MandateData};
 use diesel_models::{ephemeral_key, fraud_check::FraudCheck};
 use error_stack::{IntoReport, ResultExt};
 use futures::future::join_all;
@@ -2050,6 +2050,7 @@ where
     pub mandate_connector: Option<MandateConnectorDetails>,
     pub currency: storage_enums::Currency,
     pub setup_mandate: Option<MandateData>,
+    pub customer_acceptance: Option<CustomerAcceptance>,
     pub address: PaymentAddress,
     pub token: Option<String>,
     pub confirm: Option<bool>,

crates/router/src/core/payments/flows/authorize_flow.rs

@@ -99,7 +99,6 @@ impl Feature<api::Authorize, types::PaymentsAuthorizeData> for types::PaymentsAu
                     merchant_account,
                     self.request.payment_method_type,
                     key_store,
-                    is_mandate,
                 ))
                 .await?;
                 Ok(mandate::mandate_procedure(
@@ -131,7 +130,6 @@ impl Feature<api::Authorize, types::PaymentsAuthorizeData> for types::PaymentsAu
                         &merchant_account,
                         self.request.payment_method_type,
                         &key_store,
-                        is_mandate,
                     ))
                     .await;
 
@@ -294,6 +292,9 @@ impl mandate::MandateBehaviour for types::PaymentsAuthorizeData {
     fn set_mandate_id(&mut self, new_mandate_id: Option<api_models::payments::MandateIds>) {
         self.mandate_id = new_mandate_id;
     }
+    fn get_customer_acceptance(&self) -> Option<api_models::payments::CustomerAcceptance> {
+        self.customer_acceptance.clone().map(From::from)
+    }
 }
 
 pub async fn authorize_preprocessing_steps<F: Clone>(

crates/router/src/core/payments/flows/setup_mandate_flow.rs

@@ -98,7 +98,7 @@ impl Feature<api::SetupMandate, types::SetupMandateRequestData> for types::Setup
             )
             .await
             .to_setup_mandate_failed_response()?;
-            let is_mandate = resp.request.setup_mandate_details.is_some();
+
             let pm_id = Box::pin(tokenization::save_payment_method(
                 state,
                 connector,
@@ -107,7 +107,6 @@ impl Feature<api::SetupMandate, types::SetupMandateRequestData> for types::Setup
                 merchant_account,
                 self.request.payment_method_type,
                 key_store,
-                is_mandate,
             ))
             .await?;
             mandate::mandate_procedure(
@@ -234,8 +233,6 @@ impl types::SetupMandateRouterData {
 
                 let payment_method_type = self.request.payment_method_type;
 
-                let is_mandate = resp.request.setup_mandate_details.is_some();
-
                 let pm_id = Box::pin(tokenization::save_payment_method(
                     state,
                     connector,
@@ -244,7 +241,6 @@ impl types::SetupMandateRouterData {
                     merchant_account,
                     payment_method_type,
                     key_store,
-                    is_mandate,
                 ))
                 .await?;
 
@@ -320,7 +316,6 @@ impl types::SetupMandateRouterData {
             )
             .await
             .to_setup_mandate_failed_response()?;
-            let is_mandate = resp.request.setup_mandate_details.is_some();
             let pm_id = Box::pin(tokenization::save_payment_method(
                 state,
                 connector,
@@ -329,7 +324,6 @@ impl types::SetupMandateRouterData {
                 merchant_account,
                 self.request.payment_method_type,
                 key_store,
-                is_mandate,
             ))
             .await?;
             let mandate = state
@@ -430,6 +424,9 @@ impl mandate::MandateBehaviour for types::SetupMandateRequestData {
     fn get_setup_mandate_details(&self) -> Option<&data_models::mandates::MandateData> {
         self.setup_mandate_details.as_ref()
     }
+    fn get_customer_acceptance(&self) -> Option<api_models::payments::CustomerAcceptance> {
+        self.customer_acceptance.clone().map(From::from)
+    }
 }
 
 impl TryFrom<types::SetupMandateRequestData> for types::PaymentMethodTokenizationData {

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

@@ -825,16 +825,6 @@ fn validate_new_mandate_request(
         .clone()
         .get_required_value("mandate_data")?;
 
-    if api_enums::FutureUsage::OnSession
-        == req
-            .setup_future_usage
-            .get_required_value("setup_future_usage")?
-    {
-        Err(report!(errors::ApiErrorResponse::PreconditionFailed {
-            message: "`setup_future_usage` must be `off_session` for mandates".into()
-        }))?
-    };
-
     // Only use this validation if the customer_acceptance is present
     if mandate_data
         .customer_acceptance
@@ -3862,3 +3852,17 @@ pub fn validate_session_expiry(session_expiry: u32) -> Result<(), errors::ApiErr
         Ok(())
     }
 }
+
+// This function validates the  mandate_data with its setup_future_usage
+pub fn validate_mandate_data_and_future_usage(
+    setup_future_usages: Option<api_enums::FutureUsage>,
+    mandate_details_present: bool,
+) -> Result<(), errors::ApiErrorResponse> {
+    if Some(api_enums::FutureUsage::OnSession) == setup_future_usages && mandate_details_present {
+        Err(errors::ApiErrorResponse::PreconditionFailed {
+            message: "`setup_future_usage` must be `off_session` for mandates".into(),
+        })
+    } else {
+        Ok(())
+    }
+}

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

@@ -147,6 +147,7 @@ impl<F: Send + Clone, Ctx: PaymentMethodRetrieve>
             mandate_id: None,
             mandate_connector: None,
             setup_mandate: None,
+            customer_acceptance: None,
             token: None,
             address: PaymentAddress {
                 shipping: shipping_address.as_ref().map(|a| a.into()),