feat(payment_methods): added kv support for payment_methods table (#4311)

Co-authored-by: Akshay S <[email protected]>
Co-authored-by: hyperswitch-bot[bot] <148525504+hyperswitch-bot[bot]@users.noreply.github.com>

Author: 3 people

crates/diesel_models/src/kv.rs

@@ -10,7 +10,7 @@ use crate::{
     payouts::{Payouts, PayoutsNew, PayoutsUpdate},
     refund::{Refund, RefundNew, RefundUpdate},
     reverse_lookup::{ReverseLookup, ReverseLookupNew},
-    PaymentIntent, PgPooledConn,
+    PaymentIntent, PaymentMethod, PaymentMethodNew, PaymentMethodUpdateInternal, PgPooledConn,
 };
 
 #[derive(Debug, Serialize, Deserialize)]
@@ -37,6 +37,7 @@ impl DBOperation {
                 Insertable::Payouts(_) => "payouts",
                 Insertable::PayoutAttempt(_) => "payout_attempt",
                 Insertable::ReverseLookUp(_) => "reverse_lookup",
+                Insertable::PaymentMethod(_) => "payment_method",
             },
             Self::Update { updatable } => match updatable {
                 Updateable::PaymentIntentUpdate(_) => "payment_intent",
@@ -45,6 +46,7 @@ impl DBOperation {
                 Updateable::AddressUpdate(_) => "address",
                 Updateable::PayoutsUpdate(_) => "payouts",
                 Updateable::PayoutAttemptUpdate(_) => "payout_attempt",
+                Updateable::PaymentMethodUpdate(_) => "payment_method",
             },
         }
     }
@@ -59,6 +61,7 @@ pub enum DBResult {
     ReverseLookUp(Box<ReverseLookup>),
     Payouts(Box<Payouts>),
     PayoutAttempt(Box<PayoutAttempt>),
+    PaymentMethod(Box<PaymentMethod>),
 }
 
 #[derive(Debug, Serialize, Deserialize)]
@@ -86,6 +89,9 @@ impl DBOperation {
                 Insertable::PayoutAttempt(rev) => {
                     DBResult::PayoutAttempt(Box::new(rev.insert(conn).await?))
                 }
+                Insertable::PaymentMethod(rev) => {
+                    DBResult::PaymentMethod(Box::new(rev.insert(conn).await?))
+                }
             },
             Self::Update { updatable } => match updatable {
                 Updateable::PaymentIntentUpdate(a) => {
@@ -106,6 +112,11 @@ impl DBOperation {
                 Updateable::PayoutAttemptUpdate(a) => DBResult::PayoutAttempt(Box::new(
                     a.orig.update_with_attempt_id(conn, a.update_data).await?,
                 )),
+                Updateable::PaymentMethodUpdate(v) => DBResult::PaymentMethod(Box::new(
+                    v.orig
+                        .update_with_payment_method_id(conn, v.update_data)
+                        .await?,
+                )),
             },
         })
     }
@@ -142,6 +153,7 @@ pub enum Insertable {
     ReverseLookUp(ReverseLookupNew),
     Payouts(PayoutsNew),
     PayoutAttempt(PayoutAttemptNew),
+    PaymentMethod(PaymentMethodNew),
 }
 
 #[derive(Debug, Serialize, Deserialize)]
@@ -153,6 +165,7 @@ pub enum Updateable {
     AddressUpdate(Box<AddressUpdateMems>),
     PayoutsUpdate(PayoutsUpdateMems),
     PayoutAttemptUpdate(PayoutAttemptUpdateMems),
+    PaymentMethodUpdate(PaymentMethodUpdateMems),
 }
 
 #[derive(Debug, Serialize, Deserialize)]
@@ -190,3 +203,9 @@ pub struct PayoutAttemptUpdateMems {
     pub orig: PayoutAttempt,
     pub update_data: PayoutAttemptUpdate,
 }
+
+#[derive(Debug, Serialize, Deserialize)]
+pub struct PaymentMethodUpdateMems {
+    pub orig: PaymentMethod,
+    pub update_data: PaymentMethodUpdateInternal,
+}

crates/diesel_models/src/payment_method.rs

@@ -6,7 +6,7 @@ use time::PrimitiveDateTime;
 
 use crate::{encryption::Encryption, enums as storage_enums, schema::payment_methods};
 
-#[derive(Clone, Debug, Eq, PartialEq, Identifiable, Queryable)]
+#[derive(Clone, Debug, Eq, PartialEq, Identifiable, Queryable, Serialize, Deserialize)]
 #[diesel(table_name = payment_methods)]
 pub struct PaymentMethod {
     pub id: i32,
@@ -41,7 +41,9 @@ pub struct PaymentMethod {
     pub network_transaction_id: Option<String>,
 }
 
-#[derive(Clone, Debug, Eq, PartialEq, Insertable, router_derive::DebugAsDisplay)]
+#[derive(
+    Clone, Debug, Eq, PartialEq, Insertable, router_derive::DebugAsDisplay, Serialize, Deserialize,
+)]
 #[diesel(table_name = payment_methods)]
 pub struct PaymentMethodNew {
     pub customer_id: String,
@@ -138,7 +140,9 @@ pub enum PaymentMethodUpdate {
     },
 }
 
-#[derive(Clone, Debug, Default, AsChangeset, router_derive::DebugAsDisplay)]
+#[derive(
+    Clone, Debug, Default, AsChangeset, router_derive::DebugAsDisplay, Serialize, Deserialize,
+)]
 #[diesel(table_name = payment_methods)]
 pub struct PaymentMethodUpdateInternal {
     metadata: Option<serde_json::Value>,
@@ -155,6 +159,29 @@ impl PaymentMethodUpdateInternal {
 
         PaymentMethod { metadata, ..source }
     }
+
+    pub fn apply_changeset(self, source: PaymentMethod) -> PaymentMethod {
+        let Self {
+            metadata,
+            payment_method_data,
+            last_used_at,
+            network_transaction_id,
+            status,
+            connector_mandate_details,
+        } = self;
+
+        PaymentMethod {
+            metadata: metadata.map_or(source.metadata, |v| Some(v.into())),
+            payment_method_data: payment_method_data.map_or(source.payment_method_data, Some),
+            last_used_at: last_used_at.unwrap_or(source.last_used_at),
+            network_transaction_id: network_transaction_id
+                .map_or(source.network_transaction_id, Some),
+            status: status.unwrap_or(source.status),
+            connector_mandate_details: connector_mandate_details
+                .map_or(source.connector_mandate_details, Some),
+            ..source
+        }
+    }
 }
 
 impl From<PaymentMethodUpdate> for PaymentMethodUpdateInternal {
@@ -218,3 +245,38 @@ impl From<PaymentMethodUpdate> for PaymentMethodUpdateInternal {
         }
     }
 }
+
+impl From<&PaymentMethodNew> for PaymentMethod {
+    fn from(payment_method_new: &PaymentMethodNew) -> Self {
+        Self {
+            id: 0i32,
+            customer_id: payment_method_new.customer_id.clone(),
+            merchant_id: payment_method_new.merchant_id.clone(),
+            payment_method_id: payment_method_new.payment_method_id.clone(),
+            locker_id: payment_method_new.locker_id.clone(),
+            accepted_currency: payment_method_new.accepted_currency.clone(),
+            scheme: payment_method_new.scheme.clone(),
+            token: payment_method_new.token.clone(),
+            cardholder_name: payment_method_new.cardholder_name.clone(),
+            issuer_name: payment_method_new.issuer_name.clone(),
+            issuer_country: payment_method_new.issuer_country.clone(),
+            payer_country: payment_method_new.payer_country.clone(),
+            is_stored: payment_method_new.is_stored,
+            swift_code: payment_method_new.swift_code.clone(),
+            direct_debit_token: payment_method_new.direct_debit_token.clone(),
+            created_at: payment_method_new.created_at,
+            last_modified: payment_method_new.last_modified,
+            payment_method: payment_method_new.payment_method,
+            payment_method_type: payment_method_new.payment_method_type,
+            payment_method_issuer: payment_method_new.payment_method_issuer.clone(),
+            payment_method_issuer_code: payment_method_new.payment_method_issuer_code,
+            metadata: payment_method_new.metadata.clone(),
+            payment_method_data: payment_method_new.payment_method_data.clone(),
+            last_used_at: payment_method_new.last_used_at,
+            connector_mandate_details: payment_method_new.connector_mandate_details.clone(),
+            customer_acceptance: payment_method_new.customer_acceptance.clone(),
+            status: payment_method_new.status,
+            network_transaction_id: payment_method_new.network_transaction_id.clone(),
+        }
+    }
+}

crates/diesel_models/src/query/payment_method.rs

@@ -151,7 +151,7 @@ impl PaymentMethod {
     pub async fn update_with_payment_method_id(
         self,
         conn: &PgPooledConn,
-        payment_method: payment_method::PaymentMethodUpdate,
+        payment_method: payment_method::PaymentMethodUpdateInternal,
     ) -> StorageResult<Self> {
         match generics::generic_update_with_unique_predicate_get_result::<
             <Self as HasTable>::Table,
@@ -161,7 +161,7 @@ impl PaymentMethod {
         >(
             conn,
             dsl::payment_method_id.eq(self.payment_method_id.to_owned()),
-            payment_method::PaymentMethodUpdateInternal::from(payment_method),
+            payment_method,
         )
         .await
         {

crates/router/src/core/mandate.rs

@@ -43,7 +43,13 @@ pub async fn get_mandate(
         .await
         .to_not_found_response(errors::ApiErrorResponse::MandateNotFound)?;
     Ok(services::ApplicationResponse::Json(
-        mandates::MandateResponse::from_db_mandate(&state, key_store, mandate).await?,
+        mandates::MandateResponse::from_db_mandate(
+            &state,
+            key_store,
+            mandate,
+            merchant_account.storage_scheme,
+        )
+        .await?,
     ))
 }
 
@@ -226,8 +232,13 @@ pub async fn get_customer_mandates(
         let mut response_vec = Vec::with_capacity(mandates.len());
         for mandate in mandates {
             response_vec.push(
-                mandates::MandateResponse::from_db_mandate(&state, key_store.clone(), mandate)
-                    .await?,
+                mandates::MandateResponse::from_db_mandate(
+                    &state,
+                    key_store.clone(),
+                    mandate,
+                    merchant_account.storage_scheme,
+                )
+                .await?,
             );
         }
         Ok(services::ApplicationResponse::Json(response_vec))
@@ -471,7 +482,12 @@ pub async fn retrieve_mandates_list(
         .change_context(errors::ApiErrorResponse::InternalServerError)
         .attach_printable("Unable to retrieve mandates")?;
     let mandates_list = future::try_join_all(mandates.into_iter().map(|mandate| {
-        mandates::MandateResponse::from_db_mandate(&state, key_store.clone(), mandate)
+        mandates::MandateResponse::from_db_mandate(
+            &state,
+            key_store.clone(),
+            mandate,
+            merchant_account.storage_scheme,
+        )
     }))
     .await?;
     Ok(services::ApplicationResponse::Json(mandates_list))

crates/router/src/core/payment_methods.rs

@@ -38,6 +38,7 @@ pub trait PaymentMethodRetrieve {
         payment_intent: &PaymentIntent,
         card_token_data: Option<&CardToken>,
         customer: &Option<domain::Customer>,
+        storage_scheme: common_enums::enums::MerchantStorageScheme,
     ) -> RouterResult<storage::PaymentMethodDataWithId>;
 }
 
@@ -122,6 +123,7 @@ impl PaymentMethodRetrieve for Oss {
         payment_intent: &PaymentIntent,
         card_token_data: Option<&CardToken>,
         customer: &Option<domain::Customer>,
+        storage_scheme: common_enums::enums::MerchantStorageScheme,
     ) -> RouterResult<storage::PaymentMethodDataWithId> {
         let token = match token_data {
             storage::PaymentTokenData::TemporaryGeneric(generic_token) => {
@@ -172,6 +174,8 @@ impl PaymentMethodRetrieve for Oss {
                         .unwrap_or(&card_token.token),
                     payment_intent,
                     card_token_data,
+                    merchant_key_store,
+                    storage_scheme,
                 )
                 .await
                 .map(|card| Some((card, enums::PaymentMethod::Card)))?
@@ -201,6 +205,8 @@ impl PaymentMethodRetrieve for Oss {
                         .unwrap_or(&card_token.token),
                     payment_intent,
                     card_token_data,
+                    merchant_key_store,
+                    storage_scheme,
                 )
                 .await
                 .map(|card| Some((card, enums::PaymentMethod::Card)))?