text stringlengths 70 351k | source stringclasses 4
values |
|---|---|
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_domain_models/src/bulk_tokenization.rs | crate: hyperswitch_domain_models
use api_models::{payment_methods as payment_methods_api, payments as payments_api};
use crate::{
address::{Address, AddressDetails, PhoneDetails},
router_request_types::CustomerDetails,
};
fn foreign_from(req: payments_api::CustomerDetails) -> Self {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_domain_models/src/bulk_tokenization.rs | crate: hyperswitch_domain_models
use api_models::{payment_methods as payment_methods_api, payments as payments_api};
fn foreign_from(req: payment_methods_api::TokenizeDataRequest) -> Self {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_domain_models/src/bulk_tokenization.rs | crate: hyperswitch_domain_models
use api_models::{payment_methods as payment_methods_api, payments as payments_api};
use common_utils::{
errors,
ext_traits::OptionExt,
id_type, pii,
transformers::{ForeignFrom, ForeignTryFrom},
};
use crate::{
address::{Address, AddressDetails, PhoneDetails},
router_request_types::CustomerDetails,
};
fn foreign_from(req: payment_methods_api::CardNetworkTokenizeRequest) -> Self {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_domain_models/src/bulk_tokenization.rs | crate: hyperswitch_domain_models
use crate::{
address::{Address, AddressDetails, PhoneDetails},
router_request_types::CustomerDetails,
};
fn foreign_try_from(customer: CustomerDetails) -> Result<Self, Self::Error> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_domain_models/src/bulk_tokenization.rs | crate: hyperswitch_domain_models
fn foreign_from(card: &TokenizeCardRequest) -> Self {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_domain_models/src/bulk_tokenization.rs | crate: hyperswitch_domain_models
use api_models::{payment_methods as payment_methods_api, payments as payments_api};
use crate::{
address::{Address, AddressDetails, PhoneDetails},
router_request_types::CustomerDetails,
};
fn foreign_from(record: &CardNetworkTokenizeRecord) -> Self {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
// file: hyperswitch/crates/hyperswitch_domain_models/src/business_profile.rs | crate: hyperswitch_domain_models
use common_utils::{
crypto::{OptionalEncryptableName, OptionalEncryptableValue},
date_time,
encryption::Encryption,
errors::{CustomResult, ValidationError},
pii, type_name,
types::keymanager,
};
use diesel_models::business_profile::{
AuthenticationConnectorDetails, BusinessPaymentLinkConfig, BusinessPayoutLinkConfig,
CardTestingGuardConfig, ProfileUpdateInternal, WebhookDetails,
};
async fn convert(self) -> CustomResult<Self::DstType, ValidationError> {
Ok(diesel_models::business_profile::Profile {
id: self.id,
merchant_id: self.merchant_id,
profile_name: self.profile_name,
created_at: self.created_at,
modified_at: self.modified_at,
return_url: self.return_url,
enable_payment_response_hash: self.enable_payment_response_hash,
payment_response_hash_key: self.payment_response_hash_key,
redirect_to_merchant_with_http_post: self.redirect_to_merchant_with_http_post,
webhook_details: self.webhook_details,
metadata: self.metadata,
is_recon_enabled: self.is_recon_enabled,
applepay_verified_domains: self.applepay_verified_domains,
payment_link_config: self.payment_link_config,
session_expiry: self.session_expiry,
authentication_connector_details: self.authentication_connector_details,
payout_link_config: self.payout_link_config,
is_extended_card_info_enabled: self.is_extended_card_info_enabled,
extended_card_info_config: self.extended_card_info_config,
is_connector_agnostic_mit_enabled: self.is_connector_agnostic_mit_enabled,
use_billing_as_payment_method_billing: self.use_billing_as_payment_method_billing,
collect_shipping_details_from_wallet_connector: self
.collect_shipping_details_from_wallet_connector,
collect_billing_details_from_wallet_connector: self
.collect_billing_details_from_wallet_connector,
outgoing_webhook_custom_http_headers: self
.outgoing_webhook_custom_http_headers
.map(Encryption::from),
routing_algorithm_id: self.routing_algorithm_id,
always_collect_billing_details_from_wallet_connector: self
.always_collect_billing_details_from_wallet_connector,
always_collect_shipping_details_from_wallet_connector: self
.always_collect_shipping_details_from_wallet_connector,
payout_routing_algorithm_id: self.payout_routing_algorithm_id,
order_fulfillment_time: self.order_fulfillment_time,
order_fulfillment_time_origin: self.order_fulfillment_time_origin,
frm_routing_algorithm_id: self.frm_routing_algorithm_id,
default_fallback_routing: self.default_fallback_routing,
should_collect_cvv_during_payment: self.should_collect_cvv_during_payment,
tax_connector_id: self.tax_connector_id,
is_tax_connector_enabled: Some(self.is_tax_connector_enabled),
version: self.version,
dynamic_routing_algorithm: None,
is_network_tokenization_enabled: self.is_network_tokenization_enabled,
is_auto_retries_enabled: None,
max_auto_retries_enabled: None,
always_request_extended_authorization: None,
is_click_to_pay_enabled: self.is_click_to_pay_enabled,
authentication_product_ids: self.authentication_product_ids,
three_ds_decision_manager_config: self.three_ds_decision_manager_config,
card_testing_guard_config: self.card_testing_guard_config,
card_testing_secret_key: self.card_testing_secret_key.map(|name| name.into()),
is_clear_pan_retries_enabled: self.is_clear_pan_retries_enabled,
force_3ds_challenge: None,
is_debit_routing_enabled: self.is_debit_routing_enabled,
merchant_business_country: self.merchant_business_country,
})
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_domain_models/src/business_profile.rs | crate: hyperswitch_domain_models
use common_types::primitive_wrappers;
fn from(value: ProfileSetter) -> Self {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_domain_models/src/business_profile.rs | crate: hyperswitch_domain_models
pub fn get_order_fulfillment_time(&self) -> Option<i64> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_domain_models/src/business_profile.rs | crate: hyperswitch_domain_models
pub fn get_is_tax_connector_enabled(&self) -> bool {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_domain_models/src/business_profile.rs | crate: hyperswitch_domain_models
use common_utils::{
crypto::{OptionalEncryptableName, OptionalEncryptableValue},
date_time,
encryption::Encryption,
errors::{CustomResult, ValidationError},
pii, type_name,
types::keymanager,
};
fn from(profile_update: ProfileUpdate) -> Self {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_domain_models/src/customer.rs | crate: hyperswitch_domain_models
use common_utils::{
crypto::{self, Encryptable},
date_time,
encryption::Encryption,
errors::{CustomResult, ValidationError},
id_type, pii,
types::{
keymanager::{self, KeyManagerState, ToEncryptable},
Description,
},
};
fn from(customer_update: CustomerUpdate) -> Self {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_domain_models/src/customer.rs | crate: hyperswitch_domain_models
use common_utils::{
crypto::{self, Encryptable},
date_time,
encryption::Encryption,
errors::{CustomResult, ValidationError},
id_type, pii,
types::{
keymanager::{self, KeyManagerState, ToEncryptable},
Description,
},
};
use masking::{PeekInterface, Secret, SwitchStrategy};
use crate::type_encryption as types;
async fn convert_back(
state: &KeyManagerState,
item: Self::DstType,
key: &Secret<Vec<u8>>,
_key_store_ref_id: keymanager::Identifier,
) -> CustomResult<Self, ValidationError>
where
Self: Sized,
{
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
// file: hyperswitch/crates/hyperswitch_domain_models/src/customer.rs | crate: hyperswitch_domain_models
use common_utils::{
crypto::{self, Encryptable},
date_time,
encryption::Encryption,
errors::{CustomResult, ValidationError},
id_type, pii,
types::{
keymanager::{self, KeyManagerState, ToEncryptable},
Description,
},
};
use diesel_models::customers::CustomerUpdateInternal;
async fn convert(self) -> CustomResult<Self::DstType, ValidationError> {
Ok(diesel_models::customers::Customer {
id: self.id,
merchant_reference_id: self.merchant_reference_id,
merchant_id: self.merchant_id,
name: self.name.map(Encryption::from),
email: self.email.map(Encryption::from),
phone: self.phone.map(Encryption::from),
phone_country_code: self.phone_country_code,
description: self.description,
created_at: self.created_at,
metadata: self.metadata,
modified_at: self.modified_at,
connector_customer: self.connector_customer,
default_payment_method_id: self.default_payment_method_id,
updated_by: self.updated_by,
default_billing_address: self.default_billing_address,
default_shipping_address: self.default_shipping_address,
version: self.version,
status: self.status,
})
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_domain_models/src/customer.rs | crate: hyperswitch_domain_models
use common_utils::{
crypto::{self, Encryptable},
date_time,
encryption::Encryption,
errors::{CustomResult, ValidationError},
id_type, pii,
types::{
keymanager::{self, KeyManagerState, ToEncryptable},
Description,
},
};
pub fn get_connector_customer_id(
&self,
merchant_connector_id: &id_type::MerchantConnectorAccountId,
) -> Option<&str> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_domain_models/src/customer.rs | crate: hyperswitch_domain_models
use common_enums::DeleteStatus;
use common_utils::{
crypto::{self, Encryptable},
date_time,
encryption::Encryption,
errors::{CustomResult, ValidationError},
id_type, pii,
types::{
keymanager::{self, KeyManagerState, ToEncryptable},
Description,
},
};
use diesel_models::customers::CustomerUpdateInternal;
use error_stack::ResultExt;
use masking::{PeekInterface, Secret, SwitchStrategy};
use rustc_hash::FxHashMap;
use time::PrimitiveDateTime;
use crate::type_encryption as types;
pub fn get_connector_customer_id(&self, connector_label: &str) -> Option<&str> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_domain_models/src/customer.rs | crate: hyperswitch_domain_models
use common_utils::{
crypto::{self, Encryptable},
date_time,
encryption::Encryption,
errors::{CustomResult, ValidationError},
id_type, pii,
types::{
keymanager::{self, KeyManagerState, ToEncryptable},
Description,
},
};
pub fn get_id(&self) -> &id_type::GlobalCustomerId {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_domain_models/src/customer.rs | crate: hyperswitch_domain_models
use common_utils::{
crypto::{self, Encryptable},
date_time,
encryption::Encryption,
errors::{CustomResult, ValidationError},
id_type, pii,
types::{
keymanager::{self, KeyManagerState, ToEncryptable},
Description,
},
};
pub fn get_id(&self) -> &id_type::CustomerId {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_domain_models/src/behaviour.rs | crate: hyperswitch_domain_models
use common_utils::{
errors::{CustomResult, ValidationError},
types::keymanager::{Identifier, KeyManagerState},
};
use masking::Secret;
async fn convert(
self,
state: &KeyManagerState,
key: &Secret<Vec<u8>>,
key_manager_identifier: Identifier,
) -> CustomResult<U, ValidationError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_domain_models/src/relay.rs | crate: hyperswitch_domain_models
use common_enums::enums;
use common_utils::{
self,
errors::{CustomResult, ValidationError},
id_type::{self, GenerateId},
pii,
types::{keymanager, MinorUnit},
};
use masking::{ExposeInterface, Secret};
async fn convert_back(
_state: &keymanager::KeyManagerState,
item: Self::DstType,
_key: &Secret<Vec<u8>>,
_key_manager_identifier: keymanager::Identifier,
) -> CustomResult<Self, ValidationError> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_domain_models/src/relay.rs | crate: hyperswitch_domain_models
use diesel_models::relay::RelayUpdateInternal;
fn from(value: Relay) -> Self {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_domain_models/src/relay.rs | crate: hyperswitch_domain_models
use common_utils::{
self,
errors::{CustomResult, ValidationError},
id_type::{self, GenerateId},
pii,
types::{keymanager, MinorUnit},
};
fn from(value: RelayUpdate) -> Self {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_domain_models/src/relay.rs | crate: hyperswitch_domain_models
use diesel_models::relay::RelayUpdateInternal;
fn from(relay: RelayData) -> Self {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_domain_models/src/relay.rs | crate: hyperswitch_domain_models
use common_enums::enums;
use crate::{router_data::ErrorResponse, router_response_types};
pub fn from(
response: Result<router_response_types::RefundsResponseData, ErrorResponse>,
) -> Self {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_domain_models/src/relay.rs | crate: hyperswitch_domain_models
use diesel_models::relay::RelayUpdateInternal;
fn from(relay: api_models::relay::RelayRefundRequestData) -> Self {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_domain_models/src/relay.rs | crate: hyperswitch_domain_models
use diesel_models::relay::RelayUpdateInternal;
fn from(relay: api_models::relay::RelayData) -> Self {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_domain_models/src/relay.rs | crate: hyperswitch_domain_models
use common_enums::enums;
use common_utils::{
self,
errors::{CustomResult, ValidationError},
id_type::{self, GenerateId},
pii,
types::{keymanager, MinorUnit},
};
use diesel_models::relay::RelayUpdateInternal;
pub fn new(
relay_request: &api_models::relay::RelayRequest,
merchant_id: &id_type::MerchantId,
profile_id: &id_type::ProfileId,
) -> Self {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
// file: hyperswitch/crates/hyperswitch_domain_models/src/payments/payment_intent.rs | crate: hyperswitch_domain_models
use common_utils::{
consts::{PAYMENTS_LIST_MAX_LIMIT_V1, PAYMENTS_LIST_MAX_LIMIT_V2},
crypto::Encryptable,
encryption::Encryption,
errors::{CustomResult, ValidationError},
id_type,
pii::{self, Email},
type_name,
types::{
keymanager::{self, KeyManagerState, ToEncryptable},
MinorUnit,
},
};
use diesel_models::{
PaymentIntent as DieselPaymentIntent, PaymentIntentNew as DieselPaymentIntentNew,
};
async fn convert(self) -> CustomResult<Self::DstType, ValidationError> {
Ok(DieselPaymentIntent {
payment_id: self.payment_id,
merchant_id: self.merchant_id,
status: self.status,
amount: self.amount,
currency: self.currency,
amount_captured: self.amount_captured,
customer_id: self.customer_id,
description: self.description,
return_url: self.return_url,
metadata: self.metadata,
connector_id: self.connector_id,
shipping_address_id: self.shipping_address_id,
billing_address_id: self.billing_address_id,
statement_descriptor_name: self.statement_descriptor_name,
statement_descriptor_suffix: self.statement_descriptor_suffix,
created_at: self.created_at,
modified_at: self.modified_at,
last_synced: self.last_synced,
setup_future_usage: self.setup_future_usage,
off_session: self.off_session,
client_secret: self.client_secret,
active_attempt_id: self.active_attempt.get_id(),
business_country: self.business_country,
business_label: self.business_label,
order_details: self.order_details,
allowed_payment_method_types: self.allowed_payment_method_types,
connector_metadata: self.connector_metadata,
feature_metadata: self.feature_metadata,
attempt_count: self.attempt_count,
profile_id: self.profile_id,
merchant_decision: self.merchant_decision,
payment_link_id: self.payment_link_id,
payment_confirm_source: self.payment_confirm_source,
updated_by: self.updated_by,
surcharge_applicable: self.surcharge_applicable,
request_incremental_authorization: self.request_incremental_authorization,
incremental_authorization_allowed: self.incremental_authorization_allowed,
authorization_count: self.authorization_count,
fingerprint_id: self.fingerprint_id,
session_expiry: self.session_expiry,
request_external_three_ds_authentication: self.request_external_three_ds_authentication,
charges: None,
split_payments: self.split_payments,
frm_metadata: self.frm_metadata,
customer_details: self.customer_details.map(Encryption::from),
billing_details: self.billing_details.map(Encryption::from),
merchant_order_reference_id: self.merchant_order_reference_id,
shipping_details: self.shipping_details.map(Encryption::from),
is_payment_processor_token_flow: self.is_payment_processor_token_flow,
organization_id: self.organization_id,
shipping_cost: self.shipping_cost,
tax_details: self.tax_details,
skip_external_tax_calculation: self.skip_external_tax_calculation,
request_extended_authorization: self.request_extended_authorization,
psd2_sca_exemption_type: self.psd2_sca_exemption_type,
platform_merchant_id: self.platform_merchant_id,
force_3ds_challenge: self.force_3ds_challenge,
force_3ds_challenge_trigger: self.force_3ds_challenge_trigger,
})
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_domain_models/src/payments/payment_intent.rs | crate: hyperswitch_domain_models
use common_utils::errors::ParsingError;
use common_utils::{
consts::{PAYMENTS_LIST_MAX_LIMIT_V1, PAYMENTS_LIST_MAX_LIMIT_V2},
crypto::Encryptable,
encryption::Encryption,
errors::{CustomResult, ValidationError},
id_type,
pii::{self, Email},
type_name,
types::{
keymanager::{self, KeyManagerState, ToEncryptable},
MinorUnit,
},
};
use error_stack::ResultExt;
use crate::{
behaviour, errors,
merchant_key_store::MerchantKeyStore,
type_encryption::{crypto_operation, CryptoOperation},
RemoteStorageObject,
};
fn try_from(
(constraints, auth_profile_id_list): (T, Option<Vec<id_type::ProfileId>>),
) -> Result<Self, Self::Error> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_domain_models/src/payments/payment_intent.rs | crate: hyperswitch_domain_models
use common_utils::{
consts::{PAYMENTS_LIST_MAX_LIMIT_V1, PAYMENTS_LIST_MAX_LIMIT_V2},
crypto::Encryptable,
encryption::Encryption,
errors::{CustomResult, ValidationError},
id_type,
pii::{self, Email},
type_name,
types::{
keymanager::{self, KeyManagerState, ToEncryptable},
MinorUnit,
},
};
fn from(value: api_models::payments::PaymentListFilterConstraints) -> Self {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_domain_models/src/payments/payment_intent.rs | crate: hyperswitch_domain_models
use common_utils::{
consts::{PAYMENTS_LIST_MAX_LIMIT_V1, PAYMENTS_LIST_MAX_LIMIT_V2},
crypto::Encryptable,
encryption::Encryption,
errors::{CustomResult, ValidationError},
id_type,
pii::{self, Email},
type_name,
types::{
keymanager::{self, KeyManagerState, ToEncryptable},
MinorUnit,
},
};
fn from(value: api_models::payments::PaymentListConstraints) -> Self {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_domain_models/src/payments/payment_intent.rs | crate: hyperswitch_domain_models
use common_utils::{
consts::{PAYMENTS_LIST_MAX_LIMIT_V1, PAYMENTS_LIST_MAX_LIMIT_V2},
crypto::Encryptable,
encryption::Encryption,
errors::{CustomResult, ValidationError},
id_type,
pii::{self, Email},
type_name,
types::{
keymanager::{self, KeyManagerState, ToEncryptable},
MinorUnit,
},
};
pub fn get_profile_id(&self) -> Option<id_type::ProfileId> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_domain_models/src/payments/payment_intent.rs | crate: hyperswitch_domain_models
use common_utils::{
consts::{PAYMENTS_LIST_MAX_LIMIT_V1, PAYMENTS_LIST_MAX_LIMIT_V2},
crypto::Encryptable,
encryption::Encryption,
errors::{CustomResult, ValidationError},
id_type,
pii::{self, Email},
type_name,
types::{
keymanager::{self, KeyManagerState, ToEncryptable},
MinorUnit,
},
};
pub fn get_profile_id_list(&self) -> Option<Vec<id_type::ProfileId>> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_domain_models/src/payments/payment_intent.rs | crate: hyperswitch_domain_models
use common_utils::errors::ParsingError;
use common_utils::ext_traits::{Encode, ValueExt};
use common_utils::{
consts::{PAYMENTS_LIST_MAX_LIMIT_V1, PAYMENTS_LIST_MAX_LIMIT_V2},
crypto::Encryptable,
encryption::Encryption,
errors::{CustomResult, ValidationError},
id_type,
pii::{self, Email},
type_name,
types::{
keymanager::{self, KeyManagerState, ToEncryptable},
MinorUnit,
},
};
fn from(value: PaymentIntentUpdateInternal) -> Self {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_domain_models/src/payments/payment_intent.rs | crate: hyperswitch_domain_models
use common_utils::{
consts::{PAYMENTS_LIST_MAX_LIMIT_V1, PAYMENTS_LIST_MAX_LIMIT_V2},
crypto::Encryptable,
encryption::Encryption,
errors::{CustomResult, ValidationError},
id_type,
pii::{self, Email},
type_name,
types::{
keymanager::{self, KeyManagerState, ToEncryptable},
MinorUnit,
},
};
use diesel_models::{
PaymentIntentUpdate as DieselPaymentIntentUpdate,
PaymentIntentUpdateFields as DieselPaymentIntentUpdateFields,
};
fn from(value: PaymentIntentUpdate) -> Self {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_domain_models/src/payments/payment_intent.rs | crate: hyperswitch_domain_models
use common_utils::errors::ParsingError;
use common_utils::ext_traits::{Encode, ValueExt};
use common_utils::{
consts::{PAYMENTS_LIST_MAX_LIMIT_V1, PAYMENTS_LIST_MAX_LIMIT_V2},
crypto::Encryptable,
encryption::Encryption,
errors::{CustomResult, ValidationError},
id_type,
pii::{self, Email},
type_name,
types::{
keymanager::{self, KeyManagerState, ToEncryptable},
MinorUnit,
},
};
use diesel_models::{
PaymentIntentUpdate as DieselPaymentIntentUpdate,
PaymentIntentUpdateFields as DieselPaymentIntentUpdateFields,
};
fn from(payment_intent_update: PaymentIntentUpdate) -> Self {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_domain_models/src/payments/payment_intent.rs | crate: hyperswitch_domain_models
use common_utils::errors::ParsingError;
use common_utils::ext_traits::{Encode, ValueExt};
use common_utils::{
consts::{PAYMENTS_LIST_MAX_LIMIT_V1, PAYMENTS_LIST_MAX_LIMIT_V2},
crypto::Encryptable,
encryption::Encryption,
errors::{CustomResult, ValidationError},
id_type,
pii::{self, Email},
type_name,
types::{
keymanager::{self, KeyManagerState, ToEncryptable},
MinorUnit,
},
};
use masking::{Deserialize, PeekInterface, Secret};
use serde::Serialize;
use diesel_models::{
PaymentIntentUpdate as DieselPaymentIntentUpdate,
PaymentIntentUpdateFields as DieselPaymentIntentUpdateFields,
};
fn try_from(payment_intent_update: PaymentIntentUpdate) -> Result<Self, Self::Error> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_domain_models/src/router_response_types/fraud_check.rs | crate: hyperswitch_domain_models
fn get_api_event_type(&self) -> Option<common_utils::events::ApiEventsType> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_domain_models/src/router_flow_types/webhooks.rs | crate: hyperswitch_domain_models
pub fn get_id(&self) -> &masking::Secret<String> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_domain_models/src/router_flow_types/webhooks.rs | crate: hyperswitch_domain_models
pub fn new(txn_id: masking::Secret<String>) -> Self {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/connector_configs/src/transformer.rs | crate: connector_configs
use api_models::{
enums::{
Connector, PaymentMethod,
PaymentMethodType::{self, AliPay, ApplePay, GooglePay, Klarna, Paypal, WeChatPay},
},
payment_methods,
refunds::MinorUnit,
};
use crate::common_config::{
ConnectorApiIntegrationPayload, DashboardRequestPayload, PaymentMethodsEnabled, Provider,
};
pub fn transform_payment_method(
connector: Connector,
provider: Vec<Provider>,
payment_method: PaymentMethod,
) -> Vec<payment_methods::RequestPaymentMethodTypes> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/connector_configs/src/transformer.rs | crate: connector_configs
use api_models::{
enums::{
Connector, PaymentMethod,
PaymentMethodType::{self, AliPay, ApplePay, GooglePay, Klarna, Paypal, WeChatPay},
},
payment_methods,
refunds::MinorUnit,
};
pub fn get_payment_experience(
connector: Connector,
payment_method_type: PaymentMethodType,
payment_method: PaymentMethod,
payment_experience: Option<api_models::enums::PaymentExperience>,
) -> Option<api_models::enums::PaymentExperience> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/connector_configs/src/transformer.rs | crate: connector_configs
use api_models::{
enums::{
Connector, PaymentMethod,
PaymentMethodType::{self, AliPay, ApplePay, GooglePay, Klarna, Paypal, WeChatPay},
},
payment_methods,
refunds::MinorUnit,
};
pub fn transform_card(
payment_method_type: PaymentMethodType,
card_provider: Vec<api_models::enums::CardNetwork>,
) -> payment_methods::RequestPaymentMethodTypes {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/connector_configs/src/transformer.rs | crate: connector_configs
use api_models::{
enums::{
Connector, PaymentMethod,
PaymentMethodType::{self, AliPay, ApplePay, GooglePay, Klarna, Paypal, WeChatPay},
},
payment_methods,
refunds::MinorUnit,
};
use crate::common_config::{
ConnectorApiIntegrationPayload, DashboardRequestPayload, PaymentMethodsEnabled, Provider,
};
pub fn create_connector_request(
request: Self,
api_response: ConnectorApiIntegrationPayload,
) -> ConnectorApiIntegrationPayload {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/test_utils/tests/connectors/multisafepay_ui.rs | crate: test_utils | connector: multisafepay_ui
fn should_make_paypal_payment_test() {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/test_utils/tests/connectors/multisafepay_ui.rs | crate: test_utils | connector: multisafepay_ui
fn should_make_multisafepay_3ds_payment_failed_test() {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/test_utils/tests/connectors/multisafepay_ui.rs | crate: test_utils | connector: multisafepay_ui
fn should_make_multisafepay_3ds_payment_success_test() {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/test_utils/tests/connectors/multisafepay_ui.rs | crate: test_utils | connector: multisafepay_ui
async fn should_make_paypal_payment(web_driver: WebDriver) -> Result<(), WebDriverError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/test_utils/tests/connectors/multisafepay_ui.rs | crate: test_utils | connector: multisafepay_ui
async fn should_make_gpay_payment(web_driver: WebDriver) -> Result<(), WebDriverError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/test_utils/tests/connectors/multisafepay_ui.rs | crate: test_utils | connector: multisafepay_ui
async fn should_make_multisafepay_3ds_payment_failed(
web_driver: WebDriver,
) -> Result<(), WebDriverError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/test_utils/tests/connectors/multisafepay_ui.rs | crate: test_utils | connector: multisafepay_ui
async fn should_make_multisafepay_3ds_payment_success(
web_driver: WebDriver,
) -> Result<(), WebDriverError> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
// file: hyperswitch/crates/test_utils/tests/connectors/authorizedotnet_ui.rs | crate: test_utils | connector: authorizedotnet_ui
async fn should_make_gpay_payment(web_driver: WebDriver) -> Result<(), WebDriverError> {
let conn = AuthorizedotnetSeleniumTest {};
let amount = rand::thread_rng().gen_range(1..1000); //This connector detects it as fraudulent payment if the same amount is used for multiple payments so random amount is passed for testing
let pub_key = conn
.get_configs()
.automation_configs
.unwrap()
.authorizedotnet_gateway_merchant_id
.unwrap();
conn.make_gpay_payment(web_driver,
&format!("{CHECKOUT_BASE_URL}/gpay?gatewayname=authorizenet&gatewaymerchantid={pub_key}&amount={amount}&country=US¤cy=USD"),
vec![
Event::Assert(Assert::IsPresent("status")),
Event::Assert(Assert::IsPresent("processing")), // This connector status will be processing for one day
]).await?;
Ok(())
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/test_utils/tests/connectors/mollie_ui.rs | crate: test_utils | connector: mollie_ui
fn should_make_mollie_3ds_payment_test() {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/test_utils/tests/connectors/mollie_ui.rs | crate: test_utils | connector: mollie_ui
fn should_make_mollie_przelewy24_payment_test() {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/test_utils/tests/connectors/mollie_ui.rs | crate: test_utils | connector: mollie_ui
fn should_make_mollie_bancontact_card_payment_test() {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/test_utils/tests/connectors/mollie_ui.rs | crate: test_utils | connector: mollie_ui
fn should_make_mollie_giropay_payment_test() {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/test_utils/tests/connectors/mollie_ui.rs | crate: test_utils | connector: mollie_ui
fn should_make_mollie_eps_payment_test() {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/test_utils/tests/connectors/mollie_ui.rs | crate: test_utils | connector: mollie_ui
fn should_make_mollie_ideal_payment_test() {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/test_utils/tests/connectors/mollie_ui.rs | crate: test_utils | connector: mollie_ui
fn should_make_mollie_sofort_payment_test() {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/test_utils/tests/connectors/mollie_ui.rs | crate: test_utils | connector: mollie_ui
fn should_make_mollie_paypal_payment_test() {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/test_utils/tests/connectors/mollie_ui.rs | crate: test_utils | connector: mollie_ui
async fn should_make_mollie_3ds_payment(web_driver: WebDriver) -> Result<(), WebDriverError> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/test_utils/tests/connectors/mollie_ui.rs | crate: test_utils | connector: mollie_ui
async fn should_make_mollie_przelewy24_payment(c: WebDriver) -> Result<(), WebDriverError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/test_utils/tests/connectors/mollie_ui.rs | crate: test_utils | connector: mollie_ui
async fn should_make_mollie_bancontact_card_payment(c: WebDriver) -> Result<(), WebDriverError> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/test_utils/tests/connectors/mollie_ui.rs | crate: test_utils | connector: mollie_ui
async fn should_make_mollie_giropay_payment(web_driver: WebDriver) -> Result<(), WebDriverError> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/test_utils/tests/connectors/mollie_ui.rs | crate: test_utils | connector: mollie_ui
async fn should_make_mollie_eps_payment(web_driver: WebDriver) -> Result<(), WebDriverError> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/test_utils/tests/connectors/mollie_ui.rs | crate: test_utils | connector: mollie_ui
async fn should_make_mollie_ideal_payment(web_driver: WebDriver) -> Result<(), WebDriverError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/test_utils/tests/connectors/mollie_ui.rs | crate: test_utils | connector: mollie_ui
async fn should_make_mollie_sofort_payment(web_driver: WebDriver) -> Result<(), WebDriverError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/test_utils/tests/connectors/mollie_ui.rs | crate: test_utils | connector: mollie_ui
async fn should_make_mollie_paypal_payment(web_driver: WebDriver) -> Result<(), WebDriverError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/test_utils/tests/connectors/airwallex_ui.rs | crate: test_utils | connector: airwallex_ui
fn should_make_airwallex_gpay_payment_test() {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/test_utils/tests/connectors/airwallex_ui.rs | crate: test_utils | connector: airwallex_ui
fn should_make_airwallex_3ds_payment_test() {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/test_utils/tests/connectors/airwallex_ui.rs | crate: test_utils | connector: airwallex_ui
async fn should_make_airwallex_gpay_payment(web_driver: WebDriver) -> Result<(), WebDriverError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/test_utils/tests/connectors/airwallex_ui.rs | crate: test_utils | connector: airwallex_ui
async fn should_make_airwallex_3ds_payment(web_driver: WebDriver) -> Result<(), WebDriverError> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/test_utils/tests/connectors/zen_ui.rs | crate: test_utils | connector: zen_ui
fn should_make_zen_3ds_payment_test() {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/test_utils/tests/connectors/zen_ui.rs | crate: test_utils | connector: zen_ui
async fn should_make_zen_3ds_payment(web_driver: WebDriver) -> Result<(), WebDriverError> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/test_utils/tests/connectors/noon_ui.rs | crate: test_utils | connector: noon_ui
fn should_make_noon_non_3ds_mandate_payment_test() {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/test_utils/tests/connectors/noon_ui.rs | crate: test_utils | connector: noon_ui
fn should_make_noon_3ds_mandate_payment_test() {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/test_utils/tests/connectors/noon_ui.rs | crate: test_utils | connector: noon_ui
fn should_make_noon_3ds_payment_test() {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/test_utils/tests/connectors/noon_ui.rs | crate: test_utils | connector: noon_ui
async fn should_make_noon_non_3ds_mandate_payment(
web_driver: WebDriver,
) -> Result<(), WebDriverError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/test_utils/tests/connectors/noon_ui.rs | crate: test_utils | connector: noon_ui
async fn should_make_noon_3ds_mandate_payment(web_driver: WebDriver) -> Result<(), WebDriverError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/test_utils/tests/connectors/noon_ui.rs | crate: test_utils | connector: noon_ui
async fn should_make_noon_3ds_payment(web_driver: WebDriver) -> Result<(), WebDriverError> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/test_utils/tests/connectors/shift4_ui.rs | crate: test_utils | connector: shift4_ui
fn should_make_eps_payment_test() {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/test_utils/tests/connectors/shift4_ui.rs | crate: test_utils | connector: shift4_ui
fn should_make_sofort_payment_test() {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/test_utils/tests/connectors/shift4_ui.rs | crate: test_utils | connector: shift4_ui
fn should_make_ideal_payment_test() {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/test_utils/tests/connectors/shift4_ui.rs | crate: test_utils | connector: shift4_ui
fn should_make_giropay_payment_test() {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/test_utils/tests/connectors/shift4_ui.rs | crate: test_utils | connector: shift4_ui
async fn should_make_eps_payment(c: WebDriver) -> Result<(), WebDriverError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/test_utils/tests/connectors/shift4_ui.rs | crate: test_utils | connector: shift4_ui
async fn should_make_sofort_payment(c: WebDriver) -> Result<(), WebDriverError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/test_utils/tests/connectors/shift4_ui.rs | crate: test_utils | connector: shift4_ui
async fn should_make_ideal_payment(c: WebDriver) -> Result<(), WebDriverError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/test_utils/tests/connectors/shift4_ui.rs | crate: test_utils | connector: shift4_ui
async fn should_make_giropay_payment(c: WebDriver) -> Result<(), WebDriverError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/test_utils/tests/connectors/nuvei_ui.rs | crate: test_utils | connector: nuvei_ui
fn should_make_nuvei_eps_payment_test() {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/test_utils/tests/connectors/nuvei_ui.rs | crate: test_utils | connector: nuvei_ui
fn should_make_nuvei_sofort_payment_test() {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/test_utils/tests/connectors/nuvei_ui.rs | crate: test_utils | connector: nuvei_ui
fn should_make_nuvei_ideal_payment_test() {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/test_utils/tests/connectors/nuvei_ui.rs | crate: test_utils | connector: nuvei_ui
fn should_make_nuvei_giropay_payment_test() {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/test_utils/tests/connectors/nuvei_ui.rs | crate: test_utils | connector: nuvei_ui
fn should_make_nuvei_pypl_payment_test() {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/test_utils/tests/connectors/nuvei_ui.rs | crate: test_utils | connector: nuvei_ui
fn should_make_nuvei_gpay_payment_test() {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/test_utils/tests/connectors/nuvei_ui.rs | crate: test_utils | connector: nuvei_ui
fn should_make_nuvei_3ds_mandate_payment_test() {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/test_utils/tests/connectors/nuvei_ui.rs | crate: test_utils | connector: nuvei_ui
fn should_make_nuvei_3ds_payment_test() {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/test_utils/tests/connectors/nuvei_ui.rs | crate: test_utils | connector: nuvei_ui
async fn should_make_nuvei_eps_payment(c: WebDriver) -> Result<(), WebDriverError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/test_utils/tests/connectors/nuvei_ui.rs | crate: test_utils | connector: nuvei_ui
async fn should_make_nuvei_sofort_payment(c: WebDriver) -> Result<(), WebDriverError> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/test_utils/tests/connectors/nuvei_ui.rs | crate: test_utils | connector: nuvei_ui
async fn should_make_nuvei_ideal_payment(c: WebDriver) -> Result<(), WebDriverError> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/test_utils/tests/connectors/nuvei_ui.rs | crate: test_utils | connector: nuvei_ui
async fn should_make_nuvei_giropay_payment(c: WebDriver) -> Result<(), WebDriverError> {
{<|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.