text stringlengths 70 351k | source stringclasses 4 values |
|---|---|
<|fim_prefix|>
// file: hyperswitch/crates/router/src/core/payments/tokenization.rs | crate: router
authorized_amount,
authorized_currency,
merchant_connector_id,
connector_mandate_id,
mandate_metadata,
connector_mandate_request_reference_id,
),
};
Ok(mandate_reference)
}
#[cfg(feature = "v1")]
pub fn update_connector_mandate_details_status(
merchant_connector_id: id_type::MerchantConnectorAccountId,
mut payment_mandate_reference: PaymentsMandateReference,
status: ConnectorMandateStatus,
) -> RouterResult<Option<CommonMandateReference>> {
let mandate_reference = {
payment_mandate_reference
.entry(merchant_connector_id)
.and_modify(|pm| {
let update_rec = PaymentsMandateReferenceRecord {
connector_mandate_id: pm.connector_mandate_id.clone(),
payment_method_type: pm.payment_method_type,
original_payment_authorized_amount: pm.original_payment_authorized_amount,
pub fn update_connector_mandate_details_status(
merchant_connector_id: id_type::MerchantConnectorAccountId,
mut payment_mandate_reference: PaymentsMandateReference,
status: ConnectorMandateStatus,
) -> RouterResult<Option<CommonMandateReference>> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/core/payments/tokenization.rs | crate: router
pub async fn save_in_locker(
_state: &SessionState,
_merchant_account: &domain::MerchantAccount,
_payment_method_request: api::PaymentMethodCreate,
) -> RouterResult<(
api_models::payment_methods::PaymentMethodResponse,
Option<payment_methods::transformers::DataDuplicationCheck>,
)> {
todo!()
}
#[cfg(all(feature = "v2", feature = "payment_methods_v2"))]
pub async fn save_network_token_in_locker(
_state: &SessionState,
_merchant_account: &domain::MerchantAccount,
_card_data: &domain::Card,
_payment_method_request: api::PaymentMethodCreate,
) -> RouterResult<(
Option<api_models::payment_methods::PaymentMethodResponse>,
Option<payment_methods::transformers::DataDuplicationCheck>,
Option<String>,
)> {
todo!()
}
pub async fn save_network_token_in_locker(
_state: &SessionState,
_merchant_account: &domain::MerchantAccount,
_card_data: &domain::Card,
_payment_method_request: api::PaymentMethodCreate,
) -> RouterResult<(
Option<api_models::payment_methods::PaymentMethodResponse>,
Option<payment_methods::transformers::DataDuplicationCheck>,
Option<String>,
)> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/core/payments/tokenization.rs | crate: router
use common_utils::{
crypto::Encryptable,
ext_traits::{AsyncExt, Encode, ValueExt},
id_type, pii,
};
use crate::{
consts,
core::{
errors::{self, ConnectorErrorExt, RouterResult, StorageErrorExt},
mandate,
payment_methods::{self, cards::create_encrypted_data, network_tokenization},
payments,
},
logger,
routes::{metrics, SessionState},
services,
types::{
self,
api::{self, CardDetailFromLocker, CardDetailsPaymentMethod, PaymentMethodCreateExt},
domain,
storage::enums as storage_enums,
},
utils::{generate_id, OptionExt},
};
pub fn create_payment_method_metadata(
metadata: Option<&pii::SecretSerdeValue>,
connector_token: Option<(String, String)>,
) -> RouterResult<Option<serde_json::Value>> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
// file: hyperswitch/crates/router/src/core/payments/tokenization.rs | crate: router
use api_models::payment_methods::PaymentMethodsData;
use api_models::{
payment_methods::PaymentMethodDataWalletInfo, payments::ConnectorMandateReferenceId,
};
use crate::{
consts,
core::{
errors::{self, ConnectorErrorExt, RouterResult, StorageErrorExt},
mandate,
payment_methods::{self, cards::create_encrypted_data, network_tokenization},
payments,
},
logger,
routes::{metrics, SessionState},
services,
types::{
self,
api::{self, CardDetailFromLocker, CardDetailsPaymentMethod, PaymentMethodCreateExt},
domain,
storage::enums as storage_enums,
},
utils::{generate_id, OptionExt},
};
pub async fn save_network_token_in_locker(
_state: &SessionState,
_merchant_account: &domain::MerchantAccount,
_card_data: &domain::Card,
_payment_method_request: api::PaymentMethodCreate,
) -> RouterResult<(
Option<api_models::payment_methods::PaymentMethodResponse>,
Option<payment_methods::transformers::DataDuplicationCheck>,
Option<String>,
)> {
todo!()
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/core/payments/tokenization.rs | crate: router
use api_models::payment_methods::PaymentMethodsData;
use api_models::{
payment_methods::PaymentMethodDataWalletInfo, payments::ConnectorMandateReferenceId,
};
use crate::{
consts,
core::{
errors::{self, ConnectorErrorExt, RouterResult, StorageErrorExt},
mandate,
payment_methods::{self, cards::create_encrypted_data, network_tokenization},
payments,
},
logger,
routes::{metrics, SessionState},
services,
types::{
self,
api::{self, CardDetailFromLocker, CardDetailsPaymentMethod, PaymentMethodCreateExt},
domain,
storage::enums as storage_enums,
},
utils::{generate_id, OptionExt},
};
pub async fn save_in_locker(
_state: &SessionState,
_merchant_account: &domain::MerchantAccount,
_payment_method_request: api::PaymentMethodCreate,
) -> RouterResult<(
api_models::payment_methods::PaymentMethodResponse,
Option<payment_methods::transformers::DataDuplicationCheck>,
)> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/core/payments/tokenization.rs | crate: router
use api_models::payment_methods::PaymentMethodsData;
use api_models::{
payment_methods::PaymentMethodDataWalletInfo, payments::ConnectorMandateReferenceId,
};
use crate::{
consts,
core::{
errors::{self, ConnectorErrorExt, RouterResult, StorageErrorExt},
mandate,
payment_methods::{self, cards::create_encrypted_data, network_tokenization},
payments,
},
logger,
routes::{metrics, SessionState},
services,
types::{
self,
api::{self, CardDetailFromLocker, CardDetailsPaymentMethod, PaymentMethodCreateExt},
domain,
storage::enums as storage_enums,
},
utils::{generate_id, OptionExt},
};
async fn skip_saving_card_in_locker(
merchant_account: &domain::MerchantAccount,
payment_method_request: api::PaymentMethodCreate,
) -> RouterResult<(
api_models::payment_methods::PaymentMethodResponse,
Option<payment_methods::transformers::DataDuplicationCheck>,
)> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/core/payments/tokenization.rs | crate: router
use common_utils::{
crypto::Encryptable,
ext_traits::{AsyncExt, Encode, ValueExt},
id_type, pii,
};
use masking::{ExposeInterface, Secret};
use crate::{
consts,
core::{
errors::{self, ConnectorErrorExt, RouterResult, StorageErrorExt},
mandate,
payment_methods::{self, cards::create_encrypted_data, network_tokenization},
payments,
},
logger,
routes::{metrics, SessionState},
services,
types::{
self,
api::{self, CardDetailFromLocker, CardDetailsPaymentMethod, PaymentMethodCreateExt},
domain,
storage::enums as storage_enums,
},
utils::{generate_id, OptionExt},
};
pub async fn save_payment_method<FData>(
_state: &SessionState,
_connector_name: String,
_save_payment_method_data: SavePaymentMethodData<FData>,
_customer_id: Option<id_type::CustomerId>,
_merchant_account: &domain::MerchantAccount,
_payment_method_type: Option<storage_enums::PaymentMethodType>,
_key_store: &domain::MerchantKeyStore,
_billing_name: Option<Secret<String>>,
_payment_method_billing_address: Option<&api::Address>,
_business_profile: &domain::Profile,
_connector_mandate_request_reference_id: Option<String>,
) -> RouterResult<SavePaymentMethodDataResponse>
where
FData: mandate::MandateBehaviour + Clone,
{
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/core/payments/tokenization.rs | crate: router
use crate::{
consts,
core::{
errors::{self, ConnectorErrorExt, RouterResult, StorageErrorExt},
mandate,
payment_methods::{self, cards::create_encrypted_data, network_tokenization},
payments,
},
logger,
routes::{metrics, SessionState},
services,
types::{
self,
api::{self, CardDetailFromLocker, CardDetailsPaymentMethod, PaymentMethodCreateExt},
domain,
storage::enums as storage_enums,
},
utils::{generate_id, OptionExt},
};
fn from(router_data: &types::RouterData<F, Req, types::PaymentsResponseData>) -> Self {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/core/payments/tokenization.rs | crate: router
use api_models::{
payment_methods::PaymentMethodDataWalletInfo, payments::ConnectorMandateReferenceId,
};
use router_env::{instrument, tracing};
use super::helpers;
use crate::{
consts,
core::{
errors::{self, ConnectorErrorExt, RouterResult, StorageErrorExt},
mandate,
payment_methods::{self, cards::create_encrypted_data, network_tokenization},
payments,
},
logger,
routes::{metrics, SessionState},
services,
types::{
self,
api::{self, CardDetailFromLocker, CardDetailsPaymentMethod, PaymentMethodCreateExt},
domain,
storage::enums as storage_enums,
},
utils::{generate_id, OptionExt},
};
pub async fn add_payment_method_token<F: Clone, T: types::Tokenizable + Clone>(
state: &SessionState,
connector: &api::ConnectorData,
tokenization_action: &payments::TokenizationAction,
router_data: &mut types::RouterData<F, T, types::PaymentsResponseData>,
pm_token_request_data: types::PaymentMethodTokenizationData,
should_continue_payment: bool,
) -> RouterResult<types::PaymentMethodTokenResult> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/core/payments/tokenization.rs | crate: router
use api_models::payment_methods::PaymentMethodsData;
use api_models::{
payment_methods::PaymentMethodDataWalletInfo, payments::ConnectorMandateReferenceId,
};
use common_enums::{ConnectorMandateStatus, PaymentMethod};
use common_utils::{
crypto::Encryptable,
ext_traits::{AsyncExt, Encode, ValueExt},
id_type, pii,
};
use error_stack::{report, ResultExt};
use hyperswitch_domain_models::mandates::{
CommonMandateReference, PaymentsMandateReference, PaymentsMandateReferenceRecord,
};
use masking::{ExposeInterface, Secret};
use crate::{
consts,
core::{
errors::{self, ConnectorErrorExt, RouterResult, StorageErrorExt},
mandate,
payment_methods::{self, cards::create_encrypted_data, network_tokenization},
payments,
},
logger,
routes::{metrics, SessionState},
services,
types::{
self,
api::{self, CardDetailFromLocker, CardDetailsPaymentMethod, PaymentMethodCreateExt},
domain,
storage::enums as storage_enums,
},
utils::{generate_id, OptionExt},
};
pub async fn save_payment_method<FData>(
state: &SessionState,
connector_name: String,
save_payment_method_data: SavePaymentMethodData<FData>,
customer_id: Option<id_type::CustomerId>,
merchant_account: &domain::MerchantAccount,
payment_method_type: Option<storage_enums::PaymentMethodType>,
key_store: &domain::MerchantKeyStore,
billing_name: Option<Secret<String>>,
payment_method_billing_address: Option<&hyperswitch_domain_models::address::Address>,
business_profile: &domain::Profile,
mut original_connector_mandate_reference_id: Option<ConnectorMandateReferenceId>,
merchant_connector_id: Option<id_type::MerchantConnectorAccountId>,
) -> RouterResult<SavePaymentMethodDataResponse>
where
FData: mandate::MandateBehaviour + Clone,
{
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/core/payments/types.rs | crate: router
use common_utils::{
errors::CustomResult,
ext_traits::{Encode, OptionExt},
types::{self as common_types, ConnectorTransactionIdTrait},
};
pub use hyperswitch_domain_models::router_request_types::{
AuthenticationData, SplitRefundsRequest, StripeSplitRefund, SurchargeDetails,
};
use redis_interface::errors::RedisError;
use router_env::{instrument, logger, tracing};
use crate::{
consts as router_consts,
core::errors::{self, RouterResult},
routes::SessionState,
types::{
domain::Profile,
storage::{self, enums as storage_enums},
transformers::ForeignTryFrom,
},
};
pub async fn persist_individual_surcharge_details_in_redis(
&self,
state: &SessionState,
business_profile: &Profile,
) -> RouterResult<()> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/core/payments/types.rs | crate: router
pub use hyperswitch_domain_models::router_request_types::{
AuthenticationData, SplitRefundsRequest, StripeSplitRefund, SurchargeDetails,
};
pub fn get_surcharge_details_redis_hashset_key(surcharge_key: &SurchargeKey) -> String {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/core/payments/types.rs | crate: router
use hyperswitch_domain_models::payments::payment_attempt::PaymentAttempt;
pub use hyperswitch_domain_models::router_request_types::{
AuthenticationData, SplitRefundsRequest, StripeSplitRefund, SurchargeDetails,
};
fn foreign_try_from(
(surcharge_details, payment_attempt): (&SurchargeDetails, &PaymentAttempt),
) -> Result<Self, Self::Error> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/core/payments/types.rs | crate: router
use common_utils::{
errors::CustomResult,
ext_traits::{Encode, OptionExt},
types::{self as common_types, ConnectorTransactionIdTrait},
};
pub use hyperswitch_domain_models::router_request_types::{
AuthenticationData, SplitRefundsRequest, StripeSplitRefund, SurchargeDetails,
};
use redis_interface::errors::RedisError;
use router_env::{instrument, logger, tracing};
use crate::{
consts as router_consts,
core::errors::{self, RouterResult},
routes::SessionState,
types::{
domain::Profile,
storage::{self, enums as storage_enums},
transformers::ForeignTryFrom,
},
};
pub async fn get_individual_surcharge_detail_from_redis(
state: &SessionState,
surcharge_key: SurchargeKey,
payment_attempt_id: &str,
) -> CustomResult<SurchargeDetails, RedisError> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
// file: hyperswitch/crates/router/src/core/payments/types.rs | crate: router
pub use hyperswitch_domain_models::router_request_types::{
AuthenticationData, SplitRefundsRequest, StripeSplitRefund, SurchargeDetails,
};
pub fn get_surcharge_details_redis_hashset_key(surcharge_key: &SurchargeKey) -> String {
match surcharge_key {
SurchargeKey::Token(token) => {
format!("token_{}", token)
}
SurchargeKey::PaymentMethodData(payment_method, payment_method_type, card_network) => {
if let Some(card_network) = card_network {
format!(
"{}_{}_{}",
payment_method, payment_method_type, card_network
)
} else {
format!("{}_{}", payment_method, payment_method_type)
}
}
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/core/payments/types.rs | crate: router
use common_utils::{
errors::CustomResult,
ext_traits::{Encode, OptionExt},
types::{self as common_types, ConnectorTransactionIdTrait},
};
pub use hyperswitch_domain_models::router_request_types::{
AuthenticationData, SplitRefundsRequest, StripeSplitRefund, SurchargeDetails,
};
use crate::{
consts as router_consts,
core::errors::{self, RouterResult},
routes::SessionState,
types::{
domain::Profile,
storage::{self, enums as storage_enums},
transformers::ForeignTryFrom,
},
};
pub fn get_individual_surcharge_key_value_pairs(&self) -> Vec<(String, SurchargeDetails)> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/core/payments/types.rs | crate: router
pub use hyperswitch_domain_models::router_request_types::{
AuthenticationData, SplitRefundsRequest, StripeSplitRefund, SurchargeDetails,
};
pub fn get_surcharge_metadata_redis_key(payment_attempt_id: &str) -> String {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/core/payments/types.rs | crate: router
use common_utils::{
errors::CustomResult,
ext_traits::{Encode, OptionExt},
types::{self as common_types, ConnectorTransactionIdTrait},
};
pub use hyperswitch_domain_models::router_request_types::{
AuthenticationData, SplitRefundsRequest, StripeSplitRefund, SurchargeDetails,
};
use crate::{
consts as router_consts,
core::errors::{self, RouterResult},
routes::SessionState,
types::{
domain::Profile,
storage::{self, enums as storage_enums},
transformers::ForeignTryFrom,
},
};
pub fn get_surcharge_details(&self, surcharge_key: SurchargeKey) -> Option<&SurchargeDetails> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/core/payments/types.rs | crate: router
use common_utils::{
errors::CustomResult,
ext_traits::{Encode, OptionExt},
types::{self as common_types, ConnectorTransactionIdTrait},
};
pub use hyperswitch_domain_models::router_request_types::{
AuthenticationData, SplitRefundsRequest, StripeSplitRefund, SurchargeDetails,
};
use crate::{
consts as router_consts,
core::errors::{self, RouterResult},
routes::SessionState,
types::{
domain::Profile,
storage::{self, enums as storage_enums},
transformers::ForeignTryFrom,
},
};
pub fn insert_surcharge_details(
&mut self,
surcharge_key: SurchargeKey,
surcharge_details: SurchargeDetails,
) {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/core/payments/types.rs | crate: router
use common_utils::{
errors::CustomResult,
ext_traits::{Encode, OptionExt},
types::{self as common_types, ConnectorTransactionIdTrait},
};
pub use hyperswitch_domain_models::router_request_types::{
AuthenticationData, SplitRefundsRequest, StripeSplitRefund, SurchargeDetails,
};
use crate::{
consts as router_consts,
core::errors::{self, RouterResult},
routes::SessionState,
types::{
domain::Profile,
storage::{self, enums as storage_enums},
transformers::ForeignTryFrom,
},
};
pub fn get_surcharge_results_size(&self) -> usize {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/core/payments/types.rs | crate: router
use common_utils::{
errors::CustomResult,
ext_traits::{Encode, OptionExt},
types::{self as common_types, ConnectorTransactionIdTrait},
};
pub use hyperswitch_domain_models::router_request_types::{
AuthenticationData, SplitRefundsRequest, StripeSplitRefund, SurchargeDetails,
};
use crate::{
consts as router_consts,
core::errors::{self, RouterResult},
routes::SessionState,
types::{
domain::Profile,
storage::{self, enums as storage_enums},
transformers::ForeignTryFrom,
},
};
pub fn is_empty_result(&self) -> bool {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/core/payments/types.rs | crate: router
use std::{collections::HashMap, num::TryFromIntError};
pub use hyperswitch_domain_models::router_request_types::{
AuthenticationData, SplitRefundsRequest, StripeSplitRefund, SurchargeDetails,
};
pub fn new(payment_attempt_id: String) -> Self {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
// file: hyperswitch/crates/router/src/core/payments/types.rs | crate: router
use hyperswitch_domain_models::payments::payment_attempt::PaymentAttempt;
pub use hyperswitch_domain_models::router_request_types::{
AuthenticationData, SplitRefundsRequest, StripeSplitRefund, SurchargeDetails,
};
fn foreign_try_from(
(surcharge_details, payment_attempt): (&SurchargeDetails, &PaymentAttempt),
) -> Result<Self, Self::Error> {
let currency = payment_attempt.currency.unwrap_or_default();
let display_surcharge_amount = currency
.to_currency_base_unit_asf64(surcharge_details.surcharge_amount.get_amount_as_i64())?;
let display_tax_on_surcharge_amount = currency.to_currency_base_unit_asf64(
surcharge_details
.tax_on_surcharge_amount
.get_amount_as_i64(),
)?;
let display_total_surcharge_amount = currency.to_currency_base_unit_asf64(
(surcharge_details.surcharge_amount + surcharge_details.tax_on_surcharge_amount)
.get_amount_as_i64(),
)?;
Ok(Self {
surcharge: surcharge_details.surcharge.clone().into(),
tax_on_surcharge: surcharge_details.tax_on_surcharge.clone().map(Into::into),
display_surcharge_amount,
display_tax_on_surcharge_amount,
display_total_surcharge_amount,
})
} | ast_fragments |
// file: hyperswitch/crates/router/src/core/payments/types.rs | crate: router
use hyperswitch_domain_models::payments::payment_attempt::PaymentAttempt;
pub use hyperswitch_domain_models::router_request_types::{
AuthenticationData, SplitRefundsRequest, StripeSplitRefund, SurchargeDetails,
};
fn foreign_try_from(
(surcharge_details, payment_attempt): (&SurchargeDetails, &PaymentAttempt),
) -> Result<Self, Self::Error> {
todo!()
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/core/payments/types.rs | crate: router
use common_utils::{
errors::CustomResult,
ext_traits::{Encode, OptionExt},
types::{self as common_types, ConnectorTransactionIdTrait},
};
pub use hyperswitch_domain_models::router_request_types::{
AuthenticationData, SplitRefundsRequest, StripeSplitRefund, SurchargeDetails,
};
use crate::{
consts as router_consts,
core::errors::{self, RouterResult},
routes::SessionState,
types::{
domain::Profile,
storage::{self, enums as storage_enums},
transformers::ForeignTryFrom,
},
};
pub fn get_pending_captures_without_connector_capture_id(&self) -> Vec<&storage::Capture> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/core/payments/types.rs | crate: router
use common_utils::{
errors::CustomResult,
ext_traits::{Encode, OptionExt},
types::{self as common_types, ConnectorTransactionIdTrait},
};
pub use hyperswitch_domain_models::router_request_types::{
AuthenticationData, SplitRefundsRequest, StripeSplitRefund, SurchargeDetails,
};
use crate::{
consts as router_consts,
core::errors::{self, RouterResult},
routes::SessionState,
types::{
domain::Profile,
storage::{self, enums as storage_enums},
transformers::ForeignTryFrom,
},
};
pub fn get_pending_connector_capture_ids(&self) -> Vec<String> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/core/payments/types.rs | crate: router
use common_utils::{
errors::CustomResult,
ext_traits::{Encode, OptionExt},
types::{self as common_types, ConnectorTransactionIdTrait},
};
pub use hyperswitch_domain_models::router_request_types::{
AuthenticationData, SplitRefundsRequest, StripeSplitRefund, SurchargeDetails,
};
use crate::{
consts as router_consts,
core::errors::{self, RouterResult},
routes::SessionState,
types::{
domain::Profile,
storage::{self, enums as storage_enums},
transformers::ForeignTryFrom,
},
};
pub fn get_latest_capture(&self) -> &storage::Capture {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/core/payments/types.rs | crate: router
use common_utils::{
errors::CustomResult,
ext_traits::{Encode, OptionExt},
types::{self as common_types, ConnectorTransactionIdTrait},
};
pub use hyperswitch_domain_models::router_request_types::{
AuthenticationData, SplitRefundsRequest, StripeSplitRefund, SurchargeDetails,
};
use crate::{
consts as router_consts,
core::errors::{self, RouterResult},
routes::SessionState,
types::{
domain::Profile,
storage::{self, enums as storage_enums},
transformers::ForeignTryFrom,
},
};
pub fn get_capture_by_connector_capture_id(
&self,
connector_capture_id: &String,
) -> Option<&storage::Capture> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/core/payments/types.rs | crate: router
use common_utils::{
errors::CustomResult,
ext_traits::{Encode, OptionExt},
types::{self as common_types, ConnectorTransactionIdTrait},
};
pub use hyperswitch_domain_models::router_request_types::{
AuthenticationData, SplitRefundsRequest, StripeSplitRefund, SurchargeDetails,
};
use crate::{
consts as router_consts,
core::errors::{self, RouterResult},
routes::SessionState,
types::{
domain::Profile,
storage::{self, enums as storage_enums},
transformers::ForeignTryFrom,
},
};
pub fn get_capture_by_capture_id(&self, capture_id: String) -> Option<&storage::Capture> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/core/payments/types.rs | crate: router
use common_utils::{
errors::CustomResult,
ext_traits::{Encode, OptionExt},
types::{self as common_types, ConnectorTransactionIdTrait},
};
pub use hyperswitch_domain_models::router_request_types::{
AuthenticationData, SplitRefundsRequest, StripeSplitRefund, SurchargeDetails,
};
use crate::{
consts as router_consts,
core::errors::{self, RouterResult},
routes::SessionState,
types::{
domain::Profile,
storage::{self, enums as storage_enums},
transformers::ForeignTryFrom,
},
};
pub fn get_all_captures(&self) -> Vec<&storage::Capture> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/core/payments/types.rs | crate: router
use common_utils::{
errors::CustomResult,
ext_traits::{Encode, OptionExt},
types::{self as common_types, ConnectorTransactionIdTrait},
};
pub use hyperswitch_domain_models::router_request_types::{
AuthenticationData, SplitRefundsRequest, StripeSplitRefund, SurchargeDetails,
};
use crate::{
consts as router_consts,
core::errors::{self, RouterResult},
routes::SessionState,
types::{
domain::Profile,
storage::{self, enums as storage_enums},
transformers::ForeignTryFrom,
},
};
pub fn get_pending_captures(&self) -> Vec<&storage::Capture> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/core/payments/types.rs | crate: router
use common_utils::{
errors::CustomResult,
ext_traits::{Encode, OptionExt},
types::{self as common_types, ConnectorTransactionIdTrait},
};
pub use hyperswitch_domain_models::router_request_types::{
AuthenticationData, SplitRefundsRequest, StripeSplitRefund, SurchargeDetails,
};
use crate::{
consts as router_consts,
core::errors::{self, RouterResult},
routes::SessionState,
types::{
domain::Profile,
storage::{self, enums as storage_enums},
transformers::ForeignTryFrom,
},
};
pub fn get_attempt_status(
&self,
authorized_amount: common_types::MinorUnit,
) -> storage_enums::AttemptStatus {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/core/payments/types.rs | crate: router
use std::{collections::HashMap, num::TryFromIntError};
use common_utils::{
errors::CustomResult,
ext_traits::{Encode, OptionExt},
types::{self as common_types, ConnectorTransactionIdTrait},
};
pub use hyperswitch_domain_models::router_request_types::{
AuthenticationData, SplitRefundsRequest, StripeSplitRefund, SurchargeDetails,
};
use crate::{
consts as router_consts,
core::errors::{self, RouterResult},
routes::SessionState,
types::{
domain::Profile,
storage::{self, enums as storage_enums},
transformers::ForeignTryFrom,
},
};
pub fn get_status_count(&self) -> HashMap<storage_enums::CaptureStatus, i16> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/core/payments/types.rs | crate: router
use common_utils::{
errors::CustomResult,
ext_traits::{Encode, OptionExt},
types::{self as common_types, ConnectorTransactionIdTrait},
};
pub use hyperswitch_domain_models::router_request_types::{
AuthenticationData, SplitRefundsRequest, StripeSplitRefund, SurchargeDetails,
};
use redis_interface::errors::RedisError;
use crate::{
consts as router_consts,
core::errors::{self, RouterResult},
routes::SessionState,
types::{
domain::Profile,
storage::{self, enums as storage_enums},
transformers::ForeignTryFrom,
},
};
pub fn get_captures_count(&self) -> RouterResult<i16> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/core/payments/types.rs | crate: router
use common_utils::{
errors::CustomResult,
ext_traits::{Encode, OptionExt},
types::{self as common_types, ConnectorTransactionIdTrait},
};
pub use hyperswitch_domain_models::router_request_types::{
AuthenticationData, SplitRefundsRequest, StripeSplitRefund, SurchargeDetails,
};
use crate::{
consts as router_consts,
core::errors::{self, RouterResult},
routes::SessionState,
types::{
domain::Profile,
storage::{self, enums as storage_enums},
transformers::ForeignTryFrom,
},
};
pub fn get_total_charged_amount(&self) -> common_types::MinorUnit {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/core/payments/types.rs | crate: router
use common_utils::{
errors::CustomResult,
ext_traits::{Encode, OptionExt},
types::{self as common_types, ConnectorTransactionIdTrait},
};
pub use hyperswitch_domain_models::router_request_types::{
AuthenticationData, SplitRefundsRequest, StripeSplitRefund, SurchargeDetails,
};
use crate::{
consts as router_consts,
core::errors::{self, RouterResult},
routes::SessionState,
types::{
domain::Profile,
storage::{self, enums as storage_enums},
transformers::ForeignTryFrom,
},
};
pub fn get_total_blocked_amount(&self) -> common_types::MinorUnit {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/core/payments/types.rs | crate: router
use common_utils::{
errors::CustomResult,
ext_traits::{Encode, OptionExt},
types::{self as common_types, ConnectorTransactionIdTrait},
};
pub use hyperswitch_domain_models::router_request_types::{
AuthenticationData, SplitRefundsRequest, StripeSplitRefund, SurchargeDetails,
};
use crate::{
consts as router_consts,
core::errors::{self, RouterResult},
routes::SessionState,
types::{
domain::Profile,
storage::{self, enums as storage_enums},
transformers::ForeignTryFrom,
},
};
pub fn update_capture(&mut self, updated_capture: storage::Capture) {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/core/payments/types.rs | crate: router
pub use hyperswitch_domain_models::router_request_types::{
AuthenticationData, SplitRefundsRequest, StripeSplitRefund, SurchargeDetails,
};
use crate::{
consts as router_consts,
core::errors::{self, RouterResult},
routes::SessionState,
types::{
domain::Profile,
storage::{self, enums as storage_enums},
transformers::ForeignTryFrom,
},
};
pub fn new_for_create(
mut previous_captures: Vec<storage::Capture>,
new_capture: storage::Capture,
) -> Self {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/core/payments/types.rs | crate: router
use common_utils::{
errors::CustomResult,
ext_traits::{Encode, OptionExt},
types::{self as common_types, ConnectorTransactionIdTrait},
};
pub use hyperswitch_domain_models::router_request_types::{
AuthenticationData, SplitRefundsRequest, StripeSplitRefund, SurchargeDetails,
};
use redis_interface::errors::RedisError;
use crate::{
consts as router_consts,
core::errors::{self, RouterResult},
routes::SessionState,
types::{
domain::Profile,
storage::{self, enums as storage_enums},
transformers::ForeignTryFrom,
},
};
pub fn new_for_sync(
captures: Vec<storage::Capture>,
expand_captures: Option<bool>,
) -> RouterResult<Self> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/core/payments/transformers.rs | crate: router
use api_models::payments::{
Address, ConnectorMandateReferenceId, CustomerDetails, CustomerDetailsResponse, FrmMessage,
RequestSurchargeDetails,
};
use hyperswitch_domain_models::{payments::payment_intent::CustomerData, router_request_types};
use crate::{
configs::settings::ConnectorRequestReferenceIdConfig,
core::{
errors::{self, RouterResponse, RouterResult},
payments::{self, helpers},
utils as core_utils,
},
headers::X_PAYMENT_CONFIRM_SOURCE,
routes::{metrics, SessionState},
services::{self, RedirectForm},
types::{
self,
api::{self, ConnectorTransactionId},
domain,
storage::{self, enums},
transformers::{ForeignFrom, ForeignInto, ForeignTryFrom},
MultipleCaptureRequestData,
},
utils::{OptionExt, ValueExt},
};
fn foreign_from(req: (Self, Option<&api_models::payments::AdditionalPaymentData>)) -> Self {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/core/payments/transformers.rs | crate: router
use api_models::payments::{
Address, ConnectorMandateReferenceId, CustomerDetails, CustomerDetailsResponse, FrmMessage,
RequestSurchargeDetails,
};
use diesel_models::{
ephemeral_key,
payment_attempt::ConnectorMandateReferenceId as DieselConnectorMandateReferenceId,
};
fn foreign_from(config: diesel_models::PaymentLinkConfigRequestForPayments) -> Self {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
// file: hyperswitch/crates/router/src/core/payments/transformers.rs | crate: router
use api_models::payments::{
Address, ConnectorMandateReferenceId, CustomerDetails, CustomerDetailsResponse, FrmMessage,
RequestSurchargeDetails,
};
use diesel_models::{
ephemeral_key,
payment_attempt::ConnectorMandateReferenceId as DieselConnectorMandateReferenceId,
};
fn foreign_from(config: api_models::admin::PaymentLinkConfigRequest) -> Self {
Self {
theme: config.theme,
logo: config.logo,
seller_name: config.seller_name,
sdk_layout: config.sdk_layout,
display_sdk_only: config.display_sdk_only,
enabled_saved_payment_method: config.enabled_saved_payment_method,
hide_card_nickname_field: config.hide_card_nickname_field,
show_card_form_by_default: config.show_card_form_by_default,
details_layout: config.details_layout,
transaction_details: config.transaction_details.map(|transaction_details| {
transaction_details
.iter()
.map(|details| {
diesel_models::PaymentLinkTransactionDetails::foreign_from(details.clone())
})
.collect()
}),
background_image: config.background_image.map(|background_image| {
diesel_models::business_profile::PaymentLinkBackgroundImageConfig::foreign_from(
background_image.clone(),
)
}),
payment_button_text: config.payment_button_text,
custom_message_for_card_terms: config.custom_message_for_card_terms,
payment_button_colour: config.payment_button_colour,
skip_status_screen: config.skip_status_screen,
background_colour: config.background_colour,
payment_button_text_colour: config.payment_button_text_colour,
sdk_ui_rules: config.sdk_ui_rules,
payment_link_ui_rules: config.payment_link_ui_rules,
enable_button_only_on_form_ready: config.enable_button_only_on_form_ready,
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/core/payments/transformers.rs | crate: router
amount_capturable: attempt_amount_details
.map(|attempt| attempt.get_amount_capturable())
.unwrap_or(MinorUnit::zero()),
amount_captured: intent_amount_details.amount_captured,
}
}
}
#[cfg(feature = "v2")]
impl ForeignFrom<&hyperswitch_domain_models::payments::payment_attempt::PaymentAttempt>
for api_models::payments::PaymentAttemptResponse
{
fn foreign_from(
attempt: &hyperswitch_domain_models::payments::payment_attempt::PaymentAttempt,
) -> Self {
Self {
id: attempt.get_id().to_owned(),
status: attempt.status,
amount: api_models::payments::PaymentAttemptAmountDetails::foreign_from(
&attempt.amount_details,
),
connector: attempt.connector.clone(),
error: attempt
.error
.as_ref()
fn foreign_from(
attempt: &hyperswitch_domain_models::payments::payment_attempt::PaymentAttempt,
) -> Self {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/core/payments/transformers.rs | crate: router
use api_models::payments::{
Address, ConnectorMandateReferenceId, CustomerDetails, CustomerDetailsResponse, FrmMessage,
RequestSurchargeDetails,
};
use common_utils::{
consts::X_HS_LATENCY,
fp_utils, pii,
types::{
self as common_utils_type, AmountConvertor, MinorUnit, StringMajorUnit,
StringMajorUnitForConnector,
},
};
use diesel_models::{
ephemeral_key,
payment_attempt::ConnectorMandateReferenceId as DieselConnectorMandateReferenceId,
};
use hyperswitch_domain_models::ApiModelToDieselModelConvertor;
use hyperswitch_domain_models::{payments::payment_intent::CustomerData, router_request_types};
use crate::{
configs::settings::ConnectorRequestReferenceIdConfig,
core::{
errors::{self, RouterResponse, RouterResult},
payments::{self, helpers},
utils as core_utils,
},
headers::X_PAYMENT_CONFIRM_SOURCE,
routes::{metrics, SessionState},
services::{self, RedirectForm},
types::{
self,
api::{self, ConnectorTransactionId},
domain,
storage::{self, enums},
transformers::{ForeignFrom, ForeignInto, ForeignTryFrom},
MultipleCaptureRequestData,
},
utils::{OptionExt, ValueExt},
};
fn foreign_from(
(intent_amount_details, attempt_amount_details): (
&hyperswitch_domain_models::payments::AmountDetails,
Option<&hyperswitch_domain_models::payments::payment_attempt::AttemptAmountDetails>,
),
) -> Self {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/core/payments/transformers.rs | crate: router
use api_models::payments::{
Address, ConnectorMandateReferenceId, CustomerDetails, CustomerDetailsResponse, FrmMessage,
RequestSurchargeDetails,
};
use common_utils::{
consts::X_HS_LATENCY,
fp_utils, pii,
types::{
self as common_utils_type, AmountConvertor, MinorUnit, StringMajorUnit,
StringMajorUnitForConnector,
},
};
use diesel_models::{
ephemeral_key,
payment_attempt::ConnectorMandateReferenceId as DieselConnectorMandateReferenceId,
};
use hyperswitch_domain_models::{payments::payment_intent::CustomerData, router_request_types};
use super::{flows::Feature, types::AuthenticationData, OperationSessionGetters, PaymentData};
use crate::{
configs::settings::ConnectorRequestReferenceIdConfig,
core::{
errors::{self, RouterResponse, RouterResult},
payments::{self, helpers},
utils as core_utils,
},
headers::X_PAYMENT_CONFIRM_SOURCE,
routes::{metrics, SessionState},
services::{self, RedirectForm},
types::{
self,
api::{self, ConnectorTransactionId},
domain,
storage::{self, enums},
transformers::{ForeignFrom, ForeignInto, ForeignTryFrom},
MultipleCaptureRequestData,
},
utils::{OptionExt, ValueExt},
};
fn try_from(additional_data: PaymentAdditionalData<'_, F>) -> Result<Self, Self::Error> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
// file: hyperswitch/crates/router/src/core/payments/transformers.rs | crate: router
use common_utils::{
consts::X_HS_LATENCY,
fp_utils, pii,
types::{
self as common_utils_type, AmountConvertor, MinorUnit, StringMajorUnit,
StringMajorUnitForConnector,
},
};
use super::{flows::Feature, types::AuthenticationData, OperationSessionGetters, PaymentData};
use crate::{
configs::settings::ConnectorRequestReferenceIdConfig,
core::{
errors::{self, RouterResponse, RouterResult},
payments::{self, helpers},
utils as core_utils,
},
headers::X_PAYMENT_CONFIRM_SOURCE,
routes::{metrics, SessionState},
services::{self, RedirectForm},
types::{
self,
api::{self, ConnectorTransactionId},
domain,
storage::{self, enums},
transformers::{ForeignFrom, ForeignInto, ForeignTryFrom},
MultipleCaptureRequestData,
},
utils::{OptionExt, ValueExt},
};
fn foreign_try_from(
capture_sync_response: types::CaptureSyncResponse,
) -> Result<Self, Self::Error> {
match capture_sync_response {
types::CaptureSyncResponse::Success {
resource_id,
status,
connector_response_reference_id,
..
} => {
let (connector_capture_id, processor_capture_data) = match resource_id {
types::ResponseId::EncodedData(_) | types::ResponseId::NoResponseId => {
(None, None)
}
types::ResponseId::ConnectorTransactionId(id) => {
let (txn_id, txn_data) =
common_utils_type::ConnectorTransactionId::form_id_and_data(id);
(Some(txn_id), txn_data)
}
};
Ok(Self::ResponseUpdate {
status: enums::CaptureStatus::foreign_try_from(status)?,
connector_capture_id,
connector_response_reference_id,
processor_capture_data,
})
}
types::CaptureSyncResponse::Error {
code,
message,
reason,
status_code,
..
} => Ok(Self::ErrorUpdate {
status: match status_code {
500..=511 => enums::CaptureStatus::Pending,
_ => enums::CaptureStatus::Failed,
},
error_code: Some(code),
error_message: Some(message),
error_reason: reason,
}),
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/core/payments/transformers.rs | crate: router
use api_models::payments::{
Address, ConnectorMandateReferenceId, CustomerDetails, CustomerDetailsResponse, FrmMessage,
RequestSurchargeDetails,
};
use common_utils::{
consts::X_HS_LATENCY,
fp_utils, pii,
types::{
self as common_utils_type, AmountConvertor, MinorUnit, StringMajorUnit,
StringMajorUnitForConnector,
},
};
use diesel_models::{
ephemeral_key,
payment_attempt::ConnectorMandateReferenceId as DieselConnectorMandateReferenceId,
};
use hyperswitch_domain_models::{payments::payment_intent::CustomerData, router_request_types};
use super::{flows::Feature, types::AuthenticationData, OperationSessionGetters, PaymentData};
use crate::{
configs::settings::ConnectorRequestReferenceIdConfig,
core::{
errors::{self, RouterResponse, RouterResult},
payments::{self, helpers},
utils as core_utils,
},
headers::X_PAYMENT_CONFIRM_SOURCE,
routes::{metrics, SessionState},
services::{self, RedirectForm},
types::{
self,
api::{self, ConnectorTransactionId},
domain,
storage::{self, enums},
transformers::{ForeignFrom, ForeignInto, ForeignTryFrom},
MultipleCaptureRequestData,
},
utils::{OptionExt, ValueExt},
};
fn foreign_from(
(apple_pay_recurring_details, net_amount): (
diesel_models::types::ApplePayRecurringDetails,
StringMajorUnit,
),
) -> Self {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
// file: hyperswitch/crates/router/src/core/payments/transformers.rs | crate: router
connector_transaction_id: connector
.connector
.connector_transaction_id(payment_data.payment_attempt.clone())?
.ok_or(errors::ApiErrorResponse::ResourceIdNotFound)?,
})
}
}
#[cfg(feature = "v2")]
impl<F: Clone> TryFrom<PaymentAdditionalData<'_, F>> for types::PaymentsCaptureData {
type Error = error_stack::Report<errors::ApiErrorResponse>;
fn try_from(additional_data: PaymentAdditionalData<'_, F>) -> Result<Self, Self::Error> {
use masking::ExposeOptionInterface;
let payment_data = additional_data.payment_data;
let connector = api::ConnectorData::get_connector_by_name(
&additional_data.state.conf.connectors,
&additional_data.connector_name,
api::GetToken::Connector,
payment_data.payment_attempt.merchant_connector_id.clone(),
)?;
let amount_to_capture = payment_data
.payment_attempt
.amount_details
fn try_from(additional_data: PaymentAdditionalData<'_, F>) -> Result<Self, Self::Error> {
use masking::ExposeOptionInterface;
let payment_data = additional_data.payment_data;
let connector = api::ConnectorData::get_connector_by_name(
&additional_data.state.conf.connectors,
&additional_data.connector_name,
api::GetToken::Connector,
payment_data.payment_attempt.merchant_connector_id.clone(),
)?;
let amount_to_capture = payment_data
.payment_attempt
.amount_details
.get_amount_to_capture()
.unwrap_or(payment_data.payment_attempt.get_total_amount());
let amount = payment_data.payment_attempt.get_total_amount();
Ok(Self {
capture_method: Some(payment_data.payment_intent.capture_method),
amount_to_capture: amount_to_capture.get_amount_as_i64(), // This should be removed once we start moving to connector module
minor_amount_to_capture: amount_to_capture,
currency: payment_data.currency,
connector_transaction_id: connector
.connector
.connector_transaction_id(payment_data.payment_attempt.clone())?
.ok_or(errors::ApiErrorResponse::ResourceIdNotFound)?,
payment_amount: amount.get_amount_as_i64(), // This should be removed once we start moving to connector module
minor_payment_amount: amount,
connector_meta: payment_data
.payment_attempt
.connector_metadata
.expose_option(),
// TODO: add multiple capture data
multiple_capture_data: None,
// TODO: why do we need browser info during capture?
browser_info: None,
metadata: payment_data.payment_intent.metadata.expose_option(),
integrity_object: None,
split_payments: None,
webhook_url: None,
})
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/core/payments/transformers.rs | crate: router
use api_models::payments::{
Address, ConnectorMandateReferenceId, CustomerDetails, CustomerDetailsResponse, FrmMessage,
RequestSurchargeDetails,
};
use hyperswitch_domain_models::{payments::payment_intent::CustomerData, router_request_types};
use crate::{
configs::settings::ConnectorRequestReferenceIdConfig,
core::{
errors::{self, RouterResponse, RouterResult},
payments::{self, helpers},
utils as core_utils,
},
headers::X_PAYMENT_CONFIRM_SOURCE,
routes::{metrics, SessionState},
services::{self, RedirectForm},
types::{
self,
api::{self, ConnectorTransactionId},
domain,
storage::{self, enums},
transformers::{ForeignFrom, ForeignInto, ForeignTryFrom},
MultipleCaptureRequestData,
},
utils::{OptionExt, ValueExt},
};
fn foreign_from(qr_info: api_models::payments::QrCodeInformation) -> Self {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/core/payments/transformers.rs | crate: router
use api_models::payments::{
Address, ConnectorMandateReferenceId, CustomerDetails, CustomerDetailsResponse, FrmMessage,
RequestSurchargeDetails,
};
use diesel_models::{
ephemeral_key,
payment_attempt::ConnectorMandateReferenceId as DieselConnectorMandateReferenceId,
};
use hyperswitch_domain_models::{payments::payment_intent::CustomerData, router_request_types};
use crate::{
configs::settings::ConnectorRequestReferenceIdConfig,
core::{
errors::{self, RouterResponse, RouterResult},
payments::{self, helpers},
utils as core_utils,
},
headers::X_PAYMENT_CONFIRM_SOURCE,
routes::{metrics, SessionState},
services::{self, RedirectForm},
types::{
self,
api::{self, ConnectorTransactionId},
domain,
storage::{self, enums},
transformers::{ForeignFrom, ForeignInto, ForeignTryFrom},
MultipleCaptureRequestData,
},
utils::{OptionExt, ValueExt},
};
pub fn bank_transfer_next_steps_check(
payment_attempt: storage::PaymentAttempt,
) -> RouterResult<Option<api_models::payments::BankTransferNextStepsData>> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/core/payments/transformers.rs | crate: router
use api_models::payments::{
Address, ConnectorMandateReferenceId, CustomerDetails, CustomerDetailsResponse, FrmMessage,
RequestSurchargeDetails,
};
use hyperswitch_domain_models::{payments::payment_intent::CustomerData, router_request_types};
use crate::{
configs::settings::ConnectorRequestReferenceIdConfig,
core::{
errors::{self, RouterResponse, RouterResult},
payments::{self, helpers},
utils as core_utils,
},
headers::X_PAYMENT_CONFIRM_SOURCE,
routes::{metrics, SessionState},
services::{self, RedirectForm},
types::{
self,
api::{self, ConnectorTransactionId},
domain,
storage::{self, enums},
transformers::{ForeignFrom, ForeignInto, ForeignTryFrom},
MultipleCaptureRequestData,
},
utils::{OptionExt, ValueExt},
};
fn foreign_from((pi, pa): (storage::PaymentIntent, Option<storage::PaymentAttempt>)) -> Self {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/core/payments/transformers.rs | crate: router
use std::{fmt::Debug, marker::PhantomData, str::FromStr};
use diesel_models::{
ephemeral_key,
payment_attempt::ConnectorMandateReferenceId as DieselConnectorMandateReferenceId,
};
use crate::{
configs::settings::ConnectorRequestReferenceIdConfig,
core::{
errors::{self, RouterResponse, RouterResult},
payments::{self, helpers},
utils as core_utils,
},
headers::X_PAYMENT_CONFIRM_SOURCE,
routes::{metrics, SessionState},
services::{self, RedirectForm},
types::{
self,
api::{self, ConnectorTransactionId},
domain,
storage::{self, enums},
transformers::{ForeignFrom, ForeignInto, ForeignTryFrom},
MultipleCaptureRequestData,
},
utils::{OptionExt, ValueExt},
};
pub fn third_party_sdk_session_next_action<Op>(
payment_attempt: &storage::PaymentAttempt,
operation: &Op,
) -> bool
where
Op: Debug,
{
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/core/payments/transformers.rs | crate: router
use std::{fmt::Debug, marker::PhantomData, str::FromStr};
use api_models::payments::{
Address, ConnectorMandateReferenceId, CustomerDetails, CustomerDetailsResponse, FrmMessage,
RequestSurchargeDetails,
};
use hyperswitch_domain_models::{payments::payment_intent::CustomerData, router_request_types};
use masking::{ExposeInterface, Maskable, Secret};
use crate::{
configs::settings::ConnectorRequestReferenceIdConfig,
core::{
errors::{self, RouterResponse, RouterResult},
payments::{self, helpers},
utils as core_utils,
},
headers::X_PAYMENT_CONFIRM_SOURCE,
routes::{metrics, SessionState},
services::{self, RedirectForm},
types::{
self,
api::{self, ConnectorTransactionId},
domain,
storage::{self, enums},
transformers::{ForeignFrom, ForeignInto, ForeignTryFrom},
MultipleCaptureRequestData,
},
utils::{OptionExt, ValueExt},
};
fn generate_response(
payment_data: D,
customer: Option<domain::Customer>,
_auth_flow: services::AuthFlow,
_base_url: &str,
_operation: Op,
_connector_request_reference_id_config: &ConnectorRequestReferenceIdConfig,
_connector_http_status_code: Option<u16>,
_external_latency: Option<u128>,
_is_latency_header_enabled: Option<bool>,
) -> RouterResponse<Self> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/core/payments/transformers.rs | crate: router
use common_enums::{Currency, RequestIncrementalAuthorization};
use common_utils::{
consts::X_HS_LATENCY,
fp_utils, pii,
types::{
self as common_utils_type, AmountConvertor, MinorUnit, StringMajorUnit,
StringMajorUnitForConnector,
},
};
use crate::{
configs::settings::ConnectorRequestReferenceIdConfig,
core::{
errors::{self, RouterResponse, RouterResult},
payments::{self, helpers},
utils as core_utils,
},
headers::X_PAYMENT_CONFIRM_SOURCE,
routes::{metrics, SessionState},
services::{self, RedirectForm},
types::{
self,
api::{self, ConnectorTransactionId},
domain,
storage::{self, enums},
transformers::{ForeignFrom, ForeignInto, ForeignTryFrom},
MultipleCaptureRequestData,
},
utils::{OptionExt, ValueExt},
};
fn foreign_try_from(
(net_amount, shipping_cost, order_tax_amount, currency): (
MinorUnit,
Option<MinorUnit>,
Option<MinorUnit>,
Currency,
),
) -> Result<Self, Self::Error> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/core/payments/transformers.rs | crate: router
use std::{fmt::Debug, marker::PhantomData, str::FromStr};
use api_models::payments::{
Address, ConnectorMandateReferenceId, CustomerDetails, CustomerDetailsResponse, FrmMessage,
RequestSurchargeDetails,
};
use hyperswitch_domain_models::{payments::payment_intent::CustomerData, router_request_types};
use crate::{
configs::settings::ConnectorRequestReferenceIdConfig,
core::{
errors::{self, RouterResponse, RouterResult},
payments::{self, helpers},
utils as core_utils,
},
headers::X_PAYMENT_CONFIRM_SOURCE,
routes::{metrics, SessionState},
services::{self, RedirectForm},
types::{
self,
api::{self, ConnectorTransactionId},
domain,
storage::{self, enums},
transformers::{ForeignFrom, ForeignInto, ForeignTryFrom},
MultipleCaptureRequestData,
},
utils::{OptionExt, ValueExt},
};
fn generate_response(
payment_data: D,
_customer: Option<domain::Customer>,
_auth_flow: services::AuthFlow,
_base_url: &str,
_operation: Op,
_connector_request_reference_id_config: &ConnectorRequestReferenceIdConfig,
_connector_http_status_code: Option<u16>,
_external_latency: Option<u128>,
_is_latency_header_enabled: Option<bool>,
) -> RouterResponse<Self> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/core/payments/transformers.rs | crate: router
use std::{fmt::Debug, marker::PhantomData, str::FromStr};
use api_models::payments::{
Address, ConnectorMandateReferenceId, CustomerDetails, CustomerDetailsResponse, FrmMessage,
RequestSurchargeDetails,
};
use hyperswitch_domain_models::{payments::payment_intent::CustomerData, router_request_types};
use crate::{
configs::settings::ConnectorRequestReferenceIdConfig,
core::{
errors::{self, RouterResponse, RouterResult},
payments::{self, helpers},
utils as core_utils,
},
headers::X_PAYMENT_CONFIRM_SOURCE,
routes::{metrics, SessionState},
services::{self, RedirectForm},
types::{
self,
api::{self, ConnectorTransactionId},
domain,
storage::{self, enums},
transformers::{ForeignFrom, ForeignInto, ForeignTryFrom},
MultipleCaptureRequestData,
},
utils::{OptionExt, ValueExt},
};
fn generate_response(
payment_data: D,
_customer: Option<domain::Customer>,
_base_url: &str,
operation: Op,
_connector_request_reference_id_config: &ConnectorRequestReferenceIdConfig,
_connector_http_status_code: Option<u16>,
_external_latency: Option<u128>,
_is_latency_header_enabled: Option<bool>,
_merchant_account: &domain::MerchantAccount,
) -> RouterResponse<Self> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/core/payments/transformers.rs | crate: router
use std::{fmt::Debug, marker::PhantomData, str::FromStr};
use crate::{
configs::settings::ConnectorRequestReferenceIdConfig,
core::{
errors::{self, RouterResponse, RouterResult},
payments::{self, helpers},
utils as core_utils,
},
headers::X_PAYMENT_CONFIRM_SOURCE,
routes::{metrics, SessionState},
services::{self, RedirectForm},
types::{
self,
api::{self, ConnectorTransactionId},
domain,
storage::{self, enums},
transformers::{ForeignFrom, ForeignInto, ForeignTryFrom},
MultipleCaptureRequestData,
},
utils::{OptionExt, ValueExt},
};
fn generate_response(
payment_data: D,
customer: Option<domain::Customer>,
auth_flow: services::AuthFlow,
base_url: &str,
operation: Op,
connector_request_reference_id_config: &ConnectorRequestReferenceIdConfig,
connector_http_status_code: Option<u16>,
external_latency: Option<u128>,
is_latency_header_enabled: Option<bool>,
) -> RouterResponse<Self> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/core/payments/transformers.rs | crate: router
use api_models::payments::{
Address, ConnectorMandateReferenceId, CustomerDetails, CustomerDetailsResponse, FrmMessage,
RequestSurchargeDetails,
};
use common_utils::{
consts::X_HS_LATENCY,
fp_utils, pii,
types::{
self as common_utils_type, AmountConvertor, MinorUnit, StringMajorUnit,
StringMajorUnitForConnector,
},
};
use diesel_models::{
ephemeral_key,
payment_attempt::ConnectorMandateReferenceId as DieselConnectorMandateReferenceId,
};
use hyperswitch_domain_models::{payments::payment_intent::CustomerData, router_request_types};
use crate::{
configs::settings::ConnectorRequestReferenceIdConfig,
core::{
errors::{self, RouterResponse, RouterResult},
payments::{self, helpers},
utils as core_utils,
},
headers::X_PAYMENT_CONFIRM_SOURCE,
routes::{metrics, SessionState},
services::{self, RedirectForm},
types::{
self,
api::{self, ConnectorTransactionId},
domain,
storage::{self, enums},
transformers::{ForeignFrom, ForeignInto, ForeignTryFrom},
MultipleCaptureRequestData,
},
utils::{OptionExt, ValueExt},
};
fn generate_response(
self,
state: &SessionState,
connector_http_status_code: Option<u16>,
external_latency: Option<u128>,
is_latency_header_enabled: Option<bool>,
merchant_account: &domain::MerchantAccount,
profile: &domain::Profile,
) -> RouterResponse<api_models::payments::PaymentsCaptureResponse> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/core/payments/transformers.rs | crate: router
use api_models::payments::{
Address, ConnectorMandateReferenceId, CustomerDetails, CustomerDetailsResponse, FrmMessage,
RequestSurchargeDetails,
};
use diesel_models::{
ephemeral_key,
payment_attempt::ConnectorMandateReferenceId as DieselConnectorMandateReferenceId,
};
fn foreign_from(config: api_models::admin::PaymentLinkConfigRequest) -> Self {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/core/payments/transformers.rs | crate: router
#[cfg(feature = "v2")]
impl<F: Clone> TryFrom<PaymentAdditionalData<'_, F>> for types::SetupMandateRequestData {
type Error = error_stack::Report<errors::ApiErrorResponse>;
fn try_from(additional_data: PaymentAdditionalData<'_, F>) -> Result<Self, Self::Error> {
todo!()
}
}
impl ForeignTryFrom<types::CaptureSyncResponse> for storage::CaptureUpdate {
type Error = error_stack::Report<errors::ApiErrorResponse>;
fn foreign_try_from(
capture_sync_response: types::CaptureSyncResponse,
) -> Result<Self, Self::Error> {
match capture_sync_response {
types::CaptureSyncResponse::Success {
resource_id,
status,
connector_response_reference_id,
..
} => {
let (connector_capture_id, processor_capture_data) = match resource_id {
types::ResponseId::EncodedData(_) | types::ResponseId::NoResponseId => {
(None, None)
fn foreign_try_from(
capture_sync_response: types::CaptureSyncResponse,
) -> Result<Self, Self::Error> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/core/payments/transformers.rs | crate: router
use api_models::payments::{
Address, ConnectorMandateReferenceId, CustomerDetails, CustomerDetailsResponse, FrmMessage,
RequestSurchargeDetails,
};
use diesel_models::{
ephemeral_key,
payment_attempt::ConnectorMandateReferenceId as DieselConnectorMandateReferenceId,
};
use hyperswitch_domain_models::{payments::payment_intent::CustomerData, router_request_types};
use crate::{
configs::settings::ConnectorRequestReferenceIdConfig,
core::{
errors::{self, RouterResponse, RouterResult},
payments::{self, helpers},
utils as core_utils,
},
headers::X_PAYMENT_CONFIRM_SOURCE,
routes::{metrics, SessionState},
services::{self, RedirectForm},
types::{
self,
api::{self, ConnectorTransactionId},
domain,
storage::{self, enums},
transformers::{ForeignFrom, ForeignInto, ForeignTryFrom},
MultipleCaptureRequestData,
},
utils::{OptionExt, ValueExt},
};
fn foreign_from(value: diesel_models::ConnectorTokenDetails) -> Self {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/core/payments/transformers.rs | crate: router
use api_models::payments::{
Address, ConnectorMandateReferenceId, CustomerDetails, CustomerDetailsResponse, FrmMessage,
RequestSurchargeDetails,
};
use diesel_models::{
ephemeral_key,
payment_attempt::ConnectorMandateReferenceId as DieselConnectorMandateReferenceId,
};
fn foreign_from(value: ConnectorMandateReferenceId) -> Self {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/core/payments/transformers.rs | crate: router
use diesel_models::{
ephemeral_key,
payment_attempt::ConnectorMandateReferenceId as DieselConnectorMandateReferenceId,
};
fn foreign_from(value: DieselConnectorMandateReferenceId) -> Self {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/core/payments/transformers.rs | crate: router
use diesel_models::{
ephemeral_key,
payment_attempt::ConnectorMandateReferenceId as DieselConnectorMandateReferenceId,
};
fn foreign_from(from: diesel_models::TransactionDetailsUiConfiguration) -> Self {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/core/payments/transformers.rs | crate: router
use api_models::payments::{
Address, ConnectorMandateReferenceId, CustomerDetails, CustomerDetailsResponse, FrmMessage,
RequestSurchargeDetails,
};
use diesel_models::{
ephemeral_key,
payment_attempt::ConnectorMandateReferenceId as DieselConnectorMandateReferenceId,
};
fn foreign_from(from: diesel_models::PaymentLinkTransactionDetails) -> Self {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/core/payments/transformers.rs | crate: router
use api_models::payments::{
Address, ConnectorMandateReferenceId, CustomerDetails, CustomerDetailsResponse, FrmMessage,
RequestSurchargeDetails,
};
fn foreign_from(from: api_models::admin::TransactionDetailsUiConfiguration) -> Self {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/core/payments/transformers.rs | crate: router
use api_models::payments::{
Address, ConnectorMandateReferenceId, CustomerDetails, CustomerDetailsResponse, FrmMessage,
RequestSurchargeDetails,
};
use diesel_models::{
ephemeral_key,
payment_attempt::ConnectorMandateReferenceId as DieselConnectorMandateReferenceId,
};
fn foreign_from(from: api_models::admin::PaymentLinkTransactionDetails) -> Self {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/core/payments/transformers.rs | crate: router
use api_models::payments::{
Address, ConnectorMandateReferenceId, CustomerDetails, CustomerDetailsResponse, FrmMessage,
RequestSurchargeDetails,
};
use hyperswitch_domain_models::ApiModelToDieselModelConvertor;
use hyperswitch_domain_models::{payments::payment_intent::CustomerData, router_request_types};
use crate::{
configs::settings::ConnectorRequestReferenceIdConfig,
core::{
errors::{self, RouterResponse, RouterResult},
payments::{self, helpers},
utils as core_utils,
},
headers::X_PAYMENT_CONFIRM_SOURCE,
routes::{metrics, SessionState},
services::{self, RedirectForm},
types::{
self,
api::{self, ConnectorTransactionId},
domain,
storage::{self, enums},
transformers::{ForeignFrom, ForeignInto, ForeignTryFrom},
MultipleCaptureRequestData,
},
utils::{OptionExt, ValueExt},
};
fn foreign_from(amount_details: hyperswitch_domain_models::payments::AmountDetails) -> Self {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/core/payments/transformers.rs | crate: router
use api_models::payments::{
Address, ConnectorMandateReferenceId, CustomerDetails, CustomerDetailsResponse, FrmMessage,
RequestSurchargeDetails,
};
use diesel_models::{
ephemeral_key,
payment_attempt::ConnectorMandateReferenceId as DieselConnectorMandateReferenceId,
};
use hyperswitch_domain_models::ApiModelToDieselModelConvertor;
use hyperswitch_domain_models::{payments::payment_intent::CustomerData, router_request_types};
use crate::{
configs::settings::ConnectorRequestReferenceIdConfig,
core::{
errors::{self, RouterResponse, RouterResult},
payments::{self, helpers},
utils as core_utils,
},
headers::X_PAYMENT_CONFIRM_SOURCE,
routes::{metrics, SessionState},
services::{self, RedirectForm},
types::{
self,
api::{self, ConnectorTransactionId},
domain,
storage::{self, enums},
transformers::{ForeignFrom, ForeignInto, ForeignTryFrom},
MultipleCaptureRequestData,
},
utils::{OptionExt, ValueExt},
};
fn foreign_from(
feature_metadata: &hyperswitch_domain_models::payments::payment_attempt::PaymentAttemptFeatureMetadata,
) -> Self {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/core/payments/transformers.rs | crate: router
use api_models::payments::{
Address, ConnectorMandateReferenceId, CustomerDetails, CustomerDetailsResponse, FrmMessage,
RequestSurchargeDetails,
};
use diesel_models::{
ephemeral_key,
payment_attempt::ConnectorMandateReferenceId as DieselConnectorMandateReferenceId,
};
use hyperswitch_domain_models::ApiModelToDieselModelConvertor;
use hyperswitch_domain_models::{payments::payment_intent::CustomerData, router_request_types};
use crate::{
configs::settings::ConnectorRequestReferenceIdConfig,
core::{
errors::{self, RouterResponse, RouterResult},
payments::{self, helpers},
utils as core_utils,
},
headers::X_PAYMENT_CONFIRM_SOURCE,
routes::{metrics, SessionState},
services::{self, RedirectForm},
types::{
self,
api::{self, ConnectorTransactionId},
domain,
storage::{self, enums},
transformers::{ForeignFrom, ForeignInto, ForeignTryFrom},
MultipleCaptureRequestData,
},
utils::{OptionExt, ValueExt},
};
fn foreign_from(
error_details: &hyperswitch_domain_models::payments::payment_attempt::ErrorDetails,
) -> Self {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/core/payments/transformers.rs | crate: router
use api_models::payments::{
Address, ConnectorMandateReferenceId, CustomerDetails, CustomerDetailsResponse, FrmMessage,
RequestSurchargeDetails,
};
use diesel_models::{
ephemeral_key,
payment_attempt::ConnectorMandateReferenceId as DieselConnectorMandateReferenceId,
};
use hyperswitch_domain_models::ApiModelToDieselModelConvertor;
use hyperswitch_domain_models::{payments::payment_intent::CustomerData, router_request_types};
use crate::{
configs::settings::ConnectorRequestReferenceIdConfig,
core::{
errors::{self, RouterResponse, RouterResult},
payments::{self, helpers},
utils as core_utils,
},
headers::X_PAYMENT_CONFIRM_SOURCE,
routes::{metrics, SessionState},
services::{self, RedirectForm},
types::{
self,
api::{self, ConnectorTransactionId},
domain,
storage::{self, enums},
transformers::{ForeignFrom, ForeignInto, ForeignTryFrom},
MultipleCaptureRequestData,
},
utils::{OptionExt, ValueExt},
};
fn foreign_from(
amount: &hyperswitch_domain_models::payments::payment_attempt::AttemptAmountDetails,
) -> Self {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/core/payments/transformers.rs | crate: router
use api_models::payments::{
Address, ConnectorMandateReferenceId, CustomerDetails, CustomerDetailsResponse, FrmMessage,
RequestSurchargeDetails,
};
use diesel_models::{
ephemeral_key,
payment_attempt::ConnectorMandateReferenceId as DieselConnectorMandateReferenceId,
};
use hyperswitch_domain_models::ApiModelToDieselModelConvertor;
use hyperswitch_domain_models::{payments::payment_intent::CustomerData, router_request_types};
use crate::{
configs::settings::ConnectorRequestReferenceIdConfig,
core::{
errors::{self, RouterResponse, RouterResult},
payments::{self, helpers},
utils as core_utils,
},
headers::X_PAYMENT_CONFIRM_SOURCE,
routes::{metrics, SessionState},
services::{self, RedirectForm},
types::{
self,
api::{self, ConnectorTransactionId},
domain,
storage::{self, enums},
transformers::{ForeignFrom, ForeignInto, ForeignTryFrom},
MultipleCaptureRequestData,
},
utils::{OptionExt, ValueExt},
};
fn foreign_from(
(intent_amount_details, attempt_amount_details): (
&hyperswitch_domain_models::payments::AmountDetails,
&hyperswitch_domain_models::payments::payment_attempt::AttemptAmountDetails,
),
) -> Self {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/core/payments/transformers.rs | crate: router
use api_models::payments::{
Address, ConnectorMandateReferenceId, CustomerDetails, CustomerDetailsResponse, FrmMessage,
RequestSurchargeDetails,
};
fn foreign_from(customer: CustomerDetails) -> Self {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/core/payments/transformers.rs | crate: router
use api_models::payments::{
Address, ConnectorMandateReferenceId, CustomerDetails, CustomerDetailsResponse, FrmMessage,
RequestSurchargeDetails,
};
use hyperswitch_domain_models::{payments::payment_intent::CustomerData, router_request_types};
use crate::{
configs::settings::ConnectorRequestReferenceIdConfig,
core::{
errors::{self, RouterResponse, RouterResult},
payments::{self, helpers},
utils as core_utils,
},
headers::X_PAYMENT_CONFIRM_SOURCE,
routes::{metrics, SessionState},
services::{self, RedirectForm},
types::{
self,
api::{self, ConnectorTransactionId},
domain,
storage::{self, enums},
transformers::{ForeignFrom, ForeignInto, ForeignTryFrom},
MultipleCaptureRequestData,
},
utils::{OptionExt, ValueExt},
};
fn foreign_from(fraud_check: payments::FraudCheck) -> Self {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/core/payments/transformers.rs | crate: router
use common_utils::{
consts::X_HS_LATENCY,
fp_utils, pii,
types::{
self as common_utils_type, AmountConvertor, MinorUnit, StringMajorUnit,
StringMajorUnitForConnector,
},
};
use diesel_models::{
ephemeral_key,
payment_attempt::ConnectorMandateReferenceId as DieselConnectorMandateReferenceId,
};
use super::{flows::Feature, types::AuthenticationData, OperationSessionGetters, PaymentData};
use crate::{
configs::settings::ConnectorRequestReferenceIdConfig,
core::{
errors::{self, RouterResponse, RouterResult},
payments::{self, helpers},
utils as core_utils,
},
headers::X_PAYMENT_CONFIRM_SOURCE,
routes::{metrics, SessionState},
services::{self, RedirectForm},
types::{
self,
api::{self, ConnectorTransactionId},
domain,
storage::{self, enums},
transformers::{ForeignFrom, ForeignInto, ForeignTryFrom},
MultipleCaptureRequestData,
},
utils::{OptionExt, ValueExt},
};
fn foreign_from(
apple_pay_recurring_payment_interval_unit: diesel_models::types::RecurringPaymentIntervalUnit,
) -> Self {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/core/payments/transformers.rs | crate: router
use common_utils::{
consts::X_HS_LATENCY,
fp_utils, pii,
types::{
self as common_utils_type, AmountConvertor, MinorUnit, StringMajorUnit,
StringMajorUnitForConnector,
},
};
use diesel_models::{
ephemeral_key,
payment_attempt::ConnectorMandateReferenceId as DieselConnectorMandateReferenceId,
};
use super::{flows::Feature, types::AuthenticationData, OperationSessionGetters, PaymentData};
use crate::{
configs::settings::ConnectorRequestReferenceIdConfig,
core::{
errors::{self, RouterResponse, RouterResult},
payments::{self, helpers},
utils as core_utils,
},
headers::X_PAYMENT_CONFIRM_SOURCE,
routes::{metrics, SessionState},
services::{self, RedirectForm},
types::{
self,
api::{self, ConnectorTransactionId},
domain,
storage::{self, enums},
transformers::{ForeignFrom, ForeignInto, ForeignTryFrom},
MultipleCaptureRequestData,
},
utils::{OptionExt, ValueExt},
};
fn foreign_from(
apple_pay_regular_billing: diesel_models::types::ApplePayRegularBillingDetails,
) -> Self {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/core/payments/transformers.rs | crate: router
use common_utils::{
consts::X_HS_LATENCY,
fp_utils, pii,
types::{
self as common_utils_type, AmountConvertor, MinorUnit, StringMajorUnit,
StringMajorUnitForConnector,
},
};
use diesel_models::{
ephemeral_key,
payment_attempt::ConnectorMandateReferenceId as DieselConnectorMandateReferenceId,
};
use super::{flows::Feature, types::AuthenticationData, OperationSessionGetters, PaymentData};
use crate::{
configs::settings::ConnectorRequestReferenceIdConfig,
core::{
errors::{self, RouterResponse, RouterResult},
payments::{self, helpers},
utils as core_utils,
},
headers::X_PAYMENT_CONFIRM_SOURCE,
routes::{metrics, SessionState},
services::{self, RedirectForm},
types::{
self,
api::{self, ConnectorTransactionId},
domain,
storage::{self, enums},
transformers::{ForeignFrom, ForeignInto, ForeignTryFrom},
MultipleCaptureRequestData,
},
utils::{OptionExt, ValueExt},
};
fn foreign_from(
apple_pay_recurring_details: diesel_models::types::ApplePayRecurringDetails,
) -> Self {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/core/payments/transformers.rs | crate: router
fn try_from(_additional_data: PaymentAdditionalData<'_, F>) -> Result<Self, Self::Error> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
// file: hyperswitch/crates/router/src/core/payments/transformers.rs | crate: router
use api_models::payments::{
Address, ConnectorMandateReferenceId, CustomerDetails, CustomerDetailsResponse, FrmMessage,
RequestSurchargeDetails,
};
use diesel_models::{
ephemeral_key,
payment_attempt::ConnectorMandateReferenceId as DieselConnectorMandateReferenceId,
};
use hyperswitch_domain_models::{payments::payment_intent::CustomerData, router_request_types};
use crate::{
configs::settings::ConnectorRequestReferenceIdConfig,
core::{
errors::{self, RouterResponse, RouterResult},
payments::{self, helpers},
utils as core_utils,
},
headers::X_PAYMENT_CONFIRM_SOURCE,
routes::{metrics, SessionState},
services::{self, RedirectForm},
types::{
self,
api::{self, ConnectorTransactionId},
domain,
storage::{self, enums},
transformers::{ForeignFrom, ForeignInto, ForeignTryFrom},
MultipleCaptureRequestData,
},
utils::{OptionExt, ValueExt},
};
pub fn mobile_payment_next_steps_check(
payment_attempt: &storage::PaymentAttempt,
) -> RouterResult<Option<api_models::payments::MobilePaymentNextStepData>> {
let mobile_payment_next_step = if let Some(diesel_models::enums::PaymentMethod::MobilePayment) =
payment_attempt.payment_method
{
let mobile_paymebnt_next_steps: Option<api_models::payments::MobilePaymentNextStepData> =
payment_attempt
.connector_metadata
.clone()
.map(|metadata| {
metadata
.parse_value("MobilePaymentNextStepData")
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("Failed to parse the Value to NextRequirements struct")
})
.transpose()?;
mobile_paymebnt_next_steps
} else {
None
};
Ok(mobile_payment_next_step)
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/core/payments/transformers.rs | crate: router
use api_models::payments::{
Address, ConnectorMandateReferenceId, CustomerDetails, CustomerDetailsResponse, FrmMessage,
RequestSurchargeDetails,
};
use diesel_models::{
ephemeral_key,
payment_attempt::ConnectorMandateReferenceId as DieselConnectorMandateReferenceId,
};
use hyperswitch_domain_models::{payments::payment_intent::CustomerData, router_request_types};
use crate::{
configs::settings::ConnectorRequestReferenceIdConfig,
core::{
errors::{self, RouterResponse, RouterResult},
payments::{self, helpers},
utils as core_utils,
},
headers::X_PAYMENT_CONFIRM_SOURCE,
routes::{metrics, SessionState},
services::{self, RedirectForm},
types::{
self,
api::{self, ConnectorTransactionId},
domain,
storage::{self, enums},
transformers::{ForeignFrom, ForeignInto, ForeignTryFrom},
MultipleCaptureRequestData,
},
utils::{OptionExt, ValueExt},
};
pub fn voucher_next_steps_check(
payment_attempt: storage::PaymentAttempt,
) -> RouterResult<Option<api_models::payments::VoucherNextStepData>> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/core/payments/transformers.rs | crate: router
use diesel_models::{
ephemeral_key,
payment_attempt::ConnectorMandateReferenceId as DieselConnectorMandateReferenceId,
};
fn foreign_from(from: ephemeral_key::EphemeralKey) -> Self {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/core/payments/transformers.rs | crate: router
use api_models::payments::{
Address, ConnectorMandateReferenceId, CustomerDetails, CustomerDetailsResponse, FrmMessage,
RequestSurchargeDetails,
};
use hyperswitch_domain_models::{payments::payment_intent::CustomerData, router_request_types};
use crate::{
configs::settings::ConnectorRequestReferenceIdConfig,
core::{
errors::{self, RouterResponse, RouterResult},
payments::{self, helpers},
utils as core_utils,
},
headers::X_PAYMENT_CONFIRM_SOURCE,
routes::{metrics, SessionState},
services::{self, RedirectForm},
types::{
self,
api::{self, ConnectorTransactionId},
domain,
storage::{self, enums},
transformers::{ForeignFrom, ForeignInto, ForeignTryFrom},
MultipleCaptureRequestData,
},
utils::{OptionExt, ValueExt},
};
pub fn construct_connector_invoke_hidden_frame(
connector_three_ds_invoke_data: api_models::payments::PaymentsConnectorThreeDsInvokeData,
) -> RouterResult<api_models::payments::NextActionData> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/core/payments/transformers.rs | crate: router
use api_models::payments::{
Address, ConnectorMandateReferenceId, CustomerDetails, CustomerDetailsResponse, FrmMessage,
RequestSurchargeDetails,
};
use diesel_models::{
ephemeral_key,
payment_attempt::ConnectorMandateReferenceId as DieselConnectorMandateReferenceId,
};
use hyperswitch_domain_models::{payments::payment_intent::CustomerData, router_request_types};
use crate::{
configs::settings::ConnectorRequestReferenceIdConfig,
core::{
errors::{self, RouterResponse, RouterResult},
payments::{self, helpers},
utils as core_utils,
},
headers::X_PAYMENT_CONFIRM_SOURCE,
routes::{metrics, SessionState},
services::{self, RedirectForm},
types::{
self,
api::{self, ConnectorTransactionId},
domain,
storage::{self, enums},
transformers::{ForeignFrom, ForeignInto, ForeignTryFrom},
MultipleCaptureRequestData,
},
utils::{OptionExt, ValueExt},
};
pub fn next_action_invoke_hidden_frame(
payment_attempt: &storage::PaymentAttempt,
) -> RouterResult<Option<api_models::payments::PaymentsConnectorThreeDsInvokeData>> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/core/payments/transformers.rs | crate: router
use api_models::payments::{
Address, ConnectorMandateReferenceId, CustomerDetails, CustomerDetailsResponse, FrmMessage,
RequestSurchargeDetails,
};
use diesel_models::{
ephemeral_key,
payment_attempt::ConnectorMandateReferenceId as DieselConnectorMandateReferenceId,
};
use hyperswitch_domain_models::{payments::payment_intent::CustomerData, router_request_types};
use crate::{
configs::settings::ConnectorRequestReferenceIdConfig,
core::{
errors::{self, RouterResponse, RouterResult},
payments::{self, helpers},
utils as core_utils,
},
headers::X_PAYMENT_CONFIRM_SOURCE,
routes::{metrics, SessionState},
services::{self, RedirectForm},
types::{
self,
api::{self, ConnectorTransactionId},
domain,
storage::{self, enums},
transformers::{ForeignFrom, ForeignInto, ForeignTryFrom},
MultipleCaptureRequestData,
},
utils::{OptionExt, ValueExt},
};
pub fn wait_screen_next_steps_check(
payment_attempt: storage::PaymentAttempt,
) -> RouterResult<Option<api_models::payments::WaitScreenInstructions>> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/core/payments/transformers.rs | crate: router
use api_models::payments::{
Address, ConnectorMandateReferenceId, CustomerDetails, CustomerDetailsResponse, FrmMessage,
RequestSurchargeDetails,
};
use diesel_models::{
ephemeral_key,
payment_attempt::ConnectorMandateReferenceId as DieselConnectorMandateReferenceId,
};
use hyperswitch_domain_models::{payments::payment_intent::CustomerData, router_request_types};
use crate::{
configs::settings::ConnectorRequestReferenceIdConfig,
core::{
errors::{self, RouterResponse, RouterResult},
payments::{self, helpers},
utils as core_utils,
},
headers::X_PAYMENT_CONFIRM_SOURCE,
routes::{metrics, SessionState},
services::{self, RedirectForm},
types::{
self,
api::{self, ConnectorTransactionId},
domain,
storage::{self, enums},
transformers::{ForeignFrom, ForeignInto, ForeignTryFrom},
MultipleCaptureRequestData,
},
utils::{OptionExt, ValueExt},
};
pub fn fetch_qr_code_url_next_steps_check(
payment_attempt: storage::PaymentAttempt,
) -> RouterResult<Option<api_models::payments::FetchQrCodeInformation>> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/core/payments/transformers.rs | crate: router
use api_models::payments::{
Address, ConnectorMandateReferenceId, CustomerDetails, CustomerDetailsResponse, FrmMessage,
RequestSurchargeDetails,
};
use diesel_models::{
ephemeral_key,
payment_attempt::ConnectorMandateReferenceId as DieselConnectorMandateReferenceId,
};
use hyperswitch_domain_models::{payments::payment_intent::CustomerData, router_request_types};
use crate::{
configs::settings::ConnectorRequestReferenceIdConfig,
core::{
errors::{self, RouterResponse, RouterResult},
payments::{self, helpers},
utils as core_utils,
},
headers::X_PAYMENT_CONFIRM_SOURCE,
routes::{metrics, SessionState},
services::{self, RedirectForm},
types::{
self,
api::{self, ConnectorTransactionId},
domain,
storage::{self, enums},
transformers::{ForeignFrom, ForeignInto, ForeignTryFrom},
MultipleCaptureRequestData,
},
utils::{OptionExt, ValueExt},
};
pub fn paypal_sdk_next_steps_check(
payment_attempt: storage::PaymentAttempt,
) -> RouterResult<Option<api_models::payments::SdkNextActionData>> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/core/payments/transformers.rs | crate: router
use api_models::payments::{
Address, ConnectorMandateReferenceId, CustomerDetails, CustomerDetailsResponse, FrmMessage,
RequestSurchargeDetails,
};
use diesel_models::{
ephemeral_key,
payment_attempt::ConnectorMandateReferenceId as DieselConnectorMandateReferenceId,
};
use hyperswitch_domain_models::{payments::payment_intent::CustomerData, router_request_types};
use crate::{
configs::settings::ConnectorRequestReferenceIdConfig,
core::{
errors::{self, RouterResponse, RouterResult},
payments::{self, helpers},
utils as core_utils,
},
headers::X_PAYMENT_CONFIRM_SOURCE,
routes::{metrics, SessionState},
services::{self, RedirectForm},
types::{
self,
api::{self, ConnectorTransactionId},
domain,
storage::{self, enums},
transformers::{ForeignFrom, ForeignInto, ForeignTryFrom},
MultipleCaptureRequestData,
},
utils::{OptionExt, ValueExt},
};
pub fn qr_code_next_steps_check(
payment_attempt: storage::PaymentAttempt,
) -> RouterResult<Option<api_models::payments::QrCodeInformation>> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/core/payments/transformers.rs | crate: router
use std::{fmt::Debug, marker::PhantomData, str::FromStr};
use api_models::payments::{
Address, ConnectorMandateReferenceId, CustomerDetails, CustomerDetailsResponse, FrmMessage,
RequestSurchargeDetails,
};
use hyperswitch_domain_models::{payments::payment_intent::CustomerData, router_request_types};
use super::{flows::Feature, types::AuthenticationData, OperationSessionGetters, PaymentData};
use crate::{
configs::settings::ConnectorRequestReferenceIdConfig,
core::{
errors::{self, RouterResponse, RouterResult},
payments::{self, helpers},
utils as core_utils,
},
headers::X_PAYMENT_CONFIRM_SOURCE,
routes::{metrics, SessionState},
services::{self, RedirectForm},
types::{
self,
api::{self, ConnectorTransactionId},
domain,
storage::{self, enums},
transformers::{ForeignFrom, ForeignInto, ForeignTryFrom},
MultipleCaptureRequestData,
},
utils::{OptionExt, ValueExt},
};
pub fn payments_to_payments_response<Op, F: Clone, D>(
_payment_data: D,
_captures: Option<Vec<storage::Capture>>,
_customer: Option<domain::Customer>,
_auth_flow: services::AuthFlow,
_base_url: &str,
_operation: &Op,
_connector_request_reference_id_config: &ConnectorRequestReferenceIdConfig,
_connector_http_status_code: Option<u16>,
_external_latency: Option<u128>,
_is_latency_header_enabled: Option<bool>,
) -> RouterResponse<api_models::payments::PaymentsResponse>
where
Op: Debug,
D: OperationSessionGetters<F>,
{
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/core/payments/transformers.rs | crate: router
use std::{fmt::Debug, marker::PhantomData, str::FromStr};
use crate::{
configs::settings::ConnectorRequestReferenceIdConfig,
core::{
errors::{self, RouterResponse, RouterResult},
payments::{self, helpers},
utils as core_utils,
},
headers::X_PAYMENT_CONFIRM_SOURCE,
routes::{metrics, SessionState},
services::{self, RedirectForm},
types::{
self,
api::{self, ConnectorTransactionId},
domain,
storage::{self, enums},
transformers::{ForeignFrom, ForeignInto, ForeignTryFrom},
MultipleCaptureRequestData,
},
utils::{OptionExt, ValueExt},
};
fn generate_response(
_data: D,
_customer: Option<domain::Customer>,
_auth_flow: services::AuthFlow,
_base_url: &str,
_operation: Op,
_connector_request_reference_id_config: &ConnectorRequestReferenceIdConfig,
_connector_http_status_code: Option<u16>,
_external_latency: Option<u128>,
_is_latency_header_enabled: Option<bool>,
) -> RouterResponse<Self> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/core/payments/transformers.rs | crate: router
use api_models::payments::{
Address, ConnectorMandateReferenceId, CustomerDetails, CustomerDetailsResponse, FrmMessage,
RequestSurchargeDetails,
};
use common_utils::{
consts::X_HS_LATENCY,
fp_utils, pii,
types::{
self as common_utils_type, AmountConvertor, MinorUnit, StringMajorUnit,
StringMajorUnitForConnector,
},
};
use diesel_models::{
ephemeral_key,
payment_attempt::ConnectorMandateReferenceId as DieselConnectorMandateReferenceId,
};
use hyperswitch_domain_models::{payments::payment_intent::CustomerData, router_request_types};
use crate::{
configs::settings::ConnectorRequestReferenceIdConfig,
core::{
errors::{self, RouterResponse, RouterResult},
payments::{self, helpers},
utils as core_utils,
},
headers::X_PAYMENT_CONFIRM_SOURCE,
routes::{metrics, SessionState},
services::{self, RedirectForm},
types::{
self,
api::{self, ConnectorTransactionId},
domain,
storage::{self, enums},
transformers::{ForeignFrom, ForeignInto, ForeignTryFrom},
MultipleCaptureRequestData,
},
utils::{OptionExt, ValueExt},
};
fn generate_response(
self,
_state: &SessionState,
_connector_http_status_code: Option<u16>,
_external_latency: Option<u128>,
_is_latency_header_enabled: Option<bool>,
_merchant_account: &domain::MerchantAccount,
_profile: &domain::Profile,
) -> RouterResponse<api_models::payments::PaymentAttemptResponse> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/core/payments/transformers.rs | crate: router
use std::{fmt::Debug, marker::PhantomData, str::FromStr};
use crate::{
configs::settings::ConnectorRequestReferenceIdConfig,
core::{
errors::{self, RouterResponse, RouterResult},
payments::{self, helpers},
utils as core_utils,
},
headers::X_PAYMENT_CONFIRM_SOURCE,
routes::{metrics, SessionState},
services::{self, RedirectForm},
types::{
self,
api::{self, ConnectorTransactionId},
domain,
storage::{self, enums},
transformers::{ForeignFrom, ForeignInto, ForeignTryFrom},
MultipleCaptureRequestData,
},
utils::{OptionExt, ValueExt},
};
fn generate_response(
payment_data: D,
_customer: Option<domain::Customer>,
_base_url: &str,
_operation: Op,
_connector_request_reference_id_config: &ConnectorRequestReferenceIdConfig,
_connector_http_status_code: Option<u16>,
_external_latency: Option<u128>,
_is_latency_header_enabled: Option<bool>,
_merchant_account: &domain::MerchantAccount,
) -> RouterResponse<Self> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/core/payments/transformers.rs | crate: router
use api_models::payments::{
Address, ConnectorMandateReferenceId, CustomerDetails, CustomerDetailsResponse, FrmMessage,
RequestSurchargeDetails,
};
use diesel_models::{
ephemeral_key,
payment_attempt::ConnectorMandateReferenceId as DieselConnectorMandateReferenceId,
};
use hyperswitch_domain_models::{payments::payment_intent::CustomerData, router_request_types};
use router_env::{instrument, tracing};
use crate::{
configs::settings::ConnectorRequestReferenceIdConfig,
core::{
errors::{self, RouterResponse, RouterResult},
payments::{self, helpers},
utils as core_utils,
},
headers::X_PAYMENT_CONFIRM_SOURCE,
routes::{metrics, SessionState},
services::{self, RedirectForm},
types::{
self,
api::{self, ConnectorTransactionId},
domain,
storage::{self, enums},
transformers::{ForeignFrom, ForeignInto, ForeignTryFrom},
MultipleCaptureRequestData,
},
utils::{OptionExt, ValueExt},
};
fn foreign_from((pi, pa): (storage::PaymentIntent, storage::PaymentAttempt)) -> Self {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/core/payments/transformers.rs | crate: router
use api_models::payments::{
Address, ConnectorMandateReferenceId, CustomerDetails, CustomerDetailsResponse, FrmMessage,
RequestSurchargeDetails,
};
use common_utils::{
consts::X_HS_LATENCY,
fp_utils, pii,
types::{
self as common_utils_type, AmountConvertor, MinorUnit, StringMajorUnit,
StringMajorUnitForConnector,
},
};
use diesel_models::{
ephemeral_key,
payment_attempt::ConnectorMandateReferenceId as DieselConnectorMandateReferenceId,
};
use hyperswitch_domain_models::{payments::payment_intent::CustomerData, router_request_types};
use crate::{
configs::settings::ConnectorRequestReferenceIdConfig,
core::{
errors::{self, RouterResponse, RouterResult},
payments::{self, helpers},
utils as core_utils,
},
headers::X_PAYMENT_CONFIRM_SOURCE,
routes::{metrics, SessionState},
services::{self, RedirectForm},
types::{
self,
api::{self, ConnectorTransactionId},
domain,
storage::{self, enums},
transformers::{ForeignFrom, ForeignInto, ForeignTryFrom},
MultipleCaptureRequestData,
},
utils::{OptionExt, ValueExt},
};
fn generate_response(
self,
state: &SessionState,
connector_http_status_code: Option<u16>,
external_latency: Option<u128>,
is_latency_header_enabled: Option<bool>,
merchant_account: &domain::MerchantAccount,
profile: &domain::Profile,
) -> RouterResponse<api_models::payments::PaymentsResponse> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
// file: hyperswitch/crates/router/src/core/payments/transformers.rs | crate: router
use api_models::payments::{
Address, ConnectorMandateReferenceId, CustomerDetails, CustomerDetailsResponse, FrmMessage,
RequestSurchargeDetails,
};
use common_utils::{
consts::X_HS_LATENCY,
fp_utils, pii,
types::{
self as common_utils_type, AmountConvertor, MinorUnit, StringMajorUnit,
StringMajorUnitForConnector,
},
};
use diesel_models::{
ephemeral_key,
payment_attempt::ConnectorMandateReferenceId as DieselConnectorMandateReferenceId,
};
use hyperswitch_domain_models::{payments::payment_intent::CustomerData, router_request_types};
use crate::{
configs::settings::ConnectorRequestReferenceIdConfig,
core::{
errors::{self, RouterResponse, RouterResult},
payments::{self, helpers},
utils as core_utils,
},
headers::X_PAYMENT_CONFIRM_SOURCE,
routes::{metrics, SessionState},
services::{self, RedirectForm},
types::{
self,
api::{self, ConnectorTransactionId},
domain,
storage::{self, enums},
transformers::{ForeignFrom, ForeignInto, ForeignTryFrom},
MultipleCaptureRequestData,
},
utils::{OptionExt, ValueExt},
};
fn generate_response(
self,
state: &SessionState,
connector_http_status_code: Option<u16>,
external_latency: Option<u128>,
is_latency_header_enabled: Option<bool>,
merchant_account: &domain::MerchantAccount,
profile: &domain::Profile,
) -> RouterResponse<api_models::payments::PaymentsResponse> {
let payment_intent = self.payment_intent;
let payment_attempt = self.payment_attempt;
let amount = api_models::payments::PaymentAmountDetailsResponse::foreign_from((
&payment_intent.amount_details,
&payment_attempt.amount_details,
));
let connector = payment_attempt
.connector
.clone()
.get_required_value("connector")
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("Connector is none when constructing response")?;
let merchant_connector_id = payment_attempt
.merchant_connector_id
.clone()
.get_required_value("merchant_connector_id")
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("Merchant connector id is none when constructing response")?;
let error = payment_attempt
.error
.as_ref()
.map(api_models::payments::ErrorDetails::foreign_from);
let payment_address = self.payment_address;
let payment_method_data =
Some(api_models::payments::PaymentMethodDataResponseWithBilling {
payment_method_data: None,
billing: payment_address
.get_request_payment_method_billing()
.cloned()
.map(From::from),
});
// TODO: Add support for other next actions, currently only supporting redirect to url
let redirect_to_url = payment_intent.create_start_redirection_url(
&state.base_url,
merchant_account.publishable_key.clone(),
)?;
let next_action = payment_attempt
.redirection_data
.as_ref()
.map(|_| api_models::payments::NextActionData::RedirectToUrl { redirect_to_url });
let connector_token_details = payment_attempt
.connector_token_details
.and_then(Option::<api_models::payments::ConnectorTokenDetails>::foreign_from);
let return_url = payment_intent
.return_url
.clone()
.or(profile.return_url.clone());
let response = api_models::payments::PaymentsResponse {
id: payment_intent.id.clone(),
status: payment_intent.status,
amount,
customer_id: payment_intent.customer_id.clone(),
connector: Some(connector),
client_secret: payment_intent.client_secret.clone(),
created: payment_intent.created_at,
payment_method_data,
payment_method_type: Some(payment_attempt.payment_method_type),
payment_method_subtype: Some(payment_attempt.payment_method_subtype),
next_action,
connector_transaction_id: payment_attempt.connector_payment_id.clone(),
connector_reference_id: None,
connector_token_details,
merchant_connector_id: Some(merchant_connector_id),
browser_info: None,
error,
return_url,
authentication_type: payment_intent.authentication_type,
authentication_type_applied: Some(payment_attempt.authentication_type),
payment_method_id: payment_attempt.payment_method_id,
attempts: None,
billing: None, //TODO: add this
shipping: None, //TODO: add this
};
Ok(services::ApplicationResponse::JsonWithHeaders((
response,
vec![],
)))
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/core/payments/transformers.rs | crate: router
header_payload,
connector_mandate_request_reference_id: None,
authentication_id: None,
psd2_sca_exemption_type: None,
};
Ok(router_data)
}
#[cfg(feature = "v2")]
#[instrument(skip_all)]
#[allow(clippy::too_many_arguments)]
pub async fn construct_payment_router_data_for_sdk_session<'a>(
state: &'a SessionState,
payment_data: hyperswitch_domain_models::payments::PaymentIntentData<api::Session>,
connector_id: &str,
merchant_account: &domain::MerchantAccount,
_key_store: &domain::MerchantKeyStore,
customer: &'a Option<domain::Customer>,
merchant_connector_account: &domain::MerchantConnectorAccount,
_merchant_recipient_data: Option<types::MerchantRecipientData>,
header_payload: Option<hyperswitch_domain_models::payments::HeaderPayload>,
) -> RouterResult<types::PaymentsSessionRouterData> {
fp_utils::when(merchant_connector_account.is_disabled(), || {
Err(errors::ApiErrorResponse::MerchantConnectorAccountDisabled)
pub async fn construct_payment_router_data_for_sdk_session<'a>(
state: &'a SessionState,
payment_data: hyperswitch_domain_models::payments::PaymentIntentData<api::Session>,
connector_id: &str,
merchant_account: &domain::MerchantAccount,
_key_store: &domain::MerchantKeyStore,
customer: &'a Option<domain::Customer>,
merchant_connector_account: &domain::MerchantConnectorAccount,
_merchant_recipient_data: Option<types::MerchantRecipientData>,
header_payload: Option<hyperswitch_domain_models::payments::HeaderPayload>,
) -> RouterResult<types::PaymentsSessionRouterData> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/core/payments/transformers.rs | crate: router
header_payload,
connector_mandate_request_reference_id,
psd2_sca_exemption_type: None,
authentication_id: None,
};
Ok(router_data)
}
#[cfg(feature = "v2")]
#[instrument(skip_all)]
#[allow(clippy::too_many_arguments)]
pub async fn construct_router_data_for_psync<'a>(
state: &'a SessionState,
payment_data: hyperswitch_domain_models::payments::PaymentStatusData<api::PSync>,
connector_id: &str,
merchant_account: &domain::MerchantAccount,
_key_store: &domain::MerchantKeyStore,
customer: &'a Option<domain::Customer>,
merchant_connector_account: &domain::MerchantConnectorAccount,
_merchant_recipient_data: Option<types::MerchantRecipientData>,
header_payload: Option<hyperswitch_domain_models::payments::HeaderPayload>,
) -> RouterResult<types::PaymentsSyncRouterData> {
use masking::ExposeOptionInterface;
pub async fn construct_router_data_for_psync<'a>(
state: &'a SessionState,
payment_data: hyperswitch_domain_models::payments::PaymentStatusData<api::PSync>,
connector_id: &str,
merchant_account: &domain::MerchantAccount,
_key_store: &domain::MerchantKeyStore,
customer: &'a Option<domain::Customer>,
merchant_connector_account: &domain::MerchantConnectorAccount,
_merchant_recipient_data: Option<types::MerchantRecipientData>,
header_payload: Option<hyperswitch_domain_models::payments::HeaderPayload>,
) -> RouterResult<types::PaymentsSyncRouterData> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/core/payments/transformers.rs | crate: router
header_payload,
connector_mandate_request_reference_id,
authentication_id: None,
psd2_sca_exemption_type: None,
};
Ok(router_data)
}
#[cfg(feature = "v2")]
#[instrument(skip_all)]
#[allow(clippy::too_many_arguments)]
pub async fn construct_payment_router_data_for_capture<'a>(
state: &'a SessionState,
payment_data: hyperswitch_domain_models::payments::PaymentCaptureData<api::Capture>,
connector_id: &str,
merchant_account: &domain::MerchantAccount,
_key_store: &domain::MerchantKeyStore,
customer: &'a Option<domain::Customer>,
merchant_connector_account: &domain::MerchantConnectorAccount,
_merchant_recipient_data: Option<types::MerchantRecipientData>,
header_payload: Option<hyperswitch_domain_models::payments::HeaderPayload>,
) -> RouterResult<types::PaymentsCaptureRouterData> {
use masking::ExposeOptionInterface;
pub async fn construct_payment_router_data_for_capture<'a>(
state: &'a SessionState,
payment_data: hyperswitch_domain_models::payments::PaymentCaptureData<api::Capture>,
connector_id: &str,
merchant_account: &domain::MerchantAccount,
_key_store: &domain::MerchantKeyStore,
customer: &'a Option<domain::Customer>,
merchant_connector_account: &domain::MerchantConnectorAccount,
_merchant_recipient_data: Option<types::MerchantRecipientData>,
header_payload: Option<hyperswitch_domain_models::payments::HeaderPayload>,
) -> RouterResult<types::PaymentsCaptureRouterData> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/core/payments/transformers.rs | crate: router
use std::{fmt::Debug, marker::PhantomData, str::FromStr};
use common_utils::{
consts::X_HS_LATENCY,
fp_utils, pii,
types::{
self as common_utils_type, AmountConvertor, MinorUnit, StringMajorUnit,
StringMajorUnitForConnector,
},
};
use diesel_models::{
ephemeral_key,
payment_attempt::ConnectorMandateReferenceId as DieselConnectorMandateReferenceId,
};
use error_stack::{report, ResultExt};
use hyperswitch_domain_models::ApiModelToDieselModelConvertor;
use hyperswitch_domain_models::{payments::payment_intent::CustomerData, router_request_types};
use super::{flows::Feature, types::AuthenticationData, OperationSessionGetters, PaymentData};
use crate::{
configs::settings::ConnectorRequestReferenceIdConfig,
core::{
errors::{self, RouterResponse, RouterResult},
payments::{self, helpers},
utils as core_utils,
},
headers::X_PAYMENT_CONFIRM_SOURCE,
routes::{metrics, SessionState},
services::{self, RedirectForm},
types::{
self,
api::{self, ConnectorTransactionId},
domain,
storage::{self, enums},
transformers::{ForeignFrom, ForeignInto, ForeignTryFrom},
MultipleCaptureRequestData,
},
utils::{OptionExt, ValueExt},
};
pub async fn construct_router_data_to_update_calculated_tax<'a, F, T>(
state: &'a SessionState,
payment_data: PaymentData<F>,
connector_id: &str,
merchant_account: &domain::MerchantAccount,
_key_store: &domain::MerchantKeyStore,
customer: &'a Option<domain::Customer>,
merchant_connector_account: &helpers::MerchantConnectorAccountType,
) -> RouterResult<types::RouterData<F, T, types::PaymentsResponseData>>
where
T: TryFrom<PaymentAdditionalData<'a, F>>,
types::RouterData<F, T, types::PaymentsResponseData>: Feature<F, T>,
F: Clone,
error_stack::Report<errors::ApiErrorResponse>:
From<<T as TryFrom<PaymentAdditionalData<'a, F>>>::Error>,
{
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
// file: hyperswitch/crates/router/src/core/payments/transformers.rs | crate: router
use api_models::payments::{
Address, ConnectorMandateReferenceId, CustomerDetails, CustomerDetailsResponse, FrmMessage,
RequestSurchargeDetails,
};
use common_enums::{Currency, RequestIncrementalAuthorization};
use common_utils::{
consts::X_HS_LATENCY,
fp_utils, pii,
types::{
self as common_utils_type, AmountConvertor, MinorUnit, StringMajorUnit,
StringMajorUnitForConnector,
},
};
use diesel_models::{
ephemeral_key,
payment_attempt::ConnectorMandateReferenceId as DieselConnectorMandateReferenceId,
};
use hyperswitch_domain_models::{payments::payment_intent::CustomerData, router_request_types};
use super::{flows::Feature, types::AuthenticationData, OperationSessionGetters, PaymentData};
use crate::{
configs::settings::ConnectorRequestReferenceIdConfig,
core::{
errors::{self, RouterResponse, RouterResult},
payments::{self, helpers},
utils as core_utils,
},
headers::X_PAYMENT_CONFIRM_SOURCE,
routes::{metrics, SessionState},
services::{self, RedirectForm},
types::{
self,
api::{self, ConnectorTransactionId},
domain,
storage::{self, enums},
transformers::{ForeignFrom, ForeignInto, ForeignTryFrom},
MultipleCaptureRequestData,
},
utils::{OptionExt, ValueExt},
};
fn try_from(additional_data: PaymentAdditionalData<'_, F>) -> Result<Self, Self::Error> {
let payment_data = additional_data.payment_data.clone();
let router_base_url = &additional_data.router_base_url;
let connector_name = &additional_data.connector_name;
let attempt = &payment_data.payment_attempt;
let browser_info: Option<types::BrowserInformation> = attempt
.browser_info
.clone()
.map(|b| b.parse_value("BrowserInformation"))
.transpose()
.change_context(errors::ApiErrorResponse::InvalidDataValue {
field_name: "browser_info",
})?;
let order_category = additional_data
.payment_data
.payment_intent
.connector_metadata
.clone()
.map(|cm| {
cm.parse_value::<api_models::payments::ConnectorMetadata>("ConnectorMetadata")
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("Failed parsing ConnectorMetadata")
})
.transpose()?
.and_then(|cm| cm.noon.and_then(|noon| noon.order_category));
let braintree_metadata = additional_data
.payment_data
.payment_intent
.connector_metadata
.clone()
.map(|cm| {
cm.parse_value::<api_models::payments::ConnectorMetadata>("ConnectorMetadata")
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("Failed parsing ConnectorMetadata")
})
.transpose()?
.and_then(|cm| cm.braintree);
let merchant_account_id = braintree_metadata
.as_ref()
.and_then(|braintree| braintree.merchant_account_id.clone());
let merchant_config_currency =
braintree_metadata.and_then(|braintree| braintree.merchant_config_currency);
let order_details = additional_data
.payment_data
.payment_intent
.order_details
.map(|order_details| {
order_details
.iter()
.map(|data| {
data.to_owned()
.parse_value("OrderDetailsWithAmount")
.change_context(errors::ApiErrorResponse::InvalidDataValue {
field_name: "OrderDetailsWithAmount",
})
.attach_printable("Unable to parse OrderDetailsWithAmount")
})
.collect::<Result<Vec<_>, _>>()
})
.transpose()?;
let complete_authorize_url = Some(helpers::create_complete_authorize_url(
router_base_url,
attempt,
connector_name,
payment_data.creds_identifier.as_deref(),
));
let merchant_connector_account_id_or_connector_name = payment_data
.payment_attempt
.merchant_connector_id
.as_ref()
.map(|mca_id| mca_id.get_string_repr())
.unwrap_or(connector_name);
let webhook_url = Some(helpers::create_webhook_url(
router_base_url,
&attempt.merchant_id,
merchant_connector_account_id_or_connector_name,
));
let router_return_url = Some(helpers::create_redirect_url(
router_base_url,
attempt,
connector_name,
payment_data.creds_identifier.as_deref(),
));
let additional_payment_method_data: Option<api_models::payments::AdditionalPaymentData> =
payment_data.payment_attempt
.payment_method_data
.as_ref().map(|data| data.clone().parse_value("AdditionalPaymentData"))
.transpose()
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("Failed to parse AdditionalPaymentData from payment_data.payment_attempt.payment_method_data")?;
let payment_method_data = payment_data.payment_method_data.or_else(|| {
if payment_data.mandate_id.is_some() {
Some(domain::PaymentMethodData::MandatePayment)
} else {
None
}
});
let amount = payment_data.payment_attempt.get_total_amount();
let customer_name = additional_data
.customer_data
.as_ref()
.and_then(|customer_data| {
customer_data
.name
.as_ref()
.map(|customer| customer.clone().into_inner())
});
let customer_id = additional_data
.customer_data
.as_ref()
.map(|data| data.customer_id.clone());
let split_payments = payment_data.payment_intent.split_payments.clone();
let merchant_order_reference_id = payment_data
.payment_intent
.merchant_order_reference_id
.clone();
let shipping_cost = payment_data.payment_intent.shipping_cost;
Ok(Self {
payment_method_data: (payment_method_data.get_required_value("payment_method_data")?),
setup_future_usage: payment_data.payment_intent.setup_future_usage,
mandate_id: payment_data.mandate_id.clone(),
off_session: payment_data.mandate_id.as_ref().map(|_| true),
setup_mandate_details: payment_data.setup_mandate.clone(),
confirm: payment_data.payment_attempt.confirm,
statement_descriptor_suffix: payment_data.payment_intent.statement_descriptor_suffix,
statement_descriptor: payment_data.payment_intent.statement_descriptor_name,
capture_method: payment_data.payment_attempt.capture_method,
amount: amount.get_amount_as_i64(),
order_tax_amount: payment_data
.payment_attempt
.net_amount
.get_order_tax_amount(),
minor_amount: amount,
currency: payment_data.currency,
browser_info,
email: payment_data.email,
customer_name,
payment_experience: payment_data.payment_attempt.payment_experience,
order_details,
order_category,
session_token: None,
enrolled_for_3ds: true,
related_transaction_id: None,
payment_method_type: payment_data.payment_attempt.payment_method_type,
router_return_url,
webhook_url,
complete_authorize_url,
customer_id,
surcharge_details: payment_data.surcharge_details,
request_incremental_authorization: matches!(
payment_data
.payment_intent
.request_incremental_authorization,
Some(RequestIncrementalAuthorization::True)
| Some(RequestIncrementalAuthorization::Default)
),
metadata: additional_data.payment_data.payment_intent.metadata,
authentication_data: payment_data
.authentication
.as_ref()
.map(AuthenticationData::foreign_try_from)
.transpose()?,
customer_acceptance: payment_data.customer_acceptance,
request_extended_authorization: attempt.request_extended_authorization,
split_payments,
merchant_order_reference_id,
integrity_object: None,
additional_payment_method_data,
shipping_cost,
merchant_account_id,
merchant_config_currency,
})
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/core/payments/transformers.rs | crate: router
where
Op: Debug,
D: OperationSessionGetters<F>,
{
todo!()
}
#[cfg(all(any(feature = "v1", feature = "v2"), not(feature = "customer_v2")))]
#[instrument(skip_all)]
// try to use router data here so that already validated things , we don't want to repeat the validations.
// Add internal value not found and external value not found so that we can give 500 / Internal server error for internal value not found
#[allow(clippy::too_many_arguments)]
pub fn payments_to_payments_response<Op, F: Clone, D>(
payment_data: D,
captures: Option<Vec<storage::Capture>>,
customer: Option<domain::Customer>,
_auth_flow: services::AuthFlow,
base_url: &str,
operation: &Op,
connector_request_reference_id_config: &ConnectorRequestReferenceIdConfig,
connector_http_status_code: Option<u16>,
external_latency: Option<u128>,
_is_latency_header_enabled: Option<bool>,
) -> RouterResponse<api::PaymentsResponse>
where
pub fn payments_to_payments_response<Op, F: Clone, D>(
payment_data: D,
captures: Option<Vec<storage::Capture>>,
customer: Option<domain::Customer>,
_auth_flow: services::AuthFlow,
base_url: &str,
operation: &Op,
connector_request_reference_id_config: &ConnectorRequestReferenceIdConfig,
connector_http_status_code: Option<u16>,
external_latency: Option<u128>,
_is_latency_header_enabled: Option<bool>,
) -> RouterResponse<api::PaymentsResponse>
where
Op: Debug,
D: OperationSessionGetters<F>,
{
{use std::ops::Not;let payment_attempt = payment_data.get_payment_attempt().clone();<|fim_suffix|>
<|fim_middle|>
metrics::PAYMENT_OPS_COUNT.add(
1,
router_env::metric_attributes!(
("operation", format!("{:?}", operation)),
("merchant", merchant_id.clone()),
("payment_method_type", payment_method_type),
("payment_method", payment_method),
),
);Ok(output)}}
| ast_fragments |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.