text stringlengths 70 351k | source stringclasses 4
values |
|---|---|
<|fim_prefix|>
// file: hyperswitch/crates/router/src/routes/disputes.rs | crate: router
use actix_web::{web, HttpRequest, HttpResponse};
use api_models::disputes as dispute_models;
use router_env::{instrument, tracing, Flow};
use crate::{core::api_locking, services::authorization::permissions::Permission};
use super::app::AppState;
use crate::{
core::disputes,
services::{api, authentication as auth},
types::api::disputes as dispute_types,
};
pub async fn retrieve_dispute_evidence(
state: web::Data<AppState>,
req: HttpRequest,
path: web::Path<String>,
) -> HttpResponse {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/routes/disputes.rs | crate: router
use actix_multipart::Multipart;
use actix_web::{web, HttpRequest, HttpResponse};
use api_models::disputes as dispute_models;
use router_env::{instrument, tracing, Flow};
use crate::{core::api_locking, services::authorization::permissions::Permission};
use super::app::AppState;
use crate::{
core::disputes,
services::{api, authentication as auth},
types::api::disputes as dispute_types,
};
pub async fn attach_dispute_evidence(
state: web::Data<AppState>,
req: HttpRequest,
payload: Multipart,
) -> HttpResponse {
{
Ok(valid_request) => valid_request,<|fim_suffix|>
<|fim_middle|>
Err(err) => return api::log_and_return_error_response(err),
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/routes/disputes.rs | crate: router
use actix_web::{web, HttpRequest, HttpResponse};
use api_models::disputes as dispute_models;
use router_env::{instrument, tracing, Flow};
use crate::{core::api_locking, services::authorization::permissions::Permission};
use super::app::AppState;
use crate::{
core::disputes,
services::{api, authentication as auth},
types::api::disputes as dispute_types,
};
pub async fn submit_dispute_evidence(
state: web::Data<AppState>,
req: HttpRequest,
json_payload: web::Json<dispute_models::SubmitEvidenceRequest>,
) -> HttpResponse {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/routes/disputes.rs | crate: router
use actix_web::{web, HttpRequest, HttpResponse};
use api_models::disputes as dispute_models;
use router_env::{instrument, tracing, Flow};
use crate::{core::api_locking, services::authorization::permissions::Permission};
use super::app::AppState;
use crate::{
core::disputes,
services::{api, authentication as auth},
types::api::disputes as dispute_types,
};
pub async fn accept_dispute(
state: web::Data<AppState>,
req: HttpRequest,
path: web::Path<String>,
) -> HttpResponse {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/routes/disputes.rs | crate: router
use actix_web::{web, HttpRequest, HttpResponse};
use api_models::disputes as dispute_models;
use router_env::{instrument, tracing, Flow};
use crate::{core::api_locking, services::authorization::permissions::Permission};
use super::app::AppState;
use crate::{
core::disputes,
services::{api, authentication as auth},
types::api::disputes as dispute_types,
};
pub async fn get_disputes_filters_profile(
state: web::Data<AppState>,
req: HttpRequest,
) -> HttpResponse {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/routes/disputes.rs | crate: router
use actix_web::{web, HttpRequest, HttpResponse};
use api_models::disputes as dispute_models;
use router_env::{instrument, tracing, Flow};
use crate::{core::api_locking, services::authorization::permissions::Permission};
use super::app::AppState;
use crate::{
core::disputes,
services::{api, authentication as auth},
types::api::disputes as dispute_types,
};
pub async fn retrieve_disputes_list_profile(
state: web::Data<AppState>,
req: HttpRequest,
payload: web::Query<dispute_models::DisputeListGetConstraints>,
) -> HttpResponse {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/routes/disputes.rs | crate: router
use actix_web::{web, HttpRequest, HttpResponse};
use api_models::disputes as dispute_models;
use router_env::{instrument, tracing, Flow};
use crate::{core::api_locking, services::authorization::permissions::Permission};
use super::app::AppState;
use crate::{
core::disputes,
services::{api, authentication as auth},
types::api::disputes as dispute_types,
};
pub async fn retrieve_disputes_list(
state: web::Data<AppState>,
req: HttpRequest,
query: web::Query<dispute_models::DisputeListGetConstraints>,
) -> HttpResponse {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/routes/disputes.rs | crate: router
use actix_web::{web, HttpRequest, HttpResponse};
use api_models::disputes as dispute_models;
use router_env::{instrument, tracing, Flow};
use crate::{core::api_locking, services::authorization::permissions::Permission};
use super::app::AppState;
use crate::{
core::disputes,
services::{api, authentication as auth},
types::api::disputes as dispute_types,
};
pub async fn retrieve_dispute(
state: web::Data<AppState>,
req: HttpRequest,
path: web::Path<String>,
) -> HttpResponse {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/routes/disputes.rs | crate: router
use actix_web::{web, HttpRequest, HttpResponse};
use api_models::disputes as dispute_models;
use router_env::{instrument, tracing, Flow};
use crate::{core::api_locking, services::authorization::permissions::Permission};
use super::app::AppState;
use crate::{
core::disputes,
services::{api, authentication as auth},
types::api::disputes as dispute_types,
};
pub async fn delete_dispute_evidence(
state: web::Data<AppState>,
req: HttpRequest,
json_payload: web::Json<dispute_models::DeleteEvidenceRequest>,
) -> HttpResponse {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/routes/disputes.rs | crate: router
use actix_web::{web, HttpRequest, HttpResponse};
use api_models::disputes as dispute_models;
use router_env::{instrument, tracing, Flow};
use crate::{core::api_locking, services::authorization::permissions::Permission};
use super::app::AppState;
use crate::{
core::disputes,
services::{api, authentication as auth},
types::api::disputes as dispute_types,
};
pub async fn get_disputes_filters(state: web::Data<AppState>, req: HttpRequest) -> HttpResponse {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/routes/verify_connector.rs | crate: router
use actix_web::{web, HttpRequest, HttpResponse};
use api_models::verify_connector::VerifyConnectorRequest;
use router_env::{instrument, tracing, Flow};
use super::AppState;
use crate::{
core::{api_locking, verify_connector},
services::{self, authentication as auth, authorization::permissions::Permission},
};
pub async fn payment_connector_verify(
state: web::Data<AppState>,
req: HttpRequest,
json_payload: web::Json<VerifyConnectorRequest>,
) -> HttpResponse {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/routes/recon.rs | crate: router
use actix_web::{web, HttpRequest, HttpResponse};
use api_models::recon as recon_api;
use router_env::Flow;
use super::AppState;
use crate::{
core::{api_locking, recon},
services::{api, authentication, authorization::permissions::Permission},
};
pub async fn verify_recon_token(state: web::Data<AppState>, http_req: HttpRequest) -> HttpResponse {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/routes/recon.rs | crate: router
use actix_web::{web, HttpRequest, HttpResponse};
use api_models::recon as recon_api;
use router_env::Flow;
use super::AppState;
use crate::{
core::{api_locking, recon},
services::{api, authentication, authorization::permissions::Permission},
};
pub async fn get_recon_token(state: web::Data<AppState>, req: HttpRequest) -> HttpResponse {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/routes/recon.rs | crate: router
use actix_web::{web, HttpRequest, HttpResponse};
use api_models::recon as recon_api;
use router_env::Flow;
use super::AppState;
use crate::{
core::{api_locking, recon},
services::{api, authentication, authorization::permissions::Permission},
};
pub async fn request_for_recon(state: web::Data<AppState>, http_req: HttpRequest) -> HttpResponse {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/routes/recon.rs | crate: router
use actix_web::{web, HttpRequest, HttpResponse};
use api_models::recon as recon_api;
use router_env::Flow;
use super::AppState;
use crate::{
core::{api_locking, recon},
services::{api, authentication, authorization::permissions::Permission},
};
pub async fn update_merchant(
state: web::Data<AppState>,
req: HttpRequest,
path: web::Path<common_utils::id_type::MerchantId>,
json_payload: web::Json<recon_api::ReconUpdateMerchantRequest>,
) -> HttpResponse {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/routes/poll.rs | crate: router
use actix_web::{web, HttpRequest, HttpResponse};
use router_env::{instrument, tracing, Flow};
use super::app::AppState;
use crate::{
core::{api_locking, poll},
services::{api, authentication as auth},
types::api::PollId,
};
pub async fn retrieve_poll_status(
state: web::Data<AppState>,
req: HttpRequest,
path: web::Path<String>,
) -> HttpResponse {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/routes/gsm.rs | crate: router
use actix_web::{web, HttpRequest, Responder};
use api_models::gsm as gsm_api_types;
use router_env::{instrument, tracing, Flow};
use super::app::AppState;
use crate::{
core::{api_locking, gsm},
services::{api, authentication as auth},
};
pub async fn delete_gsm_rule(
state: web::Data<AppState>,
req: HttpRequest,
json_payload: web::Json<gsm_api_types::GsmDeleteRequest>,
) -> impl Responder {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/routes/gsm.rs | crate: router
use actix_web::{web, HttpRequest, Responder};
use api_models::gsm as gsm_api_types;
use router_env::{instrument, tracing, Flow};
use super::app::AppState;
use crate::{
core::{api_locking, gsm},
services::{api, authentication as auth},
};
pub async fn update_gsm_rule(
state: web::Data<AppState>,
req: HttpRequest,
json_payload: web::Json<gsm_api_types::GsmUpdateRequest>,
) -> impl Responder {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/routes/gsm.rs | crate: router
use actix_web::{web, HttpRequest, Responder};
use api_models::gsm as gsm_api_types;
use router_env::{instrument, tracing, Flow};
use super::app::AppState;
use crate::{
core::{api_locking, gsm},
services::{api, authentication as auth},
};
pub async fn get_gsm_rule(
state: web::Data<AppState>,
req: HttpRequest,
json_payload: web::Json<gsm_api_types::GsmRetrieveRequest>,
) -> impl Responder {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/routes/gsm.rs | crate: router
use actix_web::{web, HttpRequest, Responder};
use api_models::gsm as gsm_api_types;
use router_env::{instrument, tracing, Flow};
use super::app::AppState;
use crate::{
core::{api_locking, gsm},
services::{api, authentication as auth},
};
pub async fn create_gsm_rule(
state: web::Data<AppState>,
req: HttpRequest,
json_payload: web::Json<gsm_api_types::GsmCreateRequest>,
) -> impl Responder {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/routes/mandates.rs | crate: router
use actix_web::{web, HttpRequest, HttpResponse};
use router_env::{instrument, tracing, Flow};
use super::app::AppState;
use crate::{
core::{api_locking, mandate},
services::{api, authentication as auth, authorization::permissions::Permission},
types::api::mandates,
};
pub async fn retrieve_mandates_list(
state: web::Data<AppState>,
req: HttpRequest,
payload: web::Query<api_models::mandates::MandateListConstraints>,
) -> HttpResponse {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/routes/mandates.rs | crate: router
use actix_web::{web, HttpRequest, HttpResponse};
use router_env::{instrument, tracing, Flow};
use super::app::AppState;
use crate::{
core::{api_locking, mandate},
services::{api, authentication as auth, authorization::permissions::Permission},
types::api::mandates,
};
pub async fn revoke_mandate(
state: web::Data<AppState>,
req: HttpRequest,
path: web::Path<String>,
) -> HttpResponse {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/routes/mandates.rs | crate: router
use actix_web::{web, HttpRequest, HttpResponse};
use router_env::{instrument, tracing, Flow};
use super::app::AppState;
use crate::{
core::{api_locking, mandate},
services::{api, authentication as auth, authorization::permissions::Permission},
types::api::mandates,
};
pub async fn get_mandate(
state: web::Data<AppState>,
req: HttpRequest,
path: web::Path<String>,
) -> HttpResponse {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/routes/feature_matrix.rs | crate: router
use api_models::{connector_enums::Connector, feature_matrix};
use common_enums::enums;
use hyperswitch_domain_models::{
api::ApplicationResponse, router_response_types::PaymentMethodTypeMetadata,
};
use crate::{
self as app,
core::{api_locking::LockAction, errors::RouterResponse},
services::{api, authentication as auth, connector_integration_interface::ConnectorEnum},
settings,
types::api::{self as api_types, payments as payment_types},
};
fn build_payment_method_wise_feature_details(
state: &app::SessionState,
connector_name: &str,
payment_method: enums::PaymentMethod,
supported_payment_method_types: &PaymentMethodTypeMetadata,
) -> Vec<feature_matrix::SupportedPaymentMethod> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/routes/feature_matrix.rs | crate: router
use api_models::{connector_enums::Connector, feature_matrix};
use crate::{
self as app,
core::{api_locking::LockAction, errors::RouterResponse},
services::{api, authentication as auth, connector_integration_interface::ConnectorEnum},
settings,
types::api::{self as api_types, payments as payment_types},
};
fn build_connector_feature_details(
state: &app::SessionState,
connector: ConnectorEnum,
connector_name: String,
) -> Option<feature_matrix::ConnectorFeatureMatrixResponse> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/routes/feature_matrix.rs | crate: router
use api_models::{connector_enums::Connector, feature_matrix};
use hyperswitch_domain_models::{
api::ApplicationResponse, router_response_types::PaymentMethodTypeMetadata,
};
use router_env::{instrument, tracing, Flow};
use crate::{
self as app,
core::{api_locking::LockAction, errors::RouterResponse},
services::{api, authentication as auth, connector_integration_interface::ConnectorEnum},
settings,
types::api::{self as api_types, payments as payment_types},
};
pub async fn generate_feature_matrix(
state: app::SessionState,
req: payment_types::FeatureMatrixRequest,
) -> RouterResponse<feature_matrix::FeatureMatrixListResponse> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/routes/feature_matrix.rs | crate: router
use actix_web::{web, HttpRequest, Responder};
use hyperswitch_domain_models::{
api::ApplicationResponse, router_response_types::PaymentMethodTypeMetadata,
};
use hyperswitch_interfaces::api::ConnectorSpecifications;
use router_env::{instrument, tracing, Flow};
use crate::{
self as app,
core::{api_locking::LockAction, errors::RouterResponse},
services::{api, authentication as auth, connector_integration_interface::ConnectorEnum},
settings,
types::api::{self as api_types, payments as payment_types},
};
pub async fn fetch_feature_matrix(
state: web::Data<app::AppState>,
req: HttpRequest,
json_payload: Option<web::Json<payment_types::FeatureMatrixRequest>>,
) -> impl Responder {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/routes/apple_pay_certificates_migration.rs | crate: router
use actix_web::{web, HttpRequest, HttpResponse};
use router_env::Flow;
use super::AppState;
use crate::{
core::{api_locking, apple_pay_certificates_migration},
services::{api, authentication as auth},
};
pub async fn apple_pay_certificates_migration(
state: web::Data<AppState>,
req: HttpRequest,
json_payload: web::Json<
api_models::apple_pay_certificates_migration::ApplePayCertificatesMigrationRequest,
>,
) -> HttpResponse {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/routes/connector_onboarding.rs | crate: router
use actix_web::{web, HttpRequest, HttpResponse};
use api_models::connector_onboarding as api_types;
use router_env::Flow;
use super::AppState;
use crate::{
core::{api_locking, connector_onboarding as core},
services::{api, authentication as auth, authorization::permissions::Permission},
};
pub async fn reset_tracking_id(
state: web::Data<AppState>,
http_req: HttpRequest,
json_payload: web::Json<api_types::ResetTrackingIdRequest>,
) -> HttpResponse {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/routes/connector_onboarding.rs | crate: router
use actix_web::{web, HttpRequest, HttpResponse};
use api_models::connector_onboarding as api_types;
use router_env::Flow;
use super::AppState;
use crate::{
core::{api_locking, connector_onboarding as core},
services::{api, authentication as auth, authorization::permissions::Permission},
};
pub async fn sync_onboarding_status(
state: web::Data<AppState>,
http_req: HttpRequest,
json_payload: web::Json<api_types::OnboardingSyncRequest>,
) -> HttpResponse {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/routes/connector_onboarding.rs | crate: router
use actix_web::{web, HttpRequest, HttpResponse};
use api_models::connector_onboarding as api_types;
use router_env::Flow;
use super::AppState;
use crate::{
core::{api_locking, connector_onboarding as core},
services::{api, authentication as auth, authorization::permissions::Permission},
};
pub async fn get_action_url(
state: web::Data<AppState>,
http_req: HttpRequest,
json_payload: web::Json<api_types::ActionUrlRequest>,
) -> HttpResponse {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/routes/metrics/request.rs | crate: router
use crate::services::ApplicationResponse;
pub fn track_response_status_code<Q>(response: &ApplicationResponse<Q>) -> i64 {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/routes/metrics/request.rs | crate: router
use super::utils as metric_utils;
pub fn status_code_metrics(
status_code: String,
flow: String,
merchant_id: common_utils::id_type::MerchantId,
) {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/routes/metrics/request.rs | crate: router
use super::utils as metric_utils;
pub async fn record_request_time_metric<F, R>(
future: F,
flow: &impl router_env::types::FlowMetric,
) -> R
where
F: futures::Future<Output = R>,
{
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/routes/user/theme.rs | crate: router
use actix_multipart::form::MultipartForm;
use actix_web::{web, HttpRequest, HttpResponse};
use api_models::user::theme as theme_api;
use common_utils::types::theme::ThemeLineage;
use masking::Secret;
use router_env::Flow;
use crate::{
core::{api_locking, user::theme as theme_core},
routes::AppState,
services::{api, authentication as auth},
};
pub async fn upload_file_to_theme_storage(
state: web::Data<AppState>,
req: HttpRequest,
path: web::Path<String>,
MultipartForm(payload): MultipartForm<theme_api::UploadFileAssetData>,
query: web::Query<ThemeLineage>,
) -> HttpResponse {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/routes/user/theme.rs | crate: router
use actix_web::{web, HttpRequest, HttpResponse};
use common_utils::types::theme::ThemeLineage;
use router_env::Flow;
use crate::{
core::{api_locking, user::theme as theme_core},
routes::AppState,
services::{api, authentication as auth},
};
pub async fn delete_theme(
state: web::Data<AppState>,
req: HttpRequest,
path: web::Path<String>,
query: web::Query<ThemeLineage>,
) -> HttpResponse {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/routes/user/theme.rs | crate: router
use actix_web::{web, HttpRequest, HttpResponse};
use api_models::user::theme as theme_api;
use router_env::Flow;
use crate::{
core::{api_locking, user::theme as theme_core},
routes::AppState,
services::{api, authentication as auth},
};
pub async fn update_theme(
state: web::Data<AppState>,
req: HttpRequest,
path: web::Path<String>,
payload: web::Json<theme_api::UpdateThemeRequest>,
) -> HttpResponse {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/routes/user/theme.rs | crate: router
use actix_web::{web, HttpRequest, HttpResponse};
use api_models::user::theme as theme_api;
use router_env::Flow;
use crate::{
core::{api_locking, user::theme as theme_core},
routes::AppState,
services::{api, authentication as auth},
};
pub async fn create_theme(
state: web::Data<AppState>,
req: HttpRequest,
payload: web::Json<theme_api::CreateThemeRequest>,
) -> HttpResponse {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/routes/user/theme.rs | crate: router
use actix_web::{web, HttpRequest, HttpResponse};
use router_env::Flow;
use crate::{
core::{api_locking, user::theme as theme_core},
routes::AppState,
services::{api, authentication as auth},
};
pub async fn get_theme_using_theme_id(
state: web::Data<AppState>,
req: HttpRequest,
path: web::Path<String>,
) -> HttpResponse {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/routes/user/theme.rs | crate: router
use actix_web::{web, HttpRequest, HttpResponse};
use common_utils::types::theme::ThemeLineage;
use router_env::Flow;
use crate::{
core::{api_locking, user::theme as theme_core},
routes::AppState,
services::{api, authentication as auth},
};
pub async fn get_theme_using_lineage(
state: web::Data<AppState>,
req: HttpRequest,
query: web::Query<ThemeLineage>,
) -> HttpResponse {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/services/jwt.rs | crate: router
use common_utils::errors::CustomResult;
use jsonwebtoken::{encode, EncodingKey, Header};
use crate::{configs::Settings, core::errors::UserErrors};
pub async fn generate_jwt<T>(
claims_data: &T,
settings: &Settings,
) -> CustomResult<String, UserErrors>
where
T: serde::ser::Serialize,
{
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/services/jwt.rs | crate: router
use common_utils::errors::CustomResult;
use crate::{configs::Settings, core::errors::UserErrors};
pub fn generate_exp(
exp_duration: std::time::Duration,
) -> CustomResult<std::time::Duration, UserErrors> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/services/card_testing_guard.rs | crate: router
use crate::{
core::errors::{ApiErrorResponse, RouterResult},
routes::app::SessionStateInfo,
};
pub async fn increment_blocked_count_in_cache<A>(
state: &A,
cache_key: &str,
expiry: i64,
) -> RouterResult<()>
where
A: SessionStateInfo + Sync,
{
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/services/card_testing_guard.rs | crate: router
use crate::{
core::errors::{ApiErrorResponse, RouterResult},
routes::app::SessionStateInfo,
};
pub async fn get_blocked_count_from_cache<A>(
state: &A,
cache_key: &str,
) -> RouterResult<Option<i32>>
where
A: SessionStateInfo + Sync,
{
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/services/card_testing_guard.rs | crate: router
use crate::{
core::errors::{ApiErrorResponse, RouterResult},
routes::app::SessionStateInfo,
};
pub async fn set_blocked_count_in_cache<A>(
state: &A,
cache_key: &str,
value: i32,
expiry: i64,
) -> RouterResult<()>
where
A: SessionStateInfo + Sync,
{
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/services/authorization.rs | crate: router
use common_utils::id_type;
use router_env::logger;
use super::authentication::AuthToken;
use crate::{
consts,
core::errors::{ApiErrorResponse, RouterResult, StorageErrorExt},
routes::app::SessionStateInfo,
};
pub async fn get_role_info<A>(state: &A, token: &AuthToken) -> RouterResult<roles::RoleInfo>
where
A: SessionStateInfo + Sync,
{
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/services/authorization.rs | crate: router
use common_utils::id_type;
use crate::{
consts,
core::errors::{ApiErrorResponse, RouterResult, StorageErrorExt},
routes::app::SessionStateInfo,
};
pub fn check_tenant(
token_tenant_id: Option<id_type::TenantId>,
header_tenant_id: &id_type::TenantId,
) -> RouterResult<()> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/services/authorization.rs | crate: router
use crate::{
consts,
core::errors::{ApiErrorResponse, RouterResult, StorageErrorExt},
routes::app::SessionStateInfo,
};
pub fn check_permission(
required_permission: permissions::Permission,
role_info: &roles::RoleInfo,
) -> RouterResult<()> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/services/authorization.rs | crate: router
use crate::{
consts,
core::errors::{ApiErrorResponse, RouterResult, StorageErrorExt},
routes::app::SessionStateInfo,
};
pub async fn set_role_info_in_cache<A>(
state: &A,
role_id: &str,
role_info: &roles::RoleInfo,
expiry: i64,
) -> RouterResult<()>
where
A: SessionStateInfo + Sync,
{
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/services/authorization.rs | crate: router
use common_utils::id_type;
use crate::{
consts,
core::errors::{ApiErrorResponse, RouterResult, StorageErrorExt},
routes::app::SessionStateInfo,
};
async fn get_role_info_from_db<A>(
state: &A,
role_id: &str,
org_id: &id_type::OrganizationId,
tenant_id: &id_type::TenantId,
) -> RouterResult<roles::RoleInfo>
where
A: SessionStateInfo + Sync,
{
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/services/authorization.rs | crate: router
use crate::{
consts,
core::errors::{ApiErrorResponse, RouterResult, StorageErrorExt},
routes::app::SessionStateInfo,
};
pub fn get_cache_key_from_role_id(role_id: &str) -> String {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/services/authorization.rs | crate: router
use crate::{
consts,
core::errors::{ApiErrorResponse, RouterResult, StorageErrorExt},
routes::app::SessionStateInfo,
};
async fn get_role_info_from_cache<A>(state: &A, role_id: &str) -> RouterResult<roles::RoleInfo>
where
A: SessionStateInfo + Sync,
{
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/services/kafka/refund_event.rs | crate: router
use diesel_models::{enums as storage_enums, refund::Refund};
pub fn from_storage(refund: &'a Refund) -> Self {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
// file: hyperswitch/crates/router/src/services/kafka/refund_event.rs | crate: router
fn key(&self) -> String {
format!(
"{}_{}_{}_{}",
self.merchant_id.get_string_repr(),
self.payment_id.get_string_repr(),
self.attempt_id.get_string_repr(),
self.merchant_reference_id.get_string_repr()
)
} | ast_fragments |
// file: hyperswitch/crates/router/src/services/kafka/dispute.rs | crate: router
use crate::types::storage::dispute::Dispute;
pub fn from_storage(dispute: &'a Dispute) -> Self {
Self {
dispute_id: &dispute.dispute_id,
dispute_amount: dispute.amount.parse::<i64>().unwrap_or_default(),
currency: dispute.dispute_currency.unwrap_or(
dispute
.currency
.to_uppercase()
.parse_enum("Currency")
.unwrap_or_default(),
),
dispute_stage: &dispute.dispute_stage,
dispute_status: &dispute.dispute_status,
payment_id: &dispute.payment_id,
attempt_id: &dispute.attempt_id,
merchant_id: &dispute.merchant_id,
connector_status: &dispute.connector_status,
connector_dispute_id: &dispute.connector_dispute_id,
connector_reason: dispute.connector_reason.as_ref(),
connector_reason_code: dispute.connector_reason_code.as_ref(),
challenge_required_by: dispute.challenge_required_by.map(|i| i.assume_utc()),
connector_created_at: dispute.connector_created_at.map(|i| i.assume_utc()),
connector_updated_at: dispute.connector_updated_at.map(|i| i.assume_utc()),
created_at: dispute.created_at.assume_utc(),
modified_at: dispute.modified_at.assume_utc(),
connector: &dispute.connector,
evidence: &dispute.evidence,
profile_id: dispute.profile_id.as_ref(),
merchant_connector_id: dispute.merchant_connector_id.as_ref(),
organization_id: &dispute.organization_id,
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/services/kafka/dispute.rs | crate: router
use crate::types::storage::dispute::Dispute;
fn event_type(&self) -> crate::events::EventType {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/services/kafka/payment_attempt.rs | crate: router
use hyperswitch_domain_models::{
mandates::MandateDetails, payments::payment_attempt::PaymentAttempt,
};
pub fn from_storage(attempt: &'a PaymentAttempt) -> Self {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
// file: hyperswitch/crates/router/src/services/kafka/payment_attempt.rs | crate: router
fn key(&self) -> String {
format!(
"{}_{}_{}",
self.merchant_id.get_string_repr(),
self.payment_id.get_string_repr(),
self.attempt_id
)
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/services/kafka/payout.rs | crate: router
use hyperswitch_domain_models::payouts::{payout_attempt::PayoutAttempt, payouts::Payouts};
pub fn from_storage(payouts: &'a Payouts, payout_attempt: &'a PayoutAttempt) -> Self {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
// file: hyperswitch/crates/router/src/services/kafka/payout.rs | crate: router
fn event_type(&self) -> crate::events::EventType {
crate::events::EventType::Payout
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/services/kafka/fraud_check.rs | crate: router
use diesel_models::{
enums as storage_enums,
enums::{FraudCheckLastStep, FraudCheckStatus, FraudCheckType},
fraud_check::FraudCheck,
};
pub fn from_storage(check: &'a FraudCheck) -> Self {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/services/kafka/refund.rs | crate: router
use diesel_models::{enums as storage_enums, refund::Refund};
use crate::events;
fn event_type(&self) -> events::EventType {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/services/kafka/payment_intent_event.rs | crate: router
use common_utils::{crypto::Encryptable, hashing::HashedString, id_type, pii, types::MinorUnit};
use diesel_models::enums as storage_enums;
use hyperswitch_domain_models::payments::PaymentIntent;
use masking::{PeekInterface, Secret};
use serde_json::Value;
use time::OffsetDateTime;
pub fn from_storage(intent: &'a PaymentIntent) -> Self {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
// file: hyperswitch/crates/router/src/services/kafka/payment_intent_event.rs | crate: router
fn key(&self) -> String {
format!(
"{}_{}",
self.merchant_id.get_string_repr(),
self.get_id().get_string_repr(),
)
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/services/kafka/payment_intent_event.rs | crate: router
use common_utils::{crypto::Encryptable, hashing::HashedString, id_type, pii, types::MinorUnit};
pub fn get_id(&self) -> &id_type::PaymentId {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/services/kafka/payment_intent.rs | crate: router
use common_utils::{crypto::Encryptable, hashing::HashedString, id_type, pii, types::MinorUnit};
fn get_id(&self) -> &id_type::PaymentId {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/services/api/request.rs | crate: router
use crate::core::errors::{self, CustomResult};
fn add_headers(mut self, headers: reqwest::header::HeaderMap) -> Self {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/services/api/request.rs | crate: router
use std::str::FromStr;
pub use common_utils::request::ContentType;
use common_utils::request::Headers;
use error_stack::ResultExt;
pub use masking::{Mask, Maskable};
use router_env::{instrument, tracing};
use crate::core::errors::{self, CustomResult};
fn construct_header_map(
self,
) -> CustomResult<reqwest::header::HeaderMap, errors::ApiClientError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/services/authentication/cookies.rs | crate: router
pub fn get_cookie_header() -> String {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/services/authentication/cookies.rs | crate: router
fn get_set_cookie_header() -> String {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/services/authentication/cookies.rs | crate: router
use cookie::{
time::{Duration, OffsetDateTime},
SameSite,
};
fn get_expiry_and_max_age_from_seconds(seconds: i64) -> (OffsetDateTime, Duration) {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/services/authentication/cookies.rs | crate: router
use cookie::Cookie;
use cookie::{
time::{Duration, OffsetDateTime},
SameSite,
};
use masking::{ExposeInterface, Secret};
use crate::{
consts::JWT_TOKEN_COOKIE_NAME,
core::errors::{ApiErrorResponse, RouterResult},
};
fn create_cookie<'c>(
token: Secret<String>,
expires: OffsetDateTime,
max_age: Duration,
) -> Cookie<'c> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/services/authentication/cookies.rs | crate: router
use cookie::Cookie;
use cookie::{
time::{Duration, OffsetDateTime},
SameSite,
};
use error_stack::{report, ResultExt};
use crate::{
consts::JWT_TOKEN_COOKIE_NAME,
core::errors::{ApiErrorResponse, RouterResult},
};
pub fn get_jwt_from_cookies(cookies: &str) -> RouterResult<String> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/services/authentication/cookies.rs | crate: router
use crate::{
consts::JWT_TOKEN_TIME_IN_SECS,
core::errors::{UserErrors, UserResponse},
services::ApplicationResponse,
};
pub fn remove_cookie_response() -> UserResponse<()> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/services/authentication/cookies.rs | crate: router
use masking::{ExposeInterface, Secret};
use crate::{
consts::JWT_TOKEN_TIME_IN_SECS,
core::errors::{UserErrors, UserResponse},
services::ApplicationResponse,
};
pub fn set_cookie_response<R>(response: R, token: Secret<String>) -> UserResponse<R> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/connector-template/transformers.rs | crate: connector-template
fn from(item: RefundStatus) -> Self {
{
RefundStatus::Succeeded => Self::Success,<|fim_suffix|>
<|fim_middle|>
RefundStatus::Processing => Self::Pending,
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/connector-template/transformers.rs | crate: connector-template
use common_enums::enums;
use hyperswitch_domain_models::{
payment_method_data::PaymentMethodData,
router_data::{ConnectorAuthType, RouterData},
router_flow_types::refunds::{Execute, RSync},
router_request_types::ResponseId,
router_response_types::{PaymentsResponseData, RefundsResponseData},
types::{PaymentsAuthorizeRouterData, RefundsRouterData},
};
use crate::{
types::{RefundsResponseRouterData, ResponseRouterData},
utils::PaymentsAuthorizeRequestData,
};
fn try_from(item: ResponseRouterData<F, {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/connector-template/transformers.rs | crate: connector-template
fn from(item: {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/connector-template/mod.rs | crate: connector-template
use common_utils::{
errors::CustomResult,
ext_traits::BytesExt,
types::{AmountConvertor, StringMinorUnit, StringMinorUnitForConnector},
request::{Method, Request, RequestBuilder, RequestContent},
};
use hyperswitch_domain_models::{
router_data::{AccessToken, ConnectorAuthType, ErrorResponse, RouterData},
router_flow_types::{
access_token_auth::AccessTokenAuth,
payments::{
Authorize, Capture, PSync, PaymentMethodToken, Session,
SetupMandate, Void,
},
refunds::{Execute, RSync},
},
router_request_types::{
AccessTokenRequestData, PaymentMethodTokenizationData,
PaymentsAuthorizeData, PaymentsCancelData, PaymentsCaptureData, PaymentsSessionData,
PaymentsSyncData, RefundsData, SetupMandateRequestData,
},
router_response_types::{PaymentsResponseData, RefundsResponseData},
types::{
PaymentsAuthorizeRouterData,
PaymentsCaptureRouterData, PaymentsSyncRouterData, RefundSyncRouterData, RefundsRouterData,
},
};
use hyperswitch_interfaces::{
api::{self, ConnectorCommon, ConnectorCommonExt, ConnectorIntegration, ConnectorValidation, ConnectorSpecifications},
configs::Connectors,
errors,
events::connector_api_logs::ConnectorEvent,
types::{self, Response},
webhooks,
};
fn get_url(&self, _req: &RefundSyncRouterData,_connectors: &Connectors,) -> CustomResult<String,errors::ConnectorError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/connector-template/mod.rs | crate: connector-template
use common_utils::{
errors::CustomResult,
ext_traits::BytesExt,
types::{AmountConvertor, StringMinorUnit, StringMinorUnitForConnector},
request::{Method, Request, RequestBuilder, RequestContent},
};
use hyperswitch_domain_models::{
router_data::{AccessToken, ConnectorAuthType, ErrorResponse, RouterData},
router_flow_types::{
access_token_auth::AccessTokenAuth,
payments::{
Authorize, Capture, PSync, PaymentMethodToken, Session,
SetupMandate, Void,
},
refunds::{Execute, RSync},
},
router_request_types::{
AccessTokenRequestData, PaymentMethodTokenizationData,
PaymentsAuthorizeData, PaymentsCancelData, PaymentsCaptureData, PaymentsSessionData,
PaymentsSyncData, RefundsData, SetupMandateRequestData,
},
router_response_types::{PaymentsResponseData, RefundsResponseData},
types::{
PaymentsAuthorizeRouterData,
PaymentsCaptureRouterData, PaymentsSyncRouterData, RefundSyncRouterData, RefundsRouterData,
},
};
use hyperswitch_interfaces::{
api::{self, ConnectorCommon, ConnectorCommonExt, ConnectorIntegration, ConnectorValidation, ConnectorSpecifications},
configs::Connectors,
errors,
events::connector_api_logs::ConnectorEvent,
types::{self, Response},
webhooks,
};
fn get_url(&self, _req: &RefundsRouterData<Execute>, _connectors: &Connectors,) -> CustomResult<String,errors::ConnectorError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/connector-template/mod.rs | crate: connector-template
use common_utils::{
errors::CustomResult,
ext_traits::BytesExt,
types::{AmountConvertor, StringMinorUnit, StringMinorUnitForConnector},
request::{Method, Request, RequestBuilder, RequestContent},
};
use hyperswitch_domain_models::{
router_data::{AccessToken, ConnectorAuthType, ErrorResponse, RouterData},
router_flow_types::{
access_token_auth::AccessTokenAuth,
payments::{
Authorize, Capture, PSync, PaymentMethodToken, Session,
SetupMandate, Void,
},
refunds::{Execute, RSync},
},
router_request_types::{
AccessTokenRequestData, PaymentMethodTokenizationData,
PaymentsAuthorizeData, PaymentsCancelData, PaymentsCaptureData, PaymentsSessionData,
PaymentsSyncData, RefundsData, SetupMandateRequestData,
},
router_response_types::{PaymentsResponseData, RefundsResponseData},
types::{
PaymentsAuthorizeRouterData,
PaymentsCaptureRouterData, PaymentsSyncRouterData, RefundSyncRouterData, RefundsRouterData,
},
};
use hyperswitch_interfaces::{
api::{self, ConnectorCommon, ConnectorCommonExt, ConnectorIntegration, ConnectorValidation, ConnectorSpecifications},
configs::Connectors,
errors,
events::connector_api_logs::ConnectorEvent,
types::{self, Response},
webhooks,
};
fn get_url(&self, _req: &PaymentsAuthorizeRouterData, _connectors: &Connectors,) -> CustomResult<String,errors::ConnectorError> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch-card-vault/benches/luhn-test.rs | crate: benches
use criterion::{black_box, criterion_group, criterion_main, Criterion};
use tartarus::validations::{luhn, MAX_CARD_NUMBER_LENGTH};
pub fn criterion_luhn(c: &mut Criterion) {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch-card-vault/benches/luhn-test.rs | crate: benches
use tartarus::validations::{luhn, MAX_CARD_NUMBER_LENGTH};
fn card_number_generator() -> Vec<u8> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch-card-vault/src/custom_extractors.rs | crate: src
use std::sync::Arc;
use axum::{async_trait, extract::FromRequestParts, http::request::Parts};
use crate::{
app::TenantAppState,
error::{ApiError, ContainerError},
storage::consts,
tenant::GlobalAppState,
};
async fn from_request_parts(
parts: &mut Parts,
state: &Arc<GlobalAppState>,
) -> Result<Self, Self::Rejection> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch-card-vault/src/storage.rs | crate: src
use crate::{
config::Database,
crypto::encryption_manager::encryption_interface::Encryption,
error::{self, ContainerError},
};
use std::sync::Arc;
use diesel_async::{
pooled_connection::{
self,
deadpool::{Object, Pool},
},
AsyncPgConnection,
};
use error_stack::ResultExt;
type DeadPoolConnType = Object<AsyncPgConnection>;
/// Create a new storage interface from configuration
pub async fn new(
database: &Database,
schema: &str,
) -> error_stack::Result<Self, error::StorageError> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch-card-vault/src/storage.rs | crate: src
use crate::{
config::Database,
crypto::encryption_manager::encryption_interface::Encryption,
error::{self, ContainerError},
};
use diesel_async::{
pooled_connection::{
self,
deadpool::{Object, Pool},
},
AsyncPgConnection,
};
type DeadPoolConnType = Object<AsyncPgConnection>;
/// Get connection from database pool for accessing data
pub async fn get_conn(&self) -> Result<DeadPoolConnType, ContainerError<error::StorageError>> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch-card-vault/src/utils.rs | crate: src
use axum::{body::Body, extract::Request};
use crate::storage::consts;
/// Record the header's fields in request's trace
pub fn record_fields_from_header(request: &Request<Body>) -> tracing::Span {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch-card-vault/src/crypto/keymanager.rs | crate: src
pub const fn get_dek_manager() -> impl KeyProvider {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch-card-vault/src/crypto/secrets_manager/secrets_management.rs | crate: src
use error_stack::ResultExt;
use crate::crypto::secrets_manager::managers::aws_kms::core::{AwsKmsClient, AwsKmsConfig};
use crate::crypto::secrets_manager::managers::hcvault::core::{
HashiCorpVault, HashiCorpVaultConfig,
};
use crate::{
crypto::secrets_manager::{
managers::hollow::core::NoEncryption,
secrets_interface::{SecretManager, SecretsManagementError},
},
error::ConfigurationError,
};
/// Retrieves the appropriate secret management client based on the configuration.
pub async fn get_secret_management_client(
&self,
) -> error_stack::Result<impl SecretManager, SecretsManagementError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch-card-vault/src/crypto/secrets_manager/secrets_management.rs | crate: src
use crate::crypto::secrets_manager::managers::aws_kms::core::{AwsKmsClient, AwsKmsConfig};
use crate::crypto::secrets_manager::managers::hcvault::core::{
HashiCorpVault, HashiCorpVaultConfig,
};
use crate::{
crypto::secrets_manager::{
managers::hollow::core::NoEncryption,
secrets_interface::{SecretManager, SecretsManagementError},
},
error::ConfigurationError,
};
/// Verifies that the client configuration is usable
pub fn validate(&self) -> Result<(), ConfigurationError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch-card-vault/src/crypto/secrets_manager/managers/hollow/core.rs | crate: src
/// Decryption functionality
pub fn decrypt(&self, data: impl AsRef<[u8]>) -> Vec<u8> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch-card-vault/src/crypto/secrets_manager/managers/hollow/core.rs | crate: src
/// Encryption functionality
pub fn encrypt(&self, data: impl AsRef<[u8]>) -> Vec<u8> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch-card-vault/src/crypto/secrets_manager/managers/aws_kms/core.rs | crate: src
use aws_sdk_kms::{config::Region, primitives::Blob, Client};
use error_stack::{report, ResultExt};
use crate::{crypto::consts::BASE64_ENGINE, error::ConfigurationError, logger};
/// Decrypts the provided base64-encoded encrypted data using the AWS KMS SDK. We assume that
/// the SDK has the values required to interact with the AWS KMS APIs (`AWS_ACCESS_KEY_ID` and
/// `AWS_SECRET_ACCESS_KEY`) either set in environment variables, or that the SDK is running in
/// a machine that is able to assume an IAM role.
pub async fn decrypt(
&self,
data: impl AsRef<[u8]>,
) -> error_stack::Result<String, AwsKmsError> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch-card-vault/src/crypto/secrets_manager/managers/aws_kms/core.rs | crate: src
use aws_config::meta::region::RegionProviderChain;
use crate::{crypto::consts::BASE64_ENGINE, error::ConfigurationError, logger};
/// Verifies that the [`AwsKmsClient`] configuration is usable.
pub fn validate(&self) -> Result<(), ConfigurationError> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch-card-vault/src/crypto/secrets_manager/managers/aws_kms/core.rs | crate: src
use aws_config::meta::region::RegionProviderChain;
use aws_sdk_kms::{config::Region, primitives::Blob, Client};
/// Constructs a new AWS KMS client.
pub async fn new(config: &AwsKmsConfig) -> Self {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch-card-vault/src/crypto/secrets_manager/managers/hcvault/core.rs | crate: src
use crate::error::ConfigurationError;
/// Verifies that the [`HashiCorpVault`] configuration is usable.
pub fn validate(&self) -> Result<(), ConfigurationError> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch-card-vault/src/crypto/encryption_manager/managers/jw.rs | crate: src
use josekit::{jwe, jws};
fn test_jws() {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch-card-vault/src/crypto/encryption_manager/managers/jw.rs | crate: src
use josekit::{jwe, jws};
fn test_jwe() {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch-card-vault/src/crypto/encryption_manager/managers/jw.rs | crate: src
use crate::{
crypto::encryption_manager::encryption_interface::Encryption,
error::{self, ContainerError},
};
use josekit::{jwe, jws};
pub fn verify_sign(jws_body: String, key: impl AsRef<[u8]>) -> Result<String, error::CryptoError> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch-card-vault/src/crypto/encryption_manager/managers/jw.rs | crate: src
use crate::{
crypto::encryption_manager::encryption_interface::Encryption,
error::{self, ContainerError},
};
use josekit::{jwe, jws};
pub fn decrypt_jwe(
jwt: &str,
private_key: impl AsRef<[u8]>,
alg: jwe::alg::rsaes::RsaesJweAlgorithm,
) -> Result<String, error::CryptoError> {
<|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.