refactor(storage_impl): split payment attempt models to domain + diesel (#2010)

Signed-off-by: chikke srujan <[email protected]>
Co-authored-by: Mani Chandra <[email protected]>
Co-authored-by: Arjun Karthik <[email protected]>
Co-authored-by: Sai Harsha Vardhan <[email protected]>
Co-authored-by: Sanchith Hegde <[email protected]>
Co-authored-by: chikke srujan <[email protected]>
Co-authored-by: Prasunna Soppa <[email protected]>
Co-authored-by: github-actions <41898282+github-actions[bot]@users.noreply.github.com>
Co-authored-by: DEEPANSHU BANSAL <[email protected]>
Co-authored-by: Arvind Patel <[email protected]>
Co-authored-by: Jagan Elavarasan <[email protected]>
Co-authored-by: arvindpatel24 <[email protected]>
Co-authored-by: anji-reddy-j <[email protected]>
Co-authored-by: Hrithikesh <[email protected]>
Co-authored-by: Apoorv Dixit <[email protected]>
Co-authored-by: Pa1NarK <[email protected]>

Author: 16 people

Cargo.lock

@@ -15,7 +15,7 @@ diesel = { version = "2.1.0", features = ["postgres"] }
 serde  = { version = "1.0.160", features = [ "derive" ] }
 serde_json = "1.0.96"
 strum  = { version = "0.25", features = [ "derive" ] }
-time = { version = "0.3.20", features = ["serde", "serde-well-known", "std"] }
+time = { version = "0.3.21", features = ["serde", "serde-well-known", "std"] }
 utoipa = { version = "3.3.0", features = ["preserve_order"] }
 
 # First party crates

crates/common_enums/Cargo.toml

@@ -15,6 +15,7 @@ olap = []
 [dependencies]
 # First party deps
 api_models = { version = "0.1.0", path = "../api_models" }
+masking = { version = "0.1.0", path = "../masking" }
 common_enums = { version = "0.1.0", path = "../common_enums" }
 common_utils = { version = "0.1.0", path = "../common_utils" }
 

crates/data_models/Cargo.toml

@@ -1,5 +1,12 @@
+use api_models::payments::{
+    AcceptanceType as ApiAcceptanceType, CustomerAcceptance as ApiCustomerAcceptance,
+    MandateAmountData as ApiMandateAmountData, MandateData as ApiMandateData, MandateType,
+    OnlineMandate as ApiOnlineMandate,
+};
 use common_enums::Currency;
-use common_utils::pii;
+use common_utils::{date_time, errors::ParsingError, pii};
+use error_stack::{IntoReport, ResultExt};
+use masking::{PeekInterface, Secret};
 use time::PrimitiveDateTime;
 
 #[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
@@ -17,3 +24,135 @@ pub struct MandateAmountData {
     pub end_date: Option<PrimitiveDateTime>,
     pub metadata: Option<pii::SecretSerdeValue>,
 }
+
+// The fields on this struct are optional, as we want to allow the merchant to provide partial
+// information about creating mandates
+#[derive(Default, Eq, PartialEq, Debug, Clone)]
+pub struct MandateData {
+    /// A concent from the customer to store the payment method
+    pub customer_acceptance: Option<CustomerAcceptance>,
+    /// A way to select the type of mandate used
+    pub mandate_type: Option<MandateDataType>,
+}
+
+#[derive(Default, Eq, PartialEq, Debug, Clone)]
+pub struct CustomerAcceptance {
+    /// Type of acceptance provided by the
+    pub acceptance_type: AcceptanceType,
+    /// Specifying when the customer acceptance was provided
+    pub accepted_at: Option<PrimitiveDateTime>,
+    /// Information required for online mandate generation
+    pub online: Option<OnlineMandate>,
+}
+
+#[derive(Default, Debug, PartialEq, Eq, Clone)]
+pub enum AcceptanceType {
+    Online,
+    #[default]
+    Offline,
+}
+
+#[derive(Default, Eq, PartialEq, Debug, Clone)]
+pub struct OnlineMandate {
+    /// Ip address of the customer machine from which the mandate was created
+    pub ip_address: Option<Secret<String, pii::IpAddress>>,
+    /// The user-agent of the customer's browser
+    pub user_agent: String,
+}
+
+impl From<MandateType> for MandateDataType {
+    fn from(mandate_type: MandateType) -> Self {
+        match mandate_type {
+            MandateType::SingleUse(mandate_amount_data) => {
+                Self::SingleUse(mandate_amount_data.into())
+            }
+            MandateType::MultiUse(mandate_amount_data) => {
+                Self::MultiUse(mandate_amount_data.map(|d| d.into()))
+            }
+        }
+    }
+}
+
+impl From<ApiMandateAmountData> for MandateAmountData {
+    fn from(value: ApiMandateAmountData) -> Self {
+        Self {
+            amount: value.amount,
+            currency: value.currency,
+            start_date: value.start_date,
+            end_date: value.end_date,
+            metadata: value.metadata,
+        }
+    }
+}
+
+impl From<ApiMandateData> for MandateData {
+    fn from(value: ApiMandateData) -> Self {
+        Self {
+            customer_acceptance: value.customer_acceptance.map(|d| d.into()),
+            mandate_type: value.mandate_type.map(|d| d.into()),
+        }
+    }
+}
+
+impl From<ApiCustomerAcceptance> for CustomerAcceptance {
+    fn from(value: ApiCustomerAcceptance) -> 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 {
+            ApiAcceptanceType::Online => Self::Online,
+            ApiAcceptanceType::Offline => Self::Offline,
+        }
+    }
+}
+
+impl From<ApiOnlineMandate> for OnlineMandate {
+    fn from(value: ApiOnlineMandate) -> Self {
+        Self {
+            ip_address: value.ip_address,
+            user_agent: value.user_agent,
+        }
+    }
+}
+
+impl CustomerAcceptance {
+    pub fn get_ip_address(&self) -> Option<String> {
+        self.online
+            .as_ref()
+            .and_then(|data| data.ip_address.as_ref().map(|ip| ip.peek().to_owned()))
+    }
+
+    pub fn get_user_agent(&self) -> Option<String> {
+        self.online.as_ref().map(|data| data.user_agent.clone())
+    }
+
+    pub fn get_accepted_at(&self) -> PrimitiveDateTime {
+        self.accepted_at
+            .unwrap_or_else(common_utils::date_time::now)
+    }
+}
+
+impl MandateAmountData {
+    pub fn get_end_date(
+        &self,
+        format: date_time::DateFormat,
+    ) -> error_stack::Result<Option<String>, ParsingError> {
+        self.end_date
+            .map(|date| {
+                date_time::format_date(date, format)
+                    .into_report()
+                    .change_context(ParsingError::DateTimeParsingError)
+            })
+            .transpose()
+    }
+    pub fn get_metadata(&self) -> Option<pii::SecretSerdeValue> {
+        self.metadata.clone()
+    }
+}

crates/data_models/src/mandates.rs

@@ -1,3 +1,4 @@
+use api_models::enums::Connector;
 use common_enums as storage_enums;
 use serde::{Deserialize, Serialize};
 use time::PrimitiveDateTime;
@@ -77,6 +78,15 @@ pub trait PaymentAttemptInterface {
         merchant_id: &str,
         storage_scheme: MerchantStorageScheme,
     ) -> error_stack::Result<PaymentListFilters, errors::StorageError>;
+
+    async fn get_total_count_of_filtered_payment_attempts(
+        &self,
+        merchant_id: &str,
+        active_attempt_ids: &[String],
+        connector: Option<Vec<Connector>>,
+        payment_methods: Option<Vec<storage_enums::PaymentMethod>>,
+        storage_scheme: MerchantStorageScheme,
+    ) -> error_stack::Result<i64, errors::StorageError>;
 }
 
 #[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
@@ -129,7 +139,7 @@ pub struct PaymentAttempt {
     pub connector_response_reference_id: Option<String>,
 }
 
-#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub struct PaymentListFilters {
     pub connector: Vec<String>,
     pub currency: Vec<storage_enums::Currency>,
@@ -222,6 +232,13 @@ pub enum PaymentAttemptUpdate {
         payment_experience: Option<storage_enums::PaymentExperience>,
         business_sub_label: Option<String>,
         straight_through_algorithm: Option<serde_json::Value>,
+        error_code: Option<Option<String>>,
+        error_message: Option<Option<String>>,
+    },
+    RejectUpdate {
+        status: storage_enums::AttemptStatus,
+        error_code: Option<Option<String>>,
+        error_message: Option<Option<String>>,
     },
     VoidUpdate {
         status: storage_enums::AttemptStatus,
@@ -261,9 +278,8 @@ pub enum PaymentAttemptUpdate {
         error_message: Option<Option<String>>,
         error_reason: Option<Option<String>>,
     },
-    MultipleCaptureUpdate {
-        status: Option<storage_enums::AttemptStatus>,
-        multiple_capture_count: Option<i16>,
+    MultipleCaptureCountUpdate {
+        multiple_capture_count: i16,
     },
     PreprocessingUpdate {
         status: storage_enums::AttemptStatus,

crates/data_models/src/payments/payment_attempt.rs

@@ -14,7 +14,6 @@ use crate::{
     errors::{self, DatabaseError},
     payment_attempt::{
         PaymentAttempt, PaymentAttemptNew, PaymentAttemptUpdate, PaymentAttemptUpdateInternal,
-        PaymentListFilters,
     },
     payment_intent::PaymentIntent,
     query::generics::db_metrics,
@@ -212,15 +211,20 @@ impl PaymentAttempt {
         conn: &PgPooledConn,
         pi: &[PaymentIntent],
         merchant_id: &str,
-    ) -> StorageResult<PaymentListFilters> {
-        let active_attempt_ids: Vec<String> = pi
+    ) -> StorageResult<(
+        Vec<String>,
+        Vec<enums::Currency>,
+        Vec<IntentStatus>,
+        Vec<enums::PaymentMethod>,
+    )> {
+        let active_attempts: Vec<String> = pi
             .iter()
             .map(|payment_intent| payment_intent.clone().active_attempt_id)
             .collect();
 
         let filter = <Self as HasTable>::table()
             .filter(dsl::merchant_id.eq(merchant_id.to_owned()))
-            .filter(dsl::attempt_id.eq_any(active_attempt_ids));
+            .filter(dsl::attempt_id.eq_any(active_attempts));
 
         let intent_status: Vec<IntentStatus> = pi
             .iter()
@@ -268,14 +272,12 @@ impl PaymentAttempt {
             .flatten()
             .collect::<Vec<enums::PaymentMethod>>();
 
-        let filters = PaymentListFilters {
-            connector: filter_connector,
-            currency: filter_currency,
-            status: intent_status,
-            payment_method: filter_payment_method,
-        };
-
-        Ok(filters)
+        Ok((
+            filter_connector,
+            filter_currency,
+            intent_status,
+            filter_payment_method,
+        ))
     }
     pub async fn get_total_count_of_attempts(
         conn: &PgPooledConn,

crates/diesel_models/src/query/payment_attempt.rs

@@ -4,15 +4,16 @@ use common_utils::{
     date_time, fp_utils, pii,
     pii::Email,
 };
+use data_models::mandates::MandateDataType;
 use error_stack::{IntoReport, ResultExt};
 use masking::{PeekInterface, Secret};
 use reqwest::Url;
 use serde::{Deserialize, Serialize};
 
 use crate::{
     connector::utils::{
-        self, AddressDetailsData, BrowserInformationData, MandateData,
-        PaymentsAuthorizeRequestData, PaymentsCancelRequestData, RouterData,
+        self, AddressDetailsData, BrowserInformationData, PaymentsAuthorizeRequestData,
+        PaymentsCancelRequestData, RouterData,
     },
     consts,
     core::errors,
@@ -790,20 +791,28 @@ fn get_card_info<F>(
                         .change_context(errors::ConnectorError::MissingRequiredField {
                             field_name: "mandate_type",
                         })? {
-                        payments::MandateType::SingleUse(details) => details,
-                        payments::MandateType::MultiUse(details) => {
+                        MandateDataType::SingleUse(details) => details,
+                        MandateDataType::MultiUse(details) => {
                             details.ok_or(errors::ConnectorError::MissingRequiredField {
                                 field_name: "mandate_data.mandate_type.multi_use",
                             })?
                         }
                     };
-                    let mandate_meta: NuveiMandateMeta =
-                        utils::to_connector_meta_from_secret(Some(details.get_metadata()?))?;
+                    let mandate_meta: NuveiMandateMeta = utils::to_connector_meta_from_secret(
+                        Some(details.get_metadata().ok_or_else(utils::missing_field_err(
+                            "mandate_data.mandate_type.{multi_use|single_use}.metadata",
+                        ))?),
+                    )?;
                     (
                         Some("0".to_string()), // In case of first installment, rebilling should be 0
                         Some(V2AdditionalParams {
                             rebill_expiry: Some(
-                                details.get_end_date(date_time::DateFormat::YYYYMMDD)?,
+                                details
+                                    .get_end_date(date_time::DateFormat::YYYYMMDD)
+                                    .change_context(errors::ConnectorError::DateFormattingFailed)?
+                                    .ok_or_else(utils::missing_field_err(
+                                        "mandate_data.mandate_type.{multi_use|single_use}.end_date",
+                                    ))?,
                             ),
                             rebill_frequency: Some(mandate_meta.frequency),
                             challenge_window_size: None,