text stringlengths 70 351k | source stringclasses 4 values |
|---|---|
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/netcetera.rs | crate: router
use common_utils::{ext_traits::ByteSliceExt, request::RequestContent};
use transformers as netcetera;
use crate::{
configs::settings,
core::errors::{self, CustomResult},
events::connector_api_logs::ConnectorEvent,
headers,
services::{self, request, ConnectorIntegration, ConnectorSpecifications, ConnectorValidation},
types::{
self,
api::{self, ConnectorCommon, ConnectorCommonExt},
ErrorResponse, Response,
},
utils::BytesExt,
};
fn get_webhook_resource_object(
&self,
request: &api::IncomingWebhookRequestDetails<'_>,
) -> CustomResult<Box<dyn masking::ErasedMaskSerialize>, errors::ConnectorError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/netcetera.rs | crate: router
use common_utils::{ext_traits::ByteSliceExt, request::RequestContent};
use transformers as netcetera;
use crate::{
configs::settings,
core::errors::{self, CustomResult},
events::connector_api_logs::ConnectorEvent,
headers,
services::{self, request, ConnectorIntegration, ConnectorSpecifications, ConnectorValidation},
types::{
self,
api::{self, ConnectorCommon, ConnectorCommonExt},
ErrorResponse, Response,
},
utils::BytesExt,
};
fn get_webhook_object_reference_id(
&self,
request: &api::IncomingWebhookRequestDetails<'_>,
) -> CustomResult<api::webhooks::ObjectReferenceId, errors::ConnectorError> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/netcetera.rs | crate: router
use common_utils::{ext_traits::ByteSliceExt, request::RequestContent};
use crate::{
configs::settings,
core::errors::{self, CustomResult},
events::connector_api_logs::ConnectorEvent,
headers,
services::{self, request, ConnectorIntegration, ConnectorSpecifications, ConnectorValidation},
types::{
self,
api::{self, ConnectorCommon, ConnectorCommonExt},
ErrorResponse, Response,
},
utils::BytesExt,
};
fn get_auth_header(
&self,
_auth_type: &types::ConnectorAuthType,
) -> CustomResult<Vec<(String, request::Maskable<String>)>, errors::ConnectorError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
// file: hyperswitch/crates/router/src/connector/netcetera.rs | crate: router
use common_utils::{ext_traits::ByteSliceExt, request::RequestContent};
use crate::{
configs::settings,
core::errors::{self, CustomResult},
events::connector_api_logs::ConnectorEvent,
headers,
services::{self, request, ConnectorIntegration, ConnectorSpecifications, ConnectorValidation},
types::{
self,
api::{self, ConnectorCommon, ConnectorCommonExt},
ErrorResponse, Response,
},
utils::BytesExt,
};
fn build_headers(
&self,
req: &types::RouterData<Flow, Request, Response>,
_connectors: &settings::Connectors,
) -> CustomResult<Vec<(String, request::Maskable<String>)>, errors::ConnectorError> {
let mut header = vec![(
headers::CONTENT_TYPE.to_string(),
self.get_content_type().to_string().into(),
)];
let mut api_key = self.get_auth_header(&req.connector_auth_type)?;
header.append(&mut api_key);
Ok(header)
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/plaid.rs | crate: router
use common_utils::types::{AmountConvertor, FloatMajorUnit, FloatMajorUnitForConnector};
use transformers as plaid;
use crate::{
configs::settings,
connector::utils as connector_utils,
core::errors::{self, CustomResult},
events::connector_api_logs::ConnectorEvent,
headers,
services::{
self,
request::{self, Mask},
ConnectorIntegration, ConnectorSpecifications, ConnectorValidation,
},
types::{
self,
api::{self, ConnectorCommon, ConnectorCommonExt},
ErrorResponse, RequestContent, Response,
},
utils::BytesExt,
};
fn handle_response(
&self,
data: &types::PaymentsPostProcessingRouterData,
event_builder: Option<&mut ConnectorEvent>,
res: Response,
) -> CustomResult<types::PaymentsPostProcessingRouterData, errors::ConnectorError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/plaid.rs | crate: router
use common_utils::types::{AmountConvertor, FloatMajorUnit, FloatMajorUnitForConnector};
use crate::{
configs::settings,
connector::utils as connector_utils,
core::errors::{self, CustomResult},
events::connector_api_logs::ConnectorEvent,
headers,
services::{
self,
request::{self, Mask},
ConnectorIntegration, ConnectorSpecifications, ConnectorValidation,
},
types::{
self,
api::{self, ConnectorCommon, ConnectorCommonExt},
ErrorResponse, RequestContent, Response,
},
utils::BytesExt,
};
fn build_request(
&self,
req: &types::PaymentsPostProcessingRouterData,
connectors: &settings::Connectors,
) -> CustomResult<Option<services::Request>, errors::ConnectorError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/plaid.rs | crate: router
use common_utils::types::{AmountConvertor, FloatMajorUnit, FloatMajorUnitForConnector};
use transformers as plaid;
use crate::{
configs::settings,
connector::utils as connector_utils,
core::errors::{self, CustomResult},
events::connector_api_logs::ConnectorEvent,
headers,
services::{
self,
request::{self, Mask},
ConnectorIntegration, ConnectorSpecifications, ConnectorValidation,
},
types::{
self,
api::{self, ConnectorCommon, ConnectorCommonExt},
ErrorResponse, RequestContent, Response,
},
utils::BytesExt,
};
fn get_request_body(
&self,
req: &types::PaymentsPostProcessingRouterData,
_connectors: &settings::Connectors,
) -> CustomResult<RequestContent, errors::ConnectorError> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/plaid.rs | crate: router
use common_utils::types::{AmountConvertor, FloatMajorUnit, FloatMajorUnitForConnector};
use crate::{
configs::settings,
connector::utils as connector_utils,
core::errors::{self, CustomResult},
events::connector_api_logs::ConnectorEvent,
headers,
services::{
self,
request::{self, Mask},
ConnectorIntegration, ConnectorSpecifications, ConnectorValidation,
},
types::{
self,
api::{self, ConnectorCommon, ConnectorCommonExt},
ErrorResponse, RequestContent, Response,
},
utils::BytesExt,
};
fn get_url(
&self,
_req: &types::PaymentsPostProcessingRouterData,
connectors: &settings::Connectors,
) -> CustomResult<String, errors::ConnectorError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/plaid.rs | crate: router
use common_utils::types::{AmountConvertor, FloatMajorUnit, FloatMajorUnitForConnector};
use crate::{
configs::settings,
connector::utils as connector_utils,
core::errors::{self, CustomResult},
events::connector_api_logs::ConnectorEvent,
headers,
services::{
self,
request::{self, Mask},
ConnectorIntegration, ConnectorSpecifications, ConnectorValidation,
},
types::{
self,
api::{self, ConnectorCommon, ConnectorCommonExt},
ErrorResponse, RequestContent, Response,
},
utils::BytesExt,
};
fn get_headers(
&self,
req: &types::PaymentsPostProcessingRouterData,
connectors: &settings::Connectors,
) -> CustomResult<Vec<(String, request::Maskable<String>)>, errors::ConnectorError> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/plaid.rs | crate: router
use common_utils::types::{AmountConvertor, FloatMajorUnit, FloatMajorUnitForConnector};
use crate::{
configs::settings,
connector::utils as connector_utils,
core::errors::{self, CustomResult},
events::connector_api_logs::ConnectorEvent,
headers,
services::{
self,
request::{self, Mask},
ConnectorIntegration, ConnectorSpecifications, ConnectorValidation,
},
types::{
self,
api::{self, ConnectorCommon, ConnectorCommonExt},
ErrorResponse, RequestContent, Response,
},
utils::BytesExt,
};
fn get_url(
&self,
_req: &types::PaymentsSyncRouterData,
connectors: &settings::Connectors,
) -> CustomResult<String, errors::ConnectorError> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/plaid.rs | crate: router
use common_utils::types::{AmountConvertor, FloatMajorUnit, FloatMajorUnitForConnector};
use transformers as plaid;
use crate::{
configs::settings,
connector::utils as connector_utils,
core::errors::{self, CustomResult},
events::connector_api_logs::ConnectorEvent,
headers,
services::{
self,
request::{self, Mask},
ConnectorIntegration, ConnectorSpecifications, ConnectorValidation,
},
types::{
self,
api::{self, ConnectorCommon, ConnectorCommonExt},
ErrorResponse, RequestContent, Response,
},
utils::BytesExt,
};
fn get_request_body(
&self,
req: &types::PaymentsSyncRouterData,
_connectors: &settings::Connectors,
) -> CustomResult<RequestContent, errors::ConnectorError> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/plaid.rs | crate: router
use common_utils::types::{AmountConvertor, FloatMajorUnit, FloatMajorUnitForConnector};
use transformers as plaid;
use crate::{
configs::settings,
connector::utils as connector_utils,
core::errors::{self, CustomResult},
events::connector_api_logs::ConnectorEvent,
headers,
services::{
self,
request::{self, Mask},
ConnectorIntegration, ConnectorSpecifications, ConnectorValidation,
},
types::{
self,
api::{self, ConnectorCommon, ConnectorCommonExt},
ErrorResponse, RequestContent, Response,
},
utils::BytesExt,
};
fn get_auth_header(
&self,
auth_type: &types::ConnectorAuthType,
) -> CustomResult<Vec<(String, masking::Maskable<String>)>, errors::ConnectorError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/ebanx.rs | crate: router
use common_utils::request::RequestContent;
use common_utils::types::{AmountConvertor, FloatMajorUnit, FloatMajorUnitForConnector};
use transformers as ebanx;
use crate::{
configs::settings,
core::errors::{self, CustomResult},
events::connector_api_logs::ConnectorEvent,
services::{ConnectorIntegration, ConnectorSpecifications, ConnectorValidation},
types::{
self,
api::{self, ConnectorCommon, ConnectorCommonExt},
},
utils::BytesExt,
};
use crate::{
headers,
services::{self, request},
};
fn get_request_body(
&self,
req: &types::PayoutsRouterData<api::PoCancel>,
_connectors: &settings::Connectors,
) -> CustomResult<RequestContent, errors::ConnectorError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/ebanx.rs | crate: router
use common_utils::types::{AmountConvertor, FloatMajorUnit, FloatMajorUnitForConnector};
use transformers as ebanx;
use crate::{
configs::settings,
core::errors::{self, CustomResult},
events::connector_api_logs::ConnectorEvent,
services::{ConnectorIntegration, ConnectorSpecifications, ConnectorValidation},
types::{
self,
api::{self, ConnectorCommon, ConnectorCommonExt},
},
utils::BytesExt,
};
use crate::{
headers,
services::{self, request},
};
fn get_url(
&self,
_req: &types::PayoutsRouterData<api::PoCancel>,
connectors: &settings::Connectors,
) -> CustomResult<String, errors::ConnectorError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/ebanx.rs | crate: router
use common_utils::types::{AmountConvertor, FloatMajorUnit, FloatMajorUnitForConnector};
use transformers as ebanx;
use crate::{
configs::settings,
core::errors::{self, CustomResult},
events::connector_api_logs::ConnectorEvent,
services::{ConnectorIntegration, ConnectorSpecifications, ConnectorValidation},
types::{
self,
api::{self, ConnectorCommon, ConnectorCommonExt},
},
utils::BytesExt,
};
use crate::{
headers,
services::{self, request},
};
fn get_url(
&self,
_req: &types::PayoutsRouterData<api::PoFulfill>,
connectors: &settings::Connectors,
) -> CustomResult<String, errors::ConnectorError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/ebanx.rs | crate: router
use common_utils::types::{AmountConvertor, FloatMajorUnit, FloatMajorUnitForConnector};
use router_env::{instrument, tracing};
use transformers as ebanx;
use crate::{
configs::settings,
core::errors::{self, CustomResult},
events::connector_api_logs::ConnectorEvent,
services::{ConnectorIntegration, ConnectorSpecifications, ConnectorValidation},
types::{
self,
api::{self, ConnectorCommon, ConnectorCommonExt},
},
utils::BytesExt,
};
use crate::{
headers,
services::{self, request},
};
fn handle_response(
&self,
data: &types::PayoutsRouterData<api::PoCreate>,
event_builder: Option<&mut ConnectorEvent>,
res: types::Response,
) -> CustomResult<types::PayoutsRouterData<api::PoCreate>, errors::ConnectorError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/ebanx.rs | crate: router
use common_utils::request::RequestContent;
use common_utils::types::{AmountConvertor, FloatMajorUnit, FloatMajorUnitForConnector};
use crate::{
configs::settings,
core::errors::{self, CustomResult},
events::connector_api_logs::ConnectorEvent,
services::{ConnectorIntegration, ConnectorSpecifications, ConnectorValidation},
types::{
self,
api::{self, ConnectorCommon, ConnectorCommonExt},
},
utils::BytesExt,
};
use crate::{
headers,
services::{self, request},
};
fn build_headers(
&self,
_req: &types::RouterData<Flow, Request, Response>,
_connectors: &settings::Connectors,
) -> CustomResult<Vec<(String, request::Maskable<String>)>, errors::ConnectorError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/threedsecureio.rs | crate: router
use crate::{
configs::settings,
core::errors::{self, CustomResult},
events::connector_api_logs::ConnectorEvent,
headers,
services::{
self,
request::{self, Mask},
ConnectorIntegration, ConnectorSpecifications, ConnectorValidation,
},
types::{
self,
api::{self, ConnectorCommon, ConnectorCommonExt},
ErrorResponse, RequestContent, Response,
},
utils::{self, BytesExt},
};
fn build_request(
&self,
req: &types::authentication::PreAuthNRouterData,
connectors: &settings::Connectors,
) -> CustomResult<Option<services::Request>, errors::ConnectorError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/threedsecureio.rs | crate: router
use transformers as threedsecureio;
use crate::{
configs::settings,
core::errors::{self, CustomResult},
events::connector_api_logs::ConnectorEvent,
headers,
services::{
self,
request::{self, Mask},
ConnectorIntegration, ConnectorSpecifications, ConnectorValidation,
},
types::{
self,
api::{self, ConnectorCommon, ConnectorCommonExt},
ErrorResponse, RequestContent, Response,
},
utils::{self, BytesExt},
};
fn get_request_body(
&self,
req: &types::authentication::ConnectorPostAuthenticationRouterData,
_connectors: &settings::Connectors,
) -> CustomResult<RequestContent, errors::ConnectorError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/threedsecureio.rs | crate: router
use crate::{
configs::settings,
core::errors::{self, CustomResult},
events::connector_api_logs::ConnectorEvent,
headers,
services::{
self,
request::{self, Mask},
ConnectorIntegration, ConnectorSpecifications, ConnectorValidation,
},
types::{
self,
api::{self, ConnectorCommon, ConnectorCommonExt},
ErrorResponse, RequestContent, Response,
},
utils::{self, BytesExt},
};
fn get_url(
&self,
_req: &types::authentication::ConnectorPostAuthenticationRouterData,
connectors: &settings::Connectors,
) -> CustomResult<String, errors::ConnectorError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
// file: hyperswitch/crates/router/src/connector/threedsecureio.rs | crate: router
use transformers as threedsecureio;
use crate::{
configs::settings,
core::errors::{self, CustomResult},
events::connector_api_logs::ConnectorEvent,
headers,
services::{
self,
request::{self, Mask},
ConnectorIntegration, ConnectorSpecifications, ConnectorValidation,
},
types::{
self,
api::{self, ConnectorCommon, ConnectorCommonExt},
ErrorResponse, RequestContent, Response,
},
utils::{self, BytesExt},
};
fn handle_response(
&self,
data: &types::authentication::PreAuthNRouterData,
event_builder: Option<&mut ConnectorEvent>,
res: Response,
) -> CustomResult<types::authentication::PreAuthNRouterData, errors::ConnectorError> {
let response: threedsecureio::ThreedsecureioPreAuthenticationResponse = res
.response
.parse_struct("threedsecureio ThreedsecureioPreAuthenticationResponse")
.change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
event_builder.map(|i| i.set_response_body(&response));
router_env::logger::info!(connector_response=?response);
types::RouterData::try_from(types::ResponseRouterData {
response,
data: data.clone(),
http_code: res.status_code,
})
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/threedsecureio.rs | crate: router
use crate::{
configs::settings,
core::errors::{self, CustomResult},
events::connector_api_logs::ConnectorEvent,
headers,
services::{
self,
request::{self, Mask},
ConnectorIntegration, ConnectorSpecifications, ConnectorValidation,
},
types::{
self,
api::{self, ConnectorCommon, ConnectorCommonExt},
ErrorResponse, RequestContent, Response,
},
utils::{self, BytesExt},
};
fn get_url(
&self,
_req: &types::authentication::PreAuthNRouterData,
connectors: &settings::Connectors,
) -> CustomResult<String, errors::ConnectorError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/threedsecureio.rs | crate: router
use crate::{
configs::settings,
core::errors::{self, CustomResult},
events::connector_api_logs::ConnectorEvent,
headers,
services::{
self,
request::{self, Mask},
ConnectorIntegration, ConnectorSpecifications, ConnectorValidation,
},
types::{
self,
api::{self, ConnectorCommon, ConnectorCommonExt},
ErrorResponse, RequestContent, Response,
},
utils::{self, BytesExt},
};
fn get_url(
&self,
_req: &types::authentication::ConnectorAuthenticationRouterData,
connectors: &settings::Connectors,
) -> CustomResult<String, errors::ConnectorError> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/gpayments/gpayments_types.rs | crate: router
fn from(value: AuthStatus) -> Self {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
// file: hyperswitch/crates/router/src/connector/dummyconnector/transformers.rs | crate: router
use crate::{
connector::utils::RouterData,
core::errors,
services,
types::{self, api, domain, storage::enums},
};
fn try_from(item: &types::PaymentsAuthorizeRouterData) -> Result<Self, Self::Error> {
let payment_method_data: Result<PaymentMethodData, Self::Error> = match item
.request
.payment_method_data
{
domain::PaymentMethodData::Card(ref req_card) => {
let card_holder_name = item.get_optional_billing_full_name();
Ok(PaymentMethodData::Card(DummyConnectorCard::try_from((
req_card.clone(),
card_holder_name,
))?))
}
domain::PaymentMethodData::Wallet(ref wallet_data) => {
Ok(PaymentMethodData::Wallet(wallet_data.clone().try_into()?))
}
domain::PaymentMethodData::PayLater(ref pay_later_data) => Ok(
PaymentMethodData::PayLater(pay_later_data.clone().try_into()?),
),
_ => Err(errors::ConnectorError::NotImplemented("Payment methods".to_string()).into()),
};
Ok(Self {
amount: item.request.amount,
currency: item.request.currency,
payment_method_data: payment_method_data?,
return_url: item.request.router_return_url.clone(),
connector: Into::<DummyConnectors>::into(T),
})
} | ast_fragments |
// file: hyperswitch/crates/router/src/connector/dummyconnector/transformers.rs | crate: router
use diesel_models::enums::Currency;
use crate::{
connector::utils::RouterData,
core::errors,
services,
types::{self, api, domain, storage::enums},
};
fn try_from(
item: types::RefundsResponseRouterData<api::Execute, RefundResponse>,
) -> Result<Self, Self::Error> {
Ok(Self {
response: Ok(types::RefundsResponseData {
connector_refund_id: item.response.id.to_string(),
refund_status: enums::RefundStatus::from(item.response.status),
}),
..item.data
})
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/dummyconnector/transformers.rs | crate: router
use url::Url;
use crate::{
connector::utils::RouterData,
core::errors,
services,
types::{self, api, domain, storage::enums},
};
fn get_url(&self) -> Option<Url> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/dummyconnector/transformers.rs | crate: router
use diesel_models::enums::Currency;
use crate::{
connector::utils::RouterData,
core::errors,
services,
types::{self, api, domain, storage::enums},
};
fn try_from(
item: types::ResponseRouterData<F, PaymentsResponse, T, types::PaymentsResponseData>,
) -> Result<Self, Self::Error> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/dummyconnector/transformers.rs | crate: router
fn from(item: DummyConnectorPaymentStatus) -> Self {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/dummyconnector/transformers.rs | crate: router
use crate::{
connector::utils::RouterData,
core::errors,
services,
types::{self, api, domain, storage::enums},
};
fn try_from(value: domain::payments::PayLaterData) -> Result<Self, Self::Error> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/dummyconnector/transformers.rs | crate: router
use crate::{
connector::utils::RouterData,
core::errors,
services,
types::{self, api, domain, storage::enums},
};
fn try_from(value: domain::WalletData) -> Result<Self, Self::Error> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/dummyconnector/transformers.rs | crate: router
use masking::Secret;
use crate::{
connector::utils::RouterData,
core::errors,
services,
types::{self, api, domain, storage::enums},
};
fn try_from(
(value, card_holder_name): (domain::Card, Option<Secret<String>>),
) -> Result<Self, Self::Error> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/dummyconnector/transformers.rs | crate: router
fn from(value: u8) -> Self {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/dummyconnector/transformers.rs | crate: router
use crate::{
connector::utils::RouterData,
core::errors,
services,
types::{self, api, domain, storage::enums},
};
pub fn get_dummy_connector_id(self) -> &'static str {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/netcetera/transformers.rs | crate: router
use super::netcetera_types;
use crate::{
connector::utils::{self, CardData},
core::errors,
types::{self, api},
utils::OptionExt,
};
fn try_from(
value: &NetceteraRouterData<&types::authentication::PreAuthNRouterData>,
) -> Result<Self, Self::Error> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/netcetera/transformers.rs | crate: router
use crate::{
connector::utils::{self, CardData},
core::errors,
types::{self, api},
utils::OptionExt,
};
fn try_from(
item: types::ResponseRouterData<
api::Authentication,
NetceteraAuthenticationResponse,
types::authentication::ConnectorAuthenticationRequestData,
types::authentication::AuthenticationResponseData,
>,
) -> Result<Self, Self::Error> {
{
NetceteraAuthenticationResponse::Success(response) => {
let authn_flow_type = match response.acs_challenge_mandated {
Some(ACSChallengeMandatedIndicator::Y) => {
types::authentication::AuthNFlowType::Challenge(Box::new(
types::authentication::ChallengeParams {
acs_url: response.authentication_response.acs_url.clone(),
challenge_request: response.encoded_challenge_request,
acs_reference_number: response
.authentication_response
.acs_reference_number,
acs_trans_id: response.authentication_response.acs_trans_id,
three_dsserver_trans_id: Some(response.three_ds_server_trans_id),
acs_signed_content: response
.authentication_response
.acs_signed_content,
},
))
}
Some(ACSChallengeMandatedIndicator::N) | None => {
types::authentication::AuthNFlowType::Frictionless
}
};
Ok(
types::authentication::AuthenticationResponseData::AuthNResponse {
authn_flow_type,
authentication_value: response.authentication_value,
trans_status: response.trans_status,
connector_metadata: None,
ds_trans_id: response.authentication_response.ds_trans_id,
},
)
}<|fim_suffix|>
<|fim_middle|>
NetceteraAuthenticationResponse::Error(error_response) => Err(types::ErrorResponse {
code: error_response.error_details.error_code,
message: error_response.error_details.error_description,
reason: error_response.error_details.error_detail,
status_code: item.http_code,
attempt_status: None,
connector_transaction_id: None,
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
}),
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/netcetera/transformers.rs | crate: router
use crate::{
connector::utils::{self, CardData},
core::errors,
types::{self, api},
utils::OptionExt,
};
fn try_from(
item: types::ResponseRouterData<
api::PreAuthentication,
NetceteraPreAuthenticationResponse,
types::authentication::PreAuthNRequestData,
types::authentication::AuthenticationResponseData,
>,
) -> Result<Self, Self::Error> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/netcetera/transformers.rs | crate: router
use crate::{
connector::utils::{self, CardData},
core::errors,
types::{self, api},
utils::OptionExt,
};
pub fn get_three_ds_method_url(&self) -> Option<String> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/netcetera/transformers.rs | crate: router
use crate::{
connector::utils::{self, CardData},
core::errors,
types::{self, api},
utils::OptionExt,
};
pub fn get_card_range_if_available(&self) -> Option<CardRange> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
// file: hyperswitch/crates/router/src/connector/netcetera/transformers.rs | crate: router
use crate::{
connector::utils::{self, CardData},
core::errors,
types::{self, api},
utils::OptionExt,
};
fn try_from(
meta_data: &Option<common_utils::pii::SecretSerdeValue>,
) -> Result<Self, Self::Error> {
let metadata: Self = utils::to_connector_meta_from_secret::<Self>(meta_data.clone())
.change_context(errors::ConnectorError::InvalidConnectorConfig {
config: "metadata",
})?;
Ok(metadata)
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/netcetera/transformers.rs | crate: router
use error_stack::ResultExt;
use masking::Secret;
use serde::{Deserialize, Serialize};
use super::netcetera_types;
use crate::{
connector::utils::{self, CardData},
core::errors,
types::{self, api},
utils::OptionExt,
};
fn try_from(
(_currency_unit, _currency, amount, item): (
&api::CurrencyUnit,
types::storage::enums::Currency,
i64,
T,
),
) -> Result<Self, Self::Error> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/netcetera/transformers.rs | crate: router
use super::netcetera_types;
use crate::{
connector::utils::{self, CardData},
core::errors,
types::{self, api},
utils::OptionExt,
};
fn try_from(
item: &NetceteraRouterData<&types::authentication::ConnectorAuthenticationRouterData>,
) -> Result<Self, Self::Error> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/connector/signifyd/transformers/auth.rs | crate: router
use crate::{core::errors, types};
fn try_from(auth_type: &types::ConnectorAuthType) -> Result<Self, Self::Error> {
{
types::ConnectorAuthType::HeaderKey { api_key } => Ok(Self {
api_key: api_key.to_owned(),
}),<|fim_suffix|>
<|fim_middle|>
_ => Err(errors::ConnectorError::FailedToObtainAuthType.into()),
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/db/dynamic_routing_stats.rs | crate: router
use crate::{
connection,
core::errors::{self, CustomResult},
db::kafka_store::KafkaStore,
types::storage,
};
async fn update_dynamic_routing_stats(
&self,
attempt_id: String,
merchant_id: &common_utils::id_type::MerchantId,
data: storage::DynamicRoutingStatsUpdate,
) -> CustomResult<storage::DynamicRoutingStats, errors::StorageError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/db/dynamic_routing_stats.rs | crate: router
use crate::{
connection,
core::errors::{self, CustomResult},
db::kafka_store::KafkaStore,
types::storage,
};
async fn find_dynamic_routing_stats_optional_by_attempt_id_merchant_id(
&self,
attempt_id: String,
merchant_id: &common_utils::id_type::MerchantId,
) -> CustomResult<Option<storage::DynamicRoutingStats>, errors::StorageError> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/db/dynamic_routing_stats.rs | crate: router
use crate::{
connection,
core::errors::{self, CustomResult},
db::kafka_store::KafkaStore,
types::storage,
};
async fn insert_dynamic_routing_stat_entry(
&self,
dynamic_routing_stat: storage::DynamicRoutingStatsNew,
) -> CustomResult<storage::DynamicRoutingStats, errors::StorageError> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/db/dynamic_routing_stats.rs | crate: router
use crate::{
connection,
core::errors::{self, CustomResult},
db::kafka_store::KafkaStore,
types::storage,
};
async fn update_dynamic_routing_stats(
&self,
_attempt_id: String,
_merchant_id: &common_utils::id_type::MerchantId,
_data: storage::DynamicRoutingStatsUpdate,
) -> CustomResult<storage::DynamicRoutingStats, errors::StorageError> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/db/dynamic_routing_stats.rs | crate: router
use crate::{
connection,
core::errors::{self, CustomResult},
db::kafka_store::KafkaStore,
types::storage,
};
async fn find_dynamic_routing_stats_optional_by_attempt_id_merchant_id(
&self,
_attempt_id: String,
_merchant_id: &common_utils::id_type::MerchantId,
) -> CustomResult<Option<storage::DynamicRoutingStats>, errors::StorageError> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/db/dynamic_routing_stats.rs | crate: router
use crate::{
connection,
core::errors::{self, CustomResult},
db::kafka_store::KafkaStore,
types::storage,
};
async fn insert_dynamic_routing_stat_entry(
&self,
_dynamic_routing_stat: storage::DynamicRoutingStatsNew,
) -> CustomResult<storage::DynamicRoutingStats, errors::StorageError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
// file: hyperswitch/crates/router/src/db/dynamic_routing_stats.rs | crate: router
use error_stack::report;
use crate::{
connection,
core::errors::{self, CustomResult},
db::kafka_store::KafkaStore,
types::storage,
};
async fn insert_dynamic_routing_stat_entry(
&self,
dynamic_routing_stat: storage::DynamicRoutingStatsNew,
) -> CustomResult<storage::DynamicRoutingStats, errors::StorageError> {
let conn = connection::pg_connection_write(self).await?;
dynamic_routing_stat
.insert(&conn)
.await
.map_err(|error| report!(errors::StorageError::from(error)))
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/db/callback_mapper.rs | crate: router
use error_stack::report;
use hyperswitch_domain_models::callback_mapper as domain;
use crate::{
connection,
core::errors::{self, CustomResult},
types::storage,
};
async fn find_call_back_mapper_by_id(
&self,
id: &str,
) -> CustomResult<domain::CallbackMapper, errors::StorageError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
// file: hyperswitch/crates/router/src/db/callback_mapper.rs | crate: router
use error_stack::report;
use hyperswitch_domain_models::callback_mapper as domain;
use crate::{
connection,
core::errors::{self, CustomResult},
types::storage,
};
async fn insert_call_back_mapper(
&self,
call_back_mapper: domain::CallbackMapper,
) -> CustomResult<domain::CallbackMapper, errors::StorageError> {
let conn = connection::pg_connection_write(self).await?;
call_back_mapper
.to_storage_model()
.insert(&conn)
.await
.map_err(|error| report!(errors::StorageError::from(error)))
.map(domain::CallbackMapper::from_storage_model)
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/db/organization.rs | crate: router
use common_utils::{errors::CustomResult, id_type};
use diesel_models::{organization as storage, organization::OrganizationBridge};
use crate::{connection, core::errors, services::Store};
async fn update_organization_by_org_id(
&self,
org_id: &id_type::OrganizationId,
update: storage::OrganizationUpdate,
) -> CustomResult<storage::Organization, errors::StorageError> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/db/organization.rs | crate: router
use common_utils::{errors::CustomResult, id_type};
use diesel_models::{organization as storage, organization::OrganizationBridge};
use crate::{connection, core::errors, services::Store};
async fn find_organization_by_org_id(
&self,
org_id: &id_type::OrganizationId,
) -> CustomResult<storage::Organization, errors::StorageError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/db/organization.rs | crate: router
use common_utils::{errors::CustomResult, id_type};
use diesel_models::{organization as storage, organization::OrganizationBridge};
use crate::{connection, core::errors, services::Store};
async fn insert_organization(
&self,
organization: storage::OrganizationNew,
) -> CustomResult<storage::Organization, errors::StorageError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/db/fraud_check.rs | crate: router
use diesel_models::fraud_check::{self as storage, FraudCheck, FraudCheckUpdate};
use crate::{
connection,
core::errors::{self, CustomResult},
services::Store,
};
async fn find_fraud_check_by_payment_id_if_present(
&self,
_payment_id: common_utils::id_type::PaymentId,
_merchant_id: common_utils::id_type::MerchantId,
) -> CustomResult<Option<FraudCheck>, errors::StorageError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/db/fraud_check.rs | crate: router
use diesel_models::fraud_check::{self as storage, FraudCheck, FraudCheckUpdate};
use crate::{
connection,
core::errors::{self, CustomResult},
services::Store,
};
async fn find_fraud_check_by_payment_id(
&self,
_payment_id: common_utils::id_type::PaymentId,
_merchant_id: common_utils::id_type::MerchantId,
) -> CustomResult<FraudCheck, errors::StorageError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/db/fraud_check.rs | crate: router
use diesel_models::fraud_check::{self as storage, FraudCheck, FraudCheckUpdate};
use crate::{
connection,
core::errors::{self, CustomResult},
services::Store,
};
async fn update_fraud_check_response_with_attempt_id(
&self,
_this: FraudCheck,
_fraud_check: FraudCheckUpdate,
) -> CustomResult<FraudCheck, errors::StorageError> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/db/fraud_check.rs | crate: router
use diesel_models::fraud_check::{self as storage, FraudCheck, FraudCheckUpdate};
use crate::{
connection,
core::errors::{self, CustomResult},
services::Store,
};
async fn insert_fraud_check_response(
&self,
_new: storage::FraudCheckNew,
) -> CustomResult<FraudCheck, errors::StorageError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/db/fraud_check.rs | crate: router
use diesel_models::fraud_check::{self as storage, FraudCheck, FraudCheckUpdate};
use error_stack::report;
use crate::{
connection,
core::errors::{self, CustomResult},
services::Store,
};
async fn find_fraud_check_by_payment_id_if_present(
&self,
payment_id: common_utils::id_type::PaymentId,
merchant_id: common_utils::id_type::MerchantId,
) -> CustomResult<Option<FraudCheck>, errors::StorageError> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/db/fraud_check.rs | crate: router
use diesel_models::fraud_check::{self as storage, FraudCheck, FraudCheckUpdate};
use error_stack::report;
use crate::{
connection,
core::errors::{self, CustomResult},
services::Store,
};
async fn find_fraud_check_by_payment_id(
&self,
payment_id: common_utils::id_type::PaymentId,
merchant_id: common_utils::id_type::MerchantId,
) -> CustomResult<FraudCheck, errors::StorageError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/db/fraud_check.rs | crate: router
use diesel_models::fraud_check::{self as storage, FraudCheck, FraudCheckUpdate};
use error_stack::report;
use crate::{
connection,
core::errors::{self, CustomResult},
services::Store,
};
async fn update_fraud_check_response_with_attempt_id(
&self,
this: FraudCheck,
fraud_check: FraudCheckUpdate,
) -> CustomResult<FraudCheck, errors::StorageError> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/db/fraud_check.rs | crate: router
use diesel_models::fraud_check::{self as storage, FraudCheck, FraudCheckUpdate};
use error_stack::report;
use crate::{
connection,
core::errors::{self, CustomResult},
services::Store,
};
async fn insert_fraud_check_response(
&self,
new: storage::FraudCheckNew,
) -> CustomResult<FraudCheck, errors::StorageError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/db/cards_info.rs | crate: router
use crate::{
connection,
core::errors::{self, CustomResult},
db::MockDb,
services::Store,
types::storage::cards_info::{CardInfo, UpdateCardInfo},
};
async fn update_card_info(
&self,
_card_iin: String,
_data: UpdateCardInfo,
) -> CustomResult<CardInfo, errors::StorageError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/db/cards_info.rs | crate: router
use crate::{
connection,
core::errors::{self, CustomResult},
db::MockDb,
services::Store,
types::storage::cards_info::{CardInfo, UpdateCardInfo},
};
async fn add_card_info(&self, _data: CardInfo) -> CustomResult<CardInfo, errors::StorageError> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/db/cards_info.rs | crate: router
use crate::{
connection,
core::errors::{self, CustomResult},
db::MockDb,
services::Store,
types::storage::cards_info::{CardInfo, UpdateCardInfo},
};
async fn get_card_info(
&self,
card_iin: &str,
) -> CustomResult<Option<CardInfo>, errors::StorageError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/db/cards_info.rs | crate: router
use error_stack::report;
use crate::{
connection,
core::errors::{self, CustomResult},
db::MockDb,
services::Store,
types::storage::cards_info::{CardInfo, UpdateCardInfo},
};
async fn update_card_info(
&self,
card_iin: String,
data: UpdateCardInfo,
) -> CustomResult<CardInfo, errors::StorageError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/db/cards_info.rs | crate: router
use error_stack::report;
use crate::{
connection,
core::errors::{self, CustomResult},
db::MockDb,
services::Store,
types::storage::cards_info::{CardInfo, UpdateCardInfo},
};
async fn add_card_info(&self, data: CardInfo) -> CustomResult<CardInfo, errors::StorageError> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/db/configs.rs | crate: router
use error_stack::report;
use storage_impl::redis::cache::{self, CacheKind, CONFIG_CACHE};
use crate::{
connection,
core::errors::{self, CustomResult},
db::StorageInterface,
types::storage,
};
async fn find_config_by_key_unwrap_or(
&self,
key: &str,
// If the config is not found it will be cached with the default value.
default_config: Option<String>,
) -> CustomResult<storage::Config, errors::StorageError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/db/configs.rs | crate: router
use storage_impl::redis::cache::{self, CacheKind, CONFIG_CACHE};
use crate::{
connection,
core::errors::{self, CustomResult},
db::StorageInterface,
types::storage,
};
async fn find_config_by_key_from_db(
&self,
key: &str,
) -> CustomResult<storage::Config, errors::StorageError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/db/configs.rs | crate: router
use storage_impl::redis::cache::{self, CacheKind, CONFIG_CACHE};
use crate::{
connection,
core::errors::{self, CustomResult},
db::StorageInterface,
types::storage,
};
async fn find_config_by_key_unwrap_or(
&self,
key: &str,
_default_config: Option<String>,
) -> CustomResult<storage::Config, errors::StorageError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/db/configs.rs | crate: router
use diesel_models::configs::ConfigUpdateInternal;
use storage_impl::redis::cache::{self, CacheKind, CONFIG_CACHE};
use crate::{
connection,
core::errors::{self, CustomResult},
db::StorageInterface,
types::storage,
};
async fn find_config_by_key(
&self,
key: &str,
) -> CustomResult<storage::Config, errors::StorageError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/db/configs.rs | crate: router
use diesel_models::configs::ConfigUpdateInternal;
use storage_impl::redis::cache::{self, CacheKind, CONFIG_CACHE};
use crate::{
connection,
core::errors::{self, CustomResult},
db::StorageInterface,
types::storage,
};
async fn delete_config_by_key(
&self,
key: &str,
) -> CustomResult<storage::Config, errors::StorageError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/db/configs.rs | crate: router
use diesel_models::configs::ConfigUpdateInternal;
use storage_impl::redis::cache::{self, CacheKind, CONFIG_CACHE};
use crate::{
connection,
core::errors::{self, CustomResult},
db::StorageInterface,
types::storage,
};
async fn update_config_by_key(
&self,
key: &str,
config_update: storage::ConfigUpdate,
) -> CustomResult<storage::Config, errors::StorageError> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/db/configs.rs | crate: router
use diesel_models::configs::ConfigUpdateInternal;
use storage_impl::redis::cache::{self, CacheKind, CONFIG_CACHE};
use crate::{
connection,
core::errors::{self, CustomResult},
db::StorageInterface,
types::storage,
};
async fn insert_config(
&self,
config: storage::ConfigNew,
) -> CustomResult<storage::Config, errors::StorageError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
// file: hyperswitch/crates/router/src/db/configs.rs | crate: router
use error_stack::report;
use storage_impl::redis::cache::{self, CacheKind, CONFIG_CACHE};
use crate::{
connection,
core::errors::{self, CustomResult},
db::StorageInterface,
types::storage,
};
async fn update_config_in_database(
&self,
key: &str,
config_update: storage::ConfigUpdate,
) -> CustomResult<storage::Config, errors::StorageError> {
let conn = connection::pg_connection_write(self).await?;
storage::Config::update_by_key(&conn, key, config_update)
.await
.map_err(|error| report!(errors::StorageError::from(error)))
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/db/blocklist_fingerprint.rs | crate: router
use crate::{
connection,
core::errors::{self, CustomResult},
db::kafka_store::KafkaStore,
types::storage,
};
async fn find_blocklist_fingerprint_by_merchant_id_fingerprint_id(
&self,
merchant_id: &common_utils::id_type::MerchantId,
fingerprint: &str,
) -> CustomResult<storage::BlocklistFingerprint, errors::StorageError> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/db/blocklist_fingerprint.rs | crate: router
use crate::{
connection,
core::errors::{self, CustomResult},
db::kafka_store::KafkaStore,
types::storage,
};
async fn insert_blocklist_fingerprint_entry(
&self,
pm_fingerprint_new: storage::BlocklistFingerprintNew,
) -> CustomResult<storage::BlocklistFingerprint, errors::StorageError> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/db/blocklist_fingerprint.rs | crate: router
use crate::{
connection,
core::errors::{self, CustomResult},
db::kafka_store::KafkaStore,
types::storage,
};
async fn find_blocklist_fingerprint_by_merchant_id_fingerprint_id(
&self,
_merchant_id: &common_utils::id_type::MerchantId,
_fingerprint_id: &str,
) -> CustomResult<storage::BlocklistFingerprint, errors::StorageError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/db/blocklist_fingerprint.rs | crate: router
use crate::{
connection,
core::errors::{self, CustomResult},
db::kafka_store::KafkaStore,
types::storage,
};
async fn insert_blocklist_fingerprint_entry(
&self,
_pm_fingerprint_new: storage::BlocklistFingerprintNew,
) -> CustomResult<storage::BlocklistFingerprint, errors::StorageError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/db/blocklist_fingerprint.rs | crate: router
use error_stack::report;
use crate::{
connection,
core::errors::{self, CustomResult},
db::kafka_store::KafkaStore,
types::storage,
};
async fn find_blocklist_fingerprint_by_merchant_id_fingerprint_id(
&self,
merchant_id: &common_utils::id_type::MerchantId,
fingerprint_id: &str,
) -> CustomResult<storage::BlocklistFingerprint, errors::StorageError> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
// file: hyperswitch/crates/router/src/db/blocklist_fingerprint.rs | crate: router
use error_stack::report;
use crate::{
connection,
core::errors::{self, CustomResult},
db::kafka_store::KafkaStore,
types::storage,
};
async fn insert_blocklist_fingerprint_entry(
&self,
pm_fingerprint_new: storage::BlocklistFingerprintNew,
) -> CustomResult<storage::BlocklistFingerprint, errors::StorageError> {
let conn = connection::pg_connection_write(self).await?;
pm_fingerprint_new
.insert(&conn)
.await
.map_err(|error| report!(errors::StorageError::from(error)))
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/db/payment_method_session.rs | crate: router
use crate::core::errors::{self, CustomResult};
async fn update_payment_method_session(
&self,
state: &common_utils::types::keymanager::KeyManagerState,
key_store: &hyperswitch_domain_models::merchant_key_store::MerchantKeyStore,
session_id: &common_utils::id_type::GlobalPaymentMethodSessionId,
update_request: hyperswitch_domain_models::payment_methods::PaymentMethodsSessionUpdateEnum,
current_session: hyperswitch_domain_models::payment_methods::PaymentMethodSession,
) -> CustomResult<
hyperswitch_domain_models::payment_methods::PaymentMethodSession,
errors::StorageError,
> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/db/payment_method_session.rs | crate: router
use crate::core::errors::{self, CustomResult};
async fn get_payment_methods_session(
&self,
state: &common_utils::types::keymanager::KeyManagerState,
key_store: &hyperswitch_domain_models::merchant_key_store::MerchantKeyStore,
id: &common_utils::id_type::GlobalPaymentMethodSessionId,
) -> CustomResult<
hyperswitch_domain_models::payment_methods::PaymentMethodSession,
errors::StorageError,
> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/db/payment_method_session.rs | crate: router
use crate::core::errors::{self, CustomResult};
async fn update_payment_method_session(
&self,
state: &common_utils::types::keymanager::KeyManagerState,
key_store: &hyperswitch_domain_models::merchant_key_store::MerchantKeyStore,
id: &common_utils::id_type::GlobalPaymentMethodSessionId,
payment_methods_session: hyperswitch_domain_models::payment_methods::PaymentMethodsSessionUpdateEnum,
current_session: hyperswitch_domain_models::payment_methods::PaymentMethodSession,
) -> CustomResult<
hyperswitch_domain_models::payment_methods::PaymentMethodSession,
errors::StorageError,
> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/db/payment_method_session.rs | crate: router
use crate::core::errors::{self, CustomResult};
async fn insert_payment_methods_session(
&self,
state: &common_utils::types::keymanager::KeyManagerState,
key_store: &hyperswitch_domain_models::merchant_key_store::MerchantKeyStore,
payment_methods_session: hyperswitch_domain_models::payment_methods::PaymentMethodSession,
validity_in_seconds: i64,
) -> CustomResult<(), errors::StorageError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/db/payment_method_session.rs | crate: router
use crate::core::errors::{self, CustomResult};
async fn insert_payment_methods_session(
&self,
_state: &common_utils::types::keymanager::KeyManagerState,
_key_store: &hyperswitch_domain_models::merchant_key_store::MerchantKeyStore,
payment_methods_session: hyperswitch_domain_models::payment_methods::PaymentMethodSession,
validity_in_seconds: i64,
) -> CustomResult<(), errors::StorageError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/db/blocklist_lookup.rs | crate: router
use crate::{
connection,
core::errors::{self, CustomResult},
db::kafka_store::KafkaStore,
types::storage,
};
async fn find_blocklist_lookup_entry_by_merchant_id_fingerprint(
&self,
merchant_id: &common_utils::id_type::MerchantId,
fingerprint: &str,
) -> CustomResult<storage::BlocklistLookup, errors::StorageError> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/db/blocklist_lookup.rs | crate: router
use crate::{
connection,
core::errors::{self, CustomResult},
db::kafka_store::KafkaStore,
types::storage,
};
async fn insert_blocklist_lookup_entry(
&self,
blocklist_lookup_entry: storage::BlocklistLookupNew,
) -> CustomResult<storage::BlocklistLookup, errors::StorageError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/db/blocklist_lookup.rs | crate: router
use crate::{
connection,
core::errors::{self, CustomResult},
db::kafka_store::KafkaStore,
types::storage,
};
async fn delete_blocklist_lookup_entry_by_merchant_id_fingerprint(
&self,
_merchant_id: &common_utils::id_type::MerchantId,
_fingerprint: &str,
) -> CustomResult<storage::BlocklistLookup, errors::StorageError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/db/blocklist_lookup.rs | crate: router
use crate::{
connection,
core::errors::{self, CustomResult},
db::kafka_store::KafkaStore,
types::storage,
};
async fn find_blocklist_lookup_entry_by_merchant_id_fingerprint(
&self,
_merchant_id: &common_utils::id_type::MerchantId,
_fingerprint: &str,
) -> CustomResult<storage::BlocklistLookup, errors::StorageError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/db/blocklist_lookup.rs | crate: router
use crate::{
connection,
core::errors::{self, CustomResult},
db::kafka_store::KafkaStore,
types::storage,
};
async fn insert_blocklist_lookup_entry(
&self,
_blocklist_lookup_entry: storage::BlocklistLookupNew,
) -> CustomResult<storage::BlocklistLookup, errors::StorageError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/db/blocklist_lookup.rs | crate: router
use error_stack::report;
use crate::{
connection,
core::errors::{self, CustomResult},
db::kafka_store::KafkaStore,
types::storage,
};
async fn delete_blocklist_lookup_entry_by_merchant_id_fingerprint(
&self,
merchant_id: &common_utils::id_type::MerchantId,
fingerprint: &str,
) -> CustomResult<storage::BlocklistLookup, errors::StorageError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/db/user_role.rs | crate: router
use diesel_models::{
enums::{self, UserStatus},
user_role as storage,
};
use error_stack::{report, ResultExt};
use crate::{
connection,
core::errors::{self, CustomResult},
services::Store,
};
async fn list_user_roles_by_org_id<'a>(
&self,
payload: ListUserRolesByOrgIdPayload<'a>,
) -> CustomResult<Vec<storage::UserRole>, errors::StorageError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/db/user_role.rs | crate: router
use diesel_models::{
enums::{self, UserStatus},
user_role as storage,
};
use crate::{
connection,
core::errors::{self, CustomResult},
services::Store,
};
async fn list_user_roles_by_user_id<'a>(
&self,
payload: ListUserRolesByUserIdPayload<'a>,
) -> CustomResult<Vec<storage::UserRole>, errors::StorageError> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/db/user_role.rs | crate: router
use common_utils::id_type;
use diesel_models::{
enums::{self, UserStatus},
user_role as storage,
};
use crate::{
connection,
core::errors::{self, CustomResult},
services::Store,
};
async fn delete_user_role_by_user_id_and_lineage(
&self,
user_id: &str,
tenant_id: &id_type::TenantId,
org_id: &id_type::OrganizationId,
merchant_id: &id_type::MerchantId,
profile_id: &id_type::ProfileId,
version: enums::UserRoleVersion,
) -> CustomResult<storage::UserRole, errors::StorageError> {
{
Some(idx) => Ok(user_roles.remove(idx)),<|fim_suffix|>
<|fim_middle|>
None => Err(errors::StorageError::ValueNotFound(
"Cannot find user role to delete".to_string(),
)
.into()),
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/db/user_role.rs | crate: router
use common_utils::id_type;
use diesel_models::{
enums::{self, UserStatus},
user_role as storage,
};
use crate::{
connection,
core::errors::{self, CustomResult},
services::Store,
};
async fn update_user_role_by_user_id_and_lineage(
&self,
user_id: &str,
tenant_id: &id_type::TenantId,
org_id: &id_type::OrganizationId,
merchant_id: Option<&id_type::MerchantId>,
profile_id: Option<&id_type::ProfileId>,
update: storage::UserRoleUpdate,
version: enums::UserRoleVersion,
) -> CustomResult<storage::UserRole, errors::StorageError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/db/user_role.rs | crate: router
use diesel_models::{
enums::{self, UserStatus},
user_role as storage,
};
use crate::{
connection,
core::errors::{self, CustomResult},
services::Store,
};
async fn insert_user_role(
&self,
user_role: storage::UserRoleNew,
) -> CustomResult<storage::UserRole, errors::StorageError> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/db/user_role.rs | crate: router
use diesel_models::{
enums::{self, UserStatus},
user_role as storage,
};
use error_stack::{report, ResultExt};
use crate::{
connection,
core::errors::{self, CustomResult},
services::Store,
};
async fn list_user_roles_by_user_id_across_tenants(
&self,
user_id: &str,
limit: Option<u32>,
) -> CustomResult<Vec<storage::UserRole>, errors::StorageError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/db/user_role.rs | crate: router
use common_utils::id_type;
use diesel_models::{
enums::{self, UserStatus},
user_role as storage,
};
use error_stack::{report, ResultExt};
use crate::{
connection,
core::errors::{self, CustomResult},
services::Store,
};
async fn delete_user_role_by_user_id_and_lineage(
&self,
user_id: &str,
tenant_id: &id_type::TenantId,
org_id: &id_type::OrganizationId,
merchant_id: &id_type::MerchantId,
profile_id: &id_type::ProfileId,
version: enums::UserRoleVersion,
) -> CustomResult<storage::UserRole, errors::StorageError> {
<|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.