text stringlengths 70 351k | source stringclasses 4
values |
|---|---|
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/stripe/transformers.rs | crate: router
use common_utils::{
errors::CustomResult,
ext_traits::{ByteSliceExt, Encode},
pii::{self, Email},
request::RequestContent,
types::MinorUnit,
};
use crate::{
collect_missing_value_keys,
connector::utils::{self as connector_util, ApplePay, ApplePayDecrypt, RouterData},
consts,
core::errors,
headers, services,
types::{
self, api, domain,
storage::enums,
transformers::{ForeignFrom, ForeignTryFrom},
},
utils::OptionExt,
};
fn try_from(
item: types::ResponseRouterData<F, StripeCustomerResponse, T, types::PaymentsResponseData>,
) -> Result<Self, Self::Error> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/stripe/transformers.rs | crate: router
use common_utils::{
errors::CustomResult,
ext_traits::{ByteSliceExt, Encode},
pii::{self, Email},
request::RequestContent,
types::MinorUnit,
};
use crate::{
collect_missing_value_keys,
connector::utils::{self as connector_util, ApplePay, ApplePayDecrypt, RouterData},
consts,
core::errors,
headers, services,
types::{
self, api, domain,
storage::enums,
transformers::{ForeignFrom, ForeignTryFrom},
},
utils::OptionExt,
};
fn try_from(
item: types::ResponseRouterData<F, StripeTokenResponse, T, types::PaymentsResponseData>,
) -> Result<Self, Self::Error> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/stripe/transformers.rs | crate: router
use common_utils::{
errors::CustomResult,
ext_traits::{ByteSliceExt, Encode},
pii::{self, Email},
request::RequestContent,
types::MinorUnit,
};
fn try_from(capture_amount: MinorUnit) -> Result<Self, Self::Error> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/stripe/transformers.rs | crate: router
use common_utils::{
errors::CustomResult,
ext_traits::{ByteSliceExt, Encode},
pii::{self, Email},
request::RequestContent,
types::MinorUnit,
};
use crate::{
collect_missing_value_keys,
connector::utils::{self as connector_util, ApplePay, ApplePayDecrypt, RouterData},
consts,
core::errors,
headers, services,
types::{
self, api, domain,
storage::enums,
transformers::{ForeignFrom, ForeignTryFrom},
},
utils::OptionExt,
};
fn try_from(
(item, refund_amount): (&types::RefundsRouterData<F>, MinorUnit),
) -> Result<Self, Self::Error> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/stripe/transformers.rs | crate: router
fn foreign_from(latest_attempt: Option<LatestAttempt>) -> Self {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/stripe/transformers.rs | crate: router
use common_utils::{
errors::CustomResult,
ext_traits::{ByteSliceExt, Encode},
pii::{self, Email},
request::RequestContent,
types::MinorUnit,
};
use crate::{
collect_missing_value_keys,
connector::utils::{self as connector_util, ApplePay, ApplePayDecrypt, RouterData},
consts,
core::errors,
headers, services,
types::{
self, api, domain,
storage::enums,
transformers::{ForeignFrom, ForeignTryFrom},
},
utils::OptionExt,
};
fn extract_payment_method_connector_response_from_latest_attempt(
stripe_latest_attempt: &LatestAttempt,
) -> Option<types::ConnectorResponseData> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/stripe/transformers.rs | crate: router
use common_utils::{
errors::CustomResult,
ext_traits::{ByteSliceExt, Encode},
pii::{self, Email},
request::RequestContent,
types::MinorUnit,
};
use crate::{
collect_missing_value_keys,
connector::utils::{self as connector_util, ApplePay, ApplePayDecrypt, RouterData},
consts,
core::errors,
headers, services,
types::{
self, api, domain,
storage::enums,
transformers::{ForeignFrom, ForeignTryFrom},
},
utils::OptionExt,
};
fn extract_payment_method_connector_response_from_latest_charge(
stripe_charge_enum: &StripeChargeEnum,
) -> Option<types::ConnectorResponseData> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/stripe/transformers.rs | crate: router
fn from(value: SetupIntentResponse) -> Self {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/stripe/transformers.rs | crate: router
fn from(value: SetupIntentSyncResponse) -> Self {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/stripe/transformers.rs | crate: router
fn from(item: AdditionalPaymentMethodDetails) -> Self {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/stripe/transformers.rs | crate: router
use api_models::{self, enums as api_enums, payments};
use crate::{
collect_missing_value_keys,
connector::utils::{self as connector_util, ApplePay, ApplePayDecrypt, RouterData},
consts,
core::errors,
headers, services,
types::{
self, api, domain,
storage::enums,
transformers::{ForeignFrom, ForeignTryFrom},
},
utils::OptionExt,
};
fn from(item: StripePaymentStatus) -> Self {
{
StripePaymentStatus::Succeeded => Self::Charged,
StripePaymentStatus::Failed => Self::Failure,
StripePaymentStatus::Processing => Self::Authorizing,<|fim_suffix|>
<|fim_middle|>
StripePaymentStatus::Chargeable => Self::Authorizing,
StripePaymentStatus::Consumed => Self::Authorizing,
StripePaymentStatus::Pending => Self::Pending,
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/stripe/transformers.rs | crate: router
use common_utils::{
errors::CustomResult,
ext_traits::{ByteSliceExt, Encode},
pii::{self, Email},
request::RequestContent,
types::MinorUnit,
};
use masking::{ExposeInterface, ExposeOptionInterface, Mask, PeekInterface, Secret};
use crate::{
collect_missing_value_keys,
connector::utils::{self as connector_util, ApplePay, ApplePayDecrypt, RouterData},
consts,
core::errors,
headers, services,
types::{
self, api, domain,
storage::enums,
transformers::{ForeignFrom, ForeignTryFrom},
},
utils::OptionExt,
};
fn from(item: types::BrowserInformation) -> Self {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/stripe/transformers.rs | crate: router
use common_utils::{
errors::CustomResult,
ext_traits::{ByteSliceExt, Encode},
pii::{self, Email},
request::RequestContent,
types::MinorUnit,
};
use masking::{ExposeInterface, ExposeOptionInterface, Mask, PeekInterface, Secret};
use crate::{
collect_missing_value_keys,
connector::utils::{self as connector_util, ApplePay, ApplePayDecrypt, RouterData},
consts,
core::errors,
headers, services,
types::{
self, api, domain,
storage::enums,
transformers::{ForeignFrom, ForeignTryFrom},
},
utils::OptionExt,
};
fn try_from(gpay_data: &domain::GooglePayWalletData) -> Result<Self, Self::Error> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/stripe/transformers.rs | crate: router
use crate::{
collect_missing_value_keys,
connector::utils::{self as connector_util, ApplePay, ApplePayDecrypt, RouterData},
consts,
core::errors,
headers, services,
types::{
self, api, domain,
storage::enums,
transformers::{ForeignFrom, ForeignTryFrom},
},
utils::OptionExt,
};
fn try_from(
(card, payment_method_auth_type): (&domain::Card, Auth3ds),
) -> Result<Self, Self::Error> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/stripe/transformers.rs | crate: router
fn get_stripe_card_network(card_network: common_enums::CardNetwork) -> Option<StripeCardNetwork> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/stripe/transformers.rs | crate: router
use crate::{
collect_missing_value_keys,
connector::utils::{self as connector_util, ApplePay, ApplePayDecrypt, RouterData},
consts,
core::errors,
headers, services,
types::{
self, api, domain,
storage::enums,
transformers::{ForeignFrom, ForeignTryFrom},
},
utils::OptionExt,
};
fn from(bank_debit_data: &domain::BankDebitData) -> Self {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/stripe/transformers.rs | crate: router
use api_models::{self, enums as api_enums, payments};
use common_utils::{
errors::CustomResult,
ext_traits::{ByteSliceExt, Encode},
pii::{self, Email},
request::RequestContent,
types::MinorUnit,
};
use crate::{
collect_missing_value_keys,
connector::utils::{self as connector_util, ApplePay, ApplePayDecrypt, RouterData},
consts,
core::errors,
headers, services,
types::{
self, api, domain,
storage::enums,
transformers::{ForeignFrom, ForeignTryFrom},
},
utils::OptionExt,
};
fn try_from(pay_later_data: &domain::payments::PayLaterData) -> Result<Self, Self::Error> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/stripe/transformers.rs | crate: router
fn from(value: WebhookEventStatus) -> Self {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/stripe/transformers.rs | crate: router
use api_models::{self, enums as api_enums, payments};
use crate::{
collect_missing_value_keys,
connector::utils::{self as connector_util, ApplePay, ApplePayDecrypt, RouterData},
consts,
core::errors,
headers, services,
types::{
self, api, domain,
storage::enums,
transformers::{ForeignFrom, ForeignTryFrom},
},
utils::OptionExt,
};
fn from(item: Option<enums::CaptureMethod>) -> Self {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/stripe/transformers.rs | crate: router
use common_utils::{
errors::CustomResult,
ext_traits::{ByteSliceExt, Encode},
pii::{self, Email},
request::RequestContent,
types::MinorUnit,
};
use crate::{
collect_missing_value_keys,
connector::utils::{self as connector_util, ApplePay, ApplePayDecrypt, RouterData},
consts,
core::errors,
headers, services,
types::{
self, api, domain,
storage::enums,
transformers::{ForeignFrom, ForeignTryFrom},
},
utils::OptionExt,
};
fn try_from(item: &types::ConnectorAuthType) -> Result<Self, Self::Error> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/stripe/transformers.rs | crate: router
use api_models::{self, enums as api_enums, payments};
use common_utils::{
errors::CustomResult,
ext_traits::{ByteSliceExt, Encode},
pii::{self, Email},
request::RequestContent,
types::MinorUnit,
};
use crate::{
collect_missing_value_keys,
connector::utils::{self as connector_util, ApplePay, ApplePayDecrypt, RouterData},
consts,
core::errors,
headers, services,
types::{
self, api, domain,
storage::enums,
transformers::{ForeignFrom, ForeignTryFrom},
},
utils::OptionExt,
};
fn try_from(
(item, auth_type, pm_type): (
&types::SetupMandateRouterData,
enums::AuthenticationType,
StripePaymentMethodType,
),
) -> Result<Self, Self::Error> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/stripe/transformers.rs | crate: router
use std::{collections::HashMap, ops::Deref};
use api_models::{self, enums as api_enums, payments};
use common_utils::{
errors::CustomResult,
ext_traits::{ByteSliceExt, Encode},
pii::{self, Email},
request::RequestContent,
types::MinorUnit,
};
use error_stack::ResultExt;
use hyperswitch_domain_models::mandates::AcceptanceType;
use masking::{ExposeInterface, ExposeOptionInterface, Mask, PeekInterface, Secret};
use serde::{Deserialize, Serialize};
use serde_json::Value;
use time::PrimitiveDateTime;
use url::Url;
pub use self::connect::*;
use crate::{
collect_missing_value_keys,
connector::utils::{self as connector_util, ApplePay, ApplePayDecrypt, RouterData},
consts,
core::errors,
headers, services,
types::{
self, api, domain,
storage::enums,
transformers::{ForeignFrom, ForeignTryFrom},
},
utils::OptionExt,
};
fn try_from(
item: types::ResponseRouterData<
F,
PaymentIntentSyncResponse,
T,
types::PaymentsResponseData,
>,
) -> Result<Self, Self::Error> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/stripe/transformers.rs | crate: router
use std::{collections::HashMap, ops::Deref};
use api_models::{self, enums as api_enums, payments};
use common_utils::{
errors::CustomResult,
ext_traits::{ByteSliceExt, Encode},
pii::{self, Email},
request::RequestContent,
types::MinorUnit,
};
use serde_json::Value;
pub use self::connect::*;
use crate::{
collect_missing_value_keys,
connector::utils::{self as connector_util, ApplePay, ApplePayDecrypt, RouterData},
consts,
core::errors,
headers, services,
types::{
self, api, domain,
storage::enums,
transformers::{ForeignFrom, ForeignTryFrom},
},
utils::OptionExt,
};
pub fn get_connector_metadata(
next_action: Option<&StripeNextActionResponse>,
amount: MinorUnit,
) -> CustomResult<Option<Value>, errors::ConnectorError> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/stripe/transformers.rs | crate: router
use std::{collections::HashMap, ops::Deref};
use api_models::{self, enums as api_enums, payments};
use common_utils::{
errors::CustomResult,
ext_traits::{ByteSliceExt, Encode},
pii::{self, Email},
request::RequestContent,
types::MinorUnit,
};
use error_stack::ResultExt;
use hyperswitch_domain_models::mandates::AcceptanceType;
use masking::{ExposeInterface, ExposeOptionInterface, Mask, PeekInterface, Secret};
use serde::{Deserialize, Serialize};
use serde_json::Value;
use time::PrimitiveDateTime;
use url::Url;
pub use self::connect::*;
use crate::{
collect_missing_value_keys,
connector::utils::{self as connector_util, ApplePay, ApplePayDecrypt, RouterData},
consts,
core::errors,
headers, services,
types::{
self, api, domain,
storage::enums,
transformers::{ForeignFrom, ForeignTryFrom},
},
utils::OptionExt,
};
fn try_from(
item: types::ResponseRouterData<F, PaymentIntentResponse, T, types::PaymentsResponseData>,
) -> Result<Self, Self::Error> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/stripe/transformers.rs | crate: router
use common_utils::{
errors::CustomResult,
ext_traits::{ByteSliceExt, Encode},
pii::{self, Email},
request::RequestContent,
types::MinorUnit,
};
use masking::{ExposeInterface, ExposeOptionInterface, Mask, PeekInterface, Secret};
use crate::{
collect_missing_value_keys,
connector::utils::{self as connector_util, ApplePay, ApplePayDecrypt, RouterData},
consts,
core::errors,
headers, services,
types::{
self, api, domain,
storage::enums,
transformers::{ForeignFrom, ForeignTryFrom},
},
utils::OptionExt,
};
fn try_from(
(bank_redirect_data, billing_address): (
&domain::BankRedirectData,
Option<StripeBillingAddress>,
),
) -> Result<Self, Self::Error> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/stripe/transformers.rs | crate: router
use common_utils::{
errors::CustomResult,
ext_traits::{ByteSliceExt, Encode},
pii::{self, Email},
request::RequestContent,
types::MinorUnit,
};
use masking::{ExposeInterface, ExposeOptionInterface, Mask, PeekInterface, Secret};
use crate::{
collect_missing_value_keys,
connector::utils::{self as connector_util, ApplePay, ApplePayDecrypt, RouterData},
consts,
core::errors,
headers, services,
types::{
self, api, domain,
storage::enums,
transformers::{ForeignFrom, ForeignTryFrom},
},
utils::OptionExt,
};
fn try_from(
(wallet_data, payment_method_token): (
&domain::WalletData,
Option<types::PaymentMethodToken>,
),
) -> Result<Self, Self::Error> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/stripe/transformers.rs | crate: router
use api_models::{self, enums as api_enums, payments};
use common_utils::{
errors::CustomResult,
ext_traits::{ByteSliceExt, Encode},
pii::{self, Email},
request::RequestContent,
types::MinorUnit,
};
use crate::{
collect_missing_value_keys,
connector::utils::{self as connector_util, ApplePay, ApplePayDecrypt, RouterData},
consts,
core::errors,
headers, services,
types::{
self, api, domain,
storage::enums,
transformers::{ForeignFrom, ForeignTryFrom},
},
utils::OptionExt,
};
fn try_from(bank: &common_enums::enums::BankNames) -> Result<Self, Self::Error> {
{
common_enums::enums::BankNames::AbnAmro => Self::AbnAmro,
common_enums::enums::BankNames::ArzteUndApothekerBank => Self::ArzteUndApothekerBank,
common_enums::enums::BankNames::AsnBank => Self::AsnBank,
common_enums::enums::BankNames::AustrianAnadiBankAg => Self::AustrianAnadiBankAg,
common_enums::enums::BankNames::BankAustria => Self::BankAustria,
common_enums::enums::BankNames::BankhausCarlSpangler => Self::BankhausCarlSpangler,
common_enums::enums::BankNames::BankhausSchelhammerUndSchatteraAg => {
Self::BankhausSchelhammerUndSchatteraAg
}
common_enums::enums::BankNames::BawagPskAg => Self::BawagPskAg,
common_enums::enums::BankNames::BksBankAg => Self::BksBankAg,
common_enums::enums::BankNames::BrullKallmusBankAg => Self::BrullKallmusBankAg,
common_enums::enums::BankNames::BtvVierLanderBank => Self::BtvVierLanderBank,
common_enums::enums::BankNames::Bunq => Self::Bunq,
common_enums::enums::BankNames::CapitalBankGraweGruppeAg => {
Self::CapitalBankGraweGruppeAg
}
common_enums::enums::BankNames::Citi => Self::CitiHandlowy,
common_enums::enums::BankNames::Dolomitenbank => Self::Dolomitenbank,
common_enums::enums::BankNames::EasybankAg => Self::EasybankAg,
common_enums::enums::BankNames::ErsteBankUndSparkassen => Self::ErsteBankUndSparkassen,
common_enums::enums::BankNames::Handelsbanken => Self::Handelsbanken,<|fim_suffix|>
<|fim_middle|>
common_enums::enums::BankNames::EtransferPocztowy24 => Self::EtransferPocztowy24,
common_enums::enums::BankNames::BankiSpbdzielcze => Self::BankiSpbdzielcze,
common_enums::enums::BankNames::BankNowyBfgSa => Self::BankNowyBfgSa,
common_enums::enums::BankNames::GetinBank => Self::GetinBank,
common_enums::enums::BankNames::Blik => Self::Blik,
common_enums::enums::BankNames::NoblePay => Self::NoblePay,
common_enums::enums::BankNames::IdeaBank => Self::IdeaBank,
common_enums::enums::BankNames::EnveloBank => Self::EnveloBank,
common_enums::enums::BankNames::NestPrzelew => Self::NestPrzelew,
common_enums::enums::BankNames::MbankMtransfer => Self::MbankMtransfer,
common_enums::enums::BankNames::Inteligo => Self::Inteligo,
common_enums::enums::BankNames::PbacZIpko => Self::PbacZIpko,
common_enums::enums::BankNames::BnpParibas => Self::BnpParibas,
common_enums::enums::BankNames::BankPekaoSa => Self::BankPekaoSa,
common_enums::enums::BankNames::VolkswagenBank => Self::VolkswagenBank,
common_enums::enums::BankNames::AliorBank => Self::AliorBank,
common_enums::enums::BankNames::Boz => Self::Boz,
_ => Err(errors::ConnectorError::NotImplemented(
connector_util::get_unimplemented_payment_method_error_message("stripe"),
))?,
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/stripe/transformers.rs | crate: router
use api_models::{self, enums as api_enums, payments};
use common_utils::{
errors::CustomResult,
ext_traits::{ByteSliceExt, Encode},
pii::{self, Email},
request::RequestContent,
types::MinorUnit,
};
use crate::{
collect_missing_value_keys,
connector::utils::{self as connector_util, ApplePay, ApplePayDecrypt, RouterData},
consts,
core::errors,
headers, services,
types::{
self, api, domain,
storage::enums,
transformers::{ForeignFrom, ForeignTryFrom},
},
utils::OptionExt,
};
fn try_from(value: enums::PaymentMethodType) -> Result<Self, Self::Error> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/stripe/transformers.rs | crate: router
use api_models::{self, enums as api_enums, payments};
use common_utils::{
errors::CustomResult,
ext_traits::{ByteSliceExt, Encode},
pii::{self, Email},
request::RequestContent,
types::MinorUnit,
};
use error_stack::ResultExt;
use hyperswitch_domain_models::mandates::AcceptanceType;
use masking::{ExposeInterface, ExposeOptionInterface, Mask, PeekInterface, Secret};
use crate::{
collect_missing_value_keys,
connector::utils::{self as connector_util, ApplePay, ApplePayDecrypt, RouterData},
consts,
core::errors,
headers, services,
types::{
self, api, domain,
storage::enums,
transformers::{ForeignFrom, ForeignTryFrom},
},
utils::OptionExt,
};
fn try_from(
data: (&types::PaymentsAuthorizeRouterData, MinorUnit),
) -> Result<Self, Self::Error> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/stripe/transformers.rs | crate: router
use api_models::{self, enums as api_enums, payments};
use common_utils::{
errors::CustomResult,
ext_traits::{ByteSliceExt, Encode},
pii::{self, Email},
request::RequestContent,
types::MinorUnit,
};
use error_stack::ResultExt;
use crate::{
collect_missing_value_keys,
connector::utils::{self as connector_util, ApplePay, ApplePayDecrypt, RouterData},
consts,
core::errors,
headers, services,
types::{
self, api, domain,
storage::enums,
transformers::{ForeignFrom, ForeignTryFrom},
},
utils::OptionExt,
};
fn create_stripe_payment_method(
payment_method_data: &domain::PaymentMethodData,
auth_type: enums::AuthenticationType,
payment_method_token: Option<types::PaymentMethodToken>,
is_customer_initiated_mandate_payment: Option<bool>,
billing_address: StripeBillingAddress,
) -> Result<
(
StripePaymentMethodData,
Option<StripePaymentMethodType>,
StripeBillingAddress,
),
error_stack::Report<errors::ConnectorError>,
> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/stripe/transformers/connect.rs | crate: router
fn from(stripe_connect_status: StripeConnectPayoutStatus) -> Self {
{
StripeConnectPayoutStatus::Paid => Self::Success,<|fim_suffix|>
<|fim_middle|>
StripeConnectPayoutStatus::Pending | StripeConnectPayoutStatus::InTransit => {
Self::Pending
}
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/stripe/transformers/connect.rs | crate: router
use crate::{
connector::utils::{PayoutsData, RouterData},
core::{errors, payments::CustomerDetailsExt},
types::{self, storage::enums, PayoutIndividualDetailsExt},
utils::OptionExt,
};
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: types::PayoutsResponseRouterData<F, StripeConnectRecipientAccountCreateResponse>,
) -> Result<Self, Self::Error> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/stripe/transformers/connect.rs | crate: router
fn from(stripe_connect_status: StripeConnectPayoutStatus) -> Self {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
// file: hyperswitch/crates/router/src/connector/stripe/transformers/connect.rs | crate: router
use crate::{
connector::utils::{PayoutsData, RouterData},
core::{errors, payments::CustomerDetailsExt},
types::{self, storage::enums, PayoutIndividualDetailsExt},
utils::OptionExt,
};
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: types::PayoutsResponseRouterData<F, StripeConnectRecipientAccountCreateResponse>,
) -> Result<Self, Self::Error> {
Ok(Self {
response: Ok(types::PayoutsResponseData {
status: Some(enums::PayoutStatus::RequiresCreation),
connector_payout_id: item.data.request.connector_payout_id.clone(),
payout_eligible: None,
should_add_next_step_to_process_tracker: false,
error_code: None,
error_message: None,
}),
..item.data
})
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/stripe/transformers/connect.rs | crate: router
use crate::{
connector::utils::{PayoutsData, RouterData},
core::{errors, payments::CustomerDetailsExt},
types::{self, storage::enums, PayoutIndividualDetailsExt},
utils::OptionExt,
};
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: types::PayoutsResponseRouterData<F, StripeConnectRecipientCreateResponse>,
) -> Result<Self, Self::Error> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/stripe/transformers/connect.rs | crate: router
use crate::{
connector::utils::{PayoutsData, RouterData},
core::{errors, payments::CustomerDetailsExt},
types::{self, storage::enums, PayoutIndividualDetailsExt},
utils::OptionExt,
};
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: types::PayoutsResponseRouterData<F, StripeConnectReversalResponse>,
) -> Result<Self, Self::Error> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/stripe/transformers/connect.rs | crate: router
use crate::{
connector::utils::{PayoutsData, RouterData},
core::{errors, payments::CustomerDetailsExt},
types::{self, storage::enums, PayoutIndividualDetailsExt},
utils::OptionExt,
};
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: types::PayoutsResponseRouterData<F, StripeConnectPayoutFulfillResponse>,
) -> Result<Self, Self::Error> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/stripe/transformers/connect.rs | crate: router
use crate::{
connector::utils::{PayoutsData, RouterData},
core::{errors, payments::CustomerDetailsExt},
types::{self, storage::enums, PayoutIndividualDetailsExt},
utils::OptionExt,
};
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: types::PayoutsResponseRouterData<F, StripeConnectPayoutCreateResponse>,
) -> Result<Self, Self::Error> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/db/dispute.rs | crate: router
use super::{MockDb, Store};
async fn test_update_dispute_update_evidence() {
{let merchant_id =
common_utils::id_type::MerchantId::try_from(Cow::from("merchant_1")).unwrap();<|fim_suffix|>
<|fim_middle|>
assert_ne!(created_dispute.evidence, updated_dispute.evidence);}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/db/dispute.rs | crate: router
use super::{MockDb, Store};
async fn test_update_dispute_update_status() {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/db/dispute.rs | crate: router
use super::{MockDb, Store};
async fn test_find_disputes_by_merchant_id_payment_id() {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/db/dispute.rs | crate: router
use super::{MockDb, Store};
async fn test_find_disputes_by_merchant_id() {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/db/dispute.rs | crate: router
use super::{MockDb, Store};
async fn test_find_dispute_by_merchant_id_dispute_id() {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/db/dispute.rs | crate: router
use super::{MockDb, Store};
async fn test_find_by_merchant_id_payment_id_connector_dispute_id() {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/db/dispute.rs | crate: router
use hyperswitch_domain_models::disputes;
use super::{MockDb, Store};
async fn test_insert_dispute() {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/db/dispute.rs | crate: router
fn create_dispute_new(dispute_ids: DisputeNewIds) -> DisputeNew {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/db/dispute.rs | crate: router
use hyperswitch_domain_models::disputes;
use crate::{
connection,
core::errors::{self, CustomResult},
types::storage::{self, DisputeDbExt},
};
async fn insert_dispute(
&self,
dispute: storage::DisputeNew,
) -> CustomResult<storage::Dispute, errors::StorageError> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/db/dispute.rs | crate: router
use super::{MockDb, Store};
async fn test_update_dispute_update_status() {
{let merchant_id =
common_utils::id_type::MerchantId::try_from(Cow::from("merchant_1")).unwrap();<|fim_suffix|>
<|fim_middle|>
assert_eq!(created_dispute.evidence, updated_dispute.evidence);}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/db/dispute.rs | crate: router
use hyperswitch_domain_models::disputes;
use crate::{
connection,
core::errors::{self, CustomResult},
types::storage::{self, DisputeDbExt},
};
async fn find_disputes_by_merchant_id_payment_id(
&self,
merchant_id: &common_utils::id_type::MerchantId,
payment_id: &common_utils::id_type::PaymentId,
) -> CustomResult<Vec<storage::Dispute>, errors::StorageError> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/db/dispute.rs | crate: router
use hyperswitch_domain_models::disputes;
use crate::{
connection,
core::errors::{self, CustomResult},
types::storage::{self, DisputeDbExt},
};
async fn find_by_merchant_id_payment_id_connector_dispute_id(
&self,
merchant_id: &common_utils::id_type::MerchantId,
payment_id: &common_utils::id_type::PaymentId,
connector_dispute_id: &str,
) -> CustomResult<Option<storage::Dispute>, errors::StorageError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/db/dispute.rs | crate: router
use error_stack::report;
use crate::{
connection,
core::errors::{self, CustomResult},
types::storage::{self, DisputeDbExt},
};
async fn get_dispute_status_with_count(
&self,
merchant_id: &common_utils::id_type::MerchantId,
profile_id_list: Option<Vec<common_utils::id_type::ProfileId>>,
time_range: &common_utils::types::TimeRange,
) -> CustomResult<Vec<(common_enums::DisputeStatus, i64)>, errors::StorageError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/db/dispute.rs | crate: router
use error_stack::report;
use crate::{
connection,
core::errors::{self, CustomResult},
types::storage::{self, DisputeDbExt},
};
async fn update_dispute(
&self,
this: storage::Dispute,
dispute: storage::DisputeUpdate,
) -> CustomResult<storage::Dispute, errors::StorageError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/db/dispute.rs | crate: router
use error_stack::report;
use crate::{
connection,
core::errors::{self, CustomResult},
types::storage::{self, DisputeDbExt},
};
async fn find_dispute_by_merchant_id_dispute_id(
&self,
merchant_id: &common_utils::id_type::MerchantId,
dispute_id: &str,
) -> CustomResult<storage::Dispute, errors::StorageError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
// file: hyperswitch/crates/router/src/db/dispute.rs | crate: router
use error_stack::report;
use crate::{
connection,
core::errors::{self, CustomResult},
types::storage::{self, DisputeDbExt},
};
async fn insert_dispute(
&self,
dispute: storage::DisputeNew,
) -> CustomResult<storage::Dispute, errors::StorageError> {
let conn = connection::pg_connection_write(self).await?;
dispute
.insert(&conn)
.await
.map_err(|error| report!(errors::StorageError::from(error)))
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/db/dispute.rs | crate: router
use super::{MockDb, Store};
async fn test_update_dispute_update() {
{let merchant_id =
common_utils::id_type::MerchantId::try_from(Cow::from("merchant_1")).unwrap();<|fim_suffix|>
<|fim_middle|>
assert_eq!(created_dispute.evidence, updated_dispute.evidence);}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/db/dispute.rs | crate: router
use hyperswitch_domain_models::disputes;
use crate::{
connection,
core::errors::{self, CustomResult},
types::storage::{self, DisputeDbExt},
};
async fn find_disputes_by_constraints(
&self,
merchant_id: &common_utils::id_type::MerchantId,
dispute_constraints: &disputes::DisputeListConstraints,
) -> CustomResult<Vec<storage::Dispute>, errors::StorageError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/db/role.rs | crate: router
use common_utils::id_type;
use diesel_models::{
enums::{EntityType, RoleScope},
role as storage,
};
use crate::{
connection,
core::errors::{self, CustomResult},
services::Store,
};
async fn generic_list_roles_by_entity_type(
&self,
payload: storage::ListRolesByEntityPayload,
is_lineage_data_required: bool,
tenant_id: id_type::TenantId,
org_id: id_type::OrganizationId,
) -> CustomResult<Vec<storage::Role>, errors::StorageError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
// file: hyperswitch/crates/router/src/db/role.rs | crate: router
use common_utils::id_type;
use diesel_models::{
enums::{EntityType, RoleScope},
role as storage,
};
use crate::{
connection,
core::errors::{self, CustomResult},
services::Store,
};
async fn list_roles_for_org_by_parameters(
&self,
tenant_id: &id_type::TenantId,
org_id: &id_type::OrganizationId,
merchant_id: Option<&id_type::MerchantId>,
entity_type: Option<EntityType>,
limit: Option<u32>,
) -> CustomResult<Vec<storage::Role>, errors::StorageError> {
let roles = self.roles.lock().await;
let limit_usize = limit.unwrap_or(u32::MAX).try_into().unwrap_or(usize::MAX);
let roles_list: Vec<_> = roles
.iter()
.filter(|role| {
let matches_merchant = match merchant_id {
Some(merchant_id) => role.merchant_id == *merchant_id,
None => true,
};
matches_merchant
&& role.org_id == *org_id
&& role.tenant_id == *tenant_id
&& Some(role.entity_type) == entity_type
})
.take(limit_usize)
.cloned()
.collect();
Ok(roles_list)
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/db/role.rs | crate: router
use common_utils::id_type;
use diesel_models::{
enums::{EntityType, RoleScope},
role as storage,
};
use crate::{
connection,
core::errors::{self, CustomResult},
services::Store,
};
async fn find_role_by_role_id_in_lineage(
&self,
role_id: &str,
merchant_id: &id_type::MerchantId,
org_id: &id_type::OrganizationId,
profile_id: &id_type::ProfileId,
tenant_id: &id_type::TenantId,
) -> CustomResult<storage::Role, errors::StorageError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
// file: hyperswitch/crates/router/src/db/role.rs | crate: router
use diesel_models::{
enums::{EntityType, RoleScope},
role as storage,
};
use crate::{
connection,
core::errors::{self, CustomResult},
services::Store,
};
async fn insert_role(
&self,
role: storage::RoleNew,
) -> CustomResult<storage::Role, errors::StorageError> {
let mut roles = self.roles.lock().await;
if roles
.iter()
.any(|role_inner| role_inner.role_id == role.role_id)
{
Err(errors::StorageError::DuplicateValue {
entity: "role_id",
key: None,
})?
}
let role = storage::Role {
role_name: role.role_name,
role_id: role.role_id,
merchant_id: role.merchant_id,
org_id: role.org_id,
groups: role.groups,
scope: role.scope,
entity_type: role.entity_type,
created_by: role.created_by,
created_at: role.created_at,
last_modified_at: role.last_modified_at,
last_modified_by: role.last_modified_by,
profile_id: role.profile_id,
tenant_id: role.tenant_id,
};
roles.push(role.clone());
Ok(role)
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/db/role.rs | crate: router
use common_utils::id_type;
use diesel_models::{
enums::{EntityType, RoleScope},
role as storage,
};
use crate::{
connection,
core::errors::{self, CustomResult},
services::Store,
};
async fn list_roles_for_org_by_parameters(
&self,
tenant_id: &id_type::TenantId,
org_id: &id_type::OrganizationId,
merchant_id: Option<&id_type::MerchantId>,
entity_type: Option<EntityType>,
limit: Option<u32>,
) -> CustomResult<Vec<storage::Role>, errors::StorageError> {
{
Some(merchant_id) => role.merchant_id == *merchant_id,<|fim_suffix|>
<|fim_middle|>
None => true,
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/db/role.rs | crate: router
use diesel_models::{
enums::{EntityType, RoleScope},
role as storage,
};
use crate::{
connection,
core::errors::{self, CustomResult},
services::Store,
};
async fn delete_role_by_role_id(
&self,
role_id: &str,
) -> CustomResult<storage::Role, errors::StorageError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/db/role.rs | crate: router
use common_utils::id_type;
use diesel_models::{
enums::{EntityType, RoleScope},
role as storage,
};
use crate::{
connection,
core::errors::{self, CustomResult},
services::Store,
};
async fn find_by_role_id_org_id_tenant_id(
&self,
role_id: &str,
org_id: &id_type::OrganizationId,
tenant_id: &id_type::TenantId,
) -> CustomResult<storage::Role, errors::StorageError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/db/role.rs | crate: router
use common_utils::id_type;
use diesel_models::{
enums::{EntityType, RoleScope},
role as storage,
};
use error_stack::report;
use crate::{
connection,
core::errors::{self, CustomResult},
services::Store,
};
async fn list_roles_for_org_by_parameters(
&self,
tenant_id: &id_type::TenantId,
org_id: &id_type::OrganizationId,
merchant_id: Option<&id_type::MerchantId>,
entity_type: Option<EntityType>,
limit: Option<u32>,
) -> CustomResult<Vec<storage::Role>, errors::StorageError> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
// file: hyperswitch/crates/router/src/db/role.rs | crate: router
use diesel_models::{
enums::{EntityType, RoleScope},
role as storage,
};
use error_stack::report;
use crate::{
connection,
core::errors::{self, CustomResult},
services::Store,
};
async fn delete_role_by_role_id(
&self,
role_id: &str,
) -> CustomResult<storage::Role, errors::StorageError> {
let conn = connection::pg_connection_write(self).await?;
storage::Role::delete_by_role_id(&conn, role_id)
.await
.map_err(|error| report!(errors::StorageError::from(error)))
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/db/role.rs | crate: router
use diesel_models::{
enums::{EntityType, RoleScope},
role as storage,
};
use error_stack::report;
use crate::{
connection,
core::errors::{self, CustomResult},
services::Store,
};
async fn update_role_by_role_id(
&self,
role_id: &str,
role_update: storage::RoleUpdate,
) -> CustomResult<storage::Role, errors::StorageError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/db/role.rs | crate: router
use diesel_models::{
enums::{EntityType, RoleScope},
role as storage,
};
use error_stack::report;
use crate::{
connection,
core::errors::{self, CustomResult},
services::Store,
};
async fn insert_role(
&self,
role: storage::RoleNew,
) -> CustomResult<storage::Role, errors::StorageError> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/db/events.rs | crate: router
use common_utils::{ext_traits::AsyncExt, types::keymanager::KeyManagerState};
use crate::{
connection,
core::errors::{self, CustomResult},
types::{
domain::{
self,
behaviour::{Conversion, ReverseConversion},
},
storage,
},
};
async fn count_initial_events_by_constraints(
&self,
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>,
) -> CustomResult<i64, errors::StorageError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/db/events.rs | crate: router
use common_utils::{ext_traits::AsyncExt, types::keymanager::KeyManagerState};
use crate::{
connection,
core::errors::{self, CustomResult},
types::{
domain::{
self,
behaviour::{Conversion, ReverseConversion},
},
storage,
},
};
async fn update_event_by_merchant_id_event_id(
&self,
state: &KeyManagerState,
merchant_id: &common_utils::id_type::MerchantId,
event_id: &str,
event: domain::EventUpdate,
merchant_key_store: &domain::MerchantKeyStore,
) -> CustomResult<domain::Event, errors::StorageError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
// file: hyperswitch/crates/router/src/db/events.rs | crate: router
use common_utils::{ext_traits::AsyncExt, types::keymanager::KeyManagerState};
use crate::{
connection,
core::errors::{self, CustomResult},
types::{
domain::{
self,
behaviour::{Conversion, ReverseConversion},
},
storage,
},
};
async fn list_initial_events_by_profile_id_constraints(
&self,
state: &KeyManagerState,
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>,
merchant_key_store: &domain::MerchantKeyStore,
) -> CustomResult<Vec<domain::Event>, errors::StorageError> {
let locked_events = self.events.lock().await;
let events_iter = locked_events.iter().filter(|event| {
let check = event.business_profile_id == Some(profile_id.to_owned())
&& event.initial_attempt_id.as_ref() == Some(&event.event_id)
&& (event.created_at >= created_after)
&& (event.created_at <= created_before)
&& (event.is_overall_delivery_successful == is_delivered);
check
});
let offset: usize = if let Some(offset) = offset {
if offset < 0 {
Err(errors::StorageError::MockDbError)?;
}
offset
.try_into()
.map_err(|_| errors::StorageError::MockDbError)?
} else {
0
};
let limit: usize = if let Some(limit) = limit {
if limit < 0 {
Err(errors::StorageError::MockDbError)?;
}
limit
.try_into()
.map_err(|_| errors::StorageError::MockDbError)?
} else {
usize::MAX
};
let events = events_iter
.skip(offset)
.take(limit)
.cloned()
.collect::<Vec<_>>();
let mut domain_events = Vec::with_capacity(events.len());
for event in events {
let domain_event = event
.convert(
state,
merchant_key_store.key.get_inner(),
merchant_key_store.merchant_id.clone().into(),
)
.await
.change_context(errors::StorageError::DecryptionError)?;
domain_events.push(domain_event);
}
Ok(domain_events)
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/db/events.rs | crate: router
use common_utils::{ext_traits::AsyncExt, types::keymanager::KeyManagerState};
use crate::{
connection,
core::errors::{self, CustomResult},
types::{
domain::{
self,
behaviour::{Conversion, ReverseConversion},
},
storage,
},
};
async fn list_initial_events_by_profile_id_primary_object_id(
&self,
state: &KeyManagerState,
profile_id: &common_utils::id_type::ProfileId,
primary_object_id: &str,
merchant_key_store: &domain::MerchantKeyStore,
) -> CustomResult<Vec<domain::Event>, errors::StorageError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/db/events.rs | crate: router
use common_utils::{ext_traits::AsyncExt, types::keymanager::KeyManagerState};
use crate::{
connection,
core::errors::{self, CustomResult},
types::{
domain::{
self,
behaviour::{Conversion, ReverseConversion},
},
storage,
},
};
async fn list_initial_events_by_merchant_id_constraints(
&self,
state: &KeyManagerState,
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>,
merchant_key_store: &domain::MerchantKeyStore,
) -> CustomResult<Vec<domain::Event>, errors::StorageError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/db/events.rs | crate: router
use common_utils::{ext_traits::AsyncExt, types::keymanager::KeyManagerState};
use crate::{
connection,
core::errors::{self, CustomResult},
types::{
domain::{
self,
behaviour::{Conversion, ReverseConversion},
},
storage,
},
};
async fn list_initial_events_by_merchant_id_primary_object_id(
&self,
state: &KeyManagerState,
merchant_id: &common_utils::id_type::MerchantId,
primary_object_id: &str,
merchant_key_store: &domain::MerchantKeyStore,
) -> CustomResult<Vec<domain::Event>, errors::StorageError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/db/events.rs | crate: router
use common_utils::{ext_traits::AsyncExt, types::keymanager::KeyManagerState};
use crate::{
connection,
core::errors::{self, CustomResult},
types::{
domain::{
self,
behaviour::{Conversion, ReverseConversion},
},
storage,
},
};
async fn find_event_by_merchant_id_event_id(
&self,
state: &KeyManagerState,
merchant_id: &common_utils::id_type::MerchantId,
event_id: &str,
merchant_key_store: &domain::MerchantKeyStore,
) -> CustomResult<domain::Event, errors::StorageError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
// file: hyperswitch/crates/router/src/db/events.rs | crate: router
use common_utils::{ext_traits::AsyncExt, types::keymanager::KeyManagerState};
use error_stack::{report, ResultExt};
use crate::{
connection,
core::errors::{self, CustomResult},
types::{
domain::{
self,
behaviour::{Conversion, ReverseConversion},
},
storage,
},
};
async fn list_initial_events_by_profile_id_constraints(
&self,
state: &KeyManagerState,
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>,
merchant_key_store: &domain::MerchantKeyStore,
) -> CustomResult<Vec<domain::Event>, errors::StorageError> {
let conn = connection::pg_connection_read(self).await?;
storage::Event::list_initial_attempts_by_profile_id_constraints(
&conn,
profile_id,
created_after,
created_before,
limit,
offset,
is_delivered,
)
.await
.map_err(|error| report!(errors::StorageError::from(error)))
.async_and_then(|events| async {
let mut domain_events = Vec::with_capacity(events.len());
for event in events.into_iter() {
domain_events.push(
event
.convert(
state,
merchant_key_store.key.get_inner(),
common_utils::types::keymanager::Identifier::Merchant(
merchant_key_store.merchant_id.clone(),
),
)
.await
.change_context(errors::StorageError::DecryptionError)?,
);
}
Ok(domain_events)
})
.await
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/db/events.rs | crate: router
use common_utils::{ext_traits::AsyncExt, types::keymanager::KeyManagerState};
use error_stack::{report, ResultExt};
use crate::{
connection,
core::errors::{self, CustomResult},
types::{
domain::{
self,
behaviour::{Conversion, ReverseConversion},
},
storage,
},
};
async fn list_events_by_merchant_id_initial_attempt_id(
&self,
state: &KeyManagerState,
merchant_id: &common_utils::id_type::MerchantId,
initial_attempt_id: &str,
merchant_key_store: &domain::MerchantKeyStore,
) -> CustomResult<Vec<domain::Event>, errors::StorageError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/db/events.rs | crate: router
use common_utils::{ext_traits::AsyncExt, types::keymanager::KeyManagerState};
use crate::{
connection,
core::errors::{self, CustomResult},
types::{
domain::{
self,
behaviour::{Conversion, ReverseConversion},
},
storage,
},
};
async fn list_initial_events_by_profile_id_constraints(
&self,
state: &KeyManagerState,
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>,
merchant_key_store: &domain::MerchantKeyStore,
) -> CustomResult<Vec<domain::Event>, errors::StorageError> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/db/events.rs | crate: router
use common_utils::{ext_traits::AsyncExt, types::keymanager::KeyManagerState};
use error_stack::{report, ResultExt};
use crate::{
connection,
core::errors::{self, CustomResult},
types::{
domain::{
self,
behaviour::{Conversion, ReverseConversion},
},
storage,
},
};
async fn insert_event(
&self,
state: &KeyManagerState,
event: domain::Event,
merchant_key_store: &domain::MerchantKeyStore,
) -> CustomResult<domain::Event, errors::StorageError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/db/events.rs | crate: router
use common_utils::{ext_traits::AsyncExt, types::keymanager::KeyManagerState};
use super::{MockDb, Store};
use crate::{
connection,
core::errors::{self, CustomResult},
types::{
domain::{
self,
behaviour::{Conversion, ReverseConversion},
},
storage,
},
};
async fn test_mockdb_event_interface() {
{#[allow(clippy::expect_used)]<|fim_suffix|>
<|fim_middle|>
assert_eq!(updated_event.event_id, event_id);}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/db/merchant_account.rs | crate: router
use storage_impl::redis::cache::{self, CacheKind, ACCOUNTS_CACHE};
use super::{MasterKeyInterface, MockDb, Store};
use crate::{
connection,
core::errors::{self, CustomResult},
db::merchant_key_store::MerchantKeyStoreInterface,
types::{
domain::{
self,
behaviour::{Conversion, ReverseConversion},
},
storage,
},
};
async fn publish_and_redact_merchant_account_cache(
store: &dyn super::StorageInterface,
merchant_account: &storage::MerchantAccount,
) -> CustomResult<(), errors::StorageError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/db/merchant_account.rs | crate: router
use common_utils::{ext_traits::AsyncExt, types::keymanager::KeyManagerState};
use storage_impl::redis::cache::{self, CacheKind, ACCOUNTS_CACHE};
use crate::{
connection,
core::errors::{self, CustomResult},
db::merchant_key_store::MerchantKeyStoreInterface,
types::{
domain::{
self,
behaviour::{Conversion, ReverseConversion},
},
storage,
},
};
async fn list_merchant_accounts_by_organization_id(
&self,
state: &KeyManagerState,
organization_id: &common_utils::id_type::OrganizationId,
) -> CustomResult<Vec<domain::MerchantAccount>, errors::StorageError> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/db/merchant_account.rs | crate: router
use common_utils::{ext_traits::AsyncExt, types::keymanager::KeyManagerState};
use storage_impl::redis::cache::{self, CacheKind, ACCOUNTS_CACHE};
use crate::{
connection,
core::errors::{self, CustomResult},
db::merchant_key_store::MerchantKeyStoreInterface,
types::{
domain::{
self,
behaviour::{Conversion, ReverseConversion},
},
storage,
},
};
async fn find_merchant_account_by_publishable_key(
&self,
state: &KeyManagerState,
publishable_key: &str,
) -> CustomResult<(domain::MerchantAccount, domain::MerchantKeyStore), errors::StorageError>
{
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/db/merchant_account.rs | crate: router
use common_utils::{ext_traits::AsyncExt, types::keymanager::KeyManagerState};
use diesel_models::MerchantAccountUpdateInternal;
use storage_impl::redis::cache::{self, CacheKind, ACCOUNTS_CACHE};
use crate::{
connection,
core::errors::{self, CustomResult},
db::merchant_key_store::MerchantKeyStoreInterface,
types::{
domain::{
self,
behaviour::{Conversion, ReverseConversion},
},
storage,
},
};
async fn update_specific_fields_in_merchant(
&self,
state: &KeyManagerState,
merchant_id: &common_utils::id_type::MerchantId,
merchant_account_update: storage::MerchantAccountUpdate,
merchant_key_store: &domain::MerchantKeyStore,
) -> CustomResult<domain::MerchantAccount, errors::StorageError> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/db/merchant_account.rs | crate: router
use common_utils::{ext_traits::AsyncExt, types::keymanager::KeyManagerState};
use diesel_models::MerchantAccountUpdateInternal;
use storage_impl::redis::cache::{self, CacheKind, ACCOUNTS_CACHE};
use crate::{
connection,
core::errors::{self, CustomResult},
db::merchant_key_store::MerchantKeyStoreInterface,
types::{
domain::{
self,
behaviour::{Conversion, ReverseConversion},
},
storage,
},
};
async fn update_merchant(
&self,
state: &KeyManagerState,
merchant_account: domain::MerchantAccount,
merchant_account_update: storage::MerchantAccountUpdate,
merchant_key_store: &domain::MerchantKeyStore,
) -> CustomResult<domain::MerchantAccount, errors::StorageError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/db/merchant_account.rs | crate: router
use diesel_models::MerchantAccountUpdateInternal;
use error_stack::{report, ResultExt};
use storage_impl::redis::cache::{self, CacheKind, ACCOUNTS_CACHE};
use crate::{
connection,
core::errors::{self, CustomResult},
db::merchant_key_store::MerchantKeyStoreInterface,
types::{
domain::{
self,
behaviour::{Conversion, ReverseConversion},
},
storage,
},
};
async fn update_all_merchant_account(
&self,
merchant_account: storage::MerchantAccountUpdate,
) -> CustomResult<usize, errors::StorageError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/db/merchant_account.rs | crate: router
use common_utils::{ext_traits::AsyncExt, types::keymanager::KeyManagerState};
use error_stack::{report, ResultExt};
use storage_impl::redis::cache::{self, CacheKind, ACCOUNTS_CACHE};
use crate::{
connection,
core::errors::{self, CustomResult},
db::merchant_key_store::MerchantKeyStoreInterface,
types::{
domain::{
self,
behaviour::{Conversion, ReverseConversion},
},
storage,
},
};
async fn list_merchant_and_org_ids(
&self,
_state: &KeyManagerState,
limit: u32,
offset: Option<u32>,
) -> CustomResult<
Vec<(
common_utils::id_type::MerchantId,
common_utils::id_type::OrganizationId,
)>,
errors::StorageError,
> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/db/merchant_account.rs | crate: router
use std::collections::HashMap;
use common_utils::{ext_traits::AsyncExt, types::keymanager::KeyManagerState};
use error_stack::{report, ResultExt};
use storage_impl::redis::cache::{self, CacheKind, ACCOUNTS_CACHE};
use crate::{
connection,
core::errors::{self, CustomResult},
db::merchant_key_store::MerchantKeyStoreInterface,
types::{
domain::{
self,
behaviour::{Conversion, ReverseConversion},
},
storage,
},
};
async fn list_multiple_merchant_accounts(
&self,
state: &KeyManagerState,
merchant_ids: Vec<common_utils::id_type::MerchantId>,
) -> CustomResult<Vec<domain::MerchantAccount>, errors::StorageError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/db/merchant_account.rs | crate: router
use common_utils::{ext_traits::AsyncExt, types::keymanager::KeyManagerState};
use error_stack::{report, ResultExt};
use storage_impl::redis::cache::{self, CacheKind, ACCOUNTS_CACHE};
use crate::{
connection,
core::errors::{self, CustomResult},
db::merchant_key_store::MerchantKeyStoreInterface,
types::{
domain::{
self,
behaviour::{Conversion, ReverseConversion},
},
storage,
},
};
async fn update_specific_fields_in_merchant(
&self,
state: &KeyManagerState,
merchant_id: &common_utils::id_type::MerchantId,
merchant_account: storage::MerchantAccountUpdate,
merchant_key_store: &domain::MerchantKeyStore,
) -> CustomResult<domain::MerchantAccount, errors::StorageError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
// file: hyperswitch/crates/router/src/db/merchant_account.rs | crate: router
use common_utils::{ext_traits::AsyncExt, types::keymanager::KeyManagerState};
use error_stack::{report, ResultExt};
use storage_impl::redis::cache::{self, CacheKind, ACCOUNTS_CACHE};
use crate::{
connection,
core::errors::{self, CustomResult},
db::merchant_key_store::MerchantKeyStoreInterface,
types::{
domain::{
self,
behaviour::{Conversion, ReverseConversion},
},
storage,
},
};
async fn update_merchant(
&self,
state: &KeyManagerState,
this: domain::MerchantAccount,
merchant_account: storage::MerchantAccountUpdate,
merchant_key_store: &domain::MerchantKeyStore,
) -> CustomResult<domain::MerchantAccount, errors::StorageError> {
let conn = connection::pg_accounts_connection_write(self).await?;
let updated_merchant_account = Conversion::convert(this)
.await
.change_context(errors::StorageError::EncryptionError)?
.update(&conn, merchant_account.into())
.await
.map_err(|error| report!(errors::StorageError::from(error)))?;
#[cfg(feature = "accounts_cache")]
{
publish_and_redact_merchant_account_cache(self, &updated_merchant_account).await?;
}
updated_merchant_account
.convert(
state,
merchant_key_store.key.get_inner(),
merchant_key_store.merchant_id.clone().into(),
)
.await
.change_context(errors::StorageError::DecryptionError)
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/db/merchant_account.rs | crate: router
use common_utils::{ext_traits::AsyncExt, types::keymanager::KeyManagerState};
use error_stack::{report, ResultExt};
use storage_impl::redis::cache::{self, CacheKind, ACCOUNTS_CACHE};
use crate::{
connection,
core::errors::{self, CustomResult},
db::merchant_key_store::MerchantKeyStoreInterface,
types::{
domain::{
self,
behaviour::{Conversion, ReverseConversion},
},
storage,
},
};
async fn find_merchant_account_by_merchant_id(
&self,
state: &KeyManagerState,
merchant_id: &common_utils::id_type::MerchantId,
merchant_key_store: &domain::MerchantKeyStore,
) -> CustomResult<domain::MerchantAccount, errors::StorageError> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/db/merchant_account.rs | crate: router
use common_utils::{ext_traits::AsyncExt, types::keymanager::KeyManagerState};
use storage_impl::redis::cache::{self, CacheKind, ACCOUNTS_CACHE};
use crate::{
connection,
core::errors::{self, CustomResult},
db::merchant_key_store::MerchantKeyStoreInterface,
types::{
domain::{
self,
behaviour::{Conversion, ReverseConversion},
},
storage,
},
};
async fn list_multiple_merchant_accounts(
&self,
state: &KeyManagerState,
merchant_ids: Vec<common_utils::id_type::MerchantId>,
) -> CustomResult<Vec<domain::MerchantAccount>, errors::StorageError> {
{
Ok(key) => account
.clone()
.convert(state, key.key.get_inner(), key.merchant_id.clone().into())
.await
.change_context(errors::StorageError::DecryptionError),<|fim_suffix|>
<|fim_middle|>
Err(err) => Err(err),
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/db/merchant_account.rs | crate: router
use common_utils::{ext_traits::AsyncExt, types::keymanager::KeyManagerState};
use storage_impl::redis::cache::{self, CacheKind, ACCOUNTS_CACHE};
use crate::{
connection,
core::errors::{self, CustomResult},
db::merchant_key_store::MerchantKeyStoreInterface,
types::{
domain::{
self,
behaviour::{Conversion, ReverseConversion},
},
storage,
},
};
async fn list_merchant_accounts_by_organization_id(
&self,
state: &KeyManagerState,
organization_id: &common_utils::id_type::OrganizationId,
) -> CustomResult<Vec<domain::MerchantAccount>, errors::StorageError> {
{
Ok(key) => account
.clone()
.convert(state, key.key.get_inner(), key.merchant_id.clone().into())
.await
.change_context(errors::StorageError::DecryptionError),<|fim_suffix|>
<|fim_middle|>
Err(err) => Err(err),
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/db/merchant_account.rs | crate: router
use storage_impl::redis::cache::{self, CacheKind, ACCOUNTS_CACHE};
use super::{MasterKeyInterface, MockDb, Store};
use crate::{
connection,
core::errors::{self, CustomResult},
db::merchant_key_store::MerchantKeyStoreInterface,
types::{
domain::{
self,
behaviour::{Conversion, ReverseConversion},
},
storage,
},
};
async fn publish_and_redact_all_merchant_account_cache(
store: &dyn super::StorageInterface,
merchant_accounts: &[storage::MerchantAccount],
) -> CustomResult<(), errors::StorageError> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
// file: hyperswitch/crates/router/src/db/merchant_account.rs | crate: router
use common_utils::{ext_traits::AsyncExt, types::keymanager::KeyManagerState};
use storage_impl::redis::cache::{self, CacheKind, ACCOUNTS_CACHE};
use crate::{
connection,
core::errors::{self, CustomResult},
db::merchant_key_store::MerchantKeyStoreInterface,
types::{
domain::{
self,
behaviour::{Conversion, ReverseConversion},
},
storage,
},
};
async fn list_merchant_and_org_ids(
&self,
_state: &KeyManagerState,
limit: u32,
offset: Option<u32>,
) -> CustomResult<
Vec<(
common_utils::id_type::MerchantId,
common_utils::id_type::OrganizationId,
)>,
errors::StorageError,
> {
let accounts = self.merchant_accounts.lock().await;
let limit = limit.try_into().unwrap_or(accounts.len());
let offset = offset.unwrap_or(0).try_into().unwrap_or(0);
let merchant_and_org_ids = accounts
.iter()
.skip(offset)
.take(limit)
.map(|account| (account.get_id().clone(), account.organization_id.clone()))
.collect::<Vec<_>>();
Ok(merchant_and_org_ids)
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/db/merchant_account.rs | crate: router
use common_utils::{ext_traits::AsyncExt, types::keymanager::KeyManagerState};
use storage_impl::redis::cache::{self, CacheKind, ACCOUNTS_CACHE};
use crate::{
connection,
core::errors::{self, CustomResult},
db::merchant_key_store::MerchantKeyStoreInterface,
types::{
domain::{
self,
behaviour::{Conversion, ReverseConversion},
},
storage,
},
};
async fn delete_merchant_account_by_merchant_id(
&self,
merchant_id: &common_utils::id_type::MerchantId,
) -> CustomResult<bool, errors::StorageError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
// file: hyperswitch/crates/router/src/db/merchant_account.rs | crate: router
use diesel_models::MerchantAccountUpdateInternal;
use storage_impl::redis::cache::{self, CacheKind, ACCOUNTS_CACHE};
use crate::{
connection,
core::errors::{self, CustomResult},
db::merchant_key_store::MerchantKeyStoreInterface,
types::{
domain::{
self,
behaviour::{Conversion, ReverseConversion},
},
storage,
},
};
async fn update_all_merchant_account(
&self,
merchant_account_update: storage::MerchantAccountUpdate,
) -> CustomResult<usize, errors::StorageError> {
let mut accounts = self.merchant_accounts.lock().await;
Ok(accounts.iter_mut().fold(0, |acc, account| {
let update = MerchantAccountUpdateInternal::from(merchant_account_update.clone())
.apply_changeset(account.clone());
*account = update;
acc + 1
}))
} | ast_fragments |
// file: hyperswitch/crates/router/src/db/merchant_account.rs | crate: router
use common_utils::{ext_traits::AsyncExt, types::keymanager::KeyManagerState};
use storage_impl::redis::cache::{self, CacheKind, ACCOUNTS_CACHE};
use crate::{
connection,
core::errors::{self, CustomResult},
db::merchant_key_store::MerchantKeyStoreInterface,
types::{
domain::{
self,
behaviour::{Conversion, ReverseConversion},
},
storage,
},
};
async fn find_merchant_account_by_merchant_id(
&self,
state: &KeyManagerState,
merchant_id: &common_utils::id_type::MerchantId,
merchant_key_store: &domain::MerchantKeyStore,
) -> CustomResult<domain::MerchantAccount, errors::StorageError> {
let accounts = self.merchant_accounts.lock().await;
accounts
.iter()
.find(|account| account.get_id() == merchant_id)
.cloned()
.ok_or(errors::StorageError::ValueNotFound(format!(
"Merchant ID: {:?} not found",
merchant_id
)))?
.convert(
state,
merchant_key_store.key.get_inner(),
merchant_key_store.merchant_id.clone().into(),
)
.await
.change_context(errors::StorageError::DecryptionError)
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/db/merchant_account.rs | crate: router
use common_utils::{ext_traits::AsyncExt, types::keymanager::KeyManagerState};
use storage_impl::redis::cache::{self, CacheKind, ACCOUNTS_CACHE};
use crate::{
connection,
core::errors::{self, CustomResult},
db::merchant_key_store::MerchantKeyStoreInterface,
types::{
domain::{
self,
behaviour::{Conversion, ReverseConversion},
},
storage,
},
};
async fn insert_merchant(
&self,
state: &KeyManagerState,
merchant_account: domain::MerchantAccount,
merchant_key_store: &domain::MerchantKeyStore,
) -> CustomResult<domain::MerchantAccount, errors::StorageError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/db/routing_algorithm.rs | crate: router
use diesel_models::routing_algorithm as routing_storage;
use crate::{
connection,
core::errors::{self, CustomResult},
services::Store,
};
type StorageResult<T> = CustomResult<T, errors::StorageError>;
async fn find_routing_algorithm_by_algorithm_id_merchant_id(
&self,
_algorithm_id: &common_utils::id_type::RoutingId,
_merchant_id: &common_utils::id_type::MerchantId,
) -> StorageResult<routing_storage::RoutingAlgorithm> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/db/routing_algorithm.rs | crate: router
use diesel_models::routing_algorithm as routing_storage;
use crate::{
connection,
core::errors::{self, CustomResult},
services::Store,
};
type StorageResult<T> = CustomResult<T, errors::StorageError>;
async fn list_routing_algorithm_metadata_by_merchant_id_transaction_type(
&self,
_merchant_id: &common_utils::id_type::MerchantId,
_transaction_type: &common_enums::TransactionType,
_limit: i64,
_offset: i64,
) -> StorageResult<Vec<routing_storage::RoutingProfileMetadata>> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.