feat. added kv support for payment method

Author: Akshay S

crates/diesel_models/src/kv.rs

@@ -11,6 +11,7 @@ use crate::{
     refund::{Refund, RefundNew, RefundUpdate},
     reverse_lookup::{ReverseLookup, ReverseLookupNew},
     PaymentIntent, PgPooledConn,
+    PaymentMethod, PaymentMethodNew, PaymentMethodUpdateInternal,
 };
 
 #[derive(Debug, Serialize, Deserialize)]
@@ -37,6 +38,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 +47,7 @@ impl DBOperation {
                 Updateable::AddressUpdate(_) => "address",
                 Updateable::PayoutsUpdate(_) => "payouts",
                 Updateable::PayoutAttemptUpdate(_) => "payout_attempt",
+                Updateable::PaymentMethodUpdate(_) => "payment_method",
             },
         }
     }
@@ -59,6 +62,7 @@ pub enum DBResult {
     ReverseLookUp(Box<ReverseLookup>),
     Payouts(Box<Payouts>),
     PayoutAttempt(Box<PayoutAttempt>),
+    PaymentMethod(Box<PaymentMethod>),
 }
 
 #[derive(Debug, Serialize, Deserialize)]
@@ -86,6 +90,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 +113,9 @@ 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 +152,7 @@ pub enum Insertable {
     ReverseLookUp(ReverseLookupNew),
     Payouts(PayoutsNew),
     PayoutAttempt(PayoutAttemptNew),
+    PaymentMethod(PaymentMethodNew),
 }
 
 #[derive(Debug, Serialize, Deserialize)]
@@ -153,6 +164,7 @@ pub enum Updateable {
     AddressUpdate(Box<AddressUpdateMems>),
     PayoutsUpdate(PayoutsUpdateMems),
     PayoutAttemptUpdate(PayoutAttemptUpdateMems),
+    PaymentMethodUpdate(PaymentMethodUpdateMems),
 }
 
 #[derive(Debug, Serialize, Deserialize)]
@@ -190,3 +202,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,7 @@ 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 +138,7 @@ 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 +155,27 @@ 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, |v| Some(v)),
+            last_used_at : last_used_at.unwrap_or(source.last_used_at),
+            network_transaction_id: network_transaction_id.map_or(source.network_transaction_id, |v| Some(v)),
+            status : status.unwrap_or(source.status),
+            connector_mandate_details : connector_mandate_details.map_or(source.connector_mandate_details, |v| Some(v)),
+            ..source
+        }
+    }
 }
 
 impl From<PaymentMethodUpdate> for PaymentMethodUpdateInternal {
@@ -218,3 +239,39 @@ 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.clone(),
+            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.clone(),
+            last_modified: payment_method_new.last_modified.clone(),
+            payment_method: payment_method_new.payment_method.clone(),
+            payment_method_type: payment_method_new.payment_method_type.clone(),
+            payment_method_issuer: payment_method_new.payment_method_issuer.clone(),
+            payment_method_issuer_code: payment_method_new.payment_method_issuer_code.clone(),
+            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.clone(),
+            connector_mandate_details: payment_method_new.connector_mandate_details.clone(),
+            customer_acceptance: payment_method_new.customer_acceptance.clone(),
+            status: payment_method_new.status.clone(),
+            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,
@@ -172,4 +172,5 @@ impl PaymentMethod {
             result => result,
         }
     }
+
 }

crates/router/src/core/mandate.rs

@@ -43,7 +43,7 @@ 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,7 +226,7 @@ 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)
+                mandates::MandateResponse::from_db_mandate(&state, key_store.clone(), mandate, merchant_account.storage_scheme)
                     .await?,
             );
         }
@@ -471,7 +471,7 @@ 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)))?