id stringlengths 11 116 | type stringclasses 1 value | granularity stringclasses 4 values | content stringlengths 16 477k | metadata dict |
|---|---|---|---|---|
fn_clm_cards_try_from_726952742254511174 | clm | function | // Repository: hyperswitch
// Crate: cards
// Module: crates/cards/src/lib
// Implementation of CardExpiration for TryFrom<(u8, u16)>
fn try_from(items: (u8, u16)) -> errors::CustomResult<Self, errors::ValidationError> {
let month = CardExpirationMonth::try_from(items.0)?;
let year = CardExpirationYear::try_from(items.1)?;
Ok(Self { month, year })
}
| {
"crate": "cards",
"file": null,
"file_size": null,
"is_async": false,
"is_pub": false,
"num_enums": null,
"num_structs": null,
"num_tables": null,
"score": 2661,
"total_crates": null
} |
fn_clm_cards_deserialize_726952742254511174 | clm | function | // Repository: hyperswitch
// Crate: cards
// Module: crates/cards/src/lib
// Implementation of CardExpirationYear for Deserialize<'de>
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
let year = u16::deserialize(deserializer)?;
year.try_into().map_err(de::Error::custom)
}
| {
"crate": "cards",
"file": null,
"file_size": null,
"is_async": false,
"is_pub": false,
"num_enums": null,
"num_structs": null,
"num_tables": null,
"score": 140,
"total_crates": null
} |
fn_clm_cards_is_expired_726952742254511174 | clm | function | // Repository: hyperswitch
// Crate: cards
// Module: crates/cards/src/lib
// Inherent implementation for CardExpiration
pub fn is_expired(&self) -> Result<bool, error_stack::Report<errors::ValidationError>> {
let current_datetime_utc = date_time::now();
let expiration_month = time::Month::try_from(*self.month.peek()).map_err(|_| {
report!(errors::ValidationError::InvalidValue {
message: "invalid month".to_string()
})
})?;
let expiration_year = *self.year.peek();
let expiration_day = expiration_month.length(i32::from(expiration_year));
let expiration_date =
Date::from_calendar_date(i32::from(expiration_year), expiration_month, expiration_day)
.map_err(|_| {
report!(errors::ValidationError::InvalidValue {
message: "error while constructing calendar date".to_string()
})
})?;
let expiration_time = Time::MIDNIGHT;
// actual expiry date specified on card w.r.t. local timezone
// max diff b/w utc and other timezones is 14 hours
let mut expiration_datetime_utc = PrimitiveDateTime::new(expiration_date, expiration_time);
// compensating time difference b/w local and utc timezone by adding a day
expiration_datetime_utc = expiration_datetime_utc.saturating_add(Duration::days(1));
Ok(current_datetime_utc > expiration_datetime_utc)
}
| {
"crate": "cards",
"file": null,
"file_size": null,
"is_async": false,
"is_pub": true,
"num_enums": null,
"num_structs": null,
"num_tables": null,
"score": 50,
"total_crates": null
} |
fn_clm_cards_deref_726952742254511174 | clm | function | // Repository: hyperswitch
// Crate: cards
// Module: crates/cards/src/lib
// Implementation of CardExpirationYear for Deref
fn deref(&self) -> &Self::Target {
&self.0
}
| {
"crate": "cards",
"file": null,
"file_size": null,
"is_async": false,
"is_pub": false,
"num_enums": null,
"num_structs": null,
"num_tables": null,
"score": 41,
"total_crates": null
} |
fn_clm_cards_two_digits_726952742254511174 | clm | function | // Repository: hyperswitch
// Crate: cards
// Module: crates/cards/src/lib
// Inherent implementation for CardExpirationYear
pub fn two_digits(&self) -> String {
let year = self.peek() % 100;
year.to_string()
}
| {
"crate": "cards",
"file": null,
"file_size": null,
"is_async": false,
"is_pub": true,
"num_enums": null,
"num_structs": null,
"num_tables": null,
"score": 25,
"total_crates": null
} |
fn_clm_cards_try_from_-9200354715722346235 | clm | function | // Repository: hyperswitch
// Crate: cards
// Module: crates/cards/src/validate
// Implementation of NetworkToken for TryFrom<String>
fn try_from(value: String) -> Result<Self, Self::Error> {
Self::from_str(&value)
}
| {
"crate": "cards",
"file": null,
"file_size": null,
"is_async": false,
"is_pub": false,
"num_enums": null,
"num_structs": null,
"num_tables": null,
"score": 2659,
"total_crates": null
} |
fn_clm_cards_from_str_-9200354715722346235 | clm | function | // Repository: hyperswitch
// Crate: cards
// Module: crates/cards/src/validate
// Implementation of NetworkToken for FromStr
fn from_str(network_token: &str) -> Result<Self, Self::Err> {
// Valid test cards for threedsecureio
let valid_test_network_tokens = vec![
"4000100511112003",
"6000100611111203",
"3000100811111072",
"9000100111111111",
];
#[cfg(not(target_arch = "wasm32"))]
let valid_test_network_tokens = match router_env_which() {
Env::Development | Env::Sandbox => valid_test_network_tokens,
Env::Production => vec![],
};
let network_token = network_token.split_whitespace().collect::<String>();
let is_network_token_valid = sanitize_card_number(&network_token)?;
if valid_test_network_tokens.contains(&network_token.as_str()) || is_network_token_valid {
Ok(Self(StrongSecret::new(network_token)))
} else {
Err(CardNumberValidationErr("network token invalid"))
}
}
| {
"crate": "cards",
"file": null,
"file_size": null,
"is_async": false,
"is_pub": false,
"num_enums": null,
"num_structs": null,
"num_tables": null,
"score": 795,
"total_crates": null
} |
fn_clm_cards_deserialize_-9200354715722346235 | clm | function | // Repository: hyperswitch
// Crate: cards
// Module: crates/cards/src/validate
// Implementation of NetworkToken for Deserialize<'de>
fn deserialize<D: Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
let s = String::deserialize(d)?;
Self::from_str(&s).map_err(serde::de::Error::custom)
}
| {
"crate": "cards",
"file": null,
"file_size": null,
"is_async": false,
"is_pub": false,
"num_enums": null,
"num_structs": null,
"num_tables": null,
"score": 140,
"total_crates": null
} |
fn_clm_cards_is_cobadged_card_-9200354715722346235 | clm | function | // Repository: hyperswitch
// Crate: cards
// Module: crates/cards/src/validate
// Implementation of None for CardNumber
pub fn is_cobadged_card(&self) -> Result<bool, error_stack::Report<ValidationError>> {
/// Regex to identify card networks
static CARD_NETWORK_REGEX: LazyLock<HashMap<&str, Result<Regex, regex::Error>>> =
LazyLock::new(|| {
let mut map = HashMap::new();
map.insert(
"Mastercard",
Regex::new(r"^(222[1-9]|22[3-9][0-9]|2[3-6][0-9]{2}|27[0-1][0-9]|2720|5[1-5])"),
);
map.insert("American Express", Regex::new(r"^3[47]"));
map.insert("Visa", Regex::new(r"^4"));
map.insert(
"Discover",
Regex::new(
r"^(6011|64[4-9]|65|622126|622[1-9][0-9][0-9]|6229[0-1][0-9]|622925)",
),
);
map.insert(
"Maestro",
Regex::new(r"^(5018|5081|5044|504681|504993|5020|502260|5038|5893|603845|603123|6304|6759|676[1-3]|6220|504834|504817|504645|504775|600206|627741)"),
);
map.insert(
"RuPay",
Regex::new(r"^(508227|508[5-9]|603741|60698[5-9]|60699|607[0-8]|6079[0-7]|60798[0-4]|60800[1-9]|6080[1-9]|608[1-4]|608500|6521[5-9]|652[2-9]|6530|6531[0-4]|817290|817368|817378|353800|82)"),
);
map.insert("Diners Club", Regex::new(r"^(36|38|39|30[0-5])"));
map.insert("JCB", Regex::new(r"^35(2[89]|[3-8][0-9])"));
map.insert("CarteBlanche", Regex::new(r"^389[0-9]{11}$"));
map.insert("Sodex", Regex::new(r"^(637513)"));
map.insert("BAJAJ", Regex::new(r"^(203040)"));
map.insert("CartesBancaires", Regex::new(r"^(401(005|006|581)|4021(01|02)|403550|405936|406572|41(3849|4819|50(56|59|62|71|74)|6286|65(37|79)|71[7])|420110|423460|43(47(21|22)|50(48|49|50|51|52)|7875|95(09|11|15|39|98)|96(03|18|19|20|22|72))|4424(48|49|50|51|52|57)|448412|4505(19|60)|45(33|56[6-8]|61|62[^3]|6955|7452|7717|93[02379])|46(099|54(76|77)|6258|6575|98[023])|47(4107|71(73|74|86)|72(65|93)|9619)|48(1091|3622|6519)|49(7|83[5-9]|90(0[1-6]|1[0-6]|2[0-3]|3[0-3]|4[0-3]|5[0-2]|68|9[256789]))|5075(89|90|93|94|97)|51(0726|3([0-7]|8[56]|9(00|38))|5214|62(07|36)|72(22|43)|73(65|66)|7502|7647|8101|9920)|52(0993|1662|3718|7429|9227|93(13|14|31)|94(14|21|30|40|47|55|56|[6-9])|9542)|53(0901|10(28|30)|1195|23(4[4-7])|2459|25(09|34|54|56)|3801|41(02|05|11)|50(29|66)|5324|61(07|15)|71(06|12)|8011)|54(2848|5157|9538|98(5[89]))|55(39(79|93)|42(05|60)|4965|7008|88(67|82)|89(29|4[23])|9618|98(09|10))|56(0408|12(0[2-6]|4[134]|5[04678]))|58(17(0[0-7]|15|2[14]|3[16789]|4[0-9]|5[016]|6[269]|7[3789]|8[0-7]|9[017])|55(0[2-5]|7[7-9]|8[0-2])))"));
map
});
let mut no_of_supported_card_networks = 0;
let card_number_str = self.get_card_no();
for (_, regex) in CARD_NETWORK_REGEX.iter() {
let card_regex = match regex.as_ref() {
Ok(regex) => Ok(regex),
Err(_) => Err(report!(ValidationError::InvalidValue {
message: "Invalid regex expression".into(),
})),
}?;
if card_regex.is_match(&card_number_str) {
no_of_supported_card_networks += 1;
if no_of_supported_card_networks > 1 {
break;
}
}
}
Ok(no_of_supported_card_networks > 1)
}
| {
"crate": "cards",
"file": null,
"file_size": null,
"is_async": false,
"is_pub": true,
"num_enums": null,
"num_structs": null,
"num_tables": null,
"score": 87,
"total_crates": null
} |
fn_clm_cards_get_last4_-9200354715722346235 | clm | function | // Repository: hyperswitch
// Crate: cards
// Module: crates/cards/src/validate
// Inherent implementation for NetworkToken
pub fn get_last4(&self) -> String {
self.0
.peek()
.chars()
.rev()
.take(4)
.collect::<String>()
.chars()
.rev()
.collect::<String>()
}
| {
"crate": "cards",
"file": null,
"file_size": null,
"is_async": false,
"is_pub": true,
"num_enums": null,
"num_structs": null,
"num_tables": null,
"score": 66,
"total_crates": null
} |
fn_clm_currency_conversion_new_-5292738432462609255 | clm | function | // Repository: hyperswitch
// Crate: currency_conversion
// Module: crates/currency_conversion/src/types
// Inherent implementation for ExchangeRates
pub fn new(base_currency: Currency, conversion: HashMap<Currency, CurrencyFactors>) -> Self {
Self {
base_currency,
conversion,
}
}
| {
"crate": "currency_conversion",
"file": null,
"file_size": null,
"is_async": false,
"is_pub": true,
"num_enums": null,
"num_structs": null,
"num_tables": null,
"score": 14463,
"total_crates": null
} |
fn_clm_currency_conversion_forward_conversion_-5292738432462609255 | clm | function | // Repository: hyperswitch
// Crate: currency_conversion
// Module: crates/currency_conversion/src/types
// Inherent implementation for ExchangeRates
/// The flow here is from_currency -> base_currency -> to_currency
/// from to_currency -> base currency
pub fn forward_conversion(
&self,
amt: Decimal,
from_currency: Currency,
) -> Result<Decimal, CurrencyConversionError> {
let from_factor = self
.conversion
.get(&from_currency)
.ok_or_else(|| {
CurrencyConversionError::ConversionNotSupported(from_currency.to_string())
})?
.from_factor;
amt.checked_mul(from_factor)
.ok_or(CurrencyConversionError::DecimalMultiplicationFailed)
}
| {
"crate": "currency_conversion",
"file": null,
"file_size": null,
"is_async": false,
"is_pub": true,
"num_enums": null,
"num_structs": null,
"num_tables": null,
"score": 36,
"total_crates": null
} |
fn_clm_currency_conversion_backward_conversion_-5292738432462609255 | clm | function | // Repository: hyperswitch
// Crate: currency_conversion
// Module: crates/currency_conversion/src/types
// Inherent implementation for ExchangeRates
/// from base_currency -> to_currency
pub fn backward_conversion(
&self,
amt: Decimal,
to_currency: Currency,
) -> Result<Decimal, CurrencyConversionError> {
let to_factor = self
.conversion
.get(&to_currency)
.ok_or_else(|| {
CurrencyConversionError::ConversionNotSupported(to_currency.to_string())
})?
.to_factor;
amt.checked_mul(to_factor)
.ok_or(CurrencyConversionError::DecimalMultiplicationFailed)
}
| {
"crate": "currency_conversion",
"file": null,
"file_size": null,
"is_async": false,
"is_pub": true,
"num_enums": null,
"num_structs": null,
"num_tables": null,
"score": 36,
"total_crates": null
} |
fn_clm_currency_conversion_currency_match_-5292738432462609255 | clm | function | // Repository: hyperswitch
// Crate: currency_conversion
// Module: crates/currency_conversion/src/types
pub fn currency_match(currency: Currency) -> &'static iso::Currency {
match currency {
Currency::AED => iso::AED,
Currency::AFN => iso::AFN,
Currency::ALL => iso::ALL,
Currency::AMD => iso::AMD,
Currency::ANG => iso::ANG,
Currency::AOA => iso::AOA,
Currency::ARS => iso::ARS,
Currency::AUD => iso::AUD,
Currency::AWG => iso::AWG,
Currency::AZN => iso::AZN,
Currency::BAM => iso::BAM,
Currency::BBD => iso::BBD,
Currency::BDT => iso::BDT,
Currency::BGN => iso::BGN,
Currency::BHD => iso::BHD,
Currency::BIF => iso::BIF,
Currency::BMD => iso::BMD,
Currency::BND => iso::BND,
Currency::BOB => iso::BOB,
Currency::BRL => iso::BRL,
Currency::BSD => iso::BSD,
Currency::BTN => iso::BTN,
Currency::BWP => iso::BWP,
Currency::BYN => iso::BYN,
Currency::BZD => iso::BZD,
Currency::CAD => iso::CAD,
Currency::CDF => iso::CDF,
Currency::CHF => iso::CHF,
Currency::CLF => iso::CLF,
Currency::CLP => iso::CLP,
Currency::CNY => iso::CNY,
Currency::COP => iso::COP,
Currency::CRC => iso::CRC,
Currency::CUC => iso::CUC,
Currency::CUP => iso::CUP,
Currency::CVE => iso::CVE,
Currency::CZK => iso::CZK,
Currency::DJF => iso::DJF,
Currency::DKK => iso::DKK,
Currency::DOP => iso::DOP,
Currency::DZD => iso::DZD,
Currency::EGP => iso::EGP,
Currency::ERN => iso::ERN,
Currency::ETB => iso::ETB,
Currency::EUR => iso::EUR,
Currency::FJD => iso::FJD,
Currency::FKP => iso::FKP,
Currency::GBP => iso::GBP,
Currency::GEL => iso::GEL,
Currency::GHS => iso::GHS,
Currency::GIP => iso::GIP,
Currency::GMD => iso::GMD,
Currency::GNF => iso::GNF,
Currency::GTQ => iso::GTQ,
Currency::GYD => iso::GYD,
Currency::HKD => iso::HKD,
Currency::HNL => iso::HNL,
Currency::HRK => iso::HRK,
Currency::HTG => iso::HTG,
Currency::HUF => iso::HUF,
Currency::IDR => iso::IDR,
Currency::ILS => iso::ILS,
Currency::INR => iso::INR,
Currency::IQD => iso::IQD,
Currency::IRR => iso::IRR,
Currency::ISK => iso::ISK,
Currency::JMD => iso::JMD,
Currency::JOD => iso::JOD,
Currency::JPY => iso::JPY,
Currency::KES => iso::KES,
Currency::KGS => iso::KGS,
Currency::KHR => iso::KHR,
Currency::KMF => iso::KMF,
Currency::KPW => iso::KPW,
Currency::KRW => iso::KRW,
Currency::KWD => iso::KWD,
Currency::KYD => iso::KYD,
Currency::KZT => iso::KZT,
Currency::LAK => iso::LAK,
Currency::LBP => iso::LBP,
Currency::LKR => iso::LKR,
Currency::LRD => iso::LRD,
Currency::LSL => iso::LSL,
Currency::LYD => iso::LYD,
Currency::MAD => iso::MAD,
Currency::MDL => iso::MDL,
Currency::MGA => iso::MGA,
Currency::MKD => iso::MKD,
Currency::MMK => iso::MMK,
Currency::MNT => iso::MNT,
Currency::MOP => iso::MOP,
Currency::MRU => iso::MRU,
Currency::MUR => iso::MUR,
Currency::MVR => iso::MVR,
Currency::MWK => iso::MWK,
Currency::MXN => iso::MXN,
Currency::MYR => iso::MYR,
Currency::MZN => iso::MZN,
Currency::NAD => iso::NAD,
Currency::NGN => iso::NGN,
Currency::NIO => iso::NIO,
Currency::NOK => iso::NOK,
Currency::NPR => iso::NPR,
Currency::NZD => iso::NZD,
Currency::OMR => iso::OMR,
Currency::PAB => iso::PAB,
Currency::PEN => iso::PEN,
Currency::PGK => iso::PGK,
Currency::PHP => iso::PHP,
Currency::PKR => iso::PKR,
Currency::PLN => iso::PLN,
Currency::PYG => iso::PYG,
Currency::QAR => iso::QAR,
Currency::RON => iso::RON,
Currency::RSD => iso::RSD,
Currency::RUB => iso::RUB,
Currency::RWF => iso::RWF,
Currency::SAR => iso::SAR,
Currency::SBD => iso::SBD,
Currency::SCR => iso::SCR,
Currency::SDG => iso::SDG,
Currency::SEK => iso::SEK,
Currency::SGD => iso::SGD,
Currency::SHP => iso::SHP,
Currency::SLE => iso::SLE,
Currency::SLL => iso::SLL,
Currency::SOS => iso::SOS,
Currency::SRD => iso::SRD,
Currency::SSP => iso::SSP,
Currency::STD => iso::STD,
Currency::STN => iso::STN,
Currency::SVC => iso::SVC,
Currency::SYP => iso::SYP,
Currency::SZL => iso::SZL,
Currency::THB => iso::THB,
Currency::TJS => iso::TJS,
Currency::TND => iso::TND,
Currency::TMT => iso::TMT,
Currency::TOP => iso::TOP,
Currency::TTD => iso::TTD,
Currency::TRY => iso::TRY,
Currency::TWD => iso::TWD,
Currency::TZS => iso::TZS,
Currency::UAH => iso::UAH,
Currency::UGX => iso::UGX,
Currency::USD => iso::USD,
Currency::UYU => iso::UYU,
Currency::UZS => iso::UZS,
Currency::VES => iso::VES,
Currency::VND => iso::VND,
Currency::VUV => iso::VUV,
Currency::WST => iso::WST,
Currency::XAF => iso::XAF,
Currency::XCD => iso::XCD,
Currency::XOF => iso::XOF,
Currency::XPF => iso::XPF,
Currency::YER => iso::YER,
Currency::ZAR => iso::ZAR,
Currency::ZMW => iso::ZMW,
Currency::ZWL => iso::ZWL,
}
}
| {
"crate": "currency_conversion",
"file": null,
"file_size": null,
"is_async": false,
"is_pub": true,
"num_enums": null,
"num_structs": null,
"num_tables": null,
"score": 13,
"total_crates": null
} |
fn_clm_currency_conversion_convert_-1808507504419892639 | clm | function | // Repository: hyperswitch
// Crate: currency_conversion
// Module: crates/currency_conversion/src/conversion
pub fn convert(
ex_rates: &ExchangeRates,
from_currency: Currency,
to_currency: Currency,
amount: i64,
) -> Result<Decimal, CurrencyConversionError> {
let money_minor = Money::from_minor(amount, currency_match(from_currency));
let base_currency = ex_rates.base_currency;
if to_currency == base_currency {
ex_rates.forward_conversion(*money_minor.amount(), from_currency)
} else if from_currency == base_currency {
ex_rates.backward_conversion(*money_minor.amount(), to_currency)
} else {
let base_conversion_amt =
ex_rates.forward_conversion(*money_minor.amount(), from_currency)?;
ex_rates.backward_conversion(base_conversion_amt, to_currency)
}
}
| {
"crate": "currency_conversion",
"file": null,
"file_size": null,
"is_async": false,
"is_pub": true,
"num_enums": null,
"num_structs": null,
"num_tables": null,
"score": 382,
"total_crates": null
} |
fn_clm_currency_conversion_currency_to_currency_conversion_-1808507504419892639 | clm | function | // Repository: hyperswitch
// Crate: currency_conversion
// Module: crates/currency_conversion/src/conversion
fn currency_to_currency_conversion() {
use super::*;
let mut conversion: HashMap<Currency, CurrencyFactors> = HashMap::new();
let inr_conversion_rates =
CurrencyFactors::new(Decimal::new(823173, 4), Decimal::new(1214, 5));
let szl_conversion_rates =
CurrencyFactors::new(Decimal::new(194423, 4), Decimal::new(514, 4));
let convert_from = Currency::SZL;
let convert_to = Currency::INR;
let amount = 2000;
let base_currency = Currency::USD;
conversion.insert(convert_from, inr_conversion_rates);
conversion.insert(convert_to, szl_conversion_rates);
let sample_rate = ExchangeRates::new(base_currency, conversion);
let res =
convert(&sample_rate, convert_from, convert_to, amount).expect("converted_currency");
println!("The conversion from {amount} {convert_from} to {convert_to} is {res:?}");
}
| {
"crate": "currency_conversion",
"file": null,
"file_size": null,
"is_async": false,
"is_pub": false,
"num_enums": null,
"num_structs": null,
"num_tables": null,
"score": 22,
"total_crates": null
} |
fn_clm_currency_conversion_currency_to_base_conversion_-1808507504419892639 | clm | function | // Repository: hyperswitch
// Crate: currency_conversion
// Module: crates/currency_conversion/src/conversion
fn currency_to_base_conversion() {
use super::*;
let mut conversion: HashMap<Currency, CurrencyFactors> = HashMap::new();
let inr_conversion_rates =
CurrencyFactors::new(Decimal::new(823173, 4), Decimal::new(1214, 5));
let usd_conversion_rates = CurrencyFactors::new(Decimal::new(1, 0), Decimal::new(1, 0));
let convert_from = Currency::INR;
let convert_to = Currency::USD;
let amount = 2000;
let base_currency = Currency::USD;
conversion.insert(convert_from, inr_conversion_rates);
conversion.insert(convert_to, usd_conversion_rates);
let sample_rate = ExchangeRates::new(base_currency, conversion);
let res =
convert(&sample_rate, convert_from, convert_to, amount).expect("converted_currency");
println!("The conversion from {amount} {convert_from} to {convert_to} is {res:?}");
}
| {
"crate": "currency_conversion",
"file": null,
"file_size": null,
"is_async": false,
"is_pub": false,
"num_enums": null,
"num_structs": null,
"num_tables": null,
"score": 22,
"total_crates": null
} |
fn_clm_currency_conversion_base_to_currency_conversion_-1808507504419892639 | clm | function | // Repository: hyperswitch
// Crate: currency_conversion
// Module: crates/currency_conversion/src/conversion
fn base_to_currency_conversion() {
use super::*;
let mut conversion: HashMap<Currency, CurrencyFactors> = HashMap::new();
let inr_conversion_rates =
CurrencyFactors::new(Decimal::new(823173, 4), Decimal::new(1214, 5));
let usd_conversion_rates = CurrencyFactors::new(Decimal::new(1, 0), Decimal::new(1, 0));
let convert_from = Currency::USD;
let convert_to = Currency::INR;
let amount = 2000;
let base_currency = Currency::USD;
conversion.insert(convert_from, usd_conversion_rates);
conversion.insert(convert_to, inr_conversion_rates);
let sample_rate = ExchangeRates::new(base_currency, conversion);
let res =
convert(&sample_rate, convert_from, convert_to, amount).expect("converted_currency");
println!("The conversion from {amount} {convert_from} to {convert_to} is {res:?}");
}
| {
"crate": "currency_conversion",
"file": null,
"file_size": null,
"is_async": false,
"is_pub": false,
"num_enums": null,
"num_structs": null,
"num_tables": null,
"score": 22,
"total_crates": null
} |
fn_clm_diesel_models_from_6206906305210262429 | clm | function | // Repository: hyperswitch
// Crate: diesel_models
// Purpose: Database schema types directly mapping to PostgreSQL tables
// Module: crates/diesel_models/src/dispute
// Implementation of DisputeUpdateInternal for From<DisputeUpdate>
fn from(merchant_account_update: DisputeUpdate) -> Self {
match merchant_account_update {
DisputeUpdate::Update {
dispute_stage,
dispute_status,
connector_status,
connector_reason,
connector_reason_code,
challenge_required_by,
connector_updated_at,
} => Self {
dispute_stage: Some(dispute_stage),
dispute_status: Some(dispute_status),
connector_status: Some(connector_status),
connector_reason,
connector_reason_code,
challenge_required_by,
connector_updated_at,
modified_at: common_utils::date_time::now(),
evidence: None,
},
DisputeUpdate::StatusUpdate {
dispute_status,
connector_status,
} => Self {
dispute_status: Some(dispute_status),
connector_status,
modified_at: common_utils::date_time::now(),
dispute_stage: None,
connector_reason: None,
connector_reason_code: None,
challenge_required_by: None,
connector_updated_at: None,
evidence: None,
},
DisputeUpdate::EvidenceUpdate { evidence } => Self {
evidence: Some(evidence),
dispute_stage: None,
dispute_status: None,
connector_status: None,
connector_reason: None,
connector_reason_code: None,
challenge_required_by: None,
connector_updated_at: None,
modified_at: common_utils::date_time::now(),
},
}
}
| {
"crate": "diesel_models",
"file": null,
"file_size": null,
"is_async": false,
"is_pub": false,
"num_enums": null,
"num_structs": null,
"num_tables": null,
"score": 2606,
"total_crates": null
} |
fn_clm_diesel_models_execute_-6747035942392026091 | clm | function | // Repository: hyperswitch
// Crate: diesel_models
// Purpose: Database schema types directly mapping to PostgreSQL tables
// Module: crates/diesel_models/src/kv
// Inherent implementation for DBOperation
pub async fn execute(self, conn: &PgPooledConn) -> crate::StorageResult<DBResult> {
Ok(match self {
Self::Insert { insertable } => match *insertable {
Insertable::PaymentIntent(a) => {
DBResult::PaymentIntent(Box::new(a.insert(conn).await?))
}
Insertable::PaymentAttempt(a) => {
DBResult::PaymentAttempt(Box::new(a.insert(conn).await?))
}
Insertable::Refund(a) => DBResult::Refund(Box::new(a.insert(conn).await?)),
Insertable::Address(addr) => DBResult::Address(Box::new(addr.insert(conn).await?)),
Insertable::Customer(cust) => {
DBResult::Customer(Box::new(cust.insert(conn).await?))
}
Insertable::ReverseLookUp(rev) => {
DBResult::ReverseLookUp(Box::new(rev.insert(conn).await?))
}
Insertable::Payouts(rev) => DBResult::Payouts(Box::new(rev.insert(conn).await?)),
Insertable::PayoutAttempt(rev) => {
DBResult::PayoutAttempt(Box::new(rev.insert(conn).await?))
}
Insertable::PaymentMethod(rev) => {
DBResult::PaymentMethod(Box::new(rev.insert(conn).await?))
}
Insertable::Mandate(m) => DBResult::Mandate(Box::new(m.insert(conn).await?)),
},
Self::Update { updatable } => match *updatable {
#[cfg(feature = "v1")]
Updateable::PaymentIntentUpdate(a) => {
DBResult::PaymentIntent(Box::new(a.orig.update(conn, a.update_data).await?))
}
#[cfg(feature = "v2")]
Updateable::PaymentIntentUpdate(a) => {
DBResult::PaymentIntent(Box::new(a.orig.update(conn, a.update_data).await?))
}
#[cfg(feature = "v1")]
Updateable::PaymentAttemptUpdate(a) => DBResult::PaymentAttempt(Box::new(
a.orig.update_with_attempt_id(conn, a.update_data).await?,
)),
#[cfg(feature = "v2")]
Updateable::PaymentAttemptUpdate(a) => DBResult::PaymentAttempt(Box::new(
a.orig.update_with_attempt_id(conn, a.update_data).await?,
)),
#[cfg(feature = "v1")]
Updateable::RefundUpdate(a) => {
DBResult::Refund(Box::new(a.orig.update(conn, a.update_data).await?))
}
#[cfg(feature = "v2")]
Updateable::RefundUpdate(a) => {
DBResult::Refund(Box::new(a.orig.update_with_id(conn, a.update_data).await?))
}
Updateable::AddressUpdate(a) => {
DBResult::Address(Box::new(a.orig.update(conn, a.update_data).await?))
}
Updateable::PayoutsUpdate(a) => {
DBResult::Payouts(Box::new(a.orig.update(conn, a.update_data).await?))
}
Updateable::PayoutAttemptUpdate(a) => DBResult::PayoutAttempt(Box::new(
a.orig.update_with_attempt_id(conn, a.update_data).await?,
)),
#[cfg(feature = "v1")]
Updateable::PaymentMethodUpdate(v) => DBResult::PaymentMethod(Box::new(
v.orig
.update_with_payment_method_id(conn, v.update_data)
.await?,
)),
#[cfg(feature = "v2")]
Updateable::PaymentMethodUpdate(v) => DBResult::PaymentMethod(Box::new(
v.orig.update_with_id(conn, v.update_data).await?,
)),
Updateable::MandateUpdate(m) => DBResult::Mandate(Box::new(
Mandate::update_by_merchant_id_mandate_id(
conn,
&m.orig.merchant_id,
&m.orig.mandate_id,
m.update_data,
)
.await?,
)),
#[cfg(feature = "v1")]
Updateable::CustomerUpdate(cust) => DBResult::Customer(Box::new(
Customer::update_by_customer_id_merchant_id(
conn,
cust.orig.customer_id.clone(),
cust.orig.merchant_id.clone(),
cust.update_data,
)
.await?,
)),
#[cfg(feature = "v2")]
Updateable::CustomerUpdate(cust) => DBResult::Customer(Box::new(
Customer::update_by_id(conn, cust.orig.id, cust.update_data).await?,
)),
},
})
}
| {
"crate": "diesel_models",
"file": null,
"file_size": null,
"is_async": false,
"is_pub": true,
"num_enums": null,
"num_structs": null,
"num_tables": null,
"score": 244,
"total_crates": null
} |
fn_clm_diesel_models_table_-6747035942392026091 | clm | function | // Repository: hyperswitch
// Crate: diesel_models
// Purpose: Database schema types directly mapping to PostgreSQL tables
// Module: crates/diesel_models/src/kv
// Inherent implementation for DBOperation
pub fn table<'a>(&self) -> &'a str {
match self {
Self::Insert { insertable } => match **insertable {
Insertable::PaymentIntent(_) => "payment_intent",
Insertable::PaymentAttempt(_) => "payment_attempt",
Insertable::Refund(_) => "refund",
Insertable::Address(_) => "address",
Insertable::Payouts(_) => "payouts",
Insertable::PayoutAttempt(_) => "payout_attempt",
Insertable::Customer(_) => "customer",
Insertable::ReverseLookUp(_) => "reverse_lookup",
Insertable::PaymentMethod(_) => "payment_method",
Insertable::Mandate(_) => "mandate",
},
Self::Update { updatable } => match **updatable {
Updateable::PaymentIntentUpdate(_) => "payment_intent",
Updateable::PaymentAttemptUpdate(_) => "payment_attempt",
Updateable::RefundUpdate(_) => "refund",
Updateable::CustomerUpdate(_) => "customer",
Updateable::AddressUpdate(_) => "address",
Updateable::PayoutsUpdate(_) => "payouts",
Updateable::PayoutAttemptUpdate(_) => "payout_attempt",
Updateable::PaymentMethodUpdate(_) => "payment_method",
Updateable::MandateUpdate(_) => " mandate",
},
}
}
| {
"crate": "diesel_models",
"file": null,
"file_size": null,
"is_async": false,
"is_pub": true,
"num_enums": null,
"num_structs": null,
"num_tables": null,
"score": 180,
"total_crates": null
} |
fn_clm_diesel_models_to_field_value_pairs_-6747035942392026091 | clm | function | // Repository: hyperswitch
// Crate: diesel_models
// Purpose: Database schema types directly mapping to PostgreSQL tables
// Module: crates/diesel_models/src/kv
// Inherent implementation for TypedSql
pub fn to_field_value_pairs(
&self,
request_id: String,
global_id: String,
) -> crate::StorageResult<Vec<(&str, String)>> {
let pushed_at = common_utils::date_time::now_unix_timestamp();
Ok(vec![
(
"typed_sql",
serde_json::to_string(self)
.change_context(errors::DatabaseError::QueryGenerationFailed)?,
),
("global_id", global_id),
("request_id", request_id),
("pushed_at", pushed_at.to_string()),
])
}
| {
"crate": "diesel_models",
"file": null,
"file_size": null,
"is_async": false,
"is_pub": true,
"num_enums": null,
"num_structs": null,
"num_tables": null,
"score": 23,
"total_crates": null
} |
fn_clm_diesel_models_operation_-6747035942392026091 | clm | function | // Repository: hyperswitch
// Crate: diesel_models
// Purpose: Database schema types directly mapping to PostgreSQL tables
// Module: crates/diesel_models/src/kv
// Inherent implementation for DBOperation
pub fn operation<'a>(&self) -> &'a str {
match self {
Self::Insert { .. } => "insert",
Self::Update { .. } => "update",
}
}
| {
"crate": "diesel_models",
"file": null,
"file_size": null,
"is_async": false,
"is_pub": true,
"num_enums": null,
"num_structs": null,
"num_tables": null,
"score": 21,
"total_crates": null
} |
fn_clm_diesel_models_from_9169240299650421155 | clm | function | // Repository: hyperswitch
// Crate: diesel_models
// Purpose: Database schema types directly mapping to PostgreSQL tables
// Module: crates/diesel_models/src/role
// Implementation of RoleUpdateInternal for From<RoleUpdate>
fn from(value: RoleUpdate) -> Self {
match value {
RoleUpdate::UpdateDetails {
groups,
role_name,
last_modified_by,
last_modified_at,
} => Self {
groups,
role_name,
last_modified_at,
last_modified_by,
},
}
}
| {
"crate": "diesel_models",
"file": null,
"file_size": null,
"is_async": false,
"is_pub": false,
"num_enums": null,
"num_structs": null,
"num_tables": null,
"score": 2600,
"total_crates": null
} |
fn_clm_diesel_models_get_payment_method_type_3552565448639338181 | clm | function | // Repository: hyperswitch
// Crate: diesel_models
// Purpose: Database schema types directly mapping to PostgreSQL tables
// Module: crates/diesel_models/src/types
// Implementation of None for FeatureMetadata
pub fn get_payment_method_type(&self) -> Option<common_enums::PaymentMethod> {
self.payment_revenue_recovery_metadata
.as_ref()
.map(|recovery_metadata| recovery_metadata.payment_method_type)
}
| {
"crate": "diesel_models",
"file": null,
"file_size": null,
"is_async": false,
"is_pub": true,
"num_enums": null,
"num_structs": null,
"num_tables": null,
"score": 133,
"total_crates": null
} |
fn_clm_diesel_models_get_payment_method_sub_type_3552565448639338181 | clm | function | // Repository: hyperswitch
// Crate: diesel_models
// Purpose: Database schema types directly mapping to PostgreSQL tables
// Module: crates/diesel_models/src/types
// Implementation of None for FeatureMetadata
pub fn get_payment_method_sub_type(&self) -> Option<common_enums::PaymentMethodType> {
self.payment_revenue_recovery_metadata
.as_ref()
.map(|rrm| rrm.payment_method_subtype)
}
| {
"crate": "diesel_models",
"file": null,
"file_size": null,
"is_async": false,
"is_pub": true,
"num_enums": null,
"num_structs": null,
"num_tables": null,
"score": 34,
"total_crates": null
} |
fn_clm_diesel_models_get_billing_merchant_connector_account_id_3552565448639338181 | clm | function | // Repository: hyperswitch
// Crate: diesel_models
// Purpose: Database schema types directly mapping to PostgreSQL tables
// Module: crates/diesel_models/src/types
// Implementation of None for FeatureMetadata
pub fn get_billing_merchant_connector_account_id(
&self,
) -> Option<id_type::MerchantConnectorAccountId> {
self.payment_revenue_recovery_metadata
.as_ref()
.map(|recovery_metadata| recovery_metadata.billing_connector_id.clone())
}
| {
"crate": "diesel_models",
"file": null,
"file_size": null,
"is_async": false,
"is_pub": true,
"num_enums": null,
"num_structs": null,
"num_tables": null,
"score": 27,
"total_crates": null
} |
fn_clm_diesel_models_from_-3512370202979930317 | clm | function | // Repository: hyperswitch
// Crate: diesel_models
// Purpose: Database schema types directly mapping to PostgreSQL tables
// Module: crates/diesel_models/src/payment_attempt
// Implementation of PaymentAttemptUpdateInternal for From<PaymentAttemptUpdate>
fn from(payment_attempt_update: PaymentAttemptUpdate) -> Self {
match payment_attempt_update {
PaymentAttemptUpdate::Update {
amount,
currency,
status,
// connector_transaction_id,
authentication_type,
payment_method,
payment_token,
payment_method_data,
payment_method_type,
payment_experience,
business_sub_label,
amount_to_capture,
capture_method,
surcharge_amount,
tax_amount,
fingerprint_id,
updated_by,
payment_method_billing_address_id,
network_transaction_id,
} => Self {
amount: Some(amount),
currency: Some(currency),
status: Some(status),
// connector_transaction_id,
authentication_type,
payment_method,
payment_token,
modified_at: common_utils::date_time::now(),
payment_method_data,
payment_method_type,
payment_experience,
business_sub_label,
amount_to_capture,
capture_method,
surcharge_amount,
tax_amount,
fingerprint_id,
payment_method_billing_address_id,
updated_by,
net_amount: None,
connector_transaction_id: None,
connector: None,
error_message: None,
payment_method_id: None,
cancellation_reason: None,
mandate_id: None,
browser_info: None,
error_code: None,
connector_metadata: None,
straight_through_algorithm: None,
preprocessing_step_id: None,
error_reason: None,
connector_response_reference_id: None,
multiple_capture_count: None,
amount_capturable: None,
merchant_connector_id: None,
authentication_data: None,
encoded_data: None,
unified_code: None,
unified_message: None,
external_three_ds_authentication_attempted: None,
authentication_connector: None,
authentication_id: None,
client_source: None,
client_version: None,
customer_acceptance: None,
card_network: None,
shipping_cost: None,
capture_before: None,
extended_authorization_applied: None,
order_tax_amount: None,
processor_transaction_data: None,
connector_mandate_detail: None,
card_discovery: None,
charges: None,
issuer_error_code: None,
issuer_error_message: None,
setup_future_usage_applied: None,
routing_approach: None,
connector_request_reference_id: None,
network_transaction_id,
is_overcapture_enabled: None,
network_details: None,
is_stored_credential: None,
request_extended_authorization: None,
authorized_amount: None,
},
PaymentAttemptUpdate::AuthenticationTypeUpdate {
authentication_type,
updated_by,
} => Self {
authentication_type: Some(authentication_type),
modified_at: common_utils::date_time::now(),
updated_by,
amount: None,
net_amount: None,
currency: None,
status: None,
connector_transaction_id: None,
amount_to_capture: None,
connector: None,
payment_method: None,
error_message: None,
payment_method_id: None,
cancellation_reason: None,
mandate_id: None,
browser_info: None,
payment_token: None,
error_code: None,
connector_metadata: None,
payment_method_data: None,
payment_method_type: None,
payment_experience: None,
business_sub_label: None,
straight_through_algorithm: None,
preprocessing_step_id: None,
error_reason: None,
capture_method: None,
connector_response_reference_id: None,
multiple_capture_count: None,
surcharge_amount: None,
tax_amount: None,
amount_capturable: None,
merchant_connector_id: None,
authentication_data: None,
encoded_data: None,
unified_code: None,
unified_message: None,
external_three_ds_authentication_attempted: None,
authentication_connector: None,
authentication_id: None,
fingerprint_id: None,
payment_method_billing_address_id: None,
client_source: None,
client_version: None,
customer_acceptance: None,
card_network: None,
shipping_cost: None,
order_tax_amount: None,
capture_before: None,
extended_authorization_applied: None,
processor_transaction_data: None,
connector_mandate_detail: None,
card_discovery: None,
charges: None,
issuer_error_code: None,
issuer_error_message: None,
setup_future_usage_applied: None,
routing_approach: None,
connector_request_reference_id: None,
network_transaction_id: None,
is_overcapture_enabled: None,
network_details: None,
is_stored_credential: None,
request_extended_authorization: None,
authorized_amount: None,
},
PaymentAttemptUpdate::ConfirmUpdate {
amount,
currency,
authentication_type,
capture_method,
status,
payment_method,
browser_info,
connector,
payment_token,
payment_method_data,
payment_method_type,
payment_experience,
business_sub_label,
straight_through_algorithm,
error_code,
error_message,
updated_by,
merchant_connector_id,
surcharge_amount,
tax_amount,
external_three_ds_authentication_attempted,
authentication_connector,
authentication_id,
payment_method_billing_address_id,
fingerprint_id,
payment_method_id,
client_source,
client_version,
customer_acceptance,
shipping_cost,
order_tax_amount,
connector_mandate_detail,
card_discovery,
routing_approach,
connector_request_reference_id,
network_transaction_id,
is_stored_credential,
request_extended_authorization,
} => Self {
amount: Some(amount),
currency: Some(currency),
authentication_type,
status: Some(status),
payment_method,
modified_at: common_utils::date_time::now(),
browser_info,
connector: connector.map(Some),
payment_token,
payment_method_data,
payment_method_type,
payment_experience,
business_sub_label,
straight_through_algorithm,
error_code,
error_message,
amount_capturable: None,
updated_by,
merchant_connector_id: merchant_connector_id.map(Some),
surcharge_amount,
tax_amount,
external_three_ds_authentication_attempted,
authentication_connector,
authentication_id,
payment_method_billing_address_id,
fingerprint_id,
payment_method_id,
capture_method,
client_source,
client_version,
customer_acceptance,
net_amount: None,
connector_transaction_id: None,
amount_to_capture: None,
cancellation_reason: None,
mandate_id: None,
connector_metadata: None,
preprocessing_step_id: None,
error_reason: None,
connector_response_reference_id: None,
multiple_capture_count: None,
authentication_data: None,
encoded_data: None,
unified_code: None,
unified_message: None,
card_network: None,
shipping_cost,
order_tax_amount,
capture_before: None,
extended_authorization_applied: None,
processor_transaction_data: None,
connector_mandate_detail,
card_discovery,
charges: None,
issuer_error_code: None,
issuer_error_message: None,
setup_future_usage_applied: None,
routing_approach,
connector_request_reference_id,
network_transaction_id,
is_overcapture_enabled: None,
network_details: None,
is_stored_credential,
request_extended_authorization,
authorized_amount: None,
},
PaymentAttemptUpdate::VoidUpdate {
status,
cancellation_reason,
updated_by,
} => Self {
status: Some(status),
cancellation_reason,
modified_at: common_utils::date_time::now(),
updated_by,
amount: None,
net_amount: None,
currency: None,
connector_transaction_id: None,
amount_to_capture: None,
connector: None,
authentication_type: None,
payment_method: None,
error_message: None,
payment_method_id: None,
mandate_id: None,
browser_info: None,
payment_token: None,
error_code: None,
connector_metadata: None,
payment_method_data: None,
payment_method_type: None,
payment_experience: None,
business_sub_label: None,
straight_through_algorithm: None,
preprocessing_step_id: None,
error_reason: None,
capture_method: None,
connector_response_reference_id: None,
multiple_capture_count: None,
surcharge_amount: None,
tax_amount: None,
amount_capturable: None,
merchant_connector_id: None,
authentication_data: None,
encoded_data: None,
unified_code: None,
unified_message: None,
external_three_ds_authentication_attempted: None,
authentication_connector: None,
authentication_id: None,
fingerprint_id: None,
payment_method_billing_address_id: None,
client_source: None,
client_version: None,
customer_acceptance: None,
card_network: None,
shipping_cost: None,
order_tax_amount: None,
capture_before: None,
extended_authorization_applied: None,
processor_transaction_data: None,
connector_mandate_detail: None,
card_discovery: None,
charges: None,
issuer_error_code: None,
issuer_error_message: None,
setup_future_usage_applied: None,
routing_approach: None,
connector_request_reference_id: None,
network_transaction_id: None,
is_overcapture_enabled: None,
network_details: None,
is_stored_credential: None,
request_extended_authorization: None,
authorized_amount: None,
},
PaymentAttemptUpdate::RejectUpdate {
status,
error_code,
error_message,
updated_by,
} => Self {
status: Some(status),
modified_at: common_utils::date_time::now(),
error_code,
error_message,
updated_by,
amount: None,
net_amount: None,
currency: None,
connector_transaction_id: None,
amount_to_capture: None,
connector: None,
authentication_type: None,
payment_method: None,
payment_method_id: None,
cancellation_reason: None,
mandate_id: None,
browser_info: None,
payment_token: None,
connector_metadata: None,
payment_method_data: None,
payment_method_type: None,
payment_experience: None,
business_sub_label: None,
straight_through_algorithm: None,
preprocessing_step_id: None,
error_reason: None,
capture_method: None,
connector_response_reference_id: None,
multiple_capture_count: None,
surcharge_amount: None,
tax_amount: None,
amount_capturable: None,
merchant_connector_id: None,
authentication_data: None,
encoded_data: None,
unified_code: None,
unified_message: None,
external_three_ds_authentication_attempted: None,
authentication_connector: None,
authentication_id: None,
fingerprint_id: None,
payment_method_billing_address_id: None,
client_source: None,
client_version: None,
customer_acceptance: None,
card_network: None,
shipping_cost: None,
order_tax_amount: None,
capture_before: None,
extended_authorization_applied: None,
processor_transaction_data: None,
connector_mandate_detail: None,
card_discovery: None,
charges: None,
issuer_error_code: None,
issuer_error_message: None,
setup_future_usage_applied: None,
routing_approach: None,
connector_request_reference_id: None,
network_transaction_id: None,
is_overcapture_enabled: None,
network_details: None,
is_stored_credential: None,
request_extended_authorization: None,
authorized_amount: None,
},
PaymentAttemptUpdate::BlocklistUpdate {
status,
error_code,
error_message,
updated_by,
} => Self {
status: Some(status),
modified_at: common_utils::date_time::now(),
error_code,
connector: Some(None),
error_message,
updated_by,
merchant_connector_id: Some(None),
amount: None,
net_amount: None,
currency: None,
connector_transaction_id: None,
amount_to_capture: None,
authentication_type: None,
payment_method: None,
payment_method_id: None,
cancellation_reason: None,
mandate_id: None,
browser_info: None,
payment_token: None,
connector_metadata: None,
payment_method_data: None,
payment_method_type: None,
payment_experience: None,
business_sub_label: None,
straight_through_algorithm: None,
preprocessing_step_id: None,
error_reason: None,
capture_method: None,
connector_response_reference_id: None,
multiple_capture_count: None,
surcharge_amount: None,
tax_amount: None,
amount_capturable: None,
authentication_data: None,
encoded_data: None,
unified_code: None,
unified_message: None,
external_three_ds_authentication_attempted: None,
authentication_connector: None,
authentication_id: None,
fingerprint_id: None,
payment_method_billing_address_id: None,
client_source: None,
client_version: None,
customer_acceptance: None,
card_network: None,
shipping_cost: None,
order_tax_amount: None,
capture_before: None,
extended_authorization_applied: None,
processor_transaction_data: None,
connector_mandate_detail: None,
card_discovery: None,
charges: None,
issuer_error_code: None,
issuer_error_message: None,
setup_future_usage_applied: None,
routing_approach: None,
connector_request_reference_id: None,
network_transaction_id: None,
is_overcapture_enabled: None,
network_details: None,
is_stored_credential: None,
request_extended_authorization: None,
authorized_amount: None,
},
PaymentAttemptUpdate::ConnectorMandateDetailUpdate {
connector_mandate_detail,
updated_by,
} => Self {
payment_method_id: None,
modified_at: common_utils::date_time::now(),
updated_by,
amount: None,
net_amount: None,
currency: None,
status: None,
connector_transaction_id: None,
amount_to_capture: None,
connector: None,
authentication_type: None,
payment_method: None,
error_message: None,
cancellation_reason: None,
mandate_id: None,
browser_info: None,
payment_token: None,
error_code: None,
connector_metadata: None,
payment_method_data: None,
payment_method_type: None,
payment_experience: None,
business_sub_label: None,
straight_through_algorithm: None,
preprocessing_step_id: None,
error_reason: None,
capture_method: None,
connector_response_reference_id: None,
multiple_capture_count: None,
surcharge_amount: None,
tax_amount: None,
amount_capturable: None,
merchant_connector_id: None,
authentication_data: None,
encoded_data: None,
unified_code: None,
unified_message: None,
external_three_ds_authentication_attempted: None,
authentication_connector: None,
authentication_id: None,
fingerprint_id: None,
payment_method_billing_address_id: None,
client_source: None,
client_version: None,
customer_acceptance: None,
card_network: None,
shipping_cost: None,
order_tax_amount: None,
capture_before: None,
extended_authorization_applied: None,
processor_transaction_data: None,
connector_mandate_detail,
card_discovery: None,
charges: None,
issuer_error_code: None,
issuer_error_message: None,
setup_future_usage_applied: None,
routing_approach: None,
connector_request_reference_id: None,
network_transaction_id: None,
is_overcapture_enabled: None,
network_details: None,
is_stored_credential: None,
request_extended_authorization: None,
authorized_amount: None,
},
PaymentAttemptUpdate::PaymentMethodDetailsUpdate {
payment_method_id,
updated_by,
} => Self {
payment_method_id,
modified_at: common_utils::date_time::now(),
updated_by,
amount: None,
net_amount: None,
currency: None,
status: None,
connector_transaction_id: None,
amount_to_capture: None,
connector: None,
authentication_type: None,
payment_method: None,
error_message: None,
cancellation_reason: None,
mandate_id: None,
browser_info: None,
payment_token: None,
error_code: None,
connector_metadata: None,
payment_method_data: None,
payment_method_type: None,
payment_experience: None,
business_sub_label: None,
straight_through_algorithm: None,
preprocessing_step_id: None,
error_reason: None,
capture_method: None,
connector_response_reference_id: None,
multiple_capture_count: None,
surcharge_amount: None,
tax_amount: None,
amount_capturable: None,
merchant_connector_id: None,
authentication_data: None,
encoded_data: None,
unified_code: None,
unified_message: None,
external_three_ds_authentication_attempted: None,
authentication_connector: None,
authentication_id: None,
fingerprint_id: None,
payment_method_billing_address_id: None,
client_source: None,
client_version: None,
customer_acceptance: None,
card_network: None,
shipping_cost: None,
order_tax_amount: None,
capture_before: None,
extended_authorization_applied: None,
processor_transaction_data: None,
connector_mandate_detail: None,
card_discovery: None,
charges: None,
issuer_error_code: None,
issuer_error_message: None,
setup_future_usage_applied: None,
routing_approach: None,
connector_request_reference_id: None,
network_transaction_id: None,
is_overcapture_enabled: None,
network_details: None,
is_stored_credential: None,
request_extended_authorization: None,
authorized_amount: None,
},
PaymentAttemptUpdate::ResponseUpdate {
status,
connector,
connector_transaction_id,
authentication_type,
payment_method_id,
mandate_id,
connector_metadata,
payment_token,
error_code,
error_message,
error_reason,
connector_response_reference_id,
amount_capturable,
updated_by,
authentication_data,
encoded_data,
unified_code,
unified_message,
capture_before,
extended_authorization_applied,
payment_method_data,
connector_mandate_detail,
charges,
setup_future_usage_applied,
network_transaction_id,
is_overcapture_enabled,
authorized_amount,
} => {
let (connector_transaction_id, processor_transaction_data) =
connector_transaction_id
.map(ConnectorTransactionId::form_id_and_data)
.map(|(txn_id, txn_data)| (Some(txn_id), txn_data))
.unwrap_or((None, None));
Self {
status: Some(status),
connector: connector.map(Some),
connector_transaction_id,
authentication_type,
payment_method_id,
modified_at: common_utils::date_time::now(),
mandate_id,
connector_metadata,
error_code,
error_message,
payment_token,
error_reason,
connector_response_reference_id,
amount_capturable,
updated_by,
authentication_data,
encoded_data,
unified_code,
unified_message,
payment_method_data,
processor_transaction_data,
connector_mandate_detail,
charges,
amount: None,
net_amount: None,
currency: None,
amount_to_capture: None,
payment_method: None,
cancellation_reason: None,
browser_info: None,
payment_method_type: None,
payment_experience: None,
business_sub_label: None,
straight_through_algorithm: None,
preprocessing_step_id: None,
capture_method: None,
multiple_capture_count: None,
surcharge_amount: None,
tax_amount: None,
merchant_connector_id: None,
external_three_ds_authentication_attempted: None,
authentication_connector: None,
authentication_id: None,
fingerprint_id: None,
payment_method_billing_address_id: None,
client_source: None,
client_version: None,
customer_acceptance: None,
card_network: None,
capture_before,
extended_authorization_applied,
shipping_cost: None,
order_tax_amount: None,
card_discovery: None,
issuer_error_code: None,
issuer_error_message: None,
setup_future_usage_applied,
routing_approach: None,
connector_request_reference_id: None,
network_transaction_id,
is_overcapture_enabled,
network_details: None,
is_stored_credential: None,
request_extended_authorization: None,
authorized_amount,
}
}
PaymentAttemptUpdate::ErrorUpdate {
connector,
status,
error_code,
error_message,
error_reason,
amount_capturable,
updated_by,
unified_code,
unified_message,
connector_transaction_id,
payment_method_data,
authentication_type,
issuer_error_code,
issuer_error_message,
network_details,
} => {
let (connector_transaction_id, processor_transaction_data) =
connector_transaction_id
.map(ConnectorTransactionId::form_id_and_data)
.map(|(txn_id, txn_data)| (Some(txn_id), txn_data))
.unwrap_or((None, None));
Self {
connector: connector.map(Some),
status: Some(status),
error_message,
error_code,
modified_at: common_utils::date_time::now(),
error_reason,
amount_capturable,
updated_by,
unified_code,
unified_message,
connector_transaction_id,
payment_method_data,
authentication_type,
processor_transaction_data,
issuer_error_code,
issuer_error_message,
amount: None,
net_amount: None,
currency: None,
amount_to_capture: None,
payment_method: None,
payment_method_id: None,
cancellation_reason: None,
mandate_id: None,
browser_info: None,
payment_token: None,
connector_metadata: None,
payment_method_type: None,
payment_experience: None,
business_sub_label: None,
straight_through_algorithm: None,
preprocessing_step_id: None,
capture_method: None,
connector_response_reference_id: None,
multiple_capture_count: None,
surcharge_amount: None,
tax_amount: None,
merchant_connector_id: None,
authentication_data: None,
encoded_data: None,
external_three_ds_authentication_attempted: None,
authentication_connector: None,
authentication_id: None,
fingerprint_id: None,
payment_method_billing_address_id: None,
client_source: None,
client_version: None,
customer_acceptance: None,
card_network: None,
capture_before: None,
extended_authorization_applied: None,
shipping_cost: None,
order_tax_amount: None,
connector_mandate_detail: None,
card_discovery: None,
charges: None,
setup_future_usage_applied: None,
routing_approach: None,
connector_request_reference_id: None,
network_transaction_id: None,
is_overcapture_enabled: None,
network_details,
is_stored_credential: None,
request_extended_authorization: None,
authorized_amount: None,
}
}
PaymentAttemptUpdate::StatusUpdate { status, updated_by } => Self {
status: Some(status),
modified_at: common_utils::date_time::now(),
updated_by,
amount: None,
net_amount: None,
currency: None,
connector_transaction_id: None,
amount_to_capture: None,
connector: None,
authentication_type: None,
payment_method: None,
error_message: None,
payment_method_id: None,
cancellation_reason: None,
mandate_id: None,
browser_info: None,
payment_token: None,
error_code: None,
connector_metadata: None,
payment_method_data: None,
payment_method_type: None,
payment_experience: None,
business_sub_label: None,
straight_through_algorithm: None,
preprocessing_step_id: None,
error_reason: None,
capture_method: None,
connector_response_reference_id: None,
multiple_capture_count: None,
surcharge_amount: None,
tax_amount: None,
amount_capturable: None,
merchant_connector_id: None,
authentication_data: None,
encoded_data: None,
unified_code: None,
unified_message: None,
external_three_ds_authentication_attempted: None,
authentication_connector: None,
authentication_id: None,
fingerprint_id: None,
payment_method_billing_address_id: None,
client_source: None,
client_version: None,
customer_acceptance: None,
card_network: None,
shipping_cost: None,
capture_before: None,
extended_authorization_applied: None,
order_tax_amount: None,
processor_transaction_data: None,
connector_mandate_detail: None,
card_discovery: None,
charges: None,
issuer_error_code: None,
issuer_error_message: None,
setup_future_usage_applied: None,
routing_approach: None,
connector_request_reference_id: None,
network_transaction_id: None,
is_overcapture_enabled: None,
network_details: None,
is_stored_credential: None,
request_extended_authorization: None,
authorized_amount: None,
},
PaymentAttemptUpdate::UpdateTrackers {
payment_token,
connector,
straight_through_algorithm,
amount_capturable,
surcharge_amount,
tax_amount,
updated_by,
merchant_connector_id,
routing_approach,
is_stored_credential,
} => Self {
payment_token,
modified_at: common_utils::date_time::now(),
connector: connector.map(Some),
straight_through_algorithm,
amount_capturable,
surcharge_amount,
tax_amount,
updated_by,
merchant_connector_id: merchant_connector_id.map(Some),
amount: None,
net_amount: None,
currency: None,
status: None,
connector_transaction_id: None,
amount_to_capture: None,
authentication_type: None,
payment_method: None,
error_message: None,
payment_method_id: None,
cancellation_reason: None,
mandate_id: None,
browser_info: None,
error_code: None,
connector_metadata: None,
payment_method_data: None,
payment_method_type: None,
payment_experience: None,
business_sub_label: None,
preprocessing_step_id: None,
error_reason: None,
capture_method: None,
connector_response_reference_id: None,
multiple_capture_count: None,
authentication_data: None,
encoded_data: None,
unified_code: None,
unified_message: None,
external_three_ds_authentication_attempted: None,
authentication_connector: None,
authentication_id: None,
fingerprint_id: None,
payment_method_billing_address_id: None,
client_source: None,
client_version: None,
customer_acceptance: None,
card_network: None,
shipping_cost: None,
capture_before: None,
extended_authorization_applied: None,
order_tax_amount: None,
processor_transaction_data: None,
connector_mandate_detail: None,
card_discovery: None,
charges: None,
issuer_error_code: None,
issuer_error_message: None,
setup_future_usage_applied: None,
routing_approach,
connector_request_reference_id: None,
network_transaction_id: None,
is_overcapture_enabled: None,
network_details: None,
is_stored_credential,
request_extended_authorization: None,
authorized_amount: None,
},
PaymentAttemptUpdate::UnresolvedResponseUpdate {
status,
connector,
connector_transaction_id,
payment_method_id,
error_code,
error_message,
error_reason,
connector_response_reference_id,
updated_by,
} => {
let (connector_transaction_id, processor_transaction_data) =
connector_transaction_id
.map(ConnectorTransactionId::form_id_and_data)
.map(|(txn_id, txn_data)| (Some(txn_id), txn_data))
.unwrap_or((None, None));
Self {
status: Some(status),
connector: connector.map(Some),
connector_transaction_id,
payment_method_id,
modified_at: common_utils::date_time::now(),
error_code,
error_message,
error_reason,
connector_response_reference_id,
updated_by,
processor_transaction_data,
amount: None,
net_amount: None,
currency: None,
amount_to_capture: None,
authentication_type: None,
payment_method: None,
cancellation_reason: None,
mandate_id: None,
browser_info: None,
payment_token: None,
connector_metadata: None,
payment_method_data: None,
payment_method_type: None,
payment_experience: None,
business_sub_label: None,
straight_through_algorithm: None,
preprocessing_step_id: None,
capture_method: None,
multiple_capture_count: None,
surcharge_amount: None,
tax_amount: None,
amount_capturable: None,
merchant_connector_id: None,
authentication_data: None,
encoded_data: None,
unified_code: None,
unified_message: None,
external_three_ds_authentication_attempted: None,
authentication_connector: None,
authentication_id: None,
fingerprint_id: None,
payment_method_billing_address_id: None,
client_source: None,
client_version: None,
customer_acceptance: None,
card_network: None,
shipping_cost: None,
capture_before: None,
extended_authorization_applied: None,
order_tax_amount: None,
connector_mandate_detail: None,
card_discovery: None,
charges: None,
issuer_error_code: None,
issuer_error_message: None,
setup_future_usage_applied: None,
routing_approach: None,
connector_request_reference_id: None,
network_transaction_id: None,
is_overcapture_enabled: None,
network_details: None,
is_stored_credential: None,
request_extended_authorization: None,
authorized_amount: None,
}
}
PaymentAttemptUpdate::PreprocessingUpdate {
status,
payment_method_id,
connector_metadata,
preprocessing_step_id,
connector_transaction_id,
connector_response_reference_id,
updated_by,
} => {
let (connector_transaction_id, processor_transaction_data) =
connector_transaction_id
.map(ConnectorTransactionId::form_id_and_data)
.map(|(txn_id, txn_data)| (Some(txn_id), txn_data))
.unwrap_or((None, None));
Self {
status: Some(status),
payment_method_id,
modified_at: common_utils::date_time::now(),
connector_metadata,
preprocessing_step_id,
connector_transaction_id,
connector_response_reference_id,
updated_by,
processor_transaction_data,
amount: None,
net_amount: None,
currency: None,
amount_to_capture: None,
connector: None,
authentication_type: None,
payment_method: None,
error_message: None,
cancellation_reason: None,
mandate_id: None,
browser_info: None,
payment_token: None,
error_code: None,
payment_method_data: None,
payment_method_type: None,
payment_experience: None,
business_sub_label: None,
straight_through_algorithm: None,
error_reason: None,
capture_method: None,
multiple_capture_count: None,
surcharge_amount: None,
tax_amount: None,
amount_capturable: None,
merchant_connector_id: None,
authentication_data: None,
encoded_data: None,
unified_code: None,
unified_message: None,
external_three_ds_authentication_attempted: None,
authentication_connector: None,
authentication_id: None,
fingerprint_id: None,
payment_method_billing_address_id: None,
client_source: None,
client_version: None,
customer_acceptance: None,
card_network: None,
capture_before: None,
extended_authorization_applied: None,
shipping_cost: None,
order_tax_amount: None,
connector_mandate_detail: None,
card_discovery: None,
charges: None,
issuer_error_code: None,
issuer_error_message: None,
setup_future_usage_applied: None,
routing_approach: None,
connector_request_reference_id: None,
network_transaction_id: None,
is_overcapture_enabled: None,
network_details: None,
is_stored_credential: None,
request_extended_authorization: None,
authorized_amount: None,
}
}
PaymentAttemptUpdate::CaptureUpdate {
multiple_capture_count,
updated_by,
amount_to_capture,
} => Self {
multiple_capture_count,
modified_at: common_utils::date_time::now(),
updated_by,
amount_to_capture,
amount: None,
net_amount: None,
currency: None,
status: None,
connector_transaction_id: None,
connector: None,
authentication_type: None,
payment_method: None,
error_message: None,
payment_method_id: None,
cancellation_reason: None,
mandate_id: None,
browser_info: None,
payment_token: None,
error_code: None,
connector_metadata: None,
payment_method_data: None,
payment_method_type: None,
payment_experience: None,
business_sub_label: None,
straight_through_algorithm: None,
preprocessing_step_id: None,
error_reason: None,
capture_method: None,
connector_response_reference_id: None,
surcharge_amount: None,
tax_amount: None,
amount_capturable: None,
merchant_connector_id: None,
authentication_data: None,
encoded_data: None,
unified_code: None,
unified_message: None,
external_three_ds_authentication_attempted: None,
authentication_connector: None,
authentication_id: None,
fingerprint_id: None,
payment_method_billing_address_id: None,
client_source: None,
client_version: None,
customer_acceptance: None,
card_network: None,
shipping_cost: None,
order_tax_amount: None,
capture_before: None,
extended_authorization_applied: None,
processor_transaction_data: None,
connector_mandate_detail: None,
card_discovery: None,
charges: None,
issuer_error_code: None,
issuer_error_message: None,
setup_future_usage_applied: None,
routing_approach: None,
connector_request_reference_id: None,
network_transaction_id: None,
is_overcapture_enabled: None,
network_details: None,
is_stored_credential: None,
request_extended_authorization: None,
authorized_amount: None,
},
PaymentAttemptUpdate::AmountToCaptureUpdate {
status,
amount_capturable,
updated_by,
} => Self {
status: Some(status),
modified_at: common_utils::date_time::now(),
amount_capturable: Some(amount_capturable),
updated_by,
amount: None,
net_amount: None,
currency: None,
connector_transaction_id: None,
amount_to_capture: None,
connector: None,
authentication_type: None,
payment_method: None,
error_message: None,
payment_method_id: None,
cancellation_reason: None,
mandate_id: None,
browser_info: None,
payment_token: None,
error_code: None,
connector_metadata: None,
payment_method_data: None,
payment_method_type: None,
payment_experience: None,
business_sub_label: None,
straight_through_algorithm: None,
preprocessing_step_id: None,
error_reason: None,
capture_method: None,
connector_response_reference_id: None,
multiple_capture_count: None,
surcharge_amount: None,
tax_amount: None,
merchant_connector_id: None,
authentication_data: None,
encoded_data: None,
unified_code: None,
unified_message: None,
external_three_ds_authentication_attempted: None,
authentication_connector: None,
authentication_id: None,
fingerprint_id: None,
payment_method_billing_address_id: None,
client_source: None,
client_version: None,
customer_acceptance: None,
card_network: None,
shipping_cost: None,
capture_before: None,
extended_authorization_applied: None,
order_tax_amount: None,
processor_transaction_data: None,
connector_mandate_detail: None,
card_discovery: None,
charges: None,
issuer_error_code: None,
issuer_error_message: None,
setup_future_usage_applied: None,
routing_approach: None,
connector_request_reference_id: None,
network_transaction_id: None,
is_overcapture_enabled: None,
network_details: None,
is_stored_credential: None,
request_extended_authorization: None,
authorized_amount: None,
},
PaymentAttemptUpdate::ConnectorResponse {
authentication_data,
encoded_data,
connector_transaction_id,
connector,
updated_by,
charges,
} => {
let (connector_transaction_id, processor_transaction_data) =
connector_transaction_id
.map(ConnectorTransactionId::form_id_and_data)
.map(|(txn_id, txn_data)| (Some(txn_id), txn_data))
.unwrap_or((None, None));
Self {
authentication_data,
encoded_data,
connector_transaction_id,
connector: connector.map(Some),
modified_at: common_utils::date_time::now(),
updated_by,
processor_transaction_data,
charges,
amount: None,
net_amount: None,
currency: None,
status: None,
amount_to_capture: None,
authentication_type: None,
payment_method: None,
error_message: None,
payment_method_id: None,
cancellation_reason: None,
mandate_id: None,
browser_info: None,
payment_token: None,
error_code: None,
connector_metadata: None,
payment_method_data: None,
payment_method_type: None,
payment_experience: None,
business_sub_label: None,
straight_through_algorithm: None,
preprocessing_step_id: None,
error_reason: None,
capture_method: None,
connector_response_reference_id: None,
multiple_capture_count: None,
surcharge_amount: None,
tax_amount: None,
amount_capturable: None,
merchant_connector_id: None,
unified_code: None,
unified_message: None,
external_three_ds_authentication_attempted: None,
authentication_connector: None,
authentication_id: None,
fingerprint_id: None,
payment_method_billing_address_id: None,
client_source: None,
client_version: None,
customer_acceptance: None,
card_network: None,
shipping_cost: None,
capture_before: None,
extended_authorization_applied: None,
order_tax_amount: None,
connector_mandate_detail: None,
card_discovery: None,
issuer_error_code: None,
issuer_error_message: None,
setup_future_usage_applied: None,
routing_approach: None,
connector_request_reference_id: None,
network_transaction_id: None,
is_overcapture_enabled: None,
network_details: None,
is_stored_credential: None,
request_extended_authorization: None,
authorized_amount: None,
}
}
PaymentAttemptUpdate::IncrementalAuthorizationAmountUpdate {
amount,
amount_capturable,
} => Self {
amount: Some(amount),
modified_at: common_utils::date_time::now(),
amount_capturable: Some(amount_capturable),
net_amount: None,
currency: None,
status: None,
connector_transaction_id: None,
amount_to_capture: None,
connector: None,
authentication_type: None,
payment_method: None,
error_message: None,
payment_method_id: None,
cancellation_reason: None,
mandate_id: None,
browser_info: None,
payment_token: None,
error_code: None,
connector_metadata: None,
payment_method_data: None,
payment_method_type: None,
payment_experience: None,
business_sub_label: None,
straight_through_algorithm: None,
preprocessing_step_id: None,
error_reason: None,
capture_method: None,
connector_response_reference_id: None,
multiple_capture_count: None,
surcharge_amount: None,
tax_amount: None,
updated_by: String::default(),
merchant_connector_id: None,
authentication_data: None,
encoded_data: None,
unified_code: None,
unified_message: None,
external_three_ds_authentication_attempted: None,
authentication_connector: None,
authentication_id: None,
fingerprint_id: None,
payment_method_billing_address_id: None,
client_source: None,
client_version: None,
customer_acceptance: None,
card_network: None,
shipping_cost: None,
order_tax_amount: None,
capture_before: None,
extended_authorization_applied: None,
processor_transaction_data: None,
connector_mandate_detail: None,
card_discovery: None,
charges: None,
issuer_error_code: None,
issuer_error_message: None,
setup_future_usage_applied: None,
routing_approach: None,
connector_request_reference_id: None,
network_transaction_id: None,
is_overcapture_enabled: None,
network_details: None,
is_stored_credential: None,
request_extended_authorization: None,
authorized_amount: None,
},
PaymentAttemptUpdate::AuthenticationUpdate {
status,
external_three_ds_authentication_attempted,
authentication_connector,
authentication_id,
updated_by,
} => Self {
status: Some(status),
modified_at: common_utils::date_time::now(),
external_three_ds_authentication_attempted,
authentication_connector,
authentication_id,
updated_by,
amount: None,
net_amount: None,
currency: None,
connector_transaction_id: None,
amount_to_capture: None,
connector: None,
authentication_type: None,
payment_method: None,
error_message: None,
payment_method_id: None,
cancellation_reason: None,
mandate_id: None,
browser_info: None,
payment_token: None,
error_code: None,
connector_metadata: None,
payment_method_data: None,
payment_method_type: None,
payment_experience: None,
business_sub_label: None,
straight_through_algorithm: None,
preprocessing_step_id: None,
error_reason: None,
capture_method: None,
connector_response_reference_id: None,
multiple_capture_count: None,
surcharge_amount: None,
tax_amount: None,
amount_capturable: None,
merchant_connector_id: None,
authentication_data: None,
encoded_data: None,
unified_code: None,
unified_message: None,
fingerprint_id: None,
payment_method_billing_address_id: None,
client_source: None,
client_version: None,
customer_acceptance: None,
card_network: None,
shipping_cost: None,
order_tax_amount: None,
capture_before: None,
extended_authorization_applied: None,
processor_transaction_data: None,
connector_mandate_detail: None,
card_discovery: None,
charges: None,
issuer_error_code: None,
issuer_error_message: None,
setup_future_usage_applied: None,
routing_approach: None,
connector_request_reference_id: None,
network_transaction_id: None,
is_overcapture_enabled: None,
network_details: None,
is_stored_credential: None,
request_extended_authorization: None,
authorized_amount: None,
},
PaymentAttemptUpdate::ManualUpdate {
status,
error_code,
error_message,
error_reason,
updated_by,
unified_code,
unified_message,
connector_transaction_id,
} => {
let (connector_transaction_id, processor_transaction_data) =
connector_transaction_id
.map(ConnectorTransactionId::form_id_and_data)
.map(|(txn_id, txn_data)| (Some(txn_id), txn_data))
.unwrap_or((None, None));
Self {
status,
error_code: error_code.map(Some),
modified_at: common_utils::date_time::now(),
error_message: error_message.map(Some),
error_reason: error_reason.map(Some),
updated_by,
unified_code: unified_code.map(Some),
unified_message: unified_message.map(Some),
connector_transaction_id,
processor_transaction_data,
amount: None,
net_amount: None,
currency: None,
amount_to_capture: None,
connector: None,
authentication_type: None,
payment_method: None,
payment_method_id: None,
cancellation_reason: None,
mandate_id: None,
browser_info: None,
payment_token: None,
connector_metadata: None,
payment_method_data: None,
payment_method_type: None,
payment_experience: None,
business_sub_label: None,
straight_through_algorithm: None,
preprocessing_step_id: None,
capture_method: None,
connector_response_reference_id: None,
multiple_capture_count: None,
surcharge_amount: None,
tax_amount: None,
amount_capturable: None,
merchant_connector_id: None,
authentication_data: None,
encoded_data: None,
external_three_ds_authentication_attempted: None,
authentication_connector: None,
authentication_id: None,
fingerprint_id: None,
payment_method_billing_address_id: None,
client_source: None,
client_version: None,
customer_acceptance: None,
card_network: None,
shipping_cost: None,
capture_before: None,
extended_authorization_applied: None,
order_tax_amount: None,
connector_mandate_detail: None,
card_discovery: None,
charges: None,
issuer_error_code: None,
issuer_error_message: None,
setup_future_usage_applied: None,
routing_approach: None,
connector_request_reference_id: None,
network_transaction_id: None,
is_overcapture_enabled: None,
network_details: None,
is_stored_credential: None,
request_extended_authorization: None,
authorized_amount: None,
}
}
PaymentAttemptUpdate::PostSessionTokensUpdate {
updated_by,
connector_metadata,
} => Self {
status: None,
error_code: None,
modified_at: common_utils::date_time::now(),
error_message: None,
error_reason: None,
updated_by,
unified_code: None,
unified_message: None,
amount: None,
net_amount: None,
currency: None,
connector_transaction_id: None,
amount_to_capture: None,
connector: None,
authentication_type: None,
payment_method: None,
payment_method_id: None,
cancellation_reason: None,
mandate_id: None,
browser_info: None,
payment_token: None,
connector_metadata,
payment_method_data: None,
payment_method_type: None,
payment_experience: None,
business_sub_label: None,
straight_through_algorithm: None,
preprocessing_step_id: None,
capture_method: None,
connector_response_reference_id: None,
multiple_capture_count: None,
surcharge_amount: None,
tax_amount: None,
amount_capturable: None,
merchant_connector_id: None,
authentication_data: None,
encoded_data: None,
external_three_ds_authentication_attempted: None,
authentication_connector: None,
authentication_id: None,
fingerprint_id: None,
payment_method_billing_address_id: None,
client_source: None,
client_version: None,
customer_acceptance: None,
card_network: None,
shipping_cost: None,
order_tax_amount: None,
capture_before: None,
extended_authorization_applied: None,
processor_transaction_data: None,
connector_mandate_detail: None,
card_discovery: None,
charges: None,
issuer_error_code: None,
issuer_error_message: None,
setup_future_usage_applied: None,
routing_approach: None,
connector_request_reference_id: None,
network_transaction_id: None,
is_overcapture_enabled: None,
network_details: None,
is_stored_credential: None,
request_extended_authorization: None,
authorized_amount: None,
},
}
}
| {
"crate": "diesel_models",
"file": null,
"file_size": null,
"is_async": false,
"is_pub": false,
"num_enums": null,
"num_structs": null,
"num_tables": null,
"score": 2706,
"total_crates": null
} |
fn_clm_diesel_models_apply_changeset_-3512370202979930317 | clm | function | // Repository: hyperswitch
// Crate: diesel_models
// Purpose: Database schema types directly mapping to PostgreSQL tables
// Module: crates/diesel_models/src/payment_attempt
// Inherent implementation for PaymentAttemptUpdate
pub fn apply_changeset(self, source: PaymentAttempt) -> PaymentAttempt {
let PaymentAttemptUpdateInternal {
amount,
net_amount,
currency,
status,
connector_transaction_id,
amount_to_capture,
connector,
authentication_type,
payment_method,
error_message,
payment_method_id,
cancellation_reason,
modified_at: _,
mandate_id,
browser_info,
payment_token,
error_code,
connector_metadata,
payment_method_data,
payment_method_type,
payment_experience,
business_sub_label,
straight_through_algorithm,
preprocessing_step_id,
error_reason,
capture_method,
connector_response_reference_id,
multiple_capture_count,
surcharge_amount,
tax_amount,
amount_capturable,
updated_by,
merchant_connector_id,
authentication_data,
encoded_data,
unified_code,
unified_message,
external_three_ds_authentication_attempted,
authentication_connector,
authentication_id,
payment_method_billing_address_id,
fingerprint_id,
client_source,
client_version,
customer_acceptance,
card_network,
shipping_cost,
order_tax_amount,
processor_transaction_data,
connector_mandate_detail,
capture_before,
extended_authorization_applied,
card_discovery,
charges,
issuer_error_code,
issuer_error_message,
setup_future_usage_applied,
routing_approach,
connector_request_reference_id,
network_transaction_id,
is_overcapture_enabled,
network_details,
is_stored_credential,
request_extended_authorization,
authorized_amount,
} = PaymentAttemptUpdateInternal::from(self).populate_derived_fields(&source);
PaymentAttempt {
amount: amount.unwrap_or(source.amount),
net_amount: net_amount.or(source.net_amount),
currency: currency.or(source.currency),
status: status.unwrap_or(source.status),
connector_transaction_id: connector_transaction_id.or(source.connector_transaction_id),
amount_to_capture: amount_to_capture.or(source.amount_to_capture),
connector: connector.unwrap_or(source.connector),
authentication_type: authentication_type.or(source.authentication_type),
payment_method: payment_method.or(source.payment_method),
error_message: error_message.unwrap_or(source.error_message),
payment_method_id: payment_method_id.or(source.payment_method_id),
cancellation_reason: cancellation_reason.or(source.cancellation_reason),
modified_at: common_utils::date_time::now(),
mandate_id: mandate_id.or(source.mandate_id),
browser_info: browser_info.or(source.browser_info),
payment_token: payment_token.or(source.payment_token),
error_code: error_code.unwrap_or(source.error_code),
connector_metadata: connector_metadata.or(source.connector_metadata),
payment_method_data: payment_method_data.or(source.payment_method_data),
payment_method_type: payment_method_type.or(source.payment_method_type),
payment_experience: payment_experience.or(source.payment_experience),
business_sub_label: business_sub_label.or(source.business_sub_label),
straight_through_algorithm: straight_through_algorithm
.or(source.straight_through_algorithm),
preprocessing_step_id: preprocessing_step_id.or(source.preprocessing_step_id),
error_reason: error_reason.unwrap_or(source.error_reason),
capture_method: capture_method.or(source.capture_method),
connector_response_reference_id: connector_response_reference_id
.or(source.connector_response_reference_id),
multiple_capture_count: multiple_capture_count.or(source.multiple_capture_count),
surcharge_amount: surcharge_amount.or(source.surcharge_amount),
tax_amount: tax_amount.or(source.tax_amount),
amount_capturable: amount_capturable.unwrap_or(source.amount_capturable),
updated_by,
merchant_connector_id: merchant_connector_id.unwrap_or(source.merchant_connector_id),
authentication_data: authentication_data.or(source.authentication_data),
encoded_data: encoded_data.or(source.encoded_data),
unified_code: unified_code.unwrap_or(source.unified_code),
unified_message: unified_message.unwrap_or(source.unified_message),
external_three_ds_authentication_attempted: external_three_ds_authentication_attempted
.or(source.external_three_ds_authentication_attempted),
authentication_connector: authentication_connector.or(source.authentication_connector),
authentication_id: authentication_id.or(source.authentication_id),
payment_method_billing_address_id: payment_method_billing_address_id
.or(source.payment_method_billing_address_id),
fingerprint_id: fingerprint_id.or(source.fingerprint_id),
client_source: client_source.or(source.client_source),
client_version: client_version.or(source.client_version),
customer_acceptance: customer_acceptance.or(source.customer_acceptance),
card_network: card_network.or(source.card_network),
shipping_cost: shipping_cost.or(source.shipping_cost),
order_tax_amount: order_tax_amount.or(source.order_tax_amount),
processor_transaction_data: processor_transaction_data
.or(source.processor_transaction_data),
connector_mandate_detail: connector_mandate_detail.or(source.connector_mandate_detail),
capture_before: capture_before.or(source.capture_before),
extended_authorization_applied: extended_authorization_applied
.or(source.extended_authorization_applied),
card_discovery: card_discovery.or(source.card_discovery),
charges: charges.or(source.charges),
issuer_error_code: issuer_error_code.or(source.issuer_error_code),
issuer_error_message: issuer_error_message.or(source.issuer_error_message),
setup_future_usage_applied: setup_future_usage_applied
.or(source.setup_future_usage_applied),
routing_approach: routing_approach.or(source.routing_approach),
connector_request_reference_id: connector_request_reference_id
.or(source.connector_request_reference_id),
network_transaction_id: network_transaction_id.or(source.network_transaction_id),
is_overcapture_enabled: is_overcapture_enabled.or(source.is_overcapture_enabled),
network_details: network_details.or(source.network_details),
is_stored_credential: is_stored_credential.or(source.is_stored_credential),
request_extended_authorization: request_extended_authorization
.or(source.request_extended_authorization),
authorized_amount: authorized_amount.or(source.authorized_amount),
..source
}
}
| {
"crate": "diesel_models",
"file": null,
"file_size": null,
"is_async": false,
"is_pub": true,
"num_enums": null,
"num_structs": null,
"num_tables": null,
"score": 186,
"total_crates": null
} |
fn_clm_diesel_models_populate_derived_fields_-3512370202979930317 | clm | function | // Repository: hyperswitch
// Crate: diesel_models
// Purpose: Database schema types directly mapping to PostgreSQL tables
// Module: crates/diesel_models/src/payment_attempt
// Inherent implementation for PaymentAttemptUpdateInternal
pub fn populate_derived_fields(self, source: &PaymentAttempt) -> Self {
let mut update_internal = self;
update_internal.net_amount = Some(
update_internal.amount.unwrap_or(source.amount)
+ update_internal
.surcharge_amount
.or(source.surcharge_amount)
.unwrap_or(MinorUnit::new(0))
+ update_internal
.tax_amount
.or(source.tax_amount)
.unwrap_or(MinorUnit::new(0))
+ update_internal
.shipping_cost
.or(source.shipping_cost)
.unwrap_or(MinorUnit::new(0))
+ update_internal
.order_tax_amount
.or(source.order_tax_amount)
.unwrap_or(MinorUnit::new(0)),
);
update_internal.card_network = update_internal
.payment_method_data
.as_ref()
.and_then(|data| data.as_object())
.and_then(|card| card.get("card"))
.and_then(|data| data.as_object())
.and_then(|card| card.get("card_network"))
.and_then(|network| network.as_str())
.map(|network| network.to_string());
update_internal
}
| {
"crate": "diesel_models",
"file": null,
"file_size": null,
"is_async": false,
"is_pub": true,
"num_enums": null,
"num_structs": null,
"num_tables": null,
"score": 73,
"total_crates": null
} |
fn_clm_diesel_models_get_connector_mandate_request_reference_id_-3512370202979930317 | clm | function | // Repository: hyperswitch
// Crate: diesel_models
// Purpose: Database schema types directly mapping to PostgreSQL tables
// Module: crates/diesel_models/src/payment_attempt
// Inherent implementation for ConnectorMandateReferenceId
pub fn get_connector_mandate_request_reference_id(&self) -> Option<String> {
self.connector_mandate_request_reference_id.clone()
}
| {
"crate": "diesel_models",
"file": null,
"file_size": null,
"is_async": false,
"is_pub": true,
"num_enums": null,
"num_structs": null,
"num_tables": null,
"score": 44,
"total_crates": null
} |
fn_clm_diesel_models_get_optional_connector_transaction_id_-3512370202979930317 | clm | function | // Repository: hyperswitch
// Crate: diesel_models
// Purpose: Database schema types directly mapping to PostgreSQL tables
// Module: crates/diesel_models/src/payment_attempt
// Implementation of PaymentAttempt for ConnectorTransactionIdTrait
fn get_optional_connector_transaction_id(&self) -> Option<&String> {
match self
.connector_payment_id
.as_ref()
.map(|txn_id| txn_id.get_txn_id(self.connector_payment_data.as_ref()))
.transpose()
{
Ok(txn_id) => txn_id,
// In case hashed data is missing from DB, use the hashed ID as connector payment ID
Err(_) => self
.connector_payment_id
.as_ref()
.map(|txn_id| txn_id.get_id()),
}
}
| {
"crate": "diesel_models",
"file": null,
"file_size": null,
"is_async": false,
"is_pub": false,
"num_enums": null,
"num_structs": null,
"num_tables": null,
"score": 42,
"total_crates": null
} |
fn_clm_diesel_models_new_7752205783267115411 | clm | function | // Repository: hyperswitch
// Crate: diesel_models
// Purpose: Database schema types directly mapping to PostgreSQL tables
// Module: crates/diesel_models/src/organization
// Inherent implementation for OrganizationNew
pub fn new(
id: id_type::OrganizationId,
organization_type: common_enums::OrganizationType,
organization_name: Option<String>,
) -> Self {
Self {
id,
organization_name,
organization_details: None,
metadata: None,
created_at: common_utils::date_time::now(),
modified_at: common_utils::date_time::now(),
version: common_types::consts::API_VERSION,
organization_type,
platform_merchant_id: None,
}
}
| {
"crate": "diesel_models",
"file": null,
"file_size": null,
"is_async": false,
"is_pub": true,
"num_enums": null,
"num_structs": null,
"num_tables": null,
"score": 14467,
"total_crates": null
} |
fn_clm_diesel_models_from_7752205783267115411 | clm | function | // Repository: hyperswitch
// Crate: diesel_models
// Purpose: Database schema types directly mapping to PostgreSQL tables
// Module: crates/diesel_models/src/organization
// Implementation of OrganizationUpdateInternal for From<OrganizationUpdate>
fn from(value: OrganizationUpdate) -> Self {
match value {
OrganizationUpdate::Update {
organization_name,
organization_details,
metadata,
platform_merchant_id,
} => Self {
organization_name,
organization_details,
metadata,
modified_at: common_utils::date_time::now(),
platform_merchant_id,
},
}
}
| {
"crate": "diesel_models",
"file": null,
"file_size": null,
"is_async": false,
"is_pub": false,
"num_enums": null,
"num_structs": null,
"num_tables": null,
"score": 2602,
"total_crates": null
} |
fn_clm_diesel_models_get_organization_id_7752205783267115411 | clm | function | // Repository: hyperswitch
// Crate: diesel_models
// Purpose: Database schema types directly mapping to PostgreSQL tables
// Module: crates/diesel_models/src/organization
// Implementation of OrganizationNew for OrganizationBridge
fn get_organization_id(&self) -> id_type::OrganizationId {
self.id.clone()
}
| {
"crate": "diesel_models",
"file": null,
"file_size": null,
"is_async": false,
"is_pub": false,
"num_enums": null,
"num_structs": null,
"num_tables": null,
"score": 52,
"total_crates": null
} |
fn_clm_diesel_models_get_organization_name_7752205783267115411 | clm | function | // Repository: hyperswitch
// Crate: diesel_models
// Purpose: Database schema types directly mapping to PostgreSQL tables
// Module: crates/diesel_models/src/organization
// Implementation of OrganizationNew for OrganizationBridge
fn get_organization_name(&self) -> Option<String> {
self.organization_name.clone()
}
| {
"crate": "diesel_models",
"file": null,
"file_size": null,
"is_async": false,
"is_pub": false,
"num_enums": null,
"num_structs": null,
"num_tables": null,
"score": 25,
"total_crates": null
} |
fn_clm_diesel_models_get_organization_type_7752205783267115411 | clm | function | // Repository: hyperswitch
// Crate: diesel_models
// Purpose: Database schema types directly mapping to PostgreSQL tables
// Module: crates/diesel_models/src/organization
// Inherent implementation for Organization
pub fn get_organization_type(&self) -> common_enums::OrganizationType {
self.organization_type.unwrap_or_default()
}
| {
"crate": "diesel_models",
"file": null,
"file_size": null,
"is_async": false,
"is_pub": true,
"num_enums": null,
"num_structs": null,
"num_tables": null,
"score": 20,
"total_crates": null
} |
fn_clm_diesel_models_from_-2466533097134574042 | clm | function | // Repository: hyperswitch
// Crate: diesel_models
// Purpose: Database schema types directly mapping to PostgreSQL tables
// Module: crates/diesel_models/src/merchant_account
// Implementation of MerchantAccount for From<MerchantAccountSetter>
fn from(item: MerchantAccountSetter) -> Self {
Self {
id: item.id,
merchant_name: item.merchant_name,
merchant_details: item.merchant_details,
publishable_key: item.publishable_key,
storage_scheme: item.storage_scheme,
metadata: item.metadata,
created_at: item.created_at,
modified_at: item.modified_at,
organization_id: item.organization_id,
recon_status: item.recon_status,
version: item.version,
is_platform_account: item.is_platform_account,
product_type: item.product_type,
merchant_account_type: Some(item.merchant_account_type),
}
}
| {
"crate": "diesel_models",
"file": null,
"file_size": null,
"is_async": false,
"is_pub": false,
"num_enums": null,
"num_structs": null,
"num_tables": null,
"score": 2600,
"total_crates": null
} |
fn_clm_diesel_models_get_id_-2466533097134574042 | clm | function | // Repository: hyperswitch
// Crate: diesel_models
// Purpose: Database schema types directly mapping to PostgreSQL tables
// Module: crates/diesel_models/src/merchant_account
// Inherent implementation for MerchantAccount
pub fn get_id(&self) -> &common_utils::id_type::MerchantId {
&self.id
}
| {
"crate": "diesel_models",
"file": null,
"file_size": null,
"is_async": false,
"is_pub": true,
"num_enums": null,
"num_structs": null,
"num_tables": null,
"score": 2472,
"total_crates": null
} |
fn_clm_diesel_models_apply_changeset_-2466533097134574042 | clm | function | // Repository: hyperswitch
// Crate: diesel_models
// Purpose: Database schema types directly mapping to PostgreSQL tables
// Module: crates/diesel_models/src/merchant_account
// Inherent implementation for MerchantAccountUpdateInternal
pub fn apply_changeset(self, source: MerchantAccount) -> MerchantAccount {
let Self {
merchant_name,
merchant_details,
return_url,
webhook_details,
sub_merchants_enabled,
parent_merchant_id,
enable_payment_response_hash,
payment_response_hash_key,
redirect_to_merchant_with_http_post,
publishable_key,
storage_scheme,
locker_id,
metadata,
routing_algorithm,
primary_business_details,
modified_at,
intent_fulfillment_time,
frm_routing_algorithm,
payout_routing_algorithm,
organization_id,
is_recon_enabled,
default_profile,
recon_status,
payment_link_config,
pm_collect_link_config,
is_platform_account,
product_type,
} = self;
MerchantAccount {
merchant_id: source.merchant_id,
return_url: return_url.or(source.return_url),
enable_payment_response_hash: enable_payment_response_hash
.unwrap_or(source.enable_payment_response_hash),
payment_response_hash_key: payment_response_hash_key
.or(source.payment_response_hash_key),
redirect_to_merchant_with_http_post: redirect_to_merchant_with_http_post
.unwrap_or(source.redirect_to_merchant_with_http_post),
merchant_name: merchant_name.or(source.merchant_name),
merchant_details: merchant_details.or(source.merchant_details),
webhook_details: webhook_details.or(source.webhook_details),
sub_merchants_enabled: sub_merchants_enabled.or(source.sub_merchants_enabled),
parent_merchant_id: parent_merchant_id.or(source.parent_merchant_id),
publishable_key: publishable_key.or(source.publishable_key),
storage_scheme: storage_scheme.unwrap_or(source.storage_scheme),
locker_id: locker_id.or(source.locker_id),
metadata: metadata.or(source.metadata),
routing_algorithm: routing_algorithm.or(source.routing_algorithm),
primary_business_details: primary_business_details
.unwrap_or(source.primary_business_details),
intent_fulfillment_time: intent_fulfillment_time.or(source.intent_fulfillment_time),
created_at: source.created_at,
modified_at,
frm_routing_algorithm: frm_routing_algorithm.or(source.frm_routing_algorithm),
payout_routing_algorithm: payout_routing_algorithm.or(source.payout_routing_algorithm),
organization_id: organization_id.unwrap_or(source.organization_id),
is_recon_enabled: is_recon_enabled.unwrap_or(source.is_recon_enabled),
default_profile: default_profile.unwrap_or(source.default_profile),
recon_status: recon_status.unwrap_or(source.recon_status),
payment_link_config: payment_link_config.or(source.payment_link_config),
pm_collect_link_config: pm_collect_link_config.or(source.pm_collect_link_config),
version: source.version,
is_platform_account: is_platform_account.unwrap_or(source.is_platform_account),
id: source.id,
product_type: product_type.or(source.product_type),
merchant_account_type: source.merchant_account_type,
}
}
| {
"crate": "diesel_models",
"file": null,
"file_size": null,
"is_async": false,
"is_pub": true,
"num_enums": null,
"num_structs": null,
"num_tables": null,
"score": 106,
"total_crates": null
} |
fn_clm_diesel_models_default_-571444643424840521 | clm | function | // Repository: hyperswitch
// Crate: diesel_models
// Purpose: Database schema types directly mapping to PostgreSQL tables
// Module: crates/diesel_models/src/payouts
// Implementation of PayoutsUpdateInternal for Default
fn default() -> Self {
Self {
amount: None,
destination_currency: None,
source_currency: None,
description: None,
recurring: None,
auto_fulfill: None,
return_url: None,
entity_type: None,
metadata: None,
payout_method_id: None,
profile_id: None,
status: None,
last_modified_at: common_utils::date_time::now(),
attempt_count: None,
confirm: None,
payout_type: None,
address_id: None,
customer_id: None,
}
}
| {
"crate": "diesel_models",
"file": null,
"file_size": null,
"is_async": false,
"is_pub": false,
"num_enums": null,
"num_structs": null,
"num_tables": null,
"score": 7705,
"total_crates": null
} |
fn_clm_diesel_models_from_-571444643424840521 | clm | function | // Repository: hyperswitch
// Crate: diesel_models
// Purpose: Database schema types directly mapping to PostgreSQL tables
// Module: crates/diesel_models/src/payouts
// Implementation of PayoutsUpdateInternal for From<PayoutsUpdate>
fn from(payout_update: PayoutsUpdate) -> Self {
match payout_update {
PayoutsUpdate::Update {
amount,
destination_currency,
source_currency,
description,
recurring,
auto_fulfill,
return_url,
entity_type,
metadata,
profile_id,
status,
confirm,
payout_type,
address_id,
customer_id,
} => Self {
amount: Some(amount),
destination_currency: Some(destination_currency),
source_currency: Some(source_currency),
description,
recurring: Some(recurring),
auto_fulfill: Some(auto_fulfill),
return_url,
entity_type: Some(entity_type),
metadata,
profile_id,
status,
confirm,
payout_type,
address_id,
customer_id,
..Default::default()
},
PayoutsUpdate::PayoutMethodIdUpdate { payout_method_id } => Self {
payout_method_id: Some(payout_method_id),
..Default::default()
},
PayoutsUpdate::RecurringUpdate { recurring } => Self {
recurring: Some(recurring),
..Default::default()
},
PayoutsUpdate::AttemptCountUpdate { attempt_count } => Self {
attempt_count: Some(attempt_count),
..Default::default()
},
PayoutsUpdate::StatusUpdate { status } => Self {
status: Some(status),
..Default::default()
},
}
}
| {
"crate": "diesel_models",
"file": null,
"file_size": null,
"is_async": false,
"is_pub": false,
"num_enums": null,
"num_structs": null,
"num_tables": null,
"score": 2610,
"total_crates": null
} |
fn_clm_diesel_models_apply_changeset_-571444643424840521 | clm | function | // Repository: hyperswitch
// Crate: diesel_models
// Purpose: Database schema types directly mapping to PostgreSQL tables
// Module: crates/diesel_models/src/payouts
// Inherent implementation for PayoutsUpdate
pub fn apply_changeset(self, source: Payouts) -> Payouts {
let PayoutsUpdateInternal {
amount,
destination_currency,
source_currency,
description,
recurring,
auto_fulfill,
return_url,
entity_type,
metadata,
payout_method_id,
profile_id,
status,
last_modified_at,
attempt_count,
confirm,
payout_type,
address_id,
customer_id,
} = self.into();
Payouts {
amount: amount.unwrap_or(source.amount),
destination_currency: destination_currency.unwrap_or(source.destination_currency),
source_currency: source_currency.unwrap_or(source.source_currency),
description: description.or(source.description),
recurring: recurring.unwrap_or(source.recurring),
auto_fulfill: auto_fulfill.unwrap_or(source.auto_fulfill),
return_url: return_url.or(source.return_url),
entity_type: entity_type.unwrap_or(source.entity_type),
metadata: metadata.or(source.metadata),
payout_method_id: payout_method_id.or(source.payout_method_id),
profile_id: profile_id.unwrap_or(source.profile_id),
status: status.unwrap_or(source.status),
last_modified_at,
attempt_count: attempt_count.unwrap_or(source.attempt_count),
confirm: confirm.or(source.confirm),
payout_type: payout_type.or(source.payout_type),
address_id: address_id.or(source.address_id),
customer_id: customer_id.or(source.customer_id),
..source
}
}
| {
"crate": "diesel_models",
"file": null,
"file_size": null,
"is_async": false,
"is_pub": true,
"num_enums": null,
"num_structs": null,
"num_tables": null,
"score": 90,
"total_crates": null
} |
fn_clm_diesel_models_from_-6368932586777708332 | clm | function | // Repository: hyperswitch
// Crate: diesel_models
// Purpose: Database schema types directly mapping to PostgreSQL tables
// Module: crates/diesel_models/src/fraud_check
// Implementation of FraudCheckUpdateInternal for From<FraudCheckUpdate>
fn from(fraud_check_update: FraudCheckUpdate) -> Self {
match fraud_check_update {
FraudCheckUpdate::ResponseUpdate {
frm_status,
frm_transaction_id,
frm_reason,
frm_score,
metadata,
modified_at: _,
last_step,
payment_capture_method,
} => Self {
frm_status: Some(frm_status),
frm_transaction_id,
frm_reason,
frm_score,
metadata,
last_step,
payment_capture_method,
..Default::default()
},
FraudCheckUpdate::ErrorUpdate {
status,
error_message,
} => Self {
frm_status: Some(status),
frm_error: error_message,
..Default::default()
},
}
}
| {
"crate": "diesel_models",
"file": null,
"file_size": null,
"is_async": false,
"is_pub": false,
"num_enums": null,
"num_structs": null,
"num_tables": null,
"score": 2604,
"total_crates": null
} |
fn_clm_diesel_models_from_-4211779944055406365 | clm | function | // Repository: hyperswitch
// Crate: diesel_models
// Purpose: Database schema types directly mapping to PostgreSQL tables
// Module: crates/diesel_models/src/payment_method
// Implementation of CommonMandateReference for From<PaymentsMandateReference>
fn from(payment_reference: PaymentsMandateReference) -> Self {
Self {
payments: Some(payment_reference),
payouts: None,
}
}
| {
"crate": "diesel_models",
"file": null,
"file_size": null,
"is_async": false,
"is_pub": false,
"num_enums": null,
"num_structs": null,
"num_tables": null,
"score": 2600,
"total_crates": null
} |
fn_clm_diesel_models_get_id_-4211779944055406365 | clm | function | // Repository: hyperswitch
// Crate: diesel_models
// Purpose: Database schema types directly mapping to PostgreSQL tables
// Module: crates/diesel_models/src/payment_method
// Inherent implementation for PaymentMethodNew
pub fn get_id(&self) -> &common_utils::id_type::GlobalPaymentMethodId {
&self.id
}
| {
"crate": "diesel_models",
"file": null,
"file_size": null,
"is_async": false,
"is_pub": true,
"num_enums": null,
"num_structs": null,
"num_tables": null,
"score": 2472,
"total_crates": null
} |
fn_clm_diesel_models_to_sql_-4211779944055406365 | clm | function | // Repository: hyperswitch
// Crate: diesel_models
// Purpose: Database schema types directly mapping to PostgreSQL tables
// Module: crates/diesel_models/src/payment_method
// Implementation of CommonMandateReference for diesel::serialize::ToSql<diesel::sql_types::Jsonb, diesel::pg::Pg>
fn to_sql<'b>(
&'b self,
out: &mut diesel::serialize::Output<'b, '_, diesel::pg::Pg>,
) -> diesel::serialize::Result {
let payments = self.get_mandate_details_value()?;
<serde_json::Value as diesel::serialize::ToSql<
diesel::sql_types::Jsonb,
diesel::pg::Pg,
>>::to_sql(&payments, &mut out.reborrow())
}
| {
"crate": "diesel_models",
"file": null,
"file_size": null,
"is_async": false,
"is_pub": false,
"num_enums": null,
"num_structs": null,
"num_tables": null,
"score": 104,
"total_crates": null
} |
fn_clm_diesel_models_apply_changeset_-4211779944055406365 | clm | function | // Repository: hyperswitch
// Crate: diesel_models
// Purpose: Database schema types directly mapping to PostgreSQL tables
// Module: crates/diesel_models/src/payment_method
// Inherent implementation for PaymentMethodUpdateInternal
pub fn apply_changeset(self, source: PaymentMethod) -> PaymentMethod {
let Self {
metadata,
payment_method_data,
last_used_at,
network_transaction_id,
status,
locker_id,
network_token_requestor_reference_id,
payment_method,
connector_mandate_details,
updated_by,
payment_method_type,
payment_method_issuer,
last_modified,
network_token_locker_id,
network_token_payment_method_data,
scheme,
} = self;
PaymentMethod {
customer_id: source.customer_id,
merchant_id: source.merchant_id,
payment_method_id: source.payment_method_id,
accepted_currency: source.accepted_currency,
scheme: scheme.or(source.scheme),
token: source.token,
cardholder_name: source.cardholder_name,
issuer_name: source.issuer_name,
issuer_country: source.issuer_country,
payer_country: source.payer_country,
is_stored: source.is_stored,
swift_code: source.swift_code,
direct_debit_token: source.direct_debit_token,
created_at: source.created_at,
last_modified,
payment_method: payment_method.or(source.payment_method),
payment_method_type: payment_method_type.or(source.payment_method_type),
payment_method_issuer: payment_method_issuer.or(source.payment_method_issuer),
payment_method_issuer_code: source.payment_method_issuer_code,
metadata: metadata.map_or(source.metadata, |v| Some(v.into())),
payment_method_data: payment_method_data.or(source.payment_method_data),
locker_id: locker_id.or(source.locker_id),
last_used_at: last_used_at.unwrap_or(source.last_used_at),
connector_mandate_details: connector_mandate_details
.or(source.connector_mandate_details),
customer_acceptance: source.customer_acceptance,
status: status.unwrap_or(source.status),
network_transaction_id: network_transaction_id.or(source.network_transaction_id),
client_secret: source.client_secret,
payment_method_billing_address: source.payment_method_billing_address,
updated_by: updated_by.or(source.updated_by),
version: source.version,
network_token_requestor_reference_id: network_token_requestor_reference_id
.or(source.network_token_requestor_reference_id),
network_token_locker_id: network_token_locker_id.or(source.network_token_locker_id),
network_token_payment_method_data: network_token_payment_method_data
.or(source.network_token_payment_method_data),
external_vault_source: source.external_vault_source,
vault_type: source.vault_type,
}
}
| {
"crate": "diesel_models",
"file": null,
"file_size": null,
"is_async": false,
"is_pub": true,
"num_enums": null,
"num_structs": null,
"num_tables": null,
"score": 86,
"total_crates": null
} |
fn_clm_diesel_models_from_sql_-4211779944055406365 | clm | function | // Repository: hyperswitch
// Crate: diesel_models
// Purpose: Database schema types directly mapping to PostgreSQL tables
// Module: crates/diesel_models/src/payment_method
// Implementation of CommonMandateReference for diesel::deserialize::FromSql<diesel::sql_types::Jsonb, DB>
fn from_sql(bytes: DB::RawValue<'_>) -> diesel::deserialize::Result<Self> {
let value = <serde_json::Value as diesel::deserialize::FromSql<
diesel::sql_types::Jsonb,
DB,
>>::from_sql(bytes)?;
let payments_data = value
.clone()
.as_object_mut()
.map(|obj| {
obj.remove("payouts");
serde_json::from_value::<PaymentsTokenReference>(serde_json::Value::Object(
obj.clone(),
))
.inspect_err(|err| {
router_env::logger::error!("Failed to parse payments data: {}", err);
})
.change_context(ParsingError::StructParseFailure(
"Failed to parse payments data",
))
})
.transpose()?;
let payouts_data = serde_json::from_value::<Option<Self>>(value)
.inspect_err(|err| {
router_env::logger::error!("Failed to parse payouts data: {}", err);
})
.change_context(ParsingError::StructParseFailure(
"Failed to parse payouts data",
))
.map(|optional_common_mandate_details| {
optional_common_mandate_details
.and_then(|common_mandate_details| common_mandate_details.payouts)
})?;
Ok(Self {
payments: payments_data,
payouts: payouts_data,
})
}
| {
"crate": "diesel_models",
"file": null,
"file_size": null,
"is_async": false,
"is_pub": false,
"num_enums": null,
"num_structs": null,
"num_tables": null,
"score": 82,
"total_crates": null
} |
fn_clm_diesel_models_get_id_-8437217932253315203 | clm | function | // Repository: hyperswitch
// Crate: diesel_models
// Purpose: Database schema types directly mapping to PostgreSQL tables
// Module: crates/diesel_models/src/merchant_connector_account
// Inherent implementation for MerchantConnectorAccount
pub fn get_id(&self) -> id_type::MerchantConnectorAccountId {
self.id.clone()
}
| {
"crate": "diesel_models",
"file": null,
"file_size": null,
"is_async": false,
"is_pub": true,
"num_enums": null,
"num_structs": null,
"num_tables": null,
"score": 2474,
"total_crates": null
} |
fn_clm_diesel_models_create_merchant_connector_account_-8437217932253315203 | clm | function | // Repository: hyperswitch
// Crate: diesel_models
// Purpose: Database schema types directly mapping to PostgreSQL tables
// Module: crates/diesel_models/src/merchant_connector_account
// Inherent implementation for MerchantConnectorAccountUpdateInternal
pub fn create_merchant_connector_account(
self,
source: MerchantConnectorAccount,
) -> MerchantConnectorAccount {
MerchantConnectorAccount {
connector_type: self.connector_type.unwrap_or(source.connector_type),
connector_account_details: self
.connector_account_details
.unwrap_or(source.connector_account_details),
disabled: self.disabled,
payment_methods_enabled: self.payment_methods_enabled,
frm_config: self.frm_config,
modified_at: self.modified_at.unwrap_or(source.modified_at),
pm_auth_config: self.pm_auth_config,
status: self.status.unwrap_or(source.status),
feature_metadata: self.feature_metadata,
..source
}
}
| {
"crate": "diesel_models",
"file": null,
"file_size": null,
"is_async": false,
"is_pub": true,
"num_enums": null,
"num_structs": null,
"num_tables": null,
"score": 29,
"total_crates": null
} |
fn_clm_diesel_models_from_5531451374527782126 | clm | function | // Repository: hyperswitch
// Crate: diesel_models
// Purpose: Database schema types directly mapping to PostgreSQL tables
// Module: crates/diesel_models/src/configs
// Implementation of Config for From<ConfigNew>
fn from(config_new: ConfigNew) -> Self {
Self {
key: config_new.key,
config: config_new.config,
}
}
| {
"crate": "diesel_models",
"file": null,
"file_size": null,
"is_async": false,
"is_pub": false,
"num_enums": null,
"num_structs": null,
"num_tables": null,
"score": 2600,
"total_crates": null
} |
fn_clm_diesel_models_create_config_5531451374527782126 | clm | function | // Repository: hyperswitch
// Crate: diesel_models
// Purpose: Database schema types directly mapping to PostgreSQL tables
// Module: crates/diesel_models/src/configs
// Inherent implementation for ConfigUpdateInternal
pub fn create_config(self, source: Config) -> Config {
Config { ..source }
}
| {
"crate": "diesel_models",
"file": null,
"file_size": null,
"is_async": false,
"is_pub": true,
"num_enums": null,
"num_structs": null,
"num_tables": null,
"score": 21,
"total_crates": null
} |
fn_clm_diesel_models_from_-1446881798389202686 | clm | function | // Repository: hyperswitch
// Crate: diesel_models
// Purpose: Database schema types directly mapping to PostgreSQL tables
// Module: crates/diesel_models/src/lib
// Implementation of Option<Vec<T>> for From<OptionalDieselArray<T>>
fn from(option_array: OptionalDieselArray<T>) -> Self {
option_array
.0
.map(|array| array.into_iter().flatten().collect())
}
| {
"crate": "diesel_models",
"file": null,
"file_size": null,
"is_async": false,
"is_pub": false,
"num_enums": null,
"num_structs": null,
"num_tables": null,
"score": 2608,
"total_crates": null
} |
fn_clm_diesel_models_into_inner_-1446881798389202686 | clm | function | // Repository: hyperswitch
// Crate: diesel_models
// Purpose: Database schema types directly mapping to PostgreSQL tables
// Module: crates/diesel_models/src/lib
// Inherent implementation for RequiredFromNullableWithDefault<T>
/// Extracts the inner value from the wrapper
pub fn into_inner(self) -> T {
self.0
}
| {
"crate": "diesel_models",
"file": null,
"file_size": null,
"is_async": false,
"is_pub": true,
"num_enums": null,
"num_structs": null,
"num_tables": null,
"score": 2061,
"total_crates": null
} |
fn_clm_diesel_models_build_-1446881798389202686 | clm | function | // Repository: hyperswitch
// Crate: diesel_models
// Purpose: Database schema types directly mapping to PostgreSQL tables
// Module: crates/diesel_models/src/lib
// Implementation of RequiredFromNullableWithDefault<T> for Queryable<Nullable<ST>, DB>
fn build(row: Self::Row) -> diesel::deserialize::Result<Self> {
match row {
Some(inner_row) => {
let value = T::build(inner_row)?;
Ok(Self(value))
}
None => Ok(Self(T::default())),
}
}
| {
"crate": "diesel_models",
"file": null,
"file_size": null,
"is_async": false,
"is_pub": false,
"num_enums": null,
"num_structs": null,
"num_tables": null,
"score": 580,
"total_crates": null
} |
fn_clm_diesel_models_metadata_is_advanced_rule_for_payments_6062007529629841469 | clm | function | // Repository: hyperswitch
// Crate: diesel_models
// Purpose: Database schema types directly mapping to PostgreSQL tables
// Module: crates/diesel_models/src/routing_algorithm
// Inherent implementation for RoutingProfileMetadata
pub fn metadata_is_advanced_rule_for_payments(&self) -> bool {
matches!(self.kind, enums::RoutingAlgorithmKind::Advanced)
&& matches!(self.algorithm_for, enums::TransactionType::Payment)
}
| {
"crate": "diesel_models",
"file": null,
"file_size": null,
"is_async": false,
"is_pub": true,
"num_enums": null,
"num_structs": null,
"num_tables": null,
"score": 18,
"total_crates": null
} |
fn_clm_diesel_models_new_8857827427584694927 | clm | function | // Repository: hyperswitch
// Crate: diesel_models
// Purpose: Database schema types directly mapping to PostgreSQL tables
// Module: crates/diesel_models/src/subscription
// Inherent implementation for SubscriptionUpdate
pub fn new(
connector_subscription_id: Option<String>,
payment_method_id: Option<Secret<String>>,
status: Option<String>,
plan_id: Option<String>,
item_price_id: Option<String>,
) -> Self {
Self {
connector_subscription_id,
payment_method_id: payment_method_id.map(|pmid| pmid.peek().clone()),
status,
modified_at: common_utils::date_time::now(),
plan_id,
item_price_id,
}
}
| {
"crate": "diesel_models",
"file": null,
"file_size": null,
"is_async": false,
"is_pub": true,
"num_enums": null,
"num_structs": null,
"num_tables": null,
"score": 14471,
"total_crates": null
} |
fn_clm_diesel_models_generate_and_set_client_secret_8857827427584694927 | clm | function | // Repository: hyperswitch
// Crate: diesel_models
// Purpose: Database schema types directly mapping to PostgreSQL tables
// Module: crates/diesel_models/src/subscription
// Inherent implementation for SubscriptionNew
pub fn generate_and_set_client_secret(&mut self) -> Secret<String> {
let client_secret =
generate_id_with_default_len(&format!("{}_secret", self.id.get_string_repr()));
self.client_secret = Some(client_secret.clone());
Secret::new(client_secret)
}
| {
"crate": "diesel_models",
"file": null,
"file_size": null,
"is_async": false,
"is_pub": true,
"num_enums": null,
"num_structs": null,
"num_tables": null,
"score": 27,
"total_crates": null
} |
fn_clm_diesel_models_create_address_-4483737527286093456 | clm | function | // Repository: hyperswitch
// Crate: diesel_models
// Purpose: Database schema types directly mapping to PostgreSQL tables
// Module: crates/diesel_models/src/address
// Inherent implementation for AddressUpdateInternal
pub fn create_address(self, source: Address) -> Address {
Address {
city: self.city,
country: self.country,
line1: self.line1,
line2: self.line2,
line3: self.line3,
state: self.state,
zip: self.zip,
first_name: self.first_name,
last_name: self.last_name,
phone_number: self.phone_number,
country_code: self.country_code,
modified_at: self.modified_at,
updated_by: self.updated_by,
origin_zip: self.origin_zip,
..source
}
}
| {
"crate": "diesel_models",
"file": null,
"file_size": null,
"is_async": false,
"is_pub": true,
"num_enums": null,
"num_structs": null,
"num_tables": null,
"score": 30,
"total_crates": null
} |
fn_clm_diesel_models_from_1624844874700363150 | clm | function | // Repository: hyperswitch
// Crate: diesel_models
// Purpose: Database schema types directly mapping to PostgreSQL tables
// Module: crates/diesel_models/src/user
// Implementation of UserUpdateInternal for From<UserUpdate>
fn from(user_update: UserUpdate) -> Self {
let last_modified_at = common_utils::date_time::now();
match user_update {
UserUpdate::VerifyUser => Self {
name: None,
password: None,
is_verified: Some(true),
last_modified_at,
totp_status: None,
totp_secret: None,
totp_recovery_codes: None,
last_password_modified_at: None,
lineage_context: None,
},
UserUpdate::AccountUpdate { name, is_verified } => Self {
name,
password: None,
is_verified,
last_modified_at,
totp_status: None,
totp_secret: None,
totp_recovery_codes: None,
last_password_modified_at: None,
lineage_context: None,
},
UserUpdate::TotpUpdate {
totp_status,
totp_secret,
totp_recovery_codes,
} => Self {
name: None,
password: None,
is_verified: None,
last_modified_at,
totp_status,
totp_secret,
totp_recovery_codes,
last_password_modified_at: None,
lineage_context: None,
},
UserUpdate::PasswordUpdate { password } => Self {
name: None,
password: Some(password),
is_verified: None,
last_modified_at,
last_password_modified_at: Some(last_modified_at),
totp_status: None,
totp_secret: None,
totp_recovery_codes: None,
lineage_context: None,
},
UserUpdate::LineageContextUpdate { lineage_context } => Self {
name: None,
password: None,
is_verified: None,
last_modified_at,
last_password_modified_at: None,
totp_status: None,
totp_secret: None,
totp_recovery_codes: None,
lineage_context: Some(lineage_context),
},
}
}
| {
"crate": "diesel_models",
"file": null,
"file_size": null,
"is_async": false,
"is_pub": false,
"num_enums": null,
"num_structs": null,
"num_tables": null,
"score": 2602,
"total_crates": null
} |
fn_clm_diesel_models_from_-6542374894342068961 | clm | function | // Repository: hyperswitch
// Crate: diesel_models
// Purpose: Database schema types directly mapping to PostgreSQL tables
// Module: crates/diesel_models/src/user_role
// Implementation of UserRoleUpdateInternal for From<UserRoleUpdate>
fn from(value: UserRoleUpdate) -> Self {
let last_modified = common_utils::date_time::now();
match value {
UserRoleUpdate::UpdateRole {
role_id,
modified_by,
} => Self {
role_id: Some(role_id),
last_modified_by: Some(modified_by),
status: None,
last_modified,
},
UserRoleUpdate::UpdateStatus {
status,
modified_by,
} => Self {
status: Some(status),
last_modified,
last_modified_by: Some(modified_by),
role_id: None,
},
}
}
| {
"crate": "diesel_models",
"file": null,
"file_size": null,
"is_async": false,
"is_pub": false,
"num_enums": null,
"num_structs": null,
"num_tables": null,
"score": 2602,
"total_crates": null
} |
fn_clm_diesel_models_eq_-6542374894342068961 | clm | function | // Repository: hyperswitch
// Crate: diesel_models
// Purpose: Database schema types directly mapping to PostgreSQL tables
// Module: crates/diesel_models/src/user_role
// Implementation of UserRole for PartialEq
fn eq(&self, other: &Self) -> bool {
match (
self.get_entity_id_and_type(),
other.get_entity_id_and_type(),
) {
(
Some((self_entity_id, self_entity_type)),
Some((other_entity_id, other_entity_type)),
) => {
self.user_id == other.user_id
&& self_entity_id == other_entity_id
&& self_entity_type == other_entity_type
}
_ => self.user_id == other.user_id,
}
}
| {
"crate": "diesel_models",
"file": null,
"file_size": null,
"is_async": false,
"is_pub": false,
"num_enums": null,
"num_structs": null,
"num_tables": null,
"score": 1662,
"total_crates": null
} |
fn_clm_diesel_models_hash_-6542374894342068961 | clm | function | // Repository: hyperswitch
// Crate: diesel_models
// Purpose: Database schema types directly mapping to PostgreSQL tables
// Module: crates/diesel_models/src/user_role
// Implementation of UserRole for Hash
fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
self.user_id.hash(state);
if let Some((entity_id, entity_type)) = self.get_entity_id_and_type() {
entity_id.hash(state);
entity_type.hash(state);
}
}
| {
"crate": "diesel_models",
"file": null,
"file_size": null,
"is_async": false,
"is_pub": false,
"num_enums": null,
"num_structs": null,
"num_tables": null,
"score": 349,
"total_crates": null
} |
fn_clm_diesel_models_get_entity_id_and_type_-6542374894342068961 | clm | function | // Repository: hyperswitch
// Crate: diesel_models
// Purpose: Database schema types directly mapping to PostgreSQL tables
// Module: crates/diesel_models/src/user_role
// Inherent implementation for UserRole
pub fn get_entity_id_and_type(&self) -> Option<(String, EntityType)> {
match (self.version, self.entity_type, self.role_id.as_str()) {
(enums::UserRoleVersion::V1, None, consts::ROLE_ID_ORGANIZATION_ADMIN) => {
let org_id = self.org_id.clone()?.get_string_repr().to_string();
Some((org_id, EntityType::Organization))
}
(enums::UserRoleVersion::V1, None, _) => {
let merchant_id = self.merchant_id.clone()?.get_string_repr().to_string();
Some((merchant_id, EntityType::Merchant))
}
(enums::UserRoleVersion::V1, Some(_), _) => {
self.entity_id.clone().zip(self.entity_type)
}
(enums::UserRoleVersion::V2, _, _) => self.entity_id.clone().zip(self.entity_type),
}
}
| {
"crate": "diesel_models",
"file": null,
"file_size": null,
"is_async": false,
"is_pub": true,
"num_enums": null,
"num_structs": null,
"num_tables": null,
"score": 94,
"total_crates": null
} |
fn_clm_diesel_models_from_-3123425703352763371 | clm | function | // Repository: hyperswitch
// Crate: diesel_models
// Purpose: Database schema types directly mapping to PostgreSQL tables
// Module: crates/diesel_models/src/refund
// Implementation of RefundUpdateInternal for From<RefundUpdate>
fn from(refund_update: RefundUpdate) -> Self {
match refund_update {
RefundUpdate::Update {
connector_refund_id,
refund_status,
sent_to_gateway,
refund_error_message,
refund_arn,
updated_by,
processor_refund_data,
} => Self {
connector_refund_id: Some(connector_refund_id),
refund_status: Some(refund_status),
sent_to_gateway: Some(sent_to_gateway),
refund_error_message,
refund_arn: Some(refund_arn),
updated_by,
processor_refund_data,
metadata: None,
refund_reason: None,
refund_error_code: None,
modified_at: common_utils::date_time::now(),
unified_code: None,
unified_message: None,
},
RefundUpdate::MetadataAndReasonUpdate {
metadata,
reason,
updated_by,
} => Self {
metadata,
refund_reason: reason,
updated_by,
connector_refund_id: None,
refund_status: None,
sent_to_gateway: None,
refund_error_message: None,
refund_arn: None,
refund_error_code: None,
modified_at: common_utils::date_time::now(),
processor_refund_data: None,
unified_code: None,
unified_message: None,
},
RefundUpdate::StatusUpdate {
connector_refund_id,
sent_to_gateway,
refund_status,
updated_by,
processor_refund_data,
} => Self {
connector_refund_id,
sent_to_gateway: Some(sent_to_gateway),
refund_status: Some(refund_status),
updated_by,
processor_refund_data,
refund_error_message: None,
refund_arn: None,
metadata: None,
refund_reason: None,
refund_error_code: None,
modified_at: common_utils::date_time::now(),
unified_code: None,
unified_message: None,
},
RefundUpdate::ErrorUpdate {
refund_status,
refund_error_message,
refund_error_code,
unified_code,
unified_message,
updated_by,
connector_refund_id,
processor_refund_data,
} => Self {
refund_status,
refund_error_message,
refund_error_code,
updated_by,
connector_refund_id,
processor_refund_data,
sent_to_gateway: None,
refund_arn: None,
metadata: None,
refund_reason: None,
modified_at: common_utils::date_time::now(),
unified_code,
unified_message,
},
RefundUpdate::ManualUpdate {
refund_status,
refund_error_message,
refund_error_code,
updated_by,
} => Self {
refund_status,
refund_error_message,
refund_error_code,
updated_by,
connector_refund_id: None,
sent_to_gateway: None,
refund_arn: None,
metadata: None,
refund_reason: None,
modified_at: common_utils::date_time::now(),
processor_refund_data: None,
unified_code: None,
unified_message: None,
},
}
}
| {
"crate": "diesel_models",
"file": null,
"file_size": null,
"is_async": false,
"is_pub": false,
"num_enums": null,
"num_structs": null,
"num_tables": null,
"score": 2610,
"total_crates": null
} |
fn_clm_diesel_models_get_connector_transaction_id_-3123425703352763371 | clm | function | // Repository: hyperswitch
// Crate: diesel_models
// Purpose: Database schema types directly mapping to PostgreSQL tables
// Module: crates/diesel_models/src/refund
// Implementation of Refund for ConnectorTransactionIdTrait
fn get_connector_transaction_id(&self) -> &String {
match self
.connector_transaction_id
.get_txn_id(self.processor_transaction_data.as_ref())
{
Ok(txn_id) => txn_id,
// In case hashed data is missing from DB, use the hashed ID as connector transaction ID
Err(_) => self.connector_transaction_id.get_id(),
}
}
| {
"crate": "diesel_models",
"file": null,
"file_size": null,
"is_async": false,
"is_pub": false,
"num_enums": null,
"num_structs": null,
"num_tables": null,
"score": 1265,
"total_crates": null
} |
fn_clm_diesel_models_apply_changeset_-3123425703352763371 | clm | function | // Repository: hyperswitch
// Crate: diesel_models
// Purpose: Database schema types directly mapping to PostgreSQL tables
// Module: crates/diesel_models/src/refund
// Implementation of None for RefundUpdate
pub fn apply_changeset(self, source: Refund) -> Refund {
let RefundUpdateInternal {
connector_refund_id,
refund_status,
sent_to_gateway,
refund_error_message,
refund_arn,
metadata,
refund_reason,
refund_error_code,
updated_by,
modified_at: _,
processor_refund_data,
unified_code,
unified_message,
} = self.into();
Refund {
connector_refund_id: connector_refund_id.or(source.connector_refund_id),
refund_status: refund_status.unwrap_or(source.refund_status),
sent_to_gateway: sent_to_gateway.unwrap_or(source.sent_to_gateway),
refund_error_message: refund_error_message.or(source.refund_error_message),
refund_error_code: refund_error_code.or(source.refund_error_code),
refund_arn: refund_arn.or(source.refund_arn),
metadata: metadata.or(source.metadata),
refund_reason: refund_reason.or(source.refund_reason),
updated_by,
modified_at: common_utils::date_time::now(),
processor_refund_data: processor_refund_data.or(source.processor_refund_data),
unified_code: unified_code.or(source.unified_code),
unified_message: unified_message.or(source.unified_message),
..source
}
}
| {
"crate": "diesel_models",
"file": null,
"file_size": null,
"is_async": false,
"is_pub": true,
"num_enums": null,
"num_structs": null,
"num_tables": null,
"score": 80,
"total_crates": null
} |
fn_clm_diesel_models_create_refund_-3123425703352763371 | clm | function | // Repository: hyperswitch
// Crate: diesel_models
// Purpose: Database schema types directly mapping to PostgreSQL tables
// Module: crates/diesel_models/src/refund
// Inherent implementation for RefundUpdateInternal
pub fn create_refund(self, source: Refund) -> Refund {
Refund {
connector_refund_id: self.connector_refund_id,
refund_status: self.refund_status.unwrap_or_default(),
sent_to_gateway: self.sent_to_gateway.unwrap_or_default(),
refund_error_message: self.refund_error_message,
refund_arn: self.refund_arn,
metadata: self.metadata,
refund_reason: self.refund_reason,
refund_error_code: self.refund_error_code,
updated_by: self.updated_by,
modified_at: self.modified_at,
processor_refund_data: self.processor_refund_data,
unified_code: self.unified_code,
unified_message: self.unified_message,
..source
}
}
| {
"crate": "diesel_models",
"file": null,
"file_size": null,
"is_async": false,
"is_pub": true,
"num_enums": null,
"num_structs": null,
"num_tables": null,
"score": 43,
"total_crates": null
} |
fn_clm_diesel_models_build_error_update_for_integrity_check_failure_-3123425703352763371 | clm | function | // Repository: hyperswitch
// Crate: diesel_models
// Purpose: Database schema types directly mapping to PostgreSQL tables
// Module: crates/diesel_models/src/refund
// Implementation of None for RefundUpdate
pub fn build_error_update_for_integrity_check_failure(
integrity_check_failed_fields: String,
connector_refund_id: Option<ConnectorTransactionId>,
storage_scheme: &storage_enums::MerchantStorageScheme,
) -> Self {
Self::ErrorUpdate {
refund_status: Some(storage_enums::RefundStatus::ManualReview),
refund_error_message: Some(format!(
"Integrity Check Failed! as data mismatched for fields {integrity_check_failed_fields}"
)),
refund_error_code: Some("IE".to_string()),
updated_by: storage_scheme.to_string(),
connector_refund_id: connector_refund_id.clone(),
processor_refund_data: connector_refund_id.and_then(|x| x.extract_hashed_data()),
unified_code: None,
unified_message: None,
}
}
| {
"crate": "diesel_models",
"file": null,
"file_size": null,
"is_async": false,
"is_pub": true,
"num_enums": null,
"num_structs": null,
"num_tables": null,
"score": 34,
"total_crates": null
} |
fn_clm_diesel_models_new_-7204015516939245849 | clm | function | // Repository: hyperswitch
// Crate: diesel_models
// Purpose: Database schema types directly mapping to PostgreSQL tables
// Module: crates/diesel_models/src/process_tracker
// Inherent implementation for ProcessTrackerNew
pub fn new<T>(
process_tracker_id: impl Into<String>,
task: impl Into<String>,
runner: ProcessTrackerRunner,
tag: impl IntoIterator<Item = impl Into<String>>,
tracking_data: T,
retry_count: Option<i32>,
schedule_time: PrimitiveDateTime,
api_version: ApiVersion,
) -> StorageResult<Self>
where
T: Serialize + std::fmt::Debug,
{
let current_time = common_utils::date_time::now();
Ok(Self {
id: process_tracker_id.into(),
name: Some(task.into()),
tag: tag.into_iter().map(Into::into).collect(),
runner: Some(runner.to_string()),
retry_count: retry_count.unwrap_or(0),
schedule_time: Some(schedule_time),
rule: String::new(),
tracking_data: tracking_data
.encode_to_value()
.change_context(errors::DatabaseError::Others)
.attach_printable("Failed to serialize process tracker tracking data")?,
business_status: String::from(business_status::PENDING),
status: storage_enums::ProcessTrackerStatus::New,
event: vec![],
created_at: current_time,
updated_at: current_time,
version: api_version,
})
}
| {
"crate": "diesel_models",
"file": null,
"file_size": null,
"is_async": false,
"is_pub": true,
"num_enums": null,
"num_structs": null,
"num_tables": null,
"score": 14489,
"total_crates": null
} |
fn_clm_diesel_models_default_-7204015516939245849 | clm | function | // Repository: hyperswitch
// Crate: diesel_models
// Purpose: Database schema types directly mapping to PostgreSQL tables
// Module: crates/diesel_models/src/process_tracker
// Implementation of ProcessTrackerUpdateInternal for Default
fn default() -> Self {
Self {
name: Option::default(),
retry_count: Option::default(),
schedule_time: Option::default(),
tracking_data: Option::default(),
business_status: Option::default(),
status: Option::default(),
updated_at: Some(common_utils::date_time::now()),
}
}
| {
"crate": "diesel_models",
"file": null,
"file_size": null,
"is_async": false,
"is_pub": false,
"num_enums": null,
"num_structs": null,
"num_tables": null,
"score": 7717,
"total_crates": null
} |
fn_clm_diesel_models_from_-7204015516939245849 | clm | function | // Repository: hyperswitch
// Crate: diesel_models
// Purpose: Database schema types directly mapping to PostgreSQL tables
// Module: crates/diesel_models/src/process_tracker
// Implementation of ProcessTrackerUpdateInternal for From<ProcessTrackerUpdate>
fn from(process_tracker_update: ProcessTrackerUpdate) -> Self {
match process_tracker_update {
ProcessTrackerUpdate::Update {
name,
retry_count,
schedule_time,
tracking_data,
business_status,
status,
updated_at,
} => Self {
name,
retry_count,
schedule_time,
tracking_data,
business_status,
status,
updated_at,
},
ProcessTrackerUpdate::StatusUpdate {
status,
business_status,
} => Self {
status: Some(status),
business_status,
..Default::default()
},
ProcessTrackerUpdate::StatusRetryUpdate {
status,
retry_count,
schedule_time,
} => Self {
status: Some(status),
retry_count: Some(retry_count),
schedule_time: Some(schedule_time),
..Default::default()
},
}
}
| {
"crate": "diesel_models",
"file": null,
"file_size": null,
"is_async": false,
"is_pub": false,
"num_enums": null,
"num_structs": null,
"num_tables": null,
"score": 2604,
"total_crates": null
} |
fn_clm_diesel_models_is_valid_business_status_-7204015516939245849 | clm | function | // Repository: hyperswitch
// Crate: diesel_models
// Purpose: Database schema types directly mapping to PostgreSQL tables
// Module: crates/diesel_models/src/process_tracker
// Inherent implementation for ProcessTracker
pub fn is_valid_business_status(&self, valid_statuses: &[&str]) -> bool {
valid_statuses.iter().any(|&x| x == self.business_status)
}
| {
"crate": "diesel_models",
"file": null,
"file_size": null,
"is_async": false,
"is_pub": true,
"num_enums": null,
"num_structs": null,
"num_tables": null,
"score": 25,
"total_crates": null
} |
fn_clm_diesel_models_test_enum_to_string_-7204015516939245849 | clm | function | // Repository: hyperswitch
// Crate: diesel_models
// Purpose: Database schema types directly mapping to PostgreSQL tables
// Module: crates/diesel_models/src/process_tracker
fn test_enum_to_string() {
let string_format = "PAYMENTS_SYNC_WORKFLOW".to_string();
let enum_format: ProcessTrackerRunner =
string_format.parse_enum("ProcessTrackerRunner").unwrap();
assert_eq!(enum_format, ProcessTrackerRunner::PaymentsSyncWorkflow);
}
| {
"crate": "diesel_models",
"file": null,
"file_size": null,
"is_async": false,
"is_pub": false,
"num_enums": null,
"num_structs": null,
"num_tables": null,
"score": 4,
"total_crates": null
} |
fn_clm_diesel_models_default_-897459058201057485 | clm | function | // Repository: hyperswitch
// Crate: diesel_models
// Purpose: Database schema types directly mapping to PostgreSQL tables
// Module: crates/diesel_models/src/business_profile
// Implementation of CardTestingGuardConfig for Default
fn default() -> Self {
Self {
is_card_ip_blocking_enabled: common_utils::consts::DEFAULT_CARD_IP_BLOCKING_STATUS,
card_ip_blocking_threshold: common_utils::consts::DEFAULT_CARD_IP_BLOCKING_THRESHOLD,
is_guest_user_card_blocking_enabled:
common_utils::consts::DEFAULT_GUEST_USER_CARD_BLOCKING_STATUS,
guest_user_card_blocking_threshold:
common_utils::consts::DEFAULT_GUEST_USER_CARD_BLOCKING_THRESHOLD,
is_customer_id_blocking_enabled:
common_utils::consts::DEFAULT_CUSTOMER_ID_BLOCKING_STATUS,
customer_id_blocking_threshold:
common_utils::consts::DEFAULT_CUSTOMER_ID_BLOCKING_THRESHOLD,
card_testing_guard_expiry:
common_utils::consts::DEFAULT_CARD_TESTING_GUARD_EXPIRY_IN_SECS,
}
}
| {
"crate": "diesel_models",
"file": null,
"file_size": null,
"is_async": false,
"is_pub": false,
"num_enums": null,
"num_structs": null,
"num_tables": null,
"score": 7703,
"total_crates": null
} |
fn_clm_diesel_models_get_id_-897459058201057485 | clm | function | // Repository: hyperswitch
// Crate: diesel_models
// Purpose: Database schema types directly mapping to PostgreSQL tables
// Module: crates/diesel_models/src/business_profile
// Inherent implementation for Profile
pub fn get_id(&self) -> &common_utils::id_type::ProfileId {
&self.id
}
| {
"crate": "diesel_models",
"file": null,
"file_size": null,
"is_async": false,
"is_pub": true,
"num_enums": null,
"num_structs": null,
"num_tables": null,
"score": 2472,
"total_crates": null
} |
fn_clm_diesel_models_apply_changeset_-897459058201057485 | clm | function | // Repository: hyperswitch
// Crate: diesel_models
// Purpose: Database schema types directly mapping to PostgreSQL tables
// Module: crates/diesel_models/src/business_profile
// Inherent implementation for ProfileUpdateInternal
pub fn apply_changeset(self, source: Profile) -> Profile {
let Self {
profile_name,
modified_at,
return_url,
enable_payment_response_hash,
payment_response_hash_key,
redirect_to_merchant_with_http_post,
webhook_details,
metadata,
is_recon_enabled,
applepay_verified_domains,
payment_link_config,
session_expiry,
authentication_connector_details,
payout_link_config,
is_extended_card_info_enabled,
extended_card_info_config,
is_connector_agnostic_mit_enabled,
use_billing_as_payment_method_billing,
collect_shipping_details_from_wallet_connector,
collect_billing_details_from_wallet_connector,
outgoing_webhook_custom_http_headers,
always_collect_billing_details_from_wallet_connector,
always_collect_shipping_details_from_wallet_connector,
tax_connector_id,
is_tax_connector_enabled,
billing_processor_id,
routing_algorithm_id,
order_fulfillment_time,
order_fulfillment_time_origin,
frm_routing_algorithm_id,
payout_routing_algorithm_id,
default_fallback_routing,
should_collect_cvv_during_payment,
is_network_tokenization_enabled,
is_auto_retries_enabled,
max_auto_retries_enabled,
is_click_to_pay_enabled,
authentication_product_ids,
three_ds_decision_manager_config,
card_testing_guard_config,
card_testing_secret_key,
is_clear_pan_retries_enabled,
is_debit_routing_enabled,
merchant_business_country,
revenue_recovery_retry_algorithm_type,
revenue_recovery_retry_algorithm_data,
is_iframe_redirection_enabled,
is_external_vault_enabled,
external_vault_connector_details,
merchant_category_code,
merchant_country_code,
split_txns_enabled,
is_l2_l3_enabled,
} = self;
Profile {
id: source.id,
merchant_id: source.merchant_id,
profile_name: profile_name.unwrap_or(source.profile_name),
created_at: source.created_at,
modified_at,
return_url: return_url.or(source.return_url),
enable_payment_response_hash: enable_payment_response_hash
.unwrap_or(source.enable_payment_response_hash),
payment_response_hash_key: payment_response_hash_key
.or(source.payment_response_hash_key),
redirect_to_merchant_with_http_post: redirect_to_merchant_with_http_post
.unwrap_or(source.redirect_to_merchant_with_http_post),
webhook_details: webhook_details.or(source.webhook_details),
metadata: metadata.or(source.metadata),
is_recon_enabled: is_recon_enabled.unwrap_or(source.is_recon_enabled),
applepay_verified_domains: applepay_verified_domains
.or(source.applepay_verified_domains),
payment_link_config: payment_link_config.or(source.payment_link_config),
session_expiry: session_expiry.or(source.session_expiry),
authentication_connector_details: authentication_connector_details
.or(source.authentication_connector_details),
payout_link_config: payout_link_config.or(source.payout_link_config),
is_extended_card_info_enabled: is_extended_card_info_enabled
.or(source.is_extended_card_info_enabled),
is_connector_agnostic_mit_enabled: is_connector_agnostic_mit_enabled
.or(source.is_connector_agnostic_mit_enabled),
extended_card_info_config: extended_card_info_config
.or(source.extended_card_info_config),
use_billing_as_payment_method_billing: use_billing_as_payment_method_billing
.or(source.use_billing_as_payment_method_billing),
collect_shipping_details_from_wallet_connector:
collect_shipping_details_from_wallet_connector
.or(source.collect_shipping_details_from_wallet_connector),
collect_billing_details_from_wallet_connector:
collect_billing_details_from_wallet_connector
.or(source.collect_billing_details_from_wallet_connector),
outgoing_webhook_custom_http_headers: outgoing_webhook_custom_http_headers
.or(source.outgoing_webhook_custom_http_headers),
always_collect_billing_details_from_wallet_connector:
always_collect_billing_details_from_wallet_connector
.or(always_collect_billing_details_from_wallet_connector),
always_collect_shipping_details_from_wallet_connector:
always_collect_shipping_details_from_wallet_connector
.or(always_collect_shipping_details_from_wallet_connector),
tax_connector_id: tax_connector_id.or(source.tax_connector_id),
is_tax_connector_enabled: is_tax_connector_enabled.or(source.is_tax_connector_enabled),
routing_algorithm_id: routing_algorithm_id.or(source.routing_algorithm_id),
order_fulfillment_time: order_fulfillment_time.or(source.order_fulfillment_time),
order_fulfillment_time_origin: order_fulfillment_time_origin
.or(source.order_fulfillment_time_origin),
frm_routing_algorithm_id: frm_routing_algorithm_id.or(source.frm_routing_algorithm_id),
payout_routing_algorithm_id: payout_routing_algorithm_id
.or(source.payout_routing_algorithm_id),
default_fallback_routing: default_fallback_routing.or(source.default_fallback_routing),
should_collect_cvv_during_payment: should_collect_cvv_during_payment
.or(source.should_collect_cvv_during_payment),
version: source.version,
dynamic_routing_algorithm: None,
is_network_tokenization_enabled: is_network_tokenization_enabled
.unwrap_or(source.is_network_tokenization_enabled),
is_auto_retries_enabled: is_auto_retries_enabled.or(source.is_auto_retries_enabled),
max_auto_retries_enabled: max_auto_retries_enabled.or(source.max_auto_retries_enabled),
always_request_extended_authorization: None,
is_click_to_pay_enabled: is_click_to_pay_enabled
.unwrap_or(source.is_click_to_pay_enabled),
authentication_product_ids: authentication_product_ids
.or(source.authentication_product_ids),
three_ds_decision_manager_config: three_ds_decision_manager_config
.or(source.three_ds_decision_manager_config),
card_testing_guard_config: card_testing_guard_config
.or(source.card_testing_guard_config),
card_testing_secret_key: card_testing_secret_key.or(source.card_testing_secret_key),
is_clear_pan_retries_enabled: is_clear_pan_retries_enabled
.unwrap_or(source.is_clear_pan_retries_enabled),
force_3ds_challenge: None,
is_debit_routing_enabled: is_debit_routing_enabled
.unwrap_or(source.is_debit_routing_enabled),
merchant_business_country: merchant_business_country
.or(source.merchant_business_country),
revenue_recovery_retry_algorithm_type: revenue_recovery_retry_algorithm_type
.or(source.revenue_recovery_retry_algorithm_type),
revenue_recovery_retry_algorithm_data: revenue_recovery_retry_algorithm_data
.or(source.revenue_recovery_retry_algorithm_data),
is_iframe_redirection_enabled: is_iframe_redirection_enabled
.or(source.is_iframe_redirection_enabled),
is_external_vault_enabled: is_external_vault_enabled
.or(source.is_external_vault_enabled),
external_vault_connector_details: external_vault_connector_details
.or(source.external_vault_connector_details),
three_ds_decision_rule_algorithm: None,
acquirer_config_map: None,
merchant_category_code: merchant_category_code.or(source.merchant_category_code),
merchant_country_code: merchant_country_code.or(source.merchant_country_code),
dispute_polling_interval: None,
split_txns_enabled: split_txns_enabled.or(source.split_txns_enabled),
is_manual_retry_enabled: None,
always_enable_overcapture: None,
is_l2_l3_enabled: None,
billing_processor_id: billing_processor_id.or(source.billing_processor_id),
}
}
| {
"crate": "diesel_models",
"file": null,
"file_size": null,
"is_async": false,
"is_pub": true,
"num_enums": null,
"num_structs": null,
"num_tables": null,
"score": 156,
"total_crates": null
} |
fn_clm_diesel_models_has_exceeded_monitoring_threshold_-897459058201057485 | clm | function | // Repository: hyperswitch
// Crate: diesel_models
// Purpose: Database schema types directly mapping to PostgreSQL tables
// Module: crates/diesel_models/src/business_profile
// Inherent implementation for RevenueRecoveryAlgorithmData
pub fn has_exceeded_monitoring_threshold(&self, monitoring_threshold_in_seconds: i64) -> bool {
let total_threshold_time = self.monitoring_configured_timestamp
+ Duration::seconds(monitoring_threshold_in_seconds);
common_utils::date_time::now() >= total_threshold_time
}
| {
"crate": "diesel_models",
"file": null,
"file_size": null,
"is_async": false,
"is_pub": true,
"num_enums": null,
"num_structs": null,
"num_tables": null,
"score": 25,
"total_crates": null
} |
fn_clm_diesel_models_new_-1225495206381143573 | clm | function | // Repository: hyperswitch
// Crate: diesel_models
// Purpose: Database schema types directly mapping to PostgreSQL tables
// Module: crates/diesel_models/src/invoice
// Inherent implementation for InvoiceUpdate
pub fn new(
amount: Option<MinorUnit>,
currency: Option<String>,
payment_method_id: Option<String>,
status: Option<InvoiceStatus>,
connector_invoice_id: Option<common_utils::id_type::InvoiceId>,
payment_intent_id: Option<common_utils::id_type::PaymentId>,
) -> Self {
Self {
status,
payment_method_id,
connector_invoice_id,
modified_at: common_utils::date_time::now(),
payment_intent_id,
amount,
currency,
}
}
| {
"crate": "diesel_models",
"file": null,
"file_size": null,
"is_async": false,
"is_pub": true,
"num_enums": null,
"num_structs": null,
"num_tables": null,
"score": 14465,
"total_crates": null
} |
fn_clm_diesel_models_default_-2598529412098725068 | clm | function | // Repository: hyperswitch
// Crate: diesel_models
// Purpose: Database schema types directly mapping to PostgreSQL tables
// Module: crates/diesel_models/src/generic_link
// Implementation of GenericLinkNew for Default
fn default() -> Self {
let now = common_utils::date_time::now();
Self {
link_id: String::default(),
primary_reference: String::default(),
merchant_id: common_utils::id_type::MerchantId::default(),
created_at: Some(now),
last_modified_at: Some(now),
expiry: now + Duration::seconds(consts::DEFAULT_SESSION_EXPIRY),
link_data: serde_json::Value::default(),
link_status: GenericLinkStatus::default(),
link_type: common_enums::GenericLinkType::default(),
url: Secret::default(),
return_url: Option::default(),
}
}
| {
"crate": "diesel_models",
"file": null,
"file_size": null,
"is_async": false,
"is_pub": false,
"num_enums": null,
"num_structs": null,
"num_tables": null,
"score": 7723,
"total_crates": null
} |
fn_clm_diesel_models_from_-2598529412098725068 | clm | function | // Repository: hyperswitch
// Crate: diesel_models
// Purpose: Database schema types directly mapping to PostgreSQL tables
// Module: crates/diesel_models/src/generic_link
// Implementation of GenericLinkUpdateInternal for From<PayoutLinkUpdate>
fn from(generic_link_update: PayoutLinkUpdate) -> Self {
match generic_link_update {
PayoutLinkUpdate::StatusUpdate { link_status } => Self {
link_status: Some(GenericLinkStatus::PayoutLink(link_status)),
},
}
}
| {
"crate": "diesel_models",
"file": null,
"file_size": null,
"is_async": false,
"is_pub": false,
"num_enums": null,
"num_structs": null,
"num_tables": null,
"score": 2602,
"total_crates": null
} |
fn_clm_diesel_models_get_payment_method_collect_data_-2598529412098725068 | clm | function | // Repository: hyperswitch
// Crate: diesel_models
// Purpose: Database schema types directly mapping to PostgreSQL tables
// Module: crates/diesel_models/src/generic_link
// Implementation of None for GenericLinkData
pub fn get_payment_method_collect_data(&self) -> Result<&PaymentMethodCollectLinkData, String> {
match self {
Self::PaymentMethodCollect(pm) => Ok(pm),
_ => Err("Invalid link type for fetching payment method collect data".to_string()),
}
}
| {
"crate": "diesel_models",
"file": null,
"file_size": null,
"is_async": false,
"is_pub": true,
"num_enums": null,
"num_structs": null,
"num_tables": null,
"score": 20,
"total_crates": null
} |
fn_clm_diesel_models_get_payout_link_data_-2598529412098725068 | clm | function | // Repository: hyperswitch
// Crate: diesel_models
// Purpose: Database schema types directly mapping to PostgreSQL tables
// Module: crates/diesel_models/src/generic_link
// Implementation of None for GenericLinkData
pub fn get_payout_link_data(&self) -> Result<&PayoutLinkData, String> {
match self {
Self::PayoutLink(pl) => Ok(pl),
_ => Err("Invalid link type for fetching payout link data".to_string()),
}
}
| {
"crate": "diesel_models",
"file": null,
"file_size": null,
"is_async": false,
"is_pub": true,
"num_enums": null,
"num_structs": null,
"num_tables": null,
"score": 20,
"total_crates": null
} |
fn_clm_diesel_models_from_-4566505850933181187 | clm | function | // Repository: hyperswitch
// Crate: diesel_models
// Purpose: Database schema types directly mapping to PostgreSQL tables
// Module: crates/diesel_models/src/unified_translations
// Implementation of UnifiedTranslationsUpdateInternal for From<UnifiedTranslationsUpdate>
fn from(value: UnifiedTranslationsUpdate) -> Self {
let now = common_utils::date_time::now();
let UnifiedTranslationsUpdate { translation } = value;
Self {
translation,
last_modified_at: now,
}
}
| {
"crate": "diesel_models",
"file": null,
"file_size": null,
"is_async": false,
"is_pub": false,
"num_enums": null,
"num_structs": null,
"num_tables": null,
"score": 2602,
"total_crates": null
} |
fn_clm_diesel_models_from_-6381279313086276777 | clm | function | // Repository: hyperswitch
// Crate: diesel_models
// Purpose: Database schema types directly mapping to PostgreSQL tables
// Module: crates/diesel_models/src/api_keys
// Implementation of HashedApiKey for From<String>
fn from(hashed_api_key: String) -> Self {
Self(hashed_api_key)
}
| {
"crate": "diesel_models",
"file": null,
"file_size": null,
"is_async": false,
"is_pub": false,
"num_enums": null,
"num_structs": null,
"num_tables": null,
"score": 2602,
"total_crates": null
} |
fn_clm_diesel_models_into_inner_-6381279313086276777 | clm | function | // Repository: hyperswitch
// Crate: diesel_models
// Purpose: Database schema types directly mapping to PostgreSQL tables
// Module: crates/diesel_models/src/api_keys
// Inherent implementation for HashedApiKey
pub fn into_inner(self) -> String {
self.0
}
| {
"crate": "diesel_models",
"file": null,
"file_size": null,
"is_async": false,
"is_pub": true,
"num_enums": null,
"num_structs": null,
"num_tables": null,
"score": 2061,
"total_crates": null
} |
fn_clm_diesel_models_build_-6381279313086276777 | clm | function | // Repository: hyperswitch
// Crate: diesel_models
// Purpose: Database schema types directly mapping to PostgreSQL tables
// Module: crates/diesel_models/src/api_keys
// Implementation of super::HashedApiKey for Queryable<Text, DB>
fn build(row: Self::Row) -> diesel::deserialize::Result<Self> {
Ok(row)
}
| {
"crate": "diesel_models",
"file": null,
"file_size": null,
"is_async": false,
"is_pub": false,
"num_enums": null,
"num_structs": null,
"num_tables": null,
"score": 572,
"total_crates": null
} |
fn_clm_diesel_models_to_sql_-6381279313086276777 | clm | function | // Repository: hyperswitch
// Crate: diesel_models
// Purpose: Database schema types directly mapping to PostgreSQL tables
// Module: crates/diesel_models/src/api_keys
// Implementation of super::HashedApiKey for ToSql<Text, DB>
fn to_sql<'b>(&'b self, out: &mut Output<'b, '_, DB>) -> diesel::serialize::Result {
self.0.to_sql(out)
}
| {
"crate": "diesel_models",
"file": null,
"file_size": null,
"is_async": false,
"is_pub": false,
"num_enums": null,
"num_structs": null,
"num_tables": null,
"score": 100,
"total_crates": null
} |
fn_clm_diesel_models_from_sql_-6381279313086276777 | clm | function | // Repository: hyperswitch
// Crate: diesel_models
// Purpose: Database schema types directly mapping to PostgreSQL tables
// Module: crates/diesel_models/src/api_keys
// Implementation of super::HashedApiKey for FromSql<Text, DB>
fn from_sql(bytes: DB::RawValue<'_>) -> diesel::deserialize::Result<Self> {
Ok(Self(String::from_sql(bytes)?))
}
| {
"crate": "diesel_models",
"file": null,
"file_size": null,
"is_async": false,
"is_pub": false,
"num_enums": null,
"num_structs": null,
"num_tables": null,
"score": 54,
"total_crates": null
} |
fn_clm_diesel_models_from_7383406899157291239 | clm | function | // Repository: hyperswitch
// Crate: diesel_models
// Purpose: Database schema types directly mapping to PostgreSQL tables
// Module: crates/diesel_models/src/errors
// Implementation of DatabaseError for From<diesel::result::Error>
fn from(error: diesel::result::Error) -> Self {
match error {
diesel::result::Error::DatabaseError(
diesel::result::DatabaseErrorKind::UniqueViolation,
_,
) => Self::UniqueViolation,
diesel::result::Error::NotFound => Self::NotFound,
diesel::result::Error::QueryBuilderError(_) => Self::QueryGenerationFailed,
_ => Self::Others,
}
}
| {
"crate": "diesel_models",
"file": null,
"file_size": null,
"is_async": false,
"is_pub": false,
"num_enums": null,
"num_structs": null,
"num_tables": null,
"score": 2600,
"total_crates": null
} |
fn_clm_diesel_models_from_-1851006187774148561 | clm | function | // Repository: hyperswitch
// Crate: diesel_models
// Purpose: Database schema types directly mapping to PostgreSQL tables
// Module: crates/diesel_models/src/customers
// Implementation of Customer for From<CustomerNew>
fn from(customer_new: CustomerNew) -> Self {
Self {
merchant_id: customer_new.merchant_id,
name: customer_new.name,
email: customer_new.email,
phone: customer_new.phone,
phone_country_code: customer_new.phone_country_code,
description: customer_new.description,
created_at: customer_new.created_at,
metadata: customer_new.metadata,
connector_customer: customer_new.connector_customer,
modified_at: customer_new.modified_at,
default_payment_method_id: None,
updated_by: customer_new.updated_by,
tax_registration_id: customer_new.tax_registration_id,
merchant_reference_id: customer_new.merchant_reference_id,
default_billing_address: customer_new.default_billing_address,
default_shipping_address: customer_new.default_shipping_address,
id: customer_new.id,
version: customer_new.version,
status: customer_new.status,
}
}
| {
"crate": "diesel_models",
"file": null,
"file_size": null,
"is_async": false,
"is_pub": false,
"num_enums": null,
"num_structs": null,
"num_tables": null,
"score": 2600,
"total_crates": null
} |
fn_clm_diesel_models_apply_changeset_-1851006187774148561 | clm | function | // Repository: hyperswitch
// Crate: diesel_models
// Purpose: Database schema types directly mapping to PostgreSQL tables
// Module: crates/diesel_models/src/customers
// Inherent implementation for CustomerUpdateInternal
pub fn apply_changeset(self, source: Customer) -> Customer {
let Self {
name,
email,
phone,
description,
phone_country_code,
metadata,
connector_customer,
default_payment_method_id,
default_billing_address,
default_shipping_address,
status,
tax_registration_id,
..
} = self;
Customer {
name: name.map_or(source.name, Some),
email: email.map_or(source.email, Some),
phone: phone.map_or(source.phone, Some),
description: description.map_or(source.description, Some),
phone_country_code: phone_country_code.map_or(source.phone_country_code, Some),
metadata: metadata.map_or(source.metadata, Some),
modified_at: common_utils::date_time::now(),
connector_customer: connector_customer.map_or(source.connector_customer, Some),
default_payment_method_id: default_payment_method_id
.flatten()
.map_or(source.default_payment_method_id, Some),
default_billing_address: default_billing_address
.map_or(source.default_billing_address, Some),
default_shipping_address: default_shipping_address
.map_or(source.default_shipping_address, Some),
status: status.unwrap_or(source.status),
tax_registration_id: tax_registration_id.map_or(source.tax_registration_id, Some),
..source
}
}
| {
"crate": "diesel_models",
"file": null,
"file_size": null,
"is_async": false,
"is_pub": true,
"num_enums": null,
"num_structs": null,
"num_tables": null,
"score": 82,
"total_crates": null
} |
fn_clm_diesel_models_update_storage_scheme_-1851006187774148561 | clm | function | // Repository: hyperswitch
// Crate: diesel_models
// Purpose: Database schema types directly mapping to PostgreSQL tables
// Module: crates/diesel_models/src/customers
// Inherent implementation for CustomerNew
pub fn update_storage_scheme(&mut self, storage_scheme: common_enums::MerchantStorageScheme) {
self.updated_by = Some(storage_scheme.to_string());
}
| {
"crate": "diesel_models",
"file": null,
"file_size": null,
"is_async": false,
"is_pub": true,
"num_enums": null,
"num_structs": null,
"num_tables": null,
"score": 20,
"total_crates": null
} |
fn_clm_diesel_models_from_5645427331483182881 | clm | function | // Repository: hyperswitch
// Crate: diesel_models
// Purpose: Database schema types directly mapping to PostgreSQL tables
// Module: crates/diesel_models/src/gsm
// Implementation of GatewayStatusMapperUpdateInternal for From<GatewayStatusMappingUpdate>
fn from(value: GatewayStatusMappingUpdate) -> Self {
let GatewayStatusMappingUpdate {
decision,
status,
router_error,
step_up_possible,
unified_code,
unified_message,
error_category,
clear_pan_possible,
feature_data,
feature,
} = value;
Self {
status,
router_error,
decision,
step_up_possible,
unified_code,
unified_message,
error_category,
last_modified: common_utils::date_time::now(),
connector: None,
flow: None,
sub_flow: None,
code: None,
message: None,
clear_pan_possible,
feature_data,
feature,
}
}
| {
"crate": "diesel_models",
"file": null,
"file_size": null,
"is_async": false,
"is_pub": false,
"num_enums": null,
"num_structs": null,
"num_tables": null,
"score": 2602,
"total_crates": null
} |
fn_clm_diesel_models_get_api_event_type_5645427331483182881 | clm | function | // Repository: hyperswitch
// Crate: diesel_models
// Purpose: Database schema types directly mapping to PostgreSQL tables
// Module: crates/diesel_models/src/gsm
// Implementation of GatewayStatusMap for ApiEventMetric
fn get_api_event_type(&self) -> Option<ApiEventsType> {
Some(ApiEventsType::Gsm)
}
| {
"crate": "diesel_models",
"file": null,
"file_size": null,
"is_async": false,
"is_pub": false,
"num_enums": null,
"num_structs": null,
"num_tables": null,
"score": 26,
"total_crates": null
} |
fn_clm_diesel_models_default_913975415099675741 | clm | function | // Repository: hyperswitch
// Crate: diesel_models
// Purpose: Database schema types directly mapping to PostgreSQL tables
// Module: crates/diesel_models/src/payout_attempt
// Implementation of PayoutAttemptUpdateInternal for Default
fn default() -> Self {
Self {
payout_token: None,
connector_payout_id: None,
status: None,
error_message: None,
error_code: None,
is_eligible: None,
business_country: None,
business_label: None,
connector: None,
routing_info: None,
merchant_connector_id: None,
last_modified_at: common_utils::date_time::now(),
address_id: None,
customer_id: None,
unified_code: None,
unified_message: None,
additional_payout_method_data: None,
merchant_order_reference_id: None,
payout_connector_metadata: None,
}
}
| {
"crate": "diesel_models",
"file": null,
"file_size": null,
"is_async": false,
"is_pub": false,
"num_enums": null,
"num_structs": null,
"num_tables": null,
"score": 7705,
"total_crates": null
} |
fn_clm_diesel_models_from_913975415099675741 | clm | function | // Repository: hyperswitch
// Crate: diesel_models
// Purpose: Database schema types directly mapping to PostgreSQL tables
// Module: crates/diesel_models/src/payout_attempt
// Implementation of PayoutAttemptUpdateInternal for From<PayoutAttemptUpdate>
fn from(payout_update: PayoutAttemptUpdate) -> Self {
match payout_update {
PayoutAttemptUpdate::PayoutTokenUpdate { payout_token } => Self {
payout_token: Some(payout_token),
..Default::default()
},
PayoutAttemptUpdate::StatusUpdate {
connector_payout_id,
status,
error_message,
error_code,
is_eligible,
unified_code,
unified_message,
payout_connector_metadata,
} => Self {
connector_payout_id,
status: Some(status),
error_message,
error_code,
is_eligible,
unified_code,
unified_message,
payout_connector_metadata,
..Default::default()
},
PayoutAttemptUpdate::BusinessUpdate {
business_country,
business_label,
address_id,
customer_id,
} => Self {
business_country,
business_label,
address_id,
customer_id,
..Default::default()
},
PayoutAttemptUpdate::UpdateRouting {
connector,
routing_info,
merchant_connector_id,
} => Self {
connector: Some(connector),
routing_info,
merchant_connector_id,
..Default::default()
},
PayoutAttemptUpdate::AdditionalPayoutMethodDataUpdate {
additional_payout_method_data,
} => Self {
additional_payout_method_data,
..Default::default()
},
}
}
| {
"crate": "diesel_models",
"file": null,
"file_size": null,
"is_async": false,
"is_pub": false,
"num_enums": null,
"num_structs": null,
"num_tables": null,
"score": 2610,
"total_crates": null
} |
fn_clm_diesel_models_apply_changeset_913975415099675741 | clm | function | // Repository: hyperswitch
// Crate: diesel_models
// Purpose: Database schema types directly mapping to PostgreSQL tables
// Module: crates/diesel_models/src/payout_attempt
// Inherent implementation for PayoutAttemptUpdate
pub fn apply_changeset(self, source: PayoutAttempt) -> PayoutAttempt {
let PayoutAttemptUpdateInternal {
payout_token,
connector_payout_id,
status,
error_message,
error_code,
is_eligible,
business_country,
business_label,
connector,
routing_info,
last_modified_at,
address_id,
customer_id,
merchant_connector_id,
unified_code,
unified_message,
additional_payout_method_data,
merchant_order_reference_id,
payout_connector_metadata,
} = self.into();
PayoutAttempt {
payout_token: payout_token.or(source.payout_token),
connector_payout_id: connector_payout_id.or(source.connector_payout_id),
status: status.unwrap_or(source.status),
error_message: error_message.or(source.error_message),
error_code: error_code.or(source.error_code),
is_eligible: is_eligible.or(source.is_eligible),
business_country: business_country.or(source.business_country),
business_label: business_label.or(source.business_label),
connector: connector.or(source.connector),
routing_info: routing_info.or(source.routing_info),
last_modified_at,
address_id: address_id.or(source.address_id),
customer_id: customer_id.or(source.customer_id),
merchant_connector_id: merchant_connector_id.or(source.merchant_connector_id),
unified_code: unified_code.or(source.unified_code),
unified_message: unified_message.or(source.unified_message),
additional_payout_method_data: additional_payout_method_data
.or(source.additional_payout_method_data),
merchant_order_reference_id: merchant_order_reference_id
.or(source.merchant_order_reference_id),
payout_connector_metadata: payout_connector_metadata
.or(source.payout_connector_metadata),
..source
}
}
| {
"crate": "diesel_models",
"file": null,
"file_size": null,
"is_async": false,
"is_pub": true,
"num_enums": null,
"num_structs": null,
"num_tables": null,
"score": 92,
"total_crates": null
} |
fn_clm_diesel_models_default_-7696312247864174804 | clm | function | // Repository: hyperswitch
// Crate: diesel_models
// Purpose: Database schema types directly mapping to PostgreSQL tables
// Module: crates/diesel_models/src/authentication
// Implementation of AuthenticationUpdateInternal for Default
fn default() -> Self {
Self {
connector_authentication_id: Default::default(),
payment_method_id: Default::default(),
authentication_type: Default::default(),
authentication_status: Default::default(),
authentication_lifecycle_status: Default::default(),
modified_at: common_utils::date_time::now(),
error_message: Default::default(),
error_code: Default::default(),
connector_metadata: Default::default(),
maximum_supported_version: Default::default(),
threeds_server_transaction_id: Default::default(),
authentication_flow_type: Default::default(),
message_version: Default::default(),
eci: Default::default(),
trans_status: Default::default(),
acquirer_bin: Default::default(),
acquirer_merchant_id: Default::default(),
three_ds_method_data: Default::default(),
three_ds_method_url: Default::default(),
acs_url: Default::default(),
challenge_request: Default::default(),
acs_reference_number: Default::default(),
acs_trans_id: Default::default(),
acs_signed_content: Default::default(),
ds_trans_id: Default::default(),
directory_server_id: Default::default(),
acquirer_country_code: Default::default(),
service_details: Default::default(),
force_3ds_challenge: Default::default(),
psd2_sca_exemption_type: Default::default(),
billing_address: Default::default(),
shipping_address: Default::default(),
browser_info: Default::default(),
email: Default::default(),
profile_acquirer_id: Default::default(),
challenge_code: Default::default(),
challenge_cancel: Default::default(),
challenge_code_reason: Default::default(),
message_extension: Default::default(),
challenge_request_key: Default::default(),
}
}
| {
"crate": "diesel_models",
"file": null,
"file_size": null,
"is_async": false,
"is_pub": false,
"num_enums": null,
"num_structs": null,
"num_tables": null,
"score": 7783,
"total_crates": null
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.