add payout link support

crates/api_models/src/payouts.rs

@@ -148,6 +148,33 @@ pub struct PayoutCreateRequest {
  /// The business profile to use for this payment, if not passed the default business profile
  /// associated with the merchant account will be used.
  pub profile_id: Option<String>,
+
+ /// Whether to get the payment link (if applicable)
+ #[schema(default = false, example = true)]
+ pub payout_link: Option<bool>,
+
+ /// custom payment link config for the particular payment
+ #[schema(value_type = Option<PayoutCreatePayoutLinkConfig>)]
+ pub payout_link_config: Option<PayoutCreatePayoutLinkConfig>,
+}
+
+#[derive(Default, Debug, Deserialize, Serialize, Clone, ToSchema)]
+pub struct PayoutCreatePayoutLinkConfig {
+ /// The unique identifier for the collect link.
+ #[schema(value_type = Option<String>, example = "pm_collect_link_2bdacf398vwzq5n422S1")]
+ pub payout_link_id: Option<String>,
+
+ #[serde(flatten)]
+ pub ui_config: Option<api_enums::CollectLinkConfig>,
+
+ /// Will be used to expire client secret after certain amount of time to be supplied in seconds
+ /// (900) for 15 mins
+ #[schema(value_type = Option<u32>, example = 900)]
+ pub session_expiry: Option<u32>,
+
+ /// List of payment methods shown on collect UI
+ #[schema(value_type = Option<Vec<EnabledPaymentMethod>>, example = r#"[{"payment_method": "bank_transfer", "payment_method_types": ["ach", "bacs"]}]"#)]
+ pub enabled_payment_methods: Option<Vec<api_enums::EnabledPaymentMethod>>,
 }
 
 #[derive(Debug, Clone, Deserialize, Serialize, ToSchema)]
@@ -445,6 +472,9 @@ pub struct PayoutCreateResponse {
  #[schema(value_type = Option<Vec<PayoutAttemptResponse>>)]
  #[serde(skip_serializing_if = "Option::is_none")]
  pub attempts: Option<Vec<PayoutAttemptResponse>>,
+
+ // If payout link is request, this represents response on
+ pub payout_link: Option<PayoutLinkResponse>,
 }
 
 #[derive(
@@ -652,3 +682,9 @@ pub struct PayoutListFilters {
  /// The list of available payment method filters
  pub payout_method: Vec<common_enums::PayoutType>,
 }
+
+#[derive(Clone, Debug, serde::Serialize, ToSchema)]
+pub struct PayoutLinkResponse {
+ pub link: Secret<String>,
+ pub payout_link_id: String,
+}

crates/diesel_models/src/payouts.rs

@@ -33,6 +33,7 @@ pub struct Payouts {
  pub profile_id: String,
  pub status: storage_enums::PayoutStatus,
  pub confirm: Option<bool>,
+ pub payout_link_id: Option<String>,
 }
 
 #[derive(
@@ -72,6 +73,7 @@ pub struct PayoutsNew {
  pub profile_id: String,
  pub status: storage_enums::PayoutStatus,
  pub confirm: Option<bool>,
+ pub payout_link_id: Option<String>,
 }
 
 #[derive(Debug, Clone, Serialize, Deserialize)]

crates/diesel_models/src/schema.rs

@@ -1042,6 +1042,8 @@ diesel::table! {
  profile_id -> Varchar,
  status -> PayoutStatus,
  confirm -> Nullable<Bool>,
+ #[max_length = 255]
+ payout_link_id -> Nullable<Varchar>,
  }
 }
 

crates/hyperswitch_domain_models/src/payouts/payouts.rs

@@ -90,6 +90,7 @@ pub struct Payouts {
  pub profile_id: String,
  pub status: storage_enums::PayoutStatus,
  pub confirm: Option<bool>,
+ pub payout_link_id: Option<String>,
 }
 
 #[derive(Clone, Debug, Eq, PartialEq)]
@@ -115,6 +116,7 @@ pub struct PayoutsNew {
  pub profile_id: String,
  pub status: storage_enums::PayoutStatus,
  pub confirm: Option<bool>,
+ pub payout_link_id: Option<String>,
 }
 
 impl Default for PayoutsNew {
@@ -143,6 +145,7 @@ impl Default for PayoutsNew {
  profile_id: String::default(),
  status: storage_enums::PayoutStatus::default(),
  confirm: None,
+ payout_link_id: Option::default(),
  }
  }
 }

crates/router/src/core/payment_methods.rs

@@ -121,8 +121,13 @@ pub async fn initiate_pm_collect_link(
  .await?;
 
  // Create DB entries
- let pm_collect_link =
- create_pm_collect_db_entry(&state, &merchant_account, &pm_collect_link_data, &req).await?;
+ let pm_collect_link = create_pm_collect_db_entry(
+ &state,
+ &merchant_account,
+ &pm_collect_link_data,
+ req.return_url.clone(),
+ )
+ .await?;
 
  // Return response
  let response = payment_methods::PaymentMethodCollectLinkResponse {
@@ -141,7 +146,7 @@ pub async fn create_pm_collect_db_entry(
  state: &AppState,
  merchant_account: &domain::MerchantAccount,
  pm_collect_link_data: &PaymentMethodCollectLinkData,
- req: &payment_methods::PaymentMethodCollectLinkRequest,
+ return_url: Option<String>,
 ) -> RouterResult<PaymentMethodCollectLink> {
  let db: &dyn StorageInterface = &*state.store;
 
@@ -156,7 +161,7 @@ pub async fn create_pm_collect_db_entry(
  link_type: common_enums::GenericLinkType::PaymentMethodCollect,
  link_data,
  url: pm_collect_link_data.link.clone(),
- return_url: req.return_url.clone(),
+ return_url,
  expiry: common_utils::date_time::now()
  + Duration::seconds(pm_collect_link_data.session_expiry.into()),
  ..Default::default()

crates/router/src/core/payments/transformers.rs

@@ -945,6 +945,7 @@ impl ForeignFrom<(storage::Payouts, storage::PayoutAttempt, domain::Customer)>
  attempts: Some(attempts),
  billing: None,
  client_secret: None,
+ payout_link: None
  }
  }
 }

crates/router/src/core/payouts.rs

@@ -5,7 +5,7 @@ pub mod retry;
 pub mod validator;
 use std::vec::IntoIter;
 
-use api_models::enums as api_enums;
+use api_models::{self, enums as api_enums, payouts::PayoutLinkResponse};
 use common_utils::{consts, crypto::Encryptable, ext_traits::ValueExt, pii, types::MinorUnit};
 use diesel_models::enums as storage_enums;
 use error_stack::{report, ResultExt};
@@ -57,6 +57,7 @@ pub struct PayoutData {
  pub payout_method_data: Option<payouts::PayoutMethodData>,
  pub profile_id: String,
  pub should_terminate: bool,
+ pub payout_link_data: Option<PayoutLinkResponse>,
 }
 
 // ********************************************** CORE FLOWS **********************************************
@@ -1890,6 +1891,7 @@ pub async fn response_handler(
  profile_id: payout_attempt.profile_id,
  created: Some(payouts.created_at),
  attempts: None,
+ payout_link: payout_data.payout_link_data.to_owned(),
  };
  Ok(services::ApplicationResponse::Json(response))
 }
@@ -1931,7 +1933,36 @@ pub async fn payout_create_db_entries(
  })
  })?
  .customer_id;
+ let payout_link = if let Some(payout_link_create) = req.payout_link {
+ if payout_link_create {
+ let payout_link_config = req.payout_link_config.as_ref().ok_or_else(|| {
+ report!(errors::ApiErrorResponse::MissingRequiredField {
+ field_name: "payout_link_config",
+ })
+ })?;
+ validator::intiate_payout_link(
+ state,
+ merchant_account,
+ payout_link_config,
+ &customer_id,
+ req.return_url.to_owned(),
+ )
+ .await?
+ } else {
+ None
+ }
+ } else {
+ None
+ };
 
+ let payout_link_data = payout_link.as_ref().map(|link_data| PayoutLinkResponse {
+ link: link_data.link.clone(),
+ payout_link_id: link_data.pm_collect_link_id.clone(),
+ });
+
+ let payout_link_id = payout_link_data
+ .clone()
+ .map(|link_data| link_data.payout_link_id);
  // Get or create address
  let billing_address = payment_helpers::create_or_find_address_for_payment_by_request(
  db,
@@ -1985,6 +2016,7 @@ pub async fn payout_create_db_entries(
  attempt_count: 1,
  metadata: req.metadata.clone(),
  confirm: req.confirm,
+ payout_link_id: payout_link_id.clone(),
  ..Default::default()
  };
  let payouts = db
@@ -1994,7 +2026,7 @@ pub async fn payout_create_db_entries(
  payout_id: payout_id.to_owned(),
  })
  .attach_printable("Error inserting payouts in db")?;
-
+ logger::debug!("{:?}", payout_link_id.clone());
  // Make payout_attempt entry
  let status = if req.payout_method_data.is_some()
  || req.payout_token.is_some()
@@ -2050,6 +2082,7 @@ pub async fn payout_create_db_entries(
  .or(stored_payout_method_data.cloned()),
  should_terminate: false,
  profile_id: profile_id.to_owned(),
+ payout_link_data,
  })
 }
 
@@ -2125,6 +2158,7 @@ pub async fn make_payout_data(
  merchant_connector_account: None,
  should_terminate: false,
  profile_id,
+ payout_link_data: None, // Should be changed
  })
 }
 

crates/router/src/core/payouts/validator.rs

@@ -1,13 +1,19 @@
+use api_models::admin;
 #[cfg(feature = "olap")]
 use common_utils::errors::CustomResult;
+use common_utils::ext_traits::ValueExt;
+use diesel_models::{enums::CollectLinkConfig, generic_link::PaymentMethodCollectLinkData};
 use error_stack::{report, ResultExt};
 pub use hyperswitch_domain_models::errors::StorageError;
+use masking::Secret;
 use router_env::{instrument, tracing};
 
 use super::helpers;
 use crate::{
+ consts,
  core::{
  errors::{self, RouterResult},
+ payment_methods::create_pm_collect_db_entry,
  utils as core_utils,
  },
  db::StorageInterface,
@@ -52,6 +58,12 @@ pub async fn validate_create_request(
 ) -> RouterResult<(String, Option<payouts::PayoutMethodData>, String)> {
  let merchant_id = &merchant_account.merchant_id;
 
+ if let Some(payout_link) = &req.payout_link {
+ if *payout_link {
+ validate_payout_link_request(req.confirm)?;
+ }
+ };
+
  // Merchant ID
  let predicate = req.merchant_id.as_ref().map(|mid| mid != merchant_id);
  utils::when(predicate.unwrap_or(false), || {
@@ -119,6 +131,19 @@ pub async fn validate_create_request(
  Ok((payout_id, payout_method_data, profile_id))
 }
 
+pub fn validate_payout_link_request(confirm: Option<bool>) -> Result<(), errors::ApiErrorResponse> {
+ if let Some(cnf) = confirm {
+ if !cnf {
+ return Ok(());
+ } else {
+ return Err(errors::ApiErrorResponse::InvalidRequestData {
+ message: "cannot confirm a payout while creating a payout link".to_string(),
+ });
+ }
+ }
+ Ok(())
+}
+
 #[cfg(feature = "olap")]
 pub(super) fn validate_payout_list_request(
  req: &payouts::PayoutListConstraints,
@@ -155,3 +180,102 @@ pub(super) fn validate_payout_list_request_for_joins(
  })?;
  Ok(())
 }
+
+pub async fn intiate_payout_link(
+ state: &AppState,
+ merchant_account: &domain::MerchantAccount,
+ req: &api_models::payouts::PayoutCreatePayoutLinkConfig,
+ customer_id: &String,
+ return_url: Option<String>,
+) -> RouterResult<Option<PaymentMethodCollectLinkData>> {
+ // Create payment method collect link ID
+ let payout_link_id =
+ core_utils::get_or_generate_id("payout_link_id", &req.payout_link_id, "payout_link")?;
+
+ // Fetch all configs
+ let default_config = &state.conf.generic_link.payment_method_collect;
+ let merchant_config = merchant_account
+ .pm_collect_link_config
+ .clone()
+ .map(|config| {
+ config.parse_value::<admin::MerchantCollectLinkConfig>("MerchantCollectLinkConfig")
+ })
+ .transpose()
+ .change_context(errors::ApiErrorResponse::InvalidDataValue {
+ field_name: "pm_collect_link_config in merchant_account",
+ })?;
+ let ui_config = &req.ui_config;
+ // Create client secret
+ let client_secret = utils::generate_id(consts::ID_LENGTH, "payout_link_secret");
+
+ let fallback_ui_config = match &merchant_account.pm_collect_link_config {
+ Some(config) => {
+ config
+ .clone()
+ .parse_value::<admin::MerchantCollectLinkConfig>("MerchantCollectLinkConfig")
+ .change_context(errors::ApiErrorResponse::InvalidDataValue {
+ field_name: "pm_collect_link_config in merchant_account",
+ })?
+ .ui_config
+ }
+ None => default_config.ui_config.clone(),
+ };
+
+ // Form data to be injected in HTML
+ let sdk_host = default_config.sdk_url.clone();
+
+ let domain = merchant_config
+ .clone()
+ .and_then(|c| c.domain_name.clone())
+ .unwrap_or_else(|| state.conf.server.base_url.clone());
+
+ let (collector_name, logo, theme) = match ui_config {
+ Some(config) => (
+ config.collector_name.clone(),
+ config.logo.clone(),
+ config.theme.clone(),
+ ),
+ None => (
+ fallback_ui_config.collector_name.clone(),
+ fallback_ui_config.logo.clone(),
+ fallback_ui_config.theme.clone(),
+ ),
+ };
+
+ let session_expiry = match req.session_expiry {
+ Some(expiry) => expiry,
+ None => default_config.expiry,
+ };
+ let merchant_id = merchant_account.merchant_id.clone();
+ let link = Secret::new(format!(
+ "{domain}/payout_link/initiate/{merchant_id}/{payout_link_id}"
+ ));
+
+ let payout_link_config = CollectLinkConfig {
+ theme,
+ logo,
+ collector_name,
+ };
+
+ let enabled_payment_methods = match (&req.enabled_payment_methods, &merchant_config) {
+ (Some(enabled_payment_methods), _) => enabled_payment_methods.clone(),
+ (None, Some(config)) => config.enabled_payment_methods.clone(),
+ _ => default_config.enabled_payment_methods.clone(),
+ };
+
+ let data = PaymentMethodCollectLinkData {
+ pm_collect_link_id: payout_link_id.clone(),
+ customer_id: customer_id.to_string(),
+ link,
+ sdk_host,
+ client_secret: Secret::new(client_secret),
+ session_expiry,
+ ui_config: payout_link_config,
+ enabled_payment_methods,
+ };
+
+ let _db_link_data =
+ create_pm_collect_db_entry(state, merchant_account, &data, return_url).await?;
+
+ Ok(Some(data))
+}