text stringlengths 70 351k | source stringclasses 4 values |
|---|---|
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/inespay.rs | crate: hyperswitch_connectors | connector: inespay
merchant_id,
&connector_webhook_secrets,
)?;
let secret = connector_webhook_secrets.secret;
let signing_key = hmac::Key::new(hmac::HMAC_SHA256, &secret);
let signed_message = hmac::sign(&signing_key, &message);
let computed_signature = hex::encode(signed_message.as_ref());
let payload_sign = BASE64_ENGINE.encode(computed_signature);
Ok(payload_sign.as_bytes().eq(&signature))
}
fn get_webhook_object_reference_id(
&self,
request: &webhooks::IncomingWebhookRequestDetails<'_>,
) -> CustomResult<api_models::webhooks::ObjectReferenceId, errors::ConnectorError> {
let data_return = get_webhook_body(request.body)
.change_context(errors::ConnectorError::WebhookBodyDecodingFailed)?;
match data_return {
inespay::InespayWebhookEventData::Payment(data) => {
Ok(api_models::webhooks::ObjectReferenceId::PaymentId(
api_models::payments::PaymentIdType::ConnectorTransactionId(
data.single_payin_id,
),
))
fn get_webhook_object_reference_id(
&self,
request: &webhooks::IncomingWebhookRequestDetails<'_>,
) -> CustomResult<api_models::webhooks::ObjectReferenceId, errors::ConnectorError> {
{
inespay::InespayWebhookEventData::Payment(data) => {
Ok(api_models::webhooks::ObjectReferenceId::PaymentId(
api_models::payments::PaymentIdType::ConnectorTransactionId(
data.single_payin_id,
),
))
}<|fim_suffix|>
<|fim_middle|>
inespay::InespayWebhookEventData::Refund(data) => {
Ok(api_models::webhooks::ObjectReferenceId::RefundId(
api_models::webhooks::RefundIdType::ConnectorRefundId(data.refund_id),
))
}
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/inespay.rs | crate: hyperswitch_connectors | connector: inespay
use common_utils::{
consts::BASE64_ENGINE,
crypto,
errors::CustomResult,
ext_traits::{ByteSliceExt, BytesExt},
request::{Method, Request, RequestBuilder, RequestContent},
types::{AmountConvertor, StringMinorUnit, StringMinorUnitForConnector},
};
use hyperswitch_interfaces::{
api::{
self, ConnectorCommon, ConnectorCommonExt, ConnectorIntegration, ConnectorSpecifications,
ConnectorValidation,
},
configs::Connectors,
errors,
events::connector_api_logs::ConnectorEvent,
types::{self, Response},
webhooks,
};
use transformers as inespay;
fn get_webhook_body(
body: &[u8],
) -> CustomResult<inespay::InespayWebhookEventData, errors::ConnectorError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/inespay.rs | crate: hyperswitch_connectors | connector: inespay
use common_utils::{
consts::BASE64_ENGINE,
crypto,
errors::CustomResult,
ext_traits::{ByteSliceExt, BytesExt},
request::{Method, Request, RequestBuilder, RequestContent},
types::{AmountConvertor, StringMinorUnit, StringMinorUnitForConnector},
};
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, ConnectorSpecifications,
ConnectorValidation,
},
configs::Connectors,
errors,
events::connector_api_logs::ConnectorEvent,
types::{self, Response},
webhooks,
};
use crate::{constants::headers, types::ResponseRouterData, utils};
fn build_request(
&self,
req: &RefundsRouterData<Execute>,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
let request = RequestBuilder::new()
.method(Method::Post)
.url(&types::RefundExecuteType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(types::RefundExecuteType::get_headers(
self, req, connectors,
)?)
.set_body(types::RefundExecuteType::get_request_body(
self, req, connectors,
)?)
.build();
Ok(Some(request))
} | ast_fragments |
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/inespay.rs | crate: hyperswitch_connectors | connector: inespay
use common_utils::{
consts::BASE64_ENGINE,
crypto,
errors::CustomResult,
ext_traits::{ByteSliceExt, BytesExt},
request::{Method, Request, RequestBuilder, RequestContent},
types::{AmountConvertor, StringMinorUnit, StringMinorUnitForConnector},
};
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, ConnectorSpecifications,
ConnectorValidation,
},
configs::Connectors,
errors,
events::connector_api_logs::ConnectorEvent,
types::{self, Response},
webhooks,
};
fn get_request_body(
&self,
_req: &PaymentsCaptureRouterData,
_connectors: &Connectors,
) -> CustomResult<RequestContent, errors::ConnectorError> {
Err(errors::ConnectorError::NotImplemented("get_request_body method".to_string()).into())
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/adyen.rs | crate: hyperswitch_connectors | connector: adyen
res: Response,
event_builder: Option<&mut ConnectorEvent>,
) -> CustomResult<ErrorResponse, errors::ConnectorError> {
self.build_error_response(res, event_builder)
}
}
impl UploadFile for Adyen {}
impl RetrieveFile for Adyen {}
impl ConnectorIntegration<Retrieve, RetrieveFileRequestData, RetrieveFileResponse> for Adyen {}
impl ConnectorIntegration<Upload, UploadFileRequestData, UploadFileResponse> for Adyen {}
#[async_trait::async_trait]
impl FileUpload for Adyen {
fn validate_file_upload(
&self,
purpose: FilePurpose,
file_size: i32,
file_type: mime::Mime,
) -> CustomResult<(), errors::ConnectorError> {
match purpose {
FilePurpose::DisputeEvidence => {
let supported_file_types =
["image/jpeg", "image/jpg", "image/png", "application/pdf"];
if !supported_file_types.contains(&file_type.to_string().as_str()) {
Err(errors::ConnectorError::FileValidationFailed {
reason: "file_type does not match JPEG, JPG, PNG, or PDF format".to_owned(),
fn validate_file_upload(
&self,
purpose: FilePurpose,
file_size: i32,
file_type: mime::Mime,
) -> CustomResult<(), errors::ConnectorError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/adyen.rs | crate: hyperswitch_connectors | connector: adyen | op: verify
notif.original_reference.unwrap_or_default(),
notif.merchant_account_code,
notif.merchant_reference,
notif.amount.value,
notif.amount.currency,
notif.event_code,
notif.success
);
Ok(message.into_bytes())
}
async fn verify_webhook_source(
&self,
request: &IncomingWebhookRequestDetails<'_>,
merchant_id: &common_utils::id_type::MerchantId,
connector_webhook_details: Option<common_utils::pii::SecretSerdeValue>,
_connector_account_details: common_utils::crypto::Encryptable<Secret<serde_json::Value>>,
connector_label: &str,
) -> CustomResult<bool, errors::ConnectorError> {
let connector_webhook_secrets = self
.get_webhook_source_verification_merchant_secret(
merchant_id,
connector_label,
connector_webhook_details,
async fn verify_webhook_source(
&self,
request: &IncomingWebhookRequestDetails<'_>,
merchant_id: &common_utils::id_type::MerchantId,
connector_webhook_details: Option<common_utils::pii::SecretSerdeValue>,
_connector_account_details: common_utils::crypto::Encryptable<Secret<serde_json::Value>>,
connector_label: &str,
) -> CustomResult<bool, errors::ConnectorError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/adyen.rs | crate: hyperswitch_connectors | connector: adyen
Ok(format!(
"{}pal/servlet/Payout/{}/{}",
endpoint,
ADYEN_API_VERSION,
match payout_type {
enums::PayoutType::Bank | enums::PayoutType::Wallet =>
"confirmThirdParty".to_string(),
enums::PayoutType::Card => "payout".to_string(),
}
))
}
fn get_headers(
&self,
req: &PayoutsRouterData<PoFulfill>,
_connectors: &Connectors,
) -> CustomResult<Vec<(String, Maskable<String>)>, errors::ConnectorError> {
let mut header = vec![(
headers::CONTENT_TYPE.to_string(),
PayoutFulfillType::get_content_type(self).to_string().into(),
)];
let auth = adyen::AdyenAuthType::try_from(&req.connector_auth_type)
.change_context(errors::ConnectorError::FailedToObtainAuthType)?;
let payout_type = req
.request
fn get_headers(
&self,
req: &PayoutsRouterData<PoFulfill>,
_connectors: &Connectors,
) -> CustomResult<Vec<(String, Maskable<String>)>, errors::ConnectorError> {
let mut header = vec![(
headers::CONTENT_TYPE.to_string(),
PayoutFulfillType::get_content_type(self).to_string().into(),
)];
let auth = adyen::AdyenAuthType::try_from(&req.connector_auth_type)
.change_context(errors::ConnectorError::FailedToObtainAuthType)?;
let payout_type = req
.request
.payout_type
.to_owned()
.get_required_value("payout_type")
.change_context(errors::ConnectorError::MissingRequiredField {
field_name: "payout_type",
})?;
let mut api_key = vec![(
headers::X_API_KEY.to_string(),
match payout_type {
enums::PayoutType::Bank | enums::PayoutType::Wallet => {
auth.review_key.unwrap_or(auth.api_key).into_masked()
}
enums::PayoutType::Card => auth.api_key.into_masked(),
},
)];
header.append(&mut api_key);
Ok(header)
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/adyen.rs | crate: hyperswitch_connectors | connector: adyen
.method(Method::Post)
.url(&PaymentsSyncType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(PaymentsSyncType::get_headers(self, req, connectors)?)
.set_body(PaymentsSyncType::get_request_body(self, req, connectors)?)
.build(),
))
} else {
Ok(None)
}
}
fn handle_response(
&self,
data: &RouterData<PSync, PaymentsSyncData, PaymentsResponseData>,
event_builder: Option<&mut ConnectorEvent>,
res: Response,
) -> CustomResult<PaymentsSyncRouterData, errors::ConnectorError> {
router_env::logger::debug!(payment_sync_response=?res);
let response: adyen::AdyenPaymentResponse = res
.response
.parse_struct("AdyenPaymentResponse")
.change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
event_builder.map(|i| i.set_response_body(&response));
fn handle_response(
&self,
data: &RouterData<PSync, PaymentsSyncData, PaymentsResponseData>,
event_builder: Option<&mut ConnectorEvent>,
res: Response,
) -> CustomResult<PaymentsSyncRouterData, errors::ConnectorError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/adyen.rs | crate: hyperswitch_connectors | connector: adyen
req: &RouterData<PSync, PaymentsSyncData, PaymentsResponseData>,
_connectors: &Connectors,
) -> CustomResult<Vec<(String, Maskable<String>)>, errors::ConnectorError> {
let mut header = vec![(
headers::CONTENT_TYPE.to_string(),
PaymentsSyncType::get_content_type(self).to_string().into(),
)];
let mut api_key = self.get_auth_header(&req.connector_auth_type)?;
header.append(&mut api_key);
Ok(header)
}
fn get_request_body(
&self,
req: &RouterData<PSync, PaymentsSyncData, PaymentsResponseData>,
_connectors: &Connectors,
) -> CustomResult<RequestContent, errors::ConnectorError> {
let encoded_data = req
.request
.encoded_data
.clone()
.get_required_value("encoded_data")
.change_context(errors::ConnectorError::RequestEncodingFailed)?;
let adyen_redirection_type = serde_urlencoded::from_str::<
transformers::AdyenRedirectRequestTypes,
fn get_request_body(
&self,
req: &RouterData<PSync, PaymentsSyncData, PaymentsResponseData>,
_connectors: &Connectors,
) -> CustomResult<RequestContent, errors::ConnectorError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/adyen.rs | crate: hyperswitch_connectors | connector: adyen
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Ok(Some(
RequestBuilder::new()
.method(Method::Post)
.url(&SetupMandateType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(SetupMandateType::get_headers(self, req, connectors)?)
.set_body(SetupMandateType::get_request_body(self, req, connectors)?)
.build(),
))
}
fn handle_response(
&self,
data: &SetupMandateRouterData,
event_builder: Option<&mut ConnectorEvent>,
res: Response,
) -> CustomResult<
RouterData<SetupMandate, SetupMandateRequestData, PaymentsResponseData>,
errors::ConnectorError,
>
where
SetupMandate: Clone,
SetupMandateRequestData: Clone,
PaymentsResponseData: Clone,
fn handle_response(
&self,
data: &SetupMandateRouterData,
event_builder: Option<&mut ConnectorEvent>,
res: Response,
) -> CustomResult<
RouterData<SetupMandate, SetupMandateRequestData, PaymentsResponseData>,
errors::ConnectorError,
>
where
SetupMandate: Clone,
SetupMandateRequestData: Clone,
PaymentsResponseData: Clone,
{
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/adyen.rs | crate: hyperswitch_connectors | connector: adyen
))
}
fn get_request_body(
&self,
req: &DefendDisputeRouterData,
_connectors: &Connectors,
) -> CustomResult<RequestContent, errors::ConnectorError> {
let connector_req = adyen::AdyenDefendDisputeRequest::try_from(req)?;
Ok(RequestContent::Json(Box::new(connector_req)))
}
fn handle_response(
&self,
data: &DefendDisputeRouterData,
_event_builder: Option<&mut ConnectorEvent>,
res: Response,
) -> CustomResult<DefendDisputeRouterData, errors::ConnectorError> {
let response: adyen::AdyenDisputeResponse = res
.response
.parse_struct("AdyenDisputeResponse")
.change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
RouterData::foreign_try_from((data, response))
.change_context(errors::ConnectorError::ResponseHandlingFailed)
}
fn handle_response(
&self,
data: &DefendDisputeRouterData,
_event_builder: Option<&mut ConnectorEvent>,
res: Response,
) -> CustomResult<DefendDisputeRouterData, errors::ConnectorError> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/adyen.rs | crate: hyperswitch_connectors | connector: adyen
Ok(format!(
"{}pal/servlet/Payout/{}/{}",
endpoint,
ADYEN_API_VERSION,
match payout_type {
enums::PayoutType::Bank | enums::PayoutType::Wallet =>
"confirmThirdParty".to_string(),
enums::PayoutType::Card => "payout".to_string(),
}
))
}
fn get_headers(
&self,
req: &PayoutsRouterData<PoFulfill>,
_connectors: &Connectors,
) -> CustomResult<Vec<(String, Maskable<String>)>, errors::ConnectorError> {
let mut header = vec![(
headers::CONTENT_TYPE.to_string(),
PayoutFulfillType::get_content_type(self).to_string().into(),
)];
let auth = adyen::AdyenAuthType::try_from(&req.connector_auth_type)
.change_context(errors::ConnectorError::FailedToObtainAuthType)?;
let payout_type = req
.request
fn get_headers(
&self,
req: &PayoutsRouterData<PoFulfill>,
_connectors: &Connectors,
) -> CustomResult<Vec<(String, Maskable<String>)>, errors::ConnectorError> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/adyen.rs | crate: hyperswitch_connectors | connector: adyen
.url(&PaymentsPreProcessingType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(PaymentsPreProcessingType::get_headers(
self, req, connectors,
)?)
.set_body(PaymentsPreProcessingType::get_request_body(
self, req, connectors,
)?)
.build(),
))
}
fn handle_response(
&self,
data: &PaymentsPreProcessingRouterData,
event_builder: Option<&mut ConnectorEvent>,
res: Response,
) -> CustomResult<PaymentsPreProcessingRouterData, errors::ConnectorError> {
let response: adyen::AdyenBalanceResponse = res
.response
.parse_struct("AdyenBalanceResponse")
.change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
event_builder.map(|i| i.set_response_body(&response));
router_env::logger::info!(connector_response=?response);
fn handle_response(
&self,
data: &PaymentsPreProcessingRouterData,
event_builder: Option<&mut ConnectorEvent>,
res: Response,
) -> CustomResult<PaymentsPreProcessingRouterData, errors::ConnectorError> {
{
Some(amount) => amount,<|fim_suffix|>
<|fim_middle|>
None => Err(errors::ConnectorError::MissingRequiredField {
field_name: "amount",
})?,
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/adyen.rs | crate: hyperswitch_connectors | connector: adyen
Ok(CaptureSyncMethod::Individual)
}
fn get_5xx_error_response(
&self,
res: Response,
event_builder: Option<&mut ConnectorEvent>,
) -> CustomResult<ErrorResponse, errors::ConnectorError> {
self.build_error_response(res, event_builder)
}
}
impl ConnectorIntegration<Authorize, PaymentsAuthorizeData, PaymentsResponseData> for Adyen {
fn get_headers(
&self,
req: &PaymentsAuthorizeRouterData,
_connectors: &Connectors,
) -> CustomResult<Vec<(String, Maskable<String>)>, errors::ConnectorError>
where
Self: ConnectorIntegration<Authorize, PaymentsAuthorizeData, PaymentsResponseData>,
{
let mut header = vec![(
headers::CONTENT_TYPE.to_string(),
PaymentsAuthorizeType::get_content_type(self)
.to_string()
.into(),
fn get_headers(
&self,
req: &PaymentsAuthorizeRouterData,
_connectors: &Connectors,
) -> CustomResult<Vec<(String, Maskable<String>)>, errors::ConnectorError>
where
Self: ConnectorIntegration<Authorize, PaymentsAuthorizeData, PaymentsResponseData>,
{
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/adyen.rs | crate: hyperswitch_connectors | connector: adyen
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
let request = RequestBuilder::new()
.method(Method::Post)
.url(&SubmitEvidenceType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(SubmitEvidenceType::get_headers(self, req, connectors)?)
.set_body(SubmitEvidenceType::get_request_body(self, req, connectors)?)
.build();
Ok(Some(request))
}
fn handle_response(
&self,
data: &SubmitEvidenceRouterData,
_event_builder: Option<&mut ConnectorEvent>,
res: Response,
) -> CustomResult<SubmitEvidenceRouterData, errors::ConnectorError> {
let response: adyen::AdyenDisputeResponse = res
.response
.parse_struct("AdyenDisputeResponse")
.change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
RouterData::foreign_try_from((data, response))
.change_context(errors::ConnectorError::ResponseHandlingFailed)
}
fn handle_response(
&self,
data: &SubmitEvidenceRouterData,
_event_builder: Option<&mut ConnectorEvent>,
res: Response,
) -> CustomResult<SubmitEvidenceRouterData, errors::ConnectorError> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/adyen.rs | crate: hyperswitch_connectors | connector: adyen
))
}
fn get_request_body(
&self,
req: &SubmitEvidenceRouterData,
_connectors: &Connectors,
) -> CustomResult<RequestContent, errors::ConnectorError> {
let connector_req = adyen::Evidence::try_from(req)?;
Ok(RequestContent::Json(Box::new(connector_req)))
}
fn build_request(
&self,
req: &SubmitEvidenceRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
let request = RequestBuilder::new()
.method(Method::Post)
.url(&SubmitEvidenceType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(SubmitEvidenceType::get_headers(self, req, connectors)?)
.set_body(SubmitEvidenceType::get_request_body(self, req, connectors)?)
.build();
Ok(Some(request))
fn build_request(
&self,
req: &SubmitEvidenceRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/adyen.rs | crate: hyperswitch_connectors | connector: adyen
}
fn get_error_response(
&self,
res: Response,
event_builder: Option<&mut ConnectorEvent>,
) -> CustomResult<ErrorResponse, errors::ConnectorError> {
self.build_error_response(res, event_builder)
}
}
impl ConnectorIntegration<Evidence, SubmitEvidenceRequestData, SubmitEvidenceResponse> for Adyen {
fn get_headers(
&self,
req: &SubmitEvidenceRouterData,
_connectors: &Connectors,
) -> CustomResult<Vec<(String, Maskable<String>)>, errors::ConnectorError> {
let mut header = vec![(
headers::CONTENT_TYPE.to_string(),
SubmitEvidenceType::get_content_type(self)
.to_string()
.into(),
)];
let mut api_key = self.get_auth_header(&req.connector_auth_type)?;
header.append(&mut api_key);
fn get_headers(
&self,
req: &SubmitEvidenceRouterData,
_connectors: &Connectors,
) -> CustomResult<Vec<(String, Maskable<String>)>, errors::ConnectorError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/adyen.rs | crate: hyperswitch_connectors | connector: adyen
))
}
fn get_request_body(
&self,
req: &DefendDisputeRouterData,
_connectors: &Connectors,
) -> CustomResult<RequestContent, errors::ConnectorError> {
let connector_req = adyen::AdyenDefendDisputeRequest::try_from(req)?;
Ok(RequestContent::Json(Box::new(connector_req)))
}
fn handle_response(
&self,
data: &DefendDisputeRouterData,
_event_builder: Option<&mut ConnectorEvent>,
res: Response,
) -> CustomResult<DefendDisputeRouterData, errors::ConnectorError> {
let response: adyen::AdyenDisputeResponse = res
.response
.parse_struct("AdyenDisputeResponse")
.change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
RouterData::foreign_try_from((data, response))
.change_context(errors::ConnectorError::ResponseHandlingFailed)
}
fn handle_response(
&self,
data: &DefendDisputeRouterData,
_event_builder: Option<&mut ConnectorEvent>,
res: Response,
) -> CustomResult<DefendDisputeRouterData, errors::ConnectorError> {
let response: adyen::AdyenDisputeResponse = res
.response
.parse_struct("AdyenDisputeResponse")
.change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
RouterData::foreign_try_from((data, response))
.change_context(errors::ConnectorError::ResponseHandlingFailed)
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/adyen.rs | crate: hyperswitch_connectors | connector: adyen
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Ok(Some(
RequestBuilder::new()
.method(Method::Post)
.url(&DefendDisputeType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(DefendDisputeType::get_headers(self, req, connectors)?)
.set_body(DefendDisputeType::get_request_body(self, req, connectors)?)
.build(),
))
}
fn get_request_body(
&self,
req: &DefendDisputeRouterData,
_connectors: &Connectors,
) -> CustomResult<RequestContent, errors::ConnectorError> {
let connector_req = adyen::AdyenDefendDisputeRequest::try_from(req)?;
Ok(RequestContent::Json(Box::new(connector_req)))
}
fn handle_response(
&self,
data: &DefendDisputeRouterData,
_event_builder: Option<&mut ConnectorEvent>,
fn get_request_body(
&self,
req: &DefendDisputeRouterData,
_connectors: &Connectors,
) -> CustomResult<RequestContent, errors::ConnectorError> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/adyen.rs | crate: hyperswitch_connectors | connector: adyen
req: &DefendDisputeRouterData,
_connectors: &Connectors,
) -> CustomResult<Vec<(String, Maskable<String>)>, errors::ConnectorError> {
let mut header = vec![(
headers::CONTENT_TYPE.to_string(),
DefendDisputeType::get_content_type(self).to_string().into(),
)];
let mut api_key = self.get_auth_header(&req.connector_auth_type)?;
header.append(&mut api_key);
Ok(header)
}
fn get_url(
&self,
req: &DefendDisputeRouterData,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
let endpoint = build_env_specific_endpoint(
connectors.adyen.dispute_base_url.as_str(),
req.test_mode,
&req.connector_meta_data,
)?;
Ok(format!(
"{}ca/services/DisputeService/v30/defendDispute",
endpoint
fn get_url(
&self,
req: &DefendDisputeRouterData,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/adyen.rs | crate: hyperswitch_connectors | connector: adyen
}
fn get_error_response(
&self,
res: Response,
event_builder: Option<&mut ConnectorEvent>,
) -> CustomResult<ErrorResponse, errors::ConnectorError> {
self.build_error_response(res, event_builder)
}
}
impl ConnectorIntegration<Defend, DefendDisputeRequestData, DefendDisputeResponse> for Adyen {
fn get_headers(
&self,
req: &DefendDisputeRouterData,
_connectors: &Connectors,
) -> CustomResult<Vec<(String, Maskable<String>)>, errors::ConnectorError> {
let mut header = vec![(
headers::CONTENT_TYPE.to_string(),
DefendDisputeType::get_content_type(self).to_string().into(),
)];
let mut api_key = self.get_auth_header(&req.connector_auth_type)?;
header.append(&mut api_key);
Ok(header)
}
fn get_headers(
&self,
req: &DefendDisputeRouterData,
_connectors: &Connectors,
) -> CustomResult<Vec<(String, Maskable<String>)>, errors::ConnectorError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/adyen.rs | crate: hyperswitch_connectors | connector: adyen
.build(),
))
}
fn get_request_body(
&self,
req: &AcceptDisputeRouterData,
_connectors: &Connectors,
) -> CustomResult<RequestContent, errors::ConnectorError> {
let connector_req = adyen::AdyenAcceptDisputeRequest::try_from(req)?;
Ok(RequestContent::Json(Box::new(connector_req)))
}
fn handle_response(
&self,
data: &AcceptDisputeRouterData,
_event_builder: Option<&mut ConnectorEvent>,
res: Response,
) -> CustomResult<AcceptDisputeRouterData, errors::ConnectorError> {
let response: adyen::AdyenDisputeResponse = res
.response
.parse_struct("AdyenDisputeResponse")
.change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
RouterData::foreign_try_from((data, response))
.change_context(errors::ConnectorError::ResponseHandlingFailed)
}
fn handle_response(
&self,
data: &AcceptDisputeRouterData,
_event_builder: Option<&mut ConnectorEvent>,
res: Response,
) -> CustomResult<AcceptDisputeRouterData, errors::ConnectorError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/adyen.rs | crate: hyperswitch_connectors | connector: adyen
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Ok(Some(
RequestBuilder::new()
.method(Method::Post)
.url(&AcceptDisputeType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(AcceptDisputeType::get_headers(self, req, connectors)?)
.set_body(AcceptDisputeType::get_request_body(self, req, connectors)?)
.build(),
))
}
fn get_request_body(
&self,
req: &AcceptDisputeRouterData,
_connectors: &Connectors,
) -> CustomResult<RequestContent, errors::ConnectorError> {
let connector_req = adyen::AdyenAcceptDisputeRequest::try_from(req)?;
Ok(RequestContent::Json(Box::new(connector_req)))
}
fn handle_response(
&self,
data: &AcceptDisputeRouterData,
_event_builder: Option<&mut ConnectorEvent>,
fn get_request_body(
&self,
req: &AcceptDisputeRouterData,
_connectors: &Connectors,
) -> CustomResult<RequestContent, errors::ConnectorError> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/adyen.rs | crate: hyperswitch_connectors | connector: adyen
) -> CustomResult<String, errors::ConnectorError> {
let endpoint = build_env_specific_endpoint(
connectors.adyen.dispute_base_url.as_str(),
req.test_mode,
&req.connector_meta_data,
)?;
Ok(format!(
"{}ca/services/DisputeService/v30/acceptDispute",
endpoint
))
}
fn build_request(
&self,
req: &AcceptDisputeRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Ok(Some(
RequestBuilder::new()
.method(Method::Post)
.url(&AcceptDisputeType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(AcceptDisputeType::get_headers(self, req, connectors)?)
.set_body(AcceptDisputeType::get_request_body(self, req, connectors)?)
.build(),
fn build_request(
&self,
req: &AcceptDisputeRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/adyen.rs | crate: hyperswitch_connectors | connector: adyen
req: &AcceptDisputeRouterData,
_connectors: &Connectors,
) -> CustomResult<Vec<(String, Maskable<String>)>, errors::ConnectorError> {
let mut header = vec![(
headers::CONTENT_TYPE.to_string(),
AcceptDisputeType::get_content_type(self).to_string().into(),
)];
let mut api_key = self.get_auth_header(&req.connector_auth_type)?;
header.append(&mut api_key);
Ok(header)
}
fn get_url(
&self,
req: &AcceptDisputeRouterData,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
let endpoint = build_env_specific_endpoint(
connectors.adyen.dispute_base_url.as_str(),
req.test_mode,
&req.connector_meta_data,
)?;
Ok(format!(
"{}ca/services/DisputeService/v30/acceptDispute",
endpoint
fn get_url(
&self,
req: &AcceptDisputeRouterData,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/adyen.rs | crate: hyperswitch_connectors | connector: adyen
)
});
Ok(optional_network_txn_id)
}
}
impl Dispute for Adyen {}
impl DefendDispute for Adyen {}
impl AcceptDispute for Adyen {}
impl SubmitEvidence for Adyen {}
impl ConnectorIntegration<Accept, AcceptDisputeRequestData, AcceptDisputeResponse> for Adyen {
fn get_headers(
&self,
req: &AcceptDisputeRouterData,
_connectors: &Connectors,
) -> CustomResult<Vec<(String, Maskable<String>)>, errors::ConnectorError> {
let mut header = vec![(
headers::CONTENT_TYPE.to_string(),
AcceptDisputeType::get_content_type(self).to_string().into(),
)];
let mut api_key = self.get_auth_header(&req.connector_auth_type)?;
header.append(&mut api_key);
Ok(header)
}
fn get_headers(
&self,
req: &AcceptDisputeRouterData,
_connectors: &Connectors,
) -> CustomResult<Vec<(String, Maskable<String>)>, errors::ConnectorError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/adyen.rs | crate: hyperswitch_connectors | connector: adyen
),
));
}
#[cfg(feature = "payouts")]
if adyen::is_payout_event(¬if.event_code) {
return Ok(api_models::webhooks::ObjectReferenceId::PayoutId(
api_models::webhooks::PayoutIdType::PayoutAttemptId(notif.merchant_reference),
));
}
Err(report!(errors::ConnectorError::WebhookReferenceIdNotFound))
}
fn get_webhook_event_type(
&self,
request: &IncomingWebhookRequestDetails<'_>,
) -> CustomResult<api_models::webhooks::IncomingWebhookEvent, errors::ConnectorError> {
let notif = get_webhook_object_from_body(request.body)
.change_context(errors::ConnectorError::WebhookEventTypeNotFound)?;
Ok(transformers::get_adyen_webhook_event(
notif.event_code,
notif.success,
notif.additional_data.dispute_status,
))
}
fn get_webhook_event_type(
&self,
request: &IncomingWebhookRequestDetails<'_>,
) -> CustomResult<api_models::webhooks::IncomingWebhookEvent, errors::ConnectorError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/adyen.rs | crate: hyperswitch_connectors | connector: adyen
let item_object = webhook
.notification_items
.drain(..)
.next()
// TODO: ParsingError doesn't seem to be an apt error for this case
.ok_or(common_utils::errors::ParsingError::UnknownError)?;
Ok(item_object.notification_request_item)
}
#[async_trait::async_trait]
impl IncomingWebhook for Adyen {
fn get_webhook_source_verification_algorithm(
&self,
_request: &IncomingWebhookRequestDetails<'_>,
) -> CustomResult<Box<dyn common_utils::crypto::VerifySignature + Send>, errors::ConnectorError>
{
Ok(Box::new(common_utils::crypto::HmacSha256))
}
fn get_webhook_source_verification_signature(
&self,
request: &IncomingWebhookRequestDetails<'_>,
_connector_webhook_secrets: &api_models::webhooks::ConnectorWebhookSecrets,
) -> CustomResult<Vec<u8>, errors::ConnectorError> {
fn get_webhook_source_verification_algorithm(
&self,
_request: &IncomingWebhookRequestDetails<'_>,
) -> CustomResult<Box<dyn common_utils::crypto::VerifySignature + Send>, errors::ConnectorError>
{
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/adyen.rs | crate: hyperswitch_connectors | connector: adyen
use common_utils::{
consts,
errors::CustomResult,
ext_traits::{ByteSliceExt, OptionExt},
request::{Method, Request, RequestBuilder, RequestContent},
types::{AmountConvertor, MinorUnit, MinorUnitForConnector},
};
use hyperswitch_interfaces::{
api::{
self,
disputes::{AcceptDispute, DefendDispute, Dispute, SubmitEvidence},
files::{FilePurpose, FileUpload, RetrieveFile, UploadFile},
CaptureSyncMethod, ConnectorCommon, ConnectorIntegration, ConnectorSpecifications,
ConnectorValidation,
},
configs::Connectors,
consts::{NO_ERROR_CODE, NO_ERROR_MESSAGE},
disputes, errors,
events::connector_api_logs::ConnectorEvent,
types::{
AcceptDisputeType, DefendDisputeType, PaymentsAuthorizeType, PaymentsCaptureType,
PaymentsPreProcessingType, PaymentsSyncType, PaymentsVoidType, RefundExecuteType, Response,
SetupMandateType, SubmitEvidenceType,
},
webhooks::{IncomingWebhook, IncomingWebhookFlowError, IncomingWebhookRequestDetails},
};
use transformers as adyen;
fn get_webhook_object_from_body(
body: &[u8],
) -> CustomResult<adyen::AdyenNotificationRequestItemWH, common_utils::errors::ParsingError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/adyen.rs | crate: hyperswitch_connectors | connector: adyen
res: Response,
event_builder: Option<&mut ConnectorEvent>,
) -> CustomResult<ErrorResponse, errors::ConnectorError> {
self.build_error_response(res, event_builder)
}
}
impl api::Refund for Adyen {}
impl api::RefundExecute for Adyen {}
impl api::RefundSync for Adyen {}
impl ConnectorIntegration<Execute, RefundsData, RefundsResponseData> for Adyen {
fn get_headers(
&self,
req: &RefundsRouterData<Execute>,
_connectors: &Connectors,
) -> CustomResult<Vec<(String, Maskable<String>)>, errors::ConnectorError> {
let mut header = vec![(
headers::CONTENT_TYPE.to_string(),
RefundExecuteType::get_content_type(self).to_string().into(),
)];
let mut api_header = self.get_auth_header(&req.connector_auth_type)?;
header.append(&mut api_header);
Ok(header)
}
fn get_headers(
&self,
req: &RefundsRouterData<Execute>,
_connectors: &Connectors,
) -> CustomResult<Vec<(String, Maskable<String>)>, errors::ConnectorError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/adyen.rs | crate: hyperswitch_connectors | connector: adyen
}
fn get_5xx_error_response(
&self,
res: Response,
event_builder: Option<&mut ConnectorEvent>,
) -> CustomResult<ErrorResponse, errors::ConnectorError> {
self.build_error_response(res, event_builder)
}
}
#[cfg(feature = "payouts")]
impl ConnectorIntegration<PoFulfill, PayoutsData, PayoutsResponseData> for Adyen {
fn get_url(
&self,
req: &PayoutsRouterData<PoFulfill>,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
let endpoint = build_env_specific_endpoint(
connectors.adyen.payout_base_url.as_str(),
req.test_mode,
&req.connector_meta_data,
)?;
let payout_type = req.request.get_payout_type()?;
Ok(format!(
"{}pal/servlet/Payout/{}/{}",
fn get_url(
&self,
req: &PayoutsRouterData<PoFulfill>,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/adyen.rs | crate: hyperswitch_connectors | connector: adyen
.url(&PayoutEligibilityType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(PayoutEligibilityType::get_headers(self, req, connectors)?)
.set_body(PayoutEligibilityType::get_request_body(
self, req, connectors,
)?)
.build();
Ok(Some(request))
}
#[instrument(skip_all)]
fn handle_response(
&self,
data: &PayoutsRouterData<PoEligibility>,
event_builder: Option<&mut ConnectorEvent>,
res: Response,
) -> CustomResult<PayoutsRouterData<PoEligibility>, errors::ConnectorError> {
let response: adyen::AdyenPayoutResponse = res
.response
.parse_struct("AdyenPayoutResponse")
.change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
event_builder.map(|i| i.set_response_body(&response));
router_env::logger::info!(connector_response=?response);
RouterData::try_from(ResponseRouterData {
fn handle_response(
&self,
data: &PayoutsRouterData<PoEligibility>,
event_builder: Option<&mut ConnectorEvent>,
res: Response,
) -> CustomResult<PayoutsRouterData<PoEligibility>, errors::ConnectorError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/adyen.rs | crate: hyperswitch_connectors | connector: adyen
) -> CustomResult<RequestContent, errors::ConnectorError> {
let amount = connector_utils::convert_amount(
self.amount_converter,
req.request.minor_amount,
req.request.destination_currency,
)?;
let connector_router_data = adyen::AdyenRouterData::try_from((amount, req))?;
let connector_req = adyen::AdyenPayoutEligibilityRequest::try_from(&connector_router_data)?;
Ok(RequestContent::Json(Box::new(connector_req)))
}
fn build_request(
&self,
req: &PayoutsRouterData<PoEligibility>,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
let request = RequestBuilder::new()
.method(Method::Post)
.url(&PayoutEligibilityType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(PayoutEligibilityType::get_headers(self, req, connectors)?)
.set_body(PayoutEligibilityType::get_request_body(
self, req, connectors,
)?)
fn build_request(
&self,
req: &PayoutsRouterData<PoEligibility>,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/adyen.rs | crate: hyperswitch_connectors | connector: adyen
) -> CustomResult<Vec<(String, Maskable<String>)>, errors::ConnectorError> {
let mut header = vec![(
headers::CONTENT_TYPE.to_string(),
PayoutEligibilityType::get_content_type(self)
.to_string()
.into(),
)];
let mut api_key = self.get_auth_header(&req.connector_auth_type)?;
header.append(&mut api_key);
Ok(header)
}
fn get_request_body(
&self,
req: &PayoutsRouterData<PoEligibility>,
_connectors: &Connectors,
) -> CustomResult<RequestContent, errors::ConnectorError> {
let amount = connector_utils::convert_amount(
self.amount_converter,
req.request.minor_amount,
req.request.destination_currency,
)?;
let connector_router_data = adyen::AdyenRouterData::try_from((amount, req))?;
let connector_req = adyen::AdyenPayoutEligibilityRequest::try_from(&connector_router_data)?;
fn get_request_body(
&self,
req: &PayoutsRouterData<PoEligibility>,
_connectors: &Connectors,
) -> CustomResult<RequestContent, errors::ConnectorError> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/adyen.rs | crate: hyperswitch_connectors | connector: adyen
&self,
req: &PayoutsRouterData<PoEligibility>,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
let endpoint = build_env_specific_endpoint(
self.base_url(connectors),
req.test_mode,
&req.connector_meta_data,
)?;
Ok(format!("{}{}/payments", endpoint, ADYEN_API_VERSION))
}
fn get_headers(
&self,
req: &PayoutsRouterData<PoEligibility>,
_connectors: &Connectors,
) -> CustomResult<Vec<(String, Maskable<String>)>, errors::ConnectorError> {
let mut header = vec![(
headers::CONTENT_TYPE.to_string(),
PayoutEligibilityType::get_content_type(self)
.to_string()
.into(),
)];
let mut api_key = self.get_auth_header(&req.connector_auth_type)?;
header.append(&mut api_key);
fn get_headers(
&self,
req: &PayoutsRouterData<PoEligibility>,
_connectors: &Connectors,
) -> CustomResult<Vec<(String, Maskable<String>)>, errors::ConnectorError> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/adyen.rs | crate: hyperswitch_connectors | connector: adyen
}
fn get_5xx_error_response(
&self,
res: Response,
event_builder: Option<&mut ConnectorEvent>,
) -> CustomResult<ErrorResponse, errors::ConnectorError> {
self.build_error_response(res, event_builder)
}
}
#[cfg(feature = "payouts")]
impl ConnectorIntegration<PoEligibility, PayoutsData, PayoutsResponseData> for Adyen {
fn get_url(
&self,
req: &PayoutsRouterData<PoEligibility>,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
let endpoint = build_env_specific_endpoint(
self.base_url(connectors),
req.test_mode,
&req.connector_meta_data,
)?;
Ok(format!("{}{}/payments", endpoint, ADYEN_API_VERSION))
}
fn get_url(
&self,
req: &PayoutsRouterData<PoEligibility>,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/adyen.rs | crate: hyperswitch_connectors | connector: adyen
let request = RequestBuilder::new()
.method(Method::Post)
.url(&PayoutCreateType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(PayoutCreateType::get_headers(self, req, connectors)?)
.set_body(PayoutCreateType::get_request_body(self, req, connectors)?)
.build();
Ok(Some(request))
}
#[instrument(skip_all)]
fn handle_response(
&self,
data: &PayoutsRouterData<PoCreate>,
event_builder: Option<&mut ConnectorEvent>,
res: Response,
) -> CustomResult<PayoutsRouterData<PoCreate>, errors::ConnectorError> {
let response: adyen::AdyenPayoutResponse = res
.response
.parse_struct("AdyenPayoutResponse")
.change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
event_builder.map(|i| i.set_response_body(&response));
router_env::logger::info!(connector_response=?response);
RouterData::try_from(ResponseRouterData {
fn handle_response(
&self,
data: &PayoutsRouterData<PoCreate>,
event_builder: Option<&mut ConnectorEvent>,
res: Response,
) -> CustomResult<PayoutsRouterData<PoCreate>, errors::ConnectorError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/adyen.rs | crate: hyperswitch_connectors | connector: adyen
_connectors: &Connectors,
) -> CustomResult<RequestContent, errors::ConnectorError> {
let amount = connector_utils::convert_amount(
self.amount_converter,
req.request.minor_amount,
req.request.destination_currency,
)?;
let connector_router_data = adyen::AdyenRouterData::try_from((amount, req))?;
let connector_req = adyen::AdyenPayoutCreateRequest::try_from(&connector_router_data)?;
Ok(RequestContent::Json(Box::new(connector_req)))
}
fn build_request(
&self,
req: &PayoutsRouterData<PoCreate>,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
let request = RequestBuilder::new()
.method(Method::Post)
.url(&PayoutCreateType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(PayoutCreateType::get_headers(self, req, connectors)?)
.set_body(PayoutCreateType::get_request_body(self, req, connectors)?)
.build();
fn build_request(
&self,
req: &PayoutsRouterData<PoCreate>,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/adyen.rs | crate: hyperswitch_connectors | connector: adyen
req: &PayoutsRouterData<PoCreate>,
_connectors: &Connectors,
) -> CustomResult<Vec<(String, Maskable<String>)>, errors::ConnectorError> {
let mut header = vec![(
headers::CONTENT_TYPE.to_string(),
PayoutCreateType::get_content_type(self).to_string().into(),
)];
let mut api_key = self.get_auth_header(&req.connector_auth_type)?;
header.append(&mut api_key);
Ok(header)
}
fn get_request_body(
&self,
req: &PayoutsRouterData<PoCreate>,
_connectors: &Connectors,
) -> CustomResult<RequestContent, errors::ConnectorError> {
let amount = connector_utils::convert_amount(
self.amount_converter,
req.request.minor_amount,
req.request.destination_currency,
)?;
let connector_router_data = adyen::AdyenRouterData::try_from((amount, req))?;
let connector_req = adyen::AdyenPayoutCreateRequest::try_from(&connector_router_data)?;
Ok(RequestContent::Json(Box::new(connector_req)))
fn get_request_body(
&self,
req: &PayoutsRouterData<PoCreate>,
_connectors: &Connectors,
) -> CustomResult<RequestContent, errors::ConnectorError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/adyen.rs | crate: hyperswitch_connectors | connector: adyen
) -> CustomResult<String, errors::ConnectorError> {
let endpoint = build_env_specific_endpoint(
connectors.adyen.payout_base_url.as_str(),
req.test_mode,
&req.connector_meta_data,
)?;
Ok(format!(
"{}pal/servlet/Payout/{}/storeDetailAndSubmitThirdParty",
endpoint, ADYEN_API_VERSION
))
}
fn get_headers(
&self,
req: &PayoutsRouterData<PoCreate>,
_connectors: &Connectors,
) -> CustomResult<Vec<(String, Maskable<String>)>, errors::ConnectorError> {
let mut header = vec![(
headers::CONTENT_TYPE.to_string(),
PayoutCreateType::get_content_type(self).to_string().into(),
)];
let mut api_key = self.get_auth_header(&req.connector_auth_type)?;
header.append(&mut api_key);
Ok(header)
}
fn get_headers(
&self,
req: &PayoutsRouterData<PoCreate>,
_connectors: &Connectors,
) -> CustomResult<Vec<(String, Maskable<String>)>, errors::ConnectorError> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/adyen.rs | crate: hyperswitch_connectors | connector: adyen
}
fn get_5xx_error_response(
&self,
res: Response,
event_builder: Option<&mut ConnectorEvent>,
) -> CustomResult<ErrorResponse, errors::ConnectorError> {
self.build_error_response(res, event_builder)
}
}
#[cfg(feature = "payouts")]
impl ConnectorIntegration<PoCreate, PayoutsData, PayoutsResponseData> for Adyen {
fn get_url(
&self,
req: &PayoutsRouterData<PoCreate>,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
let endpoint = build_env_specific_endpoint(
connectors.adyen.payout_base_url.as_str(),
req.test_mode,
&req.connector_meta_data,
)?;
Ok(format!(
"{}pal/servlet/Payout/{}/storeDetailAndSubmitThirdParty",
endpoint, ADYEN_API_VERSION
fn get_url(
&self,
req: &PayoutsRouterData<PoCreate>,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/adyen.rs | crate: hyperswitch_connectors | connector: adyen
let request = RequestBuilder::new()
.method(Method::Post)
.url(&PayoutCancelType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(PayoutCancelType::get_headers(self, req, connectors)?)
.set_body(PayoutCancelType::get_request_body(self, req, connectors)?)
.build();
Ok(Some(request))
}
#[instrument(skip_all)]
fn handle_response(
&self,
data: &PayoutsRouterData<PoCancel>,
event_builder: Option<&mut ConnectorEvent>,
res: Response,
) -> CustomResult<PayoutsRouterData<PoCancel>, errors::ConnectorError> {
let response: adyen::AdyenPayoutResponse = res
.response
.parse_struct("AdyenPayoutResponse")
.change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
event_builder.map(|i| i.set_response_body(&response));
router_env::logger::info!(connector_response=?response);
RouterData::try_from(ResponseRouterData {
fn handle_response(
&self,
data: &PayoutsRouterData<PoCancel>,
event_builder: Option<&mut ConnectorEvent>,
res: Response,
) -> CustomResult<PayoutsRouterData<PoCancel>, errors::ConnectorError> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/adyen.rs | crate: hyperswitch_connectors | connector: adyen
Ok(header)
}
fn get_request_body(
&self,
req: &PayoutsRouterData<PoCancel>,
_connectors: &Connectors,
) -> CustomResult<RequestContent, errors::ConnectorError> {
let connector_req = adyen::AdyenPayoutCancelRequest::try_from(req)?;
Ok(RequestContent::Json(Box::new(connector_req)))
}
fn build_request(
&self,
req: &PayoutsRouterData<PoCancel>,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
let request = RequestBuilder::new()
.method(Method::Post)
.url(&PayoutCancelType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(PayoutCancelType::get_headers(self, req, connectors)?)
.set_body(PayoutCancelType::get_request_body(self, req, connectors)?)
.build();
fn build_request(
&self,
req: &PayoutsRouterData<PoCancel>,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/adyen.rs | crate: hyperswitch_connectors | connector: adyen
PayoutCancelType::get_content_type(self).to_string().into(),
)];
let auth = adyen::AdyenAuthType::try_from(&req.connector_auth_type)
.change_context(errors::ConnectorError::FailedToObtainAuthType)?;
let mut api_key = vec![(
headers::X_API_KEY.to_string(),
auth.review_key.unwrap_or(auth.api_key).into_masked(),
)];
header.append(&mut api_key);
Ok(header)
}
fn get_request_body(
&self,
req: &PayoutsRouterData<PoCancel>,
_connectors: &Connectors,
) -> CustomResult<RequestContent, errors::ConnectorError> {
let connector_req = adyen::AdyenPayoutCancelRequest::try_from(req)?;
Ok(RequestContent::Json(Box::new(connector_req)))
}
fn build_request(
&self,
req: &PayoutsRouterData<PoCancel>,
connectors: &Connectors,
fn get_request_body(
&self,
req: &PayoutsRouterData<PoCancel>,
_connectors: &Connectors,
) -> CustomResult<RequestContent, errors::ConnectorError> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/adyen.rs | crate: hyperswitch_connectors | connector: adyen
) -> CustomResult<String, errors::ConnectorError> {
let endpoint = build_env_specific_endpoint(
connectors.adyen.payout_base_url.as_str(),
req.test_mode,
&req.connector_meta_data,
)?;
Ok(format!(
"{}pal/servlet/Payout/{}/declineThirdParty",
endpoint, ADYEN_API_VERSION
))
}
fn get_headers(
&self,
req: &PayoutsRouterData<PoCancel>,
_connectors: &Connectors,
) -> CustomResult<Vec<(String, Maskable<String>)>, errors::ConnectorError> {
let mut header = vec![(
headers::CONTENT_TYPE.to_string(),
PayoutCancelType::get_content_type(self).to_string().into(),
)];
let auth = adyen::AdyenAuthType::try_from(&req.connector_auth_type)
.change_context(errors::ConnectorError::FailedToObtainAuthType)?;
let mut api_key = vec![(
headers::X_API_KEY.to_string(),
fn get_headers(
&self,
req: &PayoutsRouterData<PoCancel>,
_connectors: &Connectors,
) -> CustomResult<Vec<(String, Maskable<String>)>, errors::ConnectorError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/adyen.rs | crate: hyperswitch_connectors | connector: adyen
impl api::Payouts for Adyen {}
#[cfg(feature = "payouts")]
impl api::PayoutCancel for Adyen {}
#[cfg(feature = "payouts")]
impl api::PayoutCreate for Adyen {}
#[cfg(feature = "payouts")]
impl api::PayoutEligibility for Adyen {}
#[cfg(feature = "payouts")]
impl api::PayoutFulfill for Adyen {}
#[cfg(feature = "payouts")]
impl ConnectorIntegration<PoCancel, PayoutsData, PayoutsResponseData> for Adyen {
fn get_url(
&self,
req: &PayoutsRouterData<PoCancel>,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
let endpoint = build_env_specific_endpoint(
connectors.adyen.payout_base_url.as_str(),
req.test_mode,
&req.connector_meta_data,
)?;
Ok(format!(
"{}pal/servlet/Payout/{}/declineThirdParty",
endpoint, ADYEN_API_VERSION
fn get_url(
&self,
req: &PayoutsRouterData<PoCancel>,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/adyen.rs | crate: hyperswitch_connectors | connector: adyen
}
fn get_5xx_error_response(
&self,
res: Response,
event_builder: Option<&mut ConnectorEvent>,
) -> CustomResult<ErrorResponse, errors::ConnectorError> {
self.build_error_response(res, event_builder)
}
}
impl ConnectorIntegration<Void, PaymentsCancelData, PaymentsResponseData> for Adyen {
fn get_headers(
&self,
req: &PaymentsCancelRouterData,
_connectors: &Connectors,
) -> CustomResult<Vec<(String, Maskable<String>)>, errors::ConnectorError> {
let mut header = vec![(
headers::CONTENT_TYPE.to_string(),
PaymentsAuthorizeType::get_content_type(self)
.to_string()
.into(),
)];
let mut api_key = self.get_auth_header(&req.connector_auth_type)?;
header.append(&mut api_key);
fn get_headers(
&self,
req: &PaymentsCancelRouterData,
_connectors: &Connectors,
) -> CustomResult<Vec<(String, Maskable<String>)>, errors::ConnectorError> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/adyen.rs | crate: hyperswitch_connectors | connector: adyen
}
fn get_request_body(
&self,
req: &PaymentsPreProcessingRouterData,
_connectors: &Connectors,
) -> CustomResult<RequestContent, errors::ConnectorError> {
let connector_req = adyen::AdyenBalanceRequest::try_from(req)?;
Ok(RequestContent::Json(Box::new(connector_req)))
}
fn build_request(
&self,
req: &PaymentsPreProcessingRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Ok(Some(
RequestBuilder::new()
.method(Method::Post)
.url(&PaymentsPreProcessingType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(PaymentsPreProcessingType::get_headers(
self, req, connectors,
)?)
fn build_request(
&self,
req: &PaymentsPreProcessingRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Ok(Some(
RequestBuilder::new()
.method(Method::Post)
.url(&PaymentsPreProcessingType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(PaymentsPreProcessingType::get_headers(
self, req, connectors,
)?)
.set_body(PaymentsPreProcessingType::get_request_body(
self, req, connectors,
)?)
.build(),
))
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/adyen.rs | crate: hyperswitch_connectors | connector: adyen
) -> CustomResult<Vec<(String, Maskable<String>)>, errors::ConnectorError> {
let mut header = vec![(
headers::CONTENT_TYPE.to_string(),
PaymentsPreProcessingType::get_content_type(self)
.to_string()
.into(),
)];
let mut api_key = self.get_auth_header(&req.connector_auth_type)?;
header.append(&mut api_key);
Ok(header)
}
fn get_url(
&self,
req: &PaymentsPreProcessingRouterData,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
let endpoint = build_env_specific_endpoint(
self.base_url(connectors),
req.test_mode,
&req.connector_meta_data,
)?;
Ok(format!(
"{}{}/paymentMethods/balance",
endpoint, ADYEN_API_VERSION
fn get_url(
&self,
req: &PaymentsPreProcessingRouterData,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/adyen.rs | crate: hyperswitch_connectors | connector: adyen
res: Response,
event_builder: Option<&mut ConnectorEvent>,
) -> CustomResult<ErrorResponse, errors::ConnectorError> {
self.build_error_response(res, event_builder)
}
}
impl api::PaymentsPreProcessing for Adyen {}
impl ConnectorIntegration<PreProcessing, PaymentsPreProcessingData, PaymentsResponseData>
for Adyen
{
fn get_headers(
&self,
req: &PaymentsPreProcessingRouterData,
_connectors: &Connectors,
) -> CustomResult<Vec<(String, Maskable<String>)>, errors::ConnectorError> {
let mut header = vec![(
headers::CONTENT_TYPE.to_string(),
PaymentsPreProcessingType::get_content_type(self)
.to_string()
.into(),
)];
let mut api_key = self.get_auth_header(&req.connector_auth_type)?;
header.append(&mut api_key);
fn get_headers(
&self,
req: &PaymentsPreProcessingRouterData,
_connectors: &Connectors,
) -> CustomResult<Vec<(String, Maskable<String>)>, errors::ConnectorError> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/adyen.rs | crate: hyperswitch_connectors | connector: adyen
RequestBuilder::new()
.method(Method::Post)
.url(&PaymentsAuthorizeType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(PaymentsAuthorizeType::get_headers(self, req, connectors)?)
.set_body(PaymentsAuthorizeType::get_request_body(
self, req, connectors,
)?)
.build(),
))
}
fn handle_response(
&self,
data: &PaymentsAuthorizeRouterData,
event_builder: Option<&mut ConnectorEvent>,
res: Response,
) -> CustomResult<PaymentsAuthorizeRouterData, errors::ConnectorError> {
let response: adyen::AdyenPaymentResponse = res
.response
.parse_struct("AdyenPaymentResponse")
.change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
event_builder.map(|i| i.set_response_body(&response));
router_env::logger::info!(connector_response=?response);
RouterData::foreign_try_from((
fn handle_response(
&self,
data: &PaymentsAuthorizeRouterData,
event_builder: Option<&mut ConnectorEvent>,
res: Response,
) -> CustomResult<PaymentsAuthorizeRouterData, errors::ConnectorError> {
let response: adyen::AdyenPaymentResponse = res
.response
.parse_struct("AdyenPaymentResponse")
.change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
event_builder.map(|i| i.set_response_body(&response));
router_env::logger::info!(connector_response=?response);
RouterData::foreign_try_from((
ResponseRouterData {
response,
data: data.clone(),
http_code: res.status_code,
},
data.request.capture_method,
false,
data.request.payment_method_type,
))
.change_context(errors::ConnectorError::ResponseHandlingFailed)
} | ast_fragments |
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/adyen.rs | crate: hyperswitch_connectors | connector: adyen
Ok(CaptureSyncMethod::Individual)
}
fn get_5xx_error_response(
&self,
res: Response,
event_builder: Option<&mut ConnectorEvent>,
) -> CustomResult<ErrorResponse, errors::ConnectorError> {
self.build_error_response(res, event_builder)
}
}
impl ConnectorIntegration<Authorize, PaymentsAuthorizeData, PaymentsResponseData> for Adyen {
fn get_headers(
&self,
req: &PaymentsAuthorizeRouterData,
_connectors: &Connectors,
) -> CustomResult<Vec<(String, Maskable<String>)>, errors::ConnectorError>
where
Self: ConnectorIntegration<Authorize, PaymentsAuthorizeData, PaymentsResponseData>,
{
let mut header = vec![(
headers::CONTENT_TYPE.to_string(),
PaymentsAuthorizeType::get_content_type(self)
.to_string()
.into(),
fn get_headers(
&self,
req: &PaymentsAuthorizeRouterData,
_connectors: &Connectors,
) -> CustomResult<Vec<(String, Maskable<String>)>, errors::ConnectorError>
where
Self: ConnectorIntegration<Authorize, PaymentsAuthorizeData, PaymentsResponseData>,
{
let mut header = vec![(
headers::CONTENT_TYPE.to_string(),
PaymentsAuthorizeType::get_content_type(self)
.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/hyperswitch_connectors/src/connectors/adyen.rs | crate: hyperswitch_connectors | connector: adyen
adyen::AdyenRedirectRequestTypes::AdyenRefusal(req) => adyen::AdyenRedirectRequest {
details: adyen::AdyenRedirectRequestTypes::AdyenRefusal(adyen::AdyenRefusal {
payload: req.payload,
type_of_redirection_result: None,
result_code: None,
}),
},
};
Ok(RequestContent::Json(Box::new(connector_req)))
}
fn get_url(
&self,
req: &RouterData<PSync, PaymentsSyncData, PaymentsResponseData>,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
let endpoint = build_env_specific_endpoint(
self.base_url(connectors),
req.test_mode,
&req.connector_meta_data,
)?;
Ok(format!(
"{}{}/payments/details",
endpoint, ADYEN_API_VERSION
fn get_url(
&self,
req: &RouterData<PSync, PaymentsSyncData, PaymentsResponseData>,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/adyen.rs | crate: hyperswitch_connectors | connector: adyen
fn get_5xx_error_response(
&self,
res: Response,
event_builder: Option<&mut ConnectorEvent>,
) -> CustomResult<ErrorResponse, errors::ConnectorError> {
self.build_error_response(res, event_builder)
}
}
/// Payment Sync can be useful only incase of Redirect flow.
/// For payments which doesn't involve redrection we have to rely on webhooks.
impl ConnectorIntegration<PSync, PaymentsSyncData, PaymentsResponseData> for Adyen {
fn get_headers(
&self,
req: &RouterData<PSync, PaymentsSyncData, PaymentsResponseData>,
_connectors: &Connectors,
) -> CustomResult<Vec<(String, Maskable<String>)>, errors::ConnectorError> {
let mut header = vec![(
headers::CONTENT_TYPE.to_string(),
PaymentsSyncType::get_content_type(self).to_string().into(),
)];
let mut api_key = self.get_auth_header(&req.connector_auth_type)?;
header.append(&mut api_key);
Ok(header)
}
fn get_headers(
&self,
req: &RouterData<PSync, PaymentsSyncData, PaymentsResponseData>,
_connectors: &Connectors,
) -> CustomResult<Vec<(String, Maskable<String>)>, errors::ConnectorError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/adyen.rs | crate: hyperswitch_connectors | connector: adyen
) -> CustomResult<ErrorResponse, errors::ConnectorError> {
self.build_error_response(res, event_builder)
}
}
impl api::PaymentSession for Adyen {}
impl ConnectorIntegration<Session, PaymentsSessionData, PaymentsResponseData> for Adyen {
// Not Implemented (R)
}
impl ConnectorIntegration<Capture, PaymentsCaptureData, PaymentsResponseData> for Adyen {
fn get_headers(
&self,
req: &PaymentsCaptureRouterData,
_connectors: &Connectors,
) -> CustomResult<Vec<(String, Maskable<String>)>, errors::ConnectorError> {
let mut header = vec![(
headers::CONTENT_TYPE.to_string(),
self.common_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)
}
fn get_headers(
&self,
req: &PaymentsCaptureRouterData,
_connectors: &Connectors,
) -> CustomResult<Vec<(String, Maskable<String>)>, errors::ConnectorError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/adyen.rs | crate: hyperswitch_connectors | connector: adyen
req: &SetupMandateRouterData,
_connectors: &Connectors,
) -> CustomResult<Vec<(String, Maskable<String>)>, errors::ConnectorError> {
let mut header = vec![(
headers::CONTENT_TYPE.to_string(),
SetupMandateType::get_content_type(self).to_string().into(),
)];
let mut api_key = self.get_auth_header(&req.connector_auth_type)?;
header.append(&mut api_key);
Ok(header)
}
fn get_url(
&self,
req: &SetupMandateRouterData,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
let endpoint = build_env_specific_endpoint(
self.base_url(connectors),
req.test_mode,
&req.connector_meta_data,
)?;
Ok(format!("{}{}/payments", endpoint, ADYEN_API_VERSION))
}
fn get_request_body(
fn get_url(
&self,
req: &SetupMandateRouterData,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/adyen.rs | crate: hyperswitch_connectors | connector: adyen
let adyen_connector_metadata_object =
transformers::AdyenConnectorMetadataObject::try_from(connector_metadata)?;
let endpoint_prefix = adyen_connector_metadata_object.endpoint_prefix.ok_or(
errors::ConnectorError::InvalidConnectorConfig {
config: "metadata.endpoint_prefix",
},
)?;
Ok(base_url.replace("{{merchant_endpoint_prefix}}", &endpoint_prefix))
}
}
impl ConnectorIntegration<SetupMandate, SetupMandateRequestData, PaymentsResponseData> for Adyen {
fn get_headers(
&self,
req: &SetupMandateRouterData,
_connectors: &Connectors,
) -> CustomResult<Vec<(String, Maskable<String>)>, errors::ConnectorError> {
let mut header = vec![(
headers::CONTENT_TYPE.to_string(),
SetupMandateType::get_content_type(self).to_string().into(),
)];
let mut api_key = self.get_auth_header(&req.connector_auth_type)?;
header.append(&mut api_key);
Ok(header)
}
fn get_headers(
&self,
req: &SetupMandateRouterData,
_connectors: &Connectors,
) -> CustomResult<Vec<(String, Maskable<String>)>, errors::ConnectorError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/adyen.rs | crate: hyperswitch_connectors | connector: adyen
use common_utils::{
consts,
errors::CustomResult,
ext_traits::{ByteSliceExt, OptionExt},
request::{Method, Request, RequestBuilder, RequestContent},
types::{AmountConvertor, MinorUnit, MinorUnitForConnector},
};
use hyperswitch_interfaces::{
api::{
self,
disputes::{AcceptDispute, DefendDispute, Dispute, SubmitEvidence},
files::{FilePurpose, FileUpload, RetrieveFile, UploadFile},
CaptureSyncMethod, ConnectorCommon, ConnectorIntegration, ConnectorSpecifications,
ConnectorValidation,
},
configs::Connectors,
consts::{NO_ERROR_CODE, NO_ERROR_MESSAGE},
disputes, errors,
events::connector_api_logs::ConnectorEvent,
types::{
AcceptDisputeType, DefendDisputeType, PaymentsAuthorizeType, PaymentsCaptureType,
PaymentsPreProcessingType, PaymentsSyncType, PaymentsVoidType, RefundExecuteType, Response,
SetupMandateType, SubmitEvidenceType,
},
webhooks::{IncomingWebhook, IncomingWebhookFlowError, IncomingWebhookRequestDetails},
};
use transformers as adyen;
fn build_env_specific_endpoint(
base_url: &str,
test_mode: Option<bool>,
connector_metadata: &Option<common_utils::pii::SecretSerdeValue>,
) -> CustomResult<String, errors::ConnectorError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/adyen.rs | crate: hyperswitch_connectors | connector: adyen | op: sync
PaymentMethodDataType::KlarnaRedirect,
PaymentMethodDataType::Ideal,
PaymentMethodDataType::OpenBankingUk,
PaymentMethodDataType::Trustly,
PaymentMethodDataType::BancontactCard,
PaymentMethodDataType::AchBankDebit,
PaymentMethodDataType::SepaBankDebit,
PaymentMethodDataType::BecsBankDebit,
]);
is_mandate_supported(pm_data, pm_type, mandate_supported_pmd, self.id())
}
fn validate_psync_reference_id(
&self,
data: &PaymentsSyncData,
_is_three_ds: bool,
_status: enums::AttemptStatus,
_connector_meta_data: Option<common_utils::pii::SecretSerdeValue>,
) -> CustomResult<(), errors::ConnectorError> {
if data.encoded_data.is_some() {
return Ok(());
}
Err(errors::ConnectorError::MissingRequiredField {
field_name: "encoded_data",
}
fn validate_psync_reference_id(
&self,
data: &PaymentsSyncData,
_is_three_ds: bool,
_status: enums::AttemptStatus,
_connector_meta_data: Option<common_utils::pii::SecretSerdeValue>,
) -> CustomResult<(), errors::ConnectorError> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/adyen.rs | crate: hyperswitch_connectors | connector: adyen
&Self {
amount_converter: &MinorUnitForConnector,
}
}
}
impl ConnectorCommon for Adyen {
fn id(&self) -> &'static str {
"adyen"
}
fn get_currency_unit(&self) -> api::CurrencyUnit {
api::CurrencyUnit::Minor
}
fn get_auth_header(
&self,
auth_type: &ConnectorAuthType,
) -> CustomResult<Vec<(String, Maskable<String>)>, errors::ConnectorError> {
let auth = adyen::AdyenAuthType::try_from(auth_type)
.change_context(errors::ConnectorError::FailedToObtainAuthType)?;
Ok(vec![(
headers::X_API_KEY.to_string(),
auth.api_key.into_masked(),
)])
}
fn base_url<'a>(&self, connectors: &'a Connectors) -> &'a str {
connectors.adyen.base_url.as_ref()
fn get_auth_header(
&self,
auth_type: &ConnectorAuthType,
) -> CustomResult<Vec<(String, Maskable<String>)>, errors::ConnectorError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/adyen.rs | crate: hyperswitch_connectors | connector: adyen
message: response.message.to_owned(),
reason: Some(response.message),
attempt_status: None,
connector_transaction_id: response.psp_reference,
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
})
}
}
impl ConnectorValidation for Adyen {
fn validate_connector_against_payment_request(
&self,
capture_method: Option<enums::CaptureMethod>,
_payment_method: enums::PaymentMethod,
pmt: Option<PaymentMethodType>,
) -> CustomResult<(), errors::ConnectorError> {
let capture_method = capture_method.unwrap_or_default();
let connector = self.id();
match pmt {
Some(payment_method_type) => match payment_method_type {
#[cfg(feature = "v1")]
PaymentMethodType::Affirm
| PaymentMethodType::AfterpayClearpay
fn validate_connector_against_payment_request(
&self,
capture_method: Option<enums::CaptureMethod>,
_payment_method: enums::PaymentMethod,
pmt: Option<PaymentMethodType>,
) -> CustomResult<(), errors::ConnectorError> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/chargebee.rs | crate: hyperswitch_connectors | connector: chargebee | op: verify
use common_utils::types::{StringMinorUnit, StringMinorUnitForConnector};
use common_utils::{
consts::BASE64_ENGINE,
errors::CustomResult,
ext_traits::BytesExt,
request::{Method, Request, RequestBuilder, RequestContent},
types::{AmountConvertor, MinorUnit, MinorUnitForConnector},
};
use hyperswitch_interfaces::{
api::{
self, ConnectorCommon, ConnectorCommonExt, ConnectorIntegration, ConnectorSpecifications,
ConnectorValidation,
},
configs::Connectors,
errors,
events::connector_api_logs::ConnectorEvent,
types::{self, Response},
webhooks,
};
use masking::{Mask, PeekInterface, Secret};
async fn verify_webhook_source(
&self,
request: &webhooks::IncomingWebhookRequestDetails<'_>,
merchant_id: &common_utils::id_type::MerchantId,
connector_webhook_details: Option<common_utils::pii::SecretSerdeValue>,
_connector_account_details: common_utils::crypto::Encryptable<Secret<serde_json::Value>>,
connector_label: &str,
) -> CustomResult<bool, errors::ConnectorError> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/chargebee.rs | crate: hyperswitch_connectors | connector: chargebee
let invoice_id = req
.request
.merchant_reference_id
.get_string_repr()
.to_string();
Ok(format!("{url}v2/invoices/{invoice_id}/record_payment"))
}
fn get_content_type(&self) -> &'static str {
self.common_get_content_type()
}
fn get_request_body(
&self,
req: &RevenueRecoveryRecordBackRouterData,
_connectors: &Connectors,
) -> CustomResult<RequestContent, errors::ConnectorError> {
let amount = utils::convert_amount(
self.amount_converter,
req.request.amount,
req.request.currency,
)?;
let connector_router_data = chargebee::ChargebeeRouterData::from((amount, req));
let connector_req =
chargebee::ChargebeeRecordPaymentRequest::try_from(&connector_router_data)?;
fn get_request_body(
&self,
req: &RevenueRecoveryRecordBackRouterData,
_connectors: &Connectors,
) -> CustomResult<RequestContent, errors::ConnectorError> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/chargebee.rs | crate: hyperswitch_connectors | connector: chargebee
self.build_error_response(res, event_builder)
}
}
#[cfg(all(feature = "v2", feature = "revenue_recovery"))]
impl
ConnectorIntegration<
RecoveryRecordBack,
RevenueRecoveryRecordBackRequest,
RevenueRecoveryRecordBackResponse,
> for Chargebee
{
fn get_headers(
&self,
req: &RevenueRecoveryRecordBackRouterData,
connectors: &Connectors,
) -> CustomResult<Vec<(String, masking::Maskable<String>)>, errors::ConnectorError> {
self.build_headers(req, connectors)
}
fn get_url(
&self,
req: &RevenueRecoveryRecordBackRouterData,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
let metadata: chargebee::ChargebeeMetadata =
fn get_headers(
&self,
req: &RevenueRecoveryRecordBackRouterData,
connectors: &Connectors,
) -> CustomResult<Vec<(String, masking::Maskable<String>)>, errors::ConnectorError> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/chargebee.rs | crate: hyperswitch_connectors | connector: chargebee
use common_utils::{
consts::BASE64_ENGINE,
errors::CustomResult,
ext_traits::BytesExt,
request::{Method, Request, RequestBuilder, RequestContent},
types::{AmountConvertor, MinorUnit, MinorUnitForConnector},
};
use hyperswitch_domain_models::{
revenue_recovery, router_flow_types::revenue_recovery::RecoveryRecordBack,
router_request_types::revenue_recovery::RevenueRecoveryRecordBackRequest,
router_response_types::revenue_recovery::RevenueRecoveryRecordBackResponse,
types::RevenueRecoveryRecordBackRouterData,
};
use hyperswitch_interfaces::{
api::{
self, ConnectorCommon, ConnectorCommonExt, ConnectorIntegration, ConnectorSpecifications,
ConnectorValidation,
},
configs::Connectors,
errors,
events::connector_api_logs::ConnectorEvent,
types::{self, Response},
webhooks,
};
use transformers as chargebee;
fn get_revenue_recovery_invoice_details(
&self,
request: &webhooks::IncomingWebhookRequestDetails<'_>,
) -> CustomResult<revenue_recovery::RevenueRecoveryInvoiceData, errors::ConnectorError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/chargebee.rs | crate: hyperswitch_connectors | connector: chargebee
use common_utils::{
consts::BASE64_ENGINE,
errors::CustomResult,
ext_traits::BytesExt,
request::{Method, Request, RequestBuilder, RequestContent},
types::{AmountConvertor, MinorUnit, MinorUnitForConnector},
};
use hyperswitch_domain_models::{
revenue_recovery, router_flow_types::revenue_recovery::RecoveryRecordBack,
router_request_types::revenue_recovery::RevenueRecoveryRecordBackRequest,
router_response_types::revenue_recovery::RevenueRecoveryRecordBackResponse,
types::RevenueRecoveryRecordBackRouterData,
};
use hyperswitch_interfaces::{
api::{
self, ConnectorCommon, ConnectorCommonExt, ConnectorIntegration, ConnectorSpecifications,
ConnectorValidation,
},
configs::Connectors,
errors,
events::connector_api_logs::ConnectorEvent,
types::{self, Response},
webhooks,
};
use transformers as chargebee;
fn get_revenue_recovery_attempt_details(
&self,
request: &webhooks::IncomingWebhookRequestDetails<'_>,
) -> CustomResult<revenue_recovery::RevenueRecoveryAttemptData, errors::ConnectorError> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/chargebee.rs | crate: hyperswitch_connectors | connector: chargebee
use common_utils::{
consts::BASE64_ENGINE,
errors::CustomResult,
ext_traits::BytesExt,
request::{Method, Request, RequestBuilder, RequestContent},
types::{AmountConvertor, MinorUnit, MinorUnitForConnector},
};
use hyperswitch_interfaces::{
api::{
self, ConnectorCommon, ConnectorCommonExt, ConnectorIntegration, ConnectorSpecifications,
ConnectorValidation,
},
configs::Connectors,
errors,
events::connector_api_logs::ConnectorEvent,
types::{self, Response},
webhooks,
};
use crate::{constants::headers, types::ResponseRouterData, utils};
fn get_webhook_source_verification_signature(
&self,
request: &webhooks::IncomingWebhookRequestDetails<'_>,
_connector_webhook_secrets: &api_models::webhooks::ConnectorWebhookSecrets,
) -> CustomResult<Vec<u8>, errors::ConnectorError> {
let base64_signature = utils::get_header_key_value("authorization", request.headers)?;
let signature = base64_signature.as_bytes().to_owned();
Ok(signature)
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/chargebee.rs | crate: hyperswitch_connectors | connector: chargebee
)?)
.attach_default_headers()
.headers(types::RevenueRecoveryRecordBackType::get_headers(
self, req, connectors,
)?)
.set_body(types::RevenueRecoveryRecordBackType::get_request_body(
self, req, connectors,
)?)
.build(),
))
}
fn handle_response(
&self,
data: &RevenueRecoveryRecordBackRouterData,
event_builder: Option<&mut ConnectorEvent>,
res: Response,
) -> CustomResult<RevenueRecoveryRecordBackRouterData, errors::ConnectorError> {
let response: chargebee::ChargebeeRecordbackResponse = res
.response
.parse_struct("chargebee ChargebeeRecordbackResponse")
.change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
event_builder.map(|i| i.set_response_body(&response));
router_env::logger::info!(connector_response=?response);
RouterData::try_from(ResponseRouterData {
fn handle_response(
&self,
data: &RevenueRecoveryRecordBackRouterData,
event_builder: Option<&mut ConnectorEvent>,
res: Response,
) -> CustomResult<RevenueRecoveryRecordBackRouterData, errors::ConnectorError> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/chargebee.rs | crate: hyperswitch_connectors | connector: chargebee
) -> CustomResult<RequestContent, errors::ConnectorError> {
let amount = utils::convert_amount(
self.amount_converter,
req.request.amount,
req.request.currency,
)?;
let connector_router_data = chargebee::ChargebeeRouterData::from((amount, req));
let connector_req =
chargebee::ChargebeeRecordPaymentRequest::try_from(&connector_router_data)?;
Ok(RequestContent::FormUrlEncoded(Box::new(connector_req)))
}
fn build_request(
&self,
req: &RevenueRecoveryRecordBackRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Ok(Some(
RequestBuilder::new()
.method(Method::Post)
.url(&types::RevenueRecoveryRecordBackType::get_url(
self, req, connectors,
)?)
.attach_default_headers()
.headers(types::RevenueRecoveryRecordBackType::get_headers(
fn build_request(
&self,
req: &RevenueRecoveryRecordBackRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/chargebee.rs | crate: hyperswitch_connectors | connector: chargebee
use common_utils::{
consts::BASE64_ENGINE,
errors::CustomResult,
ext_traits::BytesExt,
request::{Method, Request, RequestBuilder, RequestContent},
types::{AmountConvertor, MinorUnit, MinorUnitForConnector},
};
use hyperswitch_domain_models::{
revenue_recovery, router_flow_types::revenue_recovery::RecoveryRecordBack,
router_request_types::revenue_recovery::RevenueRecoveryRecordBackRequest,
router_response_types::revenue_recovery::RevenueRecoveryRecordBackResponse,
types::RevenueRecoveryRecordBackRouterData,
};
use hyperswitch_interfaces::{
api::{
self, ConnectorCommon, ConnectorCommonExt, ConnectorIntegration, ConnectorSpecifications,
ConnectorValidation,
},
configs::Connectors,
errors,
events::connector_api_logs::ConnectorEvent,
types::{self, Response},
webhooks,
};
use transformers as chargebee;
use crate::{constants::headers, types::ResponseRouterData, utils};
fn get_request_body(
&self,
req: &RevenueRecoveryRecordBackRouterData,
_connectors: &Connectors,
) -> CustomResult<RequestContent, errors::ConnectorError> {
let amount = utils::convert_amount(
self.amount_converter,
req.request.amount,
req.request.currency,
)?;
let connector_router_data = chargebee::ChargebeeRouterData::from((amount, req));
let connector_req =
chargebee::ChargebeeRecordPaymentRequest::try_from(&connector_router_data)?;
Ok(RequestContent::FormUrlEncoded(Box::new(connector_req)))
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/chargebee.rs | crate: hyperswitch_connectors | connector: chargebee
use common_utils::{
consts::BASE64_ENGINE,
errors::CustomResult,
ext_traits::BytesExt,
request::{Method, Request, RequestBuilder, RequestContent},
types::{AmountConvertor, MinorUnit, MinorUnitForConnector},
};
use hyperswitch_domain_models::{
revenue_recovery, router_flow_types::revenue_recovery::RecoveryRecordBack,
router_request_types::revenue_recovery::RevenueRecoveryRecordBackRequest,
router_response_types::revenue_recovery::RevenueRecoveryRecordBackResponse,
types::RevenueRecoveryRecordBackRouterData,
};
use hyperswitch_interfaces::{
api::{
self, ConnectorCommon, ConnectorCommonExt, ConnectorIntegration, ConnectorSpecifications,
ConnectorValidation,
},
configs::Connectors,
errors,
events::connector_api_logs::ConnectorEvent,
types::{self, Response},
webhooks,
};
use transformers as chargebee;
use crate::{constants::headers, types::ResponseRouterData, utils};
fn get_url(
&self,
req: &RevenueRecoveryRecordBackRouterData,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/chargebee.rs | crate: hyperswitch_connectors | connector: chargebee
use common_utils::{
consts::BASE64_ENGINE,
errors::CustomResult,
ext_traits::BytesExt,
request::{Method, Request, RequestBuilder, RequestContent},
types::{AmountConvertor, MinorUnit, MinorUnitForConnector},
};
use hyperswitch_domain_models::{
revenue_recovery, router_flow_types::revenue_recovery::RecoveryRecordBack,
router_request_types::revenue_recovery::RevenueRecoveryRecordBackRequest,
router_response_types::revenue_recovery::RevenueRecoveryRecordBackResponse,
types::RevenueRecoveryRecordBackRouterData,
};
use hyperswitch_interfaces::{
api::{
self, ConnectorCommon, ConnectorCommonExt, ConnectorIntegration, ConnectorSpecifications,
ConnectorValidation,
},
configs::Connectors,
errors,
events::connector_api_logs::ConnectorEvent,
types::{self, Response},
webhooks,
};
use masking::ExposeInterface;
use masking::{Mask, PeekInterface, Secret};
fn get_headers(
&self,
req: &RevenueRecoveryRecordBackRouterData,
connectors: &Connectors,
) -> CustomResult<Vec<(String, masking::Maskable<String>)>, errors::ConnectorError> {
self.build_headers(req, connectors)
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/chargebee.rs | crate: hyperswitch_connectors | connector: chargebee
use common_utils::{
consts::BASE64_ENGINE,
errors::CustomResult,
ext_traits::BytesExt,
request::{Method, Request, RequestBuilder, RequestContent},
types::{AmountConvertor, MinorUnit, MinorUnitForConnector},
};
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, ConnectorSpecifications,
ConnectorValidation,
},
configs::Connectors,
errors,
events::connector_api_logs::ConnectorEvent,
types::{self, Response},
webhooks,
};
fn get_url(
&self,
_req: &PaymentsSyncRouterData,
_connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/chargebee.rs | crate: hyperswitch_connectors | connector: chargebee
use hyperswitch_interfaces::{
api::{
self, ConnectorCommon, ConnectorCommonExt, ConnectorIntegration, ConnectorSpecifications,
ConnectorValidation,
},
configs::Connectors,
errors,
events::connector_api_logs::ConnectorEvent,
types::{self, Response},
webhooks,
};
fn common_get_content_type(&self) -> &'static str {
"application/x-www-form-urlencoded"
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/cybersource.rs | crate: hyperswitch_connectors | connector: cybersource
self, req, connectors,
)?)
.attach_default_headers()
.headers(IncrementalAuthorizationType::get_headers(
self, req, connectors,
)?)
.set_body(IncrementalAuthorizationType::get_request_body(
self, req, connectors,
)?)
.build(),
))
}
fn handle_response(
&self,
data: &PaymentsIncrementalAuthorizationRouterData,
event_builder: Option<&mut ConnectorEvent>,
res: Response,
) -> CustomResult<
RouterData<
IncrementalAuthorization,
PaymentsIncrementalAuthorizationData,
PaymentsResponseData,
>,
errors::ConnectorError,
> {
fn handle_response(
&self,
data: &PaymentsIncrementalAuthorizationRouterData,
event_builder: Option<&mut ConnectorEvent>,
res: Response,
) -> CustomResult<
RouterData<
IncrementalAuthorization,
PaymentsIncrementalAuthorizationData,
PaymentsResponseData,
>,
errors::ConnectorError,
> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/cybersource.rs | crate: hyperswitch_connectors | connector: cybersource
http_code: res.status_code,
})
}
fn get_error_response(
&self,
res: Response,
event_builder: Option<&mut ConnectorEvent>,
) -> CustomResult<ErrorResponse, errors::ConnectorError> {
self.build_error_response(res, event_builder)
}
fn get_5xx_error_response(
&self,
res: Response,
event_builder: Option<&mut ConnectorEvent>,
) -> CustomResult<ErrorResponse, errors::ConnectorError> {
let response: cybersource::CybersourceServerErrorResponse = res
.response
.parse_struct("CybersourceServerErrorResponse")
.change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
event_builder.map(|event| event.set_response_body(&response));
router_env::logger::info!(error_response=?response);
fn get_5xx_error_response(
&self,
res: Response,
event_builder: Option<&mut ConnectorEvent>,
) -> CustomResult<ErrorResponse, errors::ConnectorError> {
{
transformers::Reason::SystemError => Some(enums::AttemptStatus::Failure),<|fim_suffix|>
<|fim_middle|>
transformers::Reason::ServerTimeout | transformers::Reason::ServiceTimeout => None,
}
} | ast_fragments |
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/cybersource.rs | crate: hyperswitch_connectors | connector: cybersource
})
}
}
fn get_error_response(
&self,
res: Response,
event_builder: Option<&mut ConnectorEvent>,
) -> CustomResult<ErrorResponse, errors::ConnectorError> {
self.build_error_response(res, event_builder)
}
fn get_5xx_error_response(
&self,
res: Response,
event_builder: Option<&mut ConnectorEvent>,
) -> CustomResult<ErrorResponse, errors::ConnectorError> {
let response: cybersource::CybersourceServerErrorResponse = res
.response
.parse_struct("CybersourceServerErrorResponse")
.change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
event_builder.map(|event| event.set_response_body(&response));
router_env::logger::info!(error_response=?response);
fn get_5xx_error_response(
&self,
res: Response,
event_builder: Option<&mut ConnectorEvent>,
) -> CustomResult<ErrorResponse, errors::ConnectorError> {
let response: cybersource::CybersourceServerErrorResponse = res
.response
.parse_struct("CybersourceServerErrorResponse")
.change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
event_builder.map(|event| event.set_response_body(&response));
router_env::logger::info!(error_response=?response);
let attempt_status = match response.reason {
Some(reason) => match reason {
transformers::Reason::SystemError => Some(enums::AttemptStatus::Failure),
transformers::Reason::ServerTimeout | transformers::Reason::ServiceTimeout => None,
},
None => None,
};
Ok(ErrorResponse {
status_code: res.status_code,
reason: response.status.clone(),
code: response
.status
.unwrap_or(hyperswitch_interfaces::consts::NO_ERROR_CODE.to_string()),
message: response
.message
.unwrap_or(hyperswitch_interfaces::consts::NO_ERROR_MESSAGE.to_string()),
attempt_status,
connector_transaction_id: None,
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
})
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/cybersource.rs | crate: hyperswitch_connectors | connector: cybersource
PaymentMethodDataType::ApplePay,
PaymentMethodDataType::GooglePay,
PaymentMethodDataType::SamsungPay,
]);
utils::is_mandate_supported(pm_data, pm_type, mandate_supported_pmd, self.id())
}
}
impl<Flow, Request, Response> ConnectorCommonExt<Flow, Request, Response> for Cybersource
where
Self: ConnectorIntegration<Flow, Request, Response>,
{
fn build_headers(
&self,
req: &RouterData<Flow, Request, Response>,
connectors: &Connectors,
) -> CustomResult<Vec<(String, Maskable<String>)>, errors::ConnectorError> {
let date = OffsetDateTime::now_utc();
let cybersource_req = self.get_request_body(req, connectors)?;
let auth = cybersource::CybersourceAuthType::try_from(&req.connector_auth_type)?;
let merchant_account = auth.merchant_account.clone();
let base_url = connectors.cybersource.base_url.as_str();
let cybersource_host =
Url::parse(base_url).change_context(errors::ConnectorError::RequestEncodingFailed)?;
let host = cybersource_host
fn build_headers(
&self,
req: &RouterData<Flow, Request, Response>,
connectors: &Connectors,
) -> CustomResult<Vec<(String, Maskable<String>)>, errors::ConnectorError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/cybersource.rs | crate: hyperswitch_connectors | connector: cybersource
use common_utils::{
consts,
errors::CustomResult,
ext_traits::BytesExt,
request::{Method, Request, RequestBuilder, RequestContent},
types::{AmountConvertor, MinorUnit, StringMajorUnit, StringMajorUnitForConnector},
};
use hyperswitch_interfaces::{
api::{
self,
payments::PaymentSession,
refunds::{Refund, RefundExecute, RefundSync},
ConnectorCommon, ConnectorCommonExt, ConnectorIntegration, ConnectorSpecifications,
ConnectorValidation,
},
configs::Connectors,
errors,
events::connector_api_logs::ConnectorEvent,
types::{
IncrementalAuthorizationType, MandateRevokeType, PaymentsAuthorizeType,
PaymentsCaptureType, PaymentsCompleteAuthorizeType, PaymentsPreProcessingType,
PaymentsSyncType, PaymentsVoidType, RefundExecuteType, RefundSyncType, Response,
SetupMandateType,
},
webhooks,
};
use ring::{digest, hmac};
use transformers as cybersource;
use crate::{
constants::{self, headers},
types::ResponseRouterData,
utils::{
self, convert_amount, PaymentMethodDataType, PaymentsAuthorizeRequestData,
RefundsRequestData, RouterData as OtherRouterData,
},
};
pub fn generate_signature(
&self,
auth: cybersource::CybersourceAuthType,
host: String,
resource: &str,
payload: &String,
date: OffsetDateTime,
http_method: Method,
) -> CustomResult<String, errors::ConnectorError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/cybersource.rs | crate: hyperswitch_connectors | connector: cybersource
http_code: res.status_code,
})
}
fn get_error_response(
&self,
res: Response,
event_builder: Option<&mut ConnectorEvent>,
) -> CustomResult<ErrorResponse, errors::ConnectorError> {
self.build_error_response(res, event_builder)
}
fn get_5xx_error_response(
&self,
res: Response,
event_builder: Option<&mut ConnectorEvent>,
) -> CustomResult<ErrorResponse, errors::ConnectorError> {
let response: cybersource::CybersourceServerErrorResponse = res
.response
.parse_struct("CybersourceServerErrorResponse")
.change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
event_builder.map(|event| event.set_response_body(&response));
router_env::logger::info!(error_response=?response);
fn get_5xx_error_response(
&self,
res: Response,
event_builder: Option<&mut ConnectorEvent>,
) -> CustomResult<ErrorResponse, errors::ConnectorError> {
{
Some(reason) => match reason {
transformers::Reason::SystemError => Some(enums::AttemptStatus::Failure),
transformers::Reason::ServerTimeout | transformers::Reason::ServiceTimeout => None,
},<|fim_suffix|>
<|fim_middle|>
None => None,
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/cybersource.rs | crate: hyperswitch_connectors | connector: cybersource
self.amount_converter,
minor_additional_amount,
req.request.currency,
)?;
let connector_router_data =
cybersource::CybersourceRouterData::from((additional_amount, req));
let connector_request =
cybersource::CybersourcePaymentsIncrementalAuthorizationRequest::try_from(
&connector_router_data,
)?;
Ok(RequestContent::Json(Box::new(connector_request)))
}
fn build_request(
&self,
req: &PaymentsIncrementalAuthorizationRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Ok(Some(
RequestBuilder::new()
.method(Method::Patch)
.url(&IncrementalAuthorizationType::get_url(
self, req, connectors,
)?)
.attach_default_headers()
.headers(IncrementalAuthorizationType::get_headers(
fn build_request(
&self,
req: &PaymentsIncrementalAuthorizationRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/cybersource.rs | crate: hyperswitch_connectors | connector: cybersource
_connectors: &Connectors,
) -> CustomResult<RequestContent, errors::ConnectorError> {
let refund_amount = convert_amount(
self.amount_converter,
req.request.minor_refund_amount,
req.request.currency,
)?;
let connector_router_data = cybersource::CybersourceRouterData::from((refund_amount, req));
let connector_req =
cybersource::CybersourceRefundRequest::try_from(&connector_router_data)?;
Ok(RequestContent::Json(Box::new(connector_req)))
}
fn build_request(
&self,
req: &RefundExecuteRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Ok(Some(
RequestBuilder::new()
.method(Method::Post)
.url(&RefundExecuteType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(RefundExecuteType::get_headers(self, req, connectors)?)
.set_body(self.get_request_body(req, connectors)?)
.build(),
fn build_request(
&self,
req: &RefundExecuteRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/cybersource.rs | crate: hyperswitch_connectors | connector: cybersource
) -> CustomResult<String, errors::ConnectorError> {
let connector_payment_id = req.request.connector_transaction_id.clone();
Ok(format!(
"{}pts/v2/payments/{connector_payment_id}/reversals",
self.base_url(connectors)
))
}
fn get_content_type(&self) -> &'static str {
self.common_get_content_type()
}
fn get_request_body(
&self,
req: &PaymentsCancelRouterData,
_connectors: &Connectors,
) -> CustomResult<RequestContent, errors::ConnectorError> {
let minor_amount =
req.request
.minor_amount
.ok_or(errors::ConnectorError::MissingRequiredField {
field_name: "Amount",
})?;
let currency =
req.request
fn get_request_body(
&self,
req: &PaymentsCancelRouterData,
_connectors: &Connectors,
) -> CustomResult<RequestContent, errors::ConnectorError> {
let minor_amount =
req.request
.minor_amount
.ok_or(errors::ConnectorError::MissingRequiredField {
field_name: "Amount",
})?;
let currency =
req.request
.currency
.ok_or(errors::ConnectorError::MissingRequiredField {
field_name: "Currency",
})?;
let amount = convert_amount(self.amount_converter, minor_amount, currency)?;
let connector_router_data = cybersource::CybersourceRouterData::from((amount, req));
let connector_req = cybersource::CybersourceVoidRequest::try_from(&connector_router_data)?;
Ok(RequestContent::Json(Box::new(connector_req)))
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/cybersource.rs | crate: hyperswitch_connectors | connector: cybersource
attempt_status,
connector_transaction_id: None,
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
})
}
}
impl ConnectorIntegration<CompleteAuthorize, CompleteAuthorizeData, PaymentsResponseData>
for Cybersource
{
fn get_headers(
&self,
req: &PaymentsCompleteAuthorizeRouterData,
connectors: &Connectors,
) -> CustomResult<Vec<(String, Maskable<String>)>, errors::ConnectorError> {
self.build_headers(req, connectors)
}
fn get_content_type(&self) -> &'static str {
self.common_get_content_type()
}
fn get_url(
&self,
_req: &PaymentsCompleteAuthorizeRouterData,
fn get_headers(
&self,
req: &PaymentsCompleteAuthorizeRouterData,
connectors: &Connectors,
) -> CustomResult<Vec<(String, Maskable<String>)>, errors::ConnectorError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/cybersource.rs | crate: hyperswitch_connectors | connector: cybersource
}
#[cfg(feature = "payouts")]
impl ConnectorIntegration<PoFulfill, PayoutsData, PayoutsResponseData> for Cybersource {
fn get_url(
&self,
_req: &PayoutsRouterData<PoFulfill>,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
Ok(format!("{}pts/v2/payouts", self.base_url(connectors)))
}
fn get_headers(
&self,
req: &PayoutsRouterData<PoFulfill>,
connectors: &Connectors,
) -> CustomResult<Vec<(String, Maskable<String>)>, errors::ConnectorError> {
self.build_headers(req, connectors)
}
fn get_request_body(
&self,
req: &PayoutsRouterData<PoFulfill>,
_connectors: &Connectors,
) -> CustomResult<RequestContent, errors::ConnectorError> {
fn get_headers(
&self,
req: &PayoutsRouterData<PoFulfill>,
connectors: &Connectors,
) -> CustomResult<Vec<(String, Maskable<String>)>, errors::ConnectorError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/cybersource.rs | crate: hyperswitch_connectors | connector: cybersource
&& req.request.authentication_data.is_none()
{
let connector_req =
cybersource::CybersourceAuthSetupRequest::try_from(&connector_router_data)?;
Ok(RequestContent::Json(Box::new(connector_req)))
} else {
let connector_req =
cybersource::CybersourcePaymentsRequest::try_from(&connector_router_data)?;
Ok(RequestContent::Json(Box::new(connector_req)))
}
}
fn build_request(
&self,
req: &PaymentsAuthorizeRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
let request = RequestBuilder::new()
.method(Method::Post)
.url(&PaymentsAuthorizeType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(PaymentsAuthorizeType::get_headers(self, req, connectors)?)
.set_body(self.get_request_body(req, connectors)?)
.build();
fn build_request(
&self,
req: &PaymentsAuthorizeRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
let request = RequestBuilder::new()
.method(Method::Post)
.url(&PaymentsAuthorizeType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(PaymentsAuthorizeType::get_headers(self, req, connectors)?)
.set_body(self.get_request_body(req, connectors)?)
.build();
Ok(Some(request))
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/cybersource.rs | crate: hyperswitch_connectors | connector: cybersource
}
fn get_error_response(
&self,
res: Response,
event_builder: Option<&mut ConnectorEvent>,
) -> CustomResult<ErrorResponse, errors::ConnectorError> {
self.build_error_response(res, event_builder)
}
}
impl ConnectorIntegration<Capture, PaymentsCaptureData, PaymentsResponseData> for Cybersource {
fn get_headers(
&self,
req: &PaymentsCaptureRouterData,
connectors: &Connectors,
) -> CustomResult<Vec<(String, Maskable<String>)>, errors::ConnectorError> {
self.build_headers(req, connectors)
}
fn get_content_type(&self) -> &'static str {
self.common_get_content_type()
}
fn get_url(
fn get_headers(
&self,
req: &PaymentsCaptureRouterData,
connectors: &Connectors,
) -> CustomResult<Vec<(String, Maskable<String>)>, errors::ConnectorError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/cybersource.rs | crate: hyperswitch_connectors | connector: cybersource
}
impl ConnectorIntegration<AccessTokenAuth, AccessTokenRequestData, AccessToken> for Cybersource {
// Not Implemented (R)
}
impl PaymentSession for Cybersource {}
impl ConnectorIntegration<Session, PaymentsSessionData, PaymentsResponseData> for Cybersource {}
impl ConnectorIntegration<PreProcessing, PaymentsPreProcessingData, PaymentsResponseData>
for Cybersource
{
fn get_headers(
&self,
req: &PaymentsPreProcessingRouterData,
connectors: &Connectors,
) -> CustomResult<Vec<(String, Maskable<String>)>, errors::ConnectorError> {
self.build_headers(req, connectors)
}
fn get_content_type(&self) -> &'static str {
self.common_get_content_type()
}
fn get_url(
&self,
req: &PaymentsPreProcessingRouterData,
fn get_headers(
&self,
req: &PaymentsPreProcessingRouterData,
connectors: &Connectors,
) -> CustomResult<Vec<(String, Maskable<String>)>, errors::ConnectorError> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/cybersource.rs | crate: hyperswitch_connectors | connector: cybersource
}
fn get_url(
&self,
req: &MandateRevokeRouterData,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
Ok(format!(
"{}tms/v1/paymentinstruments/{}",
self.base_url(connectors),
utils::RevokeMandateRequestData::get_connector_mandate_id(&req.request)?
))
}
fn build_request(
&self,
req: &MandateRevokeRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Ok(Some(
RequestBuilder::new()
.method(Method::Delete)
.url(&MandateRevokeType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(MandateRevokeType::get_headers(self, req, connectors)?)
.build(),
))
fn build_request(
&self,
req: &MandateRevokeRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Ok(Some(
RequestBuilder::new()
.method(Method::Delete)
.url(&MandateRevokeType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(MandateRevokeType::get_headers(self, req, connectors)?)
.build(),
))
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/cybersource.rs | crate: hyperswitch_connectors | connector: cybersource
use common_utils::{
consts,
errors::CustomResult,
ext_traits::BytesExt,
request::{Method, Request, RequestBuilder, RequestContent},
types::{AmountConvertor, MinorUnit, StringMajorUnit, StringMajorUnitForConnector},
};
use hyperswitch_interfaces::{
api::{
self,
payments::PaymentSession,
refunds::{Refund, RefundExecute, RefundSync},
ConnectorCommon, ConnectorCommonExt, ConnectorIntegration, ConnectorSpecifications,
ConnectorValidation,
},
configs::Connectors,
errors,
events::connector_api_logs::ConnectorEvent,
types::{
IncrementalAuthorizationType, MandateRevokeType, PaymentsAuthorizeType,
PaymentsCaptureType, PaymentsCompleteAuthorizeType, PaymentsPreProcessingType,
PaymentsSyncType, PaymentsVoidType, RefundExecuteType, RefundSyncType, Response,
SetupMandateType,
},
webhooks,
};
use crate::{
constants::{self, headers},
types::ResponseRouterData,
utils::{
self, convert_amount, PaymentMethodDataType, PaymentsAuthorizeRequestData,
RefundsRequestData, RouterData as OtherRouterData,
},
};
pub fn generate_digest(&self, payload: &[u8]) -> String {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/cybersource.rs | crate: hyperswitch_connectors | connector: cybersource
use common_utils::{
consts,
errors::CustomResult,
ext_traits::BytesExt,
request::{Method, Request, RequestBuilder, RequestContent},
types::{AmountConvertor, MinorUnit, StringMajorUnit, StringMajorUnitForConnector},
};
pub fn new() -> &'static Self {
&Self {
amount_converter: &StringMajorUnitForConnector,
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/datatrans.rs | crate: hyperswitch_connectors | connector: datatrans
| CaptureMethod::Manual
| CaptureMethod::SequentialAutomatic => Ok(()),
CaptureMethod::ManualMultiple | CaptureMethod::Scheduled => {
Err(errors::ConnectorError::NotSupported {
message: capture_method.to_string(),
connector: self.id(),
}
.into())
}
}
}
fn validate_mandate_payment(
&self,
_pm_type: Option<PaymentMethodType>,
pm_data: PaymentMethodData,
) -> CustomResult<(), errors::ConnectorError> {
let connector = self.id();
match pm_data {
PaymentMethodData::Card(_) => Ok(()),
_ => Err(errors::ConnectorError::NotSupported {
message: " mandate payment".to_string(),
connector,
}
.into()),
fn validate_mandate_payment(
&self,
_pm_type: Option<PaymentMethodType>,
pm_data: PaymentMethodData,
) -> CustomResult<(), errors::ConnectorError> {
{
PaymentMethodData::Card(_) => Ok(()),<|fim_suffix|>
<|fim_middle|>
_ => Err(errors::ConnectorError::NotSupported {
message: " mandate payment".to_string(),
connector,
}
.into()),
}
} | ast_fragments |
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/datatrans.rs | crate: hyperswitch_connectors | connector: datatrans
)?)
.attach_default_headers()
.headers(types::PaymentsAuthorizeType::get_headers(
self, req, connectors,
)?)
.set_body(types::PaymentsAuthorizeType::get_request_body(
self, req, connectors,
)?)
.build(),
))
}
fn handle_response(
&self,
data: &PaymentsAuthorizeRouterData,
event_builder: Option<&mut ConnectorEvent>,
res: Response,
) -> CustomResult<PaymentsAuthorizeRouterData, errors::ConnectorError> {
let response: datatrans::DatatransResponse = res
.response
.parse_struct("Datatrans PaymentsAuthorizeResponse")
.change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
event_builder.map(|i| i.set_response_body(&response));
router_env::logger::info!(connector_response=?response);
RouterData::try_from(ResponseRouterData {
fn handle_response(
&self,
data: &PaymentsAuthorizeRouterData,
event_builder: Option<&mut ConnectorEvent>,
res: Response,
) -> CustomResult<PaymentsAuthorizeRouterData, errors::ConnectorError> {
let response: datatrans::DatatransResponse = res
.response
.parse_struct("Datatrans PaymentsAuthorizeResponse")
.change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
event_builder.map(|i| i.set_response_body(&response));
router_env::logger::info!(connector_response=?response);
RouterData::try_from(ResponseRouterData {
response,
data: data.clone(),
http_code: res.status_code,
})
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/datatrans.rs | crate: hyperswitch_connectors | connector: datatrans
) -> CustomResult<String, errors::ConnectorError> {
Ok(format!("{}v1/transactions", self.base_url(connectors)))
}
fn get_request_body(
&self,
req: &SetupMandateRouterData,
_connectors: &Connectors,
) -> CustomResult<RequestContent, errors::ConnectorError> {
let connector_req = datatrans::DatatransPaymentsRequest::try_from(req)?;
Ok(RequestContent::Json(Box::new(connector_req)))
}
fn build_request(
&self,
req: &RouterData<SetupMandate, SetupMandateRequestData, PaymentsResponseData>,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Ok(Some(
RequestBuilder::new()
.method(Method::Post)
.url(&types::SetupMandateType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(types::SetupMandateType::get_headers(self, req, connectors)?)
.set_body(types::SetupMandateType::get_request_body(
self, req, connectors,
fn build_request(
&self,
req: &RouterData<SetupMandate, SetupMandateRequestData, PaymentsResponseData>,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/datatrans.rs | crate: hyperswitch_connectors | connector: datatrans
for Datatrans
{
fn get_headers(
&self,
req: &SetupMandateRouterData,
connectors: &Connectors,
) -> CustomResult<Vec<(String, masking::Maskable<String>)>, errors::ConnectorError> {
self.build_headers(req, connectors)
}
fn get_content_type(&self) -> &'static str {
self.common_get_content_type()
}
fn get_url(
&self,
_req: &SetupMandateRouterData,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
Ok(format!("{}v1/transactions", self.base_url(connectors)))
}
fn get_request_body(
&self,
req: &SetupMandateRouterData,
_connectors: &Connectors,
) -> CustomResult<RequestContent, errors::ConnectorError> {
let connector_req = datatrans::DatatransPaymentsRequest::try_from(req)?;
fn get_url(
&self,
_req: &SetupMandateRouterData,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
Ok(format!("{}v1/transactions", self.base_url(connectors)))
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/datatrans.rs | crate: hyperswitch_connectors | connector: datatrans
| CaptureMethod::Manual
| CaptureMethod::SequentialAutomatic => Ok(()),
CaptureMethod::ManualMultiple | CaptureMethod::Scheduled => {
Err(errors::ConnectorError::NotSupported {
message: capture_method.to_string(),
connector: self.id(),
}
.into())
}
}
}
fn validate_mandate_payment(
&self,
_pm_type: Option<PaymentMethodType>,
pm_data: PaymentMethodData,
) -> CustomResult<(), errors::ConnectorError> {
let connector = self.id();
match pm_data {
PaymentMethodData::Card(_) => Ok(()),
_ => Err(errors::ConnectorError::NotSupported {
message: " mandate payment".to_string(),
connector,
}
.into()),
fn validate_mandate_payment(
&self,
_pm_type: Option<PaymentMethodType>,
pm_data: PaymentMethodData,
) -> CustomResult<(), errors::ConnectorError> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/novalnet.rs | crate: hyperswitch_connectors | connector: novalnet
use common_enums::enums;
use common_utils::{
crypto,
errors::CustomResult,
ext_traits::{ByteSliceExt, BytesExt},
request::{Method, Request, RequestBuilder, RequestContent},
types::{AmountConvertor, StringMinorUnit, StringMinorUnitForConnector},
};
use hyperswitch_interfaces::{
api::{
self, ConnectorCommon, ConnectorCommonExt, ConnectorIntegration, ConnectorRedirectResponse,
ConnectorSpecifications, ConnectorValidation,
},
configs::Connectors,
disputes, errors,
events::connector_api_logs::ConnectorEvent,
types::{self, Response},
webhooks,
};
use transformers as novalnet;
use crate::{
constants::headers,
types::ResponseRouterData,
utils::{self, PaymentMethodDataType, PaymentsAuthorizeRequestData},
};
fn get_dispute_details(
&self,
request: &webhooks::IncomingWebhookRequestDetails<'_>,
) -> CustomResult<disputes::DisputePayload, errors::ConnectorError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/novalnet.rs | crate: hyperswitch_connectors | connector: novalnet
"{}{}{}{}{}{}",
notif.event.tid,
notif.event.event_type,
notif.result.status,
amount,
currency,
reversed_secret_auth
);
Ok(message.into_bytes())
}
fn get_webhook_object_reference_id(
&self,
request: &webhooks::IncomingWebhookRequestDetails<'_>,
) -> CustomResult<api_models::webhooks::ObjectReferenceId, errors::ConnectorError> {
let notif = get_webhook_object_from_body(request.body)
.change_context(errors::ConnectorError::WebhookReferenceIdNotFound)?;
let transaction_order_no = match notif.transaction {
novalnet::NovalnetWebhookTransactionData::CaptureTransactionData(data) => data.order_no,
novalnet::NovalnetWebhookTransactionData::CancelTransactionData(data) => data.order_no,
novalnet::NovalnetWebhookTransactionData::RefundsTransactionData(data) => data.order_no,
novalnet::NovalnetWebhookTransactionData::SyncTransactionData(data) => data.order_no,
};
fn get_webhook_object_reference_id(
&self,
request: &webhooks::IncomingWebhookRequestDetails<'_>,
) -> CustomResult<api_models::webhooks::ObjectReferenceId, errors::ConnectorError> {
let notif = get_webhook_object_from_body(request.body)
.change_context(errors::ConnectorError::WebhookReferenceIdNotFound)?;
let transaction_order_no = match notif.transaction {
novalnet::NovalnetWebhookTransactionData::CaptureTransactionData(data) => data.order_no,
novalnet::NovalnetWebhookTransactionData::CancelTransactionData(data) => data.order_no,
novalnet::NovalnetWebhookTransactionData::RefundsTransactionData(data) => data.order_no,
novalnet::NovalnetWebhookTransactionData::SyncTransactionData(data) => data.order_no,
};
if novalnet::is_refund_event(¬if.event.event_type) {
Ok(api_models::webhooks::ObjectReferenceId::RefundId(
api_models::webhooks::RefundIdType::ConnectorRefundId(notif.event.tid.to_string()),
))
} else {
match transaction_order_no {
Some(order_no) => Ok(api_models::webhooks::ObjectReferenceId::PaymentId(
api_models::payments::PaymentIdType::PaymentAttemptId(order_no),
)),
None => Ok(api_models::webhooks::ObjectReferenceId::PaymentId(
api_models::payments::PaymentIdType::ConnectorTransactionId(
notif.event.tid.to_string(),
),
)),
}
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/novalnet.rs | crate: hyperswitch_connectors | connector: novalnet
Ok(incoming_webhook_event)
}
fn get_webhook_resource_object(
&self,
request: &webhooks::IncomingWebhookRequestDetails<'_>,
) -> CustomResult<Box<dyn masking::ErasedMaskSerialize>, errors::ConnectorError> {
let notif = get_webhook_object_from_body(request.body)
.change_context(errors::ConnectorError::WebhookResourceObjectNotFound)?;
Ok(Box::new(notif))
}
fn get_dispute_details(
&self,
request: &webhooks::IncomingWebhookRequestDetails<'_>,
) -> CustomResult<disputes::DisputePayload, errors::ConnectorError> {
let notif: transformers::NovalnetWebhookNotificationResponse =
get_webhook_object_from_body(request.body)
.change_context(errors::ConnectorError::WebhookBodyDecodingFailed)?;
let (amount, currency, reason, reason_code) = match notif.transaction {
novalnet::NovalnetWebhookTransactionData::CaptureTransactionData(data) => {
(data.amount, data.currency, None, None)
}
novalnet::NovalnetWebhookTransactionData::CancelTransactionData(data) => {
(data.amount, data.currency, None, None)
fn get_dispute_details(
&self,
request: &webhooks::IncomingWebhookRequestDetails<'_>,
) -> CustomResult<disputes::DisputePayload, errors::ConnectorError> {
{
novalnet::NovalnetWebhookTransactionData::CaptureTransactionData(data) => {
(data.amount, data.currency, None, None)
}<|fim_suffix|>
<|fim_middle|>
novalnet::NovalnetWebhookTransactionData::SyncTransactionData(data) => {
(data.amount, data.currency, data.reason, data.reason_code)
}
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/hyperswitch_connectors/src/connectors/novalnet.rs | crate: hyperswitch_connectors | connector: novalnet
Some(order_no) => Ok(api_models::webhooks::ObjectReferenceId::PaymentId(
api_models::payments::PaymentIdType::PaymentAttemptId(order_no),
)),
None => Ok(api_models::webhooks::ObjectReferenceId::PaymentId(
api_models::payments::PaymentIdType::ConnectorTransactionId(
notif.event.tid.to_string(),
),
)),
}
}
}
fn get_webhook_event_type(
&self,
request: &webhooks::IncomingWebhookRequestDetails<'_>,
) -> CustomResult<api_models::webhooks::IncomingWebhookEvent, errors::ConnectorError> {
let notif = get_webhook_object_from_body(request.body)
.change_context(errors::ConnectorError::WebhookEventTypeNotFound)?;
let optional_transaction_status = match notif.transaction {
novalnet::NovalnetWebhookTransactionData::CaptureTransactionData(data) => {
Some(data.status)
}
novalnet::NovalnetWebhookTransactionData::CancelTransactionData(data) => data.status,
novalnet::NovalnetWebhookTransactionData::RefundsTransactionData(data) => {
fn get_webhook_event_type(
&self,
request: &webhooks::IncomingWebhookRequestDetails<'_>,
) -> CustomResult<api_models::webhooks::IncomingWebhookEvent, errors::ConnectorError> {
{
novalnet::NovalnetWebhookTransactionData::CaptureTransactionData(data) => {
Some(data.status)
}<|fim_suffix|>
<|fim_middle|>
novalnet::NovalnetWebhookTransactionData::SyncTransactionData(data) => {
Some(data.status)
}
}
} | ast_fragments |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.