file_name stringlengths 26 96 | text stringlengths 6.17k 164k |
|---|---|
crates__hyperswitch_connectors__src__connectors__volt__transformers.rs | use common_enums::enums;
use common_utils::{id_type, pii::Email, request::Method, types::MinorUnit};
use hyperswitch_domain_models::{
payment_method_data::{BankRedirectData, PaymentMethodData},
router_data::{AccessToken, ConnectorAuthType, ErrorResponse, RouterData},
router_flow_types::refunds::Execute,
... |
crates__hyperswitch_connectors__src__connectors__wellsfargo__transformers.rs | use api_models::payments;
use base64::Engine;
use common_enums::{enums, FutureUsage};
use common_types::payments::ApplePayPredecryptData;
use common_utils::{
consts, pii,
types::{SemanticVersion, StringMajorUnit},
};
use error_stack::ResultExt;
use hyperswitch_domain_models::{
payment_method_data::{
... |
crates__hyperswitch_connectors__src__connectors__wellsfargopayout.rs | pub mod transformers;
use api_models::webhooks::{IncomingWebhookEvent, ObjectReferenceId};
use common_utils::{
errors::CustomResult,
ext_traits::BytesExt,
request::{Method, Request, RequestBuilder, RequestContent},
types::{AmountConvertor, StringMinorUnit, StringMinorUnitForConnector},
};
use error_sta... |
crates__hyperswitch_connectors__src__connectors__wise.rs | pub mod transformers;
use api_models::webhooks::IncomingWebhookEvent;
#[cfg(feature = "payouts")]
use common_utils::request::{Method, RequestBuilder, RequestContent};
#[cfg(feature = "payouts")]
use common_utils::types::{AmountConvertor, FloatMajorUnit, FloatMajorUnitForConnector};
use common_utils::{errors::CustomRes... |
crates__hyperswitch_connectors__src__connectors__worldline__transformers.rs | use common_enums::enums::{AttemptStatus, BankNames, CaptureMethod, CountryAlpha2, Currency};
use common_utils::{pii::Email, request::Method};
use hyperswitch_domain_models::{
payment_method_data::{BankRedirectData, PaymentMethodData},
router_data::{ConnectorAuthType, RouterData},
router_flow_types::{
... |
crates__hyperswitch_connectors__src__connectors__worldpay.rs | #[cfg(feature = "payouts")]
mod payout_requests;
#[cfg(feature = "payouts")]
mod payout_response;
#[cfg(feature = "payouts")]
pub mod payout_transformers;
mod requests;
mod response;
pub mod transformers;
use std::sync::LazyLock;
use api_models::{payments::PaymentIdType, webhooks::IncomingWebhookEvent};
use common_en... |
crates__hyperswitch_connectors__src__connectors__worldpay__response.rs | use error_stack::ResultExt;
use hyperswitch_interfaces::errors;
use masking::Secret;
use serde::{Deserialize, Serialize};
use url::Url;
use super::requests::*;
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct WorldpayPaymentsResponse {
pub outcome: PaymentOu... |
crates__hyperswitch_connectors__src__connectors__worldpay__transformers.rs | use std::collections::HashMap;
use api_models::payments::{MandateIds, MandateReferenceId};
use base64::Engine;
use common_enums::enums;
use common_utils::{
consts::BASE64_ENGINE, errors::CustomResult, ext_traits::OptionExt, pii, types::MinorUnit,
};
use error_stack::ResultExt;
use hyperswitch_domain_models::{
... |
crates__hyperswitch_connectors__src__connectors__worldpaymodular.rs | pub mod transformers;
use std::sync::LazyLock;
use api_models::{
payments::PaymentIdType,
webhooks::{IncomingWebhookEvent, RefundIdType},
};
use common_enums::enums;
use common_utils::{
crypto,
errors::CustomResult,
ext_traits::ByteSliceExt,
request::{Method, Request, RequestBuilder, RequestCon... |
crates__hyperswitch_connectors__src__connectors__worldpaymodular__transformers__response.rs | use hyperswitch_domain_models::{router_request_types::*, router_response_types::*};
use hyperswitch_interfaces::errors::ConnectorError;
use masking::{ExposeInterface as _, Secret};
use serde::{Deserialize, Serialize};
use crate::utils::ForeignTryFrom;
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
#[serde... |
crates__hyperswitch_connectors__src__connectors__worldpayvantiv.rs | pub mod transformers;
use std::sync::LazyLock;
use base64::Engine;
use common_utils::{
consts::BASE64_ENGINE,
errors::CustomResult,
ext_traits::BytesExt,
request::{Method, Request, RequestBuilder, RequestContent},
types::{AmountConvertor, MinorUnit, MinorUnitForConnector},
};
use error_stack::{rep... |
crates__hyperswitch_connectors__src__connectors__worldpayxml.rs | pub mod transformers;
use std::sync::LazyLock;
use base64::Engine;
use common_utils::{
errors::CustomResult,
ext_traits::BytesExt,
request::{Method, Request, RequestBuilder, RequestContent},
types::{AmountConvertor, StringMinorUnit, StringMinorUnitForConnector},
};
use error_stack::{report, ResultExt}... |
crates__hyperswitch_connectors__src__connectors__worldpayxml__transformers.rs | #[cfg(feature = "payouts")]
use api_models::payouts::{ApplePayDecrypt, CardPayout};
use base64::Engine;
use common_enums::enums;
#[cfg(feature = "payouts")]
use common_utils::pii;
use common_utils::types::StringMinorUnit;
use error_stack::ResultExt;
use http::HeaderMap;
#[cfg(feature = "payouts")]
use hyperswitch_domai... |
crates__hyperswitch_connectors__src__connectors__xendit.rs | pub mod transformers;
use std::sync::LazyLock;
use api_models::webhooks::IncomingWebhookEvent;
use base64::Engine;
use common_enums::{enums, CallConnectorAction, CaptureMethod, PaymentAction, PaymentMethodType};
use common_utils::{
consts::BASE64_ENGINE,
crypto,
errors::CustomResult,
ext_traits::{ByteS... |
crates__hyperswitch_connectors__src__connectors__xendit__transformers.rs | use std::collections::HashMap;
use api_models::payments::QrCodeInformation;
use cards::CardNumber;
use common_enums::{enums, Currency};
use common_utils::{
errors::CustomResult, ext_traits::Encode, pii, request::Method, types::FloatMajorUnit,
};
use error_stack::ResultExt;
use hyperswitch_domain_models::{
paym... |
crates__hyperswitch_connectors__src__connectors__zen.rs | pub mod transformers;
use std::{fmt::Debug, sync::LazyLock};
use api_models::webhooks::IncomingWebhookEvent;
use common_enums::{enums, CallConnectorAction, PaymentAction};
use common_utils::{
crypto,
errors::CustomResult,
ext_traits::{ByteSliceExt, BytesExt},
request::{Method, Request, RequestBuilder, ... |
crates__hyperswitch_connectors__src__connectors__zen__transformers.rs | use cards::CardNumber;
use common_enums::enums;
use common_utils::{
errors::CustomResult,
ext_traits::{OptionExt, ValueExt},
pii::{self},
request::Method,
};
use error_stack::ResultExt;
use hyperswitch_domain_models::{
payment_method_data::{
BankDebitData, BankRedirectData, BankTransferData,... |
crates__hyperswitch_connectors__src__connectors__zift__transformers.rs | use api_models::payments::AdditionalPaymentData;
use common_enums::enums;
use common_utils::types::StringMinorUnit;
use error_stack::ResultExt;
use hyperswitch_domain_models::{
payment_method_data::PaymentMethodData,
router_data::{ConnectorAuthType, ErrorResponse, RouterData},
router_flow_types::{refunds::E... |
crates__hyperswitch_connectors__src__connectors__zsl.rs | pub mod transformers;
use std::fmt::Debug;
use api_models::webhooks::{IncomingWebhookEvent, ObjectReferenceId};
use common_enums::enums;
use common_utils::{
errors::CustomResult,
ext_traits::{BytesExt, ValueExt},
request::{Method, Request, RequestBuilder, RequestContent},
};
use error_stack::ResultExt;
us... |
crates__hyperswitch_domain_models__src__business_profile.rs | use std::borrow::Cow;
use common_enums::enums as api_enums;
use common_types::{domain::AcquirerConfig, primitive_wrappers};
use common_utils::{
crypto::{OptionalEncryptableName, OptionalEncryptableValue},
date_time,
encryption::Encryption,
errors::{CustomResult, ValidationError},
ext_traits::{Optio... |
crates__hyperswitch_domain_models__src__lib.rs | pub mod address;
pub mod api;
pub mod authentication;
pub mod behaviour;
pub mod bulk_tokenization;
pub mod business_profile;
pub mod callback_mapper;
pub mod card_testing_guard_data;
pub mod cards_info;
pub mod chat;
pub mod configs;
pub mod connector_endpoints;
pub mod consts;
pub mod customer;
pub mod disputes;
pub ... |
crates__hyperswitch_domain_models__src__mandates.rs | use std::collections::HashMap;
use api_models::payments::{
MandateAmountData as ApiMandateAmountData, MandateData as ApiMandateData, MandateType,
};
use common_enums::Currency;
use common_types::payments as common_payments_types;
use common_utils::{
date_time,
errors::{CustomResult, ParsingError},
pii,... |
crates__hyperswitch_domain_models__src__payment_methods.rs | #[cfg(feature = "v2")]
use std::collections::HashMap;
#[cfg(feature = "v2")]
use api_models::payment_methods::PaymentMethodsData;
use api_models::{customers, payment_methods, payments};
// specific imports because of using the macro
use common_enums::enums::MerchantStorageScheme;
#[cfg(feature = "v1")]
use common_util... |
crates__hyperswitch_domain_models__src__payments.rs | #[cfg(feature = "v2")]
use std::marker::PhantomData;
use api_models::customers::CustomerDocumentDetails;
#[cfg(feature = "v2")]
use api_models::payments::{ConnectorMetadata, SessionToken, VaultSessionDetails};
use common_types::primitive_wrappers;
#[cfg(feature = "v1")]
use common_types::{
payments::BillingDescrip... |
crates__hyperswitch_domain_models__src__payments__payment_attempt.rs | #[cfg(all(feature = "v1", feature = "olap"))]
use api_models::enums::Connector;
#[cfg(feature = "v2")]
use api_models::payments::{additional_info::UpiAdditionalData, AdditionalPaymentData};
use common_enums as storage_enums;
#[cfg(feature = "v2")]
use common_types::payments as common_payments_types;
#[cfg(feature = "v1... |
crates__hyperswitch_domain_models__src__router_request_types.rs | pub mod authentication;
pub mod fraud_check;
pub mod merchant_connector_webhook_management;
pub mod revenue_recovery;
pub mod subscriptions;
pub mod unified_authentication_service;
use api_models::payments::{AdditionalPaymentData, AddressDetails, RequestSurchargeDetails};
use common_types::payments as common_payments_t... |
crates__hyperswitch_domain_models__src__router_response_types.rs | pub mod disputes;
pub mod fraud_check;
pub mod merchant_connector_webhook_management;
pub mod revenue_recovery;
pub mod subscriptions;
use std::collections::HashMap;
use api_models::payments::AddressDetails;
use common_utils::{pii, request::Method, types::MinorUnit};
pub use disputes::{
AcceptDisputeResponse, Defe... |
crates__hyperswitch_domain_models__src__type_encryption.rs | use async_trait::async_trait;
use common_utils::{
crypto,
encryption::Encryption,
errors::{CryptoError, CustomResult},
ext_traits::AsyncExt,
metrics::utils::record_operation_time,
types::keymanager::{Identifier, KeyManagerState},
};
use encrypt::TypeEncryption;
use masking::Secret;
use router_en... |
crates__hyperswitch_interfaces__src__api.rs | //! API interface
/// authentication module
pub mod authentication;
/// authentication_v2 module
pub mod authentication_v2;
pub mod disputes;
pub mod disputes_v2;
pub mod files;
pub mod files_v2;
#[cfg(feature = "frm")]
pub mod fraud_check;
#[cfg(feature = "frm")]
pub mod fraud_check_v2;
pub mod gateway;
pub mod merch... |
crates__hyperswitch_interfaces__src__connector_integration_interface.rs | use api_models::webhooks::{IncomingWebhookEvent, ObjectReferenceId};
use common_enums::PaymentAction;
use common_utils::{crypto, errors::CustomResult, request::Request};
use hyperswitch_domain_models::{
api::ApplicationResponse,
connector_endpoints::Connectors,
errors::api_error_response::ApiErrorResponse,
... |
crates__masking__src__serde.rs | //! Serde-related.
pub use erased_serde::Serialize as ErasedSerialize;
pub use serde::{de, Deserialize, Serialize, Serializer};
use serde_json::{value::Serializer as JsonValueSerializer, Value};
use crate::{Secret, Strategy, StrongSecret, ZeroizableSecret};
/// Marker trait for secret types which can be [`Serialize`... |
crates__redis_interface__src__commands.rs | //! An interface to abstract the `fred` commands
//!
//! The folder provides generic functions for providing serialization
//! and deserialization while calling redis.
//! It also includes instruments to provide tracing.
use std::fmt::Debug;
use common_utils::{
errors::CustomResult,
ext_traits::{AsyncExt, Byt... |
crates__router__src__analytics.rs | pub use analytics::*;
pub mod routes {
use std::{
collections::{HashMap, HashSet},
sync::Arc,
};
use actix_web::{web, Responder, Scope};
use analytics::{
api_event::api_events_core, connector_events::connector_events_core, enums::AuthInfo,
errors::AnalyticsError, lambda... |
crates__router__src__compatibility__stripe__payment_intents__types.rs | use std::str::FromStr;
use api_models::payments;
use common_types::payments as common_payments_types;
use common_utils::{
date_time,
ext_traits::StringExt,
id_type,
pii::{IpAddress, SecretSerdeValue, UpiVpaMaskingStrategy},
types::MinorUnit,
};
use error_stack::ResultExt;
use serde::{Deserialize, S... |
crates__router__src__configs__settings.rs | use std::{
collections::{HashMap, HashSet},
path::PathBuf,
sync::Arc,
};
#[cfg(feature = "olap")]
use analytics::{opensearch::OpenSearchConfig, ReportConfig};
use api_models::enums;
use common_enums;
use common_utils::{ext_traits::ConfigExt, id_type, types::user::EmailThemeConfig};
use config::{Environment... |
crates__router__src__connector__utils.rs | use std::{
collections::{HashMap, HashSet},
ops::Deref,
str::FromStr,
sync::LazyLock,
};
#[cfg(feature = "payouts")]
use api_models::payouts::{self, PayoutVendorAccountDetails};
use api_models::{
enums::{CanadaStatesAbbreviation, UsStatesAbbreviation},
payments,
};
use base64::Engine;
use cards... |
crates__router__src__core__customers.rs | use api_models::customers::CustomerDocumentDetails;
#[cfg(feature = "v2")]
use api_models::payment_methods::PaymentMethodId;
use common_types::primitive_wrappers::CustomerListLimit;
use common_utils::{
crypto::Encryptable,
errors::ReportSwitchExt,
ext_traits::AsyncExt,
id_type, pii, type_name,
types... |
crates__router__src__core__payment_methods__transformers.rs | pub use ::payment_methods::controller::{DataDuplicationCheck, DeleteCardResp};
use api_models::payment_methods::Card;
#[cfg(feature = "v2")]
use api_models::{enums as api_enums, payment_methods::PaymentMethodResponseItem};
use common_enums::CardNetwork;
#[cfg(feature = "v1")]
use common_utils::{crypto::Encryptable, req... |
crates__router__src__core__payment_methods__vault.rs | use common_enums::PaymentMethodType;
#[cfg(feature = "v2")]
use common_utils::encryption::Encryption;
use common_utils::{
crypto::{DecodeMessage, EncodeMessage, GcmAes256},
ext_traits::{BytesExt, Encode},
generate_id_with_default_len, id_type,
pii::Email,
request,
};
use error_stack::{report, Result... |
crates__router__src__core__payments__flows__authorize_flow.rs | use std::str::FromStr;
use async_trait::async_trait;
use common_enums as enums;
use common_types::payments as common_payments_types;
#[cfg(feature = "v2")]
use common_utils::types::MinorUnit;
use common_utils::{errors, ext_traits::ValueExt, id_type, ucs_types};
use error_stack::ResultExt;
use external_services::grpc_c... |
crates__router__src__core__payments__operations.rs | #[cfg(feature = "v1")]
pub mod payment_approve;
#[cfg(feature = "v1")]
pub mod payment_cancel;
#[cfg(feature = "v1")]
pub mod payment_cancel_post_capture;
#[cfg(feature = "v1")]
pub mod payment_capture;
#[cfg(feature = "v1")]
pub mod payment_complete_authorize;
#[cfg(feature = "v1")]
pub mod payment_confirm;
#[cfg(feat... |
crates__router__src__core__payments__operations__payment_response.rs | use std::{collections::HashMap, ops::Deref};
#[cfg(feature = "v1")]
use ::payment_methods::client::{
CardDetailUpdate, PaymentMethodUpdateData, UpdatePaymentMethodV1Payload,
};
use api_models::payments::{ConnectorMandateReferenceId, MandateReferenceId};
#[cfg(feature = "dynamic_routing")]
use api_models::routing::... |
crates__router__src__core__payments__routing.rs | mod transformers;
pub mod utils;
#[cfg(all(feature = "v1", feature = "dynamic_routing"))]
use std::collections::hash_map;
#[cfg(all(feature = "v1", feature = "dynamic_routing"))]
use std::hash::{Hash, Hasher};
use std::{collections::HashMap, str::FromStr, sync::Arc};
#[cfg(feature = "v1")]
use api_models::open_router:... |
crates__router__src__core__payments__routing__utils.rs | use std::{
collections::{HashMap, HashSet},
str::FromStr,
sync::LazyLock,
};
use api_models::{
open_router as or_types,
routing::{
self as api_routing, ComparisonType, ConnectorSelection, ConnectorVolumeSplit,
DeRoutableConnectorChoice, MetadataValue, NumberComparison, RoutableConne... |
crates__router__src__core__payouts.rs | #[cfg(feature = "olap")]
use strum::IntoEnumIterator;
pub mod access_token;
pub mod helpers;
#[cfg(feature = "payout_retry")]
pub mod retry;
pub mod transformers;
pub mod validator;
use std::{
collections::{HashMap, HashSet},
vec::IntoIter,
};
use api_models::{self, enums as api_enums, payouts::PayoutLinkRespo... |
crates__router__src__core__relay.rs | use std::marker::PhantomData;
use api_models::relay as relay_api_models;
use async_trait::async_trait;
use common_enums::RelayStatus;
use common_utils::{
self, fp_utils,
id_type::{self, GenerateId},
};
use error_stack::ResultExt;
use hyperswitch_domain_models::relay;
use super::errors::{self, ConnectorErrorEx... |
crates__router__src__core__routing.rs | pub mod helpers;
pub mod transformers;
use std::collections::HashSet;
#[cfg(all(feature = "v1", feature = "dynamic_routing"))]
use api_models::routing::DynamicRoutingAlgoAccessor;
use api_models::{
enums, mandates as mandates_api,
open_router::{
DecideGatewayResponse, OpenRouterDecideGatewayRequest, Up... |
crates__router__src__core__routing__helpers.rs | //! Analysis for usage of all helper functions for use case of routing
//!
//! Functions that are used to perform the retrieval of merchant's
//! routing dict, configs, defaults
use std::fmt::Debug;
#[cfg(all(feature = "dynamic_routing", feature = "v1"))]
use std::str::FromStr;
#[cfg(all(feature = "dynamic_routing", fe... |
crates__router__src__core__unified_authentication_service.rs | pub mod types;
use std::str::FromStr;
use common_utils::ext_traits::StringExt;
pub mod utils;
#[cfg(feature = "v1")]
use api_models::authentication::{
AuthenticationEligibilityCheckData, AuthenticationEligibilityCheckRequest,
AuthenticationEligibilityCheckResponse, AuthenticationEligibilityCheckResponseData,
... |
crates__router__src__core__unified_connector_service.rs | use std::{borrow::Cow, str::FromStr, time::Instant};
use api_models::admin;
#[cfg(feature = "v2")]
use base64::Engine;
use common_enums::{
connector_enums::Connector, AttemptStatus, CallConnectorAction, ConnectorIntegrationType,
ExecutionMode, ExecutionPath, GatewaySystem, PaymentMethodType, UcsAvailability,
}... |
crates__router__src__core__user.rs | use std::{
collections::{HashMap, HashSet},
ops::Not,
};
use api_models::{
payments::RedirectionResponse,
user::{self as user_api, InviteMultipleUserResponse, NameIdUnit},
};
use common_enums::{connector_enums, EntityType, UserAuthType};
use common_utils::{
fp_utils, type_name,
types::{keymanag... |
crates__router__src__core__utils.rs | pub mod refunds_transformers;
pub mod refunds_validator;
use std::{collections::HashSet, marker::PhantomData, str::FromStr};
use api_models::enums::{Connector, DisputeStage, DisputeStatus};
#[cfg(feature = "payouts")]
use api_models::payouts::PayoutVendorAccountDetails;
use common_enums::{IntentStatus, RequestIncreme... |
crates__router__src__core__webhooks__incoming.rs | use std::{str::FromStr, time::Instant};
use actix_web::FromRequest;
#[cfg(feature = "payouts")]
use api_models::payouts as payout_models;
use api_models::{
enums::Connector,
webhooks::{self, WebhookResponseTracker},
};
pub use common_enums::{connector_enums::InvoiceStatus, enums::ProcessTrackerRunner};
use com... |
crates__router__src__core__webhooks__recovery_incoming.rs | use std::{collections::HashMap, marker::PhantomData, str::FromStr};
use api_models::{enums as api_enums, payments as api_payments, webhooks};
use common_utils::{
ext_traits::{AsyncExt, ValueExt},
id_type,
};
use diesel_models::process_tracker as storage;
use error_stack::{report, ResultExt};
use futures::strea... |
crates__router__src__db.rs | pub mod address;
pub mod api_keys;
pub mod authentication;
pub mod authorization;
pub mod blocklist;
pub mod blocklist_fingerprint;
pub mod blocklist_lookup;
pub mod business_profile;
pub mod callback_mapper;
pub mod capture;
pub mod configs;
pub mod customers;
pub mod dashboard_metadata;
pub mod dispute;
pub mod dynam... |
crates__router__src__db__events.rs | use std::collections::HashSet;
use common_utils::ext_traits::AsyncExt;
use error_stack::{report, ResultExt};
use futures::future::try_join_all;
use router_env::{instrument, tracing};
use super::{MockDb, Store};
use crate::{
connection,
core::errors::{self, CustomResult},
types::{
domain::{
... |
crates__router__src__db__refund.rs | #[cfg(feature = "olap")]
use std::collections::{HashMap, HashSet};
#[cfg(feature = "olap")]
use common_utils::types::{ConnectorTransactionIdTrait, MinorUnit};
use diesel_models::{errors::DatabaseError, refund as diesel_refund};
use hyperswitch_domain_models::refunds;
use super::MockDb;
use crate::{
core::errors::... |
crates__router__src__routes__app.rs | use std::{collections::HashMap, sync::Arc};
use actix_web::{web, Scope};
#[cfg(all(feature = "olap", feature = "v1"))]
use api_models::routing::RoutingRetrieveQuery;
use api_models::routing::RuleMigrationQuery;
#[cfg(feature = "olap")]
use common_enums::{ExecutionMode, TransactionType};
#[cfg(feature = "partial-auth")... |
crates__router__src__routes__dummy_connector__types.rs | use api_models::enums::Currency;
use common_utils::{errors::CustomResult, generate_id_with_default_len, pii};
use error_stack::report;
use masking::Secret;
use router_env::types::FlowMetric;
use strum::Display;
use time::PrimitiveDateTime;
use super::{consts, errors::DummyConnectorErrors};
use crate::services;
#[deri... |
crates__router__src__routes__payment_methods.rs | #[cfg(all(feature = "v1", any(feature = "olap", feature = "oltp")))]
use std::collections::HashMap;
use ::payment_methods::{
controller::PaymentMethodsController,
core::{migration, migration::payment_methods::migrate_payment_method},
};
#[cfg(all(feature = "v1", any(feature = "olap", feature = "oltp")))]
use a... |
crates__router__src__routes__payments.rs | use crate::{
core::api_locking::{self, GetLockingInput},
services::authorization::permissions::Permission,
};
pub mod helpers;
use actix_web::{web, Responder};
use error_stack::report;
use hyperswitch_domain_models::{ext_traits::OptionExt, payments::HeaderPayload};
use masking::{PeekInterface, Secret};
use rout... |
crates__router__src__routes__user.rs | pub mod theme;
use actix_web::{web, HttpRequest, HttpResponse};
#[cfg(feature = "dummy_connector")]
use api_models::user::sample_data::SampleDataRequest;
use api_models::{
errors::types::ApiErrorResponse,
user::{self as user_api},
};
use common_enums::TokenPurpose;
use common_utils::errors::ReportSwitchExt;
us... |
crates__router__src__services__api.rs | pub mod client;
pub mod generic_link_response;
pub mod request;
use std::{
collections::{HashMap, HashSet},
fmt::Debug,
future::Future,
str,
sync::Arc,
time::{Duration, Instant},
};
use actix_http::header::HeaderMap;
use actix_web::{
body,
http::header::{HeaderName, HeaderValue},
we... |
crates__router__src__types.rs | // FIXME: Why were these data types grouped this way?
//
// Folder `types` is strange for Rust ecosystem, nevertheless it might be okay.
// But folder `enum` is even more strange I unlikely okay. Why should not we introduce folders `type`, `structs` and `traits`? :)
// Is it better to split data types according to busi... |
crates__router__src__types__payment_methods.rs | use std::fmt::Debug;
use api_models::enums as api_enums;
use cards::{CardNumber, NetworkToken};
#[cfg(feature = "v2")]
use common_types::primitive_wrappers;
#[cfg(feature = "v2")]
use common_utils::generate_id;
use common_utils::id_type;
#[cfg(feature = "v2")]
use hyperswitch_domain_models::payment_method_data::Networ... |
crates__router__src__types__storage__revenue_recovery_redis_operation.rs | use std::collections::HashMap;
use api_models::revenue_recovery_data_backfill::{self, AccountUpdateHistoryRecord, RedisKeyType};
use common_enums::enums::CardNetwork;
use common_utils::{date_time, errors::CustomResult, id_type};
use error_stack::ResultExt;
use masking::{ExposeInterface, PeekInterface, Secret};
use red... |
crates__router__src__types__transformers.rs | use actix_web::http::header::HeaderMap;
use api_models::{
cards_info as card_info_types, enums as api_enums, gsm as gsm_api_types, payment_methods,
payments, routing::ConnectorSelection,
};
use common_utils::{
consts::X_HS_LATENCY,
crypto::Encryptable,
ext_traits::{Encode, StringExt, ValueExt},
... |
crates__storage_impl__src__lib.rs | use std::{fmt::Debug, sync::Arc};
use common_utils::types::TenantConfig;
use diesel_models as store;
use error_stack::ResultExt;
use hyperswitch_domain_models::{
behaviour::{Conversion, ReverseConversion},
merchant_key_store::MerchantKeyStore,
};
use masking::StrongSecret;
use redis::{kv_store::RedisConnInterf... |
crates__storage_impl__src__payment_method.rs | pub use diesel_models::payment_method::PaymentMethod;
use crate::redis::kv_store::KvStorePartition;
impl KvStorePartition for PaymentMethod {}
#[cfg(feature = "v1")]
use std::collections::HashSet;
use common_enums::enums::MerchantStorageScheme;
use common_utils::{errors::CustomResult, id_type};
#[cfg(feature = "v1"... |
crates__storage_impl__src__payments__payment_attempt.rs | use common_utils::{errors::CustomResult, ext_traits::AsyncExt};
#[cfg(feature = "v1")]
use common_utils::{fallback_reverse_lookup_not_found, types::ConnectorTransactionId};
use diesel_models::{
enums::{
MandateAmountData as DieselMandateAmountData, MandateDataType as DieselMandateType,
MandateDetail... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.