feat(payment_link): add status page for payment link (#3213)

Co-authored-by: hyperswitch-bot[bot] <148525504+hyperswitch-bot[bot]@users.noreply.github.com>
Co-authored-by: Kashif <[email protected]>
Co-authored-by: Kashif <[email protected]>
Co-authored-by: hrithikeshvm <[email protected]>
Co-authored-by: hrithikeshvm <[email protected]>
Co-authored-by: Sahkal Poddar <[email protected]>

Author: 6 people

config/config.example.toml

@@ -473,7 +473,7 @@ apple_pay_merchant_cert = "APPLE_PAY_MERCHNAT_CERTIFICATE"         #Merchant Cer
 apple_pay_merchant_cert_key = "APPLE_PAY_MERCHNAT_CERTIFICATE_KEY" #Private key generate by RSA:2048 algorithm
 
 [payment_link]
-sdk_url = "http://localhost:9090/dist/HyperLoader.js"
+sdk_url = "http://localhost:9090/0.16.7/v0/HyperLoader.js"
 
 [payment_method_auth]
 redis_expiry = 900

config/development.toml

@@ -494,7 +494,7 @@ apple_pay_merchant_cert = "APPLE_PAY_MERCHNAT_CERTIFICATE"
 apple_pay_merchant_cert_key = "APPLE_PAY_MERCHNAT_CERTIFICATE_KEY"
 
 [payment_link]
-sdk_url = "http://localhost:9090/dist/HyperLoader.js"
+sdk_url = "http://localhost:9050/HyperLoader.js"
 
 [payment_method_auth]
 redis_expiry = 900

crates/api_models/src/payments.rs

@@ -3358,6 +3358,13 @@ pub struct PaymentLinkInitiateRequest {
     pub payment_id: String,
 }
 
+#[derive(Debug, serde::Serialize)]
+#[serde(untagged)]
+pub enum PaymentLinkData {
+    PaymentLinkDetails(PaymentLinkDetails),
+    PaymentLinkStatusDetails(PaymentLinkStatusDetails),
+}
+
 #[derive(Debug, serde::Serialize)]
 pub struct PaymentLinkDetails {
     pub amount: String,
@@ -3376,6 +3383,21 @@ pub struct PaymentLinkDetails {
     pub merchant_description: Option<String>,
 }
 
+#[derive(Debug, serde::Serialize)]
+pub struct PaymentLinkStatusDetails {
+    pub amount: String,
+    pub currency: api_enums::Currency,
+    pub payment_id: String,
+    pub merchant_logo: String,
+    pub merchant_name: String,
+    #[serde(with = "common_utils::custom_serde::iso8601")]
+    pub created: PrimitiveDateTime,
+    pub intent_status: api_enums::IntentStatus,
+    pub payment_link_status: PaymentLinkStatus,
+    pub error_code: Option<String>,
+    pub error_message: Option<String>,
+}
+
 #[derive(Clone, Debug, serde::Deserialize, ToSchema, serde::Serialize)]
 #[serde(deny_unknown_fields)]
 
@@ -3451,7 +3473,8 @@ pub struct OrderDetailsWithStringAmount {
     pub product_img_link: Option<String>,
 }
 
-#[derive(Debug, Clone, serde::Serialize, serde::Deserialize, ToSchema)]
+#[derive(PartialEq, Debug, Clone, serde::Serialize, serde::Deserialize, ToSchema)]
+#[serde(rename_all = "snake_case")]
 pub enum PaymentLinkStatus {
     Active,
     Expired,

crates/router/src/compatibility/wrap.rs

@@ -133,19 +133,34 @@ where
             .map_into_boxed_body()
         }
 
-        Ok(api::ApplicationResponse::PaymenkLinkForm(payment_link_data)) => {
-            match api::build_payment_link_html(*payment_link_data) {
-                Ok(rendered_html) => api::http_response_html_data(rendered_html),
-                Err(_) => api::http_response_err(
-                    r#"{
-                        "error": {
-                            "message": "Error while rendering payment link html page"
-                        }
-                    }"#,
-                ),
+        Ok(api::ApplicationResponse::PaymenkLinkForm(boxed_payment_link_data)) => {
+            match *boxed_payment_link_data {
+                api::PaymentLinkAction::PaymentLinkFormData(payment_link_data) => {
+                    match api::build_payment_link_html(payment_link_data) {
+                        Ok(rendered_html) => api::http_response_html_data(rendered_html),
+                        Err(_) => api::http_response_err(
+                            r#"{
+                                "error": {
+                                    "message": "Error while rendering payment link html page"
+                                }
+                            }"#,
+                        ),
+                    }
+                }
+                api::PaymentLinkAction::PaymentLinkStatus(payment_link_data) => {
+                    match api::get_payment_link_status(payment_link_data) {
+                        Ok(rendered_html) => api::http_response_html_data(rendered_html),
+                        Err(_) => api::http_response_err(
+                            r#"{
+                                "error": {
+                                    "message": "Error while rendering payment link status page"
+                                }
+                            }"#,
+                        ),
+                    }
+                }
             }
         }
-
         Err(error) => api::log_and_return_error_response(error),
     };
 

crates/router/src/core/payment_link.rs

@@ -13,7 +13,6 @@ use time::PrimitiveDateTime;
 
 use super::errors::{self, RouterResult, StorageErrorExt};
 use crate::{
-    core::payments::helpers,
     errors::RouterResponse,
     routes::AppState,
     services,
@@ -68,18 +67,6 @@ pub async fn intiate_payment_link_flow(
         .get_required_value("payment_link_id")
         .change_context(errors::ApiErrorResponse::PaymentLinkNotFound)?;
 
-    helpers::validate_payment_status_against_not_allowed_statuses(
-        &payment_intent.status,
-        &[
-            storage_enums::IntentStatus::Cancelled,
-            storage_enums::IntentStatus::Succeeded,
-            storage_enums::IntentStatus::Processing,
-            storage_enums::IntentStatus::RequiresCapture,
-            storage_enums::IntentStatus::RequiresMerchantAction,
-        ],
-        "use payment link for",
-    )?;
-
     let merchant_name_from_merchant_account = merchant_account
         .merchant_name
         .clone()
@@ -101,7 +88,7 @@ pub async fn intiate_payment_link_flow(
         }
     };
 
-    let return_url = if let Some(payment_create_return_url) = payment_intent.return_url {
+    let return_url = if let Some(payment_create_return_url) = payment_intent.return_url.clone() {
         payment_create_return_url
     } else {
         merchant_account
@@ -114,23 +101,73 @@ pub async fn intiate_payment_link_flow(
     let (pub_key, currency, client_secret) = validate_sdk_requirements(
         merchant_account.publishable_key,
         payment_intent.currency,
-        payment_intent.client_secret,
+        payment_intent.client_secret.clone(),
     )?;
-    let order_details = validate_order_details(payment_intent.order_details, currency)?;
+    let amount = currency
+        .to_currency_base_unit(payment_intent.amount)
+        .into_report()
+        .change_context(errors::ApiErrorResponse::CurrencyConversionFailed)?;
+    let order_details = validate_order_details(payment_intent.order_details.clone(), currency)?;
 
     let session_expiry = payment_link.fulfilment_time.unwrap_or_else(|| {
-        common_utils::date_time::now()
+        payment_intent
+            .created_at
             .saturating_add(time::Duration::seconds(DEFAULT_SESSION_EXPIRY))
     });
 
     // converting first letter of merchant name to upperCase
     let merchant_name = capitalize_first_char(&payment_link_config.seller_name);
+    let css_script = get_color_scheme_css(payment_link_config.clone());
+    let payment_link_status = check_payment_link_status(session_expiry);
+
+    if check_payment_link_invalid_conditions(
+        &payment_intent.status,
+        &[
+            storage_enums::IntentStatus::Cancelled,
+            storage_enums::IntentStatus::Failed,
+            storage_enums::IntentStatus::Processing,
+            storage_enums::IntentStatus::RequiresCapture,
+            storage_enums::IntentStatus::RequiresMerchantAction,
+            storage_enums::IntentStatus::Succeeded,
+        ],
+    ) || payment_link_status == api_models::payments::PaymentLinkStatus::Expired
+    {
+        let attempt_id = payment_intent.active_attempt.get_id().clone();
+        let payment_attempt = db
+            .find_payment_attempt_by_payment_id_merchant_id_attempt_id(
+                &payment_intent.payment_id,
+                &merchant_id,
+                &attempt_id.clone(),
+                merchant_account.storage_scheme,
+            )
+            .await
+            .to_not_found_response(errors::ApiErrorResponse::PaymentNotFound)?;
+        let payment_details = api_models::payments::PaymentLinkStatusDetails {
+            amount,
+            currency,
+            payment_id: payment_intent.payment_id,
+            merchant_name,
+            merchant_logo: payment_link_config.clone().logo,
+            created: payment_link.created_at,
+            intent_status: payment_intent.status,
+            payment_link_status,
+            error_code: payment_attempt.error_code,
+            error_message: payment_attempt.error_message,
+        };
+        let js_script = get_js_script(
+            api_models::payments::PaymentLinkData::PaymentLinkStatusDetails(payment_details),
+        )?;
+        let payment_link_error_data = services::PaymentLinkStatusData {
+            js_script,
+            css_script,
+        };
+        return Ok(services::ApplicationResponse::PaymenkLinkForm(Box::new(
+            services::api::PaymentLinkAction::PaymentLinkStatus(payment_link_error_data),
+        )));
+    };
 
     let payment_details = api_models::payments::PaymentLinkDetails {
-        amount: currency
-            .to_currency_base_unit(payment_intent.amount)
-            .into_report()
-            .change_context(errors::ApiErrorResponse::CurrencyConversionFailed)?,
+        amount,
         currency,
         payment_id: payment_intent.payment_id,
         merchant_name,
@@ -145,29 +182,28 @@ pub async fn intiate_payment_link_flow(
         merchant_description: payment_intent.description,
     };
 
-    let js_script = get_js_script(payment_details)?;
-    let css_script = get_color_scheme_css(payment_link_config.clone());
+    let js_script = get_js_script(api_models::payments::PaymentLinkData::PaymentLinkDetails(
+        payment_details,
+    ))?;
     let payment_link_data = services::PaymentLinkFormData {
         js_script,
         sdk_url: state.conf.payment_link.sdk_url.clone(),
         css_script,
     };
     Ok(services::ApplicationResponse::PaymenkLinkForm(Box::new(
-        payment_link_data,
+        services::api::PaymentLinkAction::PaymentLinkFormData(payment_link_data),
     )))
 }
 
 /*
 The get_js_script function is used to inject dynamic value to payment_link sdk, which is unique to every payment.
 */
 
-fn get_js_script(
-    payment_details: api_models::payments::PaymentLinkDetails,
-) -> RouterResult<String> {
+fn get_js_script(payment_details: api_models::payments::PaymentLinkData) -> RouterResult<String> {
     let payment_details_str = serde_json::to_string(&payment_details)
         .into_report()
         .change_context(errors::ApiErrorResponse::InternalServerError)
-        .attach_printable("Failed to serialize PaymentLinkDetails")?;
+        .attach_printable("Failed to serialize PaymentLinkData")?;
     Ok(format!("window.__PAYMENT_DETAILS = {payment_details_str};"))
 }
 
@@ -218,11 +254,11 @@ pub async fn list_payment_link(
 }
 
 pub fn check_payment_link_status(
-    max_age: PrimitiveDateTime,
+    payment_link_expiry: PrimitiveDateTime,
 ) -> api_models::payments::PaymentLinkStatus {
     let curr_time = common_utils::date_time::now();
 
-    if curr_time > max_age {
+    if curr_time > payment_link_expiry {
         api_models::payments::PaymentLinkStatus::Expired
     } else {
         api_models::payments::PaymentLinkStatus::Active
@@ -369,3 +405,10 @@ fn capitalize_first_char(s: &str) -> String {
         s.to_owned()
     }
 }
+
+fn check_payment_link_invalid_conditions(
+    intent_status: &storage_enums::IntentStatus,
+    not_allowed_statuses: &[storage_enums::IntentStatus],
+) -> bool {
+    not_allowed_statuses.contains(intent_status)
+}