refactor(payment_intent_v2): payment intent fields refactoring

crates/api_models/src/payments.rs

@@ -18,11 +18,7 @@ use error_stack::ResultExt;
 use masking::{ExposeInterface, PeekInterface, Secret, SwitchStrategy, WithType};
 use router_derive::Setter;
 use rustc_hash::FxHashMap;
-use serde::{
-    de::{self, Unexpected, Visitor},
-    ser::Serializer,
-    Deserialize, Deserializer, Serialize,
-};
+use serde::{de, ser::Serializer, Deserialize, Deserializer, Serialize};
 use strum::Display;
 use time::{Date, PrimitiveDateTime};
 use url::Url;
@@ -68,154 +64,6 @@ pub struct BankCodeResponse {
     pub eligible_connectors: Vec<String>,
 }
 
-#[derive(Debug, PartialEq, Clone)]
-pub struct ClientSecret {
-    pub payment_id: id_type::PaymentId,
-    pub secret: String,
-}
-
-impl ClientSecret {
-    pub fn get_client_secret(&self) -> String {
-        format!(
-            "{}_secret_{}",
-            self.payment_id.get_string_repr(),
-            self.secret
-        )
-    }
-}
-
-impl<'de> Deserialize<'de> for ClientSecret {
-    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-    where
-        D: Deserializer<'de>,
-    {
-        struct ClientSecretVisitor;
-
-        impl<'de> Visitor<'de> for ClientSecretVisitor {
-            type Value = ClientSecret;
-
-            fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
-                formatter.write_str("a string in the format '{payment_id}_secret_{secret}'")
-            }
-
-            fn visit_str<E>(self, value: &str) -> Result<ClientSecret, E>
-            where
-                E: de::Error,
-            {
-                let (payment_id, secret) = value.rsplit_once("_secret_").ok_or_else(|| {
-                    E::invalid_value(Unexpected::Str(value), &"a string with '_secret_'")
-                })?;
-
-                let payment_id =
-                    id_type::PaymentId::try_from(std::borrow::Cow::Owned(payment_id.to_owned()))
-                        .map_err(de::Error::custom)?;
-
-                Ok(ClientSecret {
-                    payment_id,
-                    secret: secret.to_owned(),
-                })
-            }
-        }
-
-        deserializer.deserialize_str(ClientSecretVisitor)
-    }
-}
-
-impl Serialize for ClientSecret {
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: Serializer,
-    {
-        let combined = format!(
-            "{}_secret_{}",
-            self.payment_id.get_string_repr(),
-            self.secret
-        );
-        serializer.serialize_str(&combined)
-    }
-}
-
-#[cfg(test)]
-mod client_secret_tests {
-    #![allow(clippy::expect_used)]
-    #![allow(clippy::unwrap_used)]
-
-    use serde_json;
-
-    use super::*;
-
-    #[test]
-    fn test_serialize_client_secret() {
-        let client_secret1 = ClientSecret {
-            payment_id: id_type::PaymentId::try_from(std::borrow::Cow::Borrowed(
-                "pay_3TgelAms4RQec8xSStjF",
-            ))
-            .unwrap(),
-            secret: "fc34taHLw1ekPgNh92qr".to_string(),
-        };
-        let client_secret2 = ClientSecret {
-            payment_id: id_type::PaymentId::try_from(std::borrow::Cow::Borrowed(
-                "pay_3Tgel__Ams4RQ_secret_ec8xSStjF",
-            ))
-            .unwrap(),
-            secret: "fc34taHLw1ekPgNh92qr".to_string(),
-        };
-
-        let expected_str1 = r#""pay_3TgelAms4RQec8xSStjF_secret_fc34taHLw1ekPgNh92qr""#;
-        let expected_str2 = r#""pay_3Tgel__Ams4RQ_secret_ec8xSStjF_secret_fc34taHLw1ekPgNh92qr""#;
-
-        let actual_str1 =
-            serde_json::to_string(&client_secret1).expect("Failed to serialize client_secret1");
-        let actual_str2 =
-            serde_json::to_string(&client_secret2).expect("Failed to serialize client_secret2");
-
-        assert_eq!(expected_str1, actual_str1);
-        assert_eq!(expected_str2, actual_str2);
-    }
-
-    #[test]
-    fn test_deserialize_client_secret() {
-        let client_secret_str1 = r#""pay_3TgelAms4RQec8xSStjF_secret_fc34taHLw1ekPgNh92qr""#;
-        let client_secret_str2 =
-            r#""pay_3Tgel__Ams4RQ_secret_ec8xSStjF_secret_fc34taHLw1ekPgNh92qr""#;
-        let client_secret_str3 =
-            r#""pay_3Tgel__Ams4RQ_secret_ec8xSStjF_secret__secret_fc34taHLw1ekPgNh92qr""#;
-
-        let expected1 = ClientSecret {
-            payment_id: id_type::PaymentId::try_from(std::borrow::Cow::Borrowed(
-                "pay_3TgelAms4RQec8xSStjF",
-            ))
-            .unwrap(),
-            secret: "fc34taHLw1ekPgNh92qr".to_string(),
-        };
-        let expected2 = ClientSecret {
-            payment_id: id_type::PaymentId::try_from(std::borrow::Cow::Borrowed(
-                "pay_3Tgel__Ams4RQ_secret_ec8xSStjF",
-            ))
-            .unwrap(),
-            secret: "fc34taHLw1ekPgNh92qr".to_string(),
-        };
-        let expected3 = ClientSecret {
-            payment_id: id_type::PaymentId::try_from(std::borrow::Cow::Borrowed(
-                "pay_3Tgel__Ams4RQ_secret_ec8xSStjF_secret_",
-            ))
-            .unwrap(),
-            secret: "fc34taHLw1ekPgNh92qr".to_string(),
-        };
-
-        let actual1: ClientSecret = serde_json::from_str(client_secret_str1)
-            .expect("Failed to deserialize client_secret_str1");
-        let actual2: ClientSecret = serde_json::from_str(client_secret_str2)
-            .expect("Failed to deserialize client_secret_str2");
-        let actual3: ClientSecret = serde_json::from_str(client_secret_str3)
-            .expect("Failed to deserialize client_secret_str3");
-
-        assert_eq!(expected1, actual1);
-        assert_eq!(expected2, actual2);
-        assert_eq!(expected3, actual3);
-    }
-}
-
 /// Passing this object creates a new customer or attaches an existing customer to the payment
 #[derive(Debug, serde::Deserialize, serde::Serialize, Clone, ToSchema, PartialEq)]
 pub struct CustomerDetails {

crates/common_enums/src/enums.rs

@@ -3213,3 +3213,39 @@ pub enum DeleteStatus {
     Active,
     Redacted,
 }
+
+/// Whether 3ds authentication is requested or not
+#[derive(Clone, Debug, PartialEq, serde::Serialize)]
+pub enum External3dsAuthenticationRequest {
+    /// Request for 3ds authentication
+    Enable,
+    /// Skip 3ds authentication
+    Skip,
+}
+
+/// Whether payment link is requested to be enabled or not for this transaction
+#[derive(Clone, Debug, PartialEq, serde::Serialize)]
+pub enum EnablePaymentLinkRequest {
+    /// Request for enabling payment link
+    Enable,
+    /// Skip enabling payment link
+    Skip,
+}
+
+/// Whether mit exemption is requested or not
+#[derive(Clone, Debug, PartialEq, serde::Serialize)]
+pub enum MitExemptionRequest {
+    /// Request for applying MIT exemption
+    Apply,
+    /// Skip applying MIT exemption
+    Skip,
+}
+
+/// Whether customer is present / absent during the payment
+#[derive(Clone, Debug, PartialEq, serde::Serialize)]
+pub enum PresenceOfCustomerDuringPayment {
+    /// Customer is present during the payment. This is the default value
+    Present,
+    /// Customer is absent during the payment
+    Absent,
+}

crates/common_enums/src/transformers.rs

@@ -1991,6 +1991,79 @@ mod custom_serde {
     }
 }
 
+impl From<Option<bool>> for super::External3dsAuthenticationRequest {
+    fn from(value: Option<bool>) -> Self {
+        match value {
+            Some(true) => Self::Enable,
+            _ => Self::Skip,
+        }
+    }
+}
+
+/// Get the boolean value of the `External3dsAuthenticationRequest`.
+impl super::External3dsAuthenticationRequest {
+    pub fn as_bool(&self) -> bool {
+        match self {
+            Self::Enable => true,
+            Self::Skip => false,
+        }
+    }
+}
+
+impl super::EnablePaymentLinkRequest {
+    pub fn as_bool(&self) -> bool {
+        match self {
+            Self::Enable => true,
+            Self::Skip => false,
+        }
+    }
+}
+
+impl From<Option<bool>> for super::EnablePaymentLinkRequest {
+    fn from(value: Option<bool>) -> Self {
+        match value {
+            Some(true) => Self::Enable,
+            _ => Self::Skip,
+        }
+    }
+}
+
+impl From<Option<bool>> for super::MitExemptionRequest {
+    fn from(value: Option<bool>) -> Self {
+        match value {
+            Some(true) => Self::Apply,
+            _ => Self::Skip,
+        }
+    }
+}
+
+impl super::MitExemptionRequest {
+    pub fn as_bool(&self) -> bool {
+        match self {
+            Self::Apply => true,
+            Self::Skip => false,
+        }
+    }
+}
+
+impl From<Option<bool>> for super::PresenceOfCustomerDuringPayment {
+    fn from(value: Option<bool>) -> Self {
+        match value {
+            Some(false) => Self::Absent,
+            _ => Self::Present,
+        }
+    }
+}
+
+impl super::PresenceOfCustomerDuringPayment {
+    pub fn as_bool(&self) -> bool {
+        match self {
+            Self::Present => true,
+            Self::Absent => false,
+        }
+    }
+}
+
 #[cfg(test)]
 mod tests {
     #![allow(clippy::unwrap_used)]

crates/common_utils/src/consts.rs

@@ -147,5 +147,10 @@ pub const ROLE_ID_INTERNAL_VIEW_ONLY_USER: &str = "internal_view_only";
 /// Role ID for Internal Admin
 pub const ROLE_ID_INTERNAL_ADMIN: &str = "internal_admin";
 
+/// Max length allowed for Description
+pub const MAX_DESCRIPTION_LENGTH: u16 = 255;
+
+/// Max length allowed for Statement Descriptor
+pub const MAX_STATEMENT_DESCRIPTOR_LENGTH: u16 = 255;
 /// Payout flow identifier used for performing GSM operations
 pub const PAYOUT_FLOW_STR: &str = "payout_flow";

crates/common_utils/src/id_type.rs

@@ -11,9 +11,8 @@ mod payment;
 mod profile;
 mod routing;
 
+#[cfg(feature = "v2")]
 mod global_id;
-#[cfg(all(feature = "v2", feature = "payment_methods_v2"))]
-mod payment_methods;
 
 pub use customer::CustomerId;
 use diesel::{
@@ -23,12 +22,12 @@ use diesel::{
     serialize::{Output, ToSql},
     sql_types,
 };
+#[cfg(feature = "v2")]
+pub use global_id::{payment::GlobalPaymentId, payment_methods::GlobalPaymentMethodId, CellId};
 pub use merchant::MerchantId;
 pub use merchant_connector_account::MerchantConnectorAccountId;
 pub use organization::OrganizationId;
 pub use payment::PaymentId;
-#[cfg(all(feature = "v2", feature = "payment_methods_v2"))]
-pub use payment_methods::GlobalPaymentMethodId;
 pub use profile::ProfileId;
 pub use routing::RoutingId;
 use serde::{Deserialize, Serialize};
@@ -155,6 +154,7 @@ impl<const MAX_LENGTH: u8, const MIN_LENGTH: u8> LengthId<MAX_LENGTH, MIN_LENGTH
         Self(alphanumeric_id)
     }
 
+    #[cfg(feature = "v2")]
     /// Create a new LengthId from aplhanumeric id
     pub(crate) fn from_alphanumeric_id(
         alphanumeric_id: AlphaNumericId,

crates/common_utils/src/id_type/global_id.rs

@@ -1,4 +1,6 @@
 #![allow(unused)]
+pub mod payment;
+pub mod payment_methods;
 
 use diesel::{backend::Backend, deserialize::FromSql, serialize::ToSql, sql_types};
 use error_stack::ResultExt;
@@ -34,8 +36,9 @@ impl GlobalEntity {
     }
 }
 
+/// Cell identifier for an instance / deployment of application
 #[derive(Debug, Clone, Hash, PartialEq, Eq)]
-pub(crate) struct CellId(LengthId<CELL_IDENTIFIER_LENGTH, CELL_IDENTIFIER_LENGTH>);
+pub struct CellId(LengthId<CELL_IDENTIFIER_LENGTH, CELL_IDENTIFIER_LENGTH>);
 
 #[derive(Debug, Error, PartialEq, Eq)]
 pub enum CellIdError {
@@ -107,7 +110,9 @@ impl GlobalId {
         Self(LengthId::new_unchecked(alphanumeric_id))
     }
 
-    pub fn from_string(input_string: String) -> Result<Self, GlobalIdError> {
+    pub(crate) fn from_string(
+        input_string: std::borrow::Cow<'static, str>,
+    ) -> Result<Self, GlobalIdError> {
         let length_id = LengthId::from(input_string.into())?;
         let input_string = &length_id.0 .0;
         let (cell_id, remaining) = input_string
@@ -118,6 +123,10 @@ impl GlobalId {
 
         Ok(Self(length_id))
     }
+
+    pub(crate) fn get_string_repr(&self) -> &str {
+        &self.0 .0 .0
+    }
 }
 
 impl<DB> ToSql<sql_types::Text, DB> for GlobalId
@@ -154,7 +163,7 @@ impl<'de> serde::Deserialize<'de> for GlobalId {
         D: serde::Deserializer<'de>,
     {
         let deserialized_string = String::deserialize(deserializer)?;
-        Self::from_string(deserialized_string).map_err(serde::de::Error::custom)
+        Self::from_string(deserialized_string.into()).map_err(serde::de::Error::custom)
     }
 }
 
@@ -187,7 +196,7 @@ mod global_id_tests {
     #[test]
     fn test_global_id_from_string() {
         let input_string = "12345_cus_abcdefghijklmnopqrstuvwxyz1234567890";
-        let global_id = GlobalId::from_string(input_string.to_string()).unwrap();
+        let global_id = GlobalId::from_string(input_string.into()).unwrap();
         assert_eq!(global_id.0 .0 .0, input_string);
     }