text stringlengths 70 351k | source stringclasses 4
values |
|---|---|
// file: hyperswitch/crates/common_utils/src/types.rs | crate: common_utils
use std::{
borrow::Cow,
fmt::Display,
iter::Sum,
ops::{Add, Mul, Sub},
primitive::i64,
str::FromStr,
};
fn sum<I: Iterator<Item = Self>>(iter: I) -> Self {
iter.fold(Self(0), |a, b| a + b)
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/common_utils/src/types.rs | crate: common_utils
use std::{
borrow::Cow,
fmt::Display,
iter::Sum,
ops::{Add, Mul, Sub},
primitive::i64,
str::FromStr,
};
use diesel::{
backend::Backend,
deserialize,
deserialize::FromSql,
serialize::{Output, ToSql},
sql_types,
sql_types::Jsonb,
AsExpression, FromSqlRow, Queryable,
};
use crate::{
consts::{
self, MAX_DESCRIPTION_LENGTH, MAX_STATEMENT_DESCRIPTOR_LENGTH, PUBLISHABLE_KEY_LENGTH,
},
errors::{CustomResult, ParsingError, PercentageError, ValidationError},
fp_utils::when,
};
fn mul(self, a2: u16) -> Self::Output {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/common_utils/src/types.rs | crate: common_utils
use crate::{
consts::{
self, MAX_DESCRIPTION_LENGTH, MAX_STATEMENT_DESCRIPTOR_LENGTH, PUBLISHABLE_KEY_LENGTH,
},
errors::{CustomResult, ParsingError, PercentageError, ValidationError},
fp_utils::when,
};
fn sub(self, a2: Self) -> Self {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/common_utils/src/types.rs | crate: common_utils
use crate::{
consts::{
self, MAX_DESCRIPTION_LENGTH, MAX_STATEMENT_DESCRIPTOR_LENGTH, PUBLISHABLE_KEY_LENGTH,
},
errors::{CustomResult, ParsingError, PercentageError, ValidationError},
fp_utils::when,
};
fn add(self, a2: Self) -> Self {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/common_utils/src/types.rs | crate: common_utils
use std::{
borrow::Cow,
fmt::Display,
iter::Sum,
ops::{Add, Mul, Sub},
primitive::i64,
str::FromStr,
};
use diesel::{
backend::Backend,
deserialize,
deserialize::FromSql,
serialize::{Output, ToSql},
sql_types,
sql_types::Jsonb,
AsExpression, FromSqlRow, Queryable,
};
fn from_sql(value: DB::RawValue<'_>) -> deserialize::Result<Self> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/common_utils/src/types.rs | crate: common_utils
use error_stack::{report, ResultExt};
use crate::{
consts::{
self, MAX_DESCRIPTION_LENGTH, MAX_STATEMENT_DESCRIPTOR_LENGTH, PUBLISHABLE_KEY_LENGTH,
},
errors::{CustomResult, ParsingError, PercentageError, ValidationError},
fp_utils::when,
};
///Convert minor unit to string minor unit
fn to_minor_unit_as_string(self) -> Result<StringMinorUnit, error_stack::Report<ParsingError>> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/common_utils/src/types.rs | crate: common_utils
use common_enums::enums;
use error_stack::{report, ResultExt};
use rust_decimal::{
prelude::{FromPrimitive, ToPrimitive},
Decimal,
};
use crate::{
consts::{
self, MAX_DESCRIPTION_LENGTH, MAX_STATEMENT_DESCRIPTOR_LENGTH, PUBLISHABLE_KEY_LENGTH,
},
errors::{CustomResult, ParsingError, PercentageError, ValidationError},
fp_utils::when,
};
/// Convert the amount to its major denomination based on Currency and return f64
fn to_major_unit_as_f64(
self,
currency: enums::Currency,
) -> Result<FloatMajorUnit, error_stack::Report<ParsingError>> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/common_utils/src/types.rs | crate: common_utils
use common_enums::enums;
use error_stack::{report, ResultExt};
use crate::{
consts::{
self, MAX_DESCRIPTION_LENGTH, MAX_STATEMENT_DESCRIPTOR_LENGTH, PUBLISHABLE_KEY_LENGTH,
},
errors::{CustomResult, ParsingError, PercentageError, ValidationError},
fp_utils::when,
};
/// Convert the amount to its major denomination based on Currency and return String
/// Paypal Connector accepts Zero and Two decimal currency but not three decimal and it should be updated as required for 3 decimal currencies.
/// Paypal Ref - https://developer.paypal.com/docs/reports/reference/paypal-supported-currencies/
fn to_major_unit_as_string(
self,
currency: enums::Currency,
) -> Result<StringMajorUnit, error_stack::Report<ParsingError>> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/common_utils/src/types.rs | crate: common_utils
use std::{
borrow::Cow,
fmt::Display,
iter::Sum,
ops::{Add, Mul, Sub},
primitive::i64,
str::FromStr,
};
pub use primitive_wrappers::bool_wrappers::{
AlwaysRequestExtendedAuthorization, ExtendedAuthorizationAppliedBool,
RequestExtendedAuthorizationBool,
};
pub use client_secret_type::ClientSecret;
/// forms a new minor unit from amount
pub fn new(value: i64) -> Self {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/common_utils/src/types.rs | crate: common_utils
pub use primitive_wrappers::bool_wrappers::{
AlwaysRequestExtendedAuthorization, ExtendedAuthorizationAppliedBool,
RequestExtendedAuthorizationBool,
};
pub use client_secret_type::ClientSecret;
/// forms a new minor default unit i.e zero
pub fn zero() -> Self {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/common_utils/src/types.rs | crate: common_utils
use std::{
borrow::Cow,
fmt::Display,
iter::Sum,
ops::{Add, Mul, Sub},
primitive::i64,
str::FromStr,
};
pub use primitive_wrappers::bool_wrappers::{
AlwaysRequestExtendedAuthorization, ExtendedAuthorizationAppliedBool,
RequestExtendedAuthorizationBool,
};
use crate::{
consts::{
self, MAX_DESCRIPTION_LENGTH, MAX_STATEMENT_DESCRIPTOR_LENGTH, PUBLISHABLE_KEY_LENGTH,
},
errors::{CustomResult, ParsingError, PercentageError, ValidationError},
fp_utils::when,
};
pub use client_secret_type::ClientSecret;
/// gets amount as i64 value will be removed in future
pub fn get_amount_as_i64(self) -> i64 {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/common_utils/src/types.rs | crate: common_utils
use common_enums::enums;
use error_stack::{report, ResultExt};
use crate::{
consts::{
self, MAX_DESCRIPTION_LENGTH, MAX_STATEMENT_DESCRIPTOR_LENGTH, PUBLISHABLE_KEY_LENGTH,
},
errors::{CustomResult, ParsingError, PercentageError, ValidationError},
fp_utils::when,
};
fn convert_back(
&self,
amount: MinorUnit,
_currency: enums::Currency,
) -> Result<MinorUnit, error_stack::Report<ParsingError>> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/common_utils/src/types.rs | crate: common_utils
use common_enums::enums;
use diesel::{
backend::Backend,
deserialize,
deserialize::FromSql,
serialize::{Output, ToSql},
sql_types,
sql_types::Jsonb,
AsExpression, FromSqlRow, Queryable,
};
use error_stack::{report, ResultExt};
use crate::{
consts::{
self, MAX_DESCRIPTION_LENGTH, MAX_STATEMENT_DESCRIPTOR_LENGTH, PUBLISHABLE_KEY_LENGTH,
},
errors::{CustomResult, ParsingError, PercentageError, ValidationError},
fp_utils::when,
};
fn convert(
&self,
amount: MinorUnit,
_currency: enums::Currency,
) -> Result<Self::Output, error_stack::Report<ParsingError>> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/common_utils/src/types.rs | crate: common_utils
use common_enums::enums;
use error_stack::{report, ResultExt};
use crate::{
consts::{
self, MAX_DESCRIPTION_LENGTH, MAX_STATEMENT_DESCRIPTOR_LENGTH, PUBLISHABLE_KEY_LENGTH,
},
errors::{CustomResult, ParsingError, PercentageError, ValidationError},
fp_utils::when,
};
fn convert_back(
&self,
amount: FloatMajorUnit,
currency: enums::Currency,
) -> Result<MinorUnit, error_stack::Report<ParsingError>> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/common_utils/src/types.rs | crate: common_utils
use common_enums::enums;
use error_stack::{report, ResultExt};
use crate::{
consts::{
self, MAX_DESCRIPTION_LENGTH, MAX_STATEMENT_DESCRIPTOR_LENGTH, PUBLISHABLE_KEY_LENGTH,
},
errors::{CustomResult, ParsingError, PercentageError, ValidationError},
fp_utils::when,
};
fn convert_back(
&self,
amount: StringMajorUnit,
currency: enums::Currency,
) -> Result<MinorUnit, error_stack::Report<ParsingError>> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/common_utils/src/types.rs | crate: common_utils
use common_enums::enums;
use diesel::{
backend::Backend,
deserialize,
deserialize::FromSql,
serialize::{Output, ToSql},
sql_types,
sql_types::Jsonb,
AsExpression, FromSqlRow, Queryable,
};
use error_stack::{report, ResultExt};
use crate::{
consts::{
self, MAX_DESCRIPTION_LENGTH, MAX_STATEMENT_DESCRIPTOR_LENGTH, PUBLISHABLE_KEY_LENGTH,
},
errors::{CustomResult, ParsingError, PercentageError, ValidationError},
fp_utils::when,
};
fn convert(
&self,
amount: MinorUnit,
currency: enums::Currency,
) -> Result<Self::Output, error_stack::Report<ParsingError>> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/common_utils/src/types.rs | crate: common_utils
use common_enums::enums;
use diesel::{
backend::Backend,
deserialize,
deserialize::FromSql,
serialize::{Output, ToSql},
sql_types,
sql_types::Jsonb,
AsExpression, FromSqlRow, Queryable,
};
use error_stack::{report, ResultExt};
use crate::{
consts::{
self, MAX_DESCRIPTION_LENGTH, MAX_STATEMENT_DESCRIPTOR_LENGTH, PUBLISHABLE_KEY_LENGTH,
},
errors::{CustomResult, ParsingError, PercentageError, ValidationError},
fp_utils::when,
};
fn convert_back(
&self,
amount: Self::Output,
_currency: enums::Currency,
) -> Result<MinorUnit, error_stack::Report<ParsingError>> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
// file: hyperswitch/crates/common_utils/src/types.rs | crate: common_utils
use std::{
borrow::Cow,
fmt::Display,
iter::Sum,
ops::{Add, Mul, Sub},
primitive::i64,
str::FromStr,
};
use semver::Version;
use crate::{
consts::{
self, MAX_DESCRIPTION_LENGTH, MAX_STATEMENT_DESCRIPTOR_LENGTH, PUBLISHABLE_KEY_LENGTH,
},
errors::{CustomResult, ParsingError, PercentageError, ValidationError},
fp_utils::when,
};
fn from_str(s: &str) -> Result<Self, Self::Err> {
Ok(Self(Version::from_str(s).change_context(
ParsingError::StructParseFailure("SemanticVersion"),
)?))
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/common_utils/src/types.rs | crate: common_utils
pub use primitive_wrappers::bool_wrappers::{
AlwaysRequestExtendedAuthorization, ExtendedAuthorizationAppliedBool,
RequestExtendedAuthorizationBool,
};
use semver::Version;
pub use client_secret_type::ClientSecret;
/// Constructs new SemanticVersion instance
pub fn new(major: u64, minor: u64, patch: u64) -> Self {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/common_utils/src/types.rs | crate: common_utils
pub use primitive_wrappers::bool_wrappers::{
AlwaysRequestExtendedAuthorization, ExtendedAuthorizationAppliedBool,
RequestExtendedAuthorizationBool,
};
use crate::{
consts::{
self, MAX_DESCRIPTION_LENGTH, MAX_STATEMENT_DESCRIPTOR_LENGTH, PUBLISHABLE_KEY_LENGTH,
},
errors::{CustomResult, ParsingError, PercentageError, ValidationError},
fp_utils::when,
};
pub use client_secret_type::ClientSecret;
/// returns minor version number
pub fn get_minor(&self) -> u64 {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/common_utils/src/types.rs | crate: common_utils
pub use primitive_wrappers::bool_wrappers::{
AlwaysRequestExtendedAuthorization, ExtendedAuthorizationAppliedBool,
RequestExtendedAuthorizationBool,
};
use crate::{
consts::{
self, MAX_DESCRIPTION_LENGTH, MAX_STATEMENT_DESCRIPTOR_LENGTH, PUBLISHABLE_KEY_LENGTH,
},
errors::{CustomResult, ParsingError, PercentageError, ValidationError},
fp_utils::when,
};
pub use client_secret_type::ClientSecret;
/// returns major version number
pub fn get_major(&self) -> u64 {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
// file: hyperswitch/crates/common_utils/src/types.rs | crate: common_utils
use diesel::{
backend::Backend,
deserialize,
deserialize::FromSql,
serialize::{Output, ToSql},
sql_types,
sql_types::Jsonb,
AsExpression, FromSqlRow, Queryable,
};
use serde::{de::Visitor, Deserialize, Deserializer, Serialize};
use thiserror::Error;
fn deserialize<D>(data: D) -> Result<Self, D::Error>
where
D: Deserializer<'de>,
{
data.deserialize_map(PercentageVisitor::<PRECISION> {})
} | ast_fragments |
// file: hyperswitch/crates/common_utils/src/types.rs | crate: common_utils
use std::{
borrow::Cow,
fmt::Display,
iter::Sum,
ops::{Add, Mul, Sub},
primitive::i64,
str::FromStr,
};
use crate::{
consts::{
self, MAX_DESCRIPTION_LENGTH, MAX_STATEMENT_DESCRIPTOR_LENGTH, PUBLISHABLE_KEY_LENGTH,
},
errors::{CustomResult, ParsingError, PercentageError, ValidationError},
fp_utils::when,
};
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter.write_str("Percentage object")
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/common_utils/src/types.rs | crate: common_utils
use std::{
borrow::Cow,
fmt::Display,
iter::Sum,
ops::{Add, Mul, Sub},
primitive::i64,
str::FromStr,
};
fn is_valid_precision_length(value: &str) -> bool {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/common_utils/src/types.rs | crate: common_utils
fn is_valid_range(value: f32) -> bool {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/common_utils/src/types.rs | crate: common_utils
use std::{
borrow::Cow,
fmt::Display,
iter::Sum,
ops::{Add, Mul, Sub},
primitive::i64,
str::FromStr,
};
use crate::{
consts::{
self, MAX_DESCRIPTION_LENGTH, MAX_STATEMENT_DESCRIPTOR_LENGTH, PUBLISHABLE_KEY_LENGTH,
},
errors::{CustomResult, ParsingError, PercentageError, ValidationError},
fp_utils::when,
};
fn is_valid_float_string(value: &str) -> CustomResult<f32, PercentageError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/common_utils/src/types.rs | crate: common_utils
use std::{
borrow::Cow,
fmt::Display,
iter::Sum,
ops::{Add, Mul, Sub},
primitive::i64,
str::FromStr,
};
use crate::{
consts::{
self, MAX_DESCRIPTION_LENGTH, MAX_STATEMENT_DESCRIPTOR_LENGTH, PUBLISHABLE_KEY_LENGTH,
},
errors::{CustomResult, ParsingError, PercentageError, ValidationError},
fp_utils::when,
};
fn is_valid_string_value(value: &str) -> CustomResult<bool, PercentageError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/common_utils/src/types.rs | crate: common_utils
use std::{
borrow::Cow,
fmt::Display,
iter::Sum,
ops::{Add, Mul, Sub},
primitive::i64,
str::FromStr,
};
use error_stack::{report, ResultExt};
pub use primitive_wrappers::bool_wrappers::{
AlwaysRequestExtendedAuthorization, ExtendedAuthorizationAppliedBool,
RequestExtendedAuthorizationBool,
};
use crate::{
consts::{
self, MAX_DESCRIPTION_LENGTH, MAX_STATEMENT_DESCRIPTOR_LENGTH, PUBLISHABLE_KEY_LENGTH,
},
errors::{CustomResult, ParsingError, PercentageError, ValidationError},
fp_utils::when,
};
pub use client_secret_type::ClientSecret;
pub fn apply_and_ceil_result(
&self,
amount: MinorUnit,
) -> CustomResult<MinorUnit, PercentageError> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/common_utils/src/types.rs | crate: common_utils
pub use primitive_wrappers::bool_wrappers::{
AlwaysRequestExtendedAuthorization, ExtendedAuthorizationAppliedBool,
RequestExtendedAuthorizationBool,
};
use crate::{
consts::{
self, MAX_DESCRIPTION_LENGTH, MAX_STATEMENT_DESCRIPTOR_LENGTH, PUBLISHABLE_KEY_LENGTH,
},
errors::{CustomResult, ParsingError, PercentageError, ValidationError},
fp_utils::when,
};
pub use client_secret_type::ClientSecret;
/// function to get percentage value
pub fn get_percentage(&self) -> f32 {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/common_utils/src/types.rs | crate: common_utils
use error_stack::{report, ResultExt};
pub use primitive_wrappers::bool_wrappers::{
AlwaysRequestExtendedAuthorization, ExtendedAuthorizationAppliedBool,
RequestExtendedAuthorizationBool,
};
use crate::{
consts::{
self, MAX_DESCRIPTION_LENGTH, MAX_STATEMENT_DESCRIPTOR_LENGTH, PUBLISHABLE_KEY_LENGTH,
},
errors::{CustomResult, ParsingError, PercentageError, ValidationError},
fp_utils::when,
};
pub use client_secret_type::ClientSecret;
/// construct percentage using a string representation of float value
pub fn from_string(value: String) -> CustomResult<Self, PercentageError> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/common_utils/src/types.rs | crate: common_utils
fn get_invalid_percentage_error_message(precision: u8) -> String {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/common_utils/src/encryption.rs | crate: common_utils
use diesel::{
backend::Backend,
deserialize::{self, FromSql, Queryable},
expression::AsExpression,
serialize::ToSql,
sql_types,
};
use masking::Secret;
use crate::{crypto::Encryptable, pii::EncryptionStrategy};
pub fn into_inner(self) -> Secret<Vec<u8>, EncryptionStrategy> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/common_utils/src/encryption.rs | crate: common_utils
use masking::Secret;
use crate::{crypto::Encryptable, pii::EncryptionStrategy};
pub fn new(item: Secret<Vec<u8>, EncryptionStrategy>) -> Self {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/common_utils/src/encryption.rs | crate: common_utils
use diesel::{
backend::Backend,
deserialize::{self, FromSql, Queryable},
expression::AsExpression,
serialize::ToSql,
sql_types,
};
use masking::Secret;
use crate::{crypto::Encryptable, pii::EncryptionStrategy};
pub fn get_inner(&self) -> &Secret<Vec<u8>, EncryptionStrategy> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
// file: hyperswitch/crates/common_utils/src/encryption.rs | crate: common_utils
use diesel::{
backend::Backend,
deserialize::{self, FromSql, Queryable},
expression::AsExpression,
serialize::ToSql,
sql_types,
};
use masking::Secret;
use crate::{crypto::Encryptable, pii::EncryptionStrategy};
pub fn into_inner(self) -> Secret<Vec<u8>, EncryptionStrategy> {
self.inner
} | ast_fragments |
// file: hyperswitch/crates/common_utils/src/encryption.rs | crate: common_utils
use masking::Secret;
use crate::{crypto::Encryptable, pii::EncryptionStrategy};
pub fn new(item: Secret<Vec<u8>, EncryptionStrategy>) -> Self {
Self { inner: item }
} | ast_fragments |
// file: hyperswitch/crates/common_utils/src/encryption.rs | crate: common_utils
use crate::{crypto::Encryptable, pii::EncryptionStrategy};
fn from(value: Encryptable<T>) -> Self {
Self::new(value.into_encrypted())
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/common_utils/src/lib.rs | crate: common_utils
pub use base64_serializer::Base64Serializer;
pub async fn time_it<T, Fut: futures::Future<Output = T>, F: FnOnce() -> Fut>(
block: F,
) -> (T, f64) {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/common_utils/src/lib.rs | crate: common_utils
fn test_generate_merchant_ref_id_with_default_length() {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/common_utils/src/lib.rs | crate: common_utils
fn test_generate_id_with_alphanumeric_id() {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/common_utils/src/lib.rs | crate: common_utils
fn get_database_url(&self, schema: &str) -> String {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/common_utils/src/lib.rs | crate: common_utils
pub use base64_serializer::Base64Serializer;
pub fn generate_id_with_len(length: usize) -> String {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/common_utils/src/lib.rs | crate: common_utils
pub use base64_serializer::Base64Serializer;
pub fn generate_time_ordered_id_without_prefix() -> String {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/common_utils/src/lib.rs | crate: common_utils
pub use base64_serializer::Base64Serializer;
pub fn generate_time_ordered_id(prefix: &str) -> String {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/common_utils/src/lib.rs | crate: common_utils
pub use base64_serializer::Base64Serializer;
pub fn generate_id_with_default_len(prefix: &str) -> String {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/common_utils/src/lib.rs | crate: common_utils
use masking::{PeekInterface, Secret};
pub use base64_serializer::Base64Serializer;
/// Generate a merchant_connector_account id with default length, with prefix as `mca`
pub fn generate_merchant_connector_account_id_of_default_length(
) -> id_type::MerchantConnectorAccountId {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/common_utils/src/lib.rs | crate: common_utils
use masking::{PeekInterface, Secret};
pub use base64_serializer::Base64Serializer;
/// Generate a routing id with default length, with prefix as `routing`
pub fn generate_routing_id_of_default_length() -> id_type::RoutingId {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/common_utils/src/lib.rs | crate: common_utils
use masking::{PeekInterface, Secret};
pub use base64_serializer::Base64Serializer;
/// Generate a profile id with default length, with prefix as `pro`
pub fn generate_profile_id_of_default_length() -> id_type::ProfileId {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/common_utils/src/lib.rs | crate: common_utils
use masking::{PeekInterface, Secret};
pub use base64_serializer::Base64Serializer;
/// Generate a organization id with default length, with prefix as `org`
pub fn generate_organization_id_of_default_length() -> id_type::OrganizationId {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/common_utils/src/lib.rs | crate: common_utils
use masking::{PeekInterface, Secret};
pub use base64_serializer::Base64Serializer;
/// Generate a customer id with default length, with prefix as `cus`
pub fn generate_customer_id_of_default_length() -> id_type::CustomerId {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/common_utils/src/lib.rs | crate: common_utils
/// Generate a ReferenceId with the default length with the given prefix
fn generate_ref_id_with_default_length<const MAX_LENGTH: u8, const MIN_LENGTH: u8>(
prefix: &str,
) -> id_type::LengthId<MAX_LENGTH, MIN_LENGTH> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/common_utils/src/lib.rs | crate: common_utils
pub use base64_serializer::Base64Serializer;
pub fn generate_id(length: usize, prefix: &str) -> String {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/common_utils/src/lib.rs | crate: common_utils
fn fmt(input: &PrimitiveDateTime, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/common_utils/src/lib.rs | crate: common_utils
fn from(value: PrimitiveDateTime) -> Self {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/common_utils/src/lib.rs | crate: common_utils
pub use base64_serializer::Base64Serializer;
/// Return the current date and time in UTC with the format [year]-[month]-[day]T[hour]:[minute]:[second].mmmZ Eg: 2023-02-15T13:33:18.898Z
pub fn date_as_yyyymmddthhmmssmmmz() -> Result<String, time::error::Format> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/common_utils/src/lib.rs | crate: common_utils
pub use base64_serializer::Base64Serializer;
/// Return the given date and time in UTC with the given format Eg: format: YYYYMMDDHHmmss Eg: 20191105081132
pub fn format_date(
date: PrimitiveDateTime,
format: DateFormat,
) -> Result<String, time::error::Format> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
// file: hyperswitch/crates/common_utils/src/lib.rs | crate: common_utils
pub use base64_serializer::Base64Serializer;
pub async fn time_it<T, Fut: futures::Future<Output = T>, F: FnOnce() -> Fut>(
block: F,
) -> (T, f64) {
let start = Instant::now();
let result = block().await;
(result, start.elapsed().as_secs_f64() * 1000f64)
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/common_utils/src/lib.rs | crate: common_utils
pub use base64_serializer::Base64Serializer;
/// Return the UNIX timestamp of the current date and time in UTC
pub fn now_unix_timestamp() -> i64 {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/common_utils/src/lib.rs | crate: common_utils
pub use base64_serializer::Base64Serializer;
/// Convert from OffsetDateTime to PrimitiveDateTime
pub fn convert_to_pdt(offset_time: OffsetDateTime) -> PrimitiveDateTime {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/common_utils/src/lib.rs | crate: common_utils
pub use base64_serializer::Base64Serializer;
/// Create a new [`PrimitiveDateTime`] with the current date and time in UTC.
pub fn now() -> PrimitiveDateTime {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/common_utils/src/new_type.rs | crate: common_utils
/// - Only alphanumeric characters are masked; other characters remain unchanged.
///
/// # Examples
/// Sort Code
/// (12-34-56, 2, 2) -> 12-**-56
/// Routing number
/// (026009593, 3, 3) -> 026***593
/// CNPJ
/// (12345678901, 4, 4) -> *******8901
/// CNPJ
/// (12345678901, 4, 3) -> 1234***8901
/// Pix key
/// (123e-a452-1243-1244-000, 4, 4) -> 123e-****-****-****-000
/// IBAN
/// (AL35202111090000000001234567, 5, 5) -> AL352******************34567
fn apply_mask(val: &str, unmasked_char_count: usize, min_masked_char_count: usize) -> String {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/common_utils/src/new_type.rs | crate: common_utils
/// CNPJ
/// (12345678901, 4, 4) -> *******8901
/// CNPJ
/// (12345678901, 4, 3) -> 1234***8901
/// Pix key
/// (123e-a452-1243-1244-000, 4, 4) -> 123e-****-****-****-000
/// IBAN
/// (AL35202111090000000001234567, 5, 5) -> AL352******************34567
fn apply_mask(val: &str, unmasked_char_count: usize, min_masked_char_count: usize) -> String {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/common_utils/src/new_type.rs | crate: common_utils
fn test_apply_mask_fn() {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/common_utils/src/new_type.rs | crate: common_utils
fn test_masked_types() {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/common_utils/src/new_type.rs | crate: common_utils
use masking::{ExposeInterface, PeekInterface, Secret};
fn from(src: String) -> Self {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/common_utils/src/new_type.rs | crate: common_utils
use crate::{
consts::MAX_ALLOWED_MERCHANT_NAME_LENGTH,
pii::{Email, UpiVpaMaskingStrategy},
transformers::ForeignFrom,
};
fn foreign_from(email: Email) -> Self {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/common_utils/src/new_type.rs | crate: common_utils
use masking::{ExposeInterface, PeekInterface, Secret};
use crate::{
consts::MAX_ALLOWED_MERCHANT_NAME_LENGTH,
pii::{Email, UpiVpaMaskingStrategy},
transformers::ForeignFrom,
};
fn from(secret: Secret<String, UpiVpaMaskingStrategy>) -> Self {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/common_utils/src/new_type.rs | crate: common_utils
use masking::{ExposeInterface, PeekInterface, Secret};
fn from(secret: Secret<String>) -> Self {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/common_utils/src/validation.rs | crate: common_utils
use error_stack::report;
use once_cell::sync::Lazy;
use regex::Regex;
use router_env::logger;
use crate::errors::{CustomResult, ValidationError};
/// Performs a simple validation against a provided email address.
pub fn validate_email(email: &str) -> CustomResult<(), ValidationError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/common_utils/src/validation.rs | crate: common_utils
fn test_validate_phone_number(phone_number: &str) {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/common_utils/src/validation.rs | crate: common_utils
use error_stack::report;
use once_cell::sync::Lazy;
use regex::Regex;
use router_env::logger;
use crate::errors::{CustomResult, ValidationError};
/// Performs a simple validation against a provided email address.
pub fn validate_email(email: &str) -> CustomResult<(), ValidationError> {
{
Some(regex) => Ok(regex),<|fim_suffix|>
<|fim_middle|>
None => Err(report!(ValidationError::InvalidValue {
message: "Invalid regex expression".into()
})),
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/common_utils/src/validation.rs | crate: common_utils
fn test_invalid_phone_number(phone_number: &str) {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
// file: hyperswitch/crates/common_utils/src/validation.rs | crate: common_utils
fn test_validate_phone_number(phone_number: &str) {
assert!(validate_phone_number(phone_number).is_ok());
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/common_utils/src/validation.rs | crate: common_utils
fn test_validate_email() {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/common_utils/src/validation.rs | crate: common_utils
fn new_tree(&self, _runner: &mut TestRunner) -> NewTree<Self> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/common_utils/src/validation.rs | crate: common_utils
use std::collections::HashSet;
use globset::Glob;
use router_env::logger;
/// Checks whether a given domain matches against a list of valid domain glob patterns
pub fn validate_domain_against_allowed_domains(
domain: &str,
allowed_domains: HashSet<String>,
) -> bool {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/common_utils/src/validation.rs | crate: common_utils
use crate::errors::{CustomResult, ValidationError};
/// Validates a given phone number using the [phonenumber] crate
///
/// It returns a [ValidationError::InvalidValue] in case it could not parse the phone number
pub fn validate_phone_number(phone_number: &str) -> Result<(), ValidationError> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/common_utils/src/pii.rs | crate: common_utils
use std::{convert::AsRef, fmt, ops, str::FromStr};
use masking::{ExposeInterface, Secret, Strategy, WithType};
use crate::{
crypto::Encryptable,
errors::{self, ValidationError},
validation::{validate_email, validate_phone_number},
};
pub type SecretSerdeValue = Secret<serde_json::Value>;
fn from_str(email: &str) -> Result<Self, Self::Err> {
{
Ok(_) => {
let secret = Secret::<String, EmailStrategy>::new(email.to_string());
Ok(Self(secret))
}<|fim_suffix|>
<|fim_middle|>
Err(_) => Err(ValidationError::InvalidValue {
message: "Invalid email address format".into(),
}
.into()),
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/common_utils/src/pii.rs | crate: common_utils
use masking::{ExposeInterface, Secret, Strategy, WithType};
pub type SecretSerdeValue = Secret<serde_json::Value>;
fn test_invalid_upi_vpa_masking() {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/common_utils/src/pii.rs | crate: common_utils
use masking::{ExposeInterface, Secret, Strategy, WithType};
pub type SecretSerdeValue = Secret<serde_json::Value>;
fn test_valid_upi_vpa_masking() {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/common_utils/src/pii.rs | crate: common_utils
use masking::{ExposeInterface, Secret, Strategy, WithType};
pub type SecretSerdeValue = Secret<serde_json::Value>;
fn test_valid_phone_number_default_masking() {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/common_utils/src/pii.rs | crate: common_utils
use masking::{ExposeInterface, Secret, Strategy, WithType};
pub type SecretSerdeValue = Secret<serde_json::Value>;
fn test_invalid_client_secret_masking() {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/common_utils/src/pii.rs | crate: common_utils
use masking::{ExposeInterface, Secret, Strategy, WithType};
pub type SecretSerdeValue = Secret<serde_json::Value>;
fn test_valid_client_secret_masking() {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/common_utils/src/pii.rs | crate: common_utils
use masking::{ExposeInterface, Secret, Strategy, WithType};
pub type SecretSerdeValue = Secret<serde_json::Value>;
fn test_invalid_ip_addr_masking() {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/common_utils/src/pii.rs | crate: common_utils
use masking::{ExposeInterface, Secret, Strategy, WithType};
pub type SecretSerdeValue = Secret<serde_json::Value>;
fn test_valid_ip_addr_masking() {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/common_utils/src/pii.rs | crate: common_utils
fn test_redacted_email() {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/common_utils/src/pii.rs | crate: common_utils
fn test_invalid_newtype_email() {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/common_utils/src/pii.rs | crate: common_utils
fn test_valid_newtype_email() {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/common_utils/src/pii.rs | crate: common_utils
use masking::{ExposeInterface, Secret, Strategy, WithType};
pub type SecretSerdeValue = Secret<serde_json::Value>;
fn test_invalid_email_masking() {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/common_utils/src/pii.rs | crate: common_utils
use masking::{ExposeInterface, Secret, Strategy, WithType};
pub type SecretSerdeValue = Secret<serde_json::Value>;
fn test_valid_email_masking() {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/common_utils/src/pii.rs | crate: common_utils
use std::{convert::AsRef, fmt, ops, str::FromStr};
use masking::{ExposeInterface, Secret, Strategy, WithType};
use crate::{
crypto::Encryptable,
errors::{self, ValidationError},
validation::{validate_email, validate_phone_number},
};
pub type SecretSerdeValue = Secret<serde_json::Value>;
fn from_str(email: &str) -> Result<Self, Self::Err> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
// file: hyperswitch/crates/common_utils/src/pii.rs | crate: common_utils
use crate::{
crypto::Encryptable,
errors::{self, ValidationError},
validation::{validate_email, validate_phone_number},
};
fn deref(&self) -> &Self::Target {
&self.0
} | ast_fragments |
// file: hyperswitch/crates/common_utils/src/pii.rs | crate: common_utils
use crate::{
crypto::Encryptable,
errors::{self, ValidationError},
validation::{validate_email, validate_phone_number},
};
fn try_from(value: String) -> Result<Self, Self::Error> {
Self::from_str(&value).change_context(errors::ParsingError::EmailParsingError)
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/common_utils/src/pii.rs | crate: common_utils
use masking::{ExposeInterface, Secret, Strategy, WithType};
use crate::{
crypto::Encryptable,
errors::{self, ValidationError},
validation::{validate_email, validate_phone_number},
};
pub type SecretSerdeValue = Secret<serde_json::Value>;
fn expose(self) -> Secret<String, EmailStrategy> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/common_utils/src/pii.rs | crate: common_utils
use masking::{ExposeInterface, Secret, Strategy, WithType};
use crate::{
crypto::Encryptable,
errors::{self, ValidationError},
validation::{validate_email, validate_phone_number},
};
pub type SecretSerdeValue = Secret<serde_json::Value>;
fn from(item: Encryptable<Secret<String, EmailStrategy>>) -> Self {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/common_utils/src/pii.rs | crate: common_utils
use std::{convert::AsRef, fmt, ops, str::FromStr};
use masking::{ExposeInterface, Secret, Strategy, WithType};
fn fmt(val: &T, f: &mut fmt::Formatter<'_>) -> fmt::Result {
{
Some((a, b)) => write!(f, "{}@{}", "*".repeat(a.len()), b),<|fim_suffix|>
<|fim_middle|>
None => WithType::fmt(val, f),
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/common_utils/src/pii.rs | crate: common_utils
use std::{convert::AsRef, fmt, ops, str::FromStr};
fn fmt(value: &T, fmt: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/common_utils/src/pii.rs | crate: common_utils
use crate::{
crypto::Encryptable,
errors::{self, ValidationError},
validation::{validate_email, validate_phone_number},
};
fn deref_mut(&mut self) -> &mut Self::Target {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/common_utils/src/pii.rs | crate: common_utils
use std::{convert::AsRef, fmt, ops, str::FromStr};
use masking::{ExposeInterface, Secret, Strategy, WithType};
use crate::{
crypto::Encryptable,
errors::{self, ValidationError},
validation::{validate_email, validate_phone_number},
};
pub type SecretSerdeValue = Secret<serde_json::Value>;
fn from_str(phone_number: &str) -> Result<Self, Self::Err> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/common_utils/src/id_type.rs | crate: common_utils
/// Input contains invalid characters
AlphanumericIdError(AlphaNumericIdError),
}
impl From<AlphaNumericIdError> for LengthIdError {
fn from(alphanumeric_id_error: AlphaNumericIdError) -> Self {
Self::AlphanumericIdError(alphanumeric_id_error)
}
}
impl<const MAX_LENGTH: u8, const MIN_LENGTH: u8> LengthId<MAX_LENGTH, MIN_LENGTH> {
/// Generates new [MerchantReferenceId] from the given input string
pub fn from(input_string: Cow<'static, str>) -> Result<Self, LengthIdError> {
let trimmed_input_string = input_string.trim().to_string();
let length_of_input_string = u8::try_from(trimmed_input_string.len())
.map_err(|_| LengthIdError::MaxLengthViolated(MAX_LENGTH))?;
when(length_of_input_string > MAX_LENGTH, || {
Err(LengthIdError::MaxLengthViolated(MAX_LENGTH))
})?;
when(length_of_input_string < MIN_LENGTH, || {
Err(LengthIdError::MinLengthViolated(MIN_LENGTH))
})?;
/// Generates new [MerchantReferenceId] from the given input string
pub fn from(input_string: Cow<'static, str>) -> Result<Self, LengthIdError> {
{
Ok(valid_alphanumeric_id) => valid_alphanumeric_id,<|fim_suffix|>
<|fim_middle|>
Err(error) => Err(LengthIdError::AlphanumericIdError(error))?,
}
} | ast_fragments |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.