text
stringlengths 70
351k
| source
stringclasses 4
values |
|---|---|
<|meta_start|><|file|> hyperswitch/crates/diesel_models/src/query/gsm.rs<|crate|> diesel_models anchor=find kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/diesel_models/src/query/gsm.rs" role="context" start="15" end="33">
pub async fn find(
conn: &PgPooledConn,
connector: String,
flow: String,
sub_flow: String,
code: String,
message: String,
) -> StorageResult<Self> {
generics::generic_find_one::<<Self as HasTable>::Table, _, _>(
conn,
dsl::connector
.eq(connector)
.and(dsl::flow.eq(flow))
.and(dsl::sub_flow.eq(sub_flow))
.and(dsl::code.eq(code))
.and(dsl::message.eq(message)),
)
.await
}
<file_sep path="hyperswitch/crates/diesel_models/src/query/gsm.rs" role="context" start="14" end="14">
use diesel::{associations::HasTable, BoolExpressionMethods, ExpressionMethods};
use crate::{
errors, gsm::*, query::generics, schema::gateway_status_map::dsl, PgPooledConn, StorageResult,
};
<file_sep path="hyperswitch/crates/diesel_models/src/query/gsm.rs" role="context" start="48" end="79">
pub async fn update(
conn: &PgPooledConn,
connector: String,
flow: String,
sub_flow: String,
code: String,
message: String,
gsm: GatewayStatusMappingUpdate,
) -> StorageResult<Self> {
generics::generic_update_with_results::<
<Self as HasTable>::Table,
GatewayStatusMapperUpdateInternal,
_,
_,
>(
conn,
dsl::connector
.eq(connector)
.and(dsl::flow.eq(flow))
.and(dsl::sub_flow.eq(sub_flow))
.and(dsl::code.eq(code))
.and(dsl::message.eq(message)),
gsm.into(),
)
.await?
.first()
.cloned()
.ok_or_else(|| {
report!(errors::DatabaseError::NotFound)
.attach_printable("Error while updating gsm entry")
})
}
<file_sep path="hyperswitch/crates/diesel_models/src/query/gsm.rs" role="context" start="35" end="46">
pub async fn retrieve_decision(
conn: &PgPooledConn,
connector: String,
flow: String,
sub_flow: String,
code: String,
message: String,
) -> StorageResult<String> {
Self::find(conn, connector, flow, sub_flow, code, message)
.await
.map(|item| item.decision)
}
<file_sep path="hyperswitch/crates/diesel_models/src/query/gsm.rs" role="context" start="9" end="11">
pub async fn insert(self, conn: &PgPooledConn) -> StorageResult<GatewayStatusMap> {
generics::generic_insert(conn, self).await
}
<file_sep path="hyperswitch/crates/diesel_models/src/lib.rs" role="context" start="66" end="66">
pub type PgPooledConn = async_bb8_diesel::Connection<diesel::PgConnection>;
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/diesel_models/src/query/generics.rs<|crate|> diesel_models anchor=generic_find_by_id_optional kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/diesel_models/src/query/generics.rs" role="context" start="350" end="363">
pub async fn generic_find_by_id_optional<T, Pk, R>(
conn: &PgPooledConn,
id: Pk,
) -> StorageResult<Option<R>>
where
T: FindDsl<Pk> + HasTable<Table = T> + LimitDsl + Table + 'static,
<T as HasTable>::Table: FindDsl<Pk>,
Find<T, Pk>: LimitDsl + QueryFragment<Pg> + RunQueryDsl<PgConnection> + Send + 'static,
Limit<Find<T, Pk>>: LoadQuery<'static, PgConnection, R>,
Pk: Clone + Debug,
R: Send + 'static,
{
to_optional(generic_find_by_id_core::<T, _, _>(conn, id).await)
}
<file_sep path="hyperswitch/crates/diesel_models/src/query/generics.rs" role="context" start="349" end="349">
use std::fmt::Debug;
use diesel::{
associations::HasTable,
debug_query,
dsl::{Find, Limit},
helper_types::{Filter, IntoBoxed},
insertable::CanInsertInSingleQuery,
pg::{Pg, PgConnection},
query_builder::{
AsChangeset, AsQuery, DeleteStatement, InsertStatement, IntoUpdateTarget, QueryFragment,
QueryId, UpdateStatement,
},
query_dsl::{
methods::{BoxedDsl, FilterDsl, FindDsl, LimitDsl, OffsetDsl, OrderDsl},
LoadQuery, RunQueryDsl,
},
result::Error as DieselError,
Expression, Insertable, QueryDsl, QuerySource, Table,
};
use crate::{errors, PgPooledConn, StorageResult};
<file_sep path="hyperswitch/crates/diesel_models/src/query/generics.rs" role="context" start="383" end="390">
pub async fn generic_find_one<T, P, R>(conn: &PgPooledConn, predicate: P) -> StorageResult<R>
where
T: FilterDsl<P> + HasTable<Table = T> + Table + 'static,
Filter<T, P>: LoadQuery<'static, PgConnection, R> + QueryFragment<Pg> + Send + 'static,
R: Send + 'static,
{
generic_find_one_core::<T, _, _>(conn, predicate).await
}
<file_sep path="hyperswitch/crates/diesel_models/src/query/generics.rs" role="context" start="365" end="381">
async fn generic_find_one_core<T, P, R>(conn: &PgPooledConn, predicate: P) -> StorageResult<R>
where
T: FilterDsl<P> + HasTable<Table = T> + Table + 'static,
Filter<T, P>: LoadQuery<'static, PgConnection, R> + QueryFragment<Pg> + Send + 'static,
R: Send + 'static,
{
let query = <T as HasTable>::table().filter(predicate);
logger::debug!(query = %debug_query::<Pg, _>(&query).to_string());
track_database_call::<T, _, _>(query.get_result_async(conn), DatabaseOperation::FindOne)
.await
.map_err(|err| match err {
DieselError::NotFound => report!(err).change_context(errors::DatabaseError::NotFound),
_ => report!(err).change_context(errors::DatabaseError::Others),
})
.attach_printable("Error finding record by predicate")
}
<file_sep path="hyperswitch/crates/diesel_models/src/query/generics.rs" role="context" start="339" end="348">
pub async fn generic_find_by_id<T, Pk, R>(conn: &PgPooledConn, id: Pk) -> StorageResult<R>
where
T: FindDsl<Pk> + HasTable<Table = T> + LimitDsl + Table + 'static,
Find<T, Pk>: LimitDsl + QueryFragment<Pg> + RunQueryDsl<PgConnection> + Send + 'static,
Limit<Find<T, Pk>>: LoadQuery<'static, PgConnection, R>,
Pk: Clone + Debug,
R: Send + 'static,
{
generic_find_by_id_core::<T, _, _>(conn, id).await
}
<file_sep path="hyperswitch/crates/diesel_models/src/query/generics.rs" role="context" start="315" end="337">
async fn generic_find_by_id_core<T, Pk, R>(conn: &PgPooledConn, id: Pk) -> StorageResult<R>
where
T: FindDsl<Pk> + HasTable<Table = T> + LimitDsl + Table + 'static,
Find<T, Pk>: LimitDsl + QueryFragment<Pg> + RunQueryDsl<PgConnection> + Send + 'static,
Limit<Find<T, Pk>>: LoadQuery<'static, PgConnection, R>,
Pk: Clone + Debug,
R: Send + 'static,
{
let query = <T as HasTable>::table().find(id.to_owned());
logger::debug!(query = %debug_query::<Pg, _>(&query).to_string());
match track_database_call::<T, _, _>(query.first_async(conn), DatabaseOperation::FindOne).await
{
Ok(value) => Ok(value),
Err(err) => match err {
DieselError::NotFound => {
Err(report!(err)).change_context(errors::DatabaseError::NotFound)
}
_ => Err(report!(err)).change_context(errors::DatabaseError::Others),
},
}
.attach_printable_lazy(|| format!("Error finding record by primary key: {id:?}"))
}
<file_sep path="hyperswitch/crates/diesel_models/src/query/generics.rs" role="context" start="446" end="454">
fn to_optional<T>(arg: StorageResult<T>) -> StorageResult<Option<T>> {
match arg {
Ok(value) => Ok(Some(value)),
Err(err) => match err.current_context() {
errors::DatabaseError::NotFound => Ok(None),
_ => Err(err),
},
}
}
<file_sep path="hyperswitch/crates/diesel_models/src/lib.rs" role="context" start="66" end="66">
pub type PgPooledConn = async_bb8_diesel::Connection<diesel::PgConnection>;
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/diesel_models/src/query/user_role.rs<|crate|> diesel_models anchor=find_by_user_id_tenant_id_org_id_merchant_id_profile_id kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/diesel_models/src/query/user_role.rs" role="context" start="78" end="100">
pub async fn find_by_user_id_tenant_id_org_id_merchant_id_profile_id(
conn: &PgPooledConn,
user_id: String,
tenant_id: id_type::TenantId,
org_id: id_type::OrganizationId,
merchant_id: id_type::MerchantId,
profile_id: id_type::ProfileId,
version: UserRoleVersion,
) -> StorageResult<Self> {
let check_lineage = Self::check_user_in_lineage(
tenant_id,
Some(org_id),
Some(merchant_id),
Some(profile_id),
);
let predicate = dsl::user_id
.eq(user_id)
.and(check_lineage)
.and(dsl::version.eq(version));
generics::generic_find_one::<<Self as HasTable>::Table, _, _>(conn, predicate).await
}
<file_sep path="hyperswitch/crates/diesel_models/src/query/user_role.rs" role="context" start="77" end="77">
use common_utils::id_type;
use diesel::{
associations::HasTable,
debug_query,
pg::Pg,
result::Error as DieselError,
sql_types::{Bool, Nullable},
BoolExpressionMethods, ExpressionMethods, QueryDsl,
};
use crate::{
enums::{UserRoleVersion, UserStatus},
errors,
query::generics,
schema::user_roles::dsl,
user_role::*,
PgPooledConn, StorageResult,
};
<file_sep path="hyperswitch/crates/diesel_models/src/query/user_role.rs" role="context" start="157" end="180">
pub async fn delete_by_user_id_tenant_id_org_id_merchant_id_profile_id(
conn: &PgPooledConn,
user_id: String,
tenant_id: id_type::TenantId,
org_id: id_type::OrganizationId,
merchant_id: id_type::MerchantId,
profile_id: id_type::ProfileId,
version: UserRoleVersion,
) -> StorageResult<Self> {
let check_lineage = Self::check_user_in_lineage(
tenant_id,
Some(org_id),
Some(merchant_id),
Some(profile_id),
);
let predicate = dsl::user_id
.eq(user_id)
.and(check_lineage)
.and(dsl::version.eq(version));
generics::generic_delete_one_with_result::<<Self as HasTable>::Table, _, _>(conn, predicate)
.await
}
<file_sep path="hyperswitch/crates/diesel_models/src/query/user_role.rs" role="context" start="103" end="155">
pub async fn update_by_user_id_tenant_id_org_id_merchant_id_profile_id(
conn: &PgPooledConn,
user_id: String,
tenant_id: id_type::TenantId,
org_id: id_type::OrganizationId,
merchant_id: Option<id_type::MerchantId>,
profile_id: Option<id_type::ProfileId>,
update: UserRoleUpdate,
version: UserRoleVersion,
) -> StorageResult<Self> {
let check_lineage = dsl::tenant_id
.eq(tenant_id.clone())
.and(dsl::org_id.is_null())
.and(dsl::merchant_id.is_null())
.and(dsl::profile_id.is_null())
.or(
// Org-level condition
dsl::tenant_id
.eq(tenant_id.clone())
.and(dsl::org_id.eq(org_id.clone()))
.and(dsl::merchant_id.is_null())
.and(dsl::profile_id.is_null()),
)
.or(
// Merchant-level condition
dsl::tenant_id
.eq(tenant_id.clone())
.and(dsl::org_id.eq(org_id.clone()))
.and(dsl::merchant_id.eq(merchant_id.clone()))
.and(dsl::profile_id.is_null()),
)
.or(
// Profile-level condition
dsl::tenant_id
.eq(tenant_id)
.and(dsl::org_id.eq(org_id))
.and(dsl::merchant_id.eq(merchant_id))
.and(dsl::profile_id.eq(profile_id)),
);
let predicate = dsl::user_id
.eq(user_id)
.and(check_lineage)
.and(dsl::version.eq(version));
generics::generic_update_with_unique_predicate_get_result::<
<Self as HasTable>::Table,
UserRoleUpdateInternal,
_,
_,
>(conn, predicate, update.into())
.await
}
<file_sep path="hyperswitch/crates/diesel_models/src/query/user_role.rs" role="context" start="29" end="76">
fn check_user_in_lineage(
tenant_id: id_type::TenantId,
org_id: Option<id_type::OrganizationId>,
merchant_id: Option<id_type::MerchantId>,
profile_id: Option<id_type::ProfileId>,
) -> Box<
dyn diesel::BoxableExpression<<Self as HasTable>::Table, Pg, SqlType = Nullable<Bool>>
+ 'static,
> {
// Checking in user roles, for a user in token hierarchy, only one of the relations will be true:
// either tenant level, org level, merchant level, or profile level
// Tenant-level: (tenant_id = ? && org_id = null && merchant_id = null && profile_id = null)
// Org-level: (org_id = ? && merchant_id = null && profile_id = null)
// Merchant-level: (org_id = ? && merchant_id = ? && profile_id = null)
// Profile-level: (org_id = ? && merchant_id = ? && profile_id = ?)
Box::new(
// Tenant-level condition
dsl::tenant_id
.eq(tenant_id.clone())
.and(dsl::org_id.is_null())
.and(dsl::merchant_id.is_null())
.and(dsl::profile_id.is_null())
.or(
// Org-level condition
dsl::tenant_id
.eq(tenant_id.clone())
.and(dsl::org_id.eq(org_id.clone()))
.and(dsl::merchant_id.is_null())
.and(dsl::profile_id.is_null()),
)
.or(
// Merchant-level condition
dsl::tenant_id
.eq(tenant_id.clone())
.and(dsl::org_id.eq(org_id.clone()))
.and(dsl::merchant_id.eq(merchant_id.clone()))
.and(dsl::profile_id.is_null()),
)
.or(
// Profile-level condition
dsl::tenant_id
.eq(tenant_id)
.and(dsl::org_id.eq(org_id))
.and(dsl::merchant_id.eq(merchant_id))
.and(dsl::profile_id.eq(profile_id)),
),
)
}
<file_sep path="hyperswitch/crates/diesel_models/src/query/user_role.rs" role="context" start="23" end="25">
pub async fn insert(self, conn: &PgPooledConn) -> StorageResult<UserRole> {
generics::generic_insert(conn, self).await
}
<file_sep path="hyperswitch/crates/diesel_models/src/lib.rs" role="context" start="66" end="66">
pub type PgPooledConn = async_bb8_diesel::Connection<diesel::PgConnection>;
<file_sep path="hyperswitch/crates/api_models/src/admin.rs" role="context" start="698" end="700">
pub struct MerchantId {
pub merchant_id: id_type::MerchantId,
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/diesel_models/src/query/user_role.rs<|crate|> diesel_models anchor=delete_by_user_id_tenant_id_org_id_merchant_id_profile_id kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/diesel_models/src/query/user_role.rs" role="context" start="157" end="180">
pub async fn delete_by_user_id_tenant_id_org_id_merchant_id_profile_id(
conn: &PgPooledConn,
user_id: String,
tenant_id: id_type::TenantId,
org_id: id_type::OrganizationId,
merchant_id: id_type::MerchantId,
profile_id: id_type::ProfileId,
version: UserRoleVersion,
) -> StorageResult<Self> {
let check_lineage = Self::check_user_in_lineage(
tenant_id,
Some(org_id),
Some(merchant_id),
Some(profile_id),
);
let predicate = dsl::user_id
.eq(user_id)
.and(check_lineage)
.and(dsl::version.eq(version));
generics::generic_delete_one_with_result::<<Self as HasTable>::Table, _, _>(conn, predicate)
.await
}
<file_sep path="hyperswitch/crates/diesel_models/src/query/user_role.rs" role="context" start="156" end="156">
use common_utils::id_type;
use diesel::{
associations::HasTable,
debug_query,
pg::Pg,
result::Error as DieselError,
sql_types::{Bool, Nullable},
BoolExpressionMethods, ExpressionMethods, QueryDsl,
};
use crate::{
enums::{UserRoleVersion, UserStatus},
errors,
query::generics,
schema::user_roles::dsl,
user_role::*,
PgPooledConn, StorageResult,
};
<file_sep path="hyperswitch/crates/diesel_models/src/query/user_role.rs" role="context" start="246" end="296">
pub async fn generic_user_roles_list_for_org_and_extra(
conn: &PgPooledConn,
user_id: Option<String>,
tenant_id: id_type::TenantId,
org_id: id_type::OrganizationId,
merchant_id: Option<id_type::MerchantId>,
profile_id: Option<id_type::ProfileId>,
version: Option<UserRoleVersion>,
limit: Option<u32>,
) -> StorageResult<Vec<Self>> {
let mut query = <Self as HasTable>::table()
.filter(dsl::org_id.eq(org_id).and(dsl::tenant_id.eq(tenant_id)))
.into_boxed();
if let Some(user_id) = user_id {
query = query.filter(dsl::user_id.eq(user_id));
}
if let Some(merchant_id) = merchant_id {
query = query.filter(dsl::merchant_id.eq(merchant_id));
}
if let Some(profile_id) = profile_id {
query = query.filter(dsl::profile_id.eq(profile_id));
}
if let Some(version) = version {
query = query.filter(dsl::version.eq(version));
}
if let Some(limit) = limit {
query = query.limit(limit.into());
}
router_env::logger::debug!(query = %debug_query::<Pg,_>(&query).to_string());
match generics::db_metrics::track_database_call::<Self, _, _>(
query.get_results_async(conn),
generics::db_metrics::DatabaseOperation::Filter,
)
.await
{
Ok(value) => Ok(value),
Err(err) => match err {
DieselError::NotFound => {
Err(report!(err)).change_context(errors::DatabaseError::NotFound)
}
_ => Err(report!(err)).change_context(errors::DatabaseError::Others),
},
}
}
<file_sep path="hyperswitch/crates/diesel_models/src/query/user_role.rs" role="context" start="183" end="243">
pub async fn generic_user_roles_list_for_user(
conn: &PgPooledConn,
user_id: String,
tenant_id: id_type::TenantId,
org_id: Option<id_type::OrganizationId>,
merchant_id: Option<id_type::MerchantId>,
profile_id: Option<id_type::ProfileId>,
entity_id: Option<String>,
status: Option<UserStatus>,
version: Option<UserRoleVersion>,
limit: Option<u32>,
) -> StorageResult<Vec<Self>> {
let mut query = <Self as HasTable>::table()
.filter(dsl::user_id.eq(user_id).and(dsl::tenant_id.eq(tenant_id)))
.into_boxed();
if let Some(org_id) = org_id {
query = query.filter(dsl::org_id.eq(org_id));
}
if let Some(merchant_id) = merchant_id {
query = query.filter(dsl::merchant_id.eq(merchant_id));
}
if let Some(profile_id) = profile_id {
query = query.filter(dsl::profile_id.eq(profile_id));
}
if let Some(entity_id) = entity_id {
query = query.filter(dsl::entity_id.eq(entity_id));
}
if let Some(version) = version {
query = query.filter(dsl::version.eq(version));
}
if let Some(status) = status {
query = query.filter(dsl::status.eq(status));
}
if let Some(limit) = limit {
query = query.limit(limit.into());
}
router_env::logger::debug!(query = %debug_query::<Pg,_>(&query).to_string());
match generics::db_metrics::track_database_call::<Self, _, _>(
query.get_results_async(conn),
generics::db_metrics::DatabaseOperation::Filter,
)
.await
{
Ok(value) => Ok(value),
Err(err) => match err {
DieselError::NotFound => {
Err(report!(err)).change_context(errors::DatabaseError::NotFound)
}
_ => Err(report!(err)).change_context(errors::DatabaseError::Others),
},
}
}
<file_sep path="hyperswitch/crates/diesel_models/src/query/user_role.rs" role="context" start="103" end="155">
pub async fn update_by_user_id_tenant_id_org_id_merchant_id_profile_id(
conn: &PgPooledConn,
user_id: String,
tenant_id: id_type::TenantId,
org_id: id_type::OrganizationId,
merchant_id: Option<id_type::MerchantId>,
profile_id: Option<id_type::ProfileId>,
update: UserRoleUpdate,
version: UserRoleVersion,
) -> StorageResult<Self> {
let check_lineage = dsl::tenant_id
.eq(tenant_id.clone())
.and(dsl::org_id.is_null())
.and(dsl::merchant_id.is_null())
.and(dsl::profile_id.is_null())
.or(
// Org-level condition
dsl::tenant_id
.eq(tenant_id.clone())
.and(dsl::org_id.eq(org_id.clone()))
.and(dsl::merchant_id.is_null())
.and(dsl::profile_id.is_null()),
)
.or(
// Merchant-level condition
dsl::tenant_id
.eq(tenant_id.clone())
.and(dsl::org_id.eq(org_id.clone()))
.and(dsl::merchant_id.eq(merchant_id.clone()))
.and(dsl::profile_id.is_null()),
)
.or(
// Profile-level condition
dsl::tenant_id
.eq(tenant_id)
.and(dsl::org_id.eq(org_id))
.and(dsl::merchant_id.eq(merchant_id))
.and(dsl::profile_id.eq(profile_id)),
);
let predicate = dsl::user_id
.eq(user_id)
.and(check_lineage)
.and(dsl::version.eq(version));
generics::generic_update_with_unique_predicate_get_result::<
<Self as HasTable>::Table,
UserRoleUpdateInternal,
_,
_,
>(conn, predicate, update.into())
.await
}
<file_sep path="hyperswitch/crates/diesel_models/src/query/user_role.rs" role="context" start="78" end="100">
pub async fn find_by_user_id_tenant_id_org_id_merchant_id_profile_id(
conn: &PgPooledConn,
user_id: String,
tenant_id: id_type::TenantId,
org_id: id_type::OrganizationId,
merchant_id: id_type::MerchantId,
profile_id: id_type::ProfileId,
version: UserRoleVersion,
) -> StorageResult<Self> {
let check_lineage = Self::check_user_in_lineage(
tenant_id,
Some(org_id),
Some(merchant_id),
Some(profile_id),
);
let predicate = dsl::user_id
.eq(user_id)
.and(check_lineage)
.and(dsl::version.eq(version));
generics::generic_find_one::<<Self as HasTable>::Table, _, _>(conn, predicate).await
}
<file_sep path="hyperswitch/crates/diesel_models/src/query/user_role.rs" role="context" start="29" end="76">
fn check_user_in_lineage(
tenant_id: id_type::TenantId,
org_id: Option<id_type::OrganizationId>,
merchant_id: Option<id_type::MerchantId>,
profile_id: Option<id_type::ProfileId>,
) -> Box<
dyn diesel::BoxableExpression<<Self as HasTable>::Table, Pg, SqlType = Nullable<Bool>>
+ 'static,
> {
// Checking in user roles, for a user in token hierarchy, only one of the relations will be true:
// either tenant level, org level, merchant level, or profile level
// Tenant-level: (tenant_id = ? && org_id = null && merchant_id = null && profile_id = null)
// Org-level: (org_id = ? && merchant_id = null && profile_id = null)
// Merchant-level: (org_id = ? && merchant_id = ? && profile_id = null)
// Profile-level: (org_id = ? && merchant_id = ? && profile_id = ?)
Box::new(
// Tenant-level condition
dsl::tenant_id
.eq(tenant_id.clone())
.and(dsl::org_id.is_null())
.and(dsl::merchant_id.is_null())
.and(dsl::profile_id.is_null())
.or(
// Org-level condition
dsl::tenant_id
.eq(tenant_id.clone())
.and(dsl::org_id.eq(org_id.clone()))
.and(dsl::merchant_id.is_null())
.and(dsl::profile_id.is_null()),
)
.or(
// Merchant-level condition
dsl::tenant_id
.eq(tenant_id.clone())
.and(dsl::org_id.eq(org_id.clone()))
.and(dsl::merchant_id.eq(merchant_id.clone()))
.and(dsl::profile_id.is_null()),
)
.or(
// Profile-level condition
dsl::tenant_id
.eq(tenant_id)
.and(dsl::org_id.eq(org_id))
.and(dsl::merchant_id.eq(merchant_id))
.and(dsl::profile_id.eq(profile_id)),
),
)
}
<file_sep path="hyperswitch/crates/diesel_models/src/lib.rs" role="context" start="66" end="66">
pub type PgPooledConn = async_bb8_diesel::Connection<diesel::PgConnection>;
<file_sep path="hyperswitch/crates/api_models/src/admin.rs" role="context" start="698" end="700">
pub struct MerchantId {
pub merchant_id: id_type::MerchantId,
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/diesel_models/src/payout_attempt.rs<|crate|> diesel_models anchor=from kind=fn pack=symbol_neighborhood lang=rust role_window=k2 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/diesel_models/src/payout_attempt.rs" role="context" start="158" end="211">
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,
} => Self {
connector_payout_id,
status: Some(status),
error_message,
error_code,
is_eligible,
unified_code,
unified_message,
..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()
},
}
}
<file_sep path="hyperswitch/crates/diesel_models/src/payout_attempt.rs" role="context" start="215" end="256">
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,
} = 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),
..source
}
}
<file_sep path="hyperswitch/crates/diesel_models/src/payout_attempt.rs" role="context" start="134" end="154">
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,
}
}
<file_sep path="hyperswitch/crates/diesel_models/src/payout_attempt.rs" role="context" start="82" end="109">
pub enum PayoutAttemptUpdate {
StatusUpdate {
connector_payout_id: Option<String>,
status: storage_enums::PayoutStatus,
error_message: Option<String>,
error_code: Option<String>,
is_eligible: Option<bool>,
unified_code: Option<UnifiedCode>,
unified_message: Option<UnifiedMessage>,
},
PayoutTokenUpdate {
payout_token: String,
},
BusinessUpdate {
business_country: Option<storage_enums::CountryAlpha2>,
business_label: Option<String>,
address_id: Option<String>,
customer_id: Option<common_utils::id_type::CustomerId>,
},
UpdateRouting {
connector: String,
routing_info: Option<serde_json::Value>,
merchant_connector_id: Option<common_utils::id_type::MerchantConnectorAccountId>,
},
AdditionalPayoutMethodDataUpdate {
additional_payout_method_data: Option<payout_method_utils::AdditionalPayoutMethodData>,
},
}
<file_sep path="hyperswitch/postman/collection-dir/powertranz/Flow Testcases/Happy Cases/Scenario1-Create payment with confirm true/Payments - Create/event.test.js" role="context" start="61" end="78">
"INFO - Unable to assign variable {{client_secret}}, as jsonData.client_secret is undefined.",
);
}
// Response body should have value "succeeded" for "status"
if (jsonData?.status) {
pm.test(
"[POST]::/payments - Content check if value for 'status' matches 'succeeded'",
function () {
pm.expect(jsonData.status).to.eql("succeeded");
},
);
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/diesel_models/src/payment_method.rs<|crate|> diesel_models anchor=from_sql kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=1<|meta_end|>
<file_sep path="hyperswitch/crates/diesel_models/src/payment_method.rs" role="context" start="1117" end="1157">
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::<PaymentsMandateReference>(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,
})
}
<file_sep path="hyperswitch/crates/diesel_models/src/payment_method.rs" role="context" start="1116" end="1116">
use common_utils::{
encryption::Encryption,
errors::{CustomResult, ParsingError},
pii,
};
use diesel::{AsChangeset, Identifiable, Insertable, Queryable, Selectable};
use crate::{enums as storage_enums, schema::payment_methods};
use crate::{enums as storage_enums, schema_v2::payment_methods};
<file_sep path="hyperswitch/crates/diesel_models/src/payment_method.rs" role="context" start="1211" end="1216">
fn from(payment_reference: PaymentsMandateReference) -> Self {
Self {
payments: Some(payment_reference),
payouts: None,
}
}
<file_sep path="hyperswitch/crates/diesel_models/src/payment_method.rs" role="context" start="1166" end="1206">
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,
})
}
<file_sep path="hyperswitch/crates/diesel_models/src/payment_method.rs" role="context" start="1098" end="1108">
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())
}
<file_sep path="hyperswitch/crates/diesel_models/src/payment_method.rs" role="context" start="1079" end="1094">
pub fn insert_payment_token_reference_record(
&mut self,
connector_id: &common_utils::id_type::MerchantConnectorAccountId,
record: ConnectorTokenReferenceRecord,
) {
match self.payments {
Some(ref mut payments_reference) => {
payments_reference.insert(connector_id.clone(), record);
}
None => {
let mut payments_reference = HashMap::new();
payments_reference.insert(connector_id.clone(), record);
self.payments = Some(PaymentsTokenReference(payments_reference));
}
}
}
<file_sep path="hyperswitch/crates/diesel_models/src/payment_method.rs" role="context" start="961" end="963">
pub struct PaymentsMandateReference(
pub HashMap<common_utils::id_type::MerchantConnectorAccountId, PaymentsMandateReferenceRecord>,
);
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/diesel_models/src/payouts.rs<|crate|> diesel_models anchor=from kind=fn pack=symbol_neighborhood lang=rust role_window=k2 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/diesel_models/src/payouts.rs" role="context" start="165" end="218">
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()
},
}
}
<file_sep path="hyperswitch/crates/diesel_models/src/payouts.rs" role="context" start="222" end="264">
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
}
}
<file_sep path="hyperswitch/crates/diesel_models/src/payouts.rs" role="context" start="140" end="161">
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,
}
}
<file_sep path="hyperswitch/crates/diesel_models/src/payouts.rs" role="context" start="84" end="114">
pub enum PayoutsUpdate {
Update {
amount: MinorUnit,
destination_currency: storage_enums::Currency,
source_currency: storage_enums::Currency,
description: Option<String>,
recurring: bool,
auto_fulfill: bool,
return_url: Option<String>,
entity_type: storage_enums::PayoutEntityType,
metadata: Option<pii::SecretSerdeValue>,
profile_id: Option<common_utils::id_type::ProfileId>,
status: Option<storage_enums::PayoutStatus>,
confirm: Option<bool>,
payout_type: Option<storage_enums::PayoutType>,
address_id: Option<String>,
customer_id: Option<common_utils::id_type::CustomerId>,
},
PayoutMethodIdUpdate {
payout_method_id: String,
},
RecurringUpdate {
recurring: bool,
},
AttemptCountUpdate {
attempt_count: i16,
},
StatusUpdate {
status: storage_enums::PayoutStatus,
},
}
<file_sep path="hyperswitch/postman/collection-dir/powertranz/Flow Testcases/Happy Cases/Scenario1-Create payment with confirm true/Payments - Create/event.test.js" role="context" start="61" end="78">
"INFO - Unable to assign variable {{client_secret}}, as jsonData.client_secret is undefined.",
);
}
// Response body should have value "succeeded" for "status"
if (jsonData?.status) {
pm.test(
"[POST]::/payments - Content check if value for 'status' matches 'succeeded'",
function () {
pm.expect(jsonData.status).to.eql("succeeded");
},
);
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/diesel_models/src/mandate.rs<|crate|> diesel_models anchor=from kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/diesel_models/src/mandate.rs" role="context" start="209" end="238">
fn from(mandate_new: &MandateNew) -> Self {
Self {
mandate_id: mandate_new.mandate_id.clone(),
customer_id: mandate_new.customer_id.clone(),
merchant_id: mandate_new.merchant_id.clone(),
payment_method_id: mandate_new.payment_method_id.clone(),
mandate_status: mandate_new.mandate_status,
mandate_type: mandate_new.mandate_type,
customer_accepted_at: mandate_new.customer_accepted_at,
customer_ip_address: mandate_new.customer_ip_address.clone(),
customer_user_agent: mandate_new.customer_user_agent.clone(),
network_transaction_id: mandate_new.network_transaction_id.clone(),
previous_attempt_id: mandate_new.previous_attempt_id.clone(),
created_at: mandate_new
.created_at
.unwrap_or_else(common_utils::date_time::now),
mandate_amount: mandate_new.mandate_amount,
mandate_currency: mandate_new.mandate_currency,
amount_captured: mandate_new.amount_captured,
connector: mandate_new.connector.clone(),
connector_mandate_id: mandate_new.connector_mandate_id.clone(),
start_date: mandate_new.start_date,
end_date: mandate_new.end_date,
metadata: mandate_new.metadata.clone(),
connector_mandate_ids: mandate_new.connector_mandate_ids.clone(),
original_payment_id: mandate_new.original_payment_id.clone(),
merchant_connector_id: mandate_new.merchant_connector_id.clone(),
updated_by: mandate_new.updated_by.clone(),
}
}
<file_sep path="hyperswitch/crates/diesel_models/src/mandate.rs" role="context" start="208" end="208">
use common_utils::pii;
<file_sep path="hyperswitch/crates/diesel_models/src/mandate.rs" role="context" start="184" end="205">
pub fn apply_changeset(self, source: Mandate) -> Mandate {
let Self {
mandate_status,
amount_captured,
connector_mandate_ids,
connector_mandate_id,
payment_method_id,
original_payment_id,
updated_by,
} = self;
Mandate {
mandate_status: mandate_status.unwrap_or(source.mandate_status),
amount_captured: amount_captured.map_or(source.amount_captured, Some),
connector_mandate_ids: connector_mandate_ids.map_or(source.connector_mandate_ids, Some),
connector_mandate_id: connector_mandate_id.map_or(source.connector_mandate_id, Some),
payment_method_id: payment_method_id.unwrap_or(source.payment_method_id),
original_payment_id: original_payment_id.map_or(source.original_payment_id, Some),
updated_by: updated_by.map_or(source.updated_by, Some),
..source
}
}
<file_sep path="hyperswitch/crates/diesel_models/src/mandate.rs" role="context" start="141" end="180">
fn from(mandate_update: MandateUpdate) -> Self {
match mandate_update {
MandateUpdate::StatusUpdate { mandate_status } => Self {
mandate_status: Some(mandate_status),
connector_mandate_ids: None,
amount_captured: None,
connector_mandate_id: None,
payment_method_id: None,
original_payment_id: None,
updated_by: None,
},
MandateUpdate::CaptureAmountUpdate { amount_captured } => Self {
mandate_status: None,
amount_captured,
connector_mandate_ids: None,
connector_mandate_id: None,
payment_method_id: None,
original_payment_id: None,
updated_by: None,
},
MandateUpdate::ConnectorReferenceUpdate {
connector_mandate_ids,
} => Self {
connector_mandate_ids,
..Default::default()
},
MandateUpdate::ConnectorMandateIdUpdate {
connector_mandate_id,
connector_mandate_ids,
payment_method_id,
original_payment_id,
} => Self {
connector_mandate_id,
connector_mandate_ids,
payment_method_id: Some(payment_method_id),
original_payment_id,
..Default::default()
},
}
}
<file_sep path="hyperswitch/crates/diesel_models/src/mandate.rs" role="context" start="104" end="111">
pub fn convert_to_mandate_update(
self,
storage_scheme: MerchantStorageScheme,
) -> MandateUpdateInternal {
let mut updated_object = MandateUpdateInternal::from(self);
updated_object.updated_by = Some(storage_scheme.to_string());
updated_object
}
<file_sep path="hyperswitch/crates/diesel_models/src/mandate.rs" role="context" start="51" end="76">
pub struct MandateNew {
pub mandate_id: String,
pub customer_id: common_utils::id_type::CustomerId,
pub merchant_id: common_utils::id_type::MerchantId,
pub payment_method_id: String,
pub mandate_status: storage_enums::MandateStatus,
pub mandate_type: storage_enums::MandateType,
pub customer_accepted_at: Option<PrimitiveDateTime>,
pub customer_ip_address: Option<Secret<String, pii::IpAddress>>,
pub customer_user_agent: Option<String>,
pub network_transaction_id: Option<String>,
pub previous_attempt_id: Option<String>,
pub created_at: Option<PrimitiveDateTime>,
pub mandate_amount: Option<i64>,
pub mandate_currency: Option<storage_enums::Currency>,
pub amount_captured: Option<i64>,
pub connector: String,
pub connector_mandate_id: Option<String>,
pub start_date: Option<PrimitiveDateTime>,
pub end_date: Option<PrimitiveDateTime>,
pub metadata: Option<pii::SecretSerdeValue>,
pub connector_mandate_ids: Option<pii::SecretSerdeValue>,
pub original_payment_id: Option<common_utils::id_type::PaymentId>,
pub merchant_connector_id: Option<common_utils::id_type::MerchantConnectorAccountId>,
pub updated_by: Option<String>,
}
<file_sep path="hyperswitch/postman/collection-dir/powertranz/Flow Testcases/Happy Cases/Scenario1-Create payment with confirm true/Payments - Create/event.test.js" role="context" start="41" end="55">
pm.collectionVariables.set("mandate_id", jsonData.mandate_id);
console.log(
"- use {{mandate_id}} as collection variable for value",
jsonData.mandate_id,
);
} else {
console.log(
"INFO - Unable to assign variable {{mandate_id}}, as jsonData.mandate_id is undefined.",
);
}
// pm.collectionVariables - Set client_secret as variable for jsonData.client_secret
if (jsonData?.client_secret) {
pm.collectionVariables.set("client_secret", jsonData.client_secret);
console.log(
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/diesel_models/src/query/events.rs<|crate|> diesel_models anchor=count_initial_attempts_by_constraints kind=fn pack=symbol_neighborhood lang=rust role_window=k2 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/diesel_models/src/query/events.rs" role="context" start="269" end="313">
pub async fn count_initial_attempts_by_constraints(
conn: &PgPooledConn,
merchant_id: &common_utils::id_type::MerchantId,
profile_id: Option<common_utils::id_type::ProfileId>,
created_after: time::PrimitiveDateTime,
created_before: time::PrimitiveDateTime,
is_delivered: Option<bool>,
) -> StorageResult<i64> {
use async_bb8_diesel::AsyncRunQueryDsl;
use diesel::{debug_query, pg::Pg, QueryDsl};
use error_stack::ResultExt;
use router_env::logger;
use super::generics::db_metrics::{track_database_call, DatabaseOperation};
use crate::errors::DatabaseError;
let mut query = Self::table()
.count()
.filter(
dsl::event_id
.nullable()
.eq(dsl::initial_attempt_id) // Filter initial attempts only
.and(dsl::merchant_id.eq(merchant_id.to_owned())),
)
.into_boxed();
query = Self::apply_filters(
query,
profile_id,
(dsl::created_at, created_after, created_before),
None,
None,
is_delivered,
);
logger::debug!(query = %debug_query::<Pg, _>(&query).to_string());
track_database_call::<Self, _, _>(
query.get_result_async::<i64>(conn),
DatabaseOperation::Count,
)
.await
.change_context(DatabaseError::Others)
.attach_printable("Error counting events by constraints")
}
<file_sep path="hyperswitch/crates/diesel_models/src/query/events.rs" role="context" start="268" end="268">
use diesel::{
associations::HasTable, BoolExpressionMethods, ExpressionMethods, NullableExpressionMethods,
};
use super::generics;
use crate::{
events::{Event, EventNew, EventUpdateInternal},
schema::events::dsl,
PgPooledConn, StorageResult,
};
<file_sep path="hyperswitch/crates/diesel_models/src/query/events.rs" role="context" start="214" end="267">
fn apply_filters<T>(
mut query: T,
profile_id: Option<common_utils::id_type::ProfileId>,
(column, created_after, created_before): (
dsl::created_at,
time::PrimitiveDateTime,
time::PrimitiveDateTime,
),
limit: Option<i64>,
offset: Option<i64>,
is_delivered: Option<bool>,
) -> T
where
T: diesel::query_dsl::methods::LimitDsl<Output = T>
+ diesel::query_dsl::methods::OffsetDsl<Output = T>,
T: diesel::query_dsl::methods::FilterDsl<
diesel::dsl::GtEq<dsl::created_at, time::PrimitiveDateTime>,
Output = T,
>,
T: diesel::query_dsl::methods::FilterDsl<
diesel::dsl::LtEq<dsl::created_at, time::PrimitiveDateTime>,
Output = T,
>,
T: diesel::query_dsl::methods::FilterDsl<
diesel::dsl::Eq<dsl::business_profile_id, common_utils::id_type::ProfileId>,
Output = T,
>,
T: diesel::query_dsl::methods::FilterDsl<
diesel::dsl::Eq<dsl::is_overall_delivery_successful, bool>,
Output = T,
>,
{
if let Some(profile_id) = profile_id {
query = query.filter(dsl::business_profile_id.eq(profile_id));
}
query = query
.filter(column.ge(created_after))
.filter(column.le(created_before));
if let Some(limit) = limit {
query = query.limit(limit);
}
if let Some(offset) = offset {
query = query.offset(offset);
}
if let Some(is_delivered) = is_delivered {
query = query.filter(dsl::is_overall_delivery_successful.eq(is_delivered));
}
query
}
<file_sep path="hyperswitch/crates/diesel_models/src/query/events.rs" role="context" start="193" end="212">
pub async fn update_by_merchant_id_event_id(
conn: &PgPooledConn,
merchant_id: &common_utils::id_type::MerchantId,
event_id: &str,
event: EventUpdateInternal,
) -> StorageResult<Self> {
generics::generic_update_with_unique_predicate_get_result::<
<Self as HasTable>::Table,
_,
_,
_,
>(
conn,
dsl::merchant_id
.eq(merchant_id.to_owned())
.and(dsl::event_id.eq(event_id.to_owned())),
event,
)
.await
}
<file_sep path="hyperswitch/crates/diesel_models/src/query/generic_link.rs" role="context" start="126" end="126">
type Error = Report<errors::ParsingError>;
<file_sep path="hyperswitch/crates/api_models/src/admin.rs" role="context" start="698" end="700">
pub struct MerchantId {
pub merchant_id: id_type::MerchantId,
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/diesel_models/src/query/events.rs<|crate|> diesel_models anchor=list_initial_attempts_by_profile_id_constraints kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/diesel_models/src/query/events.rs" role="context" start="132" end="174">
pub async fn list_initial_attempts_by_profile_id_constraints(
conn: &PgPooledConn,
profile_id: &common_utils::id_type::ProfileId,
created_after: time::PrimitiveDateTime,
created_before: time::PrimitiveDateTime,
limit: Option<i64>,
offset: Option<i64>,
is_delivered: Option<bool>,
) -> StorageResult<Vec<Self>> {
use async_bb8_diesel::AsyncRunQueryDsl;
use diesel::{debug_query, pg::Pg, QueryDsl};
use error_stack::ResultExt;
use router_env::logger;
use super::generics::db_metrics::{track_database_call, DatabaseOperation};
use crate::errors::DatabaseError;
let mut query = Self::table()
.filter(
dsl::event_id
.nullable()
.eq(dsl::initial_attempt_id) // Filter initial attempts only
.and(dsl::business_profile_id.eq(profile_id.to_owned())),
)
.order(dsl::created_at.desc())
.into_boxed();
query = Self::apply_filters(
query,
None,
(dsl::created_at, created_after, created_before),
limit,
offset,
is_delivered,
);
logger::debug!(query = %debug_query::<Pg, _>(&query).to_string());
track_database_call::<Self, _, _>(query.get_results_async(conn), DatabaseOperation::Filter)
.await
.change_context(DatabaseError::Others) // Query returns empty Vec when no records are found
.attach_printable("Error filtering events by constraints")
}
<file_sep path="hyperswitch/crates/diesel_models/src/query/events.rs" role="context" start="131" end="131">
use diesel::{
associations::HasTable, BoolExpressionMethods, ExpressionMethods, NullableExpressionMethods,
};
use super::generics;
use crate::{
events::{Event, EventNew, EventUpdateInternal},
schema::events::dsl,
PgPooledConn, StorageResult,
};
<file_sep path="hyperswitch/crates/diesel_models/src/query/events.rs" role="context" start="193" end="212">
pub async fn update_by_merchant_id_event_id(
conn: &PgPooledConn,
merchant_id: &common_utils::id_type::MerchantId,
event_id: &str,
event: EventUpdateInternal,
) -> StorageResult<Self> {
generics::generic_update_with_unique_predicate_get_result::<
<Self as HasTable>::Table,
_,
_,
_,
>(
conn,
dsl::merchant_id
.eq(merchant_id.to_owned())
.and(dsl::event_id.eq(event_id.to_owned())),
event,
)
.await
}
<file_sep path="hyperswitch/crates/diesel_models/src/query/events.rs" role="context" start="176" end="191">
pub async fn list_by_profile_id_initial_attempt_id(
conn: &PgPooledConn,
profile_id: &common_utils::id_type::ProfileId,
initial_attempt_id: &str,
) -> StorageResult<Vec<Self>> {
generics::generic_filter::<<Self as HasTable>::Table, _, _, _>(
conn,
dsl::business_profile_id
.eq(profile_id.to_owned())
.and(dsl::initial_attempt_id.eq(initial_attempt_id.to_owned())),
None,
None,
Some(dsl::created_at.desc()),
)
.await
}
<file_sep path="hyperswitch/crates/diesel_models/src/query/events.rs" role="context" start="113" end="130">
pub async fn list_initial_attempts_by_profile_id_primary_object_id(
conn: &PgPooledConn,
profile_id: &common_utils::id_type::ProfileId,
primary_object_id: &str,
) -> StorageResult<Vec<Self>> {
generics::generic_filter::<<Self as HasTable>::Table, _, _, _>(
conn,
dsl::event_id
.nullable()
.eq(dsl::initial_attempt_id) // Filter initial attempts only
.and(dsl::business_profile_id.eq(profile_id.to_owned()))
.and(dsl::primary_object_id.eq(primary_object_id.to_owned())),
None,
None,
Some(dsl::created_at.desc()),
)
.await
}
<file_sep path="hyperswitch/crates/diesel_models/src/query/events.rs" role="context" start="96" end="111">
pub async fn list_by_merchant_id_initial_attempt_id(
conn: &PgPooledConn,
merchant_id: &common_utils::id_type::MerchantId,
initial_attempt_id: &str,
) -> StorageResult<Vec<Self>> {
generics::generic_filter::<<Self as HasTable>::Table, _, _, _>(
conn,
dsl::merchant_id
.eq(merchant_id.to_owned())
.and(dsl::initial_attempt_id.eq(initial_attempt_id.to_owned())),
None,
None,
Some(dsl::created_at.desc()),
)
.await
}
<file_sep path="hyperswitch/crates/diesel_models/src/query/events.rs" role="context" start="214" end="267">
fn apply_filters<T>(
mut query: T,
profile_id: Option<common_utils::id_type::ProfileId>,
(column, created_after, created_before): (
dsl::created_at,
time::PrimitiveDateTime,
time::PrimitiveDateTime,
),
limit: Option<i64>,
offset: Option<i64>,
is_delivered: Option<bool>,
) -> T
where
T: diesel::query_dsl::methods::LimitDsl<Output = T>
+ diesel::query_dsl::methods::OffsetDsl<Output = T>,
T: diesel::query_dsl::methods::FilterDsl<
diesel::dsl::GtEq<dsl::created_at, time::PrimitiveDateTime>,
Output = T,
>,
T: diesel::query_dsl::methods::FilterDsl<
diesel::dsl::LtEq<dsl::created_at, time::PrimitiveDateTime>,
Output = T,
>,
T: diesel::query_dsl::methods::FilterDsl<
diesel::dsl::Eq<dsl::business_profile_id, common_utils::id_type::ProfileId>,
Output = T,
>,
T: diesel::query_dsl::methods::FilterDsl<
diesel::dsl::Eq<dsl::is_overall_delivery_successful, bool>,
Output = T,
>,
{
if let Some(profile_id) = profile_id {
query = query.filter(dsl::business_profile_id.eq(profile_id));
}
query = query
.filter(column.ge(created_after))
.filter(column.le(created_before));
if let Some(limit) = limit {
query = query.limit(limit);
}
if let Some(offset) = offset {
query = query.offset(offset);
}
if let Some(is_delivered) = is_delivered {
query = query.filter(dsl::is_overall_delivery_successful.eq(is_delivered));
}
query
}
<file_sep path="hyperswitch/crates/diesel_models/src/query/generic_link.rs" role="context" start="126" end="126">
type Error = Report<errors::ParsingError>;
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/diesel_models/src/query/events.rs<|crate|> diesel_models anchor=list_initial_attempts_by_merchant_id_constraints kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/diesel_models/src/query/events.rs" role="context" start="52" end="94">
pub async fn list_initial_attempts_by_merchant_id_constraints(
conn: &PgPooledConn,
merchant_id: &common_utils::id_type::MerchantId,
created_after: time::PrimitiveDateTime,
created_before: time::PrimitiveDateTime,
limit: Option<i64>,
offset: Option<i64>,
is_delivered: Option<bool>,
) -> StorageResult<Vec<Self>> {
use async_bb8_diesel::AsyncRunQueryDsl;
use diesel::{debug_query, pg::Pg, QueryDsl};
use error_stack::ResultExt;
use router_env::logger;
use super::generics::db_metrics::{track_database_call, DatabaseOperation};
use crate::errors::DatabaseError;
let mut query = Self::table()
.filter(
dsl::event_id
.nullable()
.eq(dsl::initial_attempt_id) // Filter initial attempts only
.and(dsl::merchant_id.eq(merchant_id.to_owned())),
)
.order(dsl::created_at.desc())
.into_boxed();
query = Self::apply_filters(
query,
None,
(dsl::created_at, created_after, created_before),
limit,
offset,
is_delivered,
);
logger::debug!(query = %debug_query::<Pg, _>(&query).to_string());
track_database_call::<Self, _, _>(query.get_results_async(conn), DatabaseOperation::Filter)
.await
.change_context(DatabaseError::Others) // Query returns empty Vec when no records are found
.attach_printable("Error filtering events by constraints")
}
<file_sep path="hyperswitch/crates/diesel_models/src/query/events.rs" role="context" start="51" end="51">
use diesel::{
associations::HasTable, BoolExpressionMethods, ExpressionMethods, NullableExpressionMethods,
};
use super::generics;
use crate::{
events::{Event, EventNew, EventUpdateInternal},
schema::events::dsl,
PgPooledConn, StorageResult,
};
<file_sep path="hyperswitch/crates/diesel_models/src/query/events.rs" role="context" start="113" end="130">
pub async fn list_initial_attempts_by_profile_id_primary_object_id(
conn: &PgPooledConn,
profile_id: &common_utils::id_type::ProfileId,
primary_object_id: &str,
) -> StorageResult<Vec<Self>> {
generics::generic_filter::<<Self as HasTable>::Table, _, _, _>(
conn,
dsl::event_id
.nullable()
.eq(dsl::initial_attempt_id) // Filter initial attempts only
.and(dsl::business_profile_id.eq(profile_id.to_owned()))
.and(dsl::primary_object_id.eq(primary_object_id.to_owned())),
None,
None,
Some(dsl::created_at.desc()),
)
.await
}
<file_sep path="hyperswitch/crates/diesel_models/src/query/events.rs" role="context" start="96" end="111">
pub async fn list_by_merchant_id_initial_attempt_id(
conn: &PgPooledConn,
merchant_id: &common_utils::id_type::MerchantId,
initial_attempt_id: &str,
) -> StorageResult<Vec<Self>> {
generics::generic_filter::<<Self as HasTable>::Table, _, _, _>(
conn,
dsl::merchant_id
.eq(merchant_id.to_owned())
.and(dsl::initial_attempt_id.eq(initial_attempt_id.to_owned())),
None,
None,
Some(dsl::created_at.desc()),
)
.await
}
<file_sep path="hyperswitch/crates/diesel_models/src/query/events.rs" role="context" start="33" end="50">
pub async fn list_initial_attempts_by_merchant_id_primary_object_id(
conn: &PgPooledConn,
merchant_id: &common_utils::id_type::MerchantId,
primary_object_id: &str,
) -> StorageResult<Vec<Self>> {
generics::generic_filter::<<Self as HasTable>::Table, _, _, _>(
conn,
dsl::event_id
.nullable()
.eq(dsl::initial_attempt_id) // Filter initial attempts only
.and(dsl::merchant_id.eq(merchant_id.to_owned()))
.and(dsl::primary_object_id.eq(primary_object_id.to_owned())),
None,
None,
Some(dsl::created_at.desc()),
)
.await
}
<file_sep path="hyperswitch/crates/diesel_models/src/query/events.rs" role="context" start="19" end="31">
pub async fn find_by_merchant_id_event_id(
conn: &PgPooledConn,
merchant_id: &common_utils::id_type::MerchantId,
event_id: &str,
) -> StorageResult<Self> {
generics::generic_find_one::<<Self as HasTable>::Table, _, _>(
conn,
dsl::merchant_id
.eq(merchant_id.to_owned())
.and(dsl::event_id.eq(event_id.to_owned())),
)
.await
}
<file_sep path="hyperswitch/crates/diesel_models/src/query/events.rs" role="context" start="214" end="267">
fn apply_filters<T>(
mut query: T,
profile_id: Option<common_utils::id_type::ProfileId>,
(column, created_after, created_before): (
dsl::created_at,
time::PrimitiveDateTime,
time::PrimitiveDateTime,
),
limit: Option<i64>,
offset: Option<i64>,
is_delivered: Option<bool>,
) -> T
where
T: diesel::query_dsl::methods::LimitDsl<Output = T>
+ diesel::query_dsl::methods::OffsetDsl<Output = T>,
T: diesel::query_dsl::methods::FilterDsl<
diesel::dsl::GtEq<dsl::created_at, time::PrimitiveDateTime>,
Output = T,
>,
T: diesel::query_dsl::methods::FilterDsl<
diesel::dsl::LtEq<dsl::created_at, time::PrimitiveDateTime>,
Output = T,
>,
T: diesel::query_dsl::methods::FilterDsl<
diesel::dsl::Eq<dsl::business_profile_id, common_utils::id_type::ProfileId>,
Output = T,
>,
T: diesel::query_dsl::methods::FilterDsl<
diesel::dsl::Eq<dsl::is_overall_delivery_successful, bool>,
Output = T,
>,
{
if let Some(profile_id) = profile_id {
query = query.filter(dsl::business_profile_id.eq(profile_id));
}
query = query
.filter(column.ge(created_after))
.filter(column.le(created_before));
if let Some(limit) = limit {
query = query.limit(limit);
}
if let Some(offset) = offset {
query = query.offset(offset);
}
if let Some(is_delivered) = is_delivered {
query = query.filter(dsl::is_overall_delivery_successful.eq(is_delivered));
}
query
}
<file_sep path="hyperswitch/crates/diesel_models/src/query/generic_link.rs" role="context" start="126" end="126">
type Error = Report<errors::ParsingError>;
<file_sep path="hyperswitch/crates/api_models/src/admin.rs" role="context" start="698" end="700">
pub struct MerchantId {
pub merchant_id: id_type::MerchantId,
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/diesel_models/src/query/role.rs<|crate|> diesel_models anchor=generic_list_roles_by_entity_type kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/diesel_models/src/query/role.rs" role="context" start="162" end="220">
pub async fn generic_list_roles_by_entity_type(
conn: &PgPooledConn,
payload: ListRolesByEntityPayload,
is_lineage_data_required: bool,
tenant_id: id_type::TenantId,
org_id: id_type::OrganizationId,
) -> StorageResult<Vec<Self>> {
let mut query = <Self as HasTable>::table()
.into_boxed()
.filter(dsl::tenant_id.eq(tenant_id))
.filter(dsl::org_id.eq(org_id));
match payload {
ListRolesByEntityPayload::Organization => {
let entity_in_vec =
Self::get_entity_list(EntityType::Organization, is_lineage_data_required);
query = query.filter(dsl::entity_type.eq_any(entity_in_vec))
}
ListRolesByEntityPayload::Merchant(merchant_id) => {
let entity_in_vec =
Self::get_entity_list(EntityType::Merchant, is_lineage_data_required);
query = query
.filter(
dsl::scope
.eq(RoleScope::Organization)
.or(dsl::merchant_id.eq(merchant_id)),
)
.filter(dsl::entity_type.eq_any(entity_in_vec))
}
ListRolesByEntityPayload::Profile(merchant_id, profile_id) => {
let entity_in_vec =
Self::get_entity_list(EntityType::Profile, is_lineage_data_required);
query = query
.filter(
dsl::scope
.eq(RoleScope::Organization)
.or(dsl::scope
.eq(RoleScope::Merchant)
.and(dsl::merchant_id.eq(merchant_id.clone())))
.or(dsl::profile_id.eq(profile_id)),
)
.filter(dsl::entity_type.eq_any(entity_in_vec))
}
};
router_env::logger::debug!(query = %debug_query::<Pg,_>(&query).to_string());
match generics::db_metrics::track_database_call::<Self, _, _>(
query.get_results_async(conn),
generics::db_metrics::DatabaseOperation::Filter,
)
.await
{
Ok(value) => Ok(value),
Err(err) => Err(report!(err)).change_context(errors::DatabaseError::Others),
}
}
<file_sep path="hyperswitch/crates/diesel_models/src/query/role.rs" role="context" start="161" end="161">
use common_enums::EntityType;
use common_utils::id_type;
use diesel::{
associations::HasTable, debug_query, pg::Pg, result::Error as DieselError,
BoolExpressionMethods, ExpressionMethods, QueryDsl,
};
use error_stack::{report, ResultExt};
use crate::{
enums::RoleScope, errors, query::generics, role::*, schema::roles::dsl, PgPooledConn,
StorageResult,
};
<file_sep path="hyperswitch/crates/diesel_models/src/query/role.rs" role="context" start="115" end="160">
pub async fn generic_roles_list_for_org(
conn: &PgPooledConn,
tenant_id: id_type::TenantId,
org_id: id_type::OrganizationId,
merchant_id: Option<id_type::MerchantId>,
entity_type: Option<EntityType>,
limit: Option<u32>,
) -> StorageResult<Vec<Self>> {
let mut query = <Self as HasTable>::table()
.filter(dsl::tenant_id.eq(tenant_id).and(dsl::org_id.eq(org_id)))
.into_boxed();
if let Some(merchant_id) = merchant_id {
query = query.filter(
(dsl::merchant_id
.eq(merchant_id)
.and(dsl::scope.eq(RoleScope::Merchant)))
.or(dsl::scope.eq(RoleScope::Organization)),
);
}
if let Some(entity_type) = entity_type {
query = query.filter(dsl::entity_type.eq(entity_type))
}
if let Some(limit) = limit {
query = query.limit(limit.into());
}
router_env::logger::debug!(query = %debug_query::<Pg,_>(&query).to_string());
match generics::db_metrics::track_database_call::<Self, _, _>(
query.get_results_async(conn),
generics::db_metrics::DatabaseOperation::Filter,
)
.await
{
Ok(value) => Ok(value),
Err(err) => match err {
DieselError::NotFound => {
Err(report!(err)).change_context(errors::DatabaseError::NotFound)
}
_ => Err(report!(err)).change_context(errors::DatabaseError::Others),
},
}
}
<file_sep path="hyperswitch/crates/diesel_models/src/query/role.rs" role="context" start="106" end="112">
pub async fn delete_by_role_id(conn: &PgPooledConn, role_id: &str) -> StorageResult<Self> {
generics::generic_delete_one_with_result::<<Self as HasTable>::Table, _, _>(
conn,
dsl::role_id.eq(role_id.to_owned()),
)
.await
}
<file_sep path="hyperswitch/crates/diesel_models/src/query/role.rs" role="context" start="23" end="34">
fn get_entity_list(
current_entity: EntityType,
is_lineage_data_required: bool,
) -> Vec<EntityType> {
is_lineage_data_required
.then(|| {
EntityType::iter()
.filter(|variant| *variant <= current_entity)
.collect()
})
.unwrap_or(vec![current_entity])
}
<file_sep path="hyperswitch/crates/diesel_models/src/business_profile.rs" role="context" start="22" end="73">
pub struct Profile {
pub profile_id: common_utils::id_type::ProfileId,
pub merchant_id: common_utils::id_type::MerchantId,
pub profile_name: String,
pub created_at: time::PrimitiveDateTime,
pub modified_at: time::PrimitiveDateTime,
pub return_url: Option<String>,
pub enable_payment_response_hash: bool,
pub payment_response_hash_key: Option<String>,
pub redirect_to_merchant_with_http_post: bool,
pub webhook_details: Option<WebhookDetails>,
pub metadata: Option<pii::SecretSerdeValue>,
pub routing_algorithm: Option<serde_json::Value>,
pub intent_fulfillment_time: Option<i64>,
pub frm_routing_algorithm: Option<serde_json::Value>,
pub payout_routing_algorithm: Option<serde_json::Value>,
pub is_recon_enabled: bool,
#[diesel(deserialize_as = super::OptionalDieselArray<String>)]
pub applepay_verified_domains: Option<Vec<String>>,
pub payment_link_config: Option<BusinessPaymentLinkConfig>,
pub session_expiry: Option<i64>,
pub authentication_connector_details: Option<AuthenticationConnectorDetails>,
pub payout_link_config: Option<BusinessPayoutLinkConfig>,
pub is_extended_card_info_enabled: Option<bool>,
pub extended_card_info_config: Option<pii::SecretSerdeValue>,
pub is_connector_agnostic_mit_enabled: Option<bool>,
pub use_billing_as_payment_method_billing: Option<bool>,
pub collect_shipping_details_from_wallet_connector: Option<bool>,
pub collect_billing_details_from_wallet_connector: Option<bool>,
pub outgoing_webhook_custom_http_headers: Option<Encryption>,
pub always_collect_billing_details_from_wallet_connector: Option<bool>,
pub always_collect_shipping_details_from_wallet_connector: Option<bool>,
pub tax_connector_id: Option<common_utils::id_type::MerchantConnectorAccountId>,
pub is_tax_connector_enabled: Option<bool>,
pub version: common_enums::ApiVersion,
pub dynamic_routing_algorithm: Option<serde_json::Value>,
pub is_network_tokenization_enabled: bool,
pub is_auto_retries_enabled: Option<bool>,
pub max_auto_retries_enabled: Option<i16>,
pub always_request_extended_authorization:
Option<primitive_wrappers::AlwaysRequestExtendedAuthorization>,
pub is_click_to_pay_enabled: bool,
pub authentication_product_ids:
Option<common_types::payments::AuthenticationConnectorAccountMap>,
pub card_testing_guard_config: Option<CardTestingGuardConfig>,
pub card_testing_secret_key: Option<Encryption>,
pub is_clear_pan_retries_enabled: bool,
pub force_3ds_challenge: Option<bool>,
pub is_debit_routing_enabled: bool,
pub merchant_business_country: Option<common_enums::CountryAlpha2>,
pub id: Option<common_utils::id_type::ProfileId>,
}
<file_sep path="hyperswitch-card-vault/migrations/2023-10-21-104200_create-tables/up.sql" role="context" start="1" end="11">
-- Your SQL goes here
CREATE TABLE merchant (
id SERIAL,
tenant_id VARCHAR(255) NOT NULL,
merchant_id VARCHAR(255) NOT NULL,
enc_key BYTEA NOT NULL,
created_at TIMESTAMP NOT NULL DEFAULT now()::TIMESTAMP,
PRIMARY KEY (tenant_id, merchant_id)
);
<file_sep path="hyperswitch/crates/api_models/src/organization.rs" role="context" start="18" end="20">
pub struct OrganizationId {
pub organization_id: id_type::OrganizationId,
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/analytics/src/sqlx.rs<|crate|> analytics anchor=default kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=1<|meta_end|>
<file_sep path="hyperswitch/crates/analytics/src/sqlx.rs" role="context" start="43" end="54">
fn default() -> Self {
let database_url = format!(
"postgres://{}:{}@{}:{}/{}",
"db_user", "db_pass", "localhost", 5432, "hyperswitch_db"
);
Self {
#[allow(clippy::expect_used)]
pool: PgPoolOptions::new()
.connect_lazy(&database_url)
.expect("SQLX Pool Creation failed"),
}
}
<file_sep path="hyperswitch/crates/analytics/src/sqlx.rs" role="context" start="42" end="42">
use sqlx::{
postgres::{PgArgumentBuffer, PgPoolOptions, PgRow, PgTypeInfo, PgValueRef},
Decode, Encode,
Error::ColumnNotFound,
FromRow, Pool, Postgres, Row,
};
<file_sep path="hyperswitch/crates/analytics/src/sqlx.rs" role="context" start="111" end="116">
fn encode_by_ref(
&self,
buf: &mut PgArgumentBuffer,
) -> Result<sqlx::encode::IsNull, Box<(dyn std::error::Error + Send + Sync + 'static)>> {
<String as Encode<'q, Postgres>>::encode(self.0.to_string(), buf)
}
<file_sep path="hyperswitch/crates/analytics/src/sqlx.rs" role="context" start="58" end="67">
pub async fn from_conf(conf: &Database, schema: &str) -> Self {
let database_url = conf.get_database_url(schema);
#[allow(clippy::expect_used)]
let pool = PgPoolOptions::new()
.max_connections(conf.pool_size)
.acquire_timeout(std::time::Duration::from_secs(conf.connection_timeout))
.connect_lazy(&database_url)
.expect("SQLX Pool Creation failed");
Self { pool }
}
<file_sep path="hyperswitch/crates/analytics/src/sqlx.rs" role="context" start="1014" end="1034">
fn from_row(row: &'a PgRow) -> sqlx::Result<Self> {
let frm_name: Option<String> = row.try_get("frm_name").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let frm_status: Option<DBEnumWrapper<FraudCheckStatus>> =
row.try_get("frm_status").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let frm_transaction_type: Option<DBEnumWrapper<FrmTransactionType>> =
row.try_get("frm_transaction_type").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
Ok(Self {
frm_name,
frm_status,
frm_transaction_type,
})
}
<file_sep path="hyperswitch/crates/analytics/src/sqlx.rs" role="context" start="380" end="419">
fn from_row(row: &'a PgRow) -> sqlx::Result<Self> {
let frm_name: Option<String> = row.try_get("frm_name").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let frm_status: Option<DBEnumWrapper<FraudCheckStatus>> =
row.try_get("frm_status").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let frm_transaction_type: Option<DBEnumWrapper<FrmTransactionType>> =
row.try_get("frm_transaction_type").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let total: Option<bigdecimal::BigDecimal> = row.try_get("total").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let count: Option<i64> = row.try_get("count").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
// Removing millisecond precision to get accurate diffs against clickhouse
let start_bucket: Option<PrimitiveDateTime> = row
.try_get::<Option<PrimitiveDateTime>, _>("start_bucket")?
.and_then(|dt| dt.replace_millisecond(0).ok());
let end_bucket: Option<PrimitiveDateTime> = row
.try_get::<Option<PrimitiveDateTime>, _>("end_bucket")?
.and_then(|dt| dt.replace_millisecond(0).ok());
Ok(Self {
frm_name,
frm_status,
frm_transaction_type,
total,
count,
start_bucket,
end_bucket,
})
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/analytics/src/opensearch.rs<|crate|> analytics anchor=new kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=1<|meta_end|>
<file_sep path="hyperswitch/crates/analytics/src/opensearch.rs" role="context" start="485" end="503">
pub fn new(query_type: OpenSearchQuery, query: String, search_params: Vec<AuthInfo>) -> Self {
Self {
query_type,
query,
search_params,
offset: Default::default(),
count: Default::default(),
filters: Default::default(),
time_range: Default::default(),
case_sensitive_fields: HashSet::from([
"customer_email.keyword",
"search_tags.keyword",
"card_last_4.keyword",
"payment_id.keyword",
"amount",
"customer_id.keyword",
]),
}
}
<file_sep path="hyperswitch/crates/analytics/src/opensearch.rs" role="context" start="484" end="484">
use std::collections::HashSet;
use super::{health_check::HealthCheck, query::QueryResult, types::QueryExecutionError};
use crate::{enums::AuthInfo, query::QueryBuildingError};
<file_sep path="hyperswitch/crates/analytics/src/opensearch.rs" role="context" start="511" end="514">
pub fn set_time_range(&mut self, time_range: OpensearchTimeRange) -> QueryResult<()> {
self.time_range = Some(time_range);
Ok(())
}
<file_sep path="hyperswitch/crates/analytics/src/opensearch.rs" role="context" start="505" end="509">
pub fn set_offset_n_count(&mut self, offset: i64, count: i64) -> QueryResult<()> {
self.offset = Some(offset);
self.count = Some(count);
Ok(())
}
<file_sep path="hyperswitch/crates/analytics/src/opensearch.rs" role="context" start="433" end="451">
pub fn validate(&self) -> Result<(), ApplicationError> {
use common_utils::{ext_traits::ConfigExt, fp_utils::when};
if !self.enabled {
return Ok(());
}
when(self.host.is_default_or_empty(), || {
Err(ApplicationError::InvalidConfigurationValueError(
"Opensearch host must not be empty".into(),
))
})?;
self.indexes.validate()?;
self.auth.validate()?;
Ok(())
}
<file_sep path="hyperswitch/crates/analytics/src/opensearch.rs" role="context" start="422" end="431">
pub async fn get_opensearch_client(&self) -> StorageResult<Option<OpenSearchClient>> {
if !self.enabled {
return Ok(None);
}
Ok(Some(
OpenSearchClient::create(self)
.await
.change_context(StorageError::InitializationError)?,
))
}
<file_sep path="hyperswitch/crates/analytics/src/opensearch.rs" role="context" start="202" end="234">
pub async fn create(conf: &OpenSearchConfig) -> CustomResult<Self, OpenSearchError> {
let url = Url::parse(&conf.host).map_err(|_| OpenSearchError::ConnectionError)?;
let transport = match &conf.auth {
OpenSearchAuth::Basic { username, password } => {
let credentials = Credentials::Basic(username.clone(), password.clone());
TransportBuilder::new(SingleNodeConnectionPool::new(url))
.cert_validation(CertificateValidation::None)
.auth(credentials)
.build()
.map_err(|_| OpenSearchError::ConnectionError)?
}
OpenSearchAuth::Aws { region } => {
let region_provider = RegionProviderChain::first_try(Region::new(region.clone()));
let sdk_config = aws_config::from_env().region(region_provider).load().await;
let conn_pool = SingleNodeConnectionPool::new(url);
TransportBuilder::new(conn_pool)
.auth(
sdk_config
.clone()
.try_into()
.map_err(|_| OpenSearchError::ConnectionError)?,
)
.service_name("es")
.build()
.map_err(|_| OpenSearchError::ConnectionError)?
}
};
Ok(Self {
transport: transport.clone(),
client: OpenSearch::new(transport),
indexes: conf.indexes.clone(),
})
}
<file_sep path="hyperswitch/crates/analytics/src/opensearch.rs" role="context" start="537" end="577">
pub fn build_filter_array(
&self,
case_sensitive_filters: Vec<&(String, Vec<Value>)>,
index: SearchIndex,
) -> Vec<Value> {
let mut filter_array = Vec::new();
if !self.query.is_empty() {
filter_array.push(json!({
"multi_match": {
"type": "phrase",
"query": self.query,
"lenient": true
}
}));
}
let case_sensitive_json_filters = case_sensitive_filters
.into_iter()
.map(|(k, v)| {
let key = if *k == "amount" {
self.get_amount_field(index).to_string()
} else {
k.clone()
};
json!({"terms": {key: v}})
})
.collect::<Vec<Value>>();
filter_array.extend(case_sensitive_json_filters);
if let Some(ref time_range) = self.time_range {
let range = json!(time_range);
filter_array.push(json!({
"range": {
"@timestamp": range
}
}));
}
filter_array
}
<file_sep path="hyperswitch/crates/analytics/src/opensearch.rs" role="context" start="79" end="98">
fn default() -> Self {
Self {
host: "https://localhost:9200".to_string(),
auth: OpenSearchAuth::Basic {
username: "admin".to_string(),
password: "admin".to_string(),
},
indexes: OpenSearchIndexes {
payment_attempts: "hyperswitch-payment-attempt-events".to_string(),
payment_intents: "hyperswitch-payment-intent-events".to_string(),
refunds: "hyperswitch-refund-events".to_string(),
disputes: "hyperswitch-dispute-events".to_string(),
sessionizer_payment_attempts: "sessionizer-payment-attempt-events".to_string(),
sessionizer_payment_intents: "sessionizer-payment-intent-events".to_string(),
sessionizer_refunds: "sessionizer-refund-events".to_string(),
sessionizer_disputes: "sessionizer-dispute-events".to_string(),
},
enabled: false,
}
}
<file_sep path="hyperswitch/crates/analytics/src/opensearch.rs" role="context" start="61" end="66">
fn from(time_range: TimeRange) -> Self {
Self {
gte: time_range.start_time,
lte: time_range.end_time,
}
}
<file_sep path="hyperswitch/crates/analytics/src/opensearch.rs" role="context" start="467" end="470">
pub enum OpenSearchQuery {
Msearch(Vec<SearchIndex>),
Search(SearchIndex),
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/analytics/src/query.rs<|crate|> analytics anchor=default kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=1<|meta_end|>
<file_sep path="hyperswitch/crates/analytics/src/query.rs" role="context" start="377" end="379">
fn default() -> Self {
Self::NestedFilter(FilterCombinator::default(), Vec::new())
}
<file_sep path="hyperswitch/crates/analytics/src/query.rs" role="context" start="428" end="430">
fn to_sql(&self, _table_engine: &TableEngine) -> error_stack::Result<String, ParsingError> {
Ok(self.get_string_repr().to_owned())
}
<file_sep path="hyperswitch/crates/analytics/src/query.rs" role="context" start="383" end="400">
fn to_sql(&self, table_engine: &TableEngine) -> error_stack::Result<String, ParsingError> {
Ok(match self {
Self::Plain(l, op, r) => filter_type_to_sql(l, *op, r),
Self::NestedFilter(operator, filters) => {
format!(
"( {} )",
filters
.iter()
.map(|f| <Self as ToSql<T>>::to_sql(f, table_engine))
.collect::<Result<Vec<String>, _>>()?
.join(
<FilterCombinator as ToSql<T>>::to_sql(operator, table_engine)?
.as_ref()
)
)
}
})
}
<file_sep path="hyperswitch/crates/analytics/src/query.rs" role="context" start="361" end="367">
fn to_sql(&self, _table_engine: &TableEngine) -> error_stack::Result<String, ParsingError> {
Ok(match self {
Self::And => " AND ",
Self::Or => " OR ",
}
.to_owned())
}
<file_sep path="hyperswitch/crates/analytics/src/query.rs" role="context" start="348" end="350">
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f, "LIMIT {} BY {}", self.limit, self.columns.join(", "))
}
<file_sep path="hyperswitch/crates/analytics/src/query.rs" role="context" start="568" end="583">
pub fn new(table: AnalyticsCollection) -> Self {
Self {
columns: Default::default(),
filters: Default::default(),
group_by: Default::default(),
order_by: Default::default(),
having: Default::default(),
limit_by: Default::default(),
outer_select: Default::default(),
top_n: Default::default(),
table,
distinct: Default::default(),
db_type: Default::default(),
table_engine: T::get_table_engine(table),
}
}
<file_sep path="hyperswitch/crates/analytics/src/query.rs" role="context" start="354" end="358">
pub enum FilterCombinator {
#[default]
And,
Or,
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/analytics/src/lib.rs<|crate|> analytics anchor=default kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=1<|meta_end|>
<file_sep path="hyperswitch/crates/analytics/src/lib.rs" role="context" start="1116" end="1121">
fn default() -> Self {
Self::Sqlx {
sqlx: Database::default(),
forex_enabled: false,
}
}
<file_sep path="hyperswitch/crates/analytics/src/lib.rs" role="context" start="1115" end="1115">
use storage_impl::config::Database;
use self::{
active_payments::metrics::{ActivePaymentsMetric, ActivePaymentsMetricRow},
auth_events::metrics::{AuthEventMetric, AuthEventMetricRow},
frm::metrics::{FrmMetric, FrmMetricRow},
payment_intents::metrics::{PaymentIntentMetric, PaymentIntentMetricRow},
payments::{
distribution::{PaymentDistribution, PaymentDistributionRow},
metrics::{PaymentMetric, PaymentMetricRow},
},
refunds::metrics::{RefundMetric, RefundMetricRow},
sdk_events::metrics::{SdkEventMetric, SdkEventMetricRow},
sqlx::SqlxClient,
types::MetricsError,
};
<file_sep path="hyperswitch/crates/analytics/src/lib.rs" role="context" start="1052" end="1112">
async fn convert_to_raw_secret(
value: SecretStateContainer<Self, SecuredSecret>,
secret_management_client: &dyn SecretManagementInterface,
) -> CustomResult<SecretStateContainer<Self, RawSecret>, SecretsManagementError> {
let analytics_config = value.get_inner();
let decrypted_password = match analytics_config {
// Todo: Perform kms decryption of clickhouse password
Self::Clickhouse { .. } => masking::Secret::new(String::default()),
Self::Sqlx { sqlx, .. }
| Self::CombinedCkh { sqlx, .. }
| Self::CombinedSqlx { sqlx, .. } => {
secret_management_client
.get_secret(sqlx.password.clone())
.await?
}
};
Ok(value.transition_state(|conf| match conf {
Self::Sqlx {
sqlx,
forex_enabled,
} => Self::Sqlx {
sqlx: Database {
password: decrypted_password,
..sqlx
},
forex_enabled,
},
Self::Clickhouse {
clickhouse,
forex_enabled,
} => Self::Clickhouse {
clickhouse,
forex_enabled,
},
Self::CombinedCkh {
sqlx,
clickhouse,
forex_enabled,
} => Self::CombinedCkh {
sqlx: Database {
password: decrypted_password,
..sqlx
},
clickhouse,
forex_enabled,
},
Self::CombinedSqlx {
sqlx,
clickhouse,
forex_enabled,
} => Self::CombinedSqlx {
sqlx: Database {
password: decrypted_password,
..sqlx
},
clickhouse,
forex_enabled,
},
}))
}
<file_sep path="hyperswitch/crates/analytics/src/lib.rs" role="context" start="1040" end="1047">
pub fn get_forex_enabled(&self) -> bool {
match self {
Self::Sqlx { forex_enabled, .. }
| Self::Clickhouse { forex_enabled, .. }
| Self::CombinedCkh { forex_enabled, .. }
| Self::CombinedSqlx { forex_enabled, .. } => *forex_enabled,
}
}
<file_sep path="hyperswitch/crates/analytics/src/lib.rs" role="context" start="95" end="97">
fn default() -> Self {
Self::Sqlx(SqlxClient::default())
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/analytics/src/search.rs<|crate|> analytics anchor=convert_to_value kind=fn pack=symbol_neighborhood lang=rust role_window=k2 hops=1<|meta_end|>
<file_sep path="hyperswitch/crates/analytics/src/search.rs" role="context" start="15" end="17">
pub fn convert_to_value<T: Into<Value>>(items: Vec<T>) -> Vec<Value> {
items.into_iter().map(|item| item.into()).collect()
}
<file_sep path="hyperswitch/crates/analytics/src/search.rs" role="context" start="14" end="14">
use serde_json::Value;
<file_sep path="hyperswitch/crates/analytics/src/search.rs" role="context" start="225" end="428">
pub async fn search_results(
client: &OpenSearchClient,
req: GetSearchRequestWithIndex,
search_params: Vec<AuthInfo>,
) -> CustomResult<GetSearchResponse, OpenSearchError> {
let search_req = req.search_req;
if search_req.query.trim().is_empty()
&& search_req
.filters
.as_ref()
.map_or(true, |filters| filters.is_all_none())
{
return Err(OpenSearchError::BadRequestError(
"Both query and filters are empty".to_string(),
)
.into());
}
let mut query_builder = OpenSearchQueryBuilder::new(
OpenSearchQuery::Search(req.index),
search_req.query,
search_params,
);
if let Some(filters) = search_req.filters {
if let Some(currency) = filters.currency {
if !currency.is_empty() {
query_builder
.add_filter_clause("currency.keyword".to_string(), convert_to_value(currency))
.switch()?;
}
};
if let Some(status) = filters.status {
if !status.is_empty() {
query_builder
.add_filter_clause("status.keyword".to_string(), convert_to_value(status))
.switch()?;
}
};
if let Some(payment_method) = filters.payment_method {
if !payment_method.is_empty() {
query_builder
.add_filter_clause(
"payment_method.keyword".to_string(),
convert_to_value(payment_method),
)
.switch()?;
}
};
if let Some(customer_email) = filters.customer_email {
if !customer_email.is_empty() {
query_builder
.add_filter_clause(
"customer_email.keyword".to_string(),
convert_to_value(
customer_email
.iter()
.filter_map(|email| {
// TODO: Add trait based inputs instead of converting this to strings
serde_json::to_value(email)
.ok()
.and_then(|a| a.as_str().map(|a| a.to_string()))
})
.collect(),
),
)
.switch()?;
}
};
if let Some(search_tags) = filters.search_tags {
if !search_tags.is_empty() {
query_builder
.add_filter_clause(
"feature_metadata.search_tags.keyword".to_string(),
convert_to_value(
search_tags
.iter()
.filter_map(|search_tag| {
// TODO: Add trait based inputs instead of converting this to strings
serde_json::to_value(search_tag)
.ok()
.and_then(|a| a.as_str().map(|a| a.to_string()))
})
.collect(),
),
)
.switch()?;
}
};
if let Some(connector) = filters.connector {
if !connector.is_empty() {
query_builder
.add_filter_clause("connector.keyword".to_string(), convert_to_value(connector))
.switch()?;
}
};
if let Some(payment_method_type) = filters.payment_method_type {
if !payment_method_type.is_empty() {
query_builder
.add_filter_clause(
"payment_method_type.keyword".to_string(),
convert_to_value(payment_method_type),
)
.switch()?;
}
};
if let Some(card_network) = filters.card_network {
if !card_network.is_empty() {
query_builder
.add_filter_clause(
"card_network.keyword".to_string(),
convert_to_value(card_network),
)
.switch()?;
}
};
if let Some(card_last_4) = filters.card_last_4 {
if !card_last_4.is_empty() {
query_builder
.add_filter_clause(
"card_last_4.keyword".to_string(),
convert_to_value(card_last_4),
)
.switch()?;
}
};
if let Some(payment_id) = filters.payment_id {
if !payment_id.is_empty() {
query_builder
.add_filter_clause(
"payment_id.keyword".to_string(),
convert_to_value(payment_id),
)
.switch()?;
}
};
if let Some(amount) = filters.amount {
if !amount.is_empty() {
query_builder
.add_filter_clause("amount".to_string(), convert_to_value(amount))
.switch()?;
}
};
if let Some(customer_id) = filters.customer_id {
if !customer_id.is_empty() {
query_builder
.add_filter_clause(
"customer_id.keyword".to_string(),
convert_to_value(customer_id),
)
.switch()?;
}
};
};
if let Some(time_range) = search_req.time_range {
query_builder.set_time_range(time_range.into()).switch()?;
};
query_builder
.set_offset_n_count(search_req.offset, search_req.count)
.switch()?;
let response_text: OpensearchOutput = client
.execute(query_builder)
.await
.change_context(OpenSearchError::ConnectionError)?
.text()
.await
.change_context(OpenSearchError::ResponseError)
.and_then(|body: String| {
serde_json::from_str::<OpensearchOutput>(&body)
.change_context(OpenSearchError::DeserialisationError)
.attach_printable(body.clone())
})?;
let response_body: OpensearchOutput = response_text;
match response_body {
OpensearchOutput::Success(success) => Ok(GetSearchResponse {
count: success.hits.total.value,
index: req.index,
hits: success
.hits
.hits
.into_iter()
.map(|hit| hit.source)
.collect(),
status: SearchStatus::Success,
}),
OpensearchOutput::Error(error) => {
tracing::error!(
index = ?req.index,
error_response = ?error,
"Search error"
);
Ok(GetSearchResponse {
count: 0,
index: req.index,
hits: Vec::new(),
status: SearchStatus::Failure,
})
}
}
}
<file_sep path="hyperswitch/crates/analytics/src/search.rs" role="context" start="19" end="223">
pub async fn msearch_results(
client: &OpenSearchClient,
req: GetGlobalSearchRequest,
search_params: Vec<AuthInfo>,
indexes: Vec<SearchIndex>,
) -> CustomResult<Vec<GetSearchResponse>, OpenSearchError> {
if req.query.trim().is_empty()
&& req
.filters
.as_ref()
.map_or(true, |filters| filters.is_all_none())
{
return Err(OpenSearchError::BadRequestError(
"Both query and filters are empty".to_string(),
)
.into());
}
let mut query_builder = OpenSearchQueryBuilder::new(
OpenSearchQuery::Msearch(indexes.clone()),
req.query,
search_params,
);
if let Some(filters) = req.filters {
if let Some(currency) = filters.currency {
if !currency.is_empty() {
query_builder
.add_filter_clause("currency.keyword".to_string(), convert_to_value(currency))
.switch()?;
}
};
if let Some(status) = filters.status {
if !status.is_empty() {
query_builder
.add_filter_clause("status.keyword".to_string(), convert_to_value(status))
.switch()?;
}
};
if let Some(payment_method) = filters.payment_method {
if !payment_method.is_empty() {
query_builder
.add_filter_clause(
"payment_method.keyword".to_string(),
convert_to_value(payment_method),
)
.switch()?;
}
};
if let Some(customer_email) = filters.customer_email {
if !customer_email.is_empty() {
query_builder
.add_filter_clause(
"customer_email.keyword".to_string(),
convert_to_value(
customer_email
.iter()
.filter_map(|email| {
// TODO: Add trait based inputs instead of converting this to strings
serde_json::to_value(email)
.ok()
.and_then(|a| a.as_str().map(|a| a.to_string()))
})
.collect(),
),
)
.switch()?;
}
};
if let Some(search_tags) = filters.search_tags {
if !search_tags.is_empty() {
query_builder
.add_filter_clause(
"feature_metadata.search_tags.keyword".to_string(),
convert_to_value(
search_tags
.iter()
.filter_map(|search_tag| {
// TODO: Add trait based inputs instead of converting this to strings
serde_json::to_value(search_tag)
.ok()
.and_then(|a| a.as_str().map(|a| a.to_string()))
})
.collect(),
),
)
.switch()?;
}
};
if let Some(connector) = filters.connector {
if !connector.is_empty() {
query_builder
.add_filter_clause("connector.keyword".to_string(), convert_to_value(connector))
.switch()?;
}
};
if let Some(payment_method_type) = filters.payment_method_type {
if !payment_method_type.is_empty() {
query_builder
.add_filter_clause(
"payment_method_type.keyword".to_string(),
convert_to_value(payment_method_type),
)
.switch()?;
}
};
if let Some(card_network) = filters.card_network {
if !card_network.is_empty() {
query_builder
.add_filter_clause(
"card_network.keyword".to_string(),
convert_to_value(card_network),
)
.switch()?;
}
};
if let Some(card_last_4) = filters.card_last_4 {
if !card_last_4.is_empty() {
query_builder
.add_filter_clause(
"card_last_4.keyword".to_string(),
convert_to_value(card_last_4),
)
.switch()?;
}
};
if let Some(payment_id) = filters.payment_id {
if !payment_id.is_empty() {
query_builder
.add_filter_clause(
"payment_id.keyword".to_string(),
convert_to_value(payment_id),
)
.switch()?;
}
};
if let Some(amount) = filters.amount {
if !amount.is_empty() {
query_builder
.add_filter_clause("amount".to_string(), convert_to_value(amount))
.switch()?;
}
};
if let Some(customer_id) = filters.customer_id {
if !customer_id.is_empty() {
query_builder
.add_filter_clause(
"customer_id.keyword".to_string(),
convert_to_value(customer_id),
)
.switch()?;
}
};
};
if let Some(time_range) = req.time_range {
query_builder.set_time_range(time_range.into()).switch()?;
};
let response_text: OpenMsearchOutput = client
.execute(query_builder)
.await
.change_context(OpenSearchError::ConnectionError)?
.text()
.await
.change_context(OpenSearchError::ResponseError)
.and_then(|body: String| {
serde_json::from_str::<OpenMsearchOutput>(&body)
.change_context(OpenSearchError::DeserialisationError)
.attach_printable(body.clone())
})?;
let response_body: OpenMsearchOutput = response_text;
Ok(response_body
.responses
.into_iter()
.zip(indexes)
.map(|(index_hit, index)| match index_hit {
OpensearchOutput::Success(success) => GetSearchResponse {
count: success.hits.total.value,
index,
hits: success
.hits
.hits
.into_iter()
.map(|hit| hit.source)
.collect(),
status: SearchStatus::Success,
},
OpensearchOutput::Error(error) => {
tracing::error!(
index = ?index,
error_response = ?error,
"Search error"
);
GetSearchResponse {
count: 0,
index,
hits: Vec::new(),
status: SearchStatus::Failure,
}
}
})
.collect())
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/analytics/src/types.rs<|crate|> analytics anchor=from_str kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=1<|meta_end|>
<file_sep path="hyperswitch/crates/analytics/src/types.rs" role="context" start="76" end="81">
fn from_str(s: &str) -> Result<Self, Self::Err> {
T::from_str(s)
.map_err(|_er| report!(ParsingError::EnumParseFailure(std::any::type_name::<T>())))
.map(DBEnumWrapper)
.attach_printable_lazy(|| format!("raw_value: {s}"))
}
<file_sep path="hyperswitch/crates/analytics/src/types.rs" role="context" start="75" end="75">
use std::{fmt::Display, str::FromStr};
use common_utils::{
errors::{CustomResult, ErrorSwitch, ParsingError},
events::{ApiEventMetric, ApiEventsType},
impl_api_event_type,
};
use error_stack::{report, Report, ResultExt};
pub type MetricsResult<T> = CustomResult<T, MetricsError>;
pub type FiltersResult<T> = CustomResult<T, FiltersError>;
<file_sep path="hyperswitch/crates/analytics/src/types.rs" role="context" start="131" end="133">
fn switch(&self) -> MetricsError {
MetricsError::QueryBuildingError
}
<file_sep path="hyperswitch/crates/analytics/src/types.rs" role="context" start="94" end="96">
fn get_table_engine(_table: AnalyticsCollection) -> TableEngine {
TableEngine::BasicTree
}
<file_sep path="hyperswitch/crates/analytics/src/types.rs" role="context" start="65" end="67">
fn default() -> Self {
Self(T::default())
}
<file_sep path="hyperswitch/crates/analytics/src/types.rs" role="context" start="59" end="61">
fn as_ref(&self) -> &T {
&self.0
}
<file_sep path="hyperswitch/crates/analytics/src/types.rs" role="context" start="74" end="74">
type Err = Report<ParsingError>;
<file_sep path="hyperswitch/crates/analytics/src/types.rs" role="context" start="56" end="56">
pub struct DBEnumWrapper<T: FromStr + Display>(pub T);
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/analytics/src/sqlx.rs<|crate|> analytics anchor=decode kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/analytics/src/sqlx.rs" role="context" start="126" end="136">
fn decode(
value: PgValueRef<'r>,
) -> Result<Self, Box<dyn std::error::Error + 'static + Send + Sync>> {
let str_value = <&'r str as Decode<'r, Postgres>>::decode(value)?;
Type::from_str(str_value).map(DBEnumWrapper).or(Err(format!(
"invalid value {:?} for enum {}",
str_value,
Type::name()
)
.into()))
}
<file_sep path="hyperswitch/crates/analytics/src/sqlx.rs" role="context" start="125" end="125">
use std::{fmt::Display, str::FromStr};
use sqlx::{
postgres::{PgArgumentBuffer, PgPoolOptions, PgRow, PgTypeInfo, PgValueRef},
Decode, Encode,
Error::ColumnNotFound,
FromRow, Pool, Postgres, Row,
};
use super::{
health_check::HealthCheck,
query::{Aggregate, ToSql, Window},
types::{
AnalyticsCollection, AnalyticsDataSource, DBEnumWrapper, LoadRow, QueryExecutionError,
TableEngine,
},
};
<file_sep path="hyperswitch/crates/analytics/src/sqlx.rs" role="context" start="152" end="154">
fn load_row(row: PgRow) -> CustomResult<T, QueryExecutionError> {
T::from_row(&row).change_context(QueryExecutionError::RowExtractionFailure)
}
<file_sep path="hyperswitch/crates/analytics/src/sqlx.rs" role="context" start="143" end="145">
fn type_info() -> PgTypeInfo {
PgTypeInfo::with_name(Type::name())
}
<file_sep path="hyperswitch/crates/analytics/src/sqlx.rs" role="context" start="117" end="119">
fn size_hint(&self) -> usize {
<String as Encode<'q, Postgres>>::size_hint(&self.0.to_string())
}
<file_sep path="hyperswitch/crates/analytics/src/sqlx.rs" role="context" start="111" end="116">
fn encode_by_ref(
&self,
buf: &mut PgArgumentBuffer,
) -> Result<sqlx::encode::IsNull, Box<(dyn std::error::Error + Send + Sync + 'static)>> {
<String as Encode<'q, Postgres>>::encode(self.0.to_string(), buf)
}
<file_sep path="hyperswitch/crates/analytics/src/types.rs" role="context" start="74" end="74">
type Err = Report<ParsingError>;
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/analytics/src/query.rs<|crate|> analytics anchor=new kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/analytics/src/query.rs" role="context" start="568" end="583">
pub fn new(table: AnalyticsCollection) -> Self {
Self {
columns: Default::default(),
filters: Default::default(),
group_by: Default::default(),
order_by: Default::default(),
having: Default::default(),
limit_by: Default::default(),
outer_select: Default::default(),
top_n: Default::default(),
table,
distinct: Default::default(),
db_type: Default::default(),
table_engine: T::get_table_engine(table),
}
}
<file_sep path="hyperswitch/crates/analytics/src/query.rs" role="context" start="567" end="567">
use super::types::{AnalyticsCollection, AnalyticsDataSource, LoadRow, TableEngine};
pub type QueryResult<T> = error_stack::Result<T, QueryBuildingError>;
<file_sep path="hyperswitch/crates/analytics/src/query.rs" role="context" start="595" end="604">
pub fn transform_to_sql_values(&mut self, values: &[impl ToSql<T>]) -> QueryResult<String> {
let res = values
.iter()
.map(|i| i.to_sql(&self.table_engine))
.collect::<error_stack::Result<Vec<String>, ParsingError>>()
.change_context(QueryBuildingError::SqlSerializeError)
.attach_printable("Error serializing range filter value")?
.join(", ");
Ok(res)
}
<file_sep path="hyperswitch/crates/analytics/src/query.rs" role="context" start="585" end="593">
pub fn add_select_column(&mut self, column: impl ToSql<T>) -> QueryResult<()> {
self.columns.push(
column
.to_sql(&self.table_engine)
.change_context(QueryBuildingError::SqlSerializeError)
.attach_printable("Error serializing select column")?,
);
Ok(())
}
<file_sep path="hyperswitch/crates/analytics/src/query.rs" role="context" start="548" end="561">
pub fn filter_type_to_sql(l: &str, op: FilterTypes, r: &str) -> String {
match op {
FilterTypes::EqualBool => format!("{l} = {r}"),
FilterTypes::Equal => format!("{l} = '{r}'"),
FilterTypes::NotEqual => format!("{l} != '{r}'"),
FilterTypes::In => format!("{l} IN ({r})"),
FilterTypes::Gte => format!("{l} >= '{r}'"),
FilterTypes::Gt => format!("{l} > {r}"),
FilterTypes::Lte => format!("{l} <= '{r}'"),
FilterTypes::Like => format!("{l} LIKE '%{r}%'"),
FilterTypes::NotLike => format!("{l} NOT LIKE '%{r}%'"),
FilterTypes::IsNotNull => format!("{l} IS NOT NULL"),
}
}
<file_sep path="hyperswitch/crates/analytics/src/query.rs" role="context" start="464" end="467">
fn to_sql(&self, _table_engine: &TableEngine) -> error_stack::Result<String, ParsingError> {
let flag = *self;
Ok(i8::from(flag).to_string())
}
<file_sep path="hyperswitch/crates/analytics/src/query.rs" role="context" start="377" end="379">
fn default() -> Self {
Self::NestedFilter(FilterCombinator::default(), Vec::new())
}
<file_sep path="hyperswitch/crates/analytics/src/types.rs" role="context" start="27" end="45">
pub enum AnalyticsCollection {
Payment,
PaymentSessionized,
Refund,
RefundSessionized,
FraudCheck,
SdkEvents,
SdkEventsAnalytics,
ApiEvents,
PaymentIntent,
PaymentIntentSessionized,
ConnectorEvents,
OutgoingWebhookEvent,
Authentications,
Dispute,
DisputeSessionized,
ApiEventsAnalytics,
ActivePaymentsAnalytics,
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/analytics/src/query.rs<|crate|> analytics anchor=filter_type_to_sql kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=1<|meta_end|>
<file_sep path="hyperswitch/crates/analytics/src/query.rs" role="context" start="548" end="561">
pub fn filter_type_to_sql(l: &str, op: FilterTypes, r: &str) -> String {
match op {
FilterTypes::EqualBool => format!("{l} = {r}"),
FilterTypes::Equal => format!("{l} = '{r}'"),
FilterTypes::NotEqual => format!("{l} != '{r}'"),
FilterTypes::In => format!("{l} IN ({r})"),
FilterTypes::Gte => format!("{l} >= '{r}'"),
FilterTypes::Gt => format!("{l} > {r}"),
FilterTypes::Lte => format!("{l} <= '{r}'"),
FilterTypes::Like => format!("{l} LIKE '%{r}%'"),
FilterTypes::NotLike => format!("{l} NOT LIKE '%{r}%'"),
FilterTypes::IsNotNull => format!("{l} IS NOT NULL"),
}
}
<file_sep path="hyperswitch/crates/analytics/src/query.rs" role="context" start="547" end="547">
pub type QueryResult<T> = error_stack::Result<T, QueryBuildingError>;
<file_sep path="hyperswitch/crates/analytics/src/query.rs" role="context" start="585" end="593">
pub fn add_select_column(&mut self, column: impl ToSql<T>) -> QueryResult<()> {
self.columns.push(
column
.to_sql(&self.table_engine)
.change_context(QueryBuildingError::SqlSerializeError)
.attach_printable("Error serializing select column")?,
);
Ok(())
}
<file_sep path="hyperswitch/crates/analytics/src/query.rs" role="context" start="568" end="583">
pub fn new(table: AnalyticsCollection) -> Self {
Self {
columns: Default::default(),
filters: Default::default(),
group_by: Default::default(),
order_by: Default::default(),
having: Default::default(),
limit_by: Default::default(),
outer_select: Default::default(),
top_n: Default::default(),
table,
distinct: Default::default(),
db_type: Default::default(),
table_engine: T::get_table_engine(table),
}
}
<file_sep path="hyperswitch/crates/analytics/src/query.rs" role="context" start="464" end="467">
fn to_sql(&self, _table_engine: &TableEngine) -> error_stack::Result<String, ParsingError> {
let flag = *self;
Ok(i8::from(flag).to_string())
}
<file_sep path="hyperswitch/crates/analytics/src/query.rs" role="context" start="458" end="460">
fn to_sql(&self, _table_engine: &TableEngine) -> error_stack::Result<String, ParsingError> {
Ok(self.get_string_repr().to_owned())
}
<file_sep path="hyperswitch/crates/analytics/src/query.rs" role="context" start="383" end="400">
fn to_sql(&self, table_engine: &TableEngine) -> error_stack::Result<String, ParsingError> {
Ok(match self {
Self::Plain(l, op, r) => filter_type_to_sql(l, *op, r),
Self::NestedFilter(operator, filters) => {
format!(
"( {} )",
filters
.iter()
.map(|f| <Self as ToSql<T>>::to_sql(f, table_engine))
.collect::<Result<Vec<String>, _>>()?
.join(
<FilterCombinator as ToSql<T>>::to_sql(operator, table_engine)?
.as_ref()
)
)
}
})
}
<file_sep path="hyperswitch/crates/analytics/src/query.rs" role="context" start="823" end="830">
pub fn get_filter_type_clause(&self) -> Option<String> {
self.having.as_ref().map(|vec| {
vec.iter()
.map(|(l, op, r)| filter_type_to_sql(l, *op, r))
.collect::<Vec<String>>()
.join(" AND ")
})
}
<file_sep path="hyperswitch/crates/analytics/src/query.rs" role="context" start="535" end="546">
pub enum FilterTypes {
Equal,
NotEqual,
EqualBool,
In,
Gte,
Lte,
Gt,
Like,
NotLike,
IsNotNull,
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/analytics/src/lib.rs<|crate|> analytics anchor=from_conf kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/analytics/src/lib.rs" role="context" start="978" end="1009">
pub async fn from_conf(
config: &AnalyticsConfig,
tenant: &dyn storage_impl::config::TenantConfig,
) -> Self {
match config {
AnalyticsConfig::Sqlx { sqlx, .. } => {
Self::Sqlx(SqlxClient::from_conf(sqlx, tenant.get_schema()).await)
}
AnalyticsConfig::Clickhouse { clickhouse, .. } => Self::Clickhouse(ClickhouseClient {
config: Arc::new(clickhouse.clone()),
database: tenant.get_clickhouse_database().to_string(),
}),
AnalyticsConfig::CombinedCkh {
sqlx, clickhouse, ..
} => Self::CombinedCkh(
SqlxClient::from_conf(sqlx, tenant.get_schema()).await,
ClickhouseClient {
config: Arc::new(clickhouse.clone()),
database: tenant.get_clickhouse_database().to_string(),
},
),
AnalyticsConfig::CombinedSqlx {
sqlx, clickhouse, ..
} => Self::CombinedSqlx(
SqlxClient::from_conf(sqlx, tenant.get_schema()).await,
ClickhouseClient {
config: Arc::new(clickhouse.clone()),
database: tenant.get_clickhouse_database().to_string(),
},
),
}
}
<file_sep path="hyperswitch/crates/analytics/src/lib.rs" role="context" start="977" end="977">
pub use types::AnalyticsDomain;
use std::{collections::HashSet, sync::Arc};
use clickhouse::ClickhouseClient;
pub use clickhouse::ClickhouseConfig;
use storage_impl::config::Database;
use self::{
active_payments::metrics::{ActivePaymentsMetric, ActivePaymentsMetricRow},
auth_events::metrics::{AuthEventMetric, AuthEventMetricRow},
frm::metrics::{FrmMetric, FrmMetricRow},
payment_intents::metrics::{PaymentIntentMetric, PaymentIntentMetricRow},
payments::{
distribution::{PaymentDistribution, PaymentDistributionRow},
metrics::{PaymentMetric, PaymentMetricRow},
},
refunds::metrics::{RefundMetric, RefundMetricRow},
sdk_events::metrics::{SdkEventMetric, SdkEventMetricRow},
sqlx::SqlxClient,
types::MetricsError,
};
<file_sep path="hyperswitch/crates/analytics/src/lib.rs" role="context" start="1052" end="1112">
async fn convert_to_raw_secret(
value: SecretStateContainer<Self, SecuredSecret>,
secret_management_client: &dyn SecretManagementInterface,
) -> CustomResult<SecretStateContainer<Self, RawSecret>, SecretsManagementError> {
let analytics_config = value.get_inner();
let decrypted_password = match analytics_config {
// Todo: Perform kms decryption of clickhouse password
Self::Clickhouse { .. } => masking::Secret::new(String::default()),
Self::Sqlx { sqlx, .. }
| Self::CombinedCkh { sqlx, .. }
| Self::CombinedSqlx { sqlx, .. } => {
secret_management_client
.get_secret(sqlx.password.clone())
.await?
}
};
Ok(value.transition_state(|conf| match conf {
Self::Sqlx {
sqlx,
forex_enabled,
} => Self::Sqlx {
sqlx: Database {
password: decrypted_password,
..sqlx
},
forex_enabled,
},
Self::Clickhouse {
clickhouse,
forex_enabled,
} => Self::Clickhouse {
clickhouse,
forex_enabled,
},
Self::CombinedCkh {
sqlx,
clickhouse,
forex_enabled,
} => Self::CombinedCkh {
sqlx: Database {
password: decrypted_password,
..sqlx
},
clickhouse,
forex_enabled,
},
Self::CombinedSqlx {
sqlx,
clickhouse,
forex_enabled,
} => Self::CombinedSqlx {
sqlx: Database {
password: decrypted_password,
..sqlx
},
clickhouse,
forex_enabled,
},
}))
}
<file_sep path="hyperswitch/crates/analytics/src/lib.rs" role="context" start="1040" end="1047">
pub fn get_forex_enabled(&self) -> bool {
match self {
Self::Sqlx { forex_enabled, .. }
| Self::Clickhouse { forex_enabled, .. }
| Self::CombinedCkh { forex_enabled, .. }
| Self::CombinedSqlx { forex_enabled, .. } => *forex_enabled,
}
}
<file_sep path="hyperswitch/crates/analytics/src/lib.rs" role="context" start="949" end="976">
pub async fn get_api_event_metrics(
&self,
metric: &ApiEventMetrics,
dimensions: &[ApiEventDimensions],
merchant_id: &common_utils::id_type::MerchantId,
filters: &ApiEventFilters,
granularity: Option<Granularity>,
time_range: &TimeRange,
) -> types::MetricsResult<HashSet<(ApiEventMetricsBucketIdentifier, ApiEventMetricRow)>> {
match self {
Self::Sqlx(_pool) => Err(report!(MetricsError::NotImplemented)),
Self::Clickhouse(ckh_pool)
| Self::CombinedCkh(_, ckh_pool)
| Self::CombinedSqlx(_, ckh_pool) => {
// Since API events are ckh only use ckh here
metric
.load_metrics(
dimensions,
merchant_id,
filters,
granularity,
time_range,
ckh_pool,
)
.await
}
}
}
<file_sep path="hyperswitch/crates/analytics/src/lib.rs" role="context" start="910" end="947">
pub async fn get_auth_event_metrics(
&self,
metric: &AuthEventMetrics,
dimensions: &[AuthEventDimensions],
merchant_id: &common_utils::id_type::MerchantId,
filters: &AuthEventFilters,
granularity: Option<Granularity>,
time_range: &TimeRange,
) -> types::MetricsResult<HashSet<(AuthEventMetricsBucketIdentifier, AuthEventMetricRow)>> {
match self {
Self::Sqlx(_pool) => Err(report!(MetricsError::NotImplemented)),
Self::Clickhouse(pool) => {
metric
.load_metrics(
merchant_id,
dimensions,
filters,
granularity,
time_range,
pool,
)
.await
}
Self::CombinedCkh(_sqlx_pool, ckh_pool) | Self::CombinedSqlx(_sqlx_pool, ckh_pool) => {
metric
.load_metrics(
merchant_id,
dimensions,
filters,
granularity,
// Since API events are ckh only use ckh here
time_range,
ckh_pool,
)
.await
}
}
}
<file_sep path="hyperswitch/crates/analytics/src/lib.rs" role="context" start="1014" end="1037">
pub enum AnalyticsConfig {
Sqlx {
sqlx: Database,
#[serde(default)]
forex_enabled: bool,
},
Clickhouse {
clickhouse: ClickhouseConfig,
#[serde(default)]
forex_enabled: bool,
},
CombinedCkh {
sqlx: Database,
clickhouse: ClickhouseConfig,
#[serde(default)]
forex_enabled: bool,
},
CombinedSqlx {
sqlx: Database,
clickhouse: ClickhouseConfig,
#[serde(default)]
forex_enabled: bool,
},
}
<file_sep path="hyperswitch/crates/analytics/src/sqlx.rs" role="context" start="38" end="40">
pub struct SqlxClient {
pool: Pool<Postgres>,
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/analytics/src/sqlx.rs<|crate|> analytics anchor=from_row kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/analytics/src/sqlx.rs" role="context" start="1072" end="1117">
fn from_row(row: &'a PgRow) -> sqlx::Result<Self> {
let dispute_stage: Option<DBEnumWrapper<DisputeStage>> =
row.try_get("dispute_stage").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let dispute_status: Option<DBEnumWrapper<DisputeStatus>> =
row.try_get("dispute_status").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let connector: Option<String> = row.try_get("connector").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let currency: Option<DBEnumWrapper<Currency>> =
row.try_get("currency").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let total: Option<bigdecimal::BigDecimal> = row.try_get("total").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let count: Option<i64> = row.try_get("count").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
// Removing millisecond precision to get accurate diffs against clickhouse
let start_bucket: Option<PrimitiveDateTime> = row
.try_get::<Option<PrimitiveDateTime>, _>("start_bucket")?
.and_then(|dt| dt.replace_millisecond(0).ok());
let end_bucket: Option<PrimitiveDateTime> = row
.try_get::<Option<PrimitiveDateTime>, _>("end_bucket")?
.and_then(|dt| dt.replace_millisecond(0).ok());
Ok(Self {
dispute_stage,
dispute_status,
connector,
currency,
total,
count,
start_bucket,
end_bucket,
})
}
<file_sep path="hyperswitch/crates/analytics/src/sqlx.rs" role="context" start="1071" end="1071">
use api_models::{
analytics::{frm::FrmTransactionType, refunds::RefundType},
enums::{DisputeStage, DisputeStatus},
};
use diesel_models::enums::{
AttemptStatus, AuthenticationType, Currency, FraudCheckStatus, IntentStatus, PaymentMethod,
RefundStatus,
};
use sqlx::{
postgres::{PgArgumentBuffer, PgPoolOptions, PgRow, PgTypeInfo, PgValueRef},
Decode, Encode,
Error::ColumnNotFound,
FromRow, Pool, Postgres, Row,
};
use time::PrimitiveDateTime;
use super::{
health_check::HealthCheck,
query::{Aggregate, ToSql, Window},
types::{
AnalyticsCollection, AnalyticsDataSource, DBEnumWrapper, LoadRow, QueryExecutionError,
TableEngine,
},
};
<file_sep path="hyperswitch/crates/analytics/src/sqlx.rs" role="context" start="1127" end="1161">
fn to_sql(&self, _table_engine: &TableEngine) -> error_stack::Result<String, ParsingError> {
match self {
Self::Payment => Ok("payment_attempt".to_string()),
Self::PaymentSessionized => Err(error_stack::report!(ParsingError::UnknownError)
.attach_printable("PaymentSessionized table is not implemented for Sqlx"))?,
Self::Refund => Ok("refund".to_string()),
Self::RefundSessionized => Err(error_stack::report!(ParsingError::UnknownError)
.attach_printable("RefundSessionized table is not implemented for Sqlx"))?,
Self::SdkEvents => Err(error_stack::report!(ParsingError::UnknownError)
.attach_printable("SdkEventsAudit table is not implemented for Sqlx"))?,
Self::SdkEventsAnalytics => Err(error_stack::report!(ParsingError::UnknownError)
.attach_printable("SdkEvents table is not implemented for Sqlx"))?,
Self::ApiEvents => Err(error_stack::report!(ParsingError::UnknownError)
.attach_printable("ApiEvents table is not implemented for Sqlx"))?,
Self::FraudCheck => Ok("fraud_check".to_string()),
Self::PaymentIntent => Ok("payment_intent".to_string()),
Self::PaymentIntentSessionized => Err(error_stack::report!(
ParsingError::UnknownError
)
.attach_printable("PaymentIntentSessionized table is not implemented for Sqlx"))?,
Self::ConnectorEvents => Err(error_stack::report!(ParsingError::UnknownError)
.attach_printable("ConnectorEvents table is not implemented for Sqlx"))?,
Self::ApiEventsAnalytics => Err(error_stack::report!(ParsingError::UnknownError)
.attach_printable("ApiEvents table is not implemented for Sqlx"))?,
Self::ActivePaymentsAnalytics => Err(error_stack::report!(ParsingError::UnknownError)
.attach_printable("ActivePaymentsAnalytics table is not implemented for Sqlx"))?,
Self::OutgoingWebhookEvent => Err(error_stack::report!(ParsingError::UnknownError)
.attach_printable("OutgoingWebhookEvents table is not implemented for Sqlx"))?,
Self::Dispute => Ok("dispute".to_string()),
Self::DisputeSessionized => Err(error_stack::report!(ParsingError::UnknownError)
.attach_printable("DisputeSessionized table is not implemented for Sqlx"))?,
Self::Authentications => Err(error_stack::report!(ParsingError::UnknownError)
.attach_printable("Authentications table is not implemented for Sqlx"))?,
}
}
<file_sep path="hyperswitch/crates/analytics/src/sqlx.rs" role="context" start="1121" end="1123">
fn to_sql(&self, _table_engine: &TableEngine) -> error_stack::Result<String, ParsingError> {
Ok(self.to_string())
}
<file_sep path="hyperswitch/crates/analytics/src/sqlx.rs" role="context" start="1038" end="1069">
fn from_row(row: &'a PgRow) -> sqlx::Result<Self> {
let dispute_stage: Option<String> = row.try_get("dispute_stage").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let dispute_status: Option<String> =
row.try_get("dispute_status").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let connector: Option<String> = row.try_get("connector").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let connector_status: Option<String> =
row.try_get("connector_status").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let currency: Option<DBEnumWrapper<Currency>> =
row.try_get("currency").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
Ok(Self {
dispute_stage,
dispute_status,
connector,
connector_status,
currency,
})
}
<file_sep path="hyperswitch/crates/analytics/src/sqlx.rs" role="context" start="1014" end="1034">
fn from_row(row: &'a PgRow) -> sqlx::Result<Self> {
let frm_name: Option<String> = row.try_get("frm_name").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let frm_status: Option<DBEnumWrapper<FraudCheckStatus>> =
row.try_get("frm_status").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let frm_transaction_type: Option<DBEnumWrapper<FrmTransactionType>> =
row.try_get("frm_transaction_type").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
Ok(Self {
frm_name,
frm_status,
frm_transaction_type,
})
}
<file_sep path="hyperswitch/crates/analytics/src/sqlx.rs" role="context" start="152" end="154">
fn load_row(row: PgRow) -> CustomResult<T, QueryExecutionError> {
T::from_row(&row).change_context(QueryExecutionError::RowExtractionFailure)
}
<file_sep path="hyperswitch/crates/analytics/src/sqlx.rs" role="context" start="43" end="54">
fn default() -> Self {
let database_url = format!(
"postgres://{}:{}@{}:{}/{}",
"db_user", "db_pass", "localhost", 5432, "hyperswitch_db"
);
Self {
#[allow(clippy::expect_used)]
pool: PgPoolOptions::new()
.connect_lazy(&database_url)
.expect("SQLX Pool Creation failed"),
}
}
<file_sep path="hyperswitch/crates/analytics/src/types.rs" role="context" start="74" end="74">
type Err = Report<ParsingError>;
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/analytics/src/opensearch.rs<|crate|> analytics anchor=construct_payload kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/analytics/src/opensearch.rs" role="context" start="728" end="777">
pub fn construct_payload(&self, indexes: &[SearchIndex]) -> QueryResult<Vec<Value>> {
let mut query_obj = Map::new();
let bool_obj = Map::new();
let (case_sensitive_filters, case_insensitive_filters): (Vec<_>, Vec<_>) = self
.filters
.iter()
.partition(|(k, _)| self.case_sensitive_fields.contains(k.as_str()));
let should_array = self.build_auth_array();
query_obj.insert("bool".to_string(), Value::Object(bool_obj.clone()));
let mut sort_obj = Map::new();
sort_obj.insert(
"@timestamp".to_string(),
json!({
"order": "desc"
}),
);
Ok(indexes
.iter()
.map(|index| {
let mut payload = json!({
"query": query_obj.clone(),
"sort": [
Value::Object(sort_obj.clone())
]
});
let filter_array = self.build_filter_array(case_sensitive_filters.clone(), *index);
if !filter_array.is_empty() {
payload
.get_mut("query")
.and_then(|query| query.get_mut("bool"))
.and_then(|bool_obj| bool_obj.as_object_mut())
.map(|bool_map| {
bool_map.insert("filter".to_string(), Value::Array(filter_array));
});
}
payload = self.build_case_insensitive_filters(
payload,
&case_insensitive_filters,
should_array.clone(),
*index,
);
payload
})
.collect::<Vec<Value>>())
}
<file_sep path="hyperswitch/crates/analytics/src/opensearch.rs" role="context" start="727" end="727">
use api_models::{
analytics::search::SearchIndex,
errors::types::{ApiError, ApiErrorResponse},
};
use aws_config::{self, meta::region::RegionProviderChain, Region};
use serde_json::{json, Map, Value};
use super::{health_check::HealthCheck, query::QueryResult, types::QueryExecutionError};
use crate::{enums::AuthInfo, query::QueryBuildingError};
<file_sep path="hyperswitch/crates/analytics/src/opensearch.rs" role="context" start="640" end="719">
pub fn build_auth_array(&self) -> Vec<Value> {
self.search_params
.iter()
.map(|user_level| match user_level {
AuthInfo::OrgLevel { org_id } => {
let must_clauses = vec![json!({
"term": {
"organization_id.keyword": {
"value": org_id
}
}
})];
json!({
"bool": {
"must": must_clauses
}
})
}
AuthInfo::MerchantLevel {
org_id,
merchant_ids,
} => {
let must_clauses = vec![
json!({
"term": {
"organization_id.keyword": {
"value": org_id
}
}
}),
json!({
"terms": {
"merchant_id.keyword": merchant_ids
}
}),
];
json!({
"bool": {
"must": must_clauses
}
})
}
AuthInfo::ProfileLevel {
org_id,
merchant_id,
profile_ids,
} => {
let must_clauses = vec![
json!({
"term": {
"organization_id.keyword": {
"value": org_id
}
}
}),
json!({
"term": {
"merchant_id.keyword": {
"value": merchant_id
}
}
}),
json!({
"terms": {
"profile_id.keyword": profile_ids
}
}),
];
json!({
"bool": {
"must": must_clauses
}
})
}
})
.collect::<Vec<Value>>()
}
<file_sep path="hyperswitch/crates/analytics/src/opensearch.rs" role="context" start="579" end="638">
pub fn build_case_insensitive_filters(
&self,
mut payload: Value,
case_insensitive_filters: &[&(String, Vec<Value>)],
auth_array: Vec<Value>,
index: SearchIndex,
) -> Value {
let mut must_array = case_insensitive_filters
.iter()
.map(|(k, v)| {
let key = if *k == "status.keyword" {
self.get_status_field(index).to_string()
} else {
k.clone()
};
json!({
"bool": {
"must": [
{
"bool": {
"should": v.iter().map(|value| {
json!({
"term": {
format!("{}", key): {
"value": value,
"case_insensitive": true
}
}
})
}).collect::<Vec<Value>>(),
"minimum_should_match": 1
}
}
]
}
})
})
.collect::<Vec<Value>>();
must_array.push(json!({ "bool": {
"must": [
{
"bool": {
"should": auth_array,
"minimum_should_match": 1
}
}
]
}}));
if let Some(query) = payload.get_mut("query") {
if let Some(bool_obj) = query.get_mut("bool") {
if let Some(bool_map) = bool_obj.as_object_mut() {
bool_map.insert("must".to_string(), Value::Array(must_array));
}
}
}
payload
}
<file_sep path="hyperswitch/crates/analytics/src/opensearch.rs" role="context" start="485" end="503">
pub fn new(query_type: OpenSearchQuery, query: String, search_params: Vec<AuthInfo>) -> Self {
Self {
query_type,
query,
search_params,
offset: Default::default(),
count: Default::default(),
filters: Default::default(),
time_range: Default::default(),
case_sensitive_fields: HashSet::from([
"customer_email.keyword",
"search_tags.keyword",
"card_last_4.keyword",
"payment_id.keyword",
"amount",
"customer_id.keyword",
]),
}
}
<file_sep path="hyperswitch/crates/analytics/src/query.rs" role="context" start="35" end="35">
pub type QueryResult<T> = error_stack::Result<T, QueryBuildingError>;
<file_sep path="hyperswitch/crates/api_models/src/analytics/search.rs" role="context" start="70" end="79">
pub enum SearchIndex {
PaymentAttempts,
PaymentIntents,
Refunds,
Disputes,
SessionizerPaymentAttempts,
SessionizerPaymentIntents,
SessionizerRefunds,
SessionizerDisputes,
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/analytics/src/lib.rs<|crate|> analytics anchor=default kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/analytics/src/lib.rs" role="context" start="95" end="97">
fn default() -> Self {
Self::Sqlx(SqlxClient::default())
}
<file_sep path="hyperswitch/crates/analytics/src/lib.rs" role="context" start="94" end="94">
use self::{
active_payments::metrics::{ActivePaymentsMetric, ActivePaymentsMetricRow},
auth_events::metrics::{AuthEventMetric, AuthEventMetricRow},
frm::metrics::{FrmMetric, FrmMetricRow},
payment_intents::metrics::{PaymentIntentMetric, PaymentIntentMetricRow},
payments::{
distribution::{PaymentDistribution, PaymentDistributionRow},
metrics::{PaymentMetric, PaymentMetricRow},
},
refunds::metrics::{RefundMetric, RefundMetricRow},
sdk_events::metrics::{SdkEventMetric, SdkEventMetricRow},
sqlx::SqlxClient,
types::MetricsError,
};
<file_sep path="hyperswitch/crates/analytics/src/lib.rs" role="context" start="115" end="217">
pub async fn get_payment_metrics(
&self,
metric: &PaymentMetrics,
dimensions: &[PaymentDimensions],
auth: &AuthInfo,
filters: &PaymentFilters,
granularity: Option<Granularity>,
time_range: &TimeRange,
) -> types::MetricsResult<HashSet<(PaymentMetricsBucketIdentifier, PaymentMetricRow)>> {
// Metrics to get the fetch time for each payment metric
metrics::request::record_operation_time(
async {
match self {
Self::Sqlx(pool) => {
metric
.load_metrics(
dimensions,
auth,
filters,
granularity,
time_range,
pool,
)
.await
}
Self::Clickhouse(pool) => {
metric
.load_metrics(
dimensions,
auth,
filters,
granularity,
time_range,
pool,
)
.await
}
Self::CombinedCkh(sqlx_pool, ckh_pool) => {
let (ckh_result, sqlx_result) = tokio::join!(metric
.load_metrics(
dimensions,
auth,
filters,
granularity,
time_range,
ckh_pool,
),
metric
.load_metrics(
dimensions,
auth,
filters,
granularity,
time_range,
sqlx_pool,
));
match (&sqlx_result, &ckh_result) {
(Ok(ref sqlx_res), Ok(ref ckh_res)) if sqlx_res != ckh_res => {
router_env::logger::error!(clickhouse_result=?ckh_res, postgres_result=?sqlx_res, "Mismatch between clickhouse & postgres payments analytics metrics")
},
_ => {}
};
ckh_result
}
Self::CombinedSqlx(sqlx_pool, ckh_pool) => {
let (ckh_result, sqlx_result) = tokio::join!(metric
.load_metrics(
dimensions,
auth,
filters,
granularity,
time_range,
ckh_pool,
),
metric
.load_metrics(
dimensions,
auth,
filters,
granularity,
time_range,
sqlx_pool,
));
match (&sqlx_result, &ckh_result) {
(Ok(ref sqlx_res), Ok(ref ckh_res)) if sqlx_res != ckh_res => {
router_env::logger::error!(clickhouse_result=?ckh_res, postgres_result=?sqlx_res, "Mismatch between clickhouse & postgres payments analytics metrics")
},
_ => {}
};
sqlx_result
}
}
},
&metrics::METRIC_FETCH_TIME,
metric,
self,
)
.await
}
<file_sep path="hyperswitch/crates/analytics/src/lib.rs" role="context" start="101" end="110">
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let analytics_provider = match self {
Self::Clickhouse(_) => "Clickhouse",
Self::Sqlx(_) => "Sqlx",
Self::CombinedCkh(_, _) => "CombinedCkh",
Self::CombinedSqlx(_, _) => "CombinedSqlx",
};
write!(f, "{}", analytics_provider)
}
<file_sep path="hyperswitch/crates/analytics/src/lib.rs" role="context" start="1116" end="1121">
fn default() -> Self {
Self::Sqlx {
sqlx: Database::default(),
forex_enabled: false,
}
}
<file_sep path="hyperswitch/crates/analytics/src/sqlx.rs" role="context" start="38" end="40">
pub struct SqlxClient {
pool: Pool<Postgres>,
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/analytics/src/opensearch.rs<|crate|> analytics anchor=from kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=1<|meta_end|>
<file_sep path="hyperswitch/crates/analytics/src/opensearch.rs" role="context" start="61" end="66">
fn from(time_range: TimeRange) -> Self {
Self {
gte: time_range.start_time,
lte: time_range.end_time,
}
}
<file_sep path="hyperswitch/crates/analytics/src/opensearch.rs" role="context" start="60" end="60">
use common_utils::{
errors::{CustomResult, ErrorSwitch},
types::TimeRange,
};
<file_sep path="hyperswitch/crates/analytics/src/opensearch.rs" role="context" start="126" end="128">
fn switch(&self) -> OpenSearchError {
OpenSearchError::QueryBuildingError
}
<file_sep path="hyperswitch/crates/analytics/src/opensearch.rs" role="context" start="79" end="98">
fn default() -> Self {
Self {
host: "https://localhost:9200".to_string(),
auth: OpenSearchAuth::Basic {
username: "admin".to_string(),
password: "admin".to_string(),
},
indexes: OpenSearchIndexes {
payment_attempts: "hyperswitch-payment-attempt-events".to_string(),
payment_intents: "hyperswitch-payment-intent-events".to_string(),
refunds: "hyperswitch-refund-events".to_string(),
disputes: "hyperswitch-dispute-events".to_string(),
sessionizer_payment_attempts: "sessionizer-payment-attempt-events".to_string(),
sessionizer_payment_intents: "sessionizer-payment-intent-events".to_string(),
sessionizer_refunds: "sessionizer-refund-events".to_string(),
sessionizer_disputes: "sessionizer-dispute-events".to_string(),
},
enabled: false,
}
}
<file_sep path="hyperswitch/crates/analytics/src/opensearch.rs" role="context" start="485" end="503">
pub fn new(query_type: OpenSearchQuery, query: String, search_params: Vec<AuthInfo>) -> Self {
Self {
query_type,
query,
search_params,
offset: Default::default(),
count: Default::default(),
filters: Default::default(),
time_range: Default::default(),
case_sensitive_fields: HashSet::from([
"customer_email.keyword",
"search_tags.keyword",
"card_last_4.keyword",
"payment_id.keyword",
"amount",
"customer_id.keyword",
]),
}
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/analytics/src/sqlx.rs<|crate|> analytics anchor=load_row kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/analytics/src/sqlx.rs" role="context" start="152" end="154">
fn load_row(row: PgRow) -> CustomResult<T, QueryExecutionError> {
T::from_row(&row).change_context(QueryExecutionError::RowExtractionFailure)
}
<file_sep path="hyperswitch/crates/analytics/src/sqlx.rs" role="context" start="151" end="151">
use common_utils::{
errors::{CustomResult, ParsingError},
DbConnectionParams,
};
use sqlx::{
postgres::{PgArgumentBuffer, PgPoolOptions, PgRow, PgTypeInfo, PgValueRef},
Decode, Encode,
Error::ColumnNotFound,
FromRow, Pool, Postgres, Row,
};
use super::{
health_check::HealthCheck,
query::{Aggregate, ToSql, Window},
types::{
AnalyticsCollection, AnalyticsDataSource, DBEnumWrapper, LoadRow, QueryExecutionError,
TableEngine,
},
};
<file_sep path="hyperswitch/crates/analytics/src/sqlx.rs" role="context" start="193" end="199">
async fn deep_health_check(&self) -> CustomResult<(), QueryExecutionError> {
sqlx::query("SELECT 1")
.fetch_all(&self.pool)
.await
.map(|_| ())
.change_context(QueryExecutionError::DatabaseError)
}
<file_sep path="hyperswitch/crates/analytics/src/sqlx.rs" role="context" start="176" end="189">
async fn load_results<T>(&self, query: &str) -> CustomResult<Vec<T>, QueryExecutionError>
where
Self: LoadRow<T>,
{
sqlx::query(&format!("{query};"))
.fetch_all(&self.pool)
.await
.change_context(QueryExecutionError::DatabaseError)
.attach_printable_lazy(|| format!("Failed to run query {query}"))?
.into_iter()
.map(Self::load_row)
.collect::<Result<Vec<_>, _>>()
.change_context(QueryExecutionError::RowExtractionFailure)
}
<file_sep path="hyperswitch/crates/analytics/src/sqlx.rs" role="context" start="143" end="145">
fn type_info() -> PgTypeInfo {
PgTypeInfo::with_name(Type::name())
}
<file_sep path="hyperswitch/crates/analytics/src/sqlx.rs" role="context" start="126" end="136">
fn decode(
value: PgValueRef<'r>,
) -> Result<Self, Box<dyn std::error::Error + 'static + Send + Sync>> {
let str_value = <&'r str as Decode<'r, Postgres>>::decode(value)?;
Type::from_str(str_value).map(DBEnumWrapper).or(Err(format!(
"invalid value {:?} for enum {}",
str_value,
Type::name()
)
.into()))
}
<file_sep path="hyperswitch/crates/analytics/src/sqlx.rs" role="context" start="1072" end="1117">
fn from_row(row: &'a PgRow) -> sqlx::Result<Self> {
let dispute_stage: Option<DBEnumWrapper<DisputeStage>> =
row.try_get("dispute_stage").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let dispute_status: Option<DBEnumWrapper<DisputeStatus>> =
row.try_get("dispute_status").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let connector: Option<String> = row.try_get("connector").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let currency: Option<DBEnumWrapper<Currency>> =
row.try_get("currency").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let total: Option<bigdecimal::BigDecimal> = row.try_get("total").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let count: Option<i64> = row.try_get("count").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
// Removing millisecond precision to get accurate diffs against clickhouse
let start_bucket: Option<PrimitiveDateTime> = row
.try_get::<Option<PrimitiveDateTime>, _>("start_bucket")?
.and_then(|dt| dt.replace_millisecond(0).ok());
let end_bucket: Option<PrimitiveDateTime> = row
.try_get::<Option<PrimitiveDateTime>, _>("end_bucket")?
.and_then(|dt| dt.replace_millisecond(0).ok());
Ok(Self {
dispute_stage,
dispute_status,
connector,
currency,
total,
count,
start_bucket,
end_bucket,
})
}
<file_sep path="hyperswitch/crates/analytics/src/types.rs" role="context" start="121" end="126">
pub enum QueryExecutionError {
#[error("Failed to extract domain rows")]
RowExtractionFailure,
#[error("Database error")]
DatabaseError,
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/analytics/src/query.rs<|crate|> analytics anchor=to_sql kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/analytics/src/query.rs" role="context" start="464" end="467">
fn to_sql(&self, _table_engine: &TableEngine) -> error_stack::Result<String, ParsingError> {
let flag = *self;
Ok(i8::from(flag).to_string())
}
<file_sep path="hyperswitch/crates/analytics/src/query.rs" role="context" start="463" end="463">
use api_models::{
analytics::{
self as analytics_api,
api_event::ApiEventDimensions,
auth_events::{AuthEventDimensions, AuthEventFlows},
disputes::DisputeDimensions,
frm::{FrmDimensions, FrmTransactionType},
payment_intents::PaymentIntentDimensions,
payments::{PaymentDimensions, PaymentDistributions},
refunds::{RefundDimensions, RefundDistributions, RefundType},
sdk_events::{SdkEventDimensions, SdkEventNames},
Granularity,
},
enums::{
AttemptStatus, AuthenticationType, Connector, Currency, DisputeStage, IntentStatus,
PaymentMethod, PaymentMethodType,
},
refunds::RefundStatus,
};
use common_utils::{
errors::{CustomResult, ParsingError},
id_type::{MerchantId, OrganizationId, ProfileId},
};
use error_stack::ResultExt;
use super::types::{AnalyticsCollection, AnalyticsDataSource, LoadRow, TableEngine};
pub type QueryResult<T> = error_stack::Result<T, QueryBuildingError>;
<file_sep path="hyperswitch/crates/analytics/src/query.rs" role="context" start="568" end="583">
pub fn new(table: AnalyticsCollection) -> Self {
Self {
columns: Default::default(),
filters: Default::default(),
group_by: Default::default(),
order_by: Default::default(),
having: Default::default(),
limit_by: Default::default(),
outer_select: Default::default(),
top_n: Default::default(),
table,
distinct: Default::default(),
db_type: Default::default(),
table_engine: T::get_table_engine(table),
}
}
<file_sep path="hyperswitch/crates/analytics/src/query.rs" role="context" start="548" end="561">
pub fn filter_type_to_sql(l: &str, op: FilterTypes, r: &str) -> String {
match op {
FilterTypes::EqualBool => format!("{l} = {r}"),
FilterTypes::Equal => format!("{l} = '{r}'"),
FilterTypes::NotEqual => format!("{l} != '{r}'"),
FilterTypes::In => format!("{l} IN ({r})"),
FilterTypes::Gte => format!("{l} >= '{r}'"),
FilterTypes::Gt => format!("{l} > {r}"),
FilterTypes::Lte => format!("{l} <= '{r}'"),
FilterTypes::Like => format!("{l} LIKE '%{r}%'"),
FilterTypes::NotLike => format!("{l} NOT LIKE '%{r}%'"),
FilterTypes::IsNotNull => format!("{l} IS NOT NULL"),
}
}
<file_sep path="hyperswitch/crates/analytics/src/query.rs" role="context" start="458" end="460">
fn to_sql(&self, _table_engine: &TableEngine) -> error_stack::Result<String, ParsingError> {
Ok(self.get_string_repr().to_owned())
}
<file_sep path="hyperswitch/crates/analytics/src/query.rs" role="context" start="452" end="454">
fn to_sql(&self, _table_engine: &TableEngine) -> error_stack::Result<String, ParsingError> {
Ok(self.get_string_repr().to_owned())
}
<file_sep path="hyperswitch/crates/analytics/src/query.rs" role="context" start="770" end="773">
fn get_filter_clause(&self) -> QueryResult<String> {
<Filter as ToSql<T>>::to_sql(&self.filters, &self.table_engine)
.change_context(QueryBuildingError::SqlSerializeError)
}
<file_sep path="hyperswitch/crates/analytics/src/types.rs" role="context" start="49" end="52">
pub enum TableEngine {
CollapsingMergeTree { sign: &'static str },
BasicTree,
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/analytics/src/query.rs<|crate|> analytics anchor=get_filter_clause kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=1<|meta_end|>
<file_sep path="hyperswitch/crates/analytics/src/query.rs" role="context" start="770" end="773">
fn get_filter_clause(&self) -> QueryResult<String> {
<Filter as ToSql<T>>::to_sql(&self.filters, &self.table_engine)
.change_context(QueryBuildingError::SqlSerializeError)
}
<file_sep path="hyperswitch/crates/analytics/src/query.rs" role="context" start="769" end="769">
use api_models::{
analytics::{
self as analytics_api,
api_event::ApiEventDimensions,
auth_events::{AuthEventDimensions, AuthEventFlows},
disputes::DisputeDimensions,
frm::{FrmDimensions, FrmTransactionType},
payment_intents::PaymentIntentDimensions,
payments::{PaymentDimensions, PaymentDistributions},
refunds::{RefundDimensions, RefundDistributions, RefundType},
sdk_events::{SdkEventDimensions, SdkEventNames},
Granularity,
},
enums::{
AttemptStatus, AuthenticationType, Connector, Currency, DisputeStage, IntentStatus,
PaymentMethod, PaymentMethodType,
},
refunds::RefundStatus,
};
use diesel_models::{enums as storage_enums, enums::FraudCheckStatus};
pub type QueryResult<T> = error_stack::Result<T, QueryBuildingError>;
<file_sep path="hyperswitch/crates/analytics/src/query.rs" role="context" start="779" end="781">
fn get_group_by_clause(&self) -> String {
self.group_by.join(", ")
}
<file_sep path="hyperswitch/crates/analytics/src/query.rs" role="context" start="775" end="777">
fn get_select_clause(&self) -> String {
self.columns.join(", ")
}
<file_sep path="hyperswitch/crates/analytics/src/query.rs" role="context" start="755" end="768">
pub fn add_granularity_in_mins(&mut self, granularity: Granularity) -> QueryResult<()> {
let interval = match granularity {
Granularity::OneMin => "1",
Granularity::FiveMin => "5",
Granularity::FifteenMin => "15",
Granularity::ThirtyMin => "30",
Granularity::OneHour => "60",
Granularity::OneDay => "1440",
};
let _ = self.add_select_column(format!(
"toStartOfInterval(created_at, INTERVAL {interval} MINUTE) as time_bucket"
));
Ok(())
}
<file_sep path="hyperswitch/crates/analytics/src/query.rs" role="context" start="743" end="753">
pub fn set_limit_by(&mut self, limit: u64, columns: &[impl ToSql<T>]) -> QueryResult<()> {
let columns = columns
.iter()
.map(|col| col.to_sql(&self.table_engine))
.collect::<Result<Vec<String>, _>>()
.change_context(QueryBuildingError::SqlSerializeError)
.attach_printable("Error serializing LIMIT BY columns")?;
self.limit_by = Some(LimitByClause { limit, columns });
Ok(())
}
<file_sep path="hyperswitch/crates/analytics/src/query.rs" role="context" start="464" end="467">
fn to_sql(&self, _table_engine: &TableEngine) -> error_stack::Result<String, ParsingError> {
let flag = *self;
Ok(i8::from(flag).to_string())
}
<file_sep path="hyperswitch/crates/analytics/src/query.rs" role="context" start="423" end="425">
pub trait ToSql<T: AnalyticsDataSource> {
fn to_sql(&self, table_engine: &TableEngine) -> error_stack::Result<String, ParsingError>;
}
<file_sep path="hyperswitch/crates/analytics/src/query.rs" role="context" start="371" end="374">
pub enum Filter {
Plain(String, FilterTypes, String),
NestedFilter(FilterCombinator, Vec<Filter>),
}
<file_sep path="hyperswitch/crates/analytics/src/query.rs" role="context" start="35" end="35">
pub type QueryResult<T> = error_stack::Result<T, QueryBuildingError>;
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/analytics/src/lambda_utils.rs<|crate|> analytics anchor=get_aws_client kind=fn pack=symbol_neighborhood lang=rust role_window=k1 hops=1<|meta_end|>
<file_sep path="hyperswitch/crates/analytics/src/lambda_utils.rs" role="context" start="9" end="13">
async fn get_aws_client(region: String) -> Client {
let region_provider = RegionProviderChain::first_try(Region::new(region));
let sdk_config = aws_config::from_env().region(region_provider).load().await;
Client::new(&sdk_config)
}
<file_sep path="hyperswitch/crates/analytics/src/lambda_utils.rs" role="context" start="8" end="8">
use aws_config::{self, meta::region::RegionProviderChain, Region};
use aws_sdk_lambda::{types::InvocationType::Event, Client};
<file_sep path="hyperswitch/crates/analytics/src/lambda_utils.rs" role="context" start="15" end="35">
pub async fn invoke_lambda(
function_name: &str,
region: &str,
json_bytes: &[u8],
) -> CustomResult<(), AnalyticsError> {
get_aws_client(region.to_string())
.await
.invoke()
.function_name(function_name)
.invocation_type(Event)
.payload(Blob::new(json_bytes.to_owned()))
.send()
.await
.map_err(|er| {
let er_rep = format!("{er:?}");
report!(er).attach_printable(er_rep)
})
.change_context(AnalyticsError::UnknownError)
.attach_printable("Lambda invocation failed")?;
Ok(())
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/analytics/src/opensearch.rs<|crate|> analytics anchor=get_opensearch_client kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=1<|meta_end|>
<file_sep path="hyperswitch/crates/analytics/src/opensearch.rs" role="context" start="422" end="431">
pub async fn get_opensearch_client(&self) -> StorageResult<Option<OpenSearchClient>> {
if !self.enabled {
return Ok(None);
}
Ok(Some(
OpenSearchClient::create(self)
.await
.change_context(StorageError::InitializationError)?,
))
}
<file_sep path="hyperswitch/crates/analytics/src/opensearch.rs" role="context" start="421" end="421">
use aws_config::{self, meta::region::RegionProviderChain, Region};
use storage_impl::errors::{ApplicationError, StorageError, StorageResult};
<file_sep path="hyperswitch/crates/analytics/src/opensearch.rs" role="context" start="485" end="503">
pub fn new(query_type: OpenSearchQuery, query: String, search_params: Vec<AuthInfo>) -> Self {
Self {
query_type,
query,
search_params,
offset: Default::default(),
count: Default::default(),
filters: Default::default(),
time_range: Default::default(),
case_sensitive_fields: HashSet::from([
"customer_email.keyword",
"search_tags.keyword",
"card_last_4.keyword",
"payment_id.keyword",
"amount",
"customer_id.keyword",
]),
}
}
<file_sep path="hyperswitch/crates/analytics/src/opensearch.rs" role="context" start="433" end="451">
pub fn validate(&self) -> Result<(), ApplicationError> {
use common_utils::{ext_traits::ConfigExt, fp_utils::when};
if !self.enabled {
return Ok(());
}
when(self.host.is_default_or_empty(), || {
Err(ApplicationError::InvalidConfigurationValueError(
"Opensearch host must not be empty".into(),
))
})?;
self.indexes.validate()?;
self.auth.validate()?;
Ok(())
}
<file_sep path="hyperswitch/crates/analytics/src/opensearch.rs" role="context" start="390" end="418">
pub fn validate(&self) -> Result<(), ApplicationError> {
use common_utils::{ext_traits::ConfigExt, fp_utils::when};
match self {
Self::Basic { username, password } => {
when(username.is_default_or_empty(), || {
Err(ApplicationError::InvalidConfigurationValueError(
"Opensearch Basic auth username must not be empty".into(),
))
})?;
when(password.is_default_or_empty(), || {
Err(ApplicationError::InvalidConfigurationValueError(
"Opensearch Basic auth password must not be empty".into(),
))
})?;
}
Self::Aws { region } => {
when(region.is_default_or_empty(), || {
Err(ApplicationError::InvalidConfigurationValueError(
"Opensearch Aws auth region must not be empty".into(),
))
})?;
}
};
Ok(())
}
<file_sep path="hyperswitch/crates/analytics/src/opensearch.rs" role="context" start="328" end="386">
pub fn validate(&self) -> Result<(), ApplicationError> {
use common_utils::{ext_traits::ConfigExt, fp_utils::when};
when(self.payment_attempts.is_default_or_empty(), || {
Err(ApplicationError::InvalidConfigurationValueError(
"Opensearch Payment Attempts index must not be empty".into(),
))
})?;
when(self.payment_intents.is_default_or_empty(), || {
Err(ApplicationError::InvalidConfigurationValueError(
"Opensearch Payment Intents index must not be empty".into(),
))
})?;
when(self.refunds.is_default_or_empty(), || {
Err(ApplicationError::InvalidConfigurationValueError(
"Opensearch Refunds index must not be empty".into(),
))
})?;
when(self.disputes.is_default_or_empty(), || {
Err(ApplicationError::InvalidConfigurationValueError(
"Opensearch Disputes index must not be empty".into(),
))
})?;
when(
self.sessionizer_payment_attempts.is_default_or_empty(),
|| {
Err(ApplicationError::InvalidConfigurationValueError(
"Opensearch Sessionizer Payment Attempts index must not be empty".into(),
))
},
)?;
when(
self.sessionizer_payment_intents.is_default_or_empty(),
|| {
Err(ApplicationError::InvalidConfigurationValueError(
"Opensearch Sessionizer Payment Intents index must not be empty".into(),
))
},
)?;
when(self.sessionizer_refunds.is_default_or_empty(), || {
Err(ApplicationError::InvalidConfigurationValueError(
"Opensearch Sessionizer Refunds index must not be empty".into(),
))
})?;
when(self.sessionizer_disputes.is_default_or_empty(), || {
Err(ApplicationError::InvalidConfigurationValueError(
"Opensearch Sessionizer Disputes index must not be empty".into(),
))
})?;
Ok(())
}
<file_sep path="hyperswitch/crates/analytics/src/opensearch.rs" role="context" start="202" end="234">
pub async fn create(conf: &OpenSearchConfig) -> CustomResult<Self, OpenSearchError> {
let url = Url::parse(&conf.host).map_err(|_| OpenSearchError::ConnectionError)?;
let transport = match &conf.auth {
OpenSearchAuth::Basic { username, password } => {
let credentials = Credentials::Basic(username.clone(), password.clone());
TransportBuilder::new(SingleNodeConnectionPool::new(url))
.cert_validation(CertificateValidation::None)
.auth(credentials)
.build()
.map_err(|_| OpenSearchError::ConnectionError)?
}
OpenSearchAuth::Aws { region } => {
let region_provider = RegionProviderChain::first_try(Region::new(region.clone()));
let sdk_config = aws_config::from_env().region(region_provider).load().await;
let conn_pool = SingleNodeConnectionPool::new(url);
TransportBuilder::new(conn_pool)
.auth(
sdk_config
.clone()
.try_into()
.map_err(|_| OpenSearchError::ConnectionError)?,
)
.service_name("es")
.build()
.map_err(|_| OpenSearchError::ConnectionError)?
}
};
Ok(Self {
transport: transport.clone(),
client: OpenSearch::new(transport),
indexes: conf.indexes.clone(),
})
}
<file_sep path="hyperswitch/crates/analytics/src/opensearch.rs" role="context" start="195" end="199">
pub struct OpenSearchClient {
pub client: OpenSearch,
pub transport: Transport,
pub indexes: OpenSearchIndexes,
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/analytics/src/metrics/request.rs<|crate|> analytics anchor=time_future kind=fn pack=symbol_neighborhood lang=rust role_window=k1 hops=1<|meta_end|>
<file_sep path="hyperswitch/crates/analytics/src/metrics/request.rs" role="context" start="27" end="35">
pub async fn time_future<F, R>(future: F) -> (R, time::Duration)
where
F: futures::Future<Output = R>,
{
let start = time::Instant::now();
let result = future.await;
let time_spent = start.elapsed();
(result, time_spent)
}
<file_sep path="hyperswitch/crates/analytics/src/metrics/request.rs" role="context" start="26" end="26">
use std::time;
<file_sep path="hyperswitch/crates/analytics/src/metrics/request.rs" role="context" start="4" end="24">
pub async fn record_operation_time<F, R, T>(
future: F,
metric: &once_cell::sync::Lazy<router_env::opentelemetry::metrics::Histogram<f64>>,
metric_name: &T,
source: &crate::AnalyticsProvider,
) -> R
where
F: futures::Future<Output = R>,
T: ToString,
{
let (result, time) = time_future(future).await;
let attributes = router_env::metric_attributes!(
("metric_name", metric_name.to_string()),
("source", source.to_string()),
);
let value = time.as_secs_f64();
metric.record(value, attributes);
router_env::logger::debug!("Attributes: {:?}, Time: {}", attributes, value);
result
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/analytics/src/lambda_utils.rs<|crate|> analytics anchor=invoke_lambda kind=fn pack=symbol_neighborhood lang=rust role_window=k1 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/analytics/src/lambda_utils.rs" role="context" start="15" end="35">
pub async fn invoke_lambda(
function_name: &str,
region: &str,
json_bytes: &[u8],
) -> CustomResult<(), AnalyticsError> {
get_aws_client(region.to_string())
.await
.invoke()
.function_name(function_name)
.invocation_type(Event)
.payload(Blob::new(json_bytes.to_owned()))
.send()
.await
.map_err(|er| {
let er_rep = format!("{er:?}");
report!(er).attach_printable(er_rep)
})
.change_context(AnalyticsError::UnknownError)
.attach_printable("Lambda invocation failed")?;
Ok(())
}
<file_sep path="hyperswitch/crates/analytics/src/lambda_utils.rs" role="context" start="14" end="14">
use aws_config::{self, meta::region::RegionProviderChain, Region};
use aws_sdk_lambda::{types::InvocationType::Event, Client};
use aws_smithy_types::Blob;
use common_utils::errors::CustomResult;
use error_stack::{report, ResultExt};
use crate::errors::AnalyticsError;
<file_sep path="hyperswitch/crates/analytics/src/lambda_utils.rs" role="context" start="9" end="13">
async fn get_aws_client(region: String) -> Client {
let region_provider = RegionProviderChain::first_try(Region::new(region));
let sdk_config = aws_config::from_env().region(region_provider).load().await;
Client::new(&sdk_config)
}
<file_sep path="hyperswitch/crates/analytics/src/errors.rs" role="context" start="7" end="17">
pub enum AnalyticsError {
#[allow(dead_code)]
#[error("Not implemented: {0}")]
NotImplemented(&'static str),
#[error("Unknown Analytics Error")]
UnknownError,
#[error("Access Forbidden Analytics Error")]
AccessForbiddenError,
#[error("Failed to fetch currency exchange rate")]
ForexFetchFailed,
}
<file_sep path="hyperswitch/migrations/2022-09-29-084920_create_initial_tables/up.sql" role="context" start="279" end="295">
phone_country_code VARCHAR(255),
description VARCHAR(255),
address JSON,
created_at TIMESTAMP NOT NULL DEFAULT now()::TIMESTAMP,
metadata JSON,
PRIMARY KEY (customer_id, merchant_id)
);
CREATE TABLE events (
id SERIAL PRIMARY KEY,
event_id VARCHAR(255) NOT NULL,
event_type "EventType" NOT NULL,
event_class "EventClass" NOT NULL,
is_webhook_notified BOOLEAN NOT NULL DEFAULT FALSE,
intent_reference_id VARCHAR(255),
primary_object_id VARCHAR(255) NOT NULL,
primary_object_type "EventObjectType" NOT NULL,
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/analytics/src/query.rs<|crate|> analytics anchor=to_sql kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/analytics/src/query.rs" role="context" start="383" end="400">
fn to_sql(&self, table_engine: &TableEngine) -> error_stack::Result<String, ParsingError> {
Ok(match self {
Self::Plain(l, op, r) => filter_type_to_sql(l, *op, r),
Self::NestedFilter(operator, filters) => {
format!(
"( {} )",
filters
.iter()
.map(|f| <Self as ToSql<T>>::to_sql(f, table_engine))
.collect::<Result<Vec<String>, _>>()?
.join(
<FilterCombinator as ToSql<T>>::to_sql(operator, table_engine)?
.as_ref()
)
)
}
})
}
<file_sep path="hyperswitch/crates/analytics/src/query.rs" role="context" start="382" end="382">
use api_models::{
analytics::{
self as analytics_api,
api_event::ApiEventDimensions,
auth_events::{AuthEventDimensions, AuthEventFlows},
disputes::DisputeDimensions,
frm::{FrmDimensions, FrmTransactionType},
payment_intents::PaymentIntentDimensions,
payments::{PaymentDimensions, PaymentDistributions},
refunds::{RefundDimensions, RefundDistributions, RefundType},
sdk_events::{SdkEventDimensions, SdkEventNames},
Granularity,
},
enums::{
AttemptStatus, AuthenticationType, Connector, Currency, DisputeStage, IntentStatus,
PaymentMethod, PaymentMethodType,
},
refunds::RefundStatus,
};
use common_utils::{
errors::{CustomResult, ParsingError},
id_type::{MerchantId, OrganizationId, ProfileId},
};
use diesel_models::{enums as storage_enums, enums::FraudCheckStatus};
use error_stack::ResultExt;
use super::types::{AnalyticsCollection, AnalyticsDataSource, LoadRow, TableEngine};
pub type QueryResult<T> = error_stack::Result<T, QueryBuildingError>;
<file_sep path="hyperswitch/crates/analytics/src/query.rs" role="context" start="434" end="436">
fn to_sql(&self, _table_engine: &TableEngine) -> error_stack::Result<String, ParsingError> {
Ok(self.get_string_repr().to_owned())
}
<file_sep path="hyperswitch/crates/analytics/src/query.rs" role="context" start="428" end="430">
fn to_sql(&self, _table_engine: &TableEngine) -> error_stack::Result<String, ParsingError> {
Ok(self.get_string_repr().to_owned())
}
<file_sep path="hyperswitch/crates/analytics/src/query.rs" role="context" start="377" end="379">
fn default() -> Self {
Self::NestedFilter(FilterCombinator::default(), Vec::new())
}
<file_sep path="hyperswitch/crates/analytics/src/query.rs" role="context" start="361" end="367">
fn to_sql(&self, _table_engine: &TableEngine) -> error_stack::Result<String, ParsingError> {
Ok(match self {
Self::And => " AND ",
Self::Or => " OR ",
}
.to_owned())
}
<file_sep path="hyperswitch/crates/analytics/src/query.rs" role="context" start="548" end="561">
pub fn filter_type_to_sql(l: &str, op: FilterTypes, r: &str) -> String {
match op {
FilterTypes::EqualBool => format!("{l} = {r}"),
FilterTypes::Equal => format!("{l} = '{r}'"),
FilterTypes::NotEqual => format!("{l} != '{r}'"),
FilterTypes::In => format!("{l} IN ({r})"),
FilterTypes::Gte => format!("{l} >= '{r}'"),
FilterTypes::Gt => format!("{l} > {r}"),
FilterTypes::Lte => format!("{l} <= '{r}'"),
FilterTypes::Like => format!("{l} LIKE '%{r}%'"),
FilterTypes::NotLike => format!("{l} NOT LIKE '%{r}%'"),
FilterTypes::IsNotNull => format!("{l} IS NOT NULL"),
}
}
<file_sep path="hyperswitch/crates/analytics/src/query.rs" role="context" start="423" end="425">
pub trait ToSql<T: AnalyticsDataSource> {
fn to_sql(&self, table_engine: &TableEngine) -> error_stack::Result<String, ParsingError>;
}
<file_sep path="hyperswitch/crates/analytics/src/query.rs" role="context" start="354" end="358">
pub enum FilterCombinator {
#[default]
And,
Or,
}
<file_sep path="hyperswitch/crates/analytics/src/types.rs" role="context" start="49" end="52">
pub enum TableEngine {
CollapsingMergeTree { sign: &'static str },
BasicTree,
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/analytics/src/opensearch.rs<|crate|> analytics anchor=deep_health_check kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/analytics/src/opensearch.rs" role="context" start="306" end="324">
async fn deep_health_check(&self) -> CustomResult<(), QueryExecutionError> {
let health = Cluster::new(&self.transport)
.health(ClusterHealthParts::None)
.send()
.await
.change_context(QueryExecutionError::DatabaseError)?
.json::<OpenSearchHealth>()
.await
.change_context(QueryExecutionError::DatabaseError)?;
if health.status != OpenSearchHealthStatus::Red {
Ok(())
} else {
Err::<(), error_stack::Report<QueryExecutionError>>(
QueryExecutionError::DatabaseError.into(),
)
.attach_printable_lazy(|| format!("Opensearch cluster health is red: {health:?}"))
}
}
<file_sep path="hyperswitch/crates/analytics/src/opensearch.rs" role="context" start="305" end="305">
use aws_config::{self, meta::region::RegionProviderChain, Region};
use common_utils::{
errors::{CustomResult, ErrorSwitch},
types::TimeRange,
};
use error_stack::ResultExt;
use opensearch::{
auth::Credentials,
cert::CertificateValidation,
cluster::{Cluster, ClusterHealthParts},
http::{
request::JsonBody,
response::Response,
transport::{SingleNodeConnectionPool, Transport, TransportBuilder},
Url,
},
MsearchParts, OpenSearch, SearchParts,
};
use serde_json::{json, Map, Value};
use super::{health_check::HealthCheck, query::QueryResult, types::QueryExecutionError};
<file_sep path="hyperswitch/crates/analytics/src/opensearch.rs" role="context" start="390" end="418">
pub fn validate(&self) -> Result<(), ApplicationError> {
use common_utils::{ext_traits::ConfigExt, fp_utils::when};
match self {
Self::Basic { username, password } => {
when(username.is_default_or_empty(), || {
Err(ApplicationError::InvalidConfigurationValueError(
"Opensearch Basic auth username must not be empty".into(),
))
})?;
when(password.is_default_or_empty(), || {
Err(ApplicationError::InvalidConfigurationValueError(
"Opensearch Basic auth password must not be empty".into(),
))
})?;
}
Self::Aws { region } => {
when(region.is_default_or_empty(), || {
Err(ApplicationError::InvalidConfigurationValueError(
"Opensearch Aws auth region must not be empty".into(),
))
})?;
}
};
Ok(())
}
<file_sep path="hyperswitch/crates/analytics/src/opensearch.rs" role="context" start="328" end="386">
pub fn validate(&self) -> Result<(), ApplicationError> {
use common_utils::{ext_traits::ConfigExt, fp_utils::when};
when(self.payment_attempts.is_default_or_empty(), || {
Err(ApplicationError::InvalidConfigurationValueError(
"Opensearch Payment Attempts index must not be empty".into(),
))
})?;
when(self.payment_intents.is_default_or_empty(), || {
Err(ApplicationError::InvalidConfigurationValueError(
"Opensearch Payment Intents index must not be empty".into(),
))
})?;
when(self.refunds.is_default_or_empty(), || {
Err(ApplicationError::InvalidConfigurationValueError(
"Opensearch Refunds index must not be empty".into(),
))
})?;
when(self.disputes.is_default_or_empty(), || {
Err(ApplicationError::InvalidConfigurationValueError(
"Opensearch Disputes index must not be empty".into(),
))
})?;
when(
self.sessionizer_payment_attempts.is_default_or_empty(),
|| {
Err(ApplicationError::InvalidConfigurationValueError(
"Opensearch Sessionizer Payment Attempts index must not be empty".into(),
))
},
)?;
when(
self.sessionizer_payment_intents.is_default_or_empty(),
|| {
Err(ApplicationError::InvalidConfigurationValueError(
"Opensearch Sessionizer Payment Intents index must not be empty".into(),
))
},
)?;
when(self.sessionizer_refunds.is_default_or_empty(), || {
Err(ApplicationError::InvalidConfigurationValueError(
"Opensearch Sessionizer Refunds index must not be empty".into(),
))
})?;
when(self.sessionizer_disputes.is_default_or_empty(), || {
Err(ApplicationError::InvalidConfigurationValueError(
"Opensearch Sessionizer Disputes index must not be empty".into(),
))
})?;
Ok(())
}
<file_sep path="hyperswitch/crates/analytics/src/opensearch.rs" role="context" start="253" end="301">
pub async fn execute(
&self,
query_builder: OpenSearchQueryBuilder,
) -> CustomResult<Response, OpenSearchError> {
match query_builder.query_type {
OpenSearchQuery::Msearch(ref indexes) => {
let payload = query_builder
.construct_payload(indexes)
.change_context(OpenSearchError::QueryBuildingError)?;
let payload_with_indexes = payload.into_iter().zip(indexes).fold(
Vec::new(),
|mut payload_with_indexes, (index_hit, index)| {
payload_with_indexes.push(
json!({"index": self.search_index_to_opensearch_index(*index)}).into(),
);
payload_with_indexes.push(JsonBody::new(index_hit.clone()));
payload_with_indexes
},
);
self.client
.msearch(MsearchParts::None)
.body(payload_with_indexes)
.send()
.await
.change_context(OpenSearchError::ResponseError)
}
OpenSearchQuery::Search(index) => {
let payload = query_builder
.clone()
.construct_payload(&[index])
.change_context(OpenSearchError::QueryBuildingError)?;
let final_payload = payload.first().unwrap_or(&Value::Null);
self.client
.search(SearchParts::Index(&[
&self.search_index_to_opensearch_index(index)
]))
.from(query_builder.offset.unwrap_or(0))
.size(query_builder.count.unwrap_or(10))
.body(final_payload)
.send()
.await
.change_context(OpenSearchError::ResponseError)
}
}
}
<file_sep path="hyperswitch/crates/analytics/src/opensearch.rs" role="context" start="236" end="251">
pub fn search_index_to_opensearch_index(&self, index: SearchIndex) -> String {
match index {
SearchIndex::PaymentAttempts => self.indexes.payment_attempts.clone(),
SearchIndex::PaymentIntents => self.indexes.payment_intents.clone(),
SearchIndex::Refunds => self.indexes.refunds.clone(),
SearchIndex::Disputes => self.indexes.disputes.clone(),
SearchIndex::SessionizerPaymentAttempts => {
self.indexes.sessionizer_payment_attempts.clone()
}
SearchIndex::SessionizerPaymentIntents => {
self.indexes.sessionizer_payment_intents.clone()
}
SearchIndex::SessionizerRefunds => self.indexes.sessionizer_refunds.clone(),
SearchIndex::SessionizerDisputes => self.indexes.sessionizer_disputes.clone(),
}
}
<file_sep path="hyperswitch/crates/analytics/src/opensearch.rs" role="context" start="485" end="503">
pub fn new(query_type: OpenSearchQuery, query: String, search_params: Vec<AuthInfo>) -> Self {
Self {
query_type,
query,
search_params,
offset: Default::default(),
count: Default::default(),
filters: Default::default(),
time_range: Default::default(),
case_sensitive_fields: HashSet::from([
"customer_email.keyword",
"search_tags.keyword",
"card_last_4.keyword",
"payment_id.keyword",
"amount",
"customer_id.keyword",
]),
}
}
<file_sep path="hyperswitch/crates/analytics/src/opensearch.rs" role="context" start="462" end="464">
pub struct OpenSearchHealth {
pub status: OpenSearchHealthStatus,
}
<file_sep path="hyperswitch/crates/analytics/src/opensearch.rs" role="context" start="455" end="459">
pub enum OpenSearchHealthStatus {
Red,
Green,
Yellow,
}
<file_sep path="hyperswitch/crates/analytics/src/types.rs" role="context" start="74" end="74">
type Err = Report<ParsingError>;
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/analytics/src/metrics/request.rs<|crate|> analytics anchor=record_operation_time kind=fn pack=symbol_neighborhood lang=rust role_window=k1 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/analytics/src/metrics/request.rs" role="context" start="4" end="24">
pub async fn record_operation_time<F, R, T>(
future: F,
metric: &once_cell::sync::Lazy<router_env::opentelemetry::metrics::Histogram<f64>>,
metric_name: &T,
source: &crate::AnalyticsProvider,
) -> R
where
F: futures::Future<Output = R>,
T: ToString,
{
let (result, time) = time_future(future).await;
let attributes = router_env::metric_attributes!(
("metric_name", metric_name.to_string()),
("source", source.to_string()),
);
let value = time.as_secs_f64();
metric.record(value, attributes);
router_env::logger::debug!("Attributes: {:?}, Time: {}", attributes, value);
result
}
<file_sep path="hyperswitch/crates/analytics/src/metrics/request.rs" role="context" start="3" end="3">
use std::time;
<file_sep path="hyperswitch/crates/analytics/src/metrics/request.rs" role="context" start="27" end="35">
pub async fn time_future<F, R>(future: F) -> (R, time::Duration)
where
F: futures::Future<Output = R>,
{
let start = time::Instant::now();
let result = future.await;
let time_spent = start.elapsed();
(result, time_spent)
}
<file_sep path="hyperswitch/crates/analytics/src/lib.rs" role="context" start="87" end="92">
pub enum AnalyticsProvider {
Sqlx(SqlxClient),
Clickhouse(ClickhouseClient),
CombinedCkh(SqlxClient, ClickhouseClient),
CombinedSqlx(SqlxClient, ClickhouseClient),
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/analytics/src/sqlx.rs<|crate|> analytics anchor=from_row kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/analytics/src/sqlx.rs" role="context" start="1014" end="1034">
fn from_row(row: &'a PgRow) -> sqlx::Result<Self> {
let frm_name: Option<String> = row.try_get("frm_name").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let frm_status: Option<DBEnumWrapper<FraudCheckStatus>> =
row.try_get("frm_status").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let frm_transaction_type: Option<DBEnumWrapper<FrmTransactionType>> =
row.try_get("frm_transaction_type").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
Ok(Self {
frm_name,
frm_status,
frm_transaction_type,
})
}
<file_sep path="hyperswitch/crates/analytics/src/sqlx.rs" role="context" start="1013" end="1013">
use api_models::{
analytics::{frm::FrmTransactionType, refunds::RefundType},
enums::{DisputeStage, DisputeStatus},
};
use diesel_models::enums::{
AttemptStatus, AuthenticationType, Currency, FraudCheckStatus, IntentStatus, PaymentMethod,
RefundStatus,
};
use sqlx::{
postgres::{PgArgumentBuffer, PgPoolOptions, PgRow, PgTypeInfo, PgValueRef},
Decode, Encode,
Error::ColumnNotFound,
FromRow, Pool, Postgres, Row,
};
use super::{
health_check::HealthCheck,
query::{Aggregate, ToSql, Window},
types::{
AnalyticsCollection, AnalyticsDataSource, DBEnumWrapper, LoadRow, QueryExecutionError,
TableEngine,
},
};
<file_sep path="hyperswitch/crates/analytics/src/sqlx.rs" role="context" start="1072" end="1117">
fn from_row(row: &'a PgRow) -> sqlx::Result<Self> {
let dispute_stage: Option<DBEnumWrapper<DisputeStage>> =
row.try_get("dispute_stage").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let dispute_status: Option<DBEnumWrapper<DisputeStatus>> =
row.try_get("dispute_status").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let connector: Option<String> = row.try_get("connector").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let currency: Option<DBEnumWrapper<Currency>> =
row.try_get("currency").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let total: Option<bigdecimal::BigDecimal> = row.try_get("total").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let count: Option<i64> = row.try_get("count").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
// Removing millisecond precision to get accurate diffs against clickhouse
let start_bucket: Option<PrimitiveDateTime> = row
.try_get::<Option<PrimitiveDateTime>, _>("start_bucket")?
.and_then(|dt| dt.replace_millisecond(0).ok());
let end_bucket: Option<PrimitiveDateTime> = row
.try_get::<Option<PrimitiveDateTime>, _>("end_bucket")?
.and_then(|dt| dt.replace_millisecond(0).ok());
Ok(Self {
dispute_stage,
dispute_status,
connector,
currency,
total,
count,
start_bucket,
end_bucket,
})
}
<file_sep path="hyperswitch/crates/analytics/src/sqlx.rs" role="context" start="1038" end="1069">
fn from_row(row: &'a PgRow) -> sqlx::Result<Self> {
let dispute_stage: Option<String> = row.try_get("dispute_stage").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let dispute_status: Option<String> =
row.try_get("dispute_status").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let connector: Option<String> = row.try_get("connector").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let connector_status: Option<String> =
row.try_get("connector_status").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let currency: Option<DBEnumWrapper<Currency>> =
row.try_get("currency").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
Ok(Self {
dispute_stage,
dispute_status,
connector,
connector_status,
currency,
})
}
<file_sep path="hyperswitch/crates/analytics/src/sqlx.rs" role="context" start="949" end="1010">
fn from_row(row: &'a PgRow) -> sqlx::Result<Self> {
let currency: Option<DBEnumWrapper<Currency>> =
row.try_get("currency").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let refund_status: Option<DBEnumWrapper<RefundStatus>> =
row.try_get("refund_status").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let connector: Option<String> = row.try_get("connector").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let refund_type: Option<DBEnumWrapper<RefundType>> =
row.try_get("refund_type").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let profile_id: Option<String> = row.try_get("profile_id").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let total: Option<bigdecimal::BigDecimal> = row.try_get("total").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let count: Option<i64> = row.try_get("count").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let refund_reason: Option<String> = row.try_get("refund_reason").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let refund_error_message: Option<String> =
row.try_get("refund_error_message").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
// Removing millisecond precision to get accurate diffs against clickhouse
let start_bucket: Option<PrimitiveDateTime> = row
.try_get::<Option<PrimitiveDateTime>, _>("start_bucket")?
.and_then(|dt| dt.replace_millisecond(0).ok());
let end_bucket: Option<PrimitiveDateTime> = row
.try_get::<Option<PrimitiveDateTime>, _>("end_bucket")?
.and_then(|dt| dt.replace_millisecond(0).ok());
Ok(Self {
currency,
refund_status,
connector,
refund_type,
profile_id,
total,
count,
refund_reason,
refund_error_message,
start_bucket,
end_bucket,
})
}
<file_sep path="hyperswitch/crates/analytics/src/sqlx.rs" role="context" start="903" end="945">
fn from_row(row: &'a PgRow) -> sqlx::Result<Self> {
let currency: Option<DBEnumWrapper<Currency>> =
row.try_get("currency").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let refund_status: Option<DBEnumWrapper<RefundStatus>> =
row.try_get("refund_status").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let connector: Option<String> = row.try_get("connector").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let refund_type: Option<DBEnumWrapper<RefundType>> =
row.try_get("refund_type").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let profile_id: Option<String> = row.try_get("profile_id").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let refund_reason: Option<String> = row.try_get("refund_reason").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let refund_error_message: Option<String> =
row.try_get("refund_error_message").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
Ok(Self {
currency,
refund_status,
connector,
refund_type,
profile_id,
refund_reason,
refund_error_message,
})
}
<file_sep path="hyperswitch/crates/analytics/src/sqlx.rs" role="context" start="43" end="54">
fn default() -> Self {
let database_url = format!(
"postgres://{}:{}@{}:{}/{}",
"db_user", "db_pass", "localhost", 5432, "hyperswitch_db"
);
Self {
#[allow(clippy::expect_used)]
pool: PgPoolOptions::new()
.connect_lazy(&database_url)
.expect("SQLX Pool Creation failed"),
}
}
<file_sep path="hyperswitch/crates/analytics/src/types.rs" role="context" start="74" end="74">
type Err = Report<ParsingError>;
<file_sep path="hyperswitch/crates/api_models/src/analytics/frm.rs" role="context" start="22" end="26">
pub enum FrmTransactionType {
#[default]
PreFrm,
PostFrm,
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/analytics/src/opensearch.rs<|crate|> analytics anchor=default kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=1<|meta_end|>
<file_sep path="hyperswitch/crates/analytics/src/opensearch.rs" role="context" start="79" end="98">
fn default() -> Self {
Self {
host: "https://localhost:9200".to_string(),
auth: OpenSearchAuth::Basic {
username: "admin".to_string(),
password: "admin".to_string(),
},
indexes: OpenSearchIndexes {
payment_attempts: "hyperswitch-payment-attempt-events".to_string(),
payment_intents: "hyperswitch-payment-intent-events".to_string(),
refunds: "hyperswitch-refund-events".to_string(),
disputes: "hyperswitch-dispute-events".to_string(),
sessionizer_payment_attempts: "sessionizer-payment-attempt-events".to_string(),
sessionizer_payment_intents: "sessionizer-payment-intent-events".to_string(),
sessionizer_refunds: "sessionizer-refund-events".to_string(),
sessionizer_disputes: "sessionizer-dispute-events".to_string(),
},
enabled: false,
}
}
<file_sep path="hyperswitch/crates/analytics/src/opensearch.rs" role="context" start="78" end="78">
use opensearch::{
auth::Credentials,
cert::CertificateValidation,
cluster::{Cluster, ClusterHealthParts},
http::{
request::JsonBody,
response::Response,
transport::{SingleNodeConnectionPool, Transport, TransportBuilder},
Url,
},
MsearchParts, OpenSearch, SearchParts,
};
<file_sep path="hyperswitch/crates/analytics/src/opensearch.rs" role="context" start="132" end="191">
fn switch(&self) -> ApiErrorResponse {
match self {
Self::ConnectionError => ApiErrorResponse::InternalServerError(ApiError::new(
"IR",
0,
"Connection error",
None,
)),
Self::BadRequestError(response) => {
ApiErrorResponse::BadRequest(ApiError::new("IR", 1, response.to_string(), None))
}
Self::ResponseNotOK(response) => ApiErrorResponse::InternalServerError(ApiError::new(
"IR",
1,
format!("Something went wrong {}", response),
None,
)),
Self::ResponseError => ApiErrorResponse::InternalServerError(ApiError::new(
"IR",
2,
"Something went wrong",
None,
)),
Self::QueryBuildingError => ApiErrorResponse::InternalServerError(ApiError::new(
"IR",
3,
"Query building error",
None,
)),
Self::DeserialisationError => ApiErrorResponse::InternalServerError(ApiError::new(
"IR",
4,
"Deserialisation error",
None,
)),
Self::IndexAccessNotPermittedError(index) => {
ApiErrorResponse::ForbiddenCommonResource(ApiError::new(
"IR",
5,
format!("Index access not permitted: {index:?}"),
None,
))
}
Self::UnknownError => {
ApiErrorResponse::InternalServerError(ApiError::new("IR", 6, "Unknown error", None))
}
Self::AccessForbiddenError => ApiErrorResponse::ForbiddenCommonResource(ApiError::new(
"IR",
7,
"Access Forbidden error",
None,
)),
Self::NotEnabled => ApiErrorResponse::InternalServerError(ApiError::new(
"IR",
8,
"Opensearch is not enabled",
None,
)),
}
}
<file_sep path="hyperswitch/crates/analytics/src/opensearch.rs" role="context" start="126" end="128">
fn switch(&self) -> OpenSearchError {
OpenSearchError::QueryBuildingError
}
<file_sep path="hyperswitch/crates/analytics/src/opensearch.rs" role="context" start="61" end="66">
fn from(time_range: TimeRange) -> Self {
Self {
gte: time_range.start_time,
lte: time_range.end_time,
}
}
<file_sep path="hyperswitch/crates/analytics/src/opensearch.rs" role="context" start="485" end="503">
pub fn new(query_type: OpenSearchQuery, query: String, search_params: Vec<AuthInfo>) -> Self {
Self {
query_type,
query,
search_params,
offset: Default::default(),
count: Default::default(),
filters: Default::default(),
time_range: Default::default(),
case_sensitive_fields: HashSet::from([
"customer_email.keyword",
"search_tags.keyword",
"card_last_4.keyword",
"payment_id.keyword",
"amount",
"customer_id.keyword",
]),
}
}
<file_sep path="hyperswitch/crates/analytics/src/opensearch.rs" role="context" start="41" end="50">
pub struct OpenSearchIndexes {
pub payment_attempts: String,
pub payment_intents: String,
pub refunds: String,
pub disputes: String,
pub sessionizer_payment_attempts: String,
pub sessionizer_payment_intents: String,
pub sessionizer_refunds: String,
pub sessionizer_disputes: String,
}
<file_sep path="hyperswitch/crates/analytics/src/opensearch.rs" role="context" start="35" end="38">
pub enum OpenSearchAuth {
Basic { username: String, password: String },
Aws { region: String },
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/analytics/src/opensearch.rs<|crate|> analytics anchor=build_filter_array kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/analytics/src/opensearch.rs" role="context" start="537" end="577">
pub fn build_filter_array(
&self,
case_sensitive_filters: Vec<&(String, Vec<Value>)>,
index: SearchIndex,
) -> Vec<Value> {
let mut filter_array = Vec::new();
if !self.query.is_empty() {
filter_array.push(json!({
"multi_match": {
"type": "phrase",
"query": self.query,
"lenient": true
}
}));
}
let case_sensitive_json_filters = case_sensitive_filters
.into_iter()
.map(|(k, v)| {
let key = if *k == "amount" {
self.get_amount_field(index).to_string()
} else {
k.clone()
};
json!({"terms": {key: v}})
})
.collect::<Vec<Value>>();
filter_array.extend(case_sensitive_json_filters);
if let Some(ref time_range) = self.time_range {
let range = json!(time_range);
filter_array.push(json!({
"range": {
"@timestamp": range
}
}));
}
filter_array
}
<file_sep path="hyperswitch/crates/analytics/src/opensearch.rs" role="context" start="536" end="536">
use api_models::{
analytics::search::SearchIndex,
errors::types::{ApiError, ApiErrorResponse},
};
use aws_config::{self, meta::region::RegionProviderChain, Region};
use serde_json::{json, Map, Value};
use super::{health_check::HealthCheck, query::QueryResult, types::QueryExecutionError};
use crate::{enums::AuthInfo, query::QueryBuildingError};
<file_sep path="hyperswitch/crates/analytics/src/opensearch.rs" role="context" start="640" end="719">
pub fn build_auth_array(&self) -> Vec<Value> {
self.search_params
.iter()
.map(|user_level| match user_level {
AuthInfo::OrgLevel { org_id } => {
let must_clauses = vec![json!({
"term": {
"organization_id.keyword": {
"value": org_id
}
}
})];
json!({
"bool": {
"must": must_clauses
}
})
}
AuthInfo::MerchantLevel {
org_id,
merchant_ids,
} => {
let must_clauses = vec![
json!({
"term": {
"organization_id.keyword": {
"value": org_id
}
}
}),
json!({
"terms": {
"merchant_id.keyword": merchant_ids
}
}),
];
json!({
"bool": {
"must": must_clauses
}
})
}
AuthInfo::ProfileLevel {
org_id,
merchant_id,
profile_ids,
} => {
let must_clauses = vec![
json!({
"term": {
"organization_id.keyword": {
"value": org_id
}
}
}),
json!({
"term": {
"merchant_id.keyword": {
"value": merchant_id
}
}
}),
json!({
"terms": {
"profile_id.keyword": profile_ids
}
}),
];
json!({
"bool": {
"must": must_clauses
}
})
}
})
.collect::<Vec<Value>>()
}
<file_sep path="hyperswitch/crates/analytics/src/opensearch.rs" role="context" start="579" end="638">
pub fn build_case_insensitive_filters(
&self,
mut payload: Value,
case_insensitive_filters: &[&(String, Vec<Value>)],
auth_array: Vec<Value>,
index: SearchIndex,
) -> Value {
let mut must_array = case_insensitive_filters
.iter()
.map(|(k, v)| {
let key = if *k == "status.keyword" {
self.get_status_field(index).to_string()
} else {
k.clone()
};
json!({
"bool": {
"must": [
{
"bool": {
"should": v.iter().map(|value| {
json!({
"term": {
format!("{}", key): {
"value": value,
"case_insensitive": true
}
}
})
}).collect::<Vec<Value>>(),
"minimum_should_match": 1
}
}
]
}
})
})
.collect::<Vec<Value>>();
must_array.push(json!({ "bool": {
"must": [
{
"bool": {
"should": auth_array,
"minimum_should_match": 1
}
}
]
}}));
if let Some(query) = payload.get_mut("query") {
if let Some(bool_obj) = query.get_mut("bool") {
if let Some(bool_map) = bool_obj.as_object_mut() {
bool_map.insert("must".to_string(), Value::Array(must_array));
}
}
}
payload
}
<file_sep path="hyperswitch/crates/analytics/src/opensearch.rs" role="context" start="529" end="535">
pub fn get_amount_field(&self, index: SearchIndex) -> &str {
match index {
SearchIndex::Refunds | SearchIndex::SessionizerRefunds => "refund_amount",
SearchIndex::Disputes | SearchIndex::SessionizerDisputes => "dispute_amount",
_ => "amount",
}
}
<file_sep path="hyperswitch/crates/analytics/src/opensearch.rs" role="context" start="521" end="527">
pub fn get_status_field(&self, index: SearchIndex) -> &str {
match index {
SearchIndex::Refunds | SearchIndex::SessionizerRefunds => "refund_status.keyword",
SearchIndex::Disputes | SearchIndex::SessionizerDisputes => "dispute_status.keyword",
_ => "status.keyword",
}
}
<file_sep path="hyperswitch/crates/analytics/src/opensearch.rs" role="context" start="485" end="503">
pub fn new(query_type: OpenSearchQuery, query: String, search_params: Vec<AuthInfo>) -> Self {
Self {
query_type,
query,
search_params,
offset: Default::default(),
count: Default::default(),
filters: Default::default(),
time_range: Default::default(),
case_sensitive_fields: HashSet::from([
"customer_email.keyword",
"search_tags.keyword",
"card_last_4.keyword",
"payment_id.keyword",
"amount",
"customer_id.keyword",
]),
}
}
<file_sep path="hyperswitch/crates/api_models/src/analytics/search.rs" role="context" start="70" end="79">
pub enum SearchIndex {
PaymentAttempts,
PaymentIntents,
Refunds,
Disputes,
SessionizerPaymentAttempts,
SessionizerPaymentIntents,
SessionizerRefunds,
SessionizerDisputes,
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/analytics/src/sqlx.rs<|crate|> analytics anchor=from_row kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/analytics/src/sqlx.rs" role="context" start="1038" end="1069">
fn from_row(row: &'a PgRow) -> sqlx::Result<Self> {
let dispute_stage: Option<String> = row.try_get("dispute_stage").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let dispute_status: Option<String> =
row.try_get("dispute_status").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let connector: Option<String> = row.try_get("connector").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let connector_status: Option<String> =
row.try_get("connector_status").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let currency: Option<DBEnumWrapper<Currency>> =
row.try_get("currency").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
Ok(Self {
dispute_stage,
dispute_status,
connector,
connector_status,
currency,
})
}
<file_sep path="hyperswitch/crates/analytics/src/sqlx.rs" role="context" start="1037" end="1037">
use diesel_models::enums::{
AttemptStatus, AuthenticationType, Currency, FraudCheckStatus, IntentStatus, PaymentMethod,
RefundStatus,
};
use sqlx::{
postgres::{PgArgumentBuffer, PgPoolOptions, PgRow, PgTypeInfo, PgValueRef},
Decode, Encode,
Error::ColumnNotFound,
FromRow, Pool, Postgres, Row,
};
use super::{
health_check::HealthCheck,
query::{Aggregate, ToSql, Window},
types::{
AnalyticsCollection, AnalyticsDataSource, DBEnumWrapper, LoadRow, QueryExecutionError,
TableEngine,
},
};
<file_sep path="hyperswitch/crates/analytics/src/sqlx.rs" role="context" start="1121" end="1123">
fn to_sql(&self, _table_engine: &TableEngine) -> error_stack::Result<String, ParsingError> {
Ok(self.to_string())
}
<file_sep path="hyperswitch/crates/analytics/src/sqlx.rs" role="context" start="1072" end="1117">
fn from_row(row: &'a PgRow) -> sqlx::Result<Self> {
let dispute_stage: Option<DBEnumWrapper<DisputeStage>> =
row.try_get("dispute_stage").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let dispute_status: Option<DBEnumWrapper<DisputeStatus>> =
row.try_get("dispute_status").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let connector: Option<String> = row.try_get("connector").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let currency: Option<DBEnumWrapper<Currency>> =
row.try_get("currency").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let total: Option<bigdecimal::BigDecimal> = row.try_get("total").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let count: Option<i64> = row.try_get("count").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
// Removing millisecond precision to get accurate diffs against clickhouse
let start_bucket: Option<PrimitiveDateTime> = row
.try_get::<Option<PrimitiveDateTime>, _>("start_bucket")?
.and_then(|dt| dt.replace_millisecond(0).ok());
let end_bucket: Option<PrimitiveDateTime> = row
.try_get::<Option<PrimitiveDateTime>, _>("end_bucket")?
.and_then(|dt| dt.replace_millisecond(0).ok());
Ok(Self {
dispute_stage,
dispute_status,
connector,
currency,
total,
count,
start_bucket,
end_bucket,
})
}
<file_sep path="hyperswitch/crates/analytics/src/sqlx.rs" role="context" start="1014" end="1034">
fn from_row(row: &'a PgRow) -> sqlx::Result<Self> {
let frm_name: Option<String> = row.try_get("frm_name").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let frm_status: Option<DBEnumWrapper<FraudCheckStatus>> =
row.try_get("frm_status").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let frm_transaction_type: Option<DBEnumWrapper<FrmTransactionType>> =
row.try_get("frm_transaction_type").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
Ok(Self {
frm_name,
frm_status,
frm_transaction_type,
})
}
<file_sep path="hyperswitch/crates/analytics/src/sqlx.rs" role="context" start="949" end="1010">
fn from_row(row: &'a PgRow) -> sqlx::Result<Self> {
let currency: Option<DBEnumWrapper<Currency>> =
row.try_get("currency").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let refund_status: Option<DBEnumWrapper<RefundStatus>> =
row.try_get("refund_status").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let connector: Option<String> = row.try_get("connector").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let refund_type: Option<DBEnumWrapper<RefundType>> =
row.try_get("refund_type").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let profile_id: Option<String> = row.try_get("profile_id").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let total: Option<bigdecimal::BigDecimal> = row.try_get("total").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let count: Option<i64> = row.try_get("count").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let refund_reason: Option<String> = row.try_get("refund_reason").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let refund_error_message: Option<String> =
row.try_get("refund_error_message").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
// Removing millisecond precision to get accurate diffs against clickhouse
let start_bucket: Option<PrimitiveDateTime> = row
.try_get::<Option<PrimitiveDateTime>, _>("start_bucket")?
.and_then(|dt| dt.replace_millisecond(0).ok());
let end_bucket: Option<PrimitiveDateTime> = row
.try_get::<Option<PrimitiveDateTime>, _>("end_bucket")?
.and_then(|dt| dt.replace_millisecond(0).ok());
Ok(Self {
currency,
refund_status,
connector,
refund_type,
profile_id,
total,
count,
refund_reason,
refund_error_message,
start_bucket,
end_bucket,
})
}
<file_sep path="hyperswitch/crates/analytics/src/sqlx.rs" role="context" start="43" end="54">
fn default() -> Self {
let database_url = format!(
"postgres://{}:{}@{}:{}/{}",
"db_user", "db_pass", "localhost", 5432, "hyperswitch_db"
);
Self {
#[allow(clippy::expect_used)]
pool: PgPoolOptions::new()
.connect_lazy(&database_url)
.expect("SQLX Pool Creation failed"),
}
}
<file_sep path="hyperswitch/crates/analytics/src/types.rs" role="context" start="74" end="74">
type Err = Report<ParsingError>;
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/analytics/src/opensearch.rs<|crate|> analytics anchor=execute kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=1<|meta_end|>
<file_sep path="hyperswitch/crates/analytics/src/opensearch.rs" role="context" start="253" end="301">
pub async fn execute(
&self,
query_builder: OpenSearchQueryBuilder,
) -> CustomResult<Response, OpenSearchError> {
match query_builder.query_type {
OpenSearchQuery::Msearch(ref indexes) => {
let payload = query_builder
.construct_payload(indexes)
.change_context(OpenSearchError::QueryBuildingError)?;
let payload_with_indexes = payload.into_iter().zip(indexes).fold(
Vec::new(),
|mut payload_with_indexes, (index_hit, index)| {
payload_with_indexes.push(
json!({"index": self.search_index_to_opensearch_index(*index)}).into(),
);
payload_with_indexes.push(JsonBody::new(index_hit.clone()));
payload_with_indexes
},
);
self.client
.msearch(MsearchParts::None)
.body(payload_with_indexes)
.send()
.await
.change_context(OpenSearchError::ResponseError)
}
OpenSearchQuery::Search(index) => {
let payload = query_builder
.clone()
.construct_payload(&[index])
.change_context(OpenSearchError::QueryBuildingError)?;
let final_payload = payload.first().unwrap_or(&Value::Null);
self.client
.search(SearchParts::Index(&[
&self.search_index_to_opensearch_index(index)
]))
.from(query_builder.offset.unwrap_or(0))
.size(query_builder.count.unwrap_or(10))
.body(final_payload)
.send()
.await
.change_context(OpenSearchError::ResponseError)
}
}
}
<file_sep path="hyperswitch/crates/analytics/src/opensearch.rs" role="context" start="252" end="252">
use api_models::{
analytics::search::SearchIndex,
errors::types::{ApiError, ApiErrorResponse},
};
use aws_config::{self, meta::region::RegionProviderChain, Region};
use common_utils::{
errors::{CustomResult, ErrorSwitch},
types::TimeRange,
};
use opensearch::{
auth::Credentials,
cert::CertificateValidation,
cluster::{Cluster, ClusterHealthParts},
http::{
request::JsonBody,
response::Response,
transport::{SingleNodeConnectionPool, Transport, TransportBuilder},
Url,
},
MsearchParts, OpenSearch, SearchParts,
};
use serde_json::{json, Map, Value};
use crate::{enums::AuthInfo, query::QueryBuildingError};
<file_sep path="hyperswitch/crates/analytics/src/opensearch.rs" role="context" start="328" end="386">
pub fn validate(&self) -> Result<(), ApplicationError> {
use common_utils::{ext_traits::ConfigExt, fp_utils::when};
when(self.payment_attempts.is_default_or_empty(), || {
Err(ApplicationError::InvalidConfigurationValueError(
"Opensearch Payment Attempts index must not be empty".into(),
))
})?;
when(self.payment_intents.is_default_or_empty(), || {
Err(ApplicationError::InvalidConfigurationValueError(
"Opensearch Payment Intents index must not be empty".into(),
))
})?;
when(self.refunds.is_default_or_empty(), || {
Err(ApplicationError::InvalidConfigurationValueError(
"Opensearch Refunds index must not be empty".into(),
))
})?;
when(self.disputes.is_default_or_empty(), || {
Err(ApplicationError::InvalidConfigurationValueError(
"Opensearch Disputes index must not be empty".into(),
))
})?;
when(
self.sessionizer_payment_attempts.is_default_or_empty(),
|| {
Err(ApplicationError::InvalidConfigurationValueError(
"Opensearch Sessionizer Payment Attempts index must not be empty".into(),
))
},
)?;
when(
self.sessionizer_payment_intents.is_default_or_empty(),
|| {
Err(ApplicationError::InvalidConfigurationValueError(
"Opensearch Sessionizer Payment Intents index must not be empty".into(),
))
},
)?;
when(self.sessionizer_refunds.is_default_or_empty(), || {
Err(ApplicationError::InvalidConfigurationValueError(
"Opensearch Sessionizer Refunds index must not be empty".into(),
))
})?;
when(self.sessionizer_disputes.is_default_or_empty(), || {
Err(ApplicationError::InvalidConfigurationValueError(
"Opensearch Sessionizer Disputes index must not be empty".into(),
))
})?;
Ok(())
}
<file_sep path="hyperswitch/crates/analytics/src/opensearch.rs" role="context" start="306" end="324">
async fn deep_health_check(&self) -> CustomResult<(), QueryExecutionError> {
let health = Cluster::new(&self.transport)
.health(ClusterHealthParts::None)
.send()
.await
.change_context(QueryExecutionError::DatabaseError)?
.json::<OpenSearchHealth>()
.await
.change_context(QueryExecutionError::DatabaseError)?;
if health.status != OpenSearchHealthStatus::Red {
Ok(())
} else {
Err::<(), error_stack::Report<QueryExecutionError>>(
QueryExecutionError::DatabaseError.into(),
)
.attach_printable_lazy(|| format!("Opensearch cluster health is red: {health:?}"))
}
}
<file_sep path="hyperswitch/crates/analytics/src/opensearch.rs" role="context" start="236" end="251">
pub fn search_index_to_opensearch_index(&self, index: SearchIndex) -> String {
match index {
SearchIndex::PaymentAttempts => self.indexes.payment_attempts.clone(),
SearchIndex::PaymentIntents => self.indexes.payment_intents.clone(),
SearchIndex::Refunds => self.indexes.refunds.clone(),
SearchIndex::Disputes => self.indexes.disputes.clone(),
SearchIndex::SessionizerPaymentAttempts => {
self.indexes.sessionizer_payment_attempts.clone()
}
SearchIndex::SessionizerPaymentIntents => {
self.indexes.sessionizer_payment_intents.clone()
}
SearchIndex::SessionizerRefunds => self.indexes.sessionizer_refunds.clone(),
SearchIndex::SessionizerDisputes => self.indexes.sessionizer_disputes.clone(),
}
}
<file_sep path="hyperswitch/crates/analytics/src/opensearch.rs" role="context" start="202" end="234">
pub async fn create(conf: &OpenSearchConfig) -> CustomResult<Self, OpenSearchError> {
let url = Url::parse(&conf.host).map_err(|_| OpenSearchError::ConnectionError)?;
let transport = match &conf.auth {
OpenSearchAuth::Basic { username, password } => {
let credentials = Credentials::Basic(username.clone(), password.clone());
TransportBuilder::new(SingleNodeConnectionPool::new(url))
.cert_validation(CertificateValidation::None)
.auth(credentials)
.build()
.map_err(|_| OpenSearchError::ConnectionError)?
}
OpenSearchAuth::Aws { region } => {
let region_provider = RegionProviderChain::first_try(Region::new(region.clone()));
let sdk_config = aws_config::from_env().region(region_provider).load().await;
let conn_pool = SingleNodeConnectionPool::new(url);
TransportBuilder::new(conn_pool)
.auth(
sdk_config
.clone()
.try_into()
.map_err(|_| OpenSearchError::ConnectionError)?,
)
.service_name("es")
.build()
.map_err(|_| OpenSearchError::ConnectionError)?
}
};
Ok(Self {
transport: transport.clone(),
client: OpenSearch::new(transport),
indexes: conf.indexes.clone(),
})
}
<file_sep path="hyperswitch/crates/analytics/src/opensearch.rs" role="context" start="485" end="503">
pub fn new(query_type: OpenSearchQuery, query: String, search_params: Vec<AuthInfo>) -> Self {
Self {
query_type,
query,
search_params,
offset: Default::default(),
count: Default::default(),
filters: Default::default(),
time_range: Default::default(),
case_sensitive_fields: HashSet::from([
"customer_email.keyword",
"search_tags.keyword",
"card_last_4.keyword",
"payment_id.keyword",
"amount",
"customer_id.keyword",
]),
}
}
<file_sep path="hyperswitch/crates/analytics/src/opensearch.rs" role="context" start="473" end="482">
pub struct OpenSearchQueryBuilder {
pub query_type: OpenSearchQuery,
pub query: String,
pub offset: Option<i64>,
pub count: Option<i64>,
pub filters: Vec<(String, Vec<Value>)>,
pub time_range: Option<OpensearchTimeRange>,
search_params: Vec<AuthInfo>,
case_sensitive_fields: HashSet<&'static str>,
}
<file_sep path="hyperswitch/crates/analytics/src/opensearch.rs" role="context" start="467" end="470">
pub enum OpenSearchQuery {
Msearch(Vec<SearchIndex>),
Search(SearchIndex),
}
<file_sep path="hyperswitch/crates/analytics/src/opensearch.rs" role="context" start="102" end="123">
pub enum OpenSearchError {
#[error("Opensearch is not enabled")]
NotEnabled,
#[error("Opensearch connection error")]
ConnectionError,
#[error("Opensearch NON-200 response content: '{0}'")]
ResponseNotOK(String),
#[error("Opensearch bad request error")]
BadRequestError(String),
#[error("Opensearch response error")]
ResponseError,
#[error("Opensearch query building error")]
QueryBuildingError,
#[error("Opensearch deserialisation error")]
DeserialisationError,
#[error("Opensearch index access not present error: {0:?}")]
IndexAccessNotPermittedError(SearchIndex),
#[error("Opensearch unknown error")]
UnknownError,
#[error("Opensearch access forbidden error")]
AccessForbiddenError,
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/analytics/src/lib.rs<|crate|> analytics anchor=convert_to_raw_secret kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=1<|meta_end|>
<file_sep path="hyperswitch/crates/analytics/src/lib.rs" role="context" start="1052" end="1112">
async fn convert_to_raw_secret(
value: SecretStateContainer<Self, SecuredSecret>,
secret_management_client: &dyn SecretManagementInterface,
) -> CustomResult<SecretStateContainer<Self, RawSecret>, SecretsManagementError> {
let analytics_config = value.get_inner();
let decrypted_password = match analytics_config {
// Todo: Perform kms decryption of clickhouse password
Self::Clickhouse { .. } => masking::Secret::new(String::default()),
Self::Sqlx { sqlx, .. }
| Self::CombinedCkh { sqlx, .. }
| Self::CombinedSqlx { sqlx, .. } => {
secret_management_client
.get_secret(sqlx.password.clone())
.await?
}
};
Ok(value.transition_state(|conf| match conf {
Self::Sqlx {
sqlx,
forex_enabled,
} => Self::Sqlx {
sqlx: Database {
password: decrypted_password,
..sqlx
},
forex_enabled,
},
Self::Clickhouse {
clickhouse,
forex_enabled,
} => Self::Clickhouse {
clickhouse,
forex_enabled,
},
Self::CombinedCkh {
sqlx,
clickhouse,
forex_enabled,
} => Self::CombinedCkh {
sqlx: Database {
password: decrypted_password,
..sqlx
},
clickhouse,
forex_enabled,
},
Self::CombinedSqlx {
sqlx,
clickhouse,
forex_enabled,
} => Self::CombinedSqlx {
sqlx: Database {
password: decrypted_password,
..sqlx
},
clickhouse,
forex_enabled,
},
}))
}
<file_sep path="hyperswitch/crates/analytics/src/lib.rs" role="context" start="1051" end="1051">
use common_utils::errors::CustomResult;
use hyperswitch_interfaces::secrets_interface::{
secret_handler::SecretsHandler,
secret_state::{RawSecret, SecretStateContainer, SecuredSecret},
SecretManagementInterface, SecretsManagementError,
};
use clickhouse::ClickhouseClient;
pub use clickhouse::ClickhouseConfig;
use storage_impl::config::Database;
use self::{
active_payments::metrics::{ActivePaymentsMetric, ActivePaymentsMetricRow},
auth_events::metrics::{AuthEventMetric, AuthEventMetricRow},
frm::metrics::{FrmMetric, FrmMetricRow},
payment_intents::metrics::{PaymentIntentMetric, PaymentIntentMetricRow},
payments::{
distribution::{PaymentDistribution, PaymentDistributionRow},
metrics::{PaymentMetric, PaymentMetricRow},
},
refunds::metrics::{RefundMetric, RefundMetricRow},
sdk_events::metrics::{SdkEventMetric, SdkEventMetricRow},
sqlx::SqlxClient,
types::MetricsError,
};
<file_sep path="hyperswitch/crates/analytics/src/lib.rs" role="context" start="1116" end="1121">
fn default() -> Self {
Self::Sqlx {
sqlx: Database::default(),
forex_enabled: false,
}
}
<file_sep path="hyperswitch/crates/analytics/src/lib.rs" role="context" start="1040" end="1047">
pub fn get_forex_enabled(&self) -> bool {
match self {
Self::Sqlx { forex_enabled, .. }
| Self::Clickhouse { forex_enabled, .. }
| Self::CombinedCkh { forex_enabled, .. }
| Self::CombinedSqlx { forex_enabled, .. } => *forex_enabled,
}
}
<file_sep path="hyperswitch/crates/analytics/src/lib.rs" role="context" start="978" end="1009">
pub async fn from_conf(
config: &AnalyticsConfig,
tenant: &dyn storage_impl::config::TenantConfig,
) -> Self {
match config {
AnalyticsConfig::Sqlx { sqlx, .. } => {
Self::Sqlx(SqlxClient::from_conf(sqlx, tenant.get_schema()).await)
}
AnalyticsConfig::Clickhouse { clickhouse, .. } => Self::Clickhouse(ClickhouseClient {
config: Arc::new(clickhouse.clone()),
database: tenant.get_clickhouse_database().to_string(),
}),
AnalyticsConfig::CombinedCkh {
sqlx, clickhouse, ..
} => Self::CombinedCkh(
SqlxClient::from_conf(sqlx, tenant.get_schema()).await,
ClickhouseClient {
config: Arc::new(clickhouse.clone()),
database: tenant.get_clickhouse_database().to_string(),
},
),
AnalyticsConfig::CombinedSqlx {
sqlx, clickhouse, ..
} => Self::CombinedSqlx(
SqlxClient::from_conf(sqlx, tenant.get_schema()).await,
ClickhouseClient {
config: Arc::new(clickhouse.clone()),
database: tenant.get_clickhouse_database().to_string(),
},
),
}
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/analytics/src/sqlx.rs<|crate|> analytics anchor=from_row kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/analytics/src/sqlx.rs" role="context" start="903" end="945">
fn from_row(row: &'a PgRow) -> sqlx::Result<Self> {
let currency: Option<DBEnumWrapper<Currency>> =
row.try_get("currency").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let refund_status: Option<DBEnumWrapper<RefundStatus>> =
row.try_get("refund_status").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let connector: Option<String> = row.try_get("connector").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let refund_type: Option<DBEnumWrapper<RefundType>> =
row.try_get("refund_type").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let profile_id: Option<String> = row.try_get("profile_id").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let refund_reason: Option<String> = row.try_get("refund_reason").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let refund_error_message: Option<String> =
row.try_get("refund_error_message").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
Ok(Self {
currency,
refund_status,
connector,
refund_type,
profile_id,
refund_reason,
refund_error_message,
})
}
<file_sep path="hyperswitch/crates/analytics/src/sqlx.rs" role="context" start="902" end="902">
use api_models::{
analytics::{frm::FrmTransactionType, refunds::RefundType},
enums::{DisputeStage, DisputeStatus},
};
use diesel_models::enums::{
AttemptStatus, AuthenticationType, Currency, FraudCheckStatus, IntentStatus, PaymentMethod,
RefundStatus,
};
use sqlx::{
postgres::{PgArgumentBuffer, PgPoolOptions, PgRow, PgTypeInfo, PgValueRef},
Decode, Encode,
Error::ColumnNotFound,
FromRow, Pool, Postgres, Row,
};
use super::{
health_check::HealthCheck,
query::{Aggregate, ToSql, Window},
types::{
AnalyticsCollection, AnalyticsDataSource, DBEnumWrapper, LoadRow, QueryExecutionError,
TableEngine,
},
};
<file_sep path="hyperswitch/crates/analytics/src/sqlx.rs" role="context" start="1014" end="1034">
fn from_row(row: &'a PgRow) -> sqlx::Result<Self> {
let frm_name: Option<String> = row.try_get("frm_name").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let frm_status: Option<DBEnumWrapper<FraudCheckStatus>> =
row.try_get("frm_status").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let frm_transaction_type: Option<DBEnumWrapper<FrmTransactionType>> =
row.try_get("frm_transaction_type").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
Ok(Self {
frm_name,
frm_status,
frm_transaction_type,
})
}
<file_sep path="hyperswitch/crates/analytics/src/sqlx.rs" role="context" start="949" end="1010">
fn from_row(row: &'a PgRow) -> sqlx::Result<Self> {
let currency: Option<DBEnumWrapper<Currency>> =
row.try_get("currency").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let refund_status: Option<DBEnumWrapper<RefundStatus>> =
row.try_get("refund_status").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let connector: Option<String> = row.try_get("connector").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let refund_type: Option<DBEnumWrapper<RefundType>> =
row.try_get("refund_type").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let profile_id: Option<String> = row.try_get("profile_id").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let total: Option<bigdecimal::BigDecimal> = row.try_get("total").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let count: Option<i64> = row.try_get("count").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let refund_reason: Option<String> = row.try_get("refund_reason").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let refund_error_message: Option<String> =
row.try_get("refund_error_message").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
// Removing millisecond precision to get accurate diffs against clickhouse
let start_bucket: Option<PrimitiveDateTime> = row
.try_get::<Option<PrimitiveDateTime>, _>("start_bucket")?
.and_then(|dt| dt.replace_millisecond(0).ok());
let end_bucket: Option<PrimitiveDateTime> = row
.try_get::<Option<PrimitiveDateTime>, _>("end_bucket")?
.and_then(|dt| dt.replace_millisecond(0).ok());
Ok(Self {
currency,
refund_status,
connector,
refund_type,
profile_id,
total,
count,
refund_reason,
refund_error_message,
start_bucket,
end_bucket,
})
}
<file_sep path="hyperswitch/crates/analytics/src/sqlx.rs" role="context" start="826" end="899">
fn from_row(row: &'a PgRow) -> sqlx::Result<Self> {
let status: Option<DBEnumWrapper<IntentStatus>> =
row.try_get("status").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let currency: Option<DBEnumWrapper<Currency>> =
row.try_get("currency").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let profile_id: Option<String> = row.try_get("profile_id").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let connector: Option<String> = row.try_get("connector").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let authentication_type: Option<DBEnumWrapper<AuthenticationType>> =
row.try_get("authentication_type").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let payment_method: Option<String> =
row.try_get("payment_method").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let payment_method_type: Option<String> =
row.try_get("payment_method_type").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let card_network: Option<String> = row.try_get("card_network").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let merchant_id: Option<String> = row.try_get("merchant_id").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let card_last_4: Option<String> = row.try_get("card_last_4").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let card_issuer: Option<String> = row.try_get("card_issuer").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let error_reason: Option<String> = row.try_get("error_reason").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let customer_id: Option<String> = row.try_get("customer_id").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
Ok(Self {
status,
currency,
profile_id,
connector,
authentication_type,
payment_method,
payment_method_type,
card_network,
merchant_id,
card_last_4,
card_issuer,
error_reason,
customer_id,
})
}
<file_sep path="hyperswitch/crates/analytics/src/sqlx.rs" role="context" start="730" end="822">
fn from_row(row: &'a PgRow) -> sqlx::Result<Self> {
let status: Option<DBEnumWrapper<IntentStatus>> =
row.try_get("status").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let currency: Option<DBEnumWrapper<Currency>> =
row.try_get("currency").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let profile_id: Option<String> = row.try_get("profile_id").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let connector: Option<String> = row.try_get("connector").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let authentication_type: Option<DBEnumWrapper<AuthenticationType>> =
row.try_get("authentication_type").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let payment_method: Option<String> =
row.try_get("payment_method").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let payment_method_type: Option<String> =
row.try_get("payment_method_type").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let card_network: Option<String> = row.try_get("card_network").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let merchant_id: Option<String> = row.try_get("merchant_id").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let card_last_4: Option<String> = row.try_get("card_last_4").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let card_issuer: Option<String> = row.try_get("card_issuer").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let error_reason: Option<String> = row.try_get("error_reason").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let total: Option<bigdecimal::BigDecimal> = row.try_get("total").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let count: Option<i64> = row.try_get("count").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let first_attempt: Option<i64> = row.try_get("first_attempt").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
// Removing millisecond precision to get accurate diffs against clickhouse
let start_bucket: Option<PrimitiveDateTime> = row
.try_get::<Option<PrimitiveDateTime>, _>("start_bucket")?
.and_then(|dt| dt.replace_millisecond(0).ok());
let end_bucket: Option<PrimitiveDateTime> = row
.try_get::<Option<PrimitiveDateTime>, _>("end_bucket")?
.and_then(|dt| dt.replace_millisecond(0).ok());
Ok(Self {
status,
currency,
profile_id,
connector,
authentication_type,
payment_method,
payment_method_type,
card_network,
merchant_id,
card_last_4,
card_issuer,
error_reason,
first_attempt,
total,
count,
start_bucket,
end_bucket,
})
}
<file_sep path="hyperswitch/crates/analytics/src/sqlx.rs" role="context" start="43" end="54">
fn default() -> Self {
let database_url = format!(
"postgres://{}:{}@{}:{}/{}",
"db_user", "db_pass", "localhost", 5432, "hyperswitch_db"
);
Self {
#[allow(clippy::expect_used)]
pool: PgPoolOptions::new()
.connect_lazy(&database_url)
.expect("SQLX Pool Creation failed"),
}
}
<file_sep path="hyperswitch/crates/analytics/src/types.rs" role="context" start="74" end="74">
type Err = Report<ParsingError>;
<file_sep path="hyperswitch/crates/api_models/src/refunds.rs" role="context" start="161" end="165">
pub enum RefundType {
#[default]
Scheduled,
Instant,
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/analytics/src/opensearch.rs<|crate|> analytics anchor=switch kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/analytics/src/opensearch.rs" role="context" start="132" end="191">
fn switch(&self) -> ApiErrorResponse {
match self {
Self::ConnectionError => ApiErrorResponse::InternalServerError(ApiError::new(
"IR",
0,
"Connection error",
None,
)),
Self::BadRequestError(response) => {
ApiErrorResponse::BadRequest(ApiError::new("IR", 1, response.to_string(), None))
}
Self::ResponseNotOK(response) => ApiErrorResponse::InternalServerError(ApiError::new(
"IR",
1,
format!("Something went wrong {}", response),
None,
)),
Self::ResponseError => ApiErrorResponse::InternalServerError(ApiError::new(
"IR",
2,
"Something went wrong",
None,
)),
Self::QueryBuildingError => ApiErrorResponse::InternalServerError(ApiError::new(
"IR",
3,
"Query building error",
None,
)),
Self::DeserialisationError => ApiErrorResponse::InternalServerError(ApiError::new(
"IR",
4,
"Deserialisation error",
None,
)),
Self::IndexAccessNotPermittedError(index) => {
ApiErrorResponse::ForbiddenCommonResource(ApiError::new(
"IR",
5,
format!("Index access not permitted: {index:?}"),
None,
))
}
Self::UnknownError => {
ApiErrorResponse::InternalServerError(ApiError::new("IR", 6, "Unknown error", None))
}
Self::AccessForbiddenError => ApiErrorResponse::ForbiddenCommonResource(ApiError::new(
"IR",
7,
"Access Forbidden error",
None,
)),
Self::NotEnabled => ApiErrorResponse::InternalServerError(ApiError::new(
"IR",
8,
"Opensearch is not enabled",
None,
)),
}
}
<file_sep path="hyperswitch/crates/analytics/src/opensearch.rs" role="context" start="131" end="131">
use api_models::{
analytics::search::SearchIndex,
errors::types::{ApiError, ApiErrorResponse},
};
use aws_config::{self, meta::region::RegionProviderChain, Region};
use opensearch::{
auth::Credentials,
cert::CertificateValidation,
cluster::{Cluster, ClusterHealthParts},
http::{
request::JsonBody,
response::Response,
transport::{SingleNodeConnectionPool, Transport, TransportBuilder},
Url,
},
MsearchParts, OpenSearch, SearchParts,
};
use crate::{enums::AuthInfo, query::QueryBuildingError};
<file_sep path="hyperswitch/crates/analytics/src/opensearch.rs" role="context" start="236" end="251">
pub fn search_index_to_opensearch_index(&self, index: SearchIndex) -> String {
match index {
SearchIndex::PaymentAttempts => self.indexes.payment_attempts.clone(),
SearchIndex::PaymentIntents => self.indexes.payment_intents.clone(),
SearchIndex::Refunds => self.indexes.refunds.clone(),
SearchIndex::Disputes => self.indexes.disputes.clone(),
SearchIndex::SessionizerPaymentAttempts => {
self.indexes.sessionizer_payment_attempts.clone()
}
SearchIndex::SessionizerPaymentIntents => {
self.indexes.sessionizer_payment_intents.clone()
}
SearchIndex::SessionizerRefunds => self.indexes.sessionizer_refunds.clone(),
SearchIndex::SessionizerDisputes => self.indexes.sessionizer_disputes.clone(),
}
}
<file_sep path="hyperswitch/crates/analytics/src/opensearch.rs" role="context" start="202" end="234">
pub async fn create(conf: &OpenSearchConfig) -> CustomResult<Self, OpenSearchError> {
let url = Url::parse(&conf.host).map_err(|_| OpenSearchError::ConnectionError)?;
let transport = match &conf.auth {
OpenSearchAuth::Basic { username, password } => {
let credentials = Credentials::Basic(username.clone(), password.clone());
TransportBuilder::new(SingleNodeConnectionPool::new(url))
.cert_validation(CertificateValidation::None)
.auth(credentials)
.build()
.map_err(|_| OpenSearchError::ConnectionError)?
}
OpenSearchAuth::Aws { region } => {
let region_provider = RegionProviderChain::first_try(Region::new(region.clone()));
let sdk_config = aws_config::from_env().region(region_provider).load().await;
let conn_pool = SingleNodeConnectionPool::new(url);
TransportBuilder::new(conn_pool)
.auth(
sdk_config
.clone()
.try_into()
.map_err(|_| OpenSearchError::ConnectionError)?,
)
.service_name("es")
.build()
.map_err(|_| OpenSearchError::ConnectionError)?
}
};
Ok(Self {
transport: transport.clone(),
client: OpenSearch::new(transport),
indexes: conf.indexes.clone(),
})
}
<file_sep path="hyperswitch/crates/analytics/src/opensearch.rs" role="context" start="126" end="128">
fn switch(&self) -> OpenSearchError {
OpenSearchError::QueryBuildingError
}
<file_sep path="hyperswitch/crates/analytics/src/opensearch.rs" role="context" start="79" end="98">
fn default() -> Self {
Self {
host: "https://localhost:9200".to_string(),
auth: OpenSearchAuth::Basic {
username: "admin".to_string(),
password: "admin".to_string(),
},
indexes: OpenSearchIndexes {
payment_attempts: "hyperswitch-payment-attempt-events".to_string(),
payment_intents: "hyperswitch-payment-intent-events".to_string(),
refunds: "hyperswitch-refund-events".to_string(),
disputes: "hyperswitch-dispute-events".to_string(),
sessionizer_payment_attempts: "sessionizer-payment-attempt-events".to_string(),
sessionizer_payment_intents: "sessionizer-payment-intent-events".to_string(),
sessionizer_refunds: "sessionizer-refund-events".to_string(),
sessionizer_disputes: "sessionizer-dispute-events".to_string(),
},
enabled: false,
}
}
<file_sep path="hyperswitch/crates/analytics/src/opensearch.rs" role="context" start="485" end="503">
pub fn new(query_type: OpenSearchQuery, query: String, search_params: Vec<AuthInfo>) -> Self {
Self {
query_type,
query,
search_params,
offset: Default::default(),
count: Default::default(),
filters: Default::default(),
time_range: Default::default(),
case_sensitive_fields: HashSet::from([
"customer_email.keyword",
"search_tags.keyword",
"card_last_4.keyword",
"payment_id.keyword",
"amount",
"customer_id.keyword",
]),
}
}
<file_sep path="hyperswitch/crates/analytics/src/query.rs" role="context" start="225" end="233">
pub enum QueryBuildingError {
#[allow(dead_code)]
#[error("Not Implemented: {0}")]
NotImplemented(String),
#[error("Failed to Serialize to SQL")]
SqlSerializeError,
#[error("Failed to build sql query: {0}")]
InvalidQuery(&'static str),
}
<file_sep path="hyperswitch/crates/api_models/src/errors/types.rs" role="context" start="86" end="100">
pub enum ApiErrorResponse {
Unauthorized(ApiError),
ForbiddenCommonResource(ApiError),
ForbiddenPrivateResource(ApiError),
Conflict(ApiError),
Gone(ApiError),
Unprocessable(ApiError),
InternalServerError(ApiError),
NotImplemented(ApiError),
ConnectorError(ApiError, #[serde(skip_serializing)] StatusCode),
NotFound(ApiError),
MethodNotAllowed(ApiError),
BadRequest(ApiError),
DomainError(ApiError),
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/analytics/src/sqlx.rs<|crate|> analytics anchor=from_row kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/analytics/src/sqlx.rs" role="context" start="380" end="419">
fn from_row(row: &'a PgRow) -> sqlx::Result<Self> {
let frm_name: Option<String> = row.try_get("frm_name").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let frm_status: Option<DBEnumWrapper<FraudCheckStatus>> =
row.try_get("frm_status").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let frm_transaction_type: Option<DBEnumWrapper<FrmTransactionType>> =
row.try_get("frm_transaction_type").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let total: Option<bigdecimal::BigDecimal> = row.try_get("total").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let count: Option<i64> = row.try_get("count").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
// Removing millisecond precision to get accurate diffs against clickhouse
let start_bucket: Option<PrimitiveDateTime> = row
.try_get::<Option<PrimitiveDateTime>, _>("start_bucket")?
.and_then(|dt| dt.replace_millisecond(0).ok());
let end_bucket: Option<PrimitiveDateTime> = row
.try_get::<Option<PrimitiveDateTime>, _>("end_bucket")?
.and_then(|dt| dt.replace_millisecond(0).ok());
Ok(Self {
frm_name,
frm_status,
frm_transaction_type,
total,
count,
start_bucket,
end_bucket,
})
}
<file_sep path="hyperswitch/crates/analytics/src/sqlx.rs" role="context" start="379" end="379">
use api_models::{
analytics::{frm::FrmTransactionType, refunds::RefundType},
enums::{DisputeStage, DisputeStatus},
};
use diesel_models::enums::{
AttemptStatus, AuthenticationType, Currency, FraudCheckStatus, IntentStatus, PaymentMethod,
RefundStatus,
};
use sqlx::{
postgres::{PgArgumentBuffer, PgPoolOptions, PgRow, PgTypeInfo, PgValueRef},
Decode, Encode,
Error::ColumnNotFound,
FromRow, Pool, Postgres, Row,
};
use time::PrimitiveDateTime;
use super::{
health_check::HealthCheck,
query::{Aggregate, ToSql, Window},
types::{
AnalyticsCollection, AnalyticsDataSource, DBEnumWrapper, LoadRow, QueryExecutionError,
TableEngine,
},
};
<file_sep path="hyperswitch/crates/analytics/src/sqlx.rs" role="context" start="530" end="638">
fn from_row(row: &'a PgRow) -> sqlx::Result<Self> {
let currency: Option<DBEnumWrapper<Currency>> =
row.try_get("currency").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let status: Option<DBEnumWrapper<AttemptStatus>> =
row.try_get("status").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let connector: Option<String> = row.try_get("connector").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let authentication_type: Option<DBEnumWrapper<AuthenticationType>> =
row.try_get("authentication_type").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let payment_method: Option<String> =
row.try_get("payment_method").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let payment_method_type: Option<String> =
row.try_get("payment_method_type").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let client_source: Option<String> = row.try_get("client_source").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let client_version: Option<String> =
row.try_get("client_version").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let profile_id: Option<String> = row.try_get("profile_id").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let card_network: Option<String> = row.try_get("card_network").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let merchant_id: Option<String> = row.try_get("merchant_id").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let card_last_4: Option<String> = row.try_get("card_last_4").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let card_issuer: Option<String> = row.try_get("card_issuer").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let error_reason: Option<String> = row.try_get("error_reason").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let total: Option<bigdecimal::BigDecimal> = row.try_get("total").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let count: Option<i64> = row.try_get("count").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let error_message: Option<String> = row.try_get("error_message").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let first_attempt: Option<bool> = row.try_get("first_attempt").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
// Removing millisecond precision to get accurate diffs against clickhouse
let start_bucket: Option<PrimitiveDateTime> = row
.try_get::<Option<PrimitiveDateTime>, _>("start_bucket")?
.and_then(|dt| dt.replace_millisecond(0).ok());
let end_bucket: Option<PrimitiveDateTime> = row
.try_get::<Option<PrimitiveDateTime>, _>("end_bucket")?
.and_then(|dt| dt.replace_millisecond(0).ok());
Ok(Self {
currency,
status,
connector,
authentication_type,
payment_method,
payment_method_type,
client_source,
client_version,
profile_id,
card_network,
merchant_id,
card_last_4,
card_issuer,
error_reason,
first_attempt,
total,
count,
error_message,
start_bucket,
end_bucket,
})
}
<file_sep path="hyperswitch/crates/analytics/src/sqlx.rs" role="context" start="423" end="526">
fn from_row(row: &'a PgRow) -> sqlx::Result<Self> {
let currency: Option<DBEnumWrapper<Currency>> =
row.try_get("currency").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let status: Option<DBEnumWrapper<AttemptStatus>> =
row.try_get("status").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let connector: Option<String> = row.try_get("connector").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let authentication_type: Option<DBEnumWrapper<AuthenticationType>> =
row.try_get("authentication_type").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let payment_method: Option<String> =
row.try_get("payment_method").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let payment_method_type: Option<String> =
row.try_get("payment_method_type").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let client_source: Option<String> = row.try_get("client_source").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let client_version: Option<String> =
row.try_get("client_version").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let profile_id: Option<String> = row.try_get("profile_id").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let card_network: Option<String> = row.try_get("card_network").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let merchant_id: Option<String> = row.try_get("merchant_id").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let card_last_4: Option<String> = row.try_get("card_last_4").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let card_issuer: Option<String> = row.try_get("card_issuer").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let error_reason: Option<String> = row.try_get("error_reason").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let first_attempt: Option<bool> = row.try_get("first_attempt").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let total: Option<bigdecimal::BigDecimal> = row.try_get("total").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let count: Option<i64> = row.try_get("count").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
// Removing millisecond precision to get accurate diffs against clickhouse
let start_bucket: Option<PrimitiveDateTime> = row
.try_get::<Option<PrimitiveDateTime>, _>("start_bucket")?
.and_then(|dt| dt.replace_millisecond(0).ok());
let end_bucket: Option<PrimitiveDateTime> = row
.try_get::<Option<PrimitiveDateTime>, _>("end_bucket")?
.and_then(|dt| dt.replace_millisecond(0).ok());
Ok(Self {
currency,
status,
connector,
authentication_type,
payment_method,
payment_method_type,
client_source,
client_version,
profile_id,
card_network,
merchant_id,
card_last_4,
card_issuer,
error_reason,
first_attempt,
total,
count,
start_bucket,
end_bucket,
})
}
<file_sep path="hyperswitch/crates/analytics/src/sqlx.rs" role="context" start="315" end="376">
fn from_row(row: &'a PgRow) -> sqlx::Result<Self> {
let currency: Option<DBEnumWrapper<Currency>> =
row.try_get("currency").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let refund_status: Option<DBEnumWrapper<RefundStatus>> =
row.try_get("refund_status").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let connector: Option<String> = row.try_get("connector").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let refund_type: Option<DBEnumWrapper<RefundType>> =
row.try_get("refund_type").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let profile_id: Option<String> = row.try_get("profile_id").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let refund_reason: Option<String> = row.try_get("refund_reason").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let refund_error_message: Option<String> =
row.try_get("refund_error_message").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let total: Option<bigdecimal::BigDecimal> = row.try_get("total").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let count: Option<i64> = row.try_get("count").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
// Removing millisecond precision to get accurate diffs against clickhouse
let start_bucket: Option<PrimitiveDateTime> = row
.try_get::<Option<PrimitiveDateTime>, _>("start_bucket")?
.and_then(|dt| dt.replace_millisecond(0).ok());
let end_bucket: Option<PrimitiveDateTime> = row
.try_get::<Option<PrimitiveDateTime>, _>("end_bucket")?
.and_then(|dt| dt.replace_millisecond(0).ok());
Ok(Self {
currency,
refund_status,
connector,
refund_type,
profile_id,
refund_reason,
refund_error_message,
total,
count,
start_bucket,
end_bucket,
})
}
<file_sep path="hyperswitch/crates/analytics/src/sqlx.rs" role="context" start="266" end="311">
fn from_row(row: &'a PgRow) -> sqlx::Result<Self> {
let authentication_status: Option<DBEnumWrapper<AuthenticationStatus>> =
row.try_get("authentication_status").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let trans_status: Option<DBEnumWrapper<TransactionStatus>> =
row.try_get("trans_status").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let authentication_type: Option<DBEnumWrapper<DecoupledAuthenticationType>> =
row.try_get("authentication_type").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let error_message: Option<String> = row.try_get("error_message").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let authentication_connector: Option<DBEnumWrapper<AuthenticationConnectors>> = row
.try_get("authentication_connector")
.or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let message_version: Option<String> =
row.try_get("message_version").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let acs_reference_number: Option<String> =
row.try_get("acs_reference_number").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
Ok(Self {
authentication_status,
trans_status,
authentication_type,
error_message,
authentication_connector,
message_version,
acs_reference_number,
})
}
<file_sep path="hyperswitch/crates/analytics/src/sqlx.rs" role="context" start="43" end="54">
fn default() -> Self {
let database_url = format!(
"postgres://{}:{}@{}:{}/{}",
"db_user", "db_pass", "localhost", 5432, "hyperswitch_db"
);
Self {
#[allow(clippy::expect_used)]
pool: PgPoolOptions::new()
.connect_lazy(&database_url)
.expect("SQLX Pool Creation failed"),
}
}
<file_sep path="hyperswitch/crates/analytics/src/types.rs" role="context" start="74" end="74">
type Err = Report<ParsingError>;
<file_sep path="hyperswitch/crates/api_models/src/analytics/frm.rs" role="context" start="22" end="26">
pub enum FrmTransactionType {
#[default]
PreFrm,
PostFrm,
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/analytics/src/sqlx.rs<|crate|> analytics anchor=from_row kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/analytics/src/sqlx.rs" role="context" start="266" end="311">
fn from_row(row: &'a PgRow) -> sqlx::Result<Self> {
let authentication_status: Option<DBEnumWrapper<AuthenticationStatus>> =
row.try_get("authentication_status").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let trans_status: Option<DBEnumWrapper<TransactionStatus>> =
row.try_get("trans_status").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let authentication_type: Option<DBEnumWrapper<DecoupledAuthenticationType>> =
row.try_get("authentication_type").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let error_message: Option<String> = row.try_get("error_message").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let authentication_connector: Option<DBEnumWrapper<AuthenticationConnectors>> = row
.try_get("authentication_connector")
.or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let message_version: Option<String> =
row.try_get("message_version").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let acs_reference_number: Option<String> =
row.try_get("acs_reference_number").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
Ok(Self {
authentication_status,
trans_status,
authentication_type,
error_message,
authentication_connector,
message_version,
acs_reference_number,
})
}
<file_sep path="hyperswitch/crates/analytics/src/sqlx.rs" role="context" start="265" end="265">
use common_enums::{
AuthenticationConnectors, AuthenticationStatus, DecoupledAuthenticationType, TransactionStatus,
};
use sqlx::{
postgres::{PgArgumentBuffer, PgPoolOptions, PgRow, PgTypeInfo, PgValueRef},
Decode, Encode,
Error::ColumnNotFound,
FromRow, Pool, Postgres, Row,
};
use super::{
health_check::HealthCheck,
query::{Aggregate, ToSql, Window},
types::{
AnalyticsCollection, AnalyticsDataSource, DBEnumWrapper, LoadRow, QueryExecutionError,
TableEngine,
},
};
<file_sep path="hyperswitch/crates/analytics/src/sqlx.rs" role="context" start="380" end="419">
fn from_row(row: &'a PgRow) -> sqlx::Result<Self> {
let frm_name: Option<String> = row.try_get("frm_name").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let frm_status: Option<DBEnumWrapper<FraudCheckStatus>> =
row.try_get("frm_status").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let frm_transaction_type: Option<DBEnumWrapper<FrmTransactionType>> =
row.try_get("frm_transaction_type").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let total: Option<bigdecimal::BigDecimal> = row.try_get("total").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let count: Option<i64> = row.try_get("count").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
// Removing millisecond precision to get accurate diffs against clickhouse
let start_bucket: Option<PrimitiveDateTime> = row
.try_get::<Option<PrimitiveDateTime>, _>("start_bucket")?
.and_then(|dt| dt.replace_millisecond(0).ok());
let end_bucket: Option<PrimitiveDateTime> = row
.try_get::<Option<PrimitiveDateTime>, _>("end_bucket")?
.and_then(|dt| dt.replace_millisecond(0).ok());
Ok(Self {
frm_name,
frm_status,
frm_transaction_type,
total,
count,
start_bucket,
end_bucket,
})
}
<file_sep path="hyperswitch/crates/analytics/src/sqlx.rs" role="context" start="315" end="376">
fn from_row(row: &'a PgRow) -> sqlx::Result<Self> {
let currency: Option<DBEnumWrapper<Currency>> =
row.try_get("currency").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let refund_status: Option<DBEnumWrapper<RefundStatus>> =
row.try_get("refund_status").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let connector: Option<String> = row.try_get("connector").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let refund_type: Option<DBEnumWrapper<RefundType>> =
row.try_get("refund_type").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let profile_id: Option<String> = row.try_get("profile_id").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let refund_reason: Option<String> = row.try_get("refund_reason").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let refund_error_message: Option<String> =
row.try_get("refund_error_message").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let total: Option<bigdecimal::BigDecimal> = row.try_get("total").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let count: Option<i64> = row.try_get("count").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
// Removing millisecond precision to get accurate diffs against clickhouse
let start_bucket: Option<PrimitiveDateTime> = row
.try_get::<Option<PrimitiveDateTime>, _>("start_bucket")?
.and_then(|dt| dt.replace_millisecond(0).ok());
let end_bucket: Option<PrimitiveDateTime> = row
.try_get::<Option<PrimitiveDateTime>, _>("end_bucket")?
.and_then(|dt| dt.replace_millisecond(0).ok());
Ok(Self {
currency,
refund_status,
connector,
refund_type,
profile_id,
refund_reason,
refund_error_message,
total,
count,
start_bucket,
end_bucket,
})
}
<file_sep path="hyperswitch/crates/analytics/src/sqlx.rs" role="context" start="203" end="262">
fn from_row(row: &'a PgRow) -> sqlx::Result<Self> {
let authentication_status: Option<DBEnumWrapper<AuthenticationStatus>> =
row.try_get("authentication_status").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let trans_status: Option<DBEnumWrapper<TransactionStatus>> =
row.try_get("trans_status").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let authentication_type: Option<DBEnumWrapper<DecoupledAuthenticationType>> =
row.try_get("authentication_type").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let error_message: Option<String> = row.try_get("error_message").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let authentication_connector: Option<DBEnumWrapper<AuthenticationConnectors>> = row
.try_get("authentication_connector")
.or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let message_version: Option<String> =
row.try_get("message_version").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let acs_reference_number: Option<String> =
row.try_get("acs_reference_number").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let count: Option<i64> = row.try_get("count").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
// Removing millisecond precision to get accurate diffs against clickhouse
let start_bucket: Option<PrimitiveDateTime> = row
.try_get::<Option<PrimitiveDateTime>, _>("start_bucket")?
.and_then(|dt| dt.replace_millisecond(0).ok());
let end_bucket: Option<PrimitiveDateTime> = row
.try_get::<Option<PrimitiveDateTime>, _>("end_bucket")?
.and_then(|dt| dt.replace_millisecond(0).ok());
Ok(Self {
authentication_status,
trans_status,
authentication_type,
error_message,
authentication_connector,
message_version,
acs_reference_number,
count,
start_bucket,
end_bucket,
})
}
<file_sep path="hyperswitch/crates/analytics/src/sqlx.rs" role="context" start="193" end="199">
async fn deep_health_check(&self) -> CustomResult<(), QueryExecutionError> {
sqlx::query("SELECT 1")
.fetch_all(&self.pool)
.await
.map(|_| ())
.change_context(QueryExecutionError::DatabaseError)
}
<file_sep path="hyperswitch/crates/analytics/src/sqlx.rs" role="context" start="43" end="54">
fn default() -> Self {
let database_url = format!(
"postgres://{}:{}@{}:{}/{}",
"db_user", "db_pass", "localhost", 5432, "hyperswitch_db"
);
Self {
#[allow(clippy::expect_used)]
pool: PgPoolOptions::new()
.connect_lazy(&database_url)
.expect("SQLX Pool Creation failed"),
}
}
<file_sep path="hyperswitch/crates/analytics/src/types.rs" role="context" start="74" end="74">
type Err = Report<ParsingError>;
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/analytics/src/sqlx.rs<|crate|> analytics anchor=from_row kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/analytics/src/sqlx.rs" role="context" start="642" end="726">
fn from_row(row: &'a PgRow) -> sqlx::Result<Self> {
let currency: Option<DBEnumWrapper<Currency>> =
row.try_get("currency").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let status: Option<DBEnumWrapper<AttemptStatus>> =
row.try_get("status").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let connector: Option<String> = row.try_get("connector").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let authentication_type: Option<DBEnumWrapper<AuthenticationType>> =
row.try_get("authentication_type").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let payment_method: Option<String> =
row.try_get("payment_method").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let payment_method_type: Option<String> =
row.try_get("payment_method_type").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let client_source: Option<String> = row.try_get("client_source").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let client_version: Option<String> =
row.try_get("client_version").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let profile_id: Option<String> = row.try_get("profile_id").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let card_network: Option<String> = row.try_get("card_network").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let merchant_id: Option<String> = row.try_get("merchant_id").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let card_last_4: Option<String> = row.try_get("card_last_4").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let card_issuer: Option<String> = row.try_get("card_issuer").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let error_reason: Option<String> = row.try_get("error_reason").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let first_attempt: Option<bool> = row.try_get("first_attempt").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
Ok(Self {
currency,
status,
connector,
authentication_type,
payment_method,
payment_method_type,
client_source,
client_version,
profile_id,
card_network,
merchant_id,
card_last_4,
card_issuer,
error_reason,
first_attempt,
})
}
<file_sep path="hyperswitch/crates/analytics/src/sqlx.rs" role="context" start="641" end="641">
use diesel_models::enums::{
AttemptStatus, AuthenticationType, Currency, FraudCheckStatus, IntentStatus, PaymentMethod,
RefundStatus,
};
use sqlx::{
postgres::{PgArgumentBuffer, PgPoolOptions, PgRow, PgTypeInfo, PgValueRef},
Decode, Encode,
Error::ColumnNotFound,
FromRow, Pool, Postgres, Row,
};
use super::{
health_check::HealthCheck,
query::{Aggregate, ToSql, Window},
types::{
AnalyticsCollection, AnalyticsDataSource, DBEnumWrapper, LoadRow, QueryExecutionError,
TableEngine,
},
};
<file_sep path="hyperswitch/crates/analytics/src/sqlx.rs" role="context" start="826" end="899">
fn from_row(row: &'a PgRow) -> sqlx::Result<Self> {
let status: Option<DBEnumWrapper<IntentStatus>> =
row.try_get("status").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let currency: Option<DBEnumWrapper<Currency>> =
row.try_get("currency").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let profile_id: Option<String> = row.try_get("profile_id").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let connector: Option<String> = row.try_get("connector").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let authentication_type: Option<DBEnumWrapper<AuthenticationType>> =
row.try_get("authentication_type").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let payment_method: Option<String> =
row.try_get("payment_method").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let payment_method_type: Option<String> =
row.try_get("payment_method_type").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let card_network: Option<String> = row.try_get("card_network").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let merchant_id: Option<String> = row.try_get("merchant_id").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let card_last_4: Option<String> = row.try_get("card_last_4").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let card_issuer: Option<String> = row.try_get("card_issuer").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let error_reason: Option<String> = row.try_get("error_reason").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let customer_id: Option<String> = row.try_get("customer_id").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
Ok(Self {
status,
currency,
profile_id,
connector,
authentication_type,
payment_method,
payment_method_type,
card_network,
merchant_id,
card_last_4,
card_issuer,
error_reason,
customer_id,
})
}
<file_sep path="hyperswitch/crates/analytics/src/sqlx.rs" role="context" start="730" end="822">
fn from_row(row: &'a PgRow) -> sqlx::Result<Self> {
let status: Option<DBEnumWrapper<IntentStatus>> =
row.try_get("status").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let currency: Option<DBEnumWrapper<Currency>> =
row.try_get("currency").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let profile_id: Option<String> = row.try_get("profile_id").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let connector: Option<String> = row.try_get("connector").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let authentication_type: Option<DBEnumWrapper<AuthenticationType>> =
row.try_get("authentication_type").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let payment_method: Option<String> =
row.try_get("payment_method").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let payment_method_type: Option<String> =
row.try_get("payment_method_type").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let card_network: Option<String> = row.try_get("card_network").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let merchant_id: Option<String> = row.try_get("merchant_id").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let card_last_4: Option<String> = row.try_get("card_last_4").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let card_issuer: Option<String> = row.try_get("card_issuer").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let error_reason: Option<String> = row.try_get("error_reason").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let total: Option<bigdecimal::BigDecimal> = row.try_get("total").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let count: Option<i64> = row.try_get("count").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let first_attempt: Option<i64> = row.try_get("first_attempt").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
// Removing millisecond precision to get accurate diffs against clickhouse
let start_bucket: Option<PrimitiveDateTime> = row
.try_get::<Option<PrimitiveDateTime>, _>("start_bucket")?
.and_then(|dt| dt.replace_millisecond(0).ok());
let end_bucket: Option<PrimitiveDateTime> = row
.try_get::<Option<PrimitiveDateTime>, _>("end_bucket")?
.and_then(|dt| dt.replace_millisecond(0).ok());
Ok(Self {
status,
currency,
profile_id,
connector,
authentication_type,
payment_method,
payment_method_type,
card_network,
merchant_id,
card_last_4,
card_issuer,
error_reason,
first_attempt,
total,
count,
start_bucket,
end_bucket,
})
}
<file_sep path="hyperswitch/crates/analytics/src/sqlx.rs" role="context" start="530" end="638">
fn from_row(row: &'a PgRow) -> sqlx::Result<Self> {
let currency: Option<DBEnumWrapper<Currency>> =
row.try_get("currency").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let status: Option<DBEnumWrapper<AttemptStatus>> =
row.try_get("status").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let connector: Option<String> = row.try_get("connector").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let authentication_type: Option<DBEnumWrapper<AuthenticationType>> =
row.try_get("authentication_type").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let payment_method: Option<String> =
row.try_get("payment_method").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let payment_method_type: Option<String> =
row.try_get("payment_method_type").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let client_source: Option<String> = row.try_get("client_source").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let client_version: Option<String> =
row.try_get("client_version").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let profile_id: Option<String> = row.try_get("profile_id").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let card_network: Option<String> = row.try_get("card_network").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let merchant_id: Option<String> = row.try_get("merchant_id").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let card_last_4: Option<String> = row.try_get("card_last_4").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let card_issuer: Option<String> = row.try_get("card_issuer").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let error_reason: Option<String> = row.try_get("error_reason").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let total: Option<bigdecimal::BigDecimal> = row.try_get("total").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let count: Option<i64> = row.try_get("count").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let error_message: Option<String> = row.try_get("error_message").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let first_attempt: Option<bool> = row.try_get("first_attempt").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
// Removing millisecond precision to get accurate diffs against clickhouse
let start_bucket: Option<PrimitiveDateTime> = row
.try_get::<Option<PrimitiveDateTime>, _>("start_bucket")?
.and_then(|dt| dt.replace_millisecond(0).ok());
let end_bucket: Option<PrimitiveDateTime> = row
.try_get::<Option<PrimitiveDateTime>, _>("end_bucket")?
.and_then(|dt| dt.replace_millisecond(0).ok());
Ok(Self {
currency,
status,
connector,
authentication_type,
payment_method,
payment_method_type,
client_source,
client_version,
profile_id,
card_network,
merchant_id,
card_last_4,
card_issuer,
error_reason,
first_attempt,
total,
count,
error_message,
start_bucket,
end_bucket,
})
}
<file_sep path="hyperswitch/crates/analytics/src/sqlx.rs" role="context" start="423" end="526">
fn from_row(row: &'a PgRow) -> sqlx::Result<Self> {
let currency: Option<DBEnumWrapper<Currency>> =
row.try_get("currency").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let status: Option<DBEnumWrapper<AttemptStatus>> =
row.try_get("status").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let connector: Option<String> = row.try_get("connector").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let authentication_type: Option<DBEnumWrapper<AuthenticationType>> =
row.try_get("authentication_type").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let payment_method: Option<String> =
row.try_get("payment_method").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let payment_method_type: Option<String> =
row.try_get("payment_method_type").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let client_source: Option<String> = row.try_get("client_source").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let client_version: Option<String> =
row.try_get("client_version").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let profile_id: Option<String> = row.try_get("profile_id").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let card_network: Option<String> = row.try_get("card_network").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let merchant_id: Option<String> = row.try_get("merchant_id").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let card_last_4: Option<String> = row.try_get("card_last_4").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let card_issuer: Option<String> = row.try_get("card_issuer").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let error_reason: Option<String> = row.try_get("error_reason").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let first_attempt: Option<bool> = row.try_get("first_attempt").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let total: Option<bigdecimal::BigDecimal> = row.try_get("total").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let count: Option<i64> = row.try_get("count").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
// Removing millisecond precision to get accurate diffs against clickhouse
let start_bucket: Option<PrimitiveDateTime> = row
.try_get::<Option<PrimitiveDateTime>, _>("start_bucket")?
.and_then(|dt| dt.replace_millisecond(0).ok());
let end_bucket: Option<PrimitiveDateTime> = row
.try_get::<Option<PrimitiveDateTime>, _>("end_bucket")?
.and_then(|dt| dt.replace_millisecond(0).ok());
Ok(Self {
currency,
status,
connector,
authentication_type,
payment_method,
payment_method_type,
client_source,
client_version,
profile_id,
card_network,
merchant_id,
card_last_4,
card_issuer,
error_reason,
first_attempt,
total,
count,
start_bucket,
end_bucket,
})
}
<file_sep path="hyperswitch/crates/analytics/src/sqlx.rs" role="context" start="43" end="54">
fn default() -> Self {
let database_url = format!(
"postgres://{}:{}@{}:{}/{}",
"db_user", "db_pass", "localhost", 5432, "hyperswitch_db"
);
Self {
#[allow(clippy::expect_used)]
pool: PgPoolOptions::new()
.connect_lazy(&database_url)
.expect("SQLX Pool Creation failed"),
}
}
<file_sep path="hyperswitch/crates/analytics/src/types.rs" role="context" start="74" end="74">
type Err = Report<ParsingError>;
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/common_enums/src/transformers.rs<|crate|> common_enums anchor=deserialize kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/common_enums/src/transformers.rs" role="context" start="1967" end="1972">
pub fn deserialize<'a, D>(deserializer: D) -> Result<Country, D::Error>
where
D: serde::Deserializer<'a>,
{
CountryAlpha3::deserialize(deserializer).map(Country::from_alpha3)
}
<file_sep path="hyperswitch/crates/common_enums/src/transformers.rs" role="context" start="1966" end="1966">
use serde::{Deserialize, Serialize};
use crate::enums::{
AttemptStatus, Country, CountryAlpha2, CountryAlpha3, IntentStatus, PaymentMethod,
PaymentMethodType,
};
<file_sep path="hyperswitch/crates/common_enums/src/transformers.rs" role="context" start="1996" end="1998">
fn expecting(&self, formatter: &mut Formatter<'_>) -> fmt::Result {
formatter.write_str("Numeric country code passed as an u32")
}
<file_sep path="hyperswitch/crates/common_enums/src/transformers.rs" role="context" start="1984" end="1989">
pub fn serialize<S>(code: &Country, serializer: S) -> Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
code.to_numeric().serialize(serializer)
}
<file_sep path="hyperswitch/crates/common_enums/src/transformers.rs" role="context" start="1962" end="1964">
fn expecting(&self, formatter: &mut Formatter<'_>) -> fmt::Result {
formatter.write_str("CountryAlpha3 as a string")
}
<file_sep path="hyperswitch/crates/common_enums/src/transformers.rs" role="context" start="1950" end="1955">
pub fn serialize<S>(code: &Country, serializer: S) -> Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
code.to_alpha3().serialize(serializer)
}
<file_sep path="hyperswitch/crates/common_enums/src/transformers.rs" role="context" start="2001" end="2007">
pub fn deserialize<'a, D>(deserializer: D) -> Result<Country, D::Error>
where
D: serde::Deserializer<'a>,
{
u32::deserialize(deserializer)
.and_then(|value| Country::from_numeric(value).map_err(serde::de::Error::custom))
}
<file_sep path="hyperswitch/crates/common_enums/src/connector_enums.rs" role="context" start="605" end="605">
type Error = &'static str;
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/connector-template/mod.rs<|crate|> connector-template anchor=new kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=1<|meta_end|>
<file_sep path="hyperswitch/connector-template/mod.rs" role="context" start="56" end="60">
pub fn new() -> &'static Self {
&Self {
amount_converter: &StringMinorUnitForConnector
}
}
<file_sep path="hyperswitch/connector-template/mod.rs" role="context" start="55" end="55">
use common_utils::{
errors::CustomResult,
ext_traits::BytesExt,
types::{AmountConvertor, StringMinorUnit, StringMinorUnitForConnector},
request::{Method, Request, RequestBuilder, RequestContent},
};
<file_sep path="hyperswitch/connector-template/mod.rs" role="context" start="189" end="191">
fn get_headers(&self, req: &PaymentsAuthorizeRouterData, connectors: &Connectors,) -> CustomResult<Vec<(String, masking::Maskable<String>)>,errors::ConnectorError> {
self.build_headers(req, connectors)
}
<file_sep path="hyperswitch/connector-template/mod.rs" role="context" start="89" end="101">
fn build_headers(
&self,
req: &RouterData<Flow, Request, Response>,
_connectors: &Connectors,
) -> CustomResult<Vec<(String, masking::Maskable<String>)>, errors::ConnectorError> {
let mut header = vec![(
headers::CONTENT_TYPE.to_string(),
self.get_content_type().to_string().into(),
)];
let mut api_key = self.get_auth_header(&req.connector_auth_type)?;
header.append(&mut api_key);
Ok(header)
}
<file_sep path="hyperswitch/connector-template/mod.rs" role="context" start="217" end="235">
fn build_request(
&self,
req: &PaymentsAuthorizeRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Ok(Some(
RequestBuilder::new()
.method(Method::Post)
.url(&types::PaymentsAuthorizeType::get_url(
self, req, connectors,
)?)
.attach_default_headers()
.headers(types::PaymentsAuthorizeType::get_headers(
self, req, connectors,
)?)
.set_body(types::PaymentsAuthorizeType::get_request_body(self, req, connectors)?)
.build(),
))
}
<file_sep path="hyperswitch/connector-template/mod.rs" role="context" start="282" end="295">
fn build_request(
&self,
req: &PaymentsSyncRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Ok(Some(
RequestBuilder::new()
.method(Method::Get)
.url(&types::PaymentsSyncType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(types::PaymentsSyncType::get_headers(self, req, connectors)?)
.build(),
))
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/connector-template/mod.rs<|crate|> connector-template anchor=get_headers kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=1<|meta_end|>
<file_sep path="hyperswitch/connector-template/mod.rs" role="context" start="482" end="484">
fn get_headers(&self, req: &RefundSyncRouterData,connectors: &Connectors,) -> CustomResult<Vec<(String, masking::Maskable<String>)>,errors::ConnectorError> {
self.build_headers(req, connectors)
}
<file_sep path="hyperswitch/connector-template/mod.rs" role="context" start="481" end="481">
use masking::{ExposeInterface, Mask};
use common_utils::{
errors::CustomResult,
ext_traits::BytesExt,
types::{AmountConvertor, StringMinorUnit, StringMinorUnitForConnector},
request::{Method, Request, RequestBuilder, RequestContent},
};
use hyperswitch_domain_models::{
router_data::{AccessToken, ConnectorAuthType, ErrorResponse, RouterData},
router_flow_types::{
access_token_auth::AccessTokenAuth,
payments::{
Authorize, Capture, PSync, PaymentMethodToken, Session,
SetupMandate, Void,
},
refunds::{Execute, RSync},
},
router_request_types::{
AccessTokenRequestData, PaymentMethodTokenizationData,
PaymentsAuthorizeData, PaymentsCancelData, PaymentsCaptureData, PaymentsSessionData,
PaymentsSyncData, RefundsData, SetupMandateRequestData,
},
router_response_types::{PaymentsResponseData, RefundsResponseData},
types::{
PaymentsAuthorizeRouterData,
PaymentsCaptureRouterData, PaymentsSyncRouterData, RefundSyncRouterData, RefundsRouterData,
},
};
use hyperswitch_interfaces::{
api::{self, ConnectorCommon, ConnectorCommonExt, ConnectorIntegration, ConnectorValidation, ConnectorSpecifications},
configs::Connectors,
errors,
events::connector_api_logs::ConnectorEvent,
types::{self, Response},
webhooks,
};
<file_sep path="hyperswitch/connector-template/mod.rs" role="context" start="490" end="492">
fn get_url(&self, _req: &RefundSyncRouterData,_connectors: &Connectors,) -> CustomResult<String,errors::ConnectorError> {
Err(errors::ConnectorError::NotImplemented("get_url method".to_string()).into())
}
<file_sep path="hyperswitch/connector-template/mod.rs" role="context" start="486" end="488">
fn get_content_type(&self) -> &'static str {
self.common_get_content_type()
}
<file_sep path="hyperswitch/connector-template/mod.rs" role="context" start="475" end="477">
fn get_error_response(&self, res: Response, event_builder: Option<&mut ConnectorEvent>) -> CustomResult<ErrorResponse,errors::ConnectorError> {
self.build_error_response(res, event_builder)
}
<file_sep path="hyperswitch/connector-template/mod.rs" role="context" start="459" end="473">
fn handle_response(
&self,
data: &RefundsRouterData<Execute>,
event_builder: Option<&mut ConnectorEvent>,
res: Response,
) -> CustomResult<RefundsRouterData<Execute>,errors::ConnectorError> {
let response: {{project-name| downcase}}::RefundResponse = res.response.parse_struct("{{project-name | downcase}} RefundResponse").change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
event_builder.map(|i| i.set_response_body(&response));
router_env::logger::info!(connector_response=?response);
RouterData::try_from(ResponseRouterData {
response,
data: data.clone(),
http_code: res.status_code,
})
}
<file_sep path="hyperswitch/connector-template/mod.rs" role="context" start="282" end="295">
fn build_request(
&self,
req: &PaymentsSyncRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Ok(Some(
RequestBuilder::new()
.method(Method::Get)
.url(&types::PaymentsSyncType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(types::PaymentsSyncType::get_headers(self, req, connectors)?)
.build(),
))
}
<file_sep path="hyperswitch/connector-template/mod.rs" role="context" start="217" end="235">
fn build_request(
&self,
req: &PaymentsAuthorizeRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Ok(Some(
RequestBuilder::new()
.method(Method::Post)
.url(&types::PaymentsAuthorizeType::get_url(
self, req, connectors,
)?)
.attach_default_headers()
.headers(types::PaymentsAuthorizeType::get_headers(
self, req, connectors,
)?)
.set_body(types::PaymentsAuthorizeType::get_request_body(self, req, connectors)?)
.build(),
))
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/connector-template/mod.rs<|crate|> connector-template anchor=get_request_body kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=1<|meta_end|>
<file_sep path="hyperswitch/connector-template/mod.rs" role="context" start="432" end="440">
fn get_request_body(&self, req: &RefundsRouterData<Execute>, _connectors: &Connectors,) -> CustomResult<RequestContent, errors::ConnectorError> {
let refund_amount = utils::convert_amount(
self.amount_converter,
req.request.minor_refund_amount,
req.request.currency,
)?;
let connector_router_data =
{{project-name | downcase}}::{{project-name | downcase | pascal_case}}RouterData::from((
<file_sep path="hyperswitch/connector-template/mod.rs" role="context" start="431" end="431">
fn get_headers(&self, req: &RefundsRouterData<Execute>, connectors: &Connectors,) -> CustomResult<Vec<(String,masking::Maskable<String>)>,errors::ConnectorError> {
self.build_headers(req, connectors)
}
fn get_content_type(&self) -> &'static str {
self.common_get_content_type()
}
fn get_url(&self, _req: &RefundsRouterData<Execute>, _connectors: &Connectors,) -> CustomResult<String,errors::ConnectorError> {
Err(errors::ConnectorError::NotImplemented("get_url method".to_string()).into())
}
fn get_request_body(&self, req: &RefundsRouterData<Execute>, _connectors: &Connectors,) -> CustomResult<RequestContent, errors::ConnectorError> {
let refund_amount = utils::convert_amount(
self.amount_converter,
req.request.minor_refund_amount,
req.request.currency,
)?;
let connector_router_data =
{{project-name | downcase}}::{{project-name | downcase | pascal_case}}RouterData::from((
refund_amount,
req,
));
let connector_req = {{project-name | downcase}}::{{project-name | downcase | pascal_case}}RefundRequest::try_from(&connector_router_data)?;
<file_sep path="hyperswitch/connector-template/mod.rs" role="context" start="459" end="473">
fn handle_response(
&self,
data: &RefundsRouterData<Execute>,
event_builder: Option<&mut ConnectorEvent>,
res: Response,
) -> CustomResult<RefundsRouterData<Execute>,errors::ConnectorError> {
let response: {{project-name| downcase}}::RefundResponse = res.response.parse_struct("{{project-name | downcase}} RefundResponse").change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
event_builder.map(|i| i.set_response_body(&response));
router_env::logger::info!(connector_response=?response);
RouterData::try_from(ResponseRouterData {
response,
data: data.clone(),
http_code: res.status_code,
})
}
<file_sep path="hyperswitch/connector-template/mod.rs" role="context" start="448" end="457">
fn build_request(&self, req: &RefundsRouterData<Execute>, connectors: &Connectors,) -> CustomResult<Option<Request>,errors::ConnectorError> {
let request = RequestBuilder::new()
.method(Method::Post)
.url(&types::RefundExecuteType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(types::RefundExecuteType::get_headers(self, req, connectors)?)
.set_body(types::RefundExecuteType::get_request_body(self, req, connectors)?)
.build();
Ok(Some(request))
}
<file_sep path="hyperswitch/connector-template/mod.rs" role="context" start="428" end="430">
fn get_url(&self, _req: &RefundsRouterData<Execute>, _connectors: &Connectors,) -> CustomResult<String,errors::ConnectorError> {
Err(errors::ConnectorError::NotImplemented("get_url method".to_string()).into())
}
<file_sep path="hyperswitch/connector-template/mod.rs" role="context" start="424" end="426">
fn get_content_type(&self) -> &'static str {
self.common_get_content_type()
}
<file_sep path="hyperswitch/connector-template/mod.rs" role="context" start="360" end="376">
fn build_request(
&self,
req: &PaymentsCaptureRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Ok(Some(
RequestBuilder::new()
.method(Method::Post)
.url(&types::PaymentsCaptureType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(types::PaymentsCaptureType::get_headers(
self, req, connectors,
)?)
.set_body(types::PaymentsCaptureType::get_request_body(self, req, connectors)?)
.build(),
))
}
<file_sep path="hyperswitch/connector-template/mod.rs" role="context" start="494" end="508">
fn build_request(
&self,
req: &RefundSyncRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Ok(Some(
RequestBuilder::new()
.method(Method::Get)
.url(&types::RefundSyncType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(types::RefundSyncType::get_headers(self, req, connectors)?)
.set_body(types::RefundSyncType::get_request_body(self, req, connectors)?)
.build(),
))
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/connector-template/mod.rs<|crate|> connector-template anchor=build_request kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=1<|meta_end|>
<file_sep path="hyperswitch/connector-template/mod.rs" role="context" start="448" end="457">
fn build_request(&self, req: &RefundsRouterData<Execute>, connectors: &Connectors,) -> CustomResult<Option<Request>,errors::ConnectorError> {
let request = RequestBuilder::new()
.method(Method::Post)
.url(&types::RefundExecuteType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(types::RefundExecuteType::get_headers(self, req, connectors)?)
.set_body(types::RefundExecuteType::get_request_body(self, req, connectors)?)
.build();
Ok(Some(request))
}
<file_sep path="hyperswitch/connector-template/mod.rs" role="context" start="447" end="447">
req.request.currency,
)?;
let connector_router_data =
{{project-name | downcase}}::{{project-name | downcase | pascal_case}}RouterData::from((
refund_amount,
req,
));
let connector_req = {{project-name | downcase}}::{{project-name | downcase | pascal_case}}RefundRequest::try_from(&connector_router_data)?;
Ok(RequestContent::Json(Box::new(connector_req)))
}
fn build_request(&self, req: &RefundsRouterData<Execute>, connectors: &Connectors,) -> CustomResult<Option<Request>,errors::ConnectorError> {
let request = RequestBuilder::new()
.method(Method::Post)
.url(&types::RefundExecuteType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(types::RefundExecuteType::get_headers(self, req, connectors)?)
.set_body(types::RefundExecuteType::get_request_body(self, req, connectors)?)
.build();
Ok(Some(request))
}
fn handle_response(
&self,
<file_sep path="hyperswitch/connector-template/mod.rs" role="context" start="475" end="477">
fn get_error_response(&self, res: Response, event_builder: Option<&mut ConnectorEvent>) -> CustomResult<ErrorResponse,errors::ConnectorError> {
self.build_error_response(res, event_builder)
}
<file_sep path="hyperswitch/connector-template/mod.rs" role="context" start="459" end="473">
fn handle_response(
&self,
data: &RefundsRouterData<Execute>,
event_builder: Option<&mut ConnectorEvent>,
res: Response,
) -> CustomResult<RefundsRouterData<Execute>,errors::ConnectorError> {
let response: {{project-name| downcase}}::RefundResponse = res.response.parse_struct("{{project-name | downcase}} RefundResponse").change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
event_builder.map(|i| i.set_response_body(&response));
router_env::logger::info!(connector_response=?response);
RouterData::try_from(ResponseRouterData {
response,
data: data.clone(),
http_code: res.status_code,
})
}
<file_sep path="hyperswitch/connector-template/mod.rs" role="context" start="432" end="440">
fn get_request_body(&self, req: &RefundsRouterData<Execute>, _connectors: &Connectors,) -> CustomResult<RequestContent, errors::ConnectorError> {
let refund_amount = utils::convert_amount(
self.amount_converter,
req.request.minor_refund_amount,
req.request.currency,
)?;
let connector_router_data =
{{project-name | downcase}}::{{project-name | downcase | pascal_case}}RouterData::from((
<file_sep path="hyperswitch/connector-template/mod.rs" role="context" start="428" end="430">
fn get_url(&self, _req: &RefundsRouterData<Execute>, _connectors: &Connectors,) -> CustomResult<String,errors::ConnectorError> {
Err(errors::ConnectorError::NotImplemented("get_url method".to_string()).into())
}
<file_sep path="hyperswitch/connector-template/mod.rs" role="context" start="490" end="492">
fn get_url(&self, _req: &RefundSyncRouterData,_connectors: &Connectors,) -> CustomResult<String,errors::ConnectorError> {
Err(errors::ConnectorError::NotImplemented("get_url method".to_string()).into())
}
<file_sep path="hyperswitch/connector-template/mod.rs" role="context" start="482" end="484">
fn get_headers(&self, req: &RefundSyncRouterData,connectors: &Connectors,) -> CustomResult<Vec<(String, masking::Maskable<String>)>,errors::ConnectorError> {
self.build_headers(req, connectors)
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/connector-template/mod.rs<|crate|> connector-template anchor=build_request kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=1<|meta_end|>
<file_sep path="hyperswitch/connector-template/mod.rs" role="context" start="494" end="508">
fn build_request(
&self,
req: &RefundSyncRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Ok(Some(
RequestBuilder::new()
.method(Method::Get)
.url(&types::RefundSyncType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(types::RefundSyncType::get_headers(self, req, connectors)?)
.set_body(types::RefundSyncType::get_request_body(self, req, connectors)?)
.build(),
))
}
<file_sep path="hyperswitch/connector-template/mod.rs" role="context" start="493" end="493">
fn get_headers(&self, req: &RefundSyncRouterData,connectors: &Connectors,) -> CustomResult<Vec<(String, masking::Maskable<String>)>,errors::ConnectorError> {
self.build_headers(req, connectors)
}
fn get_content_type(&self) -> &'static str {
self.common_get_content_type()
}
fn get_url(&self, _req: &RefundSyncRouterData,_connectors: &Connectors,) -> CustomResult<String,errors::ConnectorError> {
Err(errors::ConnectorError::NotImplemented("get_url method".to_string()).into())
}
fn build_request(
&self,
req: &RefundSyncRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Ok(Some(
RequestBuilder::new()
.method(Method::Get)
.url(&types::RefundSyncType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(types::RefundSyncType::get_headers(self, req, connectors)?)
.set_body(types::RefundSyncType::get_request_body(self, req, connectors)?)
.build(),
<file_sep path="hyperswitch/connector-template/mod.rs" role="context" start="526" end="528">
fn get_error_response(&self, res: Response, event_builder: Option<&mut ConnectorEvent>) -> CustomResult<ErrorResponse,errors::ConnectorError> {
self.build_error_response(res, event_builder)
}
<file_sep path="hyperswitch/connector-template/mod.rs" role="context" start="510" end="524">
fn handle_response(
&self,
data: &RefundSyncRouterData,
event_builder: Option<&mut ConnectorEvent>,
res: Response,
) -> CustomResult<RefundSyncRouterData,errors::ConnectorError,> {
let response: {{project-name | downcase}}::RefundResponse = res.response.parse_struct("{{project-name | downcase}} RefundSyncResponse").change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
event_builder.map(|i| i.set_response_body(&response));
router_env::logger::info!(connector_response=?response);
RouterData::try_from(ResponseRouterData {
response,
data: data.clone(),
http_code: res.status_code,
})
}
<file_sep path="hyperswitch/connector-template/mod.rs" role="context" start="490" end="492">
fn get_url(&self, _req: &RefundSyncRouterData,_connectors: &Connectors,) -> CustomResult<String,errors::ConnectorError> {
Err(errors::ConnectorError::NotImplemented("get_url method".to_string()).into())
}
<file_sep path="hyperswitch/connector-template/mod.rs" role="context" start="486" end="488">
fn get_content_type(&self) -> &'static str {
self.common_get_content_type()
}
<file_sep path="hyperswitch/connector-template/mod.rs" role="context" start="432" end="440">
fn get_request_body(&self, req: &RefundsRouterData<Execute>, _connectors: &Connectors,) -> CustomResult<RequestContent, errors::ConnectorError> {
let refund_amount = utils::convert_amount(
self.amount_converter,
req.request.minor_refund_amount,
req.request.currency,
)?;
let connector_router_data =
{{project-name | downcase}}::{{project-name | downcase | pascal_case}}RouterData::from((
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/connector-template/mod.rs<|crate|> connector-template anchor=build_request kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=1<|meta_end|>
<file_sep path="hyperswitch/connector-template/mod.rs" role="context" start="360" end="376">
fn build_request(
&self,
req: &PaymentsCaptureRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Ok(Some(
RequestBuilder::new()
.method(Method::Post)
.url(&types::PaymentsCaptureType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(types::PaymentsCaptureType::get_headers(
self, req, connectors,
)?)
.set_body(types::PaymentsCaptureType::get_request_body(self, req, connectors)?)
.build(),
))
}
<file_sep path="hyperswitch/connector-template/mod.rs" role="context" start="359" end="359">
) -> CustomResult<String, errors::ConnectorError> {
Err(errors::ConnectorError::NotImplemented("get_url method".to_string()).into())
}
fn get_request_body(
&self,
_req: &PaymentsCaptureRouterData,
_connectors: &Connectors,
) -> CustomResult<RequestContent, errors::ConnectorError> {
Err(errors::ConnectorError::NotImplemented("get_request_body method".to_string()).into())
}
fn build_request(
&self,
req: &PaymentsCaptureRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Ok(Some(
RequestBuilder::new()
.method(Method::Post)
.url(&types::PaymentsCaptureType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(types::PaymentsCaptureType::get_headers(
self, req, connectors,
)?)
<file_sep path="hyperswitch/connector-template/mod.rs" role="context" start="397" end="403">
fn get_error_response(
&self,
res: Response,
event_builder: Option<&mut ConnectorEvent>
) -> CustomResult<ErrorResponse, errors::ConnectorError> {
self.build_error_response(res, event_builder)
}
<file_sep path="hyperswitch/connector-template/mod.rs" role="context" start="378" end="395">
fn handle_response(
&self,
data: &PaymentsCaptureRouterData,
event_builder: Option<&mut ConnectorEvent>,
res: Response,
) -> CustomResult<PaymentsCaptureRouterData, errors::ConnectorError> {
let response: {{project-name | downcase }}::{{project-name | downcase | pascal_case}}PaymentsResponse = res
.response
.parse_struct("{{project-name | downcase | pascal_case}} PaymentsCaptureResponse")
.change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
event_builder.map(|i| i.set_response_body(&response));
router_env::logger::info!(connector_response=?response);
RouterData::try_from(ResponseRouterData {
response,
data: data.clone(),
http_code: res.status_code,
})
}
<file_sep path="hyperswitch/connector-template/mod.rs" role="context" start="352" end="358">
fn get_request_body(
&self,
_req: &PaymentsCaptureRouterData,
_connectors: &Connectors,
) -> CustomResult<RequestContent, errors::ConnectorError> {
Err(errors::ConnectorError::NotImplemented("get_request_body method".to_string()).into())
}
<file_sep path="hyperswitch/connector-template/mod.rs" role="context" start="344" end="350">
fn get_url(
&self,
_req: &PaymentsCaptureRouterData,
_connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
Err(errors::ConnectorError::NotImplemented("get_url method".to_string()).into())
}
<file_sep path="hyperswitch/connector-template/mod.rs" role="context" start="432" end="440">
fn get_request_body(&self, req: &RefundsRouterData<Execute>, _connectors: &Connectors,) -> CustomResult<RequestContent, errors::ConnectorError> {
let refund_amount = utils::convert_amount(
self.amount_converter,
req.request.minor_refund_amount,
req.request.currency,
)?;
let connector_router_data =
{{project-name | downcase}}::{{project-name | downcase | pascal_case}}RouterData::from((
<file_sep path="hyperswitch/connector-template/mod.rs" role="context" start="490" end="492">
fn get_url(&self, _req: &RefundSyncRouterData,_connectors: &Connectors,) -> CustomResult<String,errors::ConnectorError> {
Err(errors::ConnectorError::NotImplemented("get_url method".to_string()).into())
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/connector-template/mod.rs<|crate|> connector-template anchor=build_request kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=1<|meta_end|>
<file_sep path="hyperswitch/connector-template/mod.rs" role="context" start="217" end="235">
fn build_request(
&self,
req: &PaymentsAuthorizeRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Ok(Some(
RequestBuilder::new()
.method(Method::Post)
.url(&types::PaymentsAuthorizeType::get_url(
self, req, connectors,
)?)
.attach_default_headers()
.headers(types::PaymentsAuthorizeType::get_headers(
self, req, connectors,
)?)
.set_body(types::PaymentsAuthorizeType::get_request_body(self, req, connectors)?)
.build(),
))
}
<file_sep path="hyperswitch/connector-template/mod.rs" role="context" start="216" end="216">
req.request.currency,
)?;
let connector_router_data =
{{project-name | downcase}}::{{project-name | downcase | pascal_case}}RouterData::from((
amount,
req,
));
let connector_req = {{project-name | downcase}}::{{project-name | downcase | pascal_case}}PaymentsRequest::try_from(&connector_router_data)?;
Ok(RequestContent::Json(Box::new(connector_req)))
}
fn build_request(
&self,
req: &PaymentsAuthorizeRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Ok(Some(
RequestBuilder::new()
.method(Method::Post)
.url(&types::PaymentsAuthorizeType::get_url(
self, req, connectors,
)?)
.attach_default_headers()
.headers(types::PaymentsAuthorizeType::get_headers(
<file_sep path="hyperswitch/connector-template/mod.rs" role="context" start="253" end="255">
fn get_error_response(&self, res: Response, event_builder: Option<&mut ConnectorEvent>) -> CustomResult<ErrorResponse,errors::ConnectorError> {
self.build_error_response(res, event_builder)
}
<file_sep path="hyperswitch/connector-template/mod.rs" role="context" start="237" end="251">
fn handle_response(
&self,
data: &PaymentsAuthorizeRouterData,
event_builder: Option<&mut ConnectorEvent>,
res: Response,
) -> CustomResult<PaymentsAuthorizeRouterData,errors::ConnectorError> {
let response: {{project-name | downcase}}::{{project-name | downcase | pascal_case}}PaymentsResponse = res.response.parse_struct("{{project-name | downcase | pascal_case}} PaymentsAuthorizeResponse").change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
event_builder.map(|i| i.set_response_body(&response));
router_env::logger::info!(connector_response=?response);
RouterData::try_from(ResponseRouterData {
response,
data: data.clone(),
http_code: res.status_code,
})
}
<file_sep path="hyperswitch/connector-template/mod.rs" role="context" start="201" end="209">
fn get_request_body(&self, req: &PaymentsAuthorizeRouterData, _connectors: &Connectors,) -> CustomResult<RequestContent, errors::ConnectorError> {
let amount = utils::convert_amount(
self.amount_converter,
req.request.minor_amount,
req.request.currency,
)?;
let connector_router_data =
{{project-name | downcase}}::{{project-name | downcase | pascal_case}}RouterData::from((
<file_sep path="hyperswitch/connector-template/mod.rs" role="context" start="197" end="199">
fn get_url(&self, _req: &PaymentsAuthorizeRouterData, _connectors: &Connectors,) -> CustomResult<String,errors::ConnectorError> {
Err(errors::ConnectorError::NotImplemented("get_url method".to_string()).into())
}
<file_sep path="hyperswitch/connector-template/mod.rs" role="context" start="490" end="492">
fn get_url(&self, _req: &RefundSyncRouterData,_connectors: &Connectors,) -> CustomResult<String,errors::ConnectorError> {
Err(errors::ConnectorError::NotImplemented("get_url method".to_string()).into())
}
<file_sep path="hyperswitch/connector-template/mod.rs" role="context" start="482" end="484">
fn get_headers(&self, req: &RefundSyncRouterData,connectors: &Connectors,) -> CustomResult<Vec<(String, masking::Maskable<String>)>,errors::ConnectorError> {
self.build_headers(req, connectors)
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/connector-template/transformers.rs<|crate|> connector-template anchor=from kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/connector-template/transformers.rs" role="context" start="177" end="184">
fn from(item: RefundStatus) -> Self {
match item {
RefundStatus::Succeeded => Self::Success,
RefundStatus::Failed => Self::Failure,
RefundStatus::Processing => Self::Pending,
//TODO: Review mapping
}
}
<file_sep path="hyperswitch/connector-template/transformers.rs" role="context" start="214" end="222">
fn try_from(item: RefundsResponseRouterData<RSync, RefundResponse>) -> Result<Self,Self::Error> {
Ok(Self {
response: Ok(RefundsResponseData {
connector_refund_id: item.response.id.to_string(),
refund_status: enums::RefundStatus::from(item.response.status),
}),
..item.data
})
}
<file_sep path="hyperswitch/connector-template/transformers.rs" role="context" start="198" end="208">
fn try_from(
item: RefundsResponseRouterData<Execute, RefundResponse>,
) -> Result<Self, Self::Error> {
Ok(Self {
response: Ok(RefundsResponseData {
connector_refund_id: item.response.id.to_string(),
refund_status: enums::RefundStatus::from(item.response.status),
}),
..item.data
})
}
<file_sep path="hyperswitch/connector-template/transformers.rs" role="context" start="130" end="145">
fn try_from(item: ResponseRouterData<F, {{project-name | downcase | pascal_case}}PaymentsResponse, T, PaymentsResponseData>) -> Result<Self,Self::Error> {
Ok(Self {
status: common_enums::AttemptStatus::from(item.response.status),
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(item.response.id),
redirection_data: Box::new(None),
mandate_reference: Box::new(None),
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: None,
incremental_authorization_allowed: None,
charges: None,
}),
..item.data
})
}
<file_sep path="hyperswitch/connector-template/transformers.rs" role="context" start="112" end="117">
fn from(item: {{project-name | downcase | pascal_case}}PaymentStatus) -> Self {
match item {
{{project-name | downcase | pascal_case}}PaymentStatus::Succeeded => Self::Charged,
{{project-name | downcase | pascal_case}}PaymentStatus::Failed => Self::Failure,
{{project-name | downcase | pascal_case}}PaymentStatus::Processing => Self::Authorizing,
}
<file_sep path="hyperswitch/connector-template/transformers.rs" role="context" start="169" end="174">
pub enum RefundStatus {
Succeeded,
Failed,
#[default]
Processing,
}
<file_sep path="hyperswitch/crates/api_models/src/refunds.rs" role="context" start="378" end="384">
pub enum RefundStatus {
Succeeded,
Failed,
#[default]
Pending,
Review,
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/connector-template/mod.rs<|crate|> connector-template anchor=build_request kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=1<|meta_end|>
<file_sep path="hyperswitch/connector-template/mod.rs" role="context" start="282" end="295">
fn build_request(
&self,
req: &PaymentsSyncRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Ok(Some(
RequestBuilder::new()
.method(Method::Get)
.url(&types::PaymentsSyncType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(types::PaymentsSyncType::get_headers(self, req, connectors)?)
.build(),
))
}
<file_sep path="hyperswitch/connector-template/mod.rs" role="context" start="281" end="281">
fn get_content_type(&self) -> &'static str {
self.common_get_content_type()
}
fn get_url(
&self,
_req: &PaymentsSyncRouterData,
_connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
Err(errors::ConnectorError::NotImplemented("get_url method".to_string()).into())
}
fn build_request(
&self,
req: &PaymentsSyncRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Ok(Some(
RequestBuilder::new()
.method(Method::Get)
.url(&types::PaymentsSyncType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(types::PaymentsSyncType::get_headers(self, req, connectors)?)
.build(),
))
<file_sep path="hyperswitch/connector-template/mod.rs" role="context" start="316" end="322">
fn get_error_response(
&self,
res: Response,
event_builder: Option<&mut ConnectorEvent>
) -> CustomResult<ErrorResponse, errors::ConnectorError> {
self.build_error_response(res, event_builder)
}
<file_sep path="hyperswitch/connector-template/mod.rs" role="context" start="297" end="314">
fn handle_response(
&self,
data: &PaymentsSyncRouterData,
event_builder: Option<&mut ConnectorEvent>,
res: Response,
) -> CustomResult<PaymentsSyncRouterData, errors::ConnectorError> {
let response: {{project-name | downcase}}:: {{project-name | downcase | pascal_case}}PaymentsResponse = res
.response
.parse_struct("{{project-name | downcase}} PaymentsSyncResponse")
.change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
event_builder.map(|i| i.set_response_body(&response));
router_env::logger::info!(connector_response=?response);
RouterData::try_from(ResponseRouterData {
response,
data: data.clone(),
http_code: res.status_code,
})
}
<file_sep path="hyperswitch/connector-template/mod.rs" role="context" start="274" end="280">
fn get_url(
&self,
_req: &PaymentsSyncRouterData,
_connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
Err(errors::ConnectorError::NotImplemented("get_url method".to_string()).into())
}
<file_sep path="hyperswitch/connector-template/mod.rs" role="context" start="270" end="272">
fn get_content_type(&self) -> &'static str {
self.common_get_content_type()
}
<file_sep path="hyperswitch/connector-template/mod.rs" role="context" start="490" end="492">
fn get_url(&self, _req: &RefundSyncRouterData,_connectors: &Connectors,) -> CustomResult<String,errors::ConnectorError> {
Err(errors::ConnectorError::NotImplemented("get_url method".to_string()).into())
}
<file_sep path="hyperswitch/connector-template/mod.rs" role="context" start="482" end="484">
fn get_headers(&self, req: &RefundSyncRouterData,connectors: &Connectors,) -> CustomResult<Vec<(String, masking::Maskable<String>)>,errors::ConnectorError> {
self.build_headers(req, connectors)
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/connector-template/test.rs<|crate|> connector-template anchor=should_only_authorize_payment kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=1<|meta_end|>
<file_sep path="hyperswitch/connector-template/test.rs" role="context" start="49" end="55">
async fn should_only_authorize_payment() {
let response = CONNECTOR
.authorize_payment(payment_method_details(), get_default_payment_info())
.await
.expect("Authorize payment response");
assert_eq!(response.status, enums::AttemptStatus::Authorized);
}
<file_sep path="hyperswitch/connector-template/test.rs" role="context" start="48" end="48">
use router::{
types::{self, api, storage::enums,
}};
<file_sep path="hyperswitch/connector-template/test.rs" role="context" start="69" end="82">
async fn should_partially_capture_authorized_payment() {
let response = CONNECTOR
.authorize_and_capture_payment(
payment_method_details(),
Some(types::PaymentsCaptureData {
amount_to_capture: 50,
..utils::PaymentCaptureType::default().0
}),
get_default_payment_info(),
)
.await
.expect("Capture payment response");
assert_eq!(response.status, enums::AttemptStatus::Charged);
}
<file_sep path="hyperswitch/connector-template/test.rs" role="context" start="59" end="65">
async fn should_capture_authorized_payment() {
let response = CONNECTOR
.authorize_and_capture_payment(payment_method_details(), None, get_default_payment_info())
.await
.expect("Capture payment response");
assert_eq!(response.status, enums::AttemptStatus::Charged);
}
<file_sep path="hyperswitch/connector-template/test.rs" role="context" start="42" end="44">
fn payment_method_details() -> Option<types::PaymentsAuthorizeData> {
None
}
<file_sep path="hyperswitch/connector-template/test.rs" role="context" start="38" end="40">
fn get_default_payment_info() -> Option<utils::PaymentInfo> {
None
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/connector-template/test.rs<|crate|> connector-template anchor=should_capture_authorized_payment kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/connector-template/test.rs" role="context" start="59" end="65">
async fn should_capture_authorized_payment() {
let response = CONNECTOR
.authorize_and_capture_payment(payment_method_details(), None, get_default_payment_info())
.await
.expect("Capture payment response");
assert_eq!(response.status, enums::AttemptStatus::Charged);
}
<file_sep path="hyperswitch/connector-template/test.rs" role="context" start="58" end="58">
use router::{
types::{self, api, storage::enums,
}};
<file_sep path="hyperswitch/connector-template/test.rs" role="context" start="86" end="106">
async fn should_sync_authorized_payment() {
let authorize_response = CONNECTOR
.authorize_payment(payment_method_details(), get_default_payment_info())
.await
.expect("Authorize payment response");
let txn_id = utils::get_connector_transaction_id(authorize_response.response);
let response = CONNECTOR
.psync_retry_till_status_matches(
enums::AttemptStatus::Authorized,
Some(types::PaymentsSyncData {
connector_transaction_id: types::ResponseId::ConnectorTransactionId(
txn_id.unwrap(),
),
..Default::default()
}),
get_default_payment_info(),
)
.await
.expect("PSync response");
assert_eq!(response.status, enums::AttemptStatus::Authorized,);
}
<file_sep path="hyperswitch/connector-template/test.rs" role="context" start="69" end="82">
async fn should_partially_capture_authorized_payment() {
let response = CONNECTOR
.authorize_and_capture_payment(
payment_method_details(),
Some(types::PaymentsCaptureData {
amount_to_capture: 50,
..utils::PaymentCaptureType::default().0
}),
get_default_payment_info(),
)
.await
.expect("Capture payment response");
assert_eq!(response.status, enums::AttemptStatus::Charged);
}
<file_sep path="hyperswitch/connector-template/test.rs" role="context" start="49" end="55">
async fn should_only_authorize_payment() {
let response = CONNECTOR
.authorize_payment(payment_method_details(), get_default_payment_info())
.await
.expect("Authorize payment response");
assert_eq!(response.status, enums::AttemptStatus::Authorized);
}
<file_sep path="hyperswitch/connector-template/test.rs" role="context" start="42" end="44">
fn payment_method_details() -> Option<types::PaymentsAuthorizeData> {
None
}
<file_sep path="hyperswitch/connector-template/test.rs" role="context" start="38" end="40">
fn get_default_payment_info() -> Option<utils::PaymentInfo> {
None
}
<file_sep path="hyperswitch/migrations/2023-07-07-091223_create_captures_table/up.sql" role="context" start="1" end="17">
CREATE TYPE "CaptureStatus" AS ENUM (
'started',
'charged',
'pending',
'failed'
);
ALTER TYPE "IntentStatus" ADD VALUE If NOT EXISTS 'partially_captured' AFTER 'requires_capture';
CREATE TABLE captures(
capture_id VARCHAR(64) NOT NULL PRIMARY KEY,
payment_id VARCHAR(64) NOT NULL,
merchant_id VARCHAR(64) NOT NULL,
status "CaptureStatus" NOT NULL,
amount BIGINT NOT NULL,
currency "Currency",
connector VARCHAR(255),
error_message VARCHAR(255),
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/connector-template/test.rs<|crate|> connector-template anchor=should_refund_auto_captured_payment kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/connector-template/test.rs" role="context" start="215" end="224">
async fn should_refund_auto_captured_payment() {
let response = CONNECTOR
.make_payment_and_refund(payment_method_details(), None, get_default_payment_info())
.await
.unwrap();
assert_eq!(
response.response.unwrap().refund_status,
enums::RefundStatus::Success,
);
}
<file_sep path="hyperswitch/connector-template/test.rs" role="context" start="214" end="214">
use router::{
types::{self, api, storage::enums,
}};
<file_sep path="hyperswitch/connector-template/test.rs" role="context" start="248" end="259">
async fn should_refund_succeeded_payment_multiple_times() {
CONNECTOR
.make_payment_and_multiple_refund(
payment_method_details(),
Some(types::RefundsData {
refund_amount: 50,
..utils::PaymentRefundType::default().0
}),
get_default_payment_info(),
)
.await;
}
<file_sep path="hyperswitch/connector-template/test.rs" role="context" start="228" end="244">
async fn should_partially_refund_succeeded_payment() {
let refund_response = CONNECTOR
.make_payment_and_refund(
payment_method_details(),
Some(types::RefundsData {
refund_amount: 50,
..utils::PaymentRefundType::default().0
}),
get_default_payment_info(),
)
.await
.unwrap();
assert_eq!(
refund_response.response.unwrap().refund_status,
enums::RefundStatus::Success,
);
}
<file_sep path="hyperswitch/connector-template/test.rs" role="context" start="191" end="211">
async fn should_sync_auto_captured_payment() {
let authorize_response = CONNECTOR.make_payment(payment_method_details(), get_default_payment_info()).await.unwrap();
assert_eq!(authorize_response.status, enums::AttemptStatus::Charged);
let txn_id = utils::get_connector_transaction_id(authorize_response.response);
assert_ne!(txn_id, None, "Empty connector transaction id");
let response = CONNECTOR
.psync_retry_till_status_matches(
enums::AttemptStatus::Charged,
Some(types::PaymentsSyncData {
connector_transaction_id: types::ResponseId::ConnectorTransactionId(
txn_id.unwrap(),
),
capture_method: Some(enums::CaptureMethod::Automatic),
..Default::default()
}),
get_default_payment_info(),
)
.await
.unwrap();
assert_eq!(response.status, enums::AttemptStatus::Charged,);
}
<file_sep path="hyperswitch/connector-template/test.rs" role="context" start="184" end="187">
async fn should_make_payment() {
let authorize_response = CONNECTOR.make_payment(payment_method_details(), get_default_payment_info()).await.unwrap();
assert_eq!(authorize_response.status, enums::AttemptStatus::Charged);
}
<file_sep path="hyperswitch/connector-template/test.rs" role="context" start="38" end="40">
fn get_default_payment_info() -> Option<utils::PaymentInfo> {
None
}
<file_sep path="hyperswitch/connector-template/test.rs" role="context" start="42" end="44">
fn payment_method_details() -> Option<types::PaymentsAuthorizeData> {
None
}
<file_sep path="hyperswitch/connector-template/transformers.rs" role="context" start="169" end="174">
pub enum RefundStatus {
Succeeded,
Failed,
#[default]
Processing,
}
<file_sep path="hyperswitch/crates/api_models/src/refunds.rs" role="context" start="378" end="384">
pub enum RefundStatus {
Succeeded,
Failed,
#[default]
Pending,
Review,
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/connector-template/test.rs<|crate|> connector-template anchor=should_refund_manually_captured_payment kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/connector-template/test.rs" role="context" start="128" end="137">
async fn should_refund_manually_captured_payment() {
let response = CONNECTOR
.capture_payment_and_refund(payment_method_details(), None, None, get_default_payment_info())
.await
.unwrap();
assert_eq!(
response.response.unwrap().refund_status,
enums::RefundStatus::Success,
);
}
<file_sep path="hyperswitch/connector-template/test.rs" role="context" start="127" end="127">
use router::{
types::{self, api, storage::enums,
}};
<file_sep path="hyperswitch/connector-template/test.rs" role="context" start="162" end="180">
async fn should_sync_manually_captured_refund() {
let refund_response = CONNECTOR
.capture_payment_and_refund(payment_method_details(), None, None, get_default_payment_info())
.await
.unwrap();
let response = CONNECTOR
.rsync_retry_till_status_matches(
enums::RefundStatus::Success,
refund_response.response.unwrap().connector_refund_id,
None,
get_default_payment_info(),
)
.await
.unwrap();
assert_eq!(
response.response.unwrap().refund_status,
enums::RefundStatus::Success,
);
}
<file_sep path="hyperswitch/connector-template/test.rs" role="context" start="141" end="158">
async fn should_partially_refund_manually_captured_payment() {
let response = CONNECTOR
.capture_payment_and_refund(
payment_method_details(),
None,
Some(types::RefundsData {
refund_amount: 50,
..utils::PaymentRefundType::default().0
}),
get_default_payment_info(),
)
.await
.unwrap();
assert_eq!(
response.response.unwrap().refund_status,
enums::RefundStatus::Success,
);
}
<file_sep path="hyperswitch/connector-template/test.rs" role="context" start="110" end="124">
async fn should_void_authorized_payment() {
let response = CONNECTOR
.authorize_and_void_payment(
payment_method_details(),
Some(types::PaymentsCancelData {
connector_transaction_id: String::from(""),
cancellation_reason: Some("requested_by_customer".to_string()),
..Default::default()
}),
get_default_payment_info(),
)
.await
.expect("Void payment response");
assert_eq!(response.status, enums::AttemptStatus::Voided);
}
<file_sep path="hyperswitch/connector-template/test.rs" role="context" start="86" end="106">
async fn should_sync_authorized_payment() {
let authorize_response = CONNECTOR
.authorize_payment(payment_method_details(), get_default_payment_info())
.await
.expect("Authorize payment response");
let txn_id = utils::get_connector_transaction_id(authorize_response.response);
let response = CONNECTOR
.psync_retry_till_status_matches(
enums::AttemptStatus::Authorized,
Some(types::PaymentsSyncData {
connector_transaction_id: types::ResponseId::ConnectorTransactionId(
txn_id.unwrap(),
),
..Default::default()
}),
get_default_payment_info(),
)
.await
.expect("PSync response");
assert_eq!(response.status, enums::AttemptStatus::Authorized,);
}
<file_sep path="hyperswitch/connector-template/test.rs" role="context" start="42" end="44">
fn payment_method_details() -> Option<types::PaymentsAuthorizeData> {
None
}
<file_sep path="hyperswitch/connector-template/test.rs" role="context" start="38" end="40">
fn get_default_payment_info() -> Option<utils::PaymentInfo> {
None
}
<file_sep path="hyperswitch/connector-template/transformers.rs" role="context" start="169" end="174">
pub enum RefundStatus {
Succeeded,
Failed,
#[default]
Processing,
}
<file_sep path="hyperswitch/crates/api_models/src/refunds.rs" role="context" start="378" end="384">
pub enum RefundStatus {
Succeeded,
Failed,
#[default]
Pending,
Review,
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/connector-template/test.rs<|crate|> connector-template anchor=should_refund_succeeded_payment_multiple_times kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=1<|meta_end|>
<file_sep path="hyperswitch/connector-template/test.rs" role="context" start="248" end="259">
async fn should_refund_succeeded_payment_multiple_times() {
CONNECTOR
.make_payment_and_multiple_refund(
payment_method_details(),
Some(types::RefundsData {
refund_amount: 50,
..utils::PaymentRefundType::default().0
}),
get_default_payment_info(),
)
.await;
}
<file_sep path="hyperswitch/connector-template/test.rs" role="context" start="247" end="247">
use router::{
types::{self, api, storage::enums,
}};
use crate::utils::{self, ConnectorActions};
<file_sep path="hyperswitch/connector-template/test.rs" role="context" start="286" end="304">
async fn should_fail_payment_for_incorrect_cvc() {
let response = CONNECTOR
.make_payment(
Some(types::PaymentsAuthorizeData {
payment_method_data: types::api::PaymentMethodData::Card(api::Card {
card_cvc: Secret::new("12345".to_string()),
..utils::CCardType::default().0
}),
..utils::PaymentAuthorizeType::default().0
}),
get_default_payment_info(),
)
.await
.unwrap();
assert_eq!(
response.response.unwrap_err().message,
"Your card's security code is invalid.".to_string(),
);
}
<file_sep path="hyperswitch/connector-template/test.rs" role="context" start="263" end="281">
async fn should_sync_refund() {
let refund_response = CONNECTOR
.make_payment_and_refund(payment_method_details(), None, get_default_payment_info())
.await
.unwrap();
let response = CONNECTOR
.rsync_retry_till_status_matches(
enums::RefundStatus::Success,
refund_response.response.unwrap().connector_refund_id,
None,
get_default_payment_info(),
)
.await
.unwrap();
assert_eq!(
response.response.unwrap().refund_status,
enums::RefundStatus::Success,
);
}
<file_sep path="hyperswitch/connector-template/test.rs" role="context" start="228" end="244">
async fn should_partially_refund_succeeded_payment() {
let refund_response = CONNECTOR
.make_payment_and_refund(
payment_method_details(),
Some(types::RefundsData {
refund_amount: 50,
..utils::PaymentRefundType::default().0
}),
get_default_payment_info(),
)
.await
.unwrap();
assert_eq!(
refund_response.response.unwrap().refund_status,
enums::RefundStatus::Success,
);
}
<file_sep path="hyperswitch/connector-template/test.rs" role="context" start="215" end="224">
async fn should_refund_auto_captured_payment() {
let response = CONNECTOR
.make_payment_and_refund(payment_method_details(), None, get_default_payment_info())
.await
.unwrap();
assert_eq!(
response.response.unwrap().refund_status,
enums::RefundStatus::Success,
);
}
<file_sep path="hyperswitch/connector-template/test.rs" role="context" start="38" end="40">
fn get_default_payment_info() -> Option<utils::PaymentInfo> {
None
}
<file_sep path="hyperswitch/connector-template/test.rs" role="context" start="42" end="44">
fn payment_method_details() -> Option<types::PaymentsAuthorizeData> {
None
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/connector-template/test.rs<|crate|> connector-template anchor=should_partially_capture_authorized_payment kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/connector-template/test.rs" role="context" start="69" end="82">
async fn should_partially_capture_authorized_payment() {
let response = CONNECTOR
.authorize_and_capture_payment(
payment_method_details(),
Some(types::PaymentsCaptureData {
amount_to_capture: 50,
..utils::PaymentCaptureType::default().0
}),
get_default_payment_info(),
)
.await
.expect("Capture payment response");
assert_eq!(response.status, enums::AttemptStatus::Charged);
}
<file_sep path="hyperswitch/connector-template/test.rs" role="context" start="68" end="68">
use router::{
types::{self, api, storage::enums,
}};
use crate::utils::{self, ConnectorActions};
<file_sep path="hyperswitch/connector-template/test.rs" role="context" start="110" end="124">
async fn should_void_authorized_payment() {
let response = CONNECTOR
.authorize_and_void_payment(
payment_method_details(),
Some(types::PaymentsCancelData {
connector_transaction_id: String::from(""),
cancellation_reason: Some("requested_by_customer".to_string()),
..Default::default()
}),
get_default_payment_info(),
)
.await
.expect("Void payment response");
assert_eq!(response.status, enums::AttemptStatus::Voided);
}
<file_sep path="hyperswitch/connector-template/test.rs" role="context" start="86" end="106">
async fn should_sync_authorized_payment() {
let authorize_response = CONNECTOR
.authorize_payment(payment_method_details(), get_default_payment_info())
.await
.expect("Authorize payment response");
let txn_id = utils::get_connector_transaction_id(authorize_response.response);
let response = CONNECTOR
.psync_retry_till_status_matches(
enums::AttemptStatus::Authorized,
Some(types::PaymentsSyncData {
connector_transaction_id: types::ResponseId::ConnectorTransactionId(
txn_id.unwrap(),
),
..Default::default()
}),
get_default_payment_info(),
)
.await
.expect("PSync response");
assert_eq!(response.status, enums::AttemptStatus::Authorized,);
}
<file_sep path="hyperswitch/connector-template/test.rs" role="context" start="59" end="65">
async fn should_capture_authorized_payment() {
let response = CONNECTOR
.authorize_and_capture_payment(payment_method_details(), None, get_default_payment_info())
.await
.expect("Capture payment response");
assert_eq!(response.status, enums::AttemptStatus::Charged);
}
<file_sep path="hyperswitch/connector-template/test.rs" role="context" start="49" end="55">
async fn should_only_authorize_payment() {
let response = CONNECTOR
.authorize_payment(payment_method_details(), get_default_payment_info())
.await
.expect("Authorize payment response");
assert_eq!(response.status, enums::AttemptStatus::Authorized);
}
<file_sep path="hyperswitch/connector-template/test.rs" role="context" start="42" end="44">
fn payment_method_details() -> Option<types::PaymentsAuthorizeData> {
None
}
<file_sep path="hyperswitch/connector-template/test.rs" role="context" start="38" end="40">
fn get_default_payment_info() -> Option<utils::PaymentInfo> {
None
}
<file_sep path="hyperswitch/migrations/2023-07-07-091223_create_captures_table/up.sql" role="context" start="1" end="17">
CREATE TYPE "CaptureStatus" AS ENUM (
'started',
'charged',
'pending',
'failed'
);
ALTER TYPE "IntentStatus" ADD VALUE If NOT EXISTS 'partially_captured' AFTER 'requires_capture';
CREATE TABLE captures(
capture_id VARCHAR(64) NOT NULL PRIMARY KEY,
payment_id VARCHAR(64) NOT NULL,
merchant_id VARCHAR(64) NOT NULL,
status "CaptureStatus" NOT NULL,
amount BIGINT NOT NULL,
currency "Currency",
connector VARCHAR(255),
error_message VARCHAR(255),
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/connector-template/test.rs<|crate|> connector-template anchor=should_void_authorized_payment kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=1<|meta_end|>
<file_sep path="hyperswitch/connector-template/test.rs" role="context" start="110" end="124">
async fn should_void_authorized_payment() {
let response = CONNECTOR
.authorize_and_void_payment(
payment_method_details(),
Some(types::PaymentsCancelData {
connector_transaction_id: String::from(""),
cancellation_reason: Some("requested_by_customer".to_string()),
..Default::default()
}),
get_default_payment_info(),
)
.await
.expect("Void payment response");
assert_eq!(response.status, enums::AttemptStatus::Voided);
}
<file_sep path="hyperswitch/connector-template/test.rs" role="context" start="109" end="109">
use router::{
types::{self, api, storage::enums,
}};
<file_sep path="hyperswitch/connector-template/test.rs" role="context" start="141" end="158">
async fn should_partially_refund_manually_captured_payment() {
let response = CONNECTOR
.capture_payment_and_refund(
payment_method_details(),
None,
Some(types::RefundsData {
refund_amount: 50,
..utils::PaymentRefundType::default().0
}),
get_default_payment_info(),
)
.await
.unwrap();
assert_eq!(
response.response.unwrap().refund_status,
enums::RefundStatus::Success,
);
}
<file_sep path="hyperswitch/connector-template/test.rs" role="context" start="128" end="137">
async fn should_refund_manually_captured_payment() {
let response = CONNECTOR
.capture_payment_and_refund(payment_method_details(), None, None, get_default_payment_info())
.await
.unwrap();
assert_eq!(
response.response.unwrap().refund_status,
enums::RefundStatus::Success,
);
}
<file_sep path="hyperswitch/connector-template/test.rs" role="context" start="86" end="106">
async fn should_sync_authorized_payment() {
let authorize_response = CONNECTOR
.authorize_payment(payment_method_details(), get_default_payment_info())
.await
.expect("Authorize payment response");
let txn_id = utils::get_connector_transaction_id(authorize_response.response);
let response = CONNECTOR
.psync_retry_till_status_matches(
enums::AttemptStatus::Authorized,
Some(types::PaymentsSyncData {
connector_transaction_id: types::ResponseId::ConnectorTransactionId(
txn_id.unwrap(),
),
..Default::default()
}),
get_default_payment_info(),
)
.await
.expect("PSync response");
assert_eq!(response.status, enums::AttemptStatus::Authorized,);
}
<file_sep path="hyperswitch/connector-template/test.rs" role="context" start="69" end="82">
async fn should_partially_capture_authorized_payment() {
let response = CONNECTOR
.authorize_and_capture_payment(
payment_method_details(),
Some(types::PaymentsCaptureData {
amount_to_capture: 50,
..utils::PaymentCaptureType::default().0
}),
get_default_payment_info(),
)
.await
.expect("Capture payment response");
assert_eq!(response.status, enums::AttemptStatus::Charged);
}
<file_sep path="hyperswitch/connector-template/test.rs" role="context" start="38" end="40">
fn get_default_payment_info() -> Option<utils::PaymentInfo> {
None
}
<file_sep path="hyperswitch/connector-template/test.rs" role="context" start="42" end="44">
fn payment_method_details() -> Option<types::PaymentsAuthorizeData> {
None
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/connector-template/test.rs<|crate|> connector-template anchor=should_partially_refund_succeeded_payment kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/connector-template/test.rs" role="context" start="228" end="244">
async fn should_partially_refund_succeeded_payment() {
let refund_response = CONNECTOR
.make_payment_and_refund(
payment_method_details(),
Some(types::RefundsData {
refund_amount: 50,
..utils::PaymentRefundType::default().0
}),
get_default_payment_info(),
)
.await
.unwrap();
assert_eq!(
refund_response.response.unwrap().refund_status,
enums::RefundStatus::Success,
);
}
<file_sep path="hyperswitch/connector-template/test.rs" role="context" start="227" end="227">
use router::{
types::{self, api, storage::enums,
}};
use crate::utils::{self, ConnectorActions};
<file_sep path="hyperswitch/connector-template/test.rs" role="context" start="263" end="281">
async fn should_sync_refund() {
let refund_response = CONNECTOR
.make_payment_and_refund(payment_method_details(), None, get_default_payment_info())
.await
.unwrap();
let response = CONNECTOR
.rsync_retry_till_status_matches(
enums::RefundStatus::Success,
refund_response.response.unwrap().connector_refund_id,
None,
get_default_payment_info(),
)
.await
.unwrap();
assert_eq!(
response.response.unwrap().refund_status,
enums::RefundStatus::Success,
);
}
<file_sep path="hyperswitch/connector-template/test.rs" role="context" start="248" end="259">
async fn should_refund_succeeded_payment_multiple_times() {
CONNECTOR
.make_payment_and_multiple_refund(
payment_method_details(),
Some(types::RefundsData {
refund_amount: 50,
..utils::PaymentRefundType::default().0
}),
get_default_payment_info(),
)
.await;
}
<file_sep path="hyperswitch/connector-template/test.rs" role="context" start="215" end="224">
async fn should_refund_auto_captured_payment() {
let response = CONNECTOR
.make_payment_and_refund(payment_method_details(), None, get_default_payment_info())
.await
.unwrap();
assert_eq!(
response.response.unwrap().refund_status,
enums::RefundStatus::Success,
);
}
<file_sep path="hyperswitch/connector-template/test.rs" role="context" start="191" end="211">
async fn should_sync_auto_captured_payment() {
let authorize_response = CONNECTOR.make_payment(payment_method_details(), get_default_payment_info()).await.unwrap();
assert_eq!(authorize_response.status, enums::AttemptStatus::Charged);
let txn_id = utils::get_connector_transaction_id(authorize_response.response);
assert_ne!(txn_id, None, "Empty connector transaction id");
let response = CONNECTOR
.psync_retry_till_status_matches(
enums::AttemptStatus::Charged,
Some(types::PaymentsSyncData {
connector_transaction_id: types::ResponseId::ConnectorTransactionId(
txn_id.unwrap(),
),
capture_method: Some(enums::CaptureMethod::Automatic),
..Default::default()
}),
get_default_payment_info(),
)
.await
.unwrap();
assert_eq!(response.status, enums::AttemptStatus::Charged,);
}
<file_sep path="hyperswitch/connector-template/test.rs" role="context" start="42" end="44">
fn payment_method_details() -> Option<types::PaymentsAuthorizeData> {
None
}
<file_sep path="hyperswitch/connector-template/test.rs" role="context" start="38" end="40">
fn get_default_payment_info() -> Option<utils::PaymentInfo> {
None
}
<file_sep path="hyperswitch/connector-template/transformers.rs" role="context" start="169" end="174">
pub enum RefundStatus {
Succeeded,
Failed,
#[default]
Processing,
}
<file_sep path="hyperswitch/crates/api_models/src/refunds.rs" role="context" start="378" end="384">
pub enum RefundStatus {
Succeeded,
Failed,
#[default]
Pending,
Review,
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/connector-template/test.rs<|crate|> connector-template anchor=should_partially_refund_manually_captured_payment kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/connector-template/test.rs" role="context" start="141" end="158">
async fn should_partially_refund_manually_captured_payment() {
let response = CONNECTOR
.capture_payment_and_refund(
payment_method_details(),
None,
Some(types::RefundsData {
refund_amount: 50,
..utils::PaymentRefundType::default().0
}),
get_default_payment_info(),
)
.await
.unwrap();
assert_eq!(
response.response.unwrap().refund_status,
enums::RefundStatus::Success,
);
}
<file_sep path="hyperswitch/connector-template/test.rs" role="context" start="140" end="140">
use router::{
types::{self, api, storage::enums,
}};
use crate::utils::{self, ConnectorActions};
<file_sep path="hyperswitch/connector-template/test.rs" role="context" start="184" end="187">
async fn should_make_payment() {
let authorize_response = CONNECTOR.make_payment(payment_method_details(), get_default_payment_info()).await.unwrap();
assert_eq!(authorize_response.status, enums::AttemptStatus::Charged);
}
<file_sep path="hyperswitch/connector-template/test.rs" role="context" start="162" end="180">
async fn should_sync_manually_captured_refund() {
let refund_response = CONNECTOR
.capture_payment_and_refund(payment_method_details(), None, None, get_default_payment_info())
.await
.unwrap();
let response = CONNECTOR
.rsync_retry_till_status_matches(
enums::RefundStatus::Success,
refund_response.response.unwrap().connector_refund_id,
None,
get_default_payment_info(),
)
.await
.unwrap();
assert_eq!(
response.response.unwrap().refund_status,
enums::RefundStatus::Success,
);
}
<file_sep path="hyperswitch/connector-template/test.rs" role="context" start="128" end="137">
async fn should_refund_manually_captured_payment() {
let response = CONNECTOR
.capture_payment_and_refund(payment_method_details(), None, None, get_default_payment_info())
.await
.unwrap();
assert_eq!(
response.response.unwrap().refund_status,
enums::RefundStatus::Success,
);
}
<file_sep path="hyperswitch/connector-template/test.rs" role="context" start="110" end="124">
async fn should_void_authorized_payment() {
let response = CONNECTOR
.authorize_and_void_payment(
payment_method_details(),
Some(types::PaymentsCancelData {
connector_transaction_id: String::from(""),
cancellation_reason: Some("requested_by_customer".to_string()),
..Default::default()
}),
get_default_payment_info(),
)
.await
.expect("Void payment response");
assert_eq!(response.status, enums::AttemptStatus::Voided);
}
<file_sep path="hyperswitch/connector-template/test.rs" role="context" start="38" end="40">
fn get_default_payment_info() -> Option<utils::PaymentInfo> {
None
}
<file_sep path="hyperswitch/connector-template/test.rs" role="context" start="42" end="44">
fn payment_method_details() -> Option<types::PaymentsAuthorizeData> {
None
}
<file_sep path="hyperswitch/connector-template/transformers.rs" role="context" start="169" end="174">
pub enum RefundStatus {
Succeeded,
Failed,
#[default]
Processing,
}
<file_sep path="hyperswitch/crates/api_models/src/refunds.rs" role="context" start="378" end="384">
pub enum RefundStatus {
Succeeded,
Failed,
#[default]
Pending,
Review,
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/connector-template/test.rs<|crate|> connector-template anchor=should_fail_for_refund_amount_higher_than_payment_amount kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/connector-template/test.rs" role="context" start="382" end="398">
async fn should_fail_for_refund_amount_higher_than_payment_amount() {
let response = CONNECTOR
.make_payment_and_refund(
payment_method_details(),
Some(types::RefundsData {
refund_amount: 150,
..utils::PaymentRefundType::default().0
}),
get_default_payment_info(),
)
.await
.unwrap();
assert_eq!(
response.response.unwrap_err().message,
"Refund amount (₹1.50) is greater than charge amount (₹1.00)",
);
}
<file_sep path="hyperswitch/connector-template/test.rs" role="context" start="381" end="381">
use router::{
types::{self, api, storage::enums,
}};
use crate::utils::{self, ConnectorActions};
<file_sep path="hyperswitch/connector-template/test.rs" role="context" start="369" end="378">
async fn should_fail_capture_for_invalid_payment() {
let capture_response = CONNECTOR
.capture_payment("123456789".to_string(), None, get_default_payment_info())
.await
.unwrap();
assert_eq!(
capture_response.response.unwrap_err().message,
String::from("No such payment_intent: '123456789'")
);
}
<file_sep path="hyperswitch/connector-template/test.rs" role="context" start="352" end="365">
async fn should_fail_void_payment_for_auto_capture() {
let authorize_response = CONNECTOR.make_payment(payment_method_details(), get_default_payment_info()).await.unwrap();
assert_eq!(authorize_response.status, enums::AttemptStatus::Charged);
let txn_id = utils::get_connector_transaction_id(authorize_response.response);
assert_ne!(txn_id, None, "Empty connector transaction id");
let void_response = CONNECTOR
.void_payment(txn_id.unwrap(), None, get_default_payment_info())
.await
.unwrap();
assert_eq!(
void_response.response.unwrap_err().message,
"You cannot cancel this PaymentIntent because it has a status of succeeded."
);
}
<file_sep path="hyperswitch/connector-template/test.rs" role="context" start="38" end="40">
fn get_default_payment_info() -> Option<utils::PaymentInfo> {
None
}
<file_sep path="hyperswitch/connector-template/test.rs" role="context" start="42" end="44">
fn payment_method_details() -> Option<types::PaymentsAuthorizeData> {
None
}
<file_sep path="hyperswitch/v2_compatible_migrations/2024-08-28-081721_add_v2_columns/up.sql" role="context" start="59" end="70">
ALTER TABLE merchant_connector_account
ADD COLUMN IF NOT EXISTS feature_metadata JSONB;
ALTER TABLE payment_methods
ADD COLUMN IF NOT EXISTS locker_fingerprint_id VARCHAR(64),
ADD COLUMN IF NOT EXISTS payment_method_type_v2 VARCHAR(64),
ADD COLUMN IF NOT EXISTS payment_method_subtype VARCHAR(64);
ALTER TABLE refund
ADD COLUMN IF NOT EXISTS id VARCHAR(64),
ADD COLUMN IF NOT EXISTS merchant_reference_id VARCHAR(64),
ADD COLUMN IF NOT EXISTS connector_id VARCHAR(64);
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/connector-template/test.rs<|crate|> connector-template anchor=should_sync_refund kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/connector-template/test.rs" role="context" start="263" end="281">
async fn should_sync_refund() {
let refund_response = CONNECTOR
.make_payment_and_refund(payment_method_details(), None, get_default_payment_info())
.await
.unwrap();
let response = CONNECTOR
.rsync_retry_till_status_matches(
enums::RefundStatus::Success,
refund_response.response.unwrap().connector_refund_id,
None,
get_default_payment_info(),
)
.await
.unwrap();
assert_eq!(
response.response.unwrap().refund_status,
enums::RefundStatus::Success,
);
}
<file_sep path="hyperswitch/connector-template/test.rs" role="context" start="262" end="262">
use router::{
types::{self, api, storage::enums,
}};
<file_sep path="hyperswitch/connector-template/test.rs" role="context" start="308" end="326">
async fn should_fail_payment_for_invalid_exp_month() {
let response = CONNECTOR
.make_payment(
Some(types::PaymentsAuthorizeData {
payment_method_data: api::PaymentMethodData::Card(api::Card {
card_exp_month: Secret::new("20".to_string()),
..utils::CCardType::default().0
}),
..utils::PaymentAuthorizeType::default().0
}),
get_default_payment_info(),
)
.await
.unwrap();
assert_eq!(
response.response.unwrap_err().message,
"Your card's expiration month is invalid.".to_string(),
);
}
<file_sep path="hyperswitch/connector-template/test.rs" role="context" start="286" end="304">
async fn should_fail_payment_for_incorrect_cvc() {
let response = CONNECTOR
.make_payment(
Some(types::PaymentsAuthorizeData {
payment_method_data: types::api::PaymentMethodData::Card(api::Card {
card_cvc: Secret::new("12345".to_string()),
..utils::CCardType::default().0
}),
..utils::PaymentAuthorizeType::default().0
}),
get_default_payment_info(),
)
.await
.unwrap();
assert_eq!(
response.response.unwrap_err().message,
"Your card's security code is invalid.".to_string(),
);
}
<file_sep path="hyperswitch/connector-template/test.rs" role="context" start="248" end="259">
async fn should_refund_succeeded_payment_multiple_times() {
CONNECTOR
.make_payment_and_multiple_refund(
payment_method_details(),
Some(types::RefundsData {
refund_amount: 50,
..utils::PaymentRefundType::default().0
}),
get_default_payment_info(),
)
.await;
}
<file_sep path="hyperswitch/connector-template/test.rs" role="context" start="228" end="244">
async fn should_partially_refund_succeeded_payment() {
let refund_response = CONNECTOR
.make_payment_and_refund(
payment_method_details(),
Some(types::RefundsData {
refund_amount: 50,
..utils::PaymentRefundType::default().0
}),
get_default_payment_info(),
)
.await
.unwrap();
assert_eq!(
refund_response.response.unwrap().refund_status,
enums::RefundStatus::Success,
);
}
<file_sep path="hyperswitch/connector-template/test.rs" role="context" start="42" end="44">
fn payment_method_details() -> Option<types::PaymentsAuthorizeData> {
None
}
<file_sep path="hyperswitch/connector-template/test.rs" role="context" start="38" end="40">
fn get_default_payment_info() -> Option<utils::PaymentInfo> {
None
}
<file_sep path="hyperswitch/connector-template/transformers.rs" role="context" start="169" end="174">
pub enum RefundStatus {
Succeeded,
Failed,
#[default]
Processing,
}
<file_sep path="hyperswitch/crates/api_models/src/refunds.rs" role="context" start="378" end="384">
pub enum RefundStatus {
Succeeded,
Failed,
#[default]
Pending,
Review,
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/connector-template/test.rs<|crate|> connector-template anchor=should_fail_void_payment_for_auto_capture kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/connector-template/test.rs" role="context" start="352" end="365">
async fn should_fail_void_payment_for_auto_capture() {
let authorize_response = CONNECTOR.make_payment(payment_method_details(), get_default_payment_info()).await.unwrap();
assert_eq!(authorize_response.status, enums::AttemptStatus::Charged);
let txn_id = utils::get_connector_transaction_id(authorize_response.response);
assert_ne!(txn_id, None, "Empty connector transaction id");
let void_response = CONNECTOR
.void_payment(txn_id.unwrap(), None, get_default_payment_info())
.await
.unwrap();
assert_eq!(
void_response.response.unwrap_err().message,
"You cannot cancel this PaymentIntent because it has a status of succeeded."
);
}
<file_sep path="hyperswitch/connector-template/test.rs" role="context" start="351" end="351">
use router::{
types::{self, api, storage::enums,
}};
use crate::utils::{self, ConnectorActions};
<file_sep path="hyperswitch/connector-template/test.rs" role="context" start="382" end="398">
async fn should_fail_for_refund_amount_higher_than_payment_amount() {
let response = CONNECTOR
.make_payment_and_refund(
payment_method_details(),
Some(types::RefundsData {
refund_amount: 150,
..utils::PaymentRefundType::default().0
}),
get_default_payment_info(),
)
.await
.unwrap();
assert_eq!(
response.response.unwrap_err().message,
"Refund amount (₹1.50) is greater than charge amount (₹1.00)",
);
}
<file_sep path="hyperswitch/connector-template/test.rs" role="context" start="369" end="378">
async fn should_fail_capture_for_invalid_payment() {
let capture_response = CONNECTOR
.capture_payment("123456789".to_string(), None, get_default_payment_info())
.await
.unwrap();
assert_eq!(
capture_response.response.unwrap_err().message,
String::from("No such payment_intent: '123456789'")
);
}
<file_sep path="hyperswitch/connector-template/test.rs" role="context" start="330" end="348">
async fn should_fail_payment_for_incorrect_expiry_year() {
let response = CONNECTOR
.make_payment(
Some(types::PaymentsAuthorizeData {
payment_method_data: api::PaymentMethodData::Card(api::Card {
card_exp_year: Secret::new("2000".to_string()),
..utils::CCardType::default().0
}),
..utils::PaymentAuthorizeType::default().0
}),
get_default_payment_info(),
)
.await
.unwrap();
assert_eq!(
response.response.unwrap_err().message,
"Your card's expiration year is invalid.".to_string(),
);
}
<file_sep path="hyperswitch/connector-template/test.rs" role="context" start="308" end="326">
async fn should_fail_payment_for_invalid_exp_month() {
let response = CONNECTOR
.make_payment(
Some(types::PaymentsAuthorizeData {
payment_method_data: api::PaymentMethodData::Card(api::Card {
card_exp_month: Secret::new("20".to_string()),
..utils::CCardType::default().0
}),
..utils::PaymentAuthorizeType::default().0
}),
get_default_payment_info(),
)
.await
.unwrap();
assert_eq!(
response.response.unwrap_err().message,
"Your card's expiration month is invalid.".to_string(),
);
}
<file_sep path="hyperswitch/connector-template/test.rs" role="context" start="42" end="44">
fn payment_method_details() -> Option<types::PaymentsAuthorizeData> {
None
}
<file_sep path="hyperswitch/connector-template/test.rs" role="context" start="38" end="40">
fn get_default_payment_info() -> Option<utils::PaymentInfo> {
None
}
<file_sep path="hyperswitch/v2_compatible_migrations/2024-08-28-081721_add_v2_columns/up.sql" role="context" start="19" end="35">
-- Intentionally not adding a default value here since we would have to
-- check if any merchants have enabled this from configs table,
-- before filling data for this column.
-- If no merchants have enabled this, then we can use `false` as the default value
-- when adding the column, later we can drop the default added for the column
-- so that we ensure new records inserted always have a value for the column.
ADD COLUMN should_collect_cvv_during_payment BOOLEAN;
ALTER TABLE payment_intent
ADD COLUMN merchant_reference_id VARCHAR(64),
ADD COLUMN billing_address BYTEA DEFAULT NULL,
ADD COLUMN shipping_address BYTEA DEFAULT NULL,
ADD COLUMN capture_method "CaptureMethod",
ADD COLUMN authentication_type "AuthenticationType",
ADD COLUMN amount_to_capture bigint,
ADD COLUMN prerouting_algorithm JSONB,
ADD COLUMN surcharge_amount bigint,
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/connector-template/test.rs<|crate|> connector-template anchor=should_sync_authorized_payment kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=1<|meta_end|>
<file_sep path="hyperswitch/connector-template/test.rs" role="context" start="86" end="106">
async fn should_sync_authorized_payment() {
let authorize_response = CONNECTOR
.authorize_payment(payment_method_details(), get_default_payment_info())
.await
.expect("Authorize payment response");
let txn_id = utils::get_connector_transaction_id(authorize_response.response);
let response = CONNECTOR
.psync_retry_till_status_matches(
enums::AttemptStatus::Authorized,
Some(types::PaymentsSyncData {
connector_transaction_id: types::ResponseId::ConnectorTransactionId(
txn_id.unwrap(),
),
..Default::default()
}),
get_default_payment_info(),
)
.await
.expect("PSync response");
assert_eq!(response.status, enums::AttemptStatus::Authorized,);
}
<file_sep path="hyperswitch/connector-template/test.rs" role="context" start="85" end="85">
use router::{
types::{self, api, storage::enums,
}};
use crate::utils::{self, ConnectorActions};
<file_sep path="hyperswitch/connector-template/test.rs" role="context" start="128" end="137">
async fn should_refund_manually_captured_payment() {
let response = CONNECTOR
.capture_payment_and_refund(payment_method_details(), None, None, get_default_payment_info())
.await
.unwrap();
assert_eq!(
response.response.unwrap().refund_status,
enums::RefundStatus::Success,
);
}
<file_sep path="hyperswitch/connector-template/test.rs" role="context" start="110" end="124">
async fn should_void_authorized_payment() {
let response = CONNECTOR
.authorize_and_void_payment(
payment_method_details(),
Some(types::PaymentsCancelData {
connector_transaction_id: String::from(""),
cancellation_reason: Some("requested_by_customer".to_string()),
..Default::default()
}),
get_default_payment_info(),
)
.await
.expect("Void payment response");
assert_eq!(response.status, enums::AttemptStatus::Voided);
}
<file_sep path="hyperswitch/connector-template/test.rs" role="context" start="69" end="82">
async fn should_partially_capture_authorized_payment() {
let response = CONNECTOR
.authorize_and_capture_payment(
payment_method_details(),
Some(types::PaymentsCaptureData {
amount_to_capture: 50,
..utils::PaymentCaptureType::default().0
}),
get_default_payment_info(),
)
.await
.expect("Capture payment response");
assert_eq!(response.status, enums::AttemptStatus::Charged);
}
<file_sep path="hyperswitch/connector-template/test.rs" role="context" start="59" end="65">
async fn should_capture_authorized_payment() {
let response = CONNECTOR
.authorize_and_capture_payment(payment_method_details(), None, get_default_payment_info())
.await
.expect("Capture payment response");
assert_eq!(response.status, enums::AttemptStatus::Charged);
}
<file_sep path="hyperswitch/connector-template/test.rs" role="context" start="38" end="40">
fn get_default_payment_info() -> Option<utils::PaymentInfo> {
None
}
<file_sep path="hyperswitch/connector-template/test.rs" role="context" start="42" end="44">
fn payment_method_details() -> Option<types::PaymentsAuthorizeData> {
None
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/connector-template/test.rs<|crate|> connector-template anchor=should_sync_auto_captured_payment kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=1<|meta_end|>
<file_sep path="hyperswitch/connector-template/test.rs" role="context" start="191" end="211">
async fn should_sync_auto_captured_payment() {
let authorize_response = CONNECTOR.make_payment(payment_method_details(), get_default_payment_info()).await.unwrap();
assert_eq!(authorize_response.status, enums::AttemptStatus::Charged);
let txn_id = utils::get_connector_transaction_id(authorize_response.response);
assert_ne!(txn_id, None, "Empty connector transaction id");
let response = CONNECTOR
.psync_retry_till_status_matches(
enums::AttemptStatus::Charged,
Some(types::PaymentsSyncData {
connector_transaction_id: types::ResponseId::ConnectorTransactionId(
txn_id.unwrap(),
),
capture_method: Some(enums::CaptureMethod::Automatic),
..Default::default()
}),
get_default_payment_info(),
)
.await
.unwrap();
assert_eq!(response.status, enums::AttemptStatus::Charged,);
}
<file_sep path="hyperswitch/connector-template/test.rs" role="context" start="190" end="190">
use router::{
types::{self, api, storage::enums,
}};
use crate::utils::{self, ConnectorActions};
<file_sep path="hyperswitch/connector-template/test.rs" role="context" start="228" end="244">
async fn should_partially_refund_succeeded_payment() {
let refund_response = CONNECTOR
.make_payment_and_refund(
payment_method_details(),
Some(types::RefundsData {
refund_amount: 50,
..utils::PaymentRefundType::default().0
}),
get_default_payment_info(),
)
.await
.unwrap();
assert_eq!(
refund_response.response.unwrap().refund_status,
enums::RefundStatus::Success,
);
}
<file_sep path="hyperswitch/connector-template/test.rs" role="context" start="215" end="224">
async fn should_refund_auto_captured_payment() {
let response = CONNECTOR
.make_payment_and_refund(payment_method_details(), None, get_default_payment_info())
.await
.unwrap();
assert_eq!(
response.response.unwrap().refund_status,
enums::RefundStatus::Success,
);
}
<file_sep path="hyperswitch/connector-template/test.rs" role="context" start="184" end="187">
async fn should_make_payment() {
let authorize_response = CONNECTOR.make_payment(payment_method_details(), get_default_payment_info()).await.unwrap();
assert_eq!(authorize_response.status, enums::AttemptStatus::Charged);
}
<file_sep path="hyperswitch/connector-template/test.rs" role="context" start="162" end="180">
async fn should_sync_manually_captured_refund() {
let refund_response = CONNECTOR
.capture_payment_and_refund(payment_method_details(), None, None, get_default_payment_info())
.await
.unwrap();
let response = CONNECTOR
.rsync_retry_till_status_matches(
enums::RefundStatus::Success,
refund_response.response.unwrap().connector_refund_id,
None,
get_default_payment_info(),
)
.await
.unwrap();
assert_eq!(
response.response.unwrap().refund_status,
enums::RefundStatus::Success,
);
}
<file_sep path="hyperswitch/connector-template/test.rs" role="context" start="38" end="40">
fn get_default_payment_info() -> Option<utils::PaymentInfo> {
None
}
<file_sep path="hyperswitch/connector-template/test.rs" role="context" start="42" end="44">
fn payment_method_details() -> Option<types::PaymentsAuthorizeData> {
None
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/connector-template/transformers.rs<|crate|> connector-template anchor=try_from kind=fn pack=symbol_neighborhood lang=rust role_window=k2 hops=2<|meta_end|>
<file_sep path="hyperswitch/connector-template/transformers.rs" role="context" start="214" end="222">
fn try_from(item: RefundsResponseRouterData<RSync, RefundResponse>) -> Result<Self,Self::Error> {
Ok(Self {
response: Ok(RefundsResponseData {
connector_refund_id: item.response.id.to_string(),
refund_status: enums::RefundStatus::from(item.response.status),
}),
..item.data
})
}
<file_sep path="hyperswitch/connector-template/transformers.rs" role="context" start="213" end="213">
use common_enums::enums;
use hyperswitch_domain_models::{
payment_method_data::PaymentMethodData,
router_data::{ConnectorAuthType, RouterData},
router_flow_types::refunds::{Execute, RSync},
router_request_types::ResponseId,
router_response_types::{PaymentsResponseData, RefundsResponseData},
types::{PaymentsAuthorizeRouterData, RefundsRouterData},
};
use crate::{
types::{RefundsResponseRouterData, ResponseRouterData},
utils::PaymentsAuthorizeRequestData,
};
<file_sep path="hyperswitch/connector-template/transformers.rs" role="context" start="198" end="208">
fn try_from(
item: RefundsResponseRouterData<Execute, RefundResponse>,
) -> Result<Self, Self::Error> {
Ok(Self {
response: Ok(RefundsResponseData {
connector_refund_id: item.response.id.to_string(),
refund_status: enums::RefundStatus::from(item.response.status),
}),
..item.data
})
}
<file_sep path="hyperswitch/connector-template/transformers.rs" role="context" start="177" end="184">
fn from(item: RefundStatus) -> Self {
match item {
RefundStatus::Succeeded => Self::Success,
RefundStatus::Failed => Self::Failure,
RefundStatus::Processing => Self::Pending,
//TODO: Review mapping
}
}
<file_sep path="hyperswitch/connector-template/transformers.rs" role="context" start="62" end="62">
type Error = error_stack::Report<errors::ConnectorError>;
<file_sep path="hyperswitch/connector-template/transformers.rs" role="context" start="189" end="192">
pub struct RefundResponse {
id: String,
status: RefundStatus
}
<file_sep path="hyperswitch/connector-template/transformers.rs" role="context" start="169" end="174">
pub enum RefundStatus {
Succeeded,
Failed,
#[default]
Processing,
}
<file_sep path="hyperswitch/crates/api_models/src/refunds.rs" role="context" start="378" end="384">
pub enum RefundStatus {
Succeeded,
Failed,
#[default]
Pending,
Review,
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/connector-template/transformers.rs<|crate|> connector-template anchor=try_from kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/connector-template/transformers.rs" role="context" start="198" end="208">
fn try_from(
item: RefundsResponseRouterData<Execute, RefundResponse>,
) -> Result<Self, Self::Error> {
Ok(Self {
response: Ok(RefundsResponseData {
connector_refund_id: item.response.id.to_string(),
refund_status: enums::RefundStatus::from(item.response.status),
}),
..item.data
})
}
<file_sep path="hyperswitch/connector-template/transformers.rs" role="context" start="197" end="197">
use common_enums::enums;
use hyperswitch_domain_models::{
payment_method_data::PaymentMethodData,
router_data::{ConnectorAuthType, RouterData},
router_flow_types::refunds::{Execute, RSync},
router_request_types::ResponseId,
router_response_types::{PaymentsResponseData, RefundsResponseData},
types::{PaymentsAuthorizeRouterData, RefundsRouterData},
};
use crate::{
types::{RefundsResponseRouterData, ResponseRouterData},
utils::PaymentsAuthorizeRequestData,
};
<file_sep path="hyperswitch/connector-template/transformers.rs" role="context" start="214" end="222">
fn try_from(item: RefundsResponseRouterData<RSync, RefundResponse>) -> Result<Self,Self::Error> {
Ok(Self {
response: Ok(RefundsResponseData {
connector_refund_id: item.response.id.to_string(),
refund_status: enums::RefundStatus::from(item.response.status),
}),
..item.data
})
}
<file_sep path="hyperswitch/connector-template/transformers.rs" role="context" start="177" end="184">
fn from(item: RefundStatus) -> Self {
match item {
RefundStatus::Succeeded => Self::Success,
RefundStatus::Failed => Self::Failure,
RefundStatus::Processing => Self::Pending,
//TODO: Review mapping
}
}
<file_sep path="hyperswitch/connector-template/transformers.rs" role="context" start="130" end="145">
fn try_from(item: ResponseRouterData<F, {{project-name | downcase | pascal_case}}PaymentsResponse, T, PaymentsResponseData>) -> Result<Self,Self::Error> {
Ok(Self {
status: common_enums::AttemptStatus::from(item.response.status),
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(item.response.id),
redirection_data: Box::new(None),
mandate_reference: Box::new(None),
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: None,
incremental_authorization_allowed: None,
charges: None,
}),
..item.data
})
}
<file_sep path="hyperswitch/connector-template/transformers.rs" role="context" start="62" end="62">
type Error = error_stack::Report<errors::ConnectorError>;
<file_sep path="hyperswitch/connector-template/transformers.rs" role="context" start="189" end="192">
pub struct RefundResponse {
id: String,
status: RefundStatus
}
<file_sep path="hyperswitch/connector-template/transformers.rs" role="context" start="169" end="174">
pub enum RefundStatus {
Succeeded,
Failed,
#[default]
Processing,
}
<file_sep path="hyperswitch/crates/api_models/src/refunds.rs" role="context" start="378" end="384">
pub enum RefundStatus {
Succeeded,
Failed,
#[default]
Pending,
Review,
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/connector-template/transformers.rs<|crate|> connector-template anchor=try_from kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=1<|meta_end|>
<file_sep path="hyperswitch/connector-template/transformers.rs" role="context" start="130" end="145">
fn try_from(item: ResponseRouterData<F, {{project-name | downcase | pascal_case}}PaymentsResponse, T, PaymentsResponseData>) -> Result<Self,Self::Error> {
Ok(Self {
status: common_enums::AttemptStatus::from(item.response.status),
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(item.response.id),
redirection_data: Box::new(None),
mandate_reference: Box::new(None),
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: None,
incremental_authorization_allowed: None,
charges: None,
}),
..item.data
})
}
<file_sep path="hyperswitch/connector-template/transformers.rs" role="context" start="129" end="129">
use common_enums::enums;
use hyperswitch_domain_models::{
payment_method_data::PaymentMethodData,
router_data::{ConnectorAuthType, RouterData},
router_flow_types::refunds::{Execute, RSync},
router_request_types::ResponseId,
router_response_types::{PaymentsResponseData, RefundsResponseData},
types::{PaymentsAuthorizeRouterData, RefundsRouterData},
};
use crate::{
types::{RefundsResponseRouterData, ResponseRouterData},
utils::PaymentsAuthorizeRequestData,
};
<file_sep path="hyperswitch/connector-template/transformers.rs" role="context" start="198" end="208">
fn try_from(
item: RefundsResponseRouterData<Execute, RefundResponse>,
) -> Result<Self, Self::Error> {
Ok(Self {
response: Ok(RefundsResponseData {
connector_refund_id: item.response.id.to_string(),
refund_status: enums::RefundStatus::from(item.response.status),
}),
..item.data
})
}
<file_sep path="hyperswitch/connector-template/transformers.rs" role="context" start="177" end="184">
fn from(item: RefundStatus) -> Self {
match item {
RefundStatus::Succeeded => Self::Success,
RefundStatus::Failed => Self::Failure,
RefundStatus::Processing => Self::Pending,
//TODO: Review mapping
}
}
<file_sep path="hyperswitch/connector-template/transformers.rs" role="context" start="112" end="117">
fn from(item: {{project-name | downcase | pascal_case}}PaymentStatus) -> Self {
match item {
{{project-name | downcase | pascal_case}}PaymentStatus::Succeeded => Self::Charged,
{{project-name | downcase | pascal_case}}PaymentStatus::Failed => Self::Failure,
{{project-name | downcase | pascal_case}}PaymentStatus::Processing => Self::Authorizing,
}
<file_sep path="hyperswitch/connector-template/transformers.rs" role="context" start="91" end="98">
fn try_from(auth_type: &ConnectorAuthType) -> Result<Self, Self::Error> {
match auth_type {
ConnectorAuthType::HeaderKey { api_key } => Ok(Self {
api_key: api_key.to_owned(),
}),
_ => Err(errors::ConnectorError::FailedToObtainAuthType.into()),
}
}
<file_sep path="hyperswitch/connector-template/transformers.rs" role="context" start="62" end="62">
type Error = error_stack::Report<errors::ConnectorError>;
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/connector-template/transformers.rs<|crate|> connector-template anchor=try_from kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/connector-template/transformers.rs" role="context" start="130" end="145">
fn try_from(item: ResponseRouterData<F, {{project-name | downcase | pascal_case}}PaymentsResponse, T, PaymentsResponseData>) -> Result<Self,Self::Error> {
Ok(Self {
status: common_enums::AttemptStatus::from(item.response.status),
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(item.response.id),
redirection_data: Box::new(None),
mandate_reference: Box::new(None),
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: None,
incremental_authorization_allowed: None,
charges: None,
}),
..item.data
})
}
<file_sep path="hyperswitch/connector-template/transformers.rs" role="context" start="129" end="129">
use common_enums::enums;
use hyperswitch_domain_models::{
payment_method_data::PaymentMethodData,
router_data::{ConnectorAuthType, RouterData},
router_flow_types::refunds::{Execute, RSync},
router_request_types::ResponseId,
router_response_types::{PaymentsResponseData, RefundsResponseData},
types::{PaymentsAuthorizeRouterData, RefundsRouterData},
};
use crate::{
types::{RefundsResponseRouterData, ResponseRouterData},
utils::PaymentsAuthorizeRequestData,
};
<file_sep path="hyperswitch/connector-template/transformers.rs" role="context" start="198" end="208">
fn try_from(
item: RefundsResponseRouterData<Execute, RefundResponse>,
) -> Result<Self, Self::Error> {
Ok(Self {
response: Ok(RefundsResponseData {
connector_refund_id: item.response.id.to_string(),
refund_status: enums::RefundStatus::from(item.response.status),
}),
..item.data
})
}
<file_sep path="hyperswitch/connector-template/transformers.rs" role="context" start="177" end="184">
fn from(item: RefundStatus) -> Self {
match item {
RefundStatus::Succeeded => Self::Success,
RefundStatus::Failed => Self::Failure,
RefundStatus::Processing => Self::Pending,
//TODO: Review mapping
}
}
<file_sep path="hyperswitch/connector-template/transformers.rs" role="context" start="112" end="117">
fn from(item: {{project-name | downcase | pascal_case}}PaymentStatus) -> Self {
match item {
{{project-name | downcase | pascal_case}}PaymentStatus::Succeeded => Self::Charged,
{{project-name | downcase | pascal_case}}PaymentStatus::Failed => Self::Failure,
{{project-name | downcase | pascal_case}}PaymentStatus::Processing => Self::Authorizing,
}
<file_sep path="hyperswitch/connector-template/transformers.rs" role="context" start="91" end="98">
fn try_from(auth_type: &ConnectorAuthType) -> Result<Self, Self::Error> {
match auth_type {
ConnectorAuthType::HeaderKey { api_key } => Ok(Self {
api_key: api_key.to_owned(),
}),
_ => Err(errors::ConnectorError::FailedToObtainAuthType.into()),
}
}
<file_sep path="hyperswitch/connector-template/transformers.rs" role="context" start="62" end="62">
type Error = error_stack::Report<errors::ConnectorError>;
<file_sep path="hyperswitch/crates/api_models/src/payments.rs" role="context" start="4748" end="5106">
pub struct PaymentsResponse {
/// Unique identifier for the payment. This ensures idempotency for multiple payments
/// that have been done by a single merchant.
#[schema(
min_length = 30,
max_length = 30,
example = "pay_mbabizu24mvu3mela5njyhpit4",
value_type = String,
)]
pub payment_id: id_type::PaymentId,
/// This is an identifier for the merchant account. This is inferred from the API key
/// provided during the request
#[schema(max_length = 255, example = "merchant_1668273825", value_type = String)]
pub merchant_id: id_type::MerchantId,
#[schema(value_type = IntentStatus, example = "failed", default = "requires_confirmation")]
pub status: api_enums::IntentStatus,
/// The payment amount. Amount for the payment in lowest denomination of the currency. (i.e) in cents for USD denomination, in paisa for INR denomination etc.,
#[schema(value_type = i64, example = 6540)]
pub amount: MinorUnit,
/// The payment net amount. net_amount = amount + surcharge_details.surcharge_amount + surcharge_details.tax_amount + shipping_cost + order_tax_amount,
/// If no surcharge_details, shipping_cost, order_tax_amount, net_amount = amount
#[schema(value_type = i64, example = 6540)]
pub net_amount: MinorUnit,
/// The shipping cost for the payment.
#[schema(value_type = Option<i64>, example = 6540)]
pub shipping_cost: Option<MinorUnit>,
/// The maximum amount that could be captured from the payment
#[schema(value_type = i64, minimum = 100, example = 6540)]
pub amount_capturable: MinorUnit,
/// The amount which is already captured from the payment, this helps in the cases where merchants can't capture all capturable amount at once.
#[schema(value_type = Option<i64>, example = 6540)]
pub amount_received: Option<MinorUnit>,
/// The connector used for the payment
#[schema(example = "stripe")]
pub connector: Option<String>,
/// It's a token used for client side verification.
#[schema(value_type = Option<String>, example = "pay_U42c409qyHwOkWo3vK60_secret_el9ksDkiB8hi6j9N78yo")]
pub client_secret: Option<Secret<String>>,
/// Time when the payment was created
#[schema(example = "2022-09-10T10:11:12Z")]
#[serde(with = "common_utils::custom_serde::iso8601::option")]
pub created: Option<PrimitiveDateTime>,
/// The currency of the amount of the payment
#[schema(value_type = Currency, example = "USD")]
pub currency: String,
/// The identifier for the customer object. If not provided the customer ID will be autogenerated.
/// This field will be deprecated soon. Please refer to `customer.id`
#[schema(
max_length = 64,
min_length = 1,
example = "cus_y3oqhf46pyzuxjbcn2giaqnb44",
deprecated,
value_type = Option<String>,
)]
pub customer_id: Option<id_type::CustomerId>,
pub customer: Option<CustomerDetailsResponse>,
/// A description of the payment
#[schema(example = "It's my first payment request")]
pub description: Option<String>,
/// List of refunds that happened on this intent, as same payment intent can have multiple refund requests depending on the nature of order
#[schema(value_type = Option<Vec<RefundResponse>>)]
pub refunds: Option<Vec<refunds::RefundResponse>>,
/// List of disputes that happened on this intent
#[schema(value_type = Option<Vec<DisputeResponsePaymentsRetrieve>>)]
pub disputes: Option<Vec<disputes::DisputeResponsePaymentsRetrieve>>,
/// List of attempts that happened on this intent
#[schema(value_type = Option<Vec<PaymentAttemptResponse>>)]
#[serde(skip_serializing_if = "Option::is_none")]
pub attempts: Option<Vec<PaymentAttemptResponse>>,
/// List of captures done on latest attempt
#[schema(value_type = Option<Vec<CaptureResponse>>)]
#[serde(skip_serializing_if = "Option::is_none")]
pub captures: Option<Vec<CaptureResponse>>,
/// A unique identifier to link the payment to a mandate, can be used instead of payment_method_data, in case of setting up recurring payments
#[schema(max_length = 255, example = "mandate_iwer89rnjef349dni3")]
pub mandate_id: Option<String>,
/// Provided mandate information for creating a mandate
pub mandate_data: Option<MandateData>,
/// Indicates that you intend to make future payments with this Payment’s payment method. Providing this parameter will attach the payment method to the Customer, if present, after the Payment is confirmed and any required actions from the user are complete.
#[schema(value_type = Option<FutureUsage>, example = "off_session")]
pub setup_future_usage: Option<api_enums::FutureUsage>,
/// Set to true to indicate that the customer is not in your checkout flow during this payment, and therefore is unable to authenticate. This parameter is intended for scenarios where you collect card details and charge them later. This parameter can only be used with confirm=true.
#[schema(example = true)]
pub off_session: Option<bool>,
/// A timestamp (ISO 8601 code) that determines when the payment should be captured.
/// Providing this field will automatically set `capture` to true
#[schema(example = "2022-09-10T10:11:12Z")]
#[serde(with = "common_utils::custom_serde::iso8601::option")]
#[remove_in(PaymentsCreateResponseOpenApi)]
pub capture_on: Option<PrimitiveDateTime>,
/// This is the instruction for capture/ debit the money from the users' card. On the other hand authorization refers to blocking the amount on the users' payment method.
#[schema(value_type = Option<CaptureMethod>, example = "automatic")]
pub capture_method: Option<api_enums::CaptureMethod>,
/// The payment method that is to be used
#[schema(value_type = PaymentMethod, example = "bank_transfer")]
pub payment_method: Option<api_enums::PaymentMethod>,
/// The payment method information provided for making a payment
#[schema(value_type = Option<PaymentMethodDataResponseWithBilling>, example = "bank_transfer")]
#[serde(serialize_with = "serialize_payment_method_data_response")]
pub payment_method_data: Option<PaymentMethodDataResponseWithBilling>,
/// Provide a reference to a stored payment method
#[schema(example = "187282ab-40ef-47a9-9206-5099ba31e432")]
pub payment_token: Option<String>,
/// The shipping address for the payment
pub shipping: Option<Address>,
/// The billing address for the payment
pub billing: Option<Address>,
/// Information about the product , quantity and amount for connectors. (e.g. Klarna)
#[schema(value_type = Option<Vec<OrderDetailsWithAmount>>, example = r#"[{
"product_name": "gillete creme",
"quantity": 15,
"amount" : 900
}]"#)]
pub order_details: Option<Vec<pii::SecretSerdeValue>>,
/// description: The customer's email address
/// This field will be deprecated soon. Please refer to `customer.email` object
#[schema(max_length = 255, value_type = Option<String>, example = "johntest@test.com", deprecated)]
pub email: crypto::OptionalEncryptableEmail,
/// description: The customer's name
/// This field will be deprecated soon. Please refer to `customer.name` object
#[schema(value_type = Option<String>, max_length = 255, example = "John Test", deprecated)]
pub name: crypto::OptionalEncryptableName,
/// The customer's phone number
/// This field will be deprecated soon. Please refer to `customer.phone` object
#[schema(value_type = Option<String>, max_length = 255, example = "9123456789", deprecated)]
pub phone: crypto::OptionalEncryptablePhone,
/// The URL to redirect after the completion of the operation
#[schema(example = "https://hyperswitch.io")]
pub return_url: Option<String>,
/// The transaction authentication can be set to undergo payer authentication. By default, the authentication will be marked as NO_THREE_DS, as the 3DS method helps with more robust payer authentication
#[schema(value_type = Option<AuthenticationType>, example = "no_three_ds", default = "three_ds")]
pub authentication_type: Option<api_enums::AuthenticationType>,
/// For non-card charges, you can use this value as the complete description that appears on your customers’ statements. Must contain at least one letter, maximum 22 characters.
#[schema(max_length = 255, example = "Hyperswitch Router")]
pub statement_descriptor_name: Option<String>,
/// Provides information about a card payment that customers see on their statements. Concatenated with the prefix (shortened descriptor) or statement descriptor that’s set on the account to form the complete statement descriptor. Maximum 255 characters for the concatenated descriptor.
#[schema(max_length = 255, example = "Payment for shoes purchase")]
pub statement_descriptor_suffix: Option<String>,
/// Additional information required for redirection
pub next_action: Option<NextActionData>,
/// If the payment was cancelled the reason will be provided here
pub cancellation_reason: Option<String>,
/// If there was an error while calling the connectors the code is received here
#[schema(example = "E0001")]
pub error_code: Option<String>,
/// If there was an error while calling the connector the error message is received here
#[schema(example = "Failed while verifying the card")]
pub error_message: Option<String>,
/// error code unified across the connectors is received here if there was an error while calling connector
#[remove_in(PaymentsCreateResponseOpenApi)]
pub unified_code: Option<String>,
/// error message unified across the connectors is received here if there was an error while calling connector
#[remove_in(PaymentsCreateResponseOpenApi)]
pub unified_message: Option<String>,
/// Payment Experience for the current payment
#[schema(value_type = Option<PaymentExperience>, example = "redirect_to_url")]
pub payment_experience: Option<api_enums::PaymentExperience>,
/// Can be used to specify the Payment Method Type
#[schema(value_type = Option<PaymentMethodType>, example = "gpay")]
pub payment_method_type: Option<api_enums::PaymentMethodType>,
/// The connector used for this payment along with the country and business details
#[schema(example = "stripe_US_food")]
pub connector_label: Option<String>,
/// The business country of merchant for this payment
#[schema(value_type = Option<CountryAlpha2>, example = "US")]
pub business_country: Option<api_enums::CountryAlpha2>,
/// The business label of merchant for this payment
pub business_label: Option<String>,
/// The business_sub_label for this payment
pub business_sub_label: Option<String>,
/// Allowed Payment Method Types for a given PaymentIntent
#[schema(value_type = Option<Vec<PaymentMethodType>>)]
pub allowed_payment_method_types: Option<serde_json::Value>,
/// ephemeral_key for the customer_id mentioned
pub ephemeral_key: Option<EphemeralKeyCreateResponse>,
/// If true the payment can be retried with same or different payment method which means the confirm call can be made again.
pub manual_retry_allowed: Option<bool>,
/// A unique identifier for a payment provided by the connector
#[schema(value_type = Option<String>, example = "993672945374576J")]
pub connector_transaction_id: Option<String>,
/// Frm message contains information about the frm response
pub frm_message: Option<FrmMessage>,
/// You can specify up to 50 keys, with key names up to 40 characters long and values up to 500 characters long. Metadata is useful for storing additional, structured information on an object.
#[schema(value_type = Option<Object>, example = r#"{ "udf1": "some-value", "udf2": "some-value" }"#)]
pub metadata: Option<serde_json::Value>,
/// Additional data related to some connectors
#[schema(value_type = Option<ConnectorMetadata>)]
pub connector_metadata: Option<serde_json::Value>, // This is Value because it is fetched from DB and before putting in DB the type is validated
/// Additional data that might be required by hyperswitch, to enable some specific features.
#[schema(value_type = Option<FeatureMetadata>)]
pub feature_metadata: Option<serde_json::Value>, // This is Value because it is fetched from DB and before putting in DB the type is validated
/// reference(Identifier) to the payment at connector side
#[schema(value_type = Option<String>, example = "993672945374576J")]
pub reference_id: Option<String>,
/// Details for Payment link
pub payment_link: Option<PaymentLinkResponse>,
/// The business profile that is associated with this payment
#[schema(value_type = Option<String>)]
pub profile_id: Option<id_type::ProfileId>,
/// Details of surcharge applied on this payment
pub surcharge_details: Option<RequestSurchargeDetails>,
/// Total number of attempts associated with this payment
pub attempt_count: i16,
/// Denotes the action(approve or reject) taken by merchant in case of manual review. Manual review can occur when the transaction is marked as risky by the frm_processor, payment processor or when there is underpayment/over payment incase of crypto payment
pub merchant_decision: Option<String>,
/// Identifier of the connector ( merchant connector account ) which was chosen to make the payment
#[schema(value_type = Option<String>)]
pub merchant_connector_id: Option<id_type::MerchantConnectorAccountId>,
/// If true, incremental authorization can be performed on this payment, in case the funds authorized initially fall short.
pub incremental_authorization_allowed: Option<bool>,
/// Total number of authorizations happened in an incremental_authorization payment
pub authorization_count: Option<i32>,
/// List of incremental authorizations happened to the payment
pub incremental_authorizations: Option<Vec<IncrementalAuthorizationResponse>>,
/// Details of external authentication
pub external_authentication_details: Option<ExternalAuthenticationDetailsResponse>,
/// Flag indicating if external 3ds authentication is made or not
pub external_3ds_authentication_attempted: Option<bool>,
/// Date Time for expiry of the payment
#[schema(example = "2022-09-10T10:11:12Z")]
#[serde(default, with = "common_utils::custom_serde::iso8601::option")]
pub expires_on: Option<PrimitiveDateTime>,
/// Payment Fingerprint, to identify a particular card.
/// It is a 20 character long alphanumeric code.
pub fingerprint: Option<String>,
#[schema(value_type = Option<BrowserInformation>)]
/// The browser information used for this payment
pub browser_info: Option<serde_json::Value>,
/// Identifier for Payment Method used for the payment
pub payment_method_id: Option<String>,
/// Payment Method Status, refers to the status of the payment method used for this payment.
#[schema(value_type = Option<PaymentMethodStatus>)]
pub payment_method_status: Option<common_enums::PaymentMethodStatus>,
/// Date time at which payment was updated
#[schema(example = "2022-09-10T10:11:12Z")]
#[serde(default, with = "common_utils::custom_serde::iso8601::option")]
pub updated: Option<PrimitiveDateTime>,
/// Fee information to be charged on the payment being collected
#[schema(value_type = Option<ConnectorChargeResponseData>)]
pub split_payments: Option<common_types::payments::ConnectorChargeResponseData>,
/// You can specify up to 50 keys, with key names up to 40 characters long and values up to 500 characters long. FRM Metadata is useful for storing additional, structured information on an object related to FRM.
#[schema(value_type = Option<Object>, example = r#"{ "fulfillment_method" : "deliver", "coverage_request" : "fraud" }"#)]
pub frm_metadata: Option<pii::SecretSerdeValue>,
/// flag that indicates if extended authorization is applied on this payment or not
#[schema(value_type = Option<bool>)]
pub extended_authorization_applied: Option<ExtendedAuthorizationAppliedBool>,
/// date and time after which this payment cannot be captured
#[serde(default, with = "common_utils::custom_serde::iso8601::option")]
pub capture_before: Option<PrimitiveDateTime>,
/// Merchant's identifier for the payment/invoice. This will be sent to the connector
/// if the connector provides support to accept multiple reference ids.
/// In case the connector supports only one reference id, Hyperswitch's Payment ID will be sent as reference.
#[schema(
value_type = Option<String>,
max_length = 255,
example = "Custom_Order_id_123"
)]
pub merchant_order_reference_id: Option<String>,
/// order tax amount calculated by tax connectors
pub order_tax_amount: Option<MinorUnit>,
/// Connector Identifier for the payment method
pub connector_mandate_id: Option<String>,
/// Method through which card was discovered
#[schema(value_type = Option<CardDiscovery>, example = "manual")]
pub card_discovery: Option<enums::CardDiscovery>,
/// Indicates if 3ds challenge is forced
pub force_3ds_challenge: Option<bool>,
/// Indicates if 3ds challenge is triggered
pub force_3ds_challenge_trigger: Option<bool>,
/// Error code received from the issuer in case of failed payments
pub issuer_error_code: Option<String>,
/// Error message received from the issuer in case of failed payments
pub issuer_error_message: Option<String>,
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/connector-template/test.rs<|crate|> connector-template anchor=should_fail_capture_for_invalid_payment kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=1<|meta_end|>
<file_sep path="hyperswitch/connector-template/test.rs" role="context" start="369" end="378">
async fn should_fail_capture_for_invalid_payment() {
let capture_response = CONNECTOR
.capture_payment("123456789".to_string(), None, get_default_payment_info())
.await
.unwrap();
assert_eq!(
capture_response.response.unwrap_err().message,
String::from("No such payment_intent: '123456789'")
);
}
<file_sep path="hyperswitch/connector-template/test.rs" role="context" start="382" end="398">
async fn should_fail_for_refund_amount_higher_than_payment_amount() {
let response = CONNECTOR
.make_payment_and_refund(
payment_method_details(),
Some(types::RefundsData {
refund_amount: 150,
..utils::PaymentRefundType::default().0
}),
get_default_payment_info(),
)
.await
.unwrap();
assert_eq!(
response.response.unwrap_err().message,
"Refund amount (₹1.50) is greater than charge amount (₹1.00)",
);
}
<file_sep path="hyperswitch/connector-template/test.rs" role="context" start="352" end="365">
async fn should_fail_void_payment_for_auto_capture() {
let authorize_response = CONNECTOR.make_payment(payment_method_details(), get_default_payment_info()).await.unwrap();
assert_eq!(authorize_response.status, enums::AttemptStatus::Charged);
let txn_id = utils::get_connector_transaction_id(authorize_response.response);
assert_ne!(txn_id, None, "Empty connector transaction id");
let void_response = CONNECTOR
.void_payment(txn_id.unwrap(), None, get_default_payment_info())
.await
.unwrap();
assert_eq!(
void_response.response.unwrap_err().message,
"You cannot cancel this PaymentIntent because it has a status of succeeded."
);
}
<file_sep path="hyperswitch/connector-template/test.rs" role="context" start="330" end="348">
async fn should_fail_payment_for_incorrect_expiry_year() {
let response = CONNECTOR
.make_payment(
Some(types::PaymentsAuthorizeData {
payment_method_data: api::PaymentMethodData::Card(api::Card {
card_exp_year: Secret::new("2000".to_string()),
..utils::CCardType::default().0
}),
..utils::PaymentAuthorizeType::default().0
}),
get_default_payment_info(),
)
.await
.unwrap();
assert_eq!(
response.response.unwrap_err().message,
"Your card's expiration year is invalid.".to_string(),
);
}
<file_sep path="hyperswitch/connector-template/test.rs" role="context" start="38" end="40">
fn get_default_payment_info() -> Option<utils::PaymentInfo> {
None
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/connector-template/test.rs<|crate|> connector-template anchor=should_fail_payment_for_invalid_exp_month kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=1<|meta_end|>
<file_sep path="hyperswitch/connector-template/test.rs" role="context" start="308" end="326">
async fn should_fail_payment_for_invalid_exp_month() {
let response = CONNECTOR
.make_payment(
Some(types::PaymentsAuthorizeData {
payment_method_data: api::PaymentMethodData::Card(api::Card {
card_exp_month: Secret::new("20".to_string()),
..utils::CCardType::default().0
}),
..utils::PaymentAuthorizeType::default().0
}),
get_default_payment_info(),
)
.await
.unwrap();
assert_eq!(
response.response.unwrap_err().message,
"Your card's expiration month is invalid.".to_string(),
);
}
<file_sep path="hyperswitch/connector-template/test.rs" role="context" start="307" end="307">
use masking::Secret;
use router::{
types::{self, api, storage::enums,
}};
use crate::utils::{self, ConnectorActions};
<file_sep path="hyperswitch/connector-template/test.rs" role="context" start="352" end="365">
async fn should_fail_void_payment_for_auto_capture() {
let authorize_response = CONNECTOR.make_payment(payment_method_details(), get_default_payment_info()).await.unwrap();
assert_eq!(authorize_response.status, enums::AttemptStatus::Charged);
let txn_id = utils::get_connector_transaction_id(authorize_response.response);
assert_ne!(txn_id, None, "Empty connector transaction id");
let void_response = CONNECTOR
.void_payment(txn_id.unwrap(), None, get_default_payment_info())
.await
.unwrap();
assert_eq!(
void_response.response.unwrap_err().message,
"You cannot cancel this PaymentIntent because it has a status of succeeded."
);
}
<file_sep path="hyperswitch/connector-template/test.rs" role="context" start="330" end="348">
async fn should_fail_payment_for_incorrect_expiry_year() {
let response = CONNECTOR
.make_payment(
Some(types::PaymentsAuthorizeData {
payment_method_data: api::PaymentMethodData::Card(api::Card {
card_exp_year: Secret::new("2000".to_string()),
..utils::CCardType::default().0
}),
..utils::PaymentAuthorizeType::default().0
}),
get_default_payment_info(),
)
.await
.unwrap();
assert_eq!(
response.response.unwrap_err().message,
"Your card's expiration year is invalid.".to_string(),
);
}
<file_sep path="hyperswitch/connector-template/test.rs" role="context" start="286" end="304">
async fn should_fail_payment_for_incorrect_cvc() {
let response = CONNECTOR
.make_payment(
Some(types::PaymentsAuthorizeData {
payment_method_data: types::api::PaymentMethodData::Card(api::Card {
card_cvc: Secret::new("12345".to_string()),
..utils::CCardType::default().0
}),
..utils::PaymentAuthorizeType::default().0
}),
get_default_payment_info(),
)
.await
.unwrap();
assert_eq!(
response.response.unwrap_err().message,
"Your card's security code is invalid.".to_string(),
);
}
<file_sep path="hyperswitch/connector-template/test.rs" role="context" start="263" end="281">
async fn should_sync_refund() {
let refund_response = CONNECTOR
.make_payment_and_refund(payment_method_details(), None, get_default_payment_info())
.await
.unwrap();
let response = CONNECTOR
.rsync_retry_till_status_matches(
enums::RefundStatus::Success,
refund_response.response.unwrap().connector_refund_id,
None,
get_default_payment_info(),
)
.await
.unwrap();
assert_eq!(
response.response.unwrap().refund_status,
enums::RefundStatus::Success,
);
}
<file_sep path="hyperswitch/connector-template/test.rs" role="context" start="38" end="40">
fn get_default_payment_info() -> Option<utils::PaymentInfo> {
None
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/connector-template/test.rs<|crate|> connector-template anchor=should_fail_payment_for_incorrect_expiry_year kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=1<|meta_end|>
<file_sep path="hyperswitch/connector-template/test.rs" role="context" start="330" end="348">
async fn should_fail_payment_for_incorrect_expiry_year() {
let response = CONNECTOR
.make_payment(
Some(types::PaymentsAuthorizeData {
payment_method_data: api::PaymentMethodData::Card(api::Card {
card_exp_year: Secret::new("2000".to_string()),
..utils::CCardType::default().0
}),
..utils::PaymentAuthorizeType::default().0
}),
get_default_payment_info(),
)
.await
.unwrap();
assert_eq!(
response.response.unwrap_err().message,
"Your card's expiration year is invalid.".to_string(),
);
}
<file_sep path="hyperswitch/connector-template/test.rs" role="context" start="329" end="329">
use masking::Secret;
use router::{
types::{self, api, storage::enums,
}};
use crate::utils::{self, ConnectorActions};
<file_sep path="hyperswitch/connector-template/test.rs" role="context" start="369" end="378">
async fn should_fail_capture_for_invalid_payment() {
let capture_response = CONNECTOR
.capture_payment("123456789".to_string(), None, get_default_payment_info())
.await
.unwrap();
assert_eq!(
capture_response.response.unwrap_err().message,
String::from("No such payment_intent: '123456789'")
);
}
<file_sep path="hyperswitch/connector-template/test.rs" role="context" start="352" end="365">
async fn should_fail_void_payment_for_auto_capture() {
let authorize_response = CONNECTOR.make_payment(payment_method_details(), get_default_payment_info()).await.unwrap();
assert_eq!(authorize_response.status, enums::AttemptStatus::Charged);
let txn_id = utils::get_connector_transaction_id(authorize_response.response);
assert_ne!(txn_id, None, "Empty connector transaction id");
let void_response = CONNECTOR
.void_payment(txn_id.unwrap(), None, get_default_payment_info())
.await
.unwrap();
assert_eq!(
void_response.response.unwrap_err().message,
"You cannot cancel this PaymentIntent because it has a status of succeeded."
);
}
<file_sep path="hyperswitch/connector-template/test.rs" role="context" start="308" end="326">
async fn should_fail_payment_for_invalid_exp_month() {
let response = CONNECTOR
.make_payment(
Some(types::PaymentsAuthorizeData {
payment_method_data: api::PaymentMethodData::Card(api::Card {
card_exp_month: Secret::new("20".to_string()),
..utils::CCardType::default().0
}),
..utils::PaymentAuthorizeType::default().0
}),
get_default_payment_info(),
)
.await
.unwrap();
assert_eq!(
response.response.unwrap_err().message,
"Your card's expiration month is invalid.".to_string(),
);
}
<file_sep path="hyperswitch/connector-template/test.rs" role="context" start="286" end="304">
async fn should_fail_payment_for_incorrect_cvc() {
let response = CONNECTOR
.make_payment(
Some(types::PaymentsAuthorizeData {
payment_method_data: types::api::PaymentMethodData::Card(api::Card {
card_cvc: Secret::new("12345".to_string()),
..utils::CCardType::default().0
}),
..utils::PaymentAuthorizeType::default().0
}),
get_default_payment_info(),
)
.await
.unwrap();
assert_eq!(
response.response.unwrap_err().message,
"Your card's security code is invalid.".to_string(),
);
}
<file_sep path="hyperswitch/connector-template/test.rs" role="context" start="38" end="40">
fn get_default_payment_info() -> Option<utils::PaymentInfo> {
None
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/connector-template/test.rs<|crate|> connector-template anchor=should_fail_payment_for_incorrect_cvc kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=1<|meta_end|>
<file_sep path="hyperswitch/connector-template/test.rs" role="context" start="286" end="304">
async fn should_fail_payment_for_incorrect_cvc() {
let response = CONNECTOR
.make_payment(
Some(types::PaymentsAuthorizeData {
payment_method_data: types::api::PaymentMethodData::Card(api::Card {
card_cvc: Secret::new("12345".to_string()),
..utils::CCardType::default().0
}),
..utils::PaymentAuthorizeType::default().0
}),
get_default_payment_info(),
)
.await
.unwrap();
assert_eq!(
response.response.unwrap_err().message,
"Your card's security code is invalid.".to_string(),
);
}
<file_sep path="hyperswitch/connector-template/test.rs" role="context" start="285" end="285">
use masking::Secret;
use router::{
types::{self, api, storage::enums,
}};
use crate::utils::{self, ConnectorActions};
<file_sep path="hyperswitch/connector-template/test.rs" role="context" start="330" end="348">
async fn should_fail_payment_for_incorrect_expiry_year() {
let response = CONNECTOR
.make_payment(
Some(types::PaymentsAuthorizeData {
payment_method_data: api::PaymentMethodData::Card(api::Card {
card_exp_year: Secret::new("2000".to_string()),
..utils::CCardType::default().0
}),
..utils::PaymentAuthorizeType::default().0
}),
get_default_payment_info(),
)
.await
.unwrap();
assert_eq!(
response.response.unwrap_err().message,
"Your card's expiration year is invalid.".to_string(),
);
}
<file_sep path="hyperswitch/connector-template/test.rs" role="context" start="308" end="326">
async fn should_fail_payment_for_invalid_exp_month() {
let response = CONNECTOR
.make_payment(
Some(types::PaymentsAuthorizeData {
payment_method_data: api::PaymentMethodData::Card(api::Card {
card_exp_month: Secret::new("20".to_string()),
..utils::CCardType::default().0
}),
..utils::PaymentAuthorizeType::default().0
}),
get_default_payment_info(),
)
.await
.unwrap();
assert_eq!(
response.response.unwrap_err().message,
"Your card's expiration month is invalid.".to_string(),
);
}
<file_sep path="hyperswitch/connector-template/test.rs" role="context" start="263" end="281">
async fn should_sync_refund() {
let refund_response = CONNECTOR
.make_payment_and_refund(payment_method_details(), None, get_default_payment_info())
.await
.unwrap();
let response = CONNECTOR
.rsync_retry_till_status_matches(
enums::RefundStatus::Success,
refund_response.response.unwrap().connector_refund_id,
None,
get_default_payment_info(),
)
.await
.unwrap();
assert_eq!(
response.response.unwrap().refund_status,
enums::RefundStatus::Success,
);
}
<file_sep path="hyperswitch/connector-template/test.rs" role="context" start="248" end="259">
async fn should_refund_succeeded_payment_multiple_times() {
CONNECTOR
.make_payment_and_multiple_refund(
payment_method_details(),
Some(types::RefundsData {
refund_amount: 50,
..utils::PaymentRefundType::default().0
}),
get_default_payment_info(),
)
.await;
}
<file_sep path="hyperswitch/connector-template/test.rs" role="context" start="38" end="40">
fn get_default_payment_info() -> Option<utils::PaymentInfo> {
None
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/common_utils/src/types.rs<|crate|> common_utils anchor=new kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=1<|meta_end|>
<file_sep path="hyperswitch/crates/common_utils/src/types.rs" role="context" start="722" end="727">
pub(crate) fn new(payment_id: id_type::GlobalPaymentId, secret: String) -> Self {
Self {
payment_id,
secret: masking::Secret::new(secret),
}
}
<file_sep path="hyperswitch/crates/common_utils/src/types.rs" role="context" start="721" end="721">
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;
<file_sep path="hyperswitch/crates/common_utils/src/types.rs" role="context" start="764" end="766">
fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
formatter.write_str("a string in the format '{payment_id}_secret_{secret}'")
}
<file_sep path="hyperswitch/crates/common_utils/src/types.rs" role="context" start="733" end="751">
fn from_str(str_value: &str) -> Result<Self, Self::Err> {
let (payment_id, secret) =
str_value
.rsplit_once("_secret_")
.ok_or(ParsingError::EncodeError(
"Expected a string in the format '{payment_id}_secret_{secret}'",
))?;
let payment_id = id_type::GlobalPaymentId::try_from(Cow::Owned(payment_id.to_owned()))
.map_err(|err| {
logger::error!(global_payment_id_error=?err);
ParsingError::EncodeError("Error while constructing GlobalPaymentId")
})?;
Ok(Self {
payment_id,
secret: masking::Secret::new(secret.to_owned()),
})
}
<file_sep path="hyperswitch/crates/common_utils/src/types.rs" role="context" start="713" end="719">
pub(crate) fn get_string_repr(&self) -> String {
format!(
"{}_secret_{}",
self.payment_id.get_string_repr(),
self.secret.peek()
)
}
<file_sep path="hyperswitch/crates/common_utils/src/types.rs" role="context" start="682" end="686">
fn from_sql(value: DB::RawValue<'_>) -> deserialize::Result<Self> {
let val = String::from_sql(value)?;
let url = url::Url::parse(&val)?;
Ok(Self(url))
}
<file_sep path="hyperswitch/crates/common_utils/src/types.rs" role="context" start="1004" end="1047">
fn amount_conversion_to_string_major_unit() {
let request_amount = MinorUnit::new(999999999);
let required_conversion = StringMajorUnitForConnector;
// Two decimal currency conversions
let converted_amount_two_decimal_currency = required_conversion
.convert(request_amount, TWO_DECIMAL_CURRENCY)
.unwrap();
assert_eq!(
converted_amount_two_decimal_currency.0,
"9999999.99".to_string()
);
let converted_back_amount = required_conversion
.convert_back(converted_amount_two_decimal_currency, TWO_DECIMAL_CURRENCY)
.unwrap();
assert_eq!(converted_back_amount, request_amount);
// Three decimal currency conversions
let converted_amount_three_decimal_currency = required_conversion
.convert(request_amount, THREE_DECIMAL_CURRENCY)
.unwrap();
assert_eq!(
converted_amount_three_decimal_currency.0,
"999999.999".to_string()
);
let converted_back_amount = required_conversion
.convert_back(
converted_amount_three_decimal_currency,
THREE_DECIMAL_CURRENCY,
)
.unwrap();
assert_eq!(converted_back_amount, request_amount);
// Zero decimal currency conversions
let converted_amount = required_conversion
.convert(request_amount, ZERO_DECIMAL_CURRENCY)
.unwrap();
assert_eq!(converted_amount.0, "999999999".to_string());
let converted_back_amount = required_conversion
.convert_back(converted_amount, ZERO_DECIMAL_CURRENCY)
.unwrap();
assert_eq!(converted_back_amount, request_amount);
}
<file_sep path="hyperswitch/crates/common_utils/src/types.rs" role="context" start="216" end="218">
pub fn new(major: u64, minor: u64, patch: u64) -> Self {
Self(Version::new(major, minor, patch))
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/common_utils/src/new_type.rs<|crate|> common_utils anchor=from kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=1<|meta_end|>
<file_sep path="hyperswitch/crates/common_utils/src/new_type.rs" role="context" start="234" end="236">
fn from(secret: Secret<String>) -> Self {
Self::from(secret.expose())
}
<file_sep path="hyperswitch/crates/common_utils/src/new_type.rs" role="context" start="233" end="233">
use masking::{ExposeInterface, PeekInterface, Secret};
<file_sep path="hyperswitch/crates/common_utils/src/new_type.rs" role="context" start="270" end="287">
fn test_apply_mask_fn() {
let value = "12345678901".to_string();
// Generic masked tests
assert_eq!(apply_mask(&value, 2, 2), "12*******01".to_string());
assert_eq!(apply_mask(&value, 3, 2), "123*****901".to_string());
assert_eq!(apply_mask(&value, 3, 3), "123*****901".to_string());
assert_eq!(apply_mask(&value, 4, 3), "1234***8901".to_string());
assert_eq!(apply_mask(&value, 4, 4), "*******8901".to_string());
assert_eq!(apply_mask(&value, 5, 4), "******78901".to_string());
assert_eq!(apply_mask(&value, 5, 5), "******78901".to_string());
assert_eq!(apply_mask(&value, 6, 5), "*****678901".to_string());
assert_eq!(apply_mask(&value, 6, 6), "*****678901".to_string());
assert_eq!(apply_mask(&value, 7, 6), "****5678901".to_string());
assert_eq!(apply_mask(&value, 7, 7), "****5678901".to_string());
assert_eq!(apply_mask(&value, 8, 7), "***45678901".to_string());
assert_eq!(apply_mask(&value, 8, 8), "***45678901".to_string());
}
<file_sep path="hyperswitch/crates/common_utils/src/new_type.rs" role="context" start="248" end="267">
fn test_masked_types() {
let sort_code = MaskedSortCode::from("110011".to_string());
let routing_number = MaskedRoutingNumber::from("056008849".to_string());
let bank_account = MaskedBankAccount::from("12345678901234".to_string());
let iban = MaskedIban::from("NL02ABNA0123456789".to_string());
let upi_vpa = MaskedUpiVpaId::from("someusername@okhdfcbank".to_string());
// Standard masked data tests
assert_eq!(sort_code.0.peek().to_owned(), "11**11".to_string());
assert_eq!(routing_number.0.peek().to_owned(), "056***849".to_string());
assert_eq!(
bank_account.0.peek().to_owned(),
"1234******1234".to_string()
);
assert_eq!(iban.0.peek().to_owned(), "NL02A********56789".to_string());
assert_eq!(
upi_vpa.0.peek().to_owned(),
"so**********@okhdfcbank".to_string()
);
}
<file_sep path="hyperswitch/crates/common_utils/src/new_type.rs" role="context" start="218" end="231">
fn from(src: String) -> Self {
let unmasked_char_count = 2;
let masked_value = if unmasked_char_count <= src.len() {
let len = src.len();
// mask every character except the last 2
"*".repeat(len - unmasked_char_count).to_string()
+ src
.get(len.saturating_sub(unmasked_char_count)..)
.unwrap_or("")
} else {
src
};
Self(Secret::from(masked_value))
}
<file_sep path="hyperswitch/crates/common_utils/src/new_type.rs" role="context" start="208" end="211">
fn foreign_from(email: Email) -> Self {
let email_value: String = email.expose().peek().to_owned();
Self::from(email_value)
}
<file_sep path="hyperswitch/crates/common_utils/src/new_type.rs" role="context" start="157" end="173">
fn from(src: String) -> Self {
let unmasked_char_count = 2;
let masked_value = if let Some((user_identifier, bank_or_psp)) = src.split_once('@') {
let masked_user_identifier = user_identifier
.to_string()
.chars()
.take(unmasked_char_count)
.collect::<String>()
+ &"*".repeat(user_identifier.len() - unmasked_char_count);
format!("{}@{}", masked_user_identifier, bank_or_psp)
} else {
let masked_value = apply_mask(src.as_ref(), unmasked_char_count, 8);
masked_value
};
Self(Secret::from(masked_value))
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/euclid/src/dssa/graph.rs<|crate|> euclid anchor=from_dir_values kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/euclid/src/dssa/graph.rs" role="context" start="125" end="136">
pub fn from_dir_values(vals: impl IntoIterator<Item = dir::DirValue>) -> Self {
let mut keywise_values: FxHashMap<dir::DirKey, FxHashSet<dir::DirValue>> =
FxHashMap::default();
for dir_val in vals {
let key = dir_val.get_key();
let set = keywise_values.entry(key).or_default();
set.insert(dir_val);
}
Self { keywise_values }
}
<file_sep path="hyperswitch/crates/euclid/src/dssa/graph.rs" role="context" start="124" end="124">
use rustc_hash::{FxHashMap, FxHashSet};
use crate::{
dssa::types,
frontend::dir,
types::{DataType, Metadata},
};
<file_sep path="hyperswitch/crates/euclid/src/dssa/graph.rs" role="context" start="145" end="153">
pub fn remove(&mut self, value: dir::DirValue) {
let set = self.keywise_values.entry(value.get_key()).or_default();
set.remove(&value);
if set.is_empty() {
self.keywise_values.remove(&value.get_key());
}
}
<file_sep path="hyperswitch/crates/euclid/src/dssa/graph.rs" role="context" start="138" end="143">
pub fn insert(&mut self, value: dir::DirValue) {
self.keywise_values
.entry(value.get_key())
.or_default()
.insert(value);
}
<file_sep path="hyperswitch/crates/euclid/src/dssa/graph.rs" role="context" start="104" end="116">
fn negation_from_graph_error(
metadata: Vec<&Metadata>,
graph_error: cgraph::GraphError<V>,
) -> Self {
match graph_error {
cgraph::GraphError::AnalysisError(trace) => Self::NegationTrace {
trace,
metadata: metadata.iter().map(|m| (*m).clone()).collect(),
},
other => Self::Graph(other),
}
}
<file_sep path="hyperswitch/crates/euclid/src/dssa/graph.rs" role="context" start="93" end="102">
fn assertion_from_graph_error(metadata: &Metadata, graph_error: cgraph::GraphError<V>) -> Self {
match graph_error {
cgraph::GraphError::AnalysisError(trace) => Self::AssertionTrace {
trace,
metadata: metadata.clone(),
},
other => Self::Graph(other),
}
}
<file_sep path="hyperswitch/crates/euclid/src/dssa/graph.rs" role="context" start="552" end="570">
fn test_strong_negative_relation_success() {
let graph = knowledge! {
PaymentMethod(Card) -> CaptureMethod(Automatic);
PaymentMethod(not Wallet) ->> CaptureMethod(Automatic);
};
let memo = &mut cgraph::Memoization::new();
let result = graph.key_value_analysis(
dirval!(CaptureMethod = Automatic),
&AnalysisContext::from_dir_values([
dirval!(CaptureMethod = Automatic),
dirval!(PaymentMethod = Card),
]),
memo,
&mut CycleCheck::new(),
None,
);
assert!(result.is_ok());
}
<file_sep path="hyperswitch/crates/euclid/src/dssa/graph.rs" role="context" start="688" end="706">
fn test_in_aggregator_success() {
let graph = knowledge! {
PaymentMethod(in [Card, Wallet]) -> CaptureMethod(Automatic);
};
let memo = &mut cgraph::Memoization::new();
let result = graph.key_value_analysis(
dirval!(CaptureMethod = Automatic),
&AnalysisContext::from_dir_values([
dirval!(CaptureMethod = Automatic),
dirval!(PaymentMethod = Card),
dirval!(PaymentMethod = Wallet),
]),
memo,
&mut CycleCheck::new(),
None,
);
assert!(result.is_ok());
}
<file_sep path="hyperswitch/crates/euclid/src/frontend/dir.rs" role="context" start="49" end="52">
pub struct DirKey {
pub kind: DirKeyKind,
pub value: Option<String>,
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/hyperswitch_interfaces/src/conversion_impls.rs<|crate|> hyperswitch_interfaces anchor=get_default_router_data kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/hyperswitch_interfaces/src/conversion_impls.rs" role="context" start="25" end="86">
fn get_default_router_data<F, Req, Resp>(
tenant_id: id_type::TenantId,
flow_name: &str,
request: Req,
response: Result<Resp, router_data::ErrorResponse>,
) -> RouterData<F, Req, Resp> {
RouterData {
tenant_id,
flow: std::marker::PhantomData,
merchant_id: id_type::MerchantId::get_irrelevant_merchant_id(),
customer_id: None,
connector_customer: None,
connector: get_irrelevant_id_string("connector", flow_name),
payment_id: id_type::PaymentId::get_irrelevant_id(flow_name)
.get_string_repr()
.to_owned(),
attempt_id: get_irrelevant_id_string("attempt_id", flow_name),
status: common_enums::AttemptStatus::default(),
payment_method: common_enums::PaymentMethod::default(),
connector_auth_type: router_data::ConnectorAuthType::default(),
description: None,
address: PaymentAddress::default(),
auth_type: common_enums::AuthenticationType::default(),
connector_meta_data: None,
connector_wallets_details: None,
amount_captured: None,
access_token: None,
session_token: None,
reference_id: None,
payment_method_token: None,
recurring_mandate_payment_data: None,
preprocessing_id: None,
payment_method_balance: None,
connector_api_version: None,
request,
response,
connector_request_reference_id: get_irrelevant_id_string(
"connector_request_reference_id",
flow_name,
),
#[cfg(feature = "payouts")]
payout_method_data: None,
#[cfg(feature = "payouts")]
quote_id: None,
test_mode: None,
connector_http_status_code: None,
external_latency: None,
apple_pay_flow: None,
frm_metadata: None,
dispute_id: None,
refund_id: None,
connector_response: None,
payment_method_status: None,
minor_amount_captured: None,
integrity_check: Ok(()),
additional_merchant_data: None,
header_payload: None,
connector_mandate_request_reference_id: None,
authentication_id: None,
psd2_sca_exemption_type: None,
}
}
<file_sep path="hyperswitch/crates/hyperswitch_interfaces/src/conversion_impls.rs" role="context" start="24" end="24">
use common_utils::{errors::CustomResult, id_type};
use hyperswitch_domain_models::{
payment_address::PaymentAddress,
router_data::{self, RouterData},
router_data_v2::{
flow_common_types::{
AccessTokenFlowData, BillingConnectorPaymentsSyncFlowData, DisputesFlowData,
ExternalAuthenticationFlowData, FilesFlowData, MandateRevokeFlowData, PaymentFlowData,
RefundFlowData, RevenueRecoveryRecordBackData, UasFlowData, WebhookSourceVerifyData,
},
RouterDataV2,
},
};
<file_sep path="hyperswitch/crates/hyperswitch_interfaces/src/conversion_impls.rs" role="context" start="106" end="122">
fn to_old_router_data(
new_router_data: RouterDataV2<T, Self, Req, Resp>,
) -> CustomResult<RouterData<T, Req, Resp>, ConnectorError>
where
Self: Sized,
{
let Self {} = new_router_data.resource_common_data;
let request = new_router_data.request.clone();
let response = new_router_data.response.clone();
let router_data = get_default_router_data(
new_router_data.tenant_id.clone(),
"access token",
request,
response,
);
Ok(router_data)
}
<file_sep path="hyperswitch/crates/hyperswitch_interfaces/src/conversion_impls.rs" role="context" start="89" end="104">
fn from_old_router_data(
old_router_data: &RouterData<T, Req, Resp>,
) -> CustomResult<RouterDataV2<T, Self, Req, Resp>, ConnectorError>
where
Self: Sized,
{
let resource_common_data = Self {};
Ok(RouterDataV2 {
flow: std::marker::PhantomData,
tenant_id: old_router_data.tenant_id.clone(),
resource_common_data,
connector_auth_type: old_router_data.connector_auth_type.clone(),
request: old_router_data.request.clone(),
response: old_router_data.response.clone(),
})
}
<file_sep path="hyperswitch/crates/hyperswitch_interfaces/src/conversion_impls.rs" role="context" start="22" end="24">
fn get_irrelevant_id_string(id_name: &str, flow_name: &str) -> String {
format!("irrelevant {id_name} in {flow_name} flow")
}
<file_sep path="hyperswitch/crates/hyperswitch_interfaces/src/conversion_impls.rs" role="context" start="822" end="838">
fn to_old_router_data(
new_router_data: RouterDataV2<T, Self, Req, Resp>,
) -> CustomResult<RouterData<T, Req, Resp>, ConnectorError>
where
Self: Sized,
{
let router_data = get_default_router_data(
new_router_data.tenant_id.clone(),
"BillingConnectorPaymentsSync",
new_router_data.request,
new_router_data.response,
);
Ok(RouterData {
connector_auth_type: new_router_data.connector_auth_type.clone(),
..router_data
})
}
<file_sep path="hyperswitch/crates/hyperswitch_interfaces/src/conversion_impls.rs" role="context" start="352" end="385">
fn to_old_router_data(
new_router_data: RouterDataV2<T, Self, Req, Resp>,
) -> CustomResult<RouterData<T, Req, Resp>, ConnectorError>
where
Self: Sized,
{
let Self {
merchant_id,
payment_id,
attempt_id,
payment_method,
connector_meta_data,
amount_captured,
minor_amount_captured,
connector_request_reference_id,
dispute_id,
} = new_router_data.resource_common_data;
let mut router_data = get_default_router_data(
new_router_data.tenant_id.clone(),
"Disputes",
new_router_data.request,
new_router_data.response,
);
router_data.merchant_id = merchant_id;
router_data.payment_id = payment_id;
router_data.attempt_id = attempt_id;
router_data.payment_method = payment_method;
router_data.connector_meta_data = connector_meta_data;
router_data.amount_captured = amount_captured;
router_data.minor_amount_captured = minor_amount_captured;
router_data.connector_request_reference_id = connector_request_reference_id;
router_data.dispute_id = Some(dispute_id);
Ok(router_data)
}
<file_sep path="hyperswitch/v2_compatible_migrations/2024-08-28-081721_add_v2_columns/up.sql" role="context" start="54" end="70">
ADD COLUMN redirection_data JSONB,
ADD COLUMN connector_payment_data TEXT,
ADD COLUMN connector_token_details JSONB;
-- Change the type of the column from JSON to JSONB
ALTER TABLE merchant_connector_account
ADD COLUMN IF NOT EXISTS feature_metadata JSONB;
ALTER TABLE payment_methods
ADD COLUMN IF NOT EXISTS locker_fingerprint_id VARCHAR(64),
ADD COLUMN IF NOT EXISTS payment_method_type_v2 VARCHAR(64),
ADD COLUMN IF NOT EXISTS payment_method_subtype VARCHAR(64);
ALTER TABLE refund
ADD COLUMN IF NOT EXISTS id VARCHAR(64),
ADD COLUMN IF NOT EXISTS merchant_reference_id VARCHAR(64),
ADD COLUMN IF NOT EXISTS connector_id VARCHAR(64);
<file_sep path="hyperswitch/crates/api_models/src/admin.rs" role="context" start="698" end="700">
pub struct MerchantId {
pub merchant_id: id_type::MerchantId,
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/hyperswitch_domain_models/src/type_encryption.rs<|crate|> hyperswitch_domain_models anchor=is_encryption_service_enabled kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=1<|meta_end|>
<file_sep path="hyperswitch/crates/hyperswitch_domain_models/src/type_encryption.rs" role="context" start="102" end="111">
fn is_encryption_service_enabled(_state: &KeyManagerState) -> bool {
#[cfg(feature = "encryption_service")]
{
_state.enabled
}
#[cfg(not(feature = "encryption_service"))]
{
false
}
}
<file_sep path="hyperswitch/crates/hyperswitch_domain_models/src/type_encryption.rs" role="context" start="101" end="101">
use common_utils::{
crypto,
encryption::Encryption,
errors::{self, CustomResult},
ext_traits::AsyncExt,
metrics::utils::record_operation_time,
types::keymanager::{Identifier, KeyManagerState},
};
<file_sep path="hyperswitch/crates/hyperswitch_domain_models/src/type_encryption.rs" role="context" start="156" end="196">
async fn decrypt_via_api(
state: &KeyManagerState,
encrypted_data: Encryption,
identifier: Identifier,
key: &[u8],
crypt_algo: V,
) -> CustomResult<Self, errors::CryptoError> {
// If encryption service is not enabled, fall back to application encryption or else call encryption service
if !is_encryption_service_enabled(state) {
Self::decrypt(encrypted_data, key, crypt_algo).await
} else {
let result: Result<
DecryptDataResponse,
error_stack::Report<errors::KeyManagerClientError>,
> = call_encryption_service(
state,
Method::POST,
"data/decrypt",
TransientDecryptDataRequest::from((encrypted_data.clone(), identifier)),
)
.await;
let decrypted = match result {
Ok(decrypted_data) => {
ForeignTryFrom::foreign_try_from((encrypted_data.clone(), decrypted_data))
}
Err(err) => {
logger::error!("Decryption error {:?}", err);
Err(err.change_context(errors::CryptoError::DecodingFailed))
}
};
match decrypted {
Ok(de) => Ok(de),
Err(_) => {
metrics::DECRYPTION_API_FAILURES.add(1, &[]);
logger::info!("Fall back to Application Decryption");
Self::decrypt(encrypted_data, key, crypt_algo).await
}
}
}
}
<file_sep path="hyperswitch/crates/hyperswitch_domain_models/src/type_encryption.rs" role="context" start="121" end="152">
async fn encrypt_via_api(
state: &KeyManagerState,
masked_data: Secret<String, S>,
identifier: Identifier,
key: &[u8],
crypt_algo: V,
) -> CustomResult<Self, errors::CryptoError> {
// If encryption service is not enabled, fall back to application encryption or else call encryption service
if !is_encryption_service_enabled(state) {
Self::encrypt(masked_data, key, crypt_algo).await
} else {
let result: Result<
EncryptDataResponse,
error_stack::Report<errors::KeyManagerClientError>,
> = call_encryption_service(
state,
Method::POST,
"data/encrypt",
EncryptDataRequest::from((masked_data.clone(), identifier)),
)
.await;
match result {
Ok(response) => Ok(ForeignFrom::foreign_from((masked_data.clone(), response))),
Err(err) => {
logger::error!("Encryption error {:?}", err);
metrics::ENCRYPTION_API_FAILURES.add(1, &[]);
logger::info!("Fall back to Application Encryption");
Self::encrypt(masked_data, key, crypt_algo).await
}
}
}
}
<file_sep path="hyperswitch/crates/hyperswitch_domain_models/src/type_encryption.rs" role="context" start="265" end="304">
async fn batch_decrypt_via_api(
state: &KeyManagerState,
encrypted_data: FxHashMap<String, Encryption>,
identifier: Identifier,
key: &[u8],
crypt_algo: V,
) -> CustomResult<FxHashMap<String, Self>, errors::CryptoError> {
// If encryption service is not enabled, fall back to application encryption or else call encryption service
if !is_encryption_service_enabled(state) {
Self::batch_decrypt(encrypted_data, key, crypt_algo).await
} else {
let result: Result<
BatchDecryptDataResponse,
error_stack::Report<errors::KeyManagerClientError>,
> = call_encryption_service(
state,
Method::POST,
"data/decrypt",
TransientBatchDecryptDataRequest::from((encrypted_data.clone(), identifier)),
)
.await;
let decrypted = match result {
Ok(decrypted_data) => {
ForeignTryFrom::foreign_try_from((encrypted_data.clone(), decrypted_data))
}
Err(err) => {
logger::error!("Decryption error {:?}", err);
Err(err.change_context(errors::CryptoError::DecodingFailed))
}
};
match decrypted {
Ok(de) => Ok(de),
Err(_) => {
metrics::DECRYPTION_API_FAILURES.add(1, &[]);
logger::info!("Fall back to Application Decryption");
Self::batch_decrypt(encrypted_data, key, crypt_algo).await
}
}
}
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/euclid/src/frontend/ast/parser.rs<|crate|> euclid anchor=skip_ws kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=1<|meta_end|>
<file_sep path="hyperswitch/crates/euclid/src/frontend/ast/parser.rs" role="context" start="54" end="59">
pub fn skip_ws<'a, F, O>(inner: F) -> impl FnMut(&'a str) -> ParseResult<&'a str, O>
where
F: FnMut(&'a str) -> ParseResult<&'a str, O> + 'a,
{
sequence::preceded(pchar::multispace0, inner)
}
<file_sep path="hyperswitch/crates/euclid/src/frontend/ast/parser.rs" role="context" start="53" end="53">
use nom::{
branch, bytes::complete, character::complete as pchar, combinator, error, multi, sequence,
};
pub type ParseResult<T, U> = nom::IResult<T, U, error::VerboseError<T>>;
<file_sep path="hyperswitch/crates/euclid/src/frontend/ast/parser.rs" role="context" start="74" end="86">
pub fn string_str(input: &str) -> ParseResult<&str, String> {
error::context(
"String",
combinator::map(
sequence::delimited(
complete::tag("\""),
complete::take_while1(|c: char| c != '"'),
complete::tag("\""),
),
|val: &str| val.to_string(),
),
)(input)
}
<file_sep path="hyperswitch/crates/euclid/src/frontend/ast/parser.rs" role="context" start="61" end="72">
pub fn num_i64(input: &str) -> ParseResult<&str, i64> {
error::context(
"num_i32",
combinator::map_res(
complete::take_while1(|c: char| c.is_ascii_digit()),
|o: &str| {
o.parse::<i64>()
.map_err(|_| EuclidError::InvalidNumber(o.to_string()))
},
),
)(input)
}
<file_sep path="hyperswitch/crates/euclid/src/frontend/ast/parser.rs" role="context" start="21" end="52">
fn parse_output(input: &str) -> ParseResult<&str, Self> {
let string_w = sequence::delimited(
skip_ws(complete::tag("\"")),
complete::take_while(|c| c != '"'),
skip_ws(complete::tag("\"")),
);
let full_sequence = multi::many0(sequence::preceded(
skip_ws(complete::tag(",")),
sequence::delimited(
skip_ws(complete::tag("\"")),
complete::take_while(|c| c != '"'),
skip_ws(complete::tag("\"")),
),
));
let sequence = sequence::pair(string_w, full_sequence);
error::context(
"dummy_strings",
combinator::map(
sequence::delimited(
skip_ws(complete::tag("[")),
sequence,
skip_ws(complete::tag("]")),
),
|out: (&str, Vec<&str>)| {
let mut first = out.1;
first.insert(0, out.0);
let v = first.iter().map(|s| s.to_string()).collect();
Self { outputs: v }
},
),
)(input)
}
<file_sep path="hyperswitch/crates/euclid/src/frontend/ast/parser.rs" role="context" start="335" end="357">
pub fn comparison_array(input: &str) -> ParseResult<&str, Vec<ast::Comparison>> {
let many_with_ampersand = error::context(
"many_with_amp",
multi::many0(sequence::preceded(skip_ws(complete::tag("&")), comparison)),
);
let full_sequence = sequence::pair(
skip_ws(branch::alt((comparison, arbitrary_comparison))),
many_with_ampersand,
);
error::context(
"comparison_array",
combinator::map(
full_sequence,
|tup: (ast::Comparison, Vec<ast::Comparison>)| {
let mut rest = tup.1;
rest.insert(0, tup.0);
rest
},
),
)(input)
}
<file_sep path="hyperswitch/crates/euclid/src/frontend/ast/parser.rs" role="context" start="313" end="333">
pub fn arbitrary_comparison(input: &str) -> ParseResult<&str, ast::Comparison> {
error::context(
"condition",
combinator::map(
sequence::tuple((
skip_ws(string_str),
skip_ws(comparison_type),
skip_ws(string_str),
)),
|tup: (String, ast::ComparisonType, String)| ast::Comparison {
lhs: "metadata".to_string(),
comparison: tup.1,
value: ast::ValueType::MetadataVariant(ast::MetadataValue {
key: tup.0,
value: tup.2,
}),
metadata: std::collections::HashMap::new(),
},
),
)(input)
}
<file_sep path="hyperswitch/crates/euclid/src/frontend/ast/parser.rs" role="context" start="7" end="7">
pub type ParseResult<T, U> = nom::IResult<T, U, error::VerboseError<T>>;
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/common_utils/src/types.rs<|crate|> common_utils anchor=from_sql kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=1<|meta_end|>
<file_sep path="hyperswitch/crates/common_utils/src/types.rs" role="context" start="1591" end="1594">
fn from_sql(bytes: DB::RawValue<'_>) -> deserialize::Result<Self> {
let val = LengthString::<PUBLISHABLE_KEY_LENGTH, PUBLISHABLE_KEY_LENGTH>::from_sql(bytes)?;
Ok(Self(val))
}
<file_sep path="hyperswitch/crates/common_utils/src/types.rs" role="context" start="1590" end="1590">
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,
};
<file_sep path="hyperswitch/crates/common_utils/src/types.rs" role="context" start="1602" end="1604">
fn to_sql<'b>(&'b self, out: &mut Output<'b, '_, DB>) -> diesel::serialize::Result {
self.0.to_sql(out)
}
<file_sep path="hyperswitch/crates/common_utils/src/types.rs" role="context" start="1581" end="1583">
fn build(row: Self::Row) -> deserialize::Result<Self> {
Ok(row)
}
<file_sep path="hyperswitch/crates/common_utils/src/types.rs" role="context" start="1569" end="1571">
pub fn get_string_repr(&self) -> &str {
&self.0 .0
}
<file_sep path="hyperswitch/crates/common_utils/src/types.rs" role="context" start="1350" end="1353">
fn from_sql(bytes: DB::RawValue<'_>) -> deserialize::Result<Self> {
let val = String::from_sql(bytes)?;
Ok(Self::try_from(val)?)
}
<file_sep path="hyperswitch/crates/common_utils/src/types.rs" role="context" start="824" end="843">
fn from_sql(value: DB::RawValue<'_>) -> deserialize::Result<Self> {
let string_repr = String::from_sql(value)?;
let (payment_id, secret) =
string_repr
.rsplit_once("_secret_")
.ok_or(ParsingError::EncodeError(
"Expected a string in the format '{payment_id}_secret_{secret}'",
))?;
let payment_id = id_type::GlobalPaymentId::try_from(Cow::Owned(payment_id.to_owned()))
.map_err(|err| {
logger::error!(global_payment_id_error=?err);
ParsingError::EncodeError("Error while constructing GlobalPaymentId")
})?;
Ok(Self {
payment_id,
secret: masking::Secret::new(secret.to_owned()),
})
}
<file_sep path="hyperswitch/crates/common_utils/src/types.rs" role="context" start="1089" end="1089">
pub(crate) struct LengthString<const MAX_LENGTH: u16, const MIN_LENGTH: u16>(String);
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/common_utils/src/crypto.rs<|crate|> common_utils anchor=new kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/common_utils/src/crypto.rs" role="context" start="499" end="507">
pub fn new(
masked_data: Secret<T, S>,
encrypted_data: Secret<Vec<u8>, EncryptionStrategy>,
) -> Self {
Self {
inner: masked_data,
encrypted: encrypted_data,
}
}
<file_sep path="hyperswitch/crates/common_utils/src/crypto.rs" role="context" start="498" end="498">
use masking::{ExposeInterface, Secret};
use crate::{
errors::{self, CustomResult},
pii::{self, EncryptionStrategy},
};
pub type OptionalEncryptableSecretString = Option<Encryptable<Secret<String>>>;
pub type OptionalEncryptableName = Option<Encryptable<Secret<String>>>;
pub type OptionalEncryptableEmail = Option<Encryptable<Secret<String, pii::EmailStrategy>>>;
pub type OptionalEncryptablePhone = Option<Encryptable<Secret<String>>>;
pub type OptionalEncryptableValue = Option<Encryptable<Secret<serde_json::Value>>>;
pub type OptionalSecretValue = Option<Secret<serde_json::Value>>;
pub type EncryptableName = Encryptable<Secret<String>>;
pub type EncryptableEmail = Encryptable<Secret<String, pii::EmailStrategy>>;
<file_sep path="hyperswitch/crates/common_utils/src/crypto.rs" role="context" start="519" end="521">
pub fn get_inner(&self) -> &T {
&self.inner
}
<file_sep path="hyperswitch/crates/common_utils/src/crypto.rs" role="context" start="513" end="515">
pub fn into_inner(self) -> T {
self.inner
}
<file_sep path="hyperswitch/crates/common_utils/src/crypto.rs" role="context" start="482" end="488">
pub fn generate_cryptographically_secure_random_bytes<const N: usize>() -> [u8; N] {
use rand::RngCore;
let mut bytes = [0; N];
rand::rngs::OsRng.fill_bytes(&mut bytes);
bytes
}
<file_sep path="hyperswitch/crates/common_utils/src/crypto.rs" role="context" start="473" end="477">
pub fn generate_cryptographically_secure_random_string(length: usize) -> String {
use rand::distributions::DistString;
rand::distributions::Alphanumeric.sample_string(&mut rand::rngs::OsRng, length)
}
<file_sep path="hyperswitch/crates/common_utils/src/crypto.rs" role="context" start="282" end="300">
fn encode_message(
&self,
secret: &[u8],
msg: &[u8],
) -> CustomResult<Vec<u8>, errors::CryptoError> {
let nonce_sequence =
NonceSequence::new().change_context(errors::CryptoError::EncodingFailed)?;
let current_nonce = nonce_sequence.current();
let key = UnboundKey::new(&aead::AES_256_GCM, secret)
.change_context(errors::CryptoError::EncodingFailed)?;
let mut key = SealingKey::new(key, nonce_sequence);
let mut in_out = msg.to_vec();
key.seal_in_place_append_tag(aead::Aad::empty(), &mut in_out)
.change_context(errors::CryptoError::EncodingFailed)?;
in_out.splice(0..0, current_nonce);
Ok(in_out)
}
<file_sep path="hyperswitch/crates/common_utils/src/crypto.rs" role="context" start="218" end="225">
fn sign_message(
&self,
secret: &[u8],
msg: &[u8],
) -> CustomResult<Vec<u8>, errors::CryptoError> {
let key = hmac::Key::new(hmac::HMAC_SHA512, secret);
Ok(hmac::sign(&key, msg).as_ref().to_vec())
}
<file_sep path="hyperswitch/crates/common_utils/src/pii.rs" role="context" start="151" end="151">
pub enum EncryptionStrategy {}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/common_utils/src/types.rs<|crate|> common_utils anchor=try_from kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/common_utils/src/types.rs" role="context" start="1323" end="1331">
fn try_from(src: String) -> Result<Self, Self::Error> {
if src.len() > 1024 {
Err(report!(ValidationError::InvalidValue {
message: "unified_message's length should not exceed 1024 characters".to_string()
}))
} else {
Ok(Self(src))
}
}
<file_sep path="hyperswitch/crates/common_utils/src/types.rs" role="context" start="1322" end="1322">
use error_stack::{report, ResultExt};
use thiserror::Error;
use crate::{
consts::{
self, MAX_DESCRIPTION_LENGTH, MAX_STATEMENT_DESCRIPTOR_LENGTH, PUBLISHABLE_KEY_LENGTH,
},
errors::{CustomResult, ParsingError, PercentageError, ValidationError},
fp_utils::when,
};
<file_sep path="hyperswitch/crates/common_utils/src/types.rs" role="context" start="1350" end="1353">
fn from_sql(bytes: DB::RawValue<'_>) -> deserialize::Result<Self> {
let val = String::from_sql(bytes)?;
Ok(Self::try_from(val)?)
}
<file_sep path="hyperswitch/crates/common_utils/src/types.rs" role="context" start="1341" end="1343">
fn build(row: Self::Row) -> deserialize::Result<Self> {
Ok(row)
}
<file_sep path="hyperswitch/crates/common_utils/src/types.rs" role="context" start="1309" end="1311">
fn to_sql<'b>(&'b self, out: &mut Output<'b, '_, DB>) -> diesel::serialize::Result {
self.0.to_sql(out)
}
<file_sep path="hyperswitch/crates/common_utils/src/types.rs" role="context" start="1298" end="1301">
fn from_sql(bytes: DB::RawValue<'_>) -> deserialize::Result<Self> {
let val = String::from_sql(bytes)?;
Ok(Self::try_from(val)?)
}
<file_sep path="hyperswitch/crates/common_utils/src/types.rs" role="context" start="768" end="787">
fn visit_str<E>(self, value: &str) -> Result<ClientSecret, E>
where
E: serde::de::Error,
{
let (payment_id, secret) = value.rsplit_once("_secret_").ok_or_else(|| {
E::invalid_value(
serde::de::Unexpected::Str(value),
&"a string with '_secret_'",
)
})?;
let payment_id =
id_type::GlobalPaymentId::try_from(Cow::Owned(payment_id.to_owned()))
.map_err(serde::de::Error::custom)?;
Ok(ClientSecret {
payment_id,
secret: masking::Secret::new(secret.to_owned()),
})
}
<file_sep path="hyperswitch/crates/common_utils/src/types.rs" role="context" start="1270" end="1270">
type Error = error_stack::Report<ValidationError>;
<file_sep path="hyperswitch/crates/common_utils/src/types.rs" role="context" start="228" end="228">
type Err = error_stack::Report<ParsingError>;
<file_sep path="hyperswitch/crates/common_utils/src/errors.rs" role="context" start="60" end="72">
pub enum ValidationError {
/// The provided input is missing a required field.
#[error("Missing required field: {field_name}")]
MissingRequiredField { field_name: String },
/// An incorrect value was provided for the field specified by `field_name`.
#[error("Incorrect value provided for field: {field_name}")]
IncorrectValueProvided { field_name: &'static str },
/// An invalid input was provided.
#[error("{message}")]
InvalidValue { message: String },
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/euclid/src/dssa/state_machine.rs<|crate|> euclid anchor=new kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/euclid/src/dssa/state_machine.rs" role="context" start="474" end="486">
pub fn new<O>(
program: &'a dir::DirProgram<O>,
connector_selection_data: &'a [Vec<(dir::DirValue, Metadata)>],
) -> Self {
let machine = ProgramStateMachine::new(program, connector_selection_data);
let context: types::ConjunctiveContext<'a> = Vec::new();
Self {
context,
machine,
init: false,
}
}
<file_sep path="hyperswitch/crates/euclid/src/dssa/state_machine.rs" role="context" start="473" end="473">
use super::types::EuclidAnalysable;
use crate::{dssa::types, frontend::dir, types::Metadata};
<file_sep path="hyperswitch/crates/euclid/src/dssa/state_machine.rs" role="context" start="507" end="518">
pub fn make_connector_selection_data<O: EuclidAnalysable>(
program: &dir::DirProgram<O>,
) -> Vec<Vec<(dir::DirValue, Metadata)>> {
program
.rules
.iter()
.map(|rule| {
rule.connector_selection
.get_dir_value_for_analysis(rule.name.clone())
})
.collect()
}
<file_sep path="hyperswitch/crates/euclid/src/dssa/state_machine.rs" role="context" start="488" end="504">
pub fn advance(&mut self) -> Result<Option<&types::ConjunctiveContext<'a>>, StateMachineError> {
if !self.init {
self.init = true;
self.machine.init(&mut self.context)?;
Ok(Some(&self.context))
} else if self.machine.is_finished() {
Ok(None)
} else {
self.machine.advance(&mut self.context)?;
if self.machine.is_finished() {
Ok(None)
} else {
Ok(Some(&self.context))
}
}
}
<file_sep path="hyperswitch/crates/euclid/src/dssa/state_machine.rs" role="context" start="445" end="464">
pub fn advance(
&mut self,
context: &mut types::ConjunctiveContext<'a>,
) -> Result<(), StateMachineError> {
if self
.current_rule_machine
.as_ref()
.map_or(true, |rsm| rsm.is_finished())
{
self.current_rule_machine = self.rule_machines.pop();
context.clear();
if let Some(rsm) = self.current_rule_machine.as_mut() {
rsm.init_next(context)?;
}
} else if let Some(rsm) = self.current_rule_machine.as_mut() {
rsm.advance(context)?;
}
Ok(())
}
<file_sep path="hyperswitch/crates/euclid/src/dssa/state_machine.rs" role="context" start="431" end="443">
pub fn init(
&mut self,
context: &mut types::ConjunctiveContext<'a>,
) -> Result<(), StateMachineError> {
if !self.is_init {
if let Some(rsm) = self.current_rule_machine.as_mut() {
rsm.init_next(context)?;
}
self.is_init = true;
}
Ok(())
}
<file_sep path="hyperswitch/crates/euclid/src/dssa/state_machine.rs" role="context" start="345" end="354">
pub fn new<O>(
rule: &'a dir::DirRule<O>,
connector_selection_data: &'a [(dir::DirValue, Metadata)],
) -> Self {
Self {
context: Vec::new(),
machine: RuleStateMachine::new(rule, connector_selection_data),
init: false,
}
}
<file_sep path="hyperswitch/crates/euclid/src/dssa/state_machine.rs" role="context" start="160" end="172">
fn new(stmt: &'a dir::DirIfStatement, ctx_start_idx: usize) -> Self {
let condition_machine = ConditionStateMachine::new(&stmt.condition, ctx_start_idx);
let nested: Vec<&'a dir::DirIfStatement> = match &stmt.nested {
None => Vec::new(),
Some(nested_stmts) => nested_stmts.iter().collect(),
};
Self {
condition_machine,
nested,
nested_idx: 0,
}
}
<file_sep path="hyperswitch/crates/euclid/src/dssa/state_machine.rs" role="context" start="396" end="400">
pub struct ProgramStateMachine<'a> {
rule_machines: Vec<RuleStateMachine<'a>>,
current_rule_machine: Option<RuleStateMachine<'a>>,
is_init: bool,
}
<file_sep path="hyperswitch/crates/euclid/src/frontend/dir.rs" role="context" start="483" end="546">
pub enum DirValue {
#[serde(rename = "payment_method")]
PaymentMethod(enums::PaymentMethod),
#[serde(rename = "card_bin")]
CardBin(types::StrValue),
#[serde(rename = "card_type")]
CardType(enums::CardType),
#[serde(rename = "card_network")]
CardNetwork(enums::CardNetwork),
#[serde(rename = "metadata")]
MetaData(types::MetadataValue),
#[serde(rename = "pay_later")]
PayLaterType(enums::PayLaterType),
#[serde(rename = "wallet")]
WalletType(enums::WalletType),
#[serde(rename = "acceptance_type")]
MandateAcceptanceType(euclid_enums::MandateAcceptanceType),
#[serde(rename = "mandate_type")]
MandateType(euclid_enums::MandateType),
#[serde(rename = "payment_type")]
PaymentType(euclid_enums::PaymentType),
#[serde(rename = "upi")]
UpiType(enums::UpiType),
#[serde(rename = "voucher")]
VoucherType(enums::VoucherType),
#[serde(rename = "bank_transfer")]
BankTransferType(enums::BankTransferType),
#[serde(rename = "bank_redirect")]
BankRedirectType(enums::BankRedirectType),
#[serde(rename = "bank_debit")]
BankDebitType(enums::BankDebitType),
#[serde(rename = "crypto")]
CryptoType(enums::CryptoType),
#[serde(rename = "reward")]
RewardType(enums::RewardType),
#[serde(rename = "gift_card")]
GiftCardType(enums::GiftCardType),
#[serde(rename = "amount")]
PaymentAmount(types::NumValue),
#[serde(rename = "currency")]
PaymentCurrency(enums::PaymentCurrency),
#[serde(rename = "authentication_type")]
AuthenticationType(enums::AuthenticationType),
#[serde(rename = "capture_method")]
CaptureMethod(enums::CaptureMethod),
#[serde(rename = "business_country", alias = "country")]
BusinessCountry(enums::Country),
#[serde(rename = "billing_country")]
BillingCountry(enums::Country),
#[serde(skip_deserializing, rename = "connector")]
Connector(Box<ast::ConnectorChoice>),
#[serde(rename = "business_label")]
BusinessLabel(types::StrValue),
#[serde(rename = "setup_future_usage")]
SetupFutureUsage(enums::SetupFutureUsage),
#[serde(rename = "card_redirect")]
CardRedirectType(enums::CardRedirectType),
#[serde(rename = "real_time_payment")]
RealTimePaymentType(enums::RealTimePaymentType),
#[serde(rename = "open_banking")]
OpenBankingType(enums::OpenBankingType),
#[serde(rename = "mobile_payment")]
MobilePaymentType(enums::MobilePaymentType),
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/common_utils/src/custom_serde.rs<|crate|> common_utils anchor=deserialize kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/common_utils/src/custom_serde.rs" role="context" start="269" end="277">
pub fn deserialize<'a, D>(deserializer: D) -> Result<PrimitiveDateTime, D::Error>
where
D: Deserializer<'a>,
{
iso8601::deserialize(deserializer).map(|offset_date_time| {
let utc_date_time = offset_date_time.to_offset(UtcOffset::UTC);
PrimitiveDateTime::new(utc_date_time.date(), utc_date_time.time())
})
}
<file_sep path="hyperswitch/crates/common_utils/src/custom_serde.rs" role="context" start="286" end="296">
fn test_leap_second_parse() {
#[derive(Serialize, Deserialize)]
struct Try {
#[serde(with = "crate::custom_serde::iso8601")]
f: time::PrimitiveDateTime,
}
let leap_second_date_time = json!({"f": "2023-12-31T23:59:60.000Z"});
let deser = serde_json::from_value::<Try>(leap_second_date_time);
assert!(deser.is_ok())
}
<file_sep path="hyperswitch/crates/common_utils/src/custom_serde.rs" role="context" start="255" end="266">
pub fn serialize<S>(date_time: &PrimitiveDateTime, serializer: S) -> Result<S::Ok, S::Error>
where
S: Serializer,
{
date_time
.assume_utc()
.format(&Iso8601::<FORMAT_CONFIG>)
.map_err(S::Error::custom)?
.replace('T', " ")
.replace('Z', "")
.serialize(serializer)
}
<file_sep path="hyperswitch/crates/common_utils/src/custom_serde.rs" role="context" start="222" end="229">
pub fn deserialize<'de, T, D>(deserializer: D) -> Result<T, D::Error>
where
T: DeserializeOwned,
D: Deserializer<'de>,
{
let j = String::deserialize(deserializer)?;
serde_json::from_str(&j).map_err(de::Error::custom)
}
<file_sep path="hyperswitch/crates/common_utils/src/custom_serde.rs" role="context" start="117" end="132">
pub fn deserialize<'a, D>(deserializer: D) -> Result<Option<PrimitiveDateTime>, D::Error>
where
D: Deserializer<'a>,
{
Option::deserialize(deserializer)?
.map(|time_string| {
let format =
format_description!("[year]-[month]-[day]T[hour]:[minute]:[second]");
PrimitiveDateTime::parse(time_string, format).map_err(|_| {
de::Error::custom(format!(
"Failed to parse PrimitiveDateTime from {time_string}"
))
})
})
.transpose()
}
<file_sep path="hyperswitch/crates/common_utils/src/custom_serde.rs" role="context" start="190" end="200">
pub fn deserialize<'a, D>(deserializer: D) -> Result<Option<PrimitiveDateTime>, D::Error>
where
D: Deserializer<'a>,
{
timestamp::option::deserialize(deserializer).map(|option_offset_date_time| {
option_offset_date_time.map(|offset_date_time| {
let utc_date_time = offset_date_time.to_offset(UtcOffset::UTC);
PrimitiveDateTime::new(utc_date_time.date(), utc_date_time.time())
})
})
}
<file_sep path="hyperswitch/crates/common_utils/src/types.rs" role="context" start="1270" end="1270">
type Error = error_stack::Report<ValidationError>;
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/hyperswitch_constraint_graph/src/builder.rs<|crate|> hyperswitch_constraint_graph anchor=new kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/hyperswitch_constraint_graph/src/builder.rs" role="context" start="54" end="65">
pub fn new() -> Self {
Self {
domain: DenseMap::new(),
nodes: DenseMap::new(),
edges: DenseMap::new(),
domain_identifier_map: FxHashMap::default(),
value_map: FxHashMap::default(),
edges_map: FxHashMap::default(),
node_info: DenseMap::new(),
node_metadata: DenseMap::new(),
}
}
<file_sep path="hyperswitch/crates/hyperswitch_constraint_graph/src/builder.rs" role="context" start="53" end="53">
use rustc_hash::{FxHashMap, FxHashSet};
use crate::{
dense_map::DenseMap,
error::GraphError,
graph::ConstraintGraph,
types::{
DomainId, DomainIdentifier, DomainInfo, Edge, EdgeId, Metadata, Node, NodeId, NodeType,
NodeValue, Relation, Strength, ValueNode,
},
};
<file_sep path="hyperswitch/crates/hyperswitch_constraint_graph/src/builder.rs" role="context" start="79" end="87">
fn retrieve_domain_from_identifier(
&self,
domain_ident: DomainIdentifier,
) -> Result<DomainId, GraphError<V>> {
self.domain_identifier_map
.get(&domain_ident)
.copied()
.ok_or(GraphError::DomainNotFound)
}
<file_sep path="hyperswitch/crates/hyperswitch_constraint_graph/src/builder.rs" role="context" start="67" end="77">
pub fn build(self) -> ConstraintGraph<V> {
ConstraintGraph {
domain: self.domain,
domain_identifier_map: self.domain_identifier_map,
nodes: self.nodes,
edges: self.edges,
value_map: self.value_map,
node_info: self.node_info,
node_metadata: self.node_metadata,
}
}
<file_sep path="hyperswitch/crates/hyperswitch_constraint_graph/src/builder.rs" role="context" start="33" end="35">
fn from(value: DomainId) -> Self {
Self::DomainId(value)
}
<file_sep path="hyperswitch/crates/hyperswitch_constraint_graph/src/builder.rs" role="context" start="27" end="29">
fn from(value: DomainIdentifier) -> Self {
Self::DomainIdentifier(value)
}
<file_sep path="hyperswitch/crates/hyperswitch_constraint_graph/src/builder.rs" role="context" start="89" end="111">
pub fn make_domain(
&mut self,
domain_identifier: String,
domain_description: &str,
) -> Result<DomainId, GraphError<V>> {
let domain_identifier = DomainIdentifier::new(domain_identifier);
Ok(self
.domain_identifier_map
.clone()
.get(&domain_identifier)
.map_or_else(
|| {
let domain_id = self.domain.push(DomainInfo {
domain_identifier: domain_identifier.clone(),
domain_description: domain_description.to_string(),
});
self.domain_identifier_map
.insert(domain_identifier, domain_id);
domain_id
},
|domain_id| *domain_id,
))
}
<file_sep path="hyperswitch/crates/hyperswitch_constraint_graph/src/dense_map.rs" role="context" start="26" end="29">
pub struct DenseMap<K, V> {
data: Vec<V>,
_marker: PhantomData<K>,
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch-card-vault/src/crypto/hash_manager/managers/sha.rs<|crate|> src anchor=new kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=1<|meta_end|>
<file_sep path="hyperswitch-card-vault/src/crypto/hash_manager/managers/sha.rs" role="context" start="53" end="58">
pub fn new(key: masking::Secret<Vec<u8>>) -> Self {
#[allow(clippy::let_unit_value)]
let _ = <Self as AssertGt0>::VALID;
Self(key)
}
<file_sep path="hyperswitch-card-vault/src/crypto/hash_manager/managers/sha.rs" role="context" start="52" end="52">
use masking::{PeekInterface, Secret};
<file_sep path="hyperswitch-card-vault/src/crypto/hash_manager/managers/sha.rs" role="context" start="70" end="77">
fn encode(&self, input: Secret<Vec<u8>>) -> Self::ReturnType<Secret<Vec<u8>>> {
let key = hmac::Key::new(ring::hmac::HMAC_SHA512, self.0.peek());
let first = hmac::sign(&key, input.peek());
let signature = (0..=(N - 1)).fold(first, |input, _| hmac::sign(&key, input.as_ref()));
Ok(signature.as_ref().to_vec().into())
}
<file_sep path="hyperswitch-card-vault/src/crypto/hash_manager/managers/sha.rs" role="context" start="62" end="64">
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(f, "HmacSha512<{}>", N)
}
<file_sep path="hyperswitch-card-vault/src/crypto/hash_manager/managers/sha.rs" role="context" start="14" end="17">
fn encode(&self, input: Vec<u8>) -> Self::ReturnType<Vec<u8>> {
let digest = ring::digest::digest(&ring::digest::SHA512, &input);
Ok(digest.as_ref().to_vec())
}
<file_sep path="hyperswitch-card-vault/src/crypto/hash_manager/managers/sha.rs" role="context" start="101" end="112">
fn test_input_data_equal() {
let data1 = "Hello, World!";
let data2 = "Hello, World!";
let key = "key";
let algo = HmacSha512::<1>::new(key.as_bytes().to_vec().into());
let hash1 = algo.encode(data1.as_bytes().to_vec().into()).unwrap();
let hash2 = algo.encode(data2.as_bytes().to_vec().into()).unwrap();
assert_eq!(hash1, hash2);
}
<file_sep path="hyperswitch-card-vault/src/crypto/hash_manager/managers/sha.rs" role="context" start="159" end="170">
fn test_n_equal() {
let data = "Hello, World!";
let key = "key";
let algo1 = HmacSha512::<10>::new(key.as_bytes().to_vec().into());
let algo2 = HmacSha512::<10>::new(key.as_bytes().to_vec().into());
let hash1 = algo1.encode(data.as_bytes().to_vec().into()).unwrap();
let hash2 = algo2.encode(data.as_bytes().to_vec().into()).unwrap();
assert_eq!(hash1, hash2);
}
<file_sep path="hyperswitch-card-vault/src/crypto/hash_manager/managers/sha.rs" role="context" start="80" end="82">
trait AssertGt0 {
const VALID: ();
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/common_utils/src/id_type.rs<|crate|> common_utils anchor=from kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/common_utils/src/id_type.rs" role="context" start="143" end="162">
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))
})?;
let alphanumeric_id = match AlphaNumericId::from(trimmed_input_string.into()) {
Ok(valid_alphanumeric_id) => valid_alphanumeric_id,
Err(error) => Err(LengthIdError::AlphanumericIdError(error))?,
};
Ok(Self(alphanumeric_id))
}
<file_sep path="hyperswitch/crates/common_utils/src/id_type.rs" role="context" start="142" end="142">
use std::{borrow::Cow, fmt::Debug};
pub use self::global_id::{
customer::GlobalCustomerId,
payment::{GlobalAttemptId, GlobalPaymentId},
payment_methods::{GlobalPaymentMethodId, GlobalPaymentMethodSessionId},
refunds::GlobalRefundId,
CellId,
};
pub use self::{
api_key::ApiKeyId,
client_secret::ClientSecretId,
customer::CustomerId,
merchant::MerchantId,
merchant_connector_account::MerchantConnectorAccountId,
organization::OrganizationId,
payment::{PaymentId, PaymentReferenceId},
profile::ProfileId,
refunds::RefundReferenceId,
relay::RelayId,
routing::RoutingId,
tenant::TenantId,
};
use crate::{fp_utils::when, generate_id_with_default_len};
<file_sep path="hyperswitch/crates/common_utils/src/id_type.rs" role="context" start="170" end="172">
pub(crate) fn new_unchecked(alphanumeric_id: AlphaNumericId) -> Self {
Self(alphanumeric_id)
}
<file_sep path="hyperswitch/crates/common_utils/src/id_type.rs" role="context" start="165" end="167">
pub fn new(prefix: &str) -> Self {
Self(AlphaNumericId::new(prefix))
}
<file_sep path="hyperswitch/crates/common_utils/src/id_type.rs" role="context" start="136" end="138">
fn from(alphanumeric_id_error: AlphaNumericIdError) -> Self {
Self::AlphanumericIdError(alphanumeric_id_error)
}
<file_sep path="hyperswitch/crates/common_utils/src/id_type.rs" role="context" start="109" end="111">
pub(crate) fn new(prefix: &str) -> Self {
Self(generate_id_with_default_len(prefix))
}
<file_sep path="hyperswitch/crates/common_utils/src/id_type.rs" role="context" start="251" end="257">
fn test_id_deserialize_underscore() {
let parsed_alphanumeric_id =
serde_json::from_str::<AlphaNumericId>(VALID_UNDERSCORE_ID_JSON);
let alphanumeric_id = AlphaNumericId::from(EXPECTED_VALID_UNDERSCORE_ID.into()).unwrap();
assert_eq!(parsed_alphanumeric_id.unwrap(), alphanumeric_id);
}
<file_sep path="hyperswitch/crates/common_utils/src/id_type.rs" role="context" start="121" end="133">
pub(crate) enum LengthIdError {
#[error("the maximum allowed length for this field is {0}")]
/// Maximum length of string violated
MaxLengthViolated(u8),
#[error("the minimum required length for this field is {0}")]
/// Minimum length of string violated
MinLengthViolated(u8),
#[error("{0}")]
/// Input contains invalid characters
AlphanumericIdError(AlphaNumericIdError),
}
<file_sep path="hyperswitch/crates/common_utils/src/id_type.rs" role="context" start="71" end="71">
pub(crate) struct AlphaNumericId(String);
<file_sep path="hyperswitch/crates/common_utils/src/types.rs" role="context" start="228" end="228">
type Err = error_stack::Report<ParsingError>;
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/hyperswitch_constraint_graph/src/dense_map.rs<|crate|> hyperswitch_constraint_graph anchor=new kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=1<|meta_end|>
<file_sep path="hyperswitch/crates/hyperswitch_constraint_graph/src/dense_map.rs" role="context" start="198" end="203">
fn new(iter: vec::IntoIter<V>) -> Self {
Self {
inner: iter.enumerate(),
_marker: PhantomData,
}
}
<file_sep path="hyperswitch/crates/hyperswitch_constraint_graph/src/dense_map.rs" role="context" start="197" end="197">
use std::{fmt, iter, marker::PhantomData, ops, slice, vec};
<file_sep path="hyperswitch/crates/hyperswitch_constraint_graph/src/dense_map.rs" role="context" start="224" end="226">
fn into_iter(self) -> Self::IntoIter {
IntoIter::new(self.data.into_iter())
}
<file_sep path="hyperswitch/crates/hyperswitch_constraint_graph/src/dense_map.rs" role="context" start="212" end="214">
fn next(&mut self) -> Option<Self::Item> {
self.inner.next().map(|(id, val)| (K::with_id(id), val))
}
<file_sep path="hyperswitch/crates/hyperswitch_constraint_graph/src/dense_map.rs" role="context" start="187" end="189">
fn next(&mut self) -> Option<Self::Item> {
self.inner.next().map(|(id, val)| (K::with_id(id), val))
}
<file_sep path="hyperswitch/crates/hyperswitch_constraint_graph/src/dense_map.rs" role="context" start="173" end="178">
fn new(iter: slice::IterMut<'a, V>) -> Self {
Self {
inner: iter.enumerate(),
_marker: PhantomData,
}
}
<file_sep path="hyperswitch/crates/hyperswitch_constraint_graph/src/dense_map.rs" role="context" start="77" end="79">
pub fn into_keys(self) -> Keys<K> {
Keys::new(0..self.data.len())
}
<file_sep path="hyperswitch/crates/hyperswitch_constraint_graph/src/dense_map.rs" role="context" start="41" end="43">
fn default() -> Self {
Self::new()
}
<file_sep path="hyperswitch/crates/hyperswitch_constraint_graph/src/dense_map.rs" role="context" start="192" end="195">
pub struct IntoIter<K, V> {
inner: iter::Enumerate<vec::IntoIter<V>>,
_marker: PhantomData<K>,
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/euclid_macros/src/inner/knowledge.rs<|crate|> euclid_macros anchor=new kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=1<|meta_end|>
<file_sep path="hyperswitch/crates/euclid_macros/src/inner/knowledge.rs" role="context" start="360" end="369">
fn new() -> Self {
Self {
next_idx: 1,
next_node_idx: 1,
idx2atom: FxHashMap::default(),
atom2idx: FxHashMap::default(),
edges: FxHashMap::default(),
compiled_atoms: FxHashMap::default(),
}
}
<file_sep path="hyperswitch/crates/euclid_macros/src/inner/knowledge.rs" role="context" start="359" end="359">
use rustc_hash::{FxHashMap, FxHashSet};
<file_sep path="hyperswitch/crates/euclid_macros/src/inner/knowledge.rs" role="context" start="385" end="394">
fn register_edge(&mut self, from: usize, to: usize) -> Result<(), String> {
let node_children = self.edges.entry(from).or_default();
if node_children.contains(&to) {
Err("Duplicate edge detected".to_string())
} else {
node_children.insert(to);
self.edges.entry(to).or_default();
Ok(())
}
}
<file_sep path="hyperswitch/crates/euclid_macros/src/inner/knowledge.rs" role="context" start="371" end="383">
fn register_node(&mut self, atom: Rc<Atom>) -> usize {
if let Some(idx) = self.atom2idx.get(&atom) {
*idx
} else {
let this_idx = self.next_idx;
self.next_idx += 1;
self.idx2atom.insert(this_idx, Rc::clone(&atom));
self.atom2idx.insert(atom, this_idx);
this_idx
}
}
<file_sep path="hyperswitch/crates/euclid_macros/src/inner/knowledge.rs" role="context" start="339" end="347">
fn parse(input: syn::parse::ParseStream<'_>) -> syn::Result<Self> {
let mut rules: Vec<Rc<Rule>> = Vec::new();
while !input.is_empty() {
rules.push(Rc::new(input.parse::<Rule>()?));
}
Ok(Self { rules })
}
<file_sep path="hyperswitch/crates/euclid_macros/src/inner/knowledge.rs" role="context" start="326" end="331">
fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
match self {
Self::Crate => write!(f, "crate"),
Self::Extern => write!(f, "euclid"),
}
}
<file_sep path="hyperswitch/crates/euclid_macros/src/inner/knowledge.rs" role="context" start="450" end="485">
fn detect_graph_cycles(&self) -> Result<(), String> {
let start_nodes = self.edges.keys().copied().collect::<Vec<usize>>();
let mut total_visited = FxHashSet::<usize>::default();
for node_id in start_nodes.iter().copied() {
let mut explored = FxHashSet::<usize>::default();
let mut order = Vec::<usize>::new();
match self.cycle_dfs(node_id, &mut explored, &mut total_visited, &mut order)? {
None => {}
Some(order) => {
let mut display_strings = Vec::<String>::with_capacity(order.len() + 1);
for cycle_node_id in order {
let node = self.idx2atom.get(&cycle_node_id).ok_or_else(|| {
"Failed to find node during cycle display creation".to_string()
})?;
display_strings.push(node.to_string());
}
let first = display_strings
.first()
.cloned()
.ok_or("Unable to fill cycle display array")?;
display_strings.push(first);
return Err(format!("Found cycle: {}", display_strings.join(" -> ")));
}
}
}
Ok(())
}
<file_sep path="hyperswitch/crates/euclid_macros/src/inner/knowledge.rs" role="context" start="555" end="594">
fn compile_atom_type(
&mut self,
atom_type: &AtomType,
tokens: &mut TokenStream,
) -> Result<(proc_macro2::Ident, Relation), String> {
match atom_type {
AtomType::Value { relation, atom } => {
let node_ident = self.compile_atom(atom, tokens)?;
Ok((node_ident, relation.clone()))
}
AtomType::InAggregator {
key,
values,
relation,
} => {
let key_ident = format_ident!("{key}");
let mut values_tokens: Vec<TokenStream> = Vec::new();
for value in values {
let value_ident = format_ident!("{value}");
values_tokens.push(quote! { DirValue::#key_ident(#key_ident::#value_ident) });
}
let (node_ident, _) = self.next_node_ident();
let node_code = quote! {
let #node_ident = graph.make_in_aggregator(
Vec::from_iter([#(#values_tokens),*]),
None,
None::<()>,
).expect("Failed to make In aggregator");
};
tokens.extend(node_code);
Ok((node_ident, relation.clone()))
}
}
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/hyperswitch_domain_models/src/type_encryption.rs<|crate|> hyperswitch_domain_models anchor=decrypt kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=1<|meta_end|>
<file_sep path="hyperswitch/crates/hyperswitch_domain_models/src/type_encryption.rs" role="context" start="1212" end="1227">
async fn decrypt<T: Clone, S: masking::Strategy<T>>(
state: &KeyManagerState,
inner: Encryption,
identifier: Identifier,
key: &[u8],
) -> CustomResult<crypto::Encryptable<Secret<T, S>>, CryptoError>
where
crypto::Encryptable<Secret<T, S>>: TypeEncryption<T, crypto::GcmAes256, S>,
{
record_operation_time(
crypto::Encryptable::decrypt_via_api(state, inner, identifier, key, crypto::GcmAes256),
&metrics::DECRYPTION_TIME,
&[],
)
.await
}
<file_sep path="hyperswitch/crates/hyperswitch_domain_models/src/type_encryption.rs" role="context" start="1211" end="1211">
use common_utils::{
crypto,
encryption::Encryption,
errors::{self, CustomResult},
ext_traits::AsyncExt,
metrics::utils::record_operation_time,
types::keymanager::{Identifier, KeyManagerState},
};
use encrypt::TypeEncryption;
use masking::Secret;
pub type OptionalEncryptableJsonType<T> = Option<crypto::Encryptable<Secret<EncryptedJsonType<T>>>>;
use errors::CryptoError;
<file_sep path="hyperswitch/crates/hyperswitch_domain_models/src/type_encryption.rs" role="context" start="1279" end="1316">
pub async fn crypto_operation<T: Clone + Send, S: masking::Strategy<T>>(
state: &KeyManagerState,
table_name: &str,
operation: CryptoOperation<T, S>,
identifier: Identifier,
key: &[u8],
) -> CustomResult<CryptoOutput<T, S>, CryptoError>
where
Secret<T, S>: Send,
crypto::Encryptable<Secret<T, S>>: TypeEncryption<T, crypto::GcmAes256, S>,
{
match operation {
CryptoOperation::Encrypt(data) => {
let data = encrypt(state, data, identifier, key).await?;
Ok(CryptoOutput::Operation(data))
}
CryptoOperation::EncryptOptional(data) => {
let data = encrypt_optional(state, data, identifier, key).await?;
Ok(CryptoOutput::OptionalOperation(data))
}
CryptoOperation::Decrypt(data) => {
let data = decrypt(state, data, identifier, key).await?;
Ok(CryptoOutput::Operation(data))
}
CryptoOperation::DecryptOptional(data) => {
let data = decrypt_optional(state, data, identifier, key).await?;
Ok(CryptoOutput::OptionalOperation(data))
}
CryptoOperation::BatchEncrypt(data) => {
let data = batch_encrypt(state, data, identifier, key).await?;
Ok(CryptoOutput::BatchOperation(data))
}
CryptoOperation::BatchDecrypt(data) => {
let data = batch_decrypt(state, data, identifier, key).await?;
Ok(CryptoOutput::BatchOperation(data))
}
}
}
<file_sep path="hyperswitch/crates/hyperswitch_domain_models/src/type_encryption.rs" role="context" start="1230" end="1256">
async fn batch_decrypt<E: Clone, S>(
state: &KeyManagerState,
inner: FxHashMap<String, Encryption>,
identifier: Identifier,
key: &[u8],
) -> CustomResult<FxHashMap<String, crypto::Encryptable<Secret<E, S>>>, CryptoError>
where
S: masking::Strategy<E>,
crypto::Encryptable<Secret<E, S>>: TypeEncryption<E, crypto::GcmAes256, S>,
{
if !inner.is_empty() {
record_operation_time(
crypto::Encryptable::batch_decrypt_via_api(
state,
inner,
identifier,
key,
crypto::GcmAes256,
),
&metrics::ENCRYPTION_TIME,
&[],
)
.await
} else {
Ok(FxHashMap::default())
}
}
<file_sep path="hyperswitch/crates/hyperswitch_domain_models/src/type_encryption.rs" role="context" start="1196" end="1209">
async fn decrypt_optional<T: Clone, S: masking::Strategy<T>>(
state: &KeyManagerState,
inner: Option<Encryption>,
identifier: Identifier,
key: &[u8],
) -> CustomResult<Option<crypto::Encryptable<Secret<T, S>>>, CryptoError>
where
crypto::Encryptable<Secret<T, S>>: TypeEncryption<T, crypto::GcmAes256, S>,
{
inner
.async_map(|item| decrypt(state, item, identifier, key))
.await
.transpose()
}
<file_sep path="hyperswitch/crates/hyperswitch_domain_models/src/type_encryption.rs" role="context" start="1178" end="1193">
async fn encrypt_optional<E: Clone, S>(
state: &KeyManagerState,
inner: Option<Secret<E, S>>,
identifier: Identifier,
key: &[u8],
) -> CustomResult<Option<crypto::Encryptable<Secret<E, S>>>, CryptoError>
where
Secret<E, S>: Send,
S: masking::Strategy<E>,
crypto::Encryptable<Secret<E, S>>: TypeEncryption<E, crypto::GcmAes256, S>,
{
inner
.async_map(|f| encrypt(state, f, identifier, key))
.await
.transpose()
}
<file_sep path="hyperswitch/crates/hyperswitch_domain_models/src/type_encryption.rs" role="context" start="666" end="676">
async fn decrypt(
encrypted_data: Encryption,
key: &[u8],
crypt_algo: V,
) -> CustomResult<Self, errors::CryptoError> {
let result: crypto::Encryptable<Secret<Vec<u8>>> =
TypeEncryption::decrypt(encrypted_data, key, crypt_algo).await?;
result
.deserialize_inner_value(EncryptedJsonType::deserialize_json_bytes)
.change_context(errors::CryptoError::DecodingFailed)
}
<file_sep path="hyperswitch/crates/hyperswitch_domain_models/src/type_encryption.rs" role="context" start="393" end="432">
async fn decrypt_via_api(
state: &KeyManagerState,
encrypted_data: Encryption,
identifier: Identifier,
key: &[u8],
crypt_algo: V,
) -> CustomResult<Self, errors::CryptoError> {
// If encryption service is not enabled, fall back to application encryption or else call encryption service
if !is_encryption_service_enabled(state) {
Self::decrypt(encrypted_data, key, crypt_algo).await
} else {
let result: Result<
DecryptDataResponse,
error_stack::Report<errors::KeyManagerClientError>,
> = call_encryption_service(
state,
Method::POST,
"data/decrypt",
TransientDecryptDataRequest::from((encrypted_data.clone(), identifier)),
)
.await;
let decrypted = match result {
Ok(decrypted_data) => {
ForeignTryFrom::foreign_try_from((encrypted_data.clone(), decrypted_data))
}
Err(err) => {
logger::error!("Decryption error {:?}", err);
Err(err.change_context(errors::CryptoError::EncodingFailed))
}
};
match decrypted {
Ok(de) => Ok(de),
Err(_) => {
metrics::DECRYPTION_API_FAILURES.add(1, &[]);
logger::info!("Fall back to Application Decryption");
Self::decrypt(encrypted_data, key, crypt_algo).await
}
}
}
}
<file_sep path="hyperswitch/crates/hyperswitch_domain_models/src/type_encryption.rs" role="context" start="864" end="903">
async fn decrypt_via_api(
state: &KeyManagerState,
encrypted_data: Encryption,
identifier: Identifier,
key: &[u8],
crypt_algo: V,
) -> CustomResult<Self, errors::CryptoError> {
// If encryption service is not enabled, fall back to application encryption or else call encryption service
if !is_encryption_service_enabled(state) {
Self::decrypt(encrypted_data, key, crypt_algo).await
} else {
let result: Result<
DecryptDataResponse,
error_stack::Report<errors::KeyManagerClientError>,
> = call_encryption_service(
state,
Method::POST,
"data/decrypt",
TransientDecryptDataRequest::from((encrypted_data.clone(), identifier)),
)
.await;
let decrypted = match result {
Ok(decrypted_data) => {
ForeignTryFrom::foreign_try_from((encrypted_data.clone(), decrypted_data))
}
Err(err) => {
logger::error!("Decryption error {:?}", err);
Err(err.change_context(errors::CryptoError::DecodingFailed))
}
};
match decrypted {
Ok(de) => Ok(de),
Err(_) => {
metrics::DECRYPTION_API_FAILURES.add(1, &[]);
logger::info!("Fall back to Application Decryption");
Self::decrypt(encrypted_data, key, crypt_algo).await
}
}
}
}
<file_sep path="hyperswitch/crates/hyperswitch_domain_models/src/type_encryption.rs" role="context" start="39" end="100">
pub trait TypeEncryption<
T,
V: crypto::EncodeMessage + crypto::DecodeMessage,
S: masking::Strategy<T>,
>: Sized
{
async fn encrypt_via_api(
state: &KeyManagerState,
masked_data: Secret<T, S>,
identifier: Identifier,
key: &[u8],
crypt_algo: V,
) -> CustomResult<Self, errors::CryptoError>;
async fn decrypt_via_api(
state: &KeyManagerState,
encrypted_data: Encryption,
identifier: Identifier,
key: &[u8],
crypt_algo: V,
) -> CustomResult<Self, errors::CryptoError>;
async fn encrypt(
masked_data: Secret<T, S>,
key: &[u8],
crypt_algo: V,
) -> CustomResult<Self, errors::CryptoError>;
async fn decrypt(
encrypted_data: Encryption,
key: &[u8],
crypt_algo: V,
) -> CustomResult<Self, errors::CryptoError>;
async fn batch_encrypt_via_api(
state: &KeyManagerState,
masked_data: FxHashMap<String, Secret<T, S>>,
identifier: Identifier,
key: &[u8],
crypt_algo: V,
) -> CustomResult<FxHashMap<String, Self>, errors::CryptoError>;
async fn batch_decrypt_via_api(
state: &KeyManagerState,
encrypted_data: FxHashMap<String, Encryption>,
identifier: Identifier,
key: &[u8],
crypt_algo: V,
) -> CustomResult<FxHashMap<String, Self>, errors::CryptoError>;
async fn batch_encrypt(
masked_data: FxHashMap<String, Secret<T, S>>,
key: &[u8],
crypt_algo: V,
) -> CustomResult<FxHashMap<String, Self>, errors::CryptoError>;
async fn batch_decrypt(
encrypted_data: FxHashMap<String, Encryption>,
key: &[u8],
crypt_algo: V,
) -> CustomResult<FxHashMap<String, Self>, errors::CryptoError>;
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/common_utils/src/id_type/global_id.rs<|crate|> common_utils anchor=from_str kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/common_utils/src/id_type/global_id.rs" role="context" start="72" end="77">
fn from_str(cell_id_string: impl AsRef<str>) -> Result<Self, CellIdError> {
let trimmed_input_string = cell_id_string.as_ref().trim().to_string();
let alphanumeric_id = AlphaNumericId::from(trimmed_input_string.into())?;
let length_id = LengthId::from_alphanumeric_id(alphanumeric_id)?;
Ok(Self(length_id))
}
<file_sep path="hyperswitch/crates/common_utils/src/id_type/global_id.rs" role="context" start="71" end="71">
use crate::{
consts::{CELL_IDENTIFIER_LENGTH, MAX_GLOBAL_ID_LENGTH, MIN_GLOBAL_ID_LENGTH},
errors, generate_time_ordered_id,
id_type::{AlphaNumericId, AlphaNumericIdError, LengthId, LengthIdError},
};
<file_sep path="hyperswitch/crates/common_utils/src/id_type/global_id.rs" role="context" start="91" end="93">
fn get_string_repr(&self) -> &str {
&self.0 .0 .0
}
<file_sep path="hyperswitch/crates/common_utils/src/id_type/global_id.rs" role="context" start="80" end="88">
pub fn from_string(
input_string: impl AsRef<str>,
) -> error_stack::Result<Self, errors::ValidationError> {
Self::from_str(input_string).change_context(
errors::ValidationError::IncorrectValueProvided {
field_name: "cell_id",
},
)
}
<file_sep path="hyperswitch/crates/common_utils/src/id_type/global_id.rs" role="context" start="65" end="67">
fn from(error: AlphaNumericIdError) -> Self {
Self::InvalidCellIdFormat(error)
}
<file_sep path="hyperswitch/crates/common_utils/src/id_type/global_id.rs" role="context" start="59" end="61">
fn from(error: LengthIdError) -> Self {
Self::InvalidCellLength(error)
}
<file_sep path="hyperswitch/crates/common_utils/src/id_type/global_id.rs" role="context" start="202" end="213">
fn test_global_id_generate() {
let cell_id_string = "12345";
let entity = GlobalEntity::Customer;
let cell_id = CellId::from_str(cell_id_string).unwrap();
let global_id = GlobalId::generate(&cell_id, entity);
// Generate a regex for globalid
// Eg - 12abc_cus_abcdefghijklmnopqrstuvwxyz1234567890
let regex = regex::Regex::new(r"[a-z0-9]{5}_cus_[a-z0-9]{32}").unwrap();
assert!(regex.is_match(&global_id.0 .0 .0));
}
<file_sep path="hyperswitch/crates/common_utils/src/id_type/global_id.rs" role="context" start="195" end="199">
fn test_cell_id_from_str() {
let cell_id_string = "12345";
let cell_id = CellId::from_str(cell_id_string).unwrap();
assert_eq!(cell_id.get_string_repr(), cell_id_string);
}
<file_sep path="hyperswitch/crates/common_utils/src/id_type/global_id.rs" role="context" start="50" end="56">
pub enum CellIdError {
#[error("cell id error: {0}")]
InvalidCellLength(LengthIdError),
#[error("{0}")]
InvalidCellIdFormat(AlphaNumericIdError),
}
<file_sep path="hyperswitch/crates/common_utils/src/id_type.rs" role="context" start="117" end="117">
pub(crate) struct LengthId<const MAX_LENGTH: u8, const MIN_LENGTH: u8>(AlphaNumericId);
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/external_services/src/aws_kms/core.rs<|crate|> external_services anchor=new kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/external_services/src/aws_kms/core.rs" role="context" start="34" end="42">
pub async fn new(config: &AwsKmsConfig) -> Self {
let region_provider = RegionProviderChain::first_try(Region::new(config.region.clone()));
let sdk_config = aws_config::from_env().region(region_provider).load().await;
Self {
inner_client: Client::new(&sdk_config),
key_id: config.key_id.clone(),
}
}
<file_sep path="hyperswitch/crates/external_services/src/aws_kms/core.rs" role="context" start="33" end="33">
use aws_config::meta::region::RegionProviderChain;
use aws_sdk_kms::{config::Region, primitives::Blob, Client};
<file_sep path="hyperswitch/crates/external_services/src/aws_kms/core.rs" role="context" start="87" end="114">
pub async fn encrypt(&self, data: impl AsRef<[u8]>) -> CustomResult<String, AwsKmsError> {
let start = Instant::now();
let plaintext_blob = Blob::new(data.as_ref());
let encrypted_output = self
.inner_client
.encrypt()
.key_id(&self.key_id)
.plaintext(plaintext_blob)
.send()
.await
.inspect_err(|error| {
// Logging using `Debug` representation of the error as the `Display`
// representation does not hold sufficient information.
logger::error!(aws_kms_sdk_error=?error, "Failed to AWS KMS encrypt data");
metrics::AWS_KMS_ENCRYPTION_FAILURES.add(1, &[]);
})
.change_context(AwsKmsError::EncryptionFailed)?;
let output = encrypted_output
.ciphertext_blob
.ok_or(AwsKmsError::MissingCiphertextEncryptionOutput)
.map(|blob| consts::BASE64_ENGINE.encode(blob.into_inner()))?;
let time_taken = start.elapsed();
metrics::AWS_KMS_ENCRYPT_TIME.record(time_taken.as_secs_f64(), &[]);
Ok(output)
}
<file_sep path="hyperswitch/crates/external_services/src/aws_kms/core.rs" role="context" start="48" end="81">
pub async fn decrypt(&self, data: impl AsRef<[u8]>) -> CustomResult<String, AwsKmsError> {
let start = Instant::now();
let data = consts::BASE64_ENGINE
.decode(data)
.change_context(AwsKmsError::Base64DecodingFailed)?;
let ciphertext_blob = Blob::new(data);
let decrypt_output = self
.inner_client
.decrypt()
.key_id(&self.key_id)
.ciphertext_blob(ciphertext_blob)
.send()
.await
.inspect_err(|error| {
// Logging using `Debug` representation of the error as the `Display`
// representation does not hold sufficient information.
logger::error!(aws_kms_sdk_error=?error, "Failed to AWS KMS decrypt data");
metrics::AWS_KMS_DECRYPTION_FAILURES.add(1, &[]);
})
.change_context(AwsKmsError::DecryptionFailed)?;
let output = decrypt_output
.plaintext
.ok_or(report!(AwsKmsError::MissingPlaintextDecryptionOutput))
.and_then(|blob| {
String::from_utf8(blob.into_inner()).change_context(AwsKmsError::Utf8DecodingFailed)
})?;
let time_taken = start.elapsed();
metrics::AWS_KMS_DECRYPT_TIME.record(time_taken.as_secs_f64(), &[]);
Ok(output)
}
<file_sep path="hyperswitch/crates/external_services/src/aws_kms/core.rs" role="context" start="193" end="212">
async fn check_aws_kms_decrypt() {
std::env::set_var("AWS_SECRET_ACCESS_KEY", "YOUR SECRET ACCESS KEY");
std::env::set_var("AWS_ACCESS_KEY_ID", "YOUR AWS ACCESS KEY ID");
use super::*;
let config = AwsKmsConfig {
key_id: "YOUR AWS KMS KEY ID".to_string(),
region: "AWS REGION".to_string(),
};
// Should decrypt to hello
let data = "AWS KMS ENCRYPTED CIPHER".to_string();
let binding = data.as_bytes();
let kms_encrypted_fingerprint = AwsKmsClient::new(&config)
.await
.decrypt(binding)
.await
.expect("aws kms decryption failed");
println!("{}", kms_encrypted_fingerprint);
}
<file_sep path="hyperswitch/crates/external_services/src/aws_kms/core.rs" role="context" start="17" end="23">
pub struct AwsKmsConfig {
/// The AWS key identifier of the KMS key used to encrypt or decrypt data.
pub key_id: String,
/// The AWS region to send KMS requests to.
pub region: String,
}
<file_sep path="hyperswitch/crates/external_services/src/grpc_client.rs" role="context" start="29" end="29">
pub type Client = hyper_util::client::legacy::Client<HttpConnector, UnsyncBoxBody<Bytes, Status>>;
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/common_utils/src/pii.rs<|crate|> common_utils anchor=fmt kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=1<|meta_end|>
<file_sep path="hyperswitch/crates/common_utils/src/pii.rs" role="context" start="358" end="366">
fn fmt(val: &T, f: &mut fmt::Formatter<'_>) -> fmt::Result {
let vpa_str: &str = val.as_ref();
if let Some((user_identifier, bank_or_psp)) = vpa_str.split_once('@') {
let masked_user_identifier = "*".repeat(user_identifier.len());
write!(f, "{masked_user_identifier}@{bank_or_psp}")
} else {
WithType::fmt(val, f)
}
}
<file_sep path="hyperswitch/crates/common_utils/src/pii.rs" role="context" start="357" end="357">
use std::{convert::AsRef, fmt, ops, str::FromStr};
use masking::{ExposeInterface, Secret, Strategy, WithType};
<file_sep path="hyperswitch/crates/common_utils/src/pii.rs" role="context" start="405" end="411">
fn test_invalid_email_masking() {
let secret: Secret<String, EmailStrategy> = Secret::new("myemailgmail.com".to_string());
assert_eq!("*** alloc::string::String ***", format!("{secret:?}"));
let secret: Secret<String, EmailStrategy> = Secret::new("myemail$gmail.com".to_string());
assert_eq!("*** alloc::string::String ***", format!("{secret:?}"));
}
<file_sep path="hyperswitch/crates/common_utils/src/pii.rs" role="context" start="396" end="402">
fn test_valid_email_masking() {
let secret: Secret<String, EmailStrategy> = Secret::new("example@test.com".to_string());
assert_eq!("*******@test.com", format!("{secret:?}"));
let secret: Secret<String, EmailStrategy> = Secret::new("username@gmail.com".to_string());
assert_eq!("********@gmail.com", format!("{secret:?}"));
}
<file_sep path="hyperswitch/crates/common_utils/src/pii.rs" role="context" start="326" end="347">
fn fmt(val: &T, f: &mut fmt::Formatter<'_>) -> fmt::Result {
let val_str: &str = val.as_ref();
let segments: Vec<&str> = val_str.split('.').collect();
if segments.len() != 4 {
return WithType::fmt(val, f);
}
for seg in segments.iter() {
if seg.is_empty() || seg.len() > 3 {
return WithType::fmt(val, f);
}
}
if let Some(segments) = segments.first() {
write!(f, "{}.**.**.**", segments)
} else {
#[cfg(feature = "logs")]
logger::error!("Invalid IP address: {val_str}");
WithType::fmt(val, f)
}
}
<file_sep path="hyperswitch/crates/common_utils/src/pii.rs" role="context" start="301" end="315">
fn from_str(email: &str) -> Result<Self, Self::Err> {
if email.eq(REDACTED) {
return Ok(Self(Secret::new(email.to_string())));
}
match validate_email(email) {
Ok(_) => {
let secret = Secret::<String, EmailStrategy>::new(email.to_string());
Ok(Self(secret))
}
Err(_) => Err(ValidationError::InvalidValue {
message: "Invalid email address format".into(),
}
.into()),
}
}
<file_sep path="hyperswitch/crates/common_utils/src/pii.rs" role="context" start="44" end="55">
fn fmt(val: &T, f: &mut fmt::Formatter<'_>) -> fmt::Result {
let val_str: &str = val.as_ref();
if let Some(val_str) = val_str.get(val_str.len() - 4..) {
// masks everything but the last 4 digits
write!(f, "{}{}", "*".repeat(val_str.len() - 4), val_str)
} else {
#[cfg(feature = "logs")]
logger::error!("Invalid phone number: {val_str}");
WithType::fmt(val, f)
}
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/redis_interface/src/lib.rs<|crate|> redis_interface anchor=new kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/redis_interface/src/lib.rs" role="context" start="102" end="180">
pub async fn new(conf: &RedisSettings) -> CustomResult<Self, errors::RedisError> {
let redis_connection_url = match conf.cluster_enabled {
// Fred relies on this format for specifying cluster where the host port is ignored & only query parameters are used for node addresses
// redis-cluster://username:password@host:port?node=bar.com:30002&node=baz.com:30003
true => format!(
"redis-cluster://{}:{}?{}",
conf.host,
conf.port,
conf.cluster_urls
.iter()
.flat_map(|url| vec!["&", url])
.skip(1)
.collect::<String>()
),
false => format!(
"redis://{}:{}", //URI Schema
conf.host, conf.port,
),
};
let mut config = fred::types::RedisConfig::from_url(&redis_connection_url)
.change_context(errors::RedisError::RedisConnectionError)?;
let perf = fred::types::PerformanceConfig {
auto_pipeline: conf.auto_pipeline,
default_command_timeout: std::time::Duration::from_secs(conf.default_command_timeout),
max_feed_count: conf.max_feed_count,
backpressure: fred::types::BackpressureConfig {
disable_auto_backpressure: conf.disable_auto_backpressure,
max_in_flight_commands: conf.max_in_flight_commands,
policy: fred::types::BackpressurePolicy::Drain,
},
};
let connection_config = fred::types::ConnectionConfig {
unresponsive_timeout: std::time::Duration::from_secs(conf.unresponsive_timeout),
..fred::types::ConnectionConfig::default()
};
if !conf.use_legacy_version {
config.version = fred::types::RespVersion::RESP3;
}
config.tracing = fred::types::TracingConfig::new(true);
config.blocking = fred::types::Blocking::Error;
let reconnect_policy = fred::types::ReconnectPolicy::new_constant(
conf.reconnect_max_attempts,
conf.reconnect_delay,
);
let subscriber =
SubscriberClient::new(config.clone(), reconnect_policy.clone(), perf.clone()).await?;
let publisher =
RedisClient::new(config.clone(), reconnect_policy.clone(), perf.clone()).await?;
let pool = fred::prelude::RedisPool::new(
config,
Some(perf),
Some(connection_config),
Some(reconnect_policy),
conf.pool_size,
)
.change_context(errors::RedisError::RedisConnectionError)?;
pool.connect();
pool.wait_for_connect()
.await
.change_context(errors::RedisError::RedisConnectionError)?;
let config = RedisConfig::from(conf);
Ok(Self {
pool: Arc::new(pool),
config: Arc::new(config),
is_redis_available: Arc::new(atomic::AtomicBool::new(true)),
subscriber: Arc::new(subscriber),
publisher: Arc::new(publisher),
key_prefix: String::default(),
})
}
<file_sep path="hyperswitch/crates/redis_interface/src/lib.rs" role="context" start="101" end="101">
use std::sync::{atomic, Arc};
use common_utils::errors::CustomResult;
pub use fred::interfaces::PubsubInterface;
use fred::{interfaces::ClientLike, prelude::EventInterface};
pub use self::types::*;
<file_sep path="hyperswitch/crates/redis_interface/src/lib.rs" role="context" start="191" end="216">
pub async fn on_error(&self, tx: tokio::sync::oneshot::Sender<()>) {
use futures::StreamExt;
use tokio_stream::wrappers::BroadcastStream;
let error_rxs: Vec<BroadcastStream<fred::error::RedisError>> = self
.pool
.clients()
.iter()
.map(|client| BroadcastStream::new(client.error_rx()))
.collect();
let mut error_rx = futures::stream::select_all(error_rxs);
loop {
if let Some(Ok(error)) = error_rx.next().await {
tracing::error!(?error, "Redis protocol or connection error");
if self.pool.state() == fred::types::ClientState::Disconnected {
if tx.send(()).is_err() {
tracing::error!("The redis shutdown signal sender failed to signal");
}
self.is_redis_available
.store(false, atomic::Ordering::SeqCst);
break;
}
}
}
}
<file_sep path="hyperswitch/crates/redis_interface/src/lib.rs" role="context" start="181" end="190">
pub fn clone(&self, key_prefix: &str) -> Self {
Self {
pool: Arc::clone(&self.pool),
key_prefix: key_prefix.to_string(),
config: Arc::clone(&self.config),
subscriber: Arc::clone(&self.subscriber),
publisher: Arc::clone(&self.publisher),
is_redis_available: Arc::clone(&self.is_redis_available),
}
}
<file_sep path="hyperswitch/crates/redis_interface/src/lib.rs" role="context" start="95" end="97">
fn deref(&self) -> &Self::Target {
&self.inner
}
<file_sep path="hyperswitch/crates/redis_interface/src/lib.rs" role="context" start="74" end="90">
pub async fn new(
config: fred::types::RedisConfig,
reconnect_policy: fred::types::ReconnectPolicy,
perf: fred::types::PerformanceConfig,
) -> CustomResult<Self, errors::RedisError> {
let client =
fred::clients::SubscriberClient::new(config, Some(perf), None, Some(reconnect_policy));
client.connect();
client
.wait_for_connect()
.await
.change_context(errors::RedisError::RedisConnectionError)?;
Ok(Self {
inner: client,
is_subscriber_handler_spawned: Arc::new(atomic::AtomicBool::new(false)),
})
}
<file_sep path="hyperswitch/crates/redis_interface/src/lib.rs" role="context" start="235" end="241">
fn from(config: &RedisSettings) -> Self {
Self {
default_ttl: config.default_ttl,
default_stream_read_count: config.stream_read_count,
default_hash_ttl: config.default_hash_ttl,
}
}
<file_sep path="hyperswitch/crates/redis_interface/src/lib.rs" role="context" start="228" end="232">
pub struct RedisConfig {
default_ttl: u32,
default_stream_read_count: u64,
default_hash_ttl: u32,
}
<file_sep path="hyperswitch/crates/redis_interface/src/lib.rs" role="context" start="68" end="71">
pub struct SubscriberClient {
inner: fred::clients::SubscriberClient,
pub is_subscriber_handler_spawned: Arc<atomic::AtomicBool>,
}
<file_sep path="hyperswitch/crates/redis_interface/src/errors.rs" role="context" start="4" end="79">
pub enum RedisError {
#[error("Invalid Redis configuration: {0}")]
InvalidConfiguration(String),
#[error("Failed to set key value in Redis")]
SetFailed,
#[error("Failed to set key value in Redis. Duplicate value")]
SetNxFailed,
#[error("Failed to set key value with expiry in Redis")]
SetExFailed,
#[error("Failed to set expiry for key value in Redis")]
SetExpiryFailed,
#[error("Failed to get key value in Redis")]
GetFailed,
#[error("Failed to delete key value in Redis")]
DeleteFailed,
#[error("Failed to append entry to Redis stream")]
StreamAppendFailed,
#[error("Failed to read entries from Redis stream")]
StreamReadFailed,
#[error("Failed to get stream length")]
GetLengthFailed,
#[error("Failed to delete entries from Redis stream")]
StreamDeleteFailed,
#[error("Failed to trim entries from Redis stream")]
StreamTrimFailed,
#[error("Failed to acknowledge Redis stream entry")]
StreamAcknowledgeFailed,
#[error("Stream is either empty or not available")]
StreamEmptyOrNotAvailable,
#[error("Failed to create Redis consumer group")]
ConsumerGroupCreateFailed,
#[error("Failed to destroy Redis consumer group")]
ConsumerGroupDestroyFailed,
#[error("Failed to delete consumer from consumer group")]
ConsumerGroupRemoveConsumerFailed,
#[error("Failed to set last ID on consumer group")]
ConsumerGroupSetIdFailed,
#[error("Failed to set Redis stream message owner")]
ConsumerGroupClaimFailed,
#[error("Failed to serialize application type to JSON")]
JsonSerializationFailed,
#[error("Failed to deserialize application type from JSON")]
JsonDeserializationFailed,
#[error("Failed to set hash in Redis")]
SetHashFailed,
#[error("Failed to set hash field in Redis")]
SetHashFieldFailed,
#[error("Failed to add members to set in Redis")]
SetAddMembersFailed,
#[error("Failed to get hash field in Redis")]
GetHashFieldFailed,
#[error("The requested value was not found in Redis")]
NotFound,
#[error("Invalid RedisEntryId provided")]
InvalidRedisEntryId,
#[error("Failed to establish Redis connection")]
RedisConnectionError,
#[error("Failed to subscribe to a channel")]
SubscribeError,
#[error("Failed to publish to a channel")]
PublishError,
#[error("Failed while receiving message from publisher")]
OnMessageError,
#[error("Got an unknown result from redis")]
UnknownResult,
#[error("Failed to append elements to list in Redis")]
AppendElementsToListFailed,
#[error("Failed to get list elements in Redis")]
GetListElementsFailed,
#[error("Failed to get length of list")]
GetListLengthFailed,
#[error("Failed to pop list elements in Redis")]
PopListElementsFailed,
#[error("Failed to increment hash field in Redis")]
IncrementHashFieldFailed,
}
|
symbol_neighborhood
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.