resolved comments

Author: Akshay S

crates/diesel_models/src/kv.rs

@@ -112,7 +112,7 @@ impl DBOperation {
                     a.orig.update_with_attempt_id(conn, a.update_data).await?,
                 )),
                 Updateable::MandateUpdate(m) => DBResult::Mandate(Box::new(
-                    Mandate::update_by_merchant_id_mandate_id_drainer(
+                    Mandate::update_by_merchant_id_mandate_id(
                         conn,
                         &m.orig.merchant_id,
                         &m.orig.mandate_id,

crates/diesel_models/src/mandate.rs

@@ -182,36 +182,36 @@ impl MandateUpdateInternal {
     }
 }
 
-impl MandateNew {
-    pub fn from_new(&self) -> Mandate {
+impl From<&MandateNew> for Mandate{
+    fn from(mandate_new : &MandateNew) -> Mandate {
         Mandate {
             id: 0i32,
-            mandate_id: self.mandate_id.clone(),
-            customer_id: self.customer_id.clone(),
-            merchant_id: self.merchant_id.clone(),
-            payment_method_id: self.payment_method_id.clone(),
-            mandate_status: self.mandate_status.clone(),
-            mandate_type: self.mandate_type.clone(),
-            customer_accepted_at: self.customer_accepted_at.clone(),
-            customer_ip_address: self.customer_ip_address.clone(),
-            customer_user_agent: self.customer_user_agent.clone(),
-            network_transaction_id: self.network_transaction_id.clone(),
-            previous_attempt_id: self.previous_attempt_id.clone(),
-            created_at: self
+            mandate_id: mandate_new.mandate_id.clone(),
+            customer_id: mandate_new.customer_id.clone(),
+            merchant_id: mandate_new.merchant_id.clone(),
+            payment_method_id: mandate_new.payment_method_id.clone(),
+            mandate_status: mandate_new.mandate_status.clone(),
+            mandate_type: mandate_new.mandate_type.clone(),
+            customer_accepted_at: mandate_new.customer_accepted_at.clone(),
+            customer_ip_address: mandate_new.customer_ip_address.clone(),
+            customer_user_agent: mandate_new.customer_user_agent.clone(),
+            network_transaction_id: mandate_new.network_transaction_id.clone(),
+            previous_attempt_id: mandate_new.previous_attempt_id.clone(),
+            created_at: mandate_new
                 .created_at
                 .clone()
                 .unwrap_or_else(common_utils::date_time::now),
-            mandate_amount: self.mandate_amount.clone(),
-            mandate_currency: self.mandate_currency.clone(),
-            amount_captured: self.amount_captured.clone(),
-            connector: self.connector.clone(),
-            connector_mandate_id: self.connector_mandate_id.clone(),
-            start_date: self.start_date.clone(),
-            end_date: self.end_date.clone(),
-            metadata: self.metadata.clone(),
-            connector_mandate_ids: self.connector_mandate_ids.clone(),
-            original_payment_id: self.original_payment_id.clone(),
-            merchant_connector_id: self.merchant_connector_id.clone(),
+            mandate_amount: mandate_new.mandate_amount.clone(),
+            mandate_currency: mandate_new.mandate_currency.clone(),
+            amount_captured: mandate_new.amount_captured.clone(),
+            connector: mandate_new.connector.clone(),
+            connector_mandate_id: mandate_new.connector_mandate_id.clone(),
+            start_date: mandate_new.start_date.clone(),
+            end_date: mandate_new.end_date.clone(),
+            metadata: mandate_new.metadata.clone(),
+            connector_mandate_ids: mandate_new.connector_mandate_ids.clone(),
+            original_payment_id: mandate_new.original_payment_id.clone(),
+            merchant_connector_id: mandate_new.merchant_connector_id.clone(),
         }
     }
 }

crates/diesel_models/src/query/mandate.rs

@@ -62,28 +62,6 @@ impl Mandate {
     }
 
     pub async fn update_by_merchant_id_mandate_id(
-        conn: &PgPooledConn,
-        merchant_id: &str,
-        mandate_id: &str,
-        mandate: MandateUpdate,
-    ) -> StorageResult<Self> {
-        generics::generic_update_with_results::<<Self as HasTable>::Table, _, _, _>(
-            conn,
-            dsl::merchant_id
-                .eq(merchant_id.to_owned())
-                .and(dsl::mandate_id.eq(mandate_id.to_owned())),
-            MandateUpdateInternal::from(mandate),
-        )
-        .await?
-        .first()
-        .cloned()
-        .ok_or_else(|| {
-            report!(errors::DatabaseError::NotFound)
-                .attach_printable("Error while updating mandate")
-        })
-    }
-
-    pub async fn update_by_merchant_id_mandate_id_drainer(
         conn: &PgPooledConn,
         merchant_id: &str,
         mandate_id: &str,

crates/router/src/db/mandate.rs

@@ -170,7 +170,7 @@ impl MandateInterface for Store {
 
         match storage_scheme{
             MerchantStorageScheme::PostgresOnly => {
-                storage::Mandate::update_by_merchant_id_mandate_id(&conn, merchant_id, mandate_id, mandate_update)
+                storage::Mandate::update_by_merchant_id_mandate_id(&conn, merchant_id, mandate_id, storage::MandateUpdateInternal::from(mandate_update))
                 .await
                 .map_err(|error| report!(errors::StorageError::from(error)))
             },
@@ -265,7 +265,7 @@ impl MandateInterface for Store {
                 let key = format!("mid_{}_mandate_{}", mandate.merchant_id, mandate_id);
                 let field = format!("mandate_{}", mandate_id);
 
-                let storage_mandate = mandate.from_new();
+                let storage_mandate = storage::Mandate::from(&mandate);
 
                 let redis_entry = kv::TypedSql {
                     op: kv::DBOperation::Insert {
@@ -364,7 +364,7 @@ impl MandateInterface for Store {
         mandate: storage::MandateUpdate,
     ) -> CustomResult<storage::Mandate, errors::StorageError> {
         let conn = connection::pg_connection_write(self).await?;
-        storage::Mandate::update_by_merchant_id_mandate_id(&conn, merchant_id, mandate_id, mandate)
+        storage::Mandate::update_by_merchant_id_mandate_id(&conn, merchant_id, mandate_id, storage::MandateUpdateInternal::from(mandate))
             .await
             .map_err(|error| report!(errors::StorageError::from(error)))
     }