id
stringlengths 11
116
| type
stringclasses 1
value | granularity
stringclasses 4
values | content
stringlengths 16
477k
| metadata
dict |
|---|---|---|---|---|
file_hyperswitch_connectors_6566582381475707478
|
clm
|
file
|
// Repository: hyperswitch
// Crate: hyperswitch_connectors
// File: crates/hyperswitch_connectors/src/connectors/taxjar.rs
// Contains: 1 structs, 0 enums
pub mod transformers;
use common_utils::{
errors::CustomResult,
ext_traits::BytesExt,
request::{Method, Request, RequestBuilder, RequestContent},
types::{AmountConvertor, FloatMajorUnit, FloatMajorUnitForConnector, MinorUnit},
};
use error_stack::{report, ResultExt};
use hyperswitch_domain_models::{
router_data::{AccessToken, ConnectorAuthType, ErrorResponse, RouterData},
router_flow_types::{
access_token_auth::AccessTokenAuth,
payments::{
Authorize, CalculateTax, Capture, PSync, PaymentMethodToken, Session, SetupMandate,
Void,
},
refunds::{Execute, RSync},
},
router_request_types::{
AccessTokenRequestData, PaymentMethodTokenizationData, PaymentsAuthorizeData,
PaymentsCancelData, PaymentsCaptureData, PaymentsSessionData, PaymentsSyncData,
PaymentsTaxCalculationData, RefundsData, SetupMandateRequestData,
},
router_response_types::{
ConnectorInfo, PaymentsResponseData, RefundsResponseData, SupportedPaymentMethods,
TaxCalculationResponseData,
},
types::PaymentsTaxCalculationRouterData,
};
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};
use transformers as taxjar;
use crate::{constants::headers, types::ResponseRouterData, utils};
#[derive(Clone)]
pub struct Taxjar {
amount_converter: &'static (dyn AmountConvertor<Output = FloatMajorUnit> + Sync),
}
impl Taxjar {
pub fn new() -> &'static Self {
&Self {
amount_converter: &FloatMajorUnitForConnector,
}
}
}
impl api::Payment for Taxjar {}
impl api::PaymentSession for Taxjar {}
impl api::ConnectorAccessToken for Taxjar {}
impl api::MandateSetup for Taxjar {}
impl api::PaymentAuthorize for Taxjar {}
impl api::PaymentSync for Taxjar {}
impl api::PaymentCapture for Taxjar {}
impl api::PaymentVoid for Taxjar {}
impl api::Refund for Taxjar {}
impl api::RefundExecute for Taxjar {}
impl api::RefundSync for Taxjar {}
impl api::PaymentToken for Taxjar {}
impl api::TaxCalculation for Taxjar {}
impl ConnectorIntegration<PaymentMethodToken, PaymentMethodTokenizationData, PaymentsResponseData>
for Taxjar
{
// Not Implemented (R)
}
impl<Flow, Request, Response> ConnectorCommonExt<Flow, Request, Response> for Taxjar
where
Self: ConnectorIntegration<Flow, Request, Response>,
{
fn build_headers(
&self,
req: &RouterData<Flow, Request, Response>,
_connectors: &Connectors,
) -> CustomResult<Vec<(String, masking::Maskable<String>)>, errors::ConnectorError> {
let mut header = vec![(
headers::CONTENT_TYPE.to_string(),
self.get_content_type().to_string().into(),
)];
let mut api_key = self.get_auth_header(&req.connector_auth_type)?;
header.append(&mut api_key);
Ok(header)
}
}
impl ConnectorCommon for Taxjar {
fn id(&self) -> &'static str {
"taxjar"
}
fn get_currency_unit(&self) -> api::CurrencyUnit {
api::CurrencyUnit::Base
}
fn common_get_content_type(&self) -> &'static str {
"application/json"
}
fn base_url<'a>(&self, connectors: &'a Connectors) -> &'a str {
connectors.taxjar.base_url.as_ref()
}
fn get_auth_header(
&self,
auth_type: &ConnectorAuthType,
) -> CustomResult<Vec<(String, masking::Maskable<String>)>, errors::ConnectorError> {
let auth = taxjar::TaxjarAuthType::try_from(auth_type)
.change_context(errors::ConnectorError::FailedToObtainAuthType)?;
Ok(vec![(
headers::AUTHORIZATION.to_string(),
format!("Bearer {}", auth.api_key.peek()).into_masked(),
)])
}
fn build_error_response(
&self,
res: Response,
event_builder: Option<&mut ConnectorEvent>,
) -> CustomResult<ErrorResponse, errors::ConnectorError> {
let response: taxjar::TaxjarErrorResponse = res
.response
.parse_struct("TaxjarErrorResponse")
.change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
event_builder.map(|i| i.set_response_body(&response));
router_env::logger::info!(connector_response=?response);
Ok(ErrorResponse {
status_code: res.status_code,
code: response.error.clone(),
message: response.detail.clone(),
reason: Some(response.detail),
attempt_status: None,
connector_transaction_id: None,
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
connector_metadata: None,
})
}
}
impl ConnectorValidation for Taxjar {}
impl ConnectorIntegration<Session, PaymentsSessionData, PaymentsResponseData> for Taxjar {}
impl ConnectorIntegration<AccessTokenAuth, AccessTokenRequestData, AccessToken> for Taxjar {}
impl ConnectorIntegration<SetupMandate, SetupMandateRequestData, PaymentsResponseData> for Taxjar {}
impl ConnectorIntegration<Authorize, PaymentsAuthorizeData, PaymentsResponseData> for Taxjar {}
impl ConnectorIntegration<CalculateTax, PaymentsTaxCalculationData, TaxCalculationResponseData>
for Taxjar
{
fn get_headers(
&self,
req: &PaymentsTaxCalculationRouterData,
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: &PaymentsTaxCalculationRouterData,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
Ok(format!("{}taxes", self.base_url(connectors)))
}
fn get_request_body(
&self,
req: &PaymentsTaxCalculationRouterData,
_connectors: &Connectors,
) -> CustomResult<RequestContent, errors::ConnectorError> {
let amount = utils::convert_amount(
self.amount_converter,
req.request.amount,
req.request.currency,
)?;
let shipping = utils::convert_amount(
self.amount_converter,
req.request.shipping_cost.unwrap_or(MinorUnit::zero()),
req.request.currency,
)?;
let order_amount = utils::convert_amount(
self.amount_converter,
req.request
.order_details
.as_ref()
.map(|details| details.iter().map(|item| item.amount).sum())
.unwrap_or(MinorUnit::zero()),
req.request.currency,
)?;
let connector_router_data =
taxjar::TaxjarRouterData::from((amount, order_amount, shipping, req));
let connector_req = taxjar::TaxjarPaymentsRequest::try_from(&connector_router_data)?;
Ok(RequestContent::Json(Box::new(connector_req)))
}
fn build_request(
&self,
req: &PaymentsTaxCalculationRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Ok(Some(
RequestBuilder::new()
.method(Method::Post)
.url(&types::PaymentsTaxCalculationType::get_url(
self, req, connectors,
)?)
.attach_default_headers()
.headers(types::PaymentsTaxCalculationType::get_headers(
self, req, connectors,
)?)
.set_body(types::PaymentsTaxCalculationType::get_request_body(
self, req, connectors,
)?)
.build(),
))
}
fn handle_response(
&self,
data: &PaymentsTaxCalculationRouterData,
event_builder: Option<&mut ConnectorEvent>,
res: Response,
) -> CustomResult<PaymentsTaxCalculationRouterData, errors::ConnectorError> {
let response: taxjar::TaxjarPaymentsResponse = res
.response
.parse_struct("Taxjar PaymentsResponse")
.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,
})
}
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<PSync, PaymentsSyncData, PaymentsResponseData> for Taxjar {}
impl ConnectorIntegration<Capture, PaymentsCaptureData, PaymentsResponseData> for Taxjar {}
impl ConnectorIntegration<Void, PaymentsCancelData, PaymentsResponseData> for Taxjar {}
impl ConnectorIntegration<Execute, RefundsData, RefundsResponseData> for Taxjar {}
impl ConnectorIntegration<RSync, RefundsData, RefundsResponseData> for Taxjar {}
#[async_trait::async_trait]
impl webhooks::IncomingWebhook for Taxjar {
fn get_webhook_object_reference_id(
&self,
_request: &webhooks::IncomingWebhookRequestDetails<'_>,
) -> CustomResult<api_models::webhooks::ObjectReferenceId, errors::ConnectorError> {
Err(report!(errors::ConnectorError::WebhooksNotImplemented))
}
fn get_webhook_event_type(
&self,
_request: &webhooks::IncomingWebhookRequestDetails<'_>,
) -> CustomResult<api_models::webhooks::IncomingWebhookEvent, errors::ConnectorError> {
Err(report!(errors::ConnectorError::WebhooksNotImplemented))
}
fn get_webhook_resource_object(
&self,
_request: &webhooks::IncomingWebhookRequestDetails<'_>,
) -> CustomResult<Box<dyn masking::ErasedMaskSerialize>, errors::ConnectorError> {
Err(report!(errors::ConnectorError::WebhooksNotImplemented))
}
}
static TAXJAR_CONNECTOR_INFO: ConnectorInfo = ConnectorInfo {
display_name: "Taxjar",
description: "TaxJar is a cloud-based platform that automates sales tax calculations, reporting, and filing for businesses across multiple channels",
connector_type: common_enums::HyperswitchConnectorCategory::TaxCalculationProvider,
integration_status: common_enums::ConnectorIntegrationStatus::Sandbox,
};
impl ConnectorSpecifications for Taxjar {
fn get_connector_about(&self) -> Option<&'static ConnectorInfo> {
Some(&TAXJAR_CONNECTOR_INFO)
}
fn get_supported_payment_methods(&self) -> Option<&'static SupportedPaymentMethods> {
None
}
fn get_supported_webhook_flows(&self) -> Option<&'static [common_enums::enums::EventClass]> {
None
}
}
|
{
"crate": "hyperswitch_connectors",
"file": "crates/hyperswitch_connectors/src/connectors/taxjar.rs",
"file_size": null,
"is_async": null,
"is_pub": null,
"num_enums": 0,
"num_structs": 1,
"num_tables": null,
"score": null,
"total_crates": null
}
|
file_hyperswitch_connectors_-3720917872374609408
|
clm
|
file
|
// Repository: hyperswitch
// Crate: hyperswitch_connectors
// File: crates/hyperswitch_connectors/src/connectors/authorizedotnet.rs
// Contains: 1 structs, 0 enums
pub mod transformers;
use std::sync::LazyLock;
use common_enums::{enums, PaymentAction};
use common_utils::{
crypto,
errors::CustomResult,
ext_traits::ByteSliceExt,
request::{Method, Request, RequestBuilder, RequestContent},
types::{AmountConvertor, FloatMajorUnit, FloatMajorUnitForConnector},
};
use error_stack::ResultExt;
use hyperswitch_domain_models::{
payment_method_data::PaymentMethodData,
router_data::{AccessToken, ErrorResponse, RouterData},
router_flow_types::{
access_token_auth::AccessTokenAuth,
payments::{Authorize, Capture, PSync, PaymentMethodToken, Session, SetupMandate, Void},
refunds::{Execute, RSync},
CompleteAuthorize, CreateConnectorCustomer,
},
router_request_types::{
AccessTokenRequestData, CompleteAuthorizeData, ConnectorCustomerData,
PaymentMethodTokenizationData, PaymentsAuthorizeData, PaymentsCancelData,
PaymentsCaptureData, PaymentsSessionData, PaymentsSyncData, RefundsData,
SetupMandateRequestData,
},
router_response_types::{
ConnectorInfo, PaymentMethodDetails, PaymentsResponseData, RefundsResponseData,
SupportedPaymentMethods, SupportedPaymentMethodsExt,
},
types::{
ConnectorCustomerRouterData, PaymentsAuthorizeRouterData, PaymentsCancelRouterData,
PaymentsCaptureRouterData, PaymentsCompleteAuthorizeRouterData, PaymentsSyncRouterData,
RefundsRouterData, SetupMandateRouterData,
},
};
use hyperswitch_interfaces::{
api::{
self, ConnectorCommon, ConnectorCommonExt, ConnectorIntegration, ConnectorSpecifications,
ConnectorValidation, MandateSetup,
},
configs::Connectors,
consts, errors,
events::connector_api_logs::ConnectorEvent,
types::{
ConnectorCustomerType, PaymentsAuthorizeType, PaymentsCaptureType,
PaymentsCompleteAuthorizeType, PaymentsSyncType, PaymentsVoidType, RefundExecuteType,
RefundSyncType, Response, SetupMandateType,
},
webhooks,
};
use masking::Maskable;
use transformers as authorizedotnet;
use crate::{
connectors::authorizedotnet::transformers::AuthorizedotnetRouterData,
constants::headers,
types::ResponseRouterData,
utils::{
self as connector_utils, convert_amount, ForeignTryFrom, PaymentMethodDataType,
PaymentsAuthorizeRequestData, PaymentsCompleteAuthorizeRequestData,
},
};
#[derive(Clone)]
pub struct Authorizedotnet {
amount_convertor: &'static (dyn AmountConvertor<Output = FloatMajorUnit> + Sync),
}
impl Authorizedotnet {
pub fn new() -> &'static Self {
&Self {
amount_convertor: &FloatMajorUnitForConnector,
}
}
}
impl<Flow, Request, Response> ConnectorCommonExt<Flow, Request, Response> for Authorizedotnet
where
Self: ConnectorIntegration<Flow, Request, Response>,
{
fn build_headers(
&self,
_req: &RouterData<Flow, Request, Response>,
_connectors: &Connectors,
) -> CustomResult<Vec<(String, Maskable<String>)>, errors::ConnectorError> {
Ok(vec![(
headers::CONTENT_TYPE.to_string(),
self.get_content_type().to_string().into(),
)])
}
}
impl ConnectorCommon for Authorizedotnet {
fn id(&self) -> &'static str {
"authorizedotnet"
}
fn get_currency_unit(&self) -> api::CurrencyUnit {
api::CurrencyUnit::Base
}
fn common_get_content_type(&self) -> &'static str {
"application/json"
}
fn base_url<'a>(&self, connectors: &'a Connectors) -> &'a str {
connectors.authorizedotnet.base_url.as_ref()
}
}
impl ConnectorValidation for Authorizedotnet {
fn validate_mandate_payment(
&self,
pm_type: Option<enums::PaymentMethodType>,
pm_data: PaymentMethodData,
) -> CustomResult<(), errors::ConnectorError> {
let mandate_supported_pmd = std::collections::HashSet::from([
PaymentMethodDataType::Card,
PaymentMethodDataType::GooglePay,
PaymentMethodDataType::ApplePay,
]);
connector_utils::is_mandate_supported(pm_data, pm_type, mandate_supported_pmd, self.id())
}
}
impl api::Payment for Authorizedotnet {}
impl api::PaymentAuthorize for Authorizedotnet {}
impl api::PaymentSync for Authorizedotnet {}
impl api::PaymentVoid for Authorizedotnet {}
impl api::PaymentCapture for Authorizedotnet {}
impl api::PaymentSession for Authorizedotnet {}
impl api::ConnectorAccessToken for Authorizedotnet {}
impl api::PaymentToken for Authorizedotnet {}
impl ConnectorIntegration<PaymentMethodToken, PaymentMethodTokenizationData, PaymentsResponseData>
for Authorizedotnet
{
// Not Implemented (R)
}
impl ConnectorIntegration<Session, PaymentsSessionData, PaymentsResponseData> for Authorizedotnet {
// Not Implemented (R)
}
impl ConnectorIntegration<AccessTokenAuth, AccessTokenRequestData, AccessToken>
for Authorizedotnet
{
// Not Implemented (R)
}
impl api::ConnectorCustomer for Authorizedotnet {}
impl ConnectorIntegration<CreateConnectorCustomer, ConnectorCustomerData, PaymentsResponseData>
for Authorizedotnet
{
fn get_headers(
&self,
req: &ConnectorCustomerRouterData,
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: &ConnectorCustomerRouterData,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
Ok(self.base_url(connectors).to_string())
}
fn get_request_body(
&self,
req: &ConnectorCustomerRouterData,
_connectors: &Connectors,
) -> CustomResult<RequestContent, errors::ConnectorError> {
let connector_req = authorizedotnet::CustomerRequest::try_from(req)?;
Ok(RequestContent::Json(Box::new(connector_req)))
}
fn build_request(
&self,
req: &ConnectorCustomerRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Ok(Some(
RequestBuilder::new()
.method(Method::Post)
.url(&ConnectorCustomerType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(ConnectorCustomerType::get_headers(self, req, connectors)?)
.set_body(ConnectorCustomerType::get_request_body(
self, req, connectors,
)?)
.build(),
))
}
fn handle_response(
&self,
data: &ConnectorCustomerRouterData,
event_builder: Option<&mut ConnectorEvent>,
res: Response,
) -> CustomResult<ConnectorCustomerRouterData, errors::ConnectorError>
where
PaymentsResponseData: Clone,
{
use bytes::Buf;
// Handle the case where response bytes contains U+FEFF (BOM) character sent by connector
let encoding = encoding_rs::UTF_8;
let intermediate_response = encoding.decode_with_bom_removal(res.response.chunk());
let intermediate_response =
bytes::Bytes::copy_from_slice(intermediate_response.0.as_bytes());
let response: authorizedotnet::AuthorizedotnetCustomerResponse = intermediate_response
.parse_struct("AuthorizedotnetCustomerResponse")
.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,
})
.change_context(errors::ConnectorError::ResponseHandlingFailed)
}
fn get_error_response(
&self,
res: Response,
event_builder: Option<&mut ConnectorEvent>,
) -> CustomResult<ErrorResponse, errors::ConnectorError> {
use bytes::Buf;
// Handle the case where response bytes contains U+FEFF (BOM) character sent by connector
let encoding = encoding_rs::UTF_8;
let intermediate_response = encoding.decode_with_bom_removal(res.response.chunk());
let intermediate_response =
bytes::Bytes::copy_from_slice(intermediate_response.0.as_bytes());
let response: authorizedotnet::AuthorizedotnetErrorResponse = intermediate_response
.parse_struct("AuthorizedotnetErrorResponse")
.change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
event_builder.map(|i| i.set_error_response_body(&response));
router_env::logger::info!(connector_response=?response);
Ok(ErrorResponse {
status_code: res.status_code,
code: response
.error
.code
.clone()
.unwrap_or_else(|| consts::NO_ERROR_CODE.to_string()),
message: response
.error
.message
.clone()
.unwrap_or_else(|| consts::NO_ERROR_MESSAGE.to_string()),
reason: response.error.message,
attempt_status: None,
connector_transaction_id: None,
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
connector_metadata: None,
})
}
}
impl MandateSetup for Authorizedotnet {}
impl ConnectorIntegration<SetupMandate, SetupMandateRequestData, PaymentsResponseData>
for Authorizedotnet
{
fn get_headers(
&self,
req: &SetupMandateRouterData,
connectors: &Connectors,
) -> CustomResult<Vec<(String, Maskable<String>)>, errors::ConnectorError> {
// This connector does not require an auth header, the authentication details are sent in the request body
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(self.base_url(connectors).to_string())
}
fn get_request_body(
&self,
req: &SetupMandateRouterData,
_connectors: &Connectors,
) -> CustomResult<RequestContent, errors::ConnectorError> {
let connector_req = authorizedotnet::CreateCustomerPaymentProfileRequest::try_from(req)?;
Ok(RequestContent::Json(Box::new(connector_req)))
}
fn build_request(
&self,
req: &SetupMandateRouterData,
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<SetupMandateRouterData, errors::ConnectorError> {
use bytes::Buf;
// Handle the case where response bytes contains U+FEFF (BOM) character sent by connector
let encoding = encoding_rs::UTF_8;
let intermediate_response = encoding.decode_with_bom_removal(res.response.chunk());
let intermediate_response =
bytes::Bytes::copy_from_slice(intermediate_response.0.as_bytes());
let response: authorizedotnet::AuthorizedotnetSetupMandateResponse = intermediate_response
.parse_struct("AuthorizedotnetPaymentsResponse")
.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,
})
}
fn get_error_response(
&self,
res: Response,
event_builder: Option<&mut ConnectorEvent>,
) -> CustomResult<ErrorResponse, errors::ConnectorError> {
get_error_response(res, event_builder)
}
}
impl ConnectorIntegration<Capture, PaymentsCaptureData, PaymentsResponseData> for Authorizedotnet {
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(
&self,
_req: &PaymentsCaptureRouterData,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
Ok(self.base_url(connectors).to_string())
}
fn get_request_body(
&self,
req: &PaymentsCaptureRouterData,
_connectors: &Connectors,
) -> CustomResult<RequestContent, errors::ConnectorError> {
let amount = convert_amount(
self.amount_convertor,
req.request.minor_amount_to_capture,
req.request.currency,
)?;
let connector_router_data = AuthorizedotnetRouterData::try_from((amount, req))?;
let connector_req =
authorizedotnet::CancelOrCaptureTransactionRequest::try_from(&connector_router_data)?;
Ok(RequestContent::Json(Box::new(connector_req)))
}
fn build_request(
&self,
req: &PaymentsCaptureRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Ok(Some(
RequestBuilder::new()
.method(Method::Post)
.url(&PaymentsCaptureType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(PaymentsCaptureType::get_headers(self, req, connectors)?)
.set_body(PaymentsCaptureType::get_request_body(
self, req, connectors,
)?)
.build(),
))
}
fn handle_response(
&self,
data: &PaymentsCaptureRouterData,
event_builder: Option<&mut ConnectorEvent>,
res: Response,
) -> CustomResult<PaymentsCaptureRouterData, errors::ConnectorError> {
use bytes::Buf;
// Handle the case where response bytes contains U+FEFF (BOM) character sent by connector
let encoding = encoding_rs::UTF_8;
let intermediate_response = encoding.decode_with_bom_removal(res.response.chunk());
let intermediate_response =
bytes::Bytes::copy_from_slice(intermediate_response.0.as_bytes());
let response: authorizedotnet::AuthorizedotnetPaymentsResponse = intermediate_response
.parse_struct("AuthorizedotnetPaymentsResponse")
.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,
},
true,
))
}
fn get_error_response(
&self,
res: Response,
event_builder: Option<&mut ConnectorEvent>,
) -> CustomResult<ErrorResponse, errors::ConnectorError> {
get_error_response(res, event_builder)
}
}
impl ConnectorIntegration<PSync, PaymentsSyncData, PaymentsResponseData> for Authorizedotnet {
fn get_headers(
&self,
req: &PaymentsSyncRouterData,
connectors: &Connectors,
) -> CustomResult<Vec<(String, Maskable<String>)>, errors::ConnectorError> {
// This connector does not require an auth header, the authentication details are sent in the request body
self.build_headers(req, connectors)
}
fn get_content_type(&self) -> &'static str {
self.common_get_content_type()
}
fn get_url(
&self,
_req: &PaymentsSyncRouterData,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
Ok(self.base_url(connectors).to_string())
}
fn get_request_body(
&self,
req: &PaymentsSyncRouterData,
_connectors: &Connectors,
) -> CustomResult<RequestContent, errors::ConnectorError> {
let connector_req = authorizedotnet::AuthorizedotnetCreateSyncRequest::try_from(req)?;
Ok(RequestContent::Json(Box::new(connector_req)))
}
fn build_request(
&self,
req: &PaymentsSyncRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
let request = RequestBuilder::new()
.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();
Ok(Some(request))
}
fn handle_response(
&self,
data: &PaymentsSyncRouterData,
event_builder: Option<&mut ConnectorEvent>,
res: Response,
) -> CustomResult<PaymentsSyncRouterData, errors::ConnectorError> {
use bytes::Buf;
// Handle the case where response bytes contains U+FEFF (BOM) character sent by connector
let encoding = encoding_rs::UTF_8;
let intermediate_response = encoding.decode_with_bom_removal(res.response.chunk());
let intermediate_response =
bytes::Bytes::copy_from_slice(intermediate_response.0.as_bytes());
let response: authorizedotnet::AuthorizedotnetSyncResponse = intermediate_response
.parse_struct("AuthorizedotnetSyncResponse")
.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,
})
}
fn get_error_response(
&self,
res: Response,
event_builder: Option<&mut ConnectorEvent>,
) -> CustomResult<ErrorResponse, errors::ConnectorError> {
get_error_response(res, event_builder)
}
}
impl ConnectorIntegration<Authorize, PaymentsAuthorizeData, PaymentsResponseData>
for Authorizedotnet
{
fn get_headers(
&self,
req: &PaymentsAuthorizeRouterData,
connectors: &Connectors,
) -> CustomResult<Vec<(String, Maskable<String>)>, errors::ConnectorError> {
// This connector does not require an auth header, the authentication details are sent in the request body
self.build_headers(req, connectors)
}
fn get_content_type(&self) -> &'static str {
self.common_get_content_type()
}
fn get_url(
&self,
_req: &PaymentsAuthorizeRouterData,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
Ok(self.base_url(connectors).to_string())
}
fn get_request_body(
&self,
req: &PaymentsAuthorizeRouterData,
_connectors: &Connectors,
) -> CustomResult<RequestContent, errors::ConnectorError> {
let amount = convert_amount(
self.amount_convertor,
req.request.minor_amount,
req.request.currency,
)?;
let connector_router_data = AuthorizedotnetRouterData::try_from((amount, req))?;
let connector_req =
authorizedotnet::CreateTransactionRequest::try_from(&connector_router_data)?;
Ok(RequestContent::Json(Box::new(connector_req)))
}
fn build_request(
&self,
req: &RouterData<Authorize, PaymentsAuthorizeData, PaymentsResponseData>,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Ok(Some(
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> {
use bytes::Buf;
// Handle the case where response bytes contains U+FEFF (BOM) character sent by connector
let encoding = encoding_rs::UTF_8;
let intermediate_response = encoding.decode_with_bom_removal(res.response.chunk());
let intermediate_response =
bytes::Bytes::copy_from_slice(intermediate_response.0.as_bytes());
let response: authorizedotnet::AuthorizedotnetPaymentsResponse = intermediate_response
.parse_struct("AuthorizedotnetPaymentsResponse")
.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.is_auto_capture()?,
))
}
fn get_error_response(
&self,
res: Response,
event_builder: Option<&mut ConnectorEvent>,
) -> CustomResult<ErrorResponse, errors::ConnectorError> {
get_error_response(res, event_builder)
}
}
impl ConnectorIntegration<Void, PaymentsCancelData, PaymentsResponseData> for Authorizedotnet {
fn get_headers(
&self,
req: &PaymentsCancelRouterData,
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: &PaymentsCancelRouterData,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
Ok(self.base_url(connectors).to_string())
}
fn get_request_body(
&self,
req: &PaymentsCancelRouterData,
_connectors: &Connectors,
) -> CustomResult<RequestContent, errors::ConnectorError> {
let connector_req = authorizedotnet::CancelOrCaptureTransactionRequest::try_from(req)?;
Ok(RequestContent::Json(Box::new(connector_req)))
}
fn build_request(
&self,
req: &PaymentsCancelRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Ok(Some(
RequestBuilder::new()
.method(Method::Post)
.url(&PaymentsVoidType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(PaymentsVoidType::get_headers(self, req, connectors)?)
.set_body(PaymentsVoidType::get_request_body(self, req, connectors)?)
.build(),
))
}
fn handle_response(
&self,
data: &PaymentsCancelRouterData,
event_builder: Option<&mut ConnectorEvent>,
res: Response,
) -> CustomResult<PaymentsCancelRouterData, errors::ConnectorError> {
use bytes::Buf;
// Handle the case where response bytes contains U+FEFF (BOM) character sent by connector
let encoding = encoding_rs::UTF_8;
let intermediate_response = encoding.decode_with_bom_removal(res.response.chunk());
let intermediate_response =
bytes::Bytes::copy_from_slice(intermediate_response.0.as_bytes());
let response: authorizedotnet::AuthorizedotnetVoidResponse = intermediate_response
.parse_struct("AuthorizedotnetPaymentsResponse")
.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,
})
}
fn get_error_response(
&self,
res: Response,
event_builder: Option<&mut ConnectorEvent>,
) -> CustomResult<ErrorResponse, errors::ConnectorError> {
get_error_response(res, event_builder)
}
}
impl api::Refund for Authorizedotnet {}
impl api::RefundExecute for Authorizedotnet {}
impl api::RefundSync for Authorizedotnet {}
impl ConnectorIntegration<Execute, RefundsData, RefundsResponseData> for Authorizedotnet {
fn get_headers(
&self,
req: &RefundsRouterData<Execute>,
connectors: &Connectors,
) -> CustomResult<Vec<(String, Maskable<String>)>, errors::ConnectorError> {
// This connector does not require an auth header, the authentication details are sent in the request body
self.build_headers(req, connectors)
}
fn get_content_type(&self) -> &'static str {
self.common_get_content_type()
}
fn get_url(
&self,
_req: &RefundsRouterData<Execute>,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
Ok(self.base_url(connectors).to_string())
}
fn get_request_body(
&self,
req: &RefundsRouterData<Execute>,
_connectors: &Connectors,
) -> CustomResult<RequestContent, errors::ConnectorError> {
let amount = convert_amount(
self.amount_convertor,
req.request.minor_refund_amount,
req.request.currency,
)?;
let connector_router_data = AuthorizedotnetRouterData::try_from((amount, req))?;
let connector_req = authorizedotnet::CreateRefundRequest::try_from(&connector_router_data)?;
Ok(RequestContent::Json(Box::new(connector_req)))
}
fn build_request(
&self,
req: &RefundsRouterData<Execute>,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
let request = RequestBuilder::new()
.method(Method::Post)
.url(&RefundExecuteType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(RefundExecuteType::get_headers(self, req, connectors)?)
.set_body(RefundExecuteType::get_request_body(self, req, connectors)?)
.build();
Ok(Some(request))
}
fn handle_response(
&self,
data: &RefundsRouterData<Execute>,
event_builder: Option<&mut ConnectorEvent>,
res: Response,
) -> CustomResult<RefundsRouterData<Execute>, errors::ConnectorError> {
use bytes::Buf;
// Handle the case where response bytes contains U+FEFF (BOM) character sent by connector
let encoding = encoding_rs::UTF_8;
let intermediate_response = encoding.decode_with_bom_removal(res.response.chunk());
let intermediate_response =
bytes::Bytes::copy_from_slice(intermediate_response.0.as_bytes());
let response: authorizedotnet::AuthorizedotnetRefundResponse = intermediate_response
.parse_struct("AuthorizedotnetRefundResponse")
.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,
})
}
fn get_error_response(
&self,
res: Response,
event_builder: Option<&mut ConnectorEvent>,
) -> CustomResult<ErrorResponse, errors::ConnectorError> {
get_error_response(res, event_builder)
}
}
impl ConnectorIntegration<RSync, RefundsData, RefundsResponseData> for Authorizedotnet {
fn get_headers(
&self,
req: &RefundsRouterData<RSync>,
connectors: &Connectors,
) -> CustomResult<Vec<(String, Maskable<String>)>, errors::ConnectorError> {
// This connector does not require an auth header, the authentication details are sent in the request body
self.build_headers(req, connectors)
}
fn get_content_type(&self) -> &'static str {
self.common_get_content_type()
}
fn get_url(
&self,
_req: &RefundsRouterData<RSync>,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
Ok(self.base_url(connectors).to_string())
}
fn get_request_body(
&self,
req: &RefundsRouterData<RSync>,
_connectors: &Connectors,
) -> CustomResult<RequestContent, errors::ConnectorError> {
let amount = convert_amount(
self.amount_convertor,
req.request.minor_refund_amount,
req.request.currency,
)?;
let connector_router_data = AuthorizedotnetRouterData::try_from((amount, req))?;
let connector_req =
authorizedotnet::AuthorizedotnetCreateSyncRequest::try_from(&connector_router_data)?;
Ok(RequestContent::Json(Box::new(connector_req)))
}
fn build_request(
&self,
req: &RefundsRouterData<RSync>,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
let request = RequestBuilder::new()
.method(Method::Post)
.url(&RefundSyncType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(RefundSyncType::get_headers(self, req, connectors)?)
.set_body(RefundSyncType::get_request_body(self, req, connectors)?)
.build();
Ok(Some(request))
}
fn handle_response(
&self,
data: &RefundsRouterData<RSync>,
event_builder: Option<&mut ConnectorEvent>,
res: Response,
) -> CustomResult<RefundsRouterData<RSync>, errors::ConnectorError> {
use bytes::Buf;
// Handle the case where response bytes contains U+FEFF (BOM) character sent by connector
let encoding = encoding_rs::UTF_8;
let intermediate_response = encoding.decode_with_bom_removal(res.response.chunk());
let intermediate_response =
bytes::Bytes::copy_from_slice(intermediate_response.0.as_bytes());
let response: authorizedotnet::AuthorizedotnetRSyncResponse = intermediate_response
.parse_struct("AuthorizedotnetRSyncResponse")
.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,
})
}
fn get_error_response(
&self,
res: Response,
event_builder: Option<&mut ConnectorEvent>,
) -> CustomResult<ErrorResponse, errors::ConnectorError> {
get_error_response(res, event_builder)
}
}
impl api::PaymentsCompleteAuthorize for Authorizedotnet {}
impl ConnectorIntegration<CompleteAuthorize, CompleteAuthorizeData, PaymentsResponseData>
for Authorizedotnet
{
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,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
Ok(self.base_url(connectors).to_string())
}
fn get_request_body(
&self,
req: &PaymentsCompleteAuthorizeRouterData,
_connectors: &Connectors,
) -> CustomResult<RequestContent, errors::ConnectorError> {
let amount = convert_amount(
self.amount_convertor,
req.request.minor_amount,
req.request.currency,
)?;
let connector_router_data = AuthorizedotnetRouterData::try_from((amount, req))?;
let connector_req =
authorizedotnet::PaypalConfirmRequest::try_from(&connector_router_data)?;
Ok(RequestContent::Json(Box::new(connector_req)))
}
fn build_request(
&self,
req: &PaymentsCompleteAuthorizeRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Ok(Some(
RequestBuilder::new()
.method(Method::Post)
.url(&PaymentsCompleteAuthorizeType::get_url(
self, req, connectors,
)?)
.attach_default_headers()
.headers(PaymentsCompleteAuthorizeType::get_headers(
self, req, connectors,
)?)
.set_body(PaymentsCompleteAuthorizeType::get_request_body(
self, req, connectors,
)?)
.build(),
))
}
fn handle_response(
&self,
data: &PaymentsCompleteAuthorizeRouterData,
event_builder: Option<&mut ConnectorEvent>,
res: Response,
) -> CustomResult<PaymentsCompleteAuthorizeRouterData, errors::ConnectorError> {
use bytes::Buf;
// Handle the case where response bytes contains U+FEFF (BOM) character sent by connector
let encoding = encoding_rs::UTF_8;
let intermediate_response = encoding.decode_with_bom_removal(res.response.chunk());
let intermediate_response =
bytes::Bytes::copy_from_slice(intermediate_response.0.as_bytes());
let response: authorizedotnet::AuthorizedotnetPaymentsResponse = intermediate_response
.parse_struct("AuthorizedotnetPaymentsResponse")
.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.is_auto_capture()?,
))
}
fn get_error_response(
&self,
res: Response,
event_builder: Option<&mut ConnectorEvent>,
) -> CustomResult<ErrorResponse, errors::ConnectorError> {
get_error_response(res, event_builder)
}
}
#[async_trait::async_trait]
impl webhooks::IncomingWebhook for Authorizedotnet {
fn get_webhook_source_verification_algorithm(
&self,
_request: &webhooks::IncomingWebhookRequestDetails<'_>,
) -> CustomResult<Box<dyn crypto::VerifySignature + Send>, errors::ConnectorError> {
Ok(Box::new(crypto::HmacSha512))
}
fn get_webhook_source_verification_signature(
&self,
request: &webhooks::IncomingWebhookRequestDetails<'_>,
_connector_webhook_secrets: &api_models::webhooks::ConnectorWebhookSecrets,
) -> CustomResult<Vec<u8>, errors::ConnectorError> {
let security_header = request
.headers
.get("X-ANET-Signature")
.map(|header_value| {
header_value
.to_str()
.map(String::from)
.map_err(|_| errors::ConnectorError::WebhookSignatureNotFound)
})
.ok_or(errors::ConnectorError::WebhookSignatureNotFound)??
.to_lowercase();
let (_, sig_value) = security_header
.split_once('=')
.ok_or(errors::ConnectorError::WebhookSourceVerificationFailed)?;
hex::decode(sig_value).change_context(errors::ConnectorError::WebhookSignatureNotFound)
}
fn get_webhook_source_verification_message(
&self,
request: &webhooks::IncomingWebhookRequestDetails<'_>,
_merchant_id: &common_utils::id_type::MerchantId,
_connector_webhook_secrets: &api_models::webhooks::ConnectorWebhookSecrets,
) -> CustomResult<Vec<u8>, errors::ConnectorError> {
Ok(request.body.to_vec())
}
fn get_webhook_object_reference_id(
&self,
request: &webhooks::IncomingWebhookRequestDetails<'_>,
) -> CustomResult<api_models::webhooks::ObjectReferenceId, errors::ConnectorError> {
let details: authorizedotnet::AuthorizedotnetWebhookObjectId = request
.body
.parse_struct("AuthorizedotnetWebhookObjectId")
.change_context(errors::ConnectorError::WebhookReferenceIdNotFound)?;
match details.event_type {
authorizedotnet::AuthorizedotnetWebhookEvent::RefundCreated => {
Ok(api_models::webhooks::ObjectReferenceId::RefundId(
api_models::webhooks::RefundIdType::ConnectorRefundId(
authorizedotnet::get_trans_id(&details)?,
),
))
}
authorizedotnet::AuthorizedotnetWebhookEvent::AuthorizationCreated
| authorizedotnet::AuthorizedotnetWebhookEvent::PriorAuthCapture
| authorizedotnet::AuthorizedotnetWebhookEvent::AuthCapCreated
| authorizedotnet::AuthorizedotnetWebhookEvent::CaptureCreated
| authorizedotnet::AuthorizedotnetWebhookEvent::VoidCreated => {
Ok(api_models::webhooks::ObjectReferenceId::PaymentId(
api_models::payments::PaymentIdType::ConnectorTransactionId(
authorizedotnet::get_trans_id(&details)?,
),
))
}
}
}
fn get_webhook_event_type(
&self,
request: &webhooks::IncomingWebhookRequestDetails<'_>,
) -> CustomResult<api_models::webhooks::IncomingWebhookEvent, errors::ConnectorError> {
let details: authorizedotnet::AuthorizedotnetWebhookEventType = request
.body
.parse_struct("AuthorizedotnetWebhookEventType")
.change_context(errors::ConnectorError::WebhookEventTypeNotFound)?;
Ok(api_models::webhooks::IncomingWebhookEvent::from(
details.event_type,
))
}
fn get_webhook_resource_object(
&self,
request: &webhooks::IncomingWebhookRequestDetails<'_>,
) -> CustomResult<Box<dyn masking::ErasedMaskSerialize>, errors::ConnectorError> {
let payload: authorizedotnet::AuthorizedotnetWebhookObjectId = request
.body
.parse_struct("AuthorizedotnetWebhookObjectId")
.change_context(errors::ConnectorError::WebhookResourceObjectNotFound)?;
Ok(Box::new(
authorizedotnet::AuthorizedotnetSyncResponse::try_from(payload)?,
))
}
}
#[inline]
fn get_error_response(
Response {
response,
status_code,
..
}: Response,
event_builder: Option<&mut ConnectorEvent>,
) -> CustomResult<ErrorResponse, errors::ConnectorError> {
let response: authorizedotnet::AuthorizedotnetPaymentsResponse = response
.parse_struct("AuthorizedotnetPaymentsResponse")
.change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
event_builder.map(|i| i.set_error_response_body(&response));
router_env::logger::info!(connector_response=?response);
match response.transaction_response {
Some(authorizedotnet::TransactionResponse::AuthorizedotnetTransactionResponse(
payment_response,
)) => Ok(payment_response
.errors
.and_then(|errors| {
errors.into_iter().next().map(|error| ErrorResponse {
code: error.error_code,
message: error.error_text.to_owned(),
reason: Some(error.error_text),
status_code,
attempt_status: None,
connector_transaction_id: None,
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
connector_metadata: None,
})
})
.unwrap_or_else(|| ErrorResponse {
code: consts::NO_ERROR_CODE.to_string(), // authorizedotnet sends 200 in case of bad request so this are hard coded to NO_ERROR_CODE and NO_ERROR_MESSAGE
message: consts::NO_ERROR_MESSAGE.to_string(),
reason: None,
status_code,
attempt_status: None,
connector_transaction_id: None,
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
connector_metadata: None,
})),
Some(authorizedotnet::TransactionResponse::AuthorizedotnetTransactionResponseError(_))
| None => {
let message = &response
.messages
.message
.first()
.ok_or(errors::ConnectorError::ResponseDeserializationFailed)?
.text;
Ok(ErrorResponse {
code: consts::NO_ERROR_CODE.to_string(),
message: message.to_string(),
reason: Some(message.to_string()),
status_code,
attempt_status: None,
connector_transaction_id: None,
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
connector_metadata: None,
})
}
}
}
impl api::ConnectorRedirectResponse for Authorizedotnet {
fn get_flow_type(
&self,
_query_params: &str,
_json_payload: Option<serde_json::Value>,
action: PaymentAction,
) -> CustomResult<enums::CallConnectorAction, errors::ConnectorError> {
match action {
PaymentAction::PSync
| PaymentAction::CompleteAuthorize
| PaymentAction::PaymentAuthenticateCompleteAuthorize => {
Ok(enums::CallConnectorAction::Trigger)
}
}
}
}
static AUTHORIZEDOTNET_SUPPORTED_PAYMENT_METHODS: LazyLock<SupportedPaymentMethods> =
LazyLock::new(|| {
let supported_capture_methods = vec![
enums::CaptureMethod::Automatic,
enums::CaptureMethod::Manual,
enums::CaptureMethod::SequentialAutomatic,
];
let supported_card_network = vec![
common_enums::CardNetwork::AmericanExpress,
common_enums::CardNetwork::Discover,
common_enums::CardNetwork::JCB,
common_enums::CardNetwork::Mastercard,
common_enums::CardNetwork::Visa,
];
let mut authorizedotnet_supported_payment_methods = SupportedPaymentMethods::new();
authorizedotnet_supported_payment_methods.add(
enums::PaymentMethod::Wallet,
enums::PaymentMethodType::ApplePay,
PaymentMethodDetails {
mandates: enums::FeatureStatus::Supported,
refunds: enums::FeatureStatus::Supported,
supported_capture_methods: supported_capture_methods.clone(),
specific_features: None,
},
);
authorizedotnet_supported_payment_methods.add(
enums::PaymentMethod::Wallet,
enums::PaymentMethodType::GooglePay,
PaymentMethodDetails {
mandates: enums::FeatureStatus::Supported,
refunds: enums::FeatureStatus::Supported,
supported_capture_methods: supported_capture_methods.clone(),
specific_features: None,
},
);
authorizedotnet_supported_payment_methods.add(
enums::PaymentMethod::Wallet,
enums::PaymentMethodType::Paypal,
PaymentMethodDetails {
mandates: enums::FeatureStatus::NotSupported,
refunds: enums::FeatureStatus::Supported,
supported_capture_methods: supported_capture_methods.clone(),
specific_features: None,
},
);
authorizedotnet_supported_payment_methods.add(
enums::PaymentMethod::Card,
enums::PaymentMethodType::Credit,
PaymentMethodDetails {
mandates: enums::FeatureStatus::Supported,
refunds: enums::FeatureStatus::Supported,
supported_capture_methods: supported_capture_methods.clone(),
specific_features: Some(
api_models::feature_matrix::PaymentMethodSpecificFeatures::Card({
api_models::feature_matrix::CardSpecificFeatures {
three_ds: common_enums::FeatureStatus::NotSupported,
no_three_ds: common_enums::FeatureStatus::Supported,
supported_card_networks: supported_card_network.clone(),
}
}),
),
},
);
authorizedotnet_supported_payment_methods.add(
enums::PaymentMethod::Card,
enums::PaymentMethodType::Debit,
PaymentMethodDetails {
mandates: enums::FeatureStatus::Supported,
refunds: enums::FeatureStatus::Supported,
supported_capture_methods: supported_capture_methods.clone(),
specific_features: Some(
api_models::feature_matrix::PaymentMethodSpecificFeatures::Card({
api_models::feature_matrix::CardSpecificFeatures {
three_ds: common_enums::FeatureStatus::NotSupported,
no_three_ds: common_enums::FeatureStatus::Supported,
supported_card_networks: supported_card_network.clone(),
}
}),
),
},
);
authorizedotnet_supported_payment_methods
});
static AUTHORIZEDOTNET_CONNECTOR_INFO: ConnectorInfo = ConnectorInfo {
display_name: "Authorize.net",
description:
" Authorize.net supports payment processing by helping small businesses accept credit card and eCheck payments online, in person on the go.",
connector_type: enums::HyperswitchConnectorCategory::PaymentGateway,
integration_status: enums::ConnectorIntegrationStatus::Live,
};
static AUTHORIZEDOTNET_SUPPORTED_WEBHOOK_FLOWS: [enums::EventClass; 2] =
[enums::EventClass::Payments, enums::EventClass::Refunds];
impl ConnectorSpecifications for Authorizedotnet {
fn get_connector_about(&self) -> Option<&'static ConnectorInfo> {
Some(&AUTHORIZEDOTNET_CONNECTOR_INFO)
}
fn get_supported_payment_methods(&self) -> Option<&'static SupportedPaymentMethods> {
Some(&*AUTHORIZEDOTNET_SUPPORTED_PAYMENT_METHODS)
}
fn get_supported_webhook_flows(&self) -> Option<&'static [enums::EventClass]> {
Some(&AUTHORIZEDOTNET_SUPPORTED_WEBHOOK_FLOWS)
}
fn should_call_connector_customer(
&self,
_payment_attempt: &hyperswitch_domain_models::payments::payment_attempt::PaymentAttempt,
) -> bool {
true
}
}
|
{
"crate": "hyperswitch_connectors",
"file": "crates/hyperswitch_connectors/src/connectors/authorizedotnet.rs",
"file_size": null,
"is_async": null,
"is_pub": null,
"num_enums": 0,
"num_structs": 1,
"num_tables": null,
"score": null,
"total_crates": null
}
|
file_hyperswitch_connectors_2385579833883181645
|
clm
|
file
|
// Repository: hyperswitch
// Crate: hyperswitch_connectors
// File: crates/hyperswitch_connectors/src/connectors/payeezy.rs
// Contains: 1 structs, 0 enums
pub mod transformers;
use std::sync::LazyLock;
use api_models::webhooks::IncomingWebhookEvent;
use base64::Engine;
use common_enums::enums;
use common_utils::{
errors::CustomResult,
ext_traits::ByteSliceExt,
request::{Method, Request, RequestBuilder, RequestContent},
};
use error_stack::{report, ResultExt};
use hyperswitch_domain_models::{
router_data::{AccessToken, 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::{
ConnectorInfo, PaymentMethodDetails, PaymentsResponseData, RefundsResponseData,
SupportedPaymentMethods, SupportedPaymentMethodsExt,
},
types::{
PaymentsAuthorizeRouterData, PaymentsCancelRouterData, PaymentsCaptureRouterData,
RefundsRouterData,
},
};
use hyperswitch_interfaces::{
api::{
self, ConnectorCommon, ConnectorCommonExt, ConnectorIntegration, ConnectorSpecifications,
ConnectorValidation,
},
configs::Connectors,
errors,
events::connector_api_logs::ConnectorEvent,
types::{
PaymentsAuthorizeType, PaymentsCaptureType, PaymentsVoidType, RefundExecuteType, Response,
},
webhooks::{IncomingWebhook, IncomingWebhookRequestDetails},
};
use masking::{ExposeInterface, Mask};
use rand::distributions::DistString;
use ring::hmac;
use transformers as payeezy;
use crate::{constants::headers, types::ResponseRouterData};
#[derive(Debug, Clone)]
pub struct Payeezy;
impl<Flow, Request, Response> ConnectorCommonExt<Flow, Request, Response> for Payeezy
where
Self: ConnectorIntegration<Flow, Request, Response>,
{
fn build_headers(
&self,
req: &RouterData<Flow, Request, Response>,
connectors: &Connectors,
) -> CustomResult<Vec<(String, masking::Maskable<String>)>, errors::ConnectorError> {
let auth = payeezy::PayeezyAuthType::try_from(&req.connector_auth_type)?;
let request_payload = self
.get_request_body(req, connectors)?
.get_inner_value()
.expose();
let timestamp = std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.ok()
.ok_or(errors::ConnectorError::RequestEncodingFailed)?
.as_millis()
.to_string();
let nonce = rand::distributions::Alphanumeric.sample_string(&mut rand::thread_rng(), 19);
let signature_string = auth.api_key.clone().zip(auth.merchant_token.clone()).map(
|(api_key, merchant_token)| {
format!("{api_key}{nonce}{timestamp}{merchant_token}{request_payload}")
},
);
let key = hmac::Key::new(hmac::HMAC_SHA256, auth.api_secret.expose().as_bytes());
let tag = hmac::sign(&key, signature_string.expose().as_bytes());
let hmac_sign = hex::encode(tag);
let signature_value = common_utils::consts::BASE64_ENGINE_URL_SAFE.encode(hmac_sign);
Ok(vec![
(
headers::CONTENT_TYPE.to_string(),
Self.get_content_type().to_string().into(),
),
(headers::APIKEY.to_string(), auth.api_key.into_masked()),
(
headers::TOKEN.to_string(),
auth.merchant_token.into_masked(),
),
(
headers::AUTHORIZATION.to_string(),
signature_value.into_masked(),
),
(headers::NONCE.to_string(), nonce.into_masked()),
(headers::TIMESTAMP.to_string(), timestamp.into()),
])
}
}
impl ConnectorCommon for Payeezy {
fn id(&self) -> &'static str {
"payeezy"
}
fn get_currency_unit(&self) -> api::CurrencyUnit {
api::CurrencyUnit::Base
}
fn common_get_content_type(&self) -> &'static str {
"application/json"
}
fn base_url<'a>(&self, connectors: &'a Connectors) -> &'a str {
connectors.payeezy.base_url.as_ref()
}
fn build_error_response(
&self,
res: Response,
event_builder: Option<&mut ConnectorEvent>,
) -> CustomResult<ErrorResponse, errors::ConnectorError> {
let response: payeezy::PayeezyErrorResponse = res
.response
.parse_struct("payeezy ErrorResponse")
.change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
event_builder.map(|i| i.set_error_response_body(&response));
router_env::logger::info!(connector_response=?response);
let error_messages: Vec<String> = response
.error
.messages
.iter()
.map(|m| m.description.clone())
.collect();
Ok(ErrorResponse {
status_code: res.status_code,
code: response.transaction_status,
message: error_messages.join(", "),
reason: None,
attempt_status: None,
connector_transaction_id: None,
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
connector_metadata: None,
})
}
}
impl ConnectorValidation for Payeezy {}
impl api::Payment for Payeezy {}
impl api::MandateSetup for Payeezy {}
impl ConnectorIntegration<SetupMandate, SetupMandateRequestData, PaymentsResponseData> for Payeezy {
fn build_request(
&self,
_req: &RouterData<SetupMandate, SetupMandateRequestData, PaymentsResponseData>,
_connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Err(
errors::ConnectorError::NotImplemented("Setup Mandate flow for Payeezy".to_string())
.into(),
)
}
}
impl api::PaymentToken for Payeezy {}
impl ConnectorIntegration<PaymentMethodToken, PaymentMethodTokenizationData, PaymentsResponseData>
for Payeezy
{
// Not Implemented (R)
}
impl api::PaymentVoid for Payeezy {}
impl ConnectorIntegration<Void, PaymentsCancelData, PaymentsResponseData> for Payeezy {
fn get_headers(
&self,
req: &PaymentsCancelRouterData,
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: &PaymentsCancelRouterData,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
let connector_payment_id = req.request.connector_transaction_id.clone();
Ok(format!(
"{}v1/transactions/{}",
self.base_url(connectors),
connector_payment_id
))
}
fn get_request_body(
&self,
req: &PaymentsCancelRouterData,
_connectors: &Connectors,
) -> CustomResult<RequestContent, errors::ConnectorError> {
let connector_req = payeezy::PayeezyCaptureOrVoidRequest::try_from(req)?;
Ok(RequestContent::Json(Box::new(connector_req)))
}
fn build_request(
&self,
req: &PaymentsCancelRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Ok(Some(
RequestBuilder::new()
.method(Method::Post)
.url(&PaymentsVoidType::get_url(self, req, connectors)?)
.headers(PaymentsVoidType::get_headers(self, req, connectors)?)
.set_body(PaymentsVoidType::get_request_body(self, req, connectors)?)
.build(),
))
}
fn handle_response(
&self,
data: &PaymentsCancelRouterData,
event_builder: Option<&mut ConnectorEvent>,
res: Response,
) -> CustomResult<PaymentsCancelRouterData, errors::ConnectorError> {
let response: payeezy::PayeezyPaymentsResponse = res
.response
.parse_struct("Payeezy PaymentsResponse")
.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,
})
.change_context(errors::ConnectorError::ResponseHandlingFailed)
}
fn get_error_response(
&self,
res: Response,
event_builder: Option<&mut ConnectorEvent>,
) -> CustomResult<ErrorResponse, errors::ConnectorError> {
self.build_error_response(res, event_builder)
}
}
impl api::ConnectorAccessToken for Payeezy {}
impl ConnectorIntegration<AccessTokenAuth, AccessTokenRequestData, AccessToken> for Payeezy {}
impl api::PaymentSync for Payeezy {}
impl ConnectorIntegration<PSync, PaymentsSyncData, PaymentsResponseData> for Payeezy {
// default implementation of build_request method will be executed
}
impl api::PaymentCapture for Payeezy {}
impl ConnectorIntegration<Capture, PaymentsCaptureData, PaymentsResponseData> for Payeezy {
fn get_headers(
&self,
req: &PaymentsCaptureRouterData,
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: &PaymentsCaptureRouterData,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
let connector_payment_id = req.request.connector_transaction_id.clone();
Ok(format!(
"{}v1/transactions/{}",
self.base_url(connectors),
connector_payment_id
))
}
fn get_request_body(
&self,
req: &PaymentsCaptureRouterData,
_connectors: &Connectors,
) -> CustomResult<RequestContent, errors::ConnectorError> {
let router_obj = payeezy::PayeezyRouterData::try_from((
&self.get_currency_unit(),
req.request.currency,
req.request.amount_to_capture,
req,
))?;
let connector_req = payeezy::PayeezyCaptureOrVoidRequest::try_from(&router_obj)?;
Ok(RequestContent::Json(Box::new(connector_req)))
}
fn build_request(
&self,
req: &PaymentsCaptureRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Ok(Some(
RequestBuilder::new()
.method(Method::Post)
.url(&PaymentsCaptureType::get_url(self, req, connectors)?)
.headers(PaymentsCaptureType::get_headers(self, req, connectors)?)
.set_body(PaymentsCaptureType::get_request_body(
self, req, connectors,
)?)
.build(),
))
}
fn handle_response(
&self,
data: &PaymentsCaptureRouterData,
event_builder: Option<&mut ConnectorEvent>,
res: Response,
) -> CustomResult<PaymentsCaptureRouterData, errors::ConnectorError> {
let response: payeezy::PayeezyPaymentsResponse = res
.response
.parse_struct("Payeezy PaymentsResponse")
.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,
})
.change_context(errors::ConnectorError::ResponseHandlingFailed)
}
fn get_error_response(
&self,
res: Response,
event_builder: Option<&mut ConnectorEvent>,
) -> CustomResult<ErrorResponse, errors::ConnectorError> {
self.build_error_response(res, event_builder)
}
}
impl api::PaymentSession for Payeezy {}
impl ConnectorIntegration<Session, PaymentsSessionData, PaymentsResponseData> for Payeezy {
//TODO: implement sessions flow
}
impl api::PaymentAuthorize for Payeezy {}
impl ConnectorIntegration<Authorize, PaymentsAuthorizeData, PaymentsResponseData> for Payeezy {
fn get_headers(
&self,
req: &PaymentsAuthorizeRouterData,
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: &PaymentsAuthorizeRouterData,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
Ok(format!("{}v1/transactions", self.base_url(connectors)))
}
fn get_request_body(
&self,
req: &PaymentsAuthorizeRouterData,
_connectors: &Connectors,
) -> CustomResult<RequestContent, errors::ConnectorError> {
let router_obj = payeezy::PayeezyRouterData::try_from((
&self.get_currency_unit(),
req.request.currency,
req.request.amount,
req,
))?;
let connector_req = payeezy::PayeezyPaymentsRequest::try_from(&router_obj)?;
Ok(RequestContent::Json(Box::new(connector_req)))
}
fn build_request(
&self,
req: &PaymentsAuthorizeRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Ok(Some(
RequestBuilder::new()
.method(Method::Post)
.url(&PaymentsAuthorizeType::get_url(self, req, connectors)?)
.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: payeezy::PayeezyPaymentsResponse = res
.response
.parse_struct("payeezy Response")
.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,
})
.change_context(errors::ConnectorError::ResponseHandlingFailed)
}
fn get_error_response(
&self,
res: Response,
event_builder: Option<&mut ConnectorEvent>,
) -> CustomResult<ErrorResponse, errors::ConnectorError> {
self.build_error_response(res, event_builder)
}
}
impl api::Refund for Payeezy {}
impl api::RefundExecute for Payeezy {}
impl api::RefundSync for Payeezy {}
impl ConnectorIntegration<Execute, RefundsData, RefundsResponseData> for Payeezy {
fn get_headers(
&self,
req: &RefundsRouterData<Execute>,
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: &RefundsRouterData<Execute>,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
let connector_payment_id = req.request.connector_transaction_id.clone();
Ok(format!(
"{}v1/transactions/{}",
self.base_url(connectors),
connector_payment_id
))
}
fn get_request_body(
&self,
req: &RefundsRouterData<Execute>,
_connectors: &Connectors,
) -> CustomResult<RequestContent, errors::ConnectorError> {
let router_obj = payeezy::PayeezyRouterData::try_from((
&self.get_currency_unit(),
req.request.currency,
req.request.refund_amount,
req,
))?;
let connector_req = payeezy::PayeezyRefundRequest::try_from(&router_obj)?;
Ok(RequestContent::Json(Box::new(connector_req)))
}
fn build_request(
&self,
req: &RefundsRouterData<Execute>,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
let request = RequestBuilder::new()
.method(Method::Post)
.url(&RefundExecuteType::get_url(self, req, connectors)?)
.headers(RefundExecuteType::get_headers(self, req, connectors)?)
.set_body(RefundExecuteType::get_request_body(self, req, connectors)?)
.build();
Ok(Some(request))
}
fn handle_response(
&self,
data: &RefundsRouterData<Execute>,
event_builder: Option<&mut ConnectorEvent>,
res: Response,
) -> CustomResult<RefundsRouterData<Execute>, errors::ConnectorError> {
// Parse the response into a payeezy::RefundResponse
let response: payeezy::RefundResponse = res
.response
.parse_struct("payeezy RefundResponse")
.change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
event_builder.map(|i| i.set_response_body(&response));
router_env::logger::info!(connector_response=?response);
// Create a new instance of types::RefundsRouterData based on the response, input data, and HTTP code
let response_data = ResponseRouterData {
response,
data: data.clone(),
http_code: res.status_code,
};
let router_data = RouterData::try_from(response_data)
.change_context(errors::ConnectorError::ResponseHandlingFailed)?;
Ok(router_data)
}
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<RSync, RefundsData, RefundsResponseData> for Payeezy {
// default implementation of build_request method will be executed
}
#[async_trait::async_trait]
impl IncomingWebhook for Payeezy {
fn get_webhook_object_reference_id(
&self,
_request: &IncomingWebhookRequestDetails<'_>,
) -> CustomResult<api_models::webhooks::ObjectReferenceId, errors::ConnectorError> {
Err(report!(errors::ConnectorError::WebhooksNotImplemented))
}
fn get_webhook_event_type(
&self,
_request: &IncomingWebhookRequestDetails<'_>,
) -> CustomResult<IncomingWebhookEvent, errors::ConnectorError> {
Ok(IncomingWebhookEvent::EventNotSupported)
}
fn get_webhook_resource_object(
&self,
_request: &IncomingWebhookRequestDetails<'_>,
) -> CustomResult<Box<dyn masking::ErasedMaskSerialize>, errors::ConnectorError> {
Err(report!(errors::ConnectorError::WebhooksNotImplemented))
}
}
static PAYEEZY_SUPPORTED_PAYMENT_METHODS: LazyLock<SupportedPaymentMethods> = LazyLock::new(|| {
let supported_capture_methods = vec![
enums::CaptureMethod::Automatic,
enums::CaptureMethod::Manual,
enums::CaptureMethod::SequentialAutomatic,
];
let supported_card_networks = vec![
common_enums::CardNetwork::Mastercard,
common_enums::CardNetwork::Visa,
common_enums::CardNetwork::AmericanExpress,
common_enums::CardNetwork::Discover,
];
let mut payeezy_supported_payment_methods = SupportedPaymentMethods::new();
payeezy_supported_payment_methods.add(
enums::PaymentMethod::Card,
enums::PaymentMethodType::Credit,
PaymentMethodDetails {
mandates: enums::FeatureStatus::Supported,
refunds: enums::FeatureStatus::Supported,
supported_capture_methods,
specific_features: Some(
api_models::feature_matrix::PaymentMethodSpecificFeatures::Card({
api_models::feature_matrix::CardSpecificFeatures {
three_ds: common_enums::FeatureStatus::NotSupported,
no_three_ds: common_enums::FeatureStatus::Supported,
supported_card_networks,
}
}),
),
},
);
payeezy_supported_payment_methods
});
static PAYEEZY_CONNECTOR_INFO: ConnectorInfo = ConnectorInfo {
display_name: "Payeezy",
description: "Payeezy is a payment gateway platform that facilitates online and mobile payment processing for businesses. It provides a range of features, including support for various payment methods, security features like PCI-DSS compliance and tokenization, and tools for managing transactions and customer interactions.",
connector_type: enums::HyperswitchConnectorCategory::PaymentGateway,
integration_status: enums::ConnectorIntegrationStatus::Alpha,
};
static PAYEEZY_SUPPORTED_WEBHOOK_FLOWS: [enums::EventClass; 0] = [];
impl ConnectorSpecifications for Payeezy {
fn get_connector_about(&self) -> Option<&'static ConnectorInfo> {
Some(&PAYEEZY_CONNECTOR_INFO)
}
fn get_supported_payment_methods(&self) -> Option<&'static SupportedPaymentMethods> {
Some(&*PAYEEZY_SUPPORTED_PAYMENT_METHODS)
}
fn get_supported_webhook_flows(&self) -> Option<&'static [enums::EventClass]> {
Some(&PAYEEZY_SUPPORTED_WEBHOOK_FLOWS)
}
}
|
{
"crate": "hyperswitch_connectors",
"file": "crates/hyperswitch_connectors/src/connectors/payeezy.rs",
"file_size": null,
"is_async": null,
"is_pub": null,
"num_enums": 0,
"num_structs": 1,
"num_tables": null,
"score": null,
"total_crates": null
}
|
file_hyperswitch_connectors_3899379482177228277
|
clm
|
file
|
// Repository: hyperswitch
// Crate: hyperswitch_connectors
// File: crates/hyperswitch_connectors/src/connectors/iatapay.rs
// Contains: 1 structs, 0 enums
pub mod transformers;
use api_models::{enums, webhooks::IncomingWebhookEvent};
use base64::Engine;
use common_utils::{
consts::BASE64_ENGINE,
crypto,
errors::CustomResult,
ext_traits::{ByteSliceExt, BytesExt},
request::{Method, Request, RequestBuilder, RequestContent},
types::{AmountConvertor, FloatMajorUnit, FloatMajorUnitForConnector},
};
use error_stack::ResultExt;
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::{
ConnectorInfo, PaymentMethodDetails, PaymentsResponseData, RefundsResponseData,
SupportedPaymentMethods, SupportedPaymentMethodsExt,
},
types::{
PaymentsAuthorizeRouterData, PaymentsCaptureRouterData, PaymentsSyncRouterData,
RefundSyncRouterData, RefundsRouterData,
},
};
use hyperswitch_interfaces::{
api::{
self, ConnectorCommon, ConnectorCommonExt, ConnectorIntegration, ConnectorSpecifications,
ConnectorValidation,
},
configs::Connectors,
consts::{NO_ERROR_CODE, NO_ERROR_MESSAGE},
errors,
events::connector_api_logs::ConnectorEvent,
types::{self, Response},
webhooks::{IncomingWebhook, IncomingWebhookRequestDetails},
};
use lazy_static::lazy_static;
use masking::{Mask, PeekInterface};
use transformers::{self as iatapay, IatapayPaymentsResponse};
use crate::{
constants::{headers, CONNECTOR_UNAUTHORIZED_ERROR},
types::{RefreshTokenRouterData, ResponseRouterData},
utils::{base64_decode, convert_amount, get_header_key_value},
};
#[derive(Clone)]
pub struct Iatapay {
amount_converter: &'static (dyn AmountConvertor<Output = FloatMajorUnit> + Sync),
}
impl Iatapay {
pub fn new() -> &'static Self {
&Self {
amount_converter: &FloatMajorUnitForConnector,
}
}
}
impl api::Payment for Iatapay {}
impl api::PaymentSession for Iatapay {}
impl api::ConnectorAccessToken for Iatapay {}
impl api::MandateSetup for Iatapay {}
impl api::PaymentAuthorize for Iatapay {}
impl api::PaymentSync for Iatapay {}
impl api::PaymentCapture for Iatapay {}
impl api::PaymentVoid for Iatapay {}
impl api::Refund for Iatapay {}
impl api::RefundExecute for Iatapay {}
impl api::RefundSync for Iatapay {}
impl api::PaymentToken for Iatapay {}
impl ConnectorIntegration<PaymentMethodToken, PaymentMethodTokenizationData, PaymentsResponseData>
for Iatapay
{
// Not Implemented (R)
}
impl<Flow, Request, Response> ConnectorCommonExt<Flow, Request, Response> for Iatapay
where
Self: ConnectorIntegration<Flow, Request, Response>,
{
fn build_headers(
&self,
req: &RouterData<Flow, Request, Response>,
_connectors: &Connectors,
) -> CustomResult<Vec<(String, masking::Maskable<String>)>, errors::ConnectorError> {
let mut headers = vec![(
headers::CONTENT_TYPE.to_string(),
self.get_content_type().to_string().into(),
)];
let access_token = req
.access_token
.clone()
.ok_or(errors::ConnectorError::FailedToObtainAuthType)?;
let auth_header = (
headers::AUTHORIZATION.to_string(),
format!("Bearer {}", access_token.token.peek()).into_masked(),
);
headers.push(auth_header);
Ok(headers)
}
}
impl ConnectorCommon for Iatapay {
fn id(&self) -> &'static str {
"iatapay"
}
fn common_get_content_type(&self) -> &'static str {
"application/json"
}
fn get_currency_unit(&self) -> api::CurrencyUnit {
api::CurrencyUnit::Base
}
fn base_url<'a>(&self, connectors: &'a Connectors) -> &'a str {
connectors.iatapay.base_url.as_ref()
}
fn get_auth_header(
&self,
auth_type: &ConnectorAuthType,
) -> CustomResult<Vec<(String, masking::Maskable<String>)>, errors::ConnectorError> {
let auth = iatapay::IatapayAuthType::try_from(auth_type)
.change_context(errors::ConnectorError::FailedToObtainAuthType)?;
Ok(vec![(
headers::AUTHORIZATION.to_string(),
auth.client_id.into_masked(),
)])
}
fn build_error_response(
&self,
res: Response,
event_builder: Option<&mut ConnectorEvent>,
) -> CustomResult<ErrorResponse, errors::ConnectorError> {
let response_error_message = if res.response.is_empty() && res.status_code == 401 {
ErrorResponse {
status_code: res.status_code,
code: NO_ERROR_CODE.to_string(),
message: NO_ERROR_MESSAGE.to_string(),
reason: Some(CONNECTOR_UNAUTHORIZED_ERROR.to_string()),
attempt_status: None,
connector_transaction_id: None,
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
connector_metadata: None,
}
} else {
let response: iatapay::IatapayErrorResponse = res
.response
.parse_struct("IatapayErrorResponse")
.change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
event_builder.map(|i| i.set_error_response_body(&response));
router_env::logger::info!(connector_response=?response);
ErrorResponse {
status_code: res.status_code,
code: response.error,
message: response.message.unwrap_or(NO_ERROR_MESSAGE.to_string()),
reason: response.reason,
attempt_status: None,
connector_transaction_id: None,
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
connector_metadata: None,
}
};
Ok(response_error_message)
}
}
impl ConnectorValidation for Iatapay {}
impl ConnectorIntegration<Session, PaymentsSessionData, PaymentsResponseData> for Iatapay {
//TODO: implement sessions flow
}
impl ConnectorIntegration<AccessTokenAuth, AccessTokenRequestData, AccessToken> for Iatapay {
fn get_url(
&self,
_req: &RefreshTokenRouterData,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
Ok(format!("{}{}", self.base_url(connectors), "/oauth/token"))
}
fn get_content_type(&self) -> &'static str {
"application/x-www-form-urlencoded"
}
fn get_headers(
&self,
req: &RefreshTokenRouterData,
_connectors: &Connectors,
) -> CustomResult<Vec<(String, masking::Maskable<String>)>, errors::ConnectorError> {
let auth: iatapay::IatapayAuthType =
iatapay::IatapayAuthType::try_from(&req.connector_auth_type)
.change_context(errors::ConnectorError::FailedToObtainAuthType)?;
let auth_id = format!("{}:{}", auth.client_id.peek(), auth.client_secret.peek());
let auth_val: String = format!("Basic {}", BASE64_ENGINE.encode(auth_id));
Ok(vec![
(
headers::CONTENT_TYPE.to_string(),
types::RefreshTokenType::get_content_type(self)
.to_string()
.into(),
),
(headers::AUTHORIZATION.to_string(), auth_val.into_masked()),
])
}
fn get_request_body(
&self,
req: &RefreshTokenRouterData,
_connectors: &Connectors,
) -> CustomResult<RequestContent, errors::ConnectorError> {
let connector_req = iatapay::IatapayAuthUpdateRequest::try_from(req)?;
Ok(RequestContent::FormUrlEncoded(Box::new(connector_req)))
}
fn build_request(
&self,
req: &RefreshTokenRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
let req = Some(
RequestBuilder::new()
.method(Method::Post)
.attach_default_headers()
.headers(types::RefreshTokenType::get_headers(self, req, connectors)?)
.url(&types::RefreshTokenType::get_url(self, req, connectors)?)
.set_body(types::RefreshTokenType::get_request_body(
self, req, connectors,
)?)
.build(),
);
Ok(req)
}
fn handle_response(
&self,
data: &RefreshTokenRouterData,
event_builder: Option<&mut ConnectorEvent>,
res: Response,
) -> CustomResult<RefreshTokenRouterData, errors::ConnectorError> {
let response: iatapay::IatapayAuthUpdateResponse = res
.response
.parse_struct("iatapay IatapayAuthUpdateResponse")
.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,
})
}
fn get_error_response(
&self,
res: Response,
event_builder: Option<&mut ConnectorEvent>,
) -> CustomResult<ErrorResponse, errors::ConnectorError> {
let response: iatapay::IatapayAccessTokenErrorResponse = res
.response
.parse_struct("Iatapay AccessTokenErrorResponse")
.change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
event_builder.map(|i| i.set_error_response_body(&response));
router_env::logger::info!(connector_response=?response);
Ok(ErrorResponse {
status_code: res.status_code,
code: response.error.clone(),
message: response.path.unwrap_or(response.error),
reason: None,
attempt_status: None,
connector_transaction_id: None,
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
connector_metadata: None,
})
}
}
impl ConnectorIntegration<SetupMandate, SetupMandateRequestData, PaymentsResponseData> for Iatapay {
fn build_request(
&self,
_req: &RouterData<SetupMandate, SetupMandateRequestData, PaymentsResponseData>,
_connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Err(
errors::ConnectorError::NotImplemented("Setup Mandate flow for Iatapay".to_string())
.into(),
)
}
}
impl ConnectorIntegration<Authorize, PaymentsAuthorizeData, PaymentsResponseData> for Iatapay {
fn get_headers(
&self,
req: &PaymentsAuthorizeRouterData,
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: &PaymentsAuthorizeRouterData,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
Ok(format!("{}/payments/", self.base_url(connectors)))
}
fn get_request_body(
&self,
req: &PaymentsAuthorizeRouterData,
_connectors: &Connectors,
) -> CustomResult<RequestContent, errors::ConnectorError> {
let amount = convert_amount(
self.amount_converter,
req.request.minor_amount,
req.request.currency,
)?;
let connector_router_data = iatapay::IatapayRouterData::try_from((amount, req))?;
let connector_req = iatapay::IatapayPaymentsRequest::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> {
Ok(Some(
RequestBuilder::new()
.method(Method::Post)
.url(&types::PaymentsAuthorizeType::get_url(
self, req, connectors,
)?)
.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: IatapayPaymentsResponse = res
.response
.parse_struct("Iatapay 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,
})
.change_context(errors::ConnectorError::ResponseHandlingFailed)
}
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<PSync, PaymentsSyncData, PaymentsResponseData> for Iatapay {
fn get_headers(
&self,
req: &PaymentsSyncRouterData,
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: &PaymentsSyncRouterData,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
let auth: iatapay::IatapayAuthType =
iatapay::IatapayAuthType::try_from(&req.connector_auth_type)?;
let merchant_id = auth.merchant_id.peek();
Ok(format!(
"{}/merchants/{merchant_id}/payments/{}",
self.base_url(connectors),
req.connector_request_reference_id.clone()
))
}
fn build_request(
&self,
req: &PaymentsSyncRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Ok(Some(
RequestBuilder::new()
.method(Method::Get)
.url(&types::PaymentsSyncType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(types::PaymentsSyncType::get_headers(self, req, connectors)?)
.build(),
))
}
fn handle_response(
&self,
data: &PaymentsSyncRouterData,
event_builder: Option<&mut ConnectorEvent>,
res: Response,
) -> CustomResult<PaymentsSyncRouterData, errors::ConnectorError> {
let response: IatapayPaymentsResponse = res
.response
.parse_struct("iatapay PaymentsSyncResponse")
.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,
})
.change_context(errors::ConnectorError::ResponseHandlingFailed)
}
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 Iatapay {
fn build_request(
&self,
_req: &PaymentsCaptureRouterData,
_connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Err(errors::ConnectorError::FlowNotSupported {
flow: "Capture".to_string(),
connector: "Iatapay".to_string(),
}
.into())
}
}
impl ConnectorIntegration<Void, PaymentsCancelData, PaymentsResponseData> for Iatapay {}
impl ConnectorIntegration<Execute, RefundsData, RefundsResponseData> for Iatapay {
fn get_headers(
&self,
req: &RefundsRouterData<Execute>,
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: &RefundsRouterData<Execute>,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
Ok(format!(
"{}{}{}{}",
self.base_url(connectors),
"/payments/",
req.request.connector_transaction_id,
"/refund"
))
}
fn get_request_body(
&self,
req: &RefundsRouterData<Execute>,
_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 = iatapay::IatapayRouterData::try_from((refund_amount, req))?;
let connector_req = iatapay::IatapayRefundRequest::try_from(&connector_router_data)?;
Ok(RequestContent::Json(Box::new(connector_req)))
}
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))
}
fn handle_response(
&self,
data: &RefundsRouterData<Execute>,
event_builder: Option<&mut ConnectorEvent>,
res: Response,
) -> CustomResult<RefundsRouterData<Execute>, errors::ConnectorError> {
let response: iatapay::RefundResponse = res
.response
.parse_struct("iatapay RefundResponse")
.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,
})
.change_context(errors::ConnectorError::ResponseHandlingFailed)
}
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<RSync, RefundsData, RefundsResponseData> for Iatapay {
fn get_headers(
&self,
req: &RefundSyncRouterData,
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: &RefundSyncRouterData,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
Ok(format!(
"{}{}{}",
self.base_url(connectors),
"/refunds/",
match req.request.connector_refund_id.clone() {
Some(val) => val,
None => req.request.refund_id.clone(),
},
))
}
fn build_request(
&self,
req: &RefundSyncRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Ok(Some(
RequestBuilder::new()
.method(Method::Get)
.url(&types::RefundSyncType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(types::RefundSyncType::get_headers(self, req, connectors)?)
.build(),
))
}
fn handle_response(
&self,
data: &RefundSyncRouterData,
event_builder: Option<&mut ConnectorEvent>,
res: Response,
) -> CustomResult<RefundSyncRouterData, errors::ConnectorError> {
let response: iatapay::RefundResponse = res
.response
.parse_struct("iatapay RefundSyncResponse")
.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,
})
.change_context(errors::ConnectorError::ResponseHandlingFailed)
}
fn get_error_response(
&self,
res: Response,
event_builder: Option<&mut ConnectorEvent>,
) -> CustomResult<ErrorResponse, errors::ConnectorError> {
self.build_error_response(res, event_builder)
}
}
#[async_trait::async_trait]
impl IncomingWebhook for Iatapay {
fn get_webhook_source_verification_algorithm(
&self,
_request: &IncomingWebhookRequestDetails<'_>,
) -> CustomResult<Box<dyn crypto::VerifySignature + Send>, errors::ConnectorError> {
Ok(Box::new(crypto::HmacSha256))
}
fn get_webhook_source_verification_signature(
&self,
request: &IncomingWebhookRequestDetails<'_>,
_connector_webhook_secrets: &api_models::webhooks::ConnectorWebhookSecrets,
) -> CustomResult<Vec<u8>, errors::ConnectorError> {
let base64_signature = get_header_key_value("Authorization", request.headers)?;
let base64_signature = base64_signature.replace("IATAPAY-HMAC-SHA256 ", "");
base64_decode(base64_signature)
}
fn get_webhook_source_verification_message(
&self,
request: &IncomingWebhookRequestDetails<'_>,
_merchant_id: &common_utils::id_type::MerchantId,
_connector_webhook_secrets: &api_models::webhooks::ConnectorWebhookSecrets,
) -> CustomResult<Vec<u8>, errors::ConnectorError> {
let message = std::str::from_utf8(request.body)
.change_context(errors::ConnectorError::WebhookSourceVerificationFailed)?;
Ok(message.to_string().into_bytes())
}
fn get_webhook_object_reference_id(
&self,
request: &IncomingWebhookRequestDetails<'_>,
) -> CustomResult<api_models::webhooks::ObjectReferenceId, errors::ConnectorError> {
let notif: iatapay::IatapayWebhookResponse = request
.body
.parse_struct("IatapayWebhookResponse")
.change_context(errors::ConnectorError::WebhookReferenceIdNotFound)?;
match notif {
iatapay::IatapayWebhookResponse::IatapayPaymentWebhookBody(wh_body) => {
match wh_body.merchant_payment_id {
Some(merchant_payment_id) => {
Ok(api_models::webhooks::ObjectReferenceId::PaymentId(
api_models::payments::PaymentIdType::PaymentAttemptId(
merchant_payment_id,
),
))
}
None => Ok(api_models::webhooks::ObjectReferenceId::PaymentId(
api_models::payments::PaymentIdType::ConnectorTransactionId(
wh_body.iata_payment_id,
),
)),
}
}
iatapay::IatapayWebhookResponse::IatapayRefundWebhookBody(wh_body) => {
match wh_body.merchant_refund_id {
Some(merchant_refund_id) => {
Ok(api_models::webhooks::ObjectReferenceId::RefundId(
api_models::webhooks::RefundIdType::RefundId(merchant_refund_id),
))
}
None => Ok(api_models::webhooks::ObjectReferenceId::RefundId(
api_models::webhooks::RefundIdType::ConnectorRefundId(
wh_body.iata_refund_id,
),
)),
}
}
}
}
fn get_webhook_event_type(
&self,
request: &IncomingWebhookRequestDetails<'_>,
) -> CustomResult<IncomingWebhookEvent, errors::ConnectorError> {
let notif: iatapay::IatapayWebhookResponse = request
.body
.parse_struct("IatapayWebhookResponse")
.change_context(errors::ConnectorError::WebhookEventTypeNotFound)?;
IncomingWebhookEvent::try_from(notif)
}
fn get_webhook_resource_object(
&self,
request: &IncomingWebhookRequestDetails<'_>,
) -> CustomResult<Box<dyn masking::ErasedMaskSerialize>, errors::ConnectorError> {
let notif: iatapay::IatapayWebhookResponse = request
.body
.parse_struct("IatapayWebhookResponse")
.change_context(errors::ConnectorError::WebhookBodyDecodingFailed)?;
match notif {
iatapay::IatapayWebhookResponse::IatapayPaymentWebhookBody(wh_body) => {
Ok(Box::new(wh_body))
}
iatapay::IatapayWebhookResponse::IatapayRefundWebhookBody(refund_wh_body) => {
Ok(Box::new(refund_wh_body))
}
}
}
}
lazy_static! {
static ref IATAPAY_CONNECTOR_INFO: ConnectorInfo = ConnectorInfo {
display_name: "Iatapay",
description:
"IATA Pay is a payment method for travellers to pay for air tickets purchased online by directly debiting their bank account.",
connector_type: enums::HyperswitchConnectorCategory::PaymentGateway,
integration_status: enums::ConnectorIntegrationStatus::Live,
};
static ref IATAPAY_SUPPORTED_PAYMENT_METHODS: SupportedPaymentMethods = {
let supported_capture_methods = vec![
enums::CaptureMethod::Automatic
];
let mut iatapay_supported_payment_methods = SupportedPaymentMethods::new();
iatapay_supported_payment_methods.add(
enums::PaymentMethod::Upi,
enums::PaymentMethodType::UpiCollect,
PaymentMethodDetails {
mandates: common_enums::FeatureStatus::NotSupported,
refunds: common_enums::FeatureStatus::Supported,
supported_capture_methods: supported_capture_methods.clone(),
specific_features: None
}
);
iatapay_supported_payment_methods.add(
enums::PaymentMethod::Upi,
enums::PaymentMethodType::UpiIntent,
PaymentMethodDetails {
mandates: common_enums::FeatureStatus::NotSupported,
refunds: common_enums::FeatureStatus::Supported,
supported_capture_methods: supported_capture_methods.clone(),
specific_features: None
}
);
iatapay_supported_payment_methods.add(
enums::PaymentMethod::BankRedirect,
enums::PaymentMethodType::Ideal,
PaymentMethodDetails {
mandates: common_enums::FeatureStatus::NotSupported,
refunds: common_enums::FeatureStatus::Supported,
supported_capture_methods: supported_capture_methods.clone(),
specific_features: None
}
);
iatapay_supported_payment_methods.add(
enums::PaymentMethod::BankRedirect,
enums::PaymentMethodType::LocalBankRedirect,
PaymentMethodDetails {
mandates: common_enums::FeatureStatus::NotSupported,
refunds: common_enums::FeatureStatus::Supported,
supported_capture_methods: supported_capture_methods.clone(),
specific_features: None
}
);
iatapay_supported_payment_methods.add(
enums::PaymentMethod::RealTimePayment,
enums::PaymentMethodType::DuitNow,
PaymentMethodDetails {
mandates: common_enums::FeatureStatus::NotSupported,
refunds: common_enums::FeatureStatus::Supported,
supported_capture_methods: supported_capture_methods.clone(),
specific_features: None
}
);
iatapay_supported_payment_methods.add(
enums::PaymentMethod::RealTimePayment,
enums::PaymentMethodType::Fps,
PaymentMethodDetails {
mandates: common_enums::FeatureStatus::NotSupported,
refunds: common_enums::FeatureStatus::Supported,
supported_capture_methods: supported_capture_methods.clone(),
specific_features: None
}
);
iatapay_supported_payment_methods.add(
enums::PaymentMethod::RealTimePayment,
enums::PaymentMethodType::PromptPay,
PaymentMethodDetails {
mandates: common_enums::FeatureStatus::NotSupported,
refunds: common_enums::FeatureStatus::Supported,
supported_capture_methods: supported_capture_methods.clone(),
specific_features: None
}
);
iatapay_supported_payment_methods.add(
enums::PaymentMethod::RealTimePayment,
enums::PaymentMethodType::VietQr,
PaymentMethodDetails {
mandates: common_enums::FeatureStatus::NotSupported,
refunds: common_enums::FeatureStatus::Supported,
supported_capture_methods: supported_capture_methods.clone(),
specific_features: None
}
);
iatapay_supported_payment_methods
};
static ref IATAPAY_SUPPORTED_WEBHOOK_FLOWS: Vec<enums::EventClass> =
vec![enums::EventClass::Payments, enums::EventClass::Refunds,];
}
impl ConnectorSpecifications for Iatapay {
fn get_connector_about(&self) -> Option<&'static ConnectorInfo> {
Some(&*IATAPAY_CONNECTOR_INFO)
}
fn get_supported_payment_methods(&self) -> Option<&'static SupportedPaymentMethods> {
Some(&*IATAPAY_SUPPORTED_PAYMENT_METHODS)
}
fn get_supported_webhook_flows(&self) -> Option<&'static [enums::EventClass]> {
Some(&*IATAPAY_SUPPORTED_WEBHOOK_FLOWS)
}
}
|
{
"crate": "hyperswitch_connectors",
"file": "crates/hyperswitch_connectors/src/connectors/iatapay.rs",
"file_size": null,
"is_async": null,
"is_pub": null,
"num_enums": 0,
"num_structs": 1,
"num_tables": null,
"score": null,
"total_crates": null
}
|
file_hyperswitch_connectors_9142266387744730390
|
clm
|
file
|
// Repository: hyperswitch
// Crate: hyperswitch_connectors
// File: crates/hyperswitch_connectors/src/connectors/fiservemea.rs
// Contains: 1 structs, 0 enums
pub mod transformers;
use std::sync::LazyLock;
use base64::Engine;
use common_enums::enums;
use common_utils::{
errors::CustomResult,
ext_traits::BytesExt,
request::{Method, Request, RequestBuilder, RequestContent},
types::{AmountConvertor, StringMajorUnit, StringMajorUnitForConnector},
};
use error_stack::{report, ResultExt};
use hyperswitch_domain_models::{
router_data::{AccessToken, 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::{
ConnectorInfo, PaymentMethodDetails, PaymentsResponseData, RefundsResponseData,
SupportedPaymentMethods, SupportedPaymentMethodsExt,
},
types::{
PaymentsAuthorizeRouterData, PaymentsCancelRouterData, PaymentsCaptureRouterData,
PaymentsSyncRouterData, RefundSyncRouterData, RefundsRouterData,
},
};
use hyperswitch_interfaces::{
api::{
self, ConnectorCommon, ConnectorCommonExt, ConnectorIntegration, ConnectorSpecifications,
ConnectorValidation,
},
configs::Connectors,
consts, errors,
events::connector_api_logs::ConnectorEvent,
types::{self, Response},
webhooks,
};
use masking::{ExposeInterface, Mask, PeekInterface};
use ring::hmac;
use time::OffsetDateTime;
use transformers as fiservemea;
use uuid::Uuid;
use crate::{
constants::headers,
types::ResponseRouterData,
utils::{self, RefundsRequestData as _},
};
#[derive(Clone)]
pub struct Fiservemea {
amount_converter: &'static (dyn AmountConvertor<Output = StringMajorUnit> + Sync),
}
impl Fiservemea {
pub fn new() -> &'static Self {
&Self {
amount_converter: &StringMajorUnitForConnector,
}
}
pub fn generate_authorization_signature(
&self,
auth: fiservemea::FiservemeaAuthType,
request_id: &str,
payload: &str,
timestamp: i128,
) -> CustomResult<String, errors::ConnectorError> {
let fiservemea::FiservemeaAuthType {
api_key,
secret_key,
} = auth;
let raw_signature = format!("{}{request_id}{timestamp}{payload}", api_key.peek());
let key = hmac::Key::new(hmac::HMAC_SHA256, secret_key.expose().as_bytes());
let signature_value = common_utils::consts::BASE64_ENGINE
.encode(hmac::sign(&key, raw_signature.as_bytes()).as_ref());
Ok(signature_value)
}
}
impl api::Payment for Fiservemea {}
impl api::PaymentSession for Fiservemea {}
impl api::ConnectorAccessToken for Fiservemea {}
impl api::MandateSetup for Fiservemea {}
impl api::PaymentAuthorize for Fiservemea {}
impl api::PaymentSync for Fiservemea {}
impl api::PaymentCapture for Fiservemea {}
impl api::PaymentVoid for Fiservemea {}
impl api::Refund for Fiservemea {}
impl api::RefundExecute for Fiservemea {}
impl api::RefundSync for Fiservemea {}
impl api::PaymentToken for Fiservemea {}
impl ConnectorIntegration<Session, PaymentsSessionData, PaymentsResponseData> for Fiservemea {}
impl ConnectorIntegration<AccessTokenAuth, AccessTokenRequestData, AccessToken> for Fiservemea {}
impl ConnectorIntegration<SetupMandate, SetupMandateRequestData, PaymentsResponseData>
for Fiservemea
{
fn build_request(
&self,
_req: &RouterData<SetupMandate, SetupMandateRequestData, PaymentsResponseData>,
_connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Err(
errors::ConnectorError::NotImplemented("Setup Mandate flow for Fiservemea".to_string())
.into(),
)
}
}
impl ConnectorIntegration<PaymentMethodToken, PaymentMethodTokenizationData, PaymentsResponseData>
for Fiservemea
{
}
impl<Flow, Request, Response> ConnectorCommonExt<Flow, Request, Response> for Fiservemea
where
Self: ConnectorIntegration<Flow, Request, Response>,
{
fn build_headers(
&self,
req: &RouterData<Flow, Request, Response>,
connectors: &Connectors,
) -> CustomResult<Vec<(String, masking::Maskable<String>)>, errors::ConnectorError> {
let timestamp = OffsetDateTime::now_utc().unix_timestamp_nanos() / 1_000_000;
let auth: fiservemea::FiservemeaAuthType =
fiservemea::FiservemeaAuthType::try_from(&req.connector_auth_type)?;
let client_request_id = Uuid::new_v4().to_string();
let http_method = self.get_http_method();
let hmac = match http_method {
Method::Get => self
.generate_authorization_signature(auth.clone(), &client_request_id, "", timestamp)
.change_context(errors::ConnectorError::RequestEncodingFailed)?,
Method::Post | Method::Put | Method::Delete | Method::Patch => {
let fiserv_req = self.get_request_body(req, connectors)?;
self.generate_authorization_signature(
auth.clone(),
&client_request_id,
fiserv_req.get_inner_value().peek(),
timestamp,
)
.change_context(errors::ConnectorError::RequestEncodingFailed)?
}
};
let headers = vec![
(
headers::CONTENT_TYPE.to_string(),
types::PaymentsAuthorizeType::get_content_type(self)
.to_string()
.into(),
),
("Client-Request-Id".to_string(), client_request_id.into()),
(headers::API_KEY.to_string(), auth.api_key.expose().into()),
(headers::TIMESTAMP.to_string(), timestamp.to_string().into()),
(headers::MESSAGE_SIGNATURE.to_string(), hmac.into_masked()),
];
Ok(headers)
}
}
impl ConnectorCommon for Fiservemea {
fn id(&self) -> &'static str {
"fiservemea"
}
fn get_currency_unit(&self) -> api::CurrencyUnit {
api::CurrencyUnit::Base
}
fn common_get_content_type(&self) -> &'static str {
"application/json"
}
fn base_url<'a>(&self, connectors: &'a Connectors) -> &'a str {
connectors.fiservemea.base_url.as_ref()
}
fn build_error_response(
&self,
res: Response,
event_builder: Option<&mut ConnectorEvent>,
) -> CustomResult<ErrorResponse, errors::ConnectorError> {
let response: fiservemea::FiservemeaErrorResponse = res
.response
.parse_struct("FiservemeaErrorResponse")
.change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
event_builder.map(|i| i.set_response_body(&response));
router_env::logger::info!(connector_response=?response);
match response.error {
Some(error) => {
let details = error.details.map(|details| {
details
.iter()
.map(|detail| {
format!(
"{}: {}",
detail
.field
.clone()
.unwrap_or("No Field Provided".to_string()),
detail
.message
.clone()
.unwrap_or("No Message Provided".to_string())
)
})
.collect::<Vec<String>>()
.join(", ")
});
Ok(ErrorResponse {
status_code: res.status_code,
code: error.code.unwrap_or(consts::NO_ERROR_CODE.to_string()),
message: response
.response_type
.unwrap_or(consts::NO_ERROR_MESSAGE.to_string()),
reason: match details {
Some(details) => Some(format!(
"{} {}",
error.message.unwrap_or("".to_string()),
details
)),
None => error.message,
},
attempt_status: None,
connector_transaction_id: None,
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
connector_metadata: None,
})
}
None => Ok(ErrorResponse {
status_code: res.status_code,
code: consts::NO_ERROR_CODE.to_string(),
message: response
.response_type
.clone()
.unwrap_or(consts::NO_ERROR_MESSAGE.to_string()),
reason: response.response_type,
attempt_status: None,
connector_transaction_id: None,
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
connector_metadata: None,
}),
}
}
}
impl ConnectorValidation for Fiservemea {}
impl ConnectorIntegration<Authorize, PaymentsAuthorizeData, PaymentsResponseData> for Fiservemea {
fn get_headers(
&self,
req: &PaymentsAuthorizeRouterData,
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: &PaymentsAuthorizeRouterData,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
Ok(format!(
"{}/ipp/payments-gateway/v2/payments",
self.base_url(connectors)
))
}
fn get_request_body(
&self,
req: &PaymentsAuthorizeRouterData,
_connectors: &Connectors,
) -> CustomResult<RequestContent, errors::ConnectorError> {
let amount = utils::convert_amount(
self.amount_converter,
req.request.minor_amount,
req.request.currency,
)?;
let connector_router_data = fiservemea::FiservemeaRouterData::from((amount, req));
let connector_req =
fiservemea::FiservemeaPaymentsRequest::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> {
Ok(Some(
RequestBuilder::new()
.method(Method::Post)
.url(&types::PaymentsAuthorizeType::get_url(
self, req, connectors,
)?)
.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: fiservemea::FiservemeaPaymentsResponse = res
.response
.parse_struct("Fiservemea 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,
})
}
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<PSync, PaymentsSyncData, PaymentsResponseData> for Fiservemea {
fn get_headers(
&self,
req: &PaymentsSyncRouterData,
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_http_method(&self) -> Method {
Method::Get
}
fn get_url(
&self,
req: &PaymentsSyncRouterData,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
let connector_payment_id = req
.request
.connector_transaction_id
.get_connector_transaction_id()
.change_context(errors::ConnectorError::MissingConnectorTransactionID)?;
Ok(format!(
"{}/ipp/payments-gateway/v2/payments/{connector_payment_id}",
self.base_url(connectors)
))
}
fn build_request(
&self,
req: &PaymentsSyncRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Ok(Some(
RequestBuilder::new()
.method(Method::Get)
.url(&types::PaymentsSyncType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(types::PaymentsSyncType::get_headers(self, req, connectors)?)
.build(),
))
}
fn handle_response(
&self,
data: &PaymentsSyncRouterData,
event_builder: Option<&mut ConnectorEvent>,
res: Response,
) -> CustomResult<PaymentsSyncRouterData, errors::ConnectorError> {
let response: fiservemea::FiservemeaPaymentsResponse = res
.response
.parse_struct("fiservemea PaymentsSyncResponse")
.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,
})
}
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 Fiservemea {
fn get_headers(
&self,
req: &PaymentsCaptureRouterData,
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: &PaymentsCaptureRouterData,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
let connector_payment_id = req.request.connector_transaction_id.clone();
Ok(format!(
"{}/ipp/payments-gateway/v2/payments/{connector_payment_id}",
self.base_url(connectors)
))
}
fn get_request_body(
&self,
req: &PaymentsCaptureRouterData,
_connectors: &Connectors,
) -> CustomResult<RequestContent, errors::ConnectorError> {
let amount = utils::convert_amount(
self.amount_converter,
req.request.minor_amount_to_capture,
req.request.currency,
)?;
let connector_router_data = fiservemea::FiservemeaRouterData::from((amount, req));
let connector_req = fiservemea::FiservemeaCaptureRequest::try_from(&connector_router_data)?;
Ok(RequestContent::Json(Box::new(connector_req)))
}
fn build_request(
&self,
req: &PaymentsCaptureRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Ok(Some(
RequestBuilder::new()
.method(Method::Post)
.url(&types::PaymentsCaptureType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(types::PaymentsCaptureType::get_headers(
self, req, connectors,
)?)
.set_body(types::PaymentsCaptureType::get_request_body(
self, req, connectors,
)?)
.build(),
))
}
fn handle_response(
&self,
data: &PaymentsCaptureRouterData,
event_builder: Option<&mut ConnectorEvent>,
res: Response,
) -> CustomResult<PaymentsCaptureRouterData, errors::ConnectorError> {
let response: fiservemea::FiservemeaPaymentsResponse = res
.response
.parse_struct("Fiservemea PaymentsCaptureResponse")
.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,
})
}
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<Void, PaymentsCancelData, PaymentsResponseData> for Fiservemea {
fn get_headers(
&self,
req: &PaymentsCancelRouterData,
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: &PaymentsCancelRouterData,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
let connector_payment_id = req.request.connector_transaction_id.clone();
Ok(format!(
"{}/ipp/payments-gateway/v2/payments/{connector_payment_id}",
self.base_url(connectors)
))
}
fn get_request_body(
&self,
req: &PaymentsCancelRouterData,
_connectors: &Connectors,
) -> CustomResult<RequestContent, errors::ConnectorError> {
let connector_req = fiservemea::FiservemeaVoidRequest::try_from(req)?;
Ok(RequestContent::Json(Box::new(connector_req)))
}
fn build_request(
&self,
req: &PaymentsCancelRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Ok(Some(
RequestBuilder::new()
.method(Method::Post)
.url(&types::PaymentsVoidType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(types::PaymentsVoidType::get_headers(self, req, connectors)?)
.set_body(types::PaymentsVoidType::get_request_body(
self, req, connectors,
)?)
.build(),
))
}
fn handle_response(
&self,
data: &PaymentsCancelRouterData,
event_builder: Option<&mut ConnectorEvent>,
res: Response,
) -> CustomResult<PaymentsCancelRouterData, errors::ConnectorError> {
let response: fiservemea::FiservemeaPaymentsResponse = res
.response
.parse_struct("Fiservemea PaymentsCaptureResponse")
.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,
})
}
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<Execute, RefundsData, RefundsResponseData> for Fiservemea {
fn get_headers(
&self,
req: &RefundsRouterData<Execute>,
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: &RefundsRouterData<Execute>,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
let connector_payment_id = req.request.connector_transaction_id.clone();
Ok(format!(
"{}/ipp/payments-gateway/v2/payments/{connector_payment_id}",
self.base_url(connectors)
))
}
fn get_request_body(
&self,
req: &RefundsRouterData<Execute>,
_connectors: &Connectors,
) -> CustomResult<RequestContent, errors::ConnectorError> {
let refund_amount = utils::convert_amount(
self.amount_converter,
req.request.minor_refund_amount,
req.request.currency,
)?;
let connector_router_data = fiservemea::FiservemeaRouterData::from((refund_amount, req));
let connector_req = fiservemea::FiservemeaRefundRequest::try_from(&connector_router_data)?;
Ok(RequestContent::Json(Box::new(connector_req)))
}
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))
}
fn handle_response(
&self,
data: &RefundsRouterData<Execute>,
event_builder: Option<&mut ConnectorEvent>,
res: Response,
) -> CustomResult<RefundsRouterData<Execute>, errors::ConnectorError> {
let response: fiservemea::FiservemeaPaymentsResponse = res
.response
.parse_struct("fiservemea RefundResponse")
.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,
})
}
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<RSync, RefundsData, RefundsResponseData> for Fiservemea {
fn get_headers(
&self,
req: &RefundSyncRouterData,
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_http_method(&self) -> Method {
Method::Get
}
fn get_url(
&self,
req: &RefundSyncRouterData,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
let connector_payment_id = req.request.get_connector_refund_id()?;
Ok(format!(
"{}/ipp/payments-gateway/v2/payments/{connector_payment_id}",
self.base_url(connectors)
))
}
fn build_request(
&self,
req: &RefundSyncRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Ok(Some(
RequestBuilder::new()
.method(Method::Get)
.url(&types::RefundSyncType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(types::RefundSyncType::get_headers(self, req, connectors)?)
.set_body(types::RefundSyncType::get_request_body(
self, req, connectors,
)?)
.build(),
))
}
fn handle_response(
&self,
data: &RefundSyncRouterData,
event_builder: Option<&mut ConnectorEvent>,
res: Response,
) -> CustomResult<RefundSyncRouterData, errors::ConnectorError> {
let response: fiservemea::FiservemeaPaymentsResponse = res
.response
.parse_struct("fiservemea RefundSyncResponse")
.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,
})
}
fn get_error_response(
&self,
res: Response,
event_builder: Option<&mut ConnectorEvent>,
) -> CustomResult<ErrorResponse, errors::ConnectorError> {
self.build_error_response(res, event_builder)
}
}
#[async_trait::async_trait]
impl webhooks::IncomingWebhook for Fiservemea {
fn get_webhook_object_reference_id(
&self,
_request: &webhooks::IncomingWebhookRequestDetails<'_>,
) -> CustomResult<api_models::webhooks::ObjectReferenceId, errors::ConnectorError> {
Err(report!(errors::ConnectorError::WebhooksNotImplemented))
}
fn get_webhook_event_type(
&self,
_request: &webhooks::IncomingWebhookRequestDetails<'_>,
) -> CustomResult<api_models::webhooks::IncomingWebhookEvent, errors::ConnectorError> {
Err(report!(errors::ConnectorError::WebhooksNotImplemented))
}
fn get_webhook_resource_object(
&self,
_request: &webhooks::IncomingWebhookRequestDetails<'_>,
) -> CustomResult<Box<dyn masking::ErasedMaskSerialize>, errors::ConnectorError> {
Err(report!(errors::ConnectorError::WebhooksNotImplemented))
}
}
static FISERVEMEA_SUPPORTED_PAYMENT_METHODS: LazyLock<SupportedPaymentMethods> =
LazyLock::new(|| {
let supported_capture_methods = vec![
enums::CaptureMethod::Automatic,
enums::CaptureMethod::Manual,
enums::CaptureMethod::SequentialAutomatic,
];
let supported_card_network = vec![
common_enums::CardNetwork::Mastercard,
common_enums::CardNetwork::Visa,
common_enums::CardNetwork::AmericanExpress,
common_enums::CardNetwork::Discover,
common_enums::CardNetwork::JCB,
common_enums::CardNetwork::UnionPay,
common_enums::CardNetwork::DinersClub,
common_enums::CardNetwork::Interac,
common_enums::CardNetwork::CartesBancaires,
];
let mut fiservemea_supported_payment_methods = SupportedPaymentMethods::new();
fiservemea_supported_payment_methods.add(
enums::PaymentMethod::Card,
enums::PaymentMethodType::Credit,
PaymentMethodDetails {
mandates: enums::FeatureStatus::NotSupported,
refunds: enums::FeatureStatus::Supported,
supported_capture_methods: supported_capture_methods.clone(),
specific_features: Some(
api_models::feature_matrix::PaymentMethodSpecificFeatures::Card({
api_models::feature_matrix::CardSpecificFeatures {
three_ds: common_enums::FeatureStatus::NotSupported,
no_three_ds: common_enums::FeatureStatus::Supported,
supported_card_networks: supported_card_network.clone(),
}
}),
),
},
);
fiservemea_supported_payment_methods.add(
enums::PaymentMethod::Card,
enums::PaymentMethodType::Debit,
PaymentMethodDetails {
mandates: enums::FeatureStatus::NotSupported,
refunds: enums::FeatureStatus::Supported,
supported_capture_methods: supported_capture_methods.clone(),
specific_features: Some(
api_models::feature_matrix::PaymentMethodSpecificFeatures::Card({
api_models::feature_matrix::CardSpecificFeatures {
three_ds: common_enums::FeatureStatus::NotSupported,
no_three_ds: common_enums::FeatureStatus::Supported,
supported_card_networks: supported_card_network.clone(),
}
}),
),
},
);
fiservemea_supported_payment_methods
});
static FISERVEMEA_CONNECTOR_INFO: ConnectorInfo = ConnectorInfo {
display_name: "Fiservemea",
description: "Fiserv powers over 6+ million merchants and 10,000+ financial institutions enabling them to accept billions of payments a year.",
connector_type: enums::HyperswitchConnectorCategory::BankAcquirer,
integration_status: enums::ConnectorIntegrationStatus::Sandbox,
};
static FISERVEMEA_SUPPORTED_WEBHOOK_FLOWS: [enums::EventClass; 0] = [];
impl ConnectorSpecifications for Fiservemea {
fn get_connector_about(&self) -> Option<&'static ConnectorInfo> {
Some(&FISERVEMEA_CONNECTOR_INFO)
}
fn get_supported_payment_methods(&self) -> Option<&'static SupportedPaymentMethods> {
Some(&*FISERVEMEA_SUPPORTED_PAYMENT_METHODS)
}
fn get_supported_webhook_flows(&self) -> Option<&'static [enums::EventClass]> {
Some(&FISERVEMEA_SUPPORTED_WEBHOOK_FLOWS)
}
}
|
{
"crate": "hyperswitch_connectors",
"file": "crates/hyperswitch_connectors/src/connectors/fiservemea.rs",
"file_size": null,
"is_async": null,
"is_pub": null,
"num_enums": 0,
"num_structs": 1,
"num_tables": null,
"score": null,
"total_crates": null
}
|
file_hyperswitch_connectors_1591437662701720130
|
clm
|
file
|
// Repository: hyperswitch
// Crate: hyperswitch_connectors
// File: crates/hyperswitch_connectors/src/connectors/recurly.rs
// Contains: 1 structs, 0 enums
pub mod transformers;
use base64::Engine;
#[cfg(all(feature = "v2", feature = "revenue_recovery"))]
use common_utils::request::{Method, Request, RequestBuilder};
use common_utils::{consts, errors::CustomResult, ext_traits::BytesExt};
#[cfg(feature = "v1")]
use error_stack::report;
use error_stack::ResultExt;
use hyperswitch_domain_models::{
router_data::{ConnectorAuthType, ErrorResponse},
router_data_v2::{
flow_common_types::{
GetSubscriptionEstimateData, GetSubscriptionPlanPricesData, GetSubscriptionPlansData,
InvoiceRecordBackData, SubscriptionCreateData, SubscriptionCustomerData,
},
UasFlowData,
},
router_flow_types::{
subscriptions::{
GetSubscriptionEstimate, GetSubscriptionPlanPrices, GetSubscriptionPlans,
SubscriptionCreate,
},
unified_authentication_service::{
Authenticate, AuthenticationConfirmation, PostAuthenticate, PreAuthenticate,
},
CreateConnectorCustomer, InvoiceRecordBack,
},
router_request_types::{
revenue_recovery::InvoiceRecordBackRequest,
subscriptions::{
GetSubscriptionEstimateRequest, GetSubscriptionPlanPricesRequest,
GetSubscriptionPlansRequest, SubscriptionCreateRequest,
},
unified_authentication_service::{
UasAuthenticationRequestData, UasAuthenticationResponseData,
UasConfirmationRequestData, UasPostAuthenticationRequestData,
UasPreAuthenticationRequestData,
},
ConnectorCustomerData,
},
router_response_types::{
revenue_recovery::InvoiceRecordBackResponse,
subscriptions::{
GetSubscriptionEstimateResponse, GetSubscriptionPlanPricesResponse,
GetSubscriptionPlansResponse, SubscriptionCreateResponse,
},
PaymentsResponseData,
},
};
#[cfg(all(feature = "v2", feature = "revenue_recovery"))]
use hyperswitch_domain_models::{
router_data_v2::flow_common_types as recovery_flow_common_types,
router_flow_types::revenue_recovery as recovery_router_flows,
router_request_types::revenue_recovery as recovery_request_types,
router_response_types::revenue_recovery as recovery_response_types,
types as recovery_router_data_types,
};
#[cfg(all(feature = "v2", feature = "revenue_recovery"))]
use hyperswitch_interfaces::types;
use hyperswitch_interfaces::{
api::{self, ConnectorCommon, ConnectorSpecifications, ConnectorValidation},
configs::Connectors,
connector_integration_v2::ConnectorIntegrationV2,
errors,
events::connector_api_logs::ConnectorEvent,
types::Response,
webhooks,
};
use masking::{Mask, PeekInterface};
use transformers as recurly;
use crate::{connectors::recurly::transformers::RecurlyWebhookBody, constants::headers};
#[cfg(all(feature = "v2", feature = "revenue_recovery"))]
use crate::{
connectors::recurly::transformers::{RecurlyRecordStatus, RecurlyRecoveryDetailsData},
types::ResponseRouterDataV2,
};
#[cfg(all(feature = "v2", feature = "revenue_recovery"))]
const STATUS_SUCCESSFUL_ENDPOINT: &str = "mark_successful";
#[cfg(all(feature = "v2", feature = "revenue_recovery"))]
const STATUS_FAILED_ENDPOINT: &str = "mark_failed";
const RECURLY_API_VERSION: &str = "application/vnd.recurly.v2021-02-25";
// We don't need an amount converter because we are not using it anywhere in code, but it's important to note that Float Major Unit is the standard format used by Recurly.
#[derive(Clone)]
pub struct Recurly {
// amount_converter: &'static (dyn AmountConvertor<Output = FloatMajorUnit> + Sync),
}
impl Recurly {
pub fn new() -> &'static Self {
&Self {}
}
fn get_signature_elements_from_header(
headers: &actix_web::http::header::HeaderMap,
) -> CustomResult<Vec<Vec<u8>>, errors::ConnectorError> {
let security_header = headers
.get("recurly-signature")
.ok_or(errors::ConnectorError::WebhookSignatureNotFound)?;
let security_header_str = security_header
.to_str()
.change_context(errors::ConnectorError::WebhookSignatureNotFound)?;
let header_parts: Vec<Vec<u8>> = security_header_str
.split(',')
.map(|part| part.trim().as_bytes().to_vec())
.collect();
Ok(header_parts)
}
}
impl api::PayoutsV2 for Recurly {}
impl api::UnifiedAuthenticationServiceV2 for Recurly {}
impl api::UasPreAuthenticationV2 for Recurly {}
impl api::UasPostAuthenticationV2 for Recurly {}
impl api::UasAuthenticationV2 for Recurly {}
impl api::UasAuthenticationConfirmationV2 for Recurly {}
impl
ConnectorIntegrationV2<
PreAuthenticate,
UasFlowData,
UasPreAuthenticationRequestData,
UasAuthenticationResponseData,
> for Recurly
{
//TODO: implement sessions flow
}
impl
ConnectorIntegrationV2<
PostAuthenticate,
UasFlowData,
UasPostAuthenticationRequestData,
UasAuthenticationResponseData,
> for Recurly
{
//TODO: implement sessions flow
}
impl
ConnectorIntegrationV2<
AuthenticationConfirmation,
UasFlowData,
UasConfirmationRequestData,
UasAuthenticationResponseData,
> for Recurly
{
//TODO: implement sessions flow
}
impl
ConnectorIntegrationV2<
Authenticate,
UasFlowData,
UasAuthenticationRequestData,
UasAuthenticationResponseData,
> for Recurly
{
//TODO: implement sessions flow
}
impl api::revenue_recovery_v2::RevenueRecoveryV2 for Recurly {}
impl api::subscriptions_v2::SubscriptionsV2 for Recurly {}
impl api::subscriptions_v2::GetSubscriptionPlansV2 for Recurly {}
impl api::subscriptions_v2::SubscriptionRecordBackV2 for Recurly {}
impl api::subscriptions_v2::SubscriptionConnectorCustomerV2 for Recurly {}
impl
ConnectorIntegrationV2<
GetSubscriptionPlans,
GetSubscriptionPlansData,
GetSubscriptionPlansRequest,
GetSubscriptionPlansResponse,
> for Recurly
{
}
#[cfg(feature = "v1")]
impl
ConnectorIntegrationV2<
InvoiceRecordBack,
InvoiceRecordBackData,
InvoiceRecordBackRequest,
InvoiceRecordBackResponse,
> for Recurly
{
}
impl
ConnectorIntegrationV2<
CreateConnectorCustomer,
SubscriptionCustomerData,
ConnectorCustomerData,
PaymentsResponseData,
> for Recurly
{
}
impl api::subscriptions_v2::GetSubscriptionPlanPricesV2 for Recurly {}
impl
ConnectorIntegrationV2<
GetSubscriptionPlanPrices,
GetSubscriptionPlanPricesData,
GetSubscriptionPlanPricesRequest,
GetSubscriptionPlanPricesResponse,
> for Recurly
{
}
impl api::subscriptions_v2::SubscriptionsCreateV2 for Recurly {}
impl
ConnectorIntegrationV2<
SubscriptionCreate,
SubscriptionCreateData,
SubscriptionCreateRequest,
SubscriptionCreateResponse,
> for Recurly
{
}
impl api::subscriptions_v2::GetSubscriptionEstimateV2 for Recurly {}
impl
ConnectorIntegrationV2<
GetSubscriptionEstimate,
GetSubscriptionEstimateData,
GetSubscriptionEstimateRequest,
GetSubscriptionEstimateResponse,
> for Recurly
{
}
#[cfg(all(feature = "v2", feature = "revenue_recovery"))]
impl api::revenue_recovery_v2::RevenueRecoveryRecordBackV2 for Recurly {}
#[cfg(all(feature = "v2", feature = "revenue_recovery"))]
impl api::revenue_recovery_v2::BillingConnectorPaymentsSyncIntegrationV2 for Recurly {}
#[cfg(all(feature = "v2", feature = "revenue_recovery"))]
impl api::revenue_recovery_v2::BillingConnectorInvoiceSyncIntegrationV2 for Recurly {}
impl ConnectorCommon for Recurly {
fn id(&self) -> &'static str {
"recurly"
}
fn get_currency_unit(&self) -> api::CurrencyUnit {
api::CurrencyUnit::Minor
// TODO! Check connector documentation, on which unit they are processing the currency.
// If the connector accepts amount in lower unit ( i.e cents for USD) then return api::CurrencyUnit::Minor,
// if connector accepts amount in base unit (i.e dollars for USD) then return api::CurrencyUnit::Base
}
fn common_get_content_type(&self) -> &'static str {
"application/json"
}
fn base_url<'a>(&self, connectors: &'a Connectors) -> &'a str {
connectors.recurly.base_url.as_ref()
}
fn get_auth_header(
&self,
auth_type: &ConnectorAuthType,
) -> CustomResult<Vec<(String, masking::Maskable<String>)>, errors::ConnectorError> {
let auth = recurly::RecurlyAuthType::try_from(auth_type)
.change_context(errors::ConnectorError::FailedToObtainAuthType)?;
Ok(vec![
(
headers::AUTHORIZATION.to_string(),
format!(
"Basic {}",
consts::BASE64_ENGINE.encode(auth.api_key.peek())
)
.into_masked(),
),
(
headers::ACCEPT.to_string(),
RECURLY_API_VERSION.to_string().into_masked(),
),
])
}
fn build_error_response(
&self,
res: Response,
event_builder: Option<&mut ConnectorEvent>,
) -> CustomResult<ErrorResponse, errors::ConnectorError> {
let response: recurly::RecurlyErrorResponse = res
.response
.parse_struct("RecurlyErrorResponse")
.change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
event_builder.map(|i| i.set_response_body(&response));
router_env::logger::info!(connector_response=?response);
Ok(ErrorResponse {
status_code: res.status_code,
code: response.code,
message: response.message,
reason: response.reason,
attempt_status: None,
connector_transaction_id: None,
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
connector_metadata: None,
})
}
}
impl ConnectorValidation for Recurly {
//TODO: implement functions when support enabled
}
#[cfg(all(feature = "v2", feature = "revenue_recovery"))]
impl
ConnectorIntegrationV2<
recovery_router_flows::BillingConnectorPaymentsSync,
recovery_flow_common_types::BillingConnectorPaymentsSyncFlowData,
recovery_request_types::BillingConnectorPaymentsSyncRequest,
recovery_response_types::BillingConnectorPaymentsSyncResponse,
> for Recurly
{
fn get_headers(
&self,
req: &recovery_router_data_types::BillingConnectorPaymentsSyncRouterDataV2,
) -> CustomResult<Vec<(String, masking::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_url(
&self,
req: &recovery_router_data_types::BillingConnectorPaymentsSyncRouterDataV2,
) -> CustomResult<String, errors::ConnectorError> {
let transaction_uuid = &req.request.billing_connector_psync_id;
Ok(format!(
"{}/transactions/uuid-{transaction_uuid}",
req.request.connector_params.base_url,
))
}
fn build_request_v2(
&self,
req: &recovery_router_data_types::BillingConnectorPaymentsSyncRouterDataV2,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
let request = RequestBuilder::new()
.method(Method::Get)
.url(&types::BillingConnectorPaymentsSyncTypeV2::get_url(
self, req,
)?)
.attach_default_headers()
.headers(types::BillingConnectorPaymentsSyncTypeV2::get_headers(
self, req,
)?)
.build();
Ok(Some(request))
}
fn handle_response_v2(
&self,
data: &recovery_router_data_types::BillingConnectorPaymentsSyncRouterDataV2,
event_builder: Option<&mut ConnectorEvent>,
res: Response,
) -> CustomResult<
recovery_router_data_types::BillingConnectorPaymentsSyncRouterDataV2,
errors::ConnectorError,
> {
let response: RecurlyRecoveryDetailsData = res
.response
.parse_struct::<RecurlyRecoveryDetailsData>("RecurlyRecoveryDetailsData")
.change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
event_builder.map(|i| i.set_response_body(&response));
router_env::logger::info!(connector_response=?response);
recovery_router_data_types::BillingConnectorPaymentsSyncRouterDataV2::try_from(
ResponseRouterDataV2 {
response,
data: data.clone(),
http_code: res.status_code,
},
)
}
fn get_error_response_v2(
&self,
res: Response,
event_builder: Option<&mut ConnectorEvent>,
) -> CustomResult<ErrorResponse, errors::ConnectorError> {
self.build_error_response(res, event_builder)
}
}
#[cfg(all(feature = "v2", feature = "revenue_recovery"))]
impl
ConnectorIntegrationV2<
InvoiceRecordBack,
InvoiceRecordBackData,
InvoiceRecordBackRequest,
InvoiceRecordBackResponse,
> for Recurly
{
fn get_headers(
&self,
req: &recovery_router_data_types::InvoiceRecordBackRouterDataV2,
) -> CustomResult<Vec<(String, masking::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_url(
&self,
req: &recovery_router_data_types::InvoiceRecordBackRouterDataV2,
) -> CustomResult<String, errors::ConnectorError> {
let invoice_id = req
.request
.merchant_reference_id
.get_string_repr()
.to_string();
let status = RecurlyRecordStatus::try_from(req.request.attempt_status)?;
let status_endpoint = match status {
RecurlyRecordStatus::Success => STATUS_SUCCESSFUL_ENDPOINT,
RecurlyRecordStatus::Failure => STATUS_FAILED_ENDPOINT,
};
Ok(format!(
"{}/invoices/{invoice_id}/{status_endpoint}",
req.request.connector_params.base_url,
))
}
fn build_request_v2(
&self,
req: &recovery_router_data_types::InvoiceRecordBackRouterDataV2,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Ok(Some(
RequestBuilder::new()
.method(Method::Put)
.url(&types::InvoiceRecordBackTypeV2::get_url(self, req)?)
.attach_default_headers()
.headers(types::InvoiceRecordBackTypeV2::get_headers(self, req)?)
.header("Content-Length", "0")
.build(),
))
}
fn handle_response_v2(
&self,
data: &recovery_router_data_types::InvoiceRecordBackRouterDataV2,
event_builder: Option<&mut ConnectorEvent>,
res: Response,
) -> CustomResult<
recovery_router_data_types::InvoiceRecordBackRouterDataV2,
errors::ConnectorError,
> {
let response: recurly::RecurlyRecordBackResponse = res
.response
.parse_struct("recurly RecurlyRecordBackResponse")
.change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
event_builder.map(|i| i.set_response_body(&response));
router_env::logger::info!(connector_response=?response);
recovery_router_data_types::InvoiceRecordBackRouterDataV2::try_from(ResponseRouterDataV2 {
response,
data: data.clone(),
http_code: res.status_code,
})
}
fn get_error_response_v2(
&self,
res: Response,
event_builder: Option<&mut ConnectorEvent>,
) -> CustomResult<ErrorResponse, errors::ConnectorError> {
self.build_error_response(res, event_builder)
}
}
#[cfg(all(feature = "v2", feature = "revenue_recovery"))]
impl
ConnectorIntegrationV2<
recovery_router_flows::BillingConnectorInvoiceSync,
recovery_flow_common_types::BillingConnectorInvoiceSyncFlowData,
recovery_request_types::BillingConnectorInvoiceSyncRequest,
recovery_response_types::BillingConnectorInvoiceSyncResponse,
> for Recurly
{
fn get_headers(
&self,
req: &recovery_router_data_types::BillingConnectorInvoiceSyncRouterDataV2,
) -> CustomResult<Vec<(String, masking::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_url(
&self,
req: &recovery_router_data_types::BillingConnectorInvoiceSyncRouterDataV2,
) -> CustomResult<String, errors::ConnectorError> {
let invoice_id = &req.request.billing_connector_invoice_id;
Ok(format!(
"{}/invoices/{invoice_id}",
req.request.connector_params.base_url,
))
}
fn build_request_v2(
&self,
req: &recovery_router_data_types::BillingConnectorInvoiceSyncRouterDataV2,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
let request = RequestBuilder::new()
.method(Method::Get)
.url(&types::BillingConnectorInvoiceSyncTypeV2::get_url(
self, req,
)?)
.attach_default_headers()
.headers(types::BillingConnectorInvoiceSyncTypeV2::get_headers(
self, req,
)?)
.build();
Ok(Some(request))
}
fn handle_response_v2(
&self,
data: &recovery_router_data_types::BillingConnectorInvoiceSyncRouterDataV2,
event_builder: Option<&mut ConnectorEvent>,
res: Response,
) -> CustomResult<
recovery_router_data_types::BillingConnectorInvoiceSyncRouterDataV2,
errors::ConnectorError,
> {
let response: recurly::RecurlyInvoiceSyncResponse = res
.response
.parse_struct::<recurly::RecurlyInvoiceSyncResponse>("RecurlyInvoiceSyncResponse")
.change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
event_builder.map(|i| i.set_response_body(&response));
router_env::logger::info!(connector_response=?response);
recovery_router_data_types::BillingConnectorInvoiceSyncRouterDataV2::try_from(
ResponseRouterDataV2 {
response,
data: data.clone(),
http_code: res.status_code,
},
)
}
fn get_error_response_v2(
&self,
res: Response,
event_builder: Option<&mut ConnectorEvent>,
) -> CustomResult<ErrorResponse, errors::ConnectorError> {
self.build_error_response(res, event_builder)
}
}
#[async_trait::async_trait]
impl webhooks::IncomingWebhook for Recurly {
fn get_webhook_source_verification_algorithm(
&self,
_request: &webhooks::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: &webhooks::IncomingWebhookRequestDetails<'_>,
_connector_webhook_secrets: &api_models::webhooks::ConnectorWebhookSecrets,
) -> CustomResult<Vec<u8>, errors::ConnectorError> {
// The `recurly-signature` header consists of a Unix timestamp (in milliseconds) followed by one or more HMAC-SHA256 signatures, separated by commas.
// Multiple signatures exist when a secret key is regenerated, with the old key remaining active for 24 hours.
let header_values = Self::get_signature_elements_from_header(request.headers)?;
let signature = header_values
.get(1)
.ok_or(errors::ConnectorError::WebhookSignatureNotFound)?;
hex::decode(signature).change_context(errors::ConnectorError::WebhookSignatureNotFound)
}
fn get_webhook_source_verification_message(
&self,
request: &webhooks::IncomingWebhookRequestDetails<'_>,
_merchant_id: &common_utils::id_type::MerchantId,
_connector_webhook_secrets: &api_models::webhooks::ConnectorWebhookSecrets,
) -> CustomResult<Vec<u8>, errors::ConnectorError> {
let header_values = Self::get_signature_elements_from_header(request.headers)?;
let timestamp = header_values
.first()
.ok_or(errors::ConnectorError::WebhookSignatureNotFound)?;
Ok(format!(
"{}.{}",
String::from_utf8_lossy(timestamp),
String::from_utf8_lossy(request.body)
)
.into_bytes())
}
#[cfg(all(feature = "revenue_recovery", feature = "v2"))]
fn get_webhook_object_reference_id(
&self,
request: &webhooks::IncomingWebhookRequestDetails<'_>,
) -> CustomResult<api_models::webhooks::ObjectReferenceId, errors::ConnectorError> {
let webhook = RecurlyWebhookBody::get_webhook_object_from_body(request.body)
.change_context(errors::ConnectorError::WebhookReferenceIdNotFound)?;
Ok(api_models::webhooks::ObjectReferenceId::PaymentId(
api_models::payments::PaymentIdType::ConnectorTransactionId(webhook.uuid),
))
}
#[cfg(any(feature = "v1", not(all(feature = "revenue_recovery", feature = "v2"))))]
fn get_webhook_object_reference_id(
&self,
_request: &webhooks::IncomingWebhookRequestDetails<'_>,
) -> CustomResult<api_models::webhooks::ObjectReferenceId, errors::ConnectorError> {
Err(report!(errors::ConnectorError::WebhooksNotImplemented))
}
#[cfg(all(feature = "revenue_recovery", feature = "v2"))]
fn get_webhook_event_type(
&self,
request: &webhooks::IncomingWebhookRequestDetails<'_>,
) -> CustomResult<api_models::webhooks::IncomingWebhookEvent, errors::ConnectorError> {
let webhook = RecurlyWebhookBody::get_webhook_object_from_body(request.body)
.change_context(errors::ConnectorError::WebhookBodyDecodingFailed)?;
let event = match webhook.event_type {
transformers::RecurlyPaymentEventType::PaymentSucceeded => {
api_models::webhooks::IncomingWebhookEvent::RecoveryPaymentSuccess
}
transformers::RecurlyPaymentEventType::PaymentFailed => {
api_models::webhooks::IncomingWebhookEvent::RecoveryPaymentFailure
}
};
Ok(event)
}
#[cfg(any(feature = "v1", not(all(feature = "revenue_recovery", feature = "v2"))))]
fn get_webhook_event_type(
&self,
_request: &webhooks::IncomingWebhookRequestDetails<'_>,
) -> CustomResult<api_models::webhooks::IncomingWebhookEvent, errors::ConnectorError> {
Err(report!(errors::ConnectorError::WebhooksNotImplemented))
}
fn get_webhook_resource_object(
&self,
request: &webhooks::IncomingWebhookRequestDetails<'_>,
) -> CustomResult<Box<dyn masking::ErasedMaskSerialize>, errors::ConnectorError> {
let webhook = RecurlyWebhookBody::get_webhook_object_from_body(request.body)
.change_context(errors::ConnectorError::WebhookResourceObjectNotFound)?;
Ok(Box::new(webhook))
}
}
impl ConnectorSpecifications for Recurly {}
|
{
"crate": "hyperswitch_connectors",
"file": "crates/hyperswitch_connectors/src/connectors/recurly.rs",
"file_size": null,
"is_async": null,
"is_pub": null,
"num_enums": 0,
"num_structs": 1,
"num_tables": null,
"score": null,
"total_crates": null
}
|
file_hyperswitch_connectors_-5536338105235790758
|
clm
|
file
|
// Repository: hyperswitch
// Crate: hyperswitch_connectors
// File: crates/hyperswitch_connectors/src/connectors/wise.rs
// Contains: 1 structs, 0 enums
pub mod transformers;
use api_models::webhooks::IncomingWebhookEvent;
#[cfg(feature = "payouts")]
use common_utils::request::{Method, RequestBuilder, RequestContent};
#[cfg(feature = "payouts")]
use common_utils::types::{AmountConvertor, FloatMajorUnit, FloatMajorUnitForConnector};
use common_utils::{errors::CustomResult, ext_traits::ByteSliceExt, request::Request};
#[cfg(not(feature = "payouts"))]
use error_stack::report;
use error_stack::ResultExt;
use hyperswitch_domain_models::{
router_data::{AccessToken, ConnectorAuthType, ErrorResponse, RouterData},
router_flow_types::{
AccessTokenAuth, Authorize, Capture, Execute, PSync, PaymentMethodToken, RSync, Session,
SetupMandate, Void,
},
router_request_types::{
AccessTokenRequestData, PaymentMethodTokenizationData, PaymentsAuthorizeData,
PaymentsCancelData, PaymentsCaptureData, PaymentsSessionData, PaymentsSyncData,
RefundsData, SetupMandateRequestData,
},
router_response_types::{
ConnectorInfo, PaymentsResponseData, RefundsResponseData, SupportedPaymentMethods,
},
};
#[cfg(feature = "payouts")]
use hyperswitch_domain_models::{
router_flow_types::{
PoCancel, PoCreate, PoEligibility, PoFulfill, PoQuote, PoRecipient, PoSync,
},
types::{PayoutsData, PayoutsResponseData, PayoutsRouterData},
};
#[cfg(feature = "payouts")]
use hyperswitch_interfaces::types::PayoutQuoteType;
#[cfg(feature = "payouts")]
use hyperswitch_interfaces::types::{
PayoutCancelType, PayoutCreateType, PayoutFulfillType, PayoutRecipientType, PayoutSyncType,
};
use hyperswitch_interfaces::{
api::{
self, ConnectorCommon, ConnectorCommonExt, ConnectorIntegration, ConnectorSpecifications,
Refund, RefundExecute, RefundSync,
},
configs::Connectors,
errors::ConnectorError,
events::connector_api_logs::ConnectorEvent,
types::Response,
webhooks::{IncomingWebhook, IncomingWebhookRequestDetails},
};
#[cfg(feature = "payouts")]
use masking::PeekInterface;
use masking::{Mask as _, Maskable};
#[cfg(feature = "payouts")]
use router_env::{instrument, tracing};
use self::transformers as wise;
use crate::constants::headers;
#[cfg(feature = "payouts")]
use crate::{types::ResponseRouterData, utils::convert_amount};
#[derive(Clone)]
pub struct Wise {
#[cfg(feature = "payouts")]
amount_converter: &'static (dyn AmountConvertor<Output = FloatMajorUnit> + Sync),
}
impl Wise {
pub fn new() -> &'static Self {
&Self {
#[cfg(feature = "payouts")]
amount_converter: &FloatMajorUnitForConnector,
}
}
}
impl<Flow, Request, Response> ConnectorCommonExt<Flow, Request, Response> for Wise
where
Self: ConnectorIntegration<Flow, Request, Response>,
{
#[cfg(feature = "payouts")]
fn build_headers(
&self,
req: &RouterData<Flow, Request, Response>,
_connectors: &Connectors,
) -> CustomResult<Vec<(String, Maskable<String>)>, ConnectorError> {
use masking::Mask as _;
let mut header = vec![(
headers::CONTENT_TYPE.to_string(),
PayoutQuoteType::get_content_type(self).to_string().into(),
)];
let auth = wise::WiseAuthType::try_from(&req.connector_auth_type)
.change_context(ConnectorError::FailedToObtainAuthType)?;
let mut api_key = vec![(
headers::AUTHORIZATION.to_string(),
auth.api_key.into_masked(),
)];
header.append(&mut api_key);
Ok(header)
}
}
impl ConnectorCommon for Wise {
fn id(&self) -> &'static str {
"wise"
}
fn get_auth_header(
&self,
auth_type: &ConnectorAuthType,
) -> CustomResult<Vec<(String, Maskable<String>)>, ConnectorError> {
let auth = wise::WiseAuthType::try_from(auth_type)
.change_context(ConnectorError::FailedToObtainAuthType)?;
Ok(vec![(
headers::AUTHORIZATION.to_string(),
auth.api_key.into_masked(),
)])
}
fn base_url<'a>(&self, connectors: &'a Connectors) -> &'a str {
connectors.wise.base_url.as_ref()
}
fn build_error_response(
&self,
res: Response,
event_builder: Option<&mut ConnectorEvent>,
) -> CustomResult<ErrorResponse, ConnectorError> {
let response: wise::ErrorResponse = res
.response
.parse_struct("ErrorResponse")
.change_context(ConnectorError::ResponseDeserializationFailed)?;
event_builder.map(|i| i.set_response_body(&response));
router_env::logger::info!(connector_response=?response);
let default_status = response.status.unwrap_or_default().get_status();
match response.errors {
Some(errs) => {
if let Some(e) = errs.first() {
Ok(ErrorResponse {
status_code: res.status_code,
code: e.code.clone(),
message: e.message.clone(),
reason: None,
attempt_status: None,
connector_transaction_id: None,
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
connector_metadata: None,
})
} else {
Ok(ErrorResponse {
status_code: res.status_code,
code: default_status,
message: response.message.unwrap_or_default(),
reason: None,
attempt_status: None,
connector_transaction_id: None,
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
connector_metadata: None,
})
}
}
None => Ok(ErrorResponse {
status_code: res.status_code,
code: default_status,
message: response.message.unwrap_or_default(),
reason: None,
attempt_status: None,
connector_transaction_id: None,
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
connector_metadata: None,
}),
}
}
}
impl api::Payment for Wise {}
impl api::PaymentAuthorize for Wise {}
impl api::PaymentSync for Wise {}
impl api::PaymentVoid for Wise {}
impl api::PaymentCapture for Wise {}
impl api::MandateSetup for Wise {}
impl api::ConnectorAccessToken for Wise {}
impl api::PaymentToken for Wise {}
impl api::ConnectorValidation for Wise {}
impl ConnectorIntegration<PaymentMethodToken, PaymentMethodTokenizationData, PaymentsResponseData>
for Wise
{
}
impl ConnectorIntegration<AccessTokenAuth, AccessTokenRequestData, AccessToken> for Wise {}
impl ConnectorIntegration<SetupMandate, SetupMandateRequestData, PaymentsResponseData> for Wise {
fn build_request(
&self,
_req: &RouterData<SetupMandate, SetupMandateRequestData, PaymentsResponseData>,
_connectors: &Connectors,
) -> CustomResult<Option<Request>, ConnectorError> {
Err(ConnectorError::NotImplemented("Setup Mandate flow for Wise".to_string()).into())
}
}
impl api::PaymentSession for Wise {}
impl ConnectorIntegration<Session, PaymentsSessionData, PaymentsResponseData> for Wise {}
impl ConnectorIntegration<Capture, PaymentsCaptureData, PaymentsResponseData> for Wise {}
impl ConnectorIntegration<PSync, PaymentsSyncData, PaymentsResponseData> for Wise {}
impl ConnectorIntegration<Authorize, PaymentsAuthorizeData, PaymentsResponseData> for Wise {}
impl ConnectorIntegration<Void, PaymentsCancelData, PaymentsResponseData> for Wise {}
impl api::Payouts for Wise {}
#[cfg(feature = "payouts")]
impl api::PayoutCancel for Wise {}
#[cfg(feature = "payouts")]
impl api::PayoutCreate for Wise {}
#[cfg(feature = "payouts")]
impl api::PayoutEligibility for Wise {}
#[cfg(feature = "payouts")]
impl api::PayoutQuote for Wise {}
#[cfg(feature = "payouts")]
impl api::PayoutRecipient for Wise {}
#[cfg(feature = "payouts")]
impl api::PayoutFulfill for Wise {}
#[cfg(feature = "payouts")]
impl api::PayoutSync for Wise {}
#[cfg(feature = "payouts")]
impl ConnectorIntegration<PoCancel, PayoutsData, PayoutsResponseData> for Wise {
fn get_url(
&self,
req: &PayoutsRouterData<PoCancel>,
connectors: &Connectors,
) -> CustomResult<String, ConnectorError> {
let transfer_id = req.request.connector_payout_id.clone().ok_or(
ConnectorError::MissingRequiredField {
field_name: "transfer_id",
},
)?;
Ok(format!(
"{}v1/transfers/{}/cancel",
connectors.wise.base_url, transfer_id
))
}
fn get_headers(
&self,
req: &PayoutsRouterData<PoCancel>,
_connectors: &Connectors,
) -> CustomResult<Vec<(String, Maskable<String>)>, ConnectorError> {
self.build_headers(req, _connectors)
}
fn build_request(
&self,
req: &PayoutsRouterData<PoCancel>,
connectors: &Connectors,
) -> CustomResult<Option<Request>, ConnectorError> {
let request = RequestBuilder::new()
.method(Method::Put)
.url(&PayoutCancelType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(PayoutCancelType::get_headers(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>, ConnectorError> {
let response: wise::WisePayoutResponse = res
.response
.parse_struct("WisePayoutResponse")
.change_context(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,
})
}
fn get_error_response(
&self,
res: Response,
event_builder: Option<&mut ConnectorEvent>,
) -> CustomResult<ErrorResponse, ConnectorError> {
let response: wise::ErrorResponse = res
.response
.parse_struct("ErrorResponse")
.change_context(ConnectorError::ResponseDeserializationFailed)?;
event_builder.map(|i| i.set_error_response_body(&response));
router_env::logger::info!(connector_response=?response);
let def_res = response.status.unwrap_or_default().get_status();
let errors = response.errors.unwrap_or_default();
let (code, message) = if let Some(e) = errors.first() {
(e.code.clone(), e.message.clone())
} else {
(def_res, response.message.unwrap_or_default())
};
Ok(ErrorResponse {
status_code: res.status_code,
code,
message,
reason: None,
attempt_status: None,
connector_transaction_id: None,
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
connector_metadata: None,
})
}
}
#[cfg(feature = "payouts")]
impl ConnectorIntegration<PoQuote, PayoutsData, PayoutsResponseData> for Wise {
fn get_url(
&self,
req: &PayoutsRouterData<PoQuote>,
connectors: &Connectors,
) -> CustomResult<String, ConnectorError> {
let auth = wise::WiseAuthType::try_from(&req.connector_auth_type)
.change_context(ConnectorError::FailedToObtainAuthType)?;
Ok(format!(
"{}v3/profiles/{}/quotes",
connectors.wise.base_url,
auth.profile_id.peek()
))
}
fn get_headers(
&self,
req: &PayoutsRouterData<PoQuote>,
connectors: &Connectors,
) -> CustomResult<Vec<(String, Maskable<String>)>, ConnectorError> {
self.build_headers(req, connectors)
}
fn get_request_body(
&self,
req: &PayoutsRouterData<PoQuote>,
_connectors: &Connectors,
) -> CustomResult<RequestContent, ConnectorError> {
let amount = convert_amount(
self.amount_converter,
req.request.minor_amount,
req.request.source_currency,
)?;
let connector_router_data = wise::WiseRouterData::from((amount, req));
let connector_req = wise::WisePayoutQuoteRequest::try_from(&connector_router_data)?;
Ok(RequestContent::Json(Box::new(connector_req)))
}
fn build_request(
&self,
req: &PayoutsRouterData<PoQuote>,
connectors: &Connectors,
) -> CustomResult<Option<Request>, ConnectorError> {
let request = RequestBuilder::new()
.method(Method::Post)
.url(&PayoutQuoteType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(PayoutQuoteType::get_headers(self, req, connectors)?)
.set_body(PayoutQuoteType::get_request_body(self, req, connectors)?)
.build();
Ok(Some(request))
}
#[instrument(skip_all)]
fn handle_response(
&self,
data: &PayoutsRouterData<PoQuote>,
event_builder: Option<&mut ConnectorEvent>,
res: Response,
) -> CustomResult<PayoutsRouterData<PoQuote>, ConnectorError> {
let response: wise::WisePayoutQuoteResponse = res
.response
.parse_struct("WisePayoutQuoteResponse")
.change_context(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,
})
}
fn get_error_response(
&self,
res: Response,
event_builder: Option<&mut ConnectorEvent>,
) -> CustomResult<ErrorResponse, ConnectorError> {
self.build_error_response(res, event_builder)
}
}
#[cfg(feature = "payouts")]
impl ConnectorIntegration<PoSync, PayoutsData, PayoutsResponseData> for Wise {
fn get_url(
&self,
req: &PayoutsRouterData<PoSync>,
connectors: &Connectors,
) -> CustomResult<String, ConnectorError> {
let transfer_id = req.request.connector_payout_id.to_owned().ok_or(
ConnectorError::MissingRequiredField {
field_name: "transfer_id",
},
)?;
Ok(format!(
"{}/v1/transfers/{}",
connectors.wise.base_url, transfer_id
))
}
fn get_headers(
&self,
req: &PayoutsRouterData<PoSync>,
connectors: &Connectors,
) -> CustomResult<Vec<(String, Maskable<String>)>, ConnectorError> {
self.build_headers(req, connectors)
}
fn build_request(
&self,
req: &PayoutsRouterData<PoSync>,
connectors: &Connectors,
) -> CustomResult<Option<Request>, ConnectorError> {
let request = RequestBuilder::new()
.method(Method::Get)
.url(&PayoutSyncType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(PayoutSyncType::get_headers(self, req, connectors)?)
.build();
Ok(Some(request))
}
#[instrument(skip_all)]
fn handle_response(
&self,
data: &PayoutsRouterData<PoSync>,
event_builder: Option<&mut ConnectorEvent>,
res: Response,
) -> CustomResult<PayoutsRouterData<PoSync>, ConnectorError> {
let response: wise::WisePayoutSyncResponse = res
.response
.parse_struct("WisePayoutSyncResponse")
.change_context(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,
})
}
fn get_error_response(
&self,
res: Response,
event_builder: Option<&mut ConnectorEvent>,
) -> CustomResult<ErrorResponse, ConnectorError> {
self.build_error_response(res, event_builder)
}
}
#[cfg(feature = "payouts")]
impl ConnectorIntegration<PoRecipient, PayoutsData, PayoutsResponseData> for Wise {
fn get_url(
&self,
_req: &PayoutsRouterData<PoRecipient>,
connectors: &Connectors,
) -> CustomResult<String, ConnectorError> {
Ok(format!("{}v1/accounts", connectors.wise.base_url))
}
fn get_headers(
&self,
req: &PayoutsRouterData<PoRecipient>,
connectors: &Connectors,
) -> CustomResult<Vec<(String, Maskable<String>)>, ConnectorError> {
self.build_headers(req, connectors)
}
fn get_request_body(
&self,
req: &PayoutsRouterData<PoRecipient>,
_connectors: &Connectors,
) -> CustomResult<RequestContent, ConnectorError> {
let amount = convert_amount(
self.amount_converter,
req.request.minor_amount,
req.request.source_currency,
)?;
let connector_router_data = wise::WiseRouterData::from((amount, req));
let connector_req = wise::WiseRecipientCreateRequest::try_from(&connector_router_data)?;
Ok(RequestContent::Json(Box::new(connector_req)))
}
fn build_request(
&self,
req: &PayoutsRouterData<PoRecipient>,
connectors: &Connectors,
) -> CustomResult<Option<Request>, ConnectorError> {
let request = RequestBuilder::new()
.method(Method::Post)
.url(&PayoutRecipientType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(PayoutRecipientType::get_headers(self, req, connectors)?)
.set_body(PayoutRecipientType::get_request_body(
self, req, connectors,
)?)
.build();
Ok(Some(request))
}
#[instrument(skip_all)]
fn handle_response(
&self,
data: &PayoutsRouterData<PoRecipient>,
event_builder: Option<&mut ConnectorEvent>,
res: Response,
) -> CustomResult<PayoutsRouterData<PoRecipient>, ConnectorError> {
let response: wise::WiseRecipientCreateResponse = res
.response
.parse_struct("WiseRecipientCreateResponse")
.change_context(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,
})
}
fn get_error_response(
&self,
res: Response,
event_builder: Option<&mut ConnectorEvent>,
) -> CustomResult<ErrorResponse, ConnectorError> {
self.build_error_response(res, event_builder)
}
}
#[async_trait::async_trait]
#[cfg(feature = "payouts")]
impl ConnectorIntegration<PoCreate, PayoutsData, PayoutsResponseData> for Wise {
fn get_url(
&self,
_req: &PayoutsRouterData<PoCreate>,
connectors: &Connectors,
) -> CustomResult<String, ConnectorError> {
Ok(format!("{}/v1/transfers", connectors.wise.base_url))
}
fn get_headers(
&self,
req: &PayoutsRouterData<PoCreate>,
connectors: &Connectors,
) -> CustomResult<Vec<(String, Maskable<String>)>, ConnectorError> {
self.build_headers(req, connectors)
}
fn get_request_body(
&self,
req: &PayoutsRouterData<PoCreate>,
_connectors: &Connectors,
) -> CustomResult<RequestContent, ConnectorError> {
let connector_req = wise::WisePayoutCreateRequest::try_from(req)?;
Ok(RequestContent::Json(Box::new(connector_req)))
}
fn build_request(
&self,
req: &PayoutsRouterData<PoCreate>,
connectors: &Connectors,
) -> CustomResult<Option<Request>, 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();
Ok(Some(request))
}
#[instrument(skip_all)]
fn handle_response(
&self,
data: &PayoutsRouterData<PoCreate>,
event_builder: Option<&mut ConnectorEvent>,
res: Response,
) -> CustomResult<PayoutsRouterData<PoCreate>, ConnectorError> {
let response: wise::WisePayoutResponse = res
.response
.parse_struct("WisePayoutResponse")
.change_context(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,
})
}
fn get_error_response(
&self,
res: Response,
event_builder: Option<&mut ConnectorEvent>,
) -> CustomResult<ErrorResponse, ConnectorError> {
self.build_error_response(res, event_builder)
}
}
#[cfg(feature = "payouts")]
impl ConnectorIntegration<PoEligibility, PayoutsData, PayoutsResponseData> for Wise {
fn build_request(
&self,
_req: &PayoutsRouterData<PoEligibility>,
_connectors: &Connectors,
) -> CustomResult<Option<Request>, ConnectorError> {
// Eligibility check for cards is not implemented
Err(ConnectorError::NotImplemented("Payout Eligibility for Wise".to_string()).into())
}
}
#[cfg(feature = "payouts")]
impl ConnectorIntegration<PoFulfill, PayoutsData, PayoutsResponseData> for Wise {
fn get_url(
&self,
req: &PayoutsRouterData<PoFulfill>,
connectors: &Connectors,
) -> CustomResult<String, ConnectorError> {
let auth = wise::WiseAuthType::try_from(&req.connector_auth_type)
.change_context(ConnectorError::FailedToObtainAuthType)?;
let transfer_id = req.request.connector_payout_id.to_owned().ok_or(
ConnectorError::MissingRequiredField {
field_name: "transfer_id",
},
)?;
Ok(format!(
"{}v3/profiles/{}/transfers/{}/payments",
connectors.wise.base_url,
auth.profile_id.peek(),
transfer_id
))
}
fn get_headers(
&self,
req: &PayoutsRouterData<PoFulfill>,
connectors: &Connectors,
) -> CustomResult<Vec<(String, Maskable<String>)>, ConnectorError> {
self.build_headers(req, connectors)
}
fn get_request_body(
&self,
req: &PayoutsRouterData<PoFulfill>,
_connectors: &Connectors,
) -> CustomResult<RequestContent, ConnectorError> {
let connector_req = wise::WisePayoutFulfillRequest::try_from(req)?;
Ok(RequestContent::Json(Box::new(connector_req)))
}
fn build_request(
&self,
req: &PayoutsRouterData<PoFulfill>,
connectors: &Connectors,
) -> CustomResult<Option<Request>, ConnectorError> {
let request = RequestBuilder::new()
.method(Method::Post)
.url(&PayoutFulfillType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(PayoutFulfillType::get_headers(self, req, connectors)?)
.set_body(PayoutFulfillType::get_request_body(self, req, connectors)?)
.build();
Ok(Some(request))
}
#[instrument(skip_all)]
fn handle_response(
&self,
data: &PayoutsRouterData<PoFulfill>,
event_builder: Option<&mut ConnectorEvent>,
res: Response,
) -> CustomResult<PayoutsRouterData<PoFulfill>, ConnectorError> {
let response: wise::WiseFulfillResponse = res
.response
.parse_struct("WiseFulfillResponse")
.change_context(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,
})
}
fn get_error_response(
&self,
res: Response,
event_builder: Option<&mut ConnectorEvent>,
) -> CustomResult<ErrorResponse, ConnectorError> {
self.build_error_response(res, event_builder)
}
}
impl Refund for Wise {}
impl RefundExecute for Wise {}
impl RefundSync for Wise {}
impl ConnectorIntegration<Execute, RefundsData, RefundsResponseData> for Wise {}
impl ConnectorIntegration<RSync, RefundsData, RefundsResponseData> for Wise {}
#[cfg(feature = "payouts")]
fn is_setup_webhook_event(request: &IncomingWebhookRequestDetails<'_>) -> bool {
let test_webhook_header = request
.headers
.get("X-Test-Notification")
.and_then(|header_value| String::from_utf8(header_value.as_bytes().to_vec()).ok());
test_webhook_header == Some("true".to_string())
}
#[async_trait::async_trait]
impl IncomingWebhook for Wise {
fn get_webhook_source_verification_algorithm(
&self,
_request: &IncomingWebhookRequestDetails<'_>,
) -> CustomResult<Box<dyn common_utils::crypto::VerifySignature + Send>, ConnectorError> {
Ok(Box::new(common_utils::crypto::RsaSha256))
}
fn get_webhook_source_verification_signature(
&self,
#[cfg(feature = "payouts")] request: &IncomingWebhookRequestDetails<'_>,
#[cfg(not(feature = "payouts"))] _request: &IncomingWebhookRequestDetails<'_>,
_connector_webhook_secrets: &api_models::webhooks::ConnectorWebhookSecrets,
) -> CustomResult<Vec<u8>, ConnectorError> {
#[cfg(feature = "payouts")]
{
request
.headers
.get("X-Signature-SHA256")
.map(|header_value| header_value.as_bytes().to_vec())
.ok_or(ConnectorError::WebhookSignatureNotFound.into())
}
#[cfg(not(feature = "payouts"))]
{
Err(report!(ConnectorError::WebhooksNotImplemented))
}
}
fn get_webhook_source_verification_message(
&self,
#[cfg(feature = "payouts")] request: &IncomingWebhookRequestDetails<'_>,
#[cfg(not(feature = "payouts"))] _request: &IncomingWebhookRequestDetails<'_>,
_merchant_id: &common_utils::id_type::MerchantId,
_connector_webhook_secrets: &api_models::webhooks::ConnectorWebhookSecrets,
) -> CustomResult<Vec<u8>, ConnectorError> {
#[cfg(feature = "payouts")]
{
Ok(request.body.to_vec())
}
#[cfg(not(feature = "payouts"))]
{
Err(report!(ConnectorError::WebhooksNotImplemented))
}
}
fn get_webhook_object_reference_id(
&self,
#[cfg(feature = "payouts")] request: &IncomingWebhookRequestDetails<'_>,
#[cfg(not(feature = "payouts"))] _request: &IncomingWebhookRequestDetails<'_>,
) -> CustomResult<api_models::webhooks::ObjectReferenceId, ConnectorError> {
#[cfg(feature = "payouts")]
{
let payload: wise::WisePayoutsWebhookBody = request
.body
.parse_struct("WisePayoutsWebhookBody")
.change_context(ConnectorError::WebhookReferenceIdNotFound)?;
Ok(api_models::webhooks::ObjectReferenceId::PayoutId(
api_models::webhooks::PayoutIdType::ConnectorPayoutId(
payload.data.resource.id.to_string(),
),
))
}
#[cfg(not(feature = "payouts"))]
{
Err(report!(ConnectorError::WebhooksNotImplemented))
}
}
fn get_webhook_event_type(
&self,
#[cfg(feature = "payouts")] request: &IncomingWebhookRequestDetails<'_>,
#[cfg(not(feature = "payouts"))] _request: &IncomingWebhookRequestDetails<'_>,
) -> CustomResult<IncomingWebhookEvent, ConnectorError> {
#[cfg(feature = "payouts")]
{
if is_setup_webhook_event(request) {
return Ok(IncomingWebhookEvent::SetupWebhook);
}
let payload: wise::WisePayoutsWebhookBody = request
.body
.parse_struct("WisePayoutsWebhookBody")
.change_context(ConnectorError::WebhookReferenceIdNotFound)?;
Ok(transformers::get_wise_webhooks_event(
payload.data.current_state,
))
}
#[cfg(not(feature = "payouts"))]
{
Err(report!(ConnectorError::WebhooksNotImplemented))
}
}
fn get_webhook_resource_object(
&self,
#[cfg(feature = "payouts")] request: &IncomingWebhookRequestDetails<'_>,
#[cfg(not(feature = "payouts"))] _request: &IncomingWebhookRequestDetails<'_>,
) -> CustomResult<Box<dyn masking::ErasedMaskSerialize>, ConnectorError> {
#[cfg(feature = "payouts")]
{
let payload: wise::WisePayoutsWebhookBody = request
.body
.parse_struct("WisePayoutsWebhookBody")
.change_context(ConnectorError::WebhookReferenceIdNotFound)?;
Ok(Box::new(wise::WisePayoutSyncResponse::from(payload.data)))
}
#[cfg(not(feature = "payouts"))]
{
Err(report!(ConnectorError::WebhooksNotImplemented))
}
}
}
static WISE_CONNECTOR_INFO: ConnectorInfo = ConnectorInfo {
display_name: "Wise",
description: "The Wise connector enables cross-border money transfers by integrating with Wise's API to initiate, track, and manage international payouts efficiently.",
connector_type: common_enums::HyperswitchConnectorCategory::PayoutProcessor,
integration_status: common_enums::ConnectorIntegrationStatus::Sandbox,
};
impl ConnectorSpecifications for Wise {
fn get_connector_about(&self) -> Option<&'static ConnectorInfo> {
Some(&WISE_CONNECTOR_INFO)
}
fn get_supported_payment_methods(&self) -> Option<&'static SupportedPaymentMethods> {
None
}
fn get_supported_webhook_flows(&self) -> Option<&'static [common_enums::enums::EventClass]> {
None
}
}
|
{
"crate": "hyperswitch_connectors",
"file": "crates/hyperswitch_connectors/src/connectors/wise.rs",
"file_size": null,
"is_async": null,
"is_pub": null,
"num_enums": 0,
"num_structs": 1,
"num_tables": null,
"score": null,
"total_crates": null
}
|
file_hyperswitch_connectors_-4340500713850198846
|
clm
|
file
|
// Repository: hyperswitch
// Crate: hyperswitch_connectors
// File: crates/hyperswitch_connectors/src/connectors/payload.rs
// Contains: 1 structs, 0 enums
mod requests;
mod responses;
pub mod transformers;
use std::sync::LazyLock;
use base64::Engine;
use common_enums::enums;
use common_utils::{
consts::BASE64_ENGINE,
errors::{CustomResult, ReportSwitchExt},
ext_traits::{ByteSliceExt, BytesExt},
request::{Method, Request, RequestBuilder, RequestContent},
types::{AmountConvertor, StringMajorUnit, StringMajorUnitForConnector},
};
use error_stack::ResultExt;
use hyperswitch_domain_models::{
payment_method_data::PaymentMethodData,
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::{
ConnectorInfo, PaymentMethodDetails, PaymentsResponseData, RefundsResponseData,
SupportedPaymentMethods, SupportedPaymentMethodsExt,
},
types::{
PaymentsAuthorizeRouterData, PaymentsCancelRouterData, PaymentsCaptureRouterData,
PaymentsSyncRouterData, RefundSyncRouterData, RefundsRouterData, SetupMandateRouterData,
},
};
use hyperswitch_interfaces::{
api::{
self, ConnectorCommon, ConnectorCommonExt, ConnectorIntegration, ConnectorSpecifications,
ConnectorValidation,
},
configs::Connectors,
errors,
events::connector_api_logs::ConnectorEvent,
types::{self, PaymentsVoidType, Response, SetupMandateType},
webhooks,
};
use masking::{ExposeInterface, Mask, Secret};
use transformers as payload;
use crate::{constants::headers, types::ResponseRouterData, utils};
#[derive(Clone)]
pub struct Payload {
amount_converter: &'static (dyn AmountConvertor<Output = StringMajorUnit> + Sync),
}
impl Payload {
pub fn new() -> &'static Self {
&Self {
amount_converter: &StringMajorUnitForConnector,
}
}
}
impl api::Payment for Payload {}
impl api::PaymentSession for Payload {}
impl api::ConnectorAccessToken for Payload {}
impl api::MandateSetup for Payload {}
impl api::PaymentAuthorize for Payload {}
impl api::PaymentSync for Payload {}
impl api::PaymentCapture for Payload {}
impl api::PaymentVoid for Payload {}
impl api::Refund for Payload {}
impl api::RefundExecute for Payload {}
impl api::RefundSync for Payload {}
impl api::PaymentToken for Payload {}
impl ConnectorIntegration<PaymentMethodToken, PaymentMethodTokenizationData, PaymentsResponseData>
for Payload
{
// Not Implemented (R)
}
impl<Flow, Request, Response> ConnectorCommonExt<Flow, Request, Response> for Payload
where
Self: ConnectorIntegration<Flow, Request, Response>,
{
fn build_headers(
&self,
req: &RouterData<Flow, Request, Response>,
_connectors: &Connectors,
) -> CustomResult<Vec<(String, masking::Maskable<String>)>, errors::ConnectorError> {
let mut header = vec![(
headers::CONTENT_TYPE.to_string(),
Self::common_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)
}
}
impl ConnectorCommon for Payload {
fn id(&self) -> &'static str {
"payload"
}
fn get_currency_unit(&self) -> api::CurrencyUnit {
api::CurrencyUnit::Minor
}
fn common_get_content_type(&self) -> &'static str {
"application/x-www-form-urlencoded"
}
fn base_url<'a>(&self, connectors: &'a Connectors) -> &'a str {
connectors.payload.base_url.as_ref()
}
fn get_auth_header(
&self,
auth_type: &ConnectorAuthType,
) -> CustomResult<Vec<(String, masking::Maskable<String>)>, errors::ConnectorError> {
let auth = payload::PayloadAuthType::try_from(auth_type)
.change_context(errors::ConnectorError::FailedToObtainAuthType)?;
// The API key is the same for all currencies, so we can take any.
let api_key = auth
.auths
.values()
.next()
.ok_or(errors::ConnectorError::FailedToObtainAuthType)?
.api_key
.clone();
let encoded_api_key = BASE64_ENGINE.encode(format!("{}:", api_key.expose()));
Ok(vec![(
headers::AUTHORIZATION.to_string(),
format!("Basic {encoded_api_key}").into_masked(),
)])
}
fn build_error_response(
&self,
res: Response,
event_builder: Option<&mut ConnectorEvent>,
) -> CustomResult<ErrorResponse, errors::ConnectorError> {
let response: responses::PayloadErrorResponse = res
.response
.parse_struct("PayloadErrorResponse")
.change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
event_builder.map(|i| i.set_response_body(&response));
router_env::logger::info!(connector_response=?response);
Ok(ErrorResponse {
status_code: res.status_code,
code: response.error_type,
message: response.error_description,
reason: response
.details
.as_ref()
.map(|details_value| details_value.to_string()),
attempt_status: None,
connector_transaction_id: None,
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
connector_metadata: None,
})
}
}
impl ConnectorValidation for Payload {
fn validate_mandate_payment(
&self,
pm_type: Option<enums::PaymentMethodType>,
pm_data: PaymentMethodData,
) -> CustomResult<(), errors::ConnectorError> {
let mandate_supported_pmd =
std::collections::HashSet::from([utils::PaymentMethodDataType::Card]);
utils::is_mandate_supported(pm_data, pm_type, mandate_supported_pmd, self.id())
}
}
impl ConnectorIntegration<Session, PaymentsSessionData, PaymentsResponseData> for Payload {}
impl ConnectorIntegration<AccessTokenAuth, AccessTokenRequestData, AccessToken> for Payload {}
impl ConnectorIntegration<SetupMandate, SetupMandateRequestData, PaymentsResponseData> for Payload {
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!("{}/transactions", self.base_url(connectors)))
}
fn get_request_body(
&self,
req: &SetupMandateRouterData,
_connectors: &Connectors,
) -> CustomResult<RequestContent, errors::ConnectorError> {
let connector_req = requests::PayloadCardsRequestData::try_from(req)?;
Ok(RequestContent::FormUrlEncoded(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(&SetupMandateType::get_url(self, req, connectors)?)
.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<SetupMandateRouterData, errors::ConnectorError> {
let response: responses::PayloadPaymentsResponse = res
.response
.parse_struct("PayloadPaymentsResponse")
.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,
})
}
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<Authorize, PaymentsAuthorizeData, PaymentsResponseData> for Payload {
fn get_headers(
&self,
req: &PaymentsAuthorizeRouterData,
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: &PaymentsAuthorizeRouterData,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
Ok(format!("{}/transactions", self.base_url(connectors)))
}
fn get_request_body(
&self,
req: &PaymentsAuthorizeRouterData,
_connectors: &Connectors,
) -> CustomResult<RequestContent, errors::ConnectorError> {
let amount = utils::convert_amount(
self.amount_converter,
req.request.minor_amount,
req.request.currency,
)?;
let connector_router_data = payload::PayloadRouterData::from((amount, req));
let connector_req = requests::PayloadPaymentsRequest::try_from(&connector_router_data)?;
Ok(RequestContent::FormUrlEncoded(Box::new(connector_req)))
}
fn build_request(
&self,
req: &PaymentsAuthorizeRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Ok(Some(
RequestBuilder::new()
.method(Method::Post)
.url(&types::PaymentsAuthorizeType::get_url(
self, req, connectors,
)?)
.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: responses::PayloadPaymentsResponse = res
.response
.parse_struct("PayloadPaymentsResponse")
.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,
})
}
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<PSync, PaymentsSyncData, PaymentsResponseData> for Payload {
fn get_headers(
&self,
req: &PaymentsSyncRouterData,
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: &PaymentsSyncRouterData,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
let payment_id = req
.request
.connector_transaction_id
.get_connector_transaction_id()
.change_context(errors::ConnectorError::MissingConnectorTransactionID)?;
Ok(format!(
"{}/transactions/{}",
self.base_url(connectors),
payment_id
))
}
fn build_request(
&self,
req: &PaymentsSyncRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Ok(Some(
RequestBuilder::new()
.method(Method::Get)
.url(&types::PaymentsSyncType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(types::PaymentsSyncType::get_headers(self, req, connectors)?)
.build(),
))
}
fn handle_response(
&self,
data: &PaymentsSyncRouterData,
event_builder: Option<&mut ConnectorEvent>,
res: Response,
) -> CustomResult<PaymentsSyncRouterData, errors::ConnectorError> {
let response: responses::PayloadPaymentsResponse = res
.response
.parse_struct("PayloadPaymentsSyncResponse")
.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,
})
}
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 Payload {
fn get_headers(
&self,
req: &PaymentsCaptureRouterData,
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: &PaymentsCaptureRouterData,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
let connector_transaction_id = req.request.connector_transaction_id.clone();
Ok(format!(
"{}/transactions/{}",
self.base_url(connectors),
connector_transaction_id
))
}
fn get_request_body(
&self,
req: &PaymentsCaptureRouterData,
_connectors: &Connectors,
) -> CustomResult<RequestContent, errors::ConnectorError> {
let amount = utils::convert_amount(
self.amount_converter,
req.request.minor_amount_to_capture,
req.request.currency,
)?;
let connector_router_data = payload::PayloadRouterData::from((amount, req));
let connector_req = requests::PayloadCaptureRequest::try_from(&connector_router_data)?;
Ok(RequestContent::FormUrlEncoded(Box::new(connector_req)))
}
fn build_request(
&self,
req: &PaymentsCaptureRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Ok(Some(
RequestBuilder::new()
.method(Method::Put)
.url(&types::PaymentsCaptureType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(types::PaymentsCaptureType::get_headers(
self, req, connectors,
)?)
.set_body(types::PaymentsCaptureType::get_request_body(
self, req, connectors,
)?)
.build(),
))
}
fn handle_response(
&self,
data: &PaymentsCaptureRouterData,
event_builder: Option<&mut ConnectorEvent>,
res: Response,
) -> CustomResult<PaymentsCaptureRouterData, errors::ConnectorError> {
let response: responses::PayloadPaymentsResponse = res
.response
.parse_struct("PayloadPaymentsCaptureResponse")
.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,
})
}
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<Void, PaymentsCancelData, PaymentsResponseData> for Payload {
fn get_headers(
&self,
req: &PaymentsCancelRouterData,
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: &PaymentsCancelRouterData,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
let payment_id = &req.request.connector_transaction_id;
Ok(format!(
"{}/transactions/{}",
self.base_url(connectors),
payment_id
))
}
fn get_request_body(
&self,
req: &PaymentsCancelRouterData,
_connectors: &Connectors,
) -> CustomResult<RequestContent, errors::ConnectorError> {
let connector_router_data = payload::PayloadRouterData::from((Default::default(), req));
let connector_req = requests::PayloadCancelRequest::try_from(&connector_router_data)?;
Ok(RequestContent::FormUrlEncoded(Box::new(connector_req)))
}
fn build_request(
&self,
req: &PaymentsCancelRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Ok(Some(
RequestBuilder::new()
.method(Method::Put)
.url(&PaymentsVoidType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(PaymentsVoidType::get_headers(self, req, connectors)?)
.set_body(PaymentsVoidType::get_request_body(self, req, connectors)?)
.build(),
))
}
fn handle_response(
&self,
data: &RouterData<Void, PaymentsCancelData, PaymentsResponseData>,
event_builder: Option<&mut ConnectorEvent>,
res: Response,
) -> CustomResult<
RouterData<Void, PaymentsCancelData, PaymentsResponseData>,
errors::ConnectorError,
> {
let response: responses::PayloadPaymentsResponse = res
.response
.parse_struct("PayloadPaymentsCancelResponse")
.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,
})
}
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<Execute, RefundsData, RefundsResponseData> for Payload {
fn get_headers(
&self,
req: &RefundsRouterData<Execute>,
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: &RefundsRouterData<Execute>,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
Ok(format!("{}/transactions", self.base_url(connectors)))
}
fn get_request_body(
&self,
req: &RefundsRouterData<Execute>,
_connectors: &Connectors,
) -> CustomResult<RequestContent, errors::ConnectorError> {
let refund_amount = utils::convert_amount(
self.amount_converter,
req.request.minor_refund_amount,
req.request.currency,
)?;
let connector_router_data = payload::PayloadRouterData::from((refund_amount, req));
let connector_req = requests::PayloadRefundRequest::try_from(&connector_router_data)?;
Ok(RequestContent::FormUrlEncoded(Box::new(connector_req)))
}
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))
}
fn handle_response(
&self,
data: &RefundsRouterData<Execute>,
event_builder: Option<&mut ConnectorEvent>,
res: Response,
) -> CustomResult<RefundsRouterData<Execute>, errors::ConnectorError> {
let response: responses::PayloadRefundResponse = res
.response
.parse_struct("PayloadRefundResponse")
.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,
})
}
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<RSync, RefundsData, RefundsResponseData> for Payload {
fn get_headers(
&self,
req: &RefundSyncRouterData,
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: &RefundSyncRouterData,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
let connector_refund_id = req
.request
.connector_refund_id
.as_ref()
.ok_or_else(|| errors::ConnectorError::MissingConnectorRefundID)?;
Ok(format!(
"{}/transactions/{}",
self.base_url(connectors),
connector_refund_id
))
}
fn build_request(
&self,
req: &RefundSyncRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Ok(Some(
RequestBuilder::new()
.method(Method::Get)
.url(&types::RefundSyncType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(types::RefundSyncType::get_headers(self, req, connectors)?)
.set_body(types::RefundSyncType::get_request_body(
self, req, connectors,
)?)
.build(),
))
}
fn handle_response(
&self,
data: &RefundSyncRouterData,
event_builder: Option<&mut ConnectorEvent>,
res: Response,
) -> CustomResult<RefundSyncRouterData, errors::ConnectorError> {
let response: responses::PayloadRefundResponse = res
.response
.parse_struct("PayloadRefundSyncResponse")
.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,
})
}
fn get_error_response(
&self,
res: Response,
event_builder: Option<&mut ConnectorEvent>,
) -> CustomResult<ErrorResponse, errors::ConnectorError> {
self.build_error_response(res, event_builder)
}
}
#[async_trait::async_trait]
impl webhooks::IncomingWebhook for Payload {
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> {
// Payload does not support source verification
// It does, but the client id and client secret generation is not possible at present
// It requires OAuth connect which falls under Access Token flow and it also requires multiple calls to be made
// We return false just so that a PSync call is triggered internally
Ok(false)
}
fn get_webhook_object_reference_id(
&self,
request: &webhooks::IncomingWebhookRequestDetails<'_>,
) -> CustomResult<api_models::webhooks::ObjectReferenceId, errors::ConnectorError> {
let webhook_body: responses::PayloadWebhookEvent = request
.body
.parse_struct("PayloadWebhookEvent")
.change_context(errors::ConnectorError::WebhookBodyDecodingFailed)?;
let reference_id = match webhook_body.trigger {
responses::PayloadWebhooksTrigger::Payment
| responses::PayloadWebhooksTrigger::Processed
| responses::PayloadWebhooksTrigger::Authorized
| responses::PayloadWebhooksTrigger::Credit
| responses::PayloadWebhooksTrigger::Reversal
| responses::PayloadWebhooksTrigger::Void
| responses::PayloadWebhooksTrigger::AutomaticPayment
| responses::PayloadWebhooksTrigger::Decline
| responses::PayloadWebhooksTrigger::Deposit
| responses::PayloadWebhooksTrigger::Reject
| responses::PayloadWebhooksTrigger::PaymentActivationStatus
| responses::PayloadWebhooksTrigger::PaymentLinkStatus
| responses::PayloadWebhooksTrigger::ProcessingStatus
| responses::PayloadWebhooksTrigger::BankAccountReject
| responses::PayloadWebhooksTrigger::Chargeback
| responses::PayloadWebhooksTrigger::ChargebackReversal
| responses::PayloadWebhooksTrigger::TransactionOperation
| responses::PayloadWebhooksTrigger::TransactionOperationClear => {
api_models::webhooks::ObjectReferenceId::PaymentId(
api_models::payments::PaymentIdType::ConnectorTransactionId(
webhook_body
.triggered_on
.transaction_id
.ok_or(errors::ConnectorError::WebhookReferenceIdNotFound)?,
),
)
}
responses::PayloadWebhooksTrigger::Refund => {
api_models::webhooks::ObjectReferenceId::RefundId(
api_models::webhooks::RefundIdType::ConnectorRefundId(
webhook_body
.triggered_on
.transaction_id
.ok_or(errors::ConnectorError::WebhookReferenceIdNotFound)?,
),
)
}
};
Ok(reference_id)
}
fn get_webhook_event_type(
&self,
request: &webhooks::IncomingWebhookRequestDetails<'_>,
) -> CustomResult<api_models::webhooks::IncomingWebhookEvent, errors::ConnectorError> {
let webhook_body: responses::PayloadWebhookEvent =
request.body.parse_struct("PayloadWebhookEvent").switch()?;
Ok(api_models::webhooks::IncomingWebhookEvent::from(
webhook_body.trigger,
))
}
fn get_webhook_resource_object(
&self,
request: &webhooks::IncomingWebhookRequestDetails<'_>,
) -> CustomResult<Box<dyn masking::ErasedMaskSerialize>, errors::ConnectorError> {
let webhook_body: responses::PayloadWebhookEvent = request
.body
.parse_struct("PayloadWebhookEvent")
.change_context(errors::ConnectorError::WebhookReferenceIdNotFound)?;
Ok(Box::new(webhook_body))
}
}
static PAYLOAD_SUPPORTED_PAYMENT_METHODS: LazyLock<SupportedPaymentMethods> = LazyLock::new(|| {
let mut payload_supported_payment_methods = SupportedPaymentMethods::new();
let supported_capture_methods = vec![
enums::CaptureMethod::Automatic,
enums::CaptureMethod::Manual,
enums::CaptureMethod::SequentialAutomatic,
];
let supported_card_network = vec![
common_enums::CardNetwork::AmericanExpress,
common_enums::CardNetwork::Discover,
common_enums::CardNetwork::Mastercard,
common_enums::CardNetwork::Visa,
];
payload_supported_payment_methods.add(
enums::PaymentMethod::Card,
enums::PaymentMethodType::Credit,
PaymentMethodDetails {
mandates: enums::FeatureStatus::Supported,
refunds: enums::FeatureStatus::Supported,
supported_capture_methods: supported_capture_methods.clone(),
specific_features: Some(
api_models::feature_matrix::PaymentMethodSpecificFeatures::Card({
api_models::feature_matrix::CardSpecificFeatures {
three_ds: common_enums::FeatureStatus::NotSupported,
no_three_ds: common_enums::FeatureStatus::Supported,
supported_card_networks: supported_card_network.clone(),
}
}),
),
},
);
payload_supported_payment_methods.add(
enums::PaymentMethod::Card,
enums::PaymentMethodType::Debit,
PaymentMethodDetails {
mandates: enums::FeatureStatus::Supported,
refunds: enums::FeatureStatus::Supported,
supported_capture_methods: supported_capture_methods.clone(),
specific_features: Some(
api_models::feature_matrix::PaymentMethodSpecificFeatures::Card({
api_models::feature_matrix::CardSpecificFeatures {
three_ds: common_enums::FeatureStatus::NotSupported,
no_three_ds: common_enums::FeatureStatus::Supported,
supported_card_networks: supported_card_network.clone(),
}
}),
),
},
);
payload_supported_payment_methods
});
static PAYLOAD_CONNECTOR_INFO: ConnectorInfo = ConnectorInfo {
display_name: "Payload",
description: "Payload is an embedded finance solution for modern platforms and businesses, automating inbound and outbound payments with an industry-leading platform and driving innovation into the future.",
connector_type: enums::HyperswitchConnectorCategory::PaymentGateway,
integration_status: enums::ConnectorIntegrationStatus::Alpha,
};
static PAYLOAD_SUPPORTED_WEBHOOK_FLOWS: [enums::EventClass; 3] = [
enums::EventClass::Disputes,
enums::EventClass::Payments,
enums::EventClass::Refunds,
];
impl ConnectorSpecifications for Payload {
fn get_connector_about(&self) -> Option<&'static ConnectorInfo> {
Some(&PAYLOAD_CONNECTOR_INFO)
}
fn get_supported_payment_methods(&self) -> Option<&'static SupportedPaymentMethods> {
Some(&*PAYLOAD_SUPPORTED_PAYMENT_METHODS)
}
fn get_supported_webhook_flows(&self) -> Option<&'static [enums::EventClass]> {
Some(&PAYLOAD_SUPPORTED_WEBHOOK_FLOWS)
}
}
|
{
"crate": "hyperswitch_connectors",
"file": "crates/hyperswitch_connectors/src/connectors/payload.rs",
"file_size": null,
"is_async": null,
"is_pub": null,
"num_enums": 0,
"num_structs": 1,
"num_tables": null,
"score": null,
"total_crates": null
}
|
file_hyperswitch_connectors_-8613997991046475660
|
clm
|
file
|
// Repository: hyperswitch
// Crate: hyperswitch_connectors
// File: crates/hyperswitch_connectors/src/connectors/mpgs.rs
// Contains: 1 structs, 0 enums
pub mod transformers;
use std::sync::LazyLock;
use common_enums::enums;
use common_utils::{
errors::CustomResult,
ext_traits::BytesExt,
request::{Method, Request, RequestBuilder, RequestContent},
types::{AmountConvertor, StringMinorUnit, StringMinorUnitForConnector},
};
use error_stack::{report, ResultExt};
use hyperswitch_domain_models::{
payment_method_data::PaymentMethodData,
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::{
ConnectorInfo, PaymentsResponseData, RefundsResponseData, SupportedPaymentMethods,
},
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 masking::{ExposeInterface, Mask};
use transformers as mpgs;
use crate::{constants::headers, types::ResponseRouterData, utils};
#[derive(Clone)]
pub struct Mpgs {
amount_converter: &'static (dyn AmountConvertor<Output = StringMinorUnit> + Sync),
}
impl Mpgs {
pub fn new() -> &'static Self {
&Self {
amount_converter: &StringMinorUnitForConnector,
}
}
}
impl api::Payment for Mpgs {}
impl api::PaymentSession for Mpgs {}
impl api::ConnectorAccessToken for Mpgs {}
impl api::MandateSetup for Mpgs {}
impl api::PaymentAuthorize for Mpgs {}
impl api::PaymentSync for Mpgs {}
impl api::PaymentCapture for Mpgs {}
impl api::PaymentVoid for Mpgs {}
impl api::Refund for Mpgs {}
impl api::RefundExecute for Mpgs {}
impl api::RefundSync for Mpgs {}
impl api::PaymentToken for Mpgs {}
impl ConnectorIntegration<PaymentMethodToken, PaymentMethodTokenizationData, PaymentsResponseData>
for Mpgs
{
// Not Implemented (R)
}
impl<Flow, Request, Response> ConnectorCommonExt<Flow, Request, Response> for Mpgs
where
Self: ConnectorIntegration<Flow, Request, Response>,
{
fn build_headers(
&self,
req: &RouterData<Flow, Request, Response>,
_connectors: &Connectors,
) -> CustomResult<Vec<(String, masking::Maskable<String>)>, errors::ConnectorError> {
let mut header = vec![(
headers::CONTENT_TYPE.to_string(),
self.get_content_type().to_string().into(),
)];
let mut api_key = self.get_auth_header(&req.connector_auth_type)?;
header.append(&mut api_key);
Ok(header)
}
}
impl ConnectorCommon for Mpgs {
fn id(&self) -> &'static str {
"mpgs"
}
fn get_currency_unit(&self) -> api::CurrencyUnit {
api::CurrencyUnit::Minor
// TODO! Check connector documentation, on which unit they are processing the currency.
// If the connector accepts amount in lower unit ( i.e cents for USD) then return api::CurrencyUnit::Minor,
// if connector accepts amount in base unit (i.e dollars for USD) then return api::CurrencyUnit::Base
}
fn common_get_content_type(&self) -> &'static str {
"application/json"
}
fn base_url<'a>(&self, connectors: &'a Connectors) -> &'a str {
connectors.mpgs.base_url.as_ref()
}
fn get_auth_header(
&self,
auth_type: &ConnectorAuthType,
) -> CustomResult<Vec<(String, masking::Maskable<String>)>, errors::ConnectorError> {
let auth = mpgs::MpgsAuthType::try_from(auth_type)
.change_context(errors::ConnectorError::FailedToObtainAuthType)?;
Ok(vec![(
headers::AUTHORIZATION.to_string(),
auth.api_key.expose().into_masked(),
)])
}
fn build_error_response(
&self,
res: Response,
event_builder: Option<&mut ConnectorEvent>,
) -> CustomResult<ErrorResponse, errors::ConnectorError> {
let response: mpgs::MpgsErrorResponse = res
.response
.parse_struct("MpgsErrorResponse")
.change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
event_builder.map(|i| i.set_response_body(&response));
router_env::logger::info!(connector_response=?response);
Ok(ErrorResponse {
status_code: res.status_code,
code: response.code,
message: response.message,
reason: response.reason,
attempt_status: None,
connector_transaction_id: None,
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
connector_metadata: None,
})
}
}
impl ConnectorValidation for Mpgs {
fn validate_mandate_payment(
&self,
_pm_type: Option<enums::PaymentMethodType>,
pm_data: PaymentMethodData,
) -> CustomResult<(), errors::ConnectorError> {
match pm_data {
PaymentMethodData::Card(_) => Err(errors::ConnectorError::NotImplemented(
"validate_mandate_payment does not support cards".to_string(),
)
.into()),
_ => Ok(()),
}
}
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> {
Ok(())
}
}
impl ConnectorIntegration<Session, PaymentsSessionData, PaymentsResponseData> for Mpgs {
//TODO: implement sessions flow
}
impl ConnectorIntegration<AccessTokenAuth, AccessTokenRequestData, AccessToken> for Mpgs {}
impl ConnectorIntegration<SetupMandate, SetupMandateRequestData, PaymentsResponseData> for Mpgs {}
impl ConnectorIntegration<Authorize, PaymentsAuthorizeData, PaymentsResponseData> for Mpgs {
fn get_headers(
&self,
req: &PaymentsAuthorizeRouterData,
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: &PaymentsAuthorizeRouterData,
_connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
Err(errors::ConnectorError::NotImplemented("get_url method".to_string()).into())
}
fn get_request_body(
&self,
req: &PaymentsAuthorizeRouterData,
_connectors: &Connectors,
) -> CustomResult<RequestContent, errors::ConnectorError> {
let amount = utils::convert_amount(
self.amount_converter,
req.request.minor_amount,
req.request.currency,
)?;
let connector_router_data = mpgs::MpgsRouterData::from((amount, req));
let connector_req = mpgs::MpgsPaymentsRequest::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> {
Ok(Some(
RequestBuilder::new()
.method(Method::Post)
.url(&types::PaymentsAuthorizeType::get_url(
self, req, connectors,
)?)
.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: mpgs::MpgsPaymentsResponse = res
.response
.parse_struct("Mpgs 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,
})
}
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<PSync, PaymentsSyncData, PaymentsResponseData> for Mpgs {
fn get_headers(
&self,
req: &PaymentsSyncRouterData,
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: &PaymentsSyncRouterData,
_connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
Err(errors::ConnectorError::NotImplemented("get_url method".to_string()).into())
}
fn build_request(
&self,
req: &PaymentsSyncRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Ok(Some(
RequestBuilder::new()
.method(Method::Get)
.url(&types::PaymentsSyncType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(types::PaymentsSyncType::get_headers(self, req, connectors)?)
.build(),
))
}
fn handle_response(
&self,
data: &PaymentsSyncRouterData,
event_builder: Option<&mut ConnectorEvent>,
res: Response,
) -> CustomResult<PaymentsSyncRouterData, errors::ConnectorError> {
let response: mpgs::MpgsPaymentsResponse = res
.response
.parse_struct("mpgs PaymentsSyncResponse")
.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,
})
}
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 Mpgs {
fn get_headers(
&self,
req: &PaymentsCaptureRouterData,
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: &PaymentsCaptureRouterData,
_connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
Err(errors::ConnectorError::NotImplemented("get_url method".to_string()).into())
}
fn get_request_body(
&self,
_req: &PaymentsCaptureRouterData,
_connectors: &Connectors,
) -> CustomResult<RequestContent, errors::ConnectorError> {
Err(errors::ConnectorError::NotImplemented("get_request_body method".to_string()).into())
}
fn build_request(
&self,
req: &PaymentsCaptureRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Ok(Some(
RequestBuilder::new()
.method(Method::Post)
.url(&types::PaymentsCaptureType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(types::PaymentsCaptureType::get_headers(
self, req, connectors,
)?)
.set_body(types::PaymentsCaptureType::get_request_body(
self, req, connectors,
)?)
.build(),
))
}
fn handle_response(
&self,
data: &PaymentsCaptureRouterData,
event_builder: Option<&mut ConnectorEvent>,
res: Response,
) -> CustomResult<PaymentsCaptureRouterData, errors::ConnectorError> {
let response: mpgs::MpgsPaymentsResponse = res
.response
.parse_struct("Mpgs PaymentsCaptureResponse")
.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,
})
}
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<Void, PaymentsCancelData, PaymentsResponseData> for Mpgs {}
impl ConnectorIntegration<Execute, RefundsData, RefundsResponseData> for Mpgs {
fn get_headers(
&self,
req: &RefundsRouterData<Execute>,
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: &RefundsRouterData<Execute>,
_connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
Err(errors::ConnectorError::NotImplemented("get_url method".to_string()).into())
}
fn get_request_body(
&self,
req: &RefundsRouterData<Execute>,
_connectors: &Connectors,
) -> CustomResult<RequestContent, errors::ConnectorError> {
let refund_amount = utils::convert_amount(
self.amount_converter,
req.request.minor_refund_amount,
req.request.currency,
)?;
let connector_router_data = mpgs::MpgsRouterData::from((refund_amount, req));
let connector_req = mpgs::MpgsRefundRequest::try_from(&connector_router_data)?;
Ok(RequestContent::Json(Box::new(connector_req)))
}
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))
}
fn handle_response(
&self,
data: &RefundsRouterData<Execute>,
event_builder: Option<&mut ConnectorEvent>,
res: Response,
) -> CustomResult<RefundsRouterData<Execute>, errors::ConnectorError> {
let response: mpgs::RefundResponse = res
.response
.parse_struct("mpgs RefundResponse")
.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,
})
}
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<RSync, RefundsData, RefundsResponseData> for Mpgs {
fn get_headers(
&self,
req: &RefundSyncRouterData,
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: &RefundSyncRouterData,
_connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
Err(errors::ConnectorError::NotImplemented("get_url method".to_string()).into())
}
fn build_request(
&self,
req: &RefundSyncRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Ok(Some(
RequestBuilder::new()
.method(Method::Get)
.url(&types::RefundSyncType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(types::RefundSyncType::get_headers(self, req, connectors)?)
.set_body(types::RefundSyncType::get_request_body(
self, req, connectors,
)?)
.build(),
))
}
fn handle_response(
&self,
data: &RefundSyncRouterData,
event_builder: Option<&mut ConnectorEvent>,
res: Response,
) -> CustomResult<RefundSyncRouterData, errors::ConnectorError> {
let response: mpgs::RefundResponse =
res.response
.parse_struct("mpgs RefundSyncResponse")
.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,
})
}
fn get_error_response(
&self,
res: Response,
event_builder: Option<&mut ConnectorEvent>,
) -> CustomResult<ErrorResponse, errors::ConnectorError> {
self.build_error_response(res, event_builder)
}
}
#[async_trait::async_trait]
impl webhooks::IncomingWebhook for Mpgs {
fn get_webhook_object_reference_id(
&self,
_request: &webhooks::IncomingWebhookRequestDetails<'_>,
) -> CustomResult<api_models::webhooks::ObjectReferenceId, errors::ConnectorError> {
Err(report!(errors::ConnectorError::WebhooksNotImplemented))
}
fn get_webhook_event_type(
&self,
_request: &webhooks::IncomingWebhookRequestDetails<'_>,
) -> CustomResult<api_models::webhooks::IncomingWebhookEvent, errors::ConnectorError> {
Err(report!(errors::ConnectorError::WebhooksNotImplemented))
}
fn get_webhook_resource_object(
&self,
_request: &webhooks::IncomingWebhookRequestDetails<'_>,
) -> CustomResult<Box<dyn masking::ErasedMaskSerialize>, errors::ConnectorError> {
Err(report!(errors::ConnectorError::WebhooksNotImplemented))
}
}
static MPGS_SUPPORTED_PAYMENT_METHODS: LazyLock<SupportedPaymentMethods> =
LazyLock::new(SupportedPaymentMethods::new);
static MPGS_CONNECTOR_INFO: ConnectorInfo = ConnectorInfo {
display_name: "Mpgs",
description: "Mpgs connector",
connector_type: enums::HyperswitchConnectorCategory::PaymentGateway,
integration_status: enums::ConnectorIntegrationStatus::Alpha,
};
static MPGS_SUPPORTED_WEBHOOK_FLOWS: [enums::EventClass; 0] = [];
impl ConnectorSpecifications for Mpgs {
fn get_connector_about(&self) -> Option<&'static ConnectorInfo> {
Some(&MPGS_CONNECTOR_INFO)
}
fn get_supported_payment_methods(&self) -> Option<&'static SupportedPaymentMethods> {
Some(&*MPGS_SUPPORTED_PAYMENT_METHODS)
}
fn get_supported_webhook_flows(&self) -> Option<&'static [enums::EventClass]> {
Some(&MPGS_SUPPORTED_WEBHOOK_FLOWS)
}
}
|
{
"crate": "hyperswitch_connectors",
"file": "crates/hyperswitch_connectors/src/connectors/mpgs.rs",
"file_size": null,
"is_async": null,
"is_pub": null,
"num_enums": 0,
"num_structs": 1,
"num_tables": null,
"score": null,
"total_crates": null
}
|
file_hyperswitch_connectors_-4128970368392066938
|
clm
|
file
|
// Repository: hyperswitch
// Crate: hyperswitch_connectors
// File: crates/hyperswitch_connectors/src/connectors/trustpay.rs
// Contains: 1 structs, 0 enums
pub mod transformers;
use std::sync::LazyLock;
use base64::Engine;
use common_enums::{enums, PaymentAction};
use common_utils::{
crypto,
errors::{CustomResult, ReportSwitchExt},
ext_traits::ByteSliceExt,
request::{Method, Request, RequestBuilder, RequestContent},
types::{
AmountConvertor, FloatMajorUnit, FloatMajorUnitForConnector, StringMajorUnit,
StringMajorUnitForConnector, StringMinorUnit, StringMinorUnitForConnector,
},
};
use error_stack::{Report, ResultExt};
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},
PreProcessing,
},
router_request_types::{
AccessTokenRequestData, PaymentMethodTokenizationData, PaymentsAuthorizeData,
PaymentsCancelData, PaymentsCaptureData, PaymentsPreProcessingData, PaymentsSessionData,
PaymentsSyncData, RefundsData, SetupMandateRequestData,
},
router_response_types::{
ConnectorInfo, PaymentMethodDetails, PaymentsResponseData, RefundsResponseData,
SupportedPaymentMethods, SupportedPaymentMethodsExt,
},
types::{
PaymentsAuthorizeRouterData, PaymentsPreProcessingRouterData, PaymentsSyncRouterData,
RefreshTokenRouterData, RefundSyncRouterData, RefundsRouterData,
},
};
use hyperswitch_interfaces::{
api::{
self, ConnectorCommon, ConnectorCommonExt, ConnectorIntegration, ConnectorRedirectResponse,
ConnectorSpecifications, ConnectorValidation,
},
configs::Connectors,
consts,
disputes::DisputePayload,
errors,
events::connector_api_logs::ConnectorEvent,
types::{
PaymentsAuthorizeType, PaymentsPreProcessingType, PaymentsSyncType, RefreshTokenType,
RefundExecuteType, RefundSyncType, Response,
},
webhooks,
};
use masking::{Mask, PeekInterface};
use transformers as trustpay;
use crate::{
constants::headers,
types::ResponseRouterData,
utils::{self, self as connector_utils, ConnectorErrorType, PaymentsPreProcessingRequestData},
};
#[derive(Clone)]
pub struct Trustpay {
amount_converter: &'static (dyn AmountConvertor<Output = StringMajorUnit> + Sync),
amount_converter_to_float_major_unit:
&'static (dyn AmountConvertor<Output = FloatMajorUnit> + Sync),
amount_converter_to_string_minor_unit:
&'static (dyn AmountConvertor<Output = StringMinorUnit> + Sync),
}
impl Trustpay {
pub fn new() -> &'static Self {
&Self {
amount_converter: &StringMajorUnitForConnector,
amount_converter_to_float_major_unit: &FloatMajorUnitForConnector,
amount_converter_to_string_minor_unit: &StringMinorUnitForConnector,
}
}
}
impl<Flow, Request, Response> ConnectorCommonExt<Flow, Request, Response> for Trustpay
where
Self: ConnectorIntegration<Flow, Request, Response>,
{
fn build_headers(
&self,
req: &RouterData<Flow, Request, Response>,
_connectors: &Connectors,
) -> CustomResult<Vec<(String, masking::Maskable<String>)>, errors::ConnectorError> {
match req.payment_method {
enums::PaymentMethod::BankRedirect | enums::PaymentMethod::BankTransfer => {
let token = req
.access_token
.clone()
.ok_or(errors::ConnectorError::FailedToObtainAuthType)?;
Ok(vec![
(
headers::CONTENT_TYPE.to_string(),
"application/json".to_owned().into(),
),
(
headers::AUTHORIZATION.to_string(),
format!("Bearer {}", token.token.peek()).into_masked(),
),
])
}
_ => {
let mut header = vec![(
headers::CONTENT_TYPE.to_string(),
self.get_content_type().to_string().into(),
)];
let mut api_key = self.get_auth_header(&req.connector_auth_type)?;
header.append(&mut api_key);
Ok(header)
}
}
}
}
impl ConnectorCommon for Trustpay {
fn id(&self) -> &'static str {
"trustpay"
}
fn get_currency_unit(&self) -> api::CurrencyUnit {
api::CurrencyUnit::Base
}
fn common_get_content_type(&self) -> &'static str {
"application/x-www-form-urlencoded"
}
fn base_url<'a>(&self, connectors: &'a Connectors) -> &'a str {
connectors.trustpay.base_url.as_ref()
}
fn get_auth_header(
&self,
auth_type: &ConnectorAuthType,
) -> CustomResult<Vec<(String, masking::Maskable<String>)>, errors::ConnectorError> {
let auth = trustpay::TrustpayAuthType::try_from(auth_type)
.change_context(errors::ConnectorError::FailedToObtainAuthType)?;
Ok(vec![(
headers::X_API_KEY.to_string(),
auth.api_key.into_masked(),
)])
}
fn build_error_response(
&self,
res: Response,
event_builder: Option<&mut ConnectorEvent>,
) -> CustomResult<ErrorResponse, errors::ConnectorError> {
let response: Result<
trustpay::TrustpayErrorResponse,
Report<common_utils::errors::ParsingError>,
> = res.response.parse_struct("trustpay ErrorResponse");
match response {
Ok(response_data) => {
event_builder.map(|i| i.set_error_response_body(&response_data));
router_env::logger::info!(connector_response=?response_data);
let error_list = response_data.errors.clone().unwrap_or_default();
let option_error_code_message =
utils::get_error_code_error_message_based_on_priority(
self.clone(),
error_list.into_iter().map(|errors| errors.into()).collect(),
);
let reason = response_data.errors.map(|errors| {
errors
.iter()
.map(|error| error.description.clone())
.collect::<Vec<String>>()
.join(" & ")
});
Ok(ErrorResponse {
status_code: res.status_code,
code: option_error_code_message
.clone()
.map(|error_code_message| error_code_message.error_code)
.unwrap_or(consts::NO_ERROR_CODE.to_string()),
// message vary for the same code, so relying on code alone as it is unique
message: option_error_code_message
.map(|error_code_message| error_code_message.error_code)
.unwrap_or(consts::NO_ERROR_MESSAGE.to_string()),
reason: reason
.or(response_data.description)
.or(response_data.payment_description),
attempt_status: None,
connector_transaction_id: response_data.instance_id,
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
connector_metadata: None,
})
}
Err(error_msg) => {
event_builder.map(|event| event.set_error(serde_json::json!({"error": res.response.escape_ascii().to_string(), "status_code": res.status_code})));
router_env::logger::error!(deserialization_error =? error_msg);
utils::handle_json_response_deserialization_failure(res, "trustpay")
}
}
}
}
impl ConnectorValidation for Trustpay {}
impl api::Payment for Trustpay {}
impl api::PaymentToken for Trustpay {}
impl ConnectorIntegration<PaymentMethodToken, PaymentMethodTokenizationData, PaymentsResponseData>
for Trustpay
{
// Not Implemented (R)
}
impl api::MandateSetup for Trustpay {}
impl ConnectorIntegration<SetupMandate, SetupMandateRequestData, PaymentsResponseData>
for Trustpay
{
fn build_request(
&self,
_req: &RouterData<SetupMandate, SetupMandateRequestData, PaymentsResponseData>,
_connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Err(
errors::ConnectorError::NotImplemented("Setup Mandate flow for Trustpay".to_string())
.into(),
)
}
}
impl api::PaymentVoid for Trustpay {}
impl ConnectorIntegration<Void, PaymentsCancelData, PaymentsResponseData> for Trustpay {}
impl api::ConnectorAccessToken for Trustpay {}
impl ConnectorIntegration<AccessTokenAuth, AccessTokenRequestData, AccessToken> for Trustpay {
fn get_url(
&self,
_req: &RefreshTokenRouterData,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
Ok(format!(
"{}{}",
connectors.trustpay.base_url_bank_redirects, "api/oauth2/token"
))
}
fn get_content_type(&self) -> &'static str {
self.common_get_content_type()
}
fn get_headers(
&self,
req: &RefreshTokenRouterData,
_connectors: &Connectors,
) -> CustomResult<Vec<(String, masking::Maskable<String>)>, errors::ConnectorError> {
let auth = trustpay::TrustpayAuthType::try_from(&req.connector_auth_type)
.change_context(errors::ConnectorError::FailedToObtainAuthType)?;
let auth_value = auth
.project_id
.zip(auth.secret_key)
.map(|(project_id, secret_key)| {
format!(
"Basic {}",
common_utils::consts::BASE64_ENGINE
.encode(format!("{project_id}:{secret_key}"))
)
});
Ok(vec![
(
headers::CONTENT_TYPE.to_string(),
RefreshTokenType::get_content_type(self).to_string().into(),
),
(headers::AUTHORIZATION.to_string(), auth_value.into_masked()),
])
}
fn get_request_body(
&self,
req: &RefreshTokenRouterData,
_connectors: &Connectors,
) -> CustomResult<RequestContent, errors::ConnectorError> {
let connector_req = trustpay::TrustpayAuthUpdateRequest::try_from(req)?;
Ok(RequestContent::FormUrlEncoded(Box::new(connector_req)))
}
fn build_request(
&self,
req: &RefreshTokenRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
let req = Some(
RequestBuilder::new()
.method(Method::Post)
.attach_default_headers()
.headers(RefreshTokenType::get_headers(self, req, connectors)?)
.url(&RefreshTokenType::get_url(self, req, connectors)?)
.set_body(RefreshTokenType::get_request_body(self, req, connectors)?)
.build(),
);
Ok(req)
}
fn handle_response(
&self,
data: &RefreshTokenRouterData,
event_builder: Option<&mut ConnectorEvent>,
res: Response,
) -> CustomResult<RefreshTokenRouterData, errors::ConnectorError> {
let response: trustpay::TrustpayAuthUpdateResponse = res
.response
.parse_struct("trustpay TrustpayAuthUpdateResponse")
.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,
})
.change_context(errors::ConnectorError::ResponseHandlingFailed)
}
fn get_error_response(
&self,
res: Response,
event_builder: Option<&mut ConnectorEvent>,
) -> CustomResult<ErrorResponse, errors::ConnectorError> {
let response: trustpay::TrustpayAccessTokenErrorResponse = res
.response
.parse_struct("Trustpay AccessTokenErrorResponse")
.change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
event_builder.map(|i| i.set_response_body(&response));
router_env::logger::info!(connector_response=?response);
Ok(ErrorResponse {
status_code: res.status_code,
code: response.result_info.result_code.to_string(),
// message vary for the same code, so relying on code alone as it is unique
message: response.result_info.result_code.to_string(),
reason: response.result_info.additional_info,
attempt_status: None,
connector_transaction_id: None,
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
connector_metadata: None,
})
}
}
impl api::PaymentSync for Trustpay {}
impl ConnectorIntegration<PSync, PaymentsSyncData, PaymentsResponseData> for Trustpay {
fn get_headers(
&self,
req: &PaymentsSyncRouterData,
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: &PaymentsSyncRouterData,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
let id = req.request.connector_transaction_id.clone();
match req.payment_method {
enums::PaymentMethod::BankRedirect | enums::PaymentMethod::BankTransfer => Ok(format!(
"{}{}/{}",
connectors.trustpay.base_url_bank_redirects,
"api/Payments/Payment",
id.get_connector_transaction_id()
.change_context(errors::ConnectorError::MissingConnectorTransactionID)?
)),
_ => Ok(format!(
"{}{}/{}",
self.base_url(connectors),
"api/v1/instance",
id.get_connector_transaction_id()
.change_context(errors::ConnectorError::MissingConnectorTransactionID)?
)),
}
}
fn build_request(
&self,
req: &PaymentsSyncRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Ok(Some(
RequestBuilder::new()
.method(Method::Get)
.url(&PaymentsSyncType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(PaymentsSyncType::get_headers(self, req, connectors)?)
.build(),
))
}
fn get_error_response(
&self,
res: Response,
event_builder: Option<&mut ConnectorEvent>,
) -> CustomResult<ErrorResponse, errors::ConnectorError> {
self.build_error_response(res, event_builder)
}
fn handle_response(
&self,
data: &PaymentsSyncRouterData,
event_builder: Option<&mut ConnectorEvent>,
res: Response,
) -> CustomResult<PaymentsSyncRouterData, errors::ConnectorError> {
let response: trustpay::TrustpayPaymentsResponse = res
.response
.parse_struct("trustpay PaymentsResponse")
.change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
match &response {
trustpay::TrustpayPaymentsResponse::WebhookResponse(webhook_response) => {
let response_integrity_object = connector_utils::get_sync_integrity_object(
self.amount_converter_to_float_major_unit,
webhook_response.amount.amount,
webhook_response.amount.currency.to_string(),
)?;
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,
})
.map(|mut router_data| {
router_data.request.integrity_object = Some(response_integrity_object);
router_data
})
.change_context(errors::ConnectorError::ResponseHandlingFailed)
}
trustpay::TrustpayPaymentsResponse::BankRedirectSync(bank_redirect_sync_response) => {
let response_integrity_object = connector_utils::get_sync_integrity_object(
self.amount_converter_to_float_major_unit,
bank_redirect_sync_response
.payment_information
.amount
.amount,
bank_redirect_sync_response
.payment_information
.amount
.currency
.to_string(),
)?;
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,
})
.map(|mut router_data| {
router_data.request.integrity_object = Some(response_integrity_object);
router_data
})
.change_context(errors::ConnectorError::ResponseHandlingFailed)
}
_ => {
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,
})
.change_context(errors::ConnectorError::ResponseHandlingFailed)
}
}
}
}
impl api::PaymentCapture for Trustpay {}
impl ConnectorIntegration<Capture, PaymentsCaptureData, PaymentsResponseData> for Trustpay {}
impl api::PaymentsPreProcessing for Trustpay {}
impl ConnectorIntegration<PreProcessing, PaymentsPreProcessingData, PaymentsResponseData>
for Trustpay
{
fn get_headers(
&self,
req: &PaymentsPreProcessingRouterData,
_connectors: &Connectors,
) -> CustomResult<Vec<(String, masking::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_content_type(&self) -> &'static str {
self.common_get_content_type()
}
fn get_url(
&self,
_req: &PaymentsPreProcessingRouterData,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
Ok(format!("{}{}", self.base_url(connectors), "api/v1/intent"))
}
fn get_request_body(
&self,
req: &PaymentsPreProcessingRouterData,
_connectors: &Connectors,
) -> CustomResult<RequestContent, errors::ConnectorError> {
let req_currency = req.request.get_currency()?;
let req_amount = req.request.get_minor_amount()?;
let amount = utils::convert_amount(self.amount_converter, req_amount, req_currency)?;
let connector_router_data = trustpay::TrustpayRouterData::try_from((amount, req))?;
let connector_req =
trustpay::TrustpayCreateIntentRequest::try_from(&connector_router_data)?;
Ok(RequestContent::FormUrlEncoded(Box::new(connector_req)))
}
fn build_request(
&self,
req: &PaymentsPreProcessingRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
let req = Some(
RequestBuilder::new()
.method(Method::Post)
.attach_default_headers()
.headers(PaymentsPreProcessingType::get_headers(
self, req, connectors,
)?)
.url(&PaymentsPreProcessingType::get_url(self, req, connectors)?)
.set_body(PaymentsPreProcessingType::get_request_body(
self, req, connectors,
)?)
.build(),
);
Ok(req)
}
fn handle_response(
&self,
data: &PaymentsPreProcessingRouterData,
event_builder: Option<&mut ConnectorEvent>,
res: Response,
) -> CustomResult<PaymentsPreProcessingRouterData, errors::ConnectorError> {
let response: trustpay::TrustpayCreateIntentResponse = res
.response
.parse_struct("TrustpayCreateIntentResponse")
.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,
})
.change_context(errors::ConnectorError::ResponseHandlingFailed)
}
fn get_error_response(
&self,
res: Response,
event_builder: Option<&mut ConnectorEvent>,
) -> CustomResult<ErrorResponse, errors::ConnectorError> {
self.build_error_response(res, event_builder)
}
}
impl api::PaymentSession for Trustpay {}
impl ConnectorIntegration<Session, PaymentsSessionData, PaymentsResponseData> for Trustpay {}
impl api::PaymentAuthorize for Trustpay {}
impl ConnectorIntegration<Authorize, PaymentsAuthorizeData, PaymentsResponseData> for Trustpay {
fn get_headers(
&self,
req: &PaymentsAuthorizeRouterData,
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: &PaymentsAuthorizeRouterData,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
match req.payment_method {
enums::PaymentMethod::BankRedirect | enums::PaymentMethod::BankTransfer => Ok(format!(
"{}{}",
connectors.trustpay.base_url_bank_redirects, "api/Payments/Payment"
)),
_ => Ok(format!(
"{}{}",
self.base_url(connectors),
"api/v1/purchase"
)),
}
}
fn get_request_body(
&self,
req: &PaymentsAuthorizeRouterData,
_connectors: &Connectors,
) -> CustomResult<RequestContent, errors::ConnectorError> {
let amount = utils::convert_amount(
self.amount_converter,
req.request.minor_amount,
req.request.currency,
)?;
let connector_router_data = trustpay::TrustpayRouterData::try_from((amount, req))?;
let connector_req = trustpay::TrustpayPaymentsRequest::try_from(&connector_router_data)?;
match req.payment_method {
enums::PaymentMethod::BankRedirect | enums::PaymentMethod::BankTransfer => {
Ok(RequestContent::Json(Box::new(connector_req)))
}
_ => Ok(RequestContent::FormUrlEncoded(Box::new(connector_req))),
}
}
fn build_request(
&self,
req: &PaymentsAuthorizeRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Ok(Some(
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: trustpay::TrustpayPaymentsResponse = res
.response
.parse_struct("trustpay PaymentsResponse")
.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,
})
.change_context(errors::ConnectorError::ResponseHandlingFailed)
}
fn get_error_response(
&self,
res: Response,
event_builder: Option<&mut ConnectorEvent>,
) -> CustomResult<ErrorResponse, errors::ConnectorError> {
self.build_error_response(res, event_builder)
}
}
impl api::Refund for Trustpay {}
impl api::RefundExecute for Trustpay {}
impl api::RefundSync for Trustpay {}
impl ConnectorIntegration<Execute, RefundsData, RefundsResponseData> for Trustpay {
fn get_headers(
&self,
req: &RefundsRouterData<Execute>,
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: &RefundsRouterData<Execute>,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
match req.payment_method {
enums::PaymentMethod::BankRedirect | enums::PaymentMethod::BankTransfer => Ok(format!(
"{}{}{}{}",
connectors.trustpay.base_url_bank_redirects,
"api/Payments/Payment/",
req.request.connector_transaction_id,
"/Refund"
)),
_ => Ok(format!("{}{}", self.base_url(connectors), "api/v1/Refund")),
}
}
fn get_request_body(
&self,
req: &RefundsRouterData<Execute>,
_connectors: &Connectors,
) -> CustomResult<RequestContent, errors::ConnectorError> {
let amount = utils::convert_amount(
self.amount_converter,
req.request.minor_refund_amount,
req.request.currency,
)?;
let connector_router_data = trustpay::TrustpayRouterData::try_from((amount, req))?;
let connector_req = trustpay::TrustpayRefundRequest::try_from(&connector_router_data)?;
match req.payment_method {
enums::PaymentMethod::BankRedirect | enums::PaymentMethod::BankTransfer => {
Ok(RequestContent::Json(Box::new(connector_req)))
}
_ => Ok(RequestContent::FormUrlEncoded(Box::new(connector_req))),
}
}
fn build_request(
&self,
req: &RefundsRouterData<Execute>,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
let request = RequestBuilder::new()
.method(Method::Post)
.url(&RefundExecuteType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(RefundExecuteType::get_headers(self, req, connectors)?)
.set_body(RefundExecuteType::get_request_body(self, req, connectors)?)
.build();
Ok(Some(request))
}
fn handle_response(
&self,
data: &RefundsRouterData<Execute>,
event_builder: Option<&mut ConnectorEvent>,
res: Response,
) -> CustomResult<RefundsRouterData<Execute>, errors::ConnectorError> {
let response: trustpay::RefundResponse = res
.response
.parse_struct("trustpay RefundResponse")
.change_context(errors::ConnectorError::RequestEncodingFailed)?;
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,
})
.change_context(errors::ConnectorError::ResponseHandlingFailed)
}
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<RSync, RefundsData, RefundsResponseData> for Trustpay {
fn get_headers(
&self,
req: &RefundSyncRouterData,
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: &RefundSyncRouterData,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
let id = req
.request
.connector_refund_id
.to_owned()
.ok_or(errors::ConnectorError::MissingConnectorRefundID)?;
match req.payment_method {
enums::PaymentMethod::BankRedirect | enums::PaymentMethod::BankTransfer => Ok(format!(
"{}{}/{}",
connectors.trustpay.base_url_bank_redirects, "api/Payments/Payment", id
)),
_ => Ok(format!(
"{}{}/{}",
self.base_url(connectors),
"api/v1/instance",
id
)),
}
}
fn build_request(
&self,
req: &RefundSyncRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Ok(Some(
RequestBuilder::new()
.method(Method::Get)
.url(&RefundSyncType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(RefundSyncType::get_headers(self, req, connectors)?)
.build(),
))
}
fn handle_response(
&self,
data: &RefundSyncRouterData,
event_builder: Option<&mut ConnectorEvent>,
res: Response,
) -> CustomResult<RefundSyncRouterData, errors::ConnectorError> {
let response: trustpay::RefundResponse = res
.response
.parse_struct("trustpay RefundResponse")
.change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
if let trustpay::RefundResponse::WebhookRefund(ref webhook_response) = response {
let response_integrity_object = connector_utils::get_refund_integrity_object(
self.amount_converter_to_float_major_unit,
webhook_response.amount.amount,
webhook_response.amount.currency.to_string(),
)?;
event_builder.map(|i| i.set_response_body(&response));
router_env::logger::info!(connector_response=?response);
let new_router_data = RouterData::try_from(ResponseRouterData {
response,
data: data.clone(),
http_code: res.status_code,
});
return new_router_data
.map(|mut router_data| {
router_data.request.integrity_object = Some(response_integrity_object);
router_data
})
.change_context(errors::ConnectorError::ResponseHandlingFailed);
}
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,
})
.change_context(errors::ConnectorError::ResponseHandlingFailed)
}
fn get_error_response(
&self,
res: Response,
event_builder: Option<&mut ConnectorEvent>,
) -> CustomResult<ErrorResponse, errors::ConnectorError> {
self.build_error_response(res, event_builder)
}
}
#[async_trait::async_trait]
impl webhooks::IncomingWebhook for Trustpay {
fn get_webhook_object_reference_id(
&self,
request: &webhooks::IncomingWebhookRequestDetails<'_>,
) -> CustomResult<api_models::webhooks::ObjectReferenceId, errors::ConnectorError> {
let details: trustpay::TrustpayWebhookResponse = request
.body
.parse_struct("TrustpayWebhookResponse")
.switch()?;
let payment_attempt_id = details
.payment_information
.references
.merchant_reference
.ok_or(errors::ConnectorError::WebhookReferenceIdNotFound)?;
match details.payment_information.credit_debit_indicator {
trustpay::CreditDebitIndicator::Crdt => {
Ok(api_models::webhooks::ObjectReferenceId::PaymentId(
api_models::payments::PaymentIdType::PaymentAttemptId(payment_attempt_id),
))
}
trustpay::CreditDebitIndicator::Dbit => {
if details.payment_information.status == trustpay::WebhookStatus::Chargebacked {
Ok(api_models::webhooks::ObjectReferenceId::PaymentId(
api_models::payments::PaymentIdType::PaymentAttemptId(payment_attempt_id),
))
} else {
Ok(api_models::webhooks::ObjectReferenceId::RefundId(
api_models::webhooks::RefundIdType::RefundId(payment_attempt_id),
))
}
}
}
}
fn get_webhook_event_type(
&self,
request: &webhooks::IncomingWebhookRequestDetails<'_>,
) -> CustomResult<api_models::webhooks::IncomingWebhookEvent, errors::ConnectorError> {
let response: trustpay::TrustpayWebhookResponse = request
.body
.parse_struct("TrustpayWebhookResponse")
.switch()?;
match (
response.payment_information.credit_debit_indicator,
response.payment_information.status,
) {
(trustpay::CreditDebitIndicator::Crdt, trustpay::WebhookStatus::Paid) => {
Ok(api_models::webhooks::IncomingWebhookEvent::PaymentIntentSuccess)
}
(trustpay::CreditDebitIndicator::Crdt, trustpay::WebhookStatus::Rejected) => {
Ok(api_models::webhooks::IncomingWebhookEvent::PaymentIntentFailure)
}
(trustpay::CreditDebitIndicator::Dbit, trustpay::WebhookStatus::Paid) => {
Ok(api_models::webhooks::IncomingWebhookEvent::RefundSuccess)
}
(trustpay::CreditDebitIndicator::Dbit, trustpay::WebhookStatus::Refunded) => {
Ok(api_models::webhooks::IncomingWebhookEvent::RefundSuccess)
}
(trustpay::CreditDebitIndicator::Dbit, trustpay::WebhookStatus::Rejected) => {
Ok(api_models::webhooks::IncomingWebhookEvent::RefundFailure)
}
(trustpay::CreditDebitIndicator::Dbit, trustpay::WebhookStatus::Chargebacked) => {
Ok(api_models::webhooks::IncomingWebhookEvent::DisputeLost)
}
(
trustpay::CreditDebitIndicator::Dbit | trustpay::CreditDebitIndicator::Crdt,
trustpay::WebhookStatus::Unknown,
) => Ok(api_models::webhooks::IncomingWebhookEvent::EventNotSupported),
(trustpay::CreditDebitIndicator::Crdt, trustpay::WebhookStatus::Refunded) => {
Ok(api_models::webhooks::IncomingWebhookEvent::EventNotSupported)
}
(trustpay::CreditDebitIndicator::Crdt, trustpay::WebhookStatus::Chargebacked) => {
Ok(api_models::webhooks::IncomingWebhookEvent::EventNotSupported)
}
}
}
fn get_webhook_resource_object(
&self,
request: &webhooks::IncomingWebhookRequestDetails<'_>,
) -> CustomResult<Box<dyn masking::ErasedMaskSerialize>, errors::ConnectorError> {
let details: trustpay::TrustpayWebhookResponse = request
.body
.parse_struct("TrustpayWebhookResponse")
.switch()?;
Ok(Box::new(details.payment_information))
}
fn get_webhook_source_verification_algorithm(
&self,
_request: &webhooks::IncomingWebhookRequestDetails<'_>,
) -> CustomResult<Box<dyn crypto::VerifySignature + Send>, errors::ConnectorError> {
Ok(Box::new(crypto::HmacSha256))
}
fn get_webhook_source_verification_signature(
&self,
request: &webhooks::IncomingWebhookRequestDetails<'_>,
_connector_webhook_secrets: &api_models::webhooks::ConnectorWebhookSecrets,
) -> CustomResult<Vec<u8>, errors::ConnectorError> {
let response: trustpay::TrustpayWebhookResponse = request
.body
.parse_struct("TrustpayWebhookResponse")
.switch()?;
hex::decode(response.signature)
.change_context(errors::ConnectorError::WebhookSignatureNotFound)
}
fn get_webhook_source_verification_message(
&self,
request: &webhooks::IncomingWebhookRequestDetails<'_>,
_merchant_id: &common_utils::id_type::MerchantId,
_connector_webhook_secrets: &api_models::webhooks::ConnectorWebhookSecrets,
) -> CustomResult<Vec<u8>, errors::ConnectorError> {
let trustpay_response: trustpay::TrustpayWebhookResponse = request
.body
.parse_struct("TrustpayWebhookResponse")
.switch()?;
let response: serde_json::Value = request.body.parse_struct("Webhook Value").switch()?;
let values = utils::collect_and_sort_values_by_removing_signature(
&response,
&trustpay_response.signature,
);
let payload = values.join("/");
Ok(payload.into_bytes())
}
fn get_dispute_details(
&self,
request: &webhooks::IncomingWebhookRequestDetails<'_>,
) -> CustomResult<DisputePayload, errors::ConnectorError> {
let trustpay_response: trustpay::TrustpayWebhookResponse = request
.body
.parse_struct("TrustpayWebhookResponse")
.switch()?;
let payment_info = trustpay_response.payment_information;
let reason = payment_info.status_reason_information.unwrap_or_default();
let connector_dispute_id = payment_info
.references
.payment_id
.ok_or(errors::ConnectorError::WebhookReferenceIdNotFound)?;
let amount = utils::convert_back_amount_to_minor_units(
self.amount_converter_to_float_major_unit,
payment_info.amount.amount,
payment_info.amount.currency,
)?;
Ok(DisputePayload {
amount: utils::convert_amount(
self.amount_converter_to_string_minor_unit,
amount,
payment_info.amount.currency,
)?,
currency: payment_info.amount.currency,
dispute_stage: api_models::enums::DisputeStage::Dispute,
connector_dispute_id,
connector_reason: reason.reason.reject_reason,
connector_reason_code: reason.reason.code,
challenge_required_by: None,
connector_status: payment_info.status.to_string(),
created_at: None,
updated_at: None,
})
}
}
impl ConnectorRedirectResponse for Trustpay {
fn get_flow_type(
&self,
_query_params: &str,
_json_payload: Option<serde_json::Value>,
action: PaymentAction,
) -> CustomResult<enums::CallConnectorAction, errors::ConnectorError> {
match action {
PaymentAction::PSync
| PaymentAction::CompleteAuthorize
| PaymentAction::PaymentAuthenticateCompleteAuthorize => {
Ok(enums::CallConnectorAction::Trigger)
}
}
}
}
impl utils::ConnectorErrorTypeMapping for Trustpay {
fn get_connector_error_type(
&self,
error_code: String,
error_message: String,
) -> ConnectorErrorType {
match (error_code.as_str(), error_message.as_str()) {
// 2xx card api error codes and messages mapping
("100.100.600", "Empty CVV for VISA, MASTER not allowed") => ConnectorErrorType::UserError,
("100.350.100", "Referenced session is rejected (no action possible)") => ConnectorErrorType::TechnicalError,
("100.380.401", "User authentication failed") => ConnectorErrorType::UserError,
("100.380.501", "Risk management transaction timeout") => ConnectorErrorType::TechnicalError,
("100.390.103", "PARes validation failed - problem with signature") => ConnectorErrorType::TechnicalError,
("100.390.111", "Communication error to VISA/Mastercard Directory Server") => ConnectorErrorType::TechnicalError,
("100.390.112", "Technical error in 3D system") => ConnectorErrorType::TechnicalError,
("100.390.115", "Authentication failed due to invalid message format") => ConnectorErrorType::TechnicalError,
("100.390.118", "Authentication failed due to suspected fraud") => ConnectorErrorType::UserError,
("100.400.304", "Invalid input data") => ConnectorErrorType::UserError,
("200.300.404", "Invalid or missing parameter") => ConnectorErrorType::UserError,
("300.100.100", "Transaction declined (additional customer authentication required)") => ConnectorErrorType::UserError,
("400.001.301", "Card not enrolled in 3DS") => ConnectorErrorType::UserError,
("400.001.600", "Authentication error") => ConnectorErrorType::UserError,
("400.001.601", "Transaction declined (auth. declined)") => ConnectorErrorType::UserError,
("400.001.602", "Invalid transaction") => ConnectorErrorType::UserError,
("400.001.603", "Invalid transaction") => ConnectorErrorType::UserError,
("700.400.200", "Cannot refund (refund volume exceeded or tx reversed or invalid workflow)") => ConnectorErrorType::BusinessError,
("700.500.001", "Referenced session contains too many transactions") => ConnectorErrorType::TechnicalError,
("700.500.003", "Test accounts not allowed in production") => ConnectorErrorType::UserError,
("800.100.151", "Transaction declined (invalid card)") => ConnectorErrorType::UserError,
("800.100.152", "Transaction declined by authorization system") => ConnectorErrorType::UserError,
("800.100.153", "Transaction declined (invalid CVV)") => ConnectorErrorType::UserError,
("800.100.155", "Transaction declined (amount exceeds credit)") => ConnectorErrorType::UserError,
("800.100.157", "Transaction declined (wrong expiry date)") => ConnectorErrorType::UserError,
("800.100.162", "Transaction declined (limit exceeded)") => ConnectorErrorType::BusinessError,
("800.100.163", "Transaction declined (maximum transaction frequency exceeded)") => ConnectorErrorType::BusinessError,
("800.100.168", "Transaction declined (restricted card)") => ConnectorErrorType::UserError,
("800.100.170", "Transaction declined (transaction not permitted)") => ConnectorErrorType::UserError,
("800.100.172", "Transaction declined (account blocked)") => ConnectorErrorType::BusinessError,
("800.100.190", "Transaction declined (invalid configuration data)") => ConnectorErrorType::BusinessError,
("800.120.100", "Rejected by throttling") => ConnectorErrorType::TechnicalError,
("800.300.401", "Bin blacklisted") => ConnectorErrorType::BusinessError,
("800.700.100", "Transaction for the same session is currently being processed, please try again later") => ConnectorErrorType::TechnicalError,
("900.100.300", "Timeout, uncertain result") => ConnectorErrorType::TechnicalError,
// 4xx error codes for cards api are unique and messages vary, so we are relying only on error code to decide an error type
("4" | "5" | "6" | "7" | "8" | "9" | "10" | "11" | "12" | "13" | "14" | "15" | "16" | "17" | "18" | "19" | "26" | "34" | "39" | "48" | "52" | "85" | "86", _) => ConnectorErrorType::UserError,
("21" | "22" | "23" | "30" | "31" | "32" | "35" | "37" | "40" | "41" | "45" | "46" | "49" | "50" | "56" | "60" | "67" | "81" | "82" | "83" | "84" | "87", _) => ConnectorErrorType::BusinessError,
("59", _) => ConnectorErrorType::TechnicalError,
("1", _) => ConnectorErrorType::UnknownError,
// Error codes for bank redirects api are unique and messages vary, so we are relying only on error code to decide an error type
("1112008" | "1132000" | "1152000", _) => ConnectorErrorType::UserError,
("1112009" | "1122006" | "1132001" | "1132002" | "1132003" | "1132004" | "1132005" | "1132006" | "1132008" | "1132009" | "1132010" | "1132011" | "1132012" | "1132013" | "1133000" | "1133001" | "1133002" | "1133003" | "1133004", _) => ConnectorErrorType::BusinessError,
("1132014", _) => ConnectorErrorType::TechnicalError,
("1132007", _) => ConnectorErrorType::UnknownError,
_ => ConnectorErrorType::UnknownError,
}
}
}
static TRUSTPAY_SUPPORTED_PAYMENT_METHODS: LazyLock<SupportedPaymentMethods> =
LazyLock::new(|| {
let supported_capture_methods = vec![
enums::CaptureMethod::Automatic,
enums::CaptureMethod::SequentialAutomatic,
];
let supported_card_network = vec![
common_enums::CardNetwork::Mastercard,
common_enums::CardNetwork::Visa,
common_enums::CardNetwork::Interac,
common_enums::CardNetwork::AmericanExpress,
common_enums::CardNetwork::JCB,
common_enums::CardNetwork::DinersClub,
common_enums::CardNetwork::Discover,
common_enums::CardNetwork::CartesBancaires,
common_enums::CardNetwork::UnionPay,
];
let mut trustpay_supported_payment_methods = SupportedPaymentMethods::new();
trustpay_supported_payment_methods.add(
enums::PaymentMethod::Card,
enums::PaymentMethodType::Credit,
PaymentMethodDetails {
mandates: enums::FeatureStatus::NotSupported,
refunds: enums::FeatureStatus::Supported,
supported_capture_methods: supported_capture_methods.clone(),
specific_features: Some(
api_models::feature_matrix::PaymentMethodSpecificFeatures::Card({
api_models::feature_matrix::CardSpecificFeatures {
three_ds: common_enums::FeatureStatus::NotSupported,
no_three_ds: common_enums::FeatureStatus::Supported,
supported_card_networks: supported_card_network.clone(),
}
}),
),
},
);
trustpay_supported_payment_methods.add(
enums::PaymentMethod::Card,
enums::PaymentMethodType::Debit,
PaymentMethodDetails {
mandates: enums::FeatureStatus::NotSupported,
refunds: enums::FeatureStatus::Supported,
supported_capture_methods: supported_capture_methods.clone(),
specific_features: Some(
api_models::feature_matrix::PaymentMethodSpecificFeatures::Card({
api_models::feature_matrix::CardSpecificFeatures {
three_ds: common_enums::FeatureStatus::NotSupported,
no_three_ds: common_enums::FeatureStatus::Supported,
supported_card_networks: supported_card_network,
}
}),
),
},
);
trustpay_supported_payment_methods.add(
enums::PaymentMethod::Wallet,
enums::PaymentMethodType::GooglePay,
PaymentMethodDetails {
mandates: enums::FeatureStatus::NotSupported,
refunds: enums::FeatureStatus::Supported,
supported_capture_methods: supported_capture_methods.clone(),
specific_features: None,
},
);
trustpay_supported_payment_methods.add(
enums::PaymentMethod::Wallet,
enums::PaymentMethodType::ApplePay,
PaymentMethodDetails {
mandates: enums::FeatureStatus::NotSupported,
refunds: enums::FeatureStatus::Supported,
supported_capture_methods: supported_capture_methods.clone(),
specific_features: None,
},
);
trustpay_supported_payment_methods.add(
enums::PaymentMethod::BankRedirect,
enums::PaymentMethodType::Eps,
PaymentMethodDetails {
mandates: enums::FeatureStatus::NotSupported,
refunds: enums::FeatureStatus::Supported,
supported_capture_methods: supported_capture_methods.clone(),
specific_features: None,
},
);
trustpay_supported_payment_methods.add(
enums::PaymentMethod::BankRedirect,
enums::PaymentMethodType::Giropay,
PaymentMethodDetails {
mandates: enums::FeatureStatus::NotSupported,
refunds: enums::FeatureStatus::Supported,
supported_capture_methods: supported_capture_methods.clone(),
specific_features: None,
},
);
trustpay_supported_payment_methods.add(
enums::PaymentMethod::BankRedirect,
enums::PaymentMethodType::Ideal,
PaymentMethodDetails {
mandates: enums::FeatureStatus::NotSupported,
refunds: enums::FeatureStatus::Supported,
supported_capture_methods: supported_capture_methods.clone(),
specific_features: None,
},
);
trustpay_supported_payment_methods.add(
enums::PaymentMethod::BankRedirect,
enums::PaymentMethodType::Sofort,
PaymentMethodDetails {
mandates: enums::FeatureStatus::NotSupported,
refunds: enums::FeatureStatus::Supported,
supported_capture_methods: supported_capture_methods.clone(),
specific_features: None,
},
);
trustpay_supported_payment_methods.add(
enums::PaymentMethod::BankRedirect,
enums::PaymentMethodType::Blik,
PaymentMethodDetails {
mandates: enums::FeatureStatus::NotSupported,
refunds: enums::FeatureStatus::Supported,
supported_capture_methods: supported_capture_methods.clone(),
specific_features: None,
},
);
trustpay_supported_payment_methods.add(
enums::PaymentMethod::BankTransfer,
enums::PaymentMethodType::SepaBankTransfer,
PaymentMethodDetails {
mandates: enums::FeatureStatus::NotSupported,
refunds: enums::FeatureStatus::Supported,
supported_capture_methods: supported_capture_methods.clone(),
specific_features: None,
},
);
trustpay_supported_payment_methods.add(
enums::PaymentMethod::BankTransfer,
enums::PaymentMethodType::InstantBankTransfer,
PaymentMethodDetails {
mandates: enums::FeatureStatus::NotSupported,
refunds: enums::FeatureStatus::Supported,
supported_capture_methods: supported_capture_methods.clone(),
specific_features: None,
},
);
trustpay_supported_payment_methods.add(
enums::PaymentMethod::BankTransfer,
enums::PaymentMethodType::InstantBankTransferFinland,
PaymentMethodDetails {
mandates: enums::FeatureStatus::NotSupported,
refunds: enums::FeatureStatus::Supported,
supported_capture_methods: supported_capture_methods.clone(),
specific_features: None,
},
);
trustpay_supported_payment_methods.add(
enums::PaymentMethod::BankTransfer,
enums::PaymentMethodType::InstantBankTransferPoland,
PaymentMethodDetails {
mandates: enums::FeatureStatus::NotSupported,
refunds: enums::FeatureStatus::Supported,
supported_capture_methods,
specific_features: None,
},
);
trustpay_supported_payment_methods
});
static TRUSTPAY_CONNECTOR_INFO: ConnectorInfo = ConnectorInfo {
display_name: "Trustpay",
description: "TrustPay offers cross-border payment solutions for online businesses, including global card processing, local payment methods, business accounts, and reconciliation tools—all under one roof.",
connector_type: enums::HyperswitchConnectorCategory::PaymentGateway,
integration_status: enums::ConnectorIntegrationStatus::Live,
};
static TRUSTPAY_SUPPORTED_WEBHOOK_FLOWS: [enums::EventClass; 3] = [
enums::EventClass::Payments,
enums::EventClass::Refunds,
enums::EventClass::Disputes,
];
impl ConnectorSpecifications for Trustpay {
fn get_connector_about(&self) -> Option<&'static ConnectorInfo> {
Some(&TRUSTPAY_CONNECTOR_INFO)
}
fn get_supported_payment_methods(&self) -> Option<&'static SupportedPaymentMethods> {
Some(&*TRUSTPAY_SUPPORTED_PAYMENT_METHODS)
}
fn get_supported_webhook_flows(&self) -> Option<&'static [enums::EventClass]> {
Some(&TRUSTPAY_SUPPORTED_WEBHOOK_FLOWS)
}
#[cfg(feature = "v2")]
fn generate_connector_request_reference_id(
&self,
_payment_intent: &hyperswitch_domain_models::payments::PaymentIntent,
_payment_attempt: &hyperswitch_domain_models::payments::payment_attempt::PaymentAttempt,
) -> String {
// The length of receipt for Trustpay order request should not exceed 35 characters.
uuid::Uuid::now_v7().simple().to_string()
}
}
|
{
"crate": "hyperswitch_connectors",
"file": "crates/hyperswitch_connectors/src/connectors/trustpay.rs",
"file_size": null,
"is_async": null,
"is_pub": null,
"num_enums": 0,
"num_structs": 1,
"num_tables": null,
"score": null,
"total_crates": null
}
|
file_hyperswitch_connectors_-2290355503717542987
|
clm
|
file
|
// Repository: hyperswitch
// Crate: hyperswitch_connectors
// File: crates/hyperswitch_connectors/src/connectors/placetopay.rs
// Contains: 1 structs, 0 enums
pub mod transformers;
use std::sync::LazyLock;
use api_models::webhooks::{IncomingWebhookEvent, ObjectReferenceId};
use common_enums::enums;
use common_utils::{
errors::CustomResult,
ext_traits::BytesExt,
request::{Method, Request, RequestBuilder, RequestContent},
types::{AmountConvertor, MinorUnit, MinorUnitForConnector},
};
use error_stack::{report, ResultExt};
use hyperswitch_domain_models::{
router_data::{AccessToken, 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::{
ConnectorInfo, PaymentMethodDetails, PaymentsResponseData, RefundsResponseData,
SupportedPaymentMethods, SupportedPaymentMethodsExt,
},
types::{
PaymentsAuthorizeRouterData, PaymentsCancelRouterData, 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::{IncomingWebhook, IncomingWebhookRequestDetails},
};
use transformers as placetopay;
use crate::{constants::headers, types::ResponseRouterData, utils::convert_amount};
#[derive(Clone)]
pub struct Placetopay {
amount_converter: &'static (dyn AmountConvertor<Output = MinorUnit> + Sync),
}
impl Placetopay {
pub fn new() -> &'static Self {
&Self {
amount_converter: &MinorUnitForConnector,
}
}
}
impl api::Payment for Placetopay {}
impl api::PaymentSession for Placetopay {}
impl api::ConnectorAccessToken for Placetopay {}
impl api::MandateSetup for Placetopay {}
impl api::PaymentAuthorize for Placetopay {}
impl api::PaymentSync for Placetopay {}
impl api::PaymentCapture for Placetopay {}
impl api::PaymentVoid for Placetopay {}
impl api::Refund for Placetopay {}
impl api::RefundExecute for Placetopay {}
impl api::RefundSync for Placetopay {}
impl api::PaymentToken for Placetopay {}
impl ConnectorIntegration<PaymentMethodToken, PaymentMethodTokenizationData, PaymentsResponseData>
for Placetopay
{
// Not Implemented (R)
}
impl<Flow, Request, Response> ConnectorCommonExt<Flow, Request, Response> for Placetopay
where
Self: ConnectorIntegration<Flow, Request, Response>,
{
fn build_headers(
&self,
req: &RouterData<Flow, Request, Response>,
_connectors: &Connectors,
) -> CustomResult<Vec<(String, masking::Maskable<String>)>, errors::ConnectorError> {
let mut header = vec![(
headers::CONTENT_TYPE.to_string(),
self.get_content_type().to_string().into(),
)];
let mut api_key = self.get_auth_header(&req.connector_auth_type)?;
header.append(&mut api_key);
Ok(header)
}
}
impl ConnectorCommon for Placetopay {
fn id(&self) -> &'static str {
"placetopay"
}
fn get_currency_unit(&self) -> api::CurrencyUnit {
api::CurrencyUnit::Minor
}
fn common_get_content_type(&self) -> &'static str {
"application/json"
}
fn base_url<'a>(&self, connectors: &'a Connectors) -> &'a str {
connectors.placetopay.base_url.as_ref()
}
fn build_error_response(
&self,
res: Response,
event_builder: Option<&mut ConnectorEvent>,
) -> CustomResult<ErrorResponse, errors::ConnectorError> {
let response: placetopay::PlacetopayErrorResponse = res
.response
.parse_struct("PlacetopayErrorResponse")
.change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
event_builder.map(|i| i.set_error_response_body(&response));
router_env::logger::info!(connector_response=?response);
Ok(ErrorResponse {
status_code: res.status_code,
code: response.status.reason.to_owned(),
message: response.status.message.to_owned(),
reason: Some(response.status.message),
attempt_status: None,
connector_transaction_id: None,
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
connector_metadata: None,
})
}
}
impl ConnectorValidation for Placetopay {}
impl ConnectorIntegration<Session, PaymentsSessionData, PaymentsResponseData> for Placetopay {}
impl ConnectorIntegration<AccessTokenAuth, AccessTokenRequestData, AccessToken> for Placetopay {}
impl ConnectorIntegration<SetupMandate, SetupMandateRequestData, PaymentsResponseData>
for Placetopay
{
fn build_request(
&self,
_req: &RouterData<SetupMandate, SetupMandateRequestData, PaymentsResponseData>,
_connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Err(
errors::ConnectorError::NotImplemented("Setup Mandate flow for Placetopay".to_string())
.into(),
)
}
}
impl ConnectorIntegration<Authorize, PaymentsAuthorizeData, PaymentsResponseData> for Placetopay {
fn get_headers(
&self,
req: &PaymentsAuthorizeRouterData,
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: &PaymentsAuthorizeRouterData,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
Ok(format!("{}/process", self.base_url(connectors)))
}
fn get_request_body(
&self,
req: &PaymentsAuthorizeRouterData,
_connectors: &Connectors,
) -> CustomResult<RequestContent, errors::ConnectorError> {
let amount = convert_amount(
self.amount_converter,
req.request.minor_amount,
req.request.currency,
)?;
let connector_router_data = placetopay::PlacetopayRouterData::from((amount, req));
let req_obj = placetopay::PlacetopayPaymentsRequest::try_from(&connector_router_data)?;
Ok(RequestContent::Json(Box::new(req_obj)))
}
fn build_request(
&self,
req: &PaymentsAuthorizeRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Ok(Some(
RequestBuilder::new()
.method(Method::Post)
.url(&types::PaymentsAuthorizeType::get_url(
self, req, connectors,
)?)
.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: placetopay::PlacetopayPaymentsResponse = res
.response
.parse_struct("Placetopay PlacetopayPaymentsResponse")
.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,
})
}
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<PSync, PaymentsSyncData, PaymentsResponseData> for Placetopay {
fn get_headers(
&self,
req: &PaymentsSyncRouterData,
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: &PaymentsSyncRouterData,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
Ok(format!("{}/query", self.base_url(connectors)))
}
fn get_request_body(
&self,
req: &PaymentsSyncRouterData,
_connectors: &Connectors,
) -> CustomResult<RequestContent, errors::ConnectorError> {
let req_obj = placetopay::PlacetopayPsyncRequest::try_from(req)?;
Ok(RequestContent::Json(Box::new(req_obj)))
}
fn build_request(
&self,
req: &PaymentsSyncRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Ok(Some(
RequestBuilder::new()
.method(Method::Post)
.url(&types::PaymentsSyncType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(types::PaymentsSyncType::get_headers(self, req, connectors)?)
.set_body(types::PaymentsSyncType::get_request_body(
self, req, connectors,
)?)
.build(),
))
}
fn handle_response(
&self,
data: &PaymentsSyncRouterData,
event_builder: Option<&mut ConnectorEvent>,
res: Response,
) -> CustomResult<PaymentsSyncRouterData, errors::ConnectorError> {
let response: placetopay::PlacetopayPaymentsResponse = res
.response
.parse_struct("placetopay PaymentsSyncResponse")
.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,
})
}
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 Placetopay {
fn get_headers(
&self,
req: &PaymentsCaptureRouterData,
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: &PaymentsCaptureRouterData,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
Ok(format!("{}/transaction", self.base_url(connectors)))
}
fn get_request_body(
&self,
req: &PaymentsCaptureRouterData,
_connectors: &Connectors,
) -> CustomResult<RequestContent, errors::ConnectorError> {
let req_obj = placetopay::PlacetopayNextActionRequest::try_from(req)?;
Ok(RequestContent::Json(Box::new(req_obj)))
}
fn build_request(
&self,
req: &PaymentsCaptureRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Ok(Some(
RequestBuilder::new()
.method(Method::Post)
.url(&types::PaymentsCaptureType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(types::PaymentsCaptureType::get_headers(
self, req, connectors,
)?)
.set_body(types::PaymentsCaptureType::get_request_body(
self, req, connectors,
)?)
.build(),
))
}
fn handle_response(
&self,
data: &PaymentsCaptureRouterData,
event_builder: Option<&mut ConnectorEvent>,
res: Response,
) -> CustomResult<PaymentsCaptureRouterData, errors::ConnectorError> {
let response: placetopay::PlacetopayPaymentsResponse = res
.response
.parse_struct("Placetopay PaymentsCaptureResponse")
.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,
})
}
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<Void, PaymentsCancelData, PaymentsResponseData> for Placetopay {
fn get_headers(
&self,
req: &PaymentsCancelRouterData,
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: &PaymentsCancelRouterData,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
Ok(format!("{}/transaction", self.base_url(connectors)))
}
fn get_request_body(
&self,
req: &PaymentsCancelRouterData,
_connectors: &Connectors,
) -> CustomResult<RequestContent, errors::ConnectorError> {
let req_obj = placetopay::PlacetopayNextActionRequest::try_from(req)?;
Ok(RequestContent::Json(Box::new(req_obj)))
}
fn build_request(
&self,
req: &PaymentsCancelRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Ok(Some(
RequestBuilder::new()
.method(Method::Post)
.url(&types::PaymentsVoidType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(types::PaymentsVoidType::get_headers(self, req, connectors)?)
.set_body(types::PaymentsVoidType::get_request_body(
self, req, connectors,
)?)
.build(),
))
}
fn handle_response(
&self,
data: &PaymentsCancelRouterData,
event_builder: Option<&mut ConnectorEvent>,
res: Response,
) -> CustomResult<PaymentsCancelRouterData, errors::ConnectorError> {
let response: placetopay::PlacetopayPaymentsResponse = res
.response
.parse_struct("Placetopay PaymentCancelResponse")
.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,
})
}
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<Execute, RefundsData, RefundsResponseData> for Placetopay {
fn get_headers(
&self,
req: &RefundsRouterData<Execute>,
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: &RefundsRouterData<Execute>,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
Ok(format!("{}/transaction", self.base_url(connectors)))
}
fn get_request_body(
&self,
req: &RefundsRouterData<Execute>,
_connectors: &Connectors,
) -> CustomResult<RequestContent, errors::ConnectorError> {
let req_obj = placetopay::PlacetopayRefundRequest::try_from(req)?;
Ok(RequestContent::Json(Box::new(req_obj)))
}
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))
}
fn handle_response(
&self,
data: &RefundsRouterData<Execute>,
event_builder: Option<&mut ConnectorEvent>,
res: Response,
) -> CustomResult<RefundsRouterData<Execute>, errors::ConnectorError> {
let response: placetopay::PlacetopayRefundResponse = res
.response
.parse_struct("placetopay PlacetopayRefundResponse")
.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,
})
}
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<RSync, RefundsData, RefundsResponseData> for Placetopay {
fn get_headers(
&self,
req: &RefundSyncRouterData,
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: &RefundSyncRouterData,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
Ok(format!("{}/query", self.base_url(connectors)))
}
fn get_request_body(
&self,
req: &RefundsRouterData<RSync>,
_connectors: &Connectors,
) -> CustomResult<RequestContent, errors::ConnectorError> {
let req_obj = placetopay::PlacetopayRsyncRequest::try_from(req)?;
Ok(RequestContent::Json(Box::new(req_obj)))
}
fn build_request(
&self,
req: &RefundSyncRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Ok(Some(
RequestBuilder::new()
.method(Method::Post)
.url(&types::RefundSyncType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(types::RefundSyncType::get_headers(self, req, connectors)?)
.set_body(types::RefundSyncType::get_request_body(
self, req, connectors,
)?)
.build(),
))
}
fn handle_response(
&self,
data: &RefundSyncRouterData,
event_builder: Option<&mut ConnectorEvent>,
res: Response,
) -> CustomResult<RefundSyncRouterData, errors::ConnectorError> {
let response: placetopay::PlacetopayRefundResponse = res
.response
.parse_struct("placetopay PlacetopayRefundResponse")
.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,
})
}
fn get_error_response(
&self,
res: Response,
event_builder: Option<&mut ConnectorEvent>,
) -> CustomResult<ErrorResponse, errors::ConnectorError> {
self.build_error_response(res, event_builder)
}
}
#[async_trait::async_trait]
impl IncomingWebhook for Placetopay {
fn get_webhook_object_reference_id(
&self,
_request: &IncomingWebhookRequestDetails<'_>,
) -> CustomResult<ObjectReferenceId, errors::ConnectorError> {
Err(report!(errors::ConnectorError::WebhooksNotImplemented))
}
fn get_webhook_event_type(
&self,
_request: &IncomingWebhookRequestDetails<'_>,
) -> CustomResult<IncomingWebhookEvent, errors::ConnectorError> {
Err(report!(errors::ConnectorError::WebhooksNotImplemented))
}
fn get_webhook_resource_object(
&self,
_request: &IncomingWebhookRequestDetails<'_>,
) -> CustomResult<Box<dyn masking::ErasedMaskSerialize>, errors::ConnectorError> {
Err(report!(errors::ConnectorError::WebhooksNotImplemented))
}
}
static PLACETOPAY_SUPPORTED_PAYMENT_METHODS: LazyLock<SupportedPaymentMethods> =
LazyLock::new(|| {
let supported_capture_methods = vec![
enums::CaptureMethod::Automatic,
enums::CaptureMethod::SequentialAutomatic,
];
let supported_card_network = vec![
common_enums::CardNetwork::AmericanExpress,
common_enums::CardNetwork::DinersClub,
common_enums::CardNetwork::Mastercard,
common_enums::CardNetwork::Visa,
];
let mut placetopay_supported_payment_methods = SupportedPaymentMethods::new();
placetopay_supported_payment_methods.add(
enums::PaymentMethod::Card,
enums::PaymentMethodType::Credit,
PaymentMethodDetails {
mandates: enums::FeatureStatus::NotSupported,
refunds: enums::FeatureStatus::Supported,
supported_capture_methods: supported_capture_methods.clone(),
specific_features: Some(
api_models::feature_matrix::PaymentMethodSpecificFeatures::Card({
api_models::feature_matrix::CardSpecificFeatures {
three_ds: common_enums::FeatureStatus::NotSupported,
no_three_ds: common_enums::FeatureStatus::Supported,
supported_card_networks: supported_card_network.clone(),
}
}),
),
},
);
placetopay_supported_payment_methods.add(
enums::PaymentMethod::Card,
enums::PaymentMethodType::Debit,
PaymentMethodDetails {
mandates: enums::FeatureStatus::NotSupported,
refunds: enums::FeatureStatus::Supported,
supported_capture_methods: supported_capture_methods.clone(),
specific_features: Some(
api_models::feature_matrix::PaymentMethodSpecificFeatures::Card({
api_models::feature_matrix::CardSpecificFeatures {
three_ds: common_enums::FeatureStatus::NotSupported,
no_three_ds: common_enums::FeatureStatus::Supported,
supported_card_networks: supported_card_network.clone(),
}
}),
),
},
);
placetopay_supported_payment_methods
});
static PLACETOPAY_CONNECTOR_INFO: ConnectorInfo = ConnectorInfo {
display_name: "PlacetoPay",
description:
"PlacetoPay is a Latin American financial technology company's online payment platform, offering various payment methods and integrations for businesses",
connector_type: enums::HyperswitchConnectorCategory::PaymentGateway,
integration_status: enums::ConnectorIntegrationStatus::Sandbox,
};
static PLACETOPAY_SUPPORTED_WEBHOOK_FLOWS: [enums::EventClass; 0] = [];
impl ConnectorSpecifications for Placetopay {
fn get_connector_about(&self) -> Option<&'static ConnectorInfo> {
Some(&PLACETOPAY_CONNECTOR_INFO)
}
fn get_supported_payment_methods(&self) -> Option<&'static SupportedPaymentMethods> {
Some(&*PLACETOPAY_SUPPORTED_PAYMENT_METHODS)
}
fn get_supported_webhook_flows(&self) -> Option<&'static [enums::EventClass]> {
Some(&PLACETOPAY_SUPPORTED_WEBHOOK_FLOWS)
}
}
|
{
"crate": "hyperswitch_connectors",
"file": "crates/hyperswitch_connectors/src/connectors/placetopay.rs",
"file_size": null,
"is_async": null,
"is_pub": null,
"num_enums": 0,
"num_structs": 1,
"num_tables": null,
"score": null,
"total_crates": null
}
|
file_hyperswitch_connectors_-8070988840823525176
|
clm
|
file
|
// Repository: hyperswitch
// Crate: hyperswitch_connectors
// File: crates/hyperswitch_connectors/src/connectors/checkbook.rs
// Contains: 1 structs, 0 enums
pub mod transformers;
use std::sync::LazyLock;
use api_models::{enums, payments::PaymentIdType};
use common_utils::{
crypto,
errors::CustomResult,
ext_traits::{ByteSliceExt, BytesExt},
request::{Method, Request, RequestBuilder, RequestContent},
types::{AmountConvertor, FloatMajorUnit, FloatMajorUnitForConnector},
};
use error_stack::ResultExt;
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::{
ConnectorInfo, PaymentMethodDetails, PaymentsResponseData, RefundsResponseData,
SupportedPaymentMethods, SupportedPaymentMethodsExt,
},
types::{
PaymentsAuthorizeRouterData, PaymentsCancelRouterData, 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 masking::{ExposeInterface, Mask};
use transformers as checkbook;
use crate::{constants::headers, types::ResponseRouterData};
#[derive(Clone)]
pub struct Checkbook {
amount_converter: &'static (dyn AmountConvertor<Output = FloatMajorUnit> + Sync),
}
impl Checkbook {
pub fn new() -> &'static Self {
&Self {
amount_converter: &FloatMajorUnitForConnector,
}
}
}
impl api::Payment for Checkbook {}
impl api::PaymentSession for Checkbook {}
impl api::ConnectorAccessToken for Checkbook {}
impl api::MandateSetup for Checkbook {}
impl api::PaymentAuthorize for Checkbook {}
impl api::PaymentSync for Checkbook {}
impl api::PaymentCapture for Checkbook {}
impl api::PaymentVoid for Checkbook {}
impl api::Refund for Checkbook {}
impl api::RefundExecute for Checkbook {}
impl api::RefundSync for Checkbook {}
impl api::PaymentToken for Checkbook {}
impl ConnectorIntegration<PaymentMethodToken, PaymentMethodTokenizationData, PaymentsResponseData>
for Checkbook
{
// Not Implemented (R)
}
impl<Flow, Request, Response> ConnectorCommonExt<Flow, Request, Response> for Checkbook
where
Self: ConnectorIntegration<Flow, Request, Response>,
{
fn build_headers(
&self,
req: &RouterData<Flow, Request, Response>,
_connectors: &Connectors,
) -> CustomResult<Vec<(String, masking::Maskable<String>)>, errors::ConnectorError> {
let mut header = vec![(
headers::CONTENT_TYPE.to_string(),
self.get_content_type().to_string().into(),
)];
let mut api_key = self.get_auth_header(&req.connector_auth_type)?;
header.append(&mut api_key);
Ok(header)
}
}
impl ConnectorCommon for Checkbook {
fn id(&self) -> &'static str {
"checkbook"
}
fn get_currency_unit(&self) -> api::CurrencyUnit {
api::CurrencyUnit::Base
}
fn common_get_content_type(&self) -> &'static str {
"application/json"
}
fn base_url<'a>(&self, connectors: &'a Connectors) -> &'a str {
connectors.checkbook.base_url.as_ref()
}
fn get_auth_header(
&self,
auth_type: &ConnectorAuthType,
) -> CustomResult<Vec<(String, masking::Maskable<String>)>, errors::ConnectorError> {
let auth = checkbook::CheckbookAuthType::try_from(auth_type)
.change_context(errors::ConnectorError::FailedToObtainAuthType)?;
let auth_key = format!(
"{}:{}",
auth.publishable_key.expose(),
auth.secret_key.expose()
);
Ok(vec![(
headers::AUTHORIZATION.to_string(),
auth_key.into_masked(),
)])
}
fn build_error_response(
&self,
res: Response,
event_builder: Option<&mut ConnectorEvent>,
) -> CustomResult<ErrorResponse, errors::ConnectorError> {
let response: checkbook::CheckbookErrorResponse = res
.response
.parse_struct("CheckbookErrorResponse")
.change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
event_builder.map(|i| i.set_response_body(&response));
router_env::logger::info!(connector_response=?response);
Ok(ErrorResponse {
status_code: res.status_code,
code: response.code,
message: response.message,
reason: response.reason,
attempt_status: None,
connector_transaction_id: None,
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
connector_metadata: None,
})
}
}
impl ConnectorValidation for Checkbook {}
impl ConnectorIntegration<Session, PaymentsSessionData, PaymentsResponseData> for Checkbook {
//TODO: implement sessions flow
}
impl ConnectorIntegration<AccessTokenAuth, AccessTokenRequestData, AccessToken> for Checkbook {}
impl ConnectorIntegration<SetupMandate, SetupMandateRequestData, PaymentsResponseData>
for Checkbook
{
}
impl ConnectorIntegration<Authorize, PaymentsAuthorizeData, PaymentsResponseData> for Checkbook {
fn get_headers(
&self,
req: &PaymentsAuthorizeRouterData,
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: &PaymentsAuthorizeRouterData,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
Ok(format!("{}/v3/invoice", self.base_url(connectors)))
}
fn get_request_body(
&self,
req: &PaymentsAuthorizeRouterData,
_connectors: &Connectors,
) -> CustomResult<RequestContent, errors::ConnectorError> {
let amount = self
.amount_converter
.convert(req.request.minor_amount, req.request.currency)
.change_context(errors::ConnectorError::RequestEncodingFailed)?;
let connector_req = checkbook::CheckbookPaymentsRequest::try_from((amount, req))?;
Ok(RequestContent::Json(Box::new(connector_req)))
}
fn build_request(
&self,
req: &PaymentsAuthorizeRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Ok(Some(
RequestBuilder::new()
.method(Method::Post)
.url(&types::PaymentsAuthorizeType::get_url(
self, req, connectors,
)?)
.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: checkbook::CheckbookPaymentsResponse = res
.response
.parse_struct("Checkbook 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,
})
}
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<PSync, PaymentsSyncData, PaymentsResponseData> for Checkbook {
fn get_headers(
&self,
req: &PaymentsSyncRouterData,
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: &PaymentsSyncRouterData,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
let connector_txn_id = req
.request
.connector_transaction_id
.get_connector_transaction_id()
.change_context(errors::ConnectorError::MissingConnectorTransactionID)?;
Ok(format!(
"{}/v3/invoice/{}",
self.base_url(connectors),
connector_txn_id
))
}
fn build_request(
&self,
req: &PaymentsSyncRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Ok(Some(
RequestBuilder::new()
.method(Method::Get)
.url(&types::PaymentsSyncType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(types::PaymentsSyncType::get_headers(self, req, connectors)?)
.build(),
))
}
fn handle_response(
&self,
data: &PaymentsSyncRouterData,
event_builder: Option<&mut ConnectorEvent>,
res: Response,
) -> CustomResult<PaymentsSyncRouterData, errors::ConnectorError> {
let response: checkbook::CheckbookPaymentsResponse = res
.response
.parse_struct("checkbook PaymentsSyncResponse")
.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,
})
}
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 Checkbook {}
impl ConnectorIntegration<Void, PaymentsCancelData, PaymentsResponseData> for Checkbook {
fn get_headers(
&self,
req: &PaymentsCancelRouterData,
connectors: &Connectors,
) -> CustomResult<Vec<(String, masking::Maskable<String>)>, errors::ConnectorError> {
self.build_headers(req, connectors)
}
fn get_url(
&self,
req: &PaymentsCancelRouterData,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
Ok(format!(
"{}v3/invoice/{}",
self.base_url(connectors),
req.request.connector_transaction_id
))
}
fn build_request(
&self,
req: &PaymentsCancelRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Ok(Some(
RequestBuilder::new()
.method(Method::Delete)
.url(&types::PaymentsVoidType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(types::PaymentsVoidType::get_headers(self, req, connectors)?)
.build(),
))
}
fn handle_response(
&self,
data: &PaymentsCancelRouterData,
event_builder: Option<&mut ConnectorEvent>,
res: Response,
) -> CustomResult<PaymentsCancelRouterData, errors::ConnectorError> {
let response: checkbook::CheckbookPaymentsResponse = res
.response
.parse_struct("Checkbook PaymentsCancelResponse")
.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,
})
}
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<Execute, RefundsData, RefundsResponseData> for Checkbook {
fn get_headers(
&self,
req: &RefundsRouterData<Execute>,
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: &RefundsRouterData<Execute>,
_connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
Err(errors::ConnectorError::NotSupported {
message: "Refunds are not supported".to_string(),
connector: "checkbook",
}
.into())
}
fn get_request_body(
&self,
_req: &RefundsRouterData<Execute>,
_connectors: &Connectors,
) -> CustomResult<RequestContent, errors::ConnectorError> {
Err(errors::ConnectorError::NotSupported {
message: "Refunds are not supported".to_string(),
connector: "checkbook",
}
.into())
}
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))
}
fn handle_response(
&self,
_data: &RefundsRouterData<Execute>,
_event_builder: Option<&mut ConnectorEvent>,
_res: Response,
) -> CustomResult<RefundsRouterData<Execute>, errors::ConnectorError> {
Err(errors::ConnectorError::NotImplemented("Refunds are not supported".to_string()).into())
}
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<RSync, RefundsData, RefundsResponseData> for Checkbook {
fn get_headers(
&self,
req: &RefundSyncRouterData,
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: &RefundSyncRouterData,
_connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
Err(errors::ConnectorError::NotImplemented("get_url method".to_string()).into())
}
fn build_request(
&self,
req: &RefundSyncRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Ok(Some(
RequestBuilder::new()
.method(Method::Get)
.url(&types::RefundSyncType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(types::RefundSyncType::get_headers(self, req, connectors)?)
.set_body(types::RefundSyncType::get_request_body(
self, req, connectors,
)?)
.build(),
))
}
fn handle_response(
&self,
_data: &RefundSyncRouterData,
_event_builder: Option<&mut ConnectorEvent>,
_res: Response,
) -> CustomResult<RefundSyncRouterData, errors::ConnectorError> {
Err(errors::ConnectorError::NotImplemented("Refunds are not supported".to_string()).into())
}
fn get_error_response(
&self,
res: Response,
event_builder: Option<&mut ConnectorEvent>,
) -> CustomResult<ErrorResponse, errors::ConnectorError> {
self.build_error_response(res, event_builder)
}
}
#[async_trait::async_trait]
impl webhooks::IncomingWebhook for Checkbook {
fn get_webhook_object_reference_id(
&self,
request: &webhooks::IncomingWebhookRequestDetails<'_>,
) -> CustomResult<api_models::webhooks::ObjectReferenceId, errors::ConnectorError> {
let details: checkbook::CheckbookPaymentsResponse = request
.body
.parse_struct("CheckbookWebhookResponse")
.change_context(errors::ConnectorError::WebhookReferenceIdNotFound)?;
Ok(api_models::webhooks::ObjectReferenceId::PaymentId(
PaymentIdType::ConnectorTransactionId(details.id),
))
}
fn get_webhook_event_type(
&self,
request: &webhooks::IncomingWebhookRequestDetails<'_>,
) -> CustomResult<api_models::webhooks::IncomingWebhookEvent, errors::ConnectorError> {
let details: checkbook::CheckbookPaymentsResponse = request
.body
.parse_struct("CheckbookWebhookResponse")
.change_context(errors::ConnectorError::WebhookEventTypeNotFound)?;
Ok(api_models::webhooks::IncomingWebhookEvent::from(
details.status,
))
}
fn get_webhook_resource_object(
&self,
request: &webhooks::IncomingWebhookRequestDetails<'_>,
) -> CustomResult<Box<dyn masking::ErasedMaskSerialize>, errors::ConnectorError> {
let details: checkbook::CheckbookPaymentsResponse = request
.body
.parse_struct("CheckbookWebhookResponse")
.change_context(errors::ConnectorError::WebhookResourceObjectNotFound)?;
Ok(Box::new(details))
}
fn get_webhook_source_verification_algorithm(
&self,
_request: &webhooks::IncomingWebhookRequestDetails<'_>,
) -> CustomResult<Box<dyn crypto::VerifySignature + Send>, errors::ConnectorError> {
Ok(Box::new(crypto::HmacSha256))
}
fn get_webhook_source_verification_signature(
&self,
request: &webhooks::IncomingWebhookRequestDetails<'_>,
_connector_webhook_secrets: &api_models::webhooks::ConnectorWebhookSecrets,
) -> CustomResult<Vec<u8>, errors::ConnectorError> {
let header_value = request
.headers
.get("signature")
.ok_or(errors::ConnectorError::WebhookSignatureNotFound)
.attach_printable("Failed to get signature for checkbook")?
.to_str()
.map_err(|_| errors::ConnectorError::WebhookSignatureNotFound)
.attach_printable("Failed to get signature for checkbook")?;
let signature = header_value
.split(',')
.find_map(|s| s.strip_prefix("signature="))
.ok_or(errors::ConnectorError::WebhookSignatureNotFound)?;
hex::decode(signature)
.change_context(errors::ConnectorError::WebhookSignatureNotFound)
.attach_printable("Failed to decrypt checkbook webhook payload for verification")
}
fn get_webhook_source_verification_message(
&self,
request: &webhooks::IncomingWebhookRequestDetails<'_>,
_merchant_id: &common_utils::id_type::MerchantId,
_connector_webhook_secrets: &api_models::webhooks::ConnectorWebhookSecrets,
) -> CustomResult<Vec<u8>, errors::ConnectorError> {
let header_value = request
.headers
.get("signature")
.ok_or(errors::ConnectorError::WebhookSignatureNotFound)?
.to_str()
.map_err(|_| errors::ConnectorError::WebhookSignatureNotFound)?;
let nonce = header_value
.split(',')
.find_map(|s| s.strip_prefix("nonce="))
.ok_or(errors::ConnectorError::WebhookSignatureNotFound)?;
let message = format!("{}{}", String::from_utf8_lossy(request.body), nonce);
Ok(message.into_bytes())
}
}
static CHECKBOOK_SUPPORTED_PAYMENT_METHODS: LazyLock<SupportedPaymentMethods> =
LazyLock::new(|| {
let supported_capture_methods = vec![enums::CaptureMethod::Automatic];
let mut checkbook_supported_payment_methods = SupportedPaymentMethods::new();
checkbook_supported_payment_methods.add(
enums::PaymentMethod::BankTransfer,
enums::PaymentMethodType::Ach,
PaymentMethodDetails {
mandates: enums::FeatureStatus::NotSupported,
refunds: enums::FeatureStatus::NotSupported,
supported_capture_methods,
specific_features: None,
},
);
checkbook_supported_payment_methods
});
static CHECKBOOK_CONNECTOR_INFO: ConnectorInfo = ConnectorInfo {
display_name: "Checkbook",
description:
"Checkbook is a payment platform that allows users to send and receive digital checks.",
connector_type: enums::HyperswitchConnectorCategory::PaymentGateway,
integration_status: common_enums::ConnectorIntegrationStatus::Beta,
};
static CHECKBOOK_SUPPORTED_WEBHOOK_FLOWS: [enums::EventClass; 1] = [enums::EventClass::Payments];
impl ConnectorSpecifications for Checkbook {
fn get_connector_about(&self) -> Option<&'static ConnectorInfo> {
Some(&CHECKBOOK_CONNECTOR_INFO)
}
fn get_supported_payment_methods(&self) -> Option<&'static SupportedPaymentMethods> {
Some(&*CHECKBOOK_SUPPORTED_PAYMENT_METHODS)
}
fn get_supported_webhook_flows(&self) -> Option<&'static [enums::EventClass]> {
Some(&CHECKBOOK_SUPPORTED_WEBHOOK_FLOWS)
}
}
|
{
"crate": "hyperswitch_connectors",
"file": "crates/hyperswitch_connectors/src/connectors/checkbook.rs",
"file_size": null,
"is_async": null,
"is_pub": null,
"num_enums": 0,
"num_structs": 1,
"num_tables": null,
"score": null,
"total_crates": null
}
|
file_hyperswitch_connectors_-1140788249280038625
|
clm
|
file
|
// Repository: hyperswitch
// Crate: hyperswitch_connectors
// File: crates/hyperswitch_connectors/src/connectors/santander.rs
// Contains: 1 structs, 0 enums
pub mod transformers;
use std::sync::LazyLock;
use base64::Engine;
use common_enums::enums;
use common_utils::{
crypto,
errors::CustomResult,
ext_traits::{ByteSliceExt, BytesExt},
request::{Method, Request, RequestBuilder, RequestContent},
types::{AmountConvertor, MinorUnit, StringMajorUnit, StringMajorUnitForConnector},
};
use error_stack::ResultExt;
use hyperswitch_domain_models::{
router_data::{AccessToken, 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::{
ConnectorInfo, PaymentMethodDetails, PaymentsResponseData, RefundsResponseData,
SupportedPaymentMethods, SupportedPaymentMethodsExt,
},
types::{
PaymentsAuthorizeRouterData, PaymentsCancelRouterData, PaymentsCaptureRouterData,
PaymentsSyncRouterData, RefundSyncRouterData, RefundsRouterData,
},
};
use hyperswitch_interfaces::{
api::{
self, ConnectorCommon, ConnectorCommonExt, ConnectorIntegration, ConnectorSpecifications,
ConnectorValidation,
},
configs::Connectors,
consts::NO_ERROR_MESSAGE,
errors,
events::connector_api_logs::ConnectorEvent,
types::{self, RefreshTokenType, Response},
webhooks,
};
use masking::{Mask, Maskable, PeekInterface, Secret};
use transformers as santander;
use crate::{
constants::headers,
types::{RefreshTokenRouterData, ResponseRouterData},
utils::{self as connector_utils, convert_amount, RefundsRequestData},
};
#[derive(Clone)]
pub struct Santander {
amount_converter: &'static (dyn AmountConvertor<Output = StringMajorUnit> + Sync),
}
impl Santander {
pub fn new() -> &'static Self {
&Self {
amount_converter: &StringMajorUnitForConnector,
}
}
}
pub mod santander_constants {
pub const SANTANDER_VERSION: &str = "v2";
}
impl api::Payment for Santander {}
impl api::PaymentSession for Santander {}
impl api::ConnectorAccessToken for Santander {}
impl api::MandateSetup for Santander {}
impl api::PaymentAuthorize for Santander {}
impl api::PaymentSync for Santander {}
impl api::PaymentCapture for Santander {}
impl api::PaymentVoid for Santander {}
impl api::Refund for Santander {}
impl api::RefundExecute for Santander {}
impl api::RefundSync for Santander {}
impl api::PaymentToken for Santander {}
impl ConnectorIntegration<PaymentMethodToken, PaymentMethodTokenizationData, PaymentsResponseData>
for Santander
{
// Not Implemented (R)
}
impl<Flow, Request, Response> ConnectorCommonExt<Flow, Request, Response> for Santander
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 mut header = vec![(
headers::CONTENT_TYPE.to_string(),
self.get_content_type().to_string().into(),
)];
let mut api_key = self.get_auth_header(&req.connector_auth_type)?;
header.append(&mut api_key);
Ok(header)
}
}
impl ConnectorCommon for Santander {
fn id(&self) -> &'static str {
"santander"
}
fn get_currency_unit(&self) -> api::CurrencyUnit {
api::CurrencyUnit::Minor
}
fn common_get_content_type(&self) -> &'static str {
"application/json"
}
fn base_url<'a>(&self, connectors: &'a Connectors) -> &'a str {
connectors.santander.base_url.as_ref()
}
fn build_error_response(
&self,
res: Response,
event_builder: Option<&mut ConnectorEvent>,
) -> CustomResult<ErrorResponse, errors::ConnectorError> {
let response: santander::SantanderErrorResponse = res
.response
.parse_struct("SantanderErrorResponse")
.change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
event_builder.map(|i| i.set_response_body(&response));
router_env::logger::info!(connector_response=?response);
match response {
santander::SantanderErrorResponse::PixQrCode(response) => {
let message = response
.detail
.as_ref()
.cloned()
.unwrap_or_else(|| NO_ERROR_MESSAGE.to_string());
Ok(ErrorResponse {
status_code: res.status_code,
code: response.status.to_string(),
message,
reason: response.detail.clone(),
attempt_status: None,
connector_transaction_id: None,
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
connector_metadata: None,
})
}
santander::SantanderErrorResponse::Boleto(response) => Ok(ErrorResponse {
status_code: res.status_code,
code: response.error_code.to_string(),
message: response.error_message.clone(),
reason: Some(
response
.errors
.as_ref()
.and_then(|v| v.first())
.map(|e| e.message.clone())
.unwrap_or_else(|| NO_ERROR_MESSAGE.to_string()),
),
attempt_status: None,
connector_transaction_id: None,
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
connector_metadata: None,
}),
}
}
}
impl ConnectorValidation for Santander {
//TODO: implement functions when support enabled
}
impl ConnectorIntegration<Session, PaymentsSessionData, PaymentsResponseData> for Santander {
//TODO: implement sessions flow
}
impl ConnectorIntegration<AccessTokenAuth, AccessTokenRequestData, AccessToken> for Santander {
fn get_headers(
&self,
req: &RefreshTokenRouterData,
_connectors: &Connectors,
) -> CustomResult<Vec<(String, Maskable<String>)>, errors::ConnectorError> {
let client_id = req.request.app_id.clone();
let client_secret = req.request.id.clone();
let creds = format!(
"{}:{}",
client_id.peek(),
client_secret.unwrap_or_default().peek()
);
let encoded_creds = common_utils::consts::BASE64_ENGINE.encode(creds);
let auth_string = format!("Basic {encoded_creds}");
Ok(vec![
(
headers::CONTENT_TYPE.to_string(),
RefreshTokenType::get_content_type(self).to_string().into(),
),
(
headers::AUTHORIZATION.to_string(),
auth_string.into_masked(),
),
])
}
fn get_content_type(&self) -> &'static str {
"application/x-www-form-urlencoded"
}
fn get_url(
&self,
_req: &RefreshTokenRouterData,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
Ok(format!(
"{}/oauth/token?grant_type=client_credentials",
connectors.santander.base_url
))
}
fn build_request(
&self,
req: &RefreshTokenRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
let req = Some(
RequestBuilder::new()
.method(Method::Post)
.attach_default_headers()
.headers(RefreshTokenType::get_headers(self, req, connectors)?)
.url(&RefreshTokenType::get_url(self, req, connectors)?)
.build(),
);
Ok(req)
}
fn handle_response(
&self,
data: &RefreshTokenRouterData,
event_builder: Option<&mut ConnectorEvent>,
res: Response,
) -> CustomResult<RefreshTokenRouterData, errors::ConnectorError> {
let response: santander::SantanderAuthUpdateResponse = res
.response
.parse_struct("santander SantanderAuthUpdateResponse")
.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,
})
.change_context(errors::ConnectorError::ResponseHandlingFailed)
}
}
impl ConnectorIntegration<SetupMandate, SetupMandateRequestData, PaymentsResponseData>
for Santander
{
fn build_request(
&self,
_req: &RouterData<SetupMandate, SetupMandateRequestData, PaymentsResponseData>,
_connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Err(
errors::ConnectorError::NotImplemented("Setup Mandate flow for Santander".to_string())
.into(),
)
}
}
impl ConnectorIntegration<Authorize, PaymentsAuthorizeData, PaymentsResponseData> for Santander {
fn get_headers(
&self,
req: &PaymentsAuthorizeRouterData,
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: &PaymentsAuthorizeRouterData,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
let santander_mca_metadata =
santander::SantanderMetadataObject::try_from(&req.connector_meta_data)?;
match req.payment_method {
enums::PaymentMethod::BankTransfer => match req.request.payment_method_type {
Some(enums::PaymentMethodType::Pix) => Ok(format!(
"{}cob/{}",
self.base_url(connectors),
req.payment_id
)),
_ => Err(errors::ConnectorError::NotSupported {
message: req.payment_method.to_string(),
connector: "Santander",
}
.into()),
},
enums::PaymentMethod::Voucher => match req.request.payment_method_type {
Some(enums::PaymentMethodType::Boleto) => Ok(format!(
"{:?}{}/workspaces/{}/bank_slips",
connectors.santander.secondary_base_url.clone(),
santander_constants::SANTANDER_VERSION,
santander_mca_metadata.workspace_id
)),
_ => Err(errors::ConnectorError::NotSupported {
message: req.payment_method.to_string(),
connector: "Santander",
}
.into()),
},
_ => Err(errors::ConnectorError::NotSupported {
message: req.payment_method.to_string(),
connector: "Santander",
}
.into()),
}
}
fn get_request_body(
&self,
req: &PaymentsAuthorizeRouterData,
_connectors: &Connectors,
) -> CustomResult<RequestContent, errors::ConnectorError> {
let amount = convert_amount(
self.amount_converter,
req.request.minor_amount,
req.request.currency,
)?;
let connector_router_data = santander::SantanderRouterData::from((amount, req));
let connector_req = santander::SantanderPaymentRequest::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> {
Ok(Some(
RequestBuilder::new()
.method(Method::Put)
.url(&types::PaymentsAuthorizeType::get_url(
self, req, connectors,
)?)
.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: santander::SantanderPaymentsResponse = res
.response
.parse_struct("Santander PaymentsAuthorizeResponse")
.change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
let original_amount = match response {
santander::SantanderPaymentsResponse::PixQRCode(ref pix_data) => {
pix_data.value.original.clone()
}
santander::SantanderPaymentsResponse::Boleto(_) => {
convert_amount(
self.amount_converter,
MinorUnit::new(data.request.amount),
data.request.currency,
)?
// no amount field in the boleto response
}
};
event_builder.map(|i| i.set_response_body(&response));
router_env::logger::info!(connector_response=?response);
let response_integrity_object = connector_utils::get_authorise_integrity_object(
self.amount_converter,
original_amount,
enums::Currency::BRL.to_string(),
)?;
let new_router_data = RouterData::try_from(ResponseRouterData {
response,
data: data.clone(),
http_code: res.status_code,
});
new_router_data
.change_context(errors::ConnectorError::ResponseHandlingFailed)
.map(|mut router_data| {
router_data.request.integrity_object = Some(response_integrity_object);
router_data
})
}
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<PSync, PaymentsSyncData, PaymentsResponseData> for Santander {
fn get_headers(
&self,
req: &PaymentsSyncRouterData,
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: &PaymentsSyncRouterData,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
match req.request.payment_method_type {
Some(enums::PaymentMethodType::Pix) => {
let connector_payment_id = req
.request
.connector_transaction_id
.get_connector_transaction_id()
.change_context(errors::ConnectorError::MissingConnectorTransactionID)?;
Ok(format!(
"{}{}{}",
self.base_url(connectors),
"cob/",
connector_payment_id
))
}
Some(enums::PaymentMethodType::Boleto) => {
let bill_id = req
.request
.connector_meta
.clone()
.and_then(|val| val.as_str().map(|s| s.to_string()))
.ok_or_else(|| errors::ConnectorError::MissingRequiredField {
field_name: "bill_id",
})?;
Ok(format!(
"{:?}/{}/bills/{}/bank_slips",
connectors.santander.secondary_base_url.clone(),
santander_constants::SANTANDER_VERSION,
bill_id
))
}
_ => Err(errors::ConnectorError::MissingRequiredField {
field_name: "payment_method_type",
}
.into()),
}
}
fn get_request_body(
&self,
req: &PaymentsSyncRouterData,
_connectors: &Connectors,
) -> CustomResult<RequestContent, errors::ConnectorError> {
let amount = convert_amount(
self.amount_converter,
req.request.amount,
req.request.currency,
)?;
let connector_router_data = santander::SantanderRouterData::from((amount, req));
let connector_req =
santander::SantanderPSyncBoletoRequest::try_from(&connector_router_data)?;
Ok(RequestContent::Json(Box::new(connector_req)))
}
fn build_request(
&self,
req: &PaymentsSyncRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
match req.request.payment_method_type {
Some(enums::PaymentMethodType::Pix) => Ok(Some(
RequestBuilder::new()
.method(Method::Get)
.url(&types::PaymentsSyncType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(types::PaymentsSyncType::get_headers(self, req, connectors)?)
.build(),
)),
Some(enums::PaymentMethodType::Boleto) => Ok(Some(
RequestBuilder::new()
.method(Method::Post)
.url(&types::PaymentsSyncType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(types::PaymentsSyncType::get_headers(self, req, connectors)?)
.set_body(types::PaymentsSyncType::get_request_body(
self, req, connectors,
)?)
.build(),
)),
_ => Err(errors::ConnectorError::MissingRequiredField {
field_name: "payment_method_type",
}
.into()),
}
}
fn handle_response(
&self,
data: &PaymentsSyncRouterData,
event_builder: Option<&mut ConnectorEvent>,
res: Response,
) -> CustomResult<PaymentsSyncRouterData, errors::ConnectorError> {
let response: santander::SantanderPaymentsSyncResponse = res
.response
.parse_struct("santander SantanderPaymentsSyncResponse")
.change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
let original_amount = match response {
santander::SantanderPaymentsSyncResponse::PixQRCode(ref pix_data) => {
pix_data.base.value.original.clone()
}
santander::SantanderPaymentsSyncResponse::Boleto(_) => convert_amount(
self.amount_converter,
data.request.amount,
data.request.currency,
)?,
};
event_builder.map(|i| i.set_response_body(&response));
router_env::logger::info!(connector_response=?response);
let response_integrity_object = connector_utils::get_sync_integrity_object(
self.amount_converter,
original_amount,
enums::Currency::BRL.to_string(),
)?;
let new_router_data = RouterData::try_from(ResponseRouterData {
response,
data: data.clone(),
http_code: res.status_code,
});
new_router_data
.change_context(errors::ConnectorError::ResponseHandlingFailed)
.map(|mut router_data| {
router_data.request.integrity_object = Some(response_integrity_object);
router_data
})
}
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 Santander {
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(
&self,
_req: &PaymentsCaptureRouterData,
_connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
Err(errors::ConnectorError::FlowNotSupported {
flow: "Capture".to_string(),
connector: "Santander".to_string(),
}
.into())
}
fn get_request_body(
&self,
_req: &PaymentsCaptureRouterData,
_connectors: &Connectors,
) -> CustomResult<RequestContent, errors::ConnectorError> {
Err(errors::ConnectorError::FlowNotSupported {
flow: "Capture".to_string(),
connector: "Santander".to_string(),
}
.into())
}
fn build_request(
&self,
req: &PaymentsCaptureRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Ok(Some(
RequestBuilder::new()
.method(Method::Post)
.url(&types::PaymentsCaptureType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(types::PaymentsCaptureType::get_headers(
self, req, connectors,
)?)
.set_body(types::PaymentsCaptureType::get_request_body(
self, req, connectors,
)?)
.build(),
))
}
fn handle_response(
&self,
data: &PaymentsCaptureRouterData,
event_builder: Option<&mut ConnectorEvent>,
res: Response,
) -> CustomResult<PaymentsCaptureRouterData, errors::ConnectorError> {
let response: santander::SantanderPaymentsResponse = res
.response
.parse_struct("Santander PaymentsCaptureResponse")
.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,
})
}
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<Void, PaymentsCancelData, PaymentsResponseData> for Santander {
fn get_headers(
&self,
req: &PaymentsCancelRouterData,
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: &PaymentsCancelRouterData,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
match req.payment_method {
enums::PaymentMethod::BankTransfer => {
let connector_payment_id = req.request.connector_transaction_id.clone();
Ok(format!(
"{}cob/{}",
self.base_url(connectors),
connector_payment_id
))
}
_ => Err(errors::ConnectorError::NotSupported {
message: req.payment_method.to_string(),
connector: "Santander",
}
.into()),
}
}
fn get_request_body(
&self,
req: &PaymentsCancelRouterData,
_connectors: &Connectors,
) -> CustomResult<RequestContent, errors::ConnectorError> {
let connector_req = santander::SantanderPaymentsCancelRequest::try_from(req)?;
Ok(RequestContent::Json(Box::new(connector_req)))
}
fn build_request(
&self,
req: &PaymentsCancelRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Ok(Some(
RequestBuilder::new()
.method(Method::Patch)
.url(&types::PaymentsVoidType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(types::PaymentsVoidType::get_headers(self, req, connectors)?)
.set_body(types::PaymentsVoidType::get_request_body(
self, req, connectors,
)?)
.build(),
))
}
fn handle_response(
&self,
data: &PaymentsCancelRouterData,
event_builder: Option<&mut ConnectorEvent>,
res: Response,
) -> CustomResult<PaymentsCancelRouterData, errors::ConnectorError> {
let response: santander::SantanderPixVoidResponse = res
.response
.parse_struct("Santander PaymentsResponse")
.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,
})
}
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<Execute, RefundsData, RefundsResponseData> for Santander {
fn get_headers(
&self,
req: &RefundsRouterData<Execute>,
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: &RefundsRouterData<Execute>,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
match req.payment_method {
enums::PaymentMethod::BankTransfer => {
let end_to_end_id = req
.request
.connector_metadata
.as_ref()
.and_then(|metadata| metadata.get("end_to_end_id"))
.and_then(|val| val.as_str().map(|id| id.to_string()))
.ok_or_else(|| errors::ConnectorError::MissingRequiredField {
field_name: "end_to_end_id",
})?;
let refund_id = req.request.connector_refund_id.clone();
Ok(format!(
"{}{}{}{}{:?}",
self.base_url(connectors),
"pix/",
end_to_end_id,
"/refund/",
refund_id
))
}
_ => Err(errors::ConnectorError::NotSupported {
message: req.payment_method.to_string(),
connector: "Santander",
}
.into()),
}
}
fn get_request_body(
&self,
req: &RefundsRouterData<Execute>,
_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 = santander::SantanderRouterData::from((refund_amount, req));
let connector_req = santander::SantanderRefundRequest::try_from(&connector_router_data)?;
Ok(RequestContent::Json(Box::new(connector_req)))
}
fn build_request(
&self,
req: &RefundsRouterData<Execute>,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
let request = RequestBuilder::new()
.method(Method::Put)
.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))
}
fn handle_response(
&self,
data: &RefundsRouterData<Execute>,
event_builder: Option<&mut ConnectorEvent>,
res: Response,
) -> CustomResult<RefundsRouterData<Execute>, errors::ConnectorError> {
let response: santander::SantanderRefundResponse = res
.response
.parse_struct("santander RefundResponse")
.change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
let original_amount = response.value.clone();
event_builder.map(|i| i.set_response_body(&response));
router_env::logger::info!(connector_response=?response);
let response_integrity_object = connector_utils::get_refund_integrity_object(
self.amount_converter,
original_amount,
enums::Currency::BRL.to_string(),
)?;
let new_router_data = RouterData::try_from(ResponseRouterData {
response,
data: data.clone(),
http_code: res.status_code,
});
new_router_data
.change_context(errors::ConnectorError::ResponseHandlingFailed)
.map(|mut router_data| {
router_data.request.integrity_object = Some(response_integrity_object);
router_data
})
}
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<RSync, RefundsData, RefundsResponseData> for Santander {
fn get_headers(
&self,
req: &RefundSyncRouterData,
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: &RefundSyncRouterData,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
let connector_metadata = req.request.connector_metadata.clone();
let end_to_end_id = match &connector_metadata {
Some(metadata) => match metadata.get("end_to_end_id") {
Some(val) => val.as_str().map(|id| id.to_string()),
None => None,
},
None => None,
}
.ok_or_else(|| errors::ConnectorError::MissingRequiredField {
field_name: "end_to_end_id",
})?;
Ok(format!(
"{}{}{}{}{}",
self.base_url(connectors),
"pix/",
end_to_end_id,
"/return/",
req.request.get_connector_refund_id()?
))
}
fn build_request(
&self,
req: &RefundSyncRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Ok(Some(
RequestBuilder::new()
.method(Method::Get)
.url(&types::RefundSyncType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(types::RefundSyncType::get_headers(self, req, connectors)?)
.set_body(types::RefundSyncType::get_request_body(
self, req, connectors,
)?)
.build(),
))
}
fn handle_response(
&self,
data: &RefundSyncRouterData,
event_builder: Option<&mut ConnectorEvent>,
res: Response,
) -> CustomResult<RefundSyncRouterData, errors::ConnectorError> {
let response: santander::SantanderRefundResponse = res
.response
.parse_struct("santander RefundSyncResponse")
.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,
})
}
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_webhook_object_from_body(
body: &[u8],
) -> CustomResult<santander::SantanderWebhookBody, common_utils::errors::ParsingError> {
let webhook: santander::SantanderWebhookBody = body.parse_struct("SantanderIncomingWebhook")?;
Ok(webhook)
}
#[async_trait::async_trait]
impl webhooks::IncomingWebhook for Santander {
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: crypto::Encryptable<Secret<serde_json::Value>>,
_connector_name: &str,
) -> CustomResult<bool, errors::ConnectorError> {
Ok(true) // Hardcoded to true as the source verification algorithm for Santander remains to be unknown (in docs it is mentioned as MTLS)
}
fn get_webhook_object_reference_id(
&self,
request: &webhooks::IncomingWebhookRequestDetails<'_>,
) -> CustomResult<api_models::webhooks::ObjectReferenceId, errors::ConnectorError> {
let webhook_body = transformers::get_webhook_object_from_body(request.body)
.change_context(errors::ConnectorError::WebhookReferenceIdNotFound)?;
Ok(api_models::webhooks::ObjectReferenceId::PaymentId(
api_models::payments::PaymentIdType::ConnectorTransactionId(
webhook_body.participant_code,
),
))
}
fn get_webhook_event_type(
&self,
request: &webhooks::IncomingWebhookRequestDetails<'_>,
) -> CustomResult<api_models::webhooks::IncomingWebhookEvent, errors::ConnectorError> {
let body = get_webhook_object_from_body(request.body)
.change_context(errors::ConnectorError::WebhookEventTypeNotFound)?;
Ok(transformers::get_santander_webhook_event(body.function))
}
fn get_webhook_resource_object(
&self,
request: &webhooks::IncomingWebhookRequestDetails<'_>,
) -> CustomResult<Box<dyn masking::ErasedMaskSerialize>, errors::ConnectorError> {
let webhook_body = transformers::get_webhook_object_from_body(request.body)
.change_context(errors::ConnectorError::WebhookResourceObjectNotFound)?;
Ok(Box::new(webhook_body))
}
}
static SANTANDER_SUPPORTED_PAYMENT_METHODS: LazyLock<SupportedPaymentMethods> =
LazyLock::new(|| {
let supported_capture_methods = vec![enums::CaptureMethod::Automatic];
let mut santander_supported_payment_methods = SupportedPaymentMethods::new();
santander_supported_payment_methods.add(
enums::PaymentMethod::BankTransfer,
enums::PaymentMethodType::Pix,
PaymentMethodDetails {
mandates: enums::FeatureStatus::NotSupported,
refunds: enums::FeatureStatus::Supported,
supported_capture_methods: supported_capture_methods.clone(),
specific_features: None,
},
);
santander_supported_payment_methods.add(
enums::PaymentMethod::Voucher,
enums::PaymentMethodType::Boleto,
PaymentMethodDetails {
mandates: enums::FeatureStatus::NotSupported,
refunds: enums::FeatureStatus::NotSupported,
supported_capture_methods,
specific_features: None,
},
);
santander_supported_payment_methods
});
static SANTANDER_CONNECTOR_INFO: ConnectorInfo = ConnectorInfo {
display_name: "Santander",
description:
"Santander is a leading private bank in Brazil, offering a wide range of financial services across retail and corporate segments. It is part of the global Santander Group, one of Europe’s largest financial institutions.",
connector_type: enums::HyperswitchConnectorCategory::PaymentGateway,
integration_status: enums::ConnectorIntegrationStatus::Alpha,
};
static SANTANDER_SUPPORTED_WEBHOOK_FLOWS: [enums::EventClass; 2] =
[enums::EventClass::Payments, enums::EventClass::Refunds];
impl ConnectorSpecifications for Santander {
fn get_connector_about(&self) -> Option<&'static ConnectorInfo> {
Some(&SANTANDER_CONNECTOR_INFO)
}
fn get_supported_payment_methods(&self) -> Option<&'static SupportedPaymentMethods> {
Some(&*SANTANDER_SUPPORTED_PAYMENT_METHODS)
}
fn get_supported_webhook_flows(&self) -> Option<&'static [enums::EventClass]> {
Some(&SANTANDER_SUPPORTED_WEBHOOK_FLOWS)
}
}
|
{
"crate": "hyperswitch_connectors",
"file": "crates/hyperswitch_connectors/src/connectors/santander.rs",
"file_size": null,
"is_async": null,
"is_pub": null,
"num_enums": 0,
"num_structs": 1,
"num_tables": null,
"score": null,
"total_crates": null
}
|
file_hyperswitch_connectors_7206881605483799527
|
clm
|
file
|
// Repository: hyperswitch
// Crate: hyperswitch_connectors
// File: crates/hyperswitch_connectors/src/connectors/tokenio.rs
// Contains: 1 structs, 0 enums
pub mod transformers;
use std::{
sync::LazyLock,
time::{SystemTime, UNIX_EPOCH},
};
use base64::{engine::general_purpose::URL_SAFE_NO_PAD, Engine as _};
use common_enums::{enums, FeatureStatus, PaymentMethodType};
use common_utils::{
crypto::{self, VerifySignature},
errors::CustomResult,
ext_traits::{ByteSliceExt, BytesExt},
request::{Method, Request, RequestBuilder, RequestContent},
types::{AmountConvertor, StringMajorUnit, StringMajorUnitForConnector},
};
use error_stack::ResultExt;
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::{
ConnectorInfo, PaymentMethodDetails, PaymentsResponseData, RefundsResponseData,
SupportedPaymentMethods, SupportedPaymentMethodsExt,
},
types::{
PaymentsAuthorizeRouterData, PaymentsCancelRouterData, PaymentsCaptureRouterData,
PaymentsSyncRouterData, RefundSyncRouterData, RefundsRouterData,
},
};
use hyperswitch_interfaces::{
api::{
self, ConnectorCommon, ConnectorCommonExt, ConnectorIntegration, ConnectorSpecifications,
ConnectorValidation,
},
configs::Connectors,
errors,
events::connector_api_logs::ConnectorEvent,
types::Response,
webhooks,
};
use masking::{ExposeInterface, Mask, Secret};
use openssl::{ec::EcKey, hash::MessageDigest, pkey::PKey, rsa::Rsa, sign::Signer};
use transformers::{self as tokenio, TokenioPaymentStatus};
use crate::{constants::headers, types::ResponseRouterData, utils};
#[derive(Clone)]
pub struct Tokenio {
amount_converter: &'static (dyn AmountConvertor<Output = StringMajorUnit> + Sync),
}
impl Tokenio {
pub fn new() -> &'static Self {
&Self {
amount_converter: &StringMajorUnitForConnector,
}
}
fn create_jwt_token(
&self,
auth: &tokenio::TokenioAuthType,
method: &str,
path: &str,
body: &RequestContent,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
// Create JWT header
let exp_time = SystemTime::now()
.duration_since(UNIX_EPOCH)
.change_context(errors::ConnectorError::RequestEncodingFailed)?
.as_millis()
+ 600_000; // 10 minutes
let header = serde_json::json!({
"alg": match auth.key_algorithm {
tokenio::CryptoAlgorithm::RS256 => "RS256",
tokenio::CryptoAlgorithm::ES256 => "ES256",
tokenio::CryptoAlgorithm::EDDSA => "EdDSA",
},
"exp": exp_time.to_string(), // Convert to string as Token.io expects
"mid": auth.merchant_id.clone().expose(),
"kid": auth.key_id.clone().expose(),
"method": method.to_uppercase(),
"host": connectors.tokenio.base_url.trim_start_matches("https://").trim_end_matches("/"),
"path": path,
"typ": "JWT",
});
// For GET requests, use detached JWT (no payload)
// For POST/PUT requests, include the request body as payload
let is_get_request = method.to_uppercase() == "GET";
let payload = if is_get_request {
None // No payload for GET requests (detached JWT)
} else {
// For non-GET requests, include the request body
match body {
RequestContent::Json(json_body) => Some(
serde_json::to_value(json_body)
.change_context(errors::ConnectorError::RequestEncodingFailed)?,
),
_ => Some(serde_json::json!({})),
}
};
// Use compact JSON serialization (no extra whitespace)
let encoded_header = self.base64url_encode(
serde_json::to_string(&header)
.change_context(errors::ConnectorError::RequestEncodingFailed)?
.as_bytes(),
)?;
let (encoded_payload, signing_input) = match payload {
Some(p) => {
// Standard JWT with payload
let encoded_payload = self.base64url_encode(
serde_json::to_string(&p)
.change_context(errors::ConnectorError::RequestEncodingFailed)?
.as_bytes(),
)?;
let signing_input = format!("{encoded_header}.{encoded_payload}");
(encoded_payload, signing_input)
}
None => {
// Detached JWT (GET requests) - sign only the header with a dot
let signing_input = format!("{encoded_header}.");
(String::new(), signing_input) // Empty payload for detached JWT
}
};
// Sign the JWT based on algorithm
let signature = match auth.key_algorithm {
tokenio::CryptoAlgorithm::RS256 => {
self.sign_rsa(&auth.private_key.clone().expose(), &signing_input)?
}
tokenio::CryptoAlgorithm::ES256 => {
self.sign_ecdsa(&auth.private_key.clone().expose(), &signing_input)?
}
tokenio::CryptoAlgorithm::EDDSA => {
self.sign_eddsa(&auth.private_key.clone().expose(), &signing_input)?
}
};
let encoded_signature = self.base64url_encode(&signature)?;
// Assemble JWT - for detached JWT, middle part is empty
Ok(format!(
"{encoded_header}.{encoded_payload}.{encoded_signature}",
))
}
fn base64url_encode(&self, data: &[u8]) -> CustomResult<String, errors::ConnectorError> {
Ok(URL_SAFE_NO_PAD.encode(data))
}
fn sign_rsa(
&self,
private_key_pem: &str,
data: &str,
) -> CustomResult<Vec<u8>, errors::ConnectorError> {
let rsa = Rsa::private_key_from_pem(private_key_pem.as_bytes())
.change_context(errors::ConnectorError::RequestEncodingFailed)?;
let pkey =
PKey::from_rsa(rsa).change_context(errors::ConnectorError::RequestEncodingFailed)?;
let mut signer = Signer::new(MessageDigest::sha256(), &pkey)
.change_context(errors::ConnectorError::RequestEncodingFailed)?;
signer
.update(data.as_bytes())
.change_context(errors::ConnectorError::RequestEncodingFailed)?;
let signature = signer
.sign_to_vec()
.change_context(errors::ConnectorError::RequestEncodingFailed)?;
Ok(signature)
}
fn sign_ecdsa(
&self,
private_key_pem: &str,
data: &str,
) -> CustomResult<Vec<u8>, errors::ConnectorError> {
let ec_key = EcKey::private_key_from_pem(private_key_pem.as_bytes())
.change_context(errors::ConnectorError::RequestEncodingFailed)?;
let pkey = PKey::from_ec_key(ec_key)
.change_context(errors::ConnectorError::RequestEncodingFailed)?;
let mut signer = Signer::new(MessageDigest::sha256(), &pkey)
.change_context(errors::ConnectorError::RequestEncodingFailed)?;
signer
.update(data.as_bytes())
.change_context(errors::ConnectorError::RequestEncodingFailed)?;
let signature = signer
.sign_to_vec()
.change_context(errors::ConnectorError::RequestEncodingFailed)?;
Ok(signature)
}
fn sign_eddsa(
&self,
private_key_pem: &str,
data: &str,
) -> CustomResult<Vec<u8>, errors::ConnectorError> {
let pkey = PKey::private_key_from_pem(private_key_pem.as_bytes())
.change_context(errors::ConnectorError::RequestEncodingFailed)?;
let mut signer = Signer::new_without_digest(&pkey)
.change_context(errors::ConnectorError::RequestEncodingFailed)?;
signer
.update(data.as_bytes())
.change_context(errors::ConnectorError::RequestEncodingFailed)?;
let signature = signer
.sign_to_vec()
.change_context(errors::ConnectorError::RequestEncodingFailed)?;
Ok(signature)
}
}
impl api::Payment for Tokenio {}
impl api::PaymentSession for Tokenio {}
impl api::ConnectorAccessToken for Tokenio {}
impl api::MandateSetup for Tokenio {}
impl api::PaymentAuthorize for Tokenio {}
impl api::PaymentSync for Tokenio {}
impl api::PaymentCapture for Tokenio {}
impl api::PaymentVoid for Tokenio {}
impl api::Refund for Tokenio {}
impl api::RefundExecute for Tokenio {}
impl api::RefundSync for Tokenio {}
impl api::PaymentToken for Tokenio {}
impl ConnectorIntegration<PaymentMethodToken, PaymentMethodTokenizationData, PaymentsResponseData>
for Tokenio
{
// Not Implemented (R)
}
impl<Flow, Request, Response> ConnectorCommonExt<Flow, Request, Response> for Tokenio
where
Self: ConnectorIntegration<Flow, Request, Response>,
{
fn build_headers(
&self,
_req: &RouterData<Flow, Request, Response>,
_connectors: &Connectors,
) -> CustomResult<Vec<(String, masking::Maskable<String>)>, errors::ConnectorError> {
// Basic headers - JWT will be added in individual build_request methods
let header = vec![(
headers::CONTENT_TYPE.to_string(),
self.get_content_type().to_string().into(),
)];
Ok(header)
}
}
impl ConnectorCommon for Tokenio {
fn id(&self) -> &'static str {
"tokenio"
}
fn get_currency_unit(&self) -> api::CurrencyUnit {
api::CurrencyUnit::Base
}
fn common_get_content_type(&self) -> &'static str {
"application/json"
}
fn base_url<'a>(&self, connectors: &'a Connectors) -> &'a str {
connectors.tokenio.base_url.as_ref()
}
fn get_auth_header(
&self,
_auth_type: &ConnectorAuthType,
) -> CustomResult<Vec<(String, masking::Maskable<String>)>, errors::ConnectorError> {
Ok(vec![])
}
fn build_error_response(
&self,
res: Response,
event_builder: Option<&mut ConnectorEvent>,
) -> CustomResult<ErrorResponse, errors::ConnectorError> {
let response: tokenio::TokenioErrorResponse = res
.response
.parse_struct("TokenioErrorResponse")
.change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
event_builder.map(|i| i.set_response_body(&response));
router_env::logger::info!(connector_response=?response);
Ok(ErrorResponse {
status_code: res.status_code,
code: response.get_error_code(),
message: response.get_message(),
reason: Some(response.get_message()),
attempt_status: None,
connector_transaction_id: None,
network_decline_code: None,
network_advice_code: None,
network_error_message: None,
connector_metadata: None,
})
}
}
impl ConnectorValidation for Tokenio {
//TODO: implement functions when support enabled
}
impl ConnectorIntegration<Session, PaymentsSessionData, PaymentsResponseData> for Tokenio {
//TODO: implement sessions flow
}
impl ConnectorIntegration<AccessTokenAuth, AccessTokenRequestData, AccessToken> for Tokenio {}
impl ConnectorIntegration<SetupMandate, SetupMandateRequestData, PaymentsResponseData> for Tokenio {}
impl ConnectorIntegration<Authorize, PaymentsAuthorizeData, PaymentsResponseData> for Tokenio {
fn get_headers(
&self,
req: &PaymentsAuthorizeRouterData,
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: &PaymentsAuthorizeRouterData,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
let base_url = self.base_url(connectors);
Ok(format!("{base_url}/v2/payments"))
}
fn get_request_body(
&self,
req: &PaymentsAuthorizeRouterData,
_connectors: &Connectors,
) -> CustomResult<RequestContent, errors::ConnectorError> {
let amount = utils::convert_amount(
self.amount_converter,
req.request.minor_amount,
req.request.currency,
)?;
let connector_router_data = tokenio::TokenioRouterData::from((amount, req));
let connector_req = tokenio::TokenioPaymentsRequest::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 auth = tokenio::TokenioAuthType::try_from(&req.connector_auth_type)
.change_context(errors::ConnectorError::FailedToObtainAuthType)?;
let url = self.get_url(req, connectors)?;
let body = self.get_request_body(req, connectors)?;
// Create JWT for authentication
let jwt = self.create_jwt_token(&auth, "POST", "/v2/payments", &body, connectors)?;
// Build headers with JWT authorization
let headers = vec![
(
headers::CONTENT_TYPE.to_string(),
"application/json".to_string().into(),
),
(
headers::AUTHORIZATION.to_string(),
format!("Bearer {jwt}").into_masked(),
),
];
Ok(Some(
RequestBuilder::new()
.method(Method::Post)
.url(&url)
.attach_default_headers()
.headers(headers)
.set_body(body)
.build(),
))
}
fn handle_response(
&self,
data: &PaymentsAuthorizeRouterData,
event_builder: Option<&mut ConnectorEvent>,
res: Response,
) -> CustomResult<PaymentsAuthorizeRouterData, errors::ConnectorError> {
let response: tokenio::TokenioPaymentsResponse = res
.response
.parse_struct("Tokenio 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,
})
}
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<PSync, PaymentsSyncData, PaymentsResponseData> for Tokenio {
fn get_headers(
&self,
req: &PaymentsSyncRouterData,
connectors: &Connectors,
) -> CustomResult<Vec<(String, masking::Maskable<String>)>, errors::ConnectorError> {
// For GET requests, we need JWT with detached format (no body)
let auth = tokenio::TokenioAuthType::try_from(&req.connector_auth_type)
.change_context(errors::ConnectorError::FailedToObtainAuthType)?;
// Use empty RequestContent for GET requests - the create_jwt_token method
// will handle this properly by creating detached JWT
let empty_body = RequestContent::Json(Box::new(serde_json::json!({})));
let path = format!(
"/v2/payments/{}",
req.request
.connector_transaction_id
.get_connector_transaction_id()
.change_context(errors::ConnectorError::MissingConnectorTransactionID)?
);
let jwt = self.create_jwt_token(&auth, "GET", &path, &empty_body, connectors)?;
let headers = vec![
(
headers::CONTENT_TYPE.to_string(),
"application/json".to_string().into(),
),
(
headers::AUTHORIZATION.to_string(),
format!("Bearer {jwt}").into_masked(),
),
];
Ok(headers)
}
fn get_content_type(&self) -> &'static str {
self.common_get_content_type()
}
fn get_url(
&self,
req: &PaymentsSyncRouterData,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
let connector_payment_id = req
.request
.connector_transaction_id
.get_connector_transaction_id()
.change_context(errors::ConnectorError::MissingConnectorTransactionID)?;
let base_url = self.base_url(connectors);
Ok(format!("{base_url}/v2/payments/{connector_payment_id}"))
}
fn build_request(
&self,
req: &PaymentsSyncRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Ok(Some(
RequestBuilder::new()
.method(Method::Get)
.url(&self.get_url(req, connectors)?)
.attach_default_headers()
.headers(self.get_headers(req, connectors)?)
.build(),
))
}
fn handle_response(
&self,
data: &PaymentsSyncRouterData,
event_builder: Option<&mut ConnectorEvent>,
res: Response,
) -> CustomResult<PaymentsSyncRouterData, errors::ConnectorError> {
let response: tokenio::TokenioPaymentsResponse = res
.response
.parse_struct("tokenio TokenioPaymentsResponse")
.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,
})
}
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 Tokenio {
fn build_request(
&self,
_req: &PaymentsCaptureRouterData,
_connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Err(errors::ConnectorError::FlowNotSupported {
flow: "Capture".to_string(),
connector: "Tokenio".to_string(),
}
.into())
}
}
impl ConnectorIntegration<Void, PaymentsCancelData, PaymentsResponseData> for Tokenio {
fn build_request(
&self,
_req: &PaymentsCancelRouterData,
_connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Err(errors::ConnectorError::FlowNotSupported {
flow: "Refunds".to_string(),
connector: "Tokenio".to_string(),
}
.into())
}
}
impl ConnectorIntegration<Execute, RefundsData, RefundsResponseData> for Tokenio {
fn build_request(
&self,
_req: &RefundsRouterData<Execute>,
_connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Err(errors::ConnectorError::FlowNotSupported {
flow: "Refunds".to_string(),
connector: "Tokenio".to_string(),
}
.into())
}
}
impl ConnectorIntegration<RSync, RefundsData, RefundsResponseData> for Tokenio {
fn build_request(
&self,
_req: &RefundSyncRouterData,
_connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Err(errors::ConnectorError::FlowNotSupported {
flow: "Refund Sync".to_string(),
connector: "Tokenio".to_string(),
}
.into())
}
}
#[async_trait::async_trait]
impl webhooks::IncomingWebhook for Tokenio {
fn get_webhook_object_reference_id(
&self,
request: &webhooks::IncomingWebhookRequestDetails<'_>,
) -> CustomResult<api_models::webhooks::ObjectReferenceId, errors::ConnectorError> {
let webhook_payload: tokenio::TokenioWebhookPayload = request
.body
.parse_struct("TokenioWebhookPayload")
.change_context(errors::ConnectorError::WebhookBodyDecodingFailed)?;
match &webhook_payload.event_data {
tokenio::TokenioWebhookEventData::PaymentV2 { payment } => {
Ok(api_models::webhooks::ObjectReferenceId::PaymentId(
api_models::payments::PaymentIdType::ConnectorTransactionId(payment.id.clone()),
))
}
}
}
fn get_webhook_event_type(
&self,
request: &webhooks::IncomingWebhookRequestDetails<'_>,
) -> CustomResult<api_models::webhooks::IncomingWebhookEvent, errors::ConnectorError> {
// Check token-event header first
let event_type = if let Some(header_value) = request.headers.get("token-event") {
header_value
.to_str()
.change_context(errors::ConnectorError::WebhookEventTypeNotFound)?
.to_string()
} else {
// Fallback to parsing body for eventType field
let webhook_payload: tokenio::TokenioWebhookPayload = request
.body
.parse_struct("TokenioWebhookPayload")
.change_context(errors::ConnectorError::WebhookBodyDecodingFailed)?;
webhook_payload
.event_type
.ok_or(errors::ConnectorError::WebhookEventTypeNotFound)?
};
match event_type.as_str() {
"PAYMENT_STATUS_CHANGED" => {
let webhook_payload: tokenio::TokenioWebhookPayload = request
.body
.parse_struct("TokenioWebhookPayload")
.change_context(errors::ConnectorError::WebhookBodyDecodingFailed)?;
let tokenio::TokenioWebhookEventData::PaymentV2 { payment } =
&webhook_payload.event_data;
match payment.status {
TokenioPaymentStatus::InitiationCompleted => {
Ok(api_models::webhooks::IncomingWebhookEvent::PaymentIntentProcessing)
}
TokenioPaymentStatus::PaymentCompleted => {
Ok(api_models::webhooks::IncomingWebhookEvent::PaymentIntentSuccess)
}
TokenioPaymentStatus::PaymentFailed => {
Ok(api_models::webhooks::IncomingWebhookEvent::PaymentIntentFailure)
}
TokenioPaymentStatus::PaymentCancelled => {
Ok(api_models::webhooks::IncomingWebhookEvent::PaymentIntentCancelled)
}
TokenioPaymentStatus::InitiationRejected => {
Ok(api_models::webhooks::IncomingWebhookEvent::PaymentIntentFailure)
}
TokenioPaymentStatus::InitiationProcessing => {
Ok(api_models::webhooks::IncomingWebhookEvent::PaymentIntentProcessing)
}
TokenioPaymentStatus::InitiationPendingRedirectHp => {
Ok(api_models::webhooks::IncomingWebhookEvent::PaymentIntentProcessing)
}
TokenioPaymentStatus::Other => {
Ok(api_models::webhooks::IncomingWebhookEvent::EventNotSupported)
}
}
}
_ => Ok(api_models::webhooks::IncomingWebhookEvent::EventNotSupported),
}
}
fn get_webhook_resource_object(
&self,
request: &webhooks::IncomingWebhookRequestDetails<'_>,
) -> CustomResult<Box<dyn masking::ErasedMaskSerialize>, errors::ConnectorError> {
let webhook_payload: tokenio::TokenioWebhookPayload = request
.body
.parse_struct("TokenioWebhookPayload")
.change_context(errors::ConnectorError::WebhookBodyDecodingFailed)?;
Ok(Box::new(webhook_payload))
}
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: crypto::Encryptable<Secret<serde_json::Value>>,
connector_name: &str,
) -> CustomResult<bool, errors::ConnectorError> {
let connector_webhook_secrets = self
.get_webhook_source_verification_merchant_secret(
merchant_id,
connector_name,
connector_webhook_details,
)
.await?;
// Convert UTF-8 bytes back to base64url string
let base64url_string = String::from_utf8(connector_webhook_secrets.secret)
.change_context(errors::ConnectorError::WebhookSourceVerificationFailed)
.attach_printable("Failed to convert public key bytes to base64url string")?;
// Decode base64url string to actual ED25519 key bytes
let public_key_bytes = URL_SAFE_NO_PAD
.decode(&base64url_string)
.change_context(errors::ConnectorError::WebhookSourceVerificationFailed)
.attach_printable("Failed to decode base64url public key to ED25519 bytes")?;
// Extract the signature from token-signature header
let signature_header = request
.headers
.get("token-signature")
.ok_or(errors::ConnectorError::WebhookSignatureNotFound)?
.to_str()
.change_context(errors::ConnectorError::WebhookSignatureNotFound)
.attach_printable("Failed to convert token-signature header to string")?;
// Decode the base64url signature to bytes
let signature_bytes = URL_SAFE_NO_PAD
.decode(signature_header)
.change_context(errors::ConnectorError::WebhookSignatureNotFound)
.attach_printable("Failed to decode base64url signature")?;
// Get the raw message body (this is what Token.io signed)
let message_bytes = request.body;
// Use ED25519 to verify the signature
let ed25519 = crypto::Ed25519;
let is_valid = ed25519
.verify_signature(
&public_key_bytes,
&signature_bytes, // ED25519 signature (64 bytes)
message_bytes, // Raw webhook body
)
.change_context(errors::ConnectorError::WebhookSourceVerificationFailed)
.attach_printable("ED25519 signature verification failed")?;
Ok(is_valid)
}
}
static TOKENIO_SUPPORTED_PAYMENT_METHODS: LazyLock<SupportedPaymentMethods> = LazyLock::new(|| {
let supported_capture_methods = vec![
enums::CaptureMethod::Automatic,
enums::CaptureMethod::Manual,
enums::CaptureMethod::SequentialAutomatic,
];
let mut tokenio_supported_payment_methods = SupportedPaymentMethods::new();
// Open Banking - SEPA
tokenio_supported_payment_methods.add(
enums::PaymentMethod::OpenBanking,
PaymentMethodType::OpenBankingPIS,
PaymentMethodDetails {
mandates: FeatureStatus::NotSupported,
refunds: FeatureStatus::NotSupported,
supported_capture_methods: supported_capture_methods.clone(),
specific_features: None,
},
);
tokenio_supported_payment_methods
});
static TOKENIO_CONNECTOR_INFO: ConnectorInfo = ConnectorInfo {
display_name: "Token.io",
description: "Token.io is a financial technology company that provides Open Banking and real-time payment solutions across Europe. They enable secure bank-to-bank transfers using various payment rails including SEPA, Faster Payments, and other regional payment systems.",
connector_type: enums::HyperswitchConnectorCategory::PaymentGateway,
integration_status: enums::ConnectorIntegrationStatus::Sandbox,
};
static TOKENIO_SUPPORTED_WEBHOOK_FLOWS: [enums::EventClass; 1] = [enums::EventClass::Payments];
impl ConnectorSpecifications for Tokenio {
fn get_connector_about(&self) -> Option<&'static ConnectorInfo> {
Some(&TOKENIO_CONNECTOR_INFO)
}
fn get_supported_payment_methods(&self) -> Option<&'static SupportedPaymentMethods> {
Some(&*TOKENIO_SUPPORTED_PAYMENT_METHODS)
}
fn get_supported_webhook_flows(&self) -> Option<&'static [enums::EventClass]> {
Some(&TOKENIO_SUPPORTED_WEBHOOK_FLOWS)
}
}
|
{
"crate": "hyperswitch_connectors",
"file": "crates/hyperswitch_connectors/src/connectors/tokenio.rs",
"file_size": null,
"is_async": null,
"is_pub": null,
"num_enums": 0,
"num_structs": 1,
"num_tables": null,
"score": null,
"total_crates": null
}
|
file_hyperswitch_connectors_4722660579388774159
|
clm
|
file
|
// Repository: hyperswitch
// Crate: hyperswitch_connectors
// File: crates/hyperswitch_connectors/src/connectors/vgs.rs
// Contains: 1 structs, 0 enums
pub mod transformers;
use base64::Engine;
use common_utils::{
errors::CustomResult,
ext_traits::BytesExt,
request::{Method, Request, RequestBuilder, RequestContent},
};
use error_stack::{report, ResultExt};
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},
ExternalVaultInsertFlow, ExternalVaultRetrieveFlow,
},
router_request_types::{
AccessTokenRequestData, PaymentMethodTokenizationData, PaymentsAuthorizeData,
PaymentsCancelData, PaymentsCaptureData, PaymentsSessionData, PaymentsSyncData,
RefundsData, SetupMandateRequestData, VaultRequestData,
},
router_response_types::{PaymentsResponseData, RefundsResponseData, VaultResponseData},
types::VaultRouterData,
};
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;
use transformers as vgs;
use crate::{constants::headers, types::ResponseRouterData};
#[derive(Clone)]
pub struct Vgs;
impl api::Payment for Vgs {}
impl api::PaymentSession for Vgs {}
impl api::ConnectorAccessToken for Vgs {}
impl api::MandateSetup for Vgs {}
impl api::PaymentAuthorize for Vgs {}
impl api::PaymentSync for Vgs {}
impl api::PaymentCapture for Vgs {}
impl api::PaymentVoid for Vgs {}
impl api::Refund for Vgs {}
impl api::RefundExecute for Vgs {}
impl api::RefundSync for Vgs {}
impl api::PaymentToken for Vgs {}
impl api::ExternalVaultInsert for Vgs {}
impl api::ExternalVault for Vgs {}
impl api::ExternalVaultRetrieve for Vgs {}
impl ConnectorIntegration<PaymentMethodToken, PaymentMethodTokenizationData, PaymentsResponseData>
for Vgs
{
// Not Implemented (R)
}
impl<Flow, Request, Response> ConnectorCommonExt<Flow, Request, Response> for Vgs
where
Self: ConnectorIntegration<Flow, Request, Response>,
{
fn build_headers(
&self,
req: &RouterData<Flow, Request, Response>,
_connectors: &Connectors,
) -> CustomResult<Vec<(String, masking::Maskable<String>)>, errors::ConnectorError> {
let auth = vgs::VgsAuthType::try_from(&req.connector_auth_type)
.change_context(errors::ConnectorError::FailedToObtainAuthType)?;
let auth_value = auth
.username
.zip(auth.password)
.map(|(username, password)| {
format!(
"Basic {}",
common_utils::consts::BASE64_ENGINE.encode(format!("{username}:{password}"))
)
});
Ok(vec![(
headers::AUTHORIZATION.to_string(),
auth_value.into_masked(),
)])
}
}
impl ConnectorCommon for Vgs {
fn id(&self) -> &'static str {
"vgs"
}
fn get_currency_unit(&self) -> api::CurrencyUnit {
api::CurrencyUnit::Minor
}
fn common_get_content_type(&self) -> &'static str {
"application/json"
}
fn base_url<'a>(&self, connectors: &'a Connectors) -> &'a str {
connectors.vgs.base_url.as_ref()
}
fn get_auth_header(
&self,
_auth_type: &ConnectorAuthType,
) -> CustomResult<Vec<(String, masking::Maskable<String>)>, errors::ConnectorError> {
Ok(vec![])
}
fn build_error_response(
&self,
res: Response,
event_builder: Option<&mut ConnectorEvent>,
) -> CustomResult<ErrorResponse, errors::ConnectorError> {
let response: vgs::VgsErrorResponse = res
.response
.parse_struct("VgsErrorResponse")
.change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
event_builder.map(|i| i.set_response_body(&response));
router_env::logger::info!(connector_response=?response);
let error = response
.errors
.first()
.ok_or(errors::ConnectorError::ResponseHandlingFailed)?;
Ok(ErrorResponse {
status_code: res.status_code,
code: error.code.clone(),
message: error.code.clone(),
reason: error.detail.clone(),
attempt_status: None,
connector_transaction_id: None,
network_decline_code: None,
network_advice_code: None,
network_error_message: None,
connector_metadata: None,
})
}
}
impl ConnectorValidation for Vgs {}
impl ConnectorIntegration<Session, PaymentsSessionData, PaymentsResponseData> for Vgs {}
impl ConnectorIntegration<AccessTokenAuth, AccessTokenRequestData, AccessToken> for Vgs {}
impl ConnectorIntegration<SetupMandate, SetupMandateRequestData, PaymentsResponseData> for Vgs {}
impl ConnectorIntegration<Authorize, PaymentsAuthorizeData, PaymentsResponseData> for Vgs {}
impl ConnectorIntegration<PSync, PaymentsSyncData, PaymentsResponseData> for Vgs {}
impl ConnectorIntegration<Capture, PaymentsCaptureData, PaymentsResponseData> for Vgs {}
impl ConnectorIntegration<Void, PaymentsCancelData, PaymentsResponseData> for Vgs {}
impl ConnectorIntegration<Execute, RefundsData, RefundsResponseData> for Vgs {}
impl ConnectorIntegration<RSync, RefundsData, RefundsResponseData> for Vgs {}
impl ConnectorIntegration<ExternalVaultInsertFlow, VaultRequestData, VaultResponseData> for Vgs {
fn get_url(
&self,
_req: &VaultRouterData<ExternalVaultInsertFlow>,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
Ok(format!("{}aliases", self.base_url(connectors)))
}
fn get_headers(
&self,
req: &VaultRouterData<ExternalVaultInsertFlow>,
connectors: &Connectors,
) -> CustomResult<Vec<(String, masking::Maskable<String>)>, errors::ConnectorError> {
self.build_headers(req, connectors)
}
fn get_request_body(
&self,
req: &VaultRouterData<ExternalVaultInsertFlow>,
_connectors: &Connectors,
) -> CustomResult<RequestContent, errors::ConnectorError> {
let connector_req = vgs::VgsInsertRequest::try_from(req)?;
Ok(RequestContent::Json(Box::new(connector_req)))
}
fn build_request(
&self,
req: &VaultRouterData<ExternalVaultInsertFlow>,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Ok(Some(
RequestBuilder::new()
.method(Method::Post)
.url(&types::ExternalVaultInsertType::get_url(
self, req, connectors,
)?)
.attach_default_headers()
.headers(types::ExternalVaultInsertType::get_headers(
self, req, connectors,
)?)
.set_body(types::ExternalVaultInsertType::get_request_body(
self, req, connectors,
)?)
.build(),
))
}
fn handle_response(
&self,
data: &VaultRouterData<ExternalVaultInsertFlow>,
event_builder: Option<&mut ConnectorEvent>,
res: Response,
) -> CustomResult<VaultRouterData<ExternalVaultInsertFlow>, errors::ConnectorError> {
let response: vgs::VgsInsertResponse = res
.response
.parse_struct("VgsInsertResponse")
.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,
})
}
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<ExternalVaultRetrieveFlow, VaultRequestData, VaultResponseData> for Vgs {
fn get_url(
&self,
req: &VaultRouterData<ExternalVaultRetrieveFlow>,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
let alias = req.request.connector_vault_id.clone().ok_or(
errors::ConnectorError::MissingRequiredField {
field_name: "connector_vault_id",
},
)?;
Ok(format!("{}aliases/{alias}", self.base_url(connectors)))
}
fn get_headers(
&self,
req: &VaultRouterData<ExternalVaultRetrieveFlow>,
connectors: &Connectors,
) -> CustomResult<Vec<(String, masking::Maskable<String>)>, errors::ConnectorError> {
self.build_headers(req, connectors)
}
fn get_http_method(&self) -> Method {
Method::Get
}
fn build_request(
&self,
req: &VaultRouterData<ExternalVaultRetrieveFlow>,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Ok(Some(
RequestBuilder::new()
.method(Method::Get)
.url(&types::ExternalVaultRetrieveType::get_url(
self, req, connectors,
)?)
.attach_default_headers()
.headers(types::ExternalVaultRetrieveType::get_headers(
self, req, connectors,
)?)
.build(),
))
}
fn handle_response(
&self,
data: &VaultRouterData<ExternalVaultRetrieveFlow>,
event_builder: Option<&mut ConnectorEvent>,
res: Response,
) -> CustomResult<VaultRouterData<ExternalVaultRetrieveFlow>, errors::ConnectorError> {
let response: vgs::VgsRetrieveResponse =
res.response
.parse_struct("VgsRetrieveResponse")
.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,
})
}
fn get_error_response(
&self,
res: Response,
event_builder: Option<&mut ConnectorEvent>,
) -> CustomResult<ErrorResponse, errors::ConnectorError> {
self.build_error_response(res, event_builder)
}
}
#[async_trait::async_trait]
impl webhooks::IncomingWebhook for Vgs {
fn get_webhook_object_reference_id(
&self,
_request: &webhooks::IncomingWebhookRequestDetails<'_>,
) -> CustomResult<api_models::webhooks::ObjectReferenceId, errors::ConnectorError> {
Err(report!(errors::ConnectorError::WebhooksNotImplemented))
}
fn get_webhook_event_type(
&self,
_request: &webhooks::IncomingWebhookRequestDetails<'_>,
) -> CustomResult<api_models::webhooks::IncomingWebhookEvent, errors::ConnectorError> {
Err(report!(errors::ConnectorError::WebhooksNotImplemented))
}
fn get_webhook_resource_object(
&self,
_request: &webhooks::IncomingWebhookRequestDetails<'_>,
) -> CustomResult<Box<dyn masking::ErasedMaskSerialize>, errors::ConnectorError> {
Err(report!(errors::ConnectorError::WebhooksNotImplemented))
}
}
impl ConnectorSpecifications for Vgs {}
|
{
"crate": "hyperswitch_connectors",
"file": "crates/hyperswitch_connectors/src/connectors/vgs.rs",
"file_size": null,
"is_async": null,
"is_pub": null,
"num_enums": 0,
"num_structs": 1,
"num_tables": null,
"score": null,
"total_crates": null
}
|
file_hyperswitch_connectors_917792140622067655
|
clm
|
file
|
// Repository: hyperswitch
// Crate: hyperswitch_connectors
// File: crates/hyperswitch_connectors/src/connectors/bamboraapac.rs
// Contains: 1 structs, 0 enums
pub mod transformers;
use std::sync::LazyLock;
use api_models::webhooks::{IncomingWebhookEvent, ObjectReferenceId};
use common_enums::enums;
use common_utils::{
errors::CustomResult,
ext_traits::{BytesExt, XmlExt},
request::{Method, Request, RequestBuilder, RequestContent},
types::{AmountConvertor, MinorUnit, MinorUnitForConnector},
};
use error_stack::{report, Report, ResultExt};
use hyperswitch_domain_models::{
payment_method_data::PaymentMethodData,
router_data::{AccessToken, 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::{
ConnectorInfo, PaymentMethodDetails, PaymentsResponseData, RefundsResponseData,
SupportedPaymentMethods, SupportedPaymentMethodsExt,
},
types::{
PaymentsAuthorizeRouterData, PaymentsCaptureRouterData, PaymentsSyncRouterData,
RefundExecuteRouterData, RefundSyncRouterData, SetupMandateRouterData,
},
};
use hyperswitch_interfaces::{
api::{
self, ConnectorCommon, ConnectorCommonExt, ConnectorIntegration, ConnectorSpecifications,
ConnectorValidation,
},
configs::Connectors,
consts::{NO_ERROR_CODE, NO_ERROR_MESSAGE},
errors,
events::connector_api_logs::ConnectorEvent,
types::{self, Response},
webhooks::{IncomingWebhook, IncomingWebhookRequestDetails},
};
use transformers as bamboraapac;
use crate::{
constants::headers,
types::ResponseRouterData,
utils::{self, convert_amount},
};
#[derive(Clone)]
pub struct Bamboraapac {
amount_converter: &'static (dyn AmountConvertor<Output = MinorUnit> + Sync),
}
impl Bamboraapac {
pub const fn new() -> &'static Self {
&Self {
amount_converter: &MinorUnitForConnector,
}
}
}
impl api::Payment for Bamboraapac {}
impl api::PaymentSession for Bamboraapac {}
impl api::ConnectorAccessToken for Bamboraapac {}
impl api::MandateSetup for Bamboraapac {}
impl api::PaymentAuthorize for Bamboraapac {}
impl api::PaymentSync for Bamboraapac {}
impl api::PaymentCapture for Bamboraapac {}
impl api::PaymentVoid for Bamboraapac {}
impl api::Refund for Bamboraapac {}
impl api::RefundExecute for Bamboraapac {}
impl api::RefundSync for Bamboraapac {}
impl api::PaymentToken for Bamboraapac {}
impl ConnectorIntegration<PaymentMethodToken, PaymentMethodTokenizationData, PaymentsResponseData>
for Bamboraapac
{
// Not Implemented (R)
}
impl<Flow, Request, Response> ConnectorCommonExt<Flow, Request, Response> for Bamboraapac
where
Self: ConnectorIntegration<Flow, Request, Response>,
{
fn build_headers(
&self,
_req: &RouterData<Flow, Request, Response>,
_connectors: &Connectors,
) -> CustomResult<Vec<(String, masking::Maskable<String>)>, errors::ConnectorError> {
let header = vec![(
headers::CONTENT_TYPE.to_string(),
self.get_content_type().to_string().into(),
)];
Ok(header)
}
}
impl ConnectorValidation for Bamboraapac {
fn validate_mandate_payment(
&self,
_pm_type: Option<enums::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()),
}
}
}
impl ConnectorCommon for Bamboraapac {
fn id(&self) -> &'static str {
"bamboraapac"
}
fn get_currency_unit(&self) -> api::CurrencyUnit {
api::CurrencyUnit::Minor
}
fn common_get_content_type(&self) -> &'static str {
"text/xml"
}
fn base_url<'a>(&self, connectors: &'a Connectors) -> &'a str {
connectors.bamboraapac.base_url.as_ref()
}
fn build_error_response(
&self,
res: Response,
event_builder: Option<&mut ConnectorEvent>,
) -> CustomResult<ErrorResponse, errors::ConnectorError> {
let response: Result<
bamboraapac::BamboraapacErrorResponse,
Report<common_utils::errors::ParsingError>,
> = res.response.parse_struct("BamboraapacErrorResponse");
match response {
Ok(response_data) => {
event_builder.map(|i| i.set_error_response_body(&response_data));
router_env::logger::info!(connector_response=?response_data);
Ok(ErrorResponse {
status_code: res.status_code,
code: response_data
.declined_code
.unwrap_or(NO_ERROR_CODE.to_string()),
message: response_data
.declined_message
.clone()
.unwrap_or(NO_ERROR_MESSAGE.to_string()),
reason: response_data.declined_message,
attempt_status: None,
connector_transaction_id: None,
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
connector_metadata: None,
})
}
Err(error_msg) => {
event_builder.map(|event| event.set_error(serde_json::json!({"error": res.response.escape_ascii().to_string(), "status_code": res.status_code})));
router_env::logger::error!(deserialization_error =? error_msg);
utils::handle_json_response_deserialization_failure(res, "bamboaraapac")
}
}
}
}
impl ConnectorIntegration<Session, PaymentsSessionData, PaymentsResponseData> for Bamboraapac {
//TODO: implement sessions flow
}
impl ConnectorIntegration<AccessTokenAuth, AccessTokenRequestData, AccessToken> for Bamboraapac {}
impl ConnectorIntegration<SetupMandate, SetupMandateRequestData, PaymentsResponseData>
for Bamboraapac
{
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!("{}/sipp.asmx", self.base_url(connectors)))
}
fn get_request_body(
&self,
req: &SetupMandateRouterData,
_connectors: &Connectors,
) -> CustomResult<RequestContent, errors::ConnectorError> {
let connector_req = bamboraapac::get_setup_mandate_body(req)?;
Ok(RequestContent::RawBytes(connector_req))
}
fn build_request(
&self,
req: &SetupMandateRouterData,
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,
)?)
.build(),
))
}
fn handle_response(
&self,
data: &SetupMandateRouterData,
event_builder: Option<&mut ConnectorEvent>,
res: Response,
) -> CustomResult<SetupMandateRouterData, errors::ConnectorError> {
let response_data = html_to_xml_string_conversion(
String::from_utf8(res.response.to_vec())
.change_context(errors::ConnectorError::ResponseDeserializationFailed)?,
);
let response = response_data
.parse_xml::<bamboraapac::BamboraapacMandateResponse>()
.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,
})
}
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<Authorize, PaymentsAuthorizeData, PaymentsResponseData> for Bamboraapac {
fn get_headers(
&self,
req: &PaymentsAuthorizeRouterData,
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: &PaymentsAuthorizeRouterData,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
Ok(format!("{}/dts.asmx", self.base_url(connectors)))
}
fn get_request_body(
&self,
req: &PaymentsAuthorizeRouterData,
_connectors: &Connectors,
) -> CustomResult<RequestContent, errors::ConnectorError> {
let amount = convert_amount(
self.amount_converter,
req.request.minor_amount,
req.request.currency,
)?;
let connector_router_data = bamboraapac::BamboraapacRouterData::try_from((amount, req))?;
let connector_req = bamboraapac::get_payment_body(&connector_router_data)?;
Ok(RequestContent::RawBytes(connector_req))
}
fn build_request(
&self,
req: &PaymentsAuthorizeRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Ok(Some(
RequestBuilder::new()
.method(Method::Post)
.url(&types::PaymentsAuthorizeType::get_url(
self, req, connectors,
)?)
.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_data = html_to_xml_string_conversion(
String::from_utf8(res.response.to_vec())
.change_context(errors::ConnectorError::ResponseDeserializationFailed)?,
);
let response = response_data
.parse_xml::<bamboraapac::BamboraapacPaymentsResponse>()
.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,
})
}
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<PSync, PaymentsSyncData, PaymentsResponseData> for Bamboraapac {
fn get_headers(
&self,
req: &PaymentsSyncRouterData,
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: &PaymentsSyncRouterData,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
Ok(format!("{}/dts.asmx", self.base_url(connectors)))
}
fn get_request_body(
&self,
req: &PaymentsSyncRouterData,
_connectors: &Connectors,
) -> CustomResult<RequestContent, errors::ConnectorError> {
let connector_req = bamboraapac::get_payment_sync_body(req)?;
Ok(RequestContent::RawBytes(connector_req))
}
fn build_request(
&self,
req: &PaymentsSyncRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Ok(Some(
RequestBuilder::new()
.method(Method::Post)
.url(&types::PaymentsSyncType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(types::PaymentsSyncType::get_headers(self, req, connectors)?)
.set_body(types::PaymentsSyncType::get_request_body(
self, req, connectors,
)?)
.build(),
))
}
fn handle_response(
&self,
data: &PaymentsSyncRouterData,
event_builder: Option<&mut ConnectorEvent>,
res: Response,
) -> CustomResult<PaymentsSyncRouterData, errors::ConnectorError> {
let response_data = html_to_xml_string_conversion(
String::from_utf8(res.response.to_vec())
.change_context(errors::ConnectorError::ResponseDeserializationFailed)?,
);
let response = response_data
.parse_xml::<bamboraapac::BamboraapacSyncResponse>()
.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,
})
}
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 Bamboraapac {
fn get_headers(
&self,
req: &PaymentsCaptureRouterData,
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: &PaymentsCaptureRouterData,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
Ok(format!("{}/dts.asmx", self.base_url(connectors)))
}
fn get_request_body(
&self,
req: &PaymentsCaptureRouterData,
_connectors: &Connectors,
) -> CustomResult<RequestContent, errors::ConnectorError> {
let amount = convert_amount(
self.amount_converter,
req.request.minor_amount_to_capture,
req.request.currency,
)?;
let connector_router_data = bamboraapac::BamboraapacRouterData::try_from((amount, req))?;
let connector_req = bamboraapac::get_capture_body(&connector_router_data)?;
Ok(RequestContent::RawBytes(connector_req))
}
fn build_request(
&self,
req: &PaymentsCaptureRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Ok(Some(
RequestBuilder::new()
.method(Method::Post)
.url(&types::PaymentsCaptureType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(types::PaymentsCaptureType::get_headers(
self, req, connectors,
)?)
.set_body(types::PaymentsCaptureType::get_request_body(
self, req, connectors,
)?)
.build(),
))
}
fn handle_response(
&self,
data: &PaymentsCaptureRouterData,
event_builder: Option<&mut ConnectorEvent>,
res: Response,
) -> CustomResult<PaymentsCaptureRouterData, errors::ConnectorError> {
let response_data = html_to_xml_string_conversion(
String::from_utf8(res.response.to_vec())
.change_context(errors::ConnectorError::ResponseDeserializationFailed)?,
);
let response = response_data
.parse_xml::<bamboraapac::BamboraapacCaptureResponse>()
.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,
})
}
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<Void, PaymentsCancelData, PaymentsResponseData> for Bamboraapac {}
impl ConnectorIntegration<Execute, RefundsData, RefundsResponseData> for Bamboraapac {
fn get_headers(
&self,
req: &RefundExecuteRouterData,
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: &RefundExecuteRouterData,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
Ok(format!("{}/dts.asmx", self.base_url(connectors)))
}
fn get_request_body(
&self,
req: &RefundExecuteRouterData,
_connectors: &Connectors,
) -> CustomResult<RequestContent, errors::ConnectorError> {
let amount = convert_amount(
self.amount_converter,
req.request.minor_refund_amount,
req.request.currency,
)?;
let connector_router_data = bamboraapac::BamboraapacRouterData::try_from((amount, req))?;
let connector_req = bamboraapac::get_refund_body(&connector_router_data)?;
Ok(RequestContent::RawBytes(connector_req))
}
fn build_request(
&self,
req: &RefundExecuteRouterData,
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))
}
fn handle_response(
&self,
data: &RefundExecuteRouterData,
event_builder: Option<&mut ConnectorEvent>,
res: Response,
) -> CustomResult<RefundExecuteRouterData, errors::ConnectorError> {
let response_data = html_to_xml_string_conversion(
String::from_utf8(res.response.to_vec())
.change_context(errors::ConnectorError::ResponseDeserializationFailed)?,
);
let response = response_data
.parse_xml::<bamboraapac::BamboraapacRefundsResponse>()
.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,
})
}
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<RSync, RefundsData, RefundsResponseData> for Bamboraapac {
fn get_headers(
&self,
req: &RefundSyncRouterData,
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: &RefundSyncRouterData,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
Ok(format!("{}/dts.asmx", self.base_url(connectors)))
}
fn get_request_body(
&self,
req: &RefundSyncRouterData,
_connectors: &Connectors,
) -> CustomResult<RequestContent, errors::ConnectorError> {
let connector_req = bamboraapac::get_refund_sync_body(req)?;
Ok(RequestContent::RawBytes(connector_req))
}
fn build_request(
&self,
req: &RefundSyncRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Ok(Some(
RequestBuilder::new()
.method(Method::Post)
.url(&types::RefundSyncType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(types::RefundSyncType::get_headers(self, req, connectors)?)
.set_body(types::RefundSyncType::get_request_body(
self, req, connectors,
)?)
.build(),
))
}
fn handle_response(
&self,
data: &RefundSyncRouterData,
event_builder: Option<&mut ConnectorEvent>,
res: Response,
) -> CustomResult<RefundSyncRouterData, errors::ConnectorError> {
let response_data = html_to_xml_string_conversion(
String::from_utf8(res.response.to_vec())
.change_context(errors::ConnectorError::ResponseDeserializationFailed)?,
);
let response = response_data
.parse_xml::<bamboraapac::BamboraapacSyncResponse>()
.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,
})
}
fn get_error_response(
&self,
res: Response,
event_builder: Option<&mut ConnectorEvent>,
) -> CustomResult<ErrorResponse, errors::ConnectorError> {
self.build_error_response(res, event_builder)
}
}
#[async_trait::async_trait]
impl IncomingWebhook for Bamboraapac {
fn get_webhook_object_reference_id(
&self,
_request: &IncomingWebhookRequestDetails<'_>,
) -> CustomResult<ObjectReferenceId, errors::ConnectorError> {
Err(report!(errors::ConnectorError::WebhooksNotImplemented))
}
fn get_webhook_event_type(
&self,
_request: &IncomingWebhookRequestDetails<'_>,
) -> CustomResult<IncomingWebhookEvent, errors::ConnectorError> {
Err(report!(errors::ConnectorError::WebhooksNotImplemented))
}
fn get_webhook_resource_object(
&self,
_request: &IncomingWebhookRequestDetails<'_>,
) -> CustomResult<Box<dyn masking::ErasedMaskSerialize>, errors::ConnectorError> {
Err(report!(errors::ConnectorError::WebhooksNotImplemented))
}
}
fn html_to_xml_string_conversion(res: String) -> String {
res.replace("<", "<").replace(">", ">")
}
static BAMBORAAPAC_SUPPORTED_PAYMENT_METHODS: LazyLock<SupportedPaymentMethods> =
LazyLock::new(|| {
let default_capture_methods = vec![
enums::CaptureMethod::Automatic,
enums::CaptureMethod::Manual,
enums::CaptureMethod::SequentialAutomatic,
];
let supported_card_network = vec![
common_enums::CardNetwork::Visa,
common_enums::CardNetwork::Mastercard,
common_enums::CardNetwork::DinersClub,
common_enums::CardNetwork::Interac,
common_enums::CardNetwork::AmericanExpress,
common_enums::CardNetwork::JCB,
common_enums::CardNetwork::Discover,
common_enums::CardNetwork::CartesBancaires,
common_enums::CardNetwork::UnionPay,
];
let mut bamboraapac_supported_payment_methods = SupportedPaymentMethods::new();
bamboraapac_supported_payment_methods.add(
enums::PaymentMethod::Card,
enums::PaymentMethodType::Credit,
PaymentMethodDetails {
mandates: common_enums::FeatureStatus::Supported,
refunds: common_enums::FeatureStatus::Supported,
supported_capture_methods: default_capture_methods.clone(),
specific_features: Some(
api_models::feature_matrix::PaymentMethodSpecificFeatures::Card({
api_models::feature_matrix::CardSpecificFeatures {
three_ds: common_enums::FeatureStatus::Supported,
no_three_ds: common_enums::FeatureStatus::Supported,
supported_card_networks: supported_card_network.clone(),
}
}),
),
},
);
bamboraapac_supported_payment_methods.add(
enums::PaymentMethod::Card,
enums::PaymentMethodType::Debit,
PaymentMethodDetails {
mandates: common_enums::FeatureStatus::Supported,
refunds: common_enums::FeatureStatus::Supported,
supported_capture_methods: default_capture_methods.clone(),
specific_features: Some(
api_models::feature_matrix::PaymentMethodSpecificFeatures::Card({
api_models::feature_matrix::CardSpecificFeatures {
three_ds: common_enums::FeatureStatus::Supported,
no_three_ds: common_enums::FeatureStatus::Supported,
supported_card_networks: supported_card_network.clone(),
}
}),
),
},
);
bamboraapac_supported_payment_methods
});
static BAMBORAAPAC_CONNECTOR_INFO: ConnectorInfo = ConnectorInfo {
display_name: "Bambora Asia-Pacific",
description: "Bambora Asia-Pacific, provides comprehensive payment solutions, offering merchants smart and smooth payment processing capabilities.",
connector_type: enums::HyperswitchConnectorCategory::PaymentGateway,
integration_status: enums::ConnectorIntegrationStatus::Sandbox,
};
static BAMBORAAPAC_SUPPORTED_WEBHOOK_FLOWS: [common_enums::EventClass; 0] = [];
impl ConnectorSpecifications for Bamboraapac {
fn get_connector_about(&self) -> Option<&'static ConnectorInfo> {
Some(&BAMBORAAPAC_CONNECTOR_INFO)
}
fn get_supported_payment_methods(&self) -> Option<&'static SupportedPaymentMethods> {
Some(&*BAMBORAAPAC_SUPPORTED_PAYMENT_METHODS)
}
fn get_supported_webhook_flows(&self) -> Option<&'static [enums::EventClass]> {
Some(&BAMBORAAPAC_SUPPORTED_WEBHOOK_FLOWS)
}
}
|
{
"crate": "hyperswitch_connectors",
"file": "crates/hyperswitch_connectors/src/connectors/bamboraapac.rs",
"file_size": null,
"is_async": null,
"is_pub": null,
"num_enums": 0,
"num_structs": 1,
"num_tables": null,
"score": null,
"total_crates": null
}
|
file_hyperswitch_connectors_-4576627754727051611
|
clm
|
file
|
// Repository: hyperswitch
// Crate: hyperswitch_connectors
// File: crates/hyperswitch_connectors/src/connectors/gpayments.rs
// Contains: 1 structs, 0 enums
pub mod gpayments_types;
pub mod transformers;
use api_models::webhooks::{IncomingWebhookEvent, ObjectReferenceId};
use common_utils::{
errors::CustomResult,
ext_traits::ByteSliceExt,
request::{Method, Request, RequestBuilder, RequestContent},
types::{AmountConvertor, MinorUnit, MinorUnitForConnector},
};
use error_stack::{report, ResultExt};
use gpayments_types::GpaymentsConnectorMetaData;
use hyperswitch_domain_models::{
router_data::{AccessToken, ConnectorAuthType, ErrorResponse, RouterData},
router_flow_types::{
authentication::{
Authentication, PostAuthentication, PreAuthentication, PreAuthenticationVersionCall,
},
AccessTokenAuth, Authorize, Capture, Execute, PSync, PaymentMethodToken, RSync, Session,
SetupMandate, Void,
},
router_request_types::{
authentication::{
ConnectorAuthenticationRequestData, ConnectorPostAuthenticationRequestData,
PreAuthNRequestData,
},
AccessTokenRequestData, PaymentMethodTokenizationData, PaymentsAuthorizeData,
PaymentsCancelData, PaymentsCaptureData, PaymentsSessionData, PaymentsSyncData,
RefundsData, SetupMandateRequestData,
},
router_response_types::{
AuthenticationResponseData, ConnectorInfo, PaymentsResponseData, RefundsResponseData,
SupportedPaymentMethods,
},
};
use hyperswitch_interfaces::{
api::{
self,
authentication::{
ConnectorAuthentication, ConnectorPostAuthentication, ConnectorPreAuthentication,
ConnectorPreAuthenticationVersionCall, ExternalAuthentication,
},
ConnectorCommon, ConnectorCommonExt, ConnectorIntegration, ConnectorSpecifications,
ConnectorValidation,
},
configs::Connectors,
errors::ConnectorError,
events::connector_api_logs::ConnectorEvent,
types::Response,
webhooks::{IncomingWebhook, IncomingWebhookRequestDetails},
};
use masking::Maskable;
use transformers as gpayments;
use crate::{
constants::headers,
types::{
ConnectorAuthenticationRouterData, ConnectorAuthenticationType,
ConnectorPostAuthenticationRouterData, ConnectorPostAuthenticationType,
ConnectorPreAuthenticationType, ConnectorPreAuthenticationVersionCallType,
PreAuthNRouterData, PreAuthNVersionCallRouterData, ResponseRouterData,
},
utils::to_connector_meta,
};
#[derive(Clone)]
pub struct Gpayments {
_amount_converter: &'static (dyn AmountConvertor<Output = MinorUnit> + Sync),
}
impl Gpayments {
pub fn new() -> &'static Self {
&Self {
_amount_converter: &MinorUnitForConnector,
}
}
}
impl api::Payment for Gpayments {}
impl api::PaymentSession for Gpayments {}
impl api::ConnectorAccessToken for Gpayments {}
impl api::MandateSetup for Gpayments {}
impl api::PaymentAuthorize for Gpayments {}
impl api::PaymentSync for Gpayments {}
impl api::PaymentCapture for Gpayments {}
impl api::PaymentVoid for Gpayments {}
impl api::Refund for Gpayments {}
impl api::RefundExecute for Gpayments {}
impl api::RefundSync for Gpayments {}
impl api::PaymentToken for Gpayments {}
impl ConnectorIntegration<PaymentMethodToken, PaymentMethodTokenizationData, PaymentsResponseData>
for Gpayments
{
// Not Implemented (R)
}
impl<Flow, Request, Response> ConnectorCommonExt<Flow, Request, Response> for Gpayments
where
Self: ConnectorIntegration<Flow, Request, Response>,
{
fn build_headers(
&self,
_req: &RouterData<Flow, Request, Response>,
_connectors: &Connectors,
) -> CustomResult<Vec<(String, Maskable<String>)>, ConnectorError> {
let header = vec![(
headers::CONTENT_TYPE.to_string(),
self.get_content_type().to_string().into(),
)];
Ok(header)
}
}
impl ConnectorCommon for Gpayments {
fn id(&self) -> &'static str {
"gpayments"
}
fn get_currency_unit(&self) -> api::CurrencyUnit {
api::CurrencyUnit::Minor
// TODO! Check connector documentation, on which unit they are processing the currency.
// If the connector accepts amount in lower unit ( i.e cents for USD) then return api::CurrencyUnit::Minor,
// if connector accepts amount in base unit (i.e dollars for USD) then return api::CurrencyUnit::Base
}
fn common_get_content_type(&self) -> &'static str {
"application/json"
}
fn base_url<'a>(&self, connectors: &'a Connectors) -> &'a str {
connectors.gpayments.base_url.as_ref()
}
fn get_auth_header(
&self,
_auth_type: &ConnectorAuthType,
) -> CustomResult<Vec<(String, Maskable<String>)>, ConnectorError> {
Ok(vec![])
}
fn build_error_response(
&self,
res: Response,
event_builder: Option<&mut ConnectorEvent>,
) -> CustomResult<ErrorResponse, ConnectorError> {
let response: gpayments_types::TDS2ApiError = res
.response
.parse_struct("gpayments_types TDS2ApiError")
.change_context(ConnectorError::ResponseDeserializationFailed)?;
event_builder.map(|i| i.set_response_body(&response));
router_env::logger::info!(connector_response=?response);
Ok(ErrorResponse {
status_code: res.status_code,
code: response.error_code,
message: response.error_description,
reason: response.error_detail,
attempt_status: None,
connector_transaction_id: None,
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
connector_metadata: None,
})
}
}
impl ConnectorValidation for Gpayments {
//TODO: implement functions when support enabled
}
impl ConnectorIntegration<Session, PaymentsSessionData, PaymentsResponseData> for Gpayments {}
impl ConnectorIntegration<AccessTokenAuth, AccessTokenRequestData, AccessToken> for Gpayments {}
impl ConnectorIntegration<SetupMandate, SetupMandateRequestData, PaymentsResponseData>
for Gpayments
{
}
impl ConnectorIntegration<Authorize, PaymentsAuthorizeData, PaymentsResponseData> for Gpayments {}
impl ConnectorIntegration<PSync, PaymentsSyncData, PaymentsResponseData> for Gpayments {}
impl ConnectorIntegration<Capture, PaymentsCaptureData, PaymentsResponseData> for Gpayments {}
impl ConnectorIntegration<Void, PaymentsCancelData, PaymentsResponseData> for Gpayments {}
impl ConnectorIntegration<Execute, RefundsData, RefundsResponseData> for Gpayments {}
impl ConnectorIntegration<RSync, RefundsData, RefundsResponseData> for Gpayments {}
#[async_trait::async_trait]
impl IncomingWebhook for Gpayments {
fn get_webhook_object_reference_id(
&self,
_request: &IncomingWebhookRequestDetails<'_>,
) -> CustomResult<ObjectReferenceId, ConnectorError> {
Err(report!(ConnectorError::WebhooksNotImplemented))
}
fn get_webhook_event_type(
&self,
_request: &IncomingWebhookRequestDetails<'_>,
) -> CustomResult<IncomingWebhookEvent, ConnectorError> {
Err(report!(ConnectorError::WebhooksNotImplemented))
}
fn get_webhook_resource_object(
&self,
_request: &IncomingWebhookRequestDetails<'_>,
) -> CustomResult<Box<dyn masking::ErasedMaskSerialize>, ConnectorError> {
Err(report!(ConnectorError::WebhooksNotImplemented))
}
}
impl ExternalAuthentication for Gpayments {}
impl ConnectorAuthentication for Gpayments {}
impl ConnectorPreAuthentication for Gpayments {}
impl ConnectorPreAuthenticationVersionCall for Gpayments {}
impl ConnectorPostAuthentication for Gpayments {}
fn build_endpoint(
base_url: &str,
connector_metadata: &Option<common_utils::pii::SecretSerdeValue>,
) -> CustomResult<String, ConnectorError> {
let metadata = gpayments::GpaymentsMetaData::try_from(connector_metadata)?;
let endpoint_prefix = metadata.endpoint_prefix;
Ok(base_url.replace("{{merchant_endpoint_prefix}}", &endpoint_prefix))
}
impl
ConnectorIntegration<
Authentication,
ConnectorAuthenticationRequestData,
AuthenticationResponseData,
> for Gpayments
{
fn get_headers(
&self,
req: &ConnectorAuthenticationRouterData,
connectors: &Connectors,
) -> CustomResult<Vec<(String, Maskable<String>)>, ConnectorError> {
self.build_headers(req, connectors)
}
fn get_content_type(&self) -> &'static str {
self.common_get_content_type()
}
fn get_url(
&self,
req: &ConnectorAuthenticationRouterData,
_connectors: &Connectors,
) -> CustomResult<String, ConnectorError> {
let connector_metadata: GpaymentsConnectorMetaData = to_connector_meta(
req.request
.pre_authentication_data
.connector_metadata
.clone(),
)?;
Ok(connector_metadata.authentication_url)
}
fn get_request_body(
&self,
req: &ConnectorAuthenticationRouterData,
_connectors: &Connectors,
) -> CustomResult<RequestContent, ConnectorError> {
let connector_router_data = gpayments::GpaymentsRouterData::from((MinorUnit::zero(), req));
let req_obj =
gpayments_types::GpaymentsAuthenticationRequest::try_from(&connector_router_data)?;
Ok(RequestContent::Json(Box::new(req_obj)))
}
fn build_request(
&self,
req: &ConnectorAuthenticationRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, ConnectorError> {
let gpayments_auth_type = gpayments::GpaymentsAuthType::try_from(&req.connector_auth_type)?;
Ok(Some(
RequestBuilder::new()
.method(Method::Post)
.url(&ConnectorAuthenticationType::get_url(
self, req, connectors,
)?)
.attach_default_headers()
.headers(ConnectorAuthenticationType::get_headers(
self, req, connectors,
)?)
.set_body(ConnectorAuthenticationType::get_request_body(
self, req, connectors,
)?)
.add_certificate(Some(gpayments_auth_type.certificate))
.add_certificate_key(Some(gpayments_auth_type.private_key))
.build(),
))
}
fn handle_response(
&self,
data: &ConnectorAuthenticationRouterData,
event_builder: Option<&mut ConnectorEvent>,
res: Response,
) -> CustomResult<ConnectorAuthenticationRouterData, ConnectorError> {
let response: gpayments_types::GpaymentsAuthenticationSuccessResponse = res
.response
.parse_struct("gpayments GpaymentsAuthenticationResponse")
.change_context(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,
})
}
fn get_error_response(
&self,
res: Response,
event_builder: Option<&mut ConnectorEvent>,
) -> CustomResult<ErrorResponse, ConnectorError> {
self.build_error_response(res, event_builder)
}
}
impl
ConnectorIntegration<
PostAuthentication,
ConnectorPostAuthenticationRequestData,
AuthenticationResponseData,
> for Gpayments
{
fn get_headers(
&self,
req: &ConnectorPostAuthenticationRouterData,
connectors: &Connectors,
) -> CustomResult<Vec<(String, Maskable<String>)>, ConnectorError> {
self.build_headers(req, connectors)
}
fn get_content_type(&self) -> &'static str {
self.common_get_content_type()
}
fn get_url(
&self,
req: &ConnectorPostAuthenticationRouterData,
connectors: &Connectors,
) -> CustomResult<String, ConnectorError> {
let base_url = build_endpoint(self.base_url(connectors), &req.connector_meta_data)?;
Ok(format!(
"{}/api/v2/auth/brw/result?threeDSServerTransID={}",
base_url, req.request.threeds_server_transaction_id,
))
}
fn build_request(
&self,
req: &ConnectorPostAuthenticationRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, ConnectorError> {
let gpayments_auth_type = gpayments::GpaymentsAuthType::try_from(&req.connector_auth_type)?;
Ok(Some(
RequestBuilder::new()
.method(Method::Get)
.url(&ConnectorPostAuthenticationType::get_url(
self, req, connectors,
)?)
.attach_default_headers()
.headers(ConnectorPostAuthenticationType::get_headers(
self, req, connectors,
)?)
.add_certificate(Some(gpayments_auth_type.certificate))
.add_certificate_key(Some(gpayments_auth_type.private_key))
.build(),
))
}
fn handle_response(
&self,
data: &ConnectorPostAuthenticationRouterData,
event_builder: Option<&mut ConnectorEvent>,
res: Response,
) -> CustomResult<ConnectorPostAuthenticationRouterData, ConnectorError> {
let response: gpayments_types::GpaymentsPostAuthenticationResponse = res
.response
.parse_struct("gpayments PaymentsSyncResponse")
.change_context(ConnectorError::ResponseDeserializationFailed)?;
event_builder.map(|i| i.set_response_body(&response));
router_env::logger::info!(connector_response=?response);
Ok(ConnectorPostAuthenticationRouterData {
response: Ok(AuthenticationResponseData::PostAuthNResponse {
trans_status: response.trans_status.into(),
authentication_value: response.authentication_value,
eci: response.eci,
challenge_cancel: None,
challenge_code_reason: None,
}),
..data.clone()
})
}
fn get_error_response(
&self,
res: Response,
event_builder: Option<&mut ConnectorEvent>,
) -> CustomResult<ErrorResponse, ConnectorError> {
self.build_error_response(res, event_builder)
}
}
impl ConnectorIntegration<PreAuthentication, PreAuthNRequestData, AuthenticationResponseData>
for Gpayments
{
fn get_headers(
&self,
req: &PreAuthNRouterData,
connectors: &Connectors,
) -> CustomResult<Vec<(String, Maskable<String>)>, ConnectorError> {
self.build_headers(req, connectors)
}
fn get_content_type(&self) -> &'static str {
self.common_get_content_type()
}
fn get_url(
&self,
req: &PreAuthNRouterData,
connectors: &Connectors,
) -> CustomResult<String, ConnectorError> {
let base_url = build_endpoint(self.base_url(connectors), &req.connector_meta_data)?;
Ok(format!("{base_url}/api/v2/auth/brw/init?mode=custom"))
}
fn get_request_body(
&self,
req: &PreAuthNRouterData,
_connectors: &Connectors,
) -> CustomResult<RequestContent, ConnectorError> {
let connector_router_data = gpayments::GpaymentsRouterData::from((MinorUnit::zero(), req));
let req_obj =
gpayments_types::GpaymentsPreAuthenticationRequest::try_from(&connector_router_data)?;
Ok(RequestContent::Json(Box::new(req_obj)))
}
fn build_request(
&self,
req: &PreAuthNRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, ConnectorError> {
let gpayments_auth_type = gpayments::GpaymentsAuthType::try_from(&req.connector_auth_type)?;
Ok(Some(
RequestBuilder::new()
.method(Method::Post)
.url(&ConnectorPreAuthenticationType::get_url(
self, req, connectors,
)?)
.attach_default_headers()
.headers(ConnectorPreAuthenticationType::get_headers(
self, req, connectors,
)?)
.set_body(ConnectorPreAuthenticationType::get_request_body(
self, req, connectors,
)?)
.add_certificate(Some(gpayments_auth_type.certificate))
.add_certificate_key(Some(gpayments_auth_type.private_key))
.build(),
))
}
fn handle_response(
&self,
data: &PreAuthNRouterData,
event_builder: Option<&mut ConnectorEvent>,
res: Response,
) -> CustomResult<PreAuthNRouterData, ConnectorError> {
let response: gpayments_types::GpaymentsPreAuthenticationResponse = res
.response
.parse_struct("gpayments GpaymentsPreAuthenticationResponse")
.change_context(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,
})
}
fn get_error_response(
&self,
res: Response,
event_builder: Option<&mut ConnectorEvent>,
) -> CustomResult<ErrorResponse, ConnectorError> {
self.build_error_response(res, event_builder)
}
}
impl
ConnectorIntegration<
PreAuthenticationVersionCall,
PreAuthNRequestData,
AuthenticationResponseData,
> for Gpayments
{
fn get_headers(
&self,
req: &PreAuthNVersionCallRouterData,
connectors: &Connectors,
) -> CustomResult<Vec<(String, Maskable<String>)>, ConnectorError> {
self.build_headers(req, connectors)
}
fn get_content_type(&self) -> &'static str {
self.common_get_content_type()
}
fn get_url(
&self,
req: &PreAuthNVersionCallRouterData,
connectors: &Connectors,
) -> CustomResult<String, ConnectorError> {
let base_url = build_endpoint(self.base_url(connectors), &req.connector_meta_data)?;
Ok(format!("{base_url}/api/v2/auth/enrol"))
}
fn get_request_body(
&self,
req: &PreAuthNVersionCallRouterData,
_connectors: &Connectors,
) -> CustomResult<RequestContent, ConnectorError> {
let connector_router_data = gpayments::GpaymentsRouterData::from((MinorUnit::zero(), req));
let req_obj =
gpayments_types::GpaymentsPreAuthVersionCallRequest::try_from(&connector_router_data)?;
Ok(RequestContent::Json(Box::new(req_obj)))
}
fn build_request(
&self,
req: &PreAuthNVersionCallRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, ConnectorError> {
let gpayments_auth_type = gpayments::GpaymentsAuthType::try_from(&req.connector_auth_type)?;
Ok(Some(
RequestBuilder::new()
.method(Method::Post)
.url(&ConnectorPreAuthenticationVersionCallType::get_url(
self, req, connectors,
)?)
.attach_default_headers()
.headers(ConnectorPreAuthenticationVersionCallType::get_headers(
self, req, connectors,
)?)
.set_body(ConnectorPreAuthenticationVersionCallType::get_request_body(
self, req, connectors,
)?)
.add_certificate(Some(gpayments_auth_type.certificate))
.add_certificate_key(Some(gpayments_auth_type.private_key))
.build(),
))
}
fn handle_response(
&self,
data: &PreAuthNVersionCallRouterData,
event_builder: Option<&mut ConnectorEvent>,
res: Response,
) -> CustomResult<PreAuthNVersionCallRouterData, ConnectorError> {
let response: gpayments_types::GpaymentsPreAuthVersionCallResponse = res
.response
.parse_struct("gpayments GpaymentsPreAuthVersionCallResponse")
.change_context(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,
})
}
fn get_error_response(
&self,
res: Response,
event_builder: Option<&mut ConnectorEvent>,
) -> CustomResult<ErrorResponse, ConnectorError> {
self.build_error_response(res, event_builder)
}
}
static GPAYMENTS_CONNECTOR_INFO: ConnectorInfo = ConnectorInfo {
display_name: "GPayments",
description: "GPayments authentication connector for 3D Secure MPI/ACS services supporting Visa Secure, Mastercard SecureCode, and global card authentication standards",
connector_type: common_enums::HyperswitchConnectorCategory::AuthenticationProvider,
integration_status: common_enums::ConnectorIntegrationStatus::Alpha,
};
impl ConnectorSpecifications for Gpayments {
fn get_connector_about(&self) -> Option<&'static ConnectorInfo> {
Some(&GPAYMENTS_CONNECTOR_INFO)
}
fn get_supported_payment_methods(&self) -> Option<&'static SupportedPaymentMethods> {
None
}
fn get_supported_webhook_flows(&self) -> Option<&'static [common_enums::enums::EventClass]> {
None
}
}
|
{
"crate": "hyperswitch_connectors",
"file": "crates/hyperswitch_connectors/src/connectors/gpayments.rs",
"file_size": null,
"is_async": null,
"is_pub": null,
"num_enums": 0,
"num_structs": 1,
"num_tables": null,
"score": null,
"total_crates": null
}
|
file_hyperswitch_connectors_-3771105792332847405
|
clm
|
file
|
// Repository: hyperswitch
// Crate: hyperswitch_connectors
// File: crates/hyperswitch_connectors/src/connectors/moneris.rs
// Contains: 1 structs, 0 enums
pub mod transformers;
use std::sync::LazyLock;
use common_enums::enums;
use common_utils::{
errors::CustomResult,
ext_traits::BytesExt,
request::{Method, Request, RequestBuilder, RequestContent},
types::{AmountConvertor, MinorUnit, MinorUnitForConnector},
};
use error_stack::{report, ResultExt};
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::{
ConnectorInfo, PaymentMethodDetails, PaymentsResponseData, RefundsResponseData,
SupportedPaymentMethods, SupportedPaymentMethodsExt,
},
types::{
PaymentsAuthorizeRouterData, PaymentsCancelRouterData, PaymentsCaptureRouterData,
PaymentsSyncRouterData, RefreshTokenRouterData, RefundSyncRouterData, RefundsRouterData,
},
};
use hyperswitch_interfaces::{
api::{
self, ConnectorCommon, ConnectorCommonExt, ConnectorIntegration, ConnectorSpecifications,
ConnectorValidation,
},
configs::Connectors,
errors,
events::connector_api_logs::ConnectorEvent,
types::{self, RefreshTokenType, Response},
webhooks,
};
use masking::{ExposeInterface, Mask, PeekInterface};
use transformers as moneris;
use crate::{
constants::headers,
types::ResponseRouterData,
utils::{self, is_mandate_supported, PaymentMethodDataType, RefundsRequestData},
};
#[derive(Clone)]
pub struct Moneris {
amount_converter: &'static (dyn AmountConvertor<Output = MinorUnit> + Sync),
}
impl Moneris {
pub fn new() -> &'static Self {
&Self {
amount_converter: &MinorUnitForConnector,
}
}
}
impl api::Payment for Moneris {}
impl api::PaymentSession for Moneris {}
impl api::ConnectorAccessToken for Moneris {}
impl api::MandateSetup for Moneris {}
impl api::PaymentAuthorize for Moneris {}
impl api::PaymentSync for Moneris {}
impl api::PaymentCapture for Moneris {}
impl api::PaymentVoid for Moneris {}
impl api::Refund for Moneris {}
impl api::RefundExecute for Moneris {}
impl api::RefundSync for Moneris {}
impl api::PaymentToken for Moneris {}
impl ConnectorIntegration<PaymentMethodToken, PaymentMethodTokenizationData, PaymentsResponseData>
for Moneris
{
// Not Implemented (R)
}
impl<Flow, Request, Response> ConnectorCommonExt<Flow, Request, Response> for Moneris
where
Self: ConnectorIntegration<Flow, Request, Response>,
{
fn build_headers(
&self,
req: &RouterData<Flow, Request, Response>,
_connectors: &Connectors,
) -> CustomResult<Vec<(String, masking::Maskable<String>)>, errors::ConnectorError> {
let auth = moneris::MonerisAuthType::try_from(&req.connector_auth_type)
.change_context(errors::ConnectorError::FailedToObtainAuthType)?;
let mut header = vec![
(
headers::CONTENT_TYPE.to_string(),
self.get_content_type().to_string().into(),
),
(
moneris::auth_headers::API_VERSION.to_string(),
"2024-09-17".to_string().into(),
),
(
moneris::auth_headers::X_MERCHANT_ID.to_string(),
auth.merchant_id.expose().into_masked(),
),
];
let access_token = req
.access_token
.clone()
.ok_or(errors::ConnectorError::FailedToObtainAuthType)?;
let auth_header = (
headers::AUTHORIZATION.to_string(),
format!("Bearer {}", access_token.token.peek()).into_masked(),
);
header.push(auth_header);
Ok(header)
}
}
impl ConnectorCommon for Moneris {
fn id(&self) -> &'static str {
"moneris"
}
fn get_currency_unit(&self) -> api::CurrencyUnit {
api::CurrencyUnit::Minor
}
fn common_get_content_type(&self) -> &'static str {
"application/json"
}
fn base_url<'a>(&self, connectors: &'a Connectors) -> &'a str {
connectors.moneris.base_url.as_ref()
}
fn get_auth_header(
&self,
auth_type: &ConnectorAuthType,
) -> CustomResult<Vec<(String, masking::Maskable<String>)>, errors::ConnectorError> {
let auth = moneris::MonerisAuthType::try_from(auth_type)
.change_context(errors::ConnectorError::FailedToObtainAuthType)?;
Ok(vec![(
headers::AUTHORIZATION.to_string(),
auth.client_id.expose().into_masked(),
)])
}
fn build_error_response(
&self,
res: Response,
event_builder: Option<&mut ConnectorEvent>,
) -> CustomResult<ErrorResponse, errors::ConnectorError> {
let response: moneris::MonerisErrorResponse = res
.response
.parse_struct("MonerisErrorResponse")
.change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
event_builder.map(|i| i.set_response_body(&response));
router_env::logger::info!(connector_response=?response);
let reason = match &response.errors {
Some(error_list) => error_list
.iter()
.map(|error| error.parameter_name.clone())
.collect::<Vec<String>>()
.join(" & "),
None => response.title.clone(),
};
Ok(ErrorResponse {
status_code: res.status_code,
code: response.category,
message: response.title,
reason: Some(reason),
attempt_status: None,
connector_transaction_id: None,
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
connector_metadata: None,
})
}
}
impl ConnectorValidation for Moneris {
fn validate_mandate_payment(
&self,
pm_type: Option<enums::PaymentMethodType>,
pm_data: hyperswitch_domain_models::payment_method_data::PaymentMethodData,
) -> CustomResult<(), errors::ConnectorError> {
let mandate_supported_pmd = std::collections::HashSet::from([PaymentMethodDataType::Card]);
is_mandate_supported(pm_data, pm_type, mandate_supported_pmd, self.id())
}
}
impl ConnectorIntegration<Session, PaymentsSessionData, PaymentsResponseData> for Moneris {
//TODO: implement sessions flow
}
impl ConnectorIntegration<AccessTokenAuth, AccessTokenRequestData, AccessToken> for Moneris {
fn get_url(
&self,
_req: &RefreshTokenRouterData,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
Ok(format!("{}/oauth2/token", self.base_url(connectors)))
}
fn get_content_type(&self) -> &'static str {
"application/x-www-form-urlencoded"
}
fn get_headers(
&self,
_req: &RefreshTokenRouterData,
_connectors: &Connectors,
) -> CustomResult<Vec<(String, masking::Maskable<String>)>, errors::ConnectorError> {
Ok(vec![(
headers::CONTENT_TYPE.to_string(),
RefreshTokenType::get_content_type(self).to_string().into(),
)])
}
fn get_request_body(
&self,
req: &RefreshTokenRouterData,
_connectors: &Connectors,
) -> CustomResult<RequestContent, errors::ConnectorError> {
let connector_req = moneris::MonerisAuthRequest::try_from(req)?;
Ok(RequestContent::FormUrlEncoded(Box::new(connector_req)))
}
fn build_request(
&self,
req: &RefreshTokenRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
let req = Some(
RequestBuilder::new()
.method(Method::Post)
.attach_default_headers()
.headers(RefreshTokenType::get_headers(self, req, connectors)?)
.url(&RefreshTokenType::get_url(self, req, connectors)?)
.set_body(RefreshTokenType::get_request_body(self, req, connectors)?)
.build(),
);
Ok(req)
}
fn handle_response(
&self,
data: &RefreshTokenRouterData,
event_builder: Option<&mut ConnectorEvent>,
res: Response,
) -> CustomResult<RefreshTokenRouterData, errors::ConnectorError> {
let response: moneris::MonerisAuthResponse = res
.response
.parse_struct("Moneris MonerisAuthResponse")
.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,
})
}
fn get_error_response(
&self,
res: Response,
event_builder: Option<&mut ConnectorEvent>,
) -> CustomResult<ErrorResponse, errors::ConnectorError> {
// auth error have different structure than common error
let response: moneris::MonerisAuthErrorResponse = res
.response
.parse_struct("MonerisAuthErrorResponse")
.change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
event_builder.map(|i| i.set_error_response_body(&response));
router_env::logger::info!(connector_response=?response);
Ok(ErrorResponse {
status_code: res.status_code,
code: response.error.to_string(),
message: response.error.clone(),
reason: response.error_description,
attempt_status: None,
connector_transaction_id: None,
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
connector_metadata: None,
})
}
}
impl ConnectorIntegration<SetupMandate, SetupMandateRequestData, PaymentsResponseData> for Moneris {
// Not Implemented (R)
fn build_request(
&self,
_req: &RouterData<SetupMandate, SetupMandateRequestData, PaymentsResponseData>,
_connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Err(
errors::ConnectorError::NotImplemented("Setup Mandate flow for Moneris".to_string())
.into(),
)
}
}
impl ConnectorIntegration<Authorize, PaymentsAuthorizeData, PaymentsResponseData> for Moneris {
fn get_headers(
&self,
req: &PaymentsAuthorizeRouterData,
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: &PaymentsAuthorizeRouterData,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
Ok(format!("{}/payments", self.base_url(connectors)))
}
fn get_request_body(
&self,
req: &PaymentsAuthorizeRouterData,
_connectors: &Connectors,
) -> CustomResult<RequestContent, errors::ConnectorError> {
let amount = utils::convert_amount(
self.amount_converter,
req.request.minor_amount,
req.request.currency,
)?;
let connector_router_data = moneris::MonerisRouterData::from((amount, req));
let connector_req = moneris::MonerisPaymentsRequest::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> {
Ok(Some(
RequestBuilder::new()
.method(Method::Post)
.url(&types::PaymentsAuthorizeType::get_url(
self, req, connectors,
)?)
.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: moneris::MonerisPaymentsResponse = res
.response
.parse_struct("Moneris 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,
})
}
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<PSync, PaymentsSyncData, PaymentsResponseData> for Moneris {
fn get_headers(
&self,
req: &PaymentsSyncRouterData,
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: &PaymentsSyncRouterData,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
let connector_payment_id = req
.request
.connector_transaction_id
.get_connector_transaction_id()
.change_context(errors::ConnectorError::MissingConnectorTransactionID)?;
Ok(format!(
"{}/payments/{connector_payment_id}",
self.base_url(connectors)
))
}
fn build_request(
&self,
req: &PaymentsSyncRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Ok(Some(
RequestBuilder::new()
.method(Method::Get)
.url(&types::PaymentsSyncType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(types::PaymentsSyncType::get_headers(self, req, connectors)?)
.build(),
))
}
fn handle_response(
&self,
data: &PaymentsSyncRouterData,
event_builder: Option<&mut ConnectorEvent>,
res: Response,
) -> CustomResult<PaymentsSyncRouterData, errors::ConnectorError> {
let response: moneris::MonerisPaymentsResponse = res
.response
.parse_struct("moneris PaymentsSyncResponse")
.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,
})
}
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 Moneris {
fn get_headers(
&self,
req: &PaymentsCaptureRouterData,
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: &PaymentsCaptureRouterData,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
let connector_payment_id = req.request.connector_transaction_id.clone();
Ok(format!(
"{}/payments/{connector_payment_id}/complete",
self.base_url(connectors)
))
}
fn get_request_body(
&self,
req: &PaymentsCaptureRouterData,
_connectors: &Connectors,
) -> CustomResult<RequestContent, errors::ConnectorError> {
let amount = utils::convert_amount(
self.amount_converter,
req.request.minor_amount_to_capture,
req.request.currency,
)?;
let connector_router_data = moneris::MonerisRouterData::from((amount, req));
let connector_req =
moneris::MonerisPaymentsCaptureRequest::try_from(&connector_router_data)?;
Ok(RequestContent::Json(Box::new(connector_req)))
}
fn build_request(
&self,
req: &PaymentsCaptureRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Ok(Some(
RequestBuilder::new()
.method(Method::Post)
.url(&types::PaymentsCaptureType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(types::PaymentsCaptureType::get_headers(
self, req, connectors,
)?)
.set_body(types::PaymentsCaptureType::get_request_body(
self, req, connectors,
)?)
.build(),
))
}
fn handle_response(
&self,
data: &PaymentsCaptureRouterData,
event_builder: Option<&mut ConnectorEvent>,
res: Response,
) -> CustomResult<PaymentsCaptureRouterData, errors::ConnectorError> {
let response: moneris::MonerisPaymentsResponse = res
.response
.parse_struct("Moneris PaymentsCaptureResponse")
.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,
})
}
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<Void, PaymentsCancelData, PaymentsResponseData> for Moneris {
fn get_headers(
&self,
req: &PaymentsCancelRouterData,
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: &PaymentsCancelRouterData,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
let connector_payment_id = req.request.connector_transaction_id.clone();
Ok(format!(
"{}/payments/{connector_payment_id}/cancel",
self.base_url(connectors)
))
}
fn get_request_body(
&self,
req: &PaymentsCancelRouterData,
_connectors: &Connectors,
) -> CustomResult<RequestContent, errors::ConnectorError> {
let connector_req = moneris::MonerisCancelRequest::try_from(req)?;
Ok(RequestContent::Json(Box::new(connector_req)))
}
fn build_request(
&self,
req: &PaymentsCancelRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Ok(Some(
RequestBuilder::new()
.method(Method::Post)
.url(&types::PaymentsVoidType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(types::PaymentsVoidType::get_headers(self, req, connectors)?)
.set_body(types::PaymentsVoidType::get_request_body(
self, req, connectors,
)?)
.build(),
))
}
fn handle_response(
&self,
data: &PaymentsCancelRouterData,
event_builder: Option<&mut ConnectorEvent>,
res: Response,
) -> CustomResult<PaymentsCancelRouterData, errors::ConnectorError> {
let response: moneris::MonerisPaymentsResponse = res
.response
.parse_struct("Moneris PaymentsCancelResponse")
.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,
})
}
}
impl ConnectorIntegration<Execute, RefundsData, RefundsResponseData> for Moneris {
fn get_headers(
&self,
req: &RefundsRouterData<Execute>,
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: &RefundsRouterData<Execute>,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
Ok(format!("{}/refunds", self.base_url(connectors)))
}
fn get_request_body(
&self,
req: &RefundsRouterData<Execute>,
_connectors: &Connectors,
) -> CustomResult<RequestContent, errors::ConnectorError> {
let refund_amount = utils::convert_amount(
self.amount_converter,
req.request.minor_refund_amount,
req.request.currency,
)?;
let connector_router_data = moneris::MonerisRouterData::from((refund_amount, req));
let connector_req = moneris::MonerisRefundRequest::try_from(&connector_router_data)?;
Ok(RequestContent::Json(Box::new(connector_req)))
}
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))
}
fn handle_response(
&self,
data: &RefundsRouterData<Execute>,
event_builder: Option<&mut ConnectorEvent>,
res: Response,
) -> CustomResult<RefundsRouterData<Execute>, errors::ConnectorError> {
let response: moneris::RefundResponse = res
.response
.parse_struct("moneris RefundResponse")
.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,
})
}
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<RSync, RefundsData, RefundsResponseData> for Moneris {
fn get_headers(
&self,
req: &RefundSyncRouterData,
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: &RefundSyncRouterData,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
let refund_id = req.request.get_connector_refund_id()?;
Ok(format!("{}/refunds/{refund_id}", self.base_url(connectors)))
}
fn build_request(
&self,
req: &RefundSyncRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Ok(Some(
RequestBuilder::new()
.method(Method::Get)
.url(&types::RefundSyncType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(types::RefundSyncType::get_headers(self, req, connectors)?)
.set_body(types::RefundSyncType::get_request_body(
self, req, connectors,
)?)
.build(),
))
}
fn handle_response(
&self,
data: &RefundSyncRouterData,
event_builder: Option<&mut ConnectorEvent>,
res: Response,
) -> CustomResult<RefundSyncRouterData, errors::ConnectorError> {
let response: moneris::RefundResponse = res
.response
.parse_struct("moneris RefundSyncResponse")
.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,
})
}
fn get_error_response(
&self,
res: Response,
event_builder: Option<&mut ConnectorEvent>,
) -> CustomResult<ErrorResponse, errors::ConnectorError> {
self.build_error_response(res, event_builder)
}
}
#[async_trait::async_trait]
impl webhooks::IncomingWebhook for Moneris {
fn get_webhook_object_reference_id(
&self,
_request: &webhooks::IncomingWebhookRequestDetails<'_>,
) -> CustomResult<api_models::webhooks::ObjectReferenceId, errors::ConnectorError> {
Err(report!(errors::ConnectorError::WebhooksNotImplemented))
}
fn get_webhook_event_type(
&self,
_request: &webhooks::IncomingWebhookRequestDetails<'_>,
) -> CustomResult<api_models::webhooks::IncomingWebhookEvent, errors::ConnectorError> {
Err(report!(errors::ConnectorError::WebhooksNotImplemented))
}
fn get_webhook_resource_object(
&self,
_request: &webhooks::IncomingWebhookRequestDetails<'_>,
) -> CustomResult<Box<dyn masking::ErasedMaskSerialize>, errors::ConnectorError> {
Err(report!(errors::ConnectorError::WebhooksNotImplemented))
}
}
static MONERIS_SUPPORTED_PAYMENT_METHODS: LazyLock<SupportedPaymentMethods> = LazyLock::new(|| {
let supported_capture_methods = vec![
enums::CaptureMethod::Automatic,
enums::CaptureMethod::Manual,
];
let supported_card_network = vec![
common_enums::CardNetwork::Mastercard,
common_enums::CardNetwork::Visa,
common_enums::CardNetwork::Interac,
common_enums::CardNetwork::AmericanExpress,
common_enums::CardNetwork::JCB,
common_enums::CardNetwork::DinersClub,
common_enums::CardNetwork::Discover,
common_enums::CardNetwork::CartesBancaires,
common_enums::CardNetwork::UnionPay,
];
let mut moneris_supported_payment_methods = SupportedPaymentMethods::new();
moneris_supported_payment_methods.add(
enums::PaymentMethod::Card,
enums::PaymentMethodType::Credit,
PaymentMethodDetails {
mandates: enums::FeatureStatus::Supported,
refunds: enums::FeatureStatus::Supported,
supported_capture_methods: supported_capture_methods.clone(),
specific_features: Some(
api_models::feature_matrix::PaymentMethodSpecificFeatures::Card({
api_models::feature_matrix::CardSpecificFeatures {
three_ds: common_enums::FeatureStatus::NotSupported,
no_three_ds: common_enums::FeatureStatus::Supported,
supported_card_networks: supported_card_network.clone(),
}
}),
),
},
);
moneris_supported_payment_methods.add(
enums::PaymentMethod::Card,
enums::PaymentMethodType::Debit,
PaymentMethodDetails {
mandates: enums::FeatureStatus::Supported,
refunds: enums::FeatureStatus::Supported,
supported_capture_methods: supported_capture_methods.clone(),
specific_features: Some(
api_models::feature_matrix::PaymentMethodSpecificFeatures::Card({
api_models::feature_matrix::CardSpecificFeatures {
three_ds: common_enums::FeatureStatus::NotSupported,
no_three_ds: common_enums::FeatureStatus::Supported,
supported_card_networks: supported_card_network.clone(),
}
}),
),
},
);
moneris_supported_payment_methods
});
static MONERIS_CONNECTOR_INFO: ConnectorInfo = ConnectorInfo {
display_name: "Moneris",
description: "Moneris is Canada's top payment solutions provider, empowering businesses with innovative mobile, online & in-store solutions.",
connector_type: enums::HyperswitchConnectorCategory::PaymentGateway,
integration_status: enums::ConnectorIntegrationStatus::Sandbox,
};
static MONERIS_SUPPORTED_WEBHOOK_FLOWS: [enums::EventClass; 0] = [];
impl ConnectorSpecifications for Moneris {
fn get_connector_about(&self) -> Option<&'static ConnectorInfo> {
Some(&MONERIS_CONNECTOR_INFO)
}
fn get_supported_payment_methods(&self) -> Option<&'static SupportedPaymentMethods> {
Some(&*MONERIS_SUPPORTED_PAYMENT_METHODS)
}
fn get_supported_webhook_flows(&self) -> Option<&'static [enums::EventClass]> {
Some(&MONERIS_SUPPORTED_WEBHOOK_FLOWS)
}
}
|
{
"crate": "hyperswitch_connectors",
"file": "crates/hyperswitch_connectors/src/connectors/moneris.rs",
"file_size": null,
"is_async": null,
"is_pub": null,
"num_enums": 0,
"num_structs": 1,
"num_tables": null,
"score": null,
"total_crates": null
}
|
file_hyperswitch_connectors_111761007295004942
|
clm
|
file
|
// Repository: hyperswitch
// Crate: hyperswitch_connectors
// File: crates/hyperswitch_connectors/src/connectors/threedsecureio.rs
// Contains: 1 structs, 0 enums
pub mod transformers;
use std::fmt::Debug;
use api_models::webhooks::{IncomingWebhookEvent, ObjectReferenceId};
use common_utils::{
errors::CustomResult,
ext_traits::BytesExt,
request::{Method, Request, RequestBuilder, RequestContent},
};
use error_stack::{report, ResultExt};
use hyperswitch_domain_models::{
router_data::{AccessToken, ConnectorAuthType, ErrorResponse, RouterData},
router_flow_types::{
authentication::{
Authentication, PostAuthentication, PreAuthentication, PreAuthenticationVersionCall,
},
AccessTokenAuth, Authorize, Capture, Execute, PSync, PaymentMethodToken, RSync, Session,
SetupMandate, Void,
},
router_request_types::{
authentication::{
ConnectorAuthenticationRequestData, ConnectorPostAuthenticationRequestData,
PreAuthNRequestData,
},
AccessTokenRequestData, PaymentMethodTokenizationData, PaymentsAuthorizeData,
PaymentsCancelData, PaymentsCaptureData, PaymentsSessionData, PaymentsSyncData,
RefundsData, SetupMandateRequestData,
},
router_response_types::{
AuthenticationResponseData, ConnectorInfo, PaymentsResponseData, RefundsResponseData,
SupportedPaymentMethods,
},
};
use hyperswitch_interfaces::{
api::{
authentication::{
ConnectorAuthentication, ConnectorPostAuthentication, ConnectorPreAuthentication,
ConnectorPreAuthenticationVersionCall, ExternalAuthentication,
},
ConnectorAccessToken, ConnectorCommon, ConnectorCommonExt, ConnectorIntegration,
ConnectorSpecifications, ConnectorValidation, CurrencyUnit, MandateSetup, Payment,
PaymentAuthorize, PaymentCapture, PaymentSession, PaymentSync, PaymentToken, PaymentVoid,
Refund, RefundExecute, RefundSync,
},
configs::Connectors,
consts::NO_ERROR_MESSAGE,
errors::ConnectorError,
events::connector_api_logs::ConnectorEvent,
types::Response,
webhooks::{IncomingWebhook, IncomingWebhookRequestDetails},
};
use masking::{ExposeInterface, Mask as _, Maskable};
use transformers as threedsecureio;
use crate::{
constants::headers,
types::{
ConnectorAuthenticationRouterData, ConnectorAuthenticationType,
ConnectorPostAuthenticationRouterData, ConnectorPostAuthenticationType,
ConnectorPreAuthenticationType, PreAuthNRouterData, ResponseRouterData,
},
utils::handle_json_response_deserialization_failure,
};
#[derive(Debug, Clone)]
pub struct Threedsecureio;
impl Payment for Threedsecureio {}
impl PaymentSession for Threedsecureio {}
impl ConnectorAccessToken for Threedsecureio {}
impl MandateSetup for Threedsecureio {}
impl PaymentAuthorize for Threedsecureio {}
impl PaymentSync for Threedsecureio {}
impl PaymentCapture for Threedsecureio {}
impl PaymentVoid for Threedsecureio {}
impl Refund for Threedsecureio {}
impl RefundExecute for Threedsecureio {}
impl RefundSync for Threedsecureio {}
impl PaymentToken for Threedsecureio {}
impl ConnectorIntegration<PaymentMethodToken, PaymentMethodTokenizationData, PaymentsResponseData>
for Threedsecureio
{
}
impl<Flow, Request, Response> ConnectorCommonExt<Flow, Request, Response> for Threedsecureio
where
Self: ConnectorIntegration<Flow, Request, Response>,
{
fn build_headers(
&self,
req: &RouterData<Flow, Request, Response>,
_connectors: &Connectors,
) -> CustomResult<Vec<(String, Maskable<String>)>, ConnectorError> {
let mut header = vec![(
headers::CONTENT_TYPE.to_string(),
"application/json; charset=utf-8".to_string().into(),
)];
let mut api_key = self.get_auth_header(&req.connector_auth_type)?;
header.append(&mut api_key);
Ok(header)
}
}
impl ConnectorCommon for Threedsecureio {
fn id(&self) -> &'static str {
"threedsecureio"
}
fn get_currency_unit(&self) -> CurrencyUnit {
CurrencyUnit::Minor
}
fn common_get_content_type(&self) -> &'static str {
"application/json"
}
fn base_url<'a>(&self, connectors: &'a Connectors) -> &'a str {
connectors.threedsecureio.base_url.as_ref()
}
fn get_auth_header(
&self,
auth_type: &ConnectorAuthType,
) -> CustomResult<Vec<(String, Maskable<String>)>, ConnectorError> {
let auth = threedsecureio::ThreedsecureioAuthType::try_from(auth_type)
.change_context(ConnectorError::FailedToObtainAuthType)?;
Ok(vec![(
headers::APIKEY.to_string(),
auth.api_key.expose().into_masked(),
)])
}
fn build_error_response(
&self,
res: Response,
event_builder: Option<&mut ConnectorEvent>,
) -> CustomResult<ErrorResponse, ConnectorError> {
let response_result: Result<
threedsecureio::ThreedsecureioErrorResponse,
error_stack::Report<common_utils::errors::ParsingError>,
> = res.response.parse_struct("ThreedsecureioErrorResponse");
match response_result {
Ok(response) => {
event_builder.map(|i| i.set_error_response_body(&response));
router_env::logger::info!(connector_response=?response);
Ok(ErrorResponse {
status_code: res.status_code,
code: response.error_code,
message: response
.error_description
.clone()
.unwrap_or(NO_ERROR_MESSAGE.to_owned()),
reason: response.error_description,
attempt_status: None,
connector_transaction_id: None,
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
connector_metadata: None,
})
}
Err(err) => {
router_env::logger::error!(deserialization_error =? err);
handle_json_response_deserialization_failure(res, "threedsecureio")
}
}
}
}
impl ConnectorValidation for Threedsecureio {}
impl ConnectorIntegration<Session, PaymentsSessionData, PaymentsResponseData> for Threedsecureio {}
impl ConnectorIntegration<AccessTokenAuth, AccessTokenRequestData, AccessToken> for Threedsecureio {}
impl ConnectorIntegration<SetupMandate, SetupMandateRequestData, PaymentsResponseData>
for Threedsecureio
{
}
impl ConnectorIntegration<Authorize, PaymentsAuthorizeData, PaymentsResponseData>
for Threedsecureio
{
}
impl ConnectorIntegration<PSync, PaymentsSyncData, PaymentsResponseData> for Threedsecureio {}
impl ConnectorIntegration<Capture, PaymentsCaptureData, PaymentsResponseData> for Threedsecureio {}
impl ConnectorIntegration<Void, PaymentsCancelData, PaymentsResponseData> for Threedsecureio {}
impl ConnectorIntegration<Execute, RefundsData, RefundsResponseData> for Threedsecureio {}
impl ConnectorIntegration<RSync, RefundsData, RefundsResponseData> for Threedsecureio {}
#[async_trait::async_trait]
impl IncomingWebhook for Threedsecureio {
fn get_webhook_object_reference_id(
&self,
_request: &IncomingWebhookRequestDetails<'_>,
) -> CustomResult<ObjectReferenceId, ConnectorError> {
Err(report!(ConnectorError::WebhooksNotImplemented))
}
fn get_webhook_event_type(
&self,
_request: &IncomingWebhookRequestDetails<'_>,
) -> CustomResult<IncomingWebhookEvent, ConnectorError> {
Err(report!(ConnectorError::WebhooksNotImplemented))
}
fn get_webhook_resource_object(
&self,
_request: &IncomingWebhookRequestDetails<'_>,
) -> CustomResult<Box<dyn masking::ErasedMaskSerialize>, ConnectorError> {
Err(report!(ConnectorError::WebhooksNotImplemented))
}
}
impl ConnectorPreAuthentication for Threedsecureio {}
impl ConnectorPreAuthenticationVersionCall for Threedsecureio {}
impl ExternalAuthentication for Threedsecureio {}
impl ConnectorAuthentication for Threedsecureio {}
impl ConnectorPostAuthentication for Threedsecureio {}
impl
ConnectorIntegration<
Authentication,
ConnectorAuthenticationRequestData,
AuthenticationResponseData,
> for Threedsecureio
{
fn get_headers(
&self,
req: &ConnectorAuthenticationRouterData,
connectors: &Connectors,
) -> CustomResult<Vec<(String, Maskable<String>)>, ConnectorError> {
self.build_headers(req, connectors)
}
fn get_content_type(&self) -> &'static str {
self.common_get_content_type()
}
fn get_url(
&self,
_req: &ConnectorAuthenticationRouterData,
connectors: &Connectors,
) -> CustomResult<String, ConnectorError> {
Ok(format!("{}/auth", self.base_url(connectors),))
}
fn get_request_body(
&self,
req: &ConnectorAuthenticationRouterData,
_connectors: &Connectors,
) -> CustomResult<RequestContent, ConnectorError> {
let connector_router_data = threedsecureio::ThreedsecureioRouterData::try_from((
&self.get_currency_unit(),
req.request
.currency
.ok_or(ConnectorError::MissingRequiredField {
field_name: "currency",
})?,
req.request
.amount
.ok_or(ConnectorError::MissingRequiredField {
field_name: "amount",
})?,
req,
))?;
let req_obj =
threedsecureio::ThreedsecureioAuthenticationRequest::try_from(&connector_router_data);
Ok(RequestContent::Json(Box::new(req_obj?)))
}
fn build_request(
&self,
req: &ConnectorAuthenticationRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, ConnectorError> {
Ok(Some(
RequestBuilder::new()
.method(Method::Post)
.url(&ConnectorAuthenticationType::get_url(
self, req, connectors,
)?)
.attach_default_headers()
.headers(ConnectorAuthenticationType::get_headers(
self, req, connectors,
)?)
.set_body(ConnectorAuthenticationType::get_request_body(
self, req, connectors,
)?)
.build(),
))
}
fn handle_response(
&self,
data: &ConnectorAuthenticationRouterData,
event_builder: Option<&mut ConnectorEvent>,
res: Response,
) -> CustomResult<ConnectorAuthenticationRouterData, ConnectorError> {
let response: threedsecureio::ThreedsecureioAuthenticationResponse = res
.response
.parse_struct("ThreedsecureioAuthenticationResponse")
.change_context(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,
})
}
fn get_error_response(
&self,
res: Response,
event_builder: Option<&mut ConnectorEvent>,
) -> CustomResult<ErrorResponse, ConnectorError> {
self.build_error_response(res, event_builder)
}
}
impl ConnectorIntegration<PreAuthentication, PreAuthNRequestData, AuthenticationResponseData>
for Threedsecureio
{
fn get_headers(
&self,
req: &PreAuthNRouterData,
connectors: &Connectors,
) -> CustomResult<Vec<(String, Maskable<String>)>, ConnectorError> {
self.build_headers(req, connectors)
}
fn get_content_type(&self) -> &'static str {
self.common_get_content_type()
}
fn get_url(
&self,
_req: &PreAuthNRouterData,
connectors: &Connectors,
) -> CustomResult<String, ConnectorError> {
Ok(format!("{}/preauth", self.base_url(connectors),))
}
fn get_request_body(
&self,
req: &PreAuthNRouterData,
_connectors: &Connectors,
) -> CustomResult<RequestContent, ConnectorError> {
let connector_router_data = threedsecureio::ThreedsecureioRouterData::try_from((0, req))?;
let req_obj = threedsecureio::ThreedsecureioPreAuthenticationRequest::try_from(
&connector_router_data,
)?;
Ok(RequestContent::Json(Box::new(req_obj)))
}
fn build_request(
&self,
req: &PreAuthNRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, ConnectorError> {
Ok(Some(
RequestBuilder::new()
.method(Method::Post)
.url(&ConnectorPreAuthenticationType::get_url(
self, req, connectors,
)?)
.attach_default_headers()
.headers(ConnectorPreAuthenticationType::get_headers(
self, req, connectors,
)?)
.set_body(ConnectorPreAuthenticationType::get_request_body(
self, req, connectors,
)?)
.build(),
))
}
fn handle_response(
&self,
data: &PreAuthNRouterData,
event_builder: Option<&mut ConnectorEvent>,
res: Response,
) -> CustomResult<PreAuthNRouterData, ConnectorError> {
let response: threedsecureio::ThreedsecureioPreAuthenticationResponse = res
.response
.parse_struct("threedsecureio ThreedsecureioPreAuthenticationResponse")
.change_context(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,
})
}
fn get_error_response(
&self,
res: Response,
event_builder: Option<&mut ConnectorEvent>,
) -> CustomResult<ErrorResponse, ConnectorError> {
self.build_error_response(res, event_builder)
}
}
impl
ConnectorIntegration<
PostAuthentication,
ConnectorPostAuthenticationRequestData,
AuthenticationResponseData,
> for Threedsecureio
{
fn get_headers(
&self,
req: &ConnectorPostAuthenticationRouterData,
connectors: &Connectors,
) -> CustomResult<Vec<(String, Maskable<String>)>, ConnectorError> {
self.build_headers(req, connectors)
}
fn get_content_type(&self) -> &'static str {
self.common_get_content_type()
}
fn get_url(
&self,
_req: &ConnectorPostAuthenticationRouterData,
connectors: &Connectors,
) -> CustomResult<String, ConnectorError> {
Ok(format!("{}/postauth", self.base_url(connectors),))
}
fn get_request_body(
&self,
req: &ConnectorPostAuthenticationRouterData,
_connectors: &Connectors,
) -> CustomResult<RequestContent, ConnectorError> {
let req_obj = threedsecureio::ThreedsecureioPostAuthenticationRequest {
three_ds_server_trans_id: req.request.threeds_server_transaction_id.clone(),
};
Ok(RequestContent::Json(Box::new(req_obj)))
}
fn build_request(
&self,
req: &ConnectorPostAuthenticationRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, ConnectorError> {
Ok(Some(
RequestBuilder::new()
.method(Method::Post)
.url(&ConnectorPostAuthenticationType::get_url(
self, req, connectors,
)?)
.attach_default_headers()
.headers(ConnectorPostAuthenticationType::get_headers(
self, req, connectors,
)?)
.set_body(ConnectorPostAuthenticationType::get_request_body(
self, req, connectors,
)?)
.build(),
))
}
fn handle_response(
&self,
data: &ConnectorPostAuthenticationRouterData,
event_builder: Option<&mut ConnectorEvent>,
res: Response,
) -> CustomResult<ConnectorPostAuthenticationRouterData, ConnectorError> {
let response: threedsecureio::ThreedsecureioPostAuthenticationResponse = res
.response
.parse_struct("threedsecureio PaymentsSyncResponse")
.change_context(ConnectorError::ResponseDeserializationFailed)?;
event_builder.map(|i| i.set_response_body(&response));
router_env::logger::info!(connector_response=?response);
Ok(ConnectorPostAuthenticationRouterData {
response: Ok(AuthenticationResponseData::PostAuthNResponse {
trans_status: response.trans_status.into(),
authentication_value: response.authentication_value,
eci: response.eci,
challenge_cancel: None,
challenge_code_reason: None,
}),
..data.clone()
})
}
fn get_error_response(
&self,
res: Response,
event_builder: Option<&mut ConnectorEvent>,
) -> CustomResult<ErrorResponse, ConnectorError> {
self.build_error_response(res, event_builder)
}
}
impl
ConnectorIntegration<
PreAuthenticationVersionCall,
PreAuthNRequestData,
AuthenticationResponseData,
> for Threedsecureio
{
}
static THREEDSECUREIO_CONNECTOR_INFO: ConnectorInfo = ConnectorInfo {
display_name: "3dsecure.io",
description: "3DSecure.io is a service that facilitates 3-D Secure verifications for online credit and debit card transactions through a simple JSON API, enhancing payment security for merchants.docs.3dsecure.io3dsecure.io",
connector_type: common_enums::HyperswitchConnectorCategory::AuthenticationProvider,
integration_status: common_enums::ConnectorIntegrationStatus::Sandbox,
};
impl ConnectorSpecifications for Threedsecureio {
fn get_connector_about(&self) -> Option<&'static ConnectorInfo> {
Some(&THREEDSECUREIO_CONNECTOR_INFO)
}
fn get_supported_payment_methods(&self) -> Option<&'static SupportedPaymentMethods> {
None
}
fn get_supported_webhook_flows(&self) -> Option<&'static [common_enums::enums::EventClass]> {
None
}
}
|
{
"crate": "hyperswitch_connectors",
"file": "crates/hyperswitch_connectors/src/connectors/threedsecureio.rs",
"file_size": null,
"is_async": null,
"is_pub": null,
"num_enums": 0,
"num_structs": 1,
"num_tables": null,
"score": null,
"total_crates": null
}
|
file_hyperswitch_connectors_6140465576570794483
|
clm
|
file
|
// Repository: hyperswitch
// Crate: hyperswitch_connectors
// File: crates/hyperswitch_connectors/src/connectors/nexixpay.rs
// Contains: 1 structs, 0 enums
pub mod transformers;
use std::collections::HashSet;
use common_enums::enums;
use common_utils::{
errors::CustomResult,
ext_traits::BytesExt,
request::{Method, Request, RequestBuilder, RequestContent},
types::{AmountConvertor, StringMinorUnit, StringMinorUnitForConnector},
};
use error_stack::{report, ResultExt};
use hyperswitch_domain_models::{
payment_method_data::PaymentMethodData,
router_data::{AccessToken, ConnectorAuthType, ErrorResponse, RouterData},
router_flow_types::{
access_token_auth::AccessTokenAuth,
payments::{
Authorize, Capture, CompleteAuthorize, PSync, PaymentMethodToken, PreProcessing,
Session, SetupMandate, Void,
},
refunds::{Execute, RSync},
},
router_request_types::{
AccessTokenRequestData, CompleteAuthorizeData, PaymentMethodTokenizationData,
PaymentsAuthorizeData, PaymentsCancelData, PaymentsCaptureData, PaymentsPreProcessingData,
PaymentsSessionData, PaymentsSyncData, RefundsData, SetupMandateRequestData,
},
router_response_types::{
ConnectorInfo, PaymentMethodDetails, PaymentsResponseData, RefundsResponseData,
SupportedPaymentMethods, SupportedPaymentMethodsExt,
},
types::{
PaymentsAuthorizeRouterData, PaymentsCancelRouterData, PaymentsCaptureRouterData,
PaymentsCompleteAuthorizeRouterData, PaymentsPreProcessingRouterData,
PaymentsSyncRouterData, RefundSyncRouterData, RefundsRouterData, SetupMandateRouterData,
},
};
use hyperswitch_interfaces::{
api::{
self, ConnectorCommon, ConnectorCommonExt, ConnectorIntegration, ConnectorSpecifications,
ConnectorValidation,
},
configs::Connectors,
consts, errors,
events::connector_api_logs::ConnectorEvent,
types::{self, Response},
webhooks,
};
use lazy_static::lazy_static;
use masking::{ExposeInterface, Mask};
use serde_json::Value;
use transformers as nexixpay;
use uuid::Uuid;
use crate::{
constants::headers,
types::ResponseRouterData,
utils::{self, PaymentMethodDataType, RefundsRequestData},
};
#[derive(Clone)]
pub struct Nexixpay {
amount_converter: &'static (dyn AmountConvertor<Output = StringMinorUnit> + Sync),
}
impl Nexixpay {
pub fn new() -> &'static Self {
&Self {
amount_converter: &StringMinorUnitForConnector,
}
}
}
impl api::Payment for Nexixpay {}
impl api::PaymentsPreProcessing for Nexixpay {}
impl api::PaymentSession for Nexixpay {}
impl api::ConnectorAccessToken for Nexixpay {}
impl api::MandateSetup for Nexixpay {}
impl api::PaymentAuthorize for Nexixpay {}
impl api::PaymentSync for Nexixpay {}
impl api::PaymentCapture for Nexixpay {}
impl api::PaymentVoid for Nexixpay {}
impl api::Refund for Nexixpay {}
impl api::RefundExecute for Nexixpay {}
impl api::RefundSync for Nexixpay {}
impl api::PaymentToken for Nexixpay {}
impl api::PaymentsCompleteAuthorize for Nexixpay {}
impl ConnectorIntegration<PaymentMethodToken, PaymentMethodTokenizationData, PaymentsResponseData>
for Nexixpay
{
// Not Implemented (R)
}
impl<Flow, Request, Response> ConnectorCommonExt<Flow, Request, Response> for Nexixpay
where
Self: ConnectorIntegration<Flow, Request, Response>,
{
fn build_headers(
&self,
req: &RouterData<Flow, Request, Response>,
_connectors: &Connectors,
) -> CustomResult<Vec<(String, masking::Maskable<String>)>, errors::ConnectorError> {
let mut header = vec![(
headers::CONTENT_TYPE.to_string(),
self.get_content_type().to_string().into(),
)];
let mut api_key = self.get_auth_header(&req.connector_auth_type)?;
header.append(&mut api_key);
Ok(header)
}
}
impl ConnectorCommon for Nexixpay {
fn id(&self) -> &'static str {
"nexixpay"
}
fn get_currency_unit(&self) -> api::CurrencyUnit {
api::CurrencyUnit::Minor
}
fn common_get_content_type(&self) -> &'static str {
"application/json"
}
fn base_url<'a>(&self, connectors: &'a Connectors) -> &'a str {
connectors.nexixpay.base_url.as_ref()
}
fn get_auth_header(
&self,
auth_type: &ConnectorAuthType,
) -> CustomResult<Vec<(String, masking::Maskable<String>)>, errors::ConnectorError> {
let auth = nexixpay::NexixpayAuthType::try_from(auth_type)
.change_context(errors::ConnectorError::FailedToObtainAuthType)?;
Ok(vec![
(
headers::X_API_KEY.to_string(),
auth.api_key.expose().into_masked(),
),
(
headers::CORRELATION_ID.to_string(),
Uuid::new_v4().to_string().into_masked(),
),
])
}
fn build_error_response(
&self,
res: Response,
event_builder: Option<&mut ConnectorEvent>,
) -> CustomResult<ErrorResponse, errors::ConnectorError> {
let response: nexixpay::NexixpayErrorResponse = match res.status_code {
401 => nexixpay::NexixpayErrorResponse {
errors: vec![nexixpay::NexixpayErrorBody {
code: Some(consts::NO_ERROR_CODE.to_string()),
description: Some("UNAUTHORIZED".to_string()),
}],
},
404 => nexixpay::NexixpayErrorResponse {
errors: vec![nexixpay::NexixpayErrorBody {
code: Some(consts::NO_ERROR_CODE.to_string()),
description: Some("NOT FOUND".to_string()),
}],
},
_ => res
.response
.parse_struct("NexixpayErrorResponse")
.change_context(errors::ConnectorError::ResponseDeserializationFailed)?,
};
let concatenated_descriptions: Option<String> = {
let descriptions: Vec<String> = response
.errors
.iter()
.filter_map(|error| error.description.as_ref())
.cloned()
.collect();
if descriptions.is_empty() {
None
} else {
Some(descriptions.join(", "))
}
};
event_builder.map(|i| i.set_response_body(&response));
router_env::logger::info!(connector_response=?response);
Ok(ErrorResponse {
status_code: res.status_code,
code: response
.errors
.first()
.and_then(|error| error.code.clone())
.unwrap_or(consts::NO_ERROR_CODE.to_string()),
message: response
.errors
.first()
.and_then(|error| error.description.clone())
.unwrap_or(consts::NO_ERROR_MESSAGE.to_string()),
reason: concatenated_descriptions,
attempt_status: None,
connector_transaction_id: None,
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
connector_metadata: None,
})
}
}
impl ConnectorValidation for Nexixpay {
fn validate_mandate_payment(
&self,
pm_type: Option<enums::PaymentMethodType>,
pm_data: PaymentMethodData,
) -> CustomResult<(), errors::ConnectorError> {
let mandate_supported_pmd: HashSet<PaymentMethodDataType> =
HashSet::from([PaymentMethodDataType::Card]);
utils::is_mandate_supported(pm_data, pm_type, mandate_supported_pmd, self.id())
}
}
impl ConnectorIntegration<Session, PaymentsSessionData, PaymentsResponseData> for Nexixpay {}
impl ConnectorIntegration<AccessTokenAuth, AccessTokenRequestData, AccessToken> for Nexixpay {}
impl ConnectorIntegration<SetupMandate, SetupMandateRequestData, PaymentsResponseData>
for Nexixpay
{
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!("{}/orders/3steps/init", self.base_url(connectors)))
}
fn get_request_body(
&self,
req: &SetupMandateRouterData,
_connectors: &Connectors,
) -> CustomResult<RequestContent, errors::ConnectorError> {
let authorize_req = utils::convert_payment_authorize_router_response((
req,
utils::convert_setup_mandate_router_data_to_authorize_router_data(req),
));
let amount = utils::convert_amount(
self.amount_converter,
authorize_req.request.minor_amount,
authorize_req.request.currency,
)?;
let connector_router_data = nexixpay::NexixpayRouterData::from((amount, &authorize_req));
let connector_req = nexixpay::NexixpayPaymentsRequest::try_from(&connector_router_data)?;
Ok(RequestContent::Json(Box::new(connector_req)))
}
fn build_request(
&self,
req: &SetupMandateRouterData,
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,
)?)
.build(),
))
}
fn handle_response(
&self,
data: &SetupMandateRouterData,
event_builder: Option<&mut ConnectorEvent>,
res: Response,
) -> CustomResult<SetupMandateRouterData, errors::ConnectorError> {
let response: nexixpay::PaymentsResponse = res
.response
.parse_struct("PaymentsResponse")
.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,
})
}
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<PreProcessing, PaymentsPreProcessingData, PaymentsResponseData>
for Nexixpay
{
fn get_headers(
&self,
req: &PaymentsPreProcessingRouterData,
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: &PaymentsPreProcessingRouterData,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
Ok(format!(
"{}/orders/3steps/validation",
self.base_url(connectors)
))
}
fn get_request_body(
&self,
req: &PaymentsPreProcessingRouterData,
_connectors: &Connectors,
) -> CustomResult<RequestContent, errors::ConnectorError> {
let connector_req = nexixpay::NexixpayPreProcessingRequest::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(&types::PaymentsPreProcessingType::get_url(
self, req, connectors,
)?)
.attach_default_headers()
.headers(types::PaymentsPreProcessingType::get_headers(
self, req, connectors,
)?)
.set_body(types::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: nexixpay::NexixpayPreProcessingResponse = res
.response
.parse_struct("NexixpayPreProcessingResponse")
.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,
})
}
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<CompleteAuthorize, CompleteAuthorizeData, PaymentsResponseData>
for Nexixpay
{
fn get_headers(
&self,
req: &PaymentsCompleteAuthorizeRouterData,
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: &PaymentsCompleteAuthorizeRouterData,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
Ok(format!(
"{}/orders/3steps/payment",
self.base_url(connectors)
))
}
fn get_request_body(
&self,
req: &PaymentsCompleteAuthorizeRouterData,
_connectors: &Connectors,
) -> CustomResult<RequestContent, errors::ConnectorError> {
let amount = utils::convert_amount(
self.amount_converter,
req.request.minor_amount,
req.request.currency,
)?;
let connector_router_data = nexixpay::NexixpayRouterData::from((amount, req));
let connector_req =
nexixpay::NexixpayCompleteAuthorizeRequest::try_from(&connector_router_data)?;
Ok(RequestContent::Json(Box::new(connector_req)))
}
fn build_request(
&self,
req: &PaymentsCompleteAuthorizeRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Ok(Some(
RequestBuilder::new()
.method(Method::Post)
.url(&types::PaymentsCompleteAuthorizeType::get_url(
self, req, connectors,
)?)
.attach_default_headers()
.headers(types::PaymentsCompleteAuthorizeType::get_headers(
self, req, connectors,
)?)
.set_body(types::PaymentsCompleteAuthorizeType::get_request_body(
self, req, connectors,
)?)
.build(),
))
}
fn handle_response(
&self,
data: &PaymentsCompleteAuthorizeRouterData,
event_builder: Option<&mut ConnectorEvent>,
res: Response,
) -> CustomResult<PaymentsCompleteAuthorizeRouterData, errors::ConnectorError> {
let response: nexixpay::NexixpayCompleteAuthorizeResponse = res
.response
.parse_struct("NexixpayCompleteAuthorizeResponse")
.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,
})
}
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<Authorize, PaymentsAuthorizeData, PaymentsResponseData> for Nexixpay {
fn get_headers(
&self,
req: &PaymentsAuthorizeRouterData,
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: &PaymentsAuthorizeRouterData,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
if req.request.off_session == Some(true) {
Ok(format!("{}/orders/mit", self.base_url(connectors)))
} else {
Ok(format!("{}/orders/3steps/init", self.base_url(connectors)))
}
}
fn get_request_body(
&self,
req: &PaymentsAuthorizeRouterData,
_connectors: &Connectors,
) -> CustomResult<RequestContent, errors::ConnectorError> {
let amount = utils::convert_amount(
self.amount_converter,
req.request.minor_amount,
req.request.currency,
)?;
let connector_router_data = nexixpay::NexixpayRouterData::from((amount, req));
let connector_req = nexixpay::NexixpayPaymentsRequest::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> {
Ok(Some(
RequestBuilder::new()
.method(Method::Post)
.url(&types::PaymentsAuthorizeType::get_url(
self, req, connectors,
)?)
.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: nexixpay::NexixpayPaymentsResponse = res
.response
.parse_struct("NexixpayPaymentsResponse")
.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,
})
}
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<PSync, PaymentsSyncData, PaymentsResponseData> for Nexixpay {
fn get_headers(
&self,
req: &PaymentsSyncRouterData,
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: &PaymentsSyncRouterData,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
let connector_payment_id = get_payment_id((req.request.connector_meta.clone(), None))?;
Ok(format!(
"{}/operations/{}",
self.base_url(connectors),
connector_payment_id
))
}
fn build_request(
&self,
req: &PaymentsSyncRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Ok(Some(
RequestBuilder::new()
.method(Method::Get)
.url(&types::PaymentsSyncType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(types::PaymentsSyncType::get_headers(self, req, connectors)?)
.build(),
))
}
fn handle_response(
&self,
data: &PaymentsSyncRouterData,
event_builder: Option<&mut ConnectorEvent>,
res: Response,
) -> CustomResult<PaymentsSyncRouterData, errors::ConnectorError> {
let response: nexixpay::NexixpayTransactionResponse = res
.response
.parse_struct("NexixpayTransactionResponse")
.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,
})
}
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_payment_id(
(metadata, payment_intent): (Option<Value>, Option<nexixpay::NexixpayPaymentIntent>),
) -> CustomResult<String, errors::ConnectorError> {
let connector_metadata = metadata.ok_or(errors::ConnectorError::MissingRequiredField {
field_name: "connector_meta",
})?;
let nexixpay_meta_data =
serde_json::from_value::<nexixpay::NexixpayConnectorMetaData>(connector_metadata)
.change_context(errors::ConnectorError::ParsingFailed)?;
let payment_flow = payment_intent.unwrap_or(nexixpay_meta_data.psync_flow);
let payment_id = match payment_flow {
nexixpay::NexixpayPaymentIntent::Cancel => nexixpay_meta_data.cancel_operation_id,
nexixpay::NexixpayPaymentIntent::Capture => nexixpay_meta_data.capture_operation_id,
nexixpay::NexixpayPaymentIntent::Authorize => nexixpay_meta_data.authorization_operation_id,
};
payment_id.ok_or_else(|| {
errors::ConnectorError::MissingRequiredField {
field_name: "operation_id",
}
.into()
})
}
impl ConnectorIntegration<Capture, PaymentsCaptureData, PaymentsResponseData> for Nexixpay {
fn get_headers(
&self,
req: &PaymentsCaptureRouterData,
_connectors: &Connectors,
) -> CustomResult<Vec<(String, masking::Maskable<String>)>, errors::ConnectorError> {
let mut header = vec![(
headers::IDEMPOTENCY_KEY.to_string(),
Uuid::new_v4().to_string().into_masked(),
)];
let mut api_key = self.get_auth_header(&req.connector_auth_type)?;
header.append(&mut api_key);
Ok(header)
}
fn get_content_type(&self) -> &'static str {
self.common_get_content_type()
}
fn get_url(
&self,
req: &PaymentsCaptureRouterData,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
let connector_payment_id = get_payment_id((
req.request.connector_meta.clone(),
Some(nexixpay::NexixpayPaymentIntent::Authorize),
))?;
Ok(format!(
"{}/operations/{}/captures",
self.base_url(connectors),
connector_payment_id
))
}
fn get_request_body(
&self,
req: &PaymentsCaptureRouterData,
_connectors: &Connectors,
) -> CustomResult<RequestContent, errors::ConnectorError> {
let amount = utils::convert_amount(
self.amount_converter,
req.request.minor_amount_to_capture,
req.request.currency,
)?;
let connector_router_data = nexixpay::NexixpayRouterData::from((amount, req));
let connector_req =
nexixpay::NexixpayPaymentsCaptureRequest::try_from(&connector_router_data)?;
Ok(RequestContent::Json(Box::new(connector_req)))
}
fn build_request(
&self,
req: &PaymentsCaptureRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Ok(Some(
RequestBuilder::new()
.method(Method::Post)
.url(&types::PaymentsCaptureType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(types::PaymentsCaptureType::get_headers(
self, req, connectors,
)?)
.set_body(types::PaymentsCaptureType::get_request_body(
self, req, connectors,
)?)
.build(),
))
}
fn handle_response(
&self,
data: &PaymentsCaptureRouterData,
event_builder: Option<&mut ConnectorEvent>,
res: Response,
) -> CustomResult<PaymentsCaptureRouterData, errors::ConnectorError> {
let response: nexixpay::NexixpayOperationResponse = res
.response
.parse_struct("NexixpayOperationResponse")
.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,
})
}
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<Void, PaymentsCancelData, PaymentsResponseData> for Nexixpay {
fn get_headers(
&self,
req: &PaymentsCancelRouterData,
_connectors: &Connectors,
) -> CustomResult<Vec<(String, masking::Maskable<String>)>, errors::ConnectorError> {
let mut header = vec![(
headers::IDEMPOTENCY_KEY.to_string(),
Uuid::new_v4().to_string().into_masked(),
)];
let mut api_key = self.get_auth_header(&req.connector_auth_type)?;
header.append(&mut api_key);
Ok(header)
}
fn get_content_type(&self) -> &'static str {
self.common_get_content_type()
}
fn get_url(
&self,
req: &PaymentsCancelRouterData,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
let connector_payment_id = get_payment_id((
req.request.connector_meta.clone(),
Some(nexixpay::NexixpayPaymentIntent::Authorize),
))?;
Ok(format!(
"{}/operations/{}/refunds",
self.base_url(connectors),
connector_payment_id
))
}
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 = utils::convert_amount(self.amount_converter, minor_amount, currency)?;
let connector_router_data = nexixpay::NexixpayRouterData::from((amount, req));
let connector_req =
nexixpay::NexixpayPaymentsCancelRequest::try_from(connector_router_data)?;
Ok(RequestContent::Json(Box::new(connector_req)))
}
fn build_request(
&self,
req: &PaymentsCancelRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Ok(Some(
RequestBuilder::new()
.method(Method::Post)
.url(&types::PaymentsVoidType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(types::PaymentsVoidType::get_headers(self, req, connectors)?)
.set_body(types::PaymentsVoidType::get_request_body(
self, req, connectors,
)?)
.build(),
))
}
fn handle_response(
&self,
data: &PaymentsCancelRouterData,
event_builder: Option<&mut ConnectorEvent>,
res: Response,
) -> CustomResult<PaymentsCancelRouterData, errors::ConnectorError> {
let response: nexixpay::NexixpayOperationResponse = res
.response
.parse_struct("NexixpayOperationResponse")
.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,
})
}
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<Execute, RefundsData, RefundsResponseData> for Nexixpay {
fn get_headers(
&self,
req: &RefundsRouterData<Execute>,
_connectors: &Connectors,
) -> CustomResult<Vec<(String, masking::Maskable<String>)>, errors::ConnectorError> {
let mut header = vec![(
headers::IDEMPOTENCY_KEY.to_string(),
Uuid::new_v4().to_string().into_masked(),
)];
let mut api_key = self.get_auth_header(&req.connector_auth_type)?;
header.append(&mut api_key);
Ok(header)
}
fn get_content_type(&self) -> &'static str {
self.common_get_content_type()
}
fn get_url(
&self,
req: &RefundsRouterData<Execute>,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
let connector_payment_id = get_payment_id((
req.request.connector_metadata.clone(),
Some(nexixpay::NexixpayPaymentIntent::Capture),
))?;
Ok(format!(
"{}/operations/{}/refunds",
self.base_url(connectors),
connector_payment_id
))
}
fn get_request_body(
&self,
req: &RefundsRouterData<Execute>,
_connectors: &Connectors,
) -> CustomResult<RequestContent, errors::ConnectorError> {
let refund_amount = utils::convert_amount(
self.amount_converter,
req.request.minor_refund_amount,
req.request.currency,
)?;
let connector_router_data = nexixpay::NexixpayRouterData::from((refund_amount, req));
let connector_req = nexixpay::NexixpayRefundRequest::try_from(&connector_router_data)?;
Ok(RequestContent::Json(Box::new(connector_req)))
}
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))
}
fn handle_response(
&self,
data: &RefundsRouterData<Execute>,
event_builder: Option<&mut ConnectorEvent>,
res: Response,
) -> CustomResult<RefundsRouterData<Execute>, errors::ConnectorError> {
let response: nexixpay::RefundResponse = res
.response
.parse_struct("RefundResponse")
.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,
})
}
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<RSync, RefundsData, RefundsResponseData> for Nexixpay {
fn get_headers(
&self,
req: &RefundSyncRouterData,
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: &RefundSyncRouterData,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
let connector_refund_id = req.request.get_connector_refund_id()?;
Ok(format!(
"{}/operations/{}",
self.base_url(connectors),
connector_refund_id
))
}
fn build_request(
&self,
req: &RefundSyncRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Ok(Some(
RequestBuilder::new()
.method(Method::Get)
.url(&types::RefundSyncType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(types::RefundSyncType::get_headers(self, req, connectors)?)
.set_body(types::RefundSyncType::get_request_body(
self, req, connectors,
)?)
.build(),
))
}
fn handle_response(
&self,
data: &RefundSyncRouterData,
event_builder: Option<&mut ConnectorEvent>,
res: Response,
) -> CustomResult<RefundSyncRouterData, errors::ConnectorError> {
let response: nexixpay::NexixpayRSyncResponse = res
.response
.parse_struct("NexixpayRSyncResponse")
.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,
})
}
fn get_error_response(
&self,
res: Response,
event_builder: Option<&mut ConnectorEvent>,
) -> CustomResult<ErrorResponse, errors::ConnectorError> {
self.build_error_response(res, event_builder)
}
}
#[async_trait::async_trait]
impl webhooks::IncomingWebhook for Nexixpay {
fn get_webhook_object_reference_id(
&self,
_request: &webhooks::IncomingWebhookRequestDetails<'_>,
) -> CustomResult<api_models::webhooks::ObjectReferenceId, errors::ConnectorError> {
Err(report!(errors::ConnectorError::WebhooksNotImplemented))
}
fn get_webhook_event_type(
&self,
_request: &webhooks::IncomingWebhookRequestDetails<'_>,
) -> CustomResult<api_models::webhooks::IncomingWebhookEvent, errors::ConnectorError> {
Err(report!(errors::ConnectorError::WebhooksNotImplemented))
}
fn get_webhook_resource_object(
&self,
_request: &webhooks::IncomingWebhookRequestDetails<'_>,
) -> CustomResult<Box<dyn masking::ErasedMaskSerialize>, errors::ConnectorError> {
Err(report!(errors::ConnectorError::WebhooksNotImplemented))
}
}
lazy_static! {
static ref NEXIXPAY_CONNECTOR_INFO: ConnectorInfo = ConnectorInfo {
display_name: "Nexixpay",
description: "Nexixpay is an Italian bank that specialises in payment systems such as Nexi Payments (formerly known as CartaSi).",
connector_type: enums::HyperswitchConnectorCategory::PaymentGateway,
integration_status: enums::ConnectorIntegrationStatus::Sandbox,
};
static ref NEXIXPAY_SUPPORTED_PAYMENT_METHODS: SupportedPaymentMethods = {
let supported_capture_methods = vec![
enums::CaptureMethod::Automatic,
enums::CaptureMethod::Manual,
enums::CaptureMethod::SequentialAutomatic,
];
let supported_card_network = vec![
common_enums::CardNetwork::Visa,
common_enums::CardNetwork::Mastercard,
common_enums::CardNetwork::AmericanExpress,
common_enums::CardNetwork::JCB,
];
let mut nexixpay_supported_payment_methods = SupportedPaymentMethods::new();
nexixpay_supported_payment_methods.add(
enums::PaymentMethod::Card,
enums::PaymentMethodType::Credit,
PaymentMethodDetails {
mandates: common_enums::FeatureStatus::Supported,
refunds: common_enums::FeatureStatus::Supported,
supported_capture_methods: supported_capture_methods.clone(),
specific_features: Some(
api_models::feature_matrix::PaymentMethodSpecificFeatures::Card({
api_models::feature_matrix::CardSpecificFeatures {
three_ds: common_enums::FeatureStatus::Supported,
no_three_ds: common_enums::FeatureStatus::Supported,
supported_card_networks: supported_card_network.clone(),
}
}),
)
}
);
nexixpay_supported_payment_methods.add(
enums::PaymentMethod::Card,
enums::PaymentMethodType::Debit,
PaymentMethodDetails {
mandates: common_enums::FeatureStatus::Supported,
refunds: common_enums::FeatureStatus::Supported,
supported_capture_methods,
specific_features: Some(
api_models::feature_matrix::PaymentMethodSpecificFeatures::Card({
api_models::feature_matrix::CardSpecificFeatures {
three_ds: common_enums::FeatureStatus::Supported,
no_three_ds: common_enums::FeatureStatus::Supported,
supported_card_networks: supported_card_network,
}
}),
)
}
);
nexixpay_supported_payment_methods
};
static ref NEXIXPAY_SUPPORTED_WEBHOOK_FLOWS: Vec<enums::EventClass> = Vec::new();
}
impl ConnectorSpecifications for Nexixpay {
fn get_connector_about(&self) -> Option<&'static ConnectorInfo> {
Some(&*NEXIXPAY_CONNECTOR_INFO)
}
fn get_supported_payment_methods(&self) -> Option<&'static SupportedPaymentMethods> {
Some(&*NEXIXPAY_SUPPORTED_PAYMENT_METHODS)
}
fn get_supported_webhook_flows(&self) -> Option<&'static [enums::EventClass]> {
Some(&*NEXIXPAY_SUPPORTED_WEBHOOK_FLOWS)
}
}
|
{
"crate": "hyperswitch_connectors",
"file": "crates/hyperswitch_connectors/src/connectors/nexixpay.rs",
"file_size": null,
"is_async": null,
"is_pub": null,
"num_enums": 0,
"num_structs": 1,
"num_tables": null,
"score": null,
"total_crates": null
}
|
file_hyperswitch_connectors_1418173927428348086
|
clm
|
file
|
// Repository: hyperswitch
// Crate: hyperswitch_connectors
// File: crates/hyperswitch_connectors/src/connectors/powertranz/transformers.rs
// Contains: 10 structs, 1 enums
use common_enums::enums::{self, AuthenticationType};
use common_utils::{pii::IpAddress, types::FloatMajorUnit};
use hyperswitch_domain_models::{
payment_method_data::{Card, PaymentMethodData},
router_data::{ConnectorAuthType, ErrorResponse, RouterData},
router_flow_types::refunds::Execute,
router_request_types::{BrowserInformation, PaymentsCancelData, ResponseId},
router_response_types::{PaymentsResponseData, RefundsResponseData},
types::{PaymentsAuthorizeRouterData, PaymentsCaptureRouterData, RefundsRouterData},
};
use hyperswitch_interfaces::{consts, errors};
use masking::{ExposeInterface, Secret};
use serde::{Deserialize, Serialize};
use uuid::Uuid;
use crate::{
types::{RefundsResponseRouterData, ResponseRouterData},
utils::{self, CardData, PaymentsAuthorizeRequestData, RouterData as _},
};
const ISO_SUCCESS_CODES: [&str; 7] = ["00", "3D0", "3D1", "HP0", "TK0", "SP4", "FC0"];
pub struct PowertranzRouterData<T> {
pub amount: FloatMajorUnit,
pub router_data: T,
}
impl<T> TryFrom<(FloatMajorUnit, T)> for PowertranzRouterData<T> {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from((amount, item): (FloatMajorUnit, T)) -> Result<Self, Self::Error> {
Ok(Self {
amount,
router_data: item,
})
}
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "PascalCase")]
pub struct PowertranzPaymentsRequest {
transaction_identifier: String,
total_amount: FloatMajorUnit,
currency_code: String,
three_d_secure: bool,
source: Source,
order_identifier: String,
// billing and shipping are optional fields and requires state in iso codes, hence commenting it
// can be added later if we have iso code for state
// billing_address: Option<PowertranzAddressDetails>,
// shipping_address: Option<PowertranzAddressDetails>,
extended_data: Option<ExtendedData>,
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "PascalCase")]
pub struct ExtendedData {
three_d_secure: ThreeDSecure,
merchant_response_url: String,
browser_info: BrowserInfo,
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "PascalCase")]
pub struct BrowserInfo {
java_enabled: Option<bool>,
javascript_enabled: Option<bool>,
accept_header: Option<String>,
language: Option<String>,
screen_height: Option<String>,
screen_width: Option<String>,
time_zone: Option<String>,
user_agent: Option<String>,
i_p: Option<Secret<String, IpAddress>>,
color_depth: Option<String>,
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "PascalCase")]
pub struct ThreeDSecure {
challenge_window_size: u8,
}
#[derive(Debug, Serialize)]
#[serde(untagged)]
pub enum Source {
Card(PowertranzCard),
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "PascalCase")]
pub struct PowertranzCard {
cardholder_name: Secret<String>,
card_pan: cards::CardNumber,
card_expiration: Secret<String>,
card_cvv: Secret<String>,
}
// #[derive(Debug, Serialize)]
// #[serde(rename_all = "PascalCase")]
// pub struct PowertranzAddressDetails {
// first_name: Option<Secret<String>>,
// last_name: Option<Secret<String>>,
// line1: Option<Secret<String>>,
// line2: Option<Secret<String>>,
// city: Option<String>,
// country: Option<enums::CountryAlpha2>,
// state: Option<Secret<String>>,
// postal_code: Option<Secret<String>>,
// email_address: Option<Email>,
// phone_number: Option<Secret<String>>,
// }
#[derive(Debug, Deserialize)]
#[serde(rename_all = "PascalCase")]
pub struct RedirectResponsePayload {
pub spi_token: Secret<String>,
}
impl TryFrom<&PowertranzRouterData<&PaymentsAuthorizeRouterData>> for PowertranzPaymentsRequest {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: &PowertranzRouterData<&PaymentsAuthorizeRouterData>,
) -> Result<Self, Self::Error> {
let source = match item.router_data.request.payment_method_data.clone() {
PaymentMethodData::Card(card) => {
let card_holder_name = item.router_data.get_optional_billing_full_name();
Source::try_from((&card, card_holder_name))
}
PaymentMethodData::Wallet(_)
| PaymentMethodData::CardRedirect(_)
| PaymentMethodData::PayLater(_)
| PaymentMethodData::BankRedirect(_)
| PaymentMethodData::BankDebit(_)
| PaymentMethodData::BankTransfer(_)
| PaymentMethodData::Crypto(_)
| PaymentMethodData::MandatePayment
| PaymentMethodData::Reward
| PaymentMethodData::RealTimePayment(_)
| PaymentMethodData::MobilePayment(_)
| PaymentMethodData::Upi(_)
| PaymentMethodData::Voucher(_)
| PaymentMethodData::GiftCard(_)
| PaymentMethodData::OpenBanking(_)
| PaymentMethodData::CardToken(_)
| PaymentMethodData::NetworkToken(_)
| PaymentMethodData::CardDetailsForNetworkTransactionId(_) => {
Err(errors::ConnectorError::NotSupported {
message: utils::SELECTED_PAYMENT_METHOD.to_string(),
connector: "powertranz",
}
.into())
}
}?;
// let billing_address = get_address_details(&item.router_data.address.billing, &item.router_data.request.email);
// let shipping_address = get_address_details(&item.router_data.address.shipping, &item.router_data.request.email);
let (three_d_secure, extended_data) = match item.router_data.auth_type {
AuthenticationType::ThreeDs => (true, Some(ExtendedData::try_from(item.router_data)?)),
AuthenticationType::NoThreeDs => (false, None),
};
Ok(Self {
transaction_identifier: Uuid::new_v4().to_string(),
total_amount: item.amount,
currency_code: item.router_data.request.currency.iso_4217().to_string(),
three_d_secure,
source,
order_identifier: item.router_data.connector_request_reference_id.clone(),
// billing_address,
// shipping_address,
extended_data,
})
}
}
impl TryFrom<&PaymentsAuthorizeRouterData> for ExtendedData {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(item: &PaymentsAuthorizeRouterData) -> Result<Self, Self::Error> {
Ok(Self {
three_d_secure: ThreeDSecure {
// Merchants preferred sized of challenge window presented to cardholder.
// 5 maps to 100% of challenge window size
challenge_window_size: 5,
},
merchant_response_url: item.request.get_complete_authorize_url()?,
browser_info: BrowserInfo::try_from(&item.request.get_browser_info()?)?,
})
}
}
impl TryFrom<&BrowserInformation> for BrowserInfo {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(item: &BrowserInformation) -> Result<Self, Self::Error> {
Ok(Self {
java_enabled: item.java_enabled,
javascript_enabled: item.java_script_enabled,
accept_header: item.accept_header.clone(),
language: item.language.clone(),
screen_height: item.screen_height.map(|height| height.to_string()),
screen_width: item.screen_width.map(|width| width.to_string()),
time_zone: item.time_zone.map(|zone| zone.to_string()),
user_agent: item.user_agent.clone(),
i_p: item
.ip_address
.map(|ip_address| Secret::new(ip_address.to_string())),
color_depth: item.color_depth.map(|depth| depth.to_string()),
})
}
}
/*fn get_address_details(
address: &Option<Address>,
email: &Option<Email>,
) -> Option<PowertranzAddressDetails> {
let phone_number = address
.as_ref()
.and_then(|address| address.phone.as_ref())
.and_then(|phone| {
phone.number.as_ref().and_then(|number| {
phone.country_code.as_ref().map(|country_code| {
Secret::new(format!("{}{}", country_code, number.clone().expose()))
})
})
});
address
.as_ref()
.and_then(|address| address.address.as_ref())
.map(|address_details| PowertranzAddressDetails {
first_name: address_details.first_name.clone(),
last_name: address_details.last_name.clone(),
line1: address_details.line1.clone(),
line2: address_details.line2.clone(),
city: address_details.city.clone(),
country: address_details.country,
state: address_details.state.clone(),
postal_code: address_details.zip.clone(),
email_address: email.clone(),
phone_number,
})
}*/
impl TryFrom<(&Card, Option<Secret<String>>)> for Source {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
(card, card_holder_name): (&Card, Option<Secret<String>>),
) -> Result<Self, Self::Error> {
let card = PowertranzCard {
cardholder_name: card_holder_name.unwrap_or(Secret::new("".to_string())),
card_pan: card.card_number.clone(),
card_expiration: card.get_expiry_date_as_yymm()?,
card_cvv: card.card_cvc.clone(),
};
Ok(Self::Card(card))
}
}
// Auth Struct
pub struct PowertranzAuthType {
pub(super) power_tranz_id: Secret<String>,
pub(super) power_tranz_password: Secret<String>,
}
impl TryFrom<&ConnectorAuthType> for PowertranzAuthType {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(auth_type: &ConnectorAuthType) -> Result<Self, Self::Error> {
match auth_type {
ConnectorAuthType::BodyKey { api_key, key1 } => Ok(Self {
power_tranz_id: key1.to_owned(),
power_tranz_password: api_key.to_owned(),
}),
_ => Err(errors::ConnectorError::FailedToObtainAuthType.into()),
}
}
}
// Common struct used in Payment, Capture, Void, Refund
#[derive(Debug, Deserialize, Serialize)]
#[serde(rename_all = "PascalCase")]
pub struct PowertranzBaseResponse {
transaction_type: u8,
approved: bool,
transaction_identifier: String,
original_trxn_identifier: Option<String>,
errors: Option<Vec<Error>>,
iso_response_code: String,
redirect_data: Option<Secret<String>>,
response_message: String,
order_identifier: String,
}
fn get_status((transaction_type, approved, is_3ds): (u8, bool, bool)) -> enums::AttemptStatus {
match transaction_type {
// Auth
1 => match approved {
true => enums::AttemptStatus::Authorized,
false => match is_3ds {
true => enums::AttemptStatus::AuthenticationPending,
false => enums::AttemptStatus::Failure,
},
},
// Sale
2 => match approved {
true => enums::AttemptStatus::Charged,
false => match is_3ds {
true => enums::AttemptStatus::AuthenticationPending,
false => enums::AttemptStatus::Failure,
},
},
// Capture
3 => match approved {
true => enums::AttemptStatus::Charged,
false => enums::AttemptStatus::Failure,
},
// Void
4 => match approved {
true => enums::AttemptStatus::Voided,
false => enums::AttemptStatus::VoidFailed,
},
// Refund
5 => match approved {
true => enums::AttemptStatus::AutoRefunded,
false => enums::AttemptStatus::Failure,
},
// Risk Management
_ => match approved {
true => enums::AttemptStatus::Pending,
false => enums::AttemptStatus::Failure,
},
}
}
impl<F, T> TryFrom<ResponseRouterData<F, PowertranzBaseResponse, T, PaymentsResponseData>>
for RouterData<F, T, PaymentsResponseData>
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: ResponseRouterData<F, PowertranzBaseResponse, T, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
let error_response = build_error_response(&item.response, item.http_code);
// original_trxn_identifier will be present only in capture and void
let connector_transaction_id = item
.response
.original_trxn_identifier
.unwrap_or(item.response.transaction_identifier.clone());
let redirection_data = item.response.redirect_data.map(|redirect_data| {
hyperswitch_domain_models::router_response_types::RedirectForm::Html {
html_data: redirect_data.expose(),
}
});
let response = error_response.map_or(
Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(connector_transaction_id),
redirection_data: Box::new(redirection_data),
mandate_reference: Box::new(None),
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: Some(item.response.order_identifier),
incremental_authorization_allowed: None,
charges: None,
}),
Err,
);
Ok(Self {
status: get_status((
item.response.transaction_type,
item.response.approved,
is_3ds_payment(item.response.iso_response_code),
)),
response,
..item.data
})
}
}
fn is_3ds_payment(response_code: String) -> bool {
matches!(response_code.as_str(), "SP4")
}
// Type definition for Capture, Void, Refund Request
#[derive(Default, Debug, Serialize)]
#[serde(rename_all = "PascalCase")]
pub struct PowertranzBaseRequest {
transaction_identifier: String,
total_amount: Option<FloatMajorUnit>,
refund: Option<bool>,
}
impl TryFrom<&PaymentsCancelData> for PowertranzBaseRequest {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(item: &PaymentsCancelData) -> Result<Self, Self::Error> {
Ok(Self {
transaction_identifier: item.connector_transaction_id.clone(),
total_amount: None,
refund: None,
})
}
}
impl TryFrom<&PowertranzRouterData<&PaymentsCaptureRouterData>> for PowertranzBaseRequest {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: &PowertranzRouterData<&PaymentsCaptureRouterData>,
) -> Result<Self, Self::Error> {
Ok(Self {
transaction_identifier: item.router_data.request.connector_transaction_id.clone(),
total_amount: Some(item.amount),
refund: None,
})
}
}
impl<F> TryFrom<&PowertranzRouterData<&RefundsRouterData<F>>> for PowertranzBaseRequest {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(item: &PowertranzRouterData<&RefundsRouterData<F>>) -> Result<Self, Self::Error> {
Ok(Self {
transaction_identifier: item.router_data.request.connector_transaction_id.clone(),
total_amount: Some(item.amount),
refund: Some(true),
})
}
}
impl TryFrom<RefundsResponseRouterData<Execute, PowertranzBaseResponse>>
for RefundsRouterData<Execute>
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: RefundsResponseRouterData<Execute, PowertranzBaseResponse>,
) -> Result<Self, Self::Error> {
let error_response = build_error_response(&item.response, item.http_code);
let response = error_response.map_or(
Ok(RefundsResponseData {
connector_refund_id: item.response.transaction_identifier.to_string(),
refund_status: match item.response.approved {
true => enums::RefundStatus::Success,
false => enums::RefundStatus::Failure,
},
}),
Err,
);
Ok(Self {
response,
..item.data
})
}
}
fn build_error_response(item: &PowertranzBaseResponse, status_code: u16) -> Option<ErrorResponse> {
// errors object has highest precedence to get error message and code
let error_response = if item.errors.is_some() {
item.errors.as_ref().map(|errors| {
let first_error = errors.first();
let code = first_error.map(|error| error.code.clone());
let message = first_error.map(|error| error.message.clone());
ErrorResponse {
status_code,
code: code.unwrap_or_else(|| consts::NO_ERROR_CODE.to_string()),
message: message.unwrap_or_else(|| consts::NO_ERROR_MESSAGE.to_string()),
reason: Some(
errors
.iter()
.map(|error| format!("{} : {}", error.code, error.message))
.collect::<Vec<_>>()
.join(", "),
),
attempt_status: None,
connector_transaction_id: None,
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
connector_metadata: None,
}
})
} else if !ISO_SUCCESS_CODES.contains(&item.iso_response_code.as_str()) {
// Incase error object is not present the error message and code should be propagated based on iso_response_code
Some(ErrorResponse {
status_code,
code: item.iso_response_code.clone(),
message: item.response_message.clone(),
reason: Some(item.response_message.clone()),
attempt_status: None,
connector_transaction_id: None,
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
connector_metadata: None,
})
} else {
None
};
error_response
}
#[derive(Debug, Deserialize)]
#[serde(rename_all = "PascalCase")]
pub struct PowertranzErrorResponse {
pub errors: Vec<Error>,
}
#[derive(Debug, Deserialize, Serialize)]
#[serde(rename_all = "PascalCase")]
pub struct Error {
pub code: String,
pub message: String,
}
|
{
"crate": "hyperswitch_connectors",
"file": "crates/hyperswitch_connectors/src/connectors/powertranz/transformers.rs",
"file_size": null,
"is_async": null,
"is_pub": null,
"num_enums": 1,
"num_structs": 10,
"num_tables": null,
"score": null,
"total_crates": null
}
|
file_hyperswitch_connectors_-5283068358765394278
|
clm
|
file
|
// Repository: hyperswitch
// Crate: hyperswitch_connectors
// File: crates/hyperswitch_connectors/src/connectors/stax/transformers.rs
// Contains: 16 structs, 3 enums
use common_enums::enums;
use common_utils::pii::Email;
use error_stack::ResultExt;
use hyperswitch_domain_models::{
payment_method_data::{BankDebitData, PaymentMethodData},
router_data::{ConnectorAuthType, PaymentMethodToken, RouterData},
router_flow_types::refunds::{Execute, RSync},
router_request_types::ResponseId,
router_response_types::{
ConnectorCustomerResponseData, PaymentsResponseData, RefundsResponseData,
},
types,
};
use hyperswitch_interfaces::{api, errors};
use masking::{ExposeInterface, Secret};
use serde::{Deserialize, Serialize};
use crate::{
types::{RefundsResponseRouterData, ResponseRouterData},
unimplemented_payment_method,
utils::{
self, missing_field_err, CardData as CardDataUtil, PaymentsAuthorizeRequestData,
RouterData as _,
},
};
#[derive(Debug, Serialize)]
pub struct StaxRouterData<T> {
pub amount: f64,
pub router_data: T,
}
impl<T> TryFrom<(&api::CurrencyUnit, enums::Currency, i64, T)> for StaxRouterData<T> {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
(currency_unit, currency, amount, item): (&api::CurrencyUnit, enums::Currency, i64, T),
) -> Result<Self, Self::Error> {
let amount = utils::get_amount_as_f64(currency_unit, amount, currency)?;
Ok(Self {
amount,
router_data: item,
})
}
}
#[derive(Debug, Serialize)]
pub struct StaxPaymentsRequestMetaData {
tax: i64,
}
#[derive(Debug, Serialize)]
pub struct StaxPaymentsRequest {
payment_method_id: Secret<String>,
total: f64,
is_refundable: bool,
pre_auth: bool,
meta: StaxPaymentsRequestMetaData,
idempotency_id: Option<String>,
}
impl TryFrom<&StaxRouterData<&types::PaymentsAuthorizeRouterData>> for StaxPaymentsRequest {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: &StaxRouterData<&types::PaymentsAuthorizeRouterData>,
) -> Result<Self, Self::Error> {
if item.router_data.request.currency != enums::Currency::USD {
Err(errors::ConnectorError::NotImplemented(
utils::get_unimplemented_payment_method_error_message("Stax"),
))?
}
let total = item.amount;
match item.router_data.request.payment_method_data.clone() {
PaymentMethodData::Card(_) => {
let pm_token = item.router_data.get_payment_method_token()?;
let pre_auth = !item.router_data.request.is_auto_capture()?;
Ok(Self {
meta: StaxPaymentsRequestMetaData { tax: 0 },
total,
is_refundable: true,
pre_auth,
payment_method_id: match pm_token {
PaymentMethodToken::Token(token) => token,
PaymentMethodToken::ApplePayDecrypt(_) => Err(
unimplemented_payment_method!("Apple Pay", "Simplified", "Stax"),
)?,
PaymentMethodToken::PazeDecrypt(_) => {
Err(unimplemented_payment_method!("Paze", "Stax"))?
}
PaymentMethodToken::GooglePayDecrypt(_) => {
Err(unimplemented_payment_method!("Google Pay", "Stax"))?
}
},
idempotency_id: Some(item.router_data.connector_request_reference_id.clone()),
})
}
PaymentMethodData::BankDebit(BankDebitData::AchBankDebit { .. }) => {
let pm_token = item.router_data.get_payment_method_token()?;
let pre_auth = !item.router_data.request.is_auto_capture()?;
Ok(Self {
meta: StaxPaymentsRequestMetaData { tax: 0 },
total,
is_refundable: true,
pre_auth,
payment_method_id: match pm_token {
PaymentMethodToken::Token(token) => token,
PaymentMethodToken::ApplePayDecrypt(_) => Err(
unimplemented_payment_method!("Apple Pay", "Simplified", "Stax"),
)?,
PaymentMethodToken::PazeDecrypt(_) => {
Err(unimplemented_payment_method!("Paze", "Stax"))?
}
PaymentMethodToken::GooglePayDecrypt(_) => {
Err(unimplemented_payment_method!("Google Pay", "Stax"))?
}
},
idempotency_id: Some(item.router_data.connector_request_reference_id.clone()),
})
}
PaymentMethodData::BankDebit(_)
| PaymentMethodData::Wallet(_)
| PaymentMethodData::PayLater(_)
| PaymentMethodData::BankRedirect(_)
| PaymentMethodData::BankTransfer(_)
| PaymentMethodData::Crypto(_)
| PaymentMethodData::MandatePayment
| PaymentMethodData::Reward
| PaymentMethodData::RealTimePayment(_)
| PaymentMethodData::MobilePayment(_)
| PaymentMethodData::Voucher(_)
| PaymentMethodData::GiftCard(_)
| PaymentMethodData::CardRedirect(_)
| PaymentMethodData::Upi(_)
| PaymentMethodData::OpenBanking(_)
| PaymentMethodData::CardToken(_)
| PaymentMethodData::NetworkToken(_)
| PaymentMethodData::CardDetailsForNetworkTransactionId(_) => {
Err(errors::ConnectorError::NotImplemented(
utils::get_unimplemented_payment_method_error_message("Stax"),
))?
}
}
}
}
// Auth Struct
pub struct StaxAuthType {
pub(super) api_key: Secret<String>,
}
impl TryFrom<&ConnectorAuthType> for StaxAuthType {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(auth_type: &ConnectorAuthType) -> Result<Self, Self::Error> {
match auth_type {
ConnectorAuthType::HeaderKey { api_key } => Ok(Self {
api_key: api_key.to_owned(),
}),
_ => Err(errors::ConnectorError::FailedToObtainAuthType.into()),
}
}
}
#[derive(Debug, Serialize)]
pub struct StaxCustomerRequest {
#[serde(skip_serializing_if = "Option::is_none")]
email: Option<Email>,
#[serde(skip_serializing_if = "Option::is_none")]
firstname: Option<Secret<String>>,
}
impl TryFrom<&types::ConnectorCustomerRouterData> for StaxCustomerRequest {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(item: &types::ConnectorCustomerRouterData) -> Result<Self, Self::Error> {
if item.request.email.is_none() && item.request.name.is_none() {
Err(errors::ConnectorError::MissingRequiredField {
field_name: "email or name",
}
.into())
} else {
Ok(Self {
email: item.request.email.to_owned(),
firstname: item.request.name.to_owned(),
})
}
}
}
#[derive(Debug, Deserialize, Serialize)]
pub struct StaxCustomerResponse {
id: Secret<String>,
}
impl<F, T> TryFrom<ResponseRouterData<F, StaxCustomerResponse, T, PaymentsResponseData>>
for RouterData<F, T, PaymentsResponseData>
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: ResponseRouterData<F, StaxCustomerResponse, T, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
Ok(Self {
response: Ok(PaymentsResponseData::ConnectorCustomerResponse(
ConnectorCustomerResponseData::new_with_customer_id(item.response.id.expose()),
)),
..item.data
})
}
}
#[derive(Debug, Serialize)]
pub struct StaxTokenizeData {
person_name: Secret<String>,
card_number: cards::CardNumber,
card_exp: Secret<String>,
card_cvv: Secret<String>,
customer_id: Secret<String>,
}
#[derive(Debug, Serialize)]
pub struct StaxBankTokenizeData {
person_name: Secret<String>,
bank_account: Secret<String>,
bank_routing: Secret<String>,
bank_name: common_enums::BankNames,
bank_type: common_enums::BankType,
bank_holder_type: common_enums::BankHolderType,
customer_id: Secret<String>,
}
#[derive(Debug, Serialize)]
#[serde(tag = "method")]
#[serde(rename_all = "lowercase")]
pub enum StaxTokenRequest {
Card(StaxTokenizeData),
Bank(StaxBankTokenizeData),
}
impl TryFrom<&types::TokenizationRouterData> for StaxTokenRequest {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(item: &types::TokenizationRouterData) -> Result<Self, Self::Error> {
let customer_id = item.get_connector_customer_id()?;
match item.request.payment_method_data.clone() {
PaymentMethodData::Card(card_data) => {
let stax_card_data = StaxTokenizeData {
card_exp: card_data
.get_card_expiry_month_year_2_digit_with_delimiter("".to_string())?,
person_name: item
.get_optional_billing_full_name()
.unwrap_or(Secret::new("".to_string())),
card_number: card_data.card_number,
card_cvv: card_data.card_cvc,
customer_id: Secret::new(customer_id),
};
Ok(Self::Card(stax_card_data))
}
PaymentMethodData::BankDebit(BankDebitData::AchBankDebit {
account_number,
routing_number,
bank_name,
bank_type,
bank_holder_type,
..
}) => {
let stax_bank_data = StaxBankTokenizeData {
person_name: item.get_billing_full_name()?,
bank_account: account_number,
bank_routing: routing_number,
bank_name: bank_name.ok_or_else(missing_field_err("bank_name"))?,
bank_type: bank_type.ok_or_else(missing_field_err("bank_type"))?,
bank_holder_type: bank_holder_type
.ok_or_else(missing_field_err("bank_holder_type"))?,
customer_id: Secret::new(customer_id),
};
Ok(Self::Bank(stax_bank_data))
}
PaymentMethodData::BankDebit(_)
| PaymentMethodData::Wallet(_)
| PaymentMethodData::PayLater(_)
| PaymentMethodData::BankRedirect(_)
| PaymentMethodData::BankTransfer(_)
| PaymentMethodData::Crypto(_)
| PaymentMethodData::MandatePayment
| PaymentMethodData::Reward
| PaymentMethodData::RealTimePayment(_)
| PaymentMethodData::MobilePayment(_)
| PaymentMethodData::Voucher(_)
| PaymentMethodData::GiftCard(_)
| PaymentMethodData::CardRedirect(_)
| PaymentMethodData::Upi(_)
| PaymentMethodData::OpenBanking(_)
| PaymentMethodData::CardToken(_)
| PaymentMethodData::NetworkToken(_)
| PaymentMethodData::CardDetailsForNetworkTransactionId(_) => {
Err(errors::ConnectorError::NotImplemented(
utils::get_unimplemented_payment_method_error_message("Stax"),
))?
}
}
}
}
#[derive(Debug, Deserialize, Serialize)]
pub struct StaxTokenResponse {
id: Secret<String>,
}
impl<F, T> TryFrom<ResponseRouterData<F, StaxTokenResponse, T, PaymentsResponseData>>
for RouterData<F, T, PaymentsResponseData>
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: ResponseRouterData<F, StaxTokenResponse, T, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
Ok(Self {
response: Ok(PaymentsResponseData::TokenizationResponse {
token: item.response.id.expose(),
}),
..item.data
})
}
}
#[derive(Debug, Deserialize, Serialize)]
#[serde(rename_all = "snake_case")]
pub enum StaxPaymentResponseTypes {
Charge,
PreAuth,
}
#[derive(Debug, Deserialize, Serialize)]
pub struct StaxChildCapture {
id: String,
}
#[derive(Debug, Deserialize, Serialize)]
pub struct StaxPaymentsResponse {
success: bool,
id: String,
is_captured: i8,
is_voided: bool,
child_captures: Vec<StaxChildCapture>,
#[serde(rename = "type")]
payment_response_type: StaxPaymentResponseTypes,
idempotency_id: Option<String>,
}
#[derive(Debug, Deserialize, Serialize)]
pub struct StaxMetaData {
pub capture_id: String,
}
impl<F, T> TryFrom<ResponseRouterData<F, StaxPaymentsResponse, T, PaymentsResponseData>>
for RouterData<F, T, PaymentsResponseData>
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: ResponseRouterData<F, StaxPaymentsResponse, T, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
let mut connector_metadata = None;
let mut status = match item.response.success {
true => match item.response.payment_response_type {
StaxPaymentResponseTypes::Charge => enums::AttemptStatus::Charged,
StaxPaymentResponseTypes::PreAuth => match item.response.is_captured {
0 => enums::AttemptStatus::Authorized,
_ => {
connector_metadata =
item.response.child_captures.first().map(|child_captures| {
serde_json::json!(StaxMetaData {
capture_id: child_captures.id.clone()
})
});
enums::AttemptStatus::Charged
}
},
},
false => enums::AttemptStatus::Failure,
};
if item.response.is_voided {
status = enums::AttemptStatus::Voided;
}
Ok(Self {
status,
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(item.response.id.clone()),
redirection_data: Box::new(None),
mandate_reference: Box::new(None),
connector_metadata,
network_txn_id: None,
connector_response_reference_id: Some(
item.response.idempotency_id.unwrap_or(item.response.id),
),
incremental_authorization_allowed: None,
charges: None,
}),
..item.data
})
}
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct StaxCaptureRequest {
total: Option<f64>,
}
impl TryFrom<&StaxRouterData<&types::PaymentsCaptureRouterData>> for StaxCaptureRequest {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: &StaxRouterData<&types::PaymentsCaptureRouterData>,
) -> Result<Self, Self::Error> {
let total = item.amount;
Ok(Self { total: Some(total) })
}
}
// REFUND :
// Type definition for RefundRequest
#[derive(Debug, Serialize)]
pub struct StaxRefundRequest {
pub total: f64,
}
impl<F> TryFrom<&StaxRouterData<&types::RefundsRouterData<F>>> for StaxRefundRequest {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(item: &StaxRouterData<&types::RefundsRouterData<F>>) -> Result<Self, Self::Error> {
Ok(Self { total: item.amount })
}
}
#[derive(Debug, Deserialize, Serialize)]
pub struct ChildTransactionsInResponse {
id: String,
success: bool,
created_at: String,
total: f64,
}
#[derive(Debug, Deserialize, Serialize)]
pub struct RefundResponse {
id: String,
success: bool,
child_transactions: Vec<ChildTransactionsInResponse>,
}
impl TryFrom<RefundsResponseRouterData<Execute, RefundResponse>>
for types::RefundsRouterData<Execute>
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: RefundsResponseRouterData<Execute, RefundResponse>,
) -> Result<Self, Self::Error> {
let refund_amount = utils::to_currency_base_unit_asf64(
item.data.request.refund_amount,
item.data.request.currency,
)
.change_context(errors::ConnectorError::ResponseHandlingFailed)?;
let filtered_txn: Vec<&ChildTransactionsInResponse> = item
.response
.child_transactions
.iter()
.filter(|txn| txn.total == refund_amount)
.collect();
let mut refund_txn = filtered_txn
.first()
.ok_or(errors::ConnectorError::ResponseHandlingFailed)?;
for child in filtered_txn.iter() {
if child.created_at > refund_txn.created_at {
refund_txn = child;
}
}
let refund_status = match refund_txn.success {
true => enums::RefundStatus::Success,
false => enums::RefundStatus::Failure,
};
Ok(Self {
response: Ok(RefundsResponseData {
connector_refund_id: refund_txn.id.clone(),
refund_status,
}),
..item.data
})
}
}
impl TryFrom<RefundsResponseRouterData<RSync, RefundResponse>> for types::RefundsRouterData<RSync> {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: RefundsResponseRouterData<RSync, RefundResponse>,
) -> Result<Self, Self::Error> {
let refund_status = match item.response.success {
true => enums::RefundStatus::Success,
false => enums::RefundStatus::Failure,
};
Ok(Self {
response: Ok(RefundsResponseData {
connector_refund_id: item.response.id,
refund_status,
}),
..item.data
})
}
}
#[derive(Debug, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum StaxWebhookEventType {
PreAuth,
Capture,
Charge,
Void,
Refund,
#[serde(other)]
Unknown,
}
#[derive(Debug, Deserialize)]
pub struct StaxWebhookBody {
#[serde(rename = "type")]
pub transaction_type: StaxWebhookEventType,
pub id: String,
pub auth_id: Option<String>,
pub success: bool,
}
|
{
"crate": "hyperswitch_connectors",
"file": "crates/hyperswitch_connectors/src/connectors/stax/transformers.rs",
"file_size": null,
"is_async": null,
"is_pub": null,
"num_enums": 3,
"num_structs": 16,
"num_tables": null,
"score": null,
"total_crates": null
}
|
file_hyperswitch_connectors_-5063692096800903328
|
clm
|
file
|
// Repository: hyperswitch
// Crate: hyperswitch_connectors
// File: crates/hyperswitch_connectors/src/connectors/tesouro/transformers.rs
// Contains: 39 structs, 13 enums
use common_enums::enums;
use common_types::payments::{ApplePayPredecryptData, GPayPredecryptData};
use common_utils::types::FloatMajorUnit;
use error_stack::ResultExt;
use hyperswitch_domain_models::{
payment_method_data::{
ApplePayWalletData, Card, GooglePayWalletData, PaymentMethodData, WalletData,
},
router_data::{AccessToken, ConnectorAuthType, ErrorResponse, PaymentMethodToken, RouterData},
router_flow_types::refunds::{Execute, RSync},
router_request_types::{
PaymentsAuthorizeData, PaymentsCancelData, PaymentsCaptureData, PaymentsSyncData,
ResponseId,
},
router_response_types::{PaymentsResponseData, RefundsResponseData},
types::{
PaymentsAuthorizeRouterData, PaymentsCancelRouterData, PaymentsCaptureRouterData,
PaymentsSyncRouterData, RefreshTokenRouterData, RefundSyncRouterData, RefundsRouterData,
},
};
use hyperswitch_interfaces::{
consts::{NO_ERROR_CODE, NO_ERROR_MESSAGE},
errors,
};
use masking::Secret;
use serde::{Deserialize, Serialize};
use crate::{
types::{RefundsResponseRouterData, ResponseRouterData},
utils::{
self as connector_utils, CardData, PaymentsAuthorizeRequestData, PaymentsSyncRequestData,
RefundsRequestData, RouterData as _,
},
};
pub mod tesouro_queries {
pub const AUTHORIZE_TRANSACTION: &str = "mutation AuthorizeCustomerInitiatedTransaction($authorizeCustomerInitiatedTransactionInput: AuthorizeCustomerInitiatedTransactionInput!) { authorizeCustomerInitiatedTransaction(authorizeCustomerInitiatedTransactionInput: $authorizeCustomerInitiatedTransactionInput) { authorizationResponse { paymentId transactionId __typename ... on AuthorizationApproval { __typename paymentId transactionId } ... on AuthorizationDecline { __typename transactionId paymentId } } errors { ... on InternalServiceError { message transactionId processorResponseCode } ... on AcceptorNotFoundError { message transactionId processorResponseCode } ... on RuleInViolationError { message transactionId processorResponseCode } ... on SyntaxOnNetworkResponseError { message transactionId processorResponseCode } ... on TimeoutOnNetworkResponseError { message transactionId processorResponseCode } ... on ValidationFailureError { message processorResponseCode transactionId } ... on UnknownCardError { message processorResponseCode transactionId } ... on TokenNotFoundError { message processorResponseCode transactionId } ... on InvalidTokenError { message processorResponseCode transactionId } ... on RouteNotFoundError { message processorResponseCode transactionId } } } }";
pub const CAPTURE_TRANSACTION: &str = "mutation CaptureAuthorization($captureAuthorizationInput: CaptureAuthorizationInput!) { captureAuthorization(captureAuthorizationInput: $captureAuthorizationInput) { captureAuthorizationResponse { __typename ... on CaptureAuthorizationApproval { __typename paymentId transactionId } ... on CaptureAuthorizationDecline { __typename paymentId transactionId } } errors { ... on InternalServiceError { message processorResponseCode transactionId } ... on RuleInViolationError { message processorResponseCode transactionId } ... on SyntaxOnNetworkResponseError { message processorResponseCode transactionId } ... on TimeoutOnNetworkResponseError { message processorResponseCode transactionId } ... on ValidationFailureError { message processorResponseCode transactionId} ... on PriorPaymentNotFoundError { message processorResponseCode transactionId } } } }";
pub const VOID_TRANSACTION: &str = "mutation ReverseTransaction($reverseTransactionInput: ReverseTransactionInput!) { reverseTransaction(reverseTransactionInput: $reverseTransactionInput) { errors { ... on InternalServiceError { message processorResponseCode transactionId } ... on RuleInViolationError { message processorResponseCode transactionId } ... on SyntaxOnNetworkResponseError { message processorResponseCode transactionId } ... on TimeoutOnNetworkResponseError { message processorResponseCode transactionId } ... on ValidationFailureError { message processorResponseCode transactionId } ... on PriorTransactionNotFoundError { message processorResponseCode transactionId } } reverseTransactionResponse { paymentId transactionId ... on ReverseTransactionApproval { paymentId transactionId } ... on ReverseTransactionDecline { message paymentId transactionId declineType } } } }";
pub const REFUND_TRANSACTION: &str = "mutation RefundPreviousPayment($refundPreviousPaymentInput: RefundPreviousPaymentInput!) { refundPreviousPayment(refundPreviousPaymentInput: $refundPreviousPaymentInput) { errors { ... on InternalServiceError { message processorResponseCode transactionId } ... on RuleInViolationError { processorResponseCode message transactionId } ... on SyntaxOnNetworkResponseError { message processorResponseCode transactionId } ... on TimeoutOnNetworkResponseError { processorResponseCode message transactionId } ... on ValidationFailureError { message processorResponseCode transactionId } ... on PriorPaymentNotFoundError { message processorResponseCode transactionId } } refundPreviousPaymentResponse { __typename ... on RefundPreviousPaymentApproval { __typename paymentId transactionId } ... on RefundPreviousPaymentDecline { __typename declineType message transactionId paymentId } } } }";
pub const SYNC_TRANSACTION: &str = "query PaymentTransaction($paymentTransactionId: UUID!) { paymentTransaction(id: $paymentTransactionId) { __typename responseType reference id paymentId ... on AcceptedSale { __typename id processorResponseCode processorResponseMessage } ... on ApprovedAuthorization { __typename id processorResponseCode processorResponseMessage } ... on ApprovedCapture { __typename id processorResponseCode processorResponseMessage } ... on ApprovedReversal { __typename id processorResponseCode processorResponseMessage } ... on DeclinedAuthorization { __typename id processorResponseCode processorResponseMessage } ... on DeclinedCapture { __typename id processorResponseCode processorResponseMessage } ... on DeclinedReversal { __typename id processorResponseCode processorResponseMessage } ... on GenericPaymentTransaction { __typename id processorResponseCode processorResponseMessage } ... on Authorization { __typename id processorResponseCode processorResponseMessage } ... on Capture { __typename id processorResponseCode processorResponseMessage } ... on Reversal { __typename id processorResponseCode processorResponseMessage } ... on Sale { __typename id processorResponseCode processorResponseMessage } } }";
}
pub mod tesouro_constants {
pub const MAX_PAYMENT_REFERENCE_ID_LENGTH: usize = 28;
}
#[derive(Debug, Clone, Serialize)]
pub struct GenericTesouroRequest<T> {
query: String,
variables: T,
}
pub type TesouroAuthorizeRequest = GenericTesouroRequest<TesouroAuthorizeInput>;
pub type TesouroCaptureRequest = GenericTesouroRequest<TesouroCaptureInput>;
pub type TesouroVoidRequest = GenericTesouroRequest<TesouroVoidInput>;
pub type TesouroRefundRequest = GenericTesouroRequest<TesouroRefundInput>;
pub type TesouroSyncRequest = GenericTesouroRequest<TesouroSyncInput>;
pub type TesouroAuthorizeResponse = TesouroApiResponse<TesouroAuthorizeResponseData>;
pub type TesouroCaptureResponse = TesouroApiResponse<TesouroCaptureResponseData>;
pub type TesouroVoidResponse = TesouroApiResponse<TesouroVoidResponseData>;
pub type TesouroRefundResponse = TesouroApiResponse<RefundTransactionResponseData>;
pub type TesouroSyncResponse = TesouroApiResponse<TesouroSyncResponseData>;
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(untagged)]
pub enum TesouroApiResponse<T> {
TesouroApiSuccessResponse(TesouroApiResponseData<T>),
TesouroErrorResponse(TesouroApiErrorResponse),
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct TesouroApiResponseData<T> {
data: T,
}
pub struct TesouroRouterData<T> {
pub amount: FloatMajorUnit,
pub router_data: T,
}
impl<T> From<(FloatMajorUnit, T)> for TesouroRouterData<T> {
fn from((amount, item): (FloatMajorUnit, T)) -> Self {
Self {
amount,
router_data: item,
}
}
}
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct TransactionResponseData<T> {
#[serde(rename = "__typename")]
pub type_name: Option<T>,
pub payment_id: Option<String>,
pub transaction_id: String,
pub decline_type: Option<String>,
pub message: Option<String>,
}
#[derive(Debug, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct TesouroAuthorizeResponseData {
authorize_customer_initiated_transaction: AuthorizeCustomerInitiatedTransactionResponseData,
}
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "PascalCase")]
pub enum AuthorizeTransactionResponseType {
AuthorizationApproval,
AuthorizationDecline,
}
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct AuthorizeCustomerInitiatedTransactionResponseData {
authorization_response: Option<TransactionResponseData<AuthorizeTransactionResponseType>>,
errors: Option<Vec<TesouroTransactionErrorResponseData>>,
}
#[derive(Debug, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct TesouroCaptureResponseData {
capture_authorization: CaptureCustomerInitiatedTransactionResponseData,
}
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct CaptureCustomerInitiatedTransactionResponseData {
capture_authorization_response: Option<TransactionResponseData<CaptureTransactionResponseType>>,
errors: Option<Vec<TesouroTransactionErrorResponseData>>,
}
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "PascalCase")]
pub enum CaptureTransactionResponseType {
CaptureAuthorizationApproval,
CaptureAuthorizationDecline,
}
#[derive(Debug, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct TesouroVoidResponseData {
reverse_transaction: ReverseTransactionResponseData,
}
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ReverseTransactionResponseData {
reverse_transaction_response: Option<TransactionResponseData<ReverseTransactionResponseType>>,
errors: Option<Vec<TesouroTransactionErrorResponseData>>,
}
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "PascalCase")]
pub enum ReverseTransactionResponseType {
ReverseTransactionApproval,
ReverseTransactionDecline,
}
#[derive(Debug, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct RefundTransactionResponseData {
refund_previous_payment: TesouroRefundPreviousPaymentResponseData,
}
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct TesouroRefundPreviousPaymentResponseData {
refund_previous_payment_response:
Option<TransactionResponseData<RefundTransactionResponseType>>,
errors: Option<Vec<TesouroTransactionErrorResponseData>>,
}
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "PascalCase")]
pub enum RefundTransactionResponseType {
RefundPreviousPaymentApproval,
RefundPreviousPaymentDecline,
}
pub struct TesouroAuthType {
pub(super) client_id: Secret<String>,
pub(super) client_secret: Secret<String>,
pub(super) acceptor_id: Secret<String>,
}
impl TesouroAuthType {
fn get_acceptor_id(&self) -> Secret<String> {
self.acceptor_id.clone()
}
}
impl TryFrom<&ConnectorAuthType> for TesouroAuthType {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(auth_type: &ConnectorAuthType) -> Result<Self, Self::Error> {
match auth_type {
ConnectorAuthType::SignatureKey {
api_key,
api_secret,
key1,
} => Ok(Self {
client_id: api_key.to_owned(),
client_secret: api_secret.to_owned(),
acceptor_id: key1.to_owned(),
}),
_ => Err(errors::ConnectorError::FailedToObtainAuthType.into()),
}
}
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct TesouroApiErrorResponse {
errors: Vec<TesouroApiErrorData>,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct TesouroApiErrorData {
message: String,
}
#[derive(Debug, Serialize, PartialEq)]
#[serde(rename_all = "snake_case")]
pub struct TesouroAccessTokenRequest {
grant_type: TesouroGrantType,
client_id: Secret<String>,
client_secret: Secret<String>,
}
#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum TesouroGrantType {
ClientCredentials,
}
impl TryFrom<&RefreshTokenRouterData> for TesouroAccessTokenRequest {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(item: &RefreshTokenRouterData) -> Result<Self, Self::Error> {
let auth = TesouroAuthType::try_from(&item.connector_auth_type)?;
Ok(Self {
grant_type: TesouroGrantType::ClientCredentials,
client_id: auth.client_id,
client_secret: auth.client_secret,
})
}
}
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub struct TesouroAccessTokenResponse {
access_token: Secret<String>,
token_type: String,
expires_in: i64,
}
impl<F, T> TryFrom<ResponseRouterData<F, TesouroAccessTokenResponse, T, AccessToken>>
for RouterData<F, T, AccessToken>
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: ResponseRouterData<F, TesouroAccessTokenResponse, T, AccessToken>,
) -> Result<Self, Self::Error> {
Ok(Self {
response: Ok(AccessToken {
token: item.response.access_token,
expires: item.response.expires_in,
}),
..item.data
})
}
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct TesouroAuthorizeInput {
pub authorize_customer_initiated_transaction_input: AuthorizeCustomerInitiatedTransactionInput,
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct TesouroCaptureInput {
pub capture_authorization_input: CaptureAuthorizationInput,
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct TesouroVoidInput {
pub reverse_transaction_input: ReverseTransactionInput,
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct TesouroRefundInput {
pub refund_previous_payment_input: RefundPreviousPaymentInput,
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct TesouroSyncInput {
pub payment_transaction_id: String,
}
#[derive(Debug, Clone, Copy, Serialize)]
#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
pub enum TesouroAuthorizationIntent {
FinalAuthorization,
PreAuthorization,
}
#[derive(Debug, Clone, Copy, Serialize)]
#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
pub enum TesouroChannel {
Ecommerce,
MailOrderTelephoneOrder,
Retail,
}
#[derive(Debug, Clone, Copy, Serialize)]
#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
pub enum TesouroAutomaticCapture {
Never,
OnApproval,
}
#[derive(Debug, Clone, Copy, Serialize)]
#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
pub enum TesouroWalletType {
ApplePay,
GooglePay,
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub enum TesouroPaymentMethodDetails {
CardWithPanDetails(TesouroCardWithPanDetails),
NetworkTokenPassThroughDetails(TesouroNetworkTokenPassThroughDetails),
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct TesouroCardWithPanDetails {
pub expiration_month: Secret<String>,
pub expiration_year: Secret<String>,
pub account_number: cards::CardNumber,
pub payment_entry_mode: TesouroPaymentEntryMode,
pub security_code: TesouroSecurityCode,
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct TesouroNetworkTokenPassThroughDetails {
pub cryptogram: Secret<String>,
pub expiration_month: Secret<String>,
pub expiration_year: Secret<String>,
pub token_value: cards::CardNumber,
pub wallet_type: TesouroWalletType,
pub ecommerce_indicator: Option<String>,
}
#[derive(Debug, Clone, Copy, Serialize)]
#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
pub enum TesouroPaymentEntryMode {
PaymentMethodNotOnFile,
}
#[derive(Debug, Serialize, Deserialize)]
pub struct TesouroSecurityCode {
pub value: Secret<String>,
}
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct TransactionAmountDetails {
pub total_amount: FloatMajorUnit,
pub currency: enums::Currency,
}
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct BillToAddress {
pub address1: Option<Secret<String>>,
pub address2: Option<Secret<String>>,
pub address3: Option<Secret<String>>,
pub city: Option<String>,
pub country_code: Option<common_enums::CountryAlpha3>,
pub first_name: Option<Secret<String>>,
pub last_name: Option<Secret<String>>,
pub postal_code: Option<Secret<String>>,
pub state: Option<Secret<String>>,
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct AuthorizeCustomerInitiatedTransactionInput {
pub acceptor_id: Secret<String>,
pub transaction_reference: String,
pub payment_method_details: TesouroPaymentMethodDetails,
pub transaction_amount_details: TransactionAmountDetails,
pub automatic_capture: TesouroAutomaticCapture,
pub authorization_intent: TesouroAuthorizationIntent,
pub bill_to_address: BillToAddress,
}
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct CaptureAuthorizationInput {
pub acceptor_id: Secret<String>,
pub payment_id: String,
pub transaction_reference: String,
pub transaction_amount_details: TransactionAmountDetails,
}
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ReverseTransactionInput {
pub acceptor_id: Secret<String>,
pub transaction_id: String,
pub transaction_reference: String,
}
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct RefundPreviousPaymentInput {
pub acceptor_id: Secret<String>,
pub payment_id: String,
pub transaction_reference: String,
pub transaction_amount_details: TransactionAmountDetails,
}
impl TryFrom<&Card> for TesouroPaymentMethodDetails {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(value: &Card) -> Result<Self, Self::Error> {
let card_data = TesouroCardWithPanDetails {
expiration_month: value.get_card_expiry_month_2_digit()?,
expiration_year: value.get_expiry_year_4_digit(),
account_number: value.card_number.clone(),
payment_entry_mode: TesouroPaymentEntryMode::PaymentMethodNotOnFile,
security_code: TesouroSecurityCode {
value: value.card_cvc.clone(),
},
};
Ok(Self::CardWithPanDetails(card_data))
}
}
fn get_apple_pay_data(
apple_pay_wallet_data: &ApplePayWalletData,
payment_method_token: Option<&PaymentMethodToken>,
) -> Result<ApplePayPredecryptData, error_stack::Report<errors::ConnectorError>> {
if let Some(PaymentMethodToken::ApplePayDecrypt(decrypted_data)) = payment_method_token {
return Ok(*decrypted_data.clone());
}
match &apple_pay_wallet_data.payment_data {
common_types::payments::ApplePayPaymentData::Decrypted(decrypted_data) => {
Ok(decrypted_data.clone())
}
common_types::payments::ApplePayPaymentData::Encrypted(_) => {
Err(errors::ConnectorError::MissingRequiredField {
field_name: "decrypted apple pay data",
})?
}
}
}
fn get_goole_pay_data(
google_pay_wallet_data: &GooglePayWalletData,
payment_method_token: Option<&PaymentMethodToken>,
) -> Result<GPayPredecryptData, error_stack::Report<errors::ConnectorError>> {
if let Some(PaymentMethodToken::GooglePayDecrypt(decrypted_data)) = payment_method_token {
return Ok(*decrypted_data.clone());
}
match &google_pay_wallet_data.tokenization_data {
common_types::payments::GpayTokenizationData::Decrypted(decrypted_data) => {
Ok(decrypted_data.clone())
}
common_types::payments::GpayTokenizationData::Encrypted(_) => {
Err(errors::ConnectorError::MissingRequiredField {
field_name: "decrypted google pay data",
})?
}
}
}
impl TryFrom<(&ApplePayWalletData, Option<&PaymentMethodToken>)> for TesouroPaymentMethodDetails {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
(wallet_data, payment_method_token): (&ApplePayWalletData, Option<&PaymentMethodToken>),
) -> Result<Self, Self::Error> {
let apple_pay_data = get_apple_pay_data(wallet_data, payment_method_token)?;
let network_token_details = TesouroNetworkTokenPassThroughDetails {
expiration_year: apple_pay_data.get_four_digit_expiry_year(),
cryptogram: apple_pay_data.payment_data.online_payment_cryptogram,
token_value: apple_pay_data.application_primary_account_number,
expiration_month: apple_pay_data.application_expiration_month,
ecommerce_indicator: apple_pay_data.payment_data.eci_indicator,
wallet_type: TesouroWalletType::ApplePay,
};
Ok(Self::NetworkTokenPassThroughDetails(network_token_details))
}
}
impl TryFrom<(&GooglePayWalletData, Option<&PaymentMethodToken>)> for TesouroPaymentMethodDetails {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
(wallet_data, payment_method_token): (&GooglePayWalletData, Option<&PaymentMethodToken>),
) -> Result<Self, Self::Error> {
let google_pay_data = get_goole_pay_data(wallet_data, payment_method_token)?;
let network_token_details = TesouroNetworkTokenPassThroughDetails {
expiration_year: google_pay_data
.get_four_digit_expiry_year()
.change_context(errors::ConnectorError::InvalidWalletToken {
wallet_name: "Google Pay".to_string(),
})?,
cryptogram: google_pay_data.cryptogram.ok_or(
errors::ConnectorError::MissingRequiredField {
field_name: "google pay data cryptogram",
},
)?,
token_value: google_pay_data.application_primary_account_number,
expiration_month: google_pay_data.card_exp_month,
ecommerce_indicator: google_pay_data.eci_indicator,
wallet_type: TesouroWalletType::GooglePay,
};
Ok(Self::NetworkTokenPassThroughDetails(network_token_details))
}
}
pub struct TesouroCaptureData {
automatic_capture: TesouroAutomaticCapture,
authorization_intent: TesouroAuthorizationIntent,
}
impl From<bool> for TesouroCaptureData {
fn from(is_auto_capture: bool) -> Self {
if is_auto_capture {
Self {
automatic_capture: TesouroAutomaticCapture::OnApproval,
authorization_intent: TesouroAuthorizationIntent::FinalAuthorization,
}
} else {
Self {
automatic_capture: TesouroAutomaticCapture::Never,
authorization_intent: TesouroAuthorizationIntent::PreAuthorization,
}
}
}
}
impl From<&PaymentsAuthorizeRouterData> for BillToAddress {
fn from(router_data: &PaymentsAuthorizeRouterData) -> Self {
Self {
address1: router_data.get_optional_billing_line1(),
address2: router_data.get_optional_billing_line2(),
address3: router_data.get_optional_billing_line3(),
city: router_data.get_optional_billing_city(),
country_code: router_data
.get_optional_billing_country()
.map(|billing_country| {
common_enums::CountryAlpha2::from_alpha2_to_alpha3(billing_country)
}),
first_name: router_data.get_optional_billing_first_name(),
last_name: router_data.get_optional_billing_last_name(),
postal_code: router_data.get_optional_billing_zip(),
state: router_data.get_optional_billing_state(),
}
}
}
impl TryFrom<&TesouroRouterData<&PaymentsAuthorizeRouterData>> for TesouroAuthorizeRequest {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: &TesouroRouterData<&PaymentsAuthorizeRouterData>,
) -> Result<Self, Self::Error> {
if item.router_data.is_three_ds() {
Err(errors::ConnectorError::NotSupported {
message: "Cards 3DS".to_string(),
connector: "Tesouro",
})?
}
let auth = TesouroAuthType::try_from(&item.router_data.connector_auth_type)?;
let acceptor_id = auth.get_acceptor_id();
let transaction_reference =
get_valid_transaction_id(item.router_data.connector_request_reference_id.clone())?;
let capture_data = TesouroCaptureData::from(item.router_data.request.is_auto_capture()?);
let payment_method_details = match &item.router_data.request.payment_method_data {
PaymentMethodData::Card(card) => TesouroPaymentMethodDetails::try_from(card),
PaymentMethodData::Wallet(wallet_data) => match wallet_data {
WalletData::ApplePay(apple_pay_wallet_data) => {
let payment_method_token = item.router_data.payment_method_token.as_ref();
TesouroPaymentMethodDetails::try_from((
apple_pay_wallet_data,
payment_method_token,
))
}
WalletData::GooglePay(google_pay_wallet_data) => {
let payment_method_token = item.router_data.payment_method_token.as_ref();
TesouroPaymentMethodDetails::try_from((
google_pay_wallet_data,
payment_method_token,
))
}
WalletData::AliPayQr(_)
| WalletData::AliPayRedirect(_)
| WalletData::AliPayHkRedirect(_)
| WalletData::AmazonPay(_)
| WalletData::AmazonPayRedirect(_)
| WalletData::Paysera(_)
| WalletData::Skrill(_)
| WalletData::BluecodeRedirect {}
| WalletData::MomoRedirect(_)
| WalletData::KakaoPayRedirect(_)
| WalletData::GoPayRedirect(_)
| WalletData::GcashRedirect(_)
| WalletData::ApplePayRedirect(_)
| WalletData::ApplePayThirdPartySdk(_)
| WalletData::DanaRedirect {}
| WalletData::GooglePayRedirect(_)
| WalletData::GooglePayThirdPartySdk(_)
| WalletData::MbWayRedirect(_)
| WalletData::MobilePayRedirect(_)
| WalletData::PaypalSdk(_)
| WalletData::PaypalRedirect(_)
| WalletData::Paze(_)
| WalletData::SamsungPay(_)
| WalletData::TwintRedirect {}
| WalletData::VippsRedirect {}
| WalletData::TouchNGoRedirect(_)
| WalletData::WeChatPayRedirect(_)
| WalletData::CashappQr(_)
| WalletData::SwishQr(_)
| WalletData::WeChatPayQr(_)
| WalletData::RevolutPay(_)
| WalletData::Mifinity(_) => Err(errors::ConnectorError::NotImplemented(
connector_utils::get_unimplemented_payment_method_error_message("Tesouro"),
))?,
},
PaymentMethodData::CardDetailsForNetworkTransactionId(_)
| PaymentMethodData::CardRedirect(_)
| PaymentMethodData::PayLater(_)
| PaymentMethodData::BankRedirect(_)
| PaymentMethodData::BankDebit(_)
| PaymentMethodData::BankTransfer(_)
| PaymentMethodData::Crypto(_)
| PaymentMethodData::MandatePayment
| PaymentMethodData::Reward
| PaymentMethodData::RealTimePayment(_)
| PaymentMethodData::Upi(_)
| PaymentMethodData::Voucher(_)
| PaymentMethodData::GiftCard(_)
| PaymentMethodData::CardToken(_)
| PaymentMethodData::OpenBanking(_)
| PaymentMethodData::NetworkToken(_)
| PaymentMethodData::MobilePayment(_) => Err(errors::ConnectorError::NotImplemented(
connector_utils::get_unimplemented_payment_method_error_message("tesouro"),
)
.into()),
}?;
let bill_to_address = BillToAddress::from(item.router_data);
Ok(Self {
query: tesouro_queries::AUTHORIZE_TRANSACTION.to_string(),
variables: TesouroAuthorizeInput {
authorize_customer_initiated_transaction_input:
AuthorizeCustomerInitiatedTransactionInput {
acceptor_id,
transaction_reference,
payment_method_details,
transaction_amount_details: TransactionAmountDetails {
total_amount: item.amount,
currency: item.router_data.request.currency,
},
automatic_capture: capture_data.automatic_capture,
authorization_intent: capture_data.authorization_intent,
bill_to_address,
},
},
})
}
}
impl TryFrom<&TesouroRouterData<&PaymentsCaptureRouterData>> for TesouroCaptureRequest {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(item: &TesouroRouterData<&PaymentsCaptureRouterData>) -> Result<Self, Self::Error> {
let auth = TesouroAuthType::try_from(&item.router_data.connector_auth_type)?;
let payment_metadata = item
.router_data
.request
.connector_meta
.clone()
.map(|payment_metadata| {
connector_utils::to_connector_meta::<TesouroTransactionMetadata>(Some(
payment_metadata,
))
})
.transpose()?;
let payment_id = payment_metadata
.ok_or(errors::ConnectorError::NoConnectorMetaData)?
.payment_id;
let transaction_id =
get_valid_transaction_id(item.router_data.connector_request_reference_id.clone())?;
Ok(Self {
query: tesouro_queries::CAPTURE_TRANSACTION.to_string(),
variables: TesouroCaptureInput {
capture_authorization_input: CaptureAuthorizationInput {
acceptor_id: auth.get_acceptor_id(),
payment_id,
transaction_reference: format!("capture_{transaction_id}"),
transaction_amount_details: TransactionAmountDetails {
total_amount: item.amount,
currency: item.router_data.request.currency,
},
},
},
})
}
}
impl TryFrom<&PaymentsCancelRouterData> for TesouroVoidRequest {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(item: &PaymentsCancelRouterData) -> Result<Self, Self::Error> {
let auth = TesouroAuthType::try_from(&item.connector_auth_type)?;
let transaction_id = get_valid_transaction_id(item.connector_request_reference_id.clone())?;
Ok(Self {
query: tesouro_queries::VOID_TRANSACTION.to_string(),
variables: TesouroVoidInput {
reverse_transaction_input: ReverseTransactionInput {
acceptor_id: auth.get_acceptor_id(),
transaction_id: item.request.connector_transaction_id.clone(),
transaction_reference: format!("rev_{transaction_id}"),
},
},
})
}
}
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct TesouroApprovalResponse {
pub payment_id: String,
pub transaction_id: String,
}
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct TesouroDeclineResponse {
pub payment_id: Option<String>,
pub transaction_id: Option<String>,
pub decline_type: String,
pub message: Option<String>,
}
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct TesouroTransactionErrorResponseData {
pub message: String,
pub processor_response_code: Option<String>,
pub transaction_id: Option<String>,
}
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct TesouroTransactionMetadata {
pub payment_id: String,
}
impl<F>
TryFrom<
ResponseRouterData<
F,
TesouroAuthorizeResponse,
PaymentsAuthorizeData,
PaymentsResponseData,
>,
> for RouterData<F, PaymentsAuthorizeData, PaymentsResponseData>
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: ResponseRouterData<
F,
TesouroAuthorizeResponse,
PaymentsAuthorizeData,
PaymentsResponseData,
>,
) -> Result<Self, Self::Error> {
match item.response {
TesouroApiResponse::TesouroApiSuccessResponse(response) => {
if let Some(authorization_response) = response
.data
.authorize_customer_initiated_transaction
.authorization_response
{
let transaction_id = authorization_response.transaction_id;
let connector_metadata = serde_json::json!(TesouroTransactionMetadata {
payment_id: authorization_response
.payment_id
.clone()
.ok_or(errors::ConnectorError::MissingConnectorTransactionID)?,
});
match authorization_response.type_name {
Some(AuthorizeTransactionResponseType::AuthorizationApproval) => Ok(Self {
status: if item.data.request.is_auto_capture()? {
enums::AttemptStatus::Charged
} else {
enums::AttemptStatus::Authorized
},
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(transaction_id),
redirection_data: Box::new(None),
mandate_reference: Box::new(None),
connector_metadata: Some(connector_metadata),
network_txn_id: None,
connector_response_reference_id: None,
incremental_authorization_allowed: None,
charges: None,
}),
..item.data
}),
Some(AuthorizeTransactionResponseType::AuthorizationDecline) => Ok(Self {
status: if item.data.request.is_auto_capture()? {
enums::AttemptStatus::Failure
} else {
enums::AttemptStatus::AuthorizationFailed
},
response: Err(ErrorResponse {
code: authorization_response
.decline_type
.clone()
.unwrap_or(NO_ERROR_CODE.to_string()),
message: authorization_response
.message
.clone()
.unwrap_or(NO_ERROR_MESSAGE.to_string()),
reason: authorization_response.message.clone(),
status_code: item.http_code,
attempt_status: None,
connector_transaction_id: Some(transaction_id.clone()),
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
connector_metadata: None,
}),
..item.data
}),
None => Ok(Self {
status: enums::AttemptStatus::Pending,
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(transaction_id),
redirection_data: Box::new(None),
mandate_reference: Box::new(None),
connector_metadata: Some(connector_metadata),
network_txn_id: None,
connector_response_reference_id: None,
incremental_authorization_allowed: None,
charges: None,
}),
..item.data
}),
}
} else if let Some(errors) = response
.data
.authorize_customer_initiated_transaction
.errors
{
let error_response = errors.first();
let error_code = error_response
.as_ref()
.and_then(|error_data| error_data.processor_response_code.clone())
.unwrap_or(NO_ERROR_CODE.to_string());
let error_message = error_response
.as_ref()
.map(|error_data| error_data.message.clone());
let connector_transaction_id = error_response
.as_ref()
.and_then(|error_data| error_data.transaction_id.clone());
Ok(Self {
status: if item.data.request.is_auto_capture()? {
enums::AttemptStatus::Failure
} else {
enums::AttemptStatus::AuthorizationFailed
},
response: Err(ErrorResponse {
code: error_code.clone(),
message: error_message
.clone()
.unwrap_or(NO_ERROR_MESSAGE.to_string()),
reason: error_message.clone(),
status_code: item.http_code,
attempt_status: None,
connector_transaction_id,
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
connector_metadata: None,
}),
..item.data
})
} else {
Err(errors::ConnectorError::UnexpectedResponseError(
bytes::Bytes::from(
"Expected either error or authorization_response".to_string(),
),
))?
}
}
TesouroAuthorizeResponse::TesouroErrorResponse(error_response) => {
let message = error_response
.errors
.iter()
.map(|error| error.message.to_string())
.collect::<Vec<String>>();
let error_message = match !message.is_empty() {
true => Some(message.join(" ")),
false => None,
};
Ok(Self {
status: if item.data.request.is_auto_capture()? {
enums::AttemptStatus::Failure
} else {
enums::AttemptStatus::AuthorizationFailed
},
response: Err(ErrorResponse {
code: NO_ERROR_CODE.to_string(),
message: error_message
.clone()
.unwrap_or(NO_ERROR_MESSAGE.to_string()),
reason: error_message.clone(),
status_code: item.http_code,
attempt_status: None,
connector_transaction_id: None,
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
connector_metadata: None,
}),
..item.data
})
}
}
}
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct TesouroAccessTokenErrorResponse {
pub error: String,
pub error_description: Option<String>,
pub error_uri: Option<String>,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct TesouroGraphQlErrorResponse {
pub errors: Vec<TesouroGraphQlError>,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct TesouroGraphQlError {
pub message: String,
pub extensions: Option<TesouroGraphQlErrorExtensions>,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct TesouroGraphQlErrorExtensions {
pub code: Option<String>,
pub reason: Option<String>,
}
impl<F>
TryFrom<
ResponseRouterData<F, TesouroCaptureResponse, PaymentsCaptureData, PaymentsResponseData>,
> for RouterData<F, PaymentsCaptureData, PaymentsResponseData>
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: ResponseRouterData<
F,
TesouroCaptureResponse,
PaymentsCaptureData,
PaymentsResponseData,
>,
) -> Result<Self, Self::Error> {
match item.response {
TesouroApiResponse::TesouroApiSuccessResponse(response) => {
if let Some(capture_authorization_response) = response
.data
.capture_authorization
.capture_authorization_response
{
let transaction_id = capture_authorization_response.transaction_id;
match capture_authorization_response.type_name {
Some(CaptureTransactionResponseType::CaptureAuthorizationApproval) => {
Ok(Self {
status: enums::AttemptStatus::Charged,
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(transaction_id),
redirection_data: Box::new(None),
mandate_reference: Box::new(None),
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: None,
incremental_authorization_allowed: None,
charges: None,
}),
..item.data
})
}
Some(CaptureTransactionResponseType::CaptureAuthorizationDecline) => {
Ok(Self {
status: enums::AttemptStatus::CaptureFailed,
response: Err(ErrorResponse {
code: capture_authorization_response
.decline_type
.clone()
.unwrap_or(NO_ERROR_CODE.to_string()),
message: capture_authorization_response
.message
.clone()
.unwrap_or(NO_ERROR_MESSAGE.to_string()),
reason: capture_authorization_response.message.clone(),
status_code: item.http_code,
attempt_status: None,
connector_transaction_id: Some(transaction_id.clone()),
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
connector_metadata: None,
}),
..item.data
})
}
None => Ok(Self {
status: enums::AttemptStatus::CaptureInitiated,
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(transaction_id),
redirection_data: Box::new(None),
mandate_reference: Box::new(None),
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: None,
incremental_authorization_allowed: None,
charges: None,
}),
..item.data
}),
}
} else if let Some(errors) = response.data.capture_authorization.errors {
let error_response = errors.first();
let error_code = error_response
.as_ref()
.and_then(|error_data| error_data.processor_response_code.clone())
.unwrap_or(NO_ERROR_CODE.to_string());
let error_message = error_response
.as_ref()
.map(|error_data| error_data.message.clone());
Ok(Self {
status: enums::AttemptStatus::CaptureFailed,
response: Err(ErrorResponse {
code: error_code.clone(),
message: error_message
.clone()
.unwrap_or(NO_ERROR_MESSAGE.to_string()),
reason: error_message.clone(),
status_code: item.http_code,
attempt_status: None,
connector_transaction_id: None,
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
connector_metadata: None,
}),
..item.data
})
} else {
Err(errors::ConnectorError::UnexpectedResponseError(
bytes::Bytes::from(
"Expected either error or capture_authorization_response".to_string(),
),
))?
}
}
TesouroApiResponse::TesouroErrorResponse(error_response) => {
let message = error_response
.errors
.iter()
.map(|error| error.message.to_string())
.collect::<Vec<String>>();
let error_message = match !message.is_empty() {
true => Some(message.join(" ")),
false => None,
};
Ok(Self {
status: enums::AttemptStatus::CaptureFailed,
response: Err(ErrorResponse {
code: NO_ERROR_CODE.to_string(),
message: error_message
.clone()
.unwrap_or(NO_ERROR_MESSAGE.to_string()),
reason: error_message.clone(),
status_code: item.http_code,
attempt_status: None,
connector_transaction_id: None,
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
connector_metadata: None,
}),
..item.data
})
}
}
}
}
impl<F>
TryFrom<ResponseRouterData<F, TesouroVoidResponse, PaymentsCancelData, PaymentsResponseData>>
for RouterData<F, PaymentsCancelData, PaymentsResponseData>
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: ResponseRouterData<F, TesouroVoidResponse, PaymentsCancelData, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
match item.response {
TesouroApiResponse::TesouroApiSuccessResponse(response) => {
if let Some(reverse_transaction) = response
.data
.reverse_transaction
.reverse_transaction_response
{
let transaction_id = reverse_transaction.transaction_id;
match reverse_transaction.type_name {
Some(ReverseTransactionResponseType::ReverseTransactionApproval) => {
Ok(Self {
status: enums::AttemptStatus::Voided,
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(transaction_id),
redirection_data: Box::new(None),
mandate_reference: Box::new(None),
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: None,
incremental_authorization_allowed: None,
charges: None,
}),
..item.data
})
}
Some(ReverseTransactionResponseType::ReverseTransactionDecline) => {
Ok(Self {
status: enums::AttemptStatus::VoidFailed,
response: Err(ErrorResponse {
code: reverse_transaction
.decline_type
.clone()
.unwrap_or(NO_ERROR_CODE.to_string()),
message: reverse_transaction
.message
.clone()
.unwrap_or(NO_ERROR_MESSAGE.to_string()),
reason: reverse_transaction.message.clone(),
status_code: item.http_code,
attempt_status: None,
connector_transaction_id: Some(transaction_id.clone()),
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
connector_metadata: None,
}),
..item.data
})
}
None => Ok(Self {
status: enums::AttemptStatus::VoidInitiated,
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(transaction_id),
redirection_data: Box::new(None),
mandate_reference: Box::new(None),
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: None,
incremental_authorization_allowed: None,
charges: None,
}),
..item.data
}),
}
} else if let Some(errors) = response.data.reverse_transaction.errors {
let error_response = errors.first();
let error_code = error_response
.as_ref()
.and_then(|error_data| error_data.processor_response_code.clone())
.unwrap_or(NO_ERROR_CODE.to_string());
let error_message = error_response
.as_ref()
.map(|error_data| error_data.message.clone());
Ok(Self {
status: enums::AttemptStatus::VoidFailed,
response: Err(ErrorResponse {
code: error_code.clone(),
message: error_message
.clone()
.unwrap_or(NO_ERROR_MESSAGE.to_string()),
reason: error_message.clone(),
status_code: item.http_code,
attempt_status: None,
connector_transaction_id: None,
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
connector_metadata: None,
}),
..item.data
})
} else {
Err(errors::ConnectorError::UnexpectedResponseError(
bytes::Bytes::from(
"Expected either error or reverse_transaction_response".to_string(),
),
))?
}
}
TesouroApiResponse::TesouroErrorResponse(error_response) => {
let message = error_response
.errors
.iter()
.map(|error| error.message.to_string())
.collect::<Vec<String>>();
let error_message = match !message.is_empty() {
true => Some(message.join(" ")),
false => None,
};
Ok(Self {
status: enums::AttemptStatus::VoidFailed,
response: Err(ErrorResponse {
code: NO_ERROR_CODE.to_string(),
message: error_message
.clone()
.unwrap_or(NO_ERROR_MESSAGE.to_string()),
reason: error_message.clone(),
status_code: item.http_code,
attempt_status: None,
connector_transaction_id: None,
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
connector_metadata: None,
}),
..item.data
})
}
}
}
}
impl<F> TryFrom<&TesouroRouterData<&RefundsRouterData<F>>> for TesouroRefundRequest {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(item: &TesouroRouterData<&RefundsRouterData<F>>) -> Result<Self, Self::Error> {
let auth = TesouroAuthType::try_from(&item.router_data.connector_auth_type)?;
let payment_metadata = item
.router_data
.request
.connector_metadata
.clone()
.map(|payment_metadata| {
connector_utils::to_connector_meta::<TesouroTransactionMetadata>(Some(
payment_metadata,
))
})
.transpose()?;
let payment_id = payment_metadata
.ok_or(errors::ConnectorError::MissingConnectorTransactionID)?
.payment_id;
let transaction_reference =
get_valid_transaction_id(item.router_data.connector_request_reference_id.clone())?;
Ok(Self {
query: tesouro_queries::REFUND_TRANSACTION.to_string(),
variables: TesouroRefundInput {
refund_previous_payment_input: RefundPreviousPaymentInput {
acceptor_id: auth.get_acceptor_id(),
payment_id,
transaction_reference,
transaction_amount_details: TransactionAmountDetails {
total_amount: item.amount,
currency: item.router_data.request.currency,
},
},
},
})
}
}
impl TryFrom<RefundsResponseRouterData<Execute, TesouroRefundResponse>>
for RefundsRouterData<Execute>
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: RefundsResponseRouterData<Execute, TesouroRefundResponse>,
) -> Result<Self, Self::Error> {
match item.response {
TesouroApiResponse::TesouroApiSuccessResponse(response) => {
if let Some(refund_previous_payment_response) = response
.data
.refund_previous_payment
.refund_previous_payment_response
{
let transaction_id = refund_previous_payment_response.transaction_id;
match refund_previous_payment_response.type_name {
Some(RefundTransactionResponseType::RefundPreviousPaymentApproval) => {
Ok(Self {
response: Ok(RefundsResponseData {
connector_refund_id: transaction_id,
refund_status: enums::RefundStatus::Success,
}),
..item.data
})
}
Some(RefundTransactionResponseType::RefundPreviousPaymentDecline) => {
Ok(Self {
response: Err(ErrorResponse {
code: refund_previous_payment_response
.decline_type
.clone()
.unwrap_or(NO_ERROR_CODE.to_string()),
message: refund_previous_payment_response
.message
.clone()
.unwrap_or(NO_ERROR_MESSAGE.to_string()),
reason: refund_previous_payment_response.message.clone(),
status_code: item.http_code,
attempt_status: None,
connector_transaction_id: None,
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
connector_metadata: None,
}),
..item.data
})
}
None => Ok(Self {
response: Ok(RefundsResponseData {
connector_refund_id: transaction_id,
refund_status: enums::RefundStatus::Pending,
}),
..item.data
}),
}
} else if let Some(errors) = response.data.refund_previous_payment.errors {
let error_response = errors.first();
let error_code = error_response
.as_ref()
.and_then(|error_data| error_data.processor_response_code.clone())
.unwrap_or(NO_ERROR_CODE.to_string());
let error_message = error_response
.as_ref()
.map(|error_data| error_data.message.clone());
Ok(Self {
response: Err(ErrorResponse {
code: error_code.clone(),
message: error_message
.clone()
.unwrap_or(NO_ERROR_MESSAGE.to_string()),
reason: error_message.clone(),
status_code: item.http_code,
attempt_status: None,
connector_transaction_id: None,
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
connector_metadata: None,
}),
..item.data
})
} else {
Err(errors::ConnectorError::UnexpectedResponseError(
bytes::Bytes::from(
"Expected either error or refund_previous_payment_response".to_string(),
),
))?
}
}
TesouroApiResponse::TesouroErrorResponse(error_response) => {
let message = error_response
.errors
.iter()
.map(|error| error.message.to_string())
.collect::<Vec<String>>();
let error_message = match !message.is_empty() {
true => Some(message.join(" ")),
false => None,
};
Ok(Self {
response: Err(ErrorResponse {
code: NO_ERROR_CODE.to_string(),
message: error_message
.clone()
.unwrap_or(NO_ERROR_MESSAGE.to_string()),
reason: error_message.clone(),
status_code: item.http_code,
attempt_status: None,
connector_transaction_id: None,
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
connector_metadata: None,
}),
..item.data
})
}
}
}
}
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct TesouroSyncResponseData {
payment_transaction: TesouroPaymentTransactionResponse,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct TesouroPaymentTransactionResponse {
pub id: String,
#[serde(rename = "__typename")]
pub typename: TesouroSyncStatus,
#[serde(rename = "processorResponseCode")]
pub processor_response_code: Option<String>,
#[serde(rename = "processorResponseMessage")]
pub processor_response_message: Option<String>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum TesouroSyncStatus {
AcceptedSale,
ApprovedAuthorization,
ApprovedCapture,
ApprovedReversal,
DeclinedAuthorization,
DeclinedCapture,
DeclinedReversal,
GenericPaymentTransaction,
Authorization,
Capture,
Reversal,
ApprovedRefund,
ApprovedRefundAuthorization,
DeclinedRefund,
DeclinedRefundAuthorization,
Refund,
RefundAuthorization,
}
fn get_payment_attempt_status(
status: TesouroSyncStatus,
is_auto_capture: bool,
previous_status: enums::AttemptStatus,
) -> Result<enums::AttemptStatus, errors::ConnectorError> {
match status {
TesouroSyncStatus::AcceptedSale | TesouroSyncStatus::ApprovedCapture => {
Ok(enums::AttemptStatus::Charged)
}
TesouroSyncStatus::ApprovedAuthorization => {
if is_auto_capture {
Ok(enums::AttemptStatus::Charged)
} else {
Ok(enums::AttemptStatus::Authorized)
}
}
TesouroSyncStatus::DeclinedAuthorization => {
if is_auto_capture {
Ok(enums::AttemptStatus::AuthorizationFailed)
} else {
Ok(enums::AttemptStatus::Failure)
}
}
TesouroSyncStatus::ApprovedReversal => Ok(enums::AttemptStatus::Voided),
TesouroSyncStatus::DeclinedCapture => Ok(enums::AttemptStatus::Failure),
TesouroSyncStatus::DeclinedReversal => Ok(enums::AttemptStatus::VoidFailed),
TesouroSyncStatus::GenericPaymentTransaction => Ok(previous_status),
TesouroSyncStatus::Authorization => Ok(enums::AttemptStatus::Authorizing),
TesouroSyncStatus::Capture => Ok(enums::AttemptStatus::CaptureInitiated),
TesouroSyncStatus::Reversal => Ok(enums::AttemptStatus::VoidInitiated),
TesouroSyncStatus::ApprovedRefund
| TesouroSyncStatus::ApprovedRefundAuthorization
| TesouroSyncStatus::DeclinedRefund
| TesouroSyncStatus::DeclinedRefundAuthorization
| TesouroSyncStatus::Refund
| TesouroSyncStatus::RefundAuthorization => {
Err(errors::ConnectorError::UnexpectedResponseError(
bytes::Bytes::from("Invalid Status Recieved".to_string()),
))
}
}
}
impl TryFrom<&PaymentsSyncRouterData> for TesouroSyncRequest {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(item: &PaymentsSyncRouterData) -> Result<Self, Self::Error> {
Ok(Self {
query: tesouro_queries::SYNC_TRANSACTION.to_string(),
variables: TesouroSyncInput {
payment_transaction_id: item
.request
.connector_transaction_id
.get_connector_transaction_id()
.change_context(errors::ConnectorError::RequestEncodingFailed)?,
},
})
}
}
impl<F> TryFrom<ResponseRouterData<F, TesouroSyncResponse, PaymentsSyncData, PaymentsResponseData>>
for RouterData<F, PaymentsSyncData, PaymentsResponseData>
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: ResponseRouterData<F, TesouroSyncResponse, PaymentsSyncData, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
match item.response {
TesouroApiResponse::TesouroApiSuccessResponse(response) => {
let status = get_payment_attempt_status(
response.data.payment_transaction.typename,
item.data.request.is_auto_capture()?,
item.data.status,
)?;
if connector_utils::is_payment_failure(status) {
let error_code = response
.data
.payment_transaction
.processor_response_code
.unwrap_or(NO_ERROR_CODE.to_string());
let error_message = response
.data
.payment_transaction
.processor_response_message
.unwrap_or(NO_ERROR_CODE.to_string());
let connector_transaction_id = response.data.payment_transaction.id.clone();
Ok(Self {
status,
response: Err(ErrorResponse {
code: error_code.clone(),
message: error_message.clone(),
reason: Some(error_message.clone()),
status_code: item.http_code,
attempt_status: None,
connector_transaction_id: Some(connector_transaction_id),
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
connector_metadata: None,
}),
..item.data
})
} else {
Ok(Self {
status,
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(
response.data.payment_transaction.id.to_string(),
),
redirection_data: Box::new(None),
mandate_reference: Box::new(None),
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: None,
incremental_authorization_allowed: None,
charges: None,
}),
..item.data
})
}
}
TesouroApiResponse::TesouroErrorResponse(error_response) => {
let message = error_response
.errors
.iter()
.map(|error| error.message.to_string())
.collect::<Vec<String>>();
let error_message = match !message.is_empty() {
true => Some(message.join(" ")),
false => None,
};
Ok(Self {
status: item.data.status,
response: Err(ErrorResponse {
code: NO_ERROR_CODE.to_string(),
message: error_message
.clone()
.unwrap_or(NO_ERROR_MESSAGE.to_string()),
reason: error_message.clone(),
status_code: item.http_code,
attempt_status: None,
connector_transaction_id: None,
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
connector_metadata: None,
}),
..item.data
})
}
}
}
}
impl TryFrom<&RefundSyncRouterData> for TesouroSyncRequest {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(item: &RefundSyncRouterData) -> Result<Self, Self::Error> {
Ok(Self {
query: tesouro_queries::SYNC_TRANSACTION.to_string(),
variables: TesouroSyncInput {
payment_transaction_id: item.request.get_connector_refund_id()?,
},
})
}
}
impl TryFrom<RefundsResponseRouterData<RSync, TesouroSyncResponse>> for RefundsRouterData<RSync> {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: RefundsResponseRouterData<RSync, TesouroSyncResponse>,
) -> Result<Self, Self::Error> {
match item.response {
TesouroApiResponse::TesouroApiSuccessResponse(response) => {
let status = match response.data.payment_transaction.typename {
TesouroSyncStatus::ApprovedRefund => enums::RefundStatus::Success,
TesouroSyncStatus::DeclinedRefund
| TesouroSyncStatus::DeclinedRefundAuthorization => {
enums::RefundStatus::Failure
}
TesouroSyncStatus::GenericPaymentTransaction
| TesouroSyncStatus::Refund
| TesouroSyncStatus::RefundAuthorization
| TesouroSyncStatus::ApprovedRefundAuthorization => {
enums::RefundStatus::Pending
}
_ => {
return Err(errors::ConnectorError::UnexpectedResponseError(
bytes::Bytes::from("Invalid Status Recieved".to_string()),
)
.into())
}
};
if connector_utils::is_refund_failure(status) {
let error_code = response
.data
.payment_transaction
.processor_response_code
.unwrap_or(NO_ERROR_CODE.to_string());
let error_message = response
.data
.payment_transaction
.processor_response_message
.unwrap_or(NO_ERROR_CODE.to_string());
Ok(Self {
response: Err(ErrorResponse {
code: error_code.clone(),
message: error_message.clone(),
reason: Some(error_message.clone()),
status_code: item.http_code,
attempt_status: None,
connector_transaction_id: None,
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
connector_metadata: None,
}),
..item.data
})
} else {
Ok(Self {
response: Ok(RefundsResponseData {
connector_refund_id: response.data.payment_transaction.id,
refund_status: enums::RefundStatus::Success,
}),
..item.data
})
}
}
TesouroApiResponse::TesouroErrorResponse(error_response) => {
let message = error_response
.errors
.iter()
.map(|error| error.message.to_string())
.collect::<Vec<String>>();
let error_message = match !message.is_empty() {
true => Some(message.join(" ")),
false => None,
};
Ok(Self {
response: Err(ErrorResponse {
code: NO_ERROR_CODE.to_string(),
message: error_message
.clone()
.unwrap_or(NO_ERROR_MESSAGE.to_string()),
reason: error_message.clone(),
status_code: item.http_code,
attempt_status: None,
connector_transaction_id: None,
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
connector_metadata: None,
}),
..item.data
})
}
}
}
}
fn get_valid_transaction_id(
id: String,
) -> Result<String, error_stack::Report<errors::ConnectorError>> {
if id.len() <= tesouro_constants::MAX_PAYMENT_REFERENCE_ID_LENGTH {
Ok(id.clone())
} else {
Err(errors::ConnectorError::MaxFieldLengthViolated {
connector: "Tesouro".to_string(),
field_name: "transaction_reference".to_string(),
max_length: tesouro_constants::MAX_PAYMENT_REFERENCE_ID_LENGTH,
received_length: id.len(),
}
.into())
}
}
|
{
"crate": "hyperswitch_connectors",
"file": "crates/hyperswitch_connectors/src/connectors/tesouro/transformers.rs",
"file_size": null,
"is_async": null,
"is_pub": null,
"num_enums": 13,
"num_structs": 39,
"num_tables": null,
"score": null,
"total_crates": null
}
|
file_hyperswitch_connectors_-4850425977948041404
|
clm
|
file
|
// Repository: hyperswitch
// Crate: hyperswitch_connectors
// File: crates/hyperswitch_connectors/src/connectors/sift/transformers.rs
// Contains: 6 structs, 2 enums
use common_enums::enums;
use common_utils::types::StringMinorUnit;
use hyperswitch_domain_models::{
payment_method_data::PaymentMethodData,
router_data::{ConnectorAuthType, RouterData},
router_flow_types::refunds::{Execute, RSync},
router_request_types::ResponseId,
router_response_types::{PaymentsResponseData, RefundsResponseData},
types::{PaymentsAuthorizeRouterData, RefundsRouterData},
};
use hyperswitch_interfaces::errors;
use masking::Secret;
use serde::{Deserialize, Serialize};
use crate::types::{RefundsResponseRouterData, ResponseRouterData};
//TODO: Fill the struct with respective fields
pub struct SiftRouterData<T> {
pub amount: StringMinorUnit, // The type of amount that a connector accepts, for example, String, i64, f64, etc.
pub router_data: T,
}
impl<T> From<(StringMinorUnit, T)> for SiftRouterData<T> {
fn from((amount, item): (StringMinorUnit, T)) -> Self {
//Todo : use utils to convert the amount to the type of amount that a connector accepts
Self {
amount,
router_data: item,
}
}
}
//TODO: Fill the struct with respective fields
#[derive(Default, Debug, Serialize, PartialEq)]
pub struct SiftPaymentsRequest {
amount: StringMinorUnit,
card: SiftCard,
}
#[derive(Default, Debug, Serialize, Eq, PartialEq)]
pub struct SiftCard {
number: cards::CardNumber,
expiry_month: Secret<String>,
expiry_year: Secret<String>,
cvc: Secret<String>,
complete: bool,
}
impl TryFrom<&SiftRouterData<&PaymentsAuthorizeRouterData>> for SiftPaymentsRequest {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(item: &SiftRouterData<&PaymentsAuthorizeRouterData>) -> Result<Self, Self::Error> {
match item.router_data.request.payment_method_data.clone() {
PaymentMethodData::Card(_) => Err(errors::ConnectorError::NotImplemented(
"Card payment method not implemented".to_string(),
)
.into()),
_ => Err(errors::ConnectorError::NotImplemented("Payment method".to_string()).into()),
}
}
}
//TODO: Fill the struct with respective fields
// Auth Struct
pub struct SiftAuthType {
pub(super) api_key: Secret<String>,
}
impl TryFrom<&ConnectorAuthType> for SiftAuthType {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(auth_type: &ConnectorAuthType) -> Result<Self, Self::Error> {
match auth_type {
ConnectorAuthType::HeaderKey { api_key } => Ok(Self {
api_key: api_key.to_owned(),
}),
_ => Err(errors::ConnectorError::FailedToObtainAuthType.into()),
}
}
}
// PaymentsResponse
//TODO: Append the remaining status flags
#[derive(Debug, Clone, Copy, Default, Serialize, Deserialize, PartialEq)]
#[serde(rename_all = "lowercase")]
pub enum SiftPaymentStatus {
Succeeded,
Failed,
#[default]
Processing,
}
impl From<SiftPaymentStatus> for common_enums::AttemptStatus {
fn from(item: SiftPaymentStatus) -> Self {
match item {
SiftPaymentStatus::Succeeded => Self::Charged,
SiftPaymentStatus::Failed => Self::Failure,
SiftPaymentStatus::Processing => Self::Authorizing,
}
}
}
//TODO: Fill the struct with respective fields
#[derive(Default, Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct SiftPaymentsResponse {
status: SiftPaymentStatus,
id: String,
}
impl<F, T> TryFrom<ResponseRouterData<F, SiftPaymentsResponse, T, PaymentsResponseData>>
for RouterData<F, T, PaymentsResponseData>
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: ResponseRouterData<F, SiftPaymentsResponse, T, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
Ok(Self {
status: common_enums::AttemptStatus::from(item.response.status),
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(item.response.id),
redirection_data: Box::new(None),
mandate_reference: Box::new(None),
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: None,
incremental_authorization_allowed: None,
charges: None,
}),
..item.data
})
}
}
//TODO: Fill the struct with respective fields
// REFUND :
// Type definition for RefundRequest
#[derive(Default, Debug, Serialize)]
pub struct SiftRefundRequest {
pub amount: StringMinorUnit,
}
impl<F> TryFrom<&SiftRouterData<&RefundsRouterData<F>>> for SiftRefundRequest {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(item: &SiftRouterData<&RefundsRouterData<F>>) -> Result<Self, Self::Error> {
Ok(Self {
amount: item.amount.to_owned(),
})
}
}
// Type definition for Refund Response
#[allow(dead_code)]
#[derive(Debug, Copy, Serialize, Default, Deserialize, Clone)]
pub enum RefundStatus {
Succeeded,
Failed,
#[default]
Processing,
}
impl From<RefundStatus> for enums::RefundStatus {
fn from(item: RefundStatus) -> Self {
match item {
RefundStatus::Succeeded => Self::Success,
RefundStatus::Failed => Self::Failure,
RefundStatus::Processing => Self::Pending,
//TODO: Review mapping
}
}
}
//TODO: Fill the struct with respective fields
#[derive(Default, Debug, Clone, Serialize, Deserialize)]
pub struct RefundResponse {
id: String,
status: RefundStatus,
}
impl TryFrom<RefundsResponseRouterData<Execute, RefundResponse>> for RefundsRouterData<Execute> {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: RefundsResponseRouterData<Execute, RefundResponse>,
) -> Result<Self, Self::Error> {
Ok(Self {
response: Ok(RefundsResponseData {
connector_refund_id: item.response.id.to_string(),
refund_status: enums::RefundStatus::from(item.response.status),
}),
..item.data
})
}
}
impl TryFrom<RefundsResponseRouterData<RSync, RefundResponse>> for RefundsRouterData<RSync> {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: RefundsResponseRouterData<RSync, RefundResponse>,
) -> Result<Self, Self::Error> {
Ok(Self {
response: Ok(RefundsResponseData {
connector_refund_id: item.response.id.to_string(),
refund_status: enums::RefundStatus::from(item.response.status),
}),
..item.data
})
}
}
//TODO: Fill the struct with respective fields
#[derive(Default, Debug, Serialize, Deserialize, PartialEq)]
pub struct SiftErrorResponse {
pub status_code: u16,
pub code: String,
pub message: String,
pub reason: Option<String>,
pub network_advice_code: Option<String>,
pub network_decline_code: Option<String>,
pub network_error_message: Option<String>,
}
|
{
"crate": "hyperswitch_connectors",
"file": "crates/hyperswitch_connectors/src/connectors/sift/transformers.rs",
"file_size": null,
"is_async": null,
"is_pub": null,
"num_enums": 2,
"num_structs": 6,
"num_tables": null,
"score": null,
"total_crates": null
}
|
file_hyperswitch_connectors_-2650301661336047125
|
clm
|
file
|
// Repository: hyperswitch
// Crate: hyperswitch_connectors
// File: crates/hyperswitch_connectors/src/connectors/worldpayxml/transformers.rs
// Contains: 29 structs, 3 enums
use common_enums::enums;
use common_utils::types::StringMinorUnit;
use error_stack::ResultExt;
use hyperswitch_domain_models::{
payment_method_data::{Card, PaymentMethodData},
router_data::{ConnectorAuthType, ErrorResponse, RouterData},
router_flow_types::refunds::{Execute, RSync},
router_request_types::{
PaymentsAuthorizeData, PaymentsCancelData, PaymentsCaptureData, PaymentsSyncData,
ResponseId,
},
router_response_types::{PaymentsResponseData, RefundsResponseData},
types::{
PaymentsAuthorizeRouterData, PaymentsCancelRouterData, PaymentsCaptureRouterData,
PaymentsSyncRouterData, RefundSyncRouterData, RefundsRouterData,
},
};
use hyperswitch_interfaces::{consts, errors};
use masking::Secret;
use serde::{Deserialize, Serialize};
use crate::{
types::{RefundsResponseRouterData, ResponseRouterData},
utils::{
self as connector_utils, CardData, PaymentsAuthorizeRequestData, PaymentsSyncRequestData,
RouterData as _,
},
};
pub struct WorldpayxmlRouterData<T> {
pub amount: StringMinorUnit,
pub router_data: T,
}
impl<T> From<(StringMinorUnit, T)> for WorldpayxmlRouterData<T> {
fn from((amount, item): (StringMinorUnit, T)) -> Self {
Self {
amount,
router_data: item,
}
}
}
pub mod worldpayxml_constants {
pub const WORLDPAYXML_VERSION: &str = "1.4";
pub const XML_VERSION: &str = "1.0";
pub const XML_ENCODING: &str = "UTF-8";
pub const WORLDPAYXML_DOC_TYPE: &str = r#"paymentService PUBLIC "-//Worldpay//DTD Worldpay PaymentService v1//EN" "http://dtd.worldpay.com/paymentService_v1.dtd""#;
}
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename = "paymentService")]
pub struct PaymentService {
#[serde(rename = "@version")]
version: String,
#[serde(rename = "@merchantCode")]
merchant_code: Secret<String>,
#[serde(skip_serializing_if = "Option::is_none")]
submit: Option<Submit>,
#[serde(skip_serializing_if = "Option::is_none")]
pub reply: Option<Reply>,
#[serde(skip_serializing_if = "Option::is_none")]
inquiry: Option<Inquiry>,
#[serde(skip_serializing_if = "Option::is_none")]
modify: Option<Modify>,
}
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
struct Modify {
order_modification: OrderModification,
}
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
struct OrderModification {
#[serde(rename = "@orderCode")]
order_code: String,
#[serde(skip_serializing_if = "Option::is_none")]
capture: Option<CaptureRequest>,
#[serde(skip_serializing_if = "Option::is_none")]
cancel: Option<CancelRequest>,
#[serde(skip_serializing_if = "Option::is_none")]
refund: Option<RefundRequest>,
}
#[derive(Debug, Serialize, Deserialize)]
struct RefundRequest {
amount: WorldpayXmlAmount,
}
#[derive(Debug, Serialize, Deserialize)]
struct CancelRequest {}
#[derive(Debug, Serialize, Deserialize)]
struct CaptureRequest {
amount: WorldpayXmlAmount,
}
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
struct Inquiry {
order_inquiry: OrderInquiry,
}
#[derive(Debug, Serialize, Deserialize)]
struct OrderInquiry {
#[serde(rename = "@orderCode")]
order_code: String,
}
#[derive(Debug, Serialize, Deserialize)]
struct Submit {
order: Order,
}
#[derive(Debug, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct Reply {
order_status: Option<OrderStatus>,
pub error: Option<WorldpayXmlErrorResponse>,
ok: Option<OkResponse>,
}
#[derive(Debug, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
struct OkResponse {
capture_received: Option<ModifyRequestReceived>,
cancel_received: Option<ModifyRequestReceived>,
refund_received: Option<ModifyRequestReceived>,
}
#[derive(Debug, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
struct ModifyRequestReceived {
#[serde(rename = "@orderCode")]
order_code: String,
amount: Option<WorldpayXmlAmount>,
}
#[derive(Debug, Deserialize, Serialize)]
pub struct WorldpayXmlErrorResponse {
#[serde(rename = "@code")]
pub code: String,
#[serde(rename = "$value")]
pub message: String,
}
#[derive(Debug, Deserialize, Serialize)]
struct OrderStatus {
#[serde(rename = "@orderCode")]
order_code: String,
payment: Option<Payment>,
error: Option<WorldpayXmlErrorResponse>,
}
#[derive(Debug, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
struct Payment {
payment_method: String,
amount: WorldpayXmlAmount,
last_event: LastEvent,
#[serde(rename = "AuthorisationId")]
authorisation_id: Option<AuthorisationId>,
scheme_response: Option<SchemeResponse>,
payment_method_detail: Option<PaymentMethodDetail>,
#[serde(rename = "CVCResultCode")]
cvc_result_code: Option<ResultCode>,
#[serde(rename = "AVSResultCode")]
avs_result_code: Option<ResultCode>,
#[serde(rename = "AAVAddressResultCode")]
aav_address_result_code: Option<ResultCode>,
#[serde(rename = "AAVPostcodeResultCode")]
aav_postcode_result_code: Option<ResultCode>,
#[serde(rename = "AAVCardholderNameResultCode")]
aav_cardholder_name_result_code: Option<ResultCode>,
#[serde(rename = "AAVTelephoneResultCode")]
aav_telephone_result_code: Option<ResultCode>,
#[serde(rename = "AAVEmailResultCode")]
aav_email_result_code: Option<ResultCode>,
issuer_country_code: Option<String>,
issuer_name: Option<String>,
balance: Option<Vec<Balance>>,
card_holder_name: Option<String>,
#[serde(rename = "ISO8583ReturnCode")]
return_code: Option<ReturnCode>,
}
#[derive(Debug, Deserialize, Serialize)]
struct ReturnCode {
#[serde(rename = "@description")]
description: String,
#[serde(rename = "@code")]
code: String,
}
#[derive(Debug, Deserialize, Serialize)]
struct ResultCode {
#[serde(rename = "@description")]
description: String,
}
#[derive(Debug, Deserialize, Serialize)]
struct Balance {
#[serde(rename = "@accountType")]
account_type: String,
amount: WorldpayXmlAmount,
}
#[derive(Debug, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
struct PaymentMethodDetail {
card: CardResponse,
}
#[derive(Debug, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
struct CardResponse {
#[serde(rename = "@number")]
number: Option<Secret<String>>,
#[serde(rename = "@type")]
card_type: String,
expiry_date: Option<ExpiryDate>,
}
#[derive(Debug, Deserialize, Serialize)]
struct AuthorisationId {
#[serde(rename = "@id")]
id: Secret<String>,
}
#[derive(Debug, Clone, Copy, Deserialize, Serialize)]
#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
enum LastEvent {
Authorised,
Refused,
Cancelled,
Captured,
Settled,
SentForAuthorisation,
SentForRefund,
Refunded,
RefundRequested,
RefundFailed,
}
#[derive(Debug, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
struct SchemeResponse {
transaction_identifier: String,
}
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
struct Order {
#[serde(rename = "@orderCode")]
order_code: String,
#[serde(rename = "@captureDelay")]
capture_delay: AutoCapture,
description: String,
amount: WorldpayXmlAmount,
payment_details: PaymentDetails,
}
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
#[serde(rename_all = "UPPERCASE")]
enum AutoCapture {
Off,
#[serde(rename = "0")]
On,
}
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
struct WorldpayXmlAmount {
#[serde(rename = "@value")]
value: StringMinorUnit,
#[serde(rename = "@currencyCode")]
currency_code: api_models::enums::Currency,
#[serde(rename = "@exponent")]
exponent: String,
}
#[derive(Debug, Serialize, Deserialize)]
struct PaymentDetails {
#[serde(rename = "CARD-SSL")]
card_ssl: CardSSL,
}
#[derive(Debug, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
struct CardSSL {
card_number: cards::CardNumber,
expiry_date: ExpiryDate,
card_holder_name: Option<Secret<String>>,
cvc: Secret<String>,
}
#[derive(Debug, Deserialize, Serialize)]
#[serde(rename = "expiryDate")]
struct ExpiryDate {
date: Date,
}
#[derive(Debug, Deserialize, Serialize)]
struct Date {
#[serde(rename = "@month")]
month: Secret<String>,
#[serde(rename = "@year")]
year: Secret<String>,
}
impl TryFrom<&Card> for PaymentDetails {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(card_data: &Card) -> Result<Self, Self::Error> {
Ok(Self {
card_ssl: CardSSL {
card_number: card_data.card_number.clone(),
expiry_date: ExpiryDate {
date: Date {
month: card_data.get_card_expiry_month_2_digit()?,
year: card_data.get_expiry_year_4_digit(),
},
},
card_holder_name: card_data.card_holder_name.to_owned(),
cvc: card_data.card_cvc.to_owned(),
},
})
}
}
impl TryFrom<(&WorldpayxmlRouterData<&PaymentsAuthorizeRouterData>, &Card)> for PaymentService {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: (&WorldpayxmlRouterData<&PaymentsAuthorizeRouterData>, &Card),
) -> Result<Self, Self::Error> {
let authorize_data = item.0;
let card_data = item.1;
let auth = WorldpayxmlAuthType::try_from(&authorize_data.router_data.connector_auth_type)
.change_context(errors::ConnectorError::FailedToObtainAuthType)?;
let order_code = authorize_data
.router_data
.connector_request_reference_id
.to_owned();
let capture_delay = if authorize_data.router_data.request.is_auto_capture()? {
AutoCapture::On
} else {
AutoCapture::Off
};
let description = authorize_data.router_data.description.clone().ok_or(
errors::ConnectorError::MissingRequiredField {
field_name: "description",
},
)?;
let exponent = authorize_data
.router_data
.request
.currency
.number_of_digits_after_decimal_point()
.to_string();
let amount = WorldpayXmlAmount {
currency_code: authorize_data.router_data.request.currency.to_owned(),
exponent,
value: authorize_data.amount.to_owned(),
};
let payment_details = PaymentDetails::try_from(card_data)?;
let submit = Some(Submit {
order: Order {
order_code,
capture_delay,
description,
amount,
payment_details,
},
});
Ok(Self {
version: worldpayxml_constants::WORLDPAYXML_VERSION.to_string(),
merchant_code: auth.merchant_code.clone(),
submit,
reply: None,
inquiry: None,
modify: None,
})
}
}
impl TryFrom<&WorldpayxmlRouterData<&PaymentsAuthorizeRouterData>> for PaymentService {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: &WorldpayxmlRouterData<&PaymentsAuthorizeRouterData>,
) -> Result<Self, Self::Error> {
if item.router_data.is_three_ds() {
Err(errors::ConnectorError::NotSupported {
message: "Card 3DS".to_string(),
connector: "Worldpayxml",
})?
};
match item.router_data.request.payment_method_data.clone() {
PaymentMethodData::Card(req_card) => Self::try_from((item, &req_card)),
_ => Err(errors::ConnectorError::NotImplemented(
connector_utils::get_unimplemented_payment_method_error_message("Worldpayxml"),
))?,
}
}
}
impl TryFrom<&WorldpayxmlRouterData<&PaymentsCaptureRouterData>> for PaymentService {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: &WorldpayxmlRouterData<&PaymentsCaptureRouterData>,
) -> Result<Self, Self::Error> {
let auth = WorldpayxmlAuthType::try_from(&item.router_data.connector_auth_type)
.change_context(errors::ConnectorError::FailedToObtainAuthType)?;
let modify = Some(Modify {
order_modification: OrderModification {
order_code: item.router_data.request.connector_transaction_id.clone(),
capture: Some(CaptureRequest {
amount: WorldpayXmlAmount {
currency_code: item.router_data.request.currency.to_owned(),
exponent: item
.router_data
.request
.currency
.number_of_digits_after_decimal_point()
.to_string(),
value: item.amount.to_owned(),
},
}),
cancel: None,
refund: None,
},
});
Ok(Self {
version: worldpayxml_constants::WORLDPAYXML_VERSION.to_string(),
merchant_code: auth.merchant_code.clone(),
submit: None,
reply: None,
inquiry: None,
modify,
})
}
}
impl TryFrom<&PaymentsCancelRouterData> for PaymentService {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(item: &PaymentsCancelRouterData) -> Result<Self, Self::Error> {
let auth = WorldpayxmlAuthType::try_from(&item.connector_auth_type)
.change_context(errors::ConnectorError::FailedToObtainAuthType)?;
let modify = Some(Modify {
order_modification: OrderModification {
order_code: item.request.connector_transaction_id.clone(),
capture: None,
cancel: Some(CancelRequest {}),
refund: None,
},
});
Ok(Self {
version: worldpayxml_constants::WORLDPAYXML_VERSION.to_string(),
merchant_code: auth.merchant_code.clone(),
submit: None,
reply: None,
inquiry: None,
modify,
})
}
}
impl<F> TryFrom<&WorldpayxmlRouterData<&RefundsRouterData<F>>> for PaymentService {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(item: &WorldpayxmlRouterData<&RefundsRouterData<F>>) -> Result<Self, Self::Error> {
let auth = WorldpayxmlAuthType::try_from(&item.router_data.connector_auth_type)?;
let modify = Some(Modify {
order_modification: OrderModification {
order_code: item.router_data.request.connector_transaction_id.clone(),
capture: None,
cancel: None,
refund: Some(RefundRequest {
amount: WorldpayXmlAmount {
currency_code: item.router_data.request.currency.to_owned(),
exponent: item
.router_data
.request
.currency
.number_of_digits_after_decimal_point()
.to_string(),
value: item.amount.to_owned(),
},
}),
},
});
Ok(Self {
version: worldpayxml_constants::WORLDPAYXML_VERSION.to_string(),
merchant_code: auth.merchant_code.clone(),
submit: None,
reply: None,
inquiry: None,
modify,
})
}
}
impl TryFrom<RefundsResponseRouterData<Execute, PaymentService>> for RefundsRouterData<Execute> {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: RefundsResponseRouterData<Execute, PaymentService>,
) -> Result<Self, Self::Error> {
let reply = item
.response
.reply
.ok_or(errors::ConnectorError::UnexpectedResponseError(
bytes::Bytes::from("Missing reply data".to_string()),
))?;
if let Some(refund_received) = reply.ok.and_then(|ok| ok.refund_received) {
Ok(Self {
response: Ok(RefundsResponseData {
connector_refund_id: refund_received.order_code,
refund_status: enums::RefundStatus::Pending,
}),
..item.data
})
} else {
let error = reply
.error
.ok_or(errors::ConnectorError::UnexpectedResponseError(
bytes::Bytes::from(
"Either refund_received or error must be present in the response"
.to_string(),
),
))?;
Ok(Self {
response: Err(ErrorResponse {
code: error.code,
message: error.message.clone(),
reason: Some(error.message.clone()),
status_code: item.http_code,
attempt_status: None,
connector_transaction_id: None,
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
connector_metadata: None,
}),
..item.data
})
}
}
}
pub struct WorldpayxmlAuthType {
pub(super) api_username: Secret<String>,
pub(super) api_password: Secret<String>,
pub(super) merchant_code: Secret<String>,
}
impl TryFrom<&ConnectorAuthType> for WorldpayxmlAuthType {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(auth_type: &ConnectorAuthType) -> Result<Self, Self::Error> {
match auth_type {
ConnectorAuthType::SignatureKey {
api_key,
key1,
api_secret,
} => Ok(Self {
api_username: api_key.to_owned(),
api_password: key1.to_owned(),
merchant_code: api_secret.to_owned(),
}),
_ => Err(errors::ConnectorError::FailedToObtainAuthType.into()),
}
}
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, PartialEq)]
#[serde(rename_all = "lowercase")]
pub enum WorldpayxmlPaymentStatus {
Succeeded,
Failed,
#[default]
Processing,
}
fn get_attempt_status(
is_auto_capture: bool,
last_event: LastEvent,
previous_status: Option<&common_enums::AttemptStatus>,
) -> Result<common_enums::AttemptStatus, errors::ConnectorError> {
match last_event {
LastEvent::Authorised => {
if is_auto_capture {
Ok(common_enums::AttemptStatus::Pending)
} else if previous_status == Some(&common_enums::AttemptStatus::CaptureInitiated)
&& !is_auto_capture
{
Ok(common_enums::AttemptStatus::CaptureInitiated)
} else if previous_status == Some(&common_enums::AttemptStatus::VoidInitiated)
&& !is_auto_capture
{
Ok(common_enums::AttemptStatus::VoidInitiated)
} else {
Ok(common_enums::AttemptStatus::Authorized)
}
}
LastEvent::Refused => Ok(common_enums::AttemptStatus::Failure),
LastEvent::Cancelled => Ok(common_enums::AttemptStatus::Voided),
LastEvent::Captured | LastEvent::Settled => Ok(common_enums::AttemptStatus::Charged),
LastEvent::SentForAuthorisation => Ok(common_enums::AttemptStatus::Authorizing),
LastEvent::Refunded
| LastEvent::SentForRefund
| LastEvent::RefundRequested
| LastEvent::RefundFailed => Err(errors::ConnectorError::UnexpectedResponseError(
bytes::Bytes::from("Invalid LastEvent".to_string()),
)),
}
}
fn get_refund_status(last_event: LastEvent) -> Result<enums::RefundStatus, errors::ConnectorError> {
match last_event {
LastEvent::Refunded => Ok(enums::RefundStatus::Success),
LastEvent::SentForRefund | LastEvent::RefundRequested => Ok(enums::RefundStatus::Pending),
LastEvent::RefundFailed => Ok(enums::RefundStatus::Failure),
LastEvent::Captured | LastEvent::Settled => Ok(enums::RefundStatus::Pending),
LastEvent::Authorised
| LastEvent::Refused
| LastEvent::Cancelled
| LastEvent::SentForAuthorisation => Err(errors::ConnectorError::UnexpectedResponseError(
bytes::Bytes::from("Invalid LastEvent".to_string()),
)),
}
}
impl<F> TryFrom<ResponseRouterData<F, PaymentService, PaymentsSyncData, PaymentsResponseData>>
for RouterData<F, PaymentsSyncData, PaymentsResponseData>
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: ResponseRouterData<F, PaymentService, PaymentsSyncData, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
let is_auto_capture = item.data.request.is_auto_capture()?;
let reply = item
.response
.reply
.ok_or(errors::ConnectorError::UnexpectedResponseError(
bytes::Bytes::from("Missing reply data".to_string()),
))?;
validate_reply(&reply)?;
if let Some(order_status) = reply.order_status {
validate_order_status(&order_status)?;
if let Some(payment_data) = order_status.payment {
let status = get_attempt_status(
is_auto_capture,
payment_data.last_event,
Some(&item.data.status),
)?;
let response = process_payment_response(
status,
&payment_data,
item.http_code,
order_status.order_code.clone(),
)
.map_err(|err| *err);
Ok(Self {
status,
response,
..item.data
})
} else {
order_status.error
.ok_or(errors::ConnectorError::UnexpectedResponseError(
bytes::Bytes::from("Either order_status.payment or order_status.error must be present in the response".to_string()),
))?;
// Handle API errors unrelated to the payment to prevent failing the payment.
Ok(Self {
status: item.data.status,
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(
order_status.order_code.clone(),
),
redirection_data: Box::new(None),
mandate_reference: Box::new(None),
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: Some(order_status.order_code.clone()),
incremental_authorization_allowed: None,
charges: None,
}),
..item.data
})
}
} else {
// Handle API errors unrelated to the payment to prevent failing the payment
Ok(Self {
status: item.data.status,
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: item.data.request.connector_transaction_id.clone(),
redirection_data: Box::new(None),
mandate_reference: Box::new(None),
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: None,
incremental_authorization_allowed: None,
charges: None,
}),
..item.data
})
}
}
}
impl TryFrom<&PaymentsSyncRouterData> for PaymentService {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(item: &PaymentsSyncRouterData) -> Result<Self, Self::Error> {
let auth = WorldpayxmlAuthType::try_from(&item.connector_auth_type)
.change_context(errors::ConnectorError::FailedToObtainAuthType)?;
let order_code = item
.request
.connector_transaction_id
.get_connector_transaction_id()
.change_context(errors::ConnectorError::MissingConnectorTransactionID)?;
let inquiry = Some(Inquiry {
order_inquiry: OrderInquiry { order_code },
});
Ok(Self {
version: worldpayxml_constants::WORLDPAYXML_VERSION.to_string(),
merchant_code: auth.merchant_code.clone(),
submit: None,
reply: None,
inquiry,
modify: None,
})
}
}
impl<F> TryFrom<ResponseRouterData<F, PaymentService, PaymentsAuthorizeData, PaymentsResponseData>>
for RouterData<F, PaymentsAuthorizeData, PaymentsResponseData>
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: ResponseRouterData<F, PaymentService, PaymentsAuthorizeData, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
let is_auto_capture = item.data.request.is_auto_capture()?;
let reply = item
.response
.reply
.ok_or(errors::ConnectorError::UnexpectedResponseError(
bytes::Bytes::from("Missing reply data".to_string()),
))?;
validate_reply(&reply)?;
if let Some(order_status) = reply.order_status {
validate_order_status(&order_status)?;
if let Some(payment_data) = order_status.payment {
let status = get_attempt_status(is_auto_capture, payment_data.last_event, None)?;
let response = process_payment_response(
status,
&payment_data,
item.http_code,
order_status.order_code.clone(),
)
.map_err(|err| *err);
Ok(Self {
status,
response,
..item.data
})
} else {
let error =
order_status.error
.ok_or(errors::ConnectorError::UnexpectedResponseError(
bytes::Bytes::from("Either order_status.payment or order_status.error must be present in the response".to_string()),
))?;
Ok(Self {
status: common_enums::AttemptStatus::Failure,
response: Err(ErrorResponse {
code: error.code,
message: error.message.clone(),
reason: Some(error.message.clone()),
status_code: item.http_code,
attempt_status: None,
connector_transaction_id: Some(order_status.order_code),
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
connector_metadata: None,
}),
..item.data
})
}
} else {
let error = reply
.error
.ok_or(errors::ConnectorError::UnexpectedResponseError(
bytes::Bytes::from("Missing reply.error".to_string()),
))?;
Ok(Self {
status: common_enums::AttemptStatus::Failure,
response: Err(ErrorResponse {
code: error.code,
message: error.message.clone(),
reason: Some(error.message.clone()),
status_code: item.http_code,
attempt_status: None,
connector_transaction_id: None,
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
connector_metadata: None,
}),
..item.data
})
}
}
}
impl<F> TryFrom<ResponseRouterData<F, PaymentService, PaymentsCaptureData, PaymentsResponseData>>
for RouterData<F, PaymentsCaptureData, PaymentsResponseData>
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: ResponseRouterData<F, PaymentService, PaymentsCaptureData, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
let reply = item
.response
.reply
.ok_or(errors::ConnectorError::UnexpectedResponseError(
bytes::Bytes::from("Missing reply data".to_string()),
))?;
if let Some(capture_received) = reply.ok.and_then(|ok| ok.capture_received) {
Ok(Self {
// Capture status will be updated via Psync
status: common_enums::AttemptStatus::CaptureInitiated,
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(
capture_received.order_code.clone(),
),
redirection_data: Box::new(None),
mandate_reference: Box::new(None),
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: Some(capture_received.order_code.clone()),
incremental_authorization_allowed: None,
charges: None,
}),
..item.data
})
} else {
let error = reply
.error
.ok_or(errors::ConnectorError::UnexpectedResponseError(
bytes::Bytes::from(
"Either capture_received or error must be present in the response"
.to_string(),
),
))?;
Ok(Self {
status: common_enums::AttemptStatus::CaptureFailed,
response: Err(ErrorResponse {
code: error.code,
message: error.message.clone(),
reason: Some(error.message.clone()),
status_code: item.http_code,
attempt_status: None,
connector_transaction_id: None,
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
connector_metadata: None,
}),
..item.data
})
}
}
}
impl<F> TryFrom<ResponseRouterData<F, PaymentService, PaymentsCancelData, PaymentsResponseData>>
for RouterData<F, PaymentsCancelData, PaymentsResponseData>
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: ResponseRouterData<F, PaymentService, PaymentsCancelData, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
let reply = item
.response
.reply
.ok_or(errors::ConnectorError::UnexpectedResponseError(
bytes::Bytes::from("Missing reply data".to_string()),
))?;
if let Some(cancel_received) = reply.ok.and_then(|ok| ok.cancel_received) {
Ok(Self {
// Cancel status will be updated via Psync
status: common_enums::AttemptStatus::VoidInitiated,
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(
cancel_received.order_code.clone(),
),
redirection_data: Box::new(None),
mandate_reference: Box::new(None),
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: Some(cancel_received.order_code.clone()),
incremental_authorization_allowed: None,
charges: None,
}),
..item.data
})
} else {
let error = reply
.error
.ok_or(errors::ConnectorError::UnexpectedResponseError(
bytes::Bytes::from(
"Either cancel_received or error must be present in the response"
.to_string(),
),
))?;
Ok(Self {
status: common_enums::AttemptStatus::VoidFailed,
response: Err(ErrorResponse {
code: error.code,
message: error.message.clone(),
reason: Some(error.message.clone()),
status_code: item.http_code,
attempt_status: None,
connector_transaction_id: None,
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
connector_metadata: None,
}),
..item.data
})
}
}
}
#[derive(Default, Debug, Serialize)]
pub struct WorldpayxmlRefundRequest {
pub amount: StringMinorUnit,
}
impl TryFrom<RefundsResponseRouterData<RSync, PaymentService>> for RefundsRouterData<RSync> {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: RefundsResponseRouterData<RSync, PaymentService>,
) -> Result<Self, Self::Error> {
let reply = item
.response
.reply
.ok_or(errors::ConnectorError::UnexpectedResponseError(
bytes::Bytes::from("Missing reply data".to_string()),
))?;
validate_reply(&reply)?;
if let Some(order_status) = reply.order_status {
validate_order_status(&order_status)?;
if let Some(payment_data) = order_status.payment {
let status = get_refund_status(payment_data.last_event)?;
let response = if connector_utils::is_refund_failure(status) {
let error_code = payment_data
.return_code
.as_ref()
.map(|code| code.code.clone());
let error_message = payment_data
.return_code
.as_ref()
.map(|code| code.description.clone());
Err(ErrorResponse {
code: error_code.unwrap_or(consts::NO_ERROR_CODE.to_string()),
message: error_message
.clone()
.unwrap_or(consts::NO_ERROR_MESSAGE.to_string()),
reason: error_message.clone(),
status_code: item.http_code,
attempt_status: None,
connector_transaction_id: None,
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
connector_metadata: None,
})
} else {
Ok(RefundsResponseData {
connector_refund_id: order_status.order_code,
refund_status: status,
})
};
Ok(Self {
response,
..item.data
})
} else {
order_status.error
.ok_or(errors::ConnectorError::UnexpectedResponseError(
bytes::Bytes::from("Either order_status.payment or order_status.error must be present in the response".to_string()),
))?;
// Return TransactionResponse for API errors unrelated to the payment to prevent failing the payment.
let response = Ok(RefundsResponseData {
connector_refund_id: order_status.order_code,
refund_status: enums::RefundStatus::Pending,
});
Ok(Self {
response,
..item.data
})
}
} else {
// Return TransactionResponse for API errors unrelated to the payment to prevent failing the payment
let response = Ok(RefundsResponseData {
connector_refund_id: item.data.request.connector_transaction_id.clone(),
refund_status: enums::RefundStatus::Pending,
});
Ok(Self {
response,
..item.data
})
}
}
}
impl TryFrom<&RefundSyncRouterData> for PaymentService {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(item: &RefundSyncRouterData) -> Result<Self, Self::Error> {
let auth = WorldpayxmlAuthType::try_from(&item.connector_auth_type)
.change_context(errors::ConnectorError::FailedToObtainAuthType)?;
let order_code = item.request.connector_transaction_id.clone();
let inquiry = Some(Inquiry {
order_inquiry: OrderInquiry { order_code },
});
Ok(Self {
version: worldpayxml_constants::WORLDPAYXML_VERSION.to_string(),
merchant_code: auth.merchant_code.clone(),
submit: None,
reply: None,
inquiry,
modify: None,
})
}
}
fn validate_reply(reply: &Reply) -> Result<(), errors::ConnectorError> {
if (reply.error.is_some() && reply.order_status.is_some())
|| (reply.error.is_none() && reply.order_status.is_none())
{
Err(errors::ConnectorError::UnexpectedResponseError(
bytes::Bytes::from(
"Either reply.error_data or reply.order_data must be present in the response"
.to_string(),
),
))
} else {
Ok(())
}
}
fn validate_order_status(order_status: &OrderStatus) -> Result<(), errors::ConnectorError> {
if (order_status.payment.is_some() && order_status.error.is_some())
|| (order_status.payment.is_none() && order_status.error.is_none())
{
Err(errors::ConnectorError::UnexpectedResponseError(
bytes::Bytes::from(
"Either order_status.payment or order_status.error must be present in the response"
.to_string(),
),
))
} else {
Ok(())
}
}
fn process_payment_response(
status: common_enums::AttemptStatus,
payment_data: &Payment,
http_code: u16,
order_code: String,
) -> Result<PaymentsResponseData, Box<ErrorResponse>> {
if connector_utils::is_payment_failure(status) {
let error_code = payment_data
.return_code
.as_ref()
.map(|code| code.code.clone());
let error_message = payment_data
.return_code
.as_ref()
.map(|code| code.description.clone());
Err(Box::new(ErrorResponse {
code: error_code.unwrap_or(consts::NO_ERROR_CODE.to_string()),
message: error_message.unwrap_or(consts::NO_ERROR_MESSAGE.to_string()),
reason: None,
status_code: http_code,
attempt_status: None,
connector_transaction_id: Some(order_code.clone()),
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
connector_metadata: None,
}))
} else {
Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(order_code.clone()),
redirection_data: Box::new(None),
mandate_reference: Box::new(None),
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: Some(order_code.clone()),
incremental_authorization_allowed: None,
charges: None,
})
}
}
|
{
"crate": "hyperswitch_connectors",
"file": "crates/hyperswitch_connectors/src/connectors/worldpayxml/transformers.rs",
"file_size": null,
"is_async": null,
"is_pub": null,
"num_enums": 3,
"num_structs": 29,
"num_tables": null,
"score": null,
"total_crates": null
}
|
file_hyperswitch_connectors_-5613206534095684467
|
clm
|
file
|
// Repository: hyperswitch
// Crate: hyperswitch_connectors
// File: crates/hyperswitch_connectors/src/connectors/coingate/transformers.rs
// Contains: 8 structs, 2 enums
use std::collections::HashMap;
use common_enums::{enums, Currency};
use common_utils::{ext_traits::OptionExt, pii, request::Method, types::StringMajorUnit};
use error_stack::ResultExt;
use hyperswitch_domain_models::{
payment_method_data::PaymentMethodData,
router_data::{ConnectorAuthType, RouterData},
router_flow_types::refunds::{Execute, RSync},
router_request_types::ResponseId,
router_response_types::{PaymentsResponseData, RedirectForm, RefundsResponseData},
types::{PaymentsAuthorizeRouterData, PaymentsSyncRouterData, RefundsRouterData},
};
use hyperswitch_interfaces::errors;
use masking::{ExposeInterface, Secret};
use serde::{Deserialize, Serialize};
use crate::{
types::{PaymentsSyncResponseRouterData, RefundsResponseRouterData, ResponseRouterData},
utils::{self, PaymentsAuthorizeRequestData},
};
pub struct CoingateRouterData<T> {
pub amount: StringMajorUnit,
pub router_data: T,
}
impl<T> From<(StringMajorUnit, T)> for CoingateRouterData<T> {
fn from((amount, item): (StringMajorUnit, T)) -> Self {
Self {
amount,
router_data: item,
}
}
}
#[derive(Debug, Serialize, Deserialize)]
pub struct CoingateConnectorMetadataObject {
pub currency_id: i32,
pub platform_id: i32,
pub ledger_account_id: Secret<String>,
}
impl TryFrom<&Option<pii::SecretSerdeValue>> for CoingateConnectorMetadataObject {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(meta_data: &Option<pii::SecretSerdeValue>) -> Result<Self, Self::Error> {
let metadata: Self = utils::to_connector_meta_from_secret::<Self>(meta_data.clone())
.change_context(errors::ConnectorError::InvalidConnectorConfig {
config: "metadata",
})?;
Ok(metadata)
}
}
#[derive(Default, Debug, Serialize, PartialEq)]
pub struct CoingatePaymentsRequest {
price_amount: StringMajorUnit,
price_currency: Currency,
receive_currency: String,
callback_url: String,
success_url: Option<String>,
cancel_url: Option<String>,
title: String,
token: Secret<String>,
}
impl TryFrom<&CoingateRouterData<&PaymentsAuthorizeRouterData>> for CoingatePaymentsRequest {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: &CoingateRouterData<&PaymentsAuthorizeRouterData>,
) -> Result<Self, Self::Error> {
let auth = CoingateAuthType::try_from(&item.router_data.connector_auth_type)?;
Ok(match item.router_data.request.payment_method_data {
PaymentMethodData::Crypto(_) => Ok(Self {
price_amount: item.amount.clone(),
price_currency: item.router_data.request.currency,
receive_currency: "DO_NOT_CONVERT".to_string(),
callback_url: item.router_data.request.get_webhook_url()?,
success_url: item.router_data.request.router_return_url.clone(),
cancel_url: item.router_data.request.router_return_url.clone(),
title: item.router_data.connector_request_reference_id.clone(),
token: auth.merchant_token,
}),
_ => Err(errors::ConnectorError::NotImplemented(
utils::get_unimplemented_payment_method_error_message("Coingate"),
)),
}?)
}
}
#[derive(Debug, Serialize, Deserialize)]
pub struct CoingateSyncResponse {
status: CoingatePaymentStatus,
id: i64,
}
impl TryFrom<PaymentsSyncResponseRouterData<CoingateSyncResponse>> for PaymentsSyncRouterData {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: PaymentsSyncResponseRouterData<CoingateSyncResponse>,
) -> Result<Self, Self::Error> {
Ok(Self {
status: enums::AttemptStatus::from(item.response.status.clone()),
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(item.response.id.to_string()),
redirection_data: Box::new(None),
mandate_reference: Box::new(None),
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: None,
incremental_authorization_allowed: None,
charges: None,
}),
..item.data
})
}
}
pub struct CoingateAuthType {
pub(super) api_key: Secret<String>,
pub(super) merchant_token: Secret<String>,
}
impl TryFrom<&ConnectorAuthType> for CoingateAuthType {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(auth_type: &ConnectorAuthType) -> Result<Self, Self::Error> {
match auth_type {
ConnectorAuthType::BodyKey { api_key, key1 } => Ok(Self {
api_key: api_key.to_owned(),
merchant_token: key1.to_owned(),
}),
_ => Err(errors::ConnectorError::FailedToObtainAuthType.into()),
}
}
}
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
#[serde(rename_all = "lowercase")]
pub enum CoingatePaymentStatus {
New,
Pending,
Confirming,
Paid,
Invalid,
Expired,
Canceled,
}
impl From<CoingatePaymentStatus> for common_enums::AttemptStatus {
fn from(item: CoingatePaymentStatus) -> Self {
match item {
CoingatePaymentStatus::Paid => Self::Charged,
CoingatePaymentStatus::Canceled
| CoingatePaymentStatus::Expired
| CoingatePaymentStatus::Invalid => Self::Failure,
CoingatePaymentStatus::Confirming | CoingatePaymentStatus::New => {
Self::AuthenticationPending
}
CoingatePaymentStatus::Pending => Self::Pending,
}
}
}
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct CoingatePaymentsResponse {
status: CoingatePaymentStatus,
id: i64,
payment_url: Option<String>,
order_id: Option<String>,
}
impl<F, T> TryFrom<ResponseRouterData<F, CoingatePaymentsResponse, T, PaymentsResponseData>>
for RouterData<F, T, PaymentsResponseData>
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: ResponseRouterData<F, CoingatePaymentsResponse, T, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
Ok(Self {
status: enums::AttemptStatus::from(item.response.status.clone()),
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(item.response.id.to_string()),
redirection_data: Box::new(Some(RedirectForm::Form {
endpoint: item.response.payment_url.clone().ok_or(
errors::ConnectorError::MissingRequiredField {
field_name: "payment_url",
},
)?,
method: Method::Get,
form_fields: HashMap::new(),
})),
mandate_reference: Box::new(None),
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: item.response.order_id.clone(),
incremental_authorization_allowed: None,
charges: None,
}),
..item.data
})
}
}
#[derive(Default, Debug, Serialize)]
pub struct CoingateRefundRequest {
pub amount: StringMajorUnit,
pub address: Secret<String>,
pub currency_id: i32,
pub platform_id: i32,
pub reason: String,
pub email: pii::Email,
pub ledger_account_id: Secret<String>,
}
impl<F> TryFrom<&CoingateRouterData<&RefundsRouterData<F>>> for CoingateRefundRequest {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(item: &CoingateRouterData<&RefundsRouterData<F>>) -> Result<Self, Self::Error> {
let metadata: CoingateConnectorMetadataObject =
utils::to_connector_meta_from_secret(item.router_data.connector_meta_data.clone())
.change_context(errors::ConnectorError::InvalidConnectorConfig {
config: "merchant_connector_account.metadata",
})?;
let refund_metadata = item
.router_data
.request
.refund_connector_metadata
.as_ref()
.get_required_value("refund_connector_metadata")
.change_context(errors::ConnectorError::MissingRequiredField {
field_name: "refund_connector_metadata",
})?
.clone()
.expose();
let address: Secret<String> = serde_json::from_value::<Secret<String>>(
refund_metadata.get("address").cloned().ok_or_else(|| {
errors::ConnectorError::MissingRequiredField {
field_name: "address",
}
})?,
)
.change_context(errors::ConnectorError::MissingRequiredField {
field_name: "address",
})?;
let email: pii::Email = serde_json::from_value::<pii::Email>(
refund_metadata.get("email").cloned().ok_or_else(|| {
errors::ConnectorError::MissingRequiredField {
field_name: "email",
}
})?,
)
.change_context(errors::ConnectorError::MissingRequiredField {
field_name: "email",
})?;
Ok(Self {
amount: item.amount.clone(),
address,
currency_id: metadata.currency_id,
platform_id: metadata.platform_id,
reason: item.router_data.request.reason.clone().ok_or(
errors::ConnectorError::MissingRequiredField {
field_name: "refund.reason",
},
)?,
email,
ledger_account_id: metadata.ledger_account_id,
})
}
}
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct CoingateRefundResponse {
pub status: CoingateRefundStatus,
pub id: i64,
}
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
#[serde(rename_all = "lowercase")]
pub enum CoingateRefundStatus {
Pending,
Completed,
Rejected,
Processing,
}
impl TryFrom<RefundsResponseRouterData<Execute, CoingateRefundResponse>>
for RefundsRouterData<Execute>
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: RefundsResponseRouterData<Execute, CoingateRefundResponse>,
) -> Result<Self, Self::Error> {
Ok(Self {
response: Ok(RefundsResponseData {
connector_refund_id: item.response.id.to_string(),
refund_status: enums::RefundStatus::from(item.response.status),
}),
..item.data
})
}
}
impl TryFrom<RefundsResponseRouterData<RSync, CoingateRefundResponse>>
for RefundsRouterData<RSync>
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: RefundsResponseRouterData<RSync, CoingateRefundResponse>,
) -> Result<Self, Self::Error> {
Ok(Self {
response: Ok(RefundsResponseData {
connector_refund_id: item.response.id.to_string(),
refund_status: enums::RefundStatus::from(item.response.status),
}),
..item.data
})
}
}
impl From<CoingateRefundStatus> for common_enums::RefundStatus {
fn from(item: CoingateRefundStatus) -> Self {
match item {
CoingateRefundStatus::Pending => Self::Pending,
CoingateRefundStatus::Completed => Self::Success,
CoingateRefundStatus::Rejected => Self::Failure,
CoingateRefundStatus::Processing => Self::Pending,
}
}
}
#[derive(Default, Debug, Serialize, Deserialize, PartialEq)]
pub struct CoingateErrorResponse {
pub message: String,
pub reason: String,
pub errors: Option<Vec<String>>,
}
#[derive(Debug, Serialize, Deserialize)]
pub struct CoingateWebhookBody {
pub token: Secret<String>,
pub status: CoingatePaymentStatus,
pub id: i64,
}
|
{
"crate": "hyperswitch_connectors",
"file": "crates/hyperswitch_connectors/src/connectors/coingate/transformers.rs",
"file_size": null,
"is_async": null,
"is_pub": null,
"num_enums": 2,
"num_structs": 8,
"num_tables": null,
"score": null,
"total_crates": null
}
|
file_hyperswitch_connectors_-4184276672003646734
|
clm
|
file
|
// Repository: hyperswitch
// Crate: hyperswitch_connectors
// File: crates/hyperswitch_connectors/src/connectors/tsys/transformers.rs
// Contains: 15 structs, 6 enums
use common_enums::enums;
use common_utils::types::StringMinorUnit;
use error_stack::ResultExt;
use hyperswitch_domain_models::{
payment_method_data::PaymentMethodData,
router_data::{self, ConnectorAuthType, RouterData},
router_flow_types::refunds::{Execute, RSync},
router_request_types::ResponseId,
router_response_types::{PaymentsResponseData, RefundsResponseData},
types::{
self, PaymentsCancelRouterData, PaymentsSyncRouterData, RefundSyncRouterData,
RefundsRouterData,
},
};
use hyperswitch_interfaces::errors;
use masking::Secret;
use serde::{Deserialize, Serialize};
pub struct TsysRouterData<T> {
pub amount: StringMinorUnit,
pub router_data: T,
}
impl<T> From<(StringMinorUnit, T)> for TsysRouterData<T> {
fn from((amount, router_data): (StringMinorUnit, T)) -> Self {
Self {
amount,
router_data,
}
}
}
use crate::{
types::{RefundsResponseRouterData, ResponseRouterData},
utils::{self, CardData as _, PaymentsAuthorizeRequestData, RefundsRequestData as _},
};
#[derive(Debug, Serialize)]
pub enum TsysPaymentsRequest {
Auth(TsysPaymentAuthSaleRequest),
Sale(TsysPaymentAuthSaleRequest),
}
#[derive(Default, Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct TsysPaymentAuthSaleRequest {
#[serde(rename = "deviceID")]
device_id: Secret<String>,
transaction_key: Secret<String>,
card_data_source: String,
transaction_amount: StringMinorUnit,
currency_code: enums::Currency,
card_number: cards::CardNumber,
expiration_date: Secret<String>,
cvv2: Secret<String>,
order_number: String,
terminal_capability: String,
terminal_operating_environment: String,
cardholder_authentication_method: String,
#[serde(rename = "developerID")]
developer_id: Secret<String>,
}
impl TryFrom<&TsysRouterData<&types::PaymentsAuthorizeRouterData>> for TsysPaymentsRequest {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item_data: &TsysRouterData<&types::PaymentsAuthorizeRouterData>,
) -> Result<Self, Self::Error> {
let item = item_data.router_data.clone();
match item.request.payment_method_data.clone() {
PaymentMethodData::Card(ccard) => {
let connector_auth: TsysAuthType =
TsysAuthType::try_from(&item.connector_auth_type)?;
let auth_data: TsysPaymentAuthSaleRequest = TsysPaymentAuthSaleRequest {
device_id: connector_auth.device_id,
transaction_key: connector_auth.transaction_key,
card_data_source: "INTERNET".to_string(),
transaction_amount: item_data.amount.clone(),
currency_code: item.request.currency,
card_number: ccard.card_number.clone(),
expiration_date: ccard
.get_card_expiry_month_year_2_digit_with_delimiter("/".to_owned())?,
cvv2: ccard.card_cvc,
order_number: item.connector_request_reference_id.clone(),
terminal_capability: "ICC_CHIP_READ_ONLY".to_string(),
terminal_operating_environment: "ON_MERCHANT_PREMISES_ATTENDED".to_string(),
cardholder_authentication_method: "NOT_AUTHENTICATED".to_string(),
developer_id: connector_auth.developer_id,
};
if item.request.is_auto_capture()? {
Ok(Self::Sale(auth_data))
} else {
Ok(Self::Auth(auth_data))
}
}
PaymentMethodData::CardRedirect(_)
| PaymentMethodData::Wallet(_)
| PaymentMethodData::PayLater(_)
| PaymentMethodData::BankRedirect(_)
| PaymentMethodData::BankDebit(_)
| PaymentMethodData::BankTransfer(_)
| PaymentMethodData::Crypto(_)
| PaymentMethodData::MandatePayment
| PaymentMethodData::Reward
| PaymentMethodData::RealTimePayment(_)
| PaymentMethodData::MobilePayment(_)
| PaymentMethodData::Upi(_)
| PaymentMethodData::Voucher(_)
| PaymentMethodData::GiftCard(_)
| PaymentMethodData::OpenBanking(_)
| PaymentMethodData::CardToken(_)
| PaymentMethodData::NetworkToken(_)
| PaymentMethodData::CardDetailsForNetworkTransactionId(_) => {
Err(errors::ConnectorError::NotImplemented(
utils::get_unimplemented_payment_method_error_message("tsys"),
))?
}
}
}
}
// Auth Struct
pub struct TsysAuthType {
pub(super) device_id: Secret<String>,
pub(super) transaction_key: Secret<String>,
pub(super) developer_id: Secret<String>,
}
impl TryFrom<&ConnectorAuthType> for TsysAuthType {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(auth_type: &ConnectorAuthType) -> Result<Self, Self::Error> {
match auth_type {
ConnectorAuthType::SignatureKey {
api_key,
key1,
api_secret,
} => Ok(Self {
device_id: api_key.to_owned(),
transaction_key: key1.to_owned(),
developer_id: api_secret.to_owned(),
}),
_ => Err(errors::ConnectorError::FailedToObtainAuthType.into()),
}
}
}
// PaymentsResponse
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(rename_all = "UPPERCASE")]
pub enum TsysPaymentStatus {
Pass,
Fail,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(rename_all = "UPPERCASE")]
pub enum TsysTransactionStatus {
Approved,
Declined,
Void,
}
impl From<TsysTransactionDetails> for enums::AttemptStatus {
fn from(item: TsysTransactionDetails) -> Self {
match item.transaction_status {
TsysTransactionStatus::Approved => {
if item.transaction_type.contains("Auth-Only") {
Self::Authorized
} else {
Self::Charged
}
}
TsysTransactionStatus::Void => Self::Voided,
TsysTransactionStatus::Declined => Self::Failure,
}
}
}
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct TsysErrorResponse {
pub status: TsysPaymentStatus,
pub response_code: String,
pub response_message: String,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct TsysTransactionDetails {
#[serde(rename = "transactionID")]
transaction_id: String,
transaction_type: String,
transaction_status: TsysTransactionStatus,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct TsysPaymentsSyncResponse {
pub status: TsysPaymentStatus,
pub response_code: String,
pub response_message: String,
pub transaction_details: TsysTransactionDetails,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct TsysResponse {
pub status: TsysPaymentStatus,
pub response_code: String,
pub response_message: String,
#[serde(rename = "transactionID")]
pub transaction_id: String,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(untagged)]
pub enum TsysResponseTypes {
SuccessResponse(TsysResponse),
ErrorResponse(TsysErrorResponse),
}
#[derive(Debug, Clone, Deserialize, Serialize)]
#[allow(clippy::enum_variant_names)]
pub enum TsysPaymentsResponse {
AuthResponse(TsysResponseTypes),
SaleResponse(TsysResponseTypes),
CaptureResponse(TsysResponseTypes),
VoidResponse(TsysResponseTypes),
}
fn get_error_response(
connector_response: TsysErrorResponse,
status_code: u16,
) -> router_data::ErrorResponse {
router_data::ErrorResponse {
code: connector_response.response_code,
message: connector_response.response_message.clone(),
reason: Some(connector_response.response_message),
status_code,
attempt_status: None,
connector_transaction_id: None,
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
connector_metadata: None,
}
}
fn get_payments_response(connector_response: TsysResponse) -> PaymentsResponseData {
PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(connector_response.transaction_id.clone()),
redirection_data: Box::new(None),
mandate_reference: Box::new(None),
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: Some(connector_response.transaction_id),
incremental_authorization_allowed: None,
charges: None,
}
}
fn get_payments_sync_response(
connector_response: &TsysPaymentsSyncResponse,
) -> PaymentsResponseData {
PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(
connector_response
.transaction_details
.transaction_id
.clone(),
),
redirection_data: Box::new(None),
mandate_reference: Box::new(None),
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: Some(
connector_response
.transaction_details
.transaction_id
.clone(),
),
incremental_authorization_allowed: None,
charges: None,
}
}
impl<F, T> TryFrom<ResponseRouterData<F, TsysPaymentsResponse, T, PaymentsResponseData>>
for RouterData<F, T, PaymentsResponseData>
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: ResponseRouterData<F, TsysPaymentsResponse, T, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
let (response, status) = match item.response {
TsysPaymentsResponse::AuthResponse(resp) => match resp {
TsysResponseTypes::SuccessResponse(auth_response) => (
Ok(get_payments_response(auth_response)),
enums::AttemptStatus::Authorized,
),
TsysResponseTypes::ErrorResponse(connector_response) => (
Err(get_error_response(connector_response, item.http_code)),
enums::AttemptStatus::AuthorizationFailed,
),
},
TsysPaymentsResponse::SaleResponse(resp) => match resp {
TsysResponseTypes::SuccessResponse(sale_response) => (
Ok(get_payments_response(sale_response)),
enums::AttemptStatus::Charged,
),
TsysResponseTypes::ErrorResponse(connector_response) => (
Err(get_error_response(connector_response, item.http_code)),
enums::AttemptStatus::Failure,
),
},
TsysPaymentsResponse::CaptureResponse(resp) => match resp {
TsysResponseTypes::SuccessResponse(capture_response) => (
Ok(get_payments_response(capture_response)),
enums::AttemptStatus::Charged,
),
TsysResponseTypes::ErrorResponse(connector_response) => (
Err(get_error_response(connector_response, item.http_code)),
enums::AttemptStatus::CaptureFailed,
),
},
TsysPaymentsResponse::VoidResponse(resp) => match resp {
TsysResponseTypes::SuccessResponse(void_response) => (
Ok(get_payments_response(void_response)),
enums::AttemptStatus::Voided,
),
TsysResponseTypes::ErrorResponse(connector_response) => (
Err(get_error_response(connector_response, item.http_code)),
enums::AttemptStatus::VoidFailed,
),
},
};
Ok(Self {
status,
response,
..item.data
})
}
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct TsysSearchTransactionRequest {
#[serde(rename = "deviceID")]
device_id: Secret<String>,
transaction_key: Secret<String>,
#[serde(rename = "transactionID")]
transaction_id: String,
#[serde(rename = "developerID")]
developer_id: Secret<String>,
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "PascalCase")]
pub struct TsysSyncRequest {
search_transaction: TsysSearchTransactionRequest,
}
impl TryFrom<&PaymentsSyncRouterData> for TsysSyncRequest {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(item: &PaymentsSyncRouterData) -> Result<Self, Self::Error> {
let connector_auth: TsysAuthType = TsysAuthType::try_from(&item.connector_auth_type)?;
let search_transaction = TsysSearchTransactionRequest {
device_id: connector_auth.device_id,
transaction_key: connector_auth.transaction_key,
transaction_id: item
.request
.connector_transaction_id
.get_connector_transaction_id()
.change_context(errors::ConnectorError::MissingConnectorTransactionID)?,
developer_id: connector_auth.developer_id,
};
Ok(Self { search_transaction })
}
}
#[derive(Debug, Deserialize, Serialize)]
#[serde(untagged)]
pub enum SearchResponseTypes {
SuccessResponse(TsysPaymentsSyncResponse),
ErrorResponse(TsysErrorResponse),
}
#[derive(Debug, Deserialize, Serialize)]
#[serde(rename_all = "PascalCase")]
pub struct TsysSyncResponse {
search_transaction_response: SearchResponseTypes,
}
impl<F, T> TryFrom<ResponseRouterData<F, TsysSyncResponse, T, PaymentsResponseData>>
for RouterData<F, T, PaymentsResponseData>
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: ResponseRouterData<F, TsysSyncResponse, T, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
let tsys_search_response = item.response.search_transaction_response;
let (response, status) = match tsys_search_response {
SearchResponseTypes::SuccessResponse(search_response) => (
Ok(get_payments_sync_response(&search_response)),
enums::AttemptStatus::from(search_response.transaction_details),
),
SearchResponseTypes::ErrorResponse(connector_response) => (
Err(get_error_response(connector_response, item.http_code)),
item.data.status,
),
};
Ok(Self {
status,
response,
..item.data
})
}
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct TsysCancelRequest {
#[serde(rename = "deviceID")]
device_id: Secret<String>,
transaction_key: Secret<String>,
#[serde(rename = "transactionID")]
transaction_id: String,
#[serde(rename = "developerID")]
developer_id: Secret<String>,
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "PascalCase")]
pub struct TsysPaymentsCancelRequest {
void: TsysCancelRequest,
}
impl TryFrom<&PaymentsCancelRouterData> for TsysPaymentsCancelRequest {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(item: &PaymentsCancelRouterData) -> Result<Self, Self::Error> {
let connector_auth: TsysAuthType = TsysAuthType::try_from(&item.connector_auth_type)?;
let void = TsysCancelRequest {
device_id: connector_auth.device_id,
transaction_key: connector_auth.transaction_key,
transaction_id: item.request.connector_transaction_id.clone(),
developer_id: connector_auth.developer_id,
};
Ok(Self { void })
}
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct TsysCaptureRequest {
#[serde(rename = "deviceID")]
device_id: Secret<String>,
transaction_key: Secret<String>,
transaction_amount: StringMinorUnit,
#[serde(rename = "transactionID")]
transaction_id: String,
#[serde(rename = "developerID")]
developer_id: Secret<String>,
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "PascalCase")]
pub struct TsysPaymentsCaptureRequest {
capture: TsysCaptureRequest,
}
impl TryFrom<&TsysRouterData<&types::PaymentsCaptureRouterData>> for TsysPaymentsCaptureRequest {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item_data: &TsysRouterData<&types::PaymentsCaptureRouterData>,
) -> Result<Self, Self::Error> {
let item = item_data.router_data.clone();
let connector_auth: TsysAuthType = TsysAuthType::try_from(&item.connector_auth_type)?;
let capture = TsysCaptureRequest {
device_id: connector_auth.device_id,
transaction_key: connector_auth.transaction_key,
transaction_id: item.request.connector_transaction_id.clone(),
developer_id: connector_auth.developer_id,
transaction_amount: item_data.amount.clone(),
};
Ok(Self { capture })
}
}
// REFUND :
// Type definition for RefundRequest
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct TsysReturnRequest {
#[serde(rename = "deviceID")]
device_id: Secret<String>,
transaction_key: Secret<String>,
transaction_amount: StringMinorUnit,
#[serde(rename = "transactionID")]
transaction_id: String,
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "PascalCase")]
pub struct TsysRefundRequest {
#[serde(rename = "Return")]
return_request: TsysReturnRequest,
}
impl<F> TryFrom<&TsysRouterData<&RefundsRouterData<F>>> for TsysRefundRequest {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(item_data: &TsysRouterData<&RefundsRouterData<F>>) -> Result<Self, Self::Error> {
let item = item_data.router_data;
let connector_auth: TsysAuthType = TsysAuthType::try_from(&item.connector_auth_type)?;
let return_request = TsysReturnRequest {
device_id: connector_auth.device_id,
transaction_key: connector_auth.transaction_key,
transaction_amount: item_data.amount.clone(),
transaction_id: item.request.connector_transaction_id.clone(),
};
Ok(Self { return_request })
}
}
impl From<TsysPaymentStatus> for enums::RefundStatus {
fn from(item: TsysPaymentStatus) -> Self {
match item {
TsysPaymentStatus::Pass => Self::Success,
TsysPaymentStatus::Fail => Self::Failure,
}
}
}
impl From<TsysTransactionDetails> for enums::RefundStatus {
fn from(item: TsysTransactionDetails) -> Self {
match item.transaction_status {
TsysTransactionStatus::Approved => Self::Pending,
//Connector calls refunds as Void
TsysTransactionStatus::Void => Self::Success,
TsysTransactionStatus::Declined => Self::Failure,
}
}
}
#[derive(Debug, Deserialize, Serialize)]
#[serde(rename_all = "PascalCase")]
pub struct RefundResponse {
return_response: TsysResponseTypes,
}
impl TryFrom<RefundsResponseRouterData<Execute, RefundResponse>> for RefundsRouterData<Execute> {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: RefundsResponseRouterData<Execute, RefundResponse>,
) -> Result<Self, Self::Error> {
let tsys_return_response = item.response.return_response;
let response = match tsys_return_response {
TsysResponseTypes::SuccessResponse(return_response) => Ok(RefundsResponseData {
connector_refund_id: return_response.transaction_id,
refund_status: enums::RefundStatus::from(return_response.status),
}),
TsysResponseTypes::ErrorResponse(connector_response) => {
Err(get_error_response(connector_response, item.http_code))
}
};
Ok(Self {
response,
..item.data
})
}
}
impl TryFrom<&RefundSyncRouterData> for TsysSyncRequest {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(item: &RefundSyncRouterData) -> Result<Self, Self::Error> {
let connector_auth: TsysAuthType = TsysAuthType::try_from(&item.connector_auth_type)?;
let search_transaction = TsysSearchTransactionRequest {
device_id: connector_auth.device_id,
transaction_key: connector_auth.transaction_key,
transaction_id: item.request.get_connector_refund_id()?,
developer_id: connector_auth.developer_id,
};
Ok(Self { search_transaction })
}
}
impl TryFrom<RefundsResponseRouterData<RSync, TsysSyncResponse>> for RefundsRouterData<RSync> {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: RefundsResponseRouterData<RSync, TsysSyncResponse>,
) -> Result<Self, Self::Error> {
let tsys_search_response = item.response.search_transaction_response;
let response = match tsys_search_response {
SearchResponseTypes::SuccessResponse(search_response) => Ok(RefundsResponseData {
connector_refund_id: search_response.transaction_details.transaction_id.clone(),
refund_status: enums::RefundStatus::from(search_response.transaction_details),
}),
SearchResponseTypes::ErrorResponse(connector_response) => {
Err(get_error_response(connector_response, item.http_code))
}
};
Ok(Self {
response,
..item.data
})
}
}
|
{
"crate": "hyperswitch_connectors",
"file": "crates/hyperswitch_connectors/src/connectors/tsys/transformers.rs",
"file_size": null,
"is_async": null,
"is_pub": null,
"num_enums": 6,
"num_structs": 15,
"num_tables": null,
"score": null,
"total_crates": null
}
|
file_hyperswitch_connectors_-3182048256060282358
|
clm
|
file
|
// Repository: hyperswitch
// Crate: hyperswitch_connectors
// File: crates/hyperswitch_connectors/src/connectors/riskified/transformers/api.rs
// Contains: 29 structs, 8 enums
use api_models::{payments::AdditionalPaymentData, webhooks::IncomingWebhookEvent};
use common_enums::{Currency, FraudCheckStatus};
use common_utils::{
ext_traits::ValueExt,
id_type,
pii::Email,
types::{AmountConvertor, StringMajorUnit, StringMajorUnitForConnector},
};
use error_stack::{self, ResultExt};
use hyperswitch_domain_models::{
router_data::RouterData,
router_flow_types::Fulfillment,
router_request_types::{
fraud_check::{FraudCheckFulfillmentData, FulfillmentStatus},
BrowserInformation, ResponseId,
},
router_response_types::fraud_check::FraudCheckResponseData,
};
use hyperswitch_interfaces::errors::ConnectorError;
use masking::Secret;
use serde::{Deserialize, Serialize};
use time::PrimitiveDateTime;
use crate::{
types::{
FrmCheckoutRouterData, FrmFulfillmentRouterData, FrmTransactionRouterData,
ResponseRouterData,
},
utils::{
convert_amount, AddressDetailsData as _, FraudCheckCheckoutRequest,
FraudCheckTransactionRequest, RouterData as _,
},
};
type Error = error_stack::Report<ConnectorError>;
pub struct RiskifiedRouterData<T> {
pub amount: StringMajorUnit,
pub router_data: T,
amount_converter: &'static (dyn AmountConvertor<Output = StringMajorUnit> + Sync),
}
impl<T> From<(StringMajorUnit, T)> for RiskifiedRouterData<T> {
fn from((amount, router_data): (StringMajorUnit, T)) -> Self {
Self {
amount,
router_data,
amount_converter: &StringMajorUnitForConnector,
}
}
}
#[derive(Debug, Deserialize, Serialize, Eq, PartialEq, Clone)]
pub struct RiskifiedPaymentsCheckoutRequest {
order: CheckoutRequest,
}
#[derive(Debug, Deserialize, Serialize, Eq, PartialEq, Clone)]
pub struct CheckoutRequest {
id: String,
note: Option<String>,
email: Option<Email>,
#[serde(with = "common_utils::custom_serde::iso8601")]
created_at: PrimitiveDateTime,
currency: Option<Currency>,
#[serde(with = "common_utils::custom_serde::iso8601")]
updated_at: PrimitiveDateTime,
gateway: Option<String>,
browser_ip: Option<std::net::IpAddr>,
total_price: StringMajorUnit,
total_discounts: i64,
cart_token: String,
referring_site: String,
line_items: Vec<LineItem>,
discount_codes: Vec<DiscountCodes>,
shipping_lines: Vec<ShippingLines>,
payment_details: Option<PaymentDetails>,
customer: RiskifiedCustomer,
billing_address: Option<OrderAddress>,
shipping_address: Option<OrderAddress>,
source: Source,
client_details: ClientDetails,
vendor_name: String,
}
#[derive(Debug, Deserialize, Serialize, Eq, PartialEq, Clone)]
pub struct PaymentDetails {
credit_card_bin: Option<Secret<String>>,
credit_card_number: Option<Secret<String>>,
credit_card_company: Option<api_models::enums::CardNetwork>,
}
#[derive(Debug, Deserialize, Serialize, Eq, PartialEq, Clone)]
pub struct ShippingLines {
price: StringMajorUnit,
title: Option<String>,
}
#[derive(Debug, Deserialize, Serialize, Eq, PartialEq, Clone)]
pub struct DiscountCodes {
amount: StringMajorUnit,
code: Option<String>,
}
#[derive(Debug, Deserialize, Serialize, Eq, PartialEq, Clone)]
pub struct ClientDetails {
user_agent: Option<String>,
accept_language: Option<String>,
}
#[derive(Debug, Deserialize, Serialize, Eq, PartialEq, Clone)]
pub struct RiskifiedCustomer {
email: Option<Email>,
first_name: Option<Secret<String>>,
last_name: Option<Secret<String>>,
#[serde(with = "common_utils::custom_serde::iso8601")]
created_at: PrimitiveDateTime,
verified_email: bool,
id: id_type::CustomerId,
account_type: CustomerAccountType,
orders_count: i32,
phone: Option<Secret<String>>,
}
#[derive(Debug, Deserialize, Serialize, Eq, PartialEq, Clone)]
#[serde(rename_all = "lowercase")]
pub enum CustomerAccountType {
Guest,
}
#[derive(Debug, Deserialize, Serialize, Eq, PartialEq, Clone)]
pub struct OrderAddress {
first_name: Option<Secret<String>>,
last_name: Option<Secret<String>>,
address1: Option<Secret<String>>,
country_code: Option<common_enums::CountryAlpha2>,
city: Option<String>,
province: Option<Secret<String>>,
phone: Option<Secret<String>>,
zip: Option<Secret<String>>,
}
#[derive(Debug, Deserialize, Serialize, Eq, PartialEq, Clone)]
pub struct LineItem {
price: StringMajorUnit,
quantity: i32,
title: String,
product_type: Option<common_enums::ProductType>,
requires_shipping: Option<bool>,
product_id: Option<String>,
category: Option<String>,
brand: Option<String>,
}
#[derive(Debug, Deserialize, Serialize, Eq, PartialEq, Clone)]
#[serde(rename_all = "snake_case")]
pub enum Source {
DesktopWeb,
}
#[derive(Debug, Deserialize, Serialize, Eq, PartialEq, Clone)]
pub struct RiskifiedMetadata {
vendor_name: String,
shipping_lines: Vec<ShippingLines>,
}
impl TryFrom<&RiskifiedRouterData<&FrmCheckoutRouterData>> for RiskifiedPaymentsCheckoutRequest {
type Error = Error;
fn try_from(
payment: &RiskifiedRouterData<&FrmCheckoutRouterData>,
) -> Result<Self, Self::Error> {
let payment_data = payment.router_data.clone();
let metadata: RiskifiedMetadata = payment_data
.frm_metadata
.clone()
.ok_or(ConnectorError::MissingRequiredField {
field_name: "frm_metadata",
})?
.parse_value("Riskified Metadata")
.change_context(ConnectorError::InvalidDataFormat {
field_name: "frm_metadata",
})?;
let billing_address = payment_data.get_billing()?;
let shipping_address = payment_data.get_shipping_address_with_phone_number()?;
let address = payment_data.get_billing_address()?;
let line_items = payment_data
.request
.get_order_details()?
.iter()
.map(|order_detail| {
let price = convert_amount(
payment.amount_converter,
order_detail.amount,
payment_data.request.currency.ok_or_else(|| {
ConnectorError::MissingRequiredField {
field_name: "currency",
}
})?,
)?;
Ok(LineItem {
price,
quantity: i32::from(order_detail.quantity),
title: order_detail.product_name.clone(),
product_type: order_detail.product_type.clone(),
requires_shipping: order_detail.requires_shipping,
product_id: order_detail.product_id.clone(),
category: order_detail.category.clone(),
brand: order_detail.brand.clone(),
})
})
.collect::<Result<Vec<_>, Self::Error>>()?;
Ok(Self {
order: CheckoutRequest {
id: payment_data.attempt_id.clone(),
email: payment_data.request.email.clone(),
created_at: common_utils::date_time::now(),
updated_at: common_utils::date_time::now(),
gateway: payment_data.request.gateway.clone(),
total_price: payment.amount.clone(),
cart_token: payment_data.attempt_id.clone(),
line_items,
source: Source::DesktopWeb,
billing_address: OrderAddress::try_from(billing_address).ok(),
shipping_address: OrderAddress::try_from(shipping_address).ok(),
total_discounts: 0,
currency: payment_data.request.currency,
referring_site: "hyperswitch.io".to_owned(),
discount_codes: Vec::new(),
shipping_lines: metadata.shipping_lines,
customer: RiskifiedCustomer {
email: payment_data.request.email.clone(),
first_name: address.get_first_name().ok().cloned(),
last_name: address.get_last_name().ok().cloned(),
created_at: common_utils::date_time::now(),
verified_email: false,
id: payment_data.get_customer_id()?,
account_type: CustomerAccountType::Guest,
orders_count: 0,
phone: billing_address
.clone()
.phone
.and_then(|phone_data| phone_data.number),
},
browser_ip: payment_data
.request
.browser_info
.as_ref()
.and_then(|browser_info| browser_info.ip_address),
client_details: ClientDetails {
user_agent: payment_data
.request
.browser_info
.as_ref()
.and_then(|browser_info| browser_info.user_agent.clone()),
accept_language: payment_data.request.browser_info.as_ref().and_then(
|browser_info: &BrowserInformation| browser_info.language.clone(),
),
},
note: payment_data.description.clone(),
vendor_name: metadata.vendor_name,
payment_details: match payment_data.request.payment_method_data.as_ref() {
Some(AdditionalPaymentData::Card(card_info)) => Some(PaymentDetails {
credit_card_bin: card_info.card_isin.clone().map(Secret::new),
credit_card_number: card_info
.last4
.clone()
.map(|last_four| format!("XXXX-XXXX-XXXX-{last_four}"))
.map(Secret::new),
credit_card_company: card_info.card_network.clone(),
}),
Some(_) | None => None,
},
},
})
}
}
#[derive(Debug, Deserialize, Serialize, Eq, PartialEq, Clone)]
pub struct RiskifiedPaymentsResponse {
order: OrderResponse,
}
#[derive(Debug, Deserialize, Serialize, Eq, PartialEq, Clone)]
pub struct OrderResponse {
id: String,
status: PaymentStatus,
description: Option<String>,
}
#[derive(Debug, Deserialize, Serialize, Eq, PartialEq, Clone)]
pub struct RiskifiedFulfilmentResponse {
order: OrderFulfilmentResponse,
}
#[derive(Debug, Deserialize, Serialize, Eq, PartialEq, Clone)]
pub struct OrderFulfilmentResponse {
id: String,
}
#[derive(Debug, Deserialize, Serialize, Eq, PartialEq, Clone)]
#[serde(rename_all = "lowercase")]
pub enum FulfilmentStatus {
Fulfilled,
}
#[derive(Debug, Deserialize, Serialize, Eq, PartialEq, Clone)]
#[serde(rename_all = "lowercase")]
pub enum PaymentStatus {
Captured,
Created,
Submitted,
Approved,
Declined,
Processing,
}
impl<F, T> TryFrom<ResponseRouterData<F, RiskifiedPaymentsResponse, T, FraudCheckResponseData>>
for RouterData<F, T, FraudCheckResponseData>
{
type Error = Error;
fn try_from(
item: ResponseRouterData<F, RiskifiedPaymentsResponse, T, FraudCheckResponseData>,
) -> Result<Self, Self::Error> {
Ok(Self {
response: Ok(FraudCheckResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(item.response.order.id),
status: FraudCheckStatus::from(item.response.order.status),
connector_metadata: None,
score: None,
reason: item.response.order.description.map(serde_json::Value::from),
}),
..item.data
})
}
}
impl From<PaymentStatus> for FraudCheckStatus {
fn from(item: PaymentStatus) -> Self {
match item {
PaymentStatus::Approved => Self::Legit,
PaymentStatus::Declined => Self::Fraud,
_ => Self::Pending,
}
}
}
#[derive(Debug, Deserialize, Serialize, Eq, PartialEq, Clone)]
pub struct TransactionFailedRequest {
checkout: FailedTransactionData,
}
#[derive(Debug, Deserialize, Serialize, Eq, PartialEq, Clone)]
pub struct FailedTransactionData {
id: String,
payment_details: Vec<DeclinedPaymentDetails>,
}
#[derive(Debug, Deserialize, Serialize, Eq, PartialEq, Clone)]
pub struct DeclinedPaymentDetails {
authorization_error: AuthorizationError,
}
#[derive(Debug, Deserialize, Serialize, Eq, PartialEq, Clone)]
pub struct AuthorizationError {
#[serde(with = "common_utils::custom_serde::iso8601")]
created_at: PrimitiveDateTime,
error_code: Option<String>,
message: Option<String>,
}
impl TryFrom<&FrmTransactionRouterData> for TransactionFailedRequest {
type Error = Error;
fn try_from(item: &FrmTransactionRouterData) -> Result<Self, Self::Error> {
Ok(Self {
checkout: FailedTransactionData {
id: item.attempt_id.clone(),
payment_details: [DeclinedPaymentDetails {
authorization_error: AuthorizationError {
created_at: common_utils::date_time::now(),
error_code: item.request.error_code.clone(),
message: item.request.error_message.clone(),
},
}]
.to_vec(),
},
})
}
}
#[derive(Debug, Deserialize, Serialize, Eq, PartialEq, Clone)]
pub struct RiskifiedFailedTransactionResponse {
checkout: OrderResponse,
}
#[derive(Debug, Deserialize, Serialize, Eq, PartialEq, Clone)]
#[serde(untagged)]
pub enum RiskifiedTransactionResponse {
FailedResponse(RiskifiedFailedTransactionResponse),
SuccessResponse(RiskifiedPaymentsResponse),
}
impl<F, T>
TryFrom<ResponseRouterData<F, RiskifiedFailedTransactionResponse, T, FraudCheckResponseData>>
for RouterData<F, T, FraudCheckResponseData>
{
type Error = Error;
fn try_from(
item: ResponseRouterData<F, RiskifiedFailedTransactionResponse, T, FraudCheckResponseData>,
) -> Result<Self, Self::Error> {
Ok(Self {
response: Ok(FraudCheckResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(item.response.checkout.id),
status: FraudCheckStatus::from(item.response.checkout.status),
connector_metadata: None,
score: None,
reason: item
.response
.checkout
.description
.map(serde_json::Value::from),
}),
..item.data
})
}
}
#[derive(Debug, Deserialize, Serialize, Eq, PartialEq, Clone)]
pub struct TransactionSuccessRequest {
order: SuccessfulTransactionData,
}
#[derive(Debug, Deserialize, Serialize, Eq, PartialEq, Clone)]
pub struct SuccessfulTransactionData {
id: String,
decision: TransactionDecisionData,
}
#[derive(Debug, Deserialize, Serialize, Eq, PartialEq, Clone)]
pub struct TransactionDecisionData {
external_status: TransactionStatus,
reason: Option<String>,
amount: StringMajorUnit,
currency: Currency,
#[serde(with = "common_utils::custom_serde::iso8601")]
decided_at: PrimitiveDateTime,
payment_details: Vec<TransactionPaymentDetails>,
}
#[derive(Debug, Deserialize, Serialize, Eq, PartialEq, Clone)]
pub struct TransactionPaymentDetails {
authorization_id: Option<String>,
}
#[derive(Debug, Deserialize, Serialize, Eq, PartialEq, Clone)]
#[serde(rename_all = "lowercase")]
pub enum TransactionStatus {
Approved,
}
impl TryFrom<&RiskifiedRouterData<&FrmTransactionRouterData>> for TransactionSuccessRequest {
type Error = Error;
fn try_from(
item_data: &RiskifiedRouterData<&FrmTransactionRouterData>,
) -> Result<Self, Self::Error> {
let item = item_data.router_data.clone();
Ok(Self {
order: SuccessfulTransactionData {
id: item.attempt_id.clone(),
decision: TransactionDecisionData {
external_status: TransactionStatus::Approved,
reason: None,
amount: item_data.amount.clone(),
currency: item.request.get_currency()?,
decided_at: common_utils::date_time::now(),
payment_details: [TransactionPaymentDetails {
authorization_id: item.request.connector_transaction_id.clone(),
}]
.to_vec(),
},
},
})
}
}
#[derive(Debug, Deserialize, Serialize, Eq, PartialEq, Clone)]
pub struct RiskifiedFulfillmentRequest {
order: OrderFulfillment,
}
#[derive(Debug, Deserialize, Serialize, Eq, PartialEq, Clone)]
#[serde(rename_all = "lowercase")]
pub enum FulfillmentRequestStatus {
Success,
Cancelled,
Error,
Failure,
}
#[derive(Debug, Deserialize, Serialize, Eq, PartialEq, Clone)]
pub struct OrderFulfillment {
id: String,
fulfillments: FulfilmentData,
}
#[derive(Debug, Deserialize, Serialize, Eq, PartialEq, Clone)]
pub struct FulfilmentData {
fulfillment_id: String,
#[serde(with = "common_utils::custom_serde::iso8601")]
created_at: PrimitiveDateTime,
status: Option<FulfillmentRequestStatus>,
tracking_company: String,
tracking_number: String,
tracking_url: Option<String>,
}
impl TryFrom<&FrmFulfillmentRouterData> for RiskifiedFulfillmentRequest {
type Error = Error;
fn try_from(item: &FrmFulfillmentRouterData) -> Result<Self, Self::Error> {
let tracking_number = item
.request
.fulfillment_req
.tracking_numbers
.as_ref()
.and_then(|numbers| numbers.first().cloned())
.ok_or(ConnectorError::MissingRequiredField {
field_name: "tracking_number",
})?;
let tracking_url = item
.request
.fulfillment_req
.tracking_urls
.as_ref()
.and_then(|urls| urls.first().cloned().map(|url| url.to_string()));
Ok(Self {
order: OrderFulfillment {
id: item.attempt_id.clone(),
fulfillments: FulfilmentData {
fulfillment_id: item.payment_id.clone(),
created_at: common_utils::date_time::now(),
status: item
.request
.fulfillment_req
.fulfillment_status
.clone()
.and_then(get_fulfillment_status),
tracking_company: item
.request
.fulfillment_req
.tracking_company
.clone()
.ok_or(ConnectorError::MissingRequiredField {
field_name: "tracking_company",
})?,
tracking_number,
tracking_url,
},
},
})
}
}
impl
TryFrom<
ResponseRouterData<
Fulfillment,
RiskifiedFulfilmentResponse,
FraudCheckFulfillmentData,
FraudCheckResponseData,
>,
> for RouterData<Fulfillment, FraudCheckFulfillmentData, FraudCheckResponseData>
{
type Error = Error;
fn try_from(
item: ResponseRouterData<
Fulfillment,
RiskifiedFulfilmentResponse,
FraudCheckFulfillmentData,
FraudCheckResponseData,
>,
) -> Result<Self, Self::Error> {
Ok(Self {
response: Ok(FraudCheckResponseData::FulfillmentResponse {
order_id: item.response.order.id,
shipment_ids: Vec::new(),
}),
..item.data
})
}
}
#[derive(Debug, Deserialize, Serialize, Eq, PartialEq, Clone)]
pub struct ErrorResponse {
pub error: ErrorData,
}
#[derive(Debug, Deserialize, Serialize, Eq, PartialEq, Clone)]
pub struct ErrorData {
pub message: String,
}
impl TryFrom<&hyperswitch_domain_models::address::Address> for OrderAddress {
type Error = Error;
fn try_from(
address_info: &hyperswitch_domain_models::address::Address,
) -> Result<Self, Self::Error> {
let address = address_info
.clone()
.address
.ok_or(ConnectorError::MissingRequiredField {
field_name: "address",
})?;
Ok(Self {
first_name: address.first_name.clone(),
last_name: address.last_name.clone(),
address1: address.line1.clone(),
country_code: address.country,
city: address.city.clone(),
province: address.state.clone(),
zip: address.zip.clone(),
phone: address_info
.phone
.clone()
.and_then(|phone_data| phone_data.number),
})
}
}
fn get_fulfillment_status(status: FulfillmentStatus) -> Option<FulfillmentRequestStatus> {
match status {
FulfillmentStatus::COMPLETE => Some(FulfillmentRequestStatus::Success),
FulfillmentStatus::CANCELED => Some(FulfillmentRequestStatus::Cancelled),
FulfillmentStatus::PARTIAL | FulfillmentStatus::REPLACEMENT => None,
}
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct RiskifiedWebhookBody {
pub id: String,
pub status: RiskifiedWebhookStatus,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub enum RiskifiedWebhookStatus {
Approved,
Declined,
}
impl From<RiskifiedWebhookStatus> for IncomingWebhookEvent {
fn from(value: RiskifiedWebhookStatus) -> Self {
match value {
RiskifiedWebhookStatus::Declined => Self::FrmRejected,
RiskifiedWebhookStatus::Approved => Self::FrmApproved,
}
}
}
|
{
"crate": "hyperswitch_connectors",
"file": "crates/hyperswitch_connectors/src/connectors/riskified/transformers/api.rs",
"file_size": null,
"is_async": null,
"is_pub": null,
"num_enums": 8,
"num_structs": 29,
"num_tables": null,
"score": null,
"total_crates": null
}
|
file_hyperswitch_connectors_5363447702411295057
|
clm
|
file
|
// Repository: hyperswitch
// Crate: hyperswitch_connectors
// File: crates/hyperswitch_connectors/src/connectors/klarna/transformers.rs
// Contains: 22 structs, 8 enums
use api_models::payments::{KlarnaSessionTokenResponse, SessionToken};
use common_enums::enums;
use common_utils::{pii, types::MinorUnit};
use error_stack::{report, ResultExt};
use hyperswitch_domain_models::{
payment_method_data::{PayLaterData, PaymentMethodData},
router_data::{
AdditionalPaymentMethodConnectorResponse, ConnectorAuthType, ConnectorResponseData,
KlarnaSdkResponse, RouterData,
},
router_flow_types::refunds::{Execute, RSync},
router_request_types::{PaymentsCaptureData, ResponseId},
router_response_types::{PaymentsResponseData, RedirectForm, RefundsResponseData},
types,
};
use hyperswitch_interfaces::errors;
use masking::{ExposeInterface, Secret};
use serde::{Deserialize, Serialize};
use crate::{
types::{
PaymentsResponseRouterData, PaymentsSessionResponseRouterData, RefundsResponseRouterData,
ResponseRouterData,
},
utils::{self, AddressData, AddressDetailsData, PaymentsAuthorizeRequestData, RouterData as _},
};
#[derive(Debug, Serialize)]
pub struct KlarnaRouterData<T> {
amount: MinorUnit,
router_data: T,
}
impl<T> From<(MinorUnit, T)> for KlarnaRouterData<T> {
fn from((amount, router_data): (MinorUnit, T)) -> Self {
Self {
amount,
router_data,
}
}
}
#[derive(Debug, Serialize, Deserialize)]
pub struct KlarnaConnectorMetadataObject {
pub klarna_region: Option<KlarnaEndpoint>,
}
#[derive(Debug, Serialize, Deserialize)]
pub enum KlarnaEndpoint {
Europe,
NorthAmerica,
Oceania,
}
impl From<KlarnaEndpoint> for String {
fn from(endpoint: KlarnaEndpoint) -> Self {
Self::from(match endpoint {
KlarnaEndpoint::Europe => "",
KlarnaEndpoint::NorthAmerica => "-na",
KlarnaEndpoint::Oceania => "-oc",
})
}
}
impl TryFrom<&Option<pii::SecretSerdeValue>> for KlarnaConnectorMetadataObject {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(meta_data: &Option<pii::SecretSerdeValue>) -> Result<Self, Self::Error> {
let metadata: Self = utils::to_connector_meta_from_secret::<Self>(meta_data.clone())
.change_context(errors::ConnectorError::InvalidConnectorConfig {
config: "metadata",
})?;
Ok(metadata)
}
}
#[derive(Debug, Serialize, Deserialize)]
#[serde(untagged)]
pub enum PaymentMethodSpecifics {
KlarnaCheckout(KlarnaCheckoutRequestData),
KlarnaSdk,
}
#[derive(Default, Debug, Serialize, Deserialize)]
pub struct MerchantURLs {
terms: String,
checkout: String,
confirmation: String,
push: String,
}
#[derive(Default, Debug, Serialize, Deserialize)]
pub struct KlarnaCheckoutRequestData {
merchant_urls: MerchantURLs,
options: CheckoutOptions,
}
#[derive(Default, Debug, Deserialize, Serialize)]
pub struct KlarnaPaymentsRequest {
order_lines: Vec<OrderLines>,
order_amount: MinorUnit,
purchase_country: enums::CountryAlpha2,
purchase_currency: enums::Currency,
merchant_reference1: Option<String>,
merchant_reference2: Option<String>,
shipping_address: Option<KlarnaShippingAddress>,
auto_capture: Option<bool>,
order_tax_amount: Option<MinorUnit>,
#[serde(flatten)]
payment_method_specifics: Option<PaymentMethodSpecifics>,
}
#[derive(Debug, Deserialize, Serialize)]
#[serde(untagged)]
pub enum KlarnaAuthResponse {
KlarnaPaymentsAuthResponse(PaymentsResponse),
KlarnaCheckoutAuthResponse(CheckoutResponse),
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct PaymentsResponse {
order_id: String,
fraud_status: KlarnaFraudStatus,
authorized_payment_method: Option<AuthorizedPaymentMethod>,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct CheckoutResponse {
order_id: String,
status: KlarnaCheckoutStatus,
html_snippet: String,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct AuthorizedPaymentMethod {
#[serde(rename = "type")]
payment_type: String,
}
impl From<AuthorizedPaymentMethod> for AdditionalPaymentMethodConnectorResponse {
fn from(item: AuthorizedPaymentMethod) -> Self {
Self::PayLater {
klarna_sdk: Some(KlarnaSdkResponse {
payment_type: Some(item.payment_type),
}),
}
}
}
#[derive(Debug, Serialize)]
pub struct KlarnaSessionRequest {
intent: KlarnaSessionIntent,
purchase_country: enums::CountryAlpha2,
purchase_currency: enums::Currency,
order_amount: MinorUnit,
order_lines: Vec<OrderLines>,
shipping_address: Option<KlarnaShippingAddress>,
}
#[derive(Debug, Serialize, Deserialize)]
pub struct KlarnaShippingAddress {
city: String,
country: enums::CountryAlpha2,
email: pii::Email,
given_name: Secret<String>,
family_name: Secret<String>,
phone: Secret<String>,
postal_code: Secret<String>,
region: Secret<String>,
street_address: Secret<String>,
street_address2: Option<Secret<String>>,
}
#[derive(Default, Debug, Serialize, Deserialize)]
pub struct CheckoutOptions {
auto_capture: bool,
}
#[derive(Deserialize, Serialize, Debug)]
pub struct KlarnaSessionResponse {
pub client_token: Secret<String>,
pub session_id: String,
}
impl TryFrom<&KlarnaRouterData<&types::PaymentsSessionRouterData>> for KlarnaSessionRequest {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: &KlarnaRouterData<&types::PaymentsSessionRouterData>,
) -> Result<Self, Self::Error> {
let request = &item.router_data.request;
match request.order_details.clone() {
Some(order_details) => Ok(Self {
intent: KlarnaSessionIntent::Buy,
purchase_country: request.country.ok_or(
errors::ConnectorError::MissingRequiredField {
field_name: "billing.address.country",
},
)?,
purchase_currency: request.currency,
order_amount: item.amount,
order_lines: order_details
.iter()
.map(|data| OrderLines {
name: data.product_name.clone(),
quantity: data.quantity,
unit_price: data.amount,
total_amount: data.amount * data.quantity,
total_tax_amount: None,
tax_rate: None,
})
.collect(),
shipping_address: get_address_info(item.router_data.get_optional_shipping())
.transpose()?,
}),
None => Err(report!(errors::ConnectorError::MissingRequiredField {
field_name: "order_details",
})),
}
}
}
impl TryFrom<PaymentsSessionResponseRouterData<KlarnaSessionResponse>>
for types::PaymentsSessionRouterData
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: PaymentsSessionResponseRouterData<KlarnaSessionResponse>,
) -> Result<Self, Self::Error> {
let response = &item.response;
Ok(Self {
response: Ok(PaymentsResponseData::SessionResponse {
session_token: SessionToken::Klarna(Box::new(KlarnaSessionTokenResponse {
session_token: response.client_token.clone().expose(),
session_id: response.session_id.clone(),
})),
}),
..item.data
})
}
}
impl TryFrom<&KlarnaRouterData<&types::PaymentsAuthorizeRouterData>> for KlarnaPaymentsRequest {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: &KlarnaRouterData<&types::PaymentsAuthorizeRouterData>,
) -> Result<Self, Self::Error> {
let request = &item.router_data.request;
let payment_method_data = request.payment_method_data.clone();
let return_url = item.router_data.request.get_router_return_url()?;
let webhook_url = item.router_data.request.get_webhook_url()?;
match payment_method_data {
PaymentMethodData::PayLater(PayLaterData::KlarnaSdk { .. }) => {
match request.order_details.clone() {
Some(order_details) => Ok(Self {
purchase_country: item.router_data.get_billing_country()?,
purchase_currency: request.currency,
order_amount: item.amount,
order_lines: order_details
.iter()
.map(|data| OrderLines {
name: data.product_name.clone(),
quantity: data.quantity,
unit_price: data.amount,
total_amount: data.amount * data.quantity,
total_tax_amount: None,
tax_rate: None,
})
.collect(),
merchant_reference1: Some(
item.router_data.connector_request_reference_id.clone(),
),
merchant_reference2: item
.router_data
.request
.merchant_order_reference_id
.clone(),
auto_capture: Some(request.is_auto_capture()?),
shipping_address: get_address_info(
item.router_data.get_optional_shipping(),
)
.transpose()?,
order_tax_amount: None,
payment_method_specifics: None,
}),
None => Err(report!(errors::ConnectorError::MissingRequiredField {
field_name: "order_details"
})),
}
}
PaymentMethodData::PayLater(PayLaterData::KlarnaRedirect {}) => {
match request.order_details.clone() {
Some(order_details) => Ok(Self {
purchase_country: item.router_data.get_billing_country()?,
purchase_currency: request.currency,
order_amount: item.amount
- request.order_tax_amount.unwrap_or(MinorUnit::zero()),
order_tax_amount: request.order_tax_amount,
order_lines: order_details
.iter()
.map(|data| OrderLines {
name: data.product_name.clone(),
quantity: data.quantity,
unit_price: data.amount,
total_amount: data.amount * data.quantity,
total_tax_amount: data.total_tax_amount,
tax_rate: data.tax_rate,
})
.collect(),
payment_method_specifics: Some(PaymentMethodSpecifics::KlarnaCheckout(
KlarnaCheckoutRequestData {
merchant_urls: MerchantURLs {
terms: return_url.clone(),
checkout: return_url.clone(),
confirmation: return_url,
push: webhook_url,
},
options: CheckoutOptions {
auto_capture: request.is_auto_capture()?,
},
},
)),
shipping_address: get_address_info(
item.router_data.get_optional_shipping(),
)
.transpose()?,
merchant_reference1: Some(
item.router_data.connector_request_reference_id.clone(),
),
merchant_reference2: item
.router_data
.request
.merchant_order_reference_id
.clone(),
auto_capture: None,
}),
None => Err(report!(errors::ConnectorError::MissingRequiredField {
field_name: "order_details"
})),
}
}
_ => Err(errors::ConnectorError::NotImplemented("Payment method".to_string()).into()),
}
}
}
fn get_address_info(
address: Option<&hyperswitch_domain_models::address::Address>,
) -> Option<Result<KlarnaShippingAddress, error_stack::Report<errors::ConnectorError>>> {
address.and_then(|add| {
add.address.as_ref().map(
|address_details| -> Result<KlarnaShippingAddress, error_stack::Report<errors::ConnectorError>> {
Ok(KlarnaShippingAddress {
city: address_details.get_city()?.to_owned(),
country: address_details.get_country()?.to_owned(),
email: add.get_email()?.to_owned(),
postal_code: address_details.get_zip()?.to_owned(),
region: address_details.to_state_code()?.to_owned(),
street_address: address_details.get_line1()?.to_owned(),
street_address2: address_details.get_optional_line2(),
given_name: address_details.get_first_name()?.to_owned(),
family_name: address_details.get_last_name()?.to_owned(),
phone: add.get_phone_with_country_code()?.to_owned(),
})
},
)
})
}
impl TryFrom<PaymentsResponseRouterData<KlarnaAuthResponse>>
for types::PaymentsAuthorizeRouterData
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(item: PaymentsResponseRouterData<KlarnaAuthResponse>) -> Result<Self, Self::Error> {
match item.response {
KlarnaAuthResponse::KlarnaPaymentsAuthResponse(ref response) => {
let connector_response =
response
.authorized_payment_method
.as_ref()
.map(|authorized_payment_method| {
ConnectorResponseData::with_additional_payment_method_data(
AdditionalPaymentMethodConnectorResponse::from(
authorized_payment_method.clone(),
),
)
});
Ok(Self {
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(response.order_id.clone()),
redirection_data: Box::new(None),
mandate_reference: Box::new(None),
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: Some(response.order_id.clone()),
incremental_authorization_allowed: None,
charges: None,
}),
status: get_fraud_status(
response.fraud_status.clone(),
item.data.request.is_auto_capture()?,
),
connector_response,
..item.data
})
}
KlarnaAuthResponse::KlarnaCheckoutAuthResponse(ref response) => Ok(Self {
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(response.order_id.clone()),
redirection_data: Box::new(Some(RedirectForm::Html {
html_data: response.html_snippet.clone(),
})),
mandate_reference: Box::new(None),
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: Some(response.order_id.clone()),
incremental_authorization_allowed: None,
charges: None,
}),
status: get_checkout_status(
response.status.clone(),
item.data.request.is_auto_capture()?,
),
connector_response: None,
..item.data
}),
}
}
}
#[derive(Default, Debug, Serialize, Deserialize)]
pub struct OrderLines {
name: String,
quantity: u16,
unit_price: MinorUnit,
total_amount: MinorUnit,
total_tax_amount: Option<MinorUnit>,
tax_rate: Option<f64>,
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "snake_case")]
#[allow(dead_code)]
pub enum KlarnaSessionIntent {
Buy,
Tokenize,
BuyAndTokenize,
}
pub struct KlarnaAuthType {
pub username: Secret<String>,
pub password: Secret<String>,
}
impl TryFrom<&ConnectorAuthType> for KlarnaAuthType {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(auth_type: &ConnectorAuthType) -> Result<Self, Self::Error> {
if let ConnectorAuthType::BodyKey { api_key, key1 } = auth_type {
Ok(Self {
username: key1.to_owned(),
password: api_key.to_owned(),
})
} else {
Err(errors::ConnectorError::FailedToObtainAuthType.into())
}
}
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "UPPERCASE")]
pub enum KlarnaFraudStatus {
Accepted,
Pending,
Rejected,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum KlarnaCheckoutStatus {
CheckoutComplete,
CheckoutIncomplete,
}
fn get_fraud_status(
klarna_status: KlarnaFraudStatus,
is_auto_capture: bool,
) -> common_enums::AttemptStatus {
match klarna_status {
KlarnaFraudStatus::Accepted => {
if is_auto_capture {
common_enums::AttemptStatus::Charged
} else {
common_enums::AttemptStatus::Authorized
}
}
KlarnaFraudStatus::Pending => common_enums::AttemptStatus::Pending,
KlarnaFraudStatus::Rejected => common_enums::AttemptStatus::Failure,
}
}
fn get_checkout_status(
klarna_status: KlarnaCheckoutStatus,
is_auto_capture: bool,
) -> common_enums::AttemptStatus {
match klarna_status {
KlarnaCheckoutStatus::CheckoutIncomplete => {
if is_auto_capture {
common_enums::AttemptStatus::AuthenticationPending
} else {
common_enums::AttemptStatus::Authorized
}
}
KlarnaCheckoutStatus::CheckoutComplete => common_enums::AttemptStatus::Charged,
}
}
#[derive(Debug, Deserialize, Serialize)]
#[serde(untagged)]
pub enum KlarnaPsyncResponse {
KlarnaSDKPsyncResponse(KlarnaSDKSyncResponse),
KlarnaCheckoutPSyncResponse(KlarnaCheckoutSyncResponse),
}
#[derive(Debug, Serialize, Deserialize)]
pub struct KlarnaSDKSyncResponse {
pub order_id: String,
pub status: KlarnaPaymentStatus,
pub klarna_reference: Option<String>,
}
#[derive(Debug, Serialize, Deserialize)]
pub struct KlarnaCheckoutSyncResponse {
pub order_id: String,
pub status: KlarnaCheckoutStatus,
pub options: CheckoutOptions,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
pub enum KlarnaPaymentStatus {
Authorized,
PartCaptured,
Captured,
Cancelled,
Expired,
Closed,
}
impl From<KlarnaPaymentStatus> for enums::AttemptStatus {
fn from(item: KlarnaPaymentStatus) -> Self {
match item {
KlarnaPaymentStatus::Authorized => Self::Authorized,
KlarnaPaymentStatus::PartCaptured => Self::PartialCharged,
KlarnaPaymentStatus::Captured => Self::Charged,
KlarnaPaymentStatus::Cancelled => Self::Voided,
KlarnaPaymentStatus::Expired | KlarnaPaymentStatus::Closed => Self::Failure,
}
}
}
impl<F, T> TryFrom<ResponseRouterData<F, KlarnaPsyncResponse, T, PaymentsResponseData>>
for RouterData<F, T, PaymentsResponseData>
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: ResponseRouterData<F, KlarnaPsyncResponse, T, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
match item.response {
KlarnaPsyncResponse::KlarnaSDKPsyncResponse(response) => Ok(Self {
status: enums::AttemptStatus::from(response.status),
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(response.order_id.clone()),
redirection_data: Box::new(None),
mandate_reference: Box::new(None),
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: response
.klarna_reference
.or(Some(response.order_id.clone())),
incremental_authorization_allowed: None,
charges: None,
}),
..item.data
}),
KlarnaPsyncResponse::KlarnaCheckoutPSyncResponse(response) => Ok(Self {
status: get_checkout_status(response.status.clone(), response.options.auto_capture),
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(response.order_id.clone()),
redirection_data: Box::new(None),
mandate_reference: Box::new(None),
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: Some(response.order_id.clone()),
incremental_authorization_allowed: None,
charges: None,
}),
..item.data
}),
}
}
}
#[derive(Debug, Serialize)]
pub struct KlarnaCaptureRequest {
captured_amount: MinorUnit,
reference: Option<String>,
}
impl TryFrom<&KlarnaRouterData<&types::PaymentsCaptureRouterData>> for KlarnaCaptureRequest {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: &KlarnaRouterData<&types::PaymentsCaptureRouterData>,
) -> Result<Self, Self::Error> {
let reference = Some(item.router_data.connector_request_reference_id.clone());
Ok(Self {
reference,
captured_amount: item.amount.to_owned(),
})
}
}
#[derive(Debug, Serialize, Deserialize)]
pub struct KlarnaMeta {
capture_id: Option<String>,
}
#[derive(Debug, Serialize, Deserialize)]
pub struct KlarnaCaptureResponse {
pub capture_id: Option<String>,
}
impl<F>
TryFrom<ResponseRouterData<F, KlarnaCaptureResponse, PaymentsCaptureData, PaymentsResponseData>>
for RouterData<F, PaymentsCaptureData, PaymentsResponseData>
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: ResponseRouterData<
F,
KlarnaCaptureResponse,
PaymentsCaptureData,
PaymentsResponseData,
>,
) -> Result<Self, Self::Error> {
let connector_meta = serde_json::json!(KlarnaMeta {
capture_id: item.response.capture_id,
});
// https://docs.klarna.com/api/ordermanagement/#operation/captureOrder
// If 201 status code, then order is captured, other status codes are handled by the error handler
let status = if item.http_code == 201 {
enums::AttemptStatus::Charged
} else {
item.data.status
};
let resource_id = item.data.request.connector_transaction_id.clone();
Ok(Self {
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(resource_id),
redirection_data: Box::new(None),
mandate_reference: Box::new(None),
connector_metadata: Some(connector_meta),
network_txn_id: None,
connector_response_reference_id: None,
incremental_authorization_allowed: None,
charges: None,
}),
status,
..item.data
})
}
}
#[derive(Default, Debug, Serialize)]
pub struct KlarnaRefundRequest {
refunded_amount: MinorUnit,
reference: Option<String>,
}
impl<F> TryFrom<&KlarnaRouterData<&types::RefundsRouterData<F>>> for KlarnaRefundRequest {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: &KlarnaRouterData<&types::RefundsRouterData<F>>,
) -> Result<Self, Self::Error> {
let request = &item.router_data.request;
Ok(Self {
refunded_amount: item.amount,
reference: Some(request.refund_id.clone()),
})
}
}
#[derive(Debug, Deserialize, Serialize)]
pub struct KlarnaRefundResponse {
pub refund_id: String,
}
impl TryFrom<RefundsResponseRouterData<Execute, KlarnaRefundResponse>>
for types::RefundsRouterData<Execute>
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: RefundsResponseRouterData<Execute, KlarnaRefundResponse>,
) -> Result<Self, Self::Error> {
// https://docs.klarna.com/api/ordermanagement/#operation/refundOrder
// If 201 status code, then Refund is Successful, other status codes are handled by the error handler
let status = if item.http_code == 201 {
enums::RefundStatus::Pending
} else {
enums::RefundStatus::Failure
};
Ok(Self {
response: Ok(RefundsResponseData {
connector_refund_id: item.response.refund_id,
refund_status: status,
}),
..item.data
})
}
}
#[derive(Debug, Deserialize, Serialize)]
pub struct KlarnaRefundSyncResponse {
pub refund_id: String,
}
impl TryFrom<RefundsResponseRouterData<RSync, KlarnaRefundSyncResponse>>
for types::RefundsRouterData<RSync>
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: RefundsResponseRouterData<RSync, KlarnaRefundSyncResponse>,
) -> Result<Self, Self::Error> {
// https://docs.klarna.com/api/ordermanagement/#operation/get
// If 200 status code, then Refund is Successful, other status codes are handled by the error handler
let status = if item.http_code == 200 {
enums::RefundStatus::Success
} else {
enums::RefundStatus::Failure
};
Ok(Self {
response: Ok(RefundsResponseData {
connector_refund_id: item.response.refund_id,
refund_status: status,
}),
..item.data
})
}
}
#[derive(Deserialize, Serialize, Debug)]
pub struct KlarnaErrorResponse {
pub error_code: String,
pub error_messages: Option<Vec<String>>,
pub error_message: Option<String>,
}
|
{
"crate": "hyperswitch_connectors",
"file": "crates/hyperswitch_connectors/src/connectors/klarna/transformers.rs",
"file_size": null,
"is_async": null,
"is_pub": null,
"num_enums": 8,
"num_structs": 22,
"num_tables": null,
"score": null,
"total_crates": null
}
|
file_hyperswitch_connectors_3599312362282887052
|
clm
|
file
|
// Repository: hyperswitch
// Crate: hyperswitch_connectors
// File: crates/hyperswitch_connectors/src/connectors/chargebee/transformers.rs
// Contains: 42 structs, 15 enums
#[cfg(all(feature = "revenue_recovery", feature = "v2"))]
use std::str::FromStr;
use common_enums::{connector_enums, enums};
use common_utils::{
errors::CustomResult,
ext_traits::ByteSliceExt,
id_type::{CustomerId, InvoiceId, SubscriptionId},
pii::{self, Email},
types::MinorUnit,
};
use error_stack::ResultExt;
#[cfg(all(feature = "revenue_recovery", feature = "v2"))]
use hyperswitch_domain_models::revenue_recovery;
use hyperswitch_domain_models::{
payment_method_data::PaymentMethodData,
router_data::{ConnectorAuthType, RouterData},
router_flow_types::{
refunds::{Execute, RSync},
subscriptions::SubscriptionCreate,
CreateConnectorCustomer, InvoiceRecordBack,
},
router_request_types::{
revenue_recovery::InvoiceRecordBackRequest,
subscriptions::{SubscriptionAutoCollection, SubscriptionCreateRequest},
ConnectorCustomerData, ResponseId,
},
router_response_types::{
revenue_recovery::InvoiceRecordBackResponse,
subscriptions::{
self, GetSubscriptionEstimateResponse, GetSubscriptionPlanPricesResponse,
GetSubscriptionPlansResponse, SubscriptionCreateResponse, SubscriptionInvoiceData,
SubscriptionLineItem, SubscriptionStatus,
},
ConnectorCustomerResponseData, PaymentsResponseData, RefundsResponseData,
},
types::{
GetSubscriptionEstimateRouterData, InvoiceRecordBackRouterData,
PaymentsAuthorizeRouterData, RefundsRouterData,
},
};
use hyperswitch_interfaces::errors;
use masking::{ExposeInterface, Secret};
use serde::{Deserialize, Serialize};
use time::PrimitiveDateTime;
use crate::{
types::{RefundsResponseRouterData, ResponseRouterData},
utils::{self, PaymentsAuthorizeRequestData, RouterData as OtherRouterData},
};
// SubscriptionCreate structures
#[derive(Debug, Serialize)]
pub struct ChargebeeSubscriptionCreateRequest {
#[serde(rename = "id")]
pub subscription_id: SubscriptionId,
#[serde(rename = "subscription_items[item_price_id][0]")]
pub item_price_id: String,
#[serde(rename = "subscription_items[quantity][0]")]
pub quantity: Option<u32>,
#[serde(rename = "billing_address[line1]")]
pub billing_address_line1: Option<Secret<String>>,
#[serde(rename = "billing_address[city]")]
pub billing_address_city: Option<String>,
#[serde(rename = "billing_address[state]")]
pub billing_address_state: Option<Secret<String>>,
#[serde(rename = "billing_address[zip]")]
pub billing_address_zip: Option<Secret<String>>,
#[serde(rename = "billing_address[country]")]
pub billing_address_country: Option<common_enums::CountryAlpha2>,
pub auto_collection: ChargebeeAutoCollection,
}
#[derive(Debug, Deserialize, Serialize, Clone)]
#[serde(rename_all = "snake_case")]
pub enum ChargebeeAutoCollection {
On,
Off,
}
impl From<SubscriptionAutoCollection> for ChargebeeAutoCollection {
fn from(auto_collection: SubscriptionAutoCollection) -> Self {
match auto_collection {
SubscriptionAutoCollection::On => Self::On,
SubscriptionAutoCollection::Off => Self::Off,
}
}
}
impl TryFrom<&ChargebeeRouterData<&hyperswitch_domain_models::types::SubscriptionCreateRouterData>>
for ChargebeeSubscriptionCreateRequest
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: &ChargebeeRouterData<&hyperswitch_domain_models::types::SubscriptionCreateRouterData>,
) -> Result<Self, Self::Error> {
let req = &item.router_data.request;
let first_item =
req.subscription_items
.first()
.ok_or(errors::ConnectorError::MissingRequiredField {
field_name: "subscription_items",
})?;
Ok(Self {
subscription_id: req.subscription_id.clone(),
item_price_id: first_item.item_price_id.clone(),
quantity: first_item.quantity,
billing_address_line1: item.router_data.get_optional_billing_line1(),
billing_address_city: item.router_data.get_optional_billing_city(),
billing_address_state: item.router_data.get_optional_billing_state(),
billing_address_zip: item.router_data.get_optional_billing_zip(),
billing_address_country: item.router_data.get_optional_billing_country(),
auto_collection: req.auto_collection.clone().into(),
})
}
}
#[derive(Debug, Deserialize, Serialize, Clone)]
pub struct ChargebeeSubscriptionCreateResponse {
pub subscription: ChargebeeSubscriptionDetails,
pub invoice: Option<ChargebeeInvoiceData>,
}
#[derive(Debug, Deserialize, Serialize, Clone)]
pub struct ChargebeeSubscriptionDetails {
pub id: SubscriptionId,
pub status: ChargebeeSubscriptionStatus,
pub customer_id: CustomerId,
pub currency_code: enums::Currency,
pub total_dues: Option<MinorUnit>,
#[serde(default, with = "common_utils::custom_serde::timestamp::option")]
pub next_billing_at: Option<PrimitiveDateTime>,
#[serde(default, with = "common_utils::custom_serde::timestamp::option")]
pub created_at: Option<PrimitiveDateTime>,
}
#[derive(Debug, Deserialize, Serialize, Clone)]
#[serde(rename_all = "snake_case")]
pub enum ChargebeeSubscriptionStatus {
Future,
#[serde(rename = "in_trial")]
InTrial,
Active,
#[serde(rename = "non_renewing")]
NonRenewing,
Paused,
Cancelled,
Transferred,
}
impl From<ChargebeeSubscriptionStatus> for SubscriptionStatus {
fn from(status: ChargebeeSubscriptionStatus) -> Self {
match status {
ChargebeeSubscriptionStatus::Future => Self::Pending,
ChargebeeSubscriptionStatus::InTrial => Self::Trial,
ChargebeeSubscriptionStatus::Active => Self::Active,
ChargebeeSubscriptionStatus::NonRenewing => Self::Onetime,
ChargebeeSubscriptionStatus::Paused => Self::Paused,
ChargebeeSubscriptionStatus::Cancelled => Self::Cancelled,
ChargebeeSubscriptionStatus::Transferred => Self::Cancelled,
}
}
}
impl
TryFrom<
ResponseRouterData<
SubscriptionCreate,
ChargebeeSubscriptionCreateResponse,
SubscriptionCreateRequest,
SubscriptionCreateResponse,
>,
> for hyperswitch_domain_models::types::SubscriptionCreateRouterData
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: ResponseRouterData<
SubscriptionCreate,
ChargebeeSubscriptionCreateResponse,
SubscriptionCreateRequest,
SubscriptionCreateResponse,
>,
) -> Result<Self, Self::Error> {
let subscription = &item.response.subscription;
Ok(Self {
response: Ok(SubscriptionCreateResponse {
subscription_id: subscription.id.clone(),
status: subscription.status.clone().into(),
customer_id: subscription.customer_id.clone(),
currency_code: subscription.currency_code,
total_amount: subscription.total_dues.unwrap_or(MinorUnit::new(0)),
next_billing_at: subscription.next_billing_at,
created_at: subscription.created_at,
invoice_details: item.response.invoice.map(SubscriptionInvoiceData::from),
}),
..item.data
})
}
}
//TODO: Fill the struct with respective fields
pub struct ChargebeeRouterData<T> {
pub amount: MinorUnit, // The type of amount that a connector accepts, for example, String, i64, f64, etc.
pub router_data: T,
}
impl<T> From<(MinorUnit, T)> for ChargebeeRouterData<T> {
fn from((amount, item): (MinorUnit, T)) -> Self {
Self {
amount,
router_data: item,
}
}
}
//TODO: Fill the struct with respective fields
#[derive(Default, Debug, Serialize, PartialEq)]
pub struct ChargebeePaymentsRequest {
amount: MinorUnit,
card: ChargebeeCard,
}
#[derive(Default, Debug, Serialize, Eq, PartialEq)]
pub struct ChargebeeCard {
number: cards::CardNumber,
expiry_month: Secret<String>,
expiry_year: Secret<String>,
cvc: Secret<String>,
complete: bool,
}
impl TryFrom<&ChargebeeRouterData<&PaymentsAuthorizeRouterData>> for ChargebeePaymentsRequest {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: &ChargebeeRouterData<&PaymentsAuthorizeRouterData>,
) -> Result<Self, Self::Error> {
match item.router_data.request.payment_method_data.clone() {
PaymentMethodData::Card(req_card) => {
let card = ChargebeeCard {
number: req_card.card_number,
expiry_month: req_card.card_exp_month,
expiry_year: req_card.card_exp_year,
cvc: req_card.card_cvc,
complete: item.router_data.request.is_auto_capture()?,
};
Ok(Self {
amount: item.amount,
card,
})
}
_ => Err(errors::ConnectorError::NotImplemented("Payment method".to_string()).into()),
}
}
}
// Auth Struct
pub struct ChargebeeAuthType {
pub(super) full_access_key_v1: Secret<String>,
}
#[derive(Debug, Serialize, Deserialize)]
pub struct ChargebeeMetadata {
pub(super) site: Secret<String>,
}
impl TryFrom<&Option<pii::SecretSerdeValue>> for ChargebeeMetadata {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(meta_data: &Option<pii::SecretSerdeValue>) -> Result<Self, Self::Error> {
let metadata: Self = utils::to_connector_meta_from_secret::<Self>(meta_data.clone())
.change_context(errors::ConnectorError::InvalidConnectorConfig {
config: "metadata",
})?;
Ok(metadata)
}
}
impl TryFrom<&ConnectorAuthType> for ChargebeeAuthType {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(auth_type: &ConnectorAuthType) -> Result<Self, Self::Error> {
match auth_type {
ConnectorAuthType::HeaderKey { api_key } => Ok(Self {
full_access_key_v1: api_key.clone(),
}),
_ => Err(errors::ConnectorError::FailedToObtainAuthType.into()),
}
}
}
// PaymentsResponse
//TODO: Append the remaining status flags
#[derive(Debug, Clone, Default, Serialize, Deserialize, PartialEq)]
#[serde(rename_all = "lowercase")]
pub enum ChargebeePaymentStatus {
Succeeded,
Failed,
#[default]
Processing,
}
impl From<ChargebeePaymentStatus> for common_enums::AttemptStatus {
fn from(item: ChargebeePaymentStatus) -> Self {
match item {
ChargebeePaymentStatus::Succeeded => Self::Charged,
ChargebeePaymentStatus::Failed => Self::Failure,
ChargebeePaymentStatus::Processing => Self::Authorizing,
}
}
}
//TODO: Fill the struct with respective fields
#[derive(Default, Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct ChargebeePaymentsResponse {
status: ChargebeePaymentStatus,
id: String,
}
impl<F, T> TryFrom<ResponseRouterData<F, ChargebeePaymentsResponse, T, PaymentsResponseData>>
for RouterData<F, T, PaymentsResponseData>
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: ResponseRouterData<F, ChargebeePaymentsResponse, T, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
Ok(Self {
status: common_enums::AttemptStatus::from(item.response.status),
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(item.response.id),
redirection_data: Box::new(None),
mandate_reference: Box::new(None),
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: None,
incremental_authorization_allowed: None,
charges: None,
}),
..item.data
})
}
}
//TODO: Fill the struct with respective fields
// REFUND :
// Type definition for RefundRequest
#[derive(Default, Debug, Serialize)]
pub struct ChargebeeRefundRequest {
pub amount: MinorUnit,
}
impl<F> TryFrom<&ChargebeeRouterData<&RefundsRouterData<F>>> for ChargebeeRefundRequest {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(item: &ChargebeeRouterData<&RefundsRouterData<F>>) -> Result<Self, Self::Error> {
Ok(Self {
amount: item.amount.to_owned(),
})
}
}
// Type definition for Refund Response
#[allow(dead_code)]
#[derive(Debug, Serialize, Default, Deserialize, Clone)]
pub enum RefundStatus {
Succeeded,
Failed,
#[default]
Processing,
}
impl From<RefundStatus> for enums::RefundStatus {
fn from(item: RefundStatus) -> Self {
match item {
RefundStatus::Succeeded => Self::Success,
RefundStatus::Failed => Self::Failure,
RefundStatus::Processing => Self::Pending,
//TODO: Review mapping
}
}
}
//TODO: Fill the struct with respective fields
#[derive(Default, Debug, Clone, Serialize, Deserialize)]
pub struct RefundResponse {
id: String,
status: RefundStatus,
}
impl TryFrom<RefundsResponseRouterData<Execute, RefundResponse>> for RefundsRouterData<Execute> {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: RefundsResponseRouterData<Execute, RefundResponse>,
) -> Result<Self, Self::Error> {
Ok(Self {
response: Ok(RefundsResponseData {
connector_refund_id: item.response.id.to_string(),
refund_status: enums::RefundStatus::from(item.response.status),
}),
..item.data
})
}
}
impl TryFrom<RefundsResponseRouterData<RSync, RefundResponse>> for RefundsRouterData<RSync> {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: RefundsResponseRouterData<RSync, RefundResponse>,
) -> Result<Self, Self::Error> {
Ok(Self {
response: Ok(RefundsResponseData {
connector_refund_id: item.response.id.to_string(),
refund_status: enums::RefundStatus::from(item.response.status),
}),
..item.data
})
}
}
#[derive(Default, Debug, Serialize, Deserialize, PartialEq)]
pub struct ChargebeeErrorResponse {
pub api_error_code: String,
pub message: String,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct ChargebeeWebhookBody {
pub content: ChargebeeWebhookContent,
pub event_type: ChargebeeEventType,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct ChargebeeInvoiceBody {
pub content: ChargebeeInvoiceContent,
pub event_type: ChargebeeEventType,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct ChargebeeInvoiceContent {
pub invoice: ChargebeeInvoiceData,
pub subscription: Option<ChargebeeSubscriptionData>,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct ChargebeeWebhookContent {
pub transaction: ChargebeeTransactionData,
pub invoice: ChargebeeInvoiceData,
pub customer: Option<ChargebeeCustomer>,
pub subscription: Option<ChargebeeSubscriptionData>,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct ChargebeeSubscriptionData {
#[serde(default, with = "common_utils::custom_serde::timestamp::option")]
pub current_term_start: Option<PrimitiveDateTime>,
#[serde(default, with = "common_utils::custom_serde::timestamp::option")]
pub next_billing_at: Option<PrimitiveDateTime>,
}
#[derive(Serialize, Deserialize, Debug)]
#[serde(rename_all = "snake_case")]
pub enum ChargebeeEventType {
PaymentSucceeded,
PaymentFailed,
InvoiceDeleted,
InvoiceGenerated,
}
#[derive(Serialize, Deserialize, Clone, Debug)]
pub struct ChargebeeInvoiceData {
// invoice id
pub id: InvoiceId,
pub total: MinorUnit,
pub currency_code: enums::Currency,
pub status: Option<ChargebeeInvoiceStatus>,
pub billing_address: Option<ChargebeeInvoiceBillingAddress>,
pub linked_payments: Option<Vec<ChargebeeInvoicePayments>>,
pub customer_id: CustomerId,
pub subscription_id: SubscriptionId,
pub first_invoice: Option<bool>,
}
#[derive(Serialize, Deserialize, Clone, Debug)]
pub struct ChargebeeInvoicePayments {
pub txn_status: Option<String>,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct ChargebeeTransactionData {
id_at_gateway: Option<String>,
status: ChargebeeTranasactionStatus,
error_code: Option<String>,
error_text: Option<String>,
gateway_account_id: String,
currency_code: enums::Currency,
amount: MinorUnit,
#[serde(default, with = "common_utils::custom_serde::timestamp::option")]
date: Option<PrimitiveDateTime>,
payment_method: ChargebeeTransactionPaymentMethod,
payment_method_details: String,
}
#[derive(Serialize, Deserialize, Debug)]
#[serde(rename_all = "snake_case")]
pub enum ChargebeeTransactionPaymentMethod {
Card,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct ChargebeePaymentMethodDetails {
card: ChargebeeCardDetails,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct ChargebeeCardDetails {
funding_type: ChargebeeFundingType,
brand: common_enums::CardNetwork,
iin: String,
}
#[derive(Serialize, Deserialize, Debug)]
#[serde(rename_all = "snake_case")]
pub enum ChargebeeFundingType {
Credit,
Debit,
}
#[derive(Serialize, Deserialize, Debug)]
#[serde(rename_all = "snake_case")]
pub enum ChargebeeTranasactionStatus {
// Waiting for response from the payment gateway.
InProgress,
// The transaction is successful.
Success,
// Transaction failed.
Failure,
// No response received while trying to charge the card.
Timeout,
// Indicates that a successful payment transaction has failed now due to a late failure notification from the payment gateway,
// typically caused by issues like insufficient funds or a closed bank account.
LateFailure,
// Connection with Gateway got terminated abruptly. So, status of this transaction needs to be resolved manually
NeedsAttention,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct ChargebeeCustomer {
pub payment_method: ChargebeePaymentMethod,
}
#[derive(Serialize, Deserialize, Clone, Debug)]
pub struct ChargebeeInvoiceBillingAddress {
pub line1: Option<Secret<String>>,
pub line2: Option<Secret<String>>,
pub line3: Option<Secret<String>>,
pub state: Option<Secret<String>>,
pub country: Option<enums::CountryAlpha2>,
pub zip: Option<Secret<String>>,
pub city: Option<String>,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct ChargebeePaymentMethod {
pub reference_id: String,
pub gateway: ChargebeeGateway,
}
#[derive(Serialize, Deserialize, Debug)]
#[serde(rename_all = "snake_case")]
pub enum ChargebeeGateway {
Stripe,
Braintree,
}
impl ChargebeeWebhookBody {
pub fn get_webhook_object_from_body(body: &[u8]) -> CustomResult<Self, errors::ConnectorError> {
let webhook_body = body
.parse_struct::<Self>("ChargebeeWebhookBody")
.change_context(errors::ConnectorError::WebhookBodyDecodingFailed)?;
Ok(webhook_body)
}
}
impl ChargebeeInvoiceBody {
pub fn get_invoice_webhook_data_from_body(
body: &[u8],
) -> CustomResult<Self, errors::ConnectorError> {
let webhook_body = body
.parse_struct::<Self>("ChargebeeInvoiceBody")
.change_context(errors::ConnectorError::WebhookBodyDecodingFailed)?;
Ok(webhook_body)
}
}
// Structure to extract MIT payment data from invoice_generated webhook
#[derive(Debug, Clone)]
pub struct ChargebeeMitPaymentData {
pub invoice_id: InvoiceId,
pub amount_due: MinorUnit,
pub currency_code: enums::Currency,
pub status: Option<ChargebeeInvoiceStatus>,
pub customer_id: CustomerId,
pub subscription_id: SubscriptionId,
pub first_invoice: bool,
}
impl TryFrom<ChargebeeInvoiceBody> for ChargebeeMitPaymentData {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(webhook_body: ChargebeeInvoiceBody) -> Result<Self, Self::Error> {
let invoice = webhook_body.content.invoice;
Ok(Self {
invoice_id: invoice.id,
amount_due: invoice.total,
currency_code: invoice.currency_code,
status: invoice.status,
customer_id: invoice.customer_id,
subscription_id: invoice.subscription_id,
first_invoice: invoice.first_invoice.unwrap_or(false),
})
}
}
pub struct ChargebeeMandateDetails {
pub customer_id: String,
pub mandate_id: String,
}
impl ChargebeeCustomer {
// the logic to find connector customer id & mandate id is different for different gateways, reference : https://apidocs.chargebee.com/docs/api/customers?prod_cat_ver=2#customer_payment_method_reference_id .
pub fn find_connector_ids(&self) -> Result<ChargebeeMandateDetails, errors::ConnectorError> {
match self.payment_method.gateway {
ChargebeeGateway::Stripe | ChargebeeGateway::Braintree => {
let mut parts = self.payment_method.reference_id.split('/');
let customer_id = parts
.next()
.ok_or(errors::ConnectorError::WebhookBodyDecodingFailed)?
.to_string();
let mandate_id = parts
.next_back()
.ok_or(errors::ConnectorError::WebhookBodyDecodingFailed)?
.to_string();
Ok(ChargebeeMandateDetails {
customer_id,
mandate_id,
})
}
}
}
}
#[cfg(all(feature = "revenue_recovery", feature = "v2"))]
impl TryFrom<ChargebeeWebhookBody> for revenue_recovery::RevenueRecoveryAttemptData {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(item: ChargebeeWebhookBody) -> Result<Self, Self::Error> {
let amount = item.content.transaction.amount;
let currency = item.content.transaction.currency_code.to_owned();
let merchant_reference_id = common_utils::id_type::PaymentReferenceId::from_str(
item.content.invoice.id.get_string_repr(),
)
.change_context(errors::ConnectorError::WebhookBodyDecodingFailed)?;
let connector_transaction_id = item
.content
.transaction
.id_at_gateway
.map(common_utils::types::ConnectorTransactionId::TxnId);
let error_code = item.content.transaction.error_code.clone();
let error_message = item.content.transaction.error_text.clone();
let connector_mandate_details = item
.content
.customer
.as_ref()
.map(|customer| customer.find_connector_ids())
.transpose()?
.ok_or(errors::ConnectorError::MissingRequiredField {
field_name: "connector_mandate_details",
})?;
let connector_account_reference_id = item.content.transaction.gateway_account_id.clone();
let transaction_created_at = item.content.transaction.date;
let status = enums::AttemptStatus::from(item.content.transaction.status);
let payment_method_type =
enums::PaymentMethod::from(item.content.transaction.payment_method);
let payment_method_details: ChargebeePaymentMethodDetails =
serde_json::from_str(&item.content.transaction.payment_method_details)
.change_context(errors::ConnectorError::WebhookBodyDecodingFailed)?;
let payment_method_sub_type =
enums::PaymentMethodType::from(payment_method_details.card.funding_type);
// Chargebee retry count will always be less than u16 always. Chargebee can have maximum 12 retry attempts
#[allow(clippy::as_conversions)]
let retry_count = item
.content
.invoice
.linked_payments
.map(|linked_payments| linked_payments.len() as u16);
let invoice_next_billing_time = item
.content
.subscription
.as_ref()
.and_then(|subscription| subscription.next_billing_at);
let invoice_billing_started_at_time = item
.content
.subscription
.as_ref()
.and_then(|subscription| subscription.current_term_start);
Ok(Self {
amount,
currency,
merchant_reference_id,
connector_transaction_id,
error_code,
error_message,
processor_payment_method_token: connector_mandate_details.mandate_id,
connector_customer_id: connector_mandate_details.customer_id,
connector_account_reference_id,
transaction_created_at,
status,
payment_method_type,
payment_method_sub_type,
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
retry_count,
invoice_next_billing_time,
invoice_billing_started_at_time,
// This field is none because it is specific to stripebilling.
charge_id: None,
// Need to populate these card info field
card_info: api_models::payments::AdditionalCardInfo {
card_network: Some(payment_method_details.card.brand),
card_isin: Some(payment_method_details.card.iin),
card_issuer: None,
card_type: None,
card_issuing_country: None,
bank_code: None,
last4: None,
card_extended_bin: None,
card_exp_month: None,
card_exp_year: None,
card_holder_name: None,
payment_checks: None,
authentication_data: None,
is_regulated: None,
signature_network: None,
},
})
}
}
impl From<ChargebeeTranasactionStatus> for enums::AttemptStatus {
fn from(status: ChargebeeTranasactionStatus) -> Self {
match status {
ChargebeeTranasactionStatus::InProgress
| ChargebeeTranasactionStatus::NeedsAttention => Self::Pending,
ChargebeeTranasactionStatus::Success => Self::Charged,
ChargebeeTranasactionStatus::Failure
| ChargebeeTranasactionStatus::Timeout
| ChargebeeTranasactionStatus::LateFailure => Self::Failure,
}
}
}
impl From<ChargebeeTransactionPaymentMethod> for enums::PaymentMethod {
fn from(payment_method: ChargebeeTransactionPaymentMethod) -> Self {
match payment_method {
ChargebeeTransactionPaymentMethod::Card => Self::Card,
}
}
}
impl From<ChargebeeFundingType> for enums::PaymentMethodType {
fn from(funding_type: ChargebeeFundingType) -> Self {
match funding_type {
ChargebeeFundingType::Credit => Self::Credit,
ChargebeeFundingType::Debit => Self::Debit,
}
}
}
#[cfg(all(feature = "revenue_recovery", feature = "v2"))]
impl From<ChargebeeEventType> for api_models::webhooks::IncomingWebhookEvent {
fn from(event: ChargebeeEventType) -> Self {
match event {
ChargebeeEventType::PaymentSucceeded => Self::RecoveryPaymentSuccess,
ChargebeeEventType::PaymentFailed => Self::RecoveryPaymentFailure,
ChargebeeEventType::InvoiceDeleted => Self::RecoveryInvoiceCancel,
ChargebeeEventType::InvoiceGenerated => Self::InvoiceGenerated,
}
}
}
#[cfg(feature = "v1")]
impl From<ChargebeeEventType> for api_models::webhooks::IncomingWebhookEvent {
fn from(event: ChargebeeEventType) -> Self {
match event {
ChargebeeEventType::PaymentSucceeded => Self::PaymentIntentSuccess,
ChargebeeEventType::PaymentFailed => Self::PaymentIntentFailure,
ChargebeeEventType::InvoiceDeleted => Self::EventNotSupported,
ChargebeeEventType::InvoiceGenerated => Self::InvoiceGenerated,
}
}
}
#[cfg(all(feature = "revenue_recovery", feature = "v2"))]
impl TryFrom<ChargebeeInvoiceBody> for revenue_recovery::RevenueRecoveryInvoiceData {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(item: ChargebeeInvoiceBody) -> Result<Self, Self::Error> {
let merchant_reference_id = common_utils::id_type::PaymentReferenceId::from_str(
item.content.invoice.id.get_string_repr(),
)
.change_context(errors::ConnectorError::WebhookBodyDecodingFailed)?;
// The retry count will never exceed u16 limit in a billing connector. It can have maximum of 12 in case of charge bee so its ok to suppress this
#[allow(clippy::as_conversions)]
let retry_count = item
.content
.invoice
.linked_payments
.as_ref()
.map(|linked_payments| linked_payments.len() as u16);
let invoice_next_billing_time = item
.content
.subscription
.as_ref()
.and_then(|subscription| subscription.next_billing_at);
let billing_started_at = item
.content
.subscription
.as_ref()
.and_then(|subscription| subscription.current_term_start);
Ok(Self {
amount: item.content.invoice.total,
currency: item.content.invoice.currency_code,
merchant_reference_id,
billing_address: Some(api_models::payments::Address::from(item.content.invoice)),
retry_count,
next_billing_at: invoice_next_billing_time,
billing_started_at,
metadata: None,
// TODO! This field should be handled for billing connnector integrations
enable_partial_authorization: None,
})
}
}
impl From<ChargebeeInvoiceData> for api_models::payments::Address {
fn from(item: ChargebeeInvoiceData) -> Self {
Self {
address: item
.billing_address
.map(api_models::payments::AddressDetails::from),
phone: None,
email: None,
}
}
}
impl From<ChargebeeInvoiceBillingAddress> for api_models::payments::AddressDetails {
fn from(item: ChargebeeInvoiceBillingAddress) -> Self {
Self {
city: item.city,
country: item.country,
state: item.state,
zip: item.zip,
line1: item.line1,
line2: item.line2,
line3: item.line3,
first_name: None,
last_name: None,
origin_zip: None,
}
}
}
#[derive(Debug, Serialize)]
pub struct ChargebeeRecordPaymentRequest {
#[serde(rename = "transaction[amount]")]
pub amount: MinorUnit,
#[serde(rename = "transaction[payment_method]")]
pub payment_method: ChargebeeRecordPaymentMethod,
#[serde(rename = "transaction[id_at_gateway]")]
pub connector_payment_id: Option<String>,
#[serde(rename = "transaction[status]")]
pub status: ChargebeeRecordStatus,
}
#[derive(Debug, Serialize, Clone, Copy)]
#[serde(rename_all = "snake_case")]
pub enum ChargebeeRecordPaymentMethod {
Other,
}
#[derive(Debug, Serialize, Clone, Copy)]
#[serde(rename_all = "snake_case")]
pub enum ChargebeeRecordStatus {
Success,
Failure,
}
impl TryFrom<&ChargebeeRouterData<&InvoiceRecordBackRouterData>> for ChargebeeRecordPaymentRequest {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: &ChargebeeRouterData<&InvoiceRecordBackRouterData>,
) -> Result<Self, Self::Error> {
let req = &item.router_data.request;
Ok(Self {
amount: req.amount,
payment_method: ChargebeeRecordPaymentMethod::Other,
connector_payment_id: req
.connector_transaction_id
.as_ref()
.map(|connector_payment_id| connector_payment_id.get_id().to_string()),
status: ChargebeeRecordStatus::try_from(req.attempt_status)?,
})
}
}
impl TryFrom<enums::AttemptStatus> for ChargebeeRecordStatus {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(status: enums::AttemptStatus) -> Result<Self, Self::Error> {
match status {
enums::AttemptStatus::Charged
| enums::AttemptStatus::PartialCharged
| enums::AttemptStatus::PartialChargedAndChargeable => Ok(Self::Success),
enums::AttemptStatus::Failure
| enums::AttemptStatus::CaptureFailed
| enums::AttemptStatus::RouterDeclined => Ok(Self::Failure),
enums::AttemptStatus::AuthenticationFailed
| enums::AttemptStatus::Started
| enums::AttemptStatus::AuthenticationPending
| enums::AttemptStatus::AuthenticationSuccessful
| enums::AttemptStatus::Authorized
| enums::AttemptStatus::PartiallyAuthorized
| enums::AttemptStatus::AuthorizationFailed
| enums::AttemptStatus::Authorizing
| enums::AttemptStatus::CodInitiated
| enums::AttemptStatus::Voided
| enums::AttemptStatus::VoidedPostCharge
| enums::AttemptStatus::VoidInitiated
| enums::AttemptStatus::CaptureInitiated
| enums::AttemptStatus::VoidFailed
| enums::AttemptStatus::AutoRefunded
| enums::AttemptStatus::Unresolved
| enums::AttemptStatus::Pending
| enums::AttemptStatus::PaymentMethodAwaited
| enums::AttemptStatus::ConfirmationAwaited
| enums::AttemptStatus::DeviceDataCollectionPending
| enums::AttemptStatus::IntegrityFailure
| enums::AttemptStatus::Expired => Err(errors::ConnectorError::NotSupported {
message: "Record back flow is only supported for terminal status".to_string(),
connector: "chargebee",
}
.into()),
}
}
}
#[derive(Debug, Deserialize, Serialize, Clone)]
pub struct ChargebeeRecordbackResponse {
pub invoice: ChargebeeRecordbackInvoice,
}
#[derive(Debug, Deserialize, Serialize, Clone)]
pub struct ChargebeeRecordbackInvoice {
pub id: common_utils::id_type::PaymentReferenceId,
}
impl
TryFrom<
ResponseRouterData<
InvoiceRecordBack,
ChargebeeRecordbackResponse,
InvoiceRecordBackRequest,
InvoiceRecordBackResponse,
>,
> for InvoiceRecordBackRouterData
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: ResponseRouterData<
InvoiceRecordBack,
ChargebeeRecordbackResponse,
InvoiceRecordBackRequest,
InvoiceRecordBackResponse,
>,
) -> Result<Self, Self::Error> {
let merchant_reference_id = item.response.invoice.id;
Ok(Self {
response: Ok(InvoiceRecordBackResponse {
merchant_reference_id,
}),
..item.data
})
}
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ChargebeeListPlansResponse {
pub list: Vec<ChargebeeItemList>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ChargebeeItemList {
pub item: ChargebeeItem,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ChargebeeItem {
pub id: String,
pub name: String,
#[serde(rename = "type")]
pub plan_type: String,
pub is_giftable: bool,
pub enabled_for_checkout: bool,
pub enabled_in_portal: bool,
pub metered: bool,
pub deleted: bool,
pub description: Option<String>,
}
impl<F, T>
TryFrom<ResponseRouterData<F, SubscriptionEstimateResponse, T, GetSubscriptionEstimateResponse>>
for RouterData<F, T, GetSubscriptionEstimateResponse>
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: ResponseRouterData<
F,
SubscriptionEstimateResponse,
T,
GetSubscriptionEstimateResponse,
>,
) -> Result<Self, Self::Error> {
let estimate = item.response.estimate;
Ok(Self {
response: Ok(GetSubscriptionEstimateResponse {
sub_total: estimate.invoice_estimate.sub_total,
total: estimate.invoice_estimate.total,
amount_paid: Some(estimate.invoice_estimate.amount_paid),
amount_due: Some(estimate.invoice_estimate.amount_due),
currency: estimate.subscription_estimate.currency_code,
next_billing_at: estimate.subscription_estimate.next_billing_at,
credits_applied: Some(estimate.invoice_estimate.credits_applied),
customer_id: Some(estimate.invoice_estimate.customer_id),
line_items: estimate
.invoice_estimate
.line_items
.into_iter()
.map(|line_item| SubscriptionLineItem {
item_id: line_item.entity_id,
item_type: line_item.entity_type,
description: line_item.description,
amount: line_item.amount,
currency: estimate.invoice_estimate.currency_code,
unit_amount: Some(line_item.unit_amount),
quantity: line_item.quantity,
pricing_model: Some(line_item.pricing_model),
})
.collect(),
}),
..item.data
})
}
}
impl<F, T>
TryFrom<ResponseRouterData<F, ChargebeeListPlansResponse, T, GetSubscriptionPlansResponse>>
for RouterData<F, T, GetSubscriptionPlansResponse>
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: ResponseRouterData<F, ChargebeeListPlansResponse, T, GetSubscriptionPlansResponse>,
) -> Result<Self, Self::Error> {
let plans = item
.response
.list
.into_iter()
.map(|plan| subscriptions::SubscriptionPlans {
subscription_provider_plan_id: plan.item.id,
name: plan.item.name,
description: plan.item.description,
})
.collect();
Ok(Self {
response: Ok(GetSubscriptionPlansResponse { list: plans }),
..item.data
})
}
}
#[derive(Debug, Serialize)]
pub struct ChargebeeCustomerCreateRequest {
#[serde(rename = "id")]
pub customer_id: CustomerId,
#[serde(rename = "first_name")]
pub name: Option<Secret<String>>,
pub email: Option<Email>,
#[serde(rename = "billing_address[first_name]")]
pub billing_address_first_name: Option<Secret<String>>,
#[serde(rename = "billing_address[last_name]")]
pub billing_address_last_name: Option<Secret<String>>,
#[serde(rename = "billing_address[line1]")]
pub billing_address_line1: Option<Secret<String>>,
#[serde(rename = "billing_address[city]")]
pub billing_address_city: Option<String>,
#[serde(rename = "billing_address[state]")]
pub billing_address_state: Option<Secret<String>>,
#[serde(rename = "billing_address[zip]")]
pub billing_address_zip: Option<Secret<String>>,
#[serde(rename = "billing_address[country]")]
pub billing_address_country: Option<String>,
}
impl TryFrom<&ChargebeeRouterData<&hyperswitch_domain_models::types::ConnectorCustomerRouterData>>
for ChargebeeCustomerCreateRequest
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: &ChargebeeRouterData<&hyperswitch_domain_models::types::ConnectorCustomerRouterData>,
) -> Result<Self, Self::Error> {
let req = &item.router_data.request;
Ok(Self {
customer_id: req
.customer_id
.as_ref()
.ok_or_else(|| errors::ConnectorError::MissingRequiredField {
field_name: "customer_id",
})?
.clone(),
name: req.name.clone(),
email: req.email.clone(),
billing_address_first_name: req
.billing_address
.as_ref()
.and_then(|address| address.first_name.clone()),
billing_address_last_name: req
.billing_address
.as_ref()
.and_then(|address| address.last_name.clone()),
billing_address_line1: req
.billing_address
.as_ref()
.and_then(|addr| addr.line1.clone()),
billing_address_city: req
.billing_address
.as_ref()
.and_then(|addr| addr.city.clone()),
billing_address_country: req
.billing_address
.as_ref()
.and_then(|addr| addr.country.map(|country| country.to_string())),
billing_address_state: req
.billing_address
.as_ref()
.and_then(|addr| addr.state.clone()),
billing_address_zip: req
.billing_address
.as_ref()
.and_then(|addr| addr.zip.clone()),
})
}
}
#[derive(Debug, Deserialize, Serialize, Clone)]
pub struct ChargebeeCustomerCreateResponse {
pub customer: ChargebeeCustomerDetails,
}
#[derive(Debug, Deserialize, Serialize, Clone)]
pub struct ChargebeeCustomerDetails {
pub id: String,
#[serde(rename = "first_name")]
pub name: Option<Secret<String>>,
pub email: Option<Email>,
pub billing_address: Option<api_models::payments::AddressDetails>,
}
impl
TryFrom<
ResponseRouterData<
CreateConnectorCustomer,
ChargebeeCustomerCreateResponse,
ConnectorCustomerData,
PaymentsResponseData,
>,
> for hyperswitch_domain_models::types::ConnectorCustomerRouterData
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: ResponseRouterData<
CreateConnectorCustomer,
ChargebeeCustomerCreateResponse,
ConnectorCustomerData,
PaymentsResponseData,
>,
) -> Result<Self, Self::Error> {
let customer_response = &item.response.customer;
Ok(Self {
response: Ok(PaymentsResponseData::ConnectorCustomerResponse(
ConnectorCustomerResponseData::new(
customer_response.id.clone(),
customer_response
.name
.as_ref()
.map(|name| name.clone().expose()),
customer_response
.email
.as_ref()
.map(|email| email.clone().expose().expose()),
customer_response.billing_address.clone(),
),
)),
..item.data
})
}
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ChargebeeSubscriptionEstimateRequest {
#[serde(rename = "subscription_items[item_price_id][0]")]
pub price_id: String,
}
impl TryFrom<&GetSubscriptionEstimateRouterData> for ChargebeeSubscriptionEstimateRequest {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(item: &GetSubscriptionEstimateRouterData) -> Result<Self, Self::Error> {
let price_id = item.request.price_id.to_owned();
Ok(Self { price_id })
}
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ChargebeeGetPlanPricesResponse {
pub list: Vec<ChargebeeGetPlanPriceList>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ChargebeeGetPlanPriceList {
pub item_price: ChargebeePlanPriceItem,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ChargebeePlanPriceItem {
pub id: String,
pub name: String,
pub currency_code: common_enums::Currency,
pub free_quantity: i64,
#[serde(default, with = "common_utils::custom_serde::timestamp::option")]
pub created_at: Option<PrimitiveDateTime>,
pub deleted: bool,
pub item_id: Option<String>,
pub period: i64,
pub period_unit: ChargebeePeriodUnit,
pub trial_period: Option<i64>,
pub trial_period_unit: Option<ChargebeeTrialPeriodUnit>,
pub price: MinorUnit,
pub pricing_model: ChargebeePricingModel,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum ChargebeePricingModel {
FlatFee,
PerUnit,
Tiered,
Volume,
Stairstep,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum ChargebeePeriodUnit {
Day,
Week,
Month,
Year,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum ChargebeeTrialPeriodUnit {
Day,
Month,
}
impl<F, T>
TryFrom<
ResponseRouterData<F, ChargebeeGetPlanPricesResponse, T, GetSubscriptionPlanPricesResponse>,
> for RouterData<F, T, GetSubscriptionPlanPricesResponse>
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: ResponseRouterData<
F,
ChargebeeGetPlanPricesResponse,
T,
GetSubscriptionPlanPricesResponse,
>,
) -> Result<Self, Self::Error> {
let plan_prices = item
.response
.list
.into_iter()
.map(|prices| subscriptions::SubscriptionPlanPrices {
price_id: prices.item_price.id,
plan_id: prices.item_price.item_id,
amount: prices.item_price.price,
currency: prices.item_price.currency_code,
interval: match prices.item_price.period_unit {
ChargebeePeriodUnit::Day => subscriptions::PeriodUnit::Day,
ChargebeePeriodUnit::Week => subscriptions::PeriodUnit::Week,
ChargebeePeriodUnit::Month => subscriptions::PeriodUnit::Month,
ChargebeePeriodUnit::Year => subscriptions::PeriodUnit::Year,
},
interval_count: prices.item_price.period,
trial_period: prices.item_price.trial_period,
trial_period_unit: match prices.item_price.trial_period_unit {
Some(ChargebeeTrialPeriodUnit::Day) => Some(subscriptions::PeriodUnit::Day),
Some(ChargebeeTrialPeriodUnit::Month) => Some(subscriptions::PeriodUnit::Month),
None => None,
},
})
.collect();
Ok(Self {
response: Ok(GetSubscriptionPlanPricesResponse { list: plan_prices }),
..item.data
})
}
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct SubscriptionEstimateResponse {
pub estimate: ChargebeeEstimate,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ChargebeeEstimate {
pub created_at: i64,
/// type of the object will be `estimate`
pub object: String,
pub subscription_estimate: SubscriptionEstimate,
pub invoice_estimate: InvoiceEstimate,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct SubscriptionEstimate {
pub status: String,
#[serde(default, with = "common_utils::custom_serde::timestamp::option")]
pub next_billing_at: Option<PrimitiveDateTime>,
/// type of the object will be `subscription_estimate`
pub object: String,
pub currency_code: enums::Currency,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct InvoiceEstimate {
pub recurring: bool,
#[serde(default, with = "common_utils::custom_serde::timestamp::option")]
pub date: Option<PrimitiveDateTime>,
pub price_type: String,
pub sub_total: MinorUnit,
pub total: MinorUnit,
pub credits_applied: MinorUnit,
pub amount_paid: MinorUnit,
pub amount_due: MinorUnit,
/// type of the object will be `invoice_estimate`
pub object: String,
pub customer_id: CustomerId,
pub line_items: Vec<LineItem>,
pub currency_code: enums::Currency,
pub round_off_amount: MinorUnit,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct LineItem {
pub id: String,
#[serde(default, with = "common_utils::custom_serde::timestamp::option")]
pub date_from: Option<PrimitiveDateTime>,
#[serde(default, with = "common_utils::custom_serde::timestamp::option")]
pub date_to: Option<PrimitiveDateTime>,
pub unit_amount: MinorUnit,
pub quantity: i64,
pub amount: MinorUnit,
pub pricing_model: String,
pub is_taxed: bool,
pub tax_amount: MinorUnit,
/// type of the object will be `line_item`
pub object: String,
pub customer_id: String,
pub description: String,
pub entity_type: String,
pub entity_id: String,
pub discount_amount: MinorUnit,
pub item_level_discount_amount: MinorUnit,
}
#[derive(Serialize, Deserialize, Clone, Debug)]
#[serde(rename_all = "snake_case")]
pub enum ChargebeeInvoiceStatus {
Paid,
Posted,
PaymentDue,
NotPaid,
Voided,
#[serde(other)]
Pending,
}
impl From<ChargebeeInvoiceData> for SubscriptionInvoiceData {
fn from(item: ChargebeeInvoiceData) -> Self {
Self {
billing_address: Some(api_models::payments::Address::from(item.clone())),
id: item.id,
total: item.total,
currency_code: item.currency_code,
status: item.status.map(connector_enums::InvoiceStatus::from),
}
}
}
impl From<ChargebeeInvoiceStatus> for connector_enums::InvoiceStatus {
fn from(status: ChargebeeInvoiceStatus) -> Self {
match status {
ChargebeeInvoiceStatus::Paid => Self::InvoicePaid,
ChargebeeInvoiceStatus::Posted => Self::PaymentPendingTimeout,
ChargebeeInvoiceStatus::PaymentDue => Self::PaymentPending,
ChargebeeInvoiceStatus::NotPaid => Self::PaymentFailed,
ChargebeeInvoiceStatus::Voided => Self::Voided,
ChargebeeInvoiceStatus::Pending => Self::InvoiceCreated,
}
}
}
|
{
"crate": "hyperswitch_connectors",
"file": "crates/hyperswitch_connectors/src/connectors/chargebee/transformers.rs",
"file_size": null,
"is_async": null,
"is_pub": null,
"num_enums": 15,
"num_structs": 42,
"num_tables": null,
"score": null,
"total_crates": null
}
|
file_hyperswitch_connectors_-7547752630450895861
|
clm
|
file
|
// Repository: hyperswitch
// Crate: hyperswitch_connectors
// File: crates/hyperswitch_connectors/src/connectors/nordea/transformers.rs
// Contains: 2 structs, 0 enums
use std::collections::HashMap;
use common_utils::{pii, request::Method, types::StringMajorUnit};
use error_stack::ResultExt;
use hyperswitch_domain_models::{
payment_method_data::{BankDebitData, PaymentMethodData},
router_data::{AccessToken, ConnectorAuthType, ErrorResponse, RouterData},
router_flow_types::{Authorize, PreProcessing},
router_request_types::{PaymentsAuthorizeData, PaymentsPreProcessingData, ResponseId},
router_response_types::{PaymentsResponseData, RedirectForm},
types::{
self, AccessTokenAuthenticationRouterData, PaymentsAuthorizeRouterData,
PaymentsPreProcessingRouterData, PaymentsSyncRouterData,
},
};
use hyperswitch_interfaces::errors;
use masking::Secret;
use rand::distributions::DistString;
use serde::{Deserialize, Deserializer, Serialize};
use crate::{
connectors::nordea::{
requests::{
AccessScope, AccountNumber, AccountType, CreditorAccount, CreditorBank, DebitorAccount,
GrantType, NordeaOAuthExchangeRequest, NordeaOAuthRequest,
NordeaPaymentsConfirmRequest, NordeaPaymentsRequest, NordeaRouterData, PaymentsUrgency,
},
responses::{
NordeaErrorBody, NordeaFailures, NordeaOAuthExchangeResponse, NordeaPaymentStatus,
NordeaPaymentsConfirmResponse, NordeaPaymentsInitiateResponse,
},
},
types::{PaymentsSyncResponseRouterData, ResponseRouterData},
utils::{self, get_unimplemented_payment_method_error_message, RouterData as _},
};
type Error = error_stack::Report<errors::ConnectorError>;
impl<T> From<(StringMajorUnit, T)> for NordeaRouterData<T> {
fn from((amount, item): (StringMajorUnit, T)) -> Self {
Self {
amount,
router_data: item,
}
}
}
// Auth Struct
#[derive(Debug)]
pub struct NordeaAuthType {
pub(super) client_id: Secret<String>,
pub(super) client_secret: Secret<String>,
/// PEM format private key for eIDAS signing
/// Should be base64 encoded
pub(super) eidas_private_key: Secret<String>,
}
impl TryFrom<&ConnectorAuthType> for NordeaAuthType {
type Error = Error;
fn try_from(auth_type: &ConnectorAuthType) -> Result<Self, Self::Error> {
match auth_type {
ConnectorAuthType::SignatureKey {
api_key,
key1,
api_secret,
} => Ok(Self {
client_id: key1.to_owned(),
client_secret: api_key.to_owned(),
eidas_private_key: api_secret.to_owned(),
}),
_ => Err(errors::ConnectorError::FailedToObtainAuthType.into()),
}
}
}
#[derive(Debug, Default, Serialize, Deserialize)]
pub struct NordeaConnectorMetadataObject {
/// Account number of the beneficiary (merchant)
pub destination_account_number: Secret<String>,
/// Account type (example: IBAN, BBAN_SE, BBAN_DK, BBAN_NO, BGNR, PGNR, GIRO_DK, BBAN_OTHER)
pub account_type: String,
/// Name of the beneficiary (merchant)
pub merchant_name: Secret<String>,
}
impl TryFrom<&Option<pii::SecretSerdeValue>> for NordeaConnectorMetadataObject {
type Error = Error;
fn try_from(meta_data: &Option<pii::SecretSerdeValue>) -> Result<Self, Self::Error> {
let metadata: Self = utils::to_connector_meta_from_secret::<Self>(meta_data.clone())
.change_context(errors::ConnectorError::InvalidConnectorConfig {
config: "merchant_connector_account.metadata",
})?;
Ok(metadata)
}
}
impl TryFrom<&AccessTokenAuthenticationRouterData> for NordeaOAuthRequest {
type Error = Error;
fn try_from(item: &AccessTokenAuthenticationRouterData) -> Result<Self, Self::Error> {
let country = item.get_billing_country()?;
// Set refresh_token maximum expiry duration to 180 days (259200 / 60 = 180)
// Minimum is 1 minute
let duration = Some(259200);
let maximum_transaction_history = Some(18);
let redirect_uri = "https://hyperswitch.io".to_string();
let scope = [
AccessScope::AccountsBasic,
AccessScope::AccountsDetails,
AccessScope::AccountsBalances,
AccessScope::AccountsTransactions,
AccessScope::PaymentsMultiple,
]
.to_vec();
let state = rand::distributions::Alphanumeric.sample_string(&mut rand::thread_rng(), 15);
Ok(Self {
country,
duration,
maximum_transaction_history,
redirect_uri,
scope,
state: state.into(),
})
}
}
impl TryFrom<&types::RefreshTokenRouterData> for NordeaOAuthExchangeRequest {
type Error = Error;
fn try_from(item: &types::RefreshTokenRouterData) -> Result<Self, Self::Error> {
let code = item
.request
.authentication_token
.as_ref()
.ok_or(errors::ConnectorError::MissingRequiredField {
field_name: "authorization_code",
})?
.code
.clone();
let grant_type = GrantType::AuthorizationCode;
let redirect_uri = Some("https://hyperswitch.io".to_string());
Ok(Self {
code: Some(code),
grant_type,
redirect_uri,
refresh_token: None, // We're not using refresh_token to generate new access_token
})
}
}
impl<F, T> TryFrom<ResponseRouterData<F, NordeaOAuthExchangeResponse, T, AccessToken>>
for RouterData<F, T, AccessToken>
{
type Error = Error;
fn try_from(
item: ResponseRouterData<F, NordeaOAuthExchangeResponse, T, AccessToken>,
) -> Result<Self, Self::Error> {
let access_token =
item.response
.access_token
.ok_or(errors::ConnectorError::MissingRequiredField {
field_name: "access_token",
})?;
let expires_in = item.response.expires_in.unwrap_or(3600); // Default to 1 hour if not provided
Ok(Self {
status: common_enums::AttemptStatus::AuthenticationSuccessful,
response: Ok(AccessToken {
token: access_token.clone(),
expires: expires_in,
}),
..item.data
})
}
}
impl TryFrom<&str> for AccountType {
type Error = Error;
fn try_from(value: &str) -> Result<Self, Self::Error> {
match value.to_uppercase().as_str() {
"IBAN" => Ok(Self::Iban),
"BBAN_SE" => Ok(Self::BbanSe),
"BBAN_DK" => Ok(Self::BbanDk),
"BBAN_NO" => Ok(Self::BbanNo),
"BGNR" => Ok(Self::Bgnr),
"PGNR" => Ok(Self::Pgnr),
"GIRO_DK" => Ok(Self::GiroDk),
"BBAN_OTHER" => Ok(Self::BbanOther),
_ => Err(errors::ConnectorError::InvalidConnectorConfig {
config: "account_type",
}
.into()),
}
}
}
impl<'de> Deserialize<'de> for PaymentsUrgency {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: Deserializer<'de>,
{
let s = String::deserialize(deserializer)?.to_lowercase();
match s.as_str() {
"standard" => Ok(Self::Standard),
"express" => Ok(Self::Express),
"sameday" => Ok(Self::Sameday),
_ => Err(serde::de::Error::unknown_variant(
&s,
&["standard", "express", "sameday"],
)),
}
}
}
fn get_creditor_account_from_metadata(
router_data: &PaymentsPreProcessingRouterData,
) -> Result<CreditorAccount, Error> {
let metadata: NordeaConnectorMetadataObject =
utils::to_connector_meta_from_secret(router_data.connector_meta_data.clone())
.change_context(errors::ConnectorError::InvalidConnectorConfig {
config: "merchant_connector_account.metadata",
})?;
let creditor_account = CreditorAccount {
account: AccountNumber {
account_type: AccountType::try_from(metadata.account_type.as_str())
.unwrap_or(AccountType::Iban),
currency: router_data.request.currency,
value: metadata.destination_account_number,
},
country: router_data.get_optional_billing_country(),
// Merchant is the beneficiary in this case
name: Some(metadata.merchant_name),
message: router_data
.description
.as_ref()
.map(|desc| desc.chars().take(20).collect::<String>()),
bank: Some(CreditorBank {
address: None,
bank_code: None,
bank_name: None,
business_identifier_code: None,
country: router_data.get_billing_country()?,
}),
creditor_address: None,
// Either Reference or Message must be supplied in the request
reference: None,
};
Ok(creditor_account)
}
impl TryFrom<&NordeaRouterData<&PaymentsPreProcessingRouterData>> for NordeaPaymentsRequest {
type Error = Error;
fn try_from(
item: &NordeaRouterData<&PaymentsPreProcessingRouterData>,
) -> Result<Self, Self::Error> {
match item.router_data.request.payment_method_data.clone() {
Some(PaymentMethodData::BankDebit(bank_debit_data)) => match bank_debit_data {
BankDebitData::SepaBankDebit { iban, .. } => {
let creditor_account = get_creditor_account_from_metadata(item.router_data)?;
let debitor_account = DebitorAccount {
account: AccountNumber {
account_type: AccountType::Iban,
currency: item.router_data.request.currency,
value: iban,
},
message: item
.router_data
.description
.as_ref()
.map(|desc| desc.chars().take(20).collect::<String>()),
};
let instructed_amount = super::requests::InstructedAmount {
amount: item.amount.clone(),
currency: item.router_data.request.currency.ok_or(
errors::ConnectorError::MissingRequiredField {
field_name: "amount",
},
)?,
};
Ok(Self {
creditor_account,
debitor_account,
end_to_end_identification: None,
external_id: Some(item.router_data.connector_request_reference_id.clone()),
instructed_amount,
recurring: None,
request_availability_of_funds: None,
requested_execution_date: None,
tpp_messages: None,
urgency: None,
})
}
BankDebitData::AchBankDebit { .. }
| BankDebitData::BacsBankDebit { .. }
| BankDebitData::BecsBankDebit { .. }
| BankDebitData::SepaGuarenteedBankDebit { .. } => {
Err(errors::ConnectorError::NotImplemented(
get_unimplemented_payment_method_error_message("Nordea"),
)
.into())
}
},
Some(PaymentMethodData::CardRedirect(_))
| Some(PaymentMethodData::CardDetailsForNetworkTransactionId(_))
| Some(PaymentMethodData::Wallet(_))
| Some(PaymentMethodData::PayLater(_))
| Some(PaymentMethodData::BankRedirect(_))
| Some(PaymentMethodData::BankTransfer(_))
| Some(PaymentMethodData::Crypto(_))
| Some(PaymentMethodData::MandatePayment)
| Some(PaymentMethodData::Reward)
| Some(PaymentMethodData::RealTimePayment(_))
| Some(PaymentMethodData::MobilePayment(_))
| Some(PaymentMethodData::Upi(_))
| Some(PaymentMethodData::Voucher(_))
| Some(PaymentMethodData::GiftCard(_))
| Some(PaymentMethodData::OpenBanking(_))
| Some(PaymentMethodData::CardToken(_))
| Some(PaymentMethodData::NetworkToken(_))
| Some(PaymentMethodData::Card(_))
| None => {
Err(errors::ConnectorError::NotImplemented("Payment method".to_string()).into())
}
}
}
}
impl TryFrom<&NordeaRouterData<&PaymentsAuthorizeRouterData>> for NordeaPaymentsConfirmRequest {
type Error = Error;
fn try_from(
item: &NordeaRouterData<&PaymentsAuthorizeRouterData>,
) -> Result<Self, Self::Error> {
let payment_ids = match &item.router_data.response {
Ok(response_data) => response_data
.get_connector_transaction_id()
.map_err(|_| errors::ConnectorError::MissingConnectorTransactionID)?,
Err(_) => return Err(errors::ConnectorError::ResponseDeserializationFailed.into()),
};
Ok(Self {
authentication_method: None,
language: None,
payments_ids: vec![payment_ids],
redirect_url: None,
state: None,
})
}
}
impl From<NordeaPaymentStatus> for common_enums::AttemptStatus {
fn from(item: NordeaPaymentStatus) -> Self {
match item {
NordeaPaymentStatus::Confirmed | NordeaPaymentStatus::Paid => Self::Charged,
NordeaPaymentStatus::PendingConfirmation
| NordeaPaymentStatus::PendingSecondConfirmation => Self::ConfirmationAwaited,
NordeaPaymentStatus::PendingUserApproval => Self::AuthenticationPending,
NordeaPaymentStatus::OnHold | NordeaPaymentStatus::Unknown => Self::Pending,
NordeaPaymentStatus::Rejected
| NordeaPaymentStatus::InsufficientFunds
| NordeaPaymentStatus::LimitExceeded
| NordeaPaymentStatus::UserApprovalFailed
| NordeaPaymentStatus::UserApprovalTimeout
| NordeaPaymentStatus::UserApprovalCancelled => Self::Failure,
}
}
}
pub fn get_error_data(error_response: Option<&NordeaErrorBody>) -> Option<&NordeaFailures> {
error_response
.and_then(|error| error.nordea_failures.as_ref())
.and_then(|failures| failures.first())
}
// Helper function to convert NordeaPaymentsInitiateResponse to common response data
fn convert_nordea_payment_response(
response: &NordeaPaymentsInitiateResponse,
) -> Result<(PaymentsResponseData, common_enums::AttemptStatus), Error> {
let payment_response = response
.payments_response
.as_ref()
.ok_or(errors::ConnectorError::ResponseHandlingFailed)?;
let resource_id = ResponseId::ConnectorTransactionId(payment_response.payment_id.clone());
let response_data = PaymentsResponseData::TransactionResponse {
resource_id,
redirection_data: Box::new(None),
mandate_reference: Box::new(None),
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: payment_response.external_id.clone(),
incremental_authorization_allowed: None,
charges: None,
};
let status = common_enums::AttemptStatus::from(payment_response.payment_status.clone());
Ok((response_data, status))
}
impl
TryFrom<
ResponseRouterData<
PreProcessing,
NordeaPaymentsInitiateResponse,
PaymentsPreProcessingData,
PaymentsResponseData,
>,
> for RouterData<PreProcessing, PaymentsPreProcessingData, PaymentsResponseData>
{
type Error = Error;
fn try_from(
item: ResponseRouterData<
PreProcessing,
NordeaPaymentsInitiateResponse,
PaymentsPreProcessingData,
PaymentsResponseData,
>,
) -> Result<Self, Self::Error> {
let (response, status) = convert_nordea_payment_response(&item.response)?;
Ok(Self {
status,
response: Ok(response),
..item.data
})
}
}
impl
TryFrom<
ResponseRouterData<
Authorize,
NordeaPaymentsConfirmResponse,
PaymentsAuthorizeData,
PaymentsResponseData,
>,
> for RouterData<Authorize, PaymentsAuthorizeData, PaymentsResponseData>
{
type Error = Error;
fn try_from(
item: ResponseRouterData<
Authorize,
NordeaPaymentsConfirmResponse,
PaymentsAuthorizeData,
PaymentsResponseData,
>,
) -> Result<Self, Self::Error> {
// First check if there are any errors in the response
if let Some(errors) = &item.response.errors {
if !errors.is_empty() {
// Get the first error for the error response
let first_error = errors
.first()
.ok_or(errors::ConnectorError::ResponseHandlingFailed)?;
return Ok(Self {
status: common_enums::AttemptStatus::Failure,
response: Err(ErrorResponse {
code: first_error
.error
.clone()
.unwrap_or_else(|| "UNKNOWN_ERROR".to_string()),
message: first_error
.error_description
.clone()
.unwrap_or_else(|| "Payment confirmation failed".to_string()),
reason: first_error.error_description.clone(),
status_code: item.http_code,
attempt_status: Some(common_enums::AttemptStatus::Failure),
connector_transaction_id: first_error.payment_id.clone(),
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
connector_metadata: None,
}),
..item.data
});
}
}
// If no errors, proceed with normal response handling
// Check if there's a redirect link at the top level only
let redirection_data = item
.response
.links
.as_ref()
.and_then(|links| {
links.iter().find(|link| {
link.rel
.as_ref()
.map(|rel| rel == "signing")
.unwrap_or(false)
})
})
.and_then(|link| link.href.clone())
.map(|redirect_url| RedirectForm::Form {
endpoint: redirect_url,
method: Method::Get,
form_fields: HashMap::new(),
});
let (response, status) = match &item.response.nordea_payments_response {
Some(payment_response_wrapper) => {
// Get the first payment from the payments array
let payment = payment_response_wrapper
.payments
.first()
.ok_or(errors::ConnectorError::ResponseHandlingFailed)?;
let resource_id = ResponseId::ConnectorTransactionId(payment.payment_id.clone());
let response = Ok(PaymentsResponseData::TransactionResponse {
resource_id,
redirection_data: Box::new(redirection_data),
mandate_reference: Box::new(None),
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: payment.external_id.clone(),
incremental_authorization_allowed: None,
charges: None,
});
let status = common_enums::AttemptStatus::from(payment.payment_status.clone());
(response, status)
}
None => {
// No payment response, but we might still have a redirect link
if let Some(redirect) = redirection_data {
let response = Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::NoResponseId,
redirection_data: Box::new(Some(redirect)),
mandate_reference: Box::new(None),
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: None,
incremental_authorization_allowed: None,
charges: None,
});
(response, common_enums::AttemptStatus::AuthenticationPending)
} else {
return Err(errors::ConnectorError::ResponseHandlingFailed.into());
}
}
};
Ok(Self {
status,
response,
..item.data
})
}
}
impl TryFrom<PaymentsSyncResponseRouterData<NordeaPaymentsInitiateResponse>>
for PaymentsSyncRouterData
{
type Error = Error;
fn try_from(
item: PaymentsSyncResponseRouterData<NordeaPaymentsInitiateResponse>,
) -> Result<Self, Self::Error> {
let (response, status) = convert_nordea_payment_response(&item.response)?;
Ok(Self {
status,
response: Ok(response),
..item.data
})
}
}
|
{
"crate": "hyperswitch_connectors",
"file": "crates/hyperswitch_connectors/src/connectors/nordea/transformers.rs",
"file_size": null,
"is_async": null,
"is_pub": null,
"num_enums": 0,
"num_structs": 2,
"num_tables": null,
"score": null,
"total_crates": null
}
|
file_hyperswitch_connectors_2118523365311970133
|
clm
|
file
|
// Repository: hyperswitch
// Crate: hyperswitch_connectors
// File: crates/hyperswitch_connectors/src/connectors/nordea/responses.rs
// Contains: 16 structs, 3 enums
use common_enums::CountryAlpha2;
use common_utils::types::StringMajorUnit;
use masking::Secret;
use serde::{Deserialize, Serialize};
use super::requests::{
CreditorAccount, DebitorAccount, InstructedAmount, PaymentsUrgency, RecurringInformation,
ThirdPartyMessages,
};
// OAuth token response structure
#[derive(Debug, Serialize, Deserialize, Clone)]
pub struct NordeaOAuthExchangeResponse {
pub access_token: Option<Secret<String>>,
pub expires_in: Option<i64>,
pub refresh_token: Option<Secret<String>>,
pub token_type: Option<String>,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, PartialEq)]
#[serde(rename_all = "PascalCase")]
pub enum NordeaPaymentStatus {
#[default]
PendingConfirmation,
PendingSecondConfirmation,
PendingUserApproval,
OnHold,
Confirmed,
Rejected,
Paid,
InsufficientFunds,
LimitExceeded,
UserApprovalFailed,
UserApprovalTimeout,
UserApprovalCancelled,
Unknown,
}
#[derive(Debug, Serialize, Deserialize, PartialEq)]
pub struct NordeaGroupHeader {
/// Response creation time. Format: date-time.
pub creation_date_time: Option<String>,
/// HTTP code for response. Format: int32.
pub http_code: Option<i32>,
/// Original request id for correlation purposes
pub message_identification: Option<String>,
/// Details of paginated response
pub message_pagination: Option<MessagePagination>,
}
#[derive(Debug, Serialize, Deserialize, PartialEq)]
pub struct NordeaResponseLinks {
/// Describes the nature of the link, e.g. 'details' for a link to the detailed information of a listed resource.
pub rel: Option<String>,
/// Relative path to the linked resource
pub href: Option<String>,
}
#[derive(Debug, Serialize, Deserialize, PartialEq)]
#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
pub enum FeesType {
Additional,
Standard,
}
#[derive(Debug, Serialize, Deserialize, PartialEq)]
pub struct TransactionFee {
/// Monetary amount
pub amount: InstructedAmount,
pub description: Option<String>,
pub excluded_from_total_fee: Option<bool>,
pub percentage: Option<bool>,
#[serde(rename = "type")]
pub fees_type: Option<FeesType>,
}
#[derive(Debug, Serialize, Deserialize, PartialEq)]
pub struct BankFee {
/// Example 'domestic_transaction' only for DK domestic payments
#[serde(rename = "_type")]
pub bank_fee_type: Option<String>,
/// Country code according to ISO Alpha-2
pub country_code: Option<CountryAlpha2>,
/// Currency code according to ISO 4217
pub currency_code: Option<api_models::enums::Currency>,
/// Value of the fee.
pub value: Option<StringMajorUnit>,
pub fees: Option<Vec<TransactionFee>>,
/// Monetary amount
pub total_fee_amount: InstructedAmount,
}
#[derive(Debug, Serialize, Deserialize, PartialEq)]
#[serde(rename_all = "lowercase")]
pub enum ChargeBearer {
Shar,
Debt,
}
#[derive(Debug, Serialize, Deserialize, PartialEq)]
pub struct ExchangeRate {
pub base_currency: Option<api_models::enums::Currency>,
pub exchange_currency: Option<api_models::enums::Currency>,
}
#[derive(Debug, Serialize, Deserialize, PartialEq)]
pub struct MessagePagination {
/// Resource listing may return a continuationKey if there's more results available.
/// Request may be retried with the continuationKey, but otherwise same parameters, in order to get more results.
pub continuation_key: Option<String>,
}
#[derive(Debug, Serialize, Deserialize, PartialEq)]
pub struct NordeaPaymentsInitiateResponseData {
/// Unique payment identifier assigned for new payment
#[serde(rename = "_id")]
pub payment_id: String,
/// HATEOAS inspired links: 'rel' and 'href'. Context specific link (only GET supported)
#[serde(rename = "_links")]
pub links: Option<Vec<NordeaResponseLinks>>,
/// Marked as required field in the docs, but connector does not send amount in payment_response.amount
pub amount: Option<StringMajorUnit>,
/// Bearer of charges. shar = The Debtor (sender of the payment) will pay all fees charged by the sending bank.
/// The Creditor (recipient of the payment) will pay all fees charged by the receiving bank.
/// debt = The Debtor (sender of the payment) will bear all of the payment transaction fees.
/// The creditor (beneficiary) will receive the full amount of the payment.
pub charge_bearer: Option<ChargeBearer>,
/// Creditor of the payment
#[serde(rename = "creditor")]
pub creditor_account: CreditorAccount,
pub currency: Option<api_models::enums::Currency>,
/// Debtor of the payment
#[serde(rename = "debtor")]
pub debitor_account: Option<DebitorAccount>,
/// Timestamp of payment creation. ISO 8601 format yyyy-mm-ddThh:mm:ss.fffZ. Format:date-time.
pub entry_date_time: Option<String>,
/// Unique identification as assigned by a partner to identify the payment.
pub external_id: Option<String>,
/// An amount the bank will charge for executing the payment
pub fee: Option<BankFee>,
pub indicative_exchange_rate: Option<ExchangeRate>,
/// It is mentioned as `number`. It can be an integer or a decimal number.
pub rate: Option<f32>,
/// Monetary amount
pub instructed_amount: Option<InstructedAmount>,
/// Indication of cross border payment to own account
pub is_own_account_transfer: Option<bool>,
/// OTP Challenge
pub otp_challenge: Option<String>,
/// Status of the payment
pub payment_status: NordeaPaymentStatus,
/// Planned execution date will indicate the day the payment will be finalized. If the payment has been pushed due to cut-off, it will be indicated in planned execution date. Format:date.
pub planned_execution_date: Option<String>,
/// Recurring information
pub recurring: Option<RecurringInformation>,
/// Choose a preferred execution date (or leave blank for today's date).
/// This should be a valid bank day, and depending on the country the date will either be pushed to the next valid bank day,
/// or return an error if a non-banking day date was supplied (all dates accepted in sandbox).
/// SEPA: max +5 years from yesterday, Domestic: max. +1 year from yesterday. NB: Not supported for Own transfer Non-Recurring Norway.
/// Format:date.
pub requested_execution_date: Option<String>,
/// Timestamp of payment creation. ISO 8601 format yyyy-mm-ddThh:mm:ss.fffZ Format:date-time.
pub timestamp: Option<String>,
/// Additional messages for third parties
pub tpp_messages: Option<Vec<ThirdPartyMessages>>,
pub transaction_fee: Option<Vec<BankFee>>,
/// Currency that the cross border payment will be transferred in.
/// This field is only supported for cross border payments for DK.
/// If this field is not supplied then the payment will use the currency specified for the currency field of instructed_amount.
pub transfer_currency: Option<api_models::enums::Currency>,
/// Urgency of the payment. NB: This field is supported for DK Domestic ('standard' and 'express') and NO Domestic bank transfer payments ('standard' and 'express').
/// Use 'express' for Straksbetaling (Instant payment).
/// All other payment types ignore this input.
/// For further details on urgencies and cut-offs, refer to the Nordea website.
/// Value 'sameday' is marked as deprecated and will be removed in the future.
pub urgency: Option<PaymentsUrgency>,
}
#[derive(Debug, Serialize, Deserialize, PartialEq)]
pub struct NordeaPaymentsInitiateResponse {
/// Payment information
#[serde(rename = "response")]
pub payments_response: Option<NordeaPaymentsInitiateResponseData>,
/// External response header
pub group_header: Option<NordeaGroupHeader>,
}
#[derive(Debug, Serialize, Deserialize, PartialEq)]
pub struct NordeaPaymentsConfirmErrorObject {
/// Error message
pub error: Option<String>,
/// Description of the error
pub error_description: Option<String>,
/// Payment id of the payment, the error is associated with
pub payment_id: Option<String>,
}
#[derive(Debug, Serialize, Deserialize, PartialEq)]
pub struct NordeaPaymentsResponseWrapper {
pub payments: Vec<NordeaPaymentsInitiateResponseData>,
}
#[derive(Debug, Serialize, Deserialize, PartialEq)]
pub struct NordeaPaymentsConfirmResponse {
/// HATEOAS inspired links: 'rel' and 'href'
#[serde(rename = "_links")]
pub links: Option<Vec<NordeaResponseLinks>>,
/// Error description
pub errors: Option<Vec<NordeaPaymentsConfirmErrorObject>>,
/// External response header
pub group_header: Option<NordeaGroupHeader>,
/// OTP Challenge
pub otp_challenge: Option<String>,
#[serde(rename = "response")]
pub nordea_payments_response: Option<NordeaPaymentsResponseWrapper>,
}
#[derive(Debug, Serialize, Deserialize, PartialEq)]
pub struct NordeaOriginalRequest {
/// Original request url
#[serde(rename = "url")]
pub nordea_url: Option<String>,
}
#[derive(Debug, Serialize, Deserialize, PartialEq)]
pub struct NordeaFailures {
/// Failure code
pub code: Option<String>,
/// Failure description
pub description: Option<String>,
/// JSON path of the failing element if applicable
pub path: Option<String>,
/// Type of the validation error, e.g. NotNull
#[serde(rename = "type")]
pub failure_type: Option<String>,
}
#[derive(Debug, Serialize, Deserialize, PartialEq)]
pub struct NordeaErrorBody {
// Serde JSON because connector returns an `(item)` object in failures array object
/// More details on the occurred error: Validation error
#[serde(rename = "failures")]
pub nordea_failures: Option<Vec<NordeaFailures>>,
/// Original request information
#[serde(rename = "request")]
pub nordea_request: Option<NordeaOriginalRequest>,
}
#[derive(Debug, Serialize, Deserialize, PartialEq)]
pub struct NordeaErrorResponse {
/// Error response body
pub error: Option<NordeaErrorBody>,
/// External response header
pub group_header: Option<NordeaGroupHeader>,
#[serde(rename = "httpCode")]
pub http_code: Option<String>,
#[serde(rename = "moreInformation")]
pub more_information: Option<String>,
}
// Nordea does not support refunds in Private APIs. Only Corporate APIs support Refunds
|
{
"crate": "hyperswitch_connectors",
"file": "crates/hyperswitch_connectors/src/connectors/nordea/responses.rs",
"file_size": null,
"is_async": null,
"is_pub": null,
"num_enums": 3,
"num_structs": 16,
"num_tables": null,
"score": null,
"total_crates": null
}
|
file_hyperswitch_connectors_-9188485327926829699
|
clm
|
file
|
// Repository: hyperswitch
// Crate: hyperswitch_connectors
// File: crates/hyperswitch_connectors/src/connectors/nordea/requests.rs
// Contains: 13 structs, 9 enums
use common_utils::types::StringMajorUnit;
use masking::Secret;
use serde::{Deserialize, Serialize};
pub struct NordeaRouterData<T> {
pub amount: StringMajorUnit,
pub router_data: T,
}
#[derive(Debug, Serialize, Deserialize, Clone)]
pub struct NordeaOAuthRequest {
/// Country is a mandatory parameter with possible values FI, DK, NO or SE
pub country: api_models::enums::CountryAlpha2,
/// Duration of access authorization in minutes. range: 1 to 259200 minutes (180 days).
/// Duration should be left empty if the request includes PAYMENTS_SINGLE_SCA scope.
#[serde(skip_serializing_if = "Option::is_none")]
pub duration: Option<i32>,
/// Maximum transaction history in months. Optional if ACCOUNTS_TRANSACTIONS scope is requested. Default=2 months. range: 1 to 18 months
#[serde(rename = "max_tx_history")]
#[serde(skip_serializing_if = "Option::is_none")]
pub maximum_transaction_history: Option<i32>,
/// Redirect URI you used when this application was registered with Nordea.
pub redirect_uri: String,
pub scope: Vec<AccessScope>,
/// The OAuth2 state parameter. This is a nonce and should be used to prevent CSRF attacks.
pub state: Secret<String>,
}
#[derive(Debug, Serialize, Deserialize, Clone)]
#[serde(rename_all = "snake_case")]
pub enum GrantType {
AuthorizationCode,
RefreshToken,
}
// To be passed in query parameters for OAuth scopes
#[derive(Debug, Serialize, Deserialize, Clone)]
#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
pub enum AccessScope {
AccountsBasic,
AccountsBalances,
AccountsDetails,
AccountsTransactions,
PaymentsMultiple,
PaymentsSingleSca,
CardsInformation,
CardsTransactions,
}
#[derive(Debug, Clone, Serialize)]
pub struct NordeaOAuthExchangeRequest {
/// authorization_code flow
#[serde(skip_serializing_if = "Option::is_none")]
pub code: Option<Secret<String>>,
pub grant_type: GrantType,
#[serde(skip_serializing_if = "Option::is_none")]
pub redirect_uri: Option<String>,
/// refresh_token flow
#[serde(skip_serializing_if = "Option::is_none")]
pub refresh_token: Option<Secret<String>>,
}
#[derive(Debug, Serialize, Deserialize, PartialEq)]
#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
pub enum AccountType {
/// International bank account number
Iban,
/// National bank account number of Sweden
BbanSe,
/// National bank account number of Denmark
BbanDk,
/// National bank account number of Norway
BbanNo,
/// Bankgiro number
Bgnr,
/// Plusgiro number
Pgnr,
/// Creditor number (Giro) Denmark
GiroDk,
/// Any bank account number without any check-digit validations
BbanOther,
}
#[derive(Debug, Serialize, Deserialize, PartialEq)]
pub struct AccountNumber {
/// Type of account number
#[serde(rename = "_type")]
pub account_type: AccountType,
/// Currency of the account (Mandatory for debtor, Optional for creditor)
#[serde(skip_serializing_if = "Option::is_none")]
pub currency: Option<api_models::enums::Currency>,
/// Actual account number
pub value: Secret<String>,
}
#[derive(Debug, Serialize, Deserialize, PartialEq)]
pub struct CreditorAccountReference {
/// RF or Invoice for FI Sepa payments, OCR for NO Kid payments and 01, 04, 15, 71, 73 or 75 for Danish Transfer Form payments.
#[serde(rename = "_type")]
pub creditor_reference_type: String,
/// Actual reference number
#[serde(skip_serializing_if = "Option::is_none")]
pub value: Option<String>,
}
#[derive(Debug, Serialize, Deserialize, PartialEq)]
pub struct NordeaAddress {
/// First line of the address. e.g. Street address
pub line1: Option<Secret<String>>,
/// Second line of the address (optional). e.g. Postal address
pub line2: Option<Secret<String>>,
/// Third line of the address (optional). e.g. Country
pub line3: Option<Secret<String>>,
}
#[derive(Debug, Serialize, Deserialize, PartialEq)]
pub struct CreditorBank {
/// Address
pub address: Option<NordeaAddress>,
/// Bank code
pub bank_code: Option<String>,
/// Business identifier code (BIC) of the creditor bank.
/// This information is required, if the creditor account number is not in IBAN format.
#[serde(rename = "bic")]
pub business_identifier_code: Option<Secret<String>>,
/// Country of the creditor bank. Only ISO 3166 alpha-2 codes are used.
pub country: api_models::enums::CountryAlpha2,
/// Name of the creditor bank.
#[serde(rename = "name")]
pub bank_name: Option<String>,
}
#[derive(Debug, Serialize, Deserialize, PartialEq)]
pub struct CreditorAccount {
/// Account number
pub account: AccountNumber,
/// Creditor bank information.
pub bank: Option<CreditorBank>,
/// Country of the creditor
pub country: Option<api_models::enums::CountryAlpha2>,
/// Address
pub creditor_address: Option<NordeaAddress>,
/// Message for the creditor to appear on their transaction.
/// Max length: FI SEPA:140; SE:12; PGNR:25; BGNR:150; DK: 40 (Instant/Express: 140); NO: 140
#[serde(skip_serializing_if = "Option::is_none")]
pub message: Option<String>,
/// Name of the creditor.
/// Max length: FI SEPA: 30; SE: 35; DK: Not use (Mandatory for Instant/Express payments: 70);
/// NO: 30 (mandatory for Straksbetaling/Express payments).
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<Secret<String>>,
/// Creditor reference number.
/// Either Reference or Message has to be passed in the Request
pub reference: Option<CreditorAccountReference>,
}
#[derive(Debug, Serialize, Deserialize, PartialEq)]
pub struct DebitorAccount {
/// Account number
pub account: AccountNumber,
/// Own message to be on the debtor's transaction.
/// Max length 20. NB: This field is not supported for SEPA and Norwegian payments and will be ignored.
#[serde(skip_serializing_if = "Option::is_none")]
pub message: Option<String>,
}
#[derive(Debug, Serialize, Deserialize, PartialEq)]
pub struct InstructedAmount {
/// Monetary amount of the payment. Max (digits+decimals): FI SEPA: (9+2); SE:(11+2); DK:(7+2); NO:(7+2)
pub amount: StringMajorUnit,
/// Currency code according to ISO 4217.
/// NB: Possible value depends on the type of the payment.
/// For domestic payment it should be same as debtor local currency,
/// for SEPA it must be EUR,
/// for cross border it can be Currency code according to ISO 4217.
pub currency: api_models::enums::Currency,
}
#[derive(Debug, Serialize, Deserialize, PartialEq)]
#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
pub enum RecurrenceType {
Daily,
Weekly,
Biweekly,
MonthlySameDay,
MonthlyEom,
QuartelySameDay,
QuartelyEom,
SemiAnnuallySameDay,
SemiAnnuallyEom,
TriAnnuallySameDay,
YearlySameDay,
YearlyEom,
EveryMinuteSandboxOnly,
}
#[derive(Debug, Serialize, PartialEq)]
#[serde(rename_all = "snake_case")]
#[allow(dead_code)] // This is an optional field and not having it is fine
pub enum FundsAvailabilityRequest {
True,
False,
}
#[derive(Debug, Serialize, PartialEq, Clone)]
pub enum PaymentsUrgency {
Standard,
Express,
Sameday,
}
#[derive(Debug, Serialize, Deserialize, PartialEq)]
pub struct RecurringInformation {
/// Number of occurrences. Not applicable for NO (use end_date instead). Format: int32.
#[serde(skip_serializing_if = "Option::is_none")]
pub count: Option<i32>,
/// Date on which the recurrence will end. Format: YYYY-MM-DD. Applicable only for Norway. Format: date
#[serde(skip_serializing_if = "Option::is_none")]
pub end_date: Option<String>,
/// Repeats every interval
#[serde(skip_serializing_if = "Option::is_none")]
pub recurrence_type: Option<RecurrenceType>,
}
#[derive(Debug, Serialize, Deserialize, PartialEq)]
#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
pub enum TppCategory {
Error,
Warning,
Info,
}
#[derive(Debug, Serialize, Deserialize, PartialEq)]
#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
pub enum TppCode {
Ds0a,
Narr,
Am21,
Am04,
Tm01,
Am12,
Rc06,
Rc07,
Rc04,
Ag06,
Bg06,
Be22,
Be20,
Ff06,
Be19,
Am03,
Am11,
Ch04,
Dt01,
Ch03,
Ff08,
Ac10,
Ac02,
Ag08,
Rr09,
Rc11,
Ff10,
Rr10,
Ff05,
Ch15,
Ff04,
Ac11,
Ac03,
Ac13,
Ac14,
Ac05,
Ac06,
Rr07,
Dt03,
Am13,
Ds24,
Fr01,
Am02,
}
#[derive(Debug, Serialize, Deserialize, PartialEq)]
pub struct ThirdPartyMessages {
/// Category of the TPP message, INFO is further information, WARNING is something can be fixed, ERROR possibly non fixable issue
#[serde(skip_serializing_if = "Option::is_none")]
pub category: Option<TppCategory>,
/// Additional code that is combined with the text
#[serde(skip_serializing_if = "Option::is_none")]
pub code: Option<TppCode>,
/// Additional explaining text to the TPP
#[serde(skip_serializing_if = "Option::is_none")]
pub text: Option<String>,
}
#[derive(Debug, Serialize, PartialEq)]
pub struct NordeaPaymentsRequest {
/// Creditor of the payment
#[serde(rename = "creditor")]
pub creditor_account: CreditorAccount,
/// Debtor of the payment
#[serde(rename = "debtor")]
pub debitor_account: DebitorAccount,
/// Free text reference that can be provided by the PSU.
/// This identification is passed on throughout the entire end-to-end chain.
/// Only in scope for Nordea Business DK.
#[serde(skip_serializing_if = "Option::is_none")]
pub end_to_end_identification: Option<String>,
/// Unique identification as assigned by a partner to identify the payment.
#[serde(skip_serializing_if = "Option::is_none")]
pub external_id: Option<String>,
/// Monetary amount
pub instructed_amount: InstructedAmount,
/// Recurring information
#[serde(skip_serializing_if = "Option::is_none")]
pub recurring: Option<RecurringInformation>,
/// Use as an indicator that the supplied payment (amount, currency and debtor account)
/// should be used to check whether the funds are available for further processing - at this moment.
#[serde(skip_serializing_if = "Option::is_none")]
pub request_availability_of_funds: Option<FundsAvailabilityRequest>,
/// Choose a preferred execution date (or leave blank for today's date).
/// This should be a valid bank day, and depending on the country the date will either be
/// pushed to the next valid bank day, or return an error if a non-banking day date was
/// supplied (all dates accepted in sandbox). SEPA: max +5 years from yesterday,
/// Domestic: max. +1 year from yesterday. NB: Not supported for Own transfer Non-Recurring Norway.
/// Format:date.
#[serde(skip_serializing_if = "Option::is_none")]
pub requested_execution_date: Option<String>,
/// Additional messages for third parties
#[serde(rename = "tpp_messages")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tpp_messages: Option<Vec<ThirdPartyMessages>>,
/// Urgency of the payment. NB: This field is supported for
/// DK Domestic ('standard' and 'express')
/// NO Domestic bank transfer payments ('standard'). Use 'express' for Straksbetaling (Instant payment).
/// FI Sepa ('standard' and 'express') All other payment types ignore this input.
/// For further details on urgencies and cut-offs, refer to the Nordea website. Value 'sameday' is marked as deprecated and will be removed in the future.
#[serde(skip_serializing_if = "Option::is_none")]
pub urgency: Option<PaymentsUrgency>,
}
#[derive(Debug, Serialize, Deserialize, PartialEq, Clone)]
#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
pub enum NordeaAuthenticationMethod {
Mta,
#[serde(rename = "CCALC (Deprecated)")]
Ccalc,
Qrt,
CardRdr,
BankidSe,
QrtSe,
BankidNo,
BankidmNo,
MtaNo,
#[serde(rename = "NEMID_2F")]
Nemid2f,
Mitid,
MtaDk,
QrtDk,
}
#[derive(Debug, Serialize, Deserialize, PartialEq, Clone)]
#[serde(rename_all = "snake_case")]
pub enum NordeaConfirmLanguage {
Fi,
Da,
Sv,
En,
No,
}
#[derive(Debug, Serialize, PartialEq)]
pub struct NordeaPaymentsConfirmRequest {
/// Authentication method to use for the signing of payment.
#[serde(skip_serializing_if = "Option::is_none")]
pub authentication_method: Option<NordeaAuthenticationMethod>,
/// Language of the signing page that will be displayed to client, ISO639-1 and 639-2, default=en
#[serde(skip_serializing_if = "Option::is_none")]
pub language: Option<NordeaConfirmLanguage>,
pub payments_ids: Vec<String>,
pub redirect_url: Option<String>,
pub state: Option<String>,
}
|
{
"crate": "hyperswitch_connectors",
"file": "crates/hyperswitch_connectors/src/connectors/nordea/requests.rs",
"file_size": null,
"is_async": null,
"is_pub": null,
"num_enums": 9,
"num_structs": 13,
"num_tables": null,
"score": null,
"total_crates": null
}
|
file_hyperswitch_connectors_6134369169822219455
|
clm
|
file
|
// Repository: hyperswitch
// Crate: hyperswitch_connectors
// File: crates/hyperswitch_connectors/src/connectors/helcim/transformers.rs
// Contains: 14 structs, 5 enums
use common_enums::enums;
use common_utils::{
pii::{Email, IpAddress},
types::FloatMajorUnit,
};
use error_stack::ResultExt;
use hyperswitch_domain_models::{
payment_method_data::{Card, PaymentMethodData},
router_data::{ConnectorAuthType, RouterData},
router_flow_types::refunds::{Execute, RSync},
router_request_types::{
PaymentsAuthorizeData, PaymentsCancelData, PaymentsCaptureData, PaymentsSyncData,
ResponseId, SetupMandateRequestData,
},
router_response_types::{PaymentsResponseData, RefundsResponseData},
types::{
PaymentsAuthorizeRouterData, PaymentsCancelRouterData, PaymentsCaptureRouterData,
RefundsRouterData, SetupMandateRouterData,
},
};
use hyperswitch_interfaces::errors;
use masking::Secret;
use serde::{Deserialize, Serialize};
use crate::{
types::{RefundsResponseRouterData, ResponseRouterData},
utils::{
AddressDetailsData, BrowserInformationData, CardData, PaymentsAuthorizeRequestData,
PaymentsCancelRequestData, PaymentsCaptureRequestData, PaymentsSetupMandateRequestData,
RefundsRequestData, RouterData as RouterDataUtils,
},
};
#[derive(Debug, Serialize)]
pub struct HelcimRouterData<T> {
pub amount: FloatMajorUnit,
pub router_data: T,
}
impl<T> TryFrom<(FloatMajorUnit, T)> for HelcimRouterData<T> {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from((amount, item): (FloatMajorUnit, T)) -> Result<Self, Self::Error> {
Ok(Self {
amount,
router_data: item,
})
}
}
pub fn check_currency(
currency: enums::Currency,
) -> Result<enums::Currency, errors::ConnectorError> {
if currency == enums::Currency::USD {
Ok(currency)
} else {
Err(errors::ConnectorError::NotSupported {
message: format!("currency {currency} is not supported for this merchant account"),
connector: "Helcim",
})?
}
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct HelcimVerifyRequest {
currency: enums::Currency,
ip_address: Secret<String, IpAddress>,
card_data: HelcimCard,
billing_address: HelcimBillingAddress,
#[serde(skip_serializing_if = "Option::is_none")]
ecommerce: Option<bool>,
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct HelcimPaymentsRequest {
amount: FloatMajorUnit,
currency: enums::Currency,
ip_address: Secret<String, IpAddress>,
card_data: HelcimCard,
invoice: HelcimInvoice,
billing_address: HelcimBillingAddress,
//The ecommerce field is an optional field in Connector Helcim.
//Setting the ecommerce field to true activates the Helcim Fraud Defender.
#[serde(skip_serializing_if = "Option::is_none")]
ecommerce: Option<bool>,
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct HelcimBillingAddress {
name: Secret<String>,
street1: Secret<String>,
postal_code: Secret<String>,
#[serde(skip_serializing_if = "Option::is_none")]
street2: Option<Secret<String>>,
#[serde(skip_serializing_if = "Option::is_none")]
city: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
email: Option<Email>,
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct HelcimInvoice {
invoice_number: String,
line_items: Vec<HelcimLineItems>,
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct HelcimLineItems {
description: String,
quantity: u8,
price: FloatMajorUnit,
total: FloatMajorUnit,
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct HelcimCard {
card_number: cards::CardNumber,
card_expiry: Secret<String>,
card_c_v_v: Secret<String>,
}
impl TryFrom<(&SetupMandateRouterData, &Card)> for HelcimVerifyRequest {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(value: (&SetupMandateRouterData, &Card)) -> Result<Self, Self::Error> {
let (item, req_card) = value;
let card_data = HelcimCard {
card_expiry: req_card
.get_card_expiry_month_year_2_digit_with_delimiter("".to_string())?,
card_number: req_card.card_number.clone(),
card_c_v_v: req_card.card_cvc.clone(),
};
let req_address = item.get_billing_address()?.to_owned();
let billing_address = HelcimBillingAddress {
name: req_address.get_full_name()?,
street1: req_address.get_line1()?.to_owned(),
postal_code: req_address.get_zip()?.to_owned(),
street2: req_address.line2,
city: req_address.city,
email: item.request.email.clone(),
};
let ip_address = item.request.get_browser_info()?.get_ip_address()?;
let currency = check_currency(item.request.currency)?;
Ok(Self {
currency,
ip_address,
card_data,
billing_address,
ecommerce: None,
})
}
}
impl TryFrom<&SetupMandateRouterData> for HelcimVerifyRequest {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(item: &SetupMandateRouterData) -> Result<Self, Self::Error> {
match item.request.payment_method_data.clone() {
PaymentMethodData::Card(req_card) => Self::try_from((item, &req_card)),
PaymentMethodData::BankTransfer(_) => {
Err(errors::ConnectorError::NotImplemented("Payment Method".to_string()).into())
}
PaymentMethodData::CardRedirect(_)
| PaymentMethodData::Wallet(_)
| PaymentMethodData::PayLater(_)
| PaymentMethodData::BankRedirect(_)
| PaymentMethodData::BankDebit(_)
| PaymentMethodData::Crypto(_)
| PaymentMethodData::MandatePayment
| PaymentMethodData::Reward
| PaymentMethodData::RealTimePayment(_)
| PaymentMethodData::Upi(_)
| PaymentMethodData::Voucher(_)
| PaymentMethodData::MobilePayment(_)
| PaymentMethodData::GiftCard(_)
| PaymentMethodData::OpenBanking(_)
| PaymentMethodData::CardToken(_)
| PaymentMethodData::NetworkToken(_)
| PaymentMethodData::CardDetailsForNetworkTransactionId(_) => {
Err(errors::ConnectorError::NotImplemented(
crate::utils::get_unimplemented_payment_method_error_message("Helcim"),
))?
}
}
}
}
impl TryFrom<(&HelcimRouterData<&PaymentsAuthorizeRouterData>, &Card)> for HelcimPaymentsRequest {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
value: (&HelcimRouterData<&PaymentsAuthorizeRouterData>, &Card),
) -> Result<Self, Self::Error> {
let (item, req_card) = value;
let card_data = HelcimCard {
card_expiry: req_card
.get_card_expiry_month_year_2_digit_with_delimiter("".to_string())?,
card_number: req_card.card_number.clone(),
card_c_v_v: req_card.card_cvc.clone(),
};
let req_address = item
.router_data
.get_billing()?
.to_owned()
.address
.ok_or_else(crate::utils::missing_field_err("billing.address"))?;
let billing_address = HelcimBillingAddress {
name: req_address.get_full_name()?,
street1: req_address.get_line1()?.to_owned(),
postal_code: req_address.get_zip()?.to_owned(),
street2: req_address.line2,
city: req_address.city,
email: item.router_data.request.email.clone(),
};
let ip_address = item
.router_data
.request
.get_browser_info()?
.get_ip_address()?;
let line_items = vec![
(HelcimLineItems {
description: item
.router_data
.description
.clone()
.unwrap_or("No Description".to_string()),
// By default quantity is set to 1 and price and total is set to amount because these three fields are required to generate an invoice.
quantity: 1,
price: item.amount,
total: item.amount,
}),
];
let invoice = HelcimInvoice {
invoice_number: item.router_data.connector_request_reference_id.clone(),
line_items,
};
let currency = check_currency(item.router_data.request.currency)?;
Ok(Self {
amount: item.amount,
currency,
ip_address,
card_data,
invoice,
billing_address,
ecommerce: None,
})
}
}
impl TryFrom<&HelcimRouterData<&PaymentsAuthorizeRouterData>> for HelcimPaymentsRequest {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: &HelcimRouterData<&PaymentsAuthorizeRouterData>,
) -> Result<Self, Self::Error> {
match item.router_data.request.payment_method_data.clone() {
PaymentMethodData::Card(req_card) => Self::try_from((item, &req_card)),
PaymentMethodData::BankTransfer(_) => {
Err(errors::ConnectorError::NotImplemented("Payment Method".to_string()).into())
}
PaymentMethodData::CardRedirect(_)
| PaymentMethodData::Wallet(_)
| PaymentMethodData::PayLater(_)
| PaymentMethodData::BankRedirect(_)
| PaymentMethodData::BankDebit(_)
| PaymentMethodData::Crypto(_)
| PaymentMethodData::MandatePayment
| PaymentMethodData::Reward
| PaymentMethodData::RealTimePayment(_)
| PaymentMethodData::Upi(_)
| PaymentMethodData::MobilePayment(_)
| PaymentMethodData::Voucher(_)
| PaymentMethodData::GiftCard(_)
| PaymentMethodData::OpenBanking(_)
| PaymentMethodData::CardToken(_)
| PaymentMethodData::NetworkToken(_)
| PaymentMethodData::CardDetailsForNetworkTransactionId(_) => {
Err(errors::ConnectorError::NotImplemented(
crate::utils::get_unimplemented_payment_method_error_message("Helcim"),
))?
}
}
}
}
// Auth Struct
pub struct HelcimAuthType {
pub(super) api_key: Secret<String>,
}
impl TryFrom<&ConnectorAuthType> for HelcimAuthType {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(auth_type: &ConnectorAuthType) -> Result<Self, Self::Error> {
match auth_type {
ConnectorAuthType::HeaderKey { api_key } => Ok(Self {
api_key: api_key.to_owned(),
}),
_ => Err(errors::ConnectorError::FailedToObtainAuthType.into()),
}
}
}
// PaymentsResponse
#[derive(Debug, Deserialize, Serialize)]
#[serde(rename_all = "UPPERCASE")]
pub enum HelcimPaymentStatus {
Approved,
Declined,
}
#[derive(Debug, Deserialize, Serialize)]
#[serde(rename_all = "lowercase")]
pub enum HelcimTransactionType {
Purchase,
PreAuth,
Capture,
Verify,
Reverse,
}
impl From<HelcimPaymentsResponse> for enums::AttemptStatus {
fn from(item: HelcimPaymentsResponse) -> Self {
match item.transaction_type {
HelcimTransactionType::Purchase | HelcimTransactionType::Verify => match item.status {
HelcimPaymentStatus::Approved => Self::Charged,
HelcimPaymentStatus::Declined => Self::Failure,
},
HelcimTransactionType::PreAuth => match item.status {
HelcimPaymentStatus::Approved => Self::Authorized,
HelcimPaymentStatus::Declined => Self::AuthorizationFailed,
},
HelcimTransactionType::Capture => match item.status {
HelcimPaymentStatus::Approved => Self::Charged,
HelcimPaymentStatus::Declined => Self::CaptureFailed,
},
HelcimTransactionType::Reverse => match item.status {
HelcimPaymentStatus::Approved => Self::Voided,
HelcimPaymentStatus::Declined => Self::VoidFailed,
},
}
}
}
#[derive(Debug, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct HelcimPaymentsResponse {
status: HelcimPaymentStatus,
transaction_id: u64,
invoice_number: Option<String>,
#[serde(rename = "type")]
transaction_type: HelcimTransactionType,
}
impl<F>
TryFrom<
ResponseRouterData<
F,
HelcimPaymentsResponse,
SetupMandateRequestData,
PaymentsResponseData,
>,
> for RouterData<F, SetupMandateRequestData, PaymentsResponseData>
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: ResponseRouterData<
F,
HelcimPaymentsResponse,
SetupMandateRequestData,
PaymentsResponseData,
>,
) -> Result<Self, Self::Error> {
Ok(Self {
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(
item.response.transaction_id.to_string(),
),
redirection_data: Box::new(None),
mandate_reference: Box::new(None),
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: item.response.invoice_number.clone(),
incremental_authorization_allowed: None,
charges: None,
}),
status: enums::AttemptStatus::from(item.response),
..item.data
})
}
}
#[derive(Debug, Deserialize, Serialize)]
pub struct HelcimMetaData {
pub preauth_transaction_id: u64,
}
impl<F>
TryFrom<
ResponseRouterData<F, HelcimPaymentsResponse, PaymentsAuthorizeData, PaymentsResponseData>,
> for RouterData<F, PaymentsAuthorizeData, PaymentsResponseData>
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: ResponseRouterData<
F,
HelcimPaymentsResponse,
PaymentsAuthorizeData,
PaymentsResponseData,
>,
) -> Result<Self, Self::Error> {
//PreAuth Transaction ID is stored in connector metadata
//Initially resource_id is stored as NoResponseID for manual capture
//After Capture Transaction is completed it is updated to store the Capture ID
let resource_id = if item.data.request.is_auto_capture()? {
ResponseId::ConnectorTransactionId(item.response.transaction_id.to_string())
} else {
ResponseId::NoResponseId
};
let connector_metadata = if !item.data.request.is_auto_capture()? {
Some(serde_json::json!(HelcimMetaData {
preauth_transaction_id: item.response.transaction_id,
}))
} else {
None
};
Ok(Self {
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id,
redirection_data: Box::new(None),
mandate_reference: Box::new(None),
connector_metadata,
network_txn_id: None,
connector_response_reference_id: item.response.invoice_number.clone(),
incremental_authorization_allowed: None,
charges: None,
}),
status: enums::AttemptStatus::from(item.response),
..item.data
})
}
}
// impl utils::MultipleCaptureSyncResponse for HelcimPaymentsResponse {
// fn get_connector_capture_id(&self) -> String {
// self.transaction_id.to_string()
// }
// fn get_capture_attempt_status(&self) -> diesel_models::enums::AttemptStatus {
// enums::AttemptStatus::from(self.to_owned())
// }
// fn is_capture_response(&self) -> bool {
// true
// }
// fn get_amount_captured(&self) -> Option<i64> {
// Some(self.amount)
// }
// fn get_connector_reference_id(&self) -> Option<String> {
// None
// }
// }
impl<F>
TryFrom<ResponseRouterData<F, HelcimPaymentsResponse, PaymentsSyncData, PaymentsResponseData>>
for RouterData<F, PaymentsSyncData, PaymentsResponseData>
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: ResponseRouterData<F, HelcimPaymentsResponse, PaymentsSyncData, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
match item.data.request.sync_type {
hyperswitch_domain_models::router_request_types::SyncRequestType::SinglePaymentSync => Ok(Self {
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(
item.response.transaction_id.to_string(),
),
redirection_data: Box::new(None),
mandate_reference: Box::new(None),
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: item.response.invoice_number.clone(),
incremental_authorization_allowed: None,
charges: None,
}),
status: enums::AttemptStatus::from(item.response),
..item.data
}),
hyperswitch_domain_models::router_request_types::SyncRequestType::MultipleCaptureSync(_) => {
Err(errors::ConnectorError::NotImplemented(
"manual multiple capture sync".to_string(),
)
.into())
// let capture_sync_response_list =
// utils::construct_captures_response_hashmap(vec![item.response]);
// Ok(Self {
// response: Ok(PaymentsResponseData::MultipleCaptureResponse {
// capture_sync_response_list,
// }),
// ..item.data
// })
}
}
}
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct HelcimCaptureRequest {
pre_auth_transaction_id: u64,
amount: FloatMajorUnit,
ip_address: Secret<String, IpAddress>,
#[serde(skip_serializing_if = "Option::is_none")]
ecommerce: Option<bool>,
}
impl TryFrom<&HelcimRouterData<&PaymentsCaptureRouterData>> for HelcimCaptureRequest {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(item: &HelcimRouterData<&PaymentsCaptureRouterData>) -> Result<Self, Self::Error> {
let ip_address = item
.router_data
.request
.get_browser_info()?
.get_ip_address()?;
Ok(Self {
pre_auth_transaction_id: item
.router_data
.request
.connector_transaction_id
.parse::<u64>()
.change_context(errors::ConnectorError::RequestEncodingFailed)?,
amount: item.amount,
ip_address,
ecommerce: None,
})
}
}
impl<F>
TryFrom<
ResponseRouterData<F, HelcimPaymentsResponse, PaymentsCaptureData, PaymentsResponseData>,
> for RouterData<F, PaymentsCaptureData, PaymentsResponseData>
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: ResponseRouterData<
F,
HelcimPaymentsResponse,
PaymentsCaptureData,
PaymentsResponseData,
>,
) -> Result<Self, Self::Error> {
Ok(Self {
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(
item.response.transaction_id.to_string(),
),
redirection_data: Box::new(None),
mandate_reference: Box::new(None),
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: item.response.invoice_number.clone(),
incremental_authorization_allowed: None,
charges: None,
}),
status: enums::AttemptStatus::from(item.response),
..item.data
})
}
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct HelcimVoidRequest {
card_transaction_id: u64,
ip_address: Secret<String, IpAddress>,
#[serde(skip_serializing_if = "Option::is_none")]
ecommerce: Option<bool>,
}
impl TryFrom<&PaymentsCancelRouterData> for HelcimVoidRequest {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(item: &PaymentsCancelRouterData) -> Result<Self, Self::Error> {
let ip_address = item.request.get_browser_info()?.get_ip_address()?;
Ok(Self {
card_transaction_id: item
.request
.connector_transaction_id
.parse::<u64>()
.change_context(errors::ConnectorError::RequestEncodingFailed)?,
ip_address,
ecommerce: None,
})
}
}
impl<F>
TryFrom<ResponseRouterData<F, HelcimPaymentsResponse, PaymentsCancelData, PaymentsResponseData>>
for RouterData<F, PaymentsCancelData, PaymentsResponseData>
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: ResponseRouterData<
F,
HelcimPaymentsResponse,
PaymentsCancelData,
PaymentsResponseData,
>,
) -> Result<Self, Self::Error> {
Ok(Self {
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(
item.response.transaction_id.to_string(),
),
redirection_data: Box::new(None),
mandate_reference: Box::new(None),
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: item.response.invoice_number.clone(),
incremental_authorization_allowed: None,
charges: None,
}),
status: enums::AttemptStatus::from(item.response),
..item.data
})
}
}
// REFUND :
// Type definition for RefundRequest
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct HelcimRefundRequest {
amount: FloatMajorUnit,
original_transaction_id: u64,
ip_address: Secret<String, IpAddress>,
#[serde(skip_serializing_if = "Option::is_none")]
ecommerce: Option<bool>,
}
impl<F> TryFrom<&HelcimRouterData<&RefundsRouterData<F>>> for HelcimRefundRequest {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(item: &HelcimRouterData<&RefundsRouterData<F>>) -> Result<Self, Self::Error> {
let original_transaction_id = item
.router_data
.request
.connector_transaction_id
.parse::<u64>()
.change_context(errors::ConnectorError::RequestEncodingFailed)?;
let ip_address = item
.router_data
.request
.get_browser_info()?
.get_ip_address()?;
Ok(Self {
amount: item.amount,
original_transaction_id,
ip_address,
ecommerce: None,
})
}
}
#[derive(Debug, Deserialize, Serialize)]
#[serde(rename_all = "lowercase")]
pub enum HelcimRefundTransactionType {
Refund,
}
#[derive(Debug, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct RefundResponse {
status: HelcimPaymentStatus,
transaction_id: u64,
#[serde(rename = "type")]
transaction_type: HelcimRefundTransactionType,
}
impl From<RefundResponse> for enums::RefundStatus {
fn from(item: RefundResponse) -> Self {
match item.transaction_type {
HelcimRefundTransactionType::Refund => match item.status {
HelcimPaymentStatus::Approved => Self::Success,
HelcimPaymentStatus::Declined => Self::Failure,
},
}
}
}
impl TryFrom<RefundsResponseRouterData<Execute, RefundResponse>> for RefundsRouterData<Execute> {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: RefundsResponseRouterData<Execute, RefundResponse>,
) -> Result<Self, Self::Error> {
Ok(Self {
response: Ok(RefundsResponseData {
connector_refund_id: item.response.transaction_id.to_string(),
refund_status: enums::RefundStatus::from(item.response),
}),
..item.data
})
}
}
impl TryFrom<RefundsResponseRouterData<RSync, RefundResponse>> for RefundsRouterData<RSync> {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: RefundsResponseRouterData<RSync, RefundResponse>,
) -> Result<Self, Self::Error> {
Ok(Self {
response: Ok(RefundsResponseData {
connector_refund_id: item.response.transaction_id.to_string(),
refund_status: enums::RefundStatus::from(item.response),
}),
..item.data
})
}
}
#[derive(Debug, strum::Display, Deserialize, Serialize)]
#[serde(untagged)]
pub enum HelcimErrorTypes {
StringType(String),
JsonType(serde_json::Value),
}
#[derive(Debug, Deserialize, Serialize)]
pub struct HelcimPaymentsErrorResponse {
pub errors: HelcimErrorTypes,
}
#[derive(Debug, Deserialize, Serialize)]
#[serde(untagged)]
pub enum HelcimErrorResponse {
Payment(HelcimPaymentsErrorResponse),
General(String),
}
|
{
"crate": "hyperswitch_connectors",
"file": "crates/hyperswitch_connectors/src/connectors/helcim/transformers.rs",
"file_size": null,
"is_async": null,
"is_pub": null,
"num_enums": 5,
"num_structs": 14,
"num_tables": null,
"score": null,
"total_crates": null
}
|
file_hyperswitch_connectors_6757878662117850365
|
clm
|
file
|
// Repository: hyperswitch
// Crate: hyperswitch_connectors
// File: crates/hyperswitch_connectors/src/connectors/airwallex/transformers.rs
// Contains: 54 structs, 16 enums
use common_enums::enums;
use common_utils::{
errors::ParsingError,
pii::{Email, IpAddress},
request::Method,
types::{MinorUnit, StringMajorUnit},
};
use error_stack::ResultExt;
use hyperswitch_domain_models::{
payment_method_data::{
BankRedirectData, BankTransferData, PayLaterData, PaymentMethodData, WalletData,
},
router_data::{AccessToken, ConnectorAuthType, RouterData},
router_flow_types::{
refunds::{Execute, RSync},
PSync,
},
router_request_types::{PaymentsSyncData, ResponseId},
router_response_types::{PaymentsResponseData, RedirectForm, RefundsResponseData},
types,
};
use hyperswitch_interfaces::errors;
use masking::{ExposeInterface, PeekInterface, Secret};
use serde::{Deserialize, Serialize};
use time::PrimitiveDateTime;
use url::Url;
use uuid::Uuid;
use crate::{
types::{RefundsResponseRouterData, ResponseRouterData},
utils::{
self, BrowserInformationData, CardData as _, ForeignTryFrom, PaymentsAuthorizeRequestData,
PhoneDetailsData, RouterData as _,
},
};
pub struct AirwallexAuthType {
pub x_api_key: Secret<String>,
pub x_client_id: Secret<String>,
}
impl TryFrom<&ConnectorAuthType> for AirwallexAuthType {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(auth_type: &ConnectorAuthType) -> Result<Self, Self::Error> {
if let ConnectorAuthType::BodyKey { api_key, key1 } = auth_type {
Ok(Self {
x_api_key: api_key.clone(),
x_client_id: key1.clone(),
})
} else {
Err(errors::ConnectorError::FailedToObtainAuthType)?
}
}
}
#[derive(Default, Debug, Serialize, Eq, PartialEq)]
pub struct ReferrerData {
#[serde(rename = "type")]
r_type: String,
version: String,
}
#[derive(Default, Debug, Serialize, Eq, PartialEq)]
pub struct AirwallexIntentRequest {
// Unique ID to be sent for each transaction/operation request to the connector
request_id: String,
amount: StringMajorUnit,
currency: enums::Currency,
//ID created in merchant's order system that corresponds to this PaymentIntent.
merchant_order_id: String,
// This data is required to whitelist Hyperswitch at Airwallex.
referrer_data: ReferrerData,
order: Option<AirwallexOrderData>,
}
impl TryFrom<&AirwallexRouterData<&types::PaymentsPreProcessingRouterData>>
for AirwallexIntentRequest
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: &AirwallexRouterData<&types::PaymentsPreProcessingRouterData>,
) -> Result<Self, Self::Error> {
let referrer_data = ReferrerData {
r_type: "hyperswitch".to_string(),
version: "1.0.0".to_string(),
};
let amount = item.amount.clone();
let currency = item.router_data.request.currency.ok_or(
errors::ConnectorError::MissingRequiredField {
field_name: "currency",
},
)?;
let order = match item.router_data.request.payment_method_data {
Some(PaymentMethodData::PayLater(_)) => Some(
item.router_data
.request
.order_details
.as_ref()
.map(|order_data| AirwallexOrderData {
products: order_data
.iter()
.map(|product| AirwallexProductData {
name: product.product_name.clone(),
quantity: product.quantity,
unit_price: product.amount,
})
.collect(),
shipping: Some(AirwallexShippingData {
first_name: item.router_data.get_optional_shipping_first_name(),
last_name: item.router_data.get_optional_shipping_last_name(),
phone_number: item.router_data.get_optional_shipping_phone_number(),
address: AirwallexPLShippingAddress {
country_code: item.router_data.get_optional_shipping_country(),
city: item.router_data.get_optional_shipping_city(),
street: item.router_data.get_optional_shipping_line1(),
postcode: item.router_data.get_optional_shipping_zip(),
},
}),
})
.ok_or(errors::ConnectorError::MissingRequiredField {
field_name: "order_details",
})?,
),
_ => None,
};
Ok(Self {
request_id: Uuid::new_v4().to_string(),
amount,
currency,
merchant_order_id: item.router_data.connector_request_reference_id.clone(),
referrer_data,
order,
})
}
}
#[derive(Debug, Serialize)]
pub struct AirwallexRouterData<T> {
pub amount: StringMajorUnit,
pub router_data: T,
}
impl<T> TryFrom<(StringMajorUnit, T)> for AirwallexRouterData<T> {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from((amount, router_data): (StringMajorUnit, T)) -> Result<Self, Self::Error> {
Ok(Self {
amount,
router_data,
})
}
}
#[derive(Debug, Serialize)]
pub struct AirwallexPaymentsRequest {
// Unique ID to be sent for each transaction/operation request to the connector
request_id: String,
payment_method: AirwallexPaymentMethod,
payment_method_options: Option<AirwallexPaymentOptions>,
return_url: Option<String>,
device_data: DeviceData,
}
#[derive(Debug, Serialize, Eq, PartialEq, Default)]
pub struct AirwallexOrderData {
products: Vec<AirwallexProductData>,
shipping: Option<AirwallexShippingData>,
}
#[derive(Debug, Serialize, Eq, PartialEq)]
pub struct AirwallexProductData {
name: String,
quantity: u16,
unit_price: MinorUnit,
}
#[derive(Debug, Serialize, Eq, PartialEq)]
pub struct AirwallexShippingData {
first_name: Option<Secret<String>>,
last_name: Option<Secret<String>>,
phone_number: Option<Secret<String>>,
address: AirwallexPLShippingAddress,
}
#[derive(Debug, Serialize, Eq, PartialEq)]
pub struct AirwallexPLShippingAddress {
country_code: Option<enums::CountryAlpha2>,
city: Option<String>,
street: Option<Secret<String>>,
postcode: Option<Secret<String>>,
}
#[derive(Debug, Serialize)]
pub struct DeviceData {
accept_header: String,
browser: Browser,
ip_address: Secret<String, IpAddress>,
language: String,
mobile: Option<Mobile>,
screen_color_depth: u8,
screen_height: u32,
screen_width: u32,
timezone: String,
}
#[derive(Debug, Serialize)]
pub struct Browser {
java_enabled: bool,
javascript_enabled: bool,
user_agent: String,
}
#[derive(Debug, Serialize)]
pub struct Mobile {
device_model: Option<String>,
os_type: Option<String>,
os_version: Option<String>,
}
#[derive(Debug, Serialize)]
#[serde(untagged)]
pub enum AirwallexPaymentMethod {
Card(AirwallexCard),
Wallets(AirwallexWalletData),
PayLater(AirwallexPayLaterData),
BankRedirect(AirwallexBankRedirectData),
BankTransfer(AirwallexBankTransferData),
}
#[derive(Debug, Serialize)]
pub struct AirwallexCard {
card: AirwallexCardDetails,
#[serde(rename = "type")]
payment_method_type: AirwallexPaymentType,
}
#[derive(Debug, Serialize)]
pub struct AirwallexCardDetails {
expiry_month: Secret<String>,
expiry_year: Secret<String>,
number: cards::CardNumber,
cvc: Secret<String>,
}
#[derive(Debug, Serialize)]
#[serde(untagged)]
pub enum AirwallexWalletData {
GooglePay(GooglePayData),
Paypal(PaypalData),
Skrill(SkrillData),
}
#[derive(Debug, Serialize)]
pub struct GooglePayData {
googlepay: GooglePayDetails,
#[serde(rename = "type")]
payment_method_type: AirwallexPaymentType,
}
#[derive(Debug, Serialize)]
pub struct PaypalData {
paypal: PaypalDetails,
#[serde(rename = "type")]
payment_method_type: AirwallexPaymentType,
}
#[derive(Debug, Serialize)]
pub struct SkrillData {
skrill: SkrillDetails,
#[serde(rename = "type")]
payment_method_type: AirwallexPaymentType,
}
#[derive(Debug, Serialize)]
pub struct GooglePayDetails {
encrypted_payment_token: Secret<String>,
payment_data_type: GpayPaymentDataType,
}
#[derive(Debug, Serialize)]
pub struct PaypalDetails {
shopper_name: Secret<String>,
country_code: enums::CountryAlpha2,
}
#[derive(Debug, Serialize)]
pub struct SkrillDetails {
shopper_name: Secret<String>,
shopper_email: Email,
country_code: enums::CountryAlpha2,
}
#[derive(Debug, Serialize)]
#[serde(untagged)]
pub enum AirwallexPayLaterData {
Klarna(Box<KlarnaData>),
Atome(AtomeData),
}
#[derive(Debug, Serialize)]
pub struct KlarnaData {
klarna: KlarnaDetails,
#[serde(rename = "type")]
payment_method_type: AirwallexPaymentType,
}
#[derive(Debug, Serialize)]
pub struct KlarnaDetails {
country_code: enums::CountryAlpha2,
billing: Option<Billing>,
}
#[derive(Debug, Serialize)]
pub struct Billing {
date_of_birth: Option<Secret<String>>,
email: Option<Email>,
first_name: Option<Secret<String>>,
last_name: Option<Secret<String>>,
phone_number: Option<Secret<String>>,
address: Option<AddressAirwallex>,
}
#[derive(Debug, Serialize)]
pub struct AddressAirwallex {
country_code: Option<enums::CountryAlpha2>,
city: Option<String>,
street: Option<Secret<String>>,
postcode: Option<Secret<String>>,
}
#[derive(Debug, Serialize)]
pub struct AtomeData {
atome: AtomeDetails,
#[serde(rename = "type")]
payment_method_type: AirwallexPaymentType,
}
#[derive(Debug, Serialize)]
pub struct AtomeDetails {
shopper_phone: Secret<String>,
}
#[derive(Debug, Serialize)]
#[serde(untagged)]
pub enum AirwallexBankTransferData {
IndonesianBankTransfer(IndonesianBankTransferData),
}
#[derive(Debug, Serialize)]
pub struct IndonesianBankTransferData {
bank_transfer: IndonesianBankTransferDetails,
#[serde(rename = "type")]
payment_method_type: AirwallexPaymentType,
}
#[derive(Debug, Serialize)]
pub struct IndonesianBankTransferDetails {
shopper_name: Secret<String>,
shopper_email: Email,
bank_name: common_enums::BankNames,
country_code: enums::CountryAlpha2,
}
#[derive(Debug, Serialize)]
#[serde(untagged)]
pub enum AirwallexBankRedirectData {
Trustly(TrustlyData),
Blik(BlikData),
Ideal(IdealData),
}
#[derive(Debug, Serialize)]
pub struct TrustlyData {
trustly: TrustlyDetails,
#[serde(rename = "type")]
payment_method_type: AirwallexPaymentType,
}
#[derive(Debug, Serialize)]
pub struct TrustlyDetails {
shopper_name: Secret<String>,
country_code: enums::CountryAlpha2,
}
#[derive(Debug, Serialize)]
pub struct BlikData {
blik: BlikDetails,
#[serde(rename = "type")]
payment_method_type: AirwallexPaymentType,
}
#[derive(Debug, Serialize)]
pub struct BlikDetails {
shopper_name: Secret<String>,
}
#[derive(Debug, Serialize)]
pub struct IdealData {
ideal: IdealDetails,
#[serde(rename = "type")]
payment_method_type: AirwallexPaymentType,
}
#[derive(Debug, Serialize)]
pub struct IdealDetails {
bank_name: Option<common_enums::BankNames>,
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "snake_case")]
pub enum AirwallexPaymentType {
Card,
Googlepay,
Paypal,
Klarna,
Atome,
Trustly,
Blik,
Ideal,
Skrill,
BankTransfer,
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "snake_case")]
pub enum GpayPaymentDataType {
EncryptedPaymentToken,
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "snake_case")]
pub enum AirwallexPaymentOptions {
Card(AirwallexCardPaymentOptions),
Klarna(AirwallexPayLaterPaymentOptions),
Atome(AirwallexPayLaterPaymentOptions),
}
#[derive(Debug, Serialize)]
pub struct AirwallexCardPaymentOptions {
auto_capture: bool,
}
#[derive(Debug, Serialize)]
pub struct AirwallexPayLaterPaymentOptions {
auto_capture: bool,
}
impl TryFrom<&AirwallexRouterData<&types::PaymentsAuthorizeRouterData>>
for AirwallexPaymentsRequest
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: &AirwallexRouterData<&types::PaymentsAuthorizeRouterData>,
) -> Result<Self, Self::Error> {
let mut payment_method_options = None;
let request = &item.router_data.request;
let payment_method = match request.payment_method_data.clone() {
PaymentMethodData::Card(ccard) => {
payment_method_options =
Some(AirwallexPaymentOptions::Card(AirwallexCardPaymentOptions {
auto_capture: matches!(
request.capture_method,
Some(enums::CaptureMethod::Automatic)
| Some(enums::CaptureMethod::SequentialAutomatic)
| None
),
}));
Ok(AirwallexPaymentMethod::Card(AirwallexCard {
card: AirwallexCardDetails {
number: ccard.card_number.clone(),
expiry_month: ccard.card_exp_month.clone(),
expiry_year: ccard.get_expiry_year_4_digit(),
cvc: ccard.card_cvc,
},
payment_method_type: AirwallexPaymentType::Card,
}))
}
PaymentMethodData::Wallet(ref wallet_data) => get_wallet_details(wallet_data, item),
PaymentMethodData::PayLater(ref paylater_data) => {
let paylater_options = AirwallexPayLaterPaymentOptions {
auto_capture: item.router_data.request.is_auto_capture()?,
};
payment_method_options = match paylater_data {
PayLaterData::KlarnaRedirect { .. } => {
Some(AirwallexPaymentOptions::Klarna(paylater_options))
}
PayLaterData::AtomeRedirect { .. } => {
Some(AirwallexPaymentOptions::Atome(paylater_options))
}
_ => None,
};
get_paylater_details(paylater_data, item)
}
PaymentMethodData::BankTransfer(ref banktransfer_data) => {
get_banktransfer_details(banktransfer_data, item)
}
PaymentMethodData::BankRedirect(ref bankredirect_data) => {
get_bankredirect_details(bankredirect_data, item)
}
PaymentMethodData::BankDebit(_)
| PaymentMethodData::CardRedirect(_)
| PaymentMethodData::Crypto(_)
| PaymentMethodData::MandatePayment
| PaymentMethodData::Reward
| PaymentMethodData::RealTimePayment(_)
| PaymentMethodData::MobilePayment(_)
| PaymentMethodData::Upi(_)
| PaymentMethodData::Voucher(_)
| PaymentMethodData::GiftCard(_)
| PaymentMethodData::OpenBanking(_)
| PaymentMethodData::CardToken(_)
| PaymentMethodData::NetworkToken(_)
| PaymentMethodData::CardDetailsForNetworkTransactionId(_) => {
Err(errors::ConnectorError::NotImplemented(
utils::get_unimplemented_payment_method_error_message("airwallex"),
))
}
}?;
let device_data = get_device_data(item.router_data)?;
let return_url = match &request.payment_method_data {
PaymentMethodData::Wallet(wallet_data) => match wallet_data {
WalletData::PaypalRedirect(_paypal_details) => {
item.router_data.request.router_return_url.clone()
}
WalletData::Skrill(_) => item.router_data.request.router_return_url.clone(),
_ => request.complete_authorize_url.clone(),
},
PaymentMethodData::BankRedirect(_bankredirect_data) => {
item.router_data.request.router_return_url.clone()
}
PaymentMethodData::PayLater(_paylater_data) => {
item.router_data.request.router_return_url.clone()
}
_ => request.complete_authorize_url.clone(),
};
Ok(Self {
request_id: Uuid::new_v4().to_string(),
payment_method,
payment_method_options,
return_url,
device_data,
})
}
}
fn get_device_data(
item: &types::PaymentsAuthorizeRouterData,
) -> Result<DeviceData, error_stack::Report<errors::ConnectorError>> {
let info = item.request.get_browser_info()?;
let browser = Browser {
java_enabled: info.get_java_enabled()?,
javascript_enabled: info.get_java_script_enabled()?,
user_agent: info.get_user_agent()?,
};
let mobile = {
let device_model = info.get_device_model().ok();
let os_type = info.get_os_type().ok();
let os_version = info.get_os_version().ok();
if device_model.is_some() || os_type.is_some() || os_version.is_some() {
Some(Mobile {
device_model,
os_type,
os_version,
})
} else {
None
}
};
Ok(DeviceData {
accept_header: info.get_accept_header()?,
browser,
ip_address: info.get_ip_address()?,
mobile,
screen_color_depth: info.get_color_depth()?,
screen_height: info.get_screen_height()?,
screen_width: info.get_screen_width()?,
timezone: info.get_time_zone()?.to_string(),
language: info.get_language()?,
})
}
fn get_banktransfer_details(
banktransfer_data: &BankTransferData,
item: &AirwallexRouterData<&types::PaymentsAuthorizeRouterData>,
) -> Result<AirwallexPaymentMethod, errors::ConnectorError> {
let _bank_transfer_details = match banktransfer_data {
BankTransferData::IndonesianBankTransfer { bank_name } => {
AirwallexPaymentMethod::BankTransfer(AirwallexBankTransferData::IndonesianBankTransfer(
IndonesianBankTransferData {
bank_transfer: IndonesianBankTransferDetails {
shopper_name: item.router_data.get_billing_full_name().map_err(|_| {
errors::ConnectorError::MissingRequiredField {
field_name: "shopper_name",
}
})?,
shopper_email: item.router_data.get_billing_email().map_err(|_| {
errors::ConnectorError::MissingRequiredField {
field_name: "shopper_email",
}
})?,
bank_name: bank_name.ok_or(
errors::ConnectorError::MissingRequiredField {
field_name: "bank_name",
},
)?,
country_code: item.router_data.get_billing_country().map_err(|_| {
errors::ConnectorError::MissingRequiredField {
field_name: "country_code",
}
})?,
},
payment_method_type: AirwallexPaymentType::BankTransfer,
},
))
}
_ => Err(errors::ConnectorError::NotImplemented(
utils::get_unimplemented_payment_method_error_message("airwallex"),
))?,
};
let not_implemented = Err(errors::ConnectorError::NotImplemented(
utils::get_unimplemented_payment_method_error_message("airwallex"),
))?;
Ok(not_implemented)
}
fn get_paylater_details(
paylater_data: &PayLaterData,
item: &AirwallexRouterData<&types::PaymentsAuthorizeRouterData>,
) -> Result<AirwallexPaymentMethod, errors::ConnectorError> {
let paylater_details = match paylater_data {
PayLaterData::KlarnaRedirect {} => {
AirwallexPaymentMethod::PayLater(AirwallexPayLaterData::Klarna(Box::new(KlarnaData {
klarna: KlarnaDetails {
country_code: item.router_data.get_billing_country().map_err(|_| {
errors::ConnectorError::MissingRequiredField {
field_name: "country_code",
}
})?,
billing: Some(Billing {
date_of_birth: None,
first_name: item.router_data.get_optional_billing_first_name(),
last_name: item.router_data.get_optional_billing_last_name(),
email: item.router_data.get_optional_billing_email(),
phone_number: item.router_data.get_optional_billing_phone_number(),
address: Some(AddressAirwallex {
country_code: item.router_data.get_optional_billing_country(),
city: item.router_data.get_optional_billing_city(),
street: item.router_data.get_optional_billing_line1(),
postcode: item.router_data.get_optional_billing_zip(),
}),
}),
},
payment_method_type: AirwallexPaymentType::Klarna,
})))
}
PayLaterData::AtomeRedirect {} => {
AirwallexPaymentMethod::PayLater(AirwallexPayLaterData::Atome(AtomeData {
atome: AtomeDetails {
shopper_phone: item
.router_data
.get_billing_phone()
.map_err(|_| errors::ConnectorError::MissingRequiredField {
field_name: "shopper_phone",
})?
.get_number_with_country_code()
.map_err(|_| errors::ConnectorError::MissingRequiredField {
field_name: "country_code",
})?,
},
payment_method_type: AirwallexPaymentType::Atome,
}))
}
_ => Err(errors::ConnectorError::NotImplemented(
utils::get_unimplemented_payment_method_error_message("airwallex"),
))?,
};
Ok(paylater_details)
}
fn get_bankredirect_details(
bankredirect_data: &BankRedirectData,
item: &AirwallexRouterData<&types::PaymentsAuthorizeRouterData>,
) -> Result<AirwallexPaymentMethod, errors::ConnectorError> {
let bank_redirect_details = match bankredirect_data {
BankRedirectData::Trustly { .. } => {
AirwallexPaymentMethod::BankRedirect(AirwallexBankRedirectData::Trustly(TrustlyData {
trustly: TrustlyDetails {
shopper_name: item.router_data.get_billing_full_name().map_err(|_| {
errors::ConnectorError::MissingRequiredField {
field_name: "shopper_name",
}
})?,
country_code: item.router_data.get_billing_country().map_err(|_| {
errors::ConnectorError::MissingRequiredField {
field_name: "country_code",
}
})?,
},
payment_method_type: AirwallexPaymentType::Trustly,
}))
}
BankRedirectData::Blik { .. } => {
AirwallexPaymentMethod::BankRedirect(AirwallexBankRedirectData::Blik(BlikData {
blik: BlikDetails {
shopper_name: item.router_data.get_billing_full_name().map_err(|_| {
errors::ConnectorError::MissingRequiredField {
field_name: "shopper_name",
}
})?,
},
payment_method_type: AirwallexPaymentType::Blik,
}))
}
BankRedirectData::Ideal { .. } => {
AirwallexPaymentMethod::BankRedirect(AirwallexBankRedirectData::Ideal(IdealData {
ideal: IdealDetails { bank_name: None },
payment_method_type: AirwallexPaymentType::Ideal,
}))
}
_ => Err(errors::ConnectorError::NotImplemented(
utils::get_unimplemented_payment_method_error_message("airwallex"),
))?,
};
Ok(bank_redirect_details)
}
fn get_wallet_details(
wallet_data: &WalletData,
item: &AirwallexRouterData<&types::PaymentsAuthorizeRouterData>,
) -> Result<AirwallexPaymentMethod, errors::ConnectorError> {
let wallet_details: AirwallexPaymentMethod = match wallet_data {
WalletData::GooglePay(gpay_details) => {
let token = gpay_details
.tokenization_data
.get_encrypted_google_pay_token()
.attach_printable("Failed to get gpay wallet token")
.map_err(|_| errors::ConnectorError::MissingRequiredField {
field_name: "gpay wallet_token",
})?;
AirwallexPaymentMethod::Wallets(AirwallexWalletData::GooglePay(GooglePayData {
googlepay: GooglePayDetails {
encrypted_payment_token: Secret::new(token.clone()),
payment_data_type: GpayPaymentDataType::EncryptedPaymentToken,
},
payment_method_type: AirwallexPaymentType::Googlepay,
}))
}
WalletData::PaypalRedirect(_paypal_details) => {
AirwallexPaymentMethod::Wallets(AirwallexWalletData::Paypal(PaypalData {
paypal: PaypalDetails {
shopper_name: item
.router_data
.request
.customer_name
.as_ref()
.cloned()
.or_else(|| item.router_data.get_billing_full_name().ok())
.ok_or(errors::ConnectorError::MissingRequiredField {
field_name: "shopper_name",
})?,
country_code: item.router_data.get_billing_country().map_err(|_| {
errors::ConnectorError::MissingRequiredField {
field_name: "country_code",
}
})?,
},
payment_method_type: AirwallexPaymentType::Paypal,
}))
}
WalletData::Skrill(_skrill_details) => {
AirwallexPaymentMethod::Wallets(AirwallexWalletData::Skrill(SkrillData {
skrill: SkrillDetails {
shopper_name: item
.router_data
.request
.customer_name
.as_ref()
.cloned()
.or_else(|| item.router_data.get_billing_full_name().ok())
.ok_or(errors::ConnectorError::MissingRequiredField {
field_name: "shopper_name",
})?,
shopper_email: item.router_data.get_billing_email().map_err(|_| {
errors::ConnectorError::MissingRequiredField {
field_name: "shopper_email",
}
})?,
country_code: item.router_data.get_billing_country().map_err(|_| {
errors::ConnectorError::MissingRequiredField {
field_name: "country_code",
}
})?,
},
payment_method_type: AirwallexPaymentType::Skrill,
}))
}
WalletData::AliPayQr(_)
| WalletData::AliPayRedirect(_)
| WalletData::AliPayHkRedirect(_)
| WalletData::AmazonPayRedirect(_)
| WalletData::Paysera(_)
| WalletData::MomoRedirect(_)
| WalletData::KakaoPayRedirect(_)
| WalletData::GoPayRedirect(_)
| WalletData::GcashRedirect(_)
| WalletData::AmazonPay(_)
| WalletData::ApplePay(_)
| WalletData::BluecodeRedirect {}
| WalletData::ApplePayRedirect(_)
| WalletData::ApplePayThirdPartySdk(_)
| WalletData::DanaRedirect {}
| WalletData::GooglePayRedirect(_)
| WalletData::GooglePayThirdPartySdk(_)
| WalletData::MbWayRedirect(_)
| WalletData::MobilePayRedirect(_)
| WalletData::PaypalSdk(_)
| WalletData::Paze(_)
| WalletData::SamsungPay(_)
| WalletData::TwintRedirect {}
| WalletData::VippsRedirect {}
| WalletData::TouchNGoRedirect(_)
| WalletData::WeChatPayRedirect(_)
| WalletData::WeChatPayQr(_)
| WalletData::CashappQr(_)
| WalletData::SwishQr(_)
| WalletData::Mifinity(_)
| WalletData::RevolutPay(_) => Err(errors::ConnectorError::NotImplemented(
utils::get_unimplemented_payment_method_error_message("airwallex"),
))?,
};
Ok(wallet_details)
}
#[derive(Deserialize, Debug, Serialize)]
pub struct AirwallexAuthUpdateResponse {
#[serde(with = "common_utils::custom_serde::iso8601")]
expires_at: PrimitiveDateTime,
token: Secret<String>,
}
impl<F, T> TryFrom<ResponseRouterData<F, AirwallexAuthUpdateResponse, T, AccessToken>>
for RouterData<F, T, AccessToken>
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: ResponseRouterData<F, AirwallexAuthUpdateResponse, T, AccessToken>,
) -> Result<Self, Self::Error> {
let expires = (item.response.expires_at - common_utils::date_time::now()).whole_seconds();
Ok(Self {
response: Ok(AccessToken {
token: item.response.token,
expires,
}),
..item.data
})
}
}
#[derive(Default, Debug, Serialize, Eq, PartialEq)]
pub struct AirwallexCompleteRequest {
request_id: String,
three_ds: AirwallexThreeDsData,
#[serde(rename = "type")]
three_ds_type: AirwallexThreeDsType,
}
#[derive(Default, Debug, Serialize, Eq, PartialEq)]
pub struct AirwallexThreeDsData {
acs_response: Option<Secret<String>>,
}
#[derive(Default, Debug, Serialize, Eq, PartialEq)]
pub enum AirwallexThreeDsType {
#[default]
#[serde(rename = "3ds_continue")]
ThreeDSContinue,
}
impl TryFrom<&types::PaymentsCompleteAuthorizeRouterData> for AirwallexCompleteRequest {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(item: &types::PaymentsCompleteAuthorizeRouterData) -> Result<Self, Self::Error> {
Ok(Self {
request_id: Uuid::new_v4().to_string(),
three_ds: AirwallexThreeDsData {
acs_response: item
.request
.redirect_response
.as_ref()
.map(|f| f.payload.to_owned())
.ok_or(errors::ConnectorError::MissingRequiredField {
field_name: "redirect_response.payload",
})?
.as_ref()
.map(|data| serde_json::to_string(data.peek()))
.transpose()
.change_context(errors::ConnectorError::ResponseDeserializationFailed)?
.map(Secret::new),
},
three_ds_type: AirwallexThreeDsType::ThreeDSContinue,
})
}
}
#[derive(Default, Debug, Serialize, Eq, PartialEq)]
pub struct AirwallexPaymentsCaptureRequest {
// Unique ID to be sent for each transaction/operation request to the connector
request_id: String,
amount: Option<String>,
}
impl TryFrom<&types::PaymentsCaptureRouterData> for AirwallexPaymentsCaptureRequest {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(item: &types::PaymentsCaptureRouterData) -> Result<Self, Self::Error> {
Ok(Self {
request_id: Uuid::new_v4().to_string(),
amount: Some(utils::to_currency_base_unit(
item.request.amount_to_capture,
item.request.currency,
)?),
})
}
}
#[derive(Default, Debug, Serialize, Eq, PartialEq)]
pub struct AirwallexPaymentsCancelRequest {
// Unique ID to be sent for each transaction/operation request to the connector
request_id: String,
cancellation_reason: Option<String>,
}
impl TryFrom<&types::PaymentsCancelRouterData> for AirwallexPaymentsCancelRequest {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(item: &types::PaymentsCancelRouterData) -> Result<Self, Self::Error> {
Ok(Self {
request_id: Uuid::new_v4().to_string(),
cancellation_reason: item.request.cancellation_reason.clone(),
})
}
}
// PaymentsResponse
#[derive(Debug, Clone, Default, Deserialize, PartialEq, Serialize)]
#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
pub enum AirwallexPaymentStatus {
Succeeded,
Failed,
#[default]
Pending,
RequiresPaymentMethod,
RequiresCustomerAction,
RequiresCapture,
Cancelled,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum AirwallexNextAction {
Payments(AirwallexPaymentsNextAction),
Redirect(AirwallexRedirectNextAction),
}
fn get_payment_status(
status: &AirwallexPaymentStatus,
next_action: &Option<AirwallexNextAction>,
) -> enums::AttemptStatus {
match status.clone() {
AirwallexPaymentStatus::Succeeded => enums::AttemptStatus::Charged,
AirwallexPaymentStatus::Failed => enums::AttemptStatus::Failure,
AirwallexPaymentStatus::Pending => enums::AttemptStatus::Pending,
AirwallexPaymentStatus::RequiresPaymentMethod => enums::AttemptStatus::PaymentMethodAwaited,
AirwallexPaymentStatus::RequiresCustomerAction => next_action.as_ref().map_or(
enums::AttemptStatus::AuthenticationPending,
|next_action| match next_action {
AirwallexNextAction::Payments(payments_next_action) => {
match payments_next_action.stage {
AirwallexNextActionStage::WaitingDeviceDataCollection => {
enums::AttemptStatus::DeviceDataCollectionPending
}
AirwallexNextActionStage::WaitingUserInfoInput => {
enums::AttemptStatus::AuthenticationPending
}
}
}
AirwallexNextAction::Redirect(_) => enums::AttemptStatus::AuthenticationPending,
},
),
AirwallexPaymentStatus::RequiresCapture => enums::AttemptStatus::Authorized,
AirwallexPaymentStatus::Cancelled => enums::AttemptStatus::Voided,
}
}
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
pub enum AirwallexNextActionStage {
WaitingDeviceDataCollection,
WaitingUserInfoInput,
}
#[derive(Debug, Clone, Deserialize, PartialEq, Serialize)]
pub struct AirwallexRedirectFormData {
#[serde(rename = "JWT")]
jwt: Option<Secret<String>>,
#[serde(rename = "threeDSMethodData")]
three_ds_method_data: Option<Secret<String>>,
token: Option<Secret<String>>,
provider: Option<String>,
version: Option<String>,
}
#[derive(Debug, Clone, Deserialize, PartialEq, Serialize)]
pub struct AirwallexPaymentsNextAction {
url: Url,
method: Method,
data: AirwallexRedirectFormData,
stage: AirwallexNextActionStage,
}
#[derive(Debug, Clone, Deserialize, PartialEq, Serialize)]
pub struct AirwallexRedirectNextAction {
url: Url,
method: Method,
}
#[derive(Default, Debug, Clone, Deserialize, PartialEq, Serialize)]
pub struct AirwallexPaymentsResponse {
status: AirwallexPaymentStatus,
//Unique identifier for the PaymentIntent
id: String,
amount: Option<f32>,
//ID of the PaymentConsent related to this PaymentIntent
payment_consent_id: Option<Secret<String>>,
next_action: Option<AirwallexPaymentsNextAction>,
}
#[derive(Default, Debug, Clone, Deserialize, PartialEq, Serialize)]
pub struct AirwallexRedirectResponse {
status: AirwallexPaymentStatus,
id: String,
amount: Option<f32>,
payment_consent_id: Option<Secret<String>>,
next_action: Option<AirwallexRedirectNextAction>,
}
#[derive(Default, Debug, Clone, Deserialize, PartialEq, Serialize)]
pub struct AirwallexPaymentsSyncResponse {
status: AirwallexPaymentStatus,
//Unique identifier for the PaymentIntent
id: String,
amount: Option<f32>,
//ID of the PaymentConsent related to this PaymentIntent
payment_consent_id: Option<Secret<String>>,
next_action: Option<AirwallexPaymentsNextAction>,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(untagged)]
pub enum AirwallexAuthorizeResponse {
AirwallexPaymentsResponse(AirwallexPaymentsResponse),
AirwallexRedirectResponse(AirwallexRedirectResponse),
}
fn get_redirection_form(response_url_data: AirwallexPaymentsNextAction) -> Option<RedirectForm> {
Some(RedirectForm::Form {
endpoint: response_url_data.url.to_string(),
method: response_url_data.method,
form_fields: std::collections::HashMap::from([
//Some form fields might be empty based on the authentication type by the connector
(
"JWT".to_string(),
response_url_data
.data
.jwt
.map(|jwt| jwt.expose())
.unwrap_or_default(),
),
(
"threeDSMethodData".to_string(),
response_url_data
.data
.three_ds_method_data
.map(|three_ds_method_data| three_ds_method_data.expose())
.unwrap_or_default(),
),
(
"token".to_string(),
response_url_data
.data
.token
.map(|token: Secret<String>| token.expose())
.unwrap_or_default(),
),
(
"provider".to_string(),
response_url_data.data.provider.unwrap_or_default(),
),
(
"version".to_string(),
response_url_data.data.version.unwrap_or_default(),
),
]),
})
}
impl<F, T>
ForeignTryFrom<ResponseRouterData<F, AirwallexAuthorizeResponse, T, PaymentsResponseData>>
for RouterData<F, T, PaymentsResponseData>
{
type Error = error_stack::Report<errors::ConnectorError>;
fn foreign_try_from(
item: ResponseRouterData<F, AirwallexAuthorizeResponse, T, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
let ResponseRouterData {
response,
data,
http_code,
} = item;
match response {
AirwallexAuthorizeResponse::AirwallexPaymentsResponse(res) => {
Self::try_from(ResponseRouterData::<
F,
AirwallexPaymentsResponse,
T,
PaymentsResponseData,
> {
response: res,
data,
http_code,
})
}
AirwallexAuthorizeResponse::AirwallexRedirectResponse(res) => {
Self::try_from(ResponseRouterData::<
F,
AirwallexRedirectResponse,
T,
PaymentsResponseData,
> {
response: res,
data,
http_code,
})
}
}
}
}
impl<F, T> TryFrom<ResponseRouterData<F, AirwallexPaymentsResponse, T, PaymentsResponseData>>
for RouterData<F, T, PaymentsResponseData>
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: ResponseRouterData<F, AirwallexPaymentsResponse, T, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
let (status, redirection_data) = item.response.next_action.clone().map_or(
// If no next action is there, map the status and set redirection form as None
(
get_payment_status(
&item.response.status,
&item
.response
.next_action
.clone()
.map(AirwallexNextAction::Payments)
.clone(),
),
None,
),
|response_url_data| {
// If the connector sends a customer action response that is already under
// process from our end it can cause an infinite loop to break this this check
// is added and fail the payment
if matches!(
(
response_url_data.stage.clone(),
item.data.status,
item.response.status.clone(),
),
// If the connector sends waiting for DDC and our status is already DDC Pending
// that means we initiated the call to collect the data and now we expect a different response
(
AirwallexNextActionStage::WaitingDeviceDataCollection,
enums::AttemptStatus::DeviceDataCollectionPending,
_
)
// If the connector sends waiting for Customer Action and our status is already Authenticaition Pending
// that means we initiated the call to authenticate and now we do not expect a requires_customer action
// it will start a loop
| (
_,
enums::AttemptStatus::AuthenticationPending,
AirwallexPaymentStatus::RequiresCustomerAction,
)
) {
// Fail the payment for above conditions
(enums::AttemptStatus::AuthenticationFailed, None)
} else {
(
//Build the redirect form and update the payment status
get_payment_status(
&item.response.status,
&item
.response
.next_action
.map(AirwallexNextAction::Payments)
.clone(),
),
get_redirection_form(response_url_data),
)
}
},
);
Ok(Self {
status,
reference_id: Some(item.response.id.clone()),
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(item.response.id.clone()),
redirection_data: Box::new(redirection_data),
mandate_reference: Box::new(None),
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: Some(item.response.id),
incremental_authorization_allowed: None,
charges: None,
}),
..item.data
})
}
}
impl<F, T> TryFrom<ResponseRouterData<F, AirwallexRedirectResponse, T, PaymentsResponseData>>
for RouterData<F, T, PaymentsResponseData>
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: ResponseRouterData<F, AirwallexRedirectResponse, T, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
let (status, redirection_data) = item.response.next_action.clone().map_or(
(
get_payment_status(
&item.response.status,
&item
.response
.next_action
.clone()
.map(AirwallexNextAction::Redirect)
.clone(),
),
None,
),
|response_url_data| {
let redirection_data =
Some(RedirectForm::from((response_url_data.url, Method::Get)));
(
get_payment_status(
&item.response.status,
&item
.response
.next_action
.map(AirwallexNextAction::Redirect)
.clone(),
),
redirection_data,
)
},
);
Ok(Self {
status,
reference_id: Some(item.response.id.clone()),
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(item.response.id.clone()),
redirection_data: Box::new(redirection_data),
mandate_reference: Box::new(None),
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: Some(item.response.id),
incremental_authorization_allowed: None,
charges: None,
}),
..item.data
})
}
}
impl
TryFrom<
ResponseRouterData<
PSync,
AirwallexPaymentsSyncResponse,
PaymentsSyncData,
PaymentsResponseData,
>,
> for types::PaymentsSyncRouterData
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: ResponseRouterData<
PSync,
AirwallexPaymentsSyncResponse,
PaymentsSyncData,
PaymentsResponseData,
>,
) -> Result<Self, Self::Error> {
let status = get_payment_status(
&item.response.status,
&item
.response
.next_action
.clone()
.map(AirwallexNextAction::Payments)
.clone(),
);
let redirection_data = if let Some(redirect_url_data) = item.response.next_action {
get_redirection_form(redirect_url_data)
} else {
None
};
Ok(Self {
status,
reference_id: Some(item.response.id.clone()),
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(item.response.id.clone()),
redirection_data: Box::new(redirection_data),
mandate_reference: Box::new(None),
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: Some(item.response.id),
incremental_authorization_allowed: None,
charges: None,
}),
..item.data
})
}
}
// Type definition for RefundRequest
#[derive(Default, Debug, Serialize)]
pub struct AirwallexRefundRequest {
// Unique ID to be sent for each transaction/operation request to the connector
request_id: String,
amount: Option<StringMajorUnit>,
reason: Option<String>,
//Identifier for the PaymentIntent for which Refund is requested
payment_intent_id: String,
}
impl<F> TryFrom<&AirwallexRouterData<&types::RefundsRouterData<F>>> for AirwallexRefundRequest {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: &AirwallexRouterData<&types::RefundsRouterData<F>>,
) -> Result<Self, Self::Error> {
Ok(Self {
request_id: Uuid::new_v4().to_string(),
amount: Some(item.amount.to_owned()),
reason: item.router_data.request.reason.clone(),
payment_intent_id: item.router_data.request.connector_transaction_id.clone(),
})
}
}
// Type definition for Refund Response
#[allow(dead_code)]
#[derive(Debug, Serialize, Default, Deserialize, Clone)]
#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
pub enum RefundStatus {
Succeeded,
Failed,
#[default]
Received,
Accepted,
}
impl From<RefundStatus> for enums::RefundStatus {
fn from(item: RefundStatus) -> Self {
match item {
RefundStatus::Succeeded => Self::Success,
RefundStatus::Failed => Self::Failure,
RefundStatus::Received | RefundStatus::Accepted => Self::Pending,
}
}
}
#[derive(Default, Debug, Clone, Serialize, Deserialize)]
pub struct RefundResponse {
//A unique number that tags a credit or debit card transaction when it goes from the merchant's bank through to the cardholder's bank.
acquirer_reference_number: Option<String>,
amount: f32,
//Unique identifier for the Refund
id: String,
status: RefundStatus,
}
impl TryFrom<RefundsResponseRouterData<Execute, RefundResponse>>
for types::RefundsRouterData<Execute>
{
type Error = error_stack::Report<ParsingError>;
fn try_from(
item: RefundsResponseRouterData<Execute, RefundResponse>,
) -> Result<Self, Self::Error> {
let refund_status = enums::RefundStatus::from(item.response.status);
Ok(Self {
response: Ok(RefundsResponseData {
connector_refund_id: item.response.id,
refund_status,
}),
..item.data
})
}
}
impl TryFrom<RefundsResponseRouterData<RSync, RefundResponse>> for types::RefundsRouterData<RSync> {
type Error = error_stack::Report<ParsingError>;
fn try_from(
item: RefundsResponseRouterData<RSync, RefundResponse>,
) -> Result<Self, Self::Error> {
let refund_status = enums::RefundStatus::from(item.response.status);
Ok(Self {
response: Ok(RefundsResponseData {
connector_refund_id: item.response.id,
refund_status,
}),
..item.data
})
}
}
#[derive(Debug, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct AirwallexWebhookData {
pub source_id: Option<String>,
pub name: AirwallexWebhookEventType,
pub data: AirwallexObjectData,
}
#[derive(Debug, Deserialize, strum::Display, PartialEq)]
pub enum AirwallexWebhookEventType {
#[serde(rename = "payment_intent.created")]
PaymentIntentCreated,
#[serde(rename = "payment_intent.requires_payment_method")]
PaymentIntentRequiresPaymentMethod,
#[serde(rename = "payment_intent.cancelled")]
PaymentIntentCancelled,
#[serde(rename = "payment_intent.succeeded")]
PaymentIntentSucceeded,
#[serde(rename = "payment_intent.requires_capture")]
PaymentIntentRequiresCapture,
#[serde(rename = "payment_intent.requires_customer_action")]
PaymentIntentRequiresCustomerAction,
#[serde(rename = "payment_attempt.authorized")]
PaymentAttemptAuthorized,
#[serde(rename = "payment_attempt.authorization_failed")]
PaymentAttemptAuthorizationFailed,
#[serde(rename = "payment_attempt.capture_requested")]
PaymentAttemptCaptureRequested,
#[serde(rename = "payment_attempt.capture_failed")]
PaymentAttemptCaptureFailed,
#[serde(rename = "payment_attempt.authentication_redirected")]
PaymentAttemptAuthenticationRedirected,
#[serde(rename = "payment_attempt.authentication_failed")]
PaymentAttemptAuthenticationFailed,
#[serde(rename = "payment_attempt.failed_to_process")]
PaymentAttemptFailedToProcess,
#[serde(rename = "payment_attempt.cancelled")]
PaymentAttemptCancelled,
#[serde(rename = "payment_attempt.expired")]
PaymentAttemptExpired,
#[serde(rename = "payment_attempt.risk_declined")]
PaymentAttemptRiskDeclined,
#[serde(rename = "payment_attempt.settled")]
PaymentAttemptSettled,
#[serde(rename = "payment_attempt.paid")]
PaymentAttemptPaid,
#[serde(rename = "refund.received")]
RefundReceived,
#[serde(rename = "refund.accepted")]
RefundAccepted,
#[serde(rename = "refund.succeeded")]
RefundSucceeded,
#[serde(rename = "refund.failed")]
RefundFailed,
#[serde(rename = "dispute.rfi_responded_by_merchant")]
DisputeRfiRespondedByMerchant,
#[serde(rename = "dispute.dispute.pre_chargeback_accepted")]
DisputePreChargebackAccepted,
#[serde(rename = "dispute.accepted")]
DisputeAccepted,
#[serde(rename = "dispute.dispute_received_by_merchant")]
DisputeReceivedByMerchant,
#[serde(rename = "dispute.dispute_responded_by_merchant")]
DisputeRespondedByMerchant,
#[serde(rename = "dispute.won")]
DisputeWon,
#[serde(rename = "dispute.lost")]
DisputeLost,
#[serde(rename = "dispute.dispute_reversed")]
DisputeReversed,
#[serde(other)]
Unknown,
}
pub fn is_transaction_event(event_code: &AirwallexWebhookEventType) -> bool {
matches!(
event_code,
AirwallexWebhookEventType::PaymentAttemptFailedToProcess
| AirwallexWebhookEventType::PaymentAttemptAuthorized
)
}
pub fn is_refund_event(event_code: &AirwallexWebhookEventType) -> bool {
matches!(
event_code,
AirwallexWebhookEventType::RefundSucceeded | AirwallexWebhookEventType::RefundFailed
)
}
pub fn is_dispute_event(event_code: &AirwallexWebhookEventType) -> bool {
matches!(
event_code,
AirwallexWebhookEventType::DisputeAccepted
| AirwallexWebhookEventType::DisputePreChargebackAccepted
| AirwallexWebhookEventType::DisputeRespondedByMerchant
| AirwallexWebhookEventType::DisputeWon
| AirwallexWebhookEventType::DisputeLost
)
}
#[derive(Debug, Deserialize)]
pub struct AirwallexObjectData {
pub object: serde_json::Value,
}
#[derive(Debug, Deserialize)]
pub struct AirwallexDisputeObject {
pub payment_intent_id: String,
pub dispute_amount: MinorUnit,
pub dispute_currency: enums::Currency,
pub stage: AirwallexDisputeStage,
pub dispute_id: String,
pub dispute_reason_type: Option<String>,
pub dispute_original_reason_code: Option<String>,
pub status: String,
#[serde(with = "common_utils::custom_serde::iso8601::option")]
pub created_at: Option<PrimitiveDateTime>,
#[serde(with = "common_utils::custom_serde::iso8601::option")]
pub updated_at: Option<PrimitiveDateTime>,
}
#[derive(Debug, Deserialize, strum::Display, Clone)]
#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
pub enum AirwallexDisputeStage {
Rfi,
Dispute,
Arbitration,
}
#[derive(Debug, Deserialize)]
pub struct AirwallexWebhookDataResource {
// Should this be a secret by default since it represents webhook payload
pub object: Secret<serde_json::Value>,
}
#[derive(Debug, Deserialize)]
pub struct AirwallexWebhookObjectResource {
pub data: AirwallexWebhookDataResource,
}
#[derive(Default, Debug, Serialize, Deserialize, PartialEq)]
pub struct AirwallexErrorResponse {
pub code: String,
pub message: String,
pub source: Option<String>,
}
impl TryFrom<AirwallexWebhookEventType> for api_models::webhooks::IncomingWebhookEvent {
type Error = errors::ConnectorError;
fn try_from(value: AirwallexWebhookEventType) -> Result<Self, Self::Error> {
Ok(match value {
AirwallexWebhookEventType::PaymentAttemptFailedToProcess => Self::PaymentIntentFailure,
AirwallexWebhookEventType::PaymentAttemptAuthorized => Self::PaymentIntentSuccess,
AirwallexWebhookEventType::RefundSucceeded => Self::RefundSuccess,
AirwallexWebhookEventType::RefundFailed => Self::RefundFailure,
AirwallexWebhookEventType::DisputeAccepted
| AirwallexWebhookEventType::DisputePreChargebackAccepted => Self::DisputeAccepted,
AirwallexWebhookEventType::DisputeRespondedByMerchant => Self::DisputeChallenged,
AirwallexWebhookEventType::DisputeWon | AirwallexWebhookEventType::DisputeReversed => {
Self::DisputeWon
}
AirwallexWebhookEventType::DisputeLost => Self::DisputeLost,
AirwallexWebhookEventType::Unknown
| AirwallexWebhookEventType::PaymentAttemptAuthenticationRedirected
| AirwallexWebhookEventType::PaymentIntentCreated
| AirwallexWebhookEventType::PaymentIntentRequiresPaymentMethod
| AirwallexWebhookEventType::PaymentIntentCancelled
| AirwallexWebhookEventType::PaymentIntentSucceeded
| AirwallexWebhookEventType::PaymentIntentRequiresCapture
| AirwallexWebhookEventType::PaymentIntentRequiresCustomerAction
| AirwallexWebhookEventType::PaymentAttemptAuthorizationFailed
| AirwallexWebhookEventType::PaymentAttemptCaptureRequested
| AirwallexWebhookEventType::PaymentAttemptCaptureFailed
| AirwallexWebhookEventType::PaymentAttemptAuthenticationFailed
| AirwallexWebhookEventType::PaymentAttemptCancelled
| AirwallexWebhookEventType::PaymentAttemptExpired
| AirwallexWebhookEventType::PaymentAttemptRiskDeclined
| AirwallexWebhookEventType::PaymentAttemptSettled
| AirwallexWebhookEventType::PaymentAttemptPaid
| AirwallexWebhookEventType::RefundReceived
| AirwallexWebhookEventType::RefundAccepted
| AirwallexWebhookEventType::DisputeRfiRespondedByMerchant
| AirwallexWebhookEventType::DisputeReceivedByMerchant => Self::EventNotSupported,
})
}
}
impl From<AirwallexDisputeStage> for api_models::enums::DisputeStage {
fn from(code: AirwallexDisputeStage) -> Self {
match code {
AirwallexDisputeStage::Rfi => Self::PreDispute,
AirwallexDisputeStage::Dispute => Self::Dispute,
AirwallexDisputeStage::Arbitration => Self::PreArbitration,
}
}
}
|
{
"crate": "hyperswitch_connectors",
"file": "crates/hyperswitch_connectors/src/connectors/airwallex/transformers.rs",
"file_size": null,
"is_async": null,
"is_pub": null,
"num_enums": 16,
"num_structs": 54,
"num_tables": null,
"score": null,
"total_crates": null
}
|
file_hyperswitch_connectors_1536824202172696562
|
clm
|
file
|
// Repository: hyperswitch
// Crate: hyperswitch_connectors
// File: crates/hyperswitch_connectors/src/connectors/dwolla/transformers.rs
// Contains: 19 structs, 4 enums
use common_enums::{enums, AttemptStatus};
use common_utils::{errors::CustomResult, types::StringMajorUnit};
use error_stack::{report, ResultExt};
use hyperswitch_domain_models::{
payment_method_data::{BankDebitData, PaymentMethodData},
router_data::{AccessToken, ConnectorAuthType, PaymentMethodToken, RouterData},
router_flow_types::refunds::RSync,
router_request_types::ResponseId,
router_response_types::{PaymentsResponseData, RefundsResponseData},
types,
types::{PaymentsAuthorizeRouterData, RefundsRouterData},
};
use hyperswitch_interfaces::errors;
use masking::{ExposeInterface, Secret};
use serde::{Deserialize, Serialize};
use crate::{
types::{RefundsResponseRouterData, ResponseRouterData},
utils::{self, CustomerData, RouterData as _},
};
pub struct DwollaAuthType {
pub(super) client_id: Secret<String>,
pub(super) client_secret: Secret<String>,
}
impl TryFrom<&ConnectorAuthType> for DwollaAuthType {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(auth_type: &ConnectorAuthType) -> Result<Self, Self::Error> {
match auth_type {
ConnectorAuthType::BodyKey { api_key, key1 } => Ok(Self {
client_id: api_key.to_owned(),
client_secret: key1.to_owned(),
}),
_ => Err(errors::ConnectorError::FailedToObtainAuthType.into()),
}
}
}
#[derive(Default, Debug, Serialize, PartialEq)]
pub struct DwollaAccessTokenRequest {
pub grant_type: String,
}
#[derive(Default, Debug, Clone, Deserialize, PartialEq, Serialize)]
pub struct DwollaAccessTokenResponse {
access_token: Secret<String>,
expires_in: i64,
token_type: String,
}
pub fn extract_token_from_body(body: &[u8]) -> CustomResult<String, errors::ConnectorError> {
let parsed: serde_json::Value = serde_json::from_slice(body)
.map_err(|_| report!(errors::ConnectorError::ResponseDeserializationFailed))?;
parsed
.get("_links")
.and_then(|links| links.get("about"))
.and_then(|about| about.get("href"))
.and_then(|href| href.as_str())
.and_then(|url| url.rsplit('/').next())
.map(|id| id.to_string())
.ok_or_else(|| report!(errors::ConnectorError::ResponseHandlingFailed))
}
fn map_topic_to_status(topic: &str) -> DwollaPaymentStatus {
match topic {
"customer_transfer_created" | "customer_bank_transfer_created" => {
DwollaPaymentStatus::Pending
}
"customer_transfer_completed" | "customer_bank_transfer_completed" => {
DwollaPaymentStatus::Succeeded
}
"customer_transfer_failed" | "customer_bank_transfer_failed" => DwollaPaymentStatus::Failed,
_ => DwollaPaymentStatus::Pending,
}
}
impl<F, T> TryFrom<ResponseRouterData<F, DwollaAccessTokenResponse, T, AccessToken>>
for RouterData<F, T, AccessToken>
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: ResponseRouterData<F, DwollaAccessTokenResponse, T, AccessToken>,
) -> Result<Self, Self::Error> {
Ok(Self {
response: Ok(AccessToken {
token: item.response.access_token,
expires: item.response.expires_in,
}),
..item.data
})
}
}
#[derive(Debug)]
pub struct DwollaRouterData<'a, T> {
pub amount: StringMajorUnit,
pub router_data: T,
pub base_url: &'a str,
}
impl<'a, T> TryFrom<(StringMajorUnit, T, &'a str)> for DwollaRouterData<'a, T> {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
(amount, router_data, base_url): (StringMajorUnit, T, &'a str),
) -> Result<Self, Self::Error> {
Ok(Self {
amount,
router_data,
base_url,
})
}
}
#[derive(Default, Debug, Serialize, PartialEq)]
#[serde(rename_all = "camelCase")]
pub struct DwollaCustomerRequest {
first_name: Secret<String>,
last_name: Secret<String>,
email: common_utils::pii::Email,
}
#[derive(Default, Debug, Serialize, Deserialize, PartialEq)]
pub struct DwollaCustomerResponse {}
#[derive(Default, Debug, Serialize, Deserialize, PartialEq)]
pub struct DwollaFundingSourceResponse {}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct DwollaFundingSourceRequest {
routing_number: Secret<String>,
account_number: Secret<String>,
#[serde(rename = "type")]
account_type: common_enums::BankType,
name: Secret<String>,
}
#[derive(Debug, Serialize, PartialEq, Deserialize, Clone)]
#[serde(rename_all = "camelCase")]
pub struct DwollaPaymentsRequest {
#[serde(rename = "_links")]
links: DwollaPaymentLinks,
amount: DwollaAmount,
correlation_id: String,
}
#[derive(Default, Debug, Serialize, PartialEq, Deserialize, Clone)]
pub struct DwollaPaymentLinks {
source: DwollaRequestLink,
destination: DwollaRequestLink,
}
#[derive(Default, Debug, Serialize, PartialEq, Deserialize, Clone)]
pub struct DwollaRequestLink {
href: String,
}
#[derive(Debug, Serialize, PartialEq, Deserialize, Clone)]
pub struct DwollaAmount {
pub currency: common_enums::Currency,
pub value: StringMajorUnit,
}
#[derive(Debug, Serialize, PartialEq, Deserialize, Clone)]
#[serde(untagged)]
pub enum DwollaPSyncResponse {
Payment(DwollaPaymentSyncResponse),
Webhook(DwollaWebhookDetails),
}
#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
pub struct DwollaPaymentSyncResponse {
pub id: String,
pub status: DwollaPaymentStatus,
pub amount: DwollaAmount,
}
#[derive(Debug, Serialize, PartialEq, Deserialize, Clone)]
#[serde(untagged)]
pub enum DwollaRSyncResponse {
Payment(DwollaRefundSyncResponse),
Webhook(DwollaWebhookDetails),
}
#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
pub struct DwollaRefundSyncResponse {
id: String,
status: DwollaPaymentStatus,
amount: DwollaAmount,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct DwollaMetaData {
pub merchant_funding_source: Secret<String>,
}
#[derive(Debug, Serialize, PartialEq, Deserialize, Clone)]
#[serde(rename_all = "camelCase")]
pub struct DwollaRefundsRequest {
#[serde(rename = "_links")]
links: DwollaPaymentLinks,
amount: DwollaAmount,
correlation_id: String,
}
impl TryFrom<&types::ConnectorCustomerRouterData> for DwollaCustomerRequest {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(item: &types::ConnectorCustomerRouterData) -> Result<Self, Self::Error> {
Ok(Self {
first_name: item.get_billing_first_name()?,
last_name: item.get_billing_last_name()?,
email: item
.request
.get_email()
.or_else(|_| item.get_billing_email())?,
})
}
}
impl TryFrom<&types::TokenizationRouterData> for DwollaFundingSourceRequest {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(item: &types::TokenizationRouterData) -> Result<Self, Self::Error> {
match item.request.payment_method_data.clone() {
PaymentMethodData::BankDebit(BankDebitData::AchBankDebit {
ref routing_number,
ref account_number,
ref bank_type,
ref bank_account_holder_name,
..
}) => {
let account_type =
(*bank_type).ok_or_else(|| errors::ConnectorError::MissingRequiredField {
field_name: "bank_type",
})?;
let name = bank_account_holder_name.clone().ok_or_else(|| {
errors::ConnectorError::MissingRequiredField {
field_name: "bank_account_holder_name",
}
})?;
let request = Self {
routing_number: routing_number.clone(),
account_number: account_number.clone(),
account_type,
name,
};
Ok(request)
}
_ => Err(errors::ConnectorError::NotImplemented(
utils::get_unimplemented_payment_method_error_message("dwolla"),
))?,
}
}
}
impl<'a> TryFrom<&DwollaRouterData<'a, &PaymentsAuthorizeRouterData>> for DwollaPaymentsRequest {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: &DwollaRouterData<'a, &PaymentsAuthorizeRouterData>,
) -> Result<Self, Self::Error> {
let source_funding = match item.router_data.get_payment_method_token().ok() {
Some(PaymentMethodToken::Token(pm_token)) => pm_token,
_ => {
return Err(report!(errors::ConnectorError::MissingRequiredField {
field_name: "payment_method_token",
}))
}
};
let metadata = utils::to_connector_meta_from_secret::<DwollaMetaData>(
item.router_data.connector_meta_data.clone(),
)
.change_context(errors::ConnectorError::InvalidConnectorConfig { config: "metadata" })?;
let source_url = format!(
"{}/funding-sources/{}",
item.base_url,
source_funding.expose()
);
let destination_url = format!(
"{}/funding-sources/{}",
item.base_url,
metadata.merchant_funding_source.expose()
);
let request = Self {
links: DwollaPaymentLinks {
source: DwollaRequestLink { href: source_url },
destination: DwollaRequestLink {
href: destination_url,
},
},
amount: DwollaAmount {
currency: item.router_data.request.currency,
value: item.amount.to_owned(),
},
correlation_id: format!(
"payment_{}",
item.router_data.connector_request_reference_id
),
};
Ok(request)
}
}
impl<F, T> TryFrom<ResponseRouterData<F, DwollaPSyncResponse, T, PaymentsResponseData>>
for RouterData<F, T, PaymentsResponseData>
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: ResponseRouterData<F, DwollaPSyncResponse, T, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
let connector_metadata =
item.data
.payment_method_token
.as_ref()
.and_then(|token| match token {
PaymentMethodToken::Token(t) => {
Some(serde_json::json!({ "payment_token": t.clone().expose() }))
}
_ => None,
});
match item.response {
DwollaPSyncResponse::Payment(payment_response) => {
let payment_id = payment_response.id.clone();
let status = payment_response.status;
Ok(Self {
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(payment_id.clone()),
redirection_data: Box::new(None),
mandate_reference: Box::new(None),
connector_metadata,
network_txn_id: None,
connector_response_reference_id: Some(payment_id.clone()),
incremental_authorization_allowed: None,
charges: None,
}),
status: AttemptStatus::from(status),
..item.data
})
}
DwollaPSyncResponse::Webhook(webhook_response) => {
let payment_id = webhook_response.resource_id.clone();
Ok(Self {
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(payment_id.clone()),
redirection_data: Box::new(None),
mandate_reference: Box::new(None),
connector_metadata,
network_txn_id: None,
connector_response_reference_id: Some(payment_id.clone()),
incremental_authorization_allowed: None,
charges: None,
}),
status: AttemptStatus::from(map_topic_to_status(
webhook_response.topic.as_str(),
)),
..item.data
})
}
}
}
}
impl<'a, F> TryFrom<&DwollaRouterData<'a, &RefundsRouterData<F>>> for DwollaRefundsRequest {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(item: &DwollaRouterData<'a, &RefundsRouterData<F>>) -> Result<Self, Self::Error> {
let destination_funding = item
.router_data
.request
.connector_metadata
.as_ref()
.and_then(|meta| {
meta.get("payment_token")
.and_then(|token| token.as_str().map(|s| s.to_string()))
})
.ok_or_else(|| errors::ConnectorError::MissingRequiredField {
field_name: "payment_token",
})?;
let metadata = utils::to_connector_meta_from_secret::<DwollaMetaData>(
item.router_data.connector_meta_data.clone(),
)
.change_context(errors::ConnectorError::InvalidConnectorConfig { config: "metadata" })?;
let source_url = format!(
"{}/funding-sources/{}",
item.base_url,
metadata.merchant_funding_source.expose()
);
let destination_url = format!("{}/funding-sources/{}", item.base_url, destination_funding);
let request = Self {
links: DwollaPaymentLinks {
source: DwollaRequestLink { href: source_url },
destination: DwollaRequestLink {
href: destination_url,
},
},
amount: DwollaAmount {
currency: item.router_data.request.currency,
value: item.amount.to_owned(),
},
correlation_id: format!("refund_{}", item.router_data.connector_request_reference_id),
};
Ok(request)
}
}
impl TryFrom<RefundsResponseRouterData<RSync, DwollaRSyncResponse>> for RefundsRouterData<RSync> {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: RefundsResponseRouterData<RSync, DwollaRSyncResponse>,
) -> Result<Self, Self::Error> {
match item.response {
DwollaRSyncResponse::Payment(refund_response) => {
let refund_id = refund_response.id.clone();
let status = refund_response.status;
Ok(Self {
response: Ok(RefundsResponseData {
connector_refund_id: refund_id,
refund_status: enums::RefundStatus::from(status),
}),
..item.data
})
}
DwollaRSyncResponse::Webhook(webhook_response) => {
let refund_id = webhook_response.resource_id.clone();
let status = map_topic_to_status(webhook_response.topic.as_str());
Ok(Self {
response: Ok(RefundsResponseData {
connector_refund_id: refund_id,
refund_status: enums::RefundStatus::from(status),
}),
..item.data
})
}
}
}
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, PartialEq)]
#[serde(rename_all = "lowercase")]
pub enum DwollaPaymentStatus {
Succeeded,
Failed,
Pending,
#[default]
Processing,
Processed,
}
impl From<DwollaPaymentStatus> for AttemptStatus {
fn from(item: DwollaPaymentStatus) -> Self {
match item {
DwollaPaymentStatus::Succeeded => Self::Charged,
DwollaPaymentStatus::Processed => Self::Charged,
DwollaPaymentStatus::Failed => Self::Failure,
DwollaPaymentStatus::Processing => Self::Pending,
DwollaPaymentStatus::Pending => Self::Pending,
}
}
}
impl From<DwollaPaymentStatus> for enums::RefundStatus {
fn from(item: DwollaPaymentStatus) -> Self {
match item {
DwollaPaymentStatus::Succeeded => Self::Success,
DwollaPaymentStatus::Processed => Self::Success,
DwollaPaymentStatus::Failed => Self::Failure,
DwollaPaymentStatus::Processing => Self::Pending,
DwollaPaymentStatus::Pending => Self::Pending,
}
}
}
#[derive(Default, Debug, Serialize, Deserialize, PartialEq)]
pub struct DwollaErrorResponse {
pub code: String,
pub message: String,
pub _embedded: Option<Vec<DwollaErrorDetails>>,
pub reason: Option<String>,
}
#[derive(Default, Debug, Serialize, Deserialize, PartialEq)]
pub struct DwollaErrorDetails {
pub errors: Vec<DwollaErrorDetail>,
}
#[derive(Default, Debug, Serialize, Deserialize, PartialEq)]
pub struct DwollaErrorDetail {
pub code: Option<String>,
pub message: Option<String>,
}
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
#[serde(rename_all = "camelCase")]
pub struct DwollaWebhookDetails {
pub id: String,
pub resource_id: String,
pub topic: String,
pub correlation_id: Option<String>,
}
impl From<&str> for DwollaWebhookEventType {
fn from(topic: &str) -> Self {
match topic {
"customer_created" => Self::CustomerCreated,
"customer_verified" => Self::CustomerVerified,
"customer_funding_source_added" => Self::CustomerFundingSourceAdded,
"customer_funding_source_removed" => Self::CustomerFundingSourceRemoved,
"customer_funding_source_verified" => Self::CustomerFundingSourceVerified,
"customer_funding_source_unverified" => Self::CustomerFundingSourceUnverified,
"customer_microdeposits_added" => Self::CustomerMicrodepositsAdded,
"customer_microdeposits_failed" => Self::CustomerMicrodepositsFailed,
"customer_microdeposits_completed" => Self::CustomerMicrodepositsCompleted,
"customer_microdeposits_maxattempts" => Self::CustomerMicrodepositsMaxAttempts,
"customer_bank_transfer_creation_failed" => Self::CustomerBankTransferCreationFailed,
"customer_bank_transfer_created" => Self::CustomerBankTransferCreated,
"customer_transfer_created" => Self::CustomerTransferCreated,
"customer_bank_transfer_failed" => Self::CustomerBankTransferFailed,
"customer_bank_transfer_completed" => Self::CustomerBankTransferCompleted,
"customer_transfer_completed" => Self::CustomerTransferCompleted,
"customer_transfer_failed" => Self::CustomerTransferFailed,
"transfer_created" => Self::TransferCreated,
"transfer_pending" => Self::TransferPending,
"transfer_completed" => Self::TransferCompleted,
"transfer_failed" => Self::TransferFailed,
_ => Self::Unknown,
}
}
}
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
#[serde(rename_all = "kebab-case")]
pub enum DwollaWebhookEventType {
CustomerCreated,
CustomerVerified,
CustomerFundingSourceAdded,
CustomerFundingSourceRemoved,
CustomerFundingSourceUnverified,
CustomerFundingSourceVerified,
CustomerMicrodepositsAdded,
CustomerMicrodepositsFailed,
CustomerMicrodepositsCompleted,
CustomerMicrodepositsMaxAttempts,
CustomerTransferCreated,
CustomerBankTransferCreationFailed,
CustomerBankTransferCreated,
CustomerBankTransferCompleted,
CustomerBankTransferFailed,
CustomerTransferCompleted,
CustomerTransferFailed,
TransferCreated,
TransferPending,
TransferCompleted,
TransferFailed,
#[serde(other)]
Unknown,
}
impl TryFrom<DwollaWebhookDetails> for api_models::webhooks::IncomingWebhookEvent {
type Error = errors::ConnectorError;
fn try_from(details: DwollaWebhookDetails) -> Result<Self, Self::Error> {
let correlation_id = match details.correlation_id.as_deref() {
Some(cid) => cid,
None => {
return Ok(Self::EventNotSupported);
}
};
let event_type = DwollaWebhookEventType::from(details.topic.as_str());
let is_refund = correlation_id.starts_with("refund_");
Ok(match (event_type, is_refund) {
(DwollaWebhookEventType::CustomerTransferCompleted, true)
| (DwollaWebhookEventType::CustomerBankTransferCompleted, true) => Self::RefundSuccess,
(DwollaWebhookEventType::CustomerTransferFailed, true)
| (DwollaWebhookEventType::CustomerBankTransferFailed, true) => Self::RefundFailure,
(DwollaWebhookEventType::CustomerTransferCreated, false)
| (DwollaWebhookEventType::CustomerBankTransferCreated, false) => {
Self::PaymentIntentProcessing
}
(DwollaWebhookEventType::CustomerTransferCompleted, false)
| (DwollaWebhookEventType::CustomerBankTransferCompleted, false) => {
Self::PaymentIntentSuccess
}
(DwollaWebhookEventType::CustomerTransferFailed, false)
| (DwollaWebhookEventType::CustomerBankTransferFailed, false) => {
Self::PaymentIntentFailure
}
_ => Self::EventNotSupported,
})
}
}
|
{
"crate": "hyperswitch_connectors",
"file": "crates/hyperswitch_connectors/src/connectors/dwolla/transformers.rs",
"file_size": null,
"is_async": null,
"is_pub": null,
"num_enums": 4,
"num_structs": 19,
"num_tables": null,
"score": null,
"total_crates": null
}
|
file_hyperswitch_connectors_-4950018339571678719
|
clm
|
file
|
// Repository: hyperswitch
// Crate: hyperswitch_connectors
// File: crates/hyperswitch_connectors/src/connectors/braintree/transformers.rs
// Contains: 94 structs, 17 enums
use api_models::{
payments as payment_types,
payments::{ApplePaySessionResponse, SessionToken},
webhooks::IncomingWebhookEvent,
};
use common_enums::enums;
use common_utils::{
ext_traits::{OptionExt, ValueExt},
pii,
types::{AmountConvertor, MinorUnit, StringMajorUnit, StringMajorUnitForConnector},
};
use error_stack::ResultExt;
use hyperswitch_domain_models::{
payment_method_data::{PaymentMethodData, WalletData},
router_data::{ConnectorAuthType, PaymentMethodToken, RouterData},
router_flow_types::refunds::{Execute, RSync},
router_request_types::{
CompleteAuthorizeData, MandateRevokeRequestData, PaymentsAuthorizeData, ResponseId,
},
router_response_types::{
MandateReference, MandateRevokeResponseData, PaymentsResponseData, RedirectForm,
RefundsResponseData,
},
types::{self, RefundsRouterData},
};
use hyperswitch_interfaces::{
consts::{NO_ERROR_CODE, NO_ERROR_MESSAGE},
errors,
};
use masking::{ExposeInterface, Secret};
use serde::{Deserialize, Serialize};
use strum::Display;
use time::PrimitiveDateTime;
use crate::{
types::{
PaymentsCaptureResponseRouterData, PaymentsSessionResponseRouterData,
RefundsResponseRouterData, ResponseRouterData,
},
unimplemented_payment_method,
utils::{
self, ForeignTryFrom, PaymentsAuthorizeRequestData, PaymentsCompleteAuthorizeRequestData,
RefundsRequestData, RouterData as _,
},
};
pub const CHANNEL_CODE: &str = "HyperSwitchBT_Ecom";
pub const CLIENT_TOKEN_MUTATION: &str = "mutation createClientToken($input: CreateClientTokenInput!) { createClientToken(input: $input) { clientToken}}";
pub const TOKENIZE_CREDIT_CARD: &str = "mutation tokenizeCreditCard($input: TokenizeCreditCardInput!) { tokenizeCreditCard(input: $input) { clientMutationId paymentMethod { id } } }";
pub const CHARGE_CREDIT_CARD_MUTATION: &str = "mutation ChargeCreditCard($input: ChargeCreditCardInput!) { chargeCreditCard(input: $input) { transaction { id legacyId createdAt amount { value currencyCode } status } } }";
pub const AUTHORIZE_CREDIT_CARD_MUTATION: &str = "mutation authorizeCreditCard($input: AuthorizeCreditCardInput!) { authorizeCreditCard(input: $input) { transaction { id legacyId amount { value currencyCode } status } } }";
pub const CAPTURE_TRANSACTION_MUTATION: &str = "mutation captureTransaction($input: CaptureTransactionInput!) { captureTransaction(input: $input) { clientMutationId transaction { id legacyId amount { value currencyCode } status } } }";
pub const VOID_TRANSACTION_MUTATION: &str = "mutation voidTransaction($input: ReverseTransactionInput!) { reverseTransaction(input: $input) { clientMutationId reversal { ... on Transaction { id legacyId amount { value currencyCode } status } } } }";
pub const REFUND_TRANSACTION_MUTATION: &str = "mutation refundTransaction($input: RefundTransactionInput!) { refundTransaction(input: $input) {clientMutationId refund { id legacyId amount { value currencyCode } status } } }";
pub const AUTHORIZE_AND_VAULT_CREDIT_CARD_MUTATION: &str="mutation authorizeCreditCard($input: AuthorizeCreditCardInput!) { authorizeCreditCard(input: $input) { transaction { id status createdAt paymentMethod { id } } } }";
pub const CHARGE_AND_VAULT_TRANSACTION_MUTATION: &str ="mutation ChargeCreditCard($input: ChargeCreditCardInput!) { chargeCreditCard(input: $input) { transaction { id status createdAt paymentMethod { id } } } }";
pub const DELETE_PAYMENT_METHOD_FROM_VAULT_MUTATION: &str = "mutation deletePaymentMethodFromVault($input: DeletePaymentMethodFromVaultInput!) { deletePaymentMethodFromVault(input: $input) { clientMutationId } }";
pub const TRANSACTION_QUERY: &str = "query($input: TransactionSearchInput!) { search { transactions(input: $input) { edges { node { id status } } } } }";
pub const REFUND_QUERY: &str = "query($input: RefundSearchInput!) { search { refunds(input: $input, first: 1) { edges { node { id status createdAt amount { value currencyCode } orderId } } } } }";
pub const CHARGE_GOOGLE_PAY_MUTATION: &str = "mutation ChargeGPay($input: ChargePaymentMethodInput!) { chargePaymentMethod(input: $input) { transaction { id status amount { value currencyCode } } } }";
pub const AUTHORIZE_GOOGLE_PAY_MUTATION: &str = "mutation authorizeGPay($input: AuthorizePaymentMethodInput!) { authorizePaymentMethod(input: $input) { transaction { id legacyId amount { value currencyCode } status } } }";
pub const CHARGE_APPLE_PAY_MUTATION: &str = "mutation ChargeApplepay($input: ChargePaymentMethodInput!) { chargePaymentMethod(input: $input) { transaction { id status amount { value currencyCode } } } }";
pub const AUTHORIZE_APPLE_PAY_MUTATION: &str = "mutation authorizeApplepay($input: AuthorizePaymentMethodInput!) { authorizePaymentMethod(input: $input) { transaction { id legacyId amount { value currencyCode } status } } }";
pub const CHARGE_PAYPAL_MUTATION: &str = "mutation ChargePaypal($input: ChargePaymentMethodInput!) { chargePaymentMethod(input: $input) { transaction { id status amount { value currencyCode } } } }";
pub const AUTHORIZE_PAYPAL_MUTATION: &str = "mutation authorizePaypal($input: AuthorizePaymentMethodInput!) { authorizePaymentMethod(input: $input) { transaction { id legacyId amount { value currencyCode } status } } }";
pub type CardPaymentRequest = GenericBraintreeRequest<VariablePaymentInput>;
pub type MandatePaymentRequest = GenericBraintreeRequest<VariablePaymentInput>;
pub type BraintreeClientTokenRequest = GenericBraintreeRequest<VariableClientTokenInput>;
pub type BraintreeTokenRequest = GenericBraintreeRequest<VariableInput>;
pub type BraintreeCaptureRequest = GenericBraintreeRequest<VariableCaptureInput>;
pub type BraintreeRefundRequest = GenericBraintreeRequest<BraintreeRefundVariables>;
pub type BraintreePSyncRequest = GenericBraintreeRequest<PSyncInput>;
pub type BraintreeRSyncRequest = GenericBraintreeRequest<RSyncInput>;
pub type BraintreeRefundResponse = GenericBraintreeResponse<RefundResponse>;
pub type BraintreeCaptureResponse = GenericBraintreeResponse<CaptureResponse>;
pub type BraintreePSyncResponse = GenericBraintreeResponse<PSyncResponse>;
pub type VariablePaymentInput = GenericVariableInput<PaymentInput>;
pub type VariableClientTokenInput = GenericVariableInput<InputClientTokenData>;
pub type VariableInput = GenericVariableInput<InputData>;
pub type VariableCaptureInput = GenericVariableInput<CaptureInputData>;
pub type BraintreeRefundVariables = GenericVariableInput<BraintreeRefundInput>;
pub type PSyncInput = GenericVariableInput<TransactionSearchInput>;
pub type RSyncInput = GenericVariableInput<RefundSearchInput>;
pub type BraintreeWalletRequest = GenericBraintreeRequest<GenericVariableInput<WalletPaymentInput>>;
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct WalletTransactionBody {
amount: StringMajorUnit,
merchant_account_id: Secret<String>,
order_id: String,
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct WalletPaymentInput {
payment_method_id: Secret<String>,
transaction: WalletTransactionBody,
}
#[derive(Debug, Clone, Serialize)]
pub struct GenericBraintreeRequest<T> {
query: String,
variables: T,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(untagged)]
pub enum GenericBraintreeResponse<T> {
SuccessResponse(Box<T>),
ErrorResponse(Box<ErrorResponse>),
}
#[derive(Debug, Clone, Serialize)]
pub struct GenericVariableInput<T> {
input: T,
}
#[derive(Debug, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct BraintreeApiErrorResponse {
pub api_error_response: ApiErrorResponse,
}
#[derive(Debug, Deserialize, Serialize)]
pub struct ErrorsObject {
pub errors: Vec<ErrorObject>,
pub transaction: Option<TransactionError>,
}
#[derive(Debug, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct TransactionError {
pub errors: Vec<ErrorObject>,
pub credit_card: Option<CreditCardError>,
}
#[derive(Debug, Deserialize, Serialize)]
pub struct CreditCardError {
pub errors: Vec<ErrorObject>,
}
#[derive(Debug, Serialize)]
pub struct BraintreeRouterData<T> {
pub amount: StringMajorUnit,
pub router_data: T,
}
impl<T> TryFrom<(StringMajorUnit, T)> for BraintreeRouterData<T> {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from((amount, item): (StringMajorUnit, T)) -> Result<Self, Self::Error> {
Ok(Self {
amount,
router_data: item,
})
}
}
#[derive(Debug, Deserialize, Serialize)]
pub struct ErrorObject {
pub code: String,
pub message: String,
}
#[derive(Debug, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct BraintreeErrorResponse {
pub errors: String,
}
#[derive(Debug, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
#[serde(untagged)]
pub enum ErrorResponses {
BraintreeApiErrorResponse(Box<BraintreeApiErrorResponse>),
BraintreeErrorResponse(Box<BraintreeErrorResponse>),
}
#[derive(Debug, Deserialize, Serialize)]
pub struct ApiErrorResponse {
pub message: String,
pub errors: ErrorsObject,
}
pub struct BraintreeAuthType {
pub(super) public_key: Secret<String>,
pub(super) private_key: Secret<String>,
}
impl TryFrom<&ConnectorAuthType> for BraintreeAuthType {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(item: &ConnectorAuthType) -> Result<Self, Self::Error> {
if let ConnectorAuthType::SignatureKey {
api_key,
api_secret,
key1: _merchant_id,
} = item
{
Ok(Self {
public_key: api_key.to_owned(),
private_key: api_secret.to_owned(),
})
} else {
Err(errors::ConnectorError::FailedToObtainAuthType)?
}
}
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct PaymentInput {
payment_method_id: Secret<String>,
transaction: TransactionBody,
}
#[derive(Debug, Serialize)]
#[serde(untagged)]
pub enum BraintreePaymentsRequest {
Card(CardPaymentRequest),
CardThreeDs(BraintreeClientTokenRequest),
Mandate(MandatePaymentRequest),
Wallet(BraintreeWalletRequest),
Session(BraintreeClientTokenRequest),
}
#[derive(Debug, Deserialize)]
pub struct BraintreeMeta {
merchant_account_id: Secret<String>,
merchant_config_currency: enums::Currency,
}
impl TryFrom<&Option<pii::SecretSerdeValue>> for BraintreeMeta {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(meta_data: &Option<pii::SecretSerdeValue>) -> Result<Self, Self::Error> {
let metadata: Self = utils::to_connector_meta_from_secret::<Self>(meta_data.clone())
.change_context(errors::ConnectorError::InvalidConnectorConfig {
config: "metadata",
})?;
Ok(metadata)
}
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct CustomerBody {
email: pii::Email,
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct RegularTransactionBody {
amount: StringMajorUnit,
merchant_account_id: Secret<String>,
channel: String,
#[serde(skip_serializing_if = "Option::is_none")]
customer_details: Option<CustomerBody>,
order_id: String,
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct VaultTransactionBody {
amount: StringMajorUnit,
merchant_account_id: Secret<String>,
vault_payment_method_after_transacting: TransactionTiming,
#[serde(skip_serializing_if = "Option::is_none")]
customer_details: Option<CustomerBody>,
order_id: String,
}
#[derive(Debug, Serialize)]
#[serde(untagged)]
pub enum TransactionBody {
Regular(RegularTransactionBody),
Vault(VaultTransactionBody),
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct TransactionTiming {
when: String,
}
impl
TryFrom<(
&BraintreeRouterData<&types::PaymentsAuthorizeRouterData>,
String,
BraintreeMeta,
)> for MandatePaymentRequest
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
(item, connector_mandate_id, metadata): (
&BraintreeRouterData<&types::PaymentsAuthorizeRouterData>,
String,
BraintreeMeta,
),
) -> Result<Self, Self::Error> {
let (query, transaction_body) = (
match item.router_data.request.is_auto_capture()? {
true => CHARGE_CREDIT_CARD_MUTATION.to_string(),
false => AUTHORIZE_CREDIT_CARD_MUTATION.to_string(),
},
TransactionBody::Regular(RegularTransactionBody {
amount: item.amount.to_owned(),
merchant_account_id: metadata.merchant_account_id,
channel: CHANNEL_CODE.to_string(),
customer_details: None,
order_id: item.router_data.connector_request_reference_id.clone(),
}),
);
Ok(Self {
query,
variables: VariablePaymentInput {
input: PaymentInput {
payment_method_id: connector_mandate_id.into(),
transaction: transaction_body,
},
},
})
}
}
impl TryFrom<&BraintreeRouterData<&types::PaymentsAuthorizeRouterData>>
for BraintreePaymentsRequest
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: &BraintreeRouterData<&types::PaymentsAuthorizeRouterData>,
) -> Result<Self, Self::Error> {
let metadata: BraintreeMeta = if let (
Some(merchant_account_id),
Some(merchant_config_currency),
) = (
item.router_data.request.merchant_account_id.clone(),
item.router_data.request.merchant_config_currency,
) {
router_env::logger::info!(
"BRAINTREE: Picking merchant_account_id and merchant_config_currency from payments request"
);
BraintreeMeta {
merchant_account_id,
merchant_config_currency,
}
} else {
utils::to_connector_meta_from_secret(item.router_data.connector_meta_data.clone())
.change_context(errors::ConnectorError::InvalidConnectorConfig {
config: "metadata",
})?
};
utils::validate_currency(
item.router_data.request.currency,
Some(metadata.merchant_config_currency),
)?;
match item.router_data.request.payment_method_data.clone() {
PaymentMethodData::Card(_) => {
if item.router_data.is_three_ds() {
Ok(Self::CardThreeDs(BraintreeClientTokenRequest::try_from(
metadata,
)?))
} else {
Ok(Self::Card(CardPaymentRequest::try_from((item, metadata))?))
}
}
PaymentMethodData::MandatePayment => {
let connector_mandate_id = item.router_data.request.connector_mandate_id().ok_or(
errors::ConnectorError::MissingRequiredField {
field_name: "connector_mandate_id",
},
)?;
Ok(Self::Mandate(MandatePaymentRequest::try_from((
item,
connector_mandate_id,
metadata,
))?))
}
PaymentMethodData::Wallet(ref wallet_data) => match wallet_data {
WalletData::GooglePayThirdPartySdk(ref req_wallet) => {
let payment_method_id = &req_wallet.token;
let query = match item.router_data.request.is_auto_capture()? {
true => CHARGE_GOOGLE_PAY_MUTATION.to_string(),
false => AUTHORIZE_GOOGLE_PAY_MUTATION.to_string(),
};
Ok(Self::Wallet(BraintreeWalletRequest {
query,
variables: GenericVariableInput {
input: WalletPaymentInput {
payment_method_id: payment_method_id.clone().ok_or(
errors::ConnectorError::MissingRequiredField {
field_name: "google_pay token",
},
)?,
transaction: WalletTransactionBody {
amount: item.amount.clone(),
merchant_account_id: metadata.merchant_account_id,
order_id: item
.router_data
.connector_request_reference_id
.clone(),
},
},
},
}))
}
WalletData::ApplePayThirdPartySdk(ref req_wallet) => {
let payment_method_id = &req_wallet.token;
let query = match item.router_data.request.is_auto_capture()? {
true => CHARGE_APPLE_PAY_MUTATION.to_string(),
false => AUTHORIZE_APPLE_PAY_MUTATION.to_string(),
};
Ok(Self::Wallet(BraintreeWalletRequest {
query,
variables: GenericVariableInput {
input: WalletPaymentInput {
payment_method_id: payment_method_id.clone().ok_or(
errors::ConnectorError::MissingRequiredField {
field_name: "apple_pay token",
},
)?,
transaction: WalletTransactionBody {
amount: item.amount.clone(),
merchant_account_id: metadata.merchant_account_id,
order_id: item
.router_data
.connector_request_reference_id
.clone(),
},
},
},
}))
}
WalletData::PaypalSdk(ref req_wallet) => {
let payment_method_id = req_wallet.token.clone();
let query = match item.router_data.request.is_auto_capture()? {
true => CHARGE_PAYPAL_MUTATION.to_string(),
false => AUTHORIZE_PAYPAL_MUTATION.to_string(),
};
Ok(Self::Wallet(BraintreeWalletRequest {
query,
variables: GenericVariableInput {
input: WalletPaymentInput {
payment_method_id: payment_method_id.clone().into(),
transaction: WalletTransactionBody {
amount: item.amount.clone(),
merchant_account_id: metadata.merchant_account_id,
order_id: item
.router_data
.connector_request_reference_id
.clone(),
},
},
},
}))
}
_ => Err(errors::ConnectorError::NotImplemented(
utils::get_unimplemented_payment_method_error_message("braintree"),
)
.into()),
},
PaymentMethodData::CardRedirect(_)
| PaymentMethodData::PayLater(_)
| PaymentMethodData::BankRedirect(_)
| PaymentMethodData::BankDebit(_)
| PaymentMethodData::BankTransfer(_)
| PaymentMethodData::Crypto(_)
| PaymentMethodData::Reward
| PaymentMethodData::RealTimePayment(_)
| PaymentMethodData::MobilePayment(_)
| PaymentMethodData::Upi(_)
| PaymentMethodData::Voucher(_)
| PaymentMethodData::GiftCard(_)
| PaymentMethodData::OpenBanking(_)
| PaymentMethodData::CardToken(_)
| PaymentMethodData::NetworkToken(_)
| PaymentMethodData::CardDetailsForNetworkTransactionId(_) => {
Err(errors::ConnectorError::NotImplemented(
utils::get_unimplemented_payment_method_error_message("braintree"),
)
.into())
}
}
}
}
impl TryFrom<&BraintreeRouterData<&types::PaymentsCompleteAuthorizeRouterData>>
for BraintreePaymentsRequest
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: &BraintreeRouterData<&types::PaymentsCompleteAuthorizeRouterData>,
) -> Result<Self, Self::Error> {
match item.router_data.payment_method {
api_models::enums::PaymentMethod::Card => {
Ok(Self::Card(CardPaymentRequest::try_from(item)?))
}
api_models::enums::PaymentMethod::CardRedirect
| api_models::enums::PaymentMethod::PayLater
| api_models::enums::PaymentMethod::Wallet
| api_models::enums::PaymentMethod::BankRedirect
| api_models::enums::PaymentMethod::BankTransfer
| api_models::enums::PaymentMethod::Crypto
| api_models::enums::PaymentMethod::BankDebit
| api_models::enums::PaymentMethod::Reward
| api_models::enums::PaymentMethod::RealTimePayment
| api_models::enums::PaymentMethod::MobilePayment
| api_models::enums::PaymentMethod::Upi
| api_models::enums::PaymentMethod::OpenBanking
| api_models::enums::PaymentMethod::Voucher
| api_models::enums::PaymentMethod::GiftCard => {
Err(errors::ConnectorError::NotImplemented(
utils::get_unimplemented_payment_method_error_message(
"complete authorize flow",
),
)
.into())
}
}
}
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct AuthResponse {
data: DataAuthResponse,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(untagged)]
pub enum BraintreeAuthResponse {
AuthResponse(Box<AuthResponse>),
ClientTokenResponse(Box<ClientTokenResponse>),
ErrorResponse(Box<ErrorResponse>),
WalletAuthResponse(Box<WalletAuthResponse>),
}
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(untagged)]
pub enum BraintreeCompleteAuthResponse {
AuthResponse(Box<AuthResponse>),
ErrorResponse(Box<ErrorResponse>),
}
#[derive(Debug, Clone, Deserialize, Serialize)]
struct PaymentMethodInfo {
id: Secret<String>,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct TransactionAuthChargeResponseBody {
id: String,
status: BraintreePaymentStatus,
payment_method: Option<PaymentMethodInfo>,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct DataAuthResponse {
authorize_credit_card: AuthChargeCreditCard,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct AuthChargeCreditCard {
transaction: TransactionAuthChargeResponseBody,
}
impl<F>
TryFrom<
ResponseRouterData<F, BraintreeAuthResponse, PaymentsAuthorizeData, PaymentsResponseData>,
> for RouterData<F, PaymentsAuthorizeData, PaymentsResponseData>
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: ResponseRouterData<
F,
BraintreeAuthResponse,
PaymentsAuthorizeData,
PaymentsResponseData,
>,
) -> Result<Self, Self::Error> {
match item.response {
BraintreeAuthResponse::ErrorResponse(error_response) => Ok(Self {
response: build_error_response(&error_response.errors, item.http_code)
.map_err(|err| *err),
..item.data
}),
BraintreeAuthResponse::AuthResponse(auth_response) => {
let transaction_data = auth_response.data.authorize_credit_card.transaction;
let status = enums::AttemptStatus::from(transaction_data.status.clone());
let response = if utils::is_payment_failure(status) {
Err(hyperswitch_domain_models::router_data::ErrorResponse {
code: transaction_data.status.to_string(),
message: transaction_data.status.to_string(),
reason: Some(transaction_data.status.to_string()),
attempt_status: None,
connector_transaction_id: Some(transaction_data.id),
status_code: item.http_code,
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
connector_metadata: None,
})
} else {
Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(transaction_data.id),
redirection_data: Box::new(None),
mandate_reference: Box::new(transaction_data.payment_method.as_ref().map(
|pm| MandateReference {
connector_mandate_id: Some(pm.id.clone().expose()),
payment_method_id: None,
mandate_metadata: None,
connector_mandate_request_reference_id: None,
},
)),
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: None,
incremental_authorization_allowed: None,
charges: None,
})
};
Ok(Self {
status,
response,
..item.data
})
}
BraintreeAuthResponse::ClientTokenResponse(client_token_data) => Ok(Self {
status: enums::AttemptStatus::AuthenticationPending,
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::NoResponseId,
redirection_data: Box::new(Some(get_braintree_redirect_form(
*client_token_data,
item.data.get_payment_method_token()?,
item.data.request.payment_method_data.clone(),
item.data.request.get_complete_authorize_url()?,
)?)),
mandate_reference: Box::new(None),
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: None,
incremental_authorization_allowed: None,
charges: None,
}),
..item.data
}),
BraintreeAuthResponse::WalletAuthResponse(wallet_response) => {
let txn = &wallet_response.data.authorize_payment_method.transaction;
let status = enums::AttemptStatus::from(txn.status.clone());
let response = if utils::is_payment_failure(status) {
Err(hyperswitch_domain_models::router_data::ErrorResponse {
code: txn.status.to_string(),
message: txn.status.to_string(),
reason: Some(txn.status.to_string()),
attempt_status: None,
connector_transaction_id: Some(txn.id.clone()),
status_code: item.http_code,
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
connector_metadata: None,
})
} else {
Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(txn.id.clone()),
redirection_data: Box::new(None),
mandate_reference: Box::new(None),
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: txn.legacy_id.clone(),
incremental_authorization_allowed: None,
charges: None,
})
};
Ok(Self {
status,
response,
..item.data
})
}
}
}
}
fn build_error_response<T>(
response: &[ErrorDetails],
http_code: u16,
) -> Result<T, Box<hyperswitch_domain_models::router_data::ErrorResponse>> {
let error_messages = response
.iter()
.map(|error| error.message.to_string())
.collect::<Vec<String>>();
let reason = match !error_messages.is_empty() {
true => Some(error_messages.join(" ")),
false => None,
};
get_error_response(
response
.first()
.and_then(|err_details| err_details.extensions.as_ref())
.and_then(|extensions| extensions.legacy_code.clone()),
response
.first()
.map(|err_details| err_details.message.clone()),
reason,
http_code,
)
}
fn get_error_response<T>(
error_code: Option<String>,
error_msg: Option<String>,
error_reason: Option<String>,
http_code: u16,
) -> Result<T, Box<hyperswitch_domain_models::router_data::ErrorResponse>> {
Err(Box::new(
hyperswitch_domain_models::router_data::ErrorResponse {
code: error_code.unwrap_or_else(|| NO_ERROR_CODE.to_string()),
message: error_msg.unwrap_or_else(|| NO_ERROR_MESSAGE.to_string()),
reason: error_reason,
status_code: http_code,
attempt_status: None,
connector_transaction_id: None,
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
connector_metadata: None,
},
))
}
#[derive(Debug, Clone, Deserialize, Serialize, strum::Display)]
#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
pub enum BraintreePaymentStatus {
Authorized,
Authorizing,
AuthorizedExpired,
Failed,
ProcessorDeclined,
GatewayRejected,
Voided,
Settling,
Settled,
SettlementPending,
SettlementDeclined,
SettlementConfirmed,
SubmittedForSettlement,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct ErrorDetails {
pub message: String,
pub extensions: Option<AdditionalErrorDetails>,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct AdditionalErrorDetails {
pub legacy_code: Option<String>,
}
impl From<BraintreePaymentStatus> for enums::AttemptStatus {
fn from(item: BraintreePaymentStatus) -> Self {
match item {
BraintreePaymentStatus::Settling
| BraintreePaymentStatus::Settled
| BraintreePaymentStatus::SettlementConfirmed
| BraintreePaymentStatus::SubmittedForSettlement
| BraintreePaymentStatus::SettlementPending => Self::Charged,
BraintreePaymentStatus::Authorizing => Self::Authorizing,
BraintreePaymentStatus::AuthorizedExpired => Self::AuthorizationFailed,
BraintreePaymentStatus::Failed
| BraintreePaymentStatus::GatewayRejected
| BraintreePaymentStatus::ProcessorDeclined
| BraintreePaymentStatus::SettlementDeclined => Self::Failure,
BraintreePaymentStatus::Authorized => Self::Authorized,
BraintreePaymentStatus::Voided => Self::Voided,
}
}
}
impl<F>
TryFrom<
ResponseRouterData<
F,
BraintreePaymentsResponse,
PaymentsAuthorizeData,
PaymentsResponseData,
>,
> for RouterData<F, PaymentsAuthorizeData, PaymentsResponseData>
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: ResponseRouterData<
F,
BraintreePaymentsResponse,
PaymentsAuthorizeData,
PaymentsResponseData,
>,
) -> Result<Self, Self::Error> {
match item.response {
BraintreePaymentsResponse::ErrorResponse(error_response) => Ok(Self {
response: build_error_response(&error_response.errors.clone(), item.http_code)
.map_err(|err| *err),
..item.data
}),
BraintreePaymentsResponse::PaymentsResponse(payment_response) => {
let transaction_data = payment_response.data.charge_credit_card.transaction;
let status = enums::AttemptStatus::from(transaction_data.status.clone());
let response = if utils::is_payment_failure(status) {
Err(hyperswitch_domain_models::router_data::ErrorResponse {
code: transaction_data.status.to_string().clone(),
message: transaction_data.status.to_string().clone(),
reason: Some(transaction_data.status.to_string().clone()),
attempt_status: None,
connector_transaction_id: Some(transaction_data.id),
status_code: item.http_code,
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
connector_metadata: None,
})
} else {
Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(transaction_data.id),
redirection_data: Box::new(None),
mandate_reference: Box::new(transaction_data.payment_method.as_ref().map(
|pm| MandateReference {
connector_mandate_id: Some(pm.id.clone().expose()),
payment_method_id: None,
mandate_metadata: None,
connector_mandate_request_reference_id: None,
},
)),
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: None,
incremental_authorization_allowed: None,
charges: None,
})
};
Ok(Self {
status,
response,
..item.data
})
}
BraintreePaymentsResponse::ClientTokenResponse(client_token_data) => Ok(Self {
status: enums::AttemptStatus::AuthenticationPending,
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::NoResponseId,
redirection_data: Box::new(Some(get_braintree_redirect_form(
*client_token_data,
item.data.get_payment_method_token()?,
item.data.request.payment_method_data.clone(),
item.data.request.get_complete_authorize_url()?,
)?)),
mandate_reference: Box::new(None),
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: None,
incremental_authorization_allowed: None,
charges: None,
}),
..item.data
}),
BraintreePaymentsResponse::WalletPaymentsResponse(google_pay_payments_response) => {
let txn = &google_pay_payments_response
.data
.charge_payment_method
.transaction;
let status = enums::AttemptStatus::from(txn.status.clone());
let response = if utils::is_payment_failure(status) {
Err(hyperswitch_domain_models::router_data::ErrorResponse {
code: txn.status.to_string(),
message: txn.status.to_string(),
reason: Some(txn.status.to_string()),
attempt_status: None,
connector_transaction_id: Some(txn.id.clone()),
status_code: item.http_code,
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
connector_metadata: None,
})
} else {
Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(txn.id.clone()),
redirection_data: Box::new(None),
mandate_reference: Box::new(None),
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: None,
incremental_authorization_allowed: None,
charges: None,
})
};
Ok(Self {
status,
response,
..item.data
})
}
}
}
}
impl<F>
TryFrom<
ResponseRouterData<
F,
BraintreeCompleteChargeResponse,
CompleteAuthorizeData,
PaymentsResponseData,
>,
> for RouterData<F, CompleteAuthorizeData, PaymentsResponseData>
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: ResponseRouterData<
F,
BraintreeCompleteChargeResponse,
CompleteAuthorizeData,
PaymentsResponseData,
>,
) -> Result<Self, Self::Error> {
match item.response {
BraintreeCompleteChargeResponse::ErrorResponse(error_response) => Ok(Self {
response: build_error_response(&error_response.errors.clone(), item.http_code)
.map_err(|err| *err),
..item.data
}),
BraintreeCompleteChargeResponse::PaymentsResponse(payment_response) => {
let transaction_data = payment_response.data.charge_credit_card.transaction;
let status = enums::AttemptStatus::from(transaction_data.status.clone());
let response = if utils::is_payment_failure(status) {
Err(hyperswitch_domain_models::router_data::ErrorResponse {
code: transaction_data.status.to_string().clone(),
message: transaction_data.status.to_string().clone(),
reason: Some(transaction_data.status.to_string().clone()),
attempt_status: None,
connector_transaction_id: Some(transaction_data.id),
status_code: item.http_code,
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
connector_metadata: None,
})
} else {
Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(transaction_data.id),
redirection_data: Box::new(None),
mandate_reference: Box::new(transaction_data.payment_method.as_ref().map(
|pm| MandateReference {
connector_mandate_id: Some(pm.id.clone().expose()),
payment_method_id: None,
mandate_metadata: None,
connector_mandate_request_reference_id: None,
},
)),
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: None,
incremental_authorization_allowed: None,
charges: None,
})
};
Ok(Self {
status,
response,
..item.data
})
}
}
}
}
impl<F>
TryFrom<
ResponseRouterData<
F,
BraintreeCompleteAuthResponse,
CompleteAuthorizeData,
PaymentsResponseData,
>,
> for RouterData<F, CompleteAuthorizeData, PaymentsResponseData>
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: ResponseRouterData<
F,
BraintreeCompleteAuthResponse,
CompleteAuthorizeData,
PaymentsResponseData,
>,
) -> Result<Self, Self::Error> {
match item.response {
BraintreeCompleteAuthResponse::ErrorResponse(error_response) => Ok(Self {
response: build_error_response(&error_response.errors, item.http_code)
.map_err(|err| *err),
..item.data
}),
BraintreeCompleteAuthResponse::AuthResponse(auth_response) => {
let transaction_data = auth_response.data.authorize_credit_card.transaction;
let status = enums::AttemptStatus::from(transaction_data.status.clone());
let response = if utils::is_payment_failure(status) {
Err(hyperswitch_domain_models::router_data::ErrorResponse {
code: transaction_data.status.to_string().clone(),
message: transaction_data.status.to_string().clone(),
reason: Some(transaction_data.status.to_string().clone()),
attempt_status: None,
connector_transaction_id: Some(transaction_data.id),
status_code: item.http_code,
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
connector_metadata: None,
})
} else {
Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(transaction_data.id),
redirection_data: Box::new(None),
mandate_reference: Box::new(transaction_data.payment_method.as_ref().map(
|pm| MandateReference {
connector_mandate_id: Some(pm.id.clone().expose()),
payment_method_id: None,
mandate_metadata: None,
connector_mandate_request_reference_id: None,
},
)),
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: None,
incremental_authorization_allowed: None,
charges: None,
})
};
Ok(Self {
status,
response,
..item.data
})
}
}
}
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct PaymentsResponse {
data: DataResponse,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct WalletPaymentsResponse {
pub data: WalletDataResponse,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct WalletDataResponse {
pub charge_payment_method: WalletTransactionWrapper,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct WalletTransactionWrapper {
pub transaction: WalletTransaction,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct WalletTransaction {
pub id: String,
#[serde(skip_serializing_if = "Option::is_none")]
pub legacy_id: Option<String>,
pub status: BraintreePaymentStatus,
pub amount: Amount,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct Amount {
pub value: String,
pub currency_code: String,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct WalletAuthResponse {
pub data: WalletAuthDataResponse,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct WalletAuthDataResponse {
pub authorize_payment_method: WalletTransactionWrapper,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(untagged)]
pub enum BraintreePaymentsResponse {
PaymentsResponse(Box<PaymentsResponse>),
WalletPaymentsResponse(Box<WalletPaymentsResponse>),
ClientTokenResponse(Box<ClientTokenResponse>),
ErrorResponse(Box<ErrorResponse>),
}
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(untagged)]
pub enum BraintreeCompleteChargeResponse {
PaymentsResponse(Box<PaymentsResponse>),
ErrorResponse(Box<ErrorResponse>),
}
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct DataResponse {
charge_credit_card: AuthChargeCreditCard,
}
#[derive(Debug, Clone, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct RefundInputData {
amount: StringMajorUnit,
merchant_account_id: Secret<String>,
#[serde(skip_serializing_if = "Option::is_none")]
order_id: Option<String>,
}
#[derive(Serialize, Debug, Clone)]
struct IdFilter {
is: String,
}
#[derive(Debug, Clone, Serialize)]
pub struct TransactionSearchInput {
id: IdFilter,
}
#[derive(Debug, Clone, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct BraintreeRefundInput {
transaction_id: String,
refund: RefundInputData,
}
impl<F> TryFrom<BraintreeRouterData<&RefundsRouterData<F>>> for BraintreeRefundRequest {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(item: BraintreeRouterData<&RefundsRouterData<F>>) -> Result<Self, Self::Error> {
let metadata: BraintreeMeta = if let (
Some(merchant_account_id),
Some(merchant_config_currency),
) = (
item.router_data.request.merchant_account_id.clone(),
item.router_data.request.merchant_config_currency,
) {
router_env::logger::info!(
"BRAINTREE: Picking merchant_account_id and merchant_config_currency from payments request"
);
BraintreeMeta {
merchant_account_id,
merchant_config_currency,
}
} else {
utils::to_connector_meta_from_secret(item.router_data.connector_meta_data.clone())
.change_context(errors::ConnectorError::InvalidConnectorConfig {
config: "metadata",
})?
};
utils::validate_currency(
item.router_data.request.currency,
Some(metadata.merchant_config_currency),
)?;
let query = REFUND_TRANSACTION_MUTATION.to_string();
let variables = BraintreeRefundVariables {
input: BraintreeRefundInput {
transaction_id: item.router_data.request.connector_transaction_id.clone(),
refund: RefundInputData {
amount: item.amount,
merchant_account_id: metadata.merchant_account_id,
order_id: item.router_data.refund_id.clone(),
},
},
};
Ok(Self { query, variables })
}
}
#[derive(Debug, Clone, Deserialize, Serialize, strum::Display)]
#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
pub enum BraintreeRefundStatus {
SettlementPending,
Settling,
Settled,
SubmittedForSettlement,
Failed,
}
impl From<BraintreeRefundStatus> for enums::RefundStatus {
fn from(item: BraintreeRefundStatus) -> Self {
match item {
BraintreeRefundStatus::Settled
| BraintreeRefundStatus::Settling
| BraintreeRefundStatus::SubmittedForSettlement
| BraintreeRefundStatus::SettlementPending => Self::Success,
BraintreeRefundStatus::Failed => Self::Failure,
}
}
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct BraintreeRefundTransactionBody {
pub id: String,
pub status: BraintreeRefundStatus,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct BraintreeRefundTransaction {
pub refund: BraintreeRefundTransactionBody,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct BraintreeRefundResponseData {
pub refund_transaction: BraintreeRefundTransaction,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct RefundResponse {
pub data: BraintreeRefundResponseData,
}
impl TryFrom<RefundsResponseRouterData<Execute, BraintreeRefundResponse>>
for RefundsRouterData<Execute>
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: RefundsResponseRouterData<Execute, BraintreeRefundResponse>,
) -> Result<Self, Self::Error> {
Ok(Self {
response: match item.response {
BraintreeRefundResponse::ErrorResponse(error_response) => {
build_error_response(&error_response.errors, item.http_code).map_err(|err| *err)
}
BraintreeRefundResponse::SuccessResponse(refund_data) => {
let refund_data = refund_data.data.refund_transaction.refund;
let refund_status = enums::RefundStatus::from(refund_data.status.clone());
if utils::is_refund_failure(refund_status) {
Err(hyperswitch_domain_models::router_data::ErrorResponse {
code: refund_data.status.to_string().clone(),
message: refund_data.status.to_string().clone(),
reason: Some(refund_data.status.to_string().clone()),
attempt_status: None,
connector_transaction_id: Some(refund_data.id),
status_code: item.http_code,
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
connector_metadata: None,
})
} else {
Ok(RefundsResponseData {
connector_refund_id: refund_data.id.clone(),
refund_status,
})
}
}
},
..item.data
})
}
}
#[derive(Debug, Clone, Serialize)]
pub struct RefundSearchInput {
id: IdFilter,
}
impl TryFrom<&types::RefundSyncRouterData> for BraintreeRSyncRequest {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(item: &types::RefundSyncRouterData) -> Result<Self, Self::Error> {
let metadata: BraintreeMeta = if let (
Some(merchant_account_id),
Some(merchant_config_currency),
) = (
item.request.merchant_account_id.clone(),
item.request.merchant_config_currency,
) {
router_env::logger::info!(
"BRAINTREE: Picking merchant_account_id and merchant_config_currency from payments request"
);
BraintreeMeta {
merchant_account_id,
merchant_config_currency,
}
} else {
utils::to_connector_meta_from_secret(item.connector_meta_data.clone()).change_context(
errors::ConnectorError::InvalidConnectorConfig { config: "metadata" },
)?
};
utils::validate_currency(
item.request.currency,
Some(metadata.merchant_config_currency),
)?;
let refund_id = item.request.get_connector_refund_id()?;
Ok(Self {
query: REFUND_QUERY.to_string(),
variables: RSyncInput {
input: RefundSearchInput {
id: IdFilter { is: refund_id },
},
},
})
}
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct RSyncNodeData {
id: String,
status: BraintreeRefundStatus,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct RSyncEdgeData {
node: RSyncNodeData,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct RefundData {
edges: Vec<RSyncEdgeData>,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct RSyncSearchData {
refunds: RefundData,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct RSyncResponseData {
search: RSyncSearchData,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct RSyncResponse {
data: RSyncResponseData,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(untagged)]
pub enum BraintreeRSyncResponse {
RSyncResponse(Box<RSyncResponse>),
ErrorResponse(Box<ErrorResponse>),
}
impl TryFrom<RefundsResponseRouterData<RSync, BraintreeRSyncResponse>>
for RefundsRouterData<RSync>
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: RefundsResponseRouterData<RSync, BraintreeRSyncResponse>,
) -> Result<Self, Self::Error> {
match item.response {
BraintreeRSyncResponse::ErrorResponse(error_response) => Ok(Self {
response: build_error_response(&error_response.errors, item.http_code)
.map_err(|err| *err),
..item.data
}),
BraintreeRSyncResponse::RSyncResponse(rsync_response) => {
let edge_data = rsync_response
.data
.search
.refunds
.edges
.first()
.ok_or(errors::ConnectorError::MissingConnectorRefundID)?;
let connector_refund_id = &edge_data.node.id;
let response = Ok(RefundsResponseData {
connector_refund_id: connector_refund_id.to_string(),
refund_status: enums::RefundStatus::from(edge_data.node.status.clone()),
});
Ok(Self {
response,
..item.data
})
}
}
}
}
#[derive(Debug, Clone, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct CreditCardData {
number: cards::CardNumber,
expiration_year: Secret<String>,
expiration_month: Secret<String>,
cvv: Secret<String>,
cardholder_name: Secret<String>,
}
#[derive(Debug, Clone, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ClientTokenInput {
merchant_account_id: Secret<String>,
}
#[derive(Debug, Clone, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct InputData {
credit_card: CreditCardData,
}
#[derive(Debug, Clone, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct InputClientTokenData {
client_token: ClientTokenInput,
}
impl TryFrom<&types::TokenizationRouterData> for BraintreeTokenRequest {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(item: &types::TokenizationRouterData) -> Result<Self, Self::Error> {
match item.request.payment_method_data.clone() {
PaymentMethodData::Card(card_data) => Ok(Self {
query: TOKENIZE_CREDIT_CARD.to_string(),
variables: VariableInput {
input: InputData {
credit_card: CreditCardData {
number: card_data.card_number,
expiration_year: card_data.card_exp_year,
expiration_month: card_data.card_exp_month,
cvv: card_data.card_cvc,
cardholder_name: item
.get_optional_billing_full_name()
.unwrap_or(Secret::new("".to_string())),
},
},
},
}),
PaymentMethodData::CardRedirect(_)
| PaymentMethodData::Wallet(_)
| PaymentMethodData::PayLater(_)
| PaymentMethodData::BankRedirect(_)
| PaymentMethodData::BankDebit(_)
| PaymentMethodData::BankTransfer(_)
| PaymentMethodData::Crypto(_)
| PaymentMethodData::MandatePayment
| PaymentMethodData::OpenBanking(_)
| PaymentMethodData::Reward
| PaymentMethodData::RealTimePayment(_)
| PaymentMethodData::MobilePayment(_)
| PaymentMethodData::Upi(_)
| PaymentMethodData::Voucher(_)
| PaymentMethodData::GiftCard(_)
| PaymentMethodData::CardToken(_)
| PaymentMethodData::NetworkToken(_)
| PaymentMethodData::CardDetailsForNetworkTransactionId(_) => {
Err(errors::ConnectorError::NotImplemented(
utils::get_unimplemented_payment_method_error_message("braintree"),
)
.into())
}
}
}
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct TokenizePaymentMethodData {
id: Secret<String>,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct TokenizeCreditCardData {
payment_method: TokenizePaymentMethodData,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ClientToken {
client_token: Secret<String>,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct TokenizeCreditCard {
tokenize_credit_card: TokenizeCreditCardData,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ClientTokenData {
create_client_token: ClientToken,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ClientTokenExtensions {
request_id: String,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct ClientTokenResponse {
data: ClientTokenData,
extensions: ClientTokenExtensions,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct TokenResponse {
data: TokenizeCreditCard,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct ErrorResponse {
errors: Vec<ErrorDetails>,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(untagged)]
pub enum BraintreeTokenResponse {
TokenResponse(Box<TokenResponse>),
ErrorResponse(Box<ErrorResponse>),
}
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(untagged)]
pub enum BraintreeSessionResponse {
SessionTokenResponse(Box<ClientTokenResponse>),
ErrorResponse(Box<ErrorResponse>),
}
impl<F, T> TryFrom<ResponseRouterData<F, BraintreeTokenResponse, T, PaymentsResponseData>>
for RouterData<F, T, PaymentsResponseData>
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: ResponseRouterData<F, BraintreeTokenResponse, T, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
Ok(Self {
response: match item.response {
BraintreeTokenResponse::ErrorResponse(error_response) => {
build_error_response(error_response.errors.as_ref(), item.http_code)
.map_err(|err| *err)
}
BraintreeTokenResponse::TokenResponse(token_response) => {
Ok(PaymentsResponseData::TokenizationResponse {
token: token_response
.data
.tokenize_credit_card
.payment_method
.id
.expose()
.clone(),
})
}
},
..item.data
})
}
}
#[derive(Debug, Clone, Display, Deserialize, Serialize)]
#[serde(rename_all = "snake_case")]
pub enum GooglePayPriceStatus {
#[strum(serialize = "FINAL")]
Final,
}
#[derive(Debug, Clone, Display, Deserialize, Serialize)]
#[serde(rename_all = "snake_case")]
pub enum PaypalFlow {
Checkout,
}
impl From<PaypalFlow> for payment_types::PaypalFlow {
fn from(item: PaypalFlow) -> Self {
match item {
PaypalFlow::Checkout => Self::Checkout,
}
}
}
impl
ForeignTryFrom<(
PaymentsSessionResponseRouterData<BraintreeSessionResponse>,
Self,
)> for types::PaymentsSessionRouterData
{
type Error = error_stack::Report<errors::ConnectorError>;
fn foreign_try_from(
(item, data): (
PaymentsSessionResponseRouterData<BraintreeSessionResponse>,
Self,
),
) -> Result<Self, Self::Error> {
let response = &item.response;
match response {
BraintreeSessionResponse::SessionTokenResponse(res) => {
let session_token = match data.payment_method_type {
Some(common_enums::PaymentMethodType::ApplePay) => {
let payment_request_data: payment_types::PaymentRequestMetadata =
if let Some(connector_meta) = data.connector_meta_data.clone() {
let meta_value: serde_json::Value = connector_meta.expose();
meta_value
.get("apple_pay_combined")
.ok_or(errors::ConnectorError::NoConnectorMetaData)
.attach_printable("Missing apple_pay_combined metadata")?
.get("manual")
.ok_or(errors::ConnectorError::NoConnectorMetaData)
.attach_printable("Missing manual metadata")?
.get("payment_request_data")
.ok_or(errors::ConnectorError::NoConnectorMetaData)
.attach_printable("Missing payment_request_data metadata")?
.clone()
.parse_value("PaymentRequestMetadata")
.change_context(errors::ConnectorError::ParsingFailed)
.attach_printable(
"Failed to parse apple_pay_combined.manual.payment_request_data metadata",
)?
} else {
return Err(errors::ConnectorError::NoConnectorMetaData)
.attach_printable("connector_meta_data is None");
};
let session_token_data = Some(ApplePaySessionResponse::ThirdPartySdk(
payment_types::ThirdPartySdkSessionResponse {
secrets: payment_types::SecretInfoToInitiateSdk {
display: res.data.create_client_token.client_token.clone(),
payment: None,
},
},
));
SessionToken::ApplePay(Box::new(
api_models::payments::ApplepaySessionTokenResponse {
session_token_data,
payment_request_data: Some(
api_models::payments::ApplePayPaymentRequest {
country_code: data.request.country.ok_or(
errors::ConnectorError::MissingRequiredField {
field_name: "country",
},
)?,
currency_code: data.request.currency,
total: api_models::payments::AmountInfo {
label: payment_request_data.label,
total_type: None,
amount: StringMajorUnitForConnector
.convert(
MinorUnit::new(data.request.amount),
data.request.currency,
)
.change_context(
errors::ConnectorError::AmountConversionFailed,
)?,
},
merchant_capabilities: Some(
payment_request_data.merchant_capabilities,
),
supported_networks: Some(
payment_request_data.supported_networks,
),
merchant_identifier: None,
required_billing_contact_fields: None,
required_shipping_contact_fields: None,
recurring_payment_request: None,
},
),
connector: data.connector.clone(),
delayed_session_token: false,
sdk_next_action: api_models::payments::SdkNextAction {
next_action: api_models::payments::NextActionCall::Confirm,
},
connector_reference_id: None,
connector_sdk_public_key: None,
connector_merchant_id: None,
},
))
}
Some(common_enums::PaymentMethodType::GooglePay) => {
let gpay_data: payment_types::GpaySessionTokenData =
if let Some(connector_meta) = data.connector_meta_data.clone() {
connector_meta
.expose()
.parse_value("GpaySessionTokenData")
.change_context(errors::ConnectorError::ParsingFailed)
.attach_printable("Failed to parse gpay metadata")?
} else {
return Err(errors::ConnectorError::NoConnectorMetaData)
.attach_printable("connector_meta_data is None");
};
SessionToken::GooglePay(Box::new(
api_models::payments::GpaySessionTokenResponse::GooglePaySession(
api_models::payments::GooglePaySessionResponse {
merchant_info: payment_types::GpayMerchantInfo {
merchant_name: gpay_data.data.merchant_info.merchant_name,
merchant_id: gpay_data.data.merchant_info.merchant_id,
},
shipping_address_required: false,
email_required: false,
shipping_address_parameters:
payment_types::GpayShippingAddressParameters {
phone_number_required: false,
},
allowed_payment_methods: gpay_data.data.allowed_payment_methods,
transaction_info: payment_types::GpayTransactionInfo {
country_code: data.request.country.ok_or(
errors::ConnectorError::MissingRequiredField {
field_name: "country",
},
)?,
currency_code: data.request.currency,
total_price_status: GooglePayPriceStatus::Final.to_string(),
total_price: StringMajorUnitForConnector
.convert(
MinorUnit::new(data.request.amount),
data.request.currency,
)
.change_context(
errors::ConnectorError::AmountConversionFailed,
)?,
},
secrets: Some(payment_types::SecretInfoToInitiateSdk {
display: res.data.create_client_token.client_token.clone(),
payment: None,
}),
delayed_session_token: false,
connector: data.connector.clone(),
sdk_next_action: payment_types::SdkNextAction {
next_action: payment_types::NextActionCall::Confirm,
},
},
),
))
}
Some(common_enums::PaymentMethodType::Paypal) => {
let paypal_sdk_data = data
.connector_meta_data
.clone()
.parse_value::<payment_types::PaypalSdkSessionTokenData>(
"PaypalSdkSessionTokenData",
)
.change_context(errors::ConnectorError::NoConnectorMetaData)
.attach_printable("Failed to parse paypal_sdk metadata.".to_string())?;
SessionToken::Paypal(Box::new(
api_models::payments::PaypalSessionTokenResponse {
connector: data.connector.clone(),
session_token: paypal_sdk_data.data.client_id,
sdk_next_action: api_models::payments::SdkNextAction {
next_action: api_models::payments::NextActionCall::Confirm,
},
client_token: Some(
res.data.create_client_token.client_token.clone().expose(),
),
transaction_info: Some(
api_models::payments::PaypalTransactionInfo {
flow: PaypalFlow::Checkout.into(),
currency_code: data.request.currency,
total_price: StringMajorUnitForConnector
.convert(
MinorUnit::new(data.request.amount),
data.request.currency,
)
.change_context(
errors::ConnectorError::AmountConversionFailed,
)?,
},
),
},
))
}
_ => {
return Err(errors::ConnectorError::NotImplemented(
format!(
"SDK session token generation is not supported for payment method: {:?}",
data.payment_method_type
)
)
.into());
}
};
Ok(Self {
response: Ok(PaymentsResponseData::SessionResponse { session_token }),
..data
})
}
BraintreeSessionResponse::ErrorResponse(error_response) => {
let err = build_error_response(error_response.errors.as_ref(), item.http_code)
.map_err(|err| *err);
Ok(Self {
response: err,
..data
})
}
}
}
}
#[derive(Debug, Clone, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct CaptureTransactionBody {
amount: StringMajorUnit,
}
#[derive(Debug, Clone, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct CaptureInputData {
transaction_id: String,
transaction: CaptureTransactionBody,
}
impl TryFrom<&BraintreeRouterData<&types::PaymentsCaptureRouterData>> for BraintreeCaptureRequest {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: &BraintreeRouterData<&types::PaymentsCaptureRouterData>,
) -> Result<Self, Self::Error> {
let query = CAPTURE_TRANSACTION_MUTATION.to_string();
let variables = VariableCaptureInput {
input: CaptureInputData {
transaction_id: item.router_data.request.connector_transaction_id.clone(),
transaction: CaptureTransactionBody {
amount: item.amount.to_owned(),
},
},
};
Ok(Self { query, variables })
}
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct CaptureResponseTransactionBody {
id: String,
status: BraintreePaymentStatus,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct CaptureTransactionData {
transaction: CaptureResponseTransactionBody,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct CaptureResponseData {
capture_transaction: CaptureTransactionData,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct CaptureResponse {
data: CaptureResponseData,
}
impl TryFrom<PaymentsCaptureResponseRouterData<BraintreeCaptureResponse>>
for types::PaymentsCaptureRouterData
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: PaymentsCaptureResponseRouterData<BraintreeCaptureResponse>,
) -> Result<Self, Self::Error> {
match item.response {
BraintreeCaptureResponse::SuccessResponse(capture_data) => {
let transaction_data = capture_data.data.capture_transaction.transaction;
let status = enums::AttemptStatus::from(transaction_data.status.clone());
let response = if utils::is_payment_failure(status) {
Err(hyperswitch_domain_models::router_data::ErrorResponse {
code: transaction_data.status.to_string().clone(),
message: transaction_data.status.to_string().clone(),
reason: Some(transaction_data.status.to_string().clone()),
attempt_status: None,
connector_transaction_id: Some(transaction_data.id),
status_code: item.http_code,
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
connector_metadata: None,
})
} else {
Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(transaction_data.id),
redirection_data: Box::new(None),
mandate_reference: Box::new(None),
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: None,
incremental_authorization_allowed: None,
charges: None,
})
};
Ok(Self {
status,
response,
..item.data
})
}
BraintreeCaptureResponse::ErrorResponse(error_data) => Ok(Self {
response: build_error_response(&error_data.errors, item.http_code)
.map_err(|err| *err),
..item.data
}),
}
}
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct DeletePaymentMethodFromVaultInputData {
payment_method_id: Secret<String>,
}
#[derive(Debug, Serialize)]
pub struct VariableDeletePaymentMethodFromVaultInput {
input: DeletePaymentMethodFromVaultInputData,
}
#[derive(Debug, Serialize)]
pub struct BraintreeRevokeMandateRequest {
query: String,
variables: VariableDeletePaymentMethodFromVaultInput,
}
impl TryFrom<&types::MandateRevokeRouterData> for BraintreeRevokeMandateRequest {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(item: &types::MandateRevokeRouterData) -> Result<Self, Self::Error> {
let query = DELETE_PAYMENT_METHOD_FROM_VAULT_MUTATION.to_string();
let variables = VariableDeletePaymentMethodFromVaultInput {
input: DeletePaymentMethodFromVaultInputData {
payment_method_id: Secret::new(
item.request
.connector_mandate_id
.clone()
.ok_or(errors::ConnectorError::MissingConnectorMandateID)?,
),
},
};
Ok(Self { query, variables })
}
}
impl<F>
TryFrom<
ResponseRouterData<
F,
BraintreeRevokeMandateResponse,
MandateRevokeRequestData,
MandateRevokeResponseData,
>,
> for RouterData<F, MandateRevokeRequestData, MandateRevokeResponseData>
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: ResponseRouterData<
F,
BraintreeRevokeMandateResponse,
MandateRevokeRequestData,
MandateRevokeResponseData,
>,
) -> Result<Self, Self::Error> {
Ok(Self {
response: match item.response {
BraintreeRevokeMandateResponse::ErrorResponse(error_response) => {
build_error_response(error_response.errors.as_ref(), item.http_code)
.map_err(|err| *err)
}
BraintreeRevokeMandateResponse::RevokeMandateResponse(..) => {
Ok(MandateRevokeResponseData {
mandate_status: common_enums::MandateStatus::Revoked,
})
}
},
..item.data
})
}
}
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(untagged)]
pub enum BraintreeRevokeMandateResponse {
RevokeMandateResponse(Box<RevokeMandateResponse>),
ErrorResponse(Box<ErrorResponse>),
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct RevokeMandateResponse {
data: DeletePaymentMethodFromVault,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct DeletePaymentMethodFromVault {
client_mutation_id: Option<String>,
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct CancelInputData {
transaction_id: String,
}
#[derive(Debug, Serialize)]
pub struct VariableCancelInput {
input: CancelInputData,
}
#[derive(Debug, Serialize)]
pub struct BraintreeCancelRequest {
query: String,
variables: VariableCancelInput,
}
impl TryFrom<&types::PaymentsCancelRouterData> for BraintreeCancelRequest {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(item: &types::PaymentsCancelRouterData) -> Result<Self, Self::Error> {
let query = VOID_TRANSACTION_MUTATION.to_string();
let variables = VariableCancelInput {
input: CancelInputData {
transaction_id: item.request.connector_transaction_id.clone(),
},
};
Ok(Self { query, variables })
}
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct CancelResponseTransactionBody {
id: String,
status: BraintreePaymentStatus,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct CancelTransactionData {
reversal: CancelResponseTransactionBody,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct CancelResponseData {
reverse_transaction: CancelTransactionData,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct CancelResponse {
data: CancelResponseData,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(untagged)]
pub enum BraintreeCancelResponse {
CancelResponse(Box<CancelResponse>),
ErrorResponse(Box<ErrorResponse>),
}
impl<F, T> TryFrom<ResponseRouterData<F, BraintreeCancelResponse, T, PaymentsResponseData>>
for RouterData<F, T, PaymentsResponseData>
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: ResponseRouterData<F, BraintreeCancelResponse, T, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
match item.response {
BraintreeCancelResponse::ErrorResponse(error_response) => Ok(Self {
response: build_error_response(&error_response.errors, item.http_code)
.map_err(|err| *err),
..item.data
}),
BraintreeCancelResponse::CancelResponse(void_response) => {
let void_data = void_response.data.reverse_transaction.reversal;
let status = enums::AttemptStatus::from(void_data.status.clone());
let response = if utils::is_payment_failure(status) {
Err(hyperswitch_domain_models::router_data::ErrorResponse {
code: void_data.status.to_string().clone(),
message: void_data.status.to_string().clone(),
reason: Some(void_data.status.to_string().clone()),
attempt_status: None,
connector_transaction_id: None,
status_code: item.http_code,
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
connector_metadata: None,
})
} else {
Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::NoResponseId,
redirection_data: Box::new(None),
mandate_reference: Box::new(None),
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: None,
incremental_authorization_allowed: None,
charges: None,
})
};
Ok(Self {
status,
response,
..item.data
})
}
}
}
}
impl TryFrom<&types::PaymentsSyncRouterData> for BraintreePSyncRequest {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(item: &types::PaymentsSyncRouterData) -> Result<Self, Self::Error> {
let transaction_id = item
.request
.connector_transaction_id
.get_connector_transaction_id()
.change_context(errors::ConnectorError::MissingConnectorTransactionID)?;
Ok(Self {
query: TRANSACTION_QUERY.to_string(),
variables: PSyncInput {
input: TransactionSearchInput {
id: IdFilter { is: transaction_id },
},
},
})
}
}
impl TryFrom<&types::PaymentsSessionRouterData> for BraintreePaymentsRequest {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(item: &types::PaymentsSessionRouterData) -> Result<Self, Self::Error> {
let metadata: BraintreeMeta = utils::to_connector_meta_from_secret(
item.connector_meta_data.clone(),
)
.change_context(errors::ConnectorError::InvalidConnectorConfig { config: "metadata" })?;
Ok(Self::Session(BraintreeClientTokenRequest {
query: CLIENT_TOKEN_MUTATION.to_owned(),
variables: VariableClientTokenInput {
input: InputClientTokenData {
client_token: ClientTokenInput {
merchant_account_id: metadata.merchant_account_id,
},
},
},
}))
}
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct NodeData {
id: String,
status: BraintreePaymentStatus,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct EdgeData {
node: NodeData,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct TransactionData {
edges: Vec<EdgeData>,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct SearchData {
transactions: TransactionData,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct PSyncResponseData {
search: SearchData,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct PSyncResponse {
data: PSyncResponseData,
}
impl<F, T> TryFrom<ResponseRouterData<F, BraintreePSyncResponse, T, PaymentsResponseData>>
for RouterData<F, T, PaymentsResponseData>
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: ResponseRouterData<F, BraintreePSyncResponse, T, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
match item.response {
BraintreePSyncResponse::ErrorResponse(error_response) => Ok(Self {
response: build_error_response(&error_response.errors, item.http_code)
.map_err(|err| *err),
..item.data
}),
BraintreePSyncResponse::SuccessResponse(psync_response) => {
let edge_data = psync_response
.data
.search
.transactions
.edges
.first()
.ok_or(errors::ConnectorError::MissingConnectorTransactionID)?;
let status = enums::AttemptStatus::from(edge_data.node.status.clone());
let response = if utils::is_payment_failure(status) {
Err(hyperswitch_domain_models::router_data::ErrorResponse {
code: edge_data.node.status.to_string().clone(),
message: edge_data.node.status.to_string().clone(),
reason: Some(edge_data.node.status.to_string().clone()),
attempt_status: None,
connector_transaction_id: None,
status_code: item.http_code,
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
connector_metadata: None,
})
} else {
Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(edge_data.node.id.clone()),
redirection_data: Box::new(None),
mandate_reference: Box::new(None),
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: None,
incremental_authorization_allowed: None,
charges: None,
})
};
Ok(Self {
status,
response,
..item.data
})
}
}
}
}
#[derive(Debug, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct BraintreeThreeDsResponse {
pub nonce: Secret<String>,
pub liability_shifted: bool,
pub liability_shift_possible: bool,
}
#[derive(Debug, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct BraintreeThreeDsErrorResponse {
pub code: String,
pub message: String,
}
#[derive(Debug, Deserialize)]
pub struct BraintreeRedirectionResponse {
pub authentication_response: String,
}
impl TryFrom<BraintreeMeta> for BraintreeClientTokenRequest {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(metadata: BraintreeMeta) -> Result<Self, Self::Error> {
Ok(Self {
query: CLIENT_TOKEN_MUTATION.to_owned(),
variables: VariableClientTokenInput {
input: InputClientTokenData {
client_token: ClientTokenInput {
merchant_account_id: metadata.merchant_account_id,
},
},
},
})
}
}
impl
TryFrom<(
&BraintreeRouterData<&types::PaymentsAuthorizeRouterData>,
BraintreeMeta,
)> for CardPaymentRequest
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
(item, metadata): (
&BraintreeRouterData<&types::PaymentsAuthorizeRouterData>,
BraintreeMeta,
),
) -> Result<Self, Self::Error> {
let (query, transaction_body) = if item.router_data.request.is_mandate_payment() {
(
match item.router_data.request.is_auto_capture()? {
true => CHARGE_AND_VAULT_TRANSACTION_MUTATION.to_string(),
false => AUTHORIZE_AND_VAULT_CREDIT_CARD_MUTATION.to_string(),
},
TransactionBody::Vault(VaultTransactionBody {
amount: item.amount.to_owned(),
merchant_account_id: metadata.merchant_account_id,
vault_payment_method_after_transacting: TransactionTiming {
when: "ALWAYS".to_string(),
},
customer_details: item
.router_data
.get_billing_email()
.ok()
.map(|email| CustomerBody { email }),
order_id: item.router_data.connector_request_reference_id.clone(),
}),
)
} else {
(
match item.router_data.request.is_auto_capture()? {
true => CHARGE_CREDIT_CARD_MUTATION.to_string(),
false => AUTHORIZE_CREDIT_CARD_MUTATION.to_string(),
},
TransactionBody::Regular(RegularTransactionBody {
amount: item.amount.to_owned(),
merchant_account_id: metadata.merchant_account_id,
channel: CHANNEL_CODE.to_string(),
customer_details: item
.router_data
.get_billing_email()
.ok()
.map(|email| CustomerBody { email }),
order_id: item.router_data.connector_request_reference_id.clone(),
}),
)
};
Ok(Self {
query,
variables: VariablePaymentInput {
input: PaymentInput {
payment_method_id: match item.router_data.get_payment_method_token()? {
PaymentMethodToken::Token(token) => token,
PaymentMethodToken::ApplePayDecrypt(_) => Err(
unimplemented_payment_method!("Apple Pay", "Simplified", "Braintree"),
)?,
PaymentMethodToken::PazeDecrypt(_) => {
Err(unimplemented_payment_method!("Paze", "Braintree"))?
}
PaymentMethodToken::GooglePayDecrypt(_) => {
Err(unimplemented_payment_method!("Google Pay", "Braintree"))?
}
},
transaction: transaction_body,
},
},
})
}
}
impl TryFrom<&BraintreeRouterData<&types::PaymentsCompleteAuthorizeRouterData>>
for CardPaymentRequest
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: &BraintreeRouterData<&types::PaymentsCompleteAuthorizeRouterData>,
) -> Result<Self, Self::Error> {
let metadata: BraintreeMeta = if let (
Some(merchant_account_id),
Some(merchant_config_currency),
) = (
item.router_data.request.merchant_account_id.clone(),
item.router_data.request.merchant_config_currency,
) {
router_env::logger::info!(
"BRAINTREE: Picking merchant_account_id and merchant_config_currency from payments request"
);
BraintreeMeta {
merchant_account_id,
merchant_config_currency,
}
} else {
utils::to_connector_meta_from_secret(item.router_data.connector_meta_data.clone())
.change_context(errors::ConnectorError::InvalidConnectorConfig {
config: "metadata",
})?
};
utils::validate_currency(
item.router_data.request.currency,
Some(metadata.merchant_config_currency),
)?;
let payload_data = PaymentsCompleteAuthorizeRequestData::get_redirect_response_payload(
&item.router_data.request,
)?
.expose();
let redirection_response: BraintreeRedirectionResponse = serde_json::from_value(
payload_data,
)
.change_context(errors::ConnectorError::MissingConnectorRedirectionPayload {
field_name: "redirection_response",
})?;
let three_ds_data = serde_json::from_str::<BraintreeThreeDsResponse>(
&redirection_response.authentication_response,
)
.change_context(errors::ConnectorError::MissingConnectorRedirectionPayload {
field_name: "three_ds_data",
})?;
let (query, transaction_body) = if item.router_data.request.is_mandate_payment() {
(
match item.router_data.request.is_auto_capture()? {
true => CHARGE_AND_VAULT_TRANSACTION_MUTATION.to_string(),
false => AUTHORIZE_AND_VAULT_CREDIT_CARD_MUTATION.to_string(),
},
TransactionBody::Vault(VaultTransactionBody {
amount: item.amount.to_owned(),
merchant_account_id: metadata.merchant_account_id,
vault_payment_method_after_transacting: TransactionTiming {
when: "ALWAYS".to_string(),
},
customer_details: item
.router_data
.get_billing_email()
.ok()
.map(|email| CustomerBody { email }),
order_id: item.router_data.connector_request_reference_id.clone(),
}),
)
} else {
(
match item.router_data.request.is_auto_capture()? {
true => CHARGE_CREDIT_CARD_MUTATION.to_string(),
false => AUTHORIZE_CREDIT_CARD_MUTATION.to_string(),
},
TransactionBody::Regular(RegularTransactionBody {
amount: item.amount.to_owned(),
merchant_account_id: metadata.merchant_account_id,
channel: CHANNEL_CODE.to_string(),
customer_details: item
.router_data
.get_billing_email()
.ok()
.map(|email| CustomerBody { email }),
order_id: item.router_data.connector_request_reference_id.clone(),
}),
)
};
Ok(Self {
query,
variables: VariablePaymentInput {
input: PaymentInput {
payment_method_id: three_ds_data.nonce,
transaction: transaction_body,
},
},
})
}
}
fn get_braintree_redirect_form(
client_token_data: ClientTokenResponse,
payment_method_token: PaymentMethodToken,
card_details: PaymentMethodData,
complete_authorize_url: String,
) -> Result<RedirectForm, error_stack::Report<errors::ConnectorError>> {
Ok(RedirectForm::Braintree {
client_token: client_token_data
.data
.create_client_token
.client_token
.expose(),
card_token: match payment_method_token {
PaymentMethodToken::Token(token) => token.expose(),
PaymentMethodToken::ApplePayDecrypt(_) => Err(unimplemented_payment_method!(
"Apple Pay",
"Simplified",
"Braintree"
))?,
PaymentMethodToken::PazeDecrypt(_) => {
Err(unimplemented_payment_method!("Paze", "Braintree"))?
}
PaymentMethodToken::GooglePayDecrypt(_) => {
Err(unimplemented_payment_method!("Google Pay", "Braintree"))?
}
},
bin: match card_details {
PaymentMethodData::Card(card_details) => card_details.card_number.get_card_isin(),
PaymentMethodData::CardRedirect(_)
| PaymentMethodData::Wallet(_)
| PaymentMethodData::PayLater(_)
| PaymentMethodData::BankRedirect(_)
| PaymentMethodData::BankDebit(_)
| PaymentMethodData::BankTransfer(_)
| PaymentMethodData::Crypto(_)
| PaymentMethodData::MandatePayment
| PaymentMethodData::OpenBanking(_)
| PaymentMethodData::Reward
| PaymentMethodData::RealTimePayment(_)
| PaymentMethodData::MobilePayment(_)
| PaymentMethodData::Upi(_)
| PaymentMethodData::Voucher(_)
| PaymentMethodData::GiftCard(_)
| PaymentMethodData::CardToken(_)
| PaymentMethodData::NetworkToken(_)
| PaymentMethodData::CardDetailsForNetworkTransactionId(_) => Err(
errors::ConnectorError::NotImplemented("given payment method".to_owned()),
)?,
},
acs_url: complete_authorize_url,
})
}
#[derive(Debug, Deserialize)]
pub struct BraintreeWebhookResponse {
pub bt_signature: String,
pub bt_payload: String,
}
#[derive(Debug, Deserialize, Serialize)]
#[serde(rename_all = "kebab-case")]
pub struct Notification {
pub kind: String, // xml parse only string to fields
pub timestamp: String,
pub dispute: Option<BraintreeDisputeData>,
}
pub(crate) fn get_status(status: &str) -> IncomingWebhookEvent {
match status {
"dispute_opened" => IncomingWebhookEvent::DisputeOpened,
"dispute_lost" => IncomingWebhookEvent::DisputeLost,
"dispute_won" => IncomingWebhookEvent::DisputeWon,
"dispute_accepted" | "dispute_auto_accepted" => IncomingWebhookEvent::DisputeAccepted,
"dispute_expired" => IncomingWebhookEvent::DisputeExpired,
"dispute_disputed" => IncomingWebhookEvent::DisputeChallenged,
_ => IncomingWebhookEvent::EventNotSupported,
}
}
#[derive(Debug, Deserialize, Serialize)]
pub struct BraintreeDisputeData {
pub amount_disputed: MinorUnit,
pub amount_won: Option<String>,
pub case_number: Option<String>,
pub chargeback_protection_level: Option<String>,
pub currency_iso_code: enums::Currency,
#[serde(default, with = "common_utils::custom_serde::iso8601::option")]
pub created_at: Option<PrimitiveDateTime>,
pub evidence: Option<DisputeEvidence>,
pub id: String,
pub kind: String, // xml parse only string to fields
pub status: String,
pub reason: Option<String>,
pub reason_code: Option<String>,
#[serde(default, with = "common_utils::custom_serde::iso8601::option")]
pub updated_at: Option<PrimitiveDateTime>,
#[serde(default, with = "common_utils::custom_serde::iso8601::option")]
pub reply_by_date: Option<PrimitiveDateTime>,
pub transaction: DisputeTransaction,
}
#[derive(Debug, Deserialize, Serialize)]
pub struct DisputeTransaction {
pub amount: StringMajorUnit,
pub id: String,
}
#[derive(Debug, Deserialize, Serialize)]
pub struct DisputeEvidence {
pub comment: String,
pub id: Secret<String>,
pub created_at: Option<PrimitiveDateTime>,
pub url: url::Url,
}
pub(crate) fn get_dispute_stage(code: &str) -> Result<enums::DisputeStage, errors::ConnectorError> {
match code {
"CHARGEBACK" => Ok(enums::DisputeStage::Dispute),
"PRE_ARBITRATION" => Ok(enums::DisputeStage::PreArbitration),
"RETRIEVAL" => Ok(enums::DisputeStage::PreDispute),
_ => Err(errors::ConnectorError::WebhookBodyDecodingFailed),
}
}
|
{
"crate": "hyperswitch_connectors",
"file": "crates/hyperswitch_connectors/src/connectors/braintree/transformers.rs",
"file_size": null,
"is_async": null,
"is_pub": null,
"num_enums": 17,
"num_structs": 94,
"num_tables": null,
"score": null,
"total_crates": null
}
|
file_hyperswitch_connectors_809757331099132177
|
clm
|
file
|
// Repository: hyperswitch
// Crate: hyperswitch_connectors
// File: crates/hyperswitch_connectors/src/connectors/worldpay/response.rs
// Contains: 29 structs, 8 enums
use error_stack::ResultExt;
use hyperswitch_interfaces::errors;
use masking::Secret;
use serde::{Deserialize, Serialize};
use url::Url;
use super::requests::*;
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct WorldpayPaymentsResponse {
pub outcome: PaymentOutcome,
pub transaction_reference: Option<String>,
#[serde(flatten)]
pub other_fields: Option<WorldpayPaymentResponseFields>,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
#[serde(untagged)]
pub enum WorldpayPaymentResponseFields {
RefusedResponse(RefusedResponse),
DDCResponse(DDCResponse),
ThreeDsChallenged(ThreeDsChallengedResponse),
FraudHighRisk(FraudHighRiskResponse),
AuthorizedResponse(Box<AuthorizedResponse>),
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct AuthorizedResponse {
pub payment_instrument: PaymentsResPaymentInstrument,
#[serde(skip_serializing_if = "Option::is_none")]
pub issuer: Option<Issuer>,
#[serde(skip_serializing_if = "Option::is_none")]
pub scheme: Option<PaymentsResponseScheme>,
#[serde(rename = "_links", skip_serializing_if = "Option::is_none")]
pub links: Option<SelfLink>,
#[serde(rename = "_actions")]
pub actions: Option<ActionLinks>,
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
pub risk_factors: Option<Vec<RiskFactorsInner>>,
pub fraud: Option<Fraud>,
/// Mandate's token
pub token: Option<MandateToken>,
/// Network transaction ID
pub scheme_reference: Option<Secret<String>>,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct MandateToken {
pub href: Secret<String>,
pub token_id: String,
pub token_expiry_date_time: String,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct FraudHighRiskResponse {
pub score: f32,
pub reason: Vec<String>,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct RefusedResponse {
pub refusal_description: String,
// Access Worldpay returns a raw response code in the refusalCode field (if enabled) containing the unmodified response code received either directly from the card scheme for Worldpay-acquired transactions, or from third party acquirers.
pub refusal_code: String,
pub risk_factors: Option<Vec<RiskFactorsInner>>,
pub fraud: Option<Fraud>,
#[serde(rename = "threeDS")]
pub three_ds: Option<ThreeDsResponse>,
pub advice: Option<Advice>,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct Advice {
pub code: Option<String>,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ThreeDsResponse {
pub outcome: String,
pub issuer_response: IssuerResponse,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ThreeDsChallengedResponse {
pub authentication: AuthenticationResponse,
pub challenge: ThreeDsChallenge,
#[serde(rename = "_actions")]
pub actions: CompleteThreeDsActionLink,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct AuthenticationResponse {
pub version: String,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct ThreeDsChallenge {
pub reference: String,
pub url: Url,
pub jwt: Secret<String>,
pub payload: Secret<String>,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct CompleteThreeDsActionLink {
#[serde(rename = "complete3dsChallenge")]
pub complete_three_ds_challenge: ActionLink,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "lowercase")]
pub enum IssuerResponse {
Challenged,
Frictionless,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct DDCResponse {
pub device_data_collection: DDCToken,
#[serde(rename = "_actions")]
pub actions: DDCActionLink,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct DDCToken {
pub jwt: Secret<String>,
pub url: Url,
pub bin: Secret<String>,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct DDCActionLink {
#[serde(rename = "supply3dsDeviceData")]
supply_ddc_data: ActionLink,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub enum PaymentOutcome {
#[serde(alias = "authorized", alias = "Authorized")]
Authorized,
Refused,
SentForSettlement,
SentForRefund,
FraudHighRisk,
#[serde(alias = "3dsDeviceDataRequired")]
ThreeDsDeviceDataRequired,
SentForCancellation,
#[serde(alias = "3dsAuthenticationFailed")]
ThreeDsAuthenticationFailed,
SentForPartialRefund,
#[serde(alias = "3dsChallenged")]
ThreeDsChallenged,
#[serde(alias = "3dsUnavailable")]
ThreeDsUnavailable,
}
impl std::fmt::Display for PaymentOutcome {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self {
Self::Authorized => write!(f, "authorized"),
Self::Refused => write!(f, "refused"),
Self::SentForSettlement => write!(f, "sentForSettlement"),
Self::SentForRefund => write!(f, "sentForRefund"),
Self::FraudHighRisk => write!(f, "fraudHighRisk"),
Self::ThreeDsDeviceDataRequired => write!(f, "3dsDeviceDataRequired"),
Self::SentForCancellation => write!(f, "sentForCancellation"),
Self::ThreeDsAuthenticationFailed => write!(f, "3dsAuthenticationFailed"),
Self::SentForPartialRefund => write!(f, "sentForPartialRefund"),
Self::ThreeDsChallenged => write!(f, "3dsChallenged"),
Self::ThreeDsUnavailable => write!(f, "3dsUnavailable"),
}
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct SelfLink {
#[serde(rename = "self")]
pub self_link: SelfLinkInner,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct SelfLinkInner {
pub href: String,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ActionLinks {
supply_3ds_device_data: Option<ActionLink>,
settle_payment: Option<ActionLink>,
partially_settle_payment: Option<ActionLink>,
refund_payment: Option<ActionLink>,
partially_refund_payment: Option<ActionLink>,
cancel_payment: Option<ActionLink>,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct ActionLink {
pub href: String,
pub method: String,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct Fraud {
pub outcome: FraudOutcome,
pub score: f32,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub enum FraudOutcome {
LowRisk,
HighRisk,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct WorldpayEventResponse {
pub last_event: EventType,
#[serde(rename = "_links", skip_serializing_if = "Option::is_none")]
pub links: Option<EventLinks>,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub enum EventType {
SentForAuthorization,
#[serde(alias = "Authorized")]
Authorized,
#[serde(alias = "Sent for Settlement")]
SentForSettlement,
Settled,
SettlementFailed,
Cancelled,
Error,
Expired,
Refused,
#[serde(alias = "Sent for Refund")]
SentForRefund,
Refunded,
RefundFailed,
#[serde(other)]
Unknown,
}
#[derive(Clone, Debug, PartialEq, Default, Serialize, Deserialize)]
pub struct EventLinks {
#[serde(rename = "payments:events", skip_serializing_if = "Option::is_none")]
pub events: Option<String>,
}
pub fn get_resource_id<T, F>(
response: WorldpayPaymentsResponse,
connector_transaction_id: Option<String>,
transform_fn: F,
) -> Result<T, error_stack::Report<errors::ConnectorError>>
where
F: Fn(String) -> T,
{
let optional_reference_id = response
.other_fields
.as_ref()
.and_then(|other_fields| match other_fields {
WorldpayPaymentResponseFields::AuthorizedResponse(res) => res
.links
.as_ref()
.and_then(|link| link.self_link.href.rsplit_once('/').map(|(_, h)| h)),
WorldpayPaymentResponseFields::DDCResponse(res) => {
res.actions.supply_ddc_data.href.split('/').nth_back(1)
}
WorldpayPaymentResponseFields::ThreeDsChallenged(res) => res
.actions
.complete_three_ds_challenge
.href
.split('/')
.nth_back(1),
WorldpayPaymentResponseFields::FraudHighRisk(_)
| WorldpayPaymentResponseFields::RefusedResponse(_) => None,
})
.map(|href| {
urlencoding::decode(href)
.map(|s| transform_fn(s.into_owned()))
.change_context(errors::ConnectorError::ResponseHandlingFailed)
})
.transpose()?;
optional_reference_id
.or_else(|| connector_transaction_id.map(transform_fn))
.ok_or_else(|| {
errors::ConnectorError::MissingRequiredField {
field_name: "_links.self.href",
}
.into()
})
}
pub struct ResponseIdStr {
pub id: String,
}
#[derive(Clone, Debug, PartialEq, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Issuer {
pub authorization_code: Secret<String>,
}
impl Issuer {
pub fn new(code: String) -> Self {
Self {
authorization_code: Secret::new(code),
}
}
}
#[derive(Clone, Debug, PartialEq, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct PaymentsResPaymentInstrument {
#[serde(rename = "type")]
pub payment_instrument_type: String,
pub card_bin: Option<String>,
pub last_four: Option<String>,
pub expiry_date: Option<ExpiryDate>,
pub card_brand: Option<String>,
pub funding_type: Option<String>,
pub category: Option<String>,
pub issuer_name: Option<String>,
pub payment_account_reference: Option<String>,
}
#[derive(Clone, Debug, PartialEq, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct RiskFactorsInner {
#[serde(rename = "type")]
pub risk_type: RiskType,
#[serde(skip_serializing_if = "Option::is_none")]
pub detail: Option<Detail>,
pub risk: Risk,
}
impl RiskFactorsInner {
pub fn new(risk_type: RiskType, risk: Risk) -> Self {
Self {
risk_type,
detail: None,
risk,
}
}
}
#[derive(
Clone, Copy, Default, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize,
)]
#[serde(rename_all = "camelCase")]
pub enum RiskType {
#[default]
Avs,
Cvc,
RiskProfile,
}
#[derive(
Clone, Copy, Default, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize,
)]
#[serde(rename_all = "lowercase")]
pub enum Detail {
#[default]
Address,
Postcode,
}
#[derive(
Clone, Copy, Default, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize,
)]
#[serde(rename_all = "camelCase")]
pub enum Risk {
#[default]
NotChecked,
NotMatched,
NotSupplied,
VerificationFailed,
}
#[derive(Clone, Debug, PartialEq, Default, Serialize, Deserialize)]
pub struct PaymentsResponseScheme {
pub reference: String,
}
impl PaymentsResponseScheme {
pub fn new(reference: String) -> Self {
Self { reference }
}
}
#[derive(Debug, Serialize, Deserialize, PartialEq)]
#[serde(rename_all = "camelCase")]
pub struct WorldpayErrorResponse {
pub error_name: String,
pub message: String,
pub validation_errors: Option<serde_json::Value>,
}
impl WorldpayErrorResponse {
pub fn default(status_code: u16) -> Self {
match status_code {
code @ 404 => Self {
error_name: format!("{code} Not found"),
message: "Resource not found".to_string(),
validation_errors: None,
},
code => Self {
error_name: code.to_string(),
message: "Unknown error".to_string(),
validation_errors: None,
},
}
}
}
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct WorldpayWebhookTransactionId {
pub event_details: EventDetails,
}
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct EventDetails {
#[serde(rename = "type")]
pub event_type: EventType,
pub transaction_reference: String,
/// Mandate's token
pub token: Option<MandateToken>,
/// Network transaction ID
pub scheme_reference: Option<Secret<String>>,
}
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct WorldpayWebhookEventType {
pub event_id: String,
pub event_timestamp: String,
pub event_details: EventDetails,
}
/// Worldpay's unique reference ID for a request
pub(super) const WP_CORRELATION_ID: &str = "WP-CorrelationId";
|
{
"crate": "hyperswitch_connectors",
"file": "crates/hyperswitch_connectors/src/connectors/worldpay/response.rs",
"file_size": null,
"is_async": null,
"is_pub": null,
"num_enums": 8,
"num_structs": 29,
"num_tables": null,
"score": null,
"total_crates": null
}
|
file_hyperswitch_connectors_-7535263408596337110
|
clm
|
file
|
// Repository: hyperswitch
// Crate: hyperswitch_connectors
// File: crates/hyperswitch_connectors/src/connectors/worldpay/payout_requests.rs
// Contains: 7 structs, 2 enums
use masking::Secret;
use serde::{Deserialize, Serialize};
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct WorldpayPayoutRequest {
pub transaction_reference: String,
pub merchant: Merchant,
pub instruction: PayoutInstruction,
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct PayoutInstruction {
pub payout_instrument: PayoutInstrument,
pub narrative: InstructionNarrative,
pub value: PayoutValue,
}
#[derive(Debug, Serialize, Deserialize)]
pub struct PayoutValue {
pub amount: i64,
pub currency: api_models::enums::Currency,
}
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Merchant {
pub entity: Secret<String>,
}
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct InstructionNarrative {
pub line1: Secret<String>,
}
#[derive(Debug, Serialize, Deserialize)]
#[serde(untagged)]
pub enum PayoutInstrument {
ApplePayDecrypt(ApplePayDecrypt),
}
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ApplePayDecrypt {
#[serde(rename = "type")]
pub payout_type: PayoutType,
pub dpan: cards::CardNumber,
pub card_expiry_date: PayoutExpiryDate,
#[serde(skip_serializing_if = "Option::is_none")]
pub card_holder_name: Option<Secret<String>>,
}
#[derive(Clone, Debug, PartialEq, Default, Serialize, Deserialize)]
pub struct PayoutExpiryDate {
pub month: Secret<i8>,
pub year: Secret<i32>,
}
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "lowercase")]
pub enum PayoutType {
#[serde(rename = "card/networkToken+applepay")]
ApplePayDecrypt,
}
|
{
"crate": "hyperswitch_connectors",
"file": "crates/hyperswitch_connectors/src/connectors/worldpay/payout_requests.rs",
"file_size": null,
"is_async": null,
"is_pub": null,
"num_enums": 2,
"num_structs": 7,
"num_tables": null,
"score": null,
"total_crates": null
}
|
file_hyperswitch_connectors_-8776447970315452656
|
clm
|
file
|
// Repository: hyperswitch
// Crate: hyperswitch_connectors
// File: crates/hyperswitch_connectors/src/connectors/worldpay/transformers.rs
// Contains: 2 structs, 0 enums
use std::collections::HashMap;
use api_models::payments::{MandateIds, MandateReferenceId};
use base64::Engine;
use common_enums::enums;
use common_utils::{
consts::BASE64_ENGINE, errors::CustomResult, ext_traits::OptionExt, pii, types::MinorUnit,
};
use error_stack::ResultExt;
use hyperswitch_domain_models::{
address,
payment_method_data::{PaymentMethodData, WalletData},
router_data::{ConnectorAuthType, ErrorResponse, RouterData},
router_flow_types::{Authorize, SetupMandate},
router_request_types::{
BrowserInformation, PaymentsAuthorizeData, ResponseId, SetupMandateRequestData,
},
router_response_types::{MandateReference, PaymentsResponseData, RedirectForm},
types,
};
use hyperswitch_interfaces::{api, errors};
use masking::{ExposeInterface, PeekInterface, Secret};
use serde::{Deserialize, Serialize};
use super::{requests::*, response::*};
use crate::{
types::ResponseRouterData,
utils::{
self, AddressData, ApplePay, CardData, ForeignTryFrom, PaymentsAuthorizeRequestData,
PaymentsSetupMandateRequestData, RouterData as RouterDataTrait,
},
};
#[derive(Debug, Serialize)]
pub struct WorldpayRouterData<T> {
amount: i64,
router_data: T,
}
impl<T> TryFrom<(&api::CurrencyUnit, enums::Currency, MinorUnit, T)> for WorldpayRouterData<T> {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
(_currency_unit, _currency, minor_amount, item): (
&api::CurrencyUnit,
enums::Currency,
MinorUnit,
T,
),
) -> Result<Self, Self::Error> {
Ok(Self {
amount: minor_amount.get_amount_as_i64(),
router_data: item,
})
}
}
#[derive(Debug, Default, Serialize, Deserialize)]
pub struct WorldpayConnectorMetadataObject {
pub merchant_name: Option<Secret<String>>,
}
impl TryFrom<Option<&pii::SecretSerdeValue>> for WorldpayConnectorMetadataObject {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(meta_data: Option<&pii::SecretSerdeValue>) -> Result<Self, Self::Error> {
let metadata: Self = utils::to_connector_meta_from_secret::<Self>(meta_data.cloned())
.change_context(errors::ConnectorError::InvalidConnectorConfig {
config: "metadata",
})?;
Ok(metadata)
}
}
fn fetch_payment_instrument(
payment_method: PaymentMethodData,
billing_address: Option<&address::Address>,
mandate_ids: Option<MandateIds>,
) -> CustomResult<PaymentInstrument, errors::ConnectorError> {
match payment_method {
PaymentMethodData::Card(card) => Ok(PaymentInstrument::Card(CardPayment {
raw_card_details: RawCardDetails {
payment_type: PaymentType::Plain,
expiry_date: ExpiryDate {
month: card.get_expiry_month_as_i8()?,
year: card.get_expiry_year_as_4_digit_i32()?,
},
card_number: card.card_number,
},
cvc: card.card_cvc,
card_holder_name: billing_address.and_then(|address| address.get_optional_full_name()),
billing_address: billing_address
.and_then(|addr| addr.address.clone())
.and_then(|address| {
match (address.line1, address.city, address.zip, address.country) {
(Some(address1), Some(city), Some(postal_code), Some(country_code)) => {
Some(BillingAddress {
address1,
address2: address.line2,
address3: address.line3,
city,
state: address.state,
postal_code,
country_code,
})
}
_ => None,
}
}),
})),
PaymentMethodData::CardDetailsForNetworkTransactionId(raw_card_details) => {
Ok(PaymentInstrument::RawCardForNTI(RawCardDetails {
payment_type: PaymentType::Plain,
expiry_date: ExpiryDate {
month: raw_card_details.get_expiry_month_as_i8()?,
year: raw_card_details.get_expiry_year_as_4_digit_i32()?,
},
card_number: raw_card_details.card_number,
}))
}
PaymentMethodData::MandatePayment => mandate_ids
.and_then(|mandate_ids| {
mandate_ids
.mandate_reference_id
.and_then(|mandate_id| match mandate_id {
MandateReferenceId::ConnectorMandateId(connector_mandate_id) => {
connector_mandate_id.get_connector_mandate_id().map(|href| {
PaymentInstrument::CardToken(CardToken {
payment_type: PaymentType::Token,
href,
cvc: None,
})
})
}
_ => None,
})
})
.ok_or(
errors::ConnectorError::MissingRequiredField {
field_name: "connector_mandate_id",
}
.into(),
),
PaymentMethodData::Wallet(wallet) => match wallet {
WalletData::GooglePay(data) => Ok(PaymentInstrument::Googlepay(WalletPayment {
payment_type: PaymentType::Encrypted,
wallet_token: Secret::new(
data.tokenization_data
.get_encrypted_google_pay_token()
.change_context(errors::ConnectorError::MissingRequiredField {
field_name: "gpay wallet_token",
})?,
),
..WalletPayment::default()
})),
WalletData::ApplePay(data) => Ok(PaymentInstrument::Applepay(WalletPayment {
payment_type: PaymentType::Encrypted,
wallet_token: data.get_applepay_decoded_payment_data()?,
..WalletPayment::default()
})),
WalletData::AliPayQr(_)
| WalletData::AliPayRedirect(_)
| WalletData::AliPayHkRedirect(_)
| WalletData::AmazonPay(_)
| WalletData::AmazonPayRedirect(_)
| WalletData::Paysera(_)
| WalletData::Skrill(_)
| WalletData::MomoRedirect(_)
| WalletData::KakaoPayRedirect(_)
| WalletData::GoPayRedirect(_)
| WalletData::BluecodeRedirect {}
| WalletData::GcashRedirect(_)
| WalletData::ApplePayRedirect(_)
| WalletData::ApplePayThirdPartySdk(_)
| WalletData::DanaRedirect {}
| WalletData::GooglePayRedirect(_)
| WalletData::GooglePayThirdPartySdk(_)
| WalletData::MbWayRedirect(_)
| WalletData::MobilePayRedirect(_)
| WalletData::PaypalRedirect(_)
| WalletData::PaypalSdk(_)
| WalletData::Paze(_)
| WalletData::SamsungPay(_)
| WalletData::TwintRedirect {}
| WalletData::VippsRedirect {}
| WalletData::TouchNGoRedirect(_)
| WalletData::WeChatPayRedirect(_)
| WalletData::CashappQr(_)
| WalletData::SwishQr(_)
| WalletData::WeChatPayQr(_)
| WalletData::Mifinity(_)
| WalletData::RevolutPay(_) => Err(errors::ConnectorError::NotImplemented(
utils::get_unimplemented_payment_method_error_message("worldpay"),
)
.into()),
},
PaymentMethodData::PayLater(_)
| PaymentMethodData::BankRedirect(_)
| PaymentMethodData::BankDebit(_)
| PaymentMethodData::BankTransfer(_)
| PaymentMethodData::Crypto(_)
| PaymentMethodData::Reward
| PaymentMethodData::RealTimePayment(_)
| PaymentMethodData::MobilePayment(_)
| PaymentMethodData::Upi(_)
| PaymentMethodData::Voucher(_)
| PaymentMethodData::CardRedirect(_)
| PaymentMethodData::GiftCard(_)
| PaymentMethodData::OpenBanking(_)
| PaymentMethodData::CardToken(_)
| PaymentMethodData::NetworkToken(_) => Err(errors::ConnectorError::NotImplemented(
utils::get_unimplemented_payment_method_error_message("worldpay"),
)
.into()),
}
}
impl TryFrom<(enums::PaymentMethod, Option<enums::PaymentMethodType>)> for PaymentMethod {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
src: (enums::PaymentMethod, Option<enums::PaymentMethodType>),
) -> Result<Self, Self::Error> {
match (src.0, src.1) {
(enums::PaymentMethod::Card, _) => Ok(Self::Card),
(enums::PaymentMethod::Wallet, pmt) => {
let pm = pmt.ok_or(errors::ConnectorError::MissingRequiredField {
field_name: "payment_method_type",
})?;
match pm {
enums::PaymentMethodType::ApplePay => Ok(Self::ApplePay),
enums::PaymentMethodType::GooglePay => Ok(Self::GooglePay),
_ => Err(errors::ConnectorError::NotImplemented(
utils::get_unimplemented_payment_method_error_message("worldpay"),
)
.into()),
}
}
_ => Err(errors::ConnectorError::NotImplemented(
utils::get_unimplemented_payment_method_error_message("worldpay"),
)
.into()),
}
}
}
// Trait to abstract common functionality between Authorize and SetupMandate
trait WorldpayPaymentsRequestData {
fn get_return_url(&self) -> Result<String, error_stack::Report<errors::ConnectorError>>;
fn get_auth_type(&self) -> &enums::AuthenticationType;
fn get_browser_info(&self) -> Option<&BrowserInformation>;
fn get_payment_method_data(&self) -> &PaymentMethodData;
fn get_setup_future_usage(&self) -> Option<enums::FutureUsage>;
fn get_off_session(&self) -> Option<bool>;
fn get_mandate_id(&self) -> Option<MandateIds>;
fn get_currency(&self) -> enums::Currency;
fn get_optional_billing_address(&self) -> Option<&address::Address>;
fn get_connector_meta_data(&self) -> Option<&pii::SecretSerdeValue>;
fn get_payment_method(&self) -> enums::PaymentMethod;
fn get_payment_method_type(&self) -> Option<enums::PaymentMethodType>;
fn get_connector_request_reference_id(&self) -> String;
fn get_is_mandate_payment(&self) -> bool;
fn get_settlement_info(&self, _amount: i64) -> Option<AutoSettlement> {
None
}
}
impl WorldpayPaymentsRequestData
for RouterData<SetupMandate, SetupMandateRequestData, PaymentsResponseData>
{
fn get_return_url(&self) -> Result<String, error_stack::Report<errors::ConnectorError>> {
self.request.get_complete_authorize_url()
}
fn get_auth_type(&self) -> &enums::AuthenticationType {
&self.auth_type
}
fn get_browser_info(&self) -> Option<&BrowserInformation> {
self.request.browser_info.as_ref()
}
fn get_payment_method_data(&self) -> &PaymentMethodData {
&self.request.payment_method_data
}
fn get_setup_future_usage(&self) -> Option<enums::FutureUsage> {
self.request.setup_future_usage
}
fn get_off_session(&self) -> Option<bool> {
self.request.off_session
}
fn get_mandate_id(&self) -> Option<MandateIds> {
self.request.mandate_id.clone()
}
fn get_currency(&self) -> enums::Currency {
self.request.currency
}
fn get_optional_billing_address(&self) -> Option<&address::Address> {
self.get_optional_billing()
}
fn get_connector_meta_data(&self) -> Option<&pii::SecretSerdeValue> {
self.connector_meta_data.as_ref()
}
fn get_payment_method(&self) -> enums::PaymentMethod {
self.payment_method
}
fn get_payment_method_type(&self) -> Option<enums::PaymentMethodType> {
self.request.payment_method_type
}
fn get_connector_request_reference_id(&self) -> String {
self.connector_request_reference_id.clone()
}
fn get_is_mandate_payment(&self) -> bool {
true
}
}
impl WorldpayPaymentsRequestData
for RouterData<Authorize, PaymentsAuthorizeData, PaymentsResponseData>
{
fn get_return_url(&self) -> Result<String, error_stack::Report<errors::ConnectorError>> {
self.request.get_complete_authorize_url()
}
fn get_auth_type(&self) -> &enums::AuthenticationType {
&self.auth_type
}
fn get_browser_info(&self) -> Option<&BrowserInformation> {
self.request.browser_info.as_ref()
}
fn get_payment_method_data(&self) -> &PaymentMethodData {
&self.request.payment_method_data
}
fn get_setup_future_usage(&self) -> Option<enums::FutureUsage> {
self.request.setup_future_usage
}
fn get_off_session(&self) -> Option<bool> {
self.request.off_session
}
fn get_mandate_id(&self) -> Option<MandateIds> {
self.request.mandate_id.clone()
}
fn get_currency(&self) -> enums::Currency {
self.request.currency
}
fn get_optional_billing_address(&self) -> Option<&address::Address> {
self.get_optional_billing()
}
fn get_connector_meta_data(&self) -> Option<&pii::SecretSerdeValue> {
self.connector_meta_data.as_ref()
}
fn get_payment_method(&self) -> enums::PaymentMethod {
self.payment_method
}
fn get_payment_method_type(&self) -> Option<enums::PaymentMethodType> {
self.request.payment_method_type
}
fn get_connector_request_reference_id(&self) -> String {
self.connector_request_reference_id.clone()
}
fn get_is_mandate_payment(&self) -> bool {
self.request.is_mandate_payment()
}
fn get_settlement_info(&self, amount: i64) -> Option<AutoSettlement> {
match (self.request.capture_method.unwrap_or_default(), amount) {
(_, 0) => None,
(enums::CaptureMethod::Automatic, _)
| (enums::CaptureMethod::SequentialAutomatic, _) => Some(AutoSettlement { auto: true }),
(enums::CaptureMethod::Manual, _) | (enums::CaptureMethod::ManualMultiple, _) => {
Some(AutoSettlement { auto: false })
}
_ => None,
}
}
}
// Dangling helper function to create ThreeDS request
fn create_three_ds_request<T: WorldpayPaymentsRequestData>(
router_data: &T,
is_mandate_payment: bool,
) -> Result<Option<ThreeDSRequest>, error_stack::Report<errors::ConnectorError>> {
match (
router_data.get_auth_type(),
router_data.get_payment_method_data(),
) {
// 3DS for NTI flow
(_, PaymentMethodData::CardDetailsForNetworkTransactionId(_)) => Ok(None),
// 3DS for regular payments
(enums::AuthenticationType::ThreeDs, _) => {
let browser_info = router_data.get_browser_info().ok_or(
errors::ConnectorError::MissingRequiredField {
field_name: "browser_info",
},
)?;
let accept_header = browser_info
.accept_header
.clone()
.get_required_value("accept_header")
.change_context(errors::ConnectorError::MissingRequiredField {
field_name: "accept_header",
})?;
let user_agent_header = browser_info
.user_agent
.clone()
.get_required_value("user_agent")
.change_context(errors::ConnectorError::MissingRequiredField {
field_name: "user_agent",
})?;
Ok(Some(ThreeDSRequest {
three_ds_type: THREE_DS_TYPE.to_string(),
mode: THREE_DS_MODE.to_string(),
device_data: ThreeDSRequestDeviceData {
accept_header,
user_agent_header,
browser_language: browser_info.language.clone(),
browser_screen_width: browser_info.screen_width,
browser_screen_height: browser_info.screen_height,
browser_color_depth: browser_info.color_depth.map(|depth| depth.to_string()),
time_zone: browser_info.time_zone.map(|tz| tz.to_string()),
browser_java_enabled: browser_info.java_enabled,
browser_javascript_enabled: browser_info.java_script_enabled,
channel: Some(ThreeDSRequestChannel::Browser),
},
challenge: ThreeDSRequestChallenge {
return_url: router_data.get_return_url()?,
preference: if is_mandate_payment {
Some(ThreeDsPreference::ChallengeMandated)
} else {
None
},
},
}))
}
// Non 3DS
_ => Ok(None),
}
}
// Dangling helper function to determine token and agreement settings
fn get_token_and_agreement(
payment_method_data: &PaymentMethodData,
setup_future_usage: Option<enums::FutureUsage>,
off_session: Option<bool>,
mandate_ids: Option<MandateIds>,
) -> (Option<TokenCreation>, Option<CustomerAgreement>) {
match (payment_method_data, setup_future_usage, off_session) {
// CIT
(PaymentMethodData::Card(_), Some(enums::FutureUsage::OffSession), _) => (
Some(TokenCreation {
token_type: TokenCreationType::Worldpay,
}),
Some(CustomerAgreement {
agreement_type: CustomerAgreementType::Subscription,
stored_card_usage: Some(StoredCardUsageType::First),
scheme_reference: None,
}),
),
// MIT
(PaymentMethodData::Card(_), _, Some(true)) => (
None,
Some(CustomerAgreement {
agreement_type: CustomerAgreementType::Subscription,
stored_card_usage: Some(StoredCardUsageType::Subsequent),
scheme_reference: None,
}),
),
// NTI with raw card data
(PaymentMethodData::CardDetailsForNetworkTransactionId(_), _, _) => (
None,
mandate_ids.and_then(|mandate_ids| {
mandate_ids
.mandate_reference_id
.and_then(|mandate_id| match mandate_id {
MandateReferenceId::NetworkMandateId(network_transaction_id) => {
Some(CustomerAgreement {
agreement_type: CustomerAgreementType::Unscheduled,
scheme_reference: Some(network_transaction_id.into()),
stored_card_usage: None,
})
}
_ => None,
})
}),
),
_ => (None, None),
}
}
// Implementation for WorldpayPaymentsRequest using abstracted request
impl<T: WorldpayPaymentsRequestData> TryFrom<(&WorldpayRouterData<&T>, &Secret<String>)>
for WorldpayPaymentsRequest
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(req: (&WorldpayRouterData<&T>, &Secret<String>)) -> Result<Self, Self::Error> {
let (item, entity_id) = req;
let worldpay_connector_metadata_object: WorldpayConnectorMetadataObject =
WorldpayConnectorMetadataObject::try_from(item.router_data.get_connector_meta_data())?;
let merchant_name = worldpay_connector_metadata_object.merchant_name.ok_or(
errors::ConnectorError::InvalidConnectorConfig {
config: "metadata.merchant_name",
},
)?;
let is_mandate_payment = item.router_data.get_is_mandate_payment();
let three_ds = create_three_ds_request(item.router_data, is_mandate_payment)?;
let (token_creation, customer_agreement) = get_token_and_agreement(
item.router_data.get_payment_method_data(),
item.router_data.get_setup_future_usage(),
item.router_data.get_off_session(),
item.router_data.get_mandate_id(),
);
Ok(Self {
instruction: Instruction {
settlement: item.router_data.get_settlement_info(item.amount),
method: PaymentMethod::try_from((
item.router_data.get_payment_method(),
item.router_data.get_payment_method_type(),
))?,
payment_instrument: fetch_payment_instrument(
item.router_data.get_payment_method_data().clone(),
item.router_data.get_optional_billing_address(),
item.router_data.get_mandate_id(),
)?,
narrative: InstructionNarrative {
line1: merchant_name.expose(),
},
value: PaymentValue {
amount: item.amount,
currency: item.router_data.get_currency(),
},
debt_repayment: None,
three_ds,
token_creation,
customer_agreement,
},
merchant: Merchant {
entity: entity_id.clone(),
..Default::default()
},
transaction_reference: item.router_data.get_connector_request_reference_id(),
customer: None,
})
}
}
pub struct WorldpayAuthType {
pub(super) api_key: Secret<String>,
pub(super) entity_id: Secret<String>,
}
impl TryFrom<&ConnectorAuthType> for WorldpayAuthType {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(auth_type: &ConnectorAuthType) -> Result<Self, Self::Error> {
match auth_type {
// TODO: Remove this later, kept purely for backwards compatibility
ConnectorAuthType::BodyKey { api_key, key1 } => {
let auth_key = format!("{}:{}", key1.peek(), api_key.peek());
let auth_header = format!("Basic {}", BASE64_ENGINE.encode(auth_key));
Ok(Self {
api_key: Secret::new(auth_header),
entity_id: Secret::new("default".to_string()),
})
}
ConnectorAuthType::SignatureKey {
api_key,
key1,
api_secret,
} => {
let auth_key = format!("{}:{}", key1.peek(), api_key.peek());
let auth_header = format!("Basic {}", BASE64_ENGINE.encode(auth_key));
Ok(Self {
api_key: Secret::new(auth_header),
entity_id: api_secret.clone(),
})
}
_ => Err(errors::ConnectorError::FailedToObtainAuthType)?,
}
}
}
impl From<PaymentOutcome> for enums::AttemptStatus {
fn from(item: PaymentOutcome) -> Self {
match item {
PaymentOutcome::Authorized => Self::Authorized,
PaymentOutcome::SentForSettlement => Self::Charged,
PaymentOutcome::ThreeDsDeviceDataRequired => Self::DeviceDataCollectionPending,
PaymentOutcome::ThreeDsAuthenticationFailed => Self::AuthenticationFailed,
PaymentOutcome::ThreeDsChallenged => Self::AuthenticationPending,
PaymentOutcome::SentForCancellation => Self::VoidInitiated,
PaymentOutcome::SentForPartialRefund | PaymentOutcome::SentForRefund => {
Self::AutoRefunded
}
PaymentOutcome::Refused | PaymentOutcome::FraudHighRisk => Self::Failure,
PaymentOutcome::ThreeDsUnavailable => Self::AuthenticationFailed,
}
}
}
impl From<PaymentOutcome> for enums::RefundStatus {
fn from(item: PaymentOutcome) -> Self {
match item {
PaymentOutcome::SentForPartialRefund | PaymentOutcome::SentForRefund => Self::Success,
PaymentOutcome::Refused
| PaymentOutcome::FraudHighRisk
| PaymentOutcome::Authorized
| PaymentOutcome::SentForSettlement
| PaymentOutcome::ThreeDsDeviceDataRequired
| PaymentOutcome::ThreeDsAuthenticationFailed
| PaymentOutcome::ThreeDsChallenged
| PaymentOutcome::SentForCancellation
| PaymentOutcome::ThreeDsUnavailable => Self::Failure,
}
}
}
impl From<&EventType> for enums::AttemptStatus {
fn from(value: &EventType) -> Self {
match value {
EventType::SentForAuthorization => Self::Authorizing,
EventType::SentForSettlement => Self::Charged,
EventType::Settled => Self::Charged,
EventType::Authorized => Self::Authorized,
EventType::Refused
| EventType::SettlementFailed
| EventType::Expired
| EventType::Cancelled
| EventType::Error => Self::Failure,
EventType::SentForRefund
| EventType::RefundFailed
| EventType::Refunded
| EventType::Unknown => Self::Pending,
}
}
}
impl From<EventType> for enums::RefundStatus {
fn from(value: EventType) -> Self {
match value {
EventType::Refunded | EventType::SentForRefund => Self::Success,
EventType::RefundFailed => Self::Failure,
EventType::Authorized
| EventType::Cancelled
| EventType::Settled
| EventType::Refused
| EventType::Error
| EventType::SentForSettlement
| EventType::SentForAuthorization
| EventType::SettlementFailed
| EventType::Expired
| EventType::Unknown => Self::Pending,
}
}
}
impl<F, T>
ForeignTryFrom<(
ResponseRouterData<F, WorldpayPaymentsResponse, T, PaymentsResponseData>,
Option<String>,
i64,
)> for RouterData<F, T, PaymentsResponseData>
{
type Error = error_stack::Report<errors::ConnectorError>;
fn foreign_try_from(
item: (
ResponseRouterData<F, WorldpayPaymentsResponse, T, PaymentsResponseData>,
Option<String>,
i64,
),
) -> Result<Self, Self::Error> {
let (router_data, optional_correlation_id, amount) = item;
let (description, redirection_data, mandate_reference, network_txn_id, error) = router_data
.response
.other_fields
.as_ref()
.map(|other_fields| match other_fields {
WorldpayPaymentResponseFields::AuthorizedResponse(res) => (
res.description.clone(),
None,
res.token.as_ref().map(|mandate_token| MandateReference {
connector_mandate_id: Some(mandate_token.href.clone().expose()),
payment_method_id: Some(mandate_token.token_id.clone()),
mandate_metadata: None,
connector_mandate_request_reference_id: None,
}),
res.scheme_reference.clone(),
None,
),
WorldpayPaymentResponseFields::DDCResponse(res) => (
None,
Some(RedirectForm::WorldpayDDCForm {
endpoint: res.device_data_collection.url.clone(),
method: common_utils::request::Method::Post,
collection_id: Some("SessionId".to_string()),
form_fields: HashMap::from([
(
"Bin".to_string(),
res.device_data_collection.bin.clone().expose(),
),
(
"JWT".to_string(),
res.device_data_collection.jwt.clone().expose(),
),
]),
}),
None,
None,
None,
),
WorldpayPaymentResponseFields::ThreeDsChallenged(res) => (
None,
Some(RedirectForm::Form {
endpoint: res.challenge.url.to_string(),
method: common_utils::request::Method::Post,
form_fields: HashMap::from([(
"JWT".to_string(),
res.challenge.jwt.clone().expose(),
)]),
}),
None,
None,
None,
),
WorldpayPaymentResponseFields::RefusedResponse(res) => (
None,
None,
None,
None,
Some((
res.refusal_code.clone(),
res.refusal_description.clone(),
res.advice
.as_ref()
.and_then(|advice_code| advice_code.code.clone()),
)),
),
WorldpayPaymentResponseFields::FraudHighRisk(_) => (None, None, None, None, None),
})
.unwrap_or((None, None, None, None, None));
let worldpay_status = router_data.response.outcome.clone();
let optional_error_message = match worldpay_status {
PaymentOutcome::ThreeDsAuthenticationFailed => {
Some("3DS authentication failed from issuer".to_string())
}
PaymentOutcome::ThreeDsUnavailable => {
Some("3DS authentication unavailable from issuer".to_string())
}
PaymentOutcome::FraudHighRisk => Some("Transaction marked as high risk".to_string()),
_ => None,
};
let status = if amount == 0 && worldpay_status == PaymentOutcome::Authorized {
enums::AttemptStatus::Charged
} else {
enums::AttemptStatus::from(worldpay_status.clone())
};
let response = match (optional_error_message, error) {
(None, None) => Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::foreign_try_from((
router_data.response,
optional_correlation_id.clone(),
))?,
redirection_data: Box::new(redirection_data),
mandate_reference: Box::new(mandate_reference),
connector_metadata: None,
network_txn_id: network_txn_id.map(|id| id.expose()),
connector_response_reference_id: optional_correlation_id.clone(),
incremental_authorization_allowed: None,
charges: None,
}),
(Some(reason), _) => Err(ErrorResponse {
code: worldpay_status.to_string(),
message: reason.clone(),
reason: Some(reason),
status_code: router_data.http_code,
attempt_status: Some(status),
connector_transaction_id: optional_correlation_id,
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
connector_metadata: None,
}),
(_, Some((code, message, advice_code))) => Err(ErrorResponse {
code: code.clone(),
message: message.clone(),
reason: Some(message.clone()),
status_code: router_data.http_code,
attempt_status: Some(status),
connector_transaction_id: optional_correlation_id,
network_advice_code: advice_code,
// Access Worldpay returns a raw response code in the refusalCode field (if enabled) containing the unmodified response code received either directly from the card scheme for Worldpay-acquired transactions, or from third party acquirers.
// You can use raw response codes to inform your retry logic. A rawCode is only returned if specifically requested.
network_decline_code: Some(code),
network_error_message: Some(message),
connector_metadata: None,
}),
};
Ok(Self {
status,
description,
response,
..router_data.data
})
}
}
impl TryFrom<(&types::PaymentsCaptureRouterData, MinorUnit)> for WorldpayPartialRequest {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(req: (&types::PaymentsCaptureRouterData, MinorUnit)) -> Result<Self, Self::Error> {
let (item, amount) = req;
Ok(Self {
reference: item.payment_id.clone().replace("_", "-"),
value: PaymentValue {
amount: amount.get_amount_as_i64(),
currency: item.request.currency,
},
})
}
}
impl<F> TryFrom<(&types::RefundsRouterData<F>, MinorUnit)> for WorldpayPartialRequest {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(req: (&types::RefundsRouterData<F>, MinorUnit)) -> Result<Self, Self::Error> {
let (item, amount) = req;
Ok(Self {
reference: item.request.refund_id.clone().replace("_", "-"),
value: PaymentValue {
amount: amount.get_amount_as_i64(),
currency: item.request.currency,
},
})
}
}
impl TryFrom<WorldpayWebhookEventType> for WorldpayEventResponse {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(event: WorldpayWebhookEventType) -> Result<Self, Self::Error> {
Ok(Self {
last_event: event.event_details.event_type,
links: None,
})
}
}
impl ForeignTryFrom<(WorldpayPaymentsResponse, Option<String>)> for ResponseIdStr {
type Error = error_stack::Report<errors::ConnectorError>;
fn foreign_try_from(
item: (WorldpayPaymentsResponse, Option<String>),
) -> Result<Self, Self::Error> {
get_resource_id(item.0, item.1, |id| Self { id })
}
}
impl ForeignTryFrom<(WorldpayPaymentsResponse, Option<String>)> for ResponseId {
type Error = error_stack::Report<errors::ConnectorError>;
fn foreign_try_from(
item: (WorldpayPaymentsResponse, Option<String>),
) -> Result<Self, Self::Error> {
get_resource_id(item.0, item.1, Self::ConnectorTransactionId)
}
}
impl TryFrom<&types::PaymentsCompleteAuthorizeRouterData> for WorldpayCompleteAuthorizationRequest {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(item: &types::PaymentsCompleteAuthorizeRouterData) -> Result<Self, Self::Error> {
let params = item
.request
.redirect_response
.as_ref()
.and_then(|redirect_response| redirect_response.params.as_ref())
.ok_or(errors::ConnectorError::ResponseDeserializationFailed)?;
let parsed_request = serde_urlencoded::from_str::<Self>(params.peek())
.change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
match item.status {
enums::AttemptStatus::DeviceDataCollectionPending => Ok(parsed_request),
enums::AttemptStatus::AuthenticationPending => {
if parsed_request.collection_reference.is_some() {
return Err(errors::ConnectorError::InvalidDataFormat {
field_name:
"collection_reference not allowed in AuthenticationPending state",
}
.into());
}
Ok(parsed_request)
}
_ => Err(
errors::ConnectorError::RequestEncodingFailedWithReason(format!(
"Invalid payment status for complete authorize: {:?}",
item.status
))
.into(),
),
}
}
}
|
{
"crate": "hyperswitch_connectors",
"file": "crates/hyperswitch_connectors/src/connectors/worldpay/transformers.rs",
"file_size": null,
"is_async": null,
"is_pub": null,
"num_enums": 0,
"num_structs": 2,
"num_tables": null,
"score": null,
"total_crates": null
}
|
file_hyperswitch_connectors_5207829551144912454
|
clm
|
file
|
// Repository: hyperswitch
// Crate: hyperswitch_connectors
// File: crates/hyperswitch_connectors/src/connectors/worldpay/payout_transformers.rs
// Contains: 2 structs, 0 enums
use base64::Engine;
use common_enums::enums;
use common_utils::{consts::BASE64_ENGINE, pii, types::MinorUnit};
use error_stack::ResultExt;
use hyperswitch_domain_models::{
router_data::ConnectorAuthType, router_flow_types::payouts::PoFulfill,
router_response_types::PayoutsResponseData, types,
};
use hyperswitch_interfaces::{api, errors};
use masking::{PeekInterface, Secret};
use serde::{Deserialize, Serialize};
use super::{payout_requests::*, payout_response::*};
use crate::{
types::PayoutsResponseRouterData,
utils::{self, CardData, RouterData as RouterDataTrait},
};
#[derive(Debug, Serialize)]
pub struct WorldpayPayoutRouterData<T> {
amount: i64,
router_data: T,
}
impl<T> TryFrom<(&api::CurrencyUnit, enums::Currency, MinorUnit, T)>
for WorldpayPayoutRouterData<T>
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
(_currency_unit, _currency, minor_amount, item): (
&api::CurrencyUnit,
enums::Currency,
MinorUnit,
T,
),
) -> Result<Self, Self::Error> {
Ok(Self {
amount: minor_amount.get_amount_as_i64(),
router_data: item,
})
}
}
pub struct WorldpayPayoutAuthType {
pub(super) api_key: Secret<String>,
pub(super) entity_id: Secret<String>,
}
impl TryFrom<&ConnectorAuthType> for WorldpayPayoutAuthType {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(auth_type: &ConnectorAuthType) -> Result<Self, Self::Error> {
match auth_type {
ConnectorAuthType::SignatureKey {
api_key,
key1,
api_secret,
} => {
let auth_key = format!("{}:{}", key1.peek(), api_key.peek());
let auth_header = format!("Basic {}", BASE64_ENGINE.encode(auth_key));
Ok(Self {
api_key: Secret::new(auth_header),
entity_id: api_secret.clone(),
})
}
_ => Err(errors::ConnectorError::FailedToObtainAuthType)?,
}
}
}
#[derive(Debug, Default, Serialize, Deserialize)]
pub struct WorldpayPayoutConnectorMetadataObject {
pub merchant_name: Option<Secret<String>>,
}
impl TryFrom<Option<&pii::SecretSerdeValue>> for WorldpayPayoutConnectorMetadataObject {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(meta_data: Option<&pii::SecretSerdeValue>) -> Result<Self, Self::Error> {
let metadata: Self = utils::to_connector_meta_from_secret::<Self>(meta_data.cloned())
.change_context(errors::ConnectorError::InvalidConnectorConfig {
config: "metadata",
})?;
Ok(metadata)
}
}
impl<F>
TryFrom<(
&WorldpayPayoutRouterData<&types::PayoutsRouterData<F>>,
&Secret<String>,
)> for WorldpayPayoutRequest
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
req: (
&WorldpayPayoutRouterData<&types::PayoutsRouterData<F>>,
&Secret<String>,
),
) -> Result<Self, Self::Error> {
let (item, entity_id) = req;
let worldpay_connector_metadata_object: WorldpayPayoutConnectorMetadataObject =
WorldpayPayoutConnectorMetadataObject::try_from(
item.router_data.connector_meta_data.as_ref(),
)?;
let merchant_name = worldpay_connector_metadata_object.merchant_name.ok_or(
errors::ConnectorError::InvalidConnectorConfig {
config: "metadata.merchant_name",
},
)?;
Ok(Self {
transaction_reference: item.router_data.connector_request_reference_id.clone(),
merchant: Merchant {
entity: entity_id.clone(),
},
instruction: PayoutInstruction {
value: PayoutValue {
amount: item.amount,
currency: item.router_data.request.destination_currency,
},
narrative: InstructionNarrative {
line1: merchant_name,
},
payout_instrument: PayoutInstrument::try_from(
item.router_data.get_payout_method_data()?,
)?,
},
})
}
}
impl TryFrom<api_models::payouts::PayoutMethodData> for PayoutInstrument {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
payout_method_data: api_models::payouts::PayoutMethodData,
) -> Result<Self, Self::Error> {
match payout_method_data {
api_models::payouts::PayoutMethodData::Wallet(
api_models::payouts::Wallet::ApplePayDecrypt(apple_pay_decrypted_data),
) => Ok(Self::ApplePayDecrypt(ApplePayDecrypt {
payout_type: PayoutType::ApplePayDecrypt,
dpan: apple_pay_decrypted_data.dpan.clone(),
card_holder_name: apple_pay_decrypted_data.card_holder_name.clone(),
card_expiry_date: PayoutExpiryDate {
month: apple_pay_decrypted_data.get_expiry_month_as_i8()?,
year: apple_pay_decrypted_data.get_expiry_year_as_4_digit_i32()?,
},
})),
api_models::payouts::PayoutMethodData::Card(_)
| api_models::payouts::PayoutMethodData::Bank(_)
| api_models::payouts::PayoutMethodData::Wallet(_)
| api_models::payouts::PayoutMethodData::BankRedirect(_) => {
Err(errors::ConnectorError::NotImplemented(
"Selected Payout Method is not implemented for Worldpay".to_string(),
)
.into())
}
}
}
}
impl From<PayoutOutcome> for enums::PayoutStatus {
fn from(item: PayoutOutcome) -> Self {
match item {
PayoutOutcome::RequestReceived => Self::Initiated,
PayoutOutcome::Error | PayoutOutcome::Refused => Self::Failed,
PayoutOutcome::QueryRequired => Self::Pending,
}
}
}
impl TryFrom<PayoutsResponseRouterData<PoFulfill, WorldpayPayoutResponse>>
for types::PayoutsRouterData<PoFulfill>
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: PayoutsResponseRouterData<PoFulfill, WorldpayPayoutResponse>,
) -> Result<Self, Self::Error> {
Ok(Self {
response: Ok(PayoutsResponseData {
status: Some(enums::PayoutStatus::from(item.response.outcome.clone())),
connector_payout_id: None,
payout_eligible: None,
should_add_next_step_to_process_tracker: false,
error_code: None,
error_message: None,
payout_connector_metadata: None,
}),
..item.data
})
}
}
|
{
"crate": "hyperswitch_connectors",
"file": "crates/hyperswitch_connectors/src/connectors/worldpay/payout_transformers.rs",
"file_size": null,
"is_async": null,
"is_pub": null,
"num_enums": 0,
"num_structs": 2,
"num_tables": null,
"score": null,
"total_crates": null
}
|
file_hyperswitch_connectors_1817370547818206615
|
clm
|
file
|
// Repository: hyperswitch
// Crate: hyperswitch_connectors
// File: crates/hyperswitch_connectors/src/connectors/worldpay/payout_response.rs
// Contains: 1 structs, 1 enums
use serde::{Deserialize, Serialize};
#[derive(Clone, Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct WorldpayPayoutResponse {
pub outcome: PayoutOutcome,
}
#[derive(Clone, Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub enum PayoutOutcome {
RequestReceived,
Refused,
Error,
QueryRequired,
}
|
{
"crate": "hyperswitch_connectors",
"file": "crates/hyperswitch_connectors/src/connectors/worldpay/payout_response.rs",
"file_size": null,
"is_async": null,
"is_pub": null,
"num_enums": 1,
"num_structs": 1,
"num_tables": null,
"score": null,
"total_crates": null
}
|
file_hyperswitch_connectors_1979245948426707336
|
clm
|
file
|
// Repository: hyperswitch
// Crate: hyperswitch_connectors
// File: crates/hyperswitch_connectors/src/connectors/worldpay/requests.rs
// Contains: 24 structs, 11 enums
use masking::Secret;
use serde::{Deserialize, Serialize};
#[derive(Clone, Debug, PartialEq, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct WorldpayPaymentsRequest {
pub transaction_reference: String,
pub merchant: Merchant,
pub instruction: Instruction,
#[serde(skip_serializing_if = "Option::is_none")]
pub customer: Option<Customer>,
}
#[derive(Clone, Debug, PartialEq, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Merchant {
pub entity: Secret<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub mcc: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub payment_facilitator: Option<PaymentFacilitator>,
}
#[derive(Clone, Debug, PartialEq, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct Instruction {
#[serde(skip_serializing_if = "Option::is_none")]
pub settlement: Option<AutoSettlement>,
pub method: PaymentMethod,
pub payment_instrument: PaymentInstrument,
pub narrative: InstructionNarrative,
pub value: PaymentValue,
#[serde(skip_serializing_if = "Option::is_none")]
pub debt_repayment: Option<bool>,
#[serde(rename = "threeDS", skip_serializing_if = "Option::is_none")]
pub three_ds: Option<ThreeDSRequest>,
/// For setting up mandates
pub token_creation: Option<TokenCreation>,
/// For specifying CIT vs MIT
pub customer_agreement: Option<CustomerAgreement>,
}
#[derive(Clone, Debug, PartialEq, Serialize)]
pub struct TokenCreation {
#[serde(rename = "type")]
pub token_type: TokenCreationType,
}
#[derive(Clone, Debug, PartialEq, Serialize)]
#[serde(rename_all = "lowercase")]
pub enum TokenCreationType {
Worldpay,
}
#[serde_with::skip_serializing_none]
#[derive(Clone, Debug, PartialEq, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct CustomerAgreement {
#[serde(rename = "type")]
pub agreement_type: CustomerAgreementType,
pub stored_card_usage: Option<StoredCardUsageType>,
#[serde(skip_serializing_if = "Option::is_none")]
pub scheme_reference: Option<Secret<String>>,
}
#[derive(Clone, Debug, PartialEq, Serialize)]
#[serde(rename_all = "lowercase")]
pub enum CustomerAgreementType {
Subscription,
Unscheduled,
}
#[derive(Clone, Debug, PartialEq, Serialize)]
#[serde(rename_all = "lowercase")]
pub enum StoredCardUsageType {
First,
Subsequent,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
#[serde(untagged)]
pub enum PaymentInstrument {
Card(CardPayment),
CardToken(CardToken),
RawCardForNTI(RawCardDetails),
Googlepay(WalletPayment),
Applepay(WalletPayment),
}
#[derive(Clone, Debug, PartialEq, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct CardPayment {
#[serde(flatten)]
pub raw_card_details: RawCardDetails,
pub cvc: Secret<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub card_holder_name: Option<Secret<String>>,
#[serde(skip_serializing_if = "Option::is_none")]
pub billing_address: Option<BillingAddress>,
}
#[derive(Clone, Debug, PartialEq, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct RawCardDetails {
#[serde(rename = "type")]
pub payment_type: PaymentType,
pub card_number: cards::CardNumber,
pub expiry_date: ExpiryDate,
}
#[derive(Clone, Debug, PartialEq, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct CardToken {
#[serde(rename = "type")]
pub payment_type: PaymentType,
pub href: String,
#[serde(skip_serializing_if = "Option::is_none")]
pub cvc: Option<Secret<String>>,
}
#[derive(Clone, Debug, PartialEq, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct WalletPayment {
#[serde(rename = "type")]
pub payment_type: PaymentType,
pub wallet_token: Secret<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub billing_address: Option<BillingAddress>,
}
#[derive(
Clone, Copy, Debug, Eq, Default, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize,
)]
#[serde(rename_all = "lowercase")]
pub enum PaymentType {
#[default]
Plain,
Token,
Encrypted,
Checkout,
}
#[derive(Clone, Debug, PartialEq, Default, Serialize, Deserialize)]
pub struct ExpiryDate {
pub month: Secret<i8>,
pub year: Secret<i32>,
}
#[derive(Clone, Debug, PartialEq, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct BillingAddress {
pub address1: Secret<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub address2: Option<Secret<String>>,
#[serde(skip_serializing_if = "Option::is_none")]
pub address3: Option<Secret<String>>,
pub city: String,
#[serde(skip_serializing_if = "Option::is_none")]
pub state: Option<Secret<String>>,
pub postal_code: Secret<String>,
pub country_code: common_enums::CountryAlpha2,
}
#[derive(Clone, Debug, PartialEq, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Customer {
#[serde(skip_serializing_if = "Option::is_none")]
pub risk_profile: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub authentication: Option<CustomerAuthentication>,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub enum CustomerAuthentication {
ThreeDS(ThreeDS),
Token(NetworkToken),
}
#[derive(Clone, Debug, PartialEq, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ThreeDS {
#[serde(skip_serializing_if = "Option::is_none")]
pub authentication_value: Option<Secret<String>>,
pub version: ThreeDSVersion,
#[serde(skip_serializing_if = "Option::is_none")]
pub transaction_id: Option<String>,
pub eci: String,
#[serde(rename = "type")]
pub auth_type: CustomerAuthType,
}
#[derive(
Clone, Copy, Default, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize,
)]
pub enum ThreeDSVersion {
#[default]
#[serde(rename = "1")]
One,
#[serde(rename = "2")]
Two,
}
#[derive(
Clone, Copy, Default, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize,
)]
pub enum CustomerAuthType {
#[serde(rename = "3DS")]
#[default]
Variant3Ds,
#[serde(rename = "card/networkToken")]
NetworkToken,
}
#[derive(Clone, Debug, PartialEq, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct NetworkToken {
#[serde(rename = "type")]
pub auth_type: CustomerAuthType,
pub authentication_value: Secret<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub eci: Option<String>,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct AutoSettlement {
pub auto: bool,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ThreeDSRequest {
#[serde(rename = "type")]
pub three_ds_type: String,
pub mode: String,
pub device_data: ThreeDSRequestDeviceData,
pub challenge: ThreeDSRequestChallenge,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ThreeDSRequestDeviceData {
pub accept_header: String,
pub user_agent_header: String,
pub browser_language: Option<String>,
pub browser_screen_width: Option<u32>,
pub browser_screen_height: Option<u32>,
pub browser_color_depth: Option<String>,
pub time_zone: Option<String>,
pub browser_java_enabled: Option<bool>,
pub browser_javascript_enabled: Option<bool>,
pub channel: Option<ThreeDSRequestChannel>,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "lowercase")]
pub enum ThreeDSRequestChannel {
Browser,
Native,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ThreeDSRequestChallenge {
pub return_url: String,
#[serde(skip_serializing_if = "Option::is_none")]
pub preference: Option<ThreeDsPreference>,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub enum ThreeDsPreference {
ChallengeMandated,
}
#[derive(Clone, Debug, PartialEq, Default, Serialize, Deserialize)]
#[serde(rename_all = "lowercase")]
pub enum PaymentMethod {
#[default]
Card,
ApplePay,
GooglePay,
}
#[derive(Clone, Debug, PartialEq, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct InstructionNarrative {
pub line1: String,
}
#[derive(Clone, Debug, PartialEq, Default, Serialize, Deserialize)]
pub struct PaymentValue {
pub amount: i64,
pub currency: api_models::enums::Currency,
}
#[derive(Clone, Debug, PartialEq, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct PaymentFacilitator {
pub pf_id: Secret<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub iso_id: Option<Secret<String>>,
pub sub_merchant: SubMerchant,
}
#[derive(Clone, Debug, PartialEq, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct SubMerchant {
pub city: String,
pub name: Secret<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub state: Option<String>,
pub postal_code: Secret<String>,
pub merchant_id: Secret<String>,
pub country_code: String,
pub street: Secret<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub tax_id: Option<String>,
}
#[derive(Default, Debug, Serialize)]
pub struct WorldpayPartialRequest {
pub value: PaymentValue,
pub reference: String,
}
#[derive(Clone, Debug, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct WorldpayCompleteAuthorizationRequest {
#[serde(skip_serializing_if = "Option::is_none")]
pub collection_reference: Option<String>,
}
pub(super) const THREE_DS_MODE: &str = "always";
pub(super) const THREE_DS_TYPE: &str = "integrated";
|
{
"crate": "hyperswitch_connectors",
"file": "crates/hyperswitch_connectors/src/connectors/worldpay/requests.rs",
"file_size": null,
"is_async": null,
"is_pub": null,
"num_enums": 11,
"num_structs": 24,
"num_tables": null,
"score": null,
"total_crates": null
}
|
file_hyperswitch_connectors_6796022961757500144
|
clm
|
file
|
// Repository: hyperswitch
// Crate: hyperswitch_connectors
// File: crates/hyperswitch_connectors/src/connectors/billwerk/transformers.rs
// Contains: 9 structs, 4 enums
use common_enums::enums;
use common_utils::{
id_type,
pii::{Email, SecretSerdeValue},
types::MinorUnit,
};
use hyperswitch_domain_models::{
payment_method_data::PaymentMethodData,
router_data::{ConnectorAuthType, ErrorResponse, PaymentMethodToken, RouterData},
router_flow_types::{
payments,
refunds::{Execute, RSync},
},
router_request_types::ResponseId,
router_response_types::{PaymentsResponseData, RefundsResponseData},
types,
};
use hyperswitch_interfaces::{
consts::{NO_ERROR_CODE, NO_ERROR_MESSAGE},
errors,
};
use masking::{ExposeInterface, Secret};
use serde::{Deserialize, Serialize};
use crate::{
types::{RefundsResponseRouterData, ResponseRouterData},
utils::{self, CardData as _, PaymentsAuthorizeRequestData, RouterData as _},
};
pub struct BillwerkRouterData<T> {
pub amount: MinorUnit,
pub router_data: T,
}
impl<T> TryFrom<(MinorUnit, T)> for BillwerkRouterData<T> {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from((amount, item): (MinorUnit, T)) -> Result<Self, Self::Error> {
Ok(Self {
amount,
router_data: item,
})
}
}
pub struct BillwerkAuthType {
pub(super) api_key: Secret<String>,
pub(super) public_api_key: Secret<String>,
}
impl TryFrom<&ConnectorAuthType> for BillwerkAuthType {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(auth_type: &ConnectorAuthType) -> Result<Self, Self::Error> {
match auth_type {
ConnectorAuthType::BodyKey { api_key, key1 } => Ok(Self {
api_key: api_key.to_owned(),
public_api_key: key1.to_owned(),
}),
_ => Err(errors::ConnectorError::FailedToObtainAuthType.into()),
}
}
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
pub enum BillwerkTokenRequestIntent {
ChargeAndStore,
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
pub enum BillwerkStrongAuthRule {
UseScaIfAvailableAuth,
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct BillwerkTokenRequest {
number: cards::CardNumber,
month: Secret<String>,
year: Secret<String>,
cvv: Secret<String>,
pkey: Secret<String>,
recurring: Option<bool>,
intent: Option<BillwerkTokenRequestIntent>,
strong_authentication_rule: Option<BillwerkStrongAuthRule>,
}
impl TryFrom<&types::TokenizationRouterData> for BillwerkTokenRequest {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(item: &types::TokenizationRouterData) -> Result<Self, Self::Error> {
match item.request.payment_method_data.clone() {
PaymentMethodData::Card(ccard) => {
let connector_auth = &item.connector_auth_type;
let auth_type = BillwerkAuthType::try_from(connector_auth)?;
Ok(Self {
number: ccard.card_number.clone(),
month: ccard.card_exp_month.clone(),
year: ccard.get_card_expiry_year_2_digit()?,
cvv: ccard.card_cvc,
pkey: auth_type.public_api_key,
recurring: None,
intent: None,
strong_authentication_rule: None,
})
}
PaymentMethodData::Wallet(_)
| PaymentMethodData::CardRedirect(_)
| PaymentMethodData::PayLater(_)
| PaymentMethodData::BankRedirect(_)
| PaymentMethodData::BankDebit(_)
| PaymentMethodData::BankTransfer(_)
| PaymentMethodData::Crypto(_)
| PaymentMethodData::MandatePayment
| PaymentMethodData::Reward
| PaymentMethodData::RealTimePayment(_)
| PaymentMethodData::MobilePayment(_)
| PaymentMethodData::Upi(_)
| PaymentMethodData::Voucher(_)
| PaymentMethodData::GiftCard(_)
| PaymentMethodData::OpenBanking(_)
| PaymentMethodData::CardToken(_)
| PaymentMethodData::NetworkToken(_)
| PaymentMethodData::CardDetailsForNetworkTransactionId(_) => {
Err(errors::ConnectorError::NotImplemented(
utils::get_unimplemented_payment_method_error_message("billwerk"),
)
.into())
}
}
}
}
#[derive(Debug, Deserialize, Serialize)]
pub struct BillwerkTokenResponse {
id: Secret<String>,
recurring: Option<bool>,
}
impl<T>
TryFrom<
ResponseRouterData<
payments::PaymentMethodToken,
BillwerkTokenResponse,
T,
PaymentsResponseData,
>,
> for RouterData<payments::PaymentMethodToken, T, PaymentsResponseData>
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: ResponseRouterData<
payments::PaymentMethodToken,
BillwerkTokenResponse,
T,
PaymentsResponseData,
>,
) -> Result<Self, Self::Error> {
Ok(Self {
response: Ok(PaymentsResponseData::TokenizationResponse {
token: item.response.id.expose(),
}),
..item.data
})
}
}
#[derive(Debug, Serialize)]
pub struct BillwerkCustomerObject {
handle: Option<id_type::CustomerId>,
email: Option<Email>,
address: Option<Secret<String>>,
address2: Option<Secret<String>>,
city: Option<String>,
country: Option<common_enums::CountryAlpha2>,
first_name: Option<Secret<String>>,
last_name: Option<Secret<String>>,
}
#[derive(Debug, Serialize)]
pub struct BillwerkPaymentsRequest {
handle: String,
amount: MinorUnit,
source: Secret<String>,
currency: common_enums::Currency,
customer: BillwerkCustomerObject,
metadata: Option<SecretSerdeValue>,
settle: bool,
}
impl TryFrom<&BillwerkRouterData<&types::PaymentsAuthorizeRouterData>> for BillwerkPaymentsRequest {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: &BillwerkRouterData<&types::PaymentsAuthorizeRouterData>,
) -> Result<Self, Self::Error> {
if item.router_data.is_three_ds() {
return Err(errors::ConnectorError::NotImplemented(
"Three_ds payments through Billwerk".to_string(),
)
.into());
};
let source = match item.router_data.get_payment_method_token()? {
PaymentMethodToken::Token(pm_token) => Ok(pm_token),
_ => Err(errors::ConnectorError::MissingRequiredField {
field_name: "payment_method_token",
}),
}?;
Ok(Self {
handle: item.router_data.connector_request_reference_id.clone(),
amount: item.amount,
source,
currency: item.router_data.request.currency,
customer: BillwerkCustomerObject {
handle: item.router_data.customer_id.clone(),
email: item.router_data.request.email.clone(),
address: item.router_data.get_optional_billing_line1(),
address2: item.router_data.get_optional_billing_line2(),
city: item.router_data.get_optional_billing_city(),
country: item.router_data.get_optional_billing_country(),
first_name: item.router_data.get_optional_billing_first_name(),
last_name: item.router_data.get_optional_billing_last_name(),
},
metadata: item.router_data.request.metadata.clone().map(Into::into),
settle: item.router_data.request.is_auto_capture()?,
})
}
}
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
#[serde(rename_all = "lowercase")]
pub enum BillwerkPaymentState {
Created,
Authorized,
Pending,
Settled,
Failed,
Cancelled,
}
impl From<BillwerkPaymentState> for enums::AttemptStatus {
fn from(item: BillwerkPaymentState) -> Self {
match item {
BillwerkPaymentState::Created | BillwerkPaymentState::Pending => Self::Pending,
BillwerkPaymentState::Authorized => Self::Authorized,
BillwerkPaymentState::Settled => Self::Charged,
BillwerkPaymentState::Failed => Self::Failure,
BillwerkPaymentState::Cancelled => Self::Voided,
}
}
}
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct BillwerkPaymentsResponse {
state: BillwerkPaymentState,
handle: String,
error: Option<String>,
error_state: Option<String>,
}
impl<F, T> TryFrom<ResponseRouterData<F, BillwerkPaymentsResponse, T, PaymentsResponseData>>
for RouterData<F, T, PaymentsResponseData>
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: ResponseRouterData<F, BillwerkPaymentsResponse, T, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
let error_response = if item.response.error.is_some() || item.response.error_state.is_some()
{
Some(ErrorResponse {
code: item
.response
.error_state
.clone()
.unwrap_or(NO_ERROR_CODE.to_string()),
message: item
.response
.error_state
.unwrap_or(NO_ERROR_MESSAGE.to_string()),
reason: item.response.error,
status_code: item.http_code,
attempt_status: None,
connector_transaction_id: Some(item.response.handle.clone()),
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
connector_metadata: None,
})
} else {
None
};
let payments_response = PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(item.response.handle.clone()),
redirection_data: Box::new(None),
mandate_reference: Box::new(None),
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: Some(item.response.handle),
incremental_authorization_allowed: None,
charges: None,
};
Ok(Self {
status: enums::AttemptStatus::from(item.response.state),
response: error_response.map_or_else(|| Ok(payments_response), Err),
..item.data
})
}
}
#[derive(Debug, Serialize)]
pub struct BillwerkCaptureRequest {
amount: MinorUnit,
}
impl TryFrom<&BillwerkRouterData<&types::PaymentsCaptureRouterData>> for BillwerkCaptureRequest {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: &BillwerkRouterData<&types::PaymentsCaptureRouterData>,
) -> Result<Self, Self::Error> {
Ok(Self {
amount: item.amount,
})
}
}
// Type definition for RefundRequest
#[derive(Debug, Serialize)]
pub struct BillwerkRefundRequest {
pub invoice: String,
pub amount: MinorUnit,
pub text: Option<String>,
}
impl<F> TryFrom<&BillwerkRouterData<&types::RefundsRouterData<F>>> for BillwerkRefundRequest {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: &BillwerkRouterData<&types::RefundsRouterData<F>>,
) -> Result<Self, Self::Error> {
Ok(Self {
amount: item.amount,
invoice: item.router_data.request.connector_transaction_id.clone(),
text: item.router_data.request.reason.clone(),
})
}
}
// Type definition for Refund Response
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "lowercase")]
pub enum RefundState {
Refunded,
Failed,
Processing,
}
impl From<RefundState> for enums::RefundStatus {
fn from(item: RefundState) -> Self {
match item {
RefundState::Refunded => Self::Success,
RefundState::Failed => Self::Failure,
RefundState::Processing => Self::Pending,
}
}
}
#[derive(Debug, Serialize, Deserialize)]
pub struct RefundResponse {
id: String,
state: RefundState,
}
impl TryFrom<RefundsResponseRouterData<Execute, RefundResponse>>
for types::RefundsRouterData<Execute>
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: RefundsResponseRouterData<Execute, RefundResponse>,
) -> Result<Self, Self::Error> {
Ok(Self {
response: Ok(RefundsResponseData {
connector_refund_id: item.response.id.to_string(),
refund_status: enums::RefundStatus::from(item.response.state),
}),
..item.data
})
}
}
impl TryFrom<RefundsResponseRouterData<RSync, RefundResponse>> for types::RefundsRouterData<RSync> {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: RefundsResponseRouterData<RSync, RefundResponse>,
) -> Result<Self, Self::Error> {
Ok(Self {
response: Ok(RefundsResponseData {
connector_refund_id: item.response.id.to_string(),
refund_status: enums::RefundStatus::from(item.response.state),
}),
..item.data
})
}
}
#[derive(Debug, Serialize, Deserialize)]
pub struct BillwerkErrorResponse {
pub code: Option<i32>,
pub error: String,
pub message: Option<String>,
}
|
{
"crate": "hyperswitch_connectors",
"file": "crates/hyperswitch_connectors/src/connectors/billwerk/transformers.rs",
"file_size": null,
"is_async": null,
"is_pub": null,
"num_enums": 4,
"num_structs": 9,
"num_tables": null,
"score": null,
"total_crates": null
}
|
file_hyperswitch_connectors_7743872983201308261
|
clm
|
file
|
// Repository: hyperswitch
// Crate: hyperswitch_connectors
// File: crates/hyperswitch_connectors/src/connectors/payu/transformers.rs
// Contains: 24 structs, 7 enums
use base64::Engine;
use common_enums::enums;
use common_utils::{
consts::BASE64_ENGINE,
pii::{Email, IpAddress},
types::MinorUnit,
};
use error_stack::ResultExt;
use hyperswitch_domain_models::{
payment_method_data::{PaymentMethodData, WalletData},
router_data::{AccessToken, ConnectorAuthType, RouterData},
router_flow_types::refunds::{Execute, RSync},
router_request_types::ResponseId,
router_response_types::{PaymentsResponseData, RefundsResponseData},
types,
};
use hyperswitch_interfaces::errors;
use masking::Secret;
use serde::{Deserialize, Serialize};
use crate::{
types::{RefundsResponseRouterData, ResponseRouterData},
utils::AccessTokenRequestInfo as _,
};
const WALLET_IDENTIFIER: &str = "PBL";
#[derive(Debug, Serialize)]
pub struct PayuRouterData<T> {
pub amount: MinorUnit,
pub router_data: T,
}
impl<T> TryFrom<(MinorUnit, T)> for PayuRouterData<T> {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from((amount, item): (MinorUnit, T)) -> Result<Self, Self::Error> {
Ok(Self {
amount,
router_data: item,
})
}
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct PayuPaymentsRequest {
customer_ip: Secret<String, IpAddress>,
merchant_pos_id: Secret<String>,
total_amount: MinorUnit,
currency_code: enums::Currency,
description: String,
pay_methods: PayuPaymentMethod,
continue_url: Option<String>,
ext_order_id: Option<String>,
}
#[derive(Debug, Eq, PartialEq, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct PayuPaymentMethod {
pay_method: PayuPaymentMethodData,
}
#[derive(Debug, Eq, PartialEq, Serialize)]
#[serde(untagged)]
pub enum PayuPaymentMethodData {
Card(PayuCard),
Wallet(PayuWallet),
}
#[derive(Debug, Eq, PartialEq, Serialize)]
#[serde(rename_all = "camelCase")]
pub enum PayuCard {
#[serde(rename_all = "camelCase")]
Card {
number: cards::CardNumber,
expiration_month: Secret<String>,
expiration_year: Secret<String>,
cvv: Secret<String>,
},
}
#[derive(Debug, Eq, PartialEq, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct PayuWallet {
pub value: PayuWalletCode,
#[serde(rename = "type")]
pub wallet_type: String,
pub authorization_code: Secret<String>,
}
#[derive(Debug, Eq, PartialEq, Serialize)]
#[serde(rename_all = "lowercase")]
pub enum PayuWalletCode {
Ap,
Jp,
}
impl TryFrom<&PayuRouterData<&types::PaymentsAuthorizeRouterData>> for PayuPaymentsRequest {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: &PayuRouterData<&types::PaymentsAuthorizeRouterData>,
) -> Result<Self, Self::Error> {
let auth_type = PayuAuthType::try_from(&item.router_data.connector_auth_type)?;
let payment_method = match item.router_data.request.payment_method_data.clone() {
PaymentMethodData::Card(ccard) => Ok(PayuPaymentMethod {
pay_method: PayuPaymentMethodData::Card(PayuCard::Card {
number: ccard.card_number,
expiration_month: ccard.card_exp_month,
expiration_year: ccard.card_exp_year,
cvv: ccard.card_cvc,
}),
}),
PaymentMethodData::Wallet(wallet_data) => match wallet_data {
WalletData::GooglePay(data) => Ok(PayuPaymentMethod {
pay_method: PayuPaymentMethodData::Wallet({
PayuWallet {
value: PayuWalletCode::Ap,
wallet_type: WALLET_IDENTIFIER.to_string(),
authorization_code: Secret::new(
BASE64_ENGINE.encode(
data.tokenization_data
.get_encrypted_google_pay_token()
.change_context(
errors::ConnectorError::MissingRequiredField {
field_name: "gpay wallet_token",
},
)?,
),
),
}
}),
}),
WalletData::ApplePay(apple_pay_data) => {
let apple_pay_encrypted_data = apple_pay_data
.payment_data
.get_encrypted_apple_pay_payment_data_mandatory()
.change_context(errors::ConnectorError::MissingRequiredField {
field_name: "Apple pay encrypted data",
})?;
Ok(PayuPaymentMethod {
pay_method: PayuPaymentMethodData::Wallet({
PayuWallet {
value: PayuWalletCode::Jp,
wallet_type: WALLET_IDENTIFIER.to_string(),
authorization_code: Secret::new(
apple_pay_encrypted_data.to_string(),
),
}
}),
})
}
_ => Err(errors::ConnectorError::NotImplemented(
"Unknown Wallet in Payment Method".to_string(),
)),
},
_ => Err(errors::ConnectorError::NotImplemented(
"Unknown payment method".to_string(),
)),
}?;
let browser_info = item.router_data.request.browser_info.clone().ok_or(
errors::ConnectorError::MissingRequiredField {
field_name: "browser_info",
},
)?;
Ok(Self {
customer_ip: Secret::new(
browser_info
.ip_address
.ok_or(errors::ConnectorError::MissingRequiredField {
field_name: "browser_info.ip_address",
})?
.to_string(),
),
merchant_pos_id: auth_type.merchant_pos_id,
ext_order_id: Some(item.router_data.connector_request_reference_id.clone()),
total_amount: item.amount.to_owned(),
currency_code: item.router_data.request.currency,
description: item.router_data.description.clone().ok_or(
errors::ConnectorError::MissingRequiredField {
field_name: "item.description",
},
)?,
pay_methods: payment_method,
continue_url: None,
})
}
}
pub struct PayuAuthType {
pub(super) api_key: Secret<String>,
pub(super) merchant_pos_id: Secret<String>,
}
impl TryFrom<&ConnectorAuthType> for PayuAuthType {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(auth_type: &ConnectorAuthType) -> Result<Self, Self::Error> {
match auth_type {
ConnectorAuthType::BodyKey { api_key, key1 } => Ok(Self {
api_key: api_key.to_owned(),
merchant_pos_id: key1.to_owned(),
}),
_ => Err(errors::ConnectorError::FailedToObtainAuthType)?,
}
}
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, PartialEq)]
#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
pub enum PayuPaymentStatus {
Success,
WarningContinueRedirect,
#[serde(rename = "WARNING_CONTINUE_3DS")]
WarningContinue3ds,
WarningContinueCvv,
#[default]
Pending,
}
impl From<PayuPaymentStatus> for enums::AttemptStatus {
fn from(item: PayuPaymentStatus) -> Self {
match item {
PayuPaymentStatus::Success => Self::Pending,
PayuPaymentStatus::WarningContinue3ds => Self::Pending,
PayuPaymentStatus::WarningContinueCvv => Self::Pending,
PayuPaymentStatus::WarningContinueRedirect => Self::Pending,
PayuPaymentStatus::Pending => Self::Pending,
}
}
}
#[derive(Debug, Clone, Deserialize, PartialEq, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct PayuPaymentsResponse {
pub status: PayuPaymentStatusData,
pub redirect_uri: String,
pub iframe_allowed: Option<bool>,
pub three_ds_protocol_version: Option<String>,
pub order_id: String,
pub ext_order_id: Option<String>,
}
impl<F, T> TryFrom<ResponseRouterData<F, PayuPaymentsResponse, T, PaymentsResponseData>>
for RouterData<F, T, PaymentsResponseData>
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: ResponseRouterData<F, PayuPaymentsResponse, T, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
Ok(Self {
status: enums::AttemptStatus::from(item.response.status.status_code),
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(item.response.order_id.clone()),
redirection_data: Box::new(None),
mandate_reference: Box::new(None),
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: item
.response
.ext_order_id
.or(Some(item.response.order_id)),
incremental_authorization_allowed: None,
charges: None,
}),
amount_captured: None,
..item.data
})
}
}
#[derive(Default, Debug, Clone, Serialize, PartialEq)]
#[serde(rename_all = "camelCase")]
pub struct PayuPaymentsCaptureRequest {
order_id: String,
order_status: OrderStatus,
}
impl TryFrom<&types::PaymentsCaptureRouterData> for PayuPaymentsCaptureRequest {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(item: &types::PaymentsCaptureRouterData) -> Result<Self, Self::Error> {
Ok(Self {
order_id: item.request.connector_transaction_id.clone(),
order_status: OrderStatus::Completed,
})
}
}
#[derive(Default, Debug, Clone, Deserialize, PartialEq, Serialize)]
pub struct PayuPaymentsCaptureResponse {
status: PayuPaymentStatusData,
}
impl<F, T> TryFrom<ResponseRouterData<F, PayuPaymentsCaptureResponse, T, PaymentsResponseData>>
for RouterData<F, T, PaymentsResponseData>
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: ResponseRouterData<F, PayuPaymentsCaptureResponse, T, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
Ok(Self {
status: enums::AttemptStatus::from(item.response.status.status_code.clone()),
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::NoResponseId,
redirection_data: Box::new(None),
mandate_reference: Box::new(None),
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: None,
incremental_authorization_allowed: None,
charges: None,
}),
amount_captured: None,
..item.data
})
}
}
#[derive(Debug, Clone, Serialize, PartialEq)]
pub struct PayuAuthUpdateRequest {
grant_type: String,
client_id: Secret<String>,
client_secret: Secret<String>,
}
impl TryFrom<&types::RefreshTokenRouterData> for PayuAuthUpdateRequest {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(item: &types::RefreshTokenRouterData) -> Result<Self, Self::Error> {
Ok(Self {
grant_type: "client_credentials".to_string(),
client_id: item.get_request_id()?,
client_secret: item.request.app_id.clone(),
})
}
}
#[derive(Default, Debug, Clone, Deserialize, PartialEq, Serialize)]
pub struct PayuAuthUpdateResponse {
pub access_token: Secret<String>,
pub token_type: String,
pub expires_in: i64,
pub grant_type: String,
}
impl<F, T> TryFrom<ResponseRouterData<F, PayuAuthUpdateResponse, T, AccessToken>>
for RouterData<F, T, AccessToken>
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: ResponseRouterData<F, PayuAuthUpdateResponse, T, AccessToken>,
) -> Result<Self, Self::Error> {
Ok(Self {
response: Ok(AccessToken {
token: item.response.access_token,
expires: item.response.expires_in,
}),
..item.data
})
}
}
#[derive(Default, Debug, Clone, Serialize, Deserialize, PartialEq)]
#[serde(rename_all = "camelCase")]
pub struct PayuPaymentsCancelResponse {
pub order_id: String,
pub ext_order_id: Option<String>,
pub status: PayuPaymentStatusData,
}
impl<F, T> TryFrom<ResponseRouterData<F, PayuPaymentsCancelResponse, T, PaymentsResponseData>>
for RouterData<F, T, PaymentsResponseData>
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: ResponseRouterData<F, PayuPaymentsCancelResponse, T, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
Ok(Self {
status: enums::AttemptStatus::from(item.response.status.status_code.clone()),
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(item.response.order_id.clone()),
redirection_data: Box::new(None),
mandate_reference: Box::new(None),
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: item
.response
.ext_order_id
.or(Some(item.response.order_id)),
incremental_authorization_allowed: None,
charges: None,
}),
amount_captured: None,
..item.data
})
}
}
#[allow(dead_code)]
#[derive(Debug, Serialize, Eq, PartialEq, Default, Deserialize, Clone)]
#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
pub enum OrderStatus {
New,
Canceled,
Completed,
WaitingForConfirmation,
#[default]
Pending,
}
impl From<OrderStatus> for enums::AttemptStatus {
fn from(item: OrderStatus) -> Self {
match item {
OrderStatus::New => Self::PaymentMethodAwaited,
OrderStatus::Canceled => Self::Voided,
OrderStatus::Completed => Self::Charged,
OrderStatus::Pending => Self::Pending,
OrderStatus::WaitingForConfirmation => Self::Authorized,
}
}
}
#[derive(Debug, Serialize, Default, Deserialize, Clone, PartialEq)]
#[serde(rename_all = "camelCase")]
pub struct PayuPaymentStatusData {
status_code: PayuPaymentStatus,
severity: Option<String>,
status_desc: Option<String>,
}
#[derive(Default, Debug, Clone, Serialize, Deserialize, PartialEq)]
#[serde(rename_all = "camelCase")]
pub struct PayuProductData {
name: String,
unit_price: String,
quantity: String,
#[serde(rename = "virtual")]
virtually: Option<bool>,
listing_date: Option<String>,
}
#[derive(Debug, Clone, Deserialize, PartialEq, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct PayuOrderResponseData {
order_id: String,
ext_order_id: Option<String>,
order_create_date: String,
notify_url: Option<String>,
customer_ip: Secret<String, IpAddress>,
merchant_pos_id: Secret<String>,
description: String,
validity_time: Option<String>,
currency_code: enums::Currency,
total_amount: String,
buyer: Option<PayuOrderResponseBuyerData>,
pay_method: Option<PayuOrderResponsePayMethod>,
products: Option<Vec<PayuProductData>>,
status: OrderStatus,
}
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
#[serde(rename_all = "camelCase")]
pub struct PayuOrderResponseBuyerData {
ext_customer_id: Option<String>,
email: Option<Email>,
phone: Option<Secret<String>>,
first_name: Option<Secret<String>>,
last_name: Option<Secret<String>>,
#[serde(rename = "nin")]
national_identification_number: Option<Secret<String>>,
language: Option<String>,
delivery: Option<String>,
customer_id: Option<String>,
}
#[derive(Debug, Clone, Deserialize, PartialEq, Serialize)]
#[serde(tag = "type", rename_all = "SCREAMING_SNAKE_CASE")]
pub enum PayuOrderResponsePayMethod {
CardToken,
Pbl,
Installemnts,
}
#[derive(Default, Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct PayuOrderResponseProperty {
name: String,
value: String,
}
#[derive(Default, Debug, Clone, Deserialize, PartialEq, Serialize)]
pub struct PayuPaymentsSyncResponse {
orders: Vec<PayuOrderResponseData>,
status: PayuPaymentStatusData,
properties: Option<Vec<PayuOrderResponseProperty>>,
}
impl<F, T> TryFrom<ResponseRouterData<F, PayuPaymentsSyncResponse, T, PaymentsResponseData>>
for RouterData<F, T, PaymentsResponseData>
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: ResponseRouterData<F, PayuPaymentsSyncResponse, T, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
let order = match item.response.orders.first() {
Some(order) => order,
_ => Err(errors::ConnectorError::ResponseHandlingFailed)?,
};
Ok(Self {
status: enums::AttemptStatus::from(order.status.clone()),
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(order.order_id.clone()),
redirection_data: Box::new(None),
mandate_reference: Box::new(None),
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: order
.ext_order_id
.clone()
.or(Some(order.order_id.clone())),
incremental_authorization_allowed: None,
charges: None,
}),
amount_captured: Some(
order
.total_amount
.parse::<i64>()
.change_context(errors::ConnectorError::ResponseDeserializationFailed)?,
),
..item.data
})
}
}
#[derive(Default, Debug, Serialize)]
pub struct PayuRefundRequestData {
description: String,
amount: Option<MinorUnit>,
}
#[derive(Default, Debug, Serialize)]
pub struct PayuRefundRequest {
refund: PayuRefundRequestData,
}
impl<F> TryFrom<&PayuRouterData<&types::RefundsRouterData<F>>> for PayuRefundRequest {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(item: &PayuRouterData<&types::RefundsRouterData<F>>) -> Result<Self, Self::Error> {
Ok(Self {
refund: PayuRefundRequestData {
description: item.router_data.request.reason.clone().ok_or(
errors::ConnectorError::MissingRequiredField {
field_name: "item.request.reason",
},
)?,
amount: None,
},
})
}
}
// Type definition for Refund Response
#[allow(dead_code)]
#[derive(Debug, Serialize, Eq, PartialEq, Default, Deserialize, Clone)]
#[serde(rename_all = "UPPERCASE")]
pub enum RefundStatus {
Finalized,
Completed,
Canceled,
#[default]
Pending,
}
impl From<RefundStatus> for enums::RefundStatus {
fn from(item: RefundStatus) -> Self {
match item {
RefundStatus::Finalized | RefundStatus::Completed => Self::Success,
RefundStatus::Canceled => Self::Failure,
RefundStatus::Pending => Self::Pending,
}
}
}
#[derive(Default, Debug, Clone, Eq, PartialEq, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct PayuRefundResponseData {
refund_id: String,
ext_refund_id: String,
amount: String,
currency_code: enums::Currency,
description: String,
creation_date_time: String,
status: RefundStatus,
status_date_time: Option<String>,
}
#[derive(Default, Debug, Clone, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct RefundResponse {
refund: PayuRefundResponseData,
}
impl TryFrom<RefundsResponseRouterData<Execute, RefundResponse>>
for types::RefundsRouterData<Execute>
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: RefundsResponseRouterData<Execute, RefundResponse>,
) -> Result<Self, Self::Error> {
let refund_status = enums::RefundStatus::from(item.response.refund.status);
Ok(Self {
response: Ok(RefundsResponseData {
connector_refund_id: item.response.refund.refund_id,
refund_status,
}),
..item.data
})
}
}
#[derive(Default, Debug, Clone, Deserialize, Serialize)]
pub struct RefundSyncResponse {
refunds: Vec<PayuRefundResponseData>,
}
impl TryFrom<RefundsResponseRouterData<RSync, RefundSyncResponse>>
for types::RefundsRouterData<RSync>
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: RefundsResponseRouterData<RSync, RefundSyncResponse>,
) -> Result<Self, Self::Error> {
let refund = match item.response.refunds.first() {
Some(refund) => refund,
_ => Err(errors::ConnectorError::ResponseHandlingFailed)?,
};
Ok(Self {
response: Ok(RefundsResponseData {
connector_refund_id: refund.refund_id.clone(),
refund_status: enums::RefundStatus::from(refund.status.clone()),
}),
..item.data
})
}
}
#[derive(Default, Debug, Serialize, Deserialize, PartialEq)]
#[serde(rename_all = "camelCase")]
pub struct PayuErrorData {
pub status_code: String,
pub code: Option<String>,
pub code_literal: Option<String>,
pub status_desc: String,
}
#[derive(Default, Debug, Serialize, Deserialize, PartialEq)]
pub struct PayuErrorResponse {
pub status: PayuErrorData,
}
#[derive(Deserialize, Debug, Serialize)]
pub struct PayuAccessTokenErrorResponse {
pub error: String,
pub error_description: String,
}
|
{
"crate": "hyperswitch_connectors",
"file": "crates/hyperswitch_connectors/src/connectors/payu/transformers.rs",
"file_size": null,
"is_async": null,
"is_pub": null,
"num_enums": 7,
"num_structs": 24,
"num_tables": null,
"score": null,
"total_crates": null
}
|
file_hyperswitch_connectors_-5394670075836062517
|
clm
|
file
|
// Repository: hyperswitch
// Crate: hyperswitch_connectors
// File: crates/hyperswitch_connectors/src/connectors/elavon/transformers.rs
// Contains: 11 structs, 6 enums
use cards::CardNumber;
use common_enums::{enums, Currency};
use common_utils::{pii::Email, types::StringMajorUnit};
use error_stack::ResultExt;
use hyperswitch_domain_models::{
payment_method_data::PaymentMethodData,
router_data::{ConnectorAuthType, ErrorResponse, RouterData},
router_flow_types::refunds::{Execute, RSync},
router_request_types::{PaymentsAuthorizeData, ResponseId},
router_response_types::{MandateReference, PaymentsResponseData, RefundsResponseData},
types::{
PaymentsAuthorizeRouterData, PaymentsCaptureRouterData, PaymentsSyncRouterData,
RefundSyncRouterData, RefundsRouterData,
},
};
use hyperswitch_interfaces::{consts::NO_ERROR_CODE, errors};
use masking::{ExposeInterface, Secret};
use serde::{Deserialize, Deserializer, Serialize};
use crate::{
types::{
PaymentsCaptureResponseRouterData, PaymentsSyncResponseRouterData,
RefundsResponseRouterData, ResponseRouterData,
},
utils::{CardData, PaymentsAuthorizeRequestData, RefundsRequestData, RouterData as _},
};
pub struct ElavonRouterData<T> {
pub amount: StringMajorUnit,
pub router_data: T,
}
impl<T> From<(StringMajorUnit, T)> for ElavonRouterData<T> {
fn from((amount, item): (StringMajorUnit, T)) -> Self {
Self {
amount,
router_data: item,
}
}
}
#[derive(Serialize, Deserialize, Debug)]
#[serde(rename_all = "lowercase")]
pub enum TransactionType {
CcSale,
CcAuthOnly,
CcComplete,
CcReturn,
TxnQuery,
}
#[derive(Serialize, Deserialize, Debug)]
#[serde(rename_all = "UPPERCASE")]
pub enum SyncTransactionType {
Sale,
AuthOnly,
Return,
}
#[derive(Debug, Serialize)]
#[serde(untagged)]
pub enum ElavonPaymentsRequest {
Card(CardPaymentRequest),
MandatePayment(MandatePaymentRequest),
}
#[derive(Debug, Serialize)]
pub struct CardPaymentRequest {
pub ssl_transaction_type: TransactionType,
pub ssl_account_id: Secret<String>,
pub ssl_user_id: Secret<String>,
pub ssl_pin: Secret<String>,
pub ssl_amount: StringMajorUnit,
pub ssl_card_number: CardNumber,
pub ssl_exp_date: Secret<String>,
pub ssl_cvv2cvc2: Secret<String>,
pub ssl_email: Email,
#[serde(skip_serializing_if = "Option::is_none")]
pub ssl_add_token: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub ssl_get_token: Option<String>,
pub ssl_transaction_currency: Currency,
}
#[derive(Debug, Serialize)]
pub struct MandatePaymentRequest {
pub ssl_transaction_type: TransactionType,
pub ssl_account_id: Secret<String>,
pub ssl_user_id: Secret<String>,
pub ssl_pin: Secret<String>,
pub ssl_amount: StringMajorUnit,
pub ssl_email: Email,
pub ssl_token: Secret<String>,
}
impl TryFrom<&ElavonRouterData<&PaymentsAuthorizeRouterData>> for ElavonPaymentsRequest {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: &ElavonRouterData<&PaymentsAuthorizeRouterData>,
) -> Result<Self, Self::Error> {
let auth = ElavonAuthType::try_from(&item.router_data.connector_auth_type)?;
if item.router_data.is_three_ds() {
Err(errors::ConnectorError::NotSupported {
message: "Card 3DS".to_string(),
connector: "Elavon",
})?
};
match item.router_data.request.payment_method_data.clone() {
PaymentMethodData::Card(req_card) => Ok(Self::Card(CardPaymentRequest {
ssl_transaction_type: match item.router_data.request.is_auto_capture()? {
true => TransactionType::CcSale,
false => TransactionType::CcAuthOnly,
},
ssl_account_id: auth.account_id.clone(),
ssl_user_id: auth.user_id.clone(),
ssl_pin: auth.pin.clone(),
ssl_amount: item.amount.clone(),
ssl_card_number: req_card.card_number.clone(),
ssl_exp_date: req_card.get_expiry_date_as_mmyy()?,
ssl_cvv2cvc2: req_card.card_cvc,
ssl_email: item.router_data.get_billing_email()?,
ssl_add_token: match item.router_data.request.is_mandate_payment() {
true => Some("Y".to_string()),
false => None,
},
ssl_get_token: match item.router_data.request.is_mandate_payment() {
true => Some("Y".to_string()),
false => None,
},
ssl_transaction_currency: item.router_data.request.currency,
})),
PaymentMethodData::MandatePayment => Ok(Self::MandatePayment(MandatePaymentRequest {
ssl_transaction_type: match item.router_data.request.is_auto_capture()? {
true => TransactionType::CcSale,
false => TransactionType::CcAuthOnly,
},
ssl_account_id: auth.account_id.clone(),
ssl_user_id: auth.user_id.clone(),
ssl_pin: auth.pin.clone(),
ssl_amount: item.amount.clone(),
ssl_email: item.router_data.get_billing_email()?,
ssl_token: Secret::new(item.router_data.request.get_connector_mandate_id()?),
})),
_ => Err(errors::ConnectorError::NotImplemented("Payment methods".to_string()).into()),
}
}
}
pub struct ElavonAuthType {
pub(super) account_id: Secret<String>,
pub(super) user_id: Secret<String>,
pub(super) pin: Secret<String>,
}
impl TryFrom<&ConnectorAuthType> for ElavonAuthType {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(auth_type: &ConnectorAuthType) -> Result<Self, Self::Error> {
match auth_type {
ConnectorAuthType::SignatureKey {
api_key,
key1,
api_secret,
} => Ok(Self {
account_id: api_key.to_owned(),
user_id: key1.to_owned(),
pin: api_secret.to_owned(),
}),
_ => Err(errors::ConnectorError::FailedToObtainAuthType.into()),
}
}
}
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
enum SslResult {
#[serde(rename = "0")]
ImportedBatchFile,
#[serde(other)]
DeclineOrUnauthorized,
}
#[derive(Debug, Clone, Serialize)]
pub struct ElavonPaymentsResponse {
pub result: ElavonResult,
}
#[derive(Debug, Clone, Serialize)]
pub enum ElavonResult {
Success(PaymentResponse),
Error(ElavonErrorResponse),
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ElavonErrorResponse {
error_code: Option<String>,
error_message: String,
error_name: String,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct PaymentResponse {
ssl_result: SslResult,
ssl_txn_id: String,
ssl_result_message: String,
ssl_token: Option<Secret<String>>,
}
impl<'de> Deserialize<'de> for ElavonPaymentsResponse {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: Deserializer<'de>,
{
#[derive(Deserialize, Debug)]
#[serde(rename = "txn")]
struct XmlResponse {
// Error fields
#[serde(rename = "errorCode", default)]
error_code: Option<String>,
#[serde(rename = "errorMessage", default)]
error_message: Option<String>,
#[serde(rename = "errorName", default)]
error_name: Option<String>,
// Success fields
#[serde(rename = "ssl_result", default)]
ssl_result: Option<SslResult>,
#[serde(rename = "ssl_txn_id", default)]
ssl_txn_id: Option<String>,
#[serde(rename = "ssl_result_message", default)]
ssl_result_message: Option<String>,
#[serde(rename = "ssl_token", default)]
ssl_token: Option<Secret<String>>,
}
let xml_res = XmlResponse::deserialize(deserializer)?;
let result = match (xml_res.error_message.clone(), xml_res.error_name.clone()) {
(Some(error_message), Some(error_name)) => ElavonResult::Error(ElavonErrorResponse {
error_code: xml_res.error_code.clone(),
error_message,
error_name,
}),
_ => {
if let (Some(ssl_result), Some(ssl_txn_id), Some(ssl_result_message)) = (
xml_res.ssl_result.clone(),
xml_res.ssl_txn_id.clone(),
xml_res.ssl_result_message.clone(),
) {
ElavonResult::Success(PaymentResponse {
ssl_result,
ssl_txn_id,
ssl_result_message,
ssl_token: xml_res.ssl_token.clone(),
})
} else {
return Err(serde::de::Error::custom(
"Invalid Response XML structure - neither error nor success",
));
}
}
};
Ok(Self { result })
}
}
impl<F>
TryFrom<
ResponseRouterData<F, ElavonPaymentsResponse, PaymentsAuthorizeData, PaymentsResponseData>,
> for RouterData<F, PaymentsAuthorizeData, PaymentsResponseData>
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: ResponseRouterData<
F,
ElavonPaymentsResponse,
PaymentsAuthorizeData,
PaymentsResponseData,
>,
) -> Result<Self, Self::Error> {
let status =
get_payment_status(&item.response.result, item.data.request.is_auto_capture()?);
let response = match &item.response.result {
ElavonResult::Error(error) => Err(ErrorResponse {
code: error
.error_code
.clone()
.unwrap_or(NO_ERROR_CODE.to_string()),
message: error.error_message.clone(),
reason: Some(error.error_message.clone()),
attempt_status: None,
connector_transaction_id: None,
status_code: item.http_code,
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
connector_metadata: None,
}),
ElavonResult::Success(response) => {
if status == enums::AttemptStatus::Failure {
Err(ErrorResponse {
code: response.ssl_result_message.clone(),
message: response.ssl_result_message.clone(),
reason: Some(response.ssl_result_message.clone()),
attempt_status: None,
connector_transaction_id: Some(response.ssl_txn_id.clone()),
status_code: item.http_code,
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
connector_metadata: None,
})
} else {
Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(
response.ssl_txn_id.clone(),
),
redirection_data: Box::new(None),
mandate_reference: Box::new(Some(MandateReference {
connector_mandate_id: response
.ssl_token
.as_ref()
.map(|secret| secret.clone().expose()),
payment_method_id: None,
mandate_metadata: None,
connector_mandate_request_reference_id: None,
})),
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: Some(response.ssl_txn_id.clone()),
incremental_authorization_allowed: None,
charges: None,
})
}
}
};
Ok(Self {
status,
response,
..item.data
})
}
}
#[derive(Debug, Serialize, Deserialize)]
pub enum TransactionSyncStatus {
PEN, // Pended
OPN, // Unpended / release / open
REV, // Review
STL, // Settled
PST, // Failed due to post-auth rule
FPR, // Failed due to fraud prevention rules
PRE, // Failed due to pre-auth rule
}
#[derive(Debug, Serialize)]
#[serde(rename = "txn")]
pub struct PaymentsCaptureRequest {
pub ssl_transaction_type: TransactionType,
pub ssl_account_id: Secret<String>,
pub ssl_user_id: Secret<String>,
pub ssl_pin: Secret<String>,
pub ssl_amount: StringMajorUnit,
pub ssl_txn_id: String,
}
#[derive(Debug, Serialize)]
#[serde(rename = "txn")]
pub struct PaymentsVoidRequest {
pub ssl_transaction_type: TransactionType,
pub ssl_account_id: Secret<String>,
pub ssl_user_id: Secret<String>,
pub ssl_pin: Secret<String>,
pub ssl_txn_id: String,
}
#[derive(Debug, Serialize)]
#[serde(rename = "txn")]
pub struct ElavonRefundRequest {
pub ssl_transaction_type: TransactionType,
pub ssl_account_id: Secret<String>,
pub ssl_user_id: Secret<String>,
pub ssl_pin: Secret<String>,
pub ssl_amount: StringMajorUnit,
pub ssl_txn_id: String,
}
#[derive(Debug, Serialize)]
#[serde(rename = "txn")]
pub struct SyncRequest {
pub ssl_transaction_type: TransactionType,
pub ssl_account_id: Secret<String>,
pub ssl_user_id: Secret<String>,
pub ssl_pin: Secret<String>,
pub ssl_txn_id: String,
}
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename = "txn")]
pub struct ElavonSyncResponse {
pub ssl_trans_status: TransactionSyncStatus,
pub ssl_transaction_type: SyncTransactionType,
pub ssl_txn_id: String,
}
impl TryFrom<&RefundSyncRouterData> for SyncRequest {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(item: &RefundSyncRouterData) -> Result<Self, Self::Error> {
let auth = ElavonAuthType::try_from(&item.connector_auth_type)?;
Ok(Self {
ssl_txn_id: item.request.get_connector_refund_id()?,
ssl_transaction_type: TransactionType::TxnQuery,
ssl_account_id: auth.account_id.clone(),
ssl_user_id: auth.user_id.clone(),
ssl_pin: auth.pin.clone(),
})
}
}
impl TryFrom<&PaymentsSyncRouterData> for SyncRequest {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(item: &PaymentsSyncRouterData) -> Result<Self, Self::Error> {
let auth = ElavonAuthType::try_from(&item.connector_auth_type)?;
Ok(Self {
ssl_txn_id: item
.request
.connector_transaction_id
.get_connector_transaction_id()
.change_context(errors::ConnectorError::MissingConnectorTransactionID)?,
ssl_transaction_type: TransactionType::TxnQuery,
ssl_account_id: auth.account_id.clone(),
ssl_user_id: auth.user_id.clone(),
ssl_pin: auth.pin.clone(),
})
}
}
impl<F> TryFrom<&ElavonRouterData<&RefundsRouterData<F>>> for ElavonRefundRequest {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(item: &ElavonRouterData<&RefundsRouterData<F>>) -> Result<Self, Self::Error> {
let auth = ElavonAuthType::try_from(&item.router_data.connector_auth_type)?;
Ok(Self {
ssl_txn_id: item.router_data.request.connector_transaction_id.clone(),
ssl_amount: item.amount.clone(),
ssl_transaction_type: TransactionType::CcReturn,
ssl_account_id: auth.account_id.clone(),
ssl_user_id: auth.user_id.clone(),
ssl_pin: auth.pin.clone(),
})
}
}
impl TryFrom<&ElavonRouterData<&PaymentsCaptureRouterData>> for PaymentsCaptureRequest {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(item: &ElavonRouterData<&PaymentsCaptureRouterData>) -> Result<Self, Self::Error> {
let auth = ElavonAuthType::try_from(&item.router_data.connector_auth_type)?;
Ok(Self {
ssl_txn_id: item.router_data.request.connector_transaction_id.clone(),
ssl_amount: item.amount.clone(),
ssl_transaction_type: TransactionType::CcComplete,
ssl_account_id: auth.account_id.clone(),
ssl_user_id: auth.user_id.clone(),
ssl_pin: auth.pin.clone(),
})
}
}
impl TryFrom<PaymentsSyncResponseRouterData<ElavonSyncResponse>> for PaymentsSyncRouterData {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: PaymentsSyncResponseRouterData<ElavonSyncResponse>,
) -> Result<Self, Self::Error> {
Ok(Self {
status: get_sync_status(item.data.status, &item.response),
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(item.response.ssl_txn_id),
redirection_data: Box::new(None),
mandate_reference: Box::new(None),
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: None,
incremental_authorization_allowed: None,
charges: None,
}),
..item.data
})
}
}
impl TryFrom<RefundsResponseRouterData<RSync, ElavonSyncResponse>> for RefundsRouterData<RSync> {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: RefundsResponseRouterData<RSync, ElavonSyncResponse>,
) -> Result<Self, Self::Error> {
Ok(Self {
response: Ok(RefundsResponseData {
connector_refund_id: item.response.ssl_txn_id.clone(),
refund_status: get_refund_status(item.data.request.refund_status, &item.response),
}),
..item.data
})
}
}
impl TryFrom<PaymentsCaptureResponseRouterData<ElavonPaymentsResponse>>
for PaymentsCaptureRouterData
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: PaymentsCaptureResponseRouterData<ElavonPaymentsResponse>,
) -> Result<Self, Self::Error> {
let status = map_payment_status(&item.response.result, enums::AttemptStatus::Charged);
let response = match &item.response.result {
ElavonResult::Error(error) => Err(ErrorResponse {
code: error
.error_code
.clone()
.unwrap_or(NO_ERROR_CODE.to_string()),
message: error.error_message.clone(),
reason: Some(error.error_message.clone()),
attempt_status: None,
connector_transaction_id: None,
status_code: item.http_code,
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
connector_metadata: None,
}),
ElavonResult::Success(response) => {
if status == enums::AttemptStatus::Failure {
Err(ErrorResponse {
code: response.ssl_result_message.clone(),
message: response.ssl_result_message.clone(),
reason: Some(response.ssl_result_message.clone()),
attempt_status: None,
connector_transaction_id: None,
status_code: item.http_code,
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
connector_metadata: None,
})
} else {
Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(
response.ssl_txn_id.clone(),
),
redirection_data: Box::new(None),
mandate_reference: Box::new(None),
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: Some(response.ssl_txn_id.clone()),
incremental_authorization_allowed: None,
charges: None,
})
}
}
};
Ok(Self {
status,
response,
..item.data
})
}
}
impl TryFrom<RefundsResponseRouterData<Execute, ElavonPaymentsResponse>>
for RefundsRouterData<Execute>
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: RefundsResponseRouterData<Execute, ElavonPaymentsResponse>,
) -> Result<Self, Self::Error> {
let status = enums::RefundStatus::from(&item.response.result);
let response = match &item.response.result {
ElavonResult::Error(error) => Err(ErrorResponse {
code: error
.error_code
.clone()
.unwrap_or(NO_ERROR_CODE.to_string()),
message: error.error_message.clone(),
reason: Some(error.error_message.clone()),
attempt_status: None,
connector_transaction_id: None,
status_code: item.http_code,
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
connector_metadata: None,
}),
ElavonResult::Success(response) => {
if status == enums::RefundStatus::Failure {
Err(ErrorResponse {
code: response.ssl_result_message.clone(),
message: response.ssl_result_message.clone(),
reason: Some(response.ssl_result_message.clone()),
attempt_status: None,
connector_transaction_id: None,
status_code: item.http_code,
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
connector_metadata: None,
})
} else {
Ok(RefundsResponseData {
connector_refund_id: response.ssl_txn_id.clone(),
refund_status: enums::RefundStatus::from(&item.response.result),
})
}
}
};
Ok(Self {
response,
..item.data
})
}
}
trait ElavonResponseValidator {
fn is_successful(&self) -> bool;
}
impl ElavonResponseValidator for ElavonResult {
fn is_successful(&self) -> bool {
matches!(self, Self::Success(response) if response.ssl_result == SslResult::ImportedBatchFile)
}
}
fn map_payment_status(
item: &ElavonResult,
success_status: enums::AttemptStatus,
) -> enums::AttemptStatus {
if item.is_successful() {
success_status
} else {
enums::AttemptStatus::Failure
}
}
impl From<&ElavonResult> for enums::RefundStatus {
fn from(item: &ElavonResult) -> Self {
if item.is_successful() {
Self::Success
} else {
Self::Failure
}
}
}
fn get_refund_status(
prev_status: enums::RefundStatus,
item: &ElavonSyncResponse,
) -> enums::RefundStatus {
match item.ssl_trans_status {
TransactionSyncStatus::REV | TransactionSyncStatus::OPN | TransactionSyncStatus::PEN => {
prev_status
}
TransactionSyncStatus::STL => enums::RefundStatus::Success,
TransactionSyncStatus::PST | TransactionSyncStatus::FPR | TransactionSyncStatus::PRE => {
enums::RefundStatus::Failure
}
}
}
impl From<&ElavonSyncResponse> for enums::AttemptStatus {
fn from(item: &ElavonSyncResponse) -> Self {
match item.ssl_trans_status {
TransactionSyncStatus::REV
| TransactionSyncStatus::OPN
| TransactionSyncStatus::PEN => Self::Pending,
TransactionSyncStatus::STL => match item.ssl_transaction_type {
SyncTransactionType::Sale => Self::Charged,
SyncTransactionType::AuthOnly => Self::Authorized,
SyncTransactionType::Return => Self::Pending,
},
TransactionSyncStatus::PST
| TransactionSyncStatus::FPR
| TransactionSyncStatus::PRE => Self::Failure,
}
}
}
fn get_sync_status(
prev_status: enums::AttemptStatus,
item: &ElavonSyncResponse,
) -> enums::AttemptStatus {
match item.ssl_trans_status {
TransactionSyncStatus::REV | TransactionSyncStatus::OPN | TransactionSyncStatus::PEN => {
prev_status
}
TransactionSyncStatus::STL => match item.ssl_transaction_type {
SyncTransactionType::Sale => enums::AttemptStatus::Charged,
SyncTransactionType::AuthOnly => enums::AttemptStatus::Authorized,
SyncTransactionType::Return => enums::AttemptStatus::Pending,
},
TransactionSyncStatus::PST | TransactionSyncStatus::FPR | TransactionSyncStatus::PRE => {
enums::AttemptStatus::Failure
}
}
}
fn get_payment_status(item: &ElavonResult, is_auto_capture: bool) -> enums::AttemptStatus {
if item.is_successful() {
if is_auto_capture {
enums::AttemptStatus::Charged
} else {
enums::AttemptStatus::Authorized
}
} else {
enums::AttemptStatus::Failure
}
}
|
{
"crate": "hyperswitch_connectors",
"file": "crates/hyperswitch_connectors/src/connectors/elavon/transformers.rs",
"file_size": null,
"is_async": null,
"is_pub": null,
"num_enums": 6,
"num_structs": 11,
"num_tables": null,
"score": null,
"total_crates": null
}
|
file_hyperswitch_connectors_-6324744643965140687
|
clm
|
file
|
// Repository: hyperswitch
// Crate: hyperswitch_connectors
// File: crates/hyperswitch_connectors/src/connectors/gigadat/transformers.rs
// Contains: 19 structs, 3 enums
#[cfg(feature = "payouts")]
use api_models::{
self,
payouts::{BankRedirect, PayoutMethodData},
};
use common_enums::{enums, Currency};
use common_utils::{
id_type,
pii::{self, Email, IpAddress},
request::Method,
types::FloatMajorUnit,
};
use error_stack::ResultExt;
use hyperswitch_domain_models::{
payment_method_data::{BankRedirectData, PaymentMethodData},
router_data::{ConnectorAuthType, RouterData},
router_flow_types::refunds::Execute,
router_request_types::ResponseId,
router_response_types::{PaymentsResponseData, RedirectForm, RefundsResponseData},
types::{PaymentsAuthorizeRouterData, RefundsRouterData},
};
#[cfg(feature = "payouts")]
use hyperswitch_domain_models::{
router_flow_types::PoQuote, router_response_types::PayoutsResponseData,
types::PayoutsRouterData,
};
use hyperswitch_interfaces::errors;
use masking::{PeekInterface, Secret};
use serde::{Deserialize, Serialize};
#[cfg(feature = "payouts")]
use crate::{types::PayoutsResponseRouterData, utils::PayoutsData as _};
use crate::{
types::{RefundsResponseRouterData, ResponseRouterData},
utils::{self, BrowserInformationData, PaymentsAuthorizeRequestData, RouterData as _},
};
pub struct GigadatRouterData<T> {
pub amount: FloatMajorUnit, // The type of amount that a connector accepts, for example, String, i64, f64, etc.
pub router_data: T,
}
impl<T> From<(FloatMajorUnit, T)> for GigadatRouterData<T> {
fn from((amount, item): (FloatMajorUnit, T)) -> Self {
Self {
amount,
router_data: item,
}
}
}
const CONNECTOR_BASE_URL: &str = "https://interac.express-connect.com/";
#[derive(Debug, Default, Serialize, Deserialize)]
pub struct GigadatConnectorMetadataObject {
pub site: String,
}
impl TryFrom<&Option<pii::SecretSerdeValue>> for GigadatConnectorMetadataObject {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(meta_data: &Option<pii::SecretSerdeValue>) -> Result<Self, Self::Error> {
let metadata: Self = utils::to_connector_meta_from_secret::<Self>(meta_data.clone())
.change_context(errors::ConnectorError::InvalidConnectorConfig {
config: "merchant_connector_account.metadata",
})?;
Ok(metadata)
}
}
// CPI (Combined Pay-in) Request Structure for Gigadat
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct GigadatCpiRequest {
pub user_id: id_type::CustomerId,
pub site: String,
pub user_ip: Secret<String, IpAddress>,
pub currency: Currency,
pub amount: FloatMajorUnit,
pub transaction_id: String,
#[serde(rename = "type")]
pub transaction_type: GidadatTransactionType,
pub sandbox: bool,
pub name: Secret<String>,
pub email: Email,
pub mobile: Secret<String>,
}
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "UPPERCASE")]
pub enum GidadatTransactionType {
Cpi,
Eto,
}
impl TryFrom<&GigadatRouterData<&PaymentsAuthorizeRouterData>> for GigadatCpiRequest {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: &GigadatRouterData<&PaymentsAuthorizeRouterData>,
) -> Result<Self, Self::Error> {
let metadata: GigadatConnectorMetadataObject =
utils::to_connector_meta_from_secret(item.router_data.connector_meta_data.clone())
.change_context(errors::ConnectorError::InvalidConnectorConfig {
config: "merchant_connector_account.metadata",
})?;
match item.router_data.request.payment_method_data.clone() {
PaymentMethodData::BankRedirect(BankRedirectData::Interac { .. }) => {
let router_data = item.router_data;
let name = router_data.get_billing_full_name()?;
let email = router_data.get_billing_email()?;
let mobile = router_data.get_billing_phone_number()?;
let currency = item.router_data.request.currency;
let sandbox = match item.router_data.test_mode {
Some(true) => true,
Some(false) | None => false,
};
let user_ip = router_data.request.get_browser_info()?.get_ip_address()?;
Ok(Self {
user_id: router_data.get_customer_id()?,
site: metadata.site,
user_ip,
currency,
amount: item.amount,
transaction_id: router_data.connector_request_reference_id.clone(),
transaction_type: GidadatTransactionType::Cpi,
name,
sandbox,
email,
mobile,
})
}
PaymentMethodData::BankRedirect(_) => Err(errors::ConnectorError::NotImplemented(
utils::get_unimplemented_payment_method_error_message("Gigadat"),
))?,
_ => Err(errors::ConnectorError::NotImplemented(
utils::get_unimplemented_payment_method_error_message("Gigadat"),
)
.into()),
}
}
}
#[derive(Debug, Clone)]
pub struct GigadatAuthType {
pub campaign_id: Secret<String>,
pub access_token: Secret<String>,
pub security_token: Secret<String>,
}
impl TryFrom<&ConnectorAuthType> for GigadatAuthType {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(auth_type: &ConnectorAuthType) -> Result<Self, Self::Error> {
match auth_type {
ConnectorAuthType::SignatureKey {
api_key,
key1,
api_secret,
} => Ok(Self {
security_token: api_secret.to_owned(),
access_token: api_key.to_owned(),
campaign_id: key1.to_owned(),
}),
_ => Err(errors::ConnectorError::FailedToObtainAuthType.into()),
}
}
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct GigadatPaymentResponse {
pub token: Secret<String>,
pub data: GigadatPaymentData,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct GigadatPaymentData {
pub transaction_id: String,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
pub enum GigadatPaymentStatus {
StatusInited,
StatusSuccess,
StatusRejected,
StatusRejected1,
StatusExpired,
StatusAborted1,
StatusPending,
StatusFailed,
}
impl From<GigadatPaymentStatus> for enums::AttemptStatus {
fn from(item: GigadatPaymentStatus) -> Self {
match item {
GigadatPaymentStatus::StatusSuccess => Self::Charged,
GigadatPaymentStatus::StatusInited | GigadatPaymentStatus::StatusPending => {
Self::Pending
}
GigadatPaymentStatus::StatusRejected
| GigadatPaymentStatus::StatusExpired
| GigadatPaymentStatus::StatusRejected1
| GigadatPaymentStatus::StatusAborted1
| GigadatPaymentStatus::StatusFailed => Self::Failure,
}
}
}
impl From<GigadatPaymentStatus> for api_models::webhooks::IncomingWebhookEvent {
fn from(item: GigadatPaymentStatus) -> Self {
match item {
GigadatPaymentStatus::StatusSuccess => Self::PaymentIntentSuccess,
GigadatPaymentStatus::StatusFailed
| GigadatPaymentStatus::StatusRejected
| GigadatPaymentStatus::StatusRejected1
| GigadatPaymentStatus::StatusExpired
| GigadatPaymentStatus::StatusAborted1 => Self::PaymentIntentFailure,
GigadatPaymentStatus::StatusInited | GigadatPaymentStatus::StatusPending => {
Self::PaymentIntentProcessing
}
}
}
}
impl TryFrom<String> for GigadatPaymentStatus {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(value: String) -> Result<Self, Self::Error> {
match value.as_str() {
"STATUS_INITED" => Ok(Self::StatusInited),
"STATUS_SUCCESS" => Ok(Self::StatusSuccess),
"STATUS_REJECTED" => Ok(Self::StatusRejected),
"STATUS_REJECTED1" => Ok(Self::StatusRejected1),
"STATUS_EXPIRED" => Ok(Self::StatusExpired),
"STATUS_ABORTED1" => Ok(Self::StatusAborted1),
"STATUS_PENDING" => Ok(Self::StatusPending),
"STATUS_FAILED" => Ok(Self::StatusFailed),
_ => Err(errors::ConnectorError::WebhookBodyDecodingFailed.into()),
}
}
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct GigadatTransactionStatusResponse {
pub status: GigadatPaymentStatus,
}
impl<F, T> TryFrom<ResponseRouterData<F, GigadatPaymentResponse, T, PaymentsResponseData>>
for RouterData<F, T, PaymentsResponseData>
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: ResponseRouterData<F, GigadatPaymentResponse, T, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
// Will be raising a sepearte PR to populate a field connect_base_url in routerData and use it here
let base_url = CONNECTOR_BASE_URL;
let redirect_url = format!(
"{}webflow?transaction={}&token={}",
base_url,
item.data.connector_request_reference_id,
item.response.token.peek()
);
let redirection_data = Some(RedirectForm::Form {
endpoint: redirect_url,
method: Method::Get,
form_fields: Default::default(),
});
Ok(Self {
status: enums::AttemptStatus::AuthenticationPending,
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(item.response.data.transaction_id),
redirection_data: Box::new(redirection_data),
mandate_reference: Box::new(None),
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: None,
incremental_authorization_allowed: None,
charges: None,
}),
..item.data
})
}
}
impl<F, T> TryFrom<ResponseRouterData<F, GigadatTransactionStatusResponse, T, PaymentsResponseData>>
for RouterData<F, T, PaymentsResponseData>
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: ResponseRouterData<F, GigadatTransactionStatusResponse, T, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
Ok(Self {
status: enums::AttemptStatus::from(item.response.status),
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::NoResponseId,
redirection_data: Box::new(None),
mandate_reference: Box::new(None),
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: None,
incremental_authorization_allowed: None,
charges: None,
}),
..item.data
})
}
}
// REFUND :
// Type definition for RefundRequest
#[derive(Default, Debug, Serialize)]
pub struct GigadatRefundRequest {
pub amount: FloatMajorUnit,
pub transaction_id: String,
pub campaign_id: Secret<String>,
}
impl<F> TryFrom<&GigadatRouterData<&RefundsRouterData<F>>> for GigadatRefundRequest {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(item: &GigadatRouterData<&RefundsRouterData<F>>) -> Result<Self, Self::Error> {
let auth_type = GigadatAuthType::try_from(&item.router_data.connector_auth_type)?;
Ok(Self {
amount: item.amount.to_owned(),
transaction_id: item.router_data.request.connector_transaction_id.clone(),
campaign_id: auth_type.campaign_id,
})
}
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct RefundResponse {
success: bool,
data: GigadatPaymentData,
}
impl TryFrom<RefundsResponseRouterData<Execute, RefundResponse>> for RefundsRouterData<Execute> {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: RefundsResponseRouterData<Execute, RefundResponse>,
) -> Result<Self, Self::Error> {
let refund_status = match item.http_code {
200 => enums::RefundStatus::Success,
400 | 401 | 422 => enums::RefundStatus::Failure,
_ => enums::RefundStatus::Pending,
};
Ok(Self {
response: Ok(RefundsResponseData {
connector_refund_id: item.response.data.transaction_id.to_string(),
refund_status,
}),
..item.data
})
}
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct GigadatPayoutQuoteRequest {
pub amount: FloatMajorUnit,
pub campaign: Secret<String>,
pub currency: Currency,
pub email: Email,
pub mobile: Secret<String>,
pub name: Secret<String>,
pub site: String,
pub transaction_id: String,
#[serde(rename = "type")]
pub transaction_type: GidadatTransactionType,
pub user_id: id_type::CustomerId,
pub user_ip: Secret<String, IpAddress>,
pub sandbox: bool,
}
// Payouts fulfill request transform
#[cfg(feature = "payouts")]
impl TryFrom<&GigadatRouterData<&PayoutsRouterData<PoQuote>>> for GigadatPayoutQuoteRequest {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: &GigadatRouterData<&PayoutsRouterData<PoQuote>>,
) -> Result<Self, Self::Error> {
match item.router_data.get_payout_method_data()? {
PayoutMethodData::BankRedirect(BankRedirect::Interac(interac_data)) => {
let metadata: GigadatConnectorMetadataObject =
utils::to_connector_meta_from_secret(
item.router_data.connector_meta_data.clone(),
)
.change_context(
errors::ConnectorError::InvalidConnectorConfig {
config: "merchant_connector_account.metadata",
},
)?;
let router_data = item.router_data;
let name = router_data.get_billing_full_name()?;
let email = interac_data.email;
let mobile = router_data.get_billing_phone_number()?;
let currency = item.router_data.request.destination_currency;
let user_ip = router_data.request.get_browser_info()?.get_ip_address()?;
let auth_type = GigadatAuthType::try_from(&item.router_data.connector_auth_type)?;
let sandbox = match item.router_data.test_mode {
Some(true) => true,
Some(false) | None => false,
};
Ok(Self {
user_id: router_data.get_customer_id()?,
site: metadata.site,
user_ip,
currency,
amount: item.amount,
transaction_id: router_data.connector_request_reference_id.clone(),
transaction_type: GidadatTransactionType::Eto,
name,
email,
mobile,
campaign: auth_type.campaign_id,
sandbox,
})
}
PayoutMethodData::Card(_) | PayoutMethodData::Bank(_) | PayoutMethodData::Wallet(_) => {
Err(errors::ConnectorError::NotSupported {
message: "Payment Method Not Supported".to_string(),
connector: "Gigadat",
})?
}
}
}
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct GigadatPayoutQuoteResponse {
pub token: Secret<String>,
pub data: GigadatPayoutData,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct GigadatPayoutData {
pub transaction_id: String,
#[serde(rename = "type")]
pub transaction_type: String,
}
#[derive(Debug, Serialize, Deserialize)]
pub struct GigadatPayoutMeta {
pub token: Secret<String>,
}
#[cfg(feature = "payouts")]
impl<F> TryFrom<PayoutsResponseRouterData<F, GigadatPayoutQuoteResponse>> for PayoutsRouterData<F> {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: PayoutsResponseRouterData<F, GigadatPayoutQuoteResponse>,
) -> Result<Self, Self::Error> {
let connector_meta = serde_json::json!(GigadatPayoutMeta {
token: item.response.token,
});
Ok(Self {
response: Ok(PayoutsResponseData {
status: None,
connector_payout_id: Some(item.response.data.transaction_id),
payout_eligible: None,
should_add_next_step_to_process_tracker: false,
error_code: None,
error_message: None,
payout_connector_metadata: Some(Secret::new(connector_meta)),
}),
..item.data
})
}
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct GigadatPayoutResponse {
pub id: String,
pub status: GigadatPayoutStatus,
pub data: GigadatPayoutData,
}
#[cfg(feature = "payouts")]
impl<F> TryFrom<PayoutsResponseRouterData<F, GigadatPayoutResponse>> for PayoutsRouterData<F> {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: PayoutsResponseRouterData<F, GigadatPayoutResponse>,
) -> Result<Self, Self::Error> {
Ok(Self {
response: Ok(PayoutsResponseData {
status: Some(enums::PayoutStatus::from(item.response.status)),
connector_payout_id: Some(item.response.data.transaction_id),
payout_eligible: None,
should_add_next_step_to_process_tracker: false,
error_code: None,
error_message: None,
payout_connector_metadata: None,
}),
..item.data
})
}
}
#[cfg(feature = "payouts")]
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct GigadatPayoutSyncResponse {
pub status: GigadatPayoutStatus,
}
#[cfg(feature = "payouts")]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
pub enum GigadatPayoutStatus {
StatusInited,
StatusSuccess,
StatusRejected,
StatusRejected1,
StatusExpired,
StatusAborted1,
StatusPending,
StatusFailed,
}
#[cfg(feature = "payouts")]
impl From<GigadatPayoutStatus> for enums::PayoutStatus {
fn from(item: GigadatPayoutStatus) -> Self {
match item {
GigadatPayoutStatus::StatusSuccess => Self::Success,
GigadatPayoutStatus::StatusPending => Self::RequiresFulfillment,
GigadatPayoutStatus::StatusInited => Self::Pending,
GigadatPayoutStatus::StatusRejected
| GigadatPayoutStatus::StatusExpired
| GigadatPayoutStatus::StatusRejected1
| GigadatPayoutStatus::StatusAborted1
| GigadatPayoutStatus::StatusFailed => Self::Failed,
}
}
}
#[cfg(feature = "payouts")]
impl<F> TryFrom<PayoutsResponseRouterData<F, GigadatPayoutSyncResponse>> for PayoutsRouterData<F> {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: PayoutsResponseRouterData<F, GigadatPayoutSyncResponse>,
) -> Result<Self, Self::Error> {
Ok(Self {
response: Ok(PayoutsResponseData {
status: Some(enums::PayoutStatus::from(item.response.status)),
connector_payout_id: None,
payout_eligible: None,
should_add_next_step_to_process_tracker: false,
error_code: None,
error_message: None,
payout_connector_metadata: None,
}),
..item.data
})
}
}
#[derive(Default, Debug, Serialize, Deserialize)]
pub struct GigadatErrorResponse {
pub err: String,
}
#[derive(Default, Debug, Serialize, Deserialize)]
pub struct GigadatRefundErrorResponse {
pub error: Vec<Error>,
pub message: String,
}
#[derive(Default, Debug, Serialize, Deserialize)]
pub struct Error {
pub code: Option<String>,
pub detail: String,
}
#[derive(Debug, Deserialize)]
pub struct GigadatWebhookQueryParameters {
pub transaction: String,
pub status: GigadatPaymentStatus,
}
#[derive(Debug, Serialize, Deserialize)]
pub struct GigadatWebhookKeyValue {
pub key: String,
pub value: String,
}
|
{
"crate": "hyperswitch_connectors",
"file": "crates/hyperswitch_connectors/src/connectors/gigadat/transformers.rs",
"file_size": null,
"is_async": null,
"is_pub": null,
"num_enums": 3,
"num_structs": 19,
"num_tables": null,
"score": null,
"total_crates": null
}
|
file_hyperswitch_connectors_5462529728514876981
|
clm
|
file
|
// Repository: hyperswitch
// Crate: hyperswitch_connectors
// File: crates/hyperswitch_connectors/src/connectors/payme/transformers.rs
// Contains: 29 structs, 7 enums
use std::collections::HashMap;
use api_models::enums::{AuthenticationType, PaymentMethod};
use common_enums::enums;
use common_utils::{
pii,
types::{MinorUnit, StringMajorUnit},
};
use error_stack::ResultExt;
use hyperswitch_domain_models::{
payment_method_data::{PaymentMethodData, WalletData},
router_data::{ConnectorAuthType, ErrorResponse, PaymentMethodToken, RouterData},
router_flow_types::{Execute, Void},
router_request_types::{PaymentsCancelData, PaymentsPreProcessingData, ResponseId},
router_response_types::{
MandateReference, PaymentsResponseData, PreprocessingResponseId, RedirectForm,
RefundsResponseData,
},
types::{
PaymentsAuthorizeRouterData, PaymentsCancelRouterData, PaymentsCaptureRouterData,
PaymentsCompleteAuthorizeRouterData, PaymentsPreProcessingRouterData,
PaymentsSyncRouterData, RefundSyncRouterData, RefundsRouterData, TokenizationRouterData,
},
};
use hyperswitch_interfaces::{consts, errors};
use masking::{ExposeInterface, Secret};
use serde::{Deserialize, Serialize};
use url::Url;
use crate::{
types::{PaymentsCancelResponseRouterData, RefundsResponseRouterData, ResponseRouterData},
unimplemented_payment_method,
utils::{
self, AddressDetailsData, CardData, PaymentsAuthorizeRequestData,
PaymentsCancelRequestData, PaymentsCompleteAuthorizeRequestData,
PaymentsPreProcessingRequestData, PaymentsSyncRequestData, RouterData as OtherRouterData,
},
};
const LANGUAGE: &str = "en";
#[derive(Debug, Serialize)]
pub struct PaymeRouterData<T> {
pub amount: MinorUnit,
pub router_data: T,
}
impl<T> TryFrom<(MinorUnit, T)> for PaymeRouterData<T> {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from((amount, item): (MinorUnit, T)) -> Result<Self, Self::Error> {
Ok(Self {
amount,
router_data: item,
})
}
}
#[derive(Debug, Serialize)]
pub struct PayRequest {
buyer_name: Secret<String>,
buyer_email: pii::Email,
payme_sale_id: String,
#[serde(flatten)]
card: PaymeCard,
language: String,
}
#[derive(Debug, Serialize)]
pub struct MandateRequest {
currency: enums::Currency,
sale_price: MinorUnit,
transaction_id: String,
product_name: String,
sale_return_url: String,
seller_payme_id: Secret<String>,
sale_callback_url: String,
buyer_key: Secret<String>,
language: String,
}
#[derive(Debug, Serialize)]
pub struct Pay3dsRequest {
buyer_name: Secret<String>,
buyer_email: pii::Email,
buyer_key: Secret<String>,
payme_sale_id: String,
meta_data_jwt: Secret<String>,
}
#[derive(Debug, Serialize)]
#[serde(untagged)]
pub enum PaymePaymentRequest {
MandateRequest(MandateRequest),
PayRequest(PayRequest),
}
#[derive(Debug, Serialize)]
pub struct PaymeQuerySaleRequest {
sale_payme_id: String,
seller_payme_id: Secret<String>,
}
#[derive(Debug, Serialize)]
pub struct PaymeQueryTransactionRequest {
payme_transaction_id: String,
seller_payme_id: Secret<String>,
}
#[derive(Debug, Serialize)]
pub struct PaymeCard {
credit_card_cvv: Secret<String>,
credit_card_exp: Secret<String>,
credit_card_number: cards::CardNumber,
}
#[derive(Debug, Serialize)]
pub struct CaptureBuyerRequest {
seller_payme_id: Secret<String>,
#[serde(flatten)]
card: PaymeCard,
}
#[derive(Debug, Deserialize, Serialize)]
pub struct CaptureBuyerResponse {
buyer_key: Secret<String>,
}
#[derive(Debug, Serialize)]
pub struct GenerateSaleRequest {
currency: enums::Currency,
sale_type: SaleType,
sale_price: MinorUnit,
transaction_id: String,
product_name: String,
sale_return_url: String,
seller_payme_id: Secret<String>,
sale_callback_url: String,
sale_payment_method: SalePaymentMethod,
services: Option<ThreeDs>,
language: String,
}
#[derive(Debug, Serialize)]
pub struct ThreeDs {
name: ThreeDsType,
settings: ThreeDsSettings,
}
#[derive(Debug, Serialize)]
pub enum ThreeDsType {
#[serde(rename = "3D Secure")]
ThreeDs,
}
#[derive(Debug, Serialize)]
pub struct ThreeDsSettings {
active: bool,
}
#[derive(Debug, Deserialize, Serialize)]
pub struct GenerateSaleResponse {
payme_sale_id: String,
}
impl<F, T> TryFrom<ResponseRouterData<F, PaymePaymentsResponse, T, PaymentsResponseData>>
for RouterData<F, T, PaymentsResponseData>
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: ResponseRouterData<F, PaymePaymentsResponse, T, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
match item.response {
// To handle webhook response
PaymePaymentsResponse::PaymePaySaleResponse(response) => {
Self::try_from(ResponseRouterData {
response,
data: item.data,
http_code: item.http_code,
})
}
// To handle PSync response
PaymePaymentsResponse::SaleQueryResponse(response) => {
Self::try_from(ResponseRouterData {
response,
data: item.data,
http_code: item.http_code,
})
}
}
}
}
impl<F, T> TryFrom<ResponseRouterData<F, PaymePaySaleResponse, T, PaymentsResponseData>>
for RouterData<F, T, PaymentsResponseData>
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: ResponseRouterData<F, PaymePaySaleResponse, T, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
let status = enums::AttemptStatus::from(item.response.sale_status.clone());
let response = if utils::is_payment_failure(status) {
// To populate error message in case of failure
Err(get_pay_sale_error_response((
&item.response,
item.http_code,
)))
} else {
Ok(PaymentsResponseData::try_from(&item.response)?)
};
Ok(Self {
status,
response,
..item.data
})
}
}
fn get_pay_sale_error_response(
(pay_sale_response, http_code): (&PaymePaySaleResponse, u16),
) -> ErrorResponse {
let code = pay_sale_response
.status_error_code
.map(|error_code| error_code.to_string())
.unwrap_or(consts::NO_ERROR_CODE.to_string());
ErrorResponse {
code,
message: pay_sale_response
.status_error_details
.clone()
.unwrap_or(consts::NO_ERROR_MESSAGE.to_string()),
reason: pay_sale_response.status_error_details.to_owned(),
status_code: http_code,
attempt_status: None,
connector_transaction_id: Some(pay_sale_response.payme_sale_id.clone()),
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
connector_metadata: None,
}
}
impl TryFrom<&PaymePaySaleResponse> for PaymentsResponseData {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(value: &PaymePaySaleResponse) -> Result<Self, Self::Error> {
let redirection_data = match value.sale_3ds {
Some(true) => value.redirect_url.clone().map(|url| RedirectForm::Form {
endpoint: url.to_string(),
method: common_utils::request::Method::Get,
form_fields: HashMap::<String, String>::new(),
}),
_ => None,
};
Ok(Self::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(value.payme_sale_id.clone()),
redirection_data: Box::new(redirection_data),
mandate_reference: Box::new(value.buyer_key.clone().map(|buyer_key| {
MandateReference {
connector_mandate_id: Some(buyer_key.expose()),
payment_method_id: None,
mandate_metadata: None,
connector_mandate_request_reference_id: None,
}
})),
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: None,
incremental_authorization_allowed: None,
charges: None,
})
}
}
impl<F, T> TryFrom<ResponseRouterData<F, SaleQueryResponse, T, PaymentsResponseData>>
for RouterData<F, T, PaymentsResponseData>
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: ResponseRouterData<F, SaleQueryResponse, T, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
// Only one element would be present since we are passing one transaction id in the PSync request
let transaction_response = item
.response
.items
.first()
.cloned()
.ok_or(errors::ConnectorError::ResponseHandlingFailed)?;
let status = enums::AttemptStatus::from(transaction_response.sale_status.clone());
let response = if utils::is_payment_failure(status) {
// To populate error message in case of failure
Err(get_sale_query_error_response((
&transaction_response,
item.http_code,
)))
} else {
Ok(PaymentsResponseData::from(&transaction_response))
};
Ok(Self {
status,
response,
..item.data
})
}
}
fn get_sale_query_error_response(
(sale_query_response, http_code): (&SaleQuery, u16),
) -> ErrorResponse {
ErrorResponse {
code: sale_query_response
.sale_error_code
.clone()
.unwrap_or(consts::NO_ERROR_CODE.to_string()),
message: sale_query_response
.sale_error_text
.clone()
.unwrap_or(consts::NO_ERROR_MESSAGE.to_string()),
reason: sale_query_response.sale_error_text.clone(),
status_code: http_code,
attempt_status: None,
connector_transaction_id: Some(sale_query_response.sale_payme_id.clone()),
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
connector_metadata: None,
}
}
impl From<&SaleQuery> for PaymentsResponseData {
fn from(value: &SaleQuery) -> Self {
Self::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(value.sale_payme_id.clone()),
redirection_data: Box::new(None),
// mandate reference will be updated with webhooks only. That has been handled with PaymePaySaleResponse struct
mandate_reference: Box::new(None),
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: None,
incremental_authorization_allowed: None,
charges: None,
}
}
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "lowercase")]
pub enum SaleType {
Sale,
Authorize,
Token,
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "kebab-case")]
pub enum SalePaymentMethod {
CreditCard,
ApplePay,
}
impl TryFrom<&PaymeRouterData<&PaymentsPreProcessingRouterData>> for GenerateSaleRequest {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: &PaymeRouterData<&PaymentsPreProcessingRouterData>,
) -> Result<Self, Self::Error> {
let sale_type = SaleType::try_from(item.router_data)?;
let seller_payme_id =
PaymeAuthType::try_from(&item.router_data.connector_auth_type)?.seller_payme_id;
let order_details = item.router_data.request.get_order_details()?;
let services = get_services(item.router_data);
let product_name = order_details
.first()
.ok_or_else(utils::missing_field_err("order_details"))?
.product_name
.clone();
let pmd = item
.router_data
.request
.payment_method_data
.to_owned()
.ok_or_else(utils::missing_field_err("payment_method_data"))?;
Ok(Self {
seller_payme_id,
sale_price: item.amount.to_owned(),
currency: item.router_data.request.get_currency()?,
product_name,
sale_payment_method: SalePaymentMethod::try_from(&pmd)?,
sale_type,
transaction_id: item.router_data.payment_id.clone(),
sale_return_url: item.router_data.request.get_router_return_url()?,
sale_callback_url: item.router_data.request.get_webhook_url()?,
language: LANGUAGE.to_string(),
services,
})
}
}
impl TryFrom<&PaymentMethodData> for SalePaymentMethod {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(item: &PaymentMethodData) -> Result<Self, Self::Error> {
match item {
PaymentMethodData::Card(_) => Ok(Self::CreditCard),
PaymentMethodData::Wallet(wallet_data) => match wallet_data {
WalletData::ApplePayThirdPartySdk(_) => Ok(Self::ApplePay),
WalletData::AliPayQr(_)
| WalletData::AliPayRedirect(_)
| WalletData::BluecodeRedirect {}
| WalletData::AliPayHkRedirect(_)
| WalletData::AmazonPay(_)
| WalletData::AmazonPayRedirect(_)
| WalletData::Paysera(_)
| WalletData::Skrill(_)
| WalletData::MomoRedirect(_)
| WalletData::KakaoPayRedirect(_)
| WalletData::GoPayRedirect(_)
| WalletData::GcashRedirect(_)
| WalletData::ApplePayRedirect(_)
| WalletData::DanaRedirect {}
| WalletData::GooglePay(_)
| WalletData::GooglePayRedirect(_)
| WalletData::GooglePayThirdPartySdk(_)
| WalletData::MbWayRedirect(_)
| WalletData::MobilePayRedirect(_)
| WalletData::PaypalRedirect(_)
| WalletData::PaypalSdk(_)
| WalletData::Paze(_)
| WalletData::SamsungPay(_)
| WalletData::TwintRedirect {}
| WalletData::VippsRedirect {}
| WalletData::TouchNGoRedirect(_)
| WalletData::WeChatPayRedirect(_)
| WalletData::WeChatPayQr(_)
| WalletData::CashappQr(_)
| WalletData::ApplePay(_)
| WalletData::SwishQr(_)
| WalletData::Mifinity(_)
| WalletData::RevolutPay(_) => Err(errors::ConnectorError::NotSupported {
message: "Wallet".to_string(),
connector: "payme",
}
.into()),
},
PaymentMethodData::PayLater(_)
| PaymentMethodData::BankRedirect(_)
| PaymentMethodData::BankDebit(_)
| PaymentMethodData::BankTransfer(_)
| PaymentMethodData::Crypto(_)
| PaymentMethodData::MandatePayment
| PaymentMethodData::Reward
| PaymentMethodData::RealTimePayment(_)
| PaymentMethodData::MobilePayment(_)
| PaymentMethodData::GiftCard(_)
| PaymentMethodData::CardRedirect(_)
| PaymentMethodData::Upi(_)
| PaymentMethodData::Voucher(_)
| PaymentMethodData::OpenBanking(_)
| PaymentMethodData::CardToken(_)
| PaymentMethodData::NetworkToken(_)
| PaymentMethodData::CardDetailsForNetworkTransactionId(_) => {
Err(errors::ConnectorError::NotImplemented("Payment methods".to_string()).into())
}
}
}
}
impl TryFrom<&PaymeRouterData<&PaymentsAuthorizeRouterData>> for PaymePaymentRequest {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
value: &PaymeRouterData<&PaymentsAuthorizeRouterData>,
) -> Result<Self, Self::Error> {
let payme_request = if value.router_data.request.mandate_id.is_some() {
Self::MandateRequest(MandateRequest::try_from(value)?)
} else {
Self::PayRequest(PayRequest::try_from(value.router_data)?)
};
Ok(payme_request)
}
}
impl TryFrom<&PaymentsSyncRouterData> for PaymeQuerySaleRequest {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(value: &PaymentsSyncRouterData) -> Result<Self, Self::Error> {
let seller_payme_id = PaymeAuthType::try_from(&value.connector_auth_type)?.seller_payme_id;
Ok(Self {
sale_payme_id: value.request.get_connector_transaction_id()?,
seller_payme_id,
})
}
}
impl TryFrom<&RefundSyncRouterData> for PaymeQueryTransactionRequest {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(value: &RefundSyncRouterData) -> Result<Self, Self::Error> {
let seller_payme_id = PaymeAuthType::try_from(&value.connector_auth_type)?.seller_payme_id;
Ok(Self {
payme_transaction_id: value
.request
.connector_refund_id
.clone()
.ok_or(errors::ConnectorError::MissingConnectorRefundID)?,
seller_payme_id,
})
}
}
impl<F>
utils::ForeignTryFrom<(
ResponseRouterData<
F,
GenerateSaleResponse,
PaymentsPreProcessingData,
PaymentsResponseData,
>,
StringMajorUnit,
)> for RouterData<F, PaymentsPreProcessingData, PaymentsResponseData>
{
type Error = error_stack::Report<errors::ConnectorError>;
fn foreign_try_from(
(item, apple_pay_amount): (
ResponseRouterData<
F,
GenerateSaleResponse,
PaymentsPreProcessingData,
PaymentsResponseData,
>,
StringMajorUnit,
),
) -> Result<Self, Self::Error> {
match item.data.payment_method {
PaymentMethod::Card => {
match item.data.auth_type {
AuthenticationType::NoThreeDs => {
Ok(Self {
// We don't get any status from payme, so defaulting it to pending
// then move to authorize flow
status: enums::AttemptStatus::Pending,
preprocessing_id: Some(item.response.payme_sale_id.to_owned()),
response: Ok(PaymentsResponseData::PreProcessingResponse {
pre_processing_id: PreprocessingResponseId::ConnectorTransactionId(
item.response.payme_sale_id,
),
connector_metadata: None,
session_token: None,
connector_response_reference_id: None,
}),
..item.data
})
}
AuthenticationType::ThreeDs => Ok(Self {
// We don't go to authorize flow in 3ds,
// Response is send directly after preprocessing flow
// redirection data is send to run script along
// status is made authentication_pending to show redirection
status: enums::AttemptStatus::AuthenticationPending,
preprocessing_id: Some(item.response.payme_sale_id.to_owned()),
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(
item.response.payme_sale_id.to_owned(),
),
redirection_data: Box::new(Some(RedirectForm::Payme)),
mandate_reference: Box::new(None),
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: None,
incremental_authorization_allowed: None,
charges: None,
}),
..item.data
}),
}
}
_ => {
let currency_code = item.data.request.get_currency()?;
let pmd = item.data.request.payment_method_data.to_owned();
let payme_auth_type = PaymeAuthType::try_from(&item.data.connector_auth_type)?;
let session_token = match pmd {
Some(PaymentMethodData::Wallet(WalletData::ApplePayThirdPartySdk(
_,
))) => Some(api_models::payments::SessionToken::ApplePay(Box::new(
api_models::payments::ApplepaySessionTokenResponse {
session_token_data: Some(
api_models::payments::ApplePaySessionResponse::NoSessionResponse(api_models::payments::NullObject),
),
payment_request_data: Some(
api_models::payments::ApplePayPaymentRequest {
country_code: item.data.get_billing_country()?,
currency_code,
total: api_models::payments::AmountInfo {
label: "Apple Pay".to_string(),
total_type: None,
amount: apple_pay_amount,
},
merchant_capabilities: None,
supported_networks: None,
merchant_identifier: None,
required_billing_contact_fields: None,
required_shipping_contact_fields: None,
recurring_payment_request: None,
},
),
connector: "payme".to_string(),
delayed_session_token: true,
sdk_next_action: api_models::payments::SdkNextAction {
next_action: api_models::payments::NextActionCall::Sync,
},
connector_reference_id: Some(item.response.payme_sale_id.to_owned()),
connector_sdk_public_key: Some(
payme_auth_type.payme_public_key.expose(),
),
connector_merchant_id: payme_auth_type
.payme_merchant_id
.map(|mid| mid.expose()),
},
))),
_ => None,
};
Ok(Self {
// We don't get any status from payme, so defaulting it to pending
status: enums::AttemptStatus::Pending,
preprocessing_id: Some(item.response.payme_sale_id.to_owned()),
response: Ok(PaymentsResponseData::PreProcessingResponse {
pre_processing_id: PreprocessingResponseId::ConnectorTransactionId(
item.response.payme_sale_id,
),
connector_metadata: None,
session_token,
connector_response_reference_id: None,
}),
..item.data
})
}
}
}
}
impl TryFrom<&PaymeRouterData<&PaymentsAuthorizeRouterData>> for MandateRequest {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(item: &PaymeRouterData<&PaymentsAuthorizeRouterData>) -> Result<Self, Self::Error> {
let seller_payme_id =
PaymeAuthType::try_from(&item.router_data.connector_auth_type)?.seller_payme_id;
let order_details = item.router_data.request.get_order_details()?;
let product_name = order_details
.first()
.ok_or_else(utils::missing_field_err("order_details"))?
.product_name
.clone();
Ok(Self {
currency: item.router_data.request.currency,
sale_price: item.amount.to_owned(),
transaction_id: item.router_data.payment_id.clone(),
product_name,
sale_return_url: item.router_data.request.get_router_return_url()?,
seller_payme_id,
sale_callback_url: item.router_data.request.get_webhook_url()?,
buyer_key: Secret::new(item.router_data.request.get_connector_mandate_id()?),
language: LANGUAGE.to_string(),
})
}
}
impl TryFrom<&PaymentsAuthorizeRouterData> for PayRequest {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(item: &PaymentsAuthorizeRouterData) -> Result<Self, Self::Error> {
match item.request.payment_method_data.clone() {
PaymentMethodData::Card(req_card) => {
let card = PaymeCard {
credit_card_cvv: req_card.card_cvc.clone(),
credit_card_exp: req_card
.get_card_expiry_month_year_2_digit_with_delimiter("".to_string())?,
credit_card_number: req_card.card_number,
};
let buyer_email = item.request.get_email()?;
let buyer_name = item.get_billing_address()?.get_full_name()?;
let payme_sale_id = item.preprocessing_id.to_owned().ok_or(
errors::ConnectorError::MissingConnectorRelatedTransactionID {
id: "payme_sale_id".to_string(),
},
)?;
Ok(Self {
card,
buyer_email,
buyer_name,
payme_sale_id,
language: LANGUAGE.to_string(),
})
}
PaymentMethodData::CardRedirect(_)
| PaymentMethodData::Wallet(_)
| PaymentMethodData::PayLater(_)
| PaymentMethodData::BankRedirect(_)
| PaymentMethodData::BankDebit(_)
| PaymentMethodData::BankTransfer(_)
| PaymentMethodData::Crypto(_)
| PaymentMethodData::MandatePayment
| PaymentMethodData::Reward
| PaymentMethodData::RealTimePayment(_)
| PaymentMethodData::MobilePayment(_)
| PaymentMethodData::Upi(_)
| PaymentMethodData::Voucher(_)
| PaymentMethodData::GiftCard(_)
| PaymentMethodData::OpenBanking(_)
| PaymentMethodData::CardToken(_)
| PaymentMethodData::NetworkToken(_)
| PaymentMethodData::CardDetailsForNetworkTransactionId(_) => {
Err(errors::ConnectorError::NotImplemented(
utils::get_unimplemented_payment_method_error_message("payme"),
))?
}
}
}
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct PaymeRedirectResponseData {
meta_data: String,
}
impl TryFrom<&PaymentsCompleteAuthorizeRouterData> for Pay3dsRequest {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(item: &PaymentsCompleteAuthorizeRouterData) -> Result<Self, Self::Error> {
match item.request.payment_method_data.clone() {
Some(PaymentMethodData::Card(_)) => {
let buyer_email = item.request.get_email()?;
let buyer_name = item.get_billing_address()?.get_full_name()?;
let payload_data = item.request.get_redirect_response_payload()?.expose();
let jwt_data: PaymeRedirectResponseData = serde_json::from_value(payload_data)
.change_context(errors::ConnectorError::MissingConnectorRedirectionPayload {
field_name: "meta_data_jwt",
})?;
let payme_sale_id = item
.request
.connector_transaction_id
.clone()
.ok_or(errors::ConnectorError::MissingConnectorTransactionID)?;
let pm_token = item.get_payment_method_token()?;
let buyer_key =
match pm_token {
PaymentMethodToken::Token(token) => token,
PaymentMethodToken::ApplePayDecrypt(_) => Err(
unimplemented_payment_method!("Apple Pay", "Simplified", "Payme"),
)?,
PaymentMethodToken::PazeDecrypt(_) => {
Err(unimplemented_payment_method!("Paze", "Payme"))?
}
PaymentMethodToken::GooglePayDecrypt(_) => {
Err(unimplemented_payment_method!("Google Pay", "Payme"))?
}
};
Ok(Self {
buyer_email,
buyer_key,
buyer_name,
payme_sale_id,
meta_data_jwt: Secret::new(jwt_data.meta_data),
})
}
Some(PaymentMethodData::CardRedirect(_))
| Some(PaymentMethodData::Wallet(_))
| Some(PaymentMethodData::PayLater(_))
| Some(PaymentMethodData::BankRedirect(_))
| Some(PaymentMethodData::BankDebit(_))
| Some(PaymentMethodData::BankTransfer(_))
| Some(PaymentMethodData::Crypto(_))
| Some(PaymentMethodData::MandatePayment)
| Some(PaymentMethodData::Reward)
| Some(PaymentMethodData::RealTimePayment(_))
| Some(PaymentMethodData::MobilePayment(_))
| Some(PaymentMethodData::Upi(_))
| Some(PaymentMethodData::Voucher(_))
| Some(PaymentMethodData::GiftCard(_))
| Some(PaymentMethodData::OpenBanking(_))
| Some(PaymentMethodData::CardToken(_))
| Some(PaymentMethodData::NetworkToken(_))
| Some(PaymentMethodData::CardDetailsForNetworkTransactionId(_))
| None => {
Err(errors::ConnectorError::NotImplemented("Tokenize Flow".to_string()).into())
}
}
}
}
impl TryFrom<&TokenizationRouterData> for CaptureBuyerRequest {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(item: &TokenizationRouterData) -> Result<Self, Self::Error> {
match item.request.payment_method_data.clone() {
PaymentMethodData::Card(req_card) => {
let seller_payme_id =
PaymeAuthType::try_from(&item.connector_auth_type)?.seller_payme_id;
let card = PaymeCard {
credit_card_cvv: req_card.card_cvc.clone(),
credit_card_exp: req_card
.get_card_expiry_month_year_2_digit_with_delimiter("".to_string())?,
credit_card_number: req_card.card_number,
};
Ok(Self {
card,
seller_payme_id,
})
}
PaymentMethodData::Wallet(_)
| PaymentMethodData::CardRedirect(_)
| PaymentMethodData::PayLater(_)
| PaymentMethodData::BankRedirect(_)
| PaymentMethodData::BankDebit(_)
| PaymentMethodData::BankTransfer(_)
| PaymentMethodData::Crypto(_)
| PaymentMethodData::MandatePayment
| PaymentMethodData::Reward
| PaymentMethodData::RealTimePayment(_)
| PaymentMethodData::MobilePayment(_)
| PaymentMethodData::Upi(_)
| PaymentMethodData::Voucher(_)
| PaymentMethodData::GiftCard(_)
| PaymentMethodData::OpenBanking(_)
| PaymentMethodData::CardToken(_)
| PaymentMethodData::NetworkToken(_)
| PaymentMethodData::CardDetailsForNetworkTransactionId(_) => {
Err(errors::ConnectorError::NotImplemented("Tokenize Flow".to_string()).into())
}
}
}
}
// Auth Struct
pub struct PaymeAuthType {
#[allow(dead_code)]
pub(super) payme_public_key: Secret<String>,
pub(super) seller_payme_id: Secret<String>,
pub(super) payme_merchant_id: Option<Secret<String>>,
}
impl TryFrom<&ConnectorAuthType> for PaymeAuthType {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(auth_type: &ConnectorAuthType) -> Result<Self, Self::Error> {
match auth_type {
ConnectorAuthType::BodyKey { api_key, key1 } => Ok(Self {
seller_payme_id: api_key.to_owned(),
payme_public_key: key1.to_owned(),
payme_merchant_id: None,
}),
ConnectorAuthType::SignatureKey {
api_key,
key1,
api_secret,
} => Ok(Self {
seller_payme_id: api_key.to_owned(),
payme_public_key: key1.to_owned(),
payme_merchant_id: Some(api_secret.to_owned()),
}),
_ => Err(errors::ConnectorError::FailedToObtainAuthType.into()),
}
}
}
impl TryFrom<&PaymentsPreProcessingRouterData> for SaleType {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(value: &PaymentsPreProcessingRouterData) -> Result<Self, Self::Error> {
let sale_type = if value.request.setup_mandate_details.is_some() {
// First mandate
Self::Token
} else {
// Normal payments
match value.request.is_auto_capture()? {
true => Self::Sale,
false => Self::Authorize,
}
};
Ok(sale_type)
}
}
#[derive(Clone, Debug, Serialize, Deserialize, PartialEq, Eq, strum::Display)]
#[serde(rename_all = "kebab-case")]
pub enum SaleStatus {
Initial,
Completed,
Refunded,
PartialRefund,
Authorized,
Voided,
PartialVoid,
Failed,
Chargeback,
}
impl From<SaleStatus> for enums::AttemptStatus {
fn from(item: SaleStatus) -> Self {
match item {
SaleStatus::Initial => Self::Authorizing,
SaleStatus::Completed => Self::Charged,
SaleStatus::Refunded | SaleStatus::PartialRefund => Self::AutoRefunded,
SaleStatus::Authorized => Self::Authorized,
SaleStatus::Voided | SaleStatus::PartialVoid => Self::Voided,
SaleStatus::Failed => Self::Failure,
SaleStatus::Chargeback => Self::AutoRefunded,
}
}
}
#[derive(Debug, Deserialize, Serialize)]
#[serde(untagged)]
pub enum PaymePaymentsResponse {
PaymePaySaleResponse(PaymePaySaleResponse),
SaleQueryResponse(SaleQueryResponse),
}
#[derive(Clone, Debug, Deserialize, Serialize)]
pub struct SaleQueryResponse {
items: Vec<SaleQuery>,
}
#[derive(Clone, Debug, Deserialize, Serialize)]
pub struct SaleQuery {
sale_status: SaleStatus,
sale_payme_id: String,
sale_error_text: Option<String>,
sale_error_code: Option<String>,
}
#[derive(Debug, Serialize, Deserialize)]
pub struct PaymePaySaleResponse {
sale_status: SaleStatus,
payme_sale_id: String,
payme_transaction_id: Option<String>,
buyer_key: Option<Secret<String>>,
status_error_details: Option<String>,
status_error_code: Option<u32>,
sale_3ds: Option<bool>,
redirect_url: Option<Url>,
}
#[derive(Serialize, Deserialize)]
pub struct PaymeMetadata {
payme_transaction_id: Option<String>,
}
impl<F, T> TryFrom<ResponseRouterData<F, CaptureBuyerResponse, T, PaymentsResponseData>>
for RouterData<F, T, PaymentsResponseData>
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: ResponseRouterData<F, CaptureBuyerResponse, T, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
Ok(Self {
payment_method_token: Some(PaymentMethodToken::Token(item.response.buyer_key.clone())),
response: Ok(PaymentsResponseData::TokenizationResponse {
token: item.response.buyer_key.expose(),
}),
..item.data
})
}
}
#[derive(Debug, Serialize)]
pub struct PaymentCaptureRequest {
payme_sale_id: String,
sale_price: MinorUnit,
}
impl TryFrom<&PaymeRouterData<&PaymentsCaptureRouterData>> for PaymentCaptureRequest {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(item: &PaymeRouterData<&PaymentsCaptureRouterData>) -> Result<Self, Self::Error> {
if item.router_data.request.minor_amount_to_capture
!= item.router_data.request.minor_payment_amount
{
Err(errors::ConnectorError::NotSupported {
message: "Partial Capture".to_string(),
connector: "Payme",
})?
}
Ok(Self {
payme_sale_id: item.router_data.request.connector_transaction_id.clone(),
sale_price: item.amount,
})
}
}
// REFUND :
// Type definition for RefundRequest
#[derive(Debug, Serialize)]
pub struct PaymeRefundRequest {
sale_refund_amount: MinorUnit,
payme_sale_id: String,
seller_payme_id: Secret<String>,
language: String,
}
impl<F> TryFrom<&PaymeRouterData<&RefundsRouterData<F>>> for PaymeRefundRequest {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(item: &PaymeRouterData<&RefundsRouterData<F>>) -> Result<Self, Self::Error> {
let auth_type = PaymeAuthType::try_from(&item.router_data.connector_auth_type)?;
Ok(Self {
payme_sale_id: item.router_data.request.connector_transaction_id.clone(),
seller_payme_id: auth_type.seller_payme_id,
sale_refund_amount: item.amount.to_owned(),
language: LANGUAGE.to_string(),
})
}
}
impl TryFrom<SaleStatus> for enums::RefundStatus {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(sale_status: SaleStatus) -> Result<Self, Self::Error> {
match sale_status {
SaleStatus::Refunded | SaleStatus::PartialRefund => Ok(Self::Success),
SaleStatus::Failed => Ok(Self::Failure),
SaleStatus::Initial
| SaleStatus::Completed
| SaleStatus::Authorized
| SaleStatus::Voided
| SaleStatus::PartialVoid
| SaleStatus::Chargeback => Err(errors::ConnectorError::ResponseHandlingFailed)?,
}
}
}
#[derive(Debug, Deserialize, Serialize)]
pub struct PaymeRefundResponse {
sale_status: SaleStatus,
payme_transaction_id: Option<String>,
status_error_code: Option<u32>,
}
impl TryFrom<RefundsResponseRouterData<Execute, PaymeRefundResponse>>
for RefundsRouterData<Execute>
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: RefundsResponseRouterData<Execute, PaymeRefundResponse>,
) -> Result<Self, Self::Error> {
let refund_status = enums::RefundStatus::try_from(item.response.sale_status.clone())?;
let response = if utils::is_refund_failure(refund_status) {
let payme_response = &item.response;
let status_error_code = payme_response
.status_error_code
.map(|error_code| error_code.to_string());
Err(ErrorResponse {
code: status_error_code
.clone()
.unwrap_or_else(|| consts::NO_ERROR_CODE.to_string()),
message: status_error_code
.clone()
.unwrap_or_else(|| consts::NO_ERROR_MESSAGE.to_string()),
reason: status_error_code,
status_code: item.http_code,
attempt_status: None,
connector_transaction_id: payme_response.payme_transaction_id.clone(),
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
connector_metadata: None,
})
} else {
Ok(RefundsResponseData {
connector_refund_id: item
.response
.payme_transaction_id
.ok_or(errors::ConnectorError::MissingConnectorRefundID)?,
refund_status,
})
};
Ok(Self {
response,
..item.data
})
}
}
#[derive(Debug, Serialize)]
pub struct PaymeVoidRequest {
sale_currency: enums::Currency,
payme_sale_id: String,
seller_payme_id: Secret<String>,
language: String,
}
impl TryFrom<&PaymeRouterData<&RouterData<Void, PaymentsCancelData, PaymentsResponseData>>>
for PaymeVoidRequest
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: &PaymeRouterData<&RouterData<Void, PaymentsCancelData, PaymentsResponseData>>,
) -> Result<Self, Self::Error> {
let auth_type = PaymeAuthType::try_from(&item.router_data.connector_auth_type)?;
Ok(Self {
payme_sale_id: item.router_data.request.connector_transaction_id.clone(),
seller_payme_id: auth_type.seller_payme_id,
sale_currency: item.router_data.request.get_currency()?,
language: LANGUAGE.to_string(),
})
}
}
#[derive(Debug, Deserialize, Serialize)]
pub struct PaymeVoidResponse {
sale_status: SaleStatus,
payme_transaction_id: Option<String>,
status_error_code: Option<u32>,
}
impl TryFrom<PaymentsCancelResponseRouterData<PaymeVoidResponse>> for PaymentsCancelRouterData {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: PaymentsCancelResponseRouterData<PaymeVoidResponse>,
) -> Result<Self, Self::Error> {
let status = enums::AttemptStatus::from(item.response.sale_status.clone());
let response = if utils::is_payment_failure(status) {
let payme_response = &item.response;
let status_error_code = payme_response
.status_error_code
.map(|error_code| error_code.to_string());
Err(ErrorResponse {
code: status_error_code
.clone()
.unwrap_or_else(|| consts::NO_ERROR_CODE.to_string()),
message: status_error_code
.clone()
.unwrap_or_else(|| consts::NO_ERROR_MESSAGE.to_string()),
reason: status_error_code,
status_code: item.http_code,
attempt_status: None,
connector_transaction_id: payme_response.payme_transaction_id.clone(),
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
connector_metadata: None,
})
} else {
// Since we are not receiving payme_sale_id, we are not populating the transaction response
Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::NoResponseId,
redirection_data: Box::new(None),
mandate_reference: Box::new(None),
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: None,
incremental_authorization_allowed: None,
charges: None,
})
};
Ok(Self {
status,
response,
..item.data
})
}
}
#[derive(Debug, Serialize, Deserialize)]
pub struct PaymeQueryTransactionResponse {
items: Vec<TransactionQuery>,
}
#[derive(Clone, Debug, Serialize, Deserialize)]
pub struct TransactionQuery {
sale_status: SaleStatus,
payme_transaction_id: String,
}
impl<F, T> TryFrom<ResponseRouterData<F, PaymeQueryTransactionResponse, T, RefundsResponseData>>
for RouterData<F, T, RefundsResponseData>
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: ResponseRouterData<F, PaymeQueryTransactionResponse, T, RefundsResponseData>,
) -> Result<Self, Self::Error> {
let pay_sale_response = item
.response
.items
.first()
.ok_or(errors::ConnectorError::ResponseHandlingFailed)?;
let refund_status = enums::RefundStatus::try_from(pay_sale_response.sale_status.clone())?;
let response = if utils::is_refund_failure(refund_status) {
Err(ErrorResponse {
code: consts::NO_ERROR_CODE.to_string(),
message: consts::NO_ERROR_CODE.to_string(),
reason: None,
status_code: item.http_code,
attempt_status: None,
connector_transaction_id: Some(pay_sale_response.payme_transaction_id.clone()),
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
connector_metadata: None,
})
} else {
Ok(RefundsResponseData {
refund_status,
connector_refund_id: pay_sale_response.payme_transaction_id.clone(),
})
};
Ok(Self {
response,
..item.data
})
}
}
fn get_services(item: &PaymentsPreProcessingRouterData) -> Option<ThreeDs> {
match item.auth_type {
AuthenticationType::ThreeDs => {
let settings = ThreeDsSettings { active: true };
Some(ThreeDs {
name: ThreeDsType::ThreeDs,
settings,
})
}
AuthenticationType::NoThreeDs => None,
}
}
#[derive(Default, Debug, Serialize, Deserialize, PartialEq)]
pub struct PaymeErrorResponse {
pub status_code: u16,
pub status_error_details: String,
pub status_additional_info: serde_json::Value,
pub status_error_code: u32,
}
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "kebab-case")]
pub enum NotifyType {
SaleComplete,
SaleAuthorized,
Refund,
SaleFailure,
SaleChargeback,
SaleChargebackRefund,
}
#[derive(Debug, Serialize, Deserialize)]
pub struct WebhookEventDataResource {
pub sale_status: SaleStatus,
pub payme_signature: Secret<String>,
pub buyer_key: Option<Secret<String>>,
pub notify_type: NotifyType,
pub payme_sale_id: String,
pub payme_transaction_id: String,
pub status_error_details: Option<String>,
pub status_error_code: Option<u32>,
pub price: MinorUnit,
pub currency: enums::Currency,
}
#[derive(Debug, Deserialize)]
pub struct WebhookEventDataResourceEvent {
pub notify_type: NotifyType,
}
#[derive(Debug, Deserialize)]
pub struct WebhookEventDataResourceSignature {
pub payme_signature: Secret<String>,
}
/// This try_from will ensure that webhook body would be properly parsed into PSync response
impl From<WebhookEventDataResource> for PaymePaySaleResponse {
fn from(value: WebhookEventDataResource) -> Self {
Self {
sale_status: value.sale_status,
payme_sale_id: value.payme_sale_id,
payme_transaction_id: Some(value.payme_transaction_id),
buyer_key: value.buyer_key,
sale_3ds: None,
redirect_url: None,
status_error_code: value.status_error_code,
status_error_details: value.status_error_details,
}
}
}
/// This try_from will ensure that webhook body would be properly parsed into RSync response
impl From<WebhookEventDataResource> for PaymeQueryTransactionResponse {
fn from(value: WebhookEventDataResource) -> Self {
let item = TransactionQuery {
sale_status: value.sale_status,
payme_transaction_id: value.payme_transaction_id,
};
Self { items: vec![item] }
}
}
impl From<NotifyType> for api_models::webhooks::IncomingWebhookEvent {
fn from(value: NotifyType) -> Self {
match value {
NotifyType::SaleComplete => Self::PaymentIntentSuccess,
NotifyType::Refund => Self::RefundSuccess,
NotifyType::SaleFailure => Self::PaymentIntentFailure,
NotifyType::SaleChargeback => Self::DisputeOpened,
NotifyType::SaleChargebackRefund => Self::DisputeWon,
NotifyType::SaleAuthorized => Self::EventNotSupported,
}
}
}
|
{
"crate": "hyperswitch_connectors",
"file": "crates/hyperswitch_connectors/src/connectors/payme/transformers.rs",
"file_size": null,
"is_async": null,
"is_pub": null,
"num_enums": 7,
"num_structs": 29,
"num_tables": null,
"score": null,
"total_crates": null
}
|
file_hyperswitch_connectors_-285307583476984431
|
clm
|
file
|
// Repository: hyperswitch
// Crate: hyperswitch_connectors
// File: crates/hyperswitch_connectors/src/connectors/thunes/transformers.rs
// Contains: 6 structs, 2 enums
use common_enums::enums;
use common_utils::types::StringMinorUnit;
use hyperswitch_domain_models::{
payment_method_data::PaymentMethodData,
router_data::{ConnectorAuthType, RouterData},
router_flow_types::refunds::{Execute, RSync},
router_request_types::ResponseId,
router_response_types::{PaymentsResponseData, RefundsResponseData},
types::{PaymentsAuthorizeRouterData, RefundsRouterData},
};
use hyperswitch_interfaces::errors;
use masking::Secret;
use serde::{Deserialize, Serialize};
use crate::{
types::{RefundsResponseRouterData, ResponseRouterData},
utils::PaymentsAuthorizeRequestData,
};
//TODO: Fill the struct with respective fields
pub struct ThunesRouterData<T> {
pub amount: StringMinorUnit, // The type of amount that a connector accepts, for example, String, i64, f64, etc.
pub router_data: T,
}
impl<T> From<(StringMinorUnit, T)> for ThunesRouterData<T> {
fn from((amount, item): (StringMinorUnit, T)) -> Self {
//Todo : use utils to convert the amount to the type of amount that a connector accepts
Self {
amount,
router_data: item,
}
}
}
//TODO: Fill the struct with respective fields
#[derive(Default, Debug, Serialize, PartialEq)]
pub struct ThunesPaymentsRequest {
amount: StringMinorUnit,
card: ThunesCard,
}
#[derive(Default, Debug, Serialize, Eq, PartialEq)]
pub struct ThunesCard {
number: cards::CardNumber,
expiry_month: Secret<String>,
expiry_year: Secret<String>,
cvc: Secret<String>,
complete: bool,
}
impl TryFrom<&ThunesRouterData<&PaymentsAuthorizeRouterData>> for ThunesPaymentsRequest {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: &ThunesRouterData<&PaymentsAuthorizeRouterData>,
) -> Result<Self, Self::Error> {
match item.router_data.request.payment_method_data.clone() {
PaymentMethodData::Card(req_card) => {
let card = ThunesCard {
number: req_card.card_number,
expiry_month: req_card.card_exp_month,
expiry_year: req_card.card_exp_year,
cvc: req_card.card_cvc,
complete: item.router_data.request.is_auto_capture()?,
};
Ok(Self {
amount: item.amount.clone(),
card,
})
}
_ => Err(errors::ConnectorError::NotImplemented("Payment methods".to_string()).into()),
}
}
}
//TODO: Fill the struct with respective fields
// Auth Struct
pub struct ThunesAuthType {
pub(super) api_key: Secret<String>,
}
impl TryFrom<&ConnectorAuthType> for ThunesAuthType {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(auth_type: &ConnectorAuthType) -> Result<Self, Self::Error> {
match auth_type {
ConnectorAuthType::HeaderKey { api_key } => Ok(Self {
api_key: api_key.to_owned(),
}),
_ => Err(errors::ConnectorError::FailedToObtainAuthType.into()),
}
}
}
// PaymentsResponse
//TODO: Append the remaining status flags
#[derive(Debug, Clone, Default, Serialize, Deserialize, PartialEq)]
#[serde(rename_all = "lowercase")]
pub enum ThunesPaymentStatus {
Succeeded,
Failed,
#[default]
Processing,
}
impl From<ThunesPaymentStatus> for common_enums::AttemptStatus {
fn from(item: ThunesPaymentStatus) -> Self {
match item {
ThunesPaymentStatus::Succeeded => Self::Charged,
ThunesPaymentStatus::Failed => Self::Failure,
ThunesPaymentStatus::Processing => Self::Authorizing,
}
}
}
//TODO: Fill the struct with respective fields
#[derive(Default, Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct ThunesPaymentsResponse {
status: ThunesPaymentStatus,
id: String,
}
impl<F, T> TryFrom<ResponseRouterData<F, ThunesPaymentsResponse, T, PaymentsResponseData>>
for RouterData<F, T, PaymentsResponseData>
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: ResponseRouterData<F, ThunesPaymentsResponse, T, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
Ok(Self {
status: common_enums::AttemptStatus::from(item.response.status),
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(item.response.id),
redirection_data: Box::new(None),
mandate_reference: Box::new(None),
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: None,
incremental_authorization_allowed: None,
charges: None,
}),
..item.data
})
}
}
//TODO: Fill the struct with respective fields
// REFUND :
// Type definition for RefundRequest
#[derive(Default, Debug, Serialize)]
pub struct ThunesRefundRequest {
pub amount: StringMinorUnit,
}
impl<F> TryFrom<&ThunesRouterData<&RefundsRouterData<F>>> for ThunesRefundRequest {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(item: &ThunesRouterData<&RefundsRouterData<F>>) -> Result<Self, Self::Error> {
Ok(Self {
amount: item.amount.to_owned(),
})
}
}
// Type definition for Refund Response
#[allow(dead_code)]
#[derive(Debug, Serialize, Default, Deserialize, Clone)]
pub enum RefundStatus {
Succeeded,
Failed,
#[default]
Processing,
}
impl From<RefundStatus> for enums::RefundStatus {
fn from(item: RefundStatus) -> Self {
match item {
RefundStatus::Succeeded => Self::Success,
RefundStatus::Failed => Self::Failure,
RefundStatus::Processing => Self::Pending,
//TODO: Review mapping
}
}
}
//TODO: Fill the struct with respective fields
#[derive(Default, Debug, Clone, Serialize, Deserialize)]
pub struct RefundResponse {
id: String,
status: RefundStatus,
}
impl TryFrom<RefundsResponseRouterData<Execute, RefundResponse>> for RefundsRouterData<Execute> {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: RefundsResponseRouterData<Execute, RefundResponse>,
) -> Result<Self, Self::Error> {
Ok(Self {
response: Ok(RefundsResponseData {
connector_refund_id: item.response.id.to_string(),
refund_status: enums::RefundStatus::from(item.response.status),
}),
..item.data
})
}
}
impl TryFrom<RefundsResponseRouterData<RSync, RefundResponse>> for RefundsRouterData<RSync> {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: RefundsResponseRouterData<RSync, RefundResponse>,
) -> Result<Self, Self::Error> {
Ok(Self {
response: Ok(RefundsResponseData {
connector_refund_id: item.response.id.to_string(),
refund_status: enums::RefundStatus::from(item.response.status),
}),
..item.data
})
}
}
//TODO: Fill the struct with respective fields
#[derive(Default, Debug, Serialize, Deserialize, PartialEq)]
pub struct ThunesErrorResponse {
pub status_code: u16,
pub code: String,
pub message: String,
pub reason: Option<String>,
}
|
{
"crate": "hyperswitch_connectors",
"file": "crates/hyperswitch_connectors/src/connectors/thunes/transformers.rs",
"file_size": null,
"is_async": null,
"is_pub": null,
"num_enums": 2,
"num_structs": 6,
"num_tables": null,
"score": null,
"total_crates": null
}
|
file_hyperswitch_connectors_5315599256600975143
|
clm
|
file
|
// Repository: hyperswitch
// Crate: hyperswitch_connectors
// File: crates/hyperswitch_connectors/src/connectors/threedsecureio/transformers.rs
// Contains: 10 structs, 6 enums
use std::str::FromStr;
use api_models::payments::{DeviceChannel, ThreeDsCompletionIndicator};
use base64::Engine;
use common_enums::enums;
use common_utils::{consts::BASE64_ENGINE, date_time, ext_traits::OptionExt as _};
use error_stack::ResultExt;
use hyperswitch_domain_models::{
router_data::{ConnectorAuthType, ErrorResponse},
router_flow_types::authentication::{Authentication, PreAuthentication},
router_request_types::{
authentication::{
AuthNFlowType, ChallengeParams, ConnectorAuthenticationRequestData, MessageCategory,
PreAuthNRequestData,
},
BrowserInformation,
},
router_response_types::AuthenticationResponseData,
};
use hyperswitch_interfaces::{api::CurrencyUnit, consts::NO_ERROR_MESSAGE, errors};
use iso_currency::Currency;
use masking::{ExposeInterface, Secret};
use serde::{Deserialize, Serialize};
use serde_json::{json, to_string};
use crate::{
types::{ConnectorAuthenticationRouterData, PreAuthNRouterData, ResponseRouterData},
utils::{get_card_details, to_connector_meta, AddressDetailsData, CardData as _},
};
pub struct ThreedsecureioRouterData<T> {
pub amount: String,
pub router_data: T,
}
impl<T> TryFrom<(&CurrencyUnit, enums::Currency, i64, T)> for ThreedsecureioRouterData<T> {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
(_currency_unit, _currency, amount, item): (&CurrencyUnit, enums::Currency, i64, T),
) -> Result<Self, Self::Error> {
Ok(Self {
amount: amount.to_string(),
router_data: item,
})
}
}
impl<T> TryFrom<(i64, T)> for ThreedsecureioRouterData<T> {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from((amount, router_data): (i64, T)) -> Result<Self, Self::Error> {
Ok(Self {
amount: amount.to_string(),
router_data,
})
}
}
impl
TryFrom<
ResponseRouterData<
PreAuthentication,
ThreedsecureioPreAuthenticationResponse,
PreAuthNRequestData,
AuthenticationResponseData,
>,
> for PreAuthNRouterData
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: ResponseRouterData<
PreAuthentication,
ThreedsecureioPreAuthenticationResponse,
PreAuthNRequestData,
AuthenticationResponseData,
>,
) -> Result<Self, Self::Error> {
let response = match item.response {
ThreedsecureioPreAuthenticationResponse::Success(pre_authn_response) => {
let three_ds_method_data = json!({
"threeDSServerTransID": pre_authn_response.threeds_server_trans_id,
});
let three_ds_method_data_str = to_string(&three_ds_method_data)
.change_context(errors::ConnectorError::ResponseDeserializationFailed)
.attach_printable("error while constructing three_ds_method_data_str")?;
let three_ds_method_data_base64 = BASE64_ENGINE.encode(three_ds_method_data_str);
let connector_metadata = serde_json::json!(ThreeDSecureIoConnectorMetaData {
ds_start_protocol_version: pre_authn_response.ds_start_protocol_version,
ds_end_protocol_version: pre_authn_response.ds_end_protocol_version,
acs_start_protocol_version: pre_authn_response.acs_start_protocol_version,
acs_end_protocol_version: pre_authn_response.acs_end_protocol_version.clone(),
});
Ok(AuthenticationResponseData::PreAuthNResponse {
threeds_server_transaction_id: pre_authn_response
.threeds_server_trans_id
.clone(),
maximum_supported_3ds_version: common_utils::types::SemanticVersion::from_str(
&pre_authn_response.acs_end_protocol_version,
)
.change_context(errors::ConnectorError::ParsingFailed)?,
connector_authentication_id: pre_authn_response.threeds_server_trans_id,
three_ds_method_data: Some(three_ds_method_data_base64),
three_ds_method_url: pre_authn_response.threeds_method_url,
message_version: common_utils::types::SemanticVersion::from_str(
&pre_authn_response.acs_end_protocol_version,
)
.change_context(errors::ConnectorError::ParsingFailed)?,
connector_metadata: Some(connector_metadata),
directory_server_id: None,
})
}
ThreedsecureioPreAuthenticationResponse::Failure(error_response) => {
Err(ErrorResponse {
code: error_response.error_code,
message: error_response
.error_description
.clone()
.unwrap_or(NO_ERROR_MESSAGE.to_owned()),
reason: error_response.error_description,
status_code: item.http_code,
attempt_status: None,
connector_transaction_id: None,
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
connector_metadata: None,
})
}
};
Ok(Self {
response,
..item.data.clone()
})
}
}
impl
TryFrom<
ResponseRouterData<
Authentication,
ThreedsecureioAuthenticationResponse,
ConnectorAuthenticationRequestData,
AuthenticationResponseData,
>,
> for ConnectorAuthenticationRouterData
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: ResponseRouterData<
Authentication,
ThreedsecureioAuthenticationResponse,
ConnectorAuthenticationRequestData,
AuthenticationResponseData,
>,
) -> Result<Self, Self::Error> {
let response = match item.response {
ThreedsecureioAuthenticationResponse::Success(response) => {
let creq = serde_json::json!({
"threeDSServerTransID": response.three_dsserver_trans_id,
"acsTransID": response.acs_trans_id,
"messageVersion": response.message_version,
"messageType": "CReq",
"challengeWindowSize": "01",
});
let creq_str = to_string(&creq)
.change_context(errors::ConnectorError::ResponseDeserializationFailed)
.attach_printable("error while constructing creq_str")?;
let creq_base64 = Engine::encode(&BASE64_ENGINE, creq_str)
.trim_end_matches('=')
.to_owned();
Ok(AuthenticationResponseData::AuthNResponse {
trans_status: response.trans_status.clone().into(),
authn_flow_type: if response.trans_status == ThreedsecureioTransStatus::C {
AuthNFlowType::Challenge(Box::new(ChallengeParams {
acs_url: response.acs_url,
challenge_request: Some(creq_base64),
acs_reference_number: Some(response.acs_reference_number.clone()),
acs_trans_id: Some(response.acs_trans_id.clone()),
three_dsserver_trans_id: Some(response.three_dsserver_trans_id),
acs_signed_content: response.acs_signed_content,
challenge_request_key: None,
}))
} else {
AuthNFlowType::Frictionless
},
authentication_value: response.authentication_value,
connector_metadata: None,
ds_trans_id: Some(response.ds_trans_id),
eci: None,
challenge_code: None,
challenge_cancel: None,
challenge_code_reason: None,
message_extension: None,
})
}
ThreedsecureioAuthenticationResponse::Error(err_response) => match *err_response {
ThreedsecureioErrorResponseWrapper::ErrorResponse(resp) => Err(ErrorResponse {
code: resp.error_code,
message: resp
.error_description
.clone()
.unwrap_or(NO_ERROR_MESSAGE.to_owned()),
reason: resp.error_description,
status_code: item.http_code,
attempt_status: None,
connector_transaction_id: None,
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
connector_metadata: None,
}),
ThreedsecureioErrorResponseWrapper::ErrorString(error) => Err(ErrorResponse {
code: error.clone(),
message: error.clone(),
reason: Some(error),
status_code: item.http_code,
attempt_status: None,
connector_transaction_id: None,
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
connector_metadata: None,
}),
},
};
Ok(Self {
response,
..item.data.clone()
})
}
}
pub struct ThreedsecureioAuthType {
pub(super) api_key: Secret<String>,
}
impl TryFrom<&ConnectorAuthType> for ThreedsecureioAuthType {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(auth_type: &ConnectorAuthType) -> Result<Self, Self::Error> {
match auth_type {
ConnectorAuthType::HeaderKey { api_key } => Ok(Self {
api_key: api_key.to_owned(),
}),
_ => Err(errors::ConnectorError::FailedToObtainAuthType.into()),
}
}
}
impl TryFrom<&ThreedsecureioRouterData<&ConnectorAuthenticationRouterData>>
for ThreedsecureioAuthenticationRequest
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: &ThreedsecureioRouterData<&ConnectorAuthenticationRouterData>,
) -> Result<Self, Self::Error> {
let request = &item.router_data.request;
//browser_details are mandatory for Browser flows
let browser_details = match request.browser_details.clone() {
Some(details) => Ok::<Option<BrowserInformation>, Self::Error>(Some(details)),
None => {
if request.device_channel == DeviceChannel::Browser {
Err(errors::ConnectorError::MissingRequiredField {
field_name: "browser_info",
})?
} else {
Ok(None)
}
}
}?;
let card_details = get_card_details(request.payment_method_data.clone(), "threedsecureio")?;
let currency = request
.currency
.map(|currency| currency.to_string())
.ok_or(errors::ConnectorError::RequestEncodingFailed)
.attach_printable("missing field currency")?;
let purchase_currency: Currency = Currency::from_code(¤cy)
.ok_or(errors::ConnectorError::RequestEncodingFailed)
.attach_printable("error while parsing Currency")?;
let billing_address = request.billing_address.address.clone().ok_or(
errors::ConnectorError::MissingRequiredField {
field_name: "billing_address.address",
},
)?;
let billing_state = billing_address.clone().to_state_code()?;
let billing_country = isocountry::CountryCode::for_alpha2(
&billing_address
.country
.ok_or(errors::ConnectorError::MissingRequiredField {
field_name: "billing_address.address.country",
})?
.to_string(),
)
.change_context(errors::ConnectorError::RequestEncodingFailed)
.attach_printable("Error parsing billing_address.address.country")?;
let connector_meta_data: ThreeDSecureIoMetaData = item
.router_data
.connector_meta_data
.clone()
.parse_value("ThreeDSecureIoMetaData")
.change_context(errors::ConnectorError::RequestEncodingFailed)?;
let pre_authentication_data = &request.pre_authentication_data;
let sdk_information = match request.device_channel {
DeviceChannel::App => Some(item.router_data.request.sdk_information.clone().ok_or(
errors::ConnectorError::MissingRequiredField {
field_name: "sdk_information",
},
)?),
DeviceChannel::Browser => None,
};
let (acquirer_bin, acquirer_merchant_id) = pre_authentication_data
.acquirer_bin
.clone()
.zip(pre_authentication_data.acquirer_merchant_id.clone())
.get_required_value("acquirer_details")
.change_context(errors::ConnectorError::MissingRequiredField {
field_name: "acquirer_details",
})?;
let meta: ThreeDSecureIoConnectorMetaData =
to_connector_meta(request.pre_authentication_data.connector_metadata.clone())?;
let card_holder_name = billing_address.get_optional_full_name();
Ok(Self {
ds_start_protocol_version: meta.ds_start_protocol_version.clone(),
ds_end_protocol_version: meta.ds_end_protocol_version.clone(),
acs_start_protocol_version: meta.acs_start_protocol_version.clone(),
acs_end_protocol_version: meta.acs_end_protocol_version.clone(),
three_dsserver_trans_id: pre_authentication_data
.threeds_server_transaction_id
.clone(),
acct_number: card_details.card_number.clone(),
notification_url: request
.return_url
.clone()
.ok_or(errors::ConnectorError::RequestEncodingFailed)
.attach_printable("missing return_url")?,
three_dscomp_ind: ThreeDSecureIoThreeDsCompletionIndicator::from(
request.threeds_method_comp_ind.clone(),
),
three_dsrequestor_url: request.three_ds_requestor_url.clone(),
acquirer_bin,
acquirer_merchant_id,
card_expiry_date: card_details.get_expiry_date_as_yymm()?.expose(),
bill_addr_city: billing_address
.city
.clone()
.ok_or(errors::ConnectorError::MissingRequiredField {
field_name: "billing_address.address.city",
})?
.to_string(),
bill_addr_country: billing_country.numeric_id().to_string().into(),
bill_addr_line1: billing_address.line1.clone().ok_or(
errors::ConnectorError::MissingRequiredField {
field_name: "billing_address.address.line1",
},
)?,
bill_addr_post_code: billing_address.zip.clone().ok_or(
errors::ConnectorError::MissingRequiredField {
field_name: "billing_address.address.zip",
},
)?,
bill_addr_state: billing_state,
// Indicates the type of Authentication request, "01" for Payment transaction
three_dsrequestor_authentication_ind: "01".to_string(),
device_channel: match item.router_data.request.device_channel.clone() {
DeviceChannel::App => "01",
DeviceChannel::Browser => "02",
}
.to_string(),
message_category: match item.router_data.request.message_category.clone() {
MessageCategory::Payment => "01",
MessageCategory::NonPayment => "02",
}
.to_string(),
browser_javascript_enabled: browser_details
.as_ref()
.and_then(|details| details.java_script_enabled),
browser_accept_header: browser_details
.as_ref()
.and_then(|details| details.accept_header.clone()),
browser_ip: browser_details
.clone()
.and_then(|details| details.ip_address.map(|ip| Secret::new(ip.to_string()))),
browser_java_enabled: browser_details
.as_ref()
.and_then(|details| details.java_enabled),
browser_language: browser_details
.as_ref()
.and_then(|details| details.language.clone()),
browser_color_depth: browser_details
.as_ref()
.and_then(|details| details.color_depth.map(|a| a.to_string())),
browser_screen_height: browser_details
.as_ref()
.and_then(|details| details.screen_height.map(|a| a.to_string())),
browser_screen_width: browser_details
.as_ref()
.and_then(|details| details.screen_width.map(|a| a.to_string())),
browser_tz: browser_details
.as_ref()
.and_then(|details| details.time_zone.map(|a| a.to_string())),
browser_user_agent: browser_details
.as_ref()
.and_then(|details| details.user_agent.clone().map(|a| a.to_string())),
mcc: connector_meta_data.mcc,
merchant_country_code: connector_meta_data.merchant_country_code,
merchant_name: connector_meta_data.merchant_name,
message_type: "AReq".to_string(),
message_version: pre_authentication_data.message_version.to_string(),
purchase_amount: item.amount.clone(),
purchase_currency: purchase_currency.numeric().to_string(),
trans_type: "01".to_string(),
purchase_exponent: purchase_currency
.exponent()
.ok_or(errors::ConnectorError::RequestEncodingFailed)
.attach_printable("missing purchase_exponent")?
.to_string(),
purchase_date: date_time::DateTime::<date_time::YYYYMMDDHHmmss>::from(date_time::now())
.to_string(),
sdk_app_id: sdk_information
.as_ref()
.map(|sdk_info| sdk_info.sdk_app_id.clone()),
sdk_enc_data: sdk_information
.as_ref()
.map(|sdk_info| sdk_info.sdk_enc_data.clone()),
sdk_ephem_pub_key: sdk_information
.as_ref()
.map(|sdk_info| sdk_info.sdk_ephem_pub_key.clone()),
sdk_reference_number: sdk_information
.as_ref()
.map(|sdk_info| sdk_info.sdk_reference_number.clone()),
sdk_trans_id: sdk_information
.as_ref()
.map(|sdk_info| sdk_info.sdk_trans_id.clone()),
sdk_max_timeout: sdk_information
.as_ref()
.map(|sdk_info| sdk_info.sdk_max_timeout.to_string()),
device_render_options: match request.device_channel {
DeviceChannel::App => Some(DeviceRenderOptions {
// SDK Interface types that the device supports for displaying specific challenge user interfaces within the SDK, 01 for Native
sdk_interface: "01".to_string(),
// UI types that the device supports for displaying specific challenge user interfaces within the SDK, 01 for Text
sdk_ui_type: vec!["01".to_string()],
}),
DeviceChannel::Browser => None,
},
cardholder_name: card_holder_name,
email: request.email.clone(),
})
}
}
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ThreedsecureioErrorResponse {
pub error_code: String,
pub error_component: Option<String>,
pub error_description: Option<String>,
pub error_detail: Option<String>,
pub error_message_type: Option<String>,
pub message_type: Option<String>,
pub message_version: Option<String>,
pub three_dsserver_trans_id: Option<String>,
}
#[derive(Debug, Deserialize, Serialize)]
#[serde(untagged)]
pub enum ThreedsecureioErrorResponseWrapper {
ErrorResponse(ThreedsecureioErrorResponse),
ErrorString(String),
}
#[derive(Debug, Serialize, Deserialize)]
#[serde(untagged)]
pub enum ThreedsecureioAuthenticationResponse {
Success(Box<ThreedsecureioAuthenticationSuccessResponse>),
Error(Box<ThreedsecureioErrorResponseWrapper>),
}
#[derive(Debug, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ThreedsecureioAuthenticationSuccessResponse {
#[serde(rename = "acsChallengeMandated")]
pub acs_challenge_mandated: Option<String>,
#[serde(rename = "acsOperatorID")]
pub acs_operator_id: Option<String>,
#[serde(rename = "acsReferenceNumber")]
pub acs_reference_number: String,
#[serde(rename = "acsTransID")]
pub acs_trans_id: String,
#[serde(rename = "acsURL")]
pub acs_url: Option<url::Url>,
#[serde(rename = "authenticationType")]
pub authentication_type: Option<String>,
#[serde(rename = "dsReferenceNumber")]
pub ds_reference_number: String,
#[serde(rename = "dsTransID")]
pub ds_trans_id: String,
#[serde(rename = "messageType")]
pub message_type: Option<String>,
#[serde(rename = "messageVersion")]
pub message_version: String,
#[serde(rename = "threeDSServerTransID")]
pub three_dsserver_trans_id: String,
#[serde(rename = "transStatus")]
pub trans_status: ThreedsecureioTransStatus,
#[serde(rename = "acsSignedContent")]
pub acs_signed_content: Option<String>,
#[serde(rename = "authenticationValue")]
pub authentication_value: Option<Secret<String>>,
}
#[derive(Debug, Serialize, Deserialize)]
pub enum ThreeDSecureIoThreeDsCompletionIndicator {
Y,
N,
U,
}
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ThreedsecureioAuthenticationRequest {
pub ds_start_protocol_version: String,
pub ds_end_protocol_version: String,
pub acs_start_protocol_version: String,
pub acs_end_protocol_version: String,
pub three_dsserver_trans_id: String,
pub acct_number: cards::CardNumber,
pub notification_url: String,
pub three_dscomp_ind: ThreeDSecureIoThreeDsCompletionIndicator,
pub three_dsrequestor_url: String,
pub acquirer_bin: String,
pub acquirer_merchant_id: String,
pub card_expiry_date: String,
pub bill_addr_city: String,
pub bill_addr_country: Secret<String>,
pub bill_addr_line1: Secret<String>,
pub bill_addr_post_code: Secret<String>,
pub bill_addr_state: Secret<String>,
pub email: Option<common_utils::pii::Email>,
pub three_dsrequestor_authentication_ind: String,
pub cardholder_name: Option<Secret<String>>,
pub device_channel: String,
pub browser_javascript_enabled: Option<bool>,
pub browser_accept_header: Option<String>,
pub browser_ip: Option<Secret<String, common_utils::pii::IpAddress>>,
pub browser_java_enabled: Option<bool>,
pub browser_language: Option<String>,
pub browser_color_depth: Option<String>,
pub browser_screen_height: Option<String>,
pub browser_screen_width: Option<String>,
pub browser_tz: Option<String>,
pub browser_user_agent: Option<String>,
pub sdk_app_id: Option<String>,
pub sdk_enc_data: Option<String>,
pub sdk_ephem_pub_key: Option<std::collections::HashMap<String, String>>,
pub sdk_reference_number: Option<String>,
pub sdk_trans_id: Option<String>,
pub mcc: String,
pub merchant_country_code: String,
pub merchant_name: String,
pub message_category: String,
pub message_type: String,
pub message_version: String,
pub purchase_amount: String,
pub purchase_currency: String,
pub purchase_exponent: String,
pub purchase_date: String,
pub trans_type: String,
pub sdk_max_timeout: Option<String>,
pub device_render_options: Option<DeviceRenderOptions>,
}
#[derive(Debug, Serialize, Deserialize)]
pub struct ThreeDSecureIoMetaData {
pub mcc: String,
pub merchant_country_code: String,
pub merchant_name: String,
}
#[derive(Debug, Serialize, Deserialize)]
pub struct ThreeDSecureIoConnectorMetaData {
pub ds_start_protocol_version: String,
pub ds_end_protocol_version: String,
pub acs_start_protocol_version: String,
pub acs_end_protocol_version: String,
}
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct DeviceRenderOptions {
pub sdk_interface: String,
pub sdk_ui_type: Vec<String>,
}
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ThreedsecureioPreAuthenticationRequest {
acct_number: cards::CardNumber,
ds: Option<DirectoryServer>,
}
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ThreedsecureioPostAuthenticationRequest {
pub three_ds_server_trans_id: String,
}
#[derive(Debug, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ThreedsecureioPostAuthenticationResponse {
pub authentication_value: Option<Secret<String>>,
pub trans_status: ThreedsecureioTransStatus,
pub eci: Option<String>,
}
#[derive(Clone, Debug, Serialize, Deserialize, Eq, PartialEq)]
pub enum ThreedsecureioTransStatus {
/// Authentication/ Account Verification Successful
Y,
/// Not Authenticated /Account Not Verified; Transaction denied
N,
/// Authentication/ Account Verification Could Not Be Performed; Technical or other problem, as indicated in ARes or RReq
U,
/// Attempts Processing Performed; Not Authenticated/Verified , but a proof of attempted authentication/verification is provided
A,
/// Authentication/ Account Verification Rejected; Issuer is rejecting authentication/verification and request that authorisation not be attempted.
R,
C,
}
impl From<ThreeDsCompletionIndicator> for ThreeDSecureIoThreeDsCompletionIndicator {
fn from(value: ThreeDsCompletionIndicator) -> Self {
match value {
ThreeDsCompletionIndicator::Success => Self::Y,
ThreeDsCompletionIndicator::Failure => Self::N,
ThreeDsCompletionIndicator::NotAvailable => Self::U,
}
}
}
impl From<ThreedsecureioTransStatus> for common_enums::TransactionStatus {
fn from(value: ThreedsecureioTransStatus) -> Self {
match value {
ThreedsecureioTransStatus::Y => Self::Success,
ThreedsecureioTransStatus::N => Self::Failure,
ThreedsecureioTransStatus::U => Self::VerificationNotPerformed,
ThreedsecureioTransStatus::A => Self::NotVerified,
ThreedsecureioTransStatus::R => Self::Rejected,
ThreedsecureioTransStatus::C => Self::ChallengeRequired,
}
}
}
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub enum DirectoryServer {
Standin,
Visa,
Mastercard,
Jcb,
Upi,
Amex,
Protectbuy,
Sbn,
}
#[derive(Debug, Deserialize, Serialize)]
#[serde(untagged)]
pub enum ThreedsecureioPreAuthenticationResponse {
Success(Box<ThreedsecureioPreAuthenticationResponseData>),
Failure(Box<ThreedsecureioErrorResponse>),
}
#[derive(Debug, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ThreedsecureioPreAuthenticationResponseData {
pub ds_start_protocol_version: String,
pub ds_end_protocol_version: String,
pub acs_start_protocol_version: String,
pub acs_end_protocol_version: String,
#[serde(rename = "threeDSMethodURL")]
pub threeds_method_url: Option<String>,
#[serde(rename = "threeDSServerTransID")]
pub threeds_server_trans_id: String,
pub scheme: Option<String>,
pub message_type: Option<String>,
}
impl TryFrom<&ThreedsecureioRouterData<&PreAuthNRouterData>>
for ThreedsecureioPreAuthenticationRequest
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
value: &ThreedsecureioRouterData<&PreAuthNRouterData>,
) -> Result<Self, Self::Error> {
let router_data = value.router_data;
Ok(Self {
acct_number: router_data.request.card.card_number.clone(),
ds: None,
})
}
}
|
{
"crate": "hyperswitch_connectors",
"file": "crates/hyperswitch_connectors/src/connectors/threedsecureio/transformers.rs",
"file_size": null,
"is_async": null,
"is_pub": null,
"num_enums": 6,
"num_structs": 10,
"num_tables": null,
"score": null,
"total_crates": null
}
|
file_hyperswitch_connectors_7501762825252660819
|
clm
|
file
|
// Repository: hyperswitch
// Crate: hyperswitch_connectors
// File: crates/hyperswitch_connectors/src/connectors/globalpay/response.rs
// Contains: 9 structs, 2 enums
use common_enums::Currency;
use common_utils::types::StringMinorUnit;
use masking::Secret;
use serde::{Deserialize, Serialize};
use crate::utils::deserialize_optional_currency;
#[derive(Debug, Serialize, Deserialize)]
pub struct GlobalpayPaymentsResponse {
pub status: GlobalpayPaymentStatus,
pub payment_method: Option<PaymentMethod>,
pub id: String,
pub amount: Option<StringMinorUnit>,
#[serde(deserialize_with = "deserialize_optional_currency")]
pub currency: Option<Currency>,
pub reference: Option<String>,
}
#[derive(Debug, Deserialize, Serialize)]
pub struct GlobalpayRefreshTokenResponse {
pub token: Secret<String>,
pub seconds_to_expire: i64,
}
#[derive(Debug, Deserialize, Serialize)]
pub struct GlobalpayRefreshTokenErrorResponse {
pub error_code: String,
pub detailed_error_description: String,
}
#[derive(Debug, Serialize, Deserialize)]
pub struct PaymentMethod {
pub apm: Option<Apm>,
pub card: Option<Card>,
pub id: Option<Secret<String>>,
pub message: Option<String>,
pub result: Option<String>,
}
/// Data associated with the response of an APM transaction.
#[derive(Debug, Serialize, Deserialize)]
pub struct Apm {
#[serde(alias = "provider_redirect_url")]
pub redirect_url: Option<String>,
}
#[derive(Debug, Serialize, Deserialize)]
pub struct Card {
pub brand_reference: Option<Secret<String>>,
}
/// Indicates where a transaction is in its lifecycle.
#[derive(Clone, Copy, Debug, Serialize, Deserialize)]
#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
pub enum GlobalpayPaymentStatus {
/// A Transaction has been successfully authorized and captured. The funding
/// process will commence once the transaction remains in this status.
Captured,
/// A Transaction where the payment method provider declined the transfer of
/// funds between the payer and the merchant.
Declined,
/// A Transaction where the funds have transferred between payer and merchant as
/// expected.
Funded,
/// A Transaction has been successfully initiated. An update on its status is
/// expected via a separate asynchronous notification to a webhook.
Initiated,
/// A Transaction has been sent to the payment method provider and are waiting
/// for a result.
Pending,
/// A Transaction has been approved but a capture request is required to
/// commence the movement of funds.
Preauthorized,
/// A Transaction where the funds were expected to transfer between payer and
/// merchant but the transfer was rejected during the funding process. This rarely happens
/// but when it does it is usually addressed by Global Payments operations.
Rejected,
/// A Transaction that had a status of PENDING, PREAUTHORIZED or CAPTURED has
/// subsequently been reversed which voids/cancels a transaction before it is funded.
Reversed,
}
#[derive(Debug, Deserialize)]
pub struct GlobalpayWebhookObjectId {
pub id: String,
}
#[derive(Debug, Deserialize)]
pub struct GlobalpayWebhookObjectEventType {
pub status: GlobalpayWebhookStatus,
}
#[derive(Debug, Deserialize)]
#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
pub enum GlobalpayWebhookStatus {
Declined,
Captured,
#[serde(other)]
Unknown,
}
#[derive(Debug, Serialize, Deserialize)]
pub struct GlobalpayPaymentMethodsResponse {
#[serde(rename = "id")]
pub payment_method_token_id: Option<Secret<String>>,
pub card: Card,
}
|
{
"crate": "hyperswitch_connectors",
"file": "crates/hyperswitch_connectors/src/connectors/globalpay/response.rs",
"file_size": null,
"is_async": null,
"is_pub": null,
"num_enums": 2,
"num_structs": 9,
"num_tables": null,
"score": null,
"total_crates": null
}
|
file_hyperswitch_connectors_1027740559790593192
|
clm
|
file
|
// Repository: hyperswitch
// Crate: hyperswitch_connectors
// File: crates/hyperswitch_connectors/src/connectors/globalpay/transformers.rs
// Contains: 2 structs, 0 enums
use common_utils::{
crypto::{self, GenerateDigest},
errors::ParsingError,
pii,
request::Method,
types::{AmountConvertor, MinorUnit, StringMinorUnit, StringMinorUnitForConnector},
};
use error_stack::ResultExt;
use hyperswitch_domain_models::{
payment_method_data,
router_data::{AccessToken, ConnectorAuthType, ErrorResponse, PaymentMethodToken, RouterData},
router_flow_types::{Execute, RSync},
router_request_types::ResponseId,
router_response_types::{
MandateReference, PaymentsResponseData, RedirectForm, RefundsResponseData,
},
types::{
PaymentsAuthorizeRouterData, PaymentsCancelRouterData, PaymentsCaptureRouterData,
PaymentsSyncRouterData, RefreshTokenRouterData, RefundExecuteRouterData, RefundsRouterData,
TokenizationRouterData,
},
};
use hyperswitch_interfaces::{
consts::{self, NO_ERROR_MESSAGE},
errors,
};
use masking::{ExposeInterface, PeekInterface, Secret};
use rand::distributions::DistString;
use serde::{Deserialize, Serialize};
use url::Url;
use super::{
requests::{
self, ApmProvider, GlobalPayRouterData, GlobalpayCancelRouterData,
GlobalpayPaymentsRequest, GlobalpayRefreshTokenRequest, Initiator, PaymentMethodData,
Sequence, StoredCredential,
},
response::{GlobalpayPaymentStatus, GlobalpayPaymentsResponse, GlobalpayRefreshTokenResponse},
};
use crate::{
connectors::globalpay::{
requests::CommonPaymentMethodData, response::GlobalpayPaymentMethodsResponse,
},
types::{PaymentsSyncResponseRouterData, RefundsResponseRouterData, ResponseRouterData},
utils::{
self, construct_captures_response_hashmap, CardData, ForeignTryFrom,
MultipleCaptureSyncResponse, PaymentMethodTokenizationRequestData,
PaymentsAuthorizeRequestData, RouterData as _, WalletData,
},
};
impl<T> From<(StringMinorUnit, T)> for GlobalPayRouterData<T> {
fn from((amount, item): (StringMinorUnit, T)) -> Self {
Self {
amount,
router_data: item,
}
}
}
impl<T> From<(Option<StringMinorUnit>, T)> for GlobalpayCancelRouterData<T> {
fn from((amount, item): (Option<StringMinorUnit>, T)) -> Self {
Self {
amount,
router_data: item,
}
}
}
type Error = error_stack::Report<errors::ConnectorError>;
#[derive(Debug, Serialize, Deserialize)]
pub struct GlobalPayMeta {
account_name: Secret<String>,
}
impl TryFrom<&Option<pii::SecretSerdeValue>> for GlobalPayMeta {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(meta_data: &Option<pii::SecretSerdeValue>) -> Result<Self, Self::Error> {
let metadata: Self = utils::to_connector_meta_from_secret::<Self>(meta_data.clone())
.change_context(errors::ConnectorError::InvalidConnectorConfig {
config: "metadata",
})?;
Ok(metadata)
}
}
impl TryFrom<&GlobalPayRouterData<&PaymentsAuthorizeRouterData>> for GlobalpayPaymentsRequest {
type Error = Error;
fn try_from(
item: &GlobalPayRouterData<&PaymentsAuthorizeRouterData>,
) -> Result<Self, Self::Error> {
if item.router_data.is_three_ds() {
return Err(errors::ConnectorError::NotSupported {
message: "3DS flow".to_string(),
connector: "Globalpay",
}
.into());
}
let metadata = GlobalPayMeta::try_from(&item.router_data.connector_meta_data)?;
let account_name = metadata.account_name;
let (initiator, stored_credential, connector_mandate_id) =
if item.router_data.request.is_mandate_payment() {
let connector_mandate_id =
item.router_data
.request
.mandate_id
.as_ref()
.and_then(|mandate_ids| match &mandate_ids.mandate_reference_id {
Some(api_models::payments::MandateReferenceId::ConnectorMandateId(
connector_mandate_ids,
)) => connector_mandate_ids.get_connector_mandate_id(),
_ => None,
});
let initiator = Some(match item.router_data.request.off_session {
Some(true) => Initiator::Merchant,
_ => Initiator::Payer,
});
let stored_credential = Some(StoredCredential {
model: Some(if connector_mandate_id.is_some() {
requests::Model::Recurring
} else {
requests::Model::Unscheduled
}),
sequence: Some(if connector_mandate_id.is_some() {
Sequence::Subsequent
} else {
Sequence::First
}),
});
(initiator, stored_credential, connector_mandate_id)
} else {
(None, None, None)
};
let payment_method = match &item.router_data.request.payment_method_data {
payment_method_data::PaymentMethodData::Card(ccard) => {
requests::GlobalPayPaymentMethodData::Common(CommonPaymentMethodData {
payment_method_data: PaymentMethodData::Card(requests::Card {
number: ccard.card_number.clone(),
expiry_month: ccard.card_exp_month.clone(),
expiry_year: ccard.get_card_expiry_year_2_digit()?,
cvv: ccard.card_cvc.clone(),
}),
entry_mode: Default::default(),
})
}
payment_method_data::PaymentMethodData::Wallet(wallet_data) => {
requests::GlobalPayPaymentMethodData::Common(CommonPaymentMethodData {
payment_method_data: get_wallet_data(wallet_data)?,
entry_mode: Default::default(),
})
}
payment_method_data::PaymentMethodData::BankRedirect(bank_redirect) => {
requests::GlobalPayPaymentMethodData::Common(CommonPaymentMethodData {
payment_method_data: PaymentMethodData::try_from(bank_redirect)?,
entry_mode: Default::default(),
})
}
payment_method_data::PaymentMethodData::MandatePayment => {
requests::GlobalPayPaymentMethodData::Mandate(requests::MandatePaymentMethodData {
entry_mode: Default::default(),
id: connector_mandate_id,
})
}
_ => Err(errors::ConnectorError::NotImplemented(
"Payment methods".to_string(),
))?,
};
Ok(Self {
account_name,
amount: Some(item.amount.to_owned()),
currency: item.router_data.request.currency.to_string(),
reference: item.router_data.connector_request_reference_id.to_string(),
country: item.router_data.get_billing_country()?,
capture_mode: Some(requests::CaptureMode::from(
item.router_data.request.capture_method,
)),
payment_method,
notifications: Some(requests::Notifications {
return_url: get_return_url(item.router_data),
status_url: item.router_data.request.webhook_url.clone(),
cancel_url: get_return_url(item.router_data),
}),
stored_credential,
channel: Default::default(),
initiator,
})
}
}
impl TryFrom<&GlobalPayRouterData<&PaymentsCaptureRouterData>>
for requests::GlobalpayCaptureRequest
{
type Error = Error;
fn try_from(
value: &GlobalPayRouterData<&PaymentsCaptureRouterData>,
) -> Result<Self, Self::Error> {
Ok(Self {
amount: Some(value.amount.to_owned()),
capture_sequence: value
.router_data
.request
.multiple_capture_data
.clone()
.map(|mcd| {
if mcd.capture_sequence == 1 {
Sequence::First
} else {
Sequence::Subsequent
}
}),
reference: value
.router_data
.request
.multiple_capture_data
.as_ref()
.map(|mcd| mcd.capture_reference.clone()),
})
}
}
impl TryFrom<&TokenizationRouterData> for requests::GlobalPayPaymentMethodsRequest {
type Error = Error;
fn try_from(item: &TokenizationRouterData) -> Result<Self, Self::Error> {
if !item.request.is_mandate_payment() {
return Err(errors::ConnectorError::FlowNotSupported {
flow: "Tokenization apart from Mandates".to_string(),
connector: "Globalpay".to_string(),
}
.into());
}
Ok(Self {
reference: item.connector_request_reference_id.clone(),
usage_mode: Some(requests::UsageMode::Multiple),
card: match &item.request.payment_method_data {
payment_method_data::PaymentMethodData::Card(card_data) => Some(requests::Card {
number: card_data.card_number.clone(),
expiry_month: card_data.card_exp_month.clone(),
expiry_year: card_data.get_card_expiry_year_2_digit()?,
cvv: card_data.card_cvc.clone(),
}),
_ => None,
},
})
}
}
impl TryFrom<&GlobalpayCancelRouterData<&PaymentsCancelRouterData>>
for requests::GlobalpayCancelRequest
{
type Error = Error;
fn try_from(
value: &GlobalpayCancelRouterData<&PaymentsCancelRouterData>,
) -> Result<Self, Self::Error> {
Ok(Self {
amount: value.amount.clone(),
})
}
}
pub struct GlobalpayAuthType {
pub app_id: Secret<String>,
pub key: Secret<String>,
}
impl TryFrom<&ConnectorAuthType> for GlobalpayAuthType {
type Error = Error;
fn try_from(auth_type: &ConnectorAuthType) -> Result<Self, Self::Error> {
match auth_type {
ConnectorAuthType::BodyKey { api_key, key1 } => Ok(Self {
app_id: key1.to_owned(),
key: api_key.to_owned(),
}),
_ => Err(errors::ConnectorError::FailedToObtainAuthType.into()),
}
}
}
impl TryFrom<GlobalpayRefreshTokenResponse> for AccessToken {
type Error = error_stack::Report<ParsingError>;
fn try_from(item: GlobalpayRefreshTokenResponse) -> Result<Self, Self::Error> {
Ok(Self {
token: item.token,
expires: item.seconds_to_expire,
})
}
}
impl TryFrom<&RefreshTokenRouterData> for GlobalpayRefreshTokenRequest {
type Error = Error;
fn try_from(item: &RefreshTokenRouterData) -> Result<Self, Self::Error> {
let globalpay_auth = GlobalpayAuthType::try_from(&item.connector_auth_type)
.change_context(errors::ConnectorError::FailedToObtainAuthType)
.attach_printable("Could not convert connector_auth to globalpay_auth")?;
let nonce = rand::distributions::Alphanumeric.sample_string(&mut rand::thread_rng(), 12);
let nonce_with_api_key = format!("{}{}", nonce, globalpay_auth.key.peek());
let secret_vec = crypto::Sha512
.generate_digest(nonce_with_api_key.as_bytes())
.change_context(errors::ConnectorError::RequestEncodingFailed)
.attach_printable("error creating request nonce")?;
let secret = hex::encode(secret_vec);
Ok(Self {
app_id: globalpay_auth.app_id,
nonce: Secret::new(nonce),
secret: Secret::new(secret),
grant_type: "client_credentials".to_string(),
})
}
}
impl From<GlobalpayPaymentStatus> for common_enums::AttemptStatus {
fn from(item: GlobalpayPaymentStatus) -> Self {
match item {
GlobalpayPaymentStatus::Captured | GlobalpayPaymentStatus::Funded => Self::Charged,
GlobalpayPaymentStatus::Declined | GlobalpayPaymentStatus::Rejected => Self::Failure,
GlobalpayPaymentStatus::Preauthorized => Self::Authorized,
GlobalpayPaymentStatus::Reversed => Self::Voided,
GlobalpayPaymentStatus::Initiated => Self::AuthenticationPending,
GlobalpayPaymentStatus::Pending => Self::Pending,
}
}
}
impl From<GlobalpayPaymentStatus> for common_enums::RefundStatus {
fn from(item: GlobalpayPaymentStatus) -> Self {
match item {
GlobalpayPaymentStatus::Captured | GlobalpayPaymentStatus::Funded => Self::Success,
GlobalpayPaymentStatus::Declined | GlobalpayPaymentStatus::Rejected => Self::Failure,
GlobalpayPaymentStatus::Initiated | GlobalpayPaymentStatus::Pending => Self::Pending,
_ => Self::Pending,
}
}
}
impl From<Option<common_enums::CaptureMethod>> for requests::CaptureMode {
fn from(capture_method: Option<common_enums::CaptureMethod>) -> Self {
match capture_method {
Some(common_enums::CaptureMethod::Manual) => Self::Later,
Some(common_enums::CaptureMethod::ManualMultiple) => Self::Multiple,
_ => Self::Auto,
}
}
}
// }
impl<F, T> TryFrom<ResponseRouterData<F, GlobalpayPaymentsResponse, T, PaymentsResponseData>>
for RouterData<F, T, PaymentsResponseData>
{
type Error = Error;
fn try_from(
item: ResponseRouterData<F, GlobalpayPaymentsResponse, T, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
let status = common_enums::AttemptStatus::from(item.response.status);
let redirect_url = item
.response
.payment_method
.as_ref()
.and_then(|payment_method| {
payment_method
.apm
.as_ref()
.and_then(|apm| apm.redirect_url.as_ref())
})
.filter(|redirect_str| !redirect_str.is_empty())
.map(|url| {
Url::parse(url).change_context(errors::ConnectorError::FailedToObtainIntegrationUrl)
})
.transpose()?;
let redirection_data = redirect_url.map(|url| RedirectForm::from((url, Method::Get)));
let payment_method_token = item.data.get_payment_method_token();
let status_code = item.http_code;
let mandate_reference = payment_method_token.ok().and_then(|token| match token {
PaymentMethodToken::Token(token_string) => Some(MandateReference {
connector_mandate_id: Some(token_string.clone().expose()),
payment_method_id: None,
mandate_metadata: None,
connector_mandate_request_reference_id: None,
}),
_ => None,
});
let response = match status {
common_enums::AttemptStatus::Failure => Err(Box::new(ErrorResponse {
message: item
.response
.payment_method
.as_ref()
.and_then(|payment_method| payment_method.message.clone())
.unwrap_or_else(|| NO_ERROR_MESSAGE.to_string()),
code: item
.response
.payment_method
.as_ref()
.and_then(|payment_method| payment_method.result.clone())
.unwrap_or_else(|| consts::NO_ERROR_CODE.to_string()),
reason: item
.response
.payment_method
.as_ref()
.and_then(|payment_method| payment_method.message.clone()),
status_code,
attempt_status: Some(status),
connector_transaction_id: Some(item.response.id.clone()),
network_decline_code: item
.response
.payment_method
.as_ref()
.and_then(|payment_method| payment_method.result.clone()),
network_advice_code: None,
network_error_message: item
.response
.payment_method
.as_ref()
.and_then(|payment_method| payment_method.message.clone()),
connector_metadata: None,
})),
_ => Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(item.response.id.clone()),
redirection_data: Box::new(redirection_data),
mandate_reference: Box::new(mandate_reference),
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: item.response.reference.clone(),
incremental_authorization_allowed: None,
charges: None,
}),
};
Ok(Self {
status,
response: response.map_err(|err| *err),
..item.data
})
}
}
impl<F, T> TryFrom<ResponseRouterData<F, GlobalpayPaymentMethodsResponse, T, PaymentsResponseData>>
for RouterData<F, T, PaymentsResponseData>
{
type Error = Error;
fn try_from(
item: ResponseRouterData<F, GlobalpayPaymentMethodsResponse, T, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
let token = item
.response
.payment_method_token_id
.clone()
.unwrap_or_default();
Ok(Self {
response: Ok(PaymentsResponseData::TokenizationResponse {
token: token.expose(),
}),
..item.data
})
}
}
impl
ForeignTryFrom<(
PaymentsSyncResponseRouterData<GlobalpayPaymentsResponse>,
bool,
)> for PaymentsSyncRouterData
{
type Error = Error;
fn foreign_try_from(
(value, is_multiple_capture_sync): (
PaymentsSyncResponseRouterData<GlobalpayPaymentsResponse>,
bool,
),
) -> Result<Self, Self::Error> {
if is_multiple_capture_sync {
let capture_sync_response_list =
construct_captures_response_hashmap(vec![value.response])?;
Ok(Self {
response: Ok(PaymentsResponseData::MultipleCaptureResponse {
capture_sync_response_list,
}),
..value.data
})
} else {
Self::try_from(value)
}
}
}
impl<F, T> TryFrom<ResponseRouterData<F, GlobalpayRefreshTokenResponse, T, AccessToken>>
for RouterData<F, T, AccessToken>
{
type Error = error_stack::Report<ParsingError>;
fn try_from(
item: ResponseRouterData<F, GlobalpayRefreshTokenResponse, T, AccessToken>,
) -> Result<Self, Self::Error> {
Ok(Self {
response: Ok(AccessToken {
token: item.response.token,
expires: item.response.seconds_to_expire,
}),
..item.data
})
}
}
impl<F> TryFrom<&GlobalPayRouterData<&RefundsRouterData<F>>> for requests::GlobalpayRefundRequest {
type Error = Error;
fn try_from(item: &GlobalPayRouterData<&RefundsRouterData<F>>) -> Result<Self, Self::Error> {
Ok(Self {
amount: item.amount.to_owned(),
})
}
}
impl TryFrom<RefundsResponseRouterData<Execute, GlobalpayPaymentsResponse>>
for RefundExecuteRouterData
{
type Error = Error;
fn try_from(
item: RefundsResponseRouterData<Execute, GlobalpayPaymentsResponse>,
) -> Result<Self, Self::Error> {
Ok(Self {
response: Ok(RefundsResponseData {
connector_refund_id: item.response.id,
refund_status: common_enums::RefundStatus::from(item.response.status),
}),
..item.data
})
}
}
impl TryFrom<RefundsResponseRouterData<RSync, GlobalpayPaymentsResponse>>
for RefundsRouterData<RSync>
{
type Error = Error;
fn try_from(
item: RefundsResponseRouterData<RSync, GlobalpayPaymentsResponse>,
) -> Result<Self, Self::Error> {
Ok(Self {
response: Ok(RefundsResponseData {
connector_refund_id: item.response.id,
refund_status: common_enums::RefundStatus::from(item.response.status),
}),
..item.data
})
}
}
#[derive(Debug, Default, Eq, PartialEq, Deserialize, Serialize)]
pub struct GlobalpayErrorResponse {
pub error_code: String,
pub detailed_error_code: String,
pub detailed_error_description: String,
}
fn get_return_url(item: &PaymentsAuthorizeRouterData) -> Option<String> {
match item.request.payment_method_data.clone() {
payment_method_data::PaymentMethodData::Wallet(
payment_method_data::WalletData::PaypalRedirect(_),
) => {
// Return URL handling for PayPal via Globalpay:
// - PayPal inconsistency: Return URLs work with HTTP, but cancel URLs require HTTPS
// - Local development: When testing locally, expose your server via HTTPS and replace
// the base URL with an HTTPS URL to ensure proper cancellation flow
// - Refer to commit 6499d429da87 for more information
item.request.complete_authorize_url.clone()
}
_ => item.request.router_return_url.clone(),
}
}
fn get_wallet_data(
wallet_data: &payment_method_data::WalletData,
) -> Result<PaymentMethodData, Error> {
match wallet_data {
payment_method_data::WalletData::PaypalRedirect(_) => {
Ok(PaymentMethodData::Apm(requests::Apm {
provider: Some(ApmProvider::Paypal),
}))
}
payment_method_data::WalletData::GooglePay(_) => {
Ok(PaymentMethodData::DigitalWallet(requests::DigitalWallet {
provider: Some(requests::DigitalWalletProvider::PayByGoogle),
payment_token: wallet_data.get_wallet_token_as_json("Google Pay".to_string())?,
}))
}
_ => Err(errors::ConnectorError::NotImplemented(
"Payment method".to_string(),
))?,
}
}
impl TryFrom<&payment_method_data::BankRedirectData> for PaymentMethodData {
type Error = Error;
fn try_from(value: &payment_method_data::BankRedirectData) -> Result<Self, Self::Error> {
match value {
payment_method_data::BankRedirectData::Eps { .. } => Ok(Self::Apm(requests::Apm {
provider: Some(ApmProvider::Eps),
})),
payment_method_data::BankRedirectData::Giropay { .. } => Ok(Self::Apm(requests::Apm {
provider: Some(ApmProvider::Giropay),
})),
payment_method_data::BankRedirectData::Ideal { .. } => Ok(Self::Apm(requests::Apm {
provider: Some(ApmProvider::Ideal),
})),
payment_method_data::BankRedirectData::Sofort { .. } => Ok(Self::Apm(requests::Apm {
provider: Some(ApmProvider::Sofort),
})),
_ => Err(errors::ConnectorError::NotImplemented("Payment method".to_string()).into()),
}
}
}
impl MultipleCaptureSyncResponse for GlobalpayPaymentsResponse {
fn get_connector_capture_id(&self) -> String {
self.id.clone()
}
fn get_capture_attempt_status(&self) -> common_enums::AttemptStatus {
common_enums::AttemptStatus::from(self.status)
}
fn is_capture_response(&self) -> bool {
true
}
fn get_amount_captured(&self) -> Result<Option<MinorUnit>, error_stack::Report<ParsingError>> {
match self.amount.clone() {
Some(amount) => {
let minor_amount = StringMinorUnitForConnector::convert_back(
&StringMinorUnitForConnector,
amount,
self.currency.unwrap_or_default(), //it is ignored in convert_back function
)?;
Ok(Some(minor_amount))
}
None => Ok(None),
}
}
fn get_connector_reference_id(&self) -> Option<String> {
self.reference.clone()
}
}
|
{
"crate": "hyperswitch_connectors",
"file": "crates/hyperswitch_connectors/src/connectors/globalpay/transformers.rs",
"file_size": null,
"is_async": null,
"is_pub": null,
"num_enums": 0,
"num_structs": 2,
"num_tables": null,
"score": null,
"total_crates": null
}
|
file_hyperswitch_connectors_-5441430105658724184
|
clm
|
file
|
// Repository: hyperswitch
// Crate: hyperswitch_connectors
// File: crates/hyperswitch_connectors/src/connectors/globalpay/requests.rs
// Contains: 16 structs, 11 enums
use common_utils::types::StringMinorUnit;
use masking::Secret;
use serde::{Deserialize, Serialize};
#[derive(Debug, Serialize)]
pub struct GlobalPayRouterData<T> {
pub amount: StringMinorUnit,
pub router_data: T,
}
#[derive(Debug, Serialize)]
pub struct GlobalpayCancelRouterData<T> {
pub amount: Option<StringMinorUnit>,
pub router_data: T,
}
#[derive(Debug, Serialize)]
pub struct GlobalpayPaymentsRequest {
pub account_name: Secret<String>,
pub amount: Option<StringMinorUnit>,
pub currency: String,
pub reference: String,
pub country: api_models::enums::CountryAlpha2,
pub capture_mode: Option<CaptureMode>,
pub notifications: Option<Notifications>,
pub payment_method: GlobalPayPaymentMethodData,
pub channel: Channel,
pub initiator: Option<Initiator>,
pub stored_credential: Option<StoredCredential>,
}
#[derive(Debug, Serialize)]
pub struct GlobalpayRefreshTokenRequest {
pub app_id: Secret<String>,
pub nonce: Secret<String>,
pub secret: Secret<String>,
pub grant_type: String,
}
#[derive(Debug, Serialize, Deserialize, Default)]
pub struct Notifications {
pub return_url: Option<String>,
pub status_url: Option<String>,
pub cancel_url: Option<String>,
}
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum PaymentMethodData {
Card(Card),
Apm(Apm),
DigitalWallet(DigitalWallet),
Token(TokenizationData),
}
#[derive(Debug, Serialize, Deserialize)]
pub struct CommonPaymentMethodData {
#[serde(flatten)]
pub payment_method_data: PaymentMethodData,
pub entry_mode: PaymentMethodEntryMode,
}
#[derive(Debug, Serialize, Deserialize)]
pub struct MandatePaymentMethodData {
pub entry_mode: PaymentMethodEntryMode,
pub id: Option<String>,
}
#[derive(Debug, Serialize, Deserialize)]
#[serde(untagged)]
pub enum GlobalPayPaymentMethodData {
Common(CommonPaymentMethodData),
Mandate(MandatePaymentMethodData),
}
#[derive(Debug, Serialize, Deserialize)]
pub struct Apm {
/// A string used to identify the payment method provider being used to execute this
/// transaction.
pub provider: Option<ApmProvider>,
}
#[derive(Debug, Default, Serialize, Deserialize)]
pub struct Card {
pub cvv: Secret<String>,
pub expiry_month: Secret<String>,
pub expiry_year: Secret<String>,
pub number: cards::CardNumber,
}
#[derive(Debug, Default, Serialize, Deserialize)]
pub struct TokenizationData {
pub brand_reference: Option<String>,
}
#[derive(Debug, Serialize, Deserialize)]
pub struct DigitalWallet {
/// Identifies who provides the digital wallet for the Payer.
pub provider: Option<DigitalWalletProvider>,
/// A token that represents, or is the payment method, stored with the digital wallet.
pub payment_token: Option<serde_json::Value>,
}
/// Stored data information used to create a transaction.
#[derive(Debug, Serialize, Deserialize)]
pub struct StoredCredential {
/// Indicates the transaction processing model being executed when using stored
/// credentials.
pub model: Option<Model>,
/// Indicates the order of this transaction in the sequence of a planned repeating
/// transaction processing model.
pub sequence: Option<Sequence>,
}
/// Indicates whether the transaction is to be captured automatically, later or later using
/// more than 1 partial capture.
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
pub enum CaptureMode {
/// If a transaction is authorized, funds will exchange between the payer and
/// merchant automatically and as soon as possible.
Auto,
/// If a transaction is authorized, funds will not exchange between the payer and
/// merchant automatically and will require a subsequent separate action to capture that
/// transaction and start the funding process. Only one successful capture is permitted.
Later,
/// If a transaction is authorized, funds will not exchange between the payer
/// and merchant automatically. One or more subsequent separate capture actions are required
/// to capture that transaction in parts and start the funding process for the part captured.
/// One or many successful capture are permitted once the total amount captured is within a
/// range of the original authorized amount.'
Multiple,
}
/// Describes whether the transaction was processed in a face to face(CP) scenario or a
/// Customer Not Present (CNP) scenario.
#[derive(Debug, Default, Serialize, Deserialize)]
pub enum Channel {
#[default]
#[serde(rename = "CNP")]
/// A Customer NOT Present transaction is when the payer and the merchant are not
/// together when exchanging payment method information to fulfill a transaction. e.g. a
/// transaction executed from a merchant's website or over the phone
CustomerNotPresent,
#[serde(rename = "CP")]
/// A Customer Present transaction is when the payer and the merchant are in direct
/// face to face contact when exchanging payment method information to fulfill a transaction.
/// e.g. in a store and paying at the counter that is attended by a clerk.
CustomerPresent,
}
/// Indicates whether the Merchant or the Payer initiated the creation of a transaction.
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
pub enum Initiator {
/// The transaction was initiated by the merchant, who is getting paid by the
/// payer.'
Merchant,
/// The transaction was initiated by the customer who is paying the merchant.
Payer,
}
/// A string used to identify the payment method provider being used to execute this
/// transaction.
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum ApmProvider {
Giropay,
Ideal,
Paypal,
Sofort,
Eps,
Testpay,
}
/// Identifies who provides the digital wallet for the Payer.
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
pub enum DigitalWalletProvider {
Applepay,
PayByGoogle,
}
/// Indicates how the payment method information was obtained by the Merchant for this
/// transaction.
#[derive(Debug, Default, Serialize, Deserialize)]
#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
pub enum PaymentMethodEntryMode {
/// A CP channel entry mode where the payment method information was obtained from a
/// chip. E.g. card is inserted into a device to read the chip.
Chip,
/// A CP channel entry mode where the payment method information was
/// obtained by bringing the payment method to close proximity of a device. E.g. tap a cardon
/// or near a device to exchange card information.
ContactlessChip,
/// A CP channel entry mode where the payment method information was
/// obtained by bringing the payment method to close proximity of a device and also swiping
/// the card. E.g. tap a card on or near a device and swipe it through device to exchange
/// card information
ContactlessSwipe,
#[default]
/// A CNP channel entry mode where the payment method was obtained via a browser.
Ecom,
/// A CNP channel entry mode where the payment method was obtained via an
/// application and applies to digital wallets only.
InApp,
/// A CNP channel entry mode where the payment method was obtained via postal mail.
Mail,
/// A CP channel entry mode where the payment method information was obtained by
/// manually keying the payment method information into the device.
Manual,
/// A CNP channel entry mode where the payment method information was obtained over
/// the phone or via postal mail.
Moto,
/// A CNP channel entry mode where the payment method was obtained over the
/// phone.
Phone,
/// A CP channel entry mode where the payment method information was obtained from
/// swiping a magnetic strip. E.g. card's magnetic strip is swiped through a device to read
/// the card information.
Swipe,
}
/// Indicates the transaction processing model being executed when using stored
/// credentials.
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
pub enum Model {
/// The transaction is a repeat transaction initiated by the merchant and
/// taken using the payment method stored with the merchant, as part of an agreed schedule of
/// transactions and where the amount is known and agreed in advanced. For example the
/// payment in full of a good in fixed installments over a defined period of time.'
Installment,
/// The transaction is a repeat transaction initiated by the merchant and taken
/// using the payment method stored with the merchant, as part of an agreed schedule of
/// transactions.
Recurring,
/// The transaction is a repeat transaction initiated by the merchant and
/// taken using the payment method stored with the merchant, as part of an agreed schedule of
/// transactions. The amount taken is based on the usage by the payer of the good or service.
/// for example a monthly mobile phone bill.
Subscription,
/// the transaction is adhoc or unscheduled. For example a payer visiting a
/// merchant to make purchase using the payment method stored with the merchant.
Unscheduled,
}
/// Indicates the order of this transaction in the sequence of a planned repeating
/// transaction processing model.
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
pub enum Sequence {
First,
Last,
Subsequent,
}
#[derive(Default, Debug, Serialize)]
pub struct GlobalpayRefundRequest {
pub amount: StringMinorUnit,
}
#[derive(Default, Debug, Serialize)]
pub struct GlobalpayCaptureRequest {
pub amount: Option<StringMinorUnit>,
pub capture_sequence: Option<Sequence>,
pub reference: Option<String>,
}
#[derive(Default, Debug, Serialize)]
pub struct GlobalpayCancelRequest {
pub amount: Option<StringMinorUnit>,
}
#[derive(Default, Debug, Serialize, Deserialize)]
#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
pub enum UsageMode {
/// This value must be used if using the Hosted Fields or the Drop-in UI integration types.
/// When creating the payment method token, this option ensures the payment method token is temporary and will be removed once a transaction is executed or after a short period of time.
#[default]
Single,
/// When creating the payment method token, this indicates it is permanent and can be used to create many transactions.
Multiple,
/// When using the payment method token to transaction process, this indicates to use the card number also known as the PAN or FPAN when both the card number and the network token are available.
UseCardNumber,
/// When using the payment method token to transaction process, this indicates to use the network token instead of the card number if both are available.
UseNetworkToken,
}
#[derive(Default, Debug, Serialize)]
pub struct GlobalPayPaymentMethodsRequest {
pub reference: String,
#[serde(skip_serializing_if = "Option::is_none")]
pub usage_mode: Option<UsageMode>,
#[serde(skip_serializing_if = "Option::is_none")]
pub card: Option<Card>,
}
|
{
"crate": "hyperswitch_connectors",
"file": "crates/hyperswitch_connectors/src/connectors/globalpay/requests.rs",
"file_size": null,
"is_async": null,
"is_pub": null,
"num_enums": 11,
"num_structs": 16,
"num_tables": null,
"score": null,
"total_crates": null
}
|
file_hyperswitch_connectors_-3229622529699816078
|
clm
|
file
|
// Repository: hyperswitch
// Crate: hyperswitch_connectors
// File: crates/hyperswitch_connectors/src/connectors/phonepe/transformers.rs
// Contains: 6 structs, 2 enums
use common_enums::enums;
use common_utils::types::StringMinorUnit;
use hyperswitch_domain_models::{
payment_method_data::PaymentMethodData,
router_data::{ConnectorAuthType, RouterData},
router_flow_types::refunds::{Execute, RSync},
router_request_types::ResponseId,
router_response_types::{PaymentsResponseData, RefundsResponseData},
types::{PaymentsAuthorizeRouterData, RefundsRouterData},
};
use hyperswitch_interfaces::errors;
use masking::{PeekInterface, Secret};
use serde::{Deserialize, Serialize};
use crate::types::{RefundsResponseRouterData, ResponseRouterData};
//TODO: Fill the struct with respective fields
pub struct PhonepeRouterData<T> {
pub amount: StringMinorUnit, // The type of amount that a connector accepts, for example, String, i64, f64, etc.
pub router_data: T,
}
impl<T> From<(StringMinorUnit, T)> for PhonepeRouterData<T> {
fn from((amount, item): (StringMinorUnit, T)) -> Self {
//Todo : use utils to convert the amount to the type of amount that a connector accepts
Self {
amount,
router_data: item,
}
}
}
//TODO: Fill the struct with respective fields
#[derive(Default, Debug, Serialize, PartialEq)]
pub struct PhonepePaymentsRequest {
amount: StringMinorUnit,
card: PhonepeCard,
}
#[derive(Default, Debug, Serialize, Eq, PartialEq)]
pub struct PhonepeCard {
number: cards::CardNumber,
expiry_month: Secret<String>,
expiry_year: Secret<String>,
cvc: Secret<String>,
complete: bool,
}
impl TryFrom<&PhonepeRouterData<&PaymentsAuthorizeRouterData>> for PhonepePaymentsRequest {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: &PhonepeRouterData<&PaymentsAuthorizeRouterData>,
) -> Result<Self, Self::Error> {
match item.router_data.request.payment_method_data.clone() {
PaymentMethodData::Card(_) => Err(errors::ConnectorError::NotImplemented(
"Card payment method not implemented".to_string(),
)
.into()),
_ => Err(errors::ConnectorError::NotImplemented("Payment method".to_string()).into()),
}
}
}
//TODO: Fill the struct with respective fields
// Auth Struct
pub struct PhonepeAuthType {
pub merchant_id: Secret<String>,
pub salt_key: Secret<String>,
pub key_index: String,
}
impl TryFrom<&ConnectorAuthType> for PhonepeAuthType {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(auth_type: &ConnectorAuthType) -> Result<Self, Self::Error> {
match auth_type {
ConnectorAuthType::SignatureKey {
api_key,
key1,
api_secret,
} => Ok(Self {
merchant_id: api_key.clone(),
salt_key: key1.clone(),
key_index: api_secret.peek().clone(), // Use api_secret for key index
}),
_ => Err(errors::ConnectorError::FailedToObtainAuthType.into()),
}
}
}
// PaymentsResponse
//TODO: Append the remaining status flags
#[derive(Debug, Clone, Copy, Default, Serialize, Deserialize, PartialEq)]
#[serde(rename_all = "lowercase")]
pub enum PhonepePaymentStatus {
Succeeded,
Failed,
#[default]
Processing,
}
impl From<PhonepePaymentStatus> for common_enums::AttemptStatus {
fn from(item: PhonepePaymentStatus) -> Self {
match item {
PhonepePaymentStatus::Succeeded => Self::Charged,
PhonepePaymentStatus::Failed => Self::Failure,
PhonepePaymentStatus::Processing => Self::Authorizing,
}
}
}
//TODO: Fill the struct with respective fields
#[derive(Default, Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct PhonepePaymentsResponse {
status: PhonepePaymentStatus,
id: String,
}
impl<F, T> TryFrom<ResponseRouterData<F, PhonepePaymentsResponse, T, PaymentsResponseData>>
for RouterData<F, T, PaymentsResponseData>
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: ResponseRouterData<F, PhonepePaymentsResponse, T, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
Ok(Self {
status: common_enums::AttemptStatus::from(item.response.status),
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(item.response.id),
redirection_data: Box::new(None),
mandate_reference: Box::new(None),
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: None,
incremental_authorization_allowed: None,
charges: None,
}),
..item.data
})
}
}
//TODO: Fill the struct with respective fields
// REFUND :
// Type definition for RefundRequest
#[derive(Default, Debug, Serialize)]
pub struct PhonepeRefundRequest {
pub amount: StringMinorUnit,
}
impl<F> TryFrom<&PhonepeRouterData<&RefundsRouterData<F>>> for PhonepeRefundRequest {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(item: &PhonepeRouterData<&RefundsRouterData<F>>) -> Result<Self, Self::Error> {
Ok(Self {
amount: item.amount.to_owned(),
})
}
}
// Type definition for Refund Response
#[allow(dead_code)]
#[derive(Debug, Copy, Serialize, Default, Deserialize, Clone)]
pub enum RefundStatus {
Succeeded,
Failed,
#[default]
Processing,
}
impl From<RefundStatus> for enums::RefundStatus {
fn from(item: RefundStatus) -> Self {
match item {
RefundStatus::Succeeded => Self::Success,
RefundStatus::Failed => Self::Failure,
RefundStatus::Processing => Self::Pending,
//TODO: Review mapping
}
}
}
//TODO: Fill the struct with respective fields
#[derive(Default, Debug, Clone, Serialize, Deserialize)]
pub struct RefundResponse {
id: String,
status: RefundStatus,
}
impl TryFrom<RefundsResponseRouterData<Execute, RefundResponse>> for RefundsRouterData<Execute> {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: RefundsResponseRouterData<Execute, RefundResponse>,
) -> Result<Self, Self::Error> {
Ok(Self {
response: Ok(RefundsResponseData {
connector_refund_id: item.response.id.to_string(),
refund_status: enums::RefundStatus::from(item.response.status),
}),
..item.data
})
}
}
impl TryFrom<RefundsResponseRouterData<RSync, RefundResponse>> for RefundsRouterData<RSync> {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: RefundsResponseRouterData<RSync, RefundResponse>,
) -> Result<Self, Self::Error> {
Ok(Self {
response: Ok(RefundsResponseData {
connector_refund_id: item.response.id.to_string(),
refund_status: enums::RefundStatus::from(item.response.status),
}),
..item.data
})
}
}
//TODO: Fill the struct with respective fields
#[derive(Default, Debug, Serialize, Deserialize, PartialEq)]
pub struct PhonepeErrorResponse {
pub status_code: u16,
pub code: String,
pub message: String,
pub reason: Option<String>,
pub network_advice_code: Option<String>,
pub network_decline_code: Option<String>,
pub network_error_message: Option<String>,
}
|
{
"crate": "hyperswitch_connectors",
"file": "crates/hyperswitch_connectors/src/connectors/phonepe/transformers.rs",
"file_size": null,
"is_async": null,
"is_pub": null,
"num_enums": 2,
"num_structs": 6,
"num_tables": null,
"score": null,
"total_crates": null
}
|
file_hyperswitch_connectors_-5861071105240745750
|
clm
|
file
|
// Repository: hyperswitch
// Crate: hyperswitch_connectors
// File: crates/hyperswitch_connectors/src/connectors/finix/transformers/response.rs
// Contains: 6 structs, 0 enums
use std::collections::HashMap;
use common_enums::Currency;
use common_utils::types::MinorUnit;
use serde::{Deserialize, Serialize};
use super::*;
#[derive(Debug, Clone, PartialEq, Deserialize, Serialize)]
pub struct FinixPaymentsResponse {
pub id: String,
pub created_at: Option<String>,
pub updated_at: Option<String>,
pub application: Option<Secret<String>>,
pub amount: MinorUnit,
pub captured_amount: Option<MinorUnit>,
pub currency: Currency,
pub is_void: Option<bool>,
pub source: Option<Secret<String>>,
pub state: FinixState,
pub failure_code: Option<String>,
pub messages: Option<Vec<String>>,
pub failure_message: Option<String>,
pub transfer: Option<String>,
pub tags: FinixTags,
#[serde(rename = "type")]
pub payment_type: Option<FinixPaymentType>,
// pub trace_id: String,
pub three_d_secure: Option<FinixThreeDSecure>,
// Add other fields from the API response as needed.
}
#[derive(Debug, Clone, PartialEq, Deserialize, Serialize)]
pub struct FinixIdentityResponse {
pub id: String,
pub created_at: Option<String>,
pub updated_at: Option<String>,
pub application: Option<String>,
pub entity: Option<HashMap<String, serde_json::Value>>,
pub tags: Option<FinixTags>,
}
#[derive(Debug, Clone, PartialEq, Deserialize, Serialize)]
pub struct FinixInstrumentResponse {
pub id: String,
pub created_at: String,
pub updated_at: String,
pub application: String,
pub identity: Option<String>,
#[serde(rename = "type")]
pub instrument_type: FinixPaymentInstrumentType,
pub tags: Option<FinixTags>,
pub card_type: Option<FinixCardType>,
pub card_brand: Option<String>,
pub fingerprint: Option<String>,
pub address: Option<FinixAddress>,
pub name: Option<Secret<String>>,
pub currency: Option<Currency>,
pub enabled: bool,
}
#[derive(Default, Debug, Serialize, Deserialize, PartialEq)]
pub struct FinixErrorResponse {
// pub status_code: u16,
pub total: Option<i64>,
#[serde(rename = "_embedded")]
pub embedded: Option<FinixErrorEmbedded>,
}
#[derive(Default, Debug, Serialize, Deserialize, PartialEq)]
pub struct FinixErrorEmbedded {
pub errors: Option<Vec<FinixError>>,
}
#[derive(Default, Debug, Serialize, Deserialize, PartialEq)]
pub struct FinixError {
// pub logref: Option<String>,
pub message: Option<String>,
pub code: Option<String>,
}
|
{
"crate": "hyperswitch_connectors",
"file": "crates/hyperswitch_connectors/src/connectors/finix/transformers/response.rs",
"file_size": null,
"is_async": null,
"is_pub": null,
"num_enums": 0,
"num_structs": 6,
"num_tables": null,
"score": null,
"total_crates": null
}
|
file_hyperswitch_connectors_-467662949786835695
|
clm
|
file
|
// Repository: hyperswitch
// Crate: hyperswitch_connectors
// File: crates/hyperswitch_connectors/src/connectors/finix/transformers/request.rs
// Contains: 15 structs, 6 enums
use std::collections::HashMap;
use common_enums::Currency;
use common_utils::{pii::Email, types::MinorUnit};
use masking::Secret;
use serde::{Deserialize, Serialize};
use super::*;
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct FinixPaymentsRequest {
pub amount: MinorUnit,
pub currency: Currency,
pub source: Secret<String>,
pub merchant: Secret<String>,
pub tags: Option<FinixTags>,
pub three_d_secure: Option<FinixThreeDSecure>,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct FinixCaptureRequest {
pub capture_amount: MinorUnit,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct FinixCancelRequest {
pub void_me: bool,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct FinixCaptureAuthorizationRequest {
pub amount: Option<MinorUnit>,
pub tags: Option<FinixTags>,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct FinixCreateIdentityRequest {
pub entity: FinixIdentityEntity,
pub tags: Option<FinixTags>,
#[serde(rename = "type")]
pub identity_type: FinixIdentityType,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct FinixIdentityEntity {
pub phone: Option<Secret<String>>,
pub first_name: Option<Secret<String>>,
pub last_name: Option<Secret<String>>,
pub email: Option<Email>,
pub personal_address: Option<FinixAddress>,
}
#[derive(Debug, Eq, PartialEq, Serialize, Deserialize)]
pub struct FinixApplePayPaymentToken {
pub token: FinixApplePayToken,
}
#[derive(Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct FinixApplePayHeader {
pub public_key_hash: String,
pub ephemeral_public_key: String,
pub transaction_id: String,
}
#[derive(Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct FinixApplePayEncryptedData {
pub data: Secret<String>,
pub signature: Secret<String>,
pub header: FinixApplePayHeader,
pub version: Secret<String>,
}
#[derive(Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct FinixApplePayPaymentMethod {
pub display_name: Secret<String>,
pub network: Secret<String>,
#[serde(rename = "type")]
pub method_type: Secret<String>,
}
#[derive(Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct FinixApplePayToken {
pub payment_data: FinixApplePayEncryptedData,
pub payment_method: FinixApplePayPaymentMethod,
pub transaction_identifier: String,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct FinixCreatePaymentInstrumentRequest {
#[serde(rename = "type")]
pub instrument_type: FinixPaymentInstrumentType,
pub name: Option<Secret<String>>,
#[serde(skip_serializing_if = "Option::is_none")]
pub number: Option<Secret<String>>,
#[serde(skip_serializing_if = "Option::is_none")]
pub security_code: Option<Secret<String>>,
#[serde(skip_serializing_if = "Option::is_none")]
pub expiration_month: Option<Secret<i8>>,
#[serde(skip_serializing_if = "Option::is_none")]
pub expiration_year: Option<Secret<i32>>,
pub identity: String,
pub tags: Option<FinixTags>,
pub address: Option<FinixAddress>,
pub card_brand: Option<String>,
pub card_type: Option<FinixCardType>,
pub additional_data: Option<HashMap<String, String>>,
pub merchant_identity: Option<Secret<String>>,
pub third_party_token: Option<Secret<String>>,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct FinixCreateRefundRequest {
pub refund_amount: MinorUnit,
}
impl FinixCreateRefundRequest {
pub fn new(refund_amount: MinorUnit) -> Self {
Self { refund_amount }
}
}
// ---------- COMMON ENUMS
#[derive(Debug, Clone)]
pub enum FinixId {
Auth(String),
Transfer(String),
}
impl From<String> for FinixId {
fn from(id: String) -> Self {
if id.starts_with("AU") {
Self::Auth(id)
} else if id.starts_with("TR") {
Self::Transfer(id)
} else {
// Default to Auth if the prefix doesn't match
Self::Auth(id)
}
}
}
impl std::fmt::Display for FinixId {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self {
Self::Auth(id) => write!(f, "{}", id),
Self::Transfer(id) => write!(f, "{}", id),
}
}
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub enum FinixState {
PENDING,
SUCCEEDED,
FAILED,
CANCELED,
#[serde(other)]
UNKNOWN,
// RETURNED
}
impl FinixState {
pub fn is_failure(&self) -> bool {
match self {
Self::PENDING | Self::SUCCEEDED => false,
Self::FAILED | Self::CANCELED | Self::UNKNOWN => true,
}
}
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub enum FinixPaymentType {
DEBIT,
CREDIT,
REVERSAL,
FEE,
ADJUSTMENT,
DISPUTE,
RESERVE,
SETTLEMENT,
#[serde(other)]
UNKNOWN,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub enum FinixPaymentInstrumentType {
#[serde(rename = "PAYMENT_CARD")]
PaymentCard,
#[serde(rename = "GOOGLE_PAY")]
GOOGLEPAY,
#[serde(rename = "BANK_ACCOUNT")]
BankAccount,
#[serde(rename = "APPLE_PAY")]
ApplePay,
#[serde(other)]
Unknown,
}
/// Represents the type of a payment card.
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub enum FinixCardType {
DEBIT,
CREDIT,
PREPAID,
#[serde(other)]
UNKNOWN,
}
/// 3D Secure authentication details.
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct FinixThreeDSecure {
pub authenticated: Option<bool>,
pub liability_shift: Option<Secret<String>>,
pub version: Option<String>,
pub eci: Option<Secret<String>>,
pub cavv: Option<Secret<String>>,
pub xid: Option<Secret<String>>,
}
/// Key-value pair tags.
pub type FinixTags = HashMap<String, String>;
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct FinixAddress {
pub line1: Option<Secret<String>>,
pub line2: Option<Secret<String>>,
pub city: Option<String>,
pub region: Option<Secret<String>>,
pub postal_code: Option<Secret<String>>,
pub country: Option<CountryAlpha3>,
}
/// The type of the business.
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub enum FinixIdentityType {
PERSONAL,
}
pub enum FinixFlow {
Auth,
Transfer,
Capture,
}
impl FinixFlow {
pub fn get_flow_for_auth(capture_method: CaptureMethod) -> Self {
match capture_method {
CaptureMethod::SequentialAutomatic | CaptureMethod::Automatic => Self::Transfer,
CaptureMethod::Manual | CaptureMethod::ManualMultiple | CaptureMethod::Scheduled => {
Self::Auth
}
}
}
}
pub struct FinixAuthType {
pub finix_user_name: Secret<String>,
pub finix_password: Secret<String>,
pub merchant_id: Secret<String>,
pub merchant_identity_id: Secret<String>,
}
|
{
"crate": "hyperswitch_connectors",
"file": "crates/hyperswitch_connectors/src/connectors/finix/transformers/request.rs",
"file_size": null,
"is_async": null,
"is_pub": null,
"num_enums": 6,
"num_structs": 15,
"num_tables": null,
"score": null,
"total_crates": null
}
|
file_hyperswitch_connectors_8417751053219946706
|
clm
|
file
|
// Repository: hyperswitch
// Crate: hyperswitch_connectors
// File: crates/hyperswitch_connectors/src/connectors/nexixpay/transformers.rs
// Contains: 34 structs, 12 enums
use std::collections::HashMap;
use cards::CardNumber;
use common_enums::{
AttemptStatus, CaptureMethod, CountryAlpha2, CountryAlpha3, Currency, RefundStatus,
};
use common_utils::{
errors::CustomResult, ext_traits::ValueExt, request::Method, types::StringMinorUnit,
};
use error_stack::ResultExt;
use hyperswitch_domain_models::{
payment_method_data::PaymentMethodData,
router_data::{ConnectorAuthType, ErrorResponse, RouterData},
router_flow_types::{
refunds::{Execute, RSync},
SetupMandate,
},
router_request_types::{
CompleteAuthorizeData, PaymentsAuthorizeData, PaymentsCancelData, PaymentsCaptureData,
PaymentsPreProcessingData, PaymentsSyncData, ResponseId, SetupMandateRequestData,
},
router_response_types::{
MandateReference, PaymentsResponseData, RedirectForm, RefundsResponseData,
},
types::{
PaymentsAuthorizeRouterData, PaymentsCancelRouterData, PaymentsCaptureRouterData,
PaymentsCompleteAuthorizeRouterData, PaymentsPreProcessingRouterData, RefundsRouterData,
},
};
use hyperswitch_interfaces::{consts::NO_ERROR_CODE, errors};
use masking::{ExposeInterface, Secret};
use serde::{Deserialize, Serialize};
use strum::Display;
use crate::{
types::{RefundsResponseRouterData, ResponseRouterData},
utils::{
get_unimplemented_payment_method_error_message, to_connector_meta,
to_connector_meta_from_secret, CardData, PaymentsAuthorizeRequestData,
PaymentsCompleteAuthorizeRequestData, PaymentsPreProcessingRequestData,
PaymentsSetupMandateRequestData, PaymentsSyncRequestData, RouterData as _,
},
};
#[derive(Clone, Copy, Debug)]
enum AddressKind {
Billing,
Shipping,
}
trait AddressConstructor {
fn new(
name: Option<Secret<String>>,
street: Option<Secret<String>>,
city: Option<String>,
post_code: Option<Secret<String>>,
country: Option<CountryAlpha3>,
) -> Self;
}
impl AddressConstructor for BillingAddress {
fn new(
name: Option<Secret<String>>,
street: Option<Secret<String>>,
city: Option<String>,
post_code: Option<Secret<String>>,
country: Option<CountryAlpha3>,
) -> Self {
Self {
name,
street,
city,
post_code,
country,
}
}
}
impl AddressConstructor for ShippingAddress {
fn new(
name: Option<Secret<String>>,
street: Option<Secret<String>>,
city: Option<String>,
post_code: Option<Secret<String>>,
country: Option<CountryAlpha3>,
) -> Self {
Self {
name,
street,
city,
post_code,
country,
}
}
}
fn get_validated_address_details_generic<RouterContextDataAlias, AddressOutput>(
data: &RouterContextDataAlias,
address_kind: AddressKind,
) -> Result<Option<AddressOutput>, error_stack::Report<errors::ConnectorError>>
where
RouterContextDataAlias: crate::utils::RouterData,
AddressOutput: AddressConstructor + Sized,
{
let (
opt_line1,
opt_line2,
opt_full_name,
opt_city,
opt_zip,
opt_country,
has_address_details_check,
address_type_str,
max_name_len,
max_street_len,
max_city_len,
max_post_code_len,
max_country_len,
) = match address_kind {
AddressKind::Billing => (
data.get_optional_billing_line1(),
data.get_optional_billing_line2(),
data.get_optional_billing_full_name(),
data.get_optional_billing_city(),
data.get_optional_billing_zip(),
data.get_optional_billing_country()
.map(CountryAlpha2::from_alpha2_to_alpha3),
data.get_optional_billing().is_some(),
"billing",
MAX_BILLING_ADDRESS_NAME_LENGTH,
MAX_BILLING_ADDRESS_STREET_LENGTH,
MAX_BILLING_ADDRESS_CITY_LENGTH,
MAX_BILLING_ADDRESS_POST_CODE_LENGTH,
MAX_BILLING_ADDRESS_COUNTRY_LENGTH,
),
AddressKind::Shipping => (
data.get_optional_shipping_line1(),
data.get_optional_shipping_line2(),
data.get_optional_shipping_full_name(),
data.get_optional_shipping_city(),
data.get_optional_shipping_zip(),
data.get_optional_shipping_country()
.map(CountryAlpha2::from_alpha2_to_alpha3),
data.get_optional_shipping().is_some(),
"shipping",
MAX_BILLING_ADDRESS_NAME_LENGTH,
MAX_BILLING_ADDRESS_STREET_LENGTH,
MAX_BILLING_ADDRESS_CITY_LENGTH,
MAX_BILLING_ADDRESS_POST_CODE_LENGTH,
MAX_BILLING_ADDRESS_COUNTRY_LENGTH,
),
};
let street_val = match (opt_line1.clone(), opt_line2.clone()) {
(Some(l1), Some(l2)) => Some(Secret::new(format!("{}, {}", l1.expose(), l2.expose()))),
(Some(l1), None) => Some(l1),
(None, Some(l2)) => Some(l2),
(None, None) => None,
};
if has_address_details_check {
let name_val = opt_full_name;
if let Some(ref val) = name_val {
let length = val.clone().expose().len();
if length > max_name_len {
return Err(error_stack::Report::from(
errors::ConnectorError::MaxFieldLengthViolated {
field_name: format!(
"{address_type_str}.address.first_name & {address_type_str}.address.last_name",
),
connector: "Nexixpay".to_string(),
max_length: max_name_len,
received_length: length,
},
));
}
}
if let Some(ref val) = street_val {
let length = val.clone().expose().len();
if length > max_street_len {
return Err(error_stack::Report::from(
errors::ConnectorError::MaxFieldLengthViolated {
field_name: format!(
"{address_type_str}.address.line1 & {address_type_str}.address.line2",
),
connector: "Nexixpay".to_string(),
max_length: max_street_len,
received_length: length,
},
));
}
}
let city_val = opt_city;
if let Some(ref val) = city_val {
let length = val.len();
if length > max_city_len {
return Err(error_stack::Report::from(
errors::ConnectorError::MaxFieldLengthViolated {
field_name: format!("{address_type_str}.address.city"),
connector: "Nexixpay".to_string(),
max_length: max_city_len,
received_length: length,
},
));
}
}
let post_code_val = opt_zip;
if let Some(ref val) = post_code_val {
let length = val.clone().expose().len();
if length > max_post_code_len {
return Err(error_stack::Report::from(
errors::ConnectorError::MaxFieldLengthViolated {
field_name: format!("{address_type_str}.address.zip"),
connector: "Nexixpay".to_string(),
max_length: max_post_code_len,
received_length: length,
},
));
}
}
let country_val = opt_country;
if let Some(ref val) = country_val {
let length = val.to_string().len();
if length > max_country_len {
return Err(error_stack::Report::from(
errors::ConnectorError::MaxFieldLengthViolated {
field_name: format!("{address_type_str}.address.country"),
connector: "Nexixpay".to_string(),
max_length: max_country_len,
received_length: length,
},
));
}
}
Ok(Some(AddressOutput::new(
name_val,
street_val,
city_val,
post_code_val,
country_val,
)))
} else {
Ok(None)
}
}
const MAX_ORDER_ID_LENGTH: usize = 18;
const MAX_CARD_HOLDER_LENGTH: usize = 255;
const MAX_BILLING_ADDRESS_NAME_LENGTH: usize = 50;
const MAX_BILLING_ADDRESS_STREET_LENGTH: usize = 50;
const MAX_BILLING_ADDRESS_CITY_LENGTH: usize = 40;
const MAX_BILLING_ADDRESS_POST_CODE_LENGTH: usize = 16;
const MAX_BILLING_ADDRESS_COUNTRY_LENGTH: usize = 3;
pub struct NexixpayRouterData<T> {
pub amount: StringMinorUnit,
pub router_data: T,
}
impl<T> From<(StringMinorUnit, T)> for NexixpayRouterData<T> {
fn from((amount, item): (StringMinorUnit, T)) -> Self {
Self {
amount,
router_data: item,
}
}
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
pub enum NexixpayRecurringAction {
NoRecurring,
SubsequentPayment,
ContractCreation,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
pub enum ContractType {
MitUnscheduled,
MitScheduled,
Cit,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct RecurrenceRequest {
action: NexixpayRecurringAction,
contract_id: Option<Secret<String>>,
contract_type: Option<ContractType>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct NexixpayNonMandatePaymentRequest {
card: NexixpayCard,
recurrence: RecurrenceRequest,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct NexixpayMandatePaymentRequest {
contract_id: Secret<String>,
capture_type: Option<NexixpayCaptureType>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
#[serde(untagged)]
pub enum NexixpayPaymentsRequestData {
NexixpayNonMandatePaymentRequest(Box<NexixpayNonMandatePaymentRequest>),
NexixpayMandatePaymentRequest(Box<NexixpayMandatePaymentRequest>),
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct NexixpayPaymentsRequest {
order: Order,
#[serde(flatten)]
payment_data: NexixpayPaymentsRequestData,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
pub enum NexixpayCaptureType {
Implicit,
Explicit,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct NexixpayCompleteAuthorizeRequest {
order: Order,
card: NexixpayCard,
operation_id: String,
capture_type: Option<NexixpayCaptureType>,
three_d_s_auth_data: ThreeDSAuthData,
recurrence: RecurrenceRequest,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct OperationData {
operation_id: String,
operation_currency: Currency,
operation_result: NexixpayPaymentStatus,
operation_type: NexixpayOperationType,
order_id: String,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct NexixpayCompleteAuthorizeResponse {
operation: OperationData,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct NexixpayPreProcessingRequest {
operation_id: Option<String>,
three_d_s_auth_response: Option<Secret<String>>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Order {
order_id: String,
amount: StringMinorUnit,
currency: Currency,
description: Option<String>,
customer_info: CustomerInfo,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct CustomerInfo {
card_holder_name: Secret<String>,
billing_address: Option<BillingAddress>,
shipping_address: Option<ShippingAddress>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct BillingAddress {
name: Option<Secret<String>>,
street: Option<Secret<String>>,
city: Option<String>,
post_code: Option<Secret<String>>,
country: Option<CountryAlpha3>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ShippingAddress {
name: Option<Secret<String>>,
street: Option<Secret<String>>,
city: Option<String>,
post_code: Option<Secret<String>>,
country: Option<CountryAlpha3>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct NexixpayCard {
pan: CardNumber,
expiry_date: Secret<String>,
cvv: Secret<String>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct PaymentsResponse {
operation: Operation,
three_d_s_auth_request: String,
three_d_s_auth_url: Secret<url::Url>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct NexixpayMandateResponse {
operation: Operation,
}
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
#[serde(untagged)]
pub enum NexixpayPaymentsResponse {
PaymentResponse(Box<PaymentsResponse>),
MandateResponse(Box<NexixpayMandateResponse>),
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ThreeDSAuthResult {
authentication_value: Option<Secret<String>>,
}
#[derive(Debug, Clone, Serialize, Deserialize, Eq, PartialEq)]
pub enum NexixpayPaymentIntent {
Capture,
Cancel,
Authorize,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct NexixpayRedirectionRequest {
pub three_d_s_auth_url: String,
pub three_ds_request: String,
pub return_url: String,
pub transaction_id: String,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct NexixpayConnectorMetaData {
pub three_d_s_auth_result: Option<ThreeDSAuthResult>,
pub three_d_s_auth_response: Option<Secret<String>>,
pub authorization_operation_id: Option<String>,
pub capture_operation_id: Option<String>,
pub cancel_operation_id: Option<String>,
pub psync_flow: NexixpayPaymentIntent,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct UpdateNexixpayConnectorMetaData {
pub three_d_s_auth_result: Option<ThreeDSAuthResult>,
pub three_d_s_auth_response: Option<Secret<String>>,
pub authorization_operation_id: Option<String>,
pub capture_operation_id: Option<String>,
pub cancel_operation_id: Option<String>,
pub psync_flow: Option<NexixpayPaymentIntent>,
pub meta_data: serde_json::Value,
pub is_auto_capture: bool,
}
fn update_nexi_meta_data(
update_request: UpdateNexixpayConnectorMetaData,
) -> CustomResult<serde_json::Value, errors::ConnectorError> {
let nexixpay_meta_data =
serde_json::from_value::<NexixpayConnectorMetaData>(update_request.meta_data)
.change_context(errors::ConnectorError::ParsingFailed)?;
Ok(serde_json::json!(NexixpayConnectorMetaData {
three_d_s_auth_result: nexixpay_meta_data
.three_d_s_auth_result
.or(update_request.three_d_s_auth_result),
three_d_s_auth_response: nexixpay_meta_data
.three_d_s_auth_response
.or(update_request.three_d_s_auth_response),
authorization_operation_id: nexixpay_meta_data
.authorization_operation_id
.clone()
.or(update_request.authorization_operation_id.clone()),
capture_operation_id: {
nexixpay_meta_data
.capture_operation_id
.or(if update_request.is_auto_capture {
nexixpay_meta_data
.authorization_operation_id
.or(update_request.authorization_operation_id.clone())
} else {
update_request.capture_operation_id
})
},
cancel_operation_id: nexixpay_meta_data
.cancel_operation_id
.or(update_request.cancel_operation_id),
psync_flow: update_request
.psync_flow
.unwrap_or(nexixpay_meta_data.psync_flow)
}))
}
pub fn get_error_response(
operation_result: NexixpayPaymentStatus,
status_code: u16,
) -> ErrorResponse {
ErrorResponse {
status_code,
code: NO_ERROR_CODE.to_string(),
message: operation_result.to_string(),
reason: Some(operation_result.to_string()),
attempt_status: None,
connector_transaction_id: None,
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
connector_metadata: None,
}
}
fn get_nexi_order_id(payment_id: &str) -> CustomResult<String, errors::ConnectorError> {
if payment_id.len() > MAX_ORDER_ID_LENGTH {
if payment_id.starts_with("pay_") {
Ok(payment_id
.chars()
.take(MAX_ORDER_ID_LENGTH)
.collect::<String>())
} else {
Err(error_stack::Report::from(
errors::ConnectorError::MaxFieldLengthViolated {
field_name: "payment_id".to_string(),
connector: "Nexixpay".to_string(),
max_length: MAX_ORDER_ID_LENGTH,
received_length: payment_id.len(),
},
))
}
} else {
Ok(payment_id.to_string())
}
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ThreeDSAuthData {
three_d_s_auth_response: Option<Secret<String>>,
authentication_value: Option<Secret<String>>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct NexixpayPreProcessingResponse {
operation: Operation,
three_d_s_auth_result: ThreeDSAuthResult,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Operation {
additional_data: AdditionalData,
channel: Option<Channel>,
customer_info: CustomerInfo,
operation_amount: StringMinorUnit,
operation_currency: Currency,
operation_id: String,
operation_result: NexixpayPaymentStatus,
operation_time: String,
operation_type: NexixpayOperationType,
order_id: String,
payment_method: String,
warnings: Option<Vec<DetailedWarnings>>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "UPPERCASE")]
pub enum Channel {
Ecommerce,
Pos,
Backoffice,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct DetailedWarnings {
code: Option<String>,
description: Option<String>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct AdditionalData {
masked_pan: String,
card_id: Secret<String>,
card_id4: Option<Secret<String>>,
card_expiry_date: Option<Secret<String>>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct RedirectPayload {
#[serde(rename = "PaRes")]
pa_res: Option<Secret<String>>,
#[serde(rename = "paymentId")]
payment_id: Option<String>,
}
impl TryFrom<&PaymentsPreProcessingRouterData> for NexixpayPreProcessingRequest {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(item: &PaymentsPreProcessingRouterData) -> Result<Self, Self::Error> {
let redirect_response = item.request.redirect_response.clone().ok_or(
errors::ConnectorError::MissingRequiredField {
field_name: "redirect_response",
},
)?;
let redirect_payload = redirect_response
.payload
.ok_or(errors::ConnectorError::MissingConnectorRedirectionPayload {
field_name: "request.redirect_response.payload",
})?
.expose();
let customer_details_encrypted: RedirectPayload =
serde_json::from_value::<RedirectPayload>(redirect_payload.clone()).change_context(
errors::ConnectorError::MissingConnectorRedirectionPayload {
field_name: "redirection_payload",
},
)?;
Ok(Self {
operation_id: customer_details_encrypted.payment_id,
three_d_s_auth_response: customer_details_encrypted.pa_res,
})
}
}
impl<F>
TryFrom<
ResponseRouterData<
F,
NexixpayPreProcessingResponse,
PaymentsPreProcessingData,
PaymentsResponseData,
>,
> for RouterData<F, PaymentsPreProcessingData, PaymentsResponseData>
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: ResponseRouterData<
F,
NexixpayPreProcessingResponse,
PaymentsPreProcessingData,
PaymentsResponseData,
>,
) -> Result<Self, Self::Error> {
let three_ds_data = item.response.three_d_s_auth_result;
let customer_details_encrypted: RedirectPayload = item
.data
.request
.redirect_response
.as_ref()
.and_then(|res| res.payload.to_owned())
.ok_or(errors::ConnectorError::MissingConnectorRedirectionPayload {
field_name: "request.redirect_response.payload",
})?
.expose()
.parse_value("RedirectPayload")
.change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
let is_auto_capture = item.data.request.is_auto_capture()?;
let meta_data = to_connector_meta_from_secret(item.data.request.metadata.clone())?;
let connector_metadata = Some(update_nexi_meta_data(UpdateNexixpayConnectorMetaData {
three_d_s_auth_result: Some(three_ds_data),
three_d_s_auth_response: customer_details_encrypted.pa_res,
authorization_operation_id: None,
capture_operation_id: None,
cancel_operation_id: None,
psync_flow: None,
meta_data,
is_auto_capture,
})?);
let status = AttemptStatus::from(item.response.operation.operation_result.clone());
match status {
AttemptStatus::Failure => {
let response = Err(get_error_response(
item.response.operation.operation_result.clone(),
item.http_code,
));
Ok(Self {
response,
..item.data
})
}
_ => Ok(Self {
status,
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(
item.response.operation.order_id.clone(),
),
redirection_data: Box::new(None),
mandate_reference: Box::new(None),
connector_metadata,
network_txn_id: None,
connector_response_reference_id: Some(item.response.operation.order_id),
incremental_authorization_allowed: None,
charges: None,
}),
..item.data
}),
}
}
}
impl TryFrom<&NexixpayRouterData<&PaymentsAuthorizeRouterData>> for NexixpayPaymentsRequest {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: &NexixpayRouterData<&PaymentsAuthorizeRouterData>,
) -> Result<Self, Self::Error> {
let order_id = get_nexi_order_id(&item.router_data.payment_id)?;
let billing_address = get_validated_billing_address(item.router_data)?;
let shipping_address = get_validated_shipping_address(item.router_data)?;
let customer_info = CustomerInfo {
card_holder_name: match item.router_data.get_billing_full_name()? {
name if name.clone().expose().len() <= MAX_CARD_HOLDER_LENGTH => name,
_ => {
return Err(error_stack::Report::from(
errors::ConnectorError::MaxFieldLengthViolated {
field_name: "billing.address.first_name & billing.address.last_name"
.to_string(),
connector: "Nexixpay".to_string(),
max_length: MAX_CARD_HOLDER_LENGTH,
received_length: item
.router_data
.get_billing_full_name()?
.expose()
.len(),
},
))
}
},
billing_address: billing_address.clone(),
shipping_address: shipping_address.clone(),
};
let order = Order {
order_id,
amount: item.amount.clone(),
currency: item.router_data.request.currency,
description: item.router_data.description.clone(),
customer_info,
};
let payment_data = NexixpayPaymentsRequestData::try_from(item)?;
Ok(Self {
order,
payment_data,
})
}
}
impl TryFrom<&NexixpayRouterData<&PaymentsAuthorizeRouterData>> for NexixpayPaymentsRequestData {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: &NexixpayRouterData<&PaymentsAuthorizeRouterData>,
) -> Result<Self, Self::Error> {
match item
.router_data
.request
.mandate_id
.clone()
.and_then(|mandate_id| mandate_id.mandate_reference_id)
{
None => {
let recurrence_request_obj = if item.router_data.request.is_mandate_payment() {
let contract_id = item
.router_data
.connector_mandate_request_reference_id
.clone()
.ok_or_else(|| errors::ConnectorError::MissingRequiredField {
field_name: "connector_mandate_request_reference_id",
})?;
RecurrenceRequest {
action: NexixpayRecurringAction::ContractCreation,
contract_id: Some(Secret::new(contract_id)),
contract_type: Some(ContractType::MitUnscheduled),
}
} else {
RecurrenceRequest {
action: NexixpayRecurringAction::NoRecurring,
contract_id: None,
contract_type: None,
}
};
match item.router_data.request.payment_method_data {
PaymentMethodData::Card(ref req_card) => {
if item.router_data.is_three_ds() {
Ok(Self::NexixpayNonMandatePaymentRequest(Box::new(
NexixpayNonMandatePaymentRequest {
card: NexixpayCard {
pan: req_card.card_number.clone(),
expiry_date: req_card.get_expiry_date_as_mmyy()?,
cvv: req_card.card_cvc.clone(),
},
recurrence: recurrence_request_obj,
},
)))
} else {
Err(errors::ConnectorError::NotSupported {
message: "No threeds is not supported".to_string(),
connector: "nexixpay",
}
.into())
}
}
PaymentMethodData::CardRedirect(_)
| PaymentMethodData::Wallet(_)
| PaymentMethodData::PayLater(_)
| PaymentMethodData::BankRedirect(_)
| PaymentMethodData::BankDebit(_)
| PaymentMethodData::BankTransfer(_)
| PaymentMethodData::Crypto(_)
| PaymentMethodData::MandatePayment
| PaymentMethodData::Reward
| PaymentMethodData::RealTimePayment(_)
| PaymentMethodData::Upi(_)
| PaymentMethodData::MobilePayment(_)
| PaymentMethodData::Voucher(_)
| PaymentMethodData::GiftCard(_)
| PaymentMethodData::OpenBanking(_)
| PaymentMethodData::CardToken(_)
| PaymentMethodData::CardDetailsForNetworkTransactionId(_)
| PaymentMethodData::NetworkToken(_) => {
Err(errors::ConnectorError::NotImplemented(
get_unimplemented_payment_method_error_message("nexixpay"),
))?
}
}
}
Some(api_models::payments::MandateReferenceId::ConnectorMandateId(mandate_data)) => {
let contract_id = Secret::new(
mandate_data
.get_connector_mandate_request_reference_id()
.ok_or(errors::ConnectorError::MissingConnectorMandateID)?,
);
let capture_type =
get_nexixpay_capture_type(item.router_data.request.capture_method)?;
Ok(Self::NexixpayMandatePaymentRequest(Box::new(
NexixpayMandatePaymentRequest {
contract_id,
capture_type,
},
)))
}
Some(api_models::payments::MandateReferenceId::NetworkTokenWithNTI(_))
| Some(api_models::payments::MandateReferenceId::NetworkMandateId(_)) => {
Err(errors::ConnectorError::NotImplemented(
get_unimplemented_payment_method_error_message("nexixpay"),
)
.into())
}
}
}
}
pub struct NexixpayAuthType {
pub(super) api_key: Secret<String>,
}
impl TryFrom<&ConnectorAuthType> for NexixpayAuthType {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(auth_type: &ConnectorAuthType) -> Result<Self, Self::Error> {
match auth_type {
ConnectorAuthType::HeaderKey { api_key } => Ok(Self {
api_key: api_key.to_owned(),
}),
_ => Err(errors::ConnectorError::FailedToObtainAuthType.into()),
}
}
}
#[derive(Display, Debug, Clone, Serialize, Deserialize, PartialEq)]
#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
pub enum NexixpayPaymentStatus {
Authorized,
Executed,
Declined,
DeniedByRisk,
ThreedsValidated,
ThreedsFailed,
Pending,
Canceled,
Voided,
Refunded,
Failed,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
pub enum NexixpayOperationType {
Authorization,
Capture,
Void,
Refund,
CardVerification,
Noshow,
Incremental,
DelayCharge,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
pub enum NexixpayRefundOperationType {
Refund,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
pub enum NexixpayRefundResultStatus {
Pending,
Voided,
Refunded,
Failed,
Executed,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct NexixpayTransactionResponse {
order_id: String,
operation_id: String,
operation_result: NexixpayPaymentStatus,
operation_type: NexixpayOperationType,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct NexixpayRSyncResponse {
order_id: String,
operation_id: String,
operation_result: NexixpayRefundResultStatus,
operation_type: NexixpayRefundOperationType,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct NexixpayPaymentsCaptureRequest {
amount: StringMinorUnit,
currency: Currency,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct NexixpayPaymentsCancelRequest {
description: Option<String>,
amount: StringMinorUnit,
currency: Currency,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct NexixpayOperationResponse {
operation_id: String,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct NexixpayRefundRequest {
pub amount: StringMinorUnit,
pub currency: Currency,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct RefundResponse {
operation_id: String,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct NexixpayErrorBody {
pub code: Option<String>,
pub description: Option<String>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct NexixpayErrorResponse {
pub errors: Vec<NexixpayErrorBody>,
}
impl From<NexixpayPaymentStatus> for AttemptStatus {
fn from(item: NexixpayPaymentStatus) -> Self {
match item {
NexixpayPaymentStatus::Declined
| NexixpayPaymentStatus::DeniedByRisk
| NexixpayPaymentStatus::ThreedsFailed
| NexixpayPaymentStatus::Failed => Self::Failure,
NexixpayPaymentStatus::Authorized => Self::Authorized,
NexixpayPaymentStatus::ThreedsValidated => Self::AuthenticationSuccessful,
NexixpayPaymentStatus::Executed => Self::Charged,
NexixpayPaymentStatus::Pending => Self::AuthenticationPending, // this is being used in authorization calls only.
NexixpayPaymentStatus::Canceled | NexixpayPaymentStatus::Voided => Self::Voided,
NexixpayPaymentStatus::Refunded => Self::AutoRefunded,
}
}
}
fn get_nexixpay_capture_type(
item: Option<CaptureMethod>,
) -> CustomResult<Option<NexixpayCaptureType>, errors::ConnectorError> {
match item {
Some(CaptureMethod::Manual) => Ok(Some(NexixpayCaptureType::Explicit)),
Some(CaptureMethod::Automatic) | Some(CaptureMethod::SequentialAutomatic) | None => {
Ok(Some(NexixpayCaptureType::Implicit))
}
Some(item) => Err(errors::ConnectorError::FlowNotSupported {
flow: item.to_string(),
connector: "Nexixpay".to_string(),
}
.into()),
}
}
impl<F>
TryFrom<
ResponseRouterData<
F,
NexixpayPaymentsResponse,
PaymentsAuthorizeData,
PaymentsResponseData,
>,
> for RouterData<F, PaymentsAuthorizeData, PaymentsResponseData>
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: ResponseRouterData<
F,
NexixpayPaymentsResponse,
PaymentsAuthorizeData,
PaymentsResponseData,
>,
) -> Result<Self, Self::Error> {
match item.response {
NexixpayPaymentsResponse::PaymentResponse(ref response_body) => {
let complete_authorize_url = item.data.request.get_complete_authorize_url()?;
let operation_id: String = response_body.operation.operation_id.clone();
let redirection_form = nexixpay_threeds_link(NexixpayRedirectionRequest {
three_d_s_auth_url: response_body
.three_d_s_auth_url
.clone()
.expose()
.to_string(),
three_ds_request: response_body.three_d_s_auth_request.clone(),
return_url: complete_authorize_url.clone(),
transaction_id: operation_id.clone(),
})?;
let is_auto_capture = item.data.request.is_auto_capture()?;
let connector_metadata = Some(serde_json::json!(NexixpayConnectorMetaData {
three_d_s_auth_result: None,
three_d_s_auth_response: None,
authorization_operation_id: Some(operation_id.clone()),
cancel_operation_id: None,
capture_operation_id: {
if is_auto_capture {
Some(operation_id)
} else {
None
}
},
psync_flow: NexixpayPaymentIntent::Authorize
}));
let mandate_reference = if item.data.request.is_mandate_payment() {
Box::new(Some(MandateReference {
connector_mandate_id: item
.data
.connector_mandate_request_reference_id
.clone(),
payment_method_id: None,
mandate_metadata: None,
connector_mandate_request_reference_id: None,
}))
} else {
Box::new(None)
};
let status = AttemptStatus::from(response_body.operation.operation_result.clone());
match status {
AttemptStatus::Failure => {
let response = Err(get_error_response(
response_body.operation.operation_result.clone(),
item.http_code,
));
Ok(Self {
response,
..item.data
})
}
_ => Ok(Self {
status,
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(
response_body.operation.order_id.clone(),
),
redirection_data: Box::new(Some(redirection_form.clone())),
mandate_reference,
connector_metadata,
network_txn_id: None,
connector_response_reference_id: Some(
response_body.operation.order_id.clone(),
),
incremental_authorization_allowed: None,
charges: None,
}),
..item.data
}),
}
}
NexixpayPaymentsResponse::MandateResponse(ref mandate_response) => {
let status =
AttemptStatus::from(mandate_response.operation.operation_result.clone());
let is_auto_capture = item.data.request.is_auto_capture()?;
let operation_id = mandate_response.operation.operation_id.clone();
let connector_metadata = Some(serde_json::json!(NexixpayConnectorMetaData {
three_d_s_auth_result: None,
three_d_s_auth_response: None,
authorization_operation_id: Some(operation_id.clone()),
cancel_operation_id: None,
capture_operation_id: {
if is_auto_capture {
Some(operation_id)
} else {
None
}
},
psync_flow: NexixpayPaymentIntent::Authorize
}));
match status {
AttemptStatus::Failure => {
let response = Err(get_error_response(
mandate_response.operation.operation_result.clone(),
item.http_code,
));
Ok(Self {
response,
..item.data
})
}
_ => Ok(Self {
status,
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(
mandate_response.operation.order_id.clone(),
),
redirection_data: Box::new(None),
mandate_reference: Box::new(None),
connector_metadata,
network_txn_id: None,
connector_response_reference_id: Some(
mandate_response.operation.order_id.clone(),
),
incremental_authorization_allowed: None,
charges: None,
}),
..item.data
}),
}
}
}
}
}
fn nexixpay_threeds_link(
request: NexixpayRedirectionRequest,
) -> CustomResult<RedirectForm, errors::ConnectorError> {
let mut form_fields = HashMap::<String, String>::new();
form_fields.insert(String::from("ThreeDsRequest"), request.three_ds_request);
form_fields.insert(String::from("ReturnUrl"), request.return_url);
form_fields.insert(String::from("transactionId"), request.transaction_id);
Ok(RedirectForm::Form {
endpoint: request.three_d_s_auth_url,
method: Method::Post,
form_fields,
})
}
impl<F> TryFrom<&NexixpayRouterData<&RefundsRouterData<F>>> for NexixpayRefundRequest {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(item: &NexixpayRouterData<&RefundsRouterData<F>>) -> Result<Self, Self::Error> {
Ok(Self {
amount: item.amount.to_owned(),
currency: item.router_data.request.currency,
})
}
}
impl From<NexixpayRefundResultStatus> for RefundStatus {
fn from(item: NexixpayRefundResultStatus) -> Self {
match item {
NexixpayRefundResultStatus::Voided
| NexixpayRefundResultStatus::Refunded
| NexixpayRefundResultStatus::Executed => Self::Success,
NexixpayRefundResultStatus::Pending => Self::Pending,
NexixpayRefundResultStatus::Failed => Self::Failure,
}
}
}
impl TryFrom<RefundsResponseRouterData<Execute, RefundResponse>> for RefundsRouterData<Execute> {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: RefundsResponseRouterData<Execute, RefundResponse>,
) -> Result<Self, Self::Error> {
Ok(Self {
response: Ok(RefundsResponseData {
connector_refund_id: item.response.operation_id,
refund_status: RefundStatus::Pending, // Refund call do not return status in their response.
}),
..item.data
})
}
}
impl TryFrom<RefundsResponseRouterData<RSync, NexixpayRSyncResponse>> for RefundsRouterData<RSync> {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: RefundsResponseRouterData<RSync, NexixpayRSyncResponse>,
) -> Result<Self, Self::Error> {
Ok(Self {
response: Ok(RefundsResponseData {
connector_refund_id: item.response.operation_id,
refund_status: RefundStatus::from(item.response.operation_result),
}),
..item.data
})
}
}
impl<F>
TryFrom<
ResponseRouterData<
F,
NexixpayCompleteAuthorizeResponse,
CompleteAuthorizeData,
PaymentsResponseData,
>,
> for RouterData<F, CompleteAuthorizeData, PaymentsResponseData>
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: ResponseRouterData<
F,
NexixpayCompleteAuthorizeResponse,
CompleteAuthorizeData,
PaymentsResponseData,
>,
) -> Result<Self, Self::Error> {
let is_auto_capture = item.data.request.is_auto_capture()?;
let meta_data = to_connector_meta(item.data.request.connector_meta.clone())?;
let connector_metadata = Some(update_nexi_meta_data(UpdateNexixpayConnectorMetaData {
three_d_s_auth_result: None,
three_d_s_auth_response: None,
authorization_operation_id: Some(item.response.operation.operation_id.clone()),
capture_operation_id: None,
cancel_operation_id: None,
psync_flow: Some(NexixpayPaymentIntent::Authorize),
meta_data,
is_auto_capture,
})?);
let mandate_reference = if item.data.request.is_mandate_payment() {
Box::new(Some(MandateReference {
connector_mandate_id: item.data.connector_mandate_request_reference_id.clone(),
payment_method_id: None,
mandate_metadata: None,
connector_mandate_request_reference_id: None,
}))
} else {
Box::new(None)
};
let status = if item.data.request.amount == 0
&& item.response.operation.operation_result == NexixpayPaymentStatus::Authorized
{
AttemptStatus::Charged
} else {
AttemptStatus::from(item.response.operation.operation_result.clone())
};
match status {
AttemptStatus::Failure => {
let response = Err(get_error_response(
item.response.operation.operation_result.clone(),
item.http_code,
));
Ok(Self {
response,
..item.data
})
}
_ => Ok(Self {
status,
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(
item.response.operation.order_id.clone(),
),
redirection_data: Box::new(None),
mandate_reference,
connector_metadata,
network_txn_id: None,
connector_response_reference_id: Some(item.response.operation.order_id),
incremental_authorization_allowed: None,
charges: None,
}),
..item.data
}),
}
}
}
impl TryFrom<&NexixpayRouterData<&PaymentsCompleteAuthorizeRouterData>>
for NexixpayCompleteAuthorizeRequest
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: &NexixpayRouterData<&PaymentsCompleteAuthorizeRouterData>,
) -> Result<Self, Self::Error> {
let payment_method_data: PaymentMethodData =
item.router_data.request.payment_method_data.clone().ok_or(
errors::ConnectorError::MissingRequiredField {
field_name: "payment_method_data",
},
)?;
let capture_type = get_nexixpay_capture_type(item.router_data.request.capture_method)?;
let order_id = get_nexi_order_id(&item.router_data.payment_id)?;
let amount = item.amount.clone();
let billing_address = get_validated_billing_address(item.router_data)?;
let shipping_address = get_validated_shipping_address(item.router_data)?;
let customer_info = CustomerInfo {
card_holder_name: item.router_data.get_billing_full_name()?,
billing_address: billing_address.clone(),
shipping_address: shipping_address.clone(),
};
let order_data = Order {
order_id,
amount,
currency: item.router_data.request.currency,
description: item.router_data.description.clone(),
customer_info,
};
let connector_metadata =
to_connector_meta(item.router_data.request.connector_meta.clone())?;
let nexixpay_meta_data =
serde_json::from_value::<NexixpayConnectorMetaData>(connector_metadata)
.change_context(errors::ConnectorError::ParsingFailed)?;
let operation_id = nexixpay_meta_data.authorization_operation_id.ok_or(
errors::ConnectorError::MissingRequiredField {
field_name: "authorization_operation_id",
},
)?;
let authentication_value = nexixpay_meta_data
.three_d_s_auth_result
.and_then(|data| data.authentication_value);
let three_d_s_auth_data = ThreeDSAuthData {
three_d_s_auth_response: nexixpay_meta_data.three_d_s_auth_response,
authentication_value,
};
let card: Result<NexixpayCard, error_stack::Report<errors::ConnectorError>> =
match payment_method_data {
PaymentMethodData::Card(req_card) => Ok(NexixpayCard {
pan: req_card.card_number.clone(),
expiry_date: req_card.get_expiry_date_as_mmyy()?,
cvv: req_card.card_cvc.clone(),
}),
PaymentMethodData::CardRedirect(_)
| PaymentMethodData::Wallet(_)
| PaymentMethodData::PayLater(_)
| PaymentMethodData::BankRedirect(_)
| PaymentMethodData::BankDebit(_)
| PaymentMethodData::BankTransfer(_)
| PaymentMethodData::Crypto(_)
| PaymentMethodData::MandatePayment
| PaymentMethodData::Reward
| PaymentMethodData::RealTimePayment(_)
| PaymentMethodData::MobilePayment(_)
| PaymentMethodData::Upi(_)
| PaymentMethodData::Voucher(_)
| PaymentMethodData::GiftCard(_)
| PaymentMethodData::OpenBanking(_)
| PaymentMethodData::CardToken(_)
| PaymentMethodData::NetworkToken(_)
| PaymentMethodData::CardDetailsForNetworkTransactionId(_) => {
Err(errors::ConnectorError::NotImplemented(
get_unimplemented_payment_method_error_message("nexixpay"),
)
.into())
}
};
let recurrence_request_obj = if item.router_data.request.is_mandate_payment() {
let contract_id = Secret::new(
item.router_data
.connector_mandate_request_reference_id
.clone()
.ok_or_else(|| errors::ConnectorError::MissingRequiredField {
field_name: "connector_mandate_request_reference_id",
})?,
);
RecurrenceRequest {
action: NexixpayRecurringAction::ContractCreation,
contract_id: Some(contract_id),
contract_type: Some(ContractType::MitUnscheduled),
}
} else {
RecurrenceRequest {
action: NexixpayRecurringAction::NoRecurring,
contract_id: None,
contract_type: None,
}
};
Ok(Self {
order: order_data,
card: card?,
operation_id,
capture_type,
three_d_s_auth_data,
recurrence: recurrence_request_obj,
})
}
}
fn get_validated_shipping_address<RouterContextDataAlias>(
data: &RouterContextDataAlias,
) -> Result<Option<ShippingAddress>, error_stack::Report<errors::ConnectorError>>
where
RouterContextDataAlias: crate::utils::RouterData,
{
get_validated_address_details_generic(data, AddressKind::Shipping)
}
fn get_validated_billing_address<RouterContextDataAlias>(
data: &RouterContextDataAlias,
) -> Result<Option<BillingAddress>, error_stack::Report<errors::ConnectorError>>
where
RouterContextDataAlias: crate::utils::RouterData,
{
get_validated_address_details_generic(data, AddressKind::Billing)
}
impl<F>
TryFrom<
ResponseRouterData<F, NexixpayTransactionResponse, PaymentsSyncData, PaymentsResponseData>,
> for RouterData<F, PaymentsSyncData, PaymentsResponseData>
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: ResponseRouterData<
F,
NexixpayTransactionResponse,
PaymentsSyncData,
PaymentsResponseData,
>,
) -> Result<Self, Self::Error> {
let status = AttemptStatus::from(item.response.operation_result.clone());
let mandate_reference = if item.data.request.is_mandate_payment() {
Box::new(Some(MandateReference {
connector_mandate_id: item.data.connector_mandate_request_reference_id.clone(),
payment_method_id: None,
mandate_metadata: None,
connector_mandate_request_reference_id: None,
}))
} else {
Box::new(None)
};
match status {
AttemptStatus::Failure => {
let response = Err(get_error_response(
item.response.operation_result.clone(),
item.http_code,
));
Ok(Self {
response,
..item.data
})
}
_ => Ok(Self {
status,
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(item.response.order_id.clone()),
redirection_data: Box::new(None),
mandate_reference,
connector_metadata: item.data.request.connector_meta.clone(),
network_txn_id: None,
connector_response_reference_id: Some(item.response.order_id.clone()),
incremental_authorization_allowed: None,
charges: None,
}),
..item.data
}),
}
}
}
impl TryFrom<&NexixpayRouterData<&PaymentsCaptureRouterData>> for NexixpayPaymentsCaptureRequest {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: &NexixpayRouterData<&PaymentsCaptureRouterData>,
) -> Result<Self, Self::Error> {
Ok(Self {
amount: item.amount.clone(),
currency: item.router_data.request.currency,
})
}
}
impl<F>
TryFrom<
ResponseRouterData<F, NexixpayOperationResponse, PaymentsCaptureData, PaymentsResponseData>,
> for RouterData<F, PaymentsCaptureData, PaymentsResponseData>
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: ResponseRouterData<
F,
NexixpayOperationResponse,
PaymentsCaptureData,
PaymentsResponseData,
>,
) -> Result<Self, Self::Error> {
let meta_data = to_connector_meta(item.data.request.connector_meta.clone())?;
let connector_metadata = Some(update_nexi_meta_data(UpdateNexixpayConnectorMetaData {
three_d_s_auth_result: None,
three_d_s_auth_response: None,
authorization_operation_id: None,
capture_operation_id: Some(item.response.operation_id.clone()),
cancel_operation_id: None,
psync_flow: Some(NexixpayPaymentIntent::Capture),
meta_data,
is_auto_capture: false,
})?);
Ok(Self {
status: AttemptStatus::Pending, // Capture call do not return status in their response.
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(
item.data.request.connector_transaction_id.clone(),
),
redirection_data: Box::new(None),
mandate_reference: Box::new(None),
connector_metadata,
network_txn_id: None,
connector_response_reference_id: Some(
item.data.request.connector_transaction_id.clone(),
),
incremental_authorization_allowed: None,
charges: None,
}),
..item.data
})
}
}
impl TryFrom<NexixpayRouterData<&PaymentsCancelRouterData>> for NexixpayPaymentsCancelRequest {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(item: NexixpayRouterData<&PaymentsCancelRouterData>) -> Result<Self, Self::Error> {
let description = item.router_data.request.cancellation_reason.clone();
let currency = item.router_data.request.currency.ok_or(
errors::ConnectorError::MissingRequiredField {
field_name: "currency",
},
)?;
Ok(Self {
amount: item.amount,
currency,
description,
})
}
}
impl<F>
TryFrom<
ResponseRouterData<F, NexixpayOperationResponse, PaymentsCancelData, PaymentsResponseData>,
> for RouterData<F, PaymentsCancelData, PaymentsResponseData>
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: ResponseRouterData<
F,
NexixpayOperationResponse,
PaymentsCancelData,
PaymentsResponseData,
>,
) -> Result<Self, Self::Error> {
let meta_data = to_connector_meta(item.data.request.connector_meta.clone())?;
let connector_metadata = Some(update_nexi_meta_data(UpdateNexixpayConnectorMetaData {
three_d_s_auth_result: None,
three_d_s_auth_response: None,
authorization_operation_id: None,
capture_operation_id: None,
cancel_operation_id: Some(item.response.operation_id.clone()),
psync_flow: Some(NexixpayPaymentIntent::Cancel),
meta_data,
is_auto_capture: false,
})?);
Ok(Self {
status: AttemptStatus::Pending, // Cancel call do not return status in their response.
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(
item.data.request.connector_transaction_id.clone(),
),
redirection_data: Box::new(None),
mandate_reference: Box::new(None),
connector_metadata,
network_txn_id: None,
connector_response_reference_id: Some(
item.data.request.connector_transaction_id.clone(),
),
incremental_authorization_allowed: None,
charges: None,
}),
..item.data
})
}
}
impl
TryFrom<
ResponseRouterData<
SetupMandate,
PaymentsResponse,
SetupMandateRequestData,
PaymentsResponseData,
>,
> for RouterData<SetupMandate, SetupMandateRequestData, PaymentsResponseData>
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: ResponseRouterData<
SetupMandate,
PaymentsResponse,
SetupMandateRequestData,
PaymentsResponseData,
>,
) -> Result<Self, Self::Error> {
let complete_authorize_url = item.data.request.get_complete_authorize_url()?;
let operation_id: String = item.response.operation.operation_id.clone();
let redirection_form = nexixpay_threeds_link(NexixpayRedirectionRequest {
three_d_s_auth_url: item
.response
.three_d_s_auth_url
.clone()
.expose()
.to_string(),
three_ds_request: item.response.three_d_s_auth_request.clone(),
return_url: complete_authorize_url.clone(),
transaction_id: operation_id.clone(),
})?;
let is_auto_capture = item.data.request.is_auto_capture()?;
let connector_metadata = Some(serde_json::json!(NexixpayConnectorMetaData {
three_d_s_auth_result: None,
three_d_s_auth_response: None,
authorization_operation_id: Some(operation_id.clone()),
cancel_operation_id: None,
capture_operation_id: {
if is_auto_capture {
Some(operation_id)
} else {
None
}
},
psync_flow: NexixpayPaymentIntent::Authorize
}));
let status = AttemptStatus::from(item.response.operation.operation_result.clone());
match status {
AttemptStatus::Failure => {
let response = Err(get_error_response(
item.response.operation.operation_result.clone(),
item.http_code,
));
Ok(Self {
response,
..item.data
})
}
_ => Ok(Self {
status,
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(
item.response.operation.order_id.clone(),
),
redirection_data: Box::new(Some(redirection_form.clone())),
mandate_reference: Box::new(Some(MandateReference {
connector_mandate_id: item
.data
.connector_mandate_request_reference_id
.clone(),
payment_method_id: None,
mandate_metadata: None,
connector_mandate_request_reference_id: None,
})),
connector_metadata,
network_txn_id: None,
connector_response_reference_id: Some(item.response.operation.order_id.clone()),
incremental_authorization_allowed: None,
charges: None,
}),
..item.data
}),
}
}
}
|
{
"crate": "hyperswitch_connectors",
"file": "crates/hyperswitch_connectors/src/connectors/nexixpay/transformers.rs",
"file_size": null,
"is_async": null,
"is_pub": null,
"num_enums": 12,
"num_structs": 34,
"num_tables": null,
"score": null,
"total_crates": null
}
|
file_hyperswitch_connectors_148810780673833958
|
clm
|
file
|
// Repository: hyperswitch
// Crate: hyperswitch_connectors
// File: crates/hyperswitch_connectors/src/connectors/novalnet/transformers.rs
// Contains: 44 structs, 10 enums
use std::collections::HashMap;
use api_models::webhooks::IncomingWebhookEvent;
use cards::CardNumber;
use common_enums::{enums, enums as api_enums};
use common_utils::{
consts,
ext_traits::OptionExt,
pii::Email,
request::Method,
types::{MinorUnit, StringMinorUnit},
};
use error_stack::ResultExt;
use hyperswitch_domain_models::{
payment_method_data::{
BankDebitData, PaymentMethodData, WalletData as WalletDataPaymentMethod,
},
router_data::{ConnectorAuthType, ErrorResponse, RouterData},
router_flow_types::refunds::{Execute, RSync},
router_request_types::{PaymentsCancelData, PaymentsCaptureData, PaymentsSyncData, ResponseId},
router_response_types::{
MandateReference, PaymentsResponseData, RedirectForm, RefundsResponseData,
},
types::{
PaymentsAuthorizeRouterData, PaymentsCancelRouterData, PaymentsCaptureRouterData,
PaymentsSyncRouterData, RefundSyncRouterData, RefundsRouterData, SetupMandateRouterData,
},
};
use hyperswitch_interfaces::errors;
use masking::{ExposeInterface, Secret};
use serde::{Deserialize, Serialize};
use strum::Display;
use crate::{
types::{RefundsResponseRouterData, ResponseRouterData},
utils::{
self, AddressData, AddressDetailsData, ApplePay, PaymentsAuthorizeRequestData,
PaymentsCancelRequestData, PaymentsCaptureRequestData, PaymentsSetupMandateRequestData,
PaymentsSyncRequestData, RefundsRequestData, RouterData as _,
},
};
pub struct NovalnetRouterData<T> {
pub amount: StringMinorUnit,
pub router_data: T,
}
impl<T> From<(StringMinorUnit, T)> for NovalnetRouterData<T> {
fn from((amount, item): (StringMinorUnit, T)) -> Self {
Self {
amount,
router_data: item,
}
}
}
const MINIMAL_CUSTOMER_DATA_PASSED: i64 = 1;
const CREATE_TOKEN_REQUIRED: i8 = 1;
const TEST_MODE_ENABLED: i8 = 1;
const TEST_MODE_DISABLED: i8 = 0;
fn get_test_mode(item: Option<bool>) -> i8 {
match item {
Some(true) => TEST_MODE_ENABLED,
Some(false) | None => TEST_MODE_DISABLED,
}
}
#[derive(Debug, Copy, Serialize, Deserialize, Clone)]
pub enum NovalNetPaymentTypes {
CREDITCARD,
PAYPAL,
GOOGLEPAY,
APPLEPAY,
#[serde(rename = "DIRECT_DEBIT_SEPA")]
DirectDebitSepa,
#[serde(rename = "GUARANTEED_DIRECT_DEBIT_SEPA")]
GuaranteedDirectDebitSepa,
}
#[derive(Default, Debug, Serialize, Clone)]
pub struct NovalnetPaymentsRequestMerchant {
signature: Secret<String>,
tariff: Secret<String>,
}
#[derive(Default, Debug, Serialize, Clone)]
pub struct NovalnetPaymentsRequestBilling {
house_no: Option<Secret<String>>,
street: Option<Secret<String>>,
city: Option<Secret<String>>,
zip: Option<Secret<String>>,
country_code: Option<api_enums::CountryAlpha2>,
}
#[derive(Default, Debug, Serialize, Clone)]
pub struct NovalnetPaymentsRequestCustomer {
first_name: Option<Secret<String>>,
last_name: Option<Secret<String>>,
email: Email,
mobile: Option<Secret<String>>,
billing: Option<NovalnetPaymentsRequestBilling>,
no_nc: i64,
birth_date: Option<String>, // Mandatory for SEPA Guarentee Payment
}
#[derive(Default, Debug, Clone, Serialize, Deserialize)]
pub struct NovalnetCard {
card_number: CardNumber,
card_expiry_month: Secret<String>,
card_expiry_year: Secret<String>,
card_cvc: Secret<String>,
card_holder: Secret<String>,
}
#[derive(Default, Debug, Clone, Serialize, Deserialize)]
pub struct NovalnetRawCardDetails {
card_number: CardNumber,
card_expiry_month: Secret<String>,
card_expiry_year: Secret<String>,
scheme_tid: Secret<String>,
}
#[derive(Debug, Serialize, Deserialize, Clone)]
pub struct NovalnetMandate {
token: Secret<String>,
}
#[derive(Debug, Serialize, Deserialize, Clone)]
pub struct NovalnetSepaDebit {
account_holder: Secret<String>,
iban: Secret<String>,
birth_date: Option<String>, // Mandatory for SEPA Guarantee Payment
}
#[derive(Default, Debug, Clone, Serialize, Deserialize)]
pub struct NovalnetGooglePay {
wallet_data: Secret<String>,
}
#[derive(Default, Debug, Clone, Serialize, Deserialize)]
pub struct NovalnetApplePay {
wallet_data: Secret<String>,
}
#[derive(Debug, Serialize, Deserialize, Clone)]
#[serde(untagged)]
pub enum NovalNetPaymentData {
Card(NovalnetCard),
RawCardForNTI(NovalnetRawCardDetails),
GooglePay(NovalnetGooglePay),
ApplePay(NovalnetApplePay),
MandatePayment(NovalnetMandate),
Sepa(NovalnetSepaDebit),
}
#[derive(Default, Debug, Serialize, Clone)]
pub struct NovalnetCustom {
lang: String,
}
#[derive(Debug, Serialize, Deserialize, Clone)]
#[serde(untagged)]
pub enum NovalNetAmount {
StringMinor(StringMinorUnit),
Int(i64),
}
#[derive(Debug, Serialize, Deserialize, Clone)]
pub struct NovalnetPaymentsRequestTransaction {
test_mode: i8,
payment_type: NovalNetPaymentTypes,
amount: NovalNetAmount,
currency: common_enums::Currency,
order_no: String,
payment_data: Option<NovalNetPaymentData>,
hook_url: Option<String>,
return_url: Option<String>,
error_return_url: Option<String>,
enforce_3d: Option<i8>, //NOTE: Needed for CREDITCARD, GOOGLEPAY
create_token: Option<i8>,
}
#[derive(Debug, Serialize, Clone)]
pub struct NovalnetPaymentsRequest {
merchant: NovalnetPaymentsRequestMerchant,
customer: NovalnetPaymentsRequestCustomer,
transaction: NovalnetPaymentsRequestTransaction,
custom: NovalnetCustom,
}
impl TryFrom<&api_enums::PaymentMethodType> for NovalNetPaymentTypes {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(item: &api_enums::PaymentMethodType) -> Result<Self, Self::Error> {
match item {
api_enums::PaymentMethodType::ApplePay => Ok(Self::APPLEPAY),
api_enums::PaymentMethodType::Credit | api_enums::PaymentMethodType::Debit => {
Ok(Self::CREDITCARD)
}
api_enums::PaymentMethodType::GooglePay => Ok(Self::GOOGLEPAY),
api_enums::PaymentMethodType::Paypal => Ok(Self::PAYPAL),
api_enums::PaymentMethodType::Sepa => Ok(Self::DirectDebitSepa),
api_enums::PaymentMethodType::SepaGuarenteedDebit => {
Ok(Self::GuaranteedDirectDebitSepa)
}
_ => Err(errors::ConnectorError::NotImplemented(
utils::get_unimplemented_payment_method_error_message("Novalnet"),
)
.into()),
}
}
}
impl TryFrom<&NovalnetRouterData<&PaymentsAuthorizeRouterData>> for NovalnetPaymentsRequest {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: &NovalnetRouterData<&PaymentsAuthorizeRouterData>,
) -> Result<Self, Self::Error> {
let auth = NovalnetAuthType::try_from(&item.router_data.connector_auth_type)?;
let merchant = NovalnetPaymentsRequestMerchant {
signature: auth.product_activation_key,
tariff: auth.tariff_id,
};
let enforce_3d = match item.router_data.auth_type {
enums::AuthenticationType::ThreeDs => Some(1),
enums::AuthenticationType::NoThreeDs => None,
};
let test_mode = get_test_mode(item.router_data.test_mode);
let billing = NovalnetPaymentsRequestBilling {
house_no: item.router_data.get_optional_billing_line1(),
street: item.router_data.get_optional_billing_line2(),
city: item
.router_data
.get_optional_billing_city()
.map(Secret::new),
zip: item.router_data.get_optional_billing_zip(),
country_code: item.router_data.get_optional_billing_country(),
};
let customer = NovalnetPaymentsRequestCustomer {
first_name: item.router_data.get_optional_billing_first_name(),
last_name: item.router_data.get_optional_billing_last_name(),
email: item
.router_data
.get_billing_email()
.or(item.router_data.request.get_email())?,
mobile: item.router_data.get_optional_billing_phone_number(),
billing: Some(billing),
// no_nc is used to indicate if minimal customer data is passed or not
no_nc: MINIMAL_CUSTOMER_DATA_PASSED,
birth_date: Some(String::from("1992-06-10")),
};
let lang = item
.router_data
.request
.get_optional_language_from_browser_info()
.unwrap_or(consts::DEFAULT_LOCALE.to_string().to_string());
let custom = NovalnetCustom { lang };
let hook_url = item.router_data.request.get_webhook_url()?;
let return_url = item.router_data.request.get_router_return_url()?;
let create_token = if item.router_data.request.is_mandate_payment() {
Some(CREATE_TOKEN_REQUIRED)
} else {
None
};
match item
.router_data
.request
.mandate_id
.clone()
.and_then(|mandate_id| mandate_id.mandate_reference_id)
{
None => match &item.router_data.request.payment_method_data {
PaymentMethodData::Card(ref req_card) => {
let novalnet_card = NovalNetPaymentData::Card(NovalnetCard {
card_number: req_card.card_number.clone(),
card_expiry_month: req_card.card_exp_month.clone(),
card_expiry_year: req_card.card_exp_year.clone(),
card_cvc: req_card.card_cvc.clone(),
card_holder: item.router_data.get_billing_full_name()?,
});
let transaction = NovalnetPaymentsRequestTransaction {
test_mode,
payment_type: NovalNetPaymentTypes::CREDITCARD,
amount: NovalNetAmount::StringMinor(item.amount.clone()),
currency: item.router_data.request.currency,
order_no: item.router_data.connector_request_reference_id.clone(),
hook_url: Some(hook_url),
return_url: Some(return_url.clone()),
error_return_url: Some(return_url.clone()),
payment_data: Some(novalnet_card),
enforce_3d,
create_token,
};
Ok(Self {
merchant,
transaction,
customer,
custom,
})
}
PaymentMethodData::Wallet(ref wallet_data) => match wallet_data {
WalletDataPaymentMethod::GooglePay(ref req_wallet) => {
let novalnet_google_pay: NovalNetPaymentData =
NovalNetPaymentData::GooglePay(NovalnetGooglePay {
wallet_data: Secret::new(
req_wallet
.tokenization_data
.get_encrypted_google_pay_token()
.change_context(
errors::ConnectorError::MissingRequiredField {
field_name: "gpay wallet_token",
},
)?
.clone(),
),
});
let transaction = NovalnetPaymentsRequestTransaction {
test_mode,
payment_type: NovalNetPaymentTypes::GOOGLEPAY,
amount: NovalNetAmount::StringMinor(item.amount.clone()),
currency: item.router_data.request.currency,
order_no: item.router_data.connector_request_reference_id.clone(),
hook_url: Some(hook_url),
return_url: None,
error_return_url: None,
payment_data: Some(novalnet_google_pay),
enforce_3d,
create_token,
};
Ok(Self {
merchant,
transaction,
customer,
custom,
})
}
WalletDataPaymentMethod::ApplePay(payment_method_data) => {
let transaction = NovalnetPaymentsRequestTransaction {
test_mode,
payment_type: NovalNetPaymentTypes::APPLEPAY,
amount: NovalNetAmount::StringMinor(item.amount.clone()),
currency: item.router_data.request.currency,
order_no: item.router_data.connector_request_reference_id.clone(),
hook_url: Some(hook_url),
return_url: None,
error_return_url: None,
payment_data: Some(NovalNetPaymentData::ApplePay(NovalnetApplePay {
wallet_data: payment_method_data
.get_applepay_decoded_payment_data()?,
})),
enforce_3d: None,
create_token,
};
Ok(Self {
merchant,
transaction,
customer,
custom,
})
}
WalletDataPaymentMethod::AliPayQr(_)
| WalletDataPaymentMethod::AliPayRedirect(_)
| WalletDataPaymentMethod::AliPayHkRedirect(_)
| WalletDataPaymentMethod::AmazonPay(_)
| WalletDataPaymentMethod::AmazonPayRedirect(_)
| WalletDataPaymentMethod::Paysera(_)
| WalletDataPaymentMethod::Skrill(_)
| WalletDataPaymentMethod::BluecodeRedirect {}
| WalletDataPaymentMethod::MomoRedirect(_)
| WalletDataPaymentMethod::KakaoPayRedirect(_)
| WalletDataPaymentMethod::GoPayRedirect(_)
| WalletDataPaymentMethod::GcashRedirect(_)
| WalletDataPaymentMethod::ApplePayRedirect(_)
| WalletDataPaymentMethod::ApplePayThirdPartySdk(_)
| WalletDataPaymentMethod::DanaRedirect {}
| WalletDataPaymentMethod::GooglePayRedirect(_)
| WalletDataPaymentMethod::GooglePayThirdPartySdk(_)
| WalletDataPaymentMethod::MbWayRedirect(_)
| WalletDataPaymentMethod::MobilePayRedirect(_)
| WalletDataPaymentMethod::RevolutPay(_) => {
Err(errors::ConnectorError::NotImplemented(
utils::get_unimplemented_payment_method_error_message("novalnet"),
)
.into())
}
WalletDataPaymentMethod::PaypalRedirect(_) => {
let transaction = NovalnetPaymentsRequestTransaction {
test_mode,
payment_type: NovalNetPaymentTypes::PAYPAL,
amount: NovalNetAmount::StringMinor(item.amount.clone()),
currency: item.router_data.request.currency,
order_no: item.router_data.connector_request_reference_id.clone(),
hook_url: Some(hook_url),
return_url: Some(return_url.clone()),
error_return_url: Some(return_url.clone()),
payment_data: None,
enforce_3d: None,
create_token,
};
Ok(Self {
merchant,
transaction,
customer,
custom,
})
}
WalletDataPaymentMethod::PaypalSdk(_)
| WalletDataPaymentMethod::Paze(_)
| WalletDataPaymentMethod::SamsungPay(_)
| WalletDataPaymentMethod::TwintRedirect {}
| WalletDataPaymentMethod::VippsRedirect {}
| WalletDataPaymentMethod::TouchNGoRedirect(_)
| WalletDataPaymentMethod::WeChatPayRedirect(_)
| WalletDataPaymentMethod::CashappQr(_)
| WalletDataPaymentMethod::SwishQr(_)
| WalletDataPaymentMethod::WeChatPayQr(_)
| WalletDataPaymentMethod::Mifinity(_) => {
Err(errors::ConnectorError::NotImplemented(
utils::get_unimplemented_payment_method_error_message("novalnet"),
)
.into())
}
},
PaymentMethodData::BankDebit(bank_debit_data) => {
let payment_type = NovalNetPaymentTypes::try_from(
&item
.router_data
.request
.payment_method_type
.ok_or(errors::ConnectorError::MissingPaymentMethodType)?,
)?;
let (iban, account_holder, dob) = match bank_debit_data {
BankDebitData::SepaBankDebit {
iban,
bank_account_holder_name,
} => {
let account_holder = match bank_account_holder_name {
Some(name) => name.clone(),
None => item.router_data.get_billing_full_name()?,
};
(iban, account_holder, None)
}
BankDebitData::SepaGuarenteedBankDebit {
iban,
bank_account_holder_name,
} => {
let account_holder = match bank_account_holder_name {
Some(name) => name.clone(),
None => item.router_data.get_billing_full_name()?,
};
(iban, account_holder, Some(String::from("1992-06-10")))
}
_ => {
return Err(
errors::ConnectorError::NotImplemented("SEPA".to_string()).into()
);
}
};
let transaction = NovalnetPaymentsRequestTransaction {
test_mode,
payment_type,
amount: NovalNetAmount::StringMinor(item.amount.clone()),
currency: item.router_data.request.currency,
order_no: item.router_data.connector_request_reference_id.clone(),
hook_url: Some(hook_url),
return_url: Some(return_url.clone()),
error_return_url: Some(return_url.clone()),
payment_data: Some(NovalNetPaymentData::Sepa(NovalnetSepaDebit {
account_holder: account_holder.clone(),
iban: iban.clone(),
birth_date: dob,
})),
enforce_3d,
create_token,
};
Ok(Self {
merchant,
transaction,
customer,
custom,
})
}
_ => Err(errors::ConnectorError::NotImplemented(
utils::get_unimplemented_payment_method_error_message("novalnet"),
)
.into()),
},
Some(api_models::payments::MandateReferenceId::ConnectorMandateId(mandate_data)) => {
let connector_mandate_id = mandate_data.get_connector_mandate_id().ok_or(
errors::ConnectorError::MissingRequiredField {
field_name: "connector_mandate_id",
},
)?;
let novalnet_mandate_data = NovalNetPaymentData::MandatePayment(NovalnetMandate {
token: Secret::new(connector_mandate_id),
});
let payment_type = match item.router_data.request.payment_method_type {
Some(pm_type) => NovalNetPaymentTypes::try_from(&pm_type)?,
None => NovalNetPaymentTypes::CREDITCARD,
};
let transaction = NovalnetPaymentsRequestTransaction {
test_mode,
payment_type,
amount: NovalNetAmount::StringMinor(item.amount.clone()),
currency: item.router_data.request.currency,
order_no: item.router_data.connector_request_reference_id.clone(),
hook_url: Some(hook_url),
return_url: None,
error_return_url: None,
payment_data: Some(novalnet_mandate_data),
enforce_3d,
create_token: None,
};
Ok(Self {
merchant,
transaction,
customer,
custom,
})
}
Some(api_models::payments::MandateReferenceId::NetworkMandateId(
network_transaction_id,
)) => match item.router_data.request.payment_method_data {
PaymentMethodData::CardDetailsForNetworkTransactionId(ref raw_card_details) => {
let novalnet_card =
NovalNetPaymentData::RawCardForNTI(NovalnetRawCardDetails {
card_number: raw_card_details.card_number.clone(),
card_expiry_month: raw_card_details.card_exp_month.clone(),
card_expiry_year: raw_card_details.card_exp_year.clone(),
scheme_tid: network_transaction_id.into(),
});
let transaction = NovalnetPaymentsRequestTransaction {
test_mode,
payment_type: NovalNetPaymentTypes::CREDITCARD,
amount: NovalNetAmount::StringMinor(item.amount.clone()),
currency: item.router_data.request.currency,
order_no: item.router_data.connector_request_reference_id.clone(),
hook_url: Some(hook_url),
return_url: Some(return_url.clone()),
error_return_url: Some(return_url.clone()),
payment_data: Some(novalnet_card),
enforce_3d,
create_token,
};
Ok(Self {
merchant,
transaction,
customer,
custom,
})
}
_ => Err(errors::ConnectorError::NotImplemented(
utils::get_unimplemented_payment_method_error_message("novalnet"),
)
.into()),
},
_ => Err(errors::ConnectorError::NotImplemented(
utils::get_unimplemented_payment_method_error_message("novalnet"),
)
.into()),
}
}
}
// Auth Struct
pub struct NovalnetAuthType {
pub(super) product_activation_key: Secret<String>,
pub(super) payment_access_key: Secret<String>,
pub(super) tariff_id: Secret<String>,
}
impl TryFrom<&ConnectorAuthType> for NovalnetAuthType {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(auth_type: &ConnectorAuthType) -> Result<Self, Self::Error> {
match auth_type {
ConnectorAuthType::SignatureKey {
api_key,
key1,
api_secret,
} => Ok(Self {
product_activation_key: api_key.to_owned(),
payment_access_key: key1.to_owned(),
tariff_id: api_secret.to_owned(),
}),
_ => Err(errors::ConnectorError::FailedToObtainAuthType.into()),
}
}
}
// PaymentsResponse
#[derive(Debug, Display, Copy, Clone, Serialize, Deserialize, PartialEq)]
#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
pub enum NovalnetTransactionStatus {
Success,
Failure,
Confirmed,
OnHold,
Pending,
Deactivated,
Progress,
}
#[derive(Debug, Copy, Display, Clone, Serialize, Deserialize, PartialEq)]
#[strum(serialize_all = "UPPERCASE")]
#[serde(rename_all = "UPPERCASE")]
pub enum NovalnetAPIStatus {
Success,
Failure,
}
impl From<NovalnetTransactionStatus> for common_enums::AttemptStatus {
fn from(item: NovalnetTransactionStatus) -> Self {
match item {
NovalnetTransactionStatus::Success | NovalnetTransactionStatus::Confirmed => {
Self::Charged
}
NovalnetTransactionStatus::OnHold => Self::Authorized,
NovalnetTransactionStatus::Pending => Self::Pending,
NovalnetTransactionStatus::Progress => Self::AuthenticationPending,
NovalnetTransactionStatus::Deactivated => Self::Voided,
NovalnetTransactionStatus::Failure => Self::Failure,
}
}
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ResultData {
pub redirect_url: Option<Secret<url::Url>>,
pub status: NovalnetAPIStatus,
pub status_code: u64,
pub status_text: String,
pub additional_message: Option<String>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct NovalnetPaymentsResponseTransactionData {
pub amount: Option<MinorUnit>,
pub currency: Option<common_enums::Currency>,
pub date: Option<String>,
pub order_no: Option<String>,
pub payment_data: Option<NovalnetResponsePaymentData>,
pub payment_type: Option<String>,
pub status_code: Option<u64>,
pub txn_secret: Option<Secret<String>>,
pub tid: Option<Secret<i64>>,
pub test_mode: Option<i8>,
pub status: Option<NovalnetTransactionStatus>,
pub authorization: Option<NovalnetAuthorizationResponse>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct NovalnetPaymentsResponse {
result: ResultData,
transaction: Option<NovalnetPaymentsResponseTransactionData>,
}
pub fn get_error_response(result: ResultData, status_code: u16) -> ErrorResponse {
let error_code = result.status;
let error_reason = result.status_text.clone();
ErrorResponse {
code: error_code.to_string(),
message: error_reason.clone(),
reason: Some(error_reason),
status_code,
attempt_status: None,
connector_transaction_id: None,
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
connector_metadata: None,
}
}
impl NovalnetPaymentsResponseTransactionData {
pub fn get_token(transaction_data: Option<&Self>) -> Option<String> {
if let Some(data) = transaction_data {
match &data.payment_data {
Some(NovalnetResponsePaymentData::Card(card_data)) => {
card_data.token.clone().map(|token| token.expose())
}
Some(NovalnetResponsePaymentData::Paypal(paypal_data)) => {
paypal_data.token.clone().map(|token| token.expose())
}
None => None,
}
} else {
None
}
}
}
impl<F, T> TryFrom<ResponseRouterData<F, NovalnetPaymentsResponse, T, PaymentsResponseData>>
for RouterData<F, T, PaymentsResponseData>
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: ResponseRouterData<F, NovalnetPaymentsResponse, T, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
match item.response.result.status {
NovalnetAPIStatus::Success => {
let redirection_data: Option<RedirectForm> =
item.response
.result
.redirect_url
.map(|url| RedirectForm::Form {
endpoint: url.expose().to_string(),
method: Method::Get,
form_fields: HashMap::new(),
});
let transaction_id = item
.response
.transaction
.clone()
.and_then(|data| data.tid.map(|tid| tid.expose().to_string()));
let mandate_reference_id = NovalnetPaymentsResponseTransactionData::get_token(
item.response.transaction.clone().as_ref(),
);
let transaction_status = item
.response
.transaction
.as_ref()
.and_then(|transaction_data| transaction_data.status)
.unwrap_or(if redirection_data.is_some() {
NovalnetTransactionStatus::Progress
// NOTE: Novalnet does not send us the transaction.status for redirection flow
// so status is mapped to Progress if flow has redirection data
} else {
NovalnetTransactionStatus::Pending
});
Ok(Self {
status: common_enums::AttemptStatus::from(transaction_status),
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: transaction_id
.clone()
.map(ResponseId::ConnectorTransactionId)
.unwrap_or(ResponseId::NoResponseId),
redirection_data: Box::new(redirection_data),
mandate_reference: Box::new(mandate_reference_id.as_ref().map(|id| {
MandateReference {
connector_mandate_id: Some(id.clone()),
payment_method_id: None,
mandate_metadata: None,
connector_mandate_request_reference_id: None,
}
})),
connector_metadata: None,
network_txn_id: item.response.transaction.and_then(|data| {
data.payment_data
.and_then(|payment_data| match payment_data {
NovalnetResponsePaymentData::Card(card) => {
card.scheme_tid.map(|tid| tid.expose())
}
NovalnetResponsePaymentData::Paypal(_) => None,
})
}),
connector_response_reference_id: transaction_id.clone(),
incremental_authorization_allowed: None,
charges: None,
}),
..item.data
})
}
NovalnetAPIStatus::Failure => {
let response = Err(get_error_response(item.response.result, item.http_code));
Ok(Self {
response,
..item.data
})
}
}
}
}
#[derive(Serialize, Deserialize, Clone, Debug)]
pub struct NovalnetResponseCustomer {
pub billing: Option<NovalnetResponseBilling>,
pub customer_ip: Option<Secret<String>>,
pub email: Option<Email>,
pub first_name: Option<Secret<String>>,
pub gender: Option<Secret<String>>,
pub last_name: Option<Secret<String>>,
pub mobile: Option<Secret<String>>,
pub tel: Option<Secret<String>>,
pub fax: Option<Secret<String>>,
}
#[derive(Serialize, Deserialize, Clone, Debug)]
pub struct NovalnetResponseBilling {
pub city: Option<Secret<String>>,
pub country_code: Option<Secret<String>>,
pub house_no: Option<Secret<String>>,
pub street: Option<Secret<String>>,
pub zip: Option<Secret<String>>,
pub state: Option<Secret<String>>,
}
#[derive(Serialize, Deserialize, Clone, Debug)]
pub struct NovalnetResponseMerchant {
pub project: Option<Secret<i64>>,
pub project_name: Option<Secret<String>>,
pub project_url: Option<url::Url>,
pub vendor: Option<Secret<i64>>,
}
#[derive(Serialize, Deserialize, Clone, Debug)]
pub struct NovalnetAuthorizationResponse {
expiry_date: Option<String>,
auto_action: Option<String>,
}
#[derive(Serialize, Deserialize, Clone, Debug)]
pub struct NovalnetSyncResponseTransactionData {
pub amount: Option<MinorUnit>,
pub currency: Option<common_enums::Currency>,
pub date: Option<String>,
pub order_no: Option<String>,
pub payment_data: Option<NovalnetResponsePaymentData>,
pub payment_type: String,
pub status: NovalnetTransactionStatus,
pub status_code: u64,
pub test_mode: u8,
pub tid: Option<Secret<i64>>,
pub txn_secret: Option<Secret<String>>,
pub authorization: Option<NovalnetAuthorizationResponse>,
pub reason: Option<String>,
pub reason_code: Option<String>,
}
#[derive(Debug, Serialize, Deserialize, Clone)]
#[serde(untagged)]
pub enum NovalnetResponsePaymentData {
Card(NovalnetResponseCard),
Paypal(NovalnetResponsePaypal),
}
#[derive(Serialize, Deserialize, Clone, Debug)]
pub struct NovalnetResponseCard {
pub card_brand: Option<Secret<String>>,
pub card_expiry_month: Secret<u8>,
pub card_expiry_year: Secret<u16>,
pub card_holder: Secret<String>,
pub card_number: Secret<String>,
pub cc_3d: Option<Secret<u8>>,
pub last_four: Option<Secret<String>>,
pub token: Option<Secret<String>>,
pub scheme_tid: Option<Secret<String>>,
}
#[derive(Serialize, Deserialize, Clone, Debug)]
pub struct NovalnetResponsePaypal {
pub paypal_account: Option<Email>,
pub paypal_transaction_id: Option<Secret<String>>,
pub token: Option<Secret<String>>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct NovalnetPSyncResponse {
pub customer: Option<NovalnetResponseCustomer>,
pub merchant: Option<NovalnetResponseMerchant>,
pub result: ResultData,
pub transaction: Option<NovalnetSyncResponseTransactionData>,
}
#[derive(Debug, Copy, Serialize, Default, Deserialize, Clone)]
pub enum CaptureType {
#[default]
Partial,
Final,
}
#[derive(Default, Debug, Serialize)]
pub struct Capture {
#[serde(rename = "type")]
cap_type: CaptureType,
reference: String,
}
#[derive(Default, Debug, Serialize)]
pub struct NovalnetTransaction {
tid: String,
amount: Option<StringMinorUnit>,
capture: Capture,
}
#[derive(Default, Debug, Serialize)]
pub struct NovalnetCaptureRequest {
pub transaction: NovalnetTransaction,
pub custom: NovalnetCustom,
}
impl TryFrom<&NovalnetRouterData<&PaymentsCaptureRouterData>> for NovalnetCaptureRequest {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: &NovalnetRouterData<&PaymentsCaptureRouterData>,
) -> Result<Self, Self::Error> {
let capture_type = CaptureType::Final;
let reference = item.router_data.connector_request_reference_id.clone();
let capture = Capture {
cap_type: capture_type,
reference,
};
let transaction = NovalnetTransaction {
tid: item.router_data.request.connector_transaction_id.clone(),
capture,
amount: Some(item.amount.to_owned()),
};
let custom = NovalnetCustom {
lang: item
.router_data
.request
.get_optional_language_from_browser_info()
.unwrap_or(consts::DEFAULT_LOCALE.to_string()),
};
Ok(Self {
transaction,
custom,
})
}
}
// Type definition for RefundRequest
#[derive(Default, Debug, Serialize)]
pub struct NovalnetRefundTransaction {
tid: String,
amount: Option<StringMinorUnit>,
}
#[derive(Default, Debug, Serialize)]
pub struct NovalnetRefundRequest {
pub transaction: NovalnetRefundTransaction,
pub custom: NovalnetCustom,
}
impl<F> TryFrom<&NovalnetRouterData<&RefundsRouterData<F>>> for NovalnetRefundRequest {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(item: &NovalnetRouterData<&RefundsRouterData<F>>) -> Result<Self, Self::Error> {
let transaction = NovalnetRefundTransaction {
tid: item.router_data.request.connector_transaction_id.clone(),
amount: Some(item.amount.to_owned()),
};
let custom = NovalnetCustom {
lang: item
.router_data
.request
.get_optional_language_from_browser_info()
.unwrap_or(consts::DEFAULT_LOCALE.to_string().to_string()),
};
Ok(Self {
transaction,
custom,
})
}
}
impl From<NovalnetTransactionStatus> for enums::RefundStatus {
fn from(item: NovalnetTransactionStatus) -> Self {
match item {
NovalnetTransactionStatus::Success | NovalnetTransactionStatus::Confirmed => {
Self::Success
}
NovalnetTransactionStatus::Pending => Self::Pending,
NovalnetTransactionStatus::Failure
| NovalnetTransactionStatus::OnHold
| NovalnetTransactionStatus::Deactivated
| NovalnetTransactionStatus::Progress => Self::Failure,
}
}
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct NovalnetRefundSyncResponse {
result: ResultData,
transaction: Option<NovalnetSyncResponseTransactionData>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct NovalnetRefundsTransactionData {
pub amount: Option<MinorUnit>,
pub date: Option<String>,
pub currency: Option<common_enums::Currency>,
pub order_no: Option<String>,
pub payment_type: String,
pub refund: RefundData,
pub refunded_amount: Option<u64>,
pub status: NovalnetTransactionStatus,
pub status_code: u64,
pub test_mode: u8,
pub tid: Option<Secret<i64>>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct RefundData {
amount: u64,
currency: common_enums::Currency,
payment_type: Option<String>,
tid: Option<Secret<i64>>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct NovalnetRefundResponse {
pub customer: Option<NovalnetResponseCustomer>,
pub merchant: Option<NovalnetResponseMerchant>,
pub result: ResultData,
pub transaction: Option<NovalnetRefundsTransactionData>,
}
impl TryFrom<RefundsResponseRouterData<Execute, NovalnetRefundResponse>>
for RefundsRouterData<Execute>
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: RefundsResponseRouterData<Execute, NovalnetRefundResponse>,
) -> Result<Self, Self::Error> {
match item.response.result.status {
NovalnetAPIStatus::Success => {
let refund_id = item
.response
.transaction
.clone()
.and_then(|data| {
data.refund
.tid
.or(data.tid)
.map(|tid| tid.expose().to_string())
})
.ok_or(errors::ConnectorError::ResponseHandlingFailed)?;
let transaction_status = item
.response
.transaction
.map(|transaction| transaction.status)
.unwrap_or(NovalnetTransactionStatus::Pending);
Ok(Self {
response: Ok(RefundsResponseData {
connector_refund_id: refund_id,
refund_status: enums::RefundStatus::from(transaction_status),
}),
..item.data
})
}
NovalnetAPIStatus::Failure => {
let response = Err(get_error_response(item.response.result, item.http_code));
Ok(Self {
response,
..item.data
})
}
}
}
}
#[derive(Debug, Serialize, Deserialize)]
pub struct NovolnetRedirectionResponse {
status: NovalnetTransactionStatus,
tid: Secret<String>,
}
impl TryFrom<&PaymentsSyncRouterData> for NovalnetSyncRequest {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(item: &PaymentsSyncRouterData) -> Result<Self, Self::Error> {
let transaction = if item
.request
.encoded_data
.clone()
.get_required_value("encoded_data")
.is_ok()
{
let encoded_data = item
.request
.encoded_data
.clone()
.get_required_value("encoded_data")
.change_context(errors::ConnectorError::RequestEncodingFailed)?;
let novalnet_redirection_response =
serde_urlencoded::from_str::<NovolnetRedirectionResponse>(encoded_data.as_str())
.change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
NovalnetSyncTransaction {
tid: novalnet_redirection_response.tid.expose(),
}
} else {
NovalnetSyncTransaction {
tid: item
.request
.get_connector_transaction_id()
.change_context(errors::ConnectorError::MissingConnectorTransactionID)?,
}
};
let custom = NovalnetCustom {
lang: consts::DEFAULT_LOCALE.to_string().to_string(),
};
Ok(Self {
transaction,
custom,
})
}
}
impl NovalnetSyncResponseTransactionData {
pub fn get_token(transaction_data: Option<&Self>) -> Option<String> {
if let Some(data) = transaction_data {
match &data.payment_data {
Some(NovalnetResponsePaymentData::Card(card_data)) => {
card_data.token.clone().map(|token| token.expose())
}
Some(NovalnetResponsePaymentData::Paypal(paypal_data)) => {
paypal_data.token.clone().map(|token| token.expose())
}
None => None,
}
} else {
None
}
}
}
impl<F>
TryFrom<ResponseRouterData<F, NovalnetPSyncResponse, PaymentsSyncData, PaymentsResponseData>>
for RouterData<F, PaymentsSyncData, PaymentsResponseData>
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: ResponseRouterData<F, NovalnetPSyncResponse, PaymentsSyncData, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
match item.response.result.status {
NovalnetAPIStatus::Success => {
let transaction_id = item
.response
.transaction
.clone()
.and_then(|data| data.tid)
.map(|tid| tid.expose().to_string());
let transaction_status = item
.response
.transaction
.clone()
.map(|transaction_data| transaction_data.status)
.unwrap_or(NovalnetTransactionStatus::Pending);
let mandate_reference_id = NovalnetSyncResponseTransactionData::get_token(
item.response.transaction.as_ref(),
);
Ok(Self {
status: common_enums::AttemptStatus::from(transaction_status),
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: transaction_id
.clone()
.map(ResponseId::ConnectorTransactionId)
.unwrap_or(ResponseId::NoResponseId),
redirection_data: Box::new(None),
mandate_reference: Box::new(mandate_reference_id.as_ref().map(|id| {
MandateReference {
connector_mandate_id: Some(id.clone()),
payment_method_id: None,
mandate_metadata: None,
connector_mandate_request_reference_id: None,
}
})),
connector_metadata: None,
network_txn_id: item.response.transaction.and_then(|data| {
data.payment_data
.and_then(|payment_data| match payment_data {
NovalnetResponsePaymentData::Card(card) => {
card.scheme_tid.map(|tid| tid.expose())
}
NovalnetResponsePaymentData::Paypal(_) => None,
})
}),
connector_response_reference_id: transaction_id.clone(),
incremental_authorization_allowed: None,
charges: None,
}),
..item.data
})
}
NovalnetAPIStatus::Failure => {
let response = Err(get_error_response(item.response.result, item.http_code));
Ok(Self {
response,
..item.data
})
}
}
}
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct NovalnetCaptureTransactionData {
pub amount: Option<MinorUnit>,
pub capture: Option<CaptureData>, // only for credit card and paypal it is sent back in response
pub currency: Option<common_enums::Currency>,
pub order_no: Option<String>,
pub payment_type: Option<String>,
pub status: Option<NovalnetTransactionStatus>, // required for CreditCard/ApplePay/GooglePay/Paypal
pub status_code: Option<u64>,
pub test_mode: Option<u8>,
pub tid: Option<Secret<i64>>, // mandatory in docs but not being sent back in sepa response -> need to double check
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct CaptureData {
amount: Option<u64>,
payment_type: Option<String>,
status: Option<String>,
status_code: u64,
tid: Option<Secret<i64>>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct NovalnetCaptureResponse {
pub result: ResultData,
pub transaction: Option<NovalnetCaptureTransactionData>,
}
impl<F>
TryFrom<
ResponseRouterData<F, NovalnetCaptureResponse, PaymentsCaptureData, PaymentsResponseData>,
> for RouterData<F, PaymentsCaptureData, PaymentsResponseData>
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: ResponseRouterData<
F,
NovalnetCaptureResponse,
PaymentsCaptureData,
PaymentsResponseData,
>,
) -> Result<Self, Self::Error> {
match item.response.result.status {
NovalnetAPIStatus::Success => {
let transaction_id = item
.response
.transaction
.clone()
.and_then(|data| data.tid.map(|tid| tid.expose().to_string()));
let transaction_status = item
.response
.transaction
.map(|transaction_data| transaction_data.status)
.unwrap_or(Some(NovalnetTransactionStatus::Pending));
Ok(Self {
status: transaction_status
.map(common_enums::AttemptStatus::from)
.unwrap_or(common_enums::AttemptStatus::Pending),
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: transaction_id
.clone()
.map(ResponseId::ConnectorTransactionId)
.unwrap_or(ResponseId::NoResponseId),
redirection_data: Box::new(None),
mandate_reference: Box::new(None),
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: transaction_id.clone(),
incremental_authorization_allowed: None,
charges: None,
}),
..item.data
})
}
NovalnetAPIStatus::Failure => {
let response = Err(get_error_response(item.response.result, item.http_code));
Ok(Self {
response,
..item.data
})
}
}
}
}
#[derive(Default, Debug, Serialize)]
pub struct NovalnetSyncTransaction {
tid: String,
}
#[derive(Default, Debug, Serialize)]
pub struct NovalnetSyncRequest {
pub transaction: NovalnetSyncTransaction,
pub custom: NovalnetCustom,
}
impl TryFrom<&RefundSyncRouterData> for NovalnetSyncRequest {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(item: &RefundSyncRouterData) -> Result<Self, Self::Error> {
let transaction = NovalnetSyncTransaction {
tid: item.request.connector_transaction_id.clone(),
};
let custom = NovalnetCustom {
lang: item
.request
.get_optional_language_from_browser_info()
.unwrap_or(consts::DEFAULT_LOCALE.to_string().to_string()),
};
Ok(Self {
transaction,
custom,
})
}
}
impl TryFrom<RefundsResponseRouterData<RSync, NovalnetRefundSyncResponse>>
for RefundsRouterData<RSync>
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: RefundsResponseRouterData<RSync, NovalnetRefundSyncResponse>,
) -> Result<Self, Self::Error> {
match item.response.result.status {
NovalnetAPIStatus::Success => {
let refund_id = item
.response
.transaction
.clone()
.and_then(|data| data.tid)
.map(|tid| tid.expose().to_string())
.unwrap_or("".to_string());
//NOTE: Mapping refund_id with "" incase we dont get any tid
let transaction_status = item
.response
.transaction
.map(|transaction_data| transaction_data.status)
.unwrap_or(NovalnetTransactionStatus::Pending);
Ok(Self {
response: Ok(RefundsResponseData {
connector_refund_id: refund_id,
refund_status: enums::RefundStatus::from(transaction_status),
}),
..item.data
})
}
NovalnetAPIStatus::Failure => {
let response = Err(get_error_response(item.response.result, item.http_code));
Ok(Self {
response,
..item.data
})
}
}
}
}
#[derive(Default, Debug, Serialize)]
pub struct NovalnetCancelTransaction {
tid: String,
}
#[derive(Default, Debug, Serialize)]
pub struct NovalnetCancelRequest {
pub transaction: NovalnetCancelTransaction,
pub custom: NovalnetCustom,
}
impl TryFrom<&PaymentsCancelRouterData> for NovalnetCancelRequest {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(item: &PaymentsCancelRouterData) -> Result<Self, Self::Error> {
let transaction = NovalnetCancelTransaction {
tid: item.request.connector_transaction_id.clone(),
};
let custom = NovalnetCustom {
lang: item
.request
.get_optional_language_from_browser_info()
.unwrap_or(consts::DEFAULT_LOCALE.to_string().to_string()),
};
Ok(Self {
transaction,
custom,
})
}
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct NovalnetCancelResponse {
result: ResultData,
transaction: Option<NovalnetPaymentsResponseTransactionData>,
}
impl<F>
TryFrom<ResponseRouterData<F, NovalnetCancelResponse, PaymentsCancelData, PaymentsResponseData>>
for RouterData<F, PaymentsCancelData, PaymentsResponseData>
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: ResponseRouterData<
F,
NovalnetCancelResponse,
PaymentsCancelData,
PaymentsResponseData,
>,
) -> Result<Self, Self::Error> {
match item.response.result.status {
NovalnetAPIStatus::Success => {
let transaction_id = item
.response
.transaction
.clone()
.and_then(|data| data.tid.map(|tid| tid.expose().to_string()));
let transaction_status = item
.response
.transaction
.and_then(|transaction_data| transaction_data.status)
.unwrap_or(NovalnetTransactionStatus::Pending);
Ok(Self {
status: if transaction_status == NovalnetTransactionStatus::Deactivated {
enums::AttemptStatus::Voided
} else {
enums::AttemptStatus::VoidFailed
},
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: transaction_id
.clone()
.map(ResponseId::ConnectorTransactionId)
.unwrap_or(ResponseId::NoResponseId),
redirection_data: Box::new(None),
mandate_reference: Box::new(None),
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: transaction_id.clone(),
incremental_authorization_allowed: None,
charges: None,
}),
..item.data
})
}
NovalnetAPIStatus::Failure => {
let response = Err(get_error_response(item.response.result, item.http_code));
Ok(Self {
response,
..item.data
})
}
}
}
}
//TODO: Fill the struct with respective fields
#[derive(Default, Debug, Serialize, Deserialize)]
pub struct NovalnetErrorResponse {
pub status_code: u64,
pub code: String,
pub message: String,
pub reason: Option<String>,
}
#[derive(Display, Debug, Serialize, Deserialize)]
#[strum(serialize_all = "SCREAMING_SNAKE_CASE")]
#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
pub enum WebhookEventType {
Payment,
TransactionCapture,
TransactionCancel,
TransactionRefund,
Chargeback,
Credit,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct NovalnetWebhookEvent {
pub checksum: String,
pub tid: i64,
pub parent_tid: Option<i64>,
#[serde(rename = "type")]
pub event_type: WebhookEventType,
}
#[derive(Debug, Serialize, Deserialize, Clone)]
#[serde(untagged)]
pub enum NovalnetWebhookTransactionData {
SyncTransactionData(NovalnetSyncResponseTransactionData),
CaptureTransactionData(NovalnetCaptureTransactionData),
CancelTransactionData(NovalnetPaymentsResponseTransactionData),
RefundsTransactionData(NovalnetRefundsTransactionData),
}
#[derive(Serialize, Deserialize, Debug)]
pub struct NovalnetWebhookNotificationResponse {
pub event: NovalnetWebhookEvent,
pub result: ResultData,
pub transaction: NovalnetWebhookTransactionData,
}
pub fn is_refund_event(event_code: &WebhookEventType) -> bool {
matches!(event_code, WebhookEventType::TransactionRefund)
}
pub fn get_incoming_webhook_event(
status: WebhookEventType,
transaction_status: NovalnetTransactionStatus,
) -> IncomingWebhookEvent {
match status {
WebhookEventType::Payment => match transaction_status {
NovalnetTransactionStatus::Confirmed | NovalnetTransactionStatus::Success => {
IncomingWebhookEvent::PaymentIntentSuccess
}
NovalnetTransactionStatus::OnHold => {
IncomingWebhookEvent::PaymentIntentAuthorizationSuccess
}
NovalnetTransactionStatus::Pending => IncomingWebhookEvent::PaymentIntentProcessing,
NovalnetTransactionStatus::Progress => IncomingWebhookEvent::EventNotSupported,
_ => IncomingWebhookEvent::PaymentIntentFailure,
},
WebhookEventType::TransactionCapture => match transaction_status {
NovalnetTransactionStatus::Confirmed | NovalnetTransactionStatus::Success => {
IncomingWebhookEvent::PaymentIntentCaptureSuccess
}
_ => IncomingWebhookEvent::PaymentIntentCaptureFailure,
},
WebhookEventType::TransactionCancel => match transaction_status {
NovalnetTransactionStatus::Deactivated => IncomingWebhookEvent::PaymentIntentCancelled,
_ => IncomingWebhookEvent::PaymentIntentCancelFailure,
},
WebhookEventType::TransactionRefund => match transaction_status {
NovalnetTransactionStatus::Confirmed | NovalnetTransactionStatus::Success => {
IncomingWebhookEvent::RefundSuccess
}
_ => IncomingWebhookEvent::RefundFailure,
},
WebhookEventType::Chargeback => IncomingWebhookEvent::DisputeOpened,
WebhookEventType::Credit => IncomingWebhookEvent::DisputeWon,
}
}
pub fn reverse_string(s: &str) -> String {
s.chars().rev().collect()
}
#[derive(Display, Debug, Serialize, Deserialize)]
pub enum WebhookDisputeStatus {
DisputeOpened,
DisputeWon,
Unknown,
}
pub fn get_novalnet_dispute_status(status: WebhookEventType) -> WebhookDisputeStatus {
match status {
WebhookEventType::Chargeback => WebhookDisputeStatus::DisputeOpened,
WebhookEventType::Credit => WebhookDisputeStatus::DisputeWon,
_ => WebhookDisputeStatus::Unknown,
}
}
pub fn option_to_result<T>(opt: Option<T>) -> Result<T, errors::ConnectorError> {
opt.ok_or(errors::ConnectorError::WebhookBodyDecodingFailed)
}
impl TryFrom<&SetupMandateRouterData> for NovalnetPaymentsRequest {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(item: &SetupMandateRouterData) -> Result<Self, Self::Error> {
let auth = NovalnetAuthType::try_from(&item.connector_auth_type)?;
let merchant = NovalnetPaymentsRequestMerchant {
signature: auth.product_activation_key,
tariff: auth.tariff_id,
};
let enforce_3d = match item.auth_type {
enums::AuthenticationType::ThreeDs => Some(1),
enums::AuthenticationType::NoThreeDs => None,
};
let test_mode = get_test_mode(item.test_mode);
let req_address = item.get_optional_billing();
let billing = NovalnetPaymentsRequestBilling {
house_no: item.get_optional_billing_line1(),
street: item.get_optional_billing_line2(),
city: item.get_optional_billing_city().map(Secret::new),
zip: item.get_optional_billing_zip(),
country_code: item.get_optional_billing_country(),
};
let email = item.get_billing_email().or(item.request.get_email())?;
let customer = NovalnetPaymentsRequestCustomer {
first_name: req_address.and_then(|addr| addr.get_optional_first_name()),
last_name: req_address.and_then(|addr| addr.get_optional_last_name()),
email,
mobile: item.get_optional_billing_phone_number(),
billing: Some(billing),
// no_nc is used to indicate if minimal customer data is passed or not
no_nc: MINIMAL_CUSTOMER_DATA_PASSED,
birth_date: Some(String::from("1992-06-10")),
};
let lang = item
.request
.get_optional_language_from_browser_info()
.unwrap_or(consts::DEFAULT_LOCALE.to_string().to_string());
let custom = NovalnetCustom { lang };
let hook_url = item.request.get_webhook_url()?;
let return_url = item.request.get_return_url()?;
let create_token = Some(CREATE_TOKEN_REQUIRED);
match item.request.payment_method_data {
PaymentMethodData::Card(ref req_card) => {
let novalnet_card = NovalNetPaymentData::Card(NovalnetCard {
card_number: req_card.card_number.clone(),
card_expiry_month: req_card.card_exp_month.clone(),
card_expiry_year: req_card.card_exp_year.clone(),
card_cvc: req_card.card_cvc.clone(),
card_holder: item.get_billing_address()?.get_full_name()?,
});
let transaction = NovalnetPaymentsRequestTransaction {
test_mode,
payment_type: NovalNetPaymentTypes::CREDITCARD,
amount: NovalNetAmount::Int(0),
currency: item.request.currency,
order_no: item.connector_request_reference_id.clone(),
hook_url: Some(hook_url),
return_url: Some(return_url.clone()),
error_return_url: Some(return_url.clone()),
payment_data: Some(novalnet_card),
enforce_3d,
create_token,
};
Ok(Self {
merchant,
transaction,
customer,
custom,
})
}
PaymentMethodData::Wallet(ref wallet_data) => match wallet_data {
WalletDataPaymentMethod::GooglePay(ref req_wallet) => {
let novalnet_google_pay: NovalNetPaymentData =
NovalNetPaymentData::GooglePay(NovalnetGooglePay {
wallet_data: Secret::new(
req_wallet
.tokenization_data
.get_encrypted_google_pay_token()
.change_context(errors::ConnectorError::MissingRequiredField {
field_name: "gpay wallet_token",
})?
.clone(),
),
});
let transaction = NovalnetPaymentsRequestTransaction {
test_mode,
payment_type: NovalNetPaymentTypes::GOOGLEPAY,
amount: NovalNetAmount::Int(0),
currency: item.request.currency,
order_no: item.connector_request_reference_id.clone(),
hook_url: Some(hook_url),
return_url: None,
error_return_url: None,
payment_data: Some(novalnet_google_pay),
enforce_3d,
create_token,
};
Ok(Self {
merchant,
transaction,
customer,
custom,
})
}
WalletDataPaymentMethod::ApplePay(payment_method_data) => {
let transaction = NovalnetPaymentsRequestTransaction {
test_mode,
payment_type: NovalNetPaymentTypes::APPLEPAY,
amount: NovalNetAmount::Int(0),
currency: item.request.currency,
order_no: item.connector_request_reference_id.clone(),
hook_url: Some(hook_url),
return_url: None,
error_return_url: None,
payment_data: Some(NovalNetPaymentData::ApplePay(NovalnetApplePay {
wallet_data: payment_method_data.get_applepay_decoded_payment_data()?,
})),
enforce_3d: None,
create_token,
};
Ok(Self {
merchant,
transaction,
customer,
custom,
})
}
WalletDataPaymentMethod::AliPayQr(_)
| WalletDataPaymentMethod::AliPayRedirect(_)
| WalletDataPaymentMethod::AliPayHkRedirect(_)
| WalletDataPaymentMethod::AmazonPay(_)
| WalletDataPaymentMethod::AmazonPayRedirect(_)
| WalletDataPaymentMethod::Paysera(_)
| WalletDataPaymentMethod::Skrill(_)
| WalletDataPaymentMethod::BluecodeRedirect {}
| WalletDataPaymentMethod::MomoRedirect(_)
| WalletDataPaymentMethod::KakaoPayRedirect(_)
| WalletDataPaymentMethod::GoPayRedirect(_)
| WalletDataPaymentMethod::GcashRedirect(_)
| WalletDataPaymentMethod::ApplePayRedirect(_)
| WalletDataPaymentMethod::ApplePayThirdPartySdk(_)
| WalletDataPaymentMethod::DanaRedirect {}
| WalletDataPaymentMethod::GooglePayRedirect(_)
| WalletDataPaymentMethod::GooglePayThirdPartySdk(_)
| WalletDataPaymentMethod::MbWayRedirect(_)
| WalletDataPaymentMethod::MobilePayRedirect(_)
| WalletDataPaymentMethod::RevolutPay(_) => {
Err(errors::ConnectorError::NotImplemented(
utils::get_unimplemented_payment_method_error_message("novalnet"),
))?
}
WalletDataPaymentMethod::PaypalRedirect(_) => {
let transaction = NovalnetPaymentsRequestTransaction {
test_mode,
payment_type: NovalNetPaymentTypes::PAYPAL,
amount: NovalNetAmount::Int(0),
currency: item.request.currency,
order_no: item.connector_request_reference_id.clone(),
hook_url: Some(hook_url),
return_url: Some(return_url.clone()),
error_return_url: Some(return_url.clone()),
payment_data: None,
enforce_3d: None,
create_token,
};
Ok(Self {
merchant,
transaction,
customer,
custom,
})
}
WalletDataPaymentMethod::PaypalSdk(_)
| WalletDataPaymentMethod::Paze(_)
| WalletDataPaymentMethod::SamsungPay(_)
| WalletDataPaymentMethod::TwintRedirect {}
| WalletDataPaymentMethod::VippsRedirect {}
| WalletDataPaymentMethod::TouchNGoRedirect(_)
| WalletDataPaymentMethod::WeChatPayRedirect(_)
| WalletDataPaymentMethod::CashappQr(_)
| WalletDataPaymentMethod::SwishQr(_)
| WalletDataPaymentMethod::WeChatPayQr(_)
| WalletDataPaymentMethod::Mifinity(_) => {
Err(errors::ConnectorError::NotImplemented(
utils::get_unimplemented_payment_method_error_message("novalnet"),
))?
}
},
_ => Err(errors::ConnectorError::NotImplemented(
utils::get_unimplemented_payment_method_error_message("novalnet"),
))?,
}
}
}
|
{
"crate": "hyperswitch_connectors",
"file": "crates/hyperswitch_connectors/src/connectors/novalnet/transformers.rs",
"file_size": null,
"is_async": null,
"is_pub": null,
"num_enums": 10,
"num_structs": 44,
"num_tables": null,
"score": null,
"total_crates": null
}
|
file_hyperswitch_connectors_-3799226406019682674
|
clm
|
file
|
// Repository: hyperswitch
// Crate: hyperswitch_connectors
// File: crates/hyperswitch_connectors/src/connectors/silverflow/transformers.rs
// Contains: 33 structs, 6 enums
use common_enums::enums;
use common_utils::types::MinorUnit;
use hyperswitch_domain_models::{
payment_method_data::PaymentMethodData,
router_data::{ConnectorAuthType, RouterData},
router_flow_types::{
payments::Void,
refunds::{Execute, RSync},
},
router_request_types::{PaymentsCancelData, ResponseId},
router_response_types::{PaymentsResponseData, RefundsResponseData},
types::{PaymentsAuthorizeRouterData, PaymentsCaptureRouterData, RefundsRouterData},
};
use hyperswitch_interfaces::errors;
use masking::{ExposeInterface, PeekInterface, Secret};
use serde::{Deserialize, Serialize};
use crate::{
types::{RefundsResponseRouterData, ResponseRouterData},
utils::{self, CardData},
};
//TODO: Fill the struct with respective fields
pub struct SilverflowRouterData<T> {
pub amount: MinorUnit, // The type of amount that a connector accepts, for example, String, i64, f64, etc.
pub router_data: T,
}
impl<T> From<(MinorUnit, T)> for SilverflowRouterData<T> {
fn from((amount, item): (MinorUnit, T)) -> Self {
//Todo : use utils to convert the amount to the type of amount that a connector accepts
Self {
amount,
router_data: item,
}
}
}
// Basic structures for Silverflow API
#[derive(Default, Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct Amount {
value: MinorUnit,
currency: String,
}
#[derive(Default, Debug, Serialize, PartialEq)]
#[serde(rename_all = "camelCase")]
pub struct Card {
number: cards::CardNumber,
expiry_month: Secret<String>,
expiry_year: Secret<String>,
cvc: Secret<String>,
holder_name: Option<Secret<String>>,
}
#[derive(Default, Debug, Serialize, PartialEq)]
#[serde(rename_all = "camelCase")]
pub struct MerchantAcceptorResolver {
merchant_acceptor_key: String,
}
#[derive(Default, Debug, Serialize, PartialEq)]
#[serde(rename_all = "camelCase")]
pub struct SilverflowPaymentsRequest {
merchant_acceptor_resolver: MerchantAcceptorResolver,
card: Card,
amount: Amount,
#[serde(rename = "type")]
payment_type: PaymentType,
clearing_mode: String,
}
#[derive(Default, Debug, Clone, Serialize, Deserialize, PartialEq)]
#[serde(rename_all = "camelCase")]
pub struct PaymentType {
intent: String,
card_entry: String,
order: String,
}
impl TryFrom<&SilverflowRouterData<&PaymentsAuthorizeRouterData>> for SilverflowPaymentsRequest {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: &SilverflowRouterData<&PaymentsAuthorizeRouterData>,
) -> Result<Self, Self::Error> {
// Check if 3DS is being requested - Silverflow doesn't support 3DS
if matches!(
item.router_data.auth_type,
enums::AuthenticationType::ThreeDs
) {
return Err(errors::ConnectorError::NotImplemented(
utils::get_unimplemented_payment_method_error_message("silverflow"),
)
.into());
}
match item.router_data.request.payment_method_data.clone() {
PaymentMethodData::Card(req_card) => {
// Extract merchant acceptor key from connector auth
let auth = SilverflowAuthType::try_from(&item.router_data.connector_auth_type)?;
let card = Card {
number: req_card.card_number.clone(),
expiry_month: req_card.card_exp_month.clone(),
expiry_year: req_card.card_exp_year.clone(),
cvc: req_card.card_cvc.clone(),
holder_name: req_card.get_cardholder_name().ok(),
};
// Determine clearing mode based on capture method
let clearing_mode = match item.router_data.request.capture_method {
Some(enums::CaptureMethod::Manual) => "manual".to_string(),
Some(enums::CaptureMethod::Automatic) | None => "auto".to_string(),
Some(enums::CaptureMethod::ManualMultiple)
| Some(enums::CaptureMethod::Scheduled)
| Some(enums::CaptureMethod::SequentialAutomatic) => {
return Err(errors::ConnectorError::NotSupported {
message: "Capture method not supported by Silverflow".to_string(),
connector: "Silverflow",
}
.into());
}
};
Ok(Self {
merchant_acceptor_resolver: MerchantAcceptorResolver {
merchant_acceptor_key: auth.merchant_acceptor_key.expose(),
},
card,
amount: Amount {
value: item.amount,
currency: item.router_data.request.currency.to_string(),
},
payment_type: PaymentType {
intent: "purchase".to_string(),
card_entry: "e-commerce".to_string(),
order: "checkout".to_string(),
},
clearing_mode,
})
}
_ => Err(errors::ConnectorError::NotImplemented(
utils::get_unimplemented_payment_method_error_message("silverflow"),
)
.into()),
}
}
}
// Auth Struct for HTTP Basic Authentication
pub struct SilverflowAuthType {
pub(super) api_key: Secret<String>,
pub(super) api_secret: Secret<String>,
pub(super) merchant_acceptor_key: Secret<String>,
}
impl TryFrom<&ConnectorAuthType> for SilverflowAuthType {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(auth_type: &ConnectorAuthType) -> Result<Self, Self::Error> {
match auth_type {
ConnectorAuthType::SignatureKey {
api_key,
key1,
api_secret,
} => Ok(Self {
api_key: api_key.clone(),
api_secret: api_secret.clone(),
merchant_acceptor_key: key1.clone(),
}),
_ => Err(errors::ConnectorError::FailedToObtainAuthType.into()),
}
}
}
// Enum for Silverflow payment authorization status
#[derive(Default, Debug, Clone, Serialize, Deserialize, PartialEq)]
#[serde(rename_all = "lowercase")]
pub enum SilverflowAuthorizationStatus {
Approved,
Declined,
Failed,
#[default]
Pending,
}
// Enum for Silverflow payment clearing status
#[derive(Default, Debug, Clone, Serialize, Deserialize, PartialEq)]
#[serde(rename_all = "lowercase")]
pub enum SilverflowClearingStatus {
Cleared,
#[default]
Pending,
Failed,
}
// Payment Authorization Response Structures
#[derive(Default, Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct PaymentStatus {
pub authentication: String,
pub authorization: SilverflowAuthorizationStatus,
pub clearing: SilverflowClearingStatus,
}
#[derive(Default, Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct MerchantAcceptorRef {
pub key: String,
pub version: i32,
}
#[derive(Default, Debug, Clone, Serialize, Deserialize, PartialEq)]
#[serde(rename_all = "camelCase")]
pub struct CardResponse {
pub masked_number: String,
}
#[derive(Default, Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct Authentication {
pub sca: SCA,
pub cvc: Secret<String>,
pub avs: String,
}
#[derive(Default, Debug, Clone, Serialize, Deserialize, PartialEq)]
#[serde(rename_all = "camelCase")]
pub struct SCA {
pub compliance: String,
pub compliance_reason: String,
pub method: String,
#[serde(skip_serializing_if = "Option::is_none")]
pub result: Option<SCAResult>,
}
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
#[serde(rename_all = "camelCase")]
pub struct SCAResult {
pub version: String,
pub directory_server_trans_id: String,
}
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
#[serde(rename_all = "camelCase")]
pub struct AuthorizationIsoFields {
pub response_code: String,
pub response_code_description: String,
pub authorization_code: String,
pub network_code: String,
pub system_trace_audit_number: Secret<String>,
pub retrieval_reference_number: String,
pub eci: String,
pub network_specific_fields: NetworkSpecificFields,
}
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
#[serde(rename_all = "camelCase")]
pub struct NetworkSpecificFields {
pub transaction_identifier: String,
pub cvv2_result_code: String,
}
#[derive(Default, Debug, Clone, Serialize, Deserialize, PartialEq)]
#[serde(rename_all = "camelCase")]
pub struct SilverflowPaymentsResponse {
pub key: String,
pub merchant_acceptor_ref: MerchantAcceptorRef,
pub card: CardResponse,
pub amount: Amount,
#[serde(rename = "type")]
pub payment_type: PaymentType,
pub clearing_mode: String,
pub status: PaymentStatus,
pub authentication: Authentication,
pub local_transaction_date_time: String,
pub fraud_liability: String,
pub authorization_iso_fields: Option<AuthorizationIsoFields>,
pub created: String,
pub version: i32,
}
impl From<&PaymentStatus> for common_enums::AttemptStatus {
fn from(status: &PaymentStatus) -> Self {
match (&status.authorization, &status.clearing) {
(SilverflowAuthorizationStatus::Approved, SilverflowClearingStatus::Cleared) => {
Self::Charged
}
(SilverflowAuthorizationStatus::Approved, SilverflowClearingStatus::Pending) => {
Self::Authorized
}
(SilverflowAuthorizationStatus::Approved, SilverflowClearingStatus::Failed) => {
Self::Failure
}
(SilverflowAuthorizationStatus::Declined, _) => Self::Failure,
(SilverflowAuthorizationStatus::Failed, _) => Self::Failure,
(SilverflowAuthorizationStatus::Pending, _) => Self::Pending,
}
}
}
impl<F, T> TryFrom<ResponseRouterData<F, SilverflowPaymentsResponse, T, PaymentsResponseData>>
for RouterData<F, T, PaymentsResponseData>
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: ResponseRouterData<F, SilverflowPaymentsResponse, T, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
Ok(Self {
status: common_enums::AttemptStatus::from(&item.response.status),
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(item.response.key.clone()),
redirection_data: Box::new(None),
mandate_reference: Box::new(None),
connector_metadata: None,
network_txn_id: item
.response
.authorization_iso_fields
.as_ref()
.map(|fields| {
fields
.network_specific_fields
.transaction_identifier
.clone()
}),
connector_response_reference_id: Some(item.response.key.clone()),
incremental_authorization_allowed: Some(false),
charges: None,
}),
..item.data
})
}
}
// CAPTURE:
// Type definition for CaptureRequest based on Silverflow API documentation
#[derive(Default, Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct SilverflowCaptureRequest {
#[serde(skip_serializing_if = "Option::is_none")]
pub amount: Option<i64>,
#[serde(skip_serializing_if = "Option::is_none")]
pub close_charge: Option<bool>,
#[serde(skip_serializing_if = "Option::is_none")]
pub reference: Option<String>,
}
impl TryFrom<&PaymentsCaptureRouterData> for SilverflowCaptureRequest {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(item: &PaymentsCaptureRouterData) -> Result<Self, Self::Error> {
// amount_to_capture is directly an i64, representing the amount in minor units
let amount_to_capture = Some(item.request.amount_to_capture);
Ok(Self {
amount: amount_to_capture,
close_charge: Some(true), // Default to closing charge after capture
reference: Some(format!("capture-{}", item.payment_id)),
})
}
}
// Enum for Silverflow capture status
#[derive(Default, Debug, Clone, Serialize, Deserialize, PartialEq)]
#[serde(rename_all = "lowercase")]
pub enum SilverflowCaptureStatus {
Completed,
#[default]
Pending,
Failed,
}
// Type definition for CaptureResponse based on Silverflow clearing action response
#[derive(Default, Debug, Clone, Serialize, Deserialize, PartialEq)]
#[serde(rename_all = "camelCase")]
pub struct SilverflowCaptureResponse {
#[serde(rename = "type")]
pub action_type: String,
pub key: String,
pub charge_key: String,
pub status: SilverflowCaptureStatus,
#[serde(skip_serializing_if = "Option::is_none")]
pub reference: Option<String>,
pub amount: Amount,
pub created: String,
pub last_modified: String,
pub version: i32,
}
impl From<&SilverflowCaptureResponse> for common_enums::AttemptStatus {
fn from(response: &SilverflowCaptureResponse) -> Self {
match response.status {
SilverflowCaptureStatus::Completed => Self::Charged,
SilverflowCaptureStatus::Pending => Self::Pending,
SilverflowCaptureStatus::Failed => Self::Failure,
}
}
}
impl<F, T> TryFrom<ResponseRouterData<F, SilverflowCaptureResponse, T, PaymentsResponseData>>
for RouterData<F, T, PaymentsResponseData>
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: ResponseRouterData<F, SilverflowCaptureResponse, T, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
Ok(Self {
status: common_enums::AttemptStatus::from(&item.response),
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(item.response.charge_key.clone()),
redirection_data: Box::new(None),
mandate_reference: Box::new(None),
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: Some(item.response.key.clone()),
incremental_authorization_allowed: Some(false),
charges: None,
}),
..item.data
})
}
}
// VOID/REVERSE:
// Type definition for Reverse Charge Request based on Silverflow API documentation
#[derive(Default, Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct SilverflowVoidRequest {
#[serde(skip_serializing_if = "Option::is_none")]
pub replacement_amount: Option<i64>,
#[serde(skip_serializing_if = "Option::is_none")]
pub reference: Option<String>,
}
impl TryFrom<&RouterData<Void, PaymentsCancelData, PaymentsResponseData>>
for SilverflowVoidRequest
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: &RouterData<Void, PaymentsCancelData, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
Ok(Self {
replacement_amount: Some(0), // Default to 0 for full reversal
reference: Some(format!("void-{}", item.payment_id)),
})
}
}
// Enum for Silverflow void authorization status
#[derive(Default, Debug, Clone, Serialize, Deserialize, PartialEq)]
#[serde(rename_all = "lowercase")]
pub enum SilverflowVoidAuthorizationStatus {
Approved,
Declined,
Failed,
#[default]
Pending,
}
// Type definition for Void Status (only authorization, no clearing)
#[derive(Default, Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct VoidStatus {
pub authorization: SilverflowVoidAuthorizationStatus,
}
// Type definition for Reverse Charge Response based on Silverflow API documentation
#[derive(Default, Debug, Clone, Serialize, Deserialize, PartialEq)]
#[serde(rename_all = "camelCase")]
pub struct SilverflowVoidResponse {
#[serde(rename = "type")]
pub action_type: String,
pub key: String,
pub charge_key: String,
#[serde(skip_serializing_if = "Option::is_none")]
pub reference: Option<String>,
pub replacement_amount: Amount,
pub status: VoidStatus,
pub authorization_response: Option<AuthorizationResponse>,
pub created: String,
pub last_modified: String,
pub version: i32,
}
impl From<&SilverflowVoidResponse> for common_enums::AttemptStatus {
fn from(response: &SilverflowVoidResponse) -> Self {
match response.status.authorization {
SilverflowVoidAuthorizationStatus::Approved => Self::Voided,
SilverflowVoidAuthorizationStatus::Declined
| SilverflowVoidAuthorizationStatus::Failed => Self::VoidFailed,
SilverflowVoidAuthorizationStatus::Pending => Self::Pending,
}
}
}
impl<F, T> TryFrom<ResponseRouterData<F, SilverflowVoidResponse, T, PaymentsResponseData>>
for RouterData<F, T, PaymentsResponseData>
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: ResponseRouterData<F, SilverflowVoidResponse, T, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
Ok(Self {
status: common_enums::AttemptStatus::from(&item.response),
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(item.response.charge_key.clone()),
redirection_data: Box::new(None),
mandate_reference: Box::new(None),
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: Some(item.response.key.clone()),
incremental_authorization_allowed: Some(false),
charges: None,
}),
..item.data
})
}
}
// REFUND :
// Type definition for DynamicDescriptor
#[derive(Debug, Serialize, Deserialize, Clone, PartialEq)]
#[serde(rename_all = "camelCase")]
pub struct DynamicDescriptor {
pub merchant_name: String,
pub merchant_city: String,
}
// Type definition for RefundRequest
#[derive(Default, Debug, Serialize)]
pub struct SilverflowRefundRequest {
#[serde(rename = "refundAmount")]
pub refund_amount: MinorUnit,
pub reference: String,
}
impl<F> TryFrom<&SilverflowRouterData<&RefundsRouterData<F>>> for SilverflowRefundRequest {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(item: &SilverflowRouterData<&RefundsRouterData<F>>) -> Result<Self, Self::Error> {
Ok(Self {
refund_amount: item.amount,
reference: format!("refund-{}", item.router_data.request.refund_id),
})
}
}
// Type definition for Authorization Response
#[derive(Debug, Serialize, Deserialize, Clone, PartialEq)]
#[serde(rename_all = "camelCase")]
pub struct AuthorizationResponse {
pub network: String,
pub response_code: String,
pub response_code_description: String,
}
// Enum for Silverflow refund authorization status
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
#[serde(rename_all = "lowercase")]
pub enum SilverflowRefundAuthorizationStatus {
Approved,
Declined,
Failed,
Pending,
}
// Enum for Silverflow refund status
#[derive(Default, Debug, Clone, Serialize, Deserialize, PartialEq)]
#[serde(rename_all = "lowercase")]
pub enum SilverflowRefundStatus {
Success,
Failure,
#[default]
Pending,
}
impl From<&SilverflowRefundStatus> for enums::RefundStatus {
fn from(item: &SilverflowRefundStatus) -> Self {
match item {
SilverflowRefundStatus::Success => Self::Success,
SilverflowRefundStatus::Failure => Self::Failure,
SilverflowRefundStatus::Pending => Self::Pending,
}
}
}
// Type definition for Refund Response
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
#[serde(rename_all = "camelCase")]
pub struct RefundResponse {
#[serde(rename = "type")]
pub action_type: String,
pub key: String,
pub charge_key: String,
pub reference: String,
pub amount: Amount,
pub status: SilverflowRefundStatus,
pub clear_after: Option<String>,
pub authorization_response: Option<AuthorizationResponse>,
pub created: String,
pub last_modified: String,
pub version: i32,
}
impl TryFrom<RefundsResponseRouterData<Execute, RefundResponse>> for RefundsRouterData<Execute> {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: RefundsResponseRouterData<Execute, RefundResponse>,
) -> Result<Self, Self::Error> {
Ok(Self {
response: Ok(RefundsResponseData {
connector_refund_id: item.response.key.clone(),
refund_status: enums::RefundStatus::from(&item.response.status),
}),
..item.data
})
}
}
impl TryFrom<RefundsResponseRouterData<RSync, RefundResponse>> for RefundsRouterData<RSync> {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: RefundsResponseRouterData<RSync, RefundResponse>,
) -> Result<Self, Self::Error> {
Ok(Self {
response: Ok(RefundsResponseData {
connector_refund_id: item.response.key.clone(),
refund_status: enums::RefundStatus::from(&item.response.status),
}),
..item.data
})
}
}
// TOKENIZATION:
// Type definition for TokenizationRequest
#[derive(Default, Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct SilverflowTokenizationRequest {
pub reference: String,
pub card_data: SilverflowCardData,
}
#[derive(Default, Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct SilverflowCardData {
pub number: String,
pub expiry_month: Secret<String>,
pub expiry_year: Secret<String>,
pub cvc: String,
pub holder_name: String,
}
impl TryFrom<&PaymentsAuthorizeRouterData> for SilverflowTokenizationRequest {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(item: &PaymentsAuthorizeRouterData) -> Result<Self, Self::Error> {
match item.request.payment_method_data.clone() {
PaymentMethodData::Card(req_card) => {
let card_data = SilverflowCardData {
number: req_card.card_number.peek().to_string(),
expiry_month: req_card.card_exp_month.clone(),
expiry_year: req_card.card_exp_year.clone(),
cvc: req_card.card_cvc.clone().expose(),
holder_name: req_card
.get_cardholder_name()
.unwrap_or(Secret::new("".to_string()))
.expose(),
};
Ok(Self {
reference: format!("CUSTOMER_ID_{}", item.payment_id),
card_data,
})
}
_ => Err(errors::ConnectorError::NotImplemented(
utils::get_unimplemented_payment_method_error_message("silverflow"),
)
.into()),
}
}
}
// Add TryFrom implementation for direct tokenization router data
impl
TryFrom<
&RouterData<
hyperswitch_domain_models::router_flow_types::payments::PaymentMethodToken,
hyperswitch_domain_models::router_request_types::PaymentMethodTokenizationData,
PaymentsResponseData,
>,
> for SilverflowTokenizationRequest
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: &RouterData<
hyperswitch_domain_models::router_flow_types::payments::PaymentMethodToken,
hyperswitch_domain_models::router_request_types::PaymentMethodTokenizationData,
PaymentsResponseData,
>,
) -> Result<Self, Self::Error> {
match item.request.payment_method_data.clone() {
PaymentMethodData::Card(req_card) => {
let card_data = SilverflowCardData {
number: req_card.card_number.peek().to_string(),
expiry_month: req_card.card_exp_month.clone(),
expiry_year: req_card.card_exp_year.clone(),
cvc: req_card.card_cvc.clone().expose(),
holder_name: req_card
.get_cardholder_name()
.unwrap_or(Secret::new("".to_string()))
.expose(),
};
Ok(Self {
reference: format!("CUSTOMER_ID_{}", item.payment_id),
card_data,
})
}
_ => Err(errors::ConnectorError::NotImplemented(
utils::get_unimplemented_payment_method_error_message("silverflow"),
)
.into()),
}
}
}
// Type definition for TokenizationResponse
#[derive(Default, Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct SilverflowTokenizationResponse {
pub key: String,
#[serde(rename = "agentKey")]
pub agent_key: String,
pub last4: String,
pub status: String,
pub reference: String,
#[serde(rename = "cardInfo")]
pub card_info: Vec<CardInfo>,
pub created: String,
#[serde(rename = "cvcPresent")]
pub cvc_present: bool,
pub version: i32,
}
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct CardInfo {
#[serde(rename = "infoSource")]
pub info_source: String,
pub network: String,
#[serde(rename = "primaryNetwork")]
pub primary_network: bool,
}
impl<F, T> TryFrom<ResponseRouterData<F, SilverflowTokenizationResponse, T, PaymentsResponseData>>
for RouterData<F, T, PaymentsResponseData>
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: ResponseRouterData<F, SilverflowTokenizationResponse, T, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
Ok(Self {
response: Ok(PaymentsResponseData::TokenizationResponse {
token: item.response.key,
}),
..item.data
})
}
}
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
#[serde(rename_all = "camelCase")]
pub struct TokenizedCardDetails {
pub masked_card_number: String,
pub expiry_month: Secret<String>,
pub expiry_year: Secret<String>,
pub card_brand: String,
}
// WEBHOOKS:
// Type definition for Webhook Event structures
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
#[serde(rename_all = "camelCase")]
pub struct SilverflowWebhookEvent {
pub event_type: String,
pub event_data: SilverflowWebhookEventData,
pub event_id: String,
pub created: String,
pub version: i32,
}
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
#[serde(rename_all = "camelCase")]
pub struct SilverflowWebhookEventData {
pub charge_key: Option<String>,
pub refund_key: Option<String>,
pub status: Option<PaymentStatus>,
pub amount: Option<Amount>,
pub transaction_reference: Option<String>,
}
// Error Response Structures based on Silverflow API format
#[derive(Debug, Serialize, Deserialize, PartialEq)]
pub struct ErrorDetails {
pub field: String,
pub issue: String,
}
#[derive(Default, Debug, Serialize, Deserialize, PartialEq)]
pub struct SilverflowErrorResponse {
pub error: SilverflowError,
}
#[derive(Default, Debug, Serialize, Deserialize, PartialEq)]
pub struct SilverflowError {
pub code: String,
pub message: String,
pub details: Option<ErrorDetails>,
}
|
{
"crate": "hyperswitch_connectors",
"file": "crates/hyperswitch_connectors/src/connectors/silverflow/transformers.rs",
"file_size": null,
"is_async": null,
"is_pub": null,
"num_enums": 6,
"num_structs": 33,
"num_tables": null,
"score": null,
"total_crates": null
}
|
file_hyperswitch_connectors_-3681629749847503762
|
clm
|
file
|
// Repository: hyperswitch
// Crate: hyperswitch_connectors
// File: crates/hyperswitch_connectors/src/connectors/taxjar/transformers.rs
// Contains: 6 structs, 0 enums
use common_enums::enums;
use common_utils::types::{FloatMajorUnit, FloatMajorUnitForConnector};
use error_stack::report;
use hyperswitch_domain_models::{
router_data::{ConnectorAuthType, RouterData},
router_request_types::PaymentsTaxCalculationData,
router_response_types::TaxCalculationResponseData,
types,
};
use hyperswitch_interfaces::errors;
use masking::Secret;
use serde::{Deserialize, Serialize};
use crate::{
types::ResponseRouterData,
utils::{self, AddressDetailsData},
};
pub struct TaxjarRouterData<T> {
pub amount: FloatMajorUnit, // The type of amount that a connector accepts, for example, String, i64, f64, etc.
pub order_amount: FloatMajorUnit,
pub shipping: FloatMajorUnit,
pub router_data: T,
}
impl<T> From<(FloatMajorUnit, FloatMajorUnit, FloatMajorUnit, T)> for TaxjarRouterData<T> {
fn from(
(amount, order_amount, shipping, item): (FloatMajorUnit, FloatMajorUnit, FloatMajorUnit, T),
) -> Self {
Self {
amount,
order_amount,
shipping,
router_data: item,
}
}
}
#[derive(Default, Debug, Serialize, PartialEq)]
pub struct TaxjarPaymentsRequest {
to_country: enums::CountryAlpha2,
to_zip: Secret<String>,
to_state: Secret<String>,
to_city: Option<String>,
to_street: Option<Secret<String>>,
amount: FloatMajorUnit,
shipping: FloatMajorUnit,
line_items: Vec<LineItem>,
}
#[derive(Serialize, Deserialize, Debug, PartialEq)]
pub struct LineItem {
id: Option<String>,
quantity: Option<u16>,
product_tax_code: Option<String>,
unit_price: Option<FloatMajorUnit>,
}
#[derive(Default, Debug, Serialize, Eq, PartialEq)]
pub struct TaxjarCard {
number: cards::CardNumber,
expiry_month: Secret<String>,
expiry_year: Secret<String>,
cvc: Secret<String>,
complete: bool,
}
impl TryFrom<&TaxjarRouterData<&types::PaymentsTaxCalculationRouterData>>
for TaxjarPaymentsRequest
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: &TaxjarRouterData<&types::PaymentsTaxCalculationRouterData>,
) -> Result<Self, Self::Error> {
let request = &item.router_data.request;
let shipping = &item
.router_data
.request
.shipping_address
.address
.clone()
.ok_or(errors::ConnectorError::MissingRequiredField {
field_name: "address",
})?;
match request.order_details.clone() {
Some(order_details) => {
let line_items: Result<Vec<LineItem>, error_stack::Report<errors::ConnectorError>> =
order_details
.iter()
.map(|line_item| {
Ok(LineItem {
id: line_item.product_id.clone(),
quantity: Some(line_item.quantity),
product_tax_code: line_item.product_tax_code.clone(),
unit_price: Some(item.order_amount),
})
})
.collect();
Ok(Self {
to_country: shipping.get_country()?.to_owned(),
to_zip: shipping.get_zip()?.to_owned(),
to_state: shipping.to_state_code()?.to_owned(),
to_city: shipping.get_optional_city(),
to_street: shipping.get_optional_line1(),
amount: item.amount,
shipping: item.shipping,
line_items: line_items?,
})
}
None => Err(report!(errors::ConnectorError::MissingRequiredField {
field_name: "order_details"
})),
}
}
}
pub struct TaxjarAuthType {
pub(super) api_key: Secret<String>,
}
impl TryFrom<&ConnectorAuthType> for TaxjarAuthType {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(auth_type: &ConnectorAuthType) -> Result<Self, Self::Error> {
match auth_type {
ConnectorAuthType::HeaderKey { api_key } => Ok(Self {
api_key: api_key.to_owned(),
}),
_ => Err(errors::ConnectorError::FailedToObtainAuthType.into()),
}
}
}
#[derive(Default, Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct TaxjarPaymentsResponse {
tax: Tax,
}
#[derive(Default, Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct Tax {
amount_to_collect: FloatMajorUnit, //calculated_tax_amount
}
impl<F>
TryFrom<
ResponseRouterData<
F,
TaxjarPaymentsResponse,
PaymentsTaxCalculationData,
TaxCalculationResponseData,
>,
> for RouterData<F, PaymentsTaxCalculationData, TaxCalculationResponseData>
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: ResponseRouterData<
F,
TaxjarPaymentsResponse,
PaymentsTaxCalculationData,
TaxCalculationResponseData,
>,
) -> Result<Self, Self::Error> {
let currency = item.data.request.currency;
let amount_to_collect = item.response.tax.amount_to_collect;
let calculated_tax = utils::convert_back_amount_to_minor_units(
&FloatMajorUnitForConnector,
amount_to_collect,
currency,
)?;
Ok(Self {
response: Ok(TaxCalculationResponseData {
order_tax_amount: calculated_tax,
}),
..item.data
})
}
}
#[derive(Default, Debug, Serialize, Deserialize, PartialEq)]
pub struct TaxjarErrorResponse {
pub status: i64,
pub error: String,
pub detail: String,
}
|
{
"crate": "hyperswitch_connectors",
"file": "crates/hyperswitch_connectors/src/connectors/taxjar/transformers.rs",
"file_size": null,
"is_async": null,
"is_pub": null,
"num_enums": 0,
"num_structs": 6,
"num_tables": null,
"score": null,
"total_crates": null
}
|
file_hyperswitch_connectors_9036444333014125635
|
clm
|
file
|
// Repository: hyperswitch
// Crate: hyperswitch_connectors
// File: crates/hyperswitch_connectors/src/connectors/celero/transformers.rs
// Contains: 17 structs, 10 enums
use common_enums::{enums, Currency};
use common_utils::{id_type::CustomerId, pii::Email, types::MinorUnit};
use hyperswitch_domain_models::{
address::Address as DomainAddress,
payment_method_data::PaymentMethodData,
router_data::{
AdditionalPaymentMethodConnectorResponse, ConnectorAuthType, ConnectorResponseData,
RouterData,
},
router_flow_types::{
payments::Capture,
refunds::{Execute, RSync},
},
router_request_types::{PaymentsCaptureData, ResponseId},
router_response_types::{MandateReference, PaymentsResponseData, RefundsResponseData},
types::{
PaymentsAuthorizeRouterData, PaymentsCaptureRouterData, PaymentsSyncRouterData,
RefundSyncRouterData, RefundsRouterData,
},
};
use hyperswitch_interfaces::{
consts,
errors::{self},
};
use masking::{PeekInterface, Secret};
use serde::{Deserialize, Serialize};
use crate::{
types::{RefundsResponseRouterData, ResponseRouterData},
utils::{
get_unimplemented_payment_method_error_message, AddressDetailsData,
PaymentsAuthorizeRequestData, RefundsRequestData, RouterData as _,
},
};
//TODO: Fill the struct with respective fields
pub struct CeleroRouterData<T> {
pub amount: MinorUnit, // CeleroCommerce expects integer cents
pub router_data: T,
}
impl<T> TryFrom<(MinorUnit, T)> for CeleroRouterData<T> {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from((amount, item): (MinorUnit, T)) -> Result<Self, Self::Error> {
Ok(Self {
amount,
router_data: item,
})
}
}
// CeleroCommerce Search Request for sync operations - POST /api/transaction/search
#[derive(Debug, Serialize, PartialEq)]
pub struct CeleroSearchRequest {
transaction_id: String,
}
impl TryFrom<&PaymentsSyncRouterData> for CeleroSearchRequest {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(item: &PaymentsSyncRouterData) -> Result<Self, Self::Error> {
let transaction_id = match &item.request.connector_transaction_id {
ResponseId::ConnectorTransactionId(id) => id.clone(),
_ => {
return Err(errors::ConnectorError::MissingConnectorTransactionID.into());
}
};
Ok(Self { transaction_id })
}
}
impl TryFrom<&RefundSyncRouterData> for CeleroSearchRequest {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(item: &RefundSyncRouterData) -> Result<Self, Self::Error> {
Ok(Self {
transaction_id: item.request.get_connector_refund_id()?,
})
}
}
// CeleroCommerce Payment Request according to API specs
#[derive(Debug, Serialize, PartialEq)]
pub struct CeleroPaymentsRequest {
idempotency_key: String,
#[serde(rename = "type")]
transaction_type: TransactionType,
amount: MinorUnit, // CeleroCommerce expects integer cents
currency: Currency,
payment_method: CeleroPaymentMethod,
#[serde(skip_serializing_if = "Option::is_none")]
billing_address: Option<CeleroAddress>,
#[serde(skip_serializing_if = "Option::is_none")]
shipping_address: Option<CeleroAddress>,
#[serde(skip_serializing_if = "Option::is_none")]
create_vault_record: Option<bool>,
// CIT/MIT fields
#[serde(skip_serializing_if = "Option::is_none")]
card_on_file_indicator: Option<CardOnFileIndicator>,
#[serde(skip_serializing_if = "Option::is_none")]
initiated_by: Option<InitiatedBy>,
#[serde(skip_serializing_if = "Option::is_none")]
initial_transaction_id: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
stored_credential_indicator: Option<StoredCredentialIndicator>,
#[serde(skip_serializing_if = "Option::is_none")]
billing_method: Option<BillingMethod>,
}
#[derive(Debug, Serialize, PartialEq)]
pub struct CeleroAddress {
first_name: Option<Secret<String>>,
last_name: Option<Secret<String>>,
address_line_1: Option<Secret<String>>,
address_line_2: Option<Secret<String>>,
city: Option<String>,
state: Option<Secret<String>>,
postal_code: Option<Secret<String>>,
country: Option<common_enums::CountryAlpha2>,
phone: Option<Secret<String>>,
email: Option<Email>,
}
impl TryFrom<&DomainAddress> for CeleroAddress {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(address: &DomainAddress) -> Result<Self, Self::Error> {
let address_details = address.address.as_ref();
match address_details {
Some(address_details) => Ok(Self {
first_name: address_details.get_optional_first_name(),
last_name: address_details.get_optional_last_name(),
address_line_1: address_details.get_optional_line1(),
address_line_2: address_details.get_optional_line2(),
city: address_details.get_optional_city(),
state: address_details.get_optional_state(),
postal_code: address_details.get_optional_zip(),
country: address_details.get_optional_country(),
phone: address
.phone
.as_ref()
.and_then(|phone| phone.number.clone()),
email: address.email.clone(),
}),
None => Err(errors::ConnectorError::MissingRequiredField {
field_name: "address_details",
}
.into()),
}
}
}
#[derive(Debug, Serialize, PartialEq)]
#[serde(rename_all = "lowercase")]
pub enum CeleroPaymentMethod {
Card(CeleroCard),
Customer(CeleroCustomer),
}
#[derive(Debug, Serialize, PartialEq)]
pub struct CeleroCustomer {
id: Option<CustomerId>,
payment_method_id: Option<String>,
}
#[derive(Debug, Serialize, PartialEq, Clone, Copy)]
#[serde(rename_all = "lowercase")]
pub enum CeleroEntryType {
Keyed,
}
#[derive(Debug, Serialize, PartialEq)]
pub struct CeleroCard {
entry_type: CeleroEntryType,
number: cards::CardNumber,
expiration_date: Secret<String>,
cvc: Secret<String>,
}
impl TryFrom<&PaymentMethodData> for CeleroPaymentMethod {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(item: &PaymentMethodData) -> Result<Self, Self::Error> {
match item {
PaymentMethodData::Card(req_card) => {
let card = CeleroCard {
entry_type: CeleroEntryType::Keyed,
number: req_card.card_number.clone(),
expiration_date: Secret::new(format!(
"{}/{}",
req_card.card_exp_month.peek(),
req_card.card_exp_year.peek()
)),
cvc: req_card.card_cvc.clone(),
};
Ok(Self::Card(card))
}
PaymentMethodData::CardDetailsForNetworkTransactionId(_)
| PaymentMethodData::CardRedirect(_)
| PaymentMethodData::Wallet(_)
| PaymentMethodData::PayLater(_)
| PaymentMethodData::BankRedirect(_)
| PaymentMethodData::BankDebit(_)
| PaymentMethodData::BankTransfer(_)
| PaymentMethodData::Crypto(_)
| PaymentMethodData::MandatePayment
| PaymentMethodData::Reward
| PaymentMethodData::RealTimePayment(_)
| PaymentMethodData::Upi(_)
| PaymentMethodData::Voucher(_)
| PaymentMethodData::GiftCard(_)
| PaymentMethodData::CardToken(_)
| PaymentMethodData::OpenBanking(_)
| PaymentMethodData::NetworkToken(_)
| PaymentMethodData::MobilePayment(_) => Err(errors::ConnectorError::NotImplemented(
"Selected payment method through celero".to_string(),
)
.into()),
}
}
}
// Implementation for handling 3DS specifically
impl TryFrom<(&PaymentMethodData, bool)> for CeleroPaymentMethod {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from((item, is_three_ds): (&PaymentMethodData, bool)) -> Result<Self, Self::Error> {
// If 3DS is requested, return an error
if is_three_ds {
return Err(errors::ConnectorError::NotSupported {
message: "Cards 3DS".to_string(),
connector: "celero",
}
.into());
}
// Otherwise, delegate to the standard implementation
Self::try_from(item)
}
}
impl TryFrom<&CeleroRouterData<&PaymentsAuthorizeRouterData>> for CeleroPaymentsRequest {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: &CeleroRouterData<&PaymentsAuthorizeRouterData>,
) -> Result<Self, Self::Error> {
let is_auto_capture = item.router_data.request.is_auto_capture()?;
let transaction_type = if is_auto_capture {
TransactionType::Sale
} else {
TransactionType::Authorize
};
let billing_address: Option<CeleroAddress> = item
.router_data
.get_optional_billing()
.and_then(|address| address.try_into().ok());
let shipping_address: Option<CeleroAddress> = item
.router_data
.get_optional_shipping()
.and_then(|address| address.try_into().ok());
// Determine CIT/MIT fields based on mandate data
let (mandate_fields, payment_method) = determine_cit_mit_fields(item.router_data)?;
let request = Self {
idempotency_key: item.router_data.connector_request_reference_id.clone(),
transaction_type,
amount: item.amount,
currency: item.router_data.request.currency,
payment_method,
billing_address,
shipping_address,
create_vault_record: Some(false),
card_on_file_indicator: mandate_fields.card_on_file_indicator,
initiated_by: mandate_fields.initiated_by,
initial_transaction_id: mandate_fields.initial_transaction_id,
stored_credential_indicator: mandate_fields.stored_credential_indicator,
billing_method: mandate_fields.billing_method,
};
Ok(request)
}
}
// Define a struct to hold CIT/MIT fields to avoid complex tuple return type
#[derive(Debug, Default)]
pub struct CeleroMandateFields {
pub card_on_file_indicator: Option<CardOnFileIndicator>,
pub initiated_by: Option<InitiatedBy>,
pub initial_transaction_id: Option<String>,
pub stored_credential_indicator: Option<StoredCredentialIndicator>,
pub billing_method: Option<BillingMethod>,
}
// Helper function to determine CIT/MIT fields based on mandate data
fn determine_cit_mit_fields(
router_data: &PaymentsAuthorizeRouterData,
) -> Result<(CeleroMandateFields, CeleroPaymentMethod), error_stack::Report<errors::ConnectorError>>
{
// Default null values
let mut mandate_fields = CeleroMandateFields::default();
// First check if there's a mandate_id in the request
match router_data
.request
.mandate_id
.clone()
.and_then(|mandate_ids| mandate_ids.mandate_reference_id)
{
// If there's a connector mandate ID, this is a MIT (Merchant Initiated Transaction)
Some(api_models::payments::MandateReferenceId::ConnectorMandateId(
connector_mandate_id,
)) => {
mandate_fields.card_on_file_indicator = Some(CardOnFileIndicator::RecurringPayment);
mandate_fields.initiated_by = Some(InitiatedBy::Merchant); // This is a MIT
mandate_fields.stored_credential_indicator = Some(StoredCredentialIndicator::Used);
mandate_fields.billing_method = Some(BillingMethod::Recurring);
mandate_fields.initial_transaction_id =
connector_mandate_id.get_connector_mandate_request_reference_id();
Ok((
mandate_fields,
CeleroPaymentMethod::Customer(CeleroCustomer {
id: Some(router_data.get_customer_id()?),
payment_method_id: connector_mandate_id.get_payment_method_id(),
}),
))
}
// For other mandate types that might not be supported
Some(api_models::payments::MandateReferenceId::NetworkMandateId(_))
| Some(api_models::payments::MandateReferenceId::NetworkTokenWithNTI(_)) => {
// These might need different handling or return an error
Err(errors::ConnectorError::NotImplemented(
get_unimplemented_payment_method_error_message("Celero"),
)
.into())
}
// If no mandate ID is present, check if it's a mandate payment
None => {
if router_data.request.is_mandate_payment() {
// This is a customer-initiated transaction for a recurring payment
mandate_fields.initiated_by = Some(InitiatedBy::Customer);
mandate_fields.card_on_file_indicator = Some(CardOnFileIndicator::RecurringPayment);
mandate_fields.billing_method = Some(BillingMethod::Recurring);
mandate_fields.stored_credential_indicator = Some(StoredCredentialIndicator::Used);
}
let is_three_ds = router_data.is_three_ds();
Ok((
mandate_fields,
CeleroPaymentMethod::try_from((
&router_data.request.payment_method_data,
is_three_ds,
))?,
))
}
}
}
// Auth Struct for CeleroCommerce API key authentication
pub struct CeleroAuthType {
pub(super) api_key: Secret<String>,
}
impl TryFrom<&ConnectorAuthType> for CeleroAuthType {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(auth_type: &ConnectorAuthType) -> Result<Self, Self::Error> {
match auth_type {
ConnectorAuthType::HeaderKey { api_key } => Ok(Self {
api_key: api_key.clone(),
}),
_ => Err(errors::ConnectorError::FailedToObtainAuthType.into()),
}
}
}
// CeleroCommerce API Response Structures
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub enum CeleroResponseStatus {
#[serde(alias = "success", alias = "Success", alias = "SUCCESS")]
Success,
#[serde(alias = "error", alias = "Error", alias = "ERROR")]
Error,
}
#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum CeleroTransactionStatus {
Approved,
Declined,
Error,
Pending,
PendingSettlement,
Settled,
Voided,
Reversed,
}
impl From<CeleroTransactionStatus> for common_enums::AttemptStatus {
fn from(item: CeleroTransactionStatus) -> Self {
match item {
CeleroTransactionStatus::Approved => Self::Authorized,
CeleroTransactionStatus::Settled => Self::Charged,
CeleroTransactionStatus::Declined | CeleroTransactionStatus::Error => Self::Failure,
CeleroTransactionStatus::Pending | CeleroTransactionStatus::PendingSettlement => {
Self::Pending
}
CeleroTransactionStatus::Voided | CeleroTransactionStatus::Reversed => Self::Voided,
}
}
}
#[serde_with::skip_serializing_none]
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct CeleroCardResponse {
pub status: CeleroTransactionStatus,
pub auth_code: Option<String>,
pub processor_response_code: Option<String>,
pub avs_response_code: Option<String>,
}
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
#[serde(rename_all = "lowercase")]
pub enum CeleroPaymentMethodResponse {
Card(CeleroCardResponse),
}
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
#[serde(rename_all = "lowercase")]
pub enum TransactionType {
Sale,
Authorize,
}
// CIT/MIT related enums
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub enum CardOnFileIndicator {
#[serde(rename = "C")]
GeneralPurposeStorage,
#[serde(rename = "R")]
RecurringPayment,
}
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
#[serde(rename_all = "lowercase")]
pub enum InitiatedBy {
Customer,
Merchant,
}
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
#[serde(rename_all = "lowercase")]
pub enum StoredCredentialIndicator {
Used,
Stored,
}
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
#[serde(rename_all = "lowercase")]
pub enum BillingMethod {
Straight,
#[serde(rename = "initial_recurring")]
InitialRecurring,
Recurring,
}
#[derive(Debug, Clone, Deserialize, Serialize, PartialEq)]
#[serde_with::skip_serializing_none]
pub struct CeleroTransactionResponseData {
pub id: String,
#[serde(rename = "type")]
pub transaction_type: TransactionType,
pub amount: i64,
pub currency: String,
pub response: CeleroPaymentMethodResponse,
pub billing_address: Option<CeleroAddressResponse>,
pub shipping_address: Option<CeleroAddressResponse>,
// Additional fields from the sample response
pub status: Option<String>,
pub response_code: Option<i32>,
pub customer_id: Option<String>,
pub payment_method_id: Option<String>,
}
impl CeleroTransactionResponseData {
pub fn get_mandate_reference(&self) -> Box<Option<MandateReference>> {
if self.payment_method_id.is_some() {
Box::new(Some(MandateReference {
connector_mandate_id: None,
payment_method_id: self.payment_method_id.clone(),
mandate_metadata: None,
connector_mandate_request_reference_id: Some(self.id.clone()),
}))
} else {
Box::new(None)
}
}
}
#[derive(Debug, Clone, Deserialize, Serialize, PartialEq)]
pub struct CeleroAddressResponse {
first_name: Option<Secret<String>>,
last_name: Option<Secret<String>>,
address_line_1: Option<Secret<String>>,
address_line_2: Option<Secret<String>>,
city: Option<String>,
state: Option<Secret<String>>,
postal_code: Option<Secret<String>>,
country: Option<common_enums::CountryAlpha2>,
phone: Option<Secret<String>>,
email: Option<Secret<String>>,
}
#[derive(Debug, Clone, Deserialize, Serialize, PartialEq)]
pub struct CeleroPaymentsResponse {
pub status: CeleroResponseStatus,
pub msg: String,
pub data: Option<CeleroTransactionResponseData>,
}
impl<F, T> TryFrom<ResponseRouterData<F, CeleroPaymentsResponse, T, PaymentsResponseData>>
for RouterData<F, T, PaymentsResponseData>
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: ResponseRouterData<F, CeleroPaymentsResponse, T, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
match item.response.status {
CeleroResponseStatus::Success => {
if let Some(data) = item.response.data {
let CeleroPaymentMethodResponse::Card(response) = &data.response;
// Check if transaction itself failed despite successful API call
match response.status {
CeleroTransactionStatus::Declined | CeleroTransactionStatus::Error => {
// Transaction failed - create error response with transaction details
let error_details = CeleroErrorDetails::from_transaction_response(
response,
item.response.msg,
);
Ok(Self {
status: common_enums::AttemptStatus::Failure,
response: Err(
hyperswitch_domain_models::router_data::ErrorResponse {
code: error_details
.error_code
.unwrap_or_else(|| "TRANSACTION_FAILED".to_string()),
message: error_details.error_message,
reason: error_details.decline_reason,
status_code: item.http_code,
attempt_status: None,
connector_transaction_id: Some(data.id),
network_decline_code: None,
network_advice_code: None,
network_error_message: None,
connector_metadata: None,
},
),
..item.data
})
}
_ => {
let connector_response_data =
convert_to_additional_payment_method_connector_response(
response.avs_response_code.clone(),
)
.map(ConnectorResponseData::with_additional_payment_method_data);
let final_status: enums::AttemptStatus = response.status.into();
Ok(Self {
status: final_status,
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(
data.id.clone(),
),
redirection_data: Box::new(None),
mandate_reference: data.get_mandate_reference(),
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: response.auth_code.clone(),
incremental_authorization_allowed: None,
charges: None,
}),
connector_response: connector_response_data,
..item.data
})
}
}
} else {
// No transaction data in successful response
// We don't have a transaction ID in this case
Ok(Self {
status: common_enums::AttemptStatus::Failure,
response: Err(hyperswitch_domain_models::router_data::ErrorResponse {
code: "MISSING_DATA".to_string(),
message: "No transaction data in response".to_string(),
reason: Some(item.response.msg),
status_code: item.http_code,
attempt_status: None,
connector_transaction_id: None,
network_decline_code: None,
network_advice_code: None,
network_error_message: None,
connector_metadata: None,
}),
..item.data
})
}
}
CeleroResponseStatus::Error => {
// Top-level API error
let error_details =
CeleroErrorDetails::from_top_level_error(item.response.msg.clone());
// Extract transaction ID from the top-level data if available
let connector_transaction_id =
item.response.data.as_ref().map(|data| data.id.clone());
Ok(Self {
status: common_enums::AttemptStatus::Failure,
response: Err(hyperswitch_domain_models::router_data::ErrorResponse {
code: error_details
.error_code
.unwrap_or_else(|| "API_ERROR".to_string()),
message: error_details.error_message,
reason: error_details.decline_reason,
status_code: item.http_code,
attempt_status: None,
connector_transaction_id,
network_decline_code: None,
network_advice_code: None,
network_error_message: None,
connector_metadata: None,
}),
..item.data
})
}
}
}
}
// CAPTURE:
// Type definition for CaptureRequest
#[derive(Default, Debug, Serialize)]
pub struct CeleroCaptureRequest {
pub amount: MinorUnit,
#[serde(skip_serializing_if = "Option::is_none")]
pub order_id: Option<String>,
}
impl TryFrom<&CeleroRouterData<&PaymentsCaptureRouterData>> for CeleroCaptureRequest {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(item: &CeleroRouterData<&PaymentsCaptureRouterData>) -> Result<Self, Self::Error> {
Ok(Self {
amount: item.amount,
order_id: Some(item.router_data.payment_id.clone()),
})
}
}
// CeleroCommerce Capture Response
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct CeleroCaptureResponse {
pub status: CeleroResponseStatus,
pub msg: Option<String>,
pub data: Option<serde_json::Value>, // Usually null for capture responses
}
impl
TryFrom<
ResponseRouterData<
Capture,
CeleroCaptureResponse,
PaymentsCaptureData,
PaymentsResponseData,
>,
> for RouterData<Capture, PaymentsCaptureData, PaymentsResponseData>
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: ResponseRouterData<
Capture,
CeleroCaptureResponse,
PaymentsCaptureData,
PaymentsResponseData,
>,
) -> Result<Self, Self::Error> {
match item.response.status {
CeleroResponseStatus::Success => Ok(Self {
status: common_enums::AttemptStatus::Charged,
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(
item.data.request.connector_transaction_id.clone(),
),
redirection_data: Box::new(None),
mandate_reference: Box::new(None),
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: None,
incremental_authorization_allowed: None,
charges: None,
}),
..item.data
}),
CeleroResponseStatus::Error => Ok(Self {
status: common_enums::AttemptStatus::Failure,
response: Err(hyperswitch_domain_models::router_data::ErrorResponse {
code: "CAPTURE_FAILED".to_string(),
message: item
.response
.msg
.clone()
.unwrap_or(consts::NO_ERROR_MESSAGE.to_string()),
reason: None,
status_code: item.http_code,
attempt_status: None,
connector_transaction_id: Some(
item.data.request.connector_transaction_id.clone(),
),
network_decline_code: None,
network_advice_code: None,
network_error_message: None,
connector_metadata: None,
}),
..item.data
}),
}
}
}
// CeleroCommerce Void Response - matches API spec format
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct CeleroVoidResponse {
pub status: CeleroResponseStatus,
pub msg: String,
pub data: Option<serde_json::Value>, // Usually null for void responses
}
impl
TryFrom<
ResponseRouterData<
hyperswitch_domain_models::router_flow_types::payments::Void,
CeleroVoidResponse,
hyperswitch_domain_models::router_request_types::PaymentsCancelData,
PaymentsResponseData,
>,
>
for RouterData<
hyperswitch_domain_models::router_flow_types::payments::Void,
hyperswitch_domain_models::router_request_types::PaymentsCancelData,
PaymentsResponseData,
>
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: ResponseRouterData<
hyperswitch_domain_models::router_flow_types::payments::Void,
CeleroVoidResponse,
hyperswitch_domain_models::router_request_types::PaymentsCancelData,
PaymentsResponseData,
>,
) -> Result<Self, Self::Error> {
match item.response.status {
CeleroResponseStatus::Success => Ok(Self {
status: common_enums::AttemptStatus::Voided,
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(
item.data.request.connector_transaction_id.clone(),
),
redirection_data: Box::new(None),
mandate_reference: Box::new(None),
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: None,
incremental_authorization_allowed: None,
charges: None,
}),
..item.data
}),
CeleroResponseStatus::Error => Ok(Self {
status: common_enums::AttemptStatus::Failure,
response: Err(hyperswitch_domain_models::router_data::ErrorResponse {
code: "VOID_FAILED".to_string(),
message: item.response.msg.clone(),
reason: Some(item.response.msg),
status_code: item.http_code,
attempt_status: None,
connector_transaction_id: Some(
item.data.request.connector_transaction_id.clone(),
),
network_decline_code: None,
network_advice_code: None,
network_error_message: None,
connector_metadata: None,
}),
..item.data
}),
}
}
}
#[derive(Default, Debug, Serialize)]
pub struct CeleroRefundRequest {
pub amount: MinorUnit,
pub surcharge: MinorUnit, // Required field as per API specification
}
impl<F> TryFrom<&CeleroRouterData<&RefundsRouterData<F>>> for CeleroRefundRequest {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(item: &CeleroRouterData<&RefundsRouterData<F>>) -> Result<Self, Self::Error> {
Ok(Self {
amount: item.amount,
surcharge: MinorUnit::zero(), // Default to 0 as per API specification
})
}
}
// CeleroCommerce Refund Response - matches API spec format
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct CeleroRefundResponse {
pub status: CeleroResponseStatus,
pub msg: String,
pub data: Option<serde_json::Value>, // Usually null for refund responses
}
impl TryFrom<RefundsResponseRouterData<Execute, CeleroRefundResponse>>
for RefundsRouterData<Execute>
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: RefundsResponseRouterData<Execute, CeleroRefundResponse>,
) -> Result<Self, Self::Error> {
match item.response.status {
CeleroResponseStatus::Success => Ok(Self {
response: Ok(RefundsResponseData {
connector_refund_id: item.data.request.refund_id.clone(),
refund_status: enums::RefundStatus::Success,
}),
..item.data
}),
CeleroResponseStatus::Error => Ok(Self {
response: Err(hyperswitch_domain_models::router_data::ErrorResponse {
code: "REFUND_FAILED".to_string(),
message: item.response.msg.clone(),
reason: Some(item.response.msg),
status_code: item.http_code,
attempt_status: None,
connector_transaction_id: Some(
item.data.request.connector_transaction_id.clone(),
),
network_decline_code: None,
network_advice_code: None,
network_error_message: None,
connector_metadata: None,
}),
..item.data
}),
}
}
}
impl TryFrom<RefundsResponseRouterData<RSync, CeleroRefundResponse>> for RefundsRouterData<RSync> {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: RefundsResponseRouterData<RSync, CeleroRefundResponse>,
) -> Result<Self, Self::Error> {
match item.response.status {
CeleroResponseStatus::Success => Ok(Self {
response: Ok(RefundsResponseData {
connector_refund_id: item.data.request.refund_id.clone(),
refund_status: enums::RefundStatus::Success,
}),
..item.data
}),
CeleroResponseStatus::Error => Ok(Self {
response: Err(hyperswitch_domain_models::router_data::ErrorResponse {
code: "REFUND_SYNC_FAILED".to_string(),
message: item.response.msg.clone(),
reason: Some(item.response.msg),
status_code: item.http_code,
attempt_status: None,
connector_transaction_id: Some(
item.data.request.connector_transaction_id.clone(),
),
network_decline_code: None,
network_advice_code: None,
network_error_message: None,
connector_metadata: None,
}),
..item.data
}),
}
}
}
// CeleroCommerce Error Response Structures
// Main error response structure - matches API spec format
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct CeleroErrorResponse {
pub status: CeleroResponseStatus,
pub msg: String,
#[serde(skip_serializing_if = "Option::is_none")]
pub data: Option<serde_json::Value>,
}
// Error details that can be extracted from various response fields
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct CeleroErrorDetails {
pub error_code: Option<String>,
pub error_message: String,
pub processor_response_code: Option<String>,
pub decline_reason: Option<String>,
}
impl From<CeleroErrorResponse> for CeleroErrorDetails {
fn from(error_response: CeleroErrorResponse) -> Self {
Self {
error_code: Some("API_ERROR".to_string()),
error_message: error_response.msg,
processor_response_code: None,
decline_reason: None,
}
}
}
// Function to extract error details from transaction response data
impl CeleroErrorDetails {
pub fn from_transaction_response(response: &CeleroCardResponse, msg: String) -> Self {
// Map specific error codes based on common response patterns
let decline_reason = Self::map_processor_error(&response.processor_response_code, &msg);
Self {
error_code: None,
error_message: msg,
processor_response_code: response.processor_response_code.clone(),
decline_reason,
}
}
pub fn from_top_level_error(msg: String) -> Self {
// Map specific error codes from top-level API errors
Self {
error_code: None,
error_message: msg,
processor_response_code: None,
decline_reason: None,
}
}
/// Map processor response codes and messages to specific Hyperswitch error codes
fn map_processor_error(processor_code: &Option<String>, message: &str) -> Option<String> {
let message_lower = message.to_lowercase();
// Check processor response codes if available
if let Some(code) = processor_code {
match code.as_str() {
"05" => Some("TRANSACTION_DECLINED".to_string()),
"14" => Some("INVALID_CARD_DATA".to_string()),
"51" => Some("INSUFFICIENT_FUNDS".to_string()),
"54" => Some("EXPIRED_CARD".to_string()),
"55" => Some("INCORRECT_CVC".to_string()),
"61" => Some("Exceeds withdrawal amount limit".to_string()),
"62" => Some("TRANSACTION_DECLINED".to_string()),
"65" => Some("Exceeds withdrawal frequency limit".to_string()),
"78" => Some("INVALID_CARD_DATA".to_string()),
"91" => Some("PROCESSING_ERROR".to_string()),
"96" => Some("PROCESSING_ERROR".to_string()),
_ => {
router_env::logger::info!(
"Celero response error code ({:?}) is not mapped to any error state ",
code
);
Some("Transaction failed".to_string())
}
}
} else {
Some(message_lower)
}
}
}
pub fn get_avs_definition(code: &str) -> Option<&'static str> {
match code {
"0" => Some("AVS Not Available"),
"A" => Some("Address match only"),
"B" => Some("Address matches, ZIP not verified"),
"C" => Some("Incompatible format"),
"D" => Some("Exact match"),
"F" => Some("Exact match, UK-issued cards"),
"G" => Some("Non-U.S. Issuer does not participate"),
"I" => Some("Not verified"),
"M" => Some("Exact match"),
"N" => Some("No address or ZIP match"),
"P" => Some("Postal Code match"),
"R" => Some("Issuer system unavailable"),
"S" => Some("Service not supported"),
"U" => Some("Address unavailable"),
"W" => Some("9-character numeric ZIP match only"),
"X" => Some("Exact match, 9-character numeric ZIP"),
"Y" => Some("Exact match, 5-character numeric ZIP"),
"Z" => Some("5-character ZIP match only"),
"L" => Some("Partial match, Name and billing postal code match"),
"1" => Some("Cardholder name and ZIP match"),
"2" => Some("Cardholder name, address and ZIP match"),
"3" => Some("Cardholder name and address match"),
"4" => Some("Cardholder name matches"),
"5" => Some("Cardholder name incorrect, ZIP matches"),
"6" => Some("Cardholder name incorrect, address and zip match"),
"7" => Some("Cardholder name incorrect, address matches"),
"8" => Some("Cardholder name, address, and ZIP do not match"),
_ => {
router_env::logger::info!(
"Celero avs response code ({:?}) is not mapped to any definition.",
code
);
None
} // No definition found for the given code
}
}
fn convert_to_additional_payment_method_connector_response(
response_code: Option<String>,
) -> Option<AdditionalPaymentMethodConnectorResponse> {
match response_code {
None => None,
Some(code) => {
let description = get_avs_definition(&code);
let payment_checks = serde_json::json!({
"avs_result_code": code,
"description": description
});
Some(AdditionalPaymentMethodConnectorResponse::Card {
authentication_data: None,
payment_checks: Some(payment_checks),
card_network: None,
domestic_network: None,
})
}
}
}
|
{
"crate": "hyperswitch_connectors",
"file": "crates/hyperswitch_connectors/src/connectors/celero/transformers.rs",
"file_size": null,
"is_async": null,
"is_pub": null,
"num_enums": 10,
"num_structs": 17,
"num_tables": null,
"score": null,
"total_crates": null
}
|
file_hyperswitch_connectors_-6298615930314475069
|
clm
|
file
|
// Repository: hyperswitch
// Crate: hyperswitch_connectors
// File: crates/hyperswitch_connectors/src/connectors/adyen/transformers.rs
// Contains: 90 structs, 30 enums
use std::str::FromStr;
#[cfg(feature = "payouts")]
use api_models::payouts::{self, PayoutMethodData};
use api_models::{
enums,
payments::{self, PollConfig, QrCodeInformation, VoucherNextStepData},
};
use cards::CardNumber;
use common_enums::enums as storage_enums;
#[cfg(feature = "payouts")]
use common_utils::ext_traits::OptionExt;
use common_utils::{
errors::{CustomResult, ParsingError},
ext_traits::{Encode, ValueExt},
pii::Email,
request::Method,
types::MinorUnit,
};
use error_stack::{report, ResultExt};
use hyperswitch_domain_models::{
network_tokenization::NetworkTokenNumber,
payment_method_data::{
BankDebitData, BankRedirectData, BankTransferData, Card, CardRedirectData, GiftCardData,
NetworkTokenData, PayLaterData, PaymentMethodData, VoucherData, WalletData,
},
router_data::{
ConnectorAuthType, ConnectorResponseData, ErrorResponse, ExtendedAuthorizationResponseData,
PaymentMethodBalance, PaymentMethodToken, RouterData,
},
router_flow_types::GiftCardBalanceCheck,
router_request_types::{
GiftCardBalanceCheckRequestData, PaymentsExtendAuthorizationData,
PaymentsPreProcessingData, ResponseId, SubmitEvidenceRequestData,
},
router_response_types::{
AcceptDisputeResponse, DefendDisputeResponse, GiftCardBalanceCheckResponseData,
MandateReference, PaymentsResponseData, RedirectForm, RefundsResponseData,
SubmitEvidenceResponse,
},
types::{
PaymentsAuthorizeRouterData, PaymentsCancelRouterData, PaymentsCaptureRouterData,
PaymentsExtendAuthorizationRouterData, PaymentsGiftCardBalanceCheckRouterData,
PaymentsPreProcessingRouterData, RefundsRouterData,
},
};
#[cfg(feature = "payouts")]
use hyperswitch_domain_models::{
router_response_types::PayoutsResponseData, types::PayoutsRouterData,
};
use hyperswitch_interfaces::{
consts::{NO_ERROR_CODE, NO_ERROR_MESSAGE},
errors,
};
use masking::{ExposeInterface, PeekInterface, Secret};
use serde::{Deserialize, Serialize};
use time::{Duration, OffsetDateTime, PrimitiveDateTime};
use url::Url;
#[cfg(feature = "payouts")]
use crate::{types::PayoutsResponseRouterData, utils::PayoutsData};
use crate::{
types::{
AcceptDisputeRouterData, DefendDisputeRouterData, PaymentsCancelResponseRouterData,
PaymentsCaptureResponseRouterData, RefundsResponseRouterData, ResponseRouterData,
SubmitEvidenceRouterData,
},
utils::{
self, is_manual_capture, missing_field_err, AddressDetailsData, BrowserInformationData,
CardData, ForeignTryFrom, NetworkTokenData as UtilsNetworkTokenData,
PaymentsAuthorizeRequestData, PhoneDetailsData, RouterData as OtherRouterData,
},
};
type Error = error_stack::Report<errors::ConnectorError>;
#[derive(Debug, Serialize)]
pub struct AdyenRouterData<T> {
pub amount: MinorUnit,
pub router_data: T,
}
impl<T> TryFrom<(MinorUnit, T)> for AdyenRouterData<T> {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from((amount, item): (MinorUnit, T)) -> Result<Self, Self::Error> {
Ok(Self {
amount,
router_data: item,
})
}
}
#[derive(Debug, Default, Serialize, Deserialize)]
pub struct AdyenConnectorMetadataObject {
pub endpoint_prefix: Option<String>,
}
impl TryFrom<&Option<common_utils::pii::SecretSerdeValue>> for AdyenConnectorMetadataObject {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
meta_data: &Option<common_utils::pii::SecretSerdeValue>,
) -> Result<Self, Self::Error> {
match meta_data {
Some(metadata) => utils::to_connector_meta_from_secret::<Self>(Some(metadata.clone()))
.change_context(errors::ConnectorError::InvalidConnectorConfig {
config: "metadata",
}),
None => Ok(Self::default()),
}
}
}
// Adyen Types Definition
// Payments Request and Response Types
#[derive(Default, Debug, Serialize, Deserialize)]
pub enum AdyenShopperInteraction {
#[default]
Ecommerce,
#[serde(rename = "ContAuth")]
ContinuedAuthentication,
Moto,
#[serde(rename = "POS")]
Pos,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "PascalCase")]
pub enum AdyenRecurringModel {
UnscheduledCardOnFile,
CardOnFile,
}
#[derive(Clone, Default, Debug, Serialize, Deserialize)]
pub enum AuthType {
#[default]
PreAuth,
}
#[serde_with::skip_serializing_none]
#[derive(Clone, Default, Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct AdditionalData {
authorisation_type: Option<AuthType>,
manual_capture: Option<String>,
execute_three_d: Option<String>,
pub recurring_processing_model: Option<AdyenRecurringModel>,
/// Enable recurring details in dashboard to receive this ID, https://docs.adyen.com/online-payments/tokenization/create-and-use-tokens#test-and-go-live
#[serde(rename = "recurring.recurringDetailReference")]
recurring_detail_reference: Option<Secret<String>>,
#[serde(rename = "recurring.shopperReference")]
recurring_shopper_reference: Option<String>,
network_tx_reference: Option<Secret<String>>,
#[cfg(feature = "payouts")]
payout_eligible: Option<PayoutEligibility>,
funds_availability: Option<String>,
refusal_reason_raw: Option<String>,
refusal_code_raw: Option<String>,
merchant_advice_code: Option<String>,
#[serde(flatten)]
riskdata: Option<RiskData>,
}
#[serde_with::skip_serializing_none]
#[derive(Default, Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ShopperName {
first_name: Option<Secret<String>>,
last_name: Option<Secret<String>>,
}
#[serde_with::skip_serializing_none]
#[derive(Default, Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Address {
city: String,
country: enums::CountryAlpha2,
house_number_or_name: Secret<String>,
postal_code: Secret<String>,
state_or_province: Option<Secret<String>>,
street: Option<Secret<String>>,
}
#[serde_with::skip_serializing_none]
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct LineItem {
amount_excluding_tax: Option<MinorUnit>,
amount_including_tax: Option<MinorUnit>,
description: Option<String>,
id: Option<String>,
tax_amount: Option<MinorUnit>,
quantity: Option<u16>,
}
#[serde_with::skip_serializing_none]
#[derive(Clone, Default, Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct RiskData {
#[serde(rename = "riskdata.basket.item1.itemID")]
item_i_d: Option<String>,
#[serde(rename = "riskdata.basket.item1.productTitle")]
product_title: Option<String>,
#[serde(rename = "riskdata.basket.item1.amountPerItem")]
amount_per_item: Option<String>,
#[serde(rename = "riskdata.basket.item1.currency")]
currency: Option<String>,
#[serde(rename = "riskdata.basket.item1.upc")]
upc: Option<String>,
#[serde(rename = "riskdata.basket.item1.brand")]
brand: Option<String>,
#[serde(rename = "riskdata.basket.item1.manufacturer")]
manufacturer: Option<String>,
#[serde(rename = "riskdata.basket.item1.category")]
category: Option<String>,
#[serde(rename = "riskdata.basket.item1.quantity")]
quantity: Option<String>,
#[serde(rename = "riskdata.basket.item1.color")]
color: Option<String>,
#[serde(rename = "riskdata.basket.item1.size")]
size: Option<String>,
#[serde(rename = "riskdata.deviceCountry")]
device_country: Option<String>,
#[serde(rename = "riskdata.houseNumberorName")]
house_numberor_name: Option<String>,
#[serde(rename = "riskdata.accountCreationDate")]
account_creation_date: Option<String>,
#[serde(rename = "riskdata.affiliateChannel")]
affiliate_channel: Option<String>,
#[serde(rename = "riskdata.avgOrderValue")]
avg_order_value: Option<String>,
#[serde(rename = "riskdata.deliveryMethod")]
delivery_method: Option<String>,
#[serde(rename = "riskdata.emailName")]
email_name: Option<String>,
#[serde(rename = "riskdata.emailDomain")]
email_domain: Option<String>,
#[serde(rename = "riskdata.lastOrderDate")]
last_order_date: Option<String>,
#[serde(rename = "riskdata.merchantReference")]
merchant_reference: Option<String>,
#[serde(rename = "riskdata.paymentMethod")]
payment_method: Option<String>,
#[serde(rename = "riskdata.promotionName")]
promotion_name: Option<String>,
#[serde(rename = "riskdata.secondaryPhoneNumber")]
secondary_phone_number: Option<String>,
#[serde(rename = "riskdata.timefromLogintoOrder")]
timefrom_loginto_order: Option<String>,
#[serde(rename = "riskdata.totalSessionTime")]
total_session_time: Option<String>,
#[serde(rename = "riskdata.totalAuthorizedAmountInLast30Days")]
total_authorized_amount_in_last30_days: Option<String>,
#[serde(rename = "riskdata.totalOrderQuantity")]
total_order_quantity: Option<String>,
#[serde(rename = "riskdata.totalLifetimeValue")]
total_lifetime_value: Option<String>,
#[serde(rename = "riskdata.visitsMonth")]
visits_month: Option<String>,
#[serde(rename = "riskdata.visitsWeek")]
visits_week: Option<String>,
#[serde(rename = "riskdata.visitsYear")]
visits_year: Option<String>,
#[serde(rename = "riskdata.shipToName")]
ship_to_name: Option<String>,
#[serde(rename = "riskdata.first8charactersofAddressLine1Zip")]
first8charactersof_address_line1_zip: Option<String>,
#[serde(rename = "riskdata.affiliateOrder")]
affiliate_order: Option<bool>,
}
#[serde_with::skip_serializing_none]
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct AdyenPaymentRequest<'a> {
amount: Amount,
merchant_account: Secret<String>,
payment_method: PaymentMethod<'a>,
mpi_data: Option<AdyenMpiData>,
reference: String,
return_url: String,
browser_info: Option<AdyenBrowserInfo>,
shopper_interaction: AdyenShopperInteraction,
recurring_processing_model: Option<AdyenRecurringModel>,
additional_data: Option<AdditionalData>,
shopper_reference: Option<String>,
store_payment_method: Option<bool>,
shopper_name: Option<ShopperName>,
#[serde(rename = "shopperIP")]
shopper_ip: Option<Secret<String, common_utils::pii::IpAddress>>,
shopper_locale: Option<String>,
shopper_email: Option<Email>,
shopper_statement: Option<String>,
social_security_number: Option<Secret<String>>,
telephone_number: Option<Secret<String>>,
billing_address: Option<Address>,
delivery_address: Option<Address>,
country_code: Option<enums::CountryAlpha2>,
line_items: Option<Vec<LineItem>>,
channel: Option<Channel>,
merchant_order_reference: Option<String>,
splits: Option<Vec<AdyenSplitData>>,
store: Option<String>,
device_fingerprint: Option<Secret<String>>,
#[serde(with = "common_utils::custom_serde::iso8601::option")]
session_validity: Option<PrimitiveDateTime>,
metadata: Option<serde_json::Value>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
struct AdyenSplitData {
amount: Option<Amount>,
#[serde(rename = "type")]
split_type: common_enums::AdyenSplitType,
account: Option<String>,
reference: String,
description: Option<String>,
}
#[serde_with::skip_serializing_none]
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
struct AdyenMpiData {
directory_response: String,
authentication_response: String,
cavv: Option<Secret<String>>,
token_authentication_verification_value: Option<Secret<String>>,
eci: Option<String>,
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
struct AdyenBrowserInfo {
user_agent: String,
accept_header: String,
language: String,
color_depth: u8,
screen_height: u32,
screen_width: u32,
time_zone_offset: i32,
java_enabled: bool,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum AdyenStatus {
AuthenticationFinished,
AuthenticationNotRequired,
Authorised,
Cancelled,
ChallengeShopper,
Error,
Pending,
Received,
RedirectShopper,
Refused,
PresentToShopper,
#[cfg(feature = "payouts")]
#[serde(rename = "[payout-confirm-received]")]
PayoutConfirmReceived,
#[cfg(feature = "payouts")]
#[serde(rename = "[payout-decline-received]")]
PayoutDeclineReceived,
#[cfg(feature = "payouts")]
#[serde(rename = "[payout-submit-received]")]
PayoutSubmitReceived,
}
#[derive(Debug, Clone, Serialize)]
pub enum Channel {
Web,
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct AdyenBalanceRequest<'a> {
pub payment_method: AdyenPaymentMethod<'a>,
pub merchant_account: Secret<String>,
}
#[derive(Debug, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct AdyenBalanceResponse {
pub psp_reference: String,
pub balance: Amount,
}
/// This implementation will be used only in Authorize, Automatic capture flow.
/// It is also being used in Psync flow, However Psync will be called only after create payment call that too in redirect flow.
fn get_adyen_payment_status(
is_manual_capture: bool,
adyen_status: AdyenStatus,
pmt: Option<common_enums::PaymentMethodType>,
) -> storage_enums::AttemptStatus {
match adyen_status {
AdyenStatus::AuthenticationFinished => {
storage_enums::AttemptStatus::AuthenticationSuccessful
}
AdyenStatus::AuthenticationNotRequired | AdyenStatus::Received => {
storage_enums::AttemptStatus::Pending
}
AdyenStatus::Authorised => match is_manual_capture {
true => storage_enums::AttemptStatus::Authorized,
// In case of Automatic capture Authorized is the final status of the payment
false => storage_enums::AttemptStatus::Charged,
},
AdyenStatus::Cancelled => storage_enums::AttemptStatus::Voided,
AdyenStatus::ChallengeShopper
| AdyenStatus::RedirectShopper
| AdyenStatus::PresentToShopper => storage_enums::AttemptStatus::AuthenticationPending,
AdyenStatus::Error | AdyenStatus::Refused => storage_enums::AttemptStatus::Failure,
AdyenStatus::Pending => match pmt {
Some(common_enums::PaymentMethodType::Pix) => {
storage_enums::AttemptStatus::AuthenticationPending
}
_ => storage_enums::AttemptStatus::Pending,
},
#[cfg(feature = "payouts")]
AdyenStatus::PayoutConfirmReceived => storage_enums::AttemptStatus::Started,
#[cfg(feature = "payouts")]
AdyenStatus::PayoutSubmitReceived => storage_enums::AttemptStatus::Pending,
#[cfg(feature = "payouts")]
AdyenStatus::PayoutDeclineReceived => storage_enums::AttemptStatus::Voided,
}
}
impl ForeignTryFrom<(bool, AdyenWebhookStatus)> for storage_enums::AttemptStatus {
type Error = error_stack::Report<errors::ConnectorError>;
fn foreign_try_from(
(is_manual_capture, adyen_webhook_status): (bool, AdyenWebhookStatus),
) -> Result<Self, Self::Error> {
match adyen_webhook_status {
AdyenWebhookStatus::Authorised | AdyenWebhookStatus::AdjustedAuthorization => {
match is_manual_capture {
true => Ok(Self::Authorized),
// In case of Automatic capture Authorized is the final status of the payment
false => Ok(Self::Charged),
}
}
AdyenWebhookStatus::AuthorisationFailed
| AdyenWebhookStatus::AdjustAuthorizationFailed => Ok(Self::Failure),
AdyenWebhookStatus::Cancelled => Ok(Self::Voided),
AdyenWebhookStatus::CancelFailed => Ok(Self::VoidFailed),
AdyenWebhookStatus::Captured => Ok(Self::Charged),
AdyenWebhookStatus::CaptureFailed => Ok(Self::CaptureFailed),
AdyenWebhookStatus::Expired => Ok(Self::Expired),
//If Unexpected Event is received, need to understand how it reached this point
//Webhooks with Payment Events only should try to conume this resource object.
AdyenWebhookStatus::UnexpectedEvent | AdyenWebhookStatus::Reversed => {
Err(report!(errors::ConnectorError::WebhookBodyDecodingFailed))
}
}
}
}
#[derive(Debug, Serialize, Deserialize, Eq, PartialEq)]
pub struct AdyenRedirectRequest {
pub details: AdyenRedirectRequestTypes,
}
#[derive(Debug, Clone, Serialize, serde::Deserialize, Eq, PartialEq)]
#[serde(untagged)]
pub enum AdyenRedirectRequestTypes {
AdyenRedirection(AdyenRedirection),
AdyenThreeDS(AdyenThreeDS),
AdyenRefusal(AdyenRefusal),
}
#[derive(Debug, Clone, Serialize, serde::Deserialize, Eq, PartialEq)]
#[serde(rename_all = "camelCase")]
pub struct AdyenRefusal {
pub payload: String,
#[serde(rename = "type")]
pub type_of_redirection_result: Option<String>,
pub result_code: Option<String>,
}
#[derive(Debug, Clone, Serialize, serde::Deserialize, Eq, PartialEq)]
#[serde(rename_all = "camelCase")]
pub struct AdyenRedirection {
pub redirect_result: String,
#[serde(rename = "type")]
pub type_of_redirection_result: Option<String>,
pub result_code: Option<String>,
}
#[derive(Debug, Clone, Serialize, serde::Deserialize, Eq, PartialEq)]
#[serde(rename_all = "camelCase")]
pub struct AdyenThreeDS {
#[serde(rename = "threeDSResult")]
pub three_ds_result: String,
#[serde(rename = "type")]
pub type_of_redirection_result: Option<String>,
pub result_code: Option<String>,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(untagged)]
pub enum AdyenPaymentResponse {
Response(Box<AdyenResponse>),
PresentToShopper(Box<PresentToShopperResponse>),
QrCodeResponse(Box<QrCodeResponseResponse>),
RedirectionResponse(Box<RedirectionResponse>),
RedirectionErrorResponse(Box<RedirectionErrorResponse>),
WebhookResponse(Box<AdyenWebhookResponse>),
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct AdyenResponse {
psp_reference: String,
result_code: AdyenStatus,
amount: Option<Amount>,
merchant_reference: String,
refusal_reason: Option<String>,
refusal_reason_code: Option<String>,
additional_data: Option<AdditionalData>,
splits: Option<Vec<AdyenSplitData>>,
store: Option<String>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum AdyenWebhookStatus {
Authorised,
AuthorisationFailed,
Cancelled,
CancelFailed,
Captured,
CaptureFailed,
Reversed,
UnexpectedEvent,
Expired,
AdjustedAuthorization,
AdjustAuthorizationFailed,
}
//Creating custom struct which can be consumed in Psync Handler triggered from Webhooks
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct AdyenWebhookResponse {
transaction_id: String,
payment_reference: Option<String>,
status: AdyenWebhookStatus,
amount: Option<Amount>,
merchant_reference_id: String,
refusal_reason: Option<String>,
refusal_reason_code: Option<String>,
event_code: WebhookEventCode,
// Raw acquirer refusal code
refusal_code_raw: Option<String>,
// Raw acquirer refusal reason
refusal_reason_raw: Option<String>,
recurring_detail_reference: Option<Secret<String>>,
recurring_shopper_reference: Option<String>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct RedirectionErrorResponse {
result_code: AdyenStatus,
refusal_reason: Option<String>,
psp_reference: Option<String>,
merchant_reference: Option<String>,
additional_data: Option<AdditionalData>,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct RedirectionResponse {
result_code: AdyenStatus,
action: AdyenRedirectAction,
amount: Option<Amount>,
refusal_reason: Option<String>,
refusal_reason_code: Option<String>,
psp_reference: Option<String>,
merchant_reference: Option<String>,
store: Option<String>,
splits: Option<Vec<AdyenSplitData>>,
additional_data: Option<AdditionalData>,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct PresentToShopperResponse {
psp_reference: Option<String>,
result_code: AdyenStatus,
action: AdyenPtsAction,
amount: Option<Amount>,
refusal_reason: Option<String>,
refusal_reason_code: Option<String>,
merchant_reference: Option<String>,
store: Option<String>,
splits: Option<Vec<AdyenSplitData>>,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct QrCodeResponseResponse {
result_code: AdyenStatus,
action: AdyenQrCodeAction,
amount: Option<Amount>,
refusal_reason: Option<String>,
refusal_reason_code: Option<String>,
additional_data: Option<QrCodeAdditionalData>,
psp_reference: Option<String>,
merchant_reference: Option<String>,
store: Option<String>,
splits: Option<Vec<AdyenSplitData>>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct AdyenQrCodeAction {
payment_method_type: PaymentType,
#[serde(rename = "type")]
type_of_response: ActionType,
#[serde(rename = "url")]
qr_code_url: Option<Url>,
qr_code_data: String,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct QrCodeAdditionalData {
#[serde(rename = "pix.expirationDate")]
#[serde(default, with = "common_utils::custom_serde::iso8601::option")]
pix_expiration_date: Option<PrimitiveDateTime>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct AdyenPtsAction {
reference: String,
download_url: Option<Url>,
payment_method_type: PaymentType,
#[serde(rename = "expiresAt")]
#[serde(
default,
with = "common_utils::custom_serde::iso8601::option_without_timezone"
)]
expires_at: Option<PrimitiveDateTime>,
initial_amount: Option<Amount>,
pass_creation_token: Option<String>,
total_amount: Option<Amount>,
#[serde(rename = "type")]
type_of_response: ActionType,
instructions_url: Option<Url>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct AdyenRedirectAction {
payment_method_type: PaymentType,
url: Option<Url>,
method: Option<Method>,
#[serde(rename = "type")]
type_of_response: ActionType,
data: Option<std::collections::HashMap<String, String>>,
payment_data: Option<String>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "lowercase")]
pub enum ActionType {
Redirect,
Await,
#[serde(rename = "qrCode")]
QrCode,
Voucher,
}
#[derive(Default, Debug, Clone, Serialize, Deserialize)]
pub struct Amount {
pub currency: storage_enums::Currency,
pub value: MinorUnit,
}
#[derive(Debug, Clone, Serialize)]
#[serde(untagged)]
pub enum PaymentMethod<'a> {
AdyenPaymentMethod(Box<AdyenPaymentMethod<'a>>),
AdyenMandatePaymentMethod(Box<AdyenMandate>),
}
#[derive(Debug, Clone, Serialize)]
#[serde(tag = "type")]
#[serde(rename_all = "lowercase")]
pub enum AdyenPaymentMethod<'a> {
#[serde(rename = "affirm")]
AdyenAffirm,
#[serde(rename = "scheme")]
AdyenCard(Box<AdyenCard>),
#[serde(rename = "klarna")]
AdyenKlarna,
#[serde(rename = "paypal")]
AdyenPaypal,
#[serde(rename = "networkToken")]
AdyenPaze(Box<AdyenPazeData>),
#[serde(rename = "afterpaytouch")]
AfterPay,
#[serde(rename = "alma")]
AlmaPayLater,
AliPay,
#[serde(rename = "alipay_hk")]
AliPayHk,
ApplePay(Box<AdyenApplePay>),
ApplePayDecrypt(Box<AdyenApplePayDecryptData>),
Atome,
#[serde(rename = "scheme")]
BancontactCard(Box<AdyenCard>),
Bizum,
Blik(Box<BlikRedirectionData>),
#[serde(rename = "boletobancario")]
BoletoBancario,
#[serde(rename = "clearpay")]
ClearPay,
#[serde(rename = "dana")]
Dana,
Eps(Box<BankRedirectionWithIssuer<'a>>),
#[serde(rename = "gcash")]
Gcash(Box<GcashData>),
#[serde(rename = "googlepay")]
Gpay(Box<AdyenGPay>),
#[serde(rename = "gopay_wallet")]
GoPay(Box<GoPayData>),
Ideal,
#[serde(rename = "kakaopay")]
Kakaopay(Box<KakaoPayData>),
Mbway(Box<MbwayData>),
MobilePay,
#[serde(rename = "momo_wallet")]
Momo(Box<MomoData>),
#[serde(rename = "momo_atm")]
MomoAtm,
#[serde(rename = "touchngo")]
TouchNGo(Box<TouchNGoData>),
#[serde(rename = "onlineBanking_CZ")]
OnlineBankingCzechRepublic(Box<OnlineBankingCzechRepublicData>),
#[serde(rename = "ebanking_FI")]
OnlineBankingFinland,
#[serde(rename = "onlineBanking_PL")]
OnlineBankingPoland(Box<OnlineBankingPolandData>),
#[serde(rename = "onlineBanking_SK")]
OnlineBankingSlovakia(Box<OnlineBankingSlovakiaData>),
#[serde(rename = "molpay_ebanking_fpx_MY")]
OnlineBankingFpx(Box<OnlineBankingFpxData>),
#[serde(rename = "molpay_ebanking_TH")]
OnlineBankingThailand(Box<OnlineBankingThailandData>),
#[serde(rename = "paybybank")]
OpenBankingUK(Box<OpenBankingUKData>),
#[serde(rename = "oxxo")]
Oxxo,
#[serde(rename = "paysafecard")]
PaySafeCard,
#[serde(rename = "paybright")]
PayBright,
#[serde(rename = "doku_permata_lite_atm")]
PermataBankTransfer(Box<DokuBankData>),
#[serde(rename = "trustly")]
Trustly,
#[serde(rename = "walley")]
Walley,
#[serde(rename = "wechatpayWeb")]
WeChatPayWeb,
#[serde(rename = "ach")]
AchDirectDebit(Box<AchDirectDebitData>),
#[serde(rename = "sepadirectdebit")]
SepaDirectDebit(Box<SepaDirectDebitData>),
#[serde(rename = "directdebit_GB")]
BacsDirectDebit(Box<BacsDirectDebitData>),
SamsungPay(Box<SamsungPayPmData>),
#[serde(rename = "doku_bca_va")]
BcaBankTransfer(Box<DokuBankData>),
#[serde(rename = "doku_bni_va")]
BniVa(Box<DokuBankData>),
#[serde(rename = "doku_bri_va")]
BriVa(Box<DokuBankData>),
#[serde(rename = "doku_cimb_va")]
CimbVa(Box<DokuBankData>),
#[serde(rename = "doku_danamon_va")]
DanamonVa(Box<DokuBankData>),
#[serde(rename = "doku_mandiri_va")]
MandiriVa(Box<DokuBankData>),
#[serde(rename = "twint")]
Twint,
#[serde(rename = "vipps")]
Vipps,
#[serde(rename = "doku_indomaret")]
Indomaret(Box<DokuBankData>),
#[serde(rename = "doku_alfamart")]
Alfamart(Box<DokuBankData>),
#[serde(rename = "givex")]
PaymentMethodBalance(Box<BalancePmData>),
#[serde(rename = "giftcard")]
AdyenGiftCard(Box<AdyenGiftCardData>),
#[serde(rename = "swish")]
Swish,
#[serde(rename = "benefit")]
Benefit,
#[serde(rename = "knet")]
Knet,
#[serde(rename = "econtext_seven_eleven")]
SevenEleven(Box<JCSVoucherData>),
#[serde(rename = "econtext_stores")]
JapaneseConvenienceStores(Box<JCSVoucherData>),
Pix,
#[serde(rename = "networkToken")]
NetworkToken(Box<AdyenNetworkTokenData>),
}
#[derive(Debug, Clone, Eq, PartialEq, serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct JCSVoucherData {
first_name: Secret<String>,
last_name: Option<Secret<String>>,
shopper_email: Email,
telephone_number: Secret<String>,
}
#[derive(Debug, Clone, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct BalancePmData {
number: Secret<String>,
cvc: Secret<String>,
}
#[derive(Debug, Clone, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct AdyenGiftCardData {
brand: GiftCardBrand,
number: Secret<String>,
cvc: Secret<String>,
}
#[derive(Debug, Clone, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct AchDirectDebitData {
bank_account_number: Secret<String>,
bank_location_id: Secret<String>,
owner_name: Secret<String>,
}
#[derive(Debug, Clone, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct SepaDirectDebitData {
#[serde(rename = "sepa.ownerName")]
owner_name: Secret<String>,
#[serde(rename = "sepa.ibanNumber")]
iban_number: Secret<String>,
}
#[derive(Debug, Clone, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct BacsDirectDebitData {
bank_account_number: Secret<String>,
bank_location_id: Secret<String>,
holder_name: Secret<String>,
}
#[derive(Debug, Clone, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct MbwayData {
telephone_number: Secret<String>,
}
#[derive(Debug, Clone, Serialize)]
pub struct SamsungPayPmData {
#[serde(rename = "samsungPayToken")]
samsung_pay_token: Secret<String>,
}
#[derive(Debug, Clone, Serialize)]
pub struct OnlineBankingCzechRepublicData {
issuer: OnlineBankingCzechRepublicBanks,
}
#[derive(Debug, Clone, Serialize)]
#[serde(rename_all = "lowercase")]
pub enum OnlineBankingCzechRepublicBanks {
KB,
CS,
}
impl TryFrom<&PaymentsAuthorizeRouterData> for JCSVoucherData {
type Error = Error;
fn try_from(item: &PaymentsAuthorizeRouterData) -> Result<Self, Self::Error> {
Ok(Self {
first_name: item.get_billing_first_name()?,
last_name: item.get_optional_billing_last_name(),
shopper_email: item.get_billing_email()?,
telephone_number: item.get_billing_phone_number()?,
})
}
}
impl TryFrom<&common_enums::BankNames> for OnlineBankingCzechRepublicBanks {
type Error = Error;
fn try_from(bank_name: &common_enums::BankNames) -> Result<Self, Self::Error> {
match bank_name {
common_enums::BankNames::KomercniBanka => Ok(Self::KB),
common_enums::BankNames::CeskaSporitelna => Ok(Self::CS),
_ => Err(errors::ConnectorError::NotImplemented(
utils::get_unimplemented_payment_method_error_message("Adyen"),
))?,
}
}
}
#[derive(Debug, Clone, Serialize)]
pub struct OnlineBankingPolandData {
issuer: OnlineBankingPolandBanks,
}
#[derive(Debug, Clone, Serialize)]
pub enum OnlineBankingPolandBanks {
#[serde(rename = "154")]
BlikPSP,
#[serde(rename = "31")]
PlaceZIPKO,
#[serde(rename = "243")]
MBank,
#[serde(rename = "112")]
PayWithING,
#[serde(rename = "20")]
SantanderPrzelew24,
#[serde(rename = "65")]
BankPEKAOSA,
#[serde(rename = "85")]
BankMillennium,
#[serde(rename = "88")]
PayWithAliorBank,
#[serde(rename = "143")]
BankiSpoldzielcze,
#[serde(rename = "26")]
PayWithInteligo,
#[serde(rename = "33")]
BNPParibasPoland,
#[serde(rename = "144")]
BankNowySA,
#[serde(rename = "45")]
CreditAgricole,
#[serde(rename = "99")]
PayWithBOS,
#[serde(rename = "119")]
PayWithCitiHandlowy,
#[serde(rename = "131")]
PayWithPlusBank,
#[serde(rename = "64")]
ToyotaBank,
#[serde(rename = "153")]
VeloBank,
#[serde(rename = "141")]
ETransferPocztowy24,
}
impl TryFrom<&common_enums::BankNames> for OnlineBankingPolandBanks {
type Error = Error;
fn try_from(bank_name: &common_enums::BankNames) -> Result<Self, Self::Error> {
match bank_name {
common_enums::BankNames::BlikPSP => Ok(Self::BlikPSP),
common_enums::BankNames::PlaceZIPKO => Ok(Self::PlaceZIPKO),
common_enums::BankNames::MBank => Ok(Self::MBank),
common_enums::BankNames::PayWithING => Ok(Self::PayWithING),
common_enums::BankNames::SantanderPrzelew24 => Ok(Self::SantanderPrzelew24),
common_enums::BankNames::BankPEKAOSA => Ok(Self::BankPEKAOSA),
common_enums::BankNames::BankMillennium => Ok(Self::BankMillennium),
common_enums::BankNames::PayWithAliorBank => Ok(Self::PayWithAliorBank),
common_enums::BankNames::BankiSpoldzielcze => Ok(Self::BankiSpoldzielcze),
common_enums::BankNames::PayWithInteligo => Ok(Self::PayWithInteligo),
common_enums::BankNames::BNPParibasPoland => Ok(Self::BNPParibasPoland),
common_enums::BankNames::BankNowySA => Ok(Self::BankNowySA),
common_enums::BankNames::CreditAgricole => Ok(Self::CreditAgricole),
common_enums::BankNames::PayWithBOS => Ok(Self::PayWithBOS),
common_enums::BankNames::PayWithCitiHandlowy => Ok(Self::PayWithCitiHandlowy),
common_enums::BankNames::PayWithPlusBank => Ok(Self::PayWithPlusBank),
common_enums::BankNames::ToyotaBank => Ok(Self::ToyotaBank),
common_enums::BankNames::VeloBank => Ok(Self::VeloBank),
common_enums::BankNames::ETransferPocztowy24 => Ok(Self::ETransferPocztowy24),
_ => Err(errors::ConnectorError::NotImplemented(
utils::get_unimplemented_payment_method_error_message("Adyen"),
))?,
}
}
}
#[derive(Debug, Clone, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct OnlineBankingSlovakiaData {
issuer: OnlineBankingSlovakiaBanks,
}
#[derive(Debug, Clone, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct OnlineBankingFpxData {
issuer: OnlineBankingFpxIssuer,
}
#[derive(Debug, Clone, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct OnlineBankingThailandData {
issuer: OnlineBankingThailandIssuer,
}
#[derive(Debug, Clone, Serialize)]
pub struct OpenBankingUKData {
issuer: Option<OpenBankingUKIssuer>,
}
#[derive(Debug, Clone, Serialize)]
#[serde(rename_all = "lowercase")]
pub enum OnlineBankingSlovakiaBanks {
Vub,
Posto,
Sporo,
Tatra,
Viamo,
}
impl TryFrom<&common_enums::BankNames> for OnlineBankingSlovakiaBanks {
type Error = Error;
fn try_from(bank_name: &common_enums::BankNames) -> Result<Self, Self::Error> {
match bank_name {
common_enums::BankNames::EPlatbyVUB => Ok(Self::Vub),
common_enums::BankNames::PostovaBanka => Ok(Self::Posto),
common_enums::BankNames::SporoPay => Ok(Self::Sporo),
common_enums::BankNames::TatraPay => Ok(Self::Tatra),
common_enums::BankNames::Viamo => Ok(Self::Viamo),
_ => Err(errors::ConnectorError::NotImplemented(
utils::get_unimplemented_payment_method_error_message("Adyen"),
))?,
}
}
}
impl TryFrom<&common_enums::BankNames> for OnlineBankingFpxIssuer {
type Error = Error;
fn try_from(bank_name: &common_enums::BankNames) -> Result<Self, Self::Error> {
match bank_name {
common_enums::BankNames::AffinBank => Ok(Self::FpxAbb),
common_enums::BankNames::AgroBank => Ok(Self::FpxAgrobank),
common_enums::BankNames::AllianceBank => Ok(Self::FpxAbmb),
common_enums::BankNames::AmBank => Ok(Self::FpxAmb),
common_enums::BankNames::BankIslam => Ok(Self::FpxBimb),
common_enums::BankNames::BankMuamalat => Ok(Self::FpxBmmb),
common_enums::BankNames::BankRakyat => Ok(Self::FpxBkrm),
common_enums::BankNames::BankSimpananNasional => Ok(Self::FpxBsn),
common_enums::BankNames::CimbBank => Ok(Self::FpxCimbclicks),
common_enums::BankNames::HongLeongBank => Ok(Self::FpxHlb),
common_enums::BankNames::HsbcBank => Ok(Self::FpxHsbc),
common_enums::BankNames::KuwaitFinanceHouse => Ok(Self::FpxKfh),
common_enums::BankNames::Maybank => Ok(Self::FpxMb2u),
common_enums::BankNames::OcbcBank => Ok(Self::FpxOcbc),
common_enums::BankNames::PublicBank => Ok(Self::FpxPbb),
common_enums::BankNames::RhbBank => Ok(Self::FpxRhb),
common_enums::BankNames::StandardCharteredBank => Ok(Self::FpxScb),
common_enums::BankNames::UobBank => Ok(Self::FpxUob),
_ => Err(errors::ConnectorError::NotImplemented(
utils::get_unimplemented_payment_method_error_message("Adyen"),
))?,
}
}
}
impl TryFrom<&common_enums::BankNames> for OnlineBankingThailandIssuer {
type Error = Error;
fn try_from(bank_name: &common_enums::BankNames) -> Result<Self, Self::Error> {
match bank_name {
common_enums::BankNames::BangkokBank => Ok(Self::Bangkokbank),
common_enums::BankNames::KrungsriBank => Ok(Self::Krungsribank),
common_enums::BankNames::KrungThaiBank => Ok(Self::Krungthaibank),
common_enums::BankNames::TheSiamCommercialBank => Ok(Self::Siamcommercialbank),
common_enums::BankNames::KasikornBank => Ok(Self::Kbank),
_ => Err(errors::ConnectorError::NotImplemented(
utils::get_unimplemented_payment_method_error_message("Adyen"),
))?,
}
}
}
impl TryFrom<&common_enums::BankNames> for OpenBankingUKIssuer {
type Error = Error;
fn try_from(bank_name: &common_enums::BankNames) -> Result<Self, Self::Error> {
match bank_name {
common_enums::BankNames::OpenBankSuccess => Ok(Self::RedirectSuccess),
common_enums::BankNames::OpenBankFailure => Ok(Self::RedirectFailure),
common_enums::BankNames::OpenBankCancelled => Ok(Self::RedirectCancelled),
common_enums::BankNames::Aib => Ok(Self::Aib),
common_enums::BankNames::BankOfScotland => Ok(Self::BankOfScotland),
common_enums::BankNames::Barclays => Ok(Self::Barclays),
common_enums::BankNames::DanskeBank => Ok(Self::DanskeBank),
common_enums::BankNames::FirstDirect => Ok(Self::FirstDirect),
common_enums::BankNames::FirstTrust => Ok(Self::FirstTrust),
common_enums::BankNames::HsbcBank => Ok(Self::HsbcBank),
common_enums::BankNames::Halifax => Ok(Self::Halifax),
common_enums::BankNames::Lloyds => Ok(Self::Lloyds),
common_enums::BankNames::Monzo => Ok(Self::Monzo),
common_enums::BankNames::NatWest => Ok(Self::NatWest),
common_enums::BankNames::NationwideBank => Ok(Self::NationwideBank),
common_enums::BankNames::Revolut => Ok(Self::Revolut),
common_enums::BankNames::RoyalBankOfScotland => Ok(Self::RoyalBankOfScotland),
common_enums::BankNames::SantanderPrzelew24 => Ok(Self::SantanderPrzelew24),
common_enums::BankNames::Starling => Ok(Self::Starling),
common_enums::BankNames::TsbBank => Ok(Self::TsbBank),
common_enums::BankNames::TescoBank => Ok(Self::TescoBank),
common_enums::BankNames::UlsterBank => Ok(Self::UlsterBank),
common_enums::BankNames::AmericanExpress
| common_enums::BankNames::AffinBank
| common_enums::BankNames::AgroBank
| common_enums::BankNames::AllianceBank
| common_enums::BankNames::AmBank
| common_enums::BankNames::BankOfAmerica
| common_enums::BankNames::BankOfChina
| common_enums::BankNames::BankIslam
| common_enums::BankNames::BankMuamalat
| common_enums::BankNames::BankRakyat
| common_enums::BankNames::BankSimpananNasional
| common_enums::BankNames::BlikPSP
| common_enums::BankNames::CapitalOne
| common_enums::BankNames::Chase
| common_enums::BankNames::Citi
| common_enums::BankNames::CimbBank
| common_enums::BankNames::Discover
| common_enums::BankNames::NavyFederalCreditUnion
| common_enums::BankNames::PentagonFederalCreditUnion
| common_enums::BankNames::SynchronyBank
| common_enums::BankNames::WellsFargo
| common_enums::BankNames::AbnAmro
| common_enums::BankNames::AsnBank
| common_enums::BankNames::Bunq
| common_enums::BankNames::Handelsbanken
| common_enums::BankNames::HongLeongBank
| common_enums::BankNames::Ing
| common_enums::BankNames::Knab
| common_enums::BankNames::KuwaitFinanceHouse
| common_enums::BankNames::Moneyou
| common_enums::BankNames::Rabobank
| common_enums::BankNames::Regiobank
| common_enums::BankNames::SnsBank
| common_enums::BankNames::TriodosBank
| common_enums::BankNames::VanLanschot
| common_enums::BankNames::ArzteUndApothekerBank
| common_enums::BankNames::AustrianAnadiBankAg
| common_enums::BankNames::BankAustria
| common_enums::BankNames::Bank99Ag
| common_enums::BankNames::BankhausCarlSpangler
| common_enums::BankNames::BankhausSchelhammerUndSchatteraAg
| common_enums::BankNames::BankMillennium
| common_enums::BankNames::BankPEKAOSA
| common_enums::BankNames::BawagPskAg
| common_enums::BankNames::BksBankAg
| common_enums::BankNames::BrullKallmusBankAg
| common_enums::BankNames::BtvVierLanderBank
| common_enums::BankNames::CapitalBankGraweGruppeAg
| common_enums::BankNames::CeskaSporitelna
| common_enums::BankNames::Dolomitenbank
| common_enums::BankNames::EasybankAg
| common_enums::BankNames::EPlatbyVUB
| common_enums::BankNames::ErsteBankUndSparkassen
| common_enums::BankNames::FrieslandBank
| common_enums::BankNames::HypoAlpeadriabankInternationalAg
| common_enums::BankNames::HypoNoeLbFurNiederosterreichUWien
| common_enums::BankNames::HypoOberosterreichSalzburgSteiermark
| common_enums::BankNames::HypoTirolBankAg
| common_enums::BankNames::HypoVorarlbergBankAg
| common_enums::BankNames::HypoBankBurgenlandAktiengesellschaft
| common_enums::BankNames::KomercniBanka
| common_enums::BankNames::MBank
| common_enums::BankNames::MarchfelderBank
| common_enums::BankNames::Maybank
| common_enums::BankNames::OberbankAg
| common_enums::BankNames::OsterreichischeArzteUndApothekerbank
| common_enums::BankNames::OcbcBank
| common_enums::BankNames::PayWithING
| common_enums::BankNames::PlaceZIPKO
| common_enums::BankNames::PlatnoscOnlineKartaPlatnicza
| common_enums::BankNames::PosojilnicaBankEGen
| common_enums::BankNames::PostovaBanka
| common_enums::BankNames::PublicBank
| common_enums::BankNames::RaiffeisenBankengruppeOsterreich
| common_enums::BankNames::RhbBank
| common_enums::BankNames::SchelhammerCapitalBankAg
| common_enums::BankNames::StandardCharteredBank
| common_enums::BankNames::SchoellerbankAg
| common_enums::BankNames::SpardaBankWien
| common_enums::BankNames::SporoPay
| common_enums::BankNames::TatraPay
| common_enums::BankNames::Viamo
| common_enums::BankNames::VolksbankGruppe
| common_enums::BankNames::VolkskreditbankAg
| common_enums::BankNames::VrBankBraunau
| common_enums::BankNames::UobBank
| common_enums::BankNames::PayWithAliorBank
| common_enums::BankNames::BankiSpoldzielcze
| common_enums::BankNames::PayWithInteligo
| common_enums::BankNames::BNPParibasPoland
| common_enums::BankNames::BankNowySA
| common_enums::BankNames::CreditAgricole
| common_enums::BankNames::PayWithBOS
| common_enums::BankNames::PayWithCitiHandlowy
| common_enums::BankNames::PayWithPlusBank
| common_enums::BankNames::ToyotaBank
| common_enums::BankNames::VeloBank
| common_enums::BankNames::ETransferPocztowy24
| common_enums::BankNames::PlusBank
| common_enums::BankNames::EtransferPocztowy24
| common_enums::BankNames::BankiSpbdzielcze
| common_enums::BankNames::BankNowyBfgSa
| common_enums::BankNames::GetinBank
| common_enums::BankNames::Blik
| common_enums::BankNames::NoblePay
| common_enums::BankNames::IdeaBank
| common_enums::BankNames::EnveloBank
| common_enums::BankNames::NestPrzelew
| common_enums::BankNames::MbankMtransfer
| common_enums::BankNames::Inteligo
| common_enums::BankNames::PbacZIpko
| common_enums::BankNames::BnpParibas
| common_enums::BankNames::BankPekaoSa
| common_enums::BankNames::VolkswagenBank
| common_enums::BankNames::AliorBank
| common_enums::BankNames::Boz
| common_enums::BankNames::BangkokBank
| common_enums::BankNames::KrungsriBank
| common_enums::BankNames::KrungThaiBank
| common_enums::BankNames::TheSiamCommercialBank
| common_enums::BankNames::Yoursafe
| common_enums::BankNames::N26
| common_enums::BankNames::NationaleNederlanden
| common_enums::BankNames::KasikornBank => {
Err(errors::ConnectorError::NotImplemented(
utils::get_unimplemented_payment_method_error_message("Adyen"),
))?
}
}
}
}
#[derive(Debug, Clone, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct BlikRedirectionData {
blik_code: Secret<String>,
}
#[serde_with::skip_serializing_none]
#[derive(Debug, Clone, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct BankRedirectionWithIssuer<'a> {
issuer: Option<&'a str>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct AdyenMandate {
#[serde(rename = "type")]
payment_type: PaymentType,
stored_payment_method_id: Secret<String>,
holder_name: Option<Secret<String>>,
}
#[serde_with::skip_serializing_none]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct AdyenCard {
number: CardNumber,
expiry_month: Secret<String>,
expiry_year: Secret<String>,
cvc: Option<Secret<String>>,
holder_name: Option<Secret<String>>,
brand: Option<CardBrand>, //Mandatory for mandate using network_txns_id
network_payment_reference: Option<Secret<String>>,
}
#[serde_with::skip_serializing_none]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct AdyenPazeData {
number: NetworkTokenNumber,
expiry_month: Secret<String>,
expiry_year: Secret<String>,
cvc: Option<Secret<String>>,
holder_name: Option<Secret<String>>,
brand: Option<CardBrand>, //Mandatory for mandate using network_txns_id
network_payment_reference: Option<Secret<String>>,
}
#[serde_with::skip_serializing_none]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct AdyenApplePayDecryptData {
number: CardNumber,
expiry_month: Secret<String>,
expiry_year: Secret<String>,
brand: String,
#[serde(rename = "type")]
payment_type: PaymentType,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "lowercase")]
pub enum CardBrand {
Visa,
MC,
Amex,
Accel,
Argencard,
Bcmc,
Bijcard,
Cabal,
Cartebancaire,
Codensa,
Cup,
Dankort,
Diners,
Discover,
Electron,
Elo,
Forbrugsforeningen,
Hiper,
Hipercard,
Jcb,
Karenmillen,
Laser,
Maestro,
Maestrouk,
Mcalphabankbonus,
Mir,
Naranja,
Oasis,
Pulse,
Rupay,
Shopping,
Star,
Solo,
Troy,
Uatp,
Visaalphabankbonus,
Visadankort,
Nyce,
Warehouse,
}
#[derive(Default, Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct AdyenCancelRequest {
merchant_account: Secret<String>,
reference: String,
}
#[derive(Default, Debug, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct AdyenCancelResponse {
payment_psp_reference: String,
status: CancelStatus,
reference: String,
}
#[derive(Default, Debug, Deserialize, Serialize)]
#[serde(rename_all = "lowercase")]
pub enum CancelStatus {
Received,
#[default]
Processing,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct GoPayData {}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct KakaoPayData {}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct GcashData {}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct MomoData {}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct TouchNGoData {}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct AdyenGPay {
#[serde(rename = "googlePayToken")]
google_pay_token: Secret<String>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct AdyenApplePay {
#[serde(rename = "applePayToken")]
apple_pay_token: Secret<String>,
}
#[serde_with::skip_serializing_none]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct AdyenNetworkTokenData {
number: NetworkTokenNumber,
expiry_month: Secret<String>,
expiry_year: Secret<String>,
holder_name: Option<Secret<String>>,
brand: Option<CardBrand>, //Mandatory for mandate using network_txns_id
network_payment_reference: Option<Secret<String>>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct DokuBankData {
first_name: Secret<String>,
last_name: Option<Secret<String>>,
shopper_email: Email,
}
// Refunds Request and Response
#[serde_with::skip_serializing_none]
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct AdyenRefundRequest {
merchant_account: Secret<String>,
amount: Amount,
merchant_refund_reason: Option<AdyenRefundRequestReason>,
reference: String,
splits: Option<Vec<AdyenSplitData>>,
store: Option<String>,
}
#[derive(Debug, Serialize, Deserialize)]
pub enum AdyenRefundRequestReason {
FRAUD,
#[serde(rename = "CUSTOMER REQUEST")]
CUSTOMERREQUEST,
RETURN,
DUPLICATE,
OTHER,
}
impl FromStr for AdyenRefundRequestReason {
type Err = error_stack::Report<errors::ConnectorError>;
fn from_str(s: &str) -> Result<Self, Self::Err> {
match s.to_uppercase().as_str() {
"FRAUD" => Ok(Self::FRAUD),
"CUSTOMER REQUEST" | "CUSTOMERREQUEST" => Ok(Self::CUSTOMERREQUEST),
"RETURN" => Ok(Self::RETURN),
"DUPLICATE" => Ok(Self::DUPLICATE),
"OTHER" => Ok(Self::OTHER),
_ => Ok(Self::OTHER),
}
}
}
#[derive(Default, Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct AdyenRefundResponse {
merchant_account: Secret<String>,
psp_reference: String,
payment_psp_reference: String,
reference: String,
status: String,
}
pub struct AdyenAuthType {
pub(super) api_key: Secret<String>,
pub(super) merchant_account: Secret<String>,
#[allow(dead_code)]
pub(super) review_key: Option<Secret<String>>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "lowercase")]
pub enum PaymentType {
Affirm,
Afterpaytouch,
Alipay,
#[serde(rename = "alipay_hk")]
AlipayHk,
#[serde(rename = "doku_alfamart")]
Alfamart,
Alma,
Applepay,
Bizum,
Atome,
Blik,
#[serde(rename = "boletobancario")]
BoletoBancario,
ClearPay,
Dana,
Eps,
Gcash,
Googlepay,
#[serde(rename = "gopay_wallet")]
GoPay,
Ideal,
#[serde(rename = "doku_indomaret")]
Indomaret,
Klarna,
Kakaopay,
Mbway,
MobilePay,
#[serde(rename = "momo_wallet")]
Momo,
#[serde(rename = "momo_atm")]
MomoAtm,
#[serde(rename = "onlineBanking_CZ")]
OnlineBankingCzechRepublic,
#[serde(rename = "ebanking_FI")]
OnlineBankingFinland,
#[serde(rename = "onlineBanking_PL")]
OnlineBankingPoland,
#[serde(rename = "onlineBanking_SK")]
OnlineBankingSlovakia,
#[serde(rename = "molpay_ebanking_fpx_MY")]
OnlineBankingFpx,
#[serde(rename = "molpay_ebanking_TH")]
OnlineBankingThailand,
#[serde(rename = "paybybank")]
OpenBankingUK,
#[serde(rename = "oxxo")]
Oxxo,
#[serde(rename = "paysafecard")]
PaySafeCard,
PayBright,
Paypal,
Scheme,
#[serde(rename = "networkToken")]
NetworkToken,
#[serde(rename = "trustly")]
Trustly,
#[serde(rename = "touchngo")]
TouchNGo,
Walley,
#[serde(rename = "wechatpayWeb")]
WeChatPayWeb,
#[serde(rename = "ach")]
AchDirectDebit,
SepaDirectDebit,
#[serde(rename = "directdebit_GB")]
BacsDirectDebit,
Samsungpay,
Twint,
Vipps,
Giftcard,
Knet,
Benefit,
Swish,
#[serde(rename = "doku_permata_lite_atm")]
PermataBankTransfer,
#[serde(rename = "doku_bca_va")]
BcaBankTransfer,
#[serde(rename = "doku_bni_va")]
BniVa,
#[serde(rename = "doku_bri_va")]
BriVa,
#[serde(rename = "doku_cimb_va")]
CimbVa,
#[serde(rename = "doku_danamon_va")]
DanamonVa,
#[serde(rename = "doku_mandiri_va")]
MandiriVa,
#[serde(rename = "econtext_seven_eleven")]
SevenEleven,
#[serde(rename = "econtext_stores")]
JapaneseConvenienceStores,
Pix,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "lowercase")]
pub enum GiftCardBrand {
Givex,
Auriga,
Babygiftcard,
}
#[derive(Debug, Eq, PartialEq, Serialize, Clone)]
#[serde(rename_all = "snake_case")]
pub enum OnlineBankingFpxIssuer {
FpxAbb,
FpxAgrobank,
FpxAbmb,
FpxAmb,
FpxBimb,
FpxBmmb,
FpxBkrm,
FpxBsn,
FpxCimbclicks,
FpxHlb,
FpxHsbc,
FpxKfh,
FpxMb2u,
FpxOcbc,
FpxPbb,
FpxRhb,
FpxScb,
FpxUob,
}
#[derive(Debug, Eq, PartialEq, Serialize, Clone)]
pub enum OnlineBankingThailandIssuer {
#[serde(rename = "molpay_bangkokbank")]
Bangkokbank,
#[serde(rename = "molpay_krungsribank")]
Krungsribank,
#[serde(rename = "molpay_krungthaibank")]
Krungthaibank,
#[serde(rename = "molpay_siamcommercialbank")]
Siamcommercialbank,
#[serde(rename = "molpay_kbank")]
Kbank,
}
#[derive(Debug, Eq, PartialEq, Serialize, Clone)]
pub enum OpenBankingUKIssuer {
#[serde(rename = "uk-test-open-banking-redirect")]
RedirectSuccess,
#[serde(rename = "uk-test-open-banking-redirect-failed")]
RedirectFailure,
#[serde(rename = "uk-test-open-banking-redirect-cancelled")]
RedirectCancelled,
#[serde(rename = "uk-aib-oauth2")]
Aib,
#[serde(rename = "uk-bankofscotland-oauth2")]
BankOfScotland,
#[serde(rename = "uk-barclays-oauth2")]
Barclays,
#[serde(rename = "uk-danskebank-oauth2")]
DanskeBank,
#[serde(rename = "uk-firstdirect-oauth2")]
FirstDirect,
#[serde(rename = "uk-firsttrust-oauth2")]
FirstTrust,
#[serde(rename = "uk-hsbc-oauth2")]
HsbcBank,
#[serde(rename = "uk-halifax-oauth2")]
Halifax,
#[serde(rename = "uk-lloyds-oauth2")]
Lloyds,
#[serde(rename = "uk-monzo-oauth2")]
Monzo,
#[serde(rename = "uk-natwest-oauth2")]
NatWest,
#[serde(rename = "uk-nationwide-oauth2")]
NationwideBank,
#[serde(rename = "uk-revolut-oauth2")]
Revolut,
#[serde(rename = "uk-rbs-oauth2")]
RoyalBankOfScotland,
#[serde(rename = "uk-santander-oauth2")]
SantanderPrzelew24,
#[serde(rename = "uk-starling-oauth2")]
Starling,
#[serde(rename = "uk-tsb-oauth2")]
TsbBank,
#[serde(rename = "uk-tesco-oauth2")]
TescoBank,
#[serde(rename = "uk-ulster-oauth2")]
UlsterBank,
}
pub struct AdyenTestBankNames<'a>(&'a str);
impl TryFrom<&common_enums::BankNames> for AdyenTestBankNames<'_> {
type Error = Error;
fn try_from(bank: &common_enums::BankNames) -> Result<Self, Self::Error> {
Ok(match bank {
common_enums::BankNames::AbnAmro => Self("1121"),
common_enums::BankNames::AsnBank => Self("1151"),
common_enums::BankNames::Bunq => Self("1152"),
common_enums::BankNames::Ing => Self("1154"),
common_enums::BankNames::Knab => Self("1155"),
common_enums::BankNames::N26 => Self("1156"),
common_enums::BankNames::NationaleNederlanden => Self("1157"),
common_enums::BankNames::Rabobank => Self("1157"),
common_enums::BankNames::Regiobank => Self("1158"),
common_enums::BankNames::Revolut => Self("1159"),
common_enums::BankNames::SnsBank => Self("1159"),
common_enums::BankNames::TriodosBank => Self("1159"),
common_enums::BankNames::VanLanschot => Self("1159"),
common_enums::BankNames::Yoursafe => Self("1159"),
common_enums::BankNames::BankAustria => Self("e6819e7a-f663-414b-92ec-cf7c82d2f4e5"),
common_enums::BankNames::BawagPskAg => Self("ba7199cc-f057-42f2-9856-2378abf21638"),
common_enums::BankNames::Dolomitenbank => Self("d5d5b133-1c0d-4c08-b2be-3c9b116dc326"),
common_enums::BankNames::EasybankAg => Self("eff103e6-843d-48b7-a6e6-fbd88f511b11"),
common_enums::BankNames::ErsteBankUndSparkassen => {
Self("3fdc41fc-3d3d-4ee3-a1fe-cd79cfd58ea3")
}
common_enums::BankNames::HypoTirolBankAg => {
Self("6765e225-a0dc-4481-9666-e26303d4f221")
}
common_enums::BankNames::PosojilnicaBankEGen => {
Self("65ef4682-4944-499f-828f-5d74ad288376")
}
common_enums::BankNames::RaiffeisenBankengruppeOsterreich => {
Self("ee9fc487-ebe0-486c-8101-17dce5141a67")
}
common_enums::BankNames::SchoellerbankAg => {
Self("1190c4d1-b37a-487e-9355-e0a067f54a9f")
}
common_enums::BankNames::SpardaBankWien => Self("8b0bfeea-fbb0-4337-b3a1-0e25c0f060fc"),
common_enums::BankNames::VolksbankGruppe => {
Self("e2e97aaa-de4c-4e18-9431-d99790773433")
}
common_enums::BankNames::VolkskreditbankAg => {
Self("4a0a975b-0594-4b40-9068-39f77b3a91f9")
}
_ => Err(errors::ConnectorError::NotImplemented(
utils::get_unimplemented_payment_method_error_message("Adyen"),
))?,
})
}
}
impl TryFrom<&ConnectorAuthType> for AdyenAuthType {
type Error = Error;
fn try_from(auth_type: &ConnectorAuthType) -> Result<Self, Self::Error> {
match auth_type {
ConnectorAuthType::BodyKey { api_key, key1 } => Ok(Self {
api_key: api_key.to_owned(),
merchant_account: key1.to_owned(),
review_key: None,
}),
ConnectorAuthType::SignatureKey {
api_key,
key1,
api_secret,
} => Ok(Self {
api_key: api_key.to_owned(),
merchant_account: key1.to_owned(),
review_key: Some(api_secret.to_owned()),
}),
_ => Err(errors::ConnectorError::FailedToObtainAuthType)?,
}
}
}
impl TryFrom<&AdyenRouterData<&PaymentsAuthorizeRouterData>> for AdyenPaymentRequest<'_> {
type Error = Error;
fn try_from(item: &AdyenRouterData<&PaymentsAuthorizeRouterData>) -> Result<Self, Self::Error> {
match item
.router_data
.request
.mandate_id
.to_owned()
.and_then(|mandate_ids| mandate_ids.mandate_reference_id)
{
Some(mandate_ref) => AdyenPaymentRequest::try_from((item, mandate_ref)),
None => match item.router_data.request.payment_method_data {
PaymentMethodData::Card(ref card) => AdyenPaymentRequest::try_from((item, card)),
PaymentMethodData::Wallet(ref wallet) => {
AdyenPaymentRequest::try_from((item, wallet))
}
PaymentMethodData::PayLater(ref pay_later) => {
AdyenPaymentRequest::try_from((item, pay_later))
}
PaymentMethodData::BankRedirect(ref bank_redirect) => {
AdyenPaymentRequest::try_from((item, bank_redirect))
}
PaymentMethodData::BankDebit(ref bank_debit) => {
AdyenPaymentRequest::try_from((item, bank_debit))
}
PaymentMethodData::BankTransfer(ref bank_transfer) => {
AdyenPaymentRequest::try_from((item, bank_transfer.as_ref()))
}
PaymentMethodData::CardRedirect(ref card_redirect_data) => {
AdyenPaymentRequest::try_from((item, card_redirect_data))
}
PaymentMethodData::Voucher(ref voucher_data) => {
AdyenPaymentRequest::try_from((item, voucher_data))
}
PaymentMethodData::GiftCard(ref gift_card_data) => {
AdyenPaymentRequest::try_from((item, gift_card_data.as_ref()))
}
PaymentMethodData::NetworkToken(ref token_data) => {
AdyenPaymentRequest::try_from((item, token_data))
}
PaymentMethodData::Crypto(_)
| PaymentMethodData::MandatePayment
| PaymentMethodData::Reward
| PaymentMethodData::RealTimePayment(_)
| PaymentMethodData::MobilePayment(_)
| PaymentMethodData::Upi(_)
| PaymentMethodData::OpenBanking(_)
| PaymentMethodData::CardToken(_)
| PaymentMethodData::CardDetailsForNetworkTransactionId(_) => {
Err(errors::ConnectorError::NotImplemented(
utils::get_unimplemented_payment_method_error_message("Adyen"),
))?
}
},
}
}
}
impl TryFrom<&PaymentsPreProcessingRouterData> for AdyenBalanceRequest<'_> {
type Error = Error;
fn try_from(item: &PaymentsPreProcessingRouterData) -> Result<Self, Self::Error> {
let payment_method = match &item.request.payment_method_data {
Some(PaymentMethodData::GiftCard(gift_card_data)) => match gift_card_data.as_ref() {
GiftCardData::Givex(gift_card_data) => {
let balance_pm = BalancePmData {
number: gift_card_data.number.clone(),
cvc: gift_card_data.cvc.clone(),
};
Ok(AdyenPaymentMethod::PaymentMethodBalance(Box::new(
balance_pm,
)))
}
GiftCardData::PaySafeCard {} | GiftCardData::BhnCardNetwork(_) => {
Err(errors::ConnectorError::FlowNotSupported {
flow: "Balance".to_string(),
connector: "adyen".to_string(),
})
}
},
_ => Err(errors::ConnectorError::FlowNotSupported {
flow: "Balance".to_string(),
connector: "adyen".to_string(),
}),
}?;
let auth_type = AdyenAuthType::try_from(&item.connector_auth_type)?;
Ok(Self {
payment_method,
merchant_account: auth_type.merchant_account,
})
}
}
impl TryFrom<&PaymentsGiftCardBalanceCheckRouterData> for AdyenBalanceRequest<'_> {
type Error = Error;
fn try_from(item: &PaymentsGiftCardBalanceCheckRouterData) -> Result<Self, Self::Error> {
let payment_method = match &item.request.payment_method_data {
PaymentMethodData::GiftCard(gift_card_data) => match gift_card_data.as_ref() {
GiftCardData::Givex(gift_card_data) => {
let balance_pm = BalancePmData {
number: gift_card_data.number.clone(),
cvc: gift_card_data.cvc.clone(),
};
Ok(AdyenPaymentMethod::PaymentMethodBalance(Box::new(
balance_pm,
)))
}
GiftCardData::PaySafeCard {} | GiftCardData::BhnCardNetwork(_) => {
Err(errors::ConnectorError::FlowNotSupported {
flow: "Balance".to_string(),
connector: "adyen".to_string(),
})
}
},
_ => Err(errors::ConnectorError::FlowNotSupported {
flow: "Balance".to_string(),
connector: "adyen".to_string(),
}),
}?;
let auth_type = AdyenAuthType::try_from(&item.connector_auth_type)?;
Ok(Self {
payment_method,
merchant_account: auth_type.merchant_account,
})
}
}
impl From<&PaymentsAuthorizeRouterData> for AdyenShopperInteraction {
fn from(item: &PaymentsAuthorizeRouterData) -> Self {
match item.request.off_session {
Some(true) => Self::ContinuedAuthentication,
_ => match item.request.payment_channel {
Some(common_enums::PaymentChannel::Ecommerce)
| None
| Some(common_enums::PaymentChannel::Other(_)) => Self::Ecommerce,
Some(common_enums::PaymentChannel::MailOrder)
| Some(common_enums::PaymentChannel::TelephoneOrder) => Self::Moto,
},
}
}
}
type RecurringDetails = (Option<AdyenRecurringModel>, Option<bool>, Option<String>);
fn get_recurring_processing_model(
item: &PaymentsAuthorizeRouterData,
) -> Result<RecurringDetails, Error> {
let shopper_reference = match item.get_connector_customer_id() {
Ok(connector_customer_id) => Some(connector_customer_id),
Err(_) => {
let customer_id = item.get_customer_id()?;
Some(format!(
"{}_{}",
item.merchant_id.get_string_repr(),
customer_id.get_string_repr()
))
}
};
match (item.request.setup_future_usage, item.request.off_session) {
(Some(storage_enums::FutureUsage::OffSession), _) => {
let store_payment_method = item.request.is_mandate_payment();
Ok((
Some(AdyenRecurringModel::UnscheduledCardOnFile),
Some(store_payment_method),
shopper_reference,
))
}
(_, Some(true)) => Ok((
Some(AdyenRecurringModel::UnscheduledCardOnFile),
None,
shopper_reference,
)),
_ => Ok((None, None, None)),
}
}
fn get_browser_info(item: &PaymentsAuthorizeRouterData) -> Result<Option<AdyenBrowserInfo>, Error> {
if item.auth_type == storage_enums::AuthenticationType::ThreeDs
|| item.payment_method == storage_enums::PaymentMethod::Card
|| item.payment_method == storage_enums::PaymentMethod::BankRedirect
|| item.request.payment_method_type == Some(storage_enums::PaymentMethodType::GoPay)
|| item.request.payment_method_type == Some(storage_enums::PaymentMethodType::GooglePay)
{
let info = item.request.get_browser_info()?;
Ok(Some(AdyenBrowserInfo {
accept_header: info.get_accept_header()?,
language: info.get_language()?,
screen_height: info.get_screen_height()?,
screen_width: info.get_screen_width()?,
color_depth: info.get_color_depth()?,
user_agent: info.get_user_agent()?,
time_zone_offset: info.get_time_zone()?,
java_enabled: info.get_java_enabled()?,
}))
} else {
Ok(None)
}
}
fn get_additional_data(item: &PaymentsAuthorizeRouterData) -> Option<AdditionalData> {
let (authorisation_type, manual_capture) = match item.request.capture_method {
Some(storage_enums::CaptureMethod::Manual) | Some(enums::CaptureMethod::ManualMultiple) => {
(Some(AuthType::PreAuth), Some("true".to_string()))
}
_ => (None, None),
};
let riskdata = item.request.metadata.clone().and_then(get_risk_data);
let execute_three_d = if matches!(item.auth_type, storage_enums::AuthenticationType::ThreeDs) {
Some("true".to_string())
} else {
Some("false".to_string())
};
Some(AdditionalData {
authorisation_type,
manual_capture,
execute_three_d,
network_tx_reference: None,
recurring_detail_reference: None,
recurring_shopper_reference: None,
recurring_processing_model: None,
riskdata,
..AdditionalData::default()
})
}
fn get_channel_type(pm_type: Option<storage_enums::PaymentMethodType>) -> Option<Channel> {
pm_type.as_ref().and_then(|pmt| match pmt {
storage_enums::PaymentMethodType::GoPay | storage_enums::PaymentMethodType::Vipps => {
Some(Channel::Web)
}
_ => None,
})
}
fn get_amount_data(item: &AdyenRouterData<&PaymentsAuthorizeRouterData>) -> Amount {
Amount {
currency: item.router_data.request.currency,
value: item.amount.to_owned(),
}
}
pub fn get_address_info(
address: Option<&hyperswitch_domain_models::address::Address>,
) -> Option<Result<Address, error_stack::Report<errors::ConnectorError>>> {
address.and_then(|add| {
add.address.as_ref().map(
|a| -> Result<Address, error_stack::Report<errors::ConnectorError>> {
Ok(Address {
city: a.get_city()?.to_owned(),
country: a.get_country()?.to_owned(),
house_number_or_name: a.get_line1()?.to_owned(),
postal_code: a.get_zip()?.to_owned(),
state_or_province: a.state.clone(),
street: a.get_optional_line2().to_owned(),
})
},
)
})
}
fn get_line_items(item: &AdyenRouterData<&PaymentsAuthorizeRouterData>) -> Vec<LineItem> {
let order_details = item.router_data.request.order_details.clone();
match order_details {
Some(od) => od
.iter()
.enumerate()
.map(|(i, data)| LineItem {
amount_including_tax: Some(data.amount),
amount_excluding_tax: Some(data.amount),
description: Some(data.product_name.clone()),
id: Some(format!("Items #{i}")),
tax_amount: None,
quantity: Some(data.quantity),
})
.collect(),
None => {
let line_item = LineItem {
amount_including_tax: Some(item.amount.to_owned()),
amount_excluding_tax: Some(item.amount.to_owned()),
description: item.router_data.description.clone(),
id: Some(String::from("Items #1")),
tax_amount: None,
quantity: Some(1),
};
vec![line_item]
}
}
}
fn get_telephone_number(item: &PaymentsAuthorizeRouterData) -> Option<Secret<String>> {
let phone = item
.get_optional_billing()
.and_then(|billing| billing.phone.as_ref());
phone.as_ref().and_then(|phone| {
phone.number.as_ref().and_then(|number| {
phone
.country_code
.as_ref()
.map(|cc| Secret::new(format!("{}{}", cc, number.peek())))
})
})
}
fn get_shopper_name(
address: Option<&hyperswitch_domain_models::address::Address>,
) -> Option<ShopperName> {
let billing = address.and_then(|billing| billing.address.as_ref());
Some(ShopperName {
first_name: billing.and_then(|a| a.first_name.clone()),
last_name: billing.and_then(|a| a.last_name.clone()),
})
}
fn get_country_code(
address: Option<&hyperswitch_domain_models::address::Address>,
) -> Option<storage_enums::CountryAlpha2> {
address.and_then(|billing| billing.address.as_ref().and_then(|address| address.country))
}
fn get_social_security_number(voucher_data: &VoucherData) -> Option<Secret<String>> {
match voucher_data {
VoucherData::Boleto(boleto_data) => boleto_data.social_security_number.clone(),
VoucherData::Alfamart { .. }
| VoucherData::Indomaret { .. }
| VoucherData::Efecty
| VoucherData::PagoEfectivo
| VoucherData::RedCompra
| VoucherData::Oxxo
| VoucherData::RedPagos
| VoucherData::SevenEleven { .. }
| VoucherData::Lawson { .. }
| VoucherData::MiniStop { .. }
| VoucherData::FamilyMart { .. }
| VoucherData::Seicomart { .. }
| VoucherData::PayEasy { .. } => None,
}
}
fn build_shopper_reference(item: &PaymentsAuthorizeRouterData) -> Option<String> {
match item.get_connector_customer_id() {
Ok(connector_customer_id) => Some(connector_customer_id),
Err(_) => match item.get_customer_id() {
Ok(customer_id) => Some(format!(
"{}_{}",
item.merchant_id.get_string_repr(),
customer_id.get_string_repr()
)),
Err(_) => None,
},
}
}
impl TryFrom<(&BankDebitData, &PaymentsAuthorizeRouterData)> for AdyenPaymentMethod<'_> {
type Error = Error;
fn try_from(
(bank_debit_data, item): (&BankDebitData, &PaymentsAuthorizeRouterData),
) -> Result<Self, Self::Error> {
match bank_debit_data {
BankDebitData::AchBankDebit {
account_number,
routing_number,
..
} => Ok(AdyenPaymentMethod::AchDirectDebit(Box::new(
AchDirectDebitData {
bank_account_number: account_number.clone(),
bank_location_id: routing_number.clone(),
owner_name: item.get_billing_full_name()?,
},
))),
BankDebitData::SepaBankDebit { iban, .. } => Ok(AdyenPaymentMethod::SepaDirectDebit(
Box::new(SepaDirectDebitData {
owner_name: item.get_billing_full_name()?,
iban_number: iban.clone(),
}),
)),
BankDebitData::BacsBankDebit {
account_number,
sort_code,
..
} => {
let testing_data = item
.request
.get_connector_testing_data()
.map(AdyenTestingData::try_from)
.transpose()?;
let test_holder_name = testing_data.and_then(|test_data| test_data.holder_name);
Ok(AdyenPaymentMethod::BacsDirectDebit(Box::new(
BacsDirectDebitData {
bank_account_number: account_number.clone(),
bank_location_id: sort_code.clone(),
holder_name: test_holder_name.unwrap_or(item.get_billing_full_name()?),
},
)))
}
BankDebitData::BecsBankDebit { .. } | BankDebitData::SepaGuarenteedBankDebit { .. } => {
Err(errors::ConnectorError::NotImplemented(
utils::get_unimplemented_payment_method_error_message("Adyen"),
)
.into())
}
}
}
}
impl TryFrom<(&VoucherData, &PaymentsAuthorizeRouterData)> for AdyenPaymentMethod<'_> {
type Error = Error;
fn try_from(
(voucher_data, item): (&VoucherData, &PaymentsAuthorizeRouterData),
) -> Result<Self, Self::Error> {
match voucher_data {
VoucherData::Boleto { .. } => Ok(AdyenPaymentMethod::BoletoBancario),
VoucherData::Alfamart(_) => Ok(AdyenPaymentMethod::Alfamart(Box::new(
DokuBankData::try_from(item)?,
))),
VoucherData::Indomaret(_) => Ok(AdyenPaymentMethod::Indomaret(Box::new(
DokuBankData::try_from(item)?,
))),
VoucherData::Oxxo => Ok(AdyenPaymentMethod::Oxxo),
VoucherData::SevenEleven(_) => Ok(AdyenPaymentMethod::SevenEleven(Box::new(
JCSVoucherData::try_from(item)?,
))),
VoucherData::Lawson(_)
| VoucherData::MiniStop(_)
| VoucherData::FamilyMart(_)
| VoucherData::Seicomart(_)
| VoucherData::PayEasy(_) => Ok(AdyenPaymentMethod::JapaneseConvenienceStores(
Box::new(JCSVoucherData::try_from(item)?),
)),
VoucherData::Efecty
| VoucherData::PagoEfectivo
| VoucherData::RedCompra
| VoucherData::RedPagos => Err(errors::ConnectorError::NotImplemented(
utils::get_unimplemented_payment_method_error_message("Adyen"),
)
.into()),
}
}
}
impl TryFrom<&GiftCardData> for AdyenPaymentMethod<'_> {
type Error = Error;
fn try_from(gift_card_data: &GiftCardData) -> Result<Self, Self::Error> {
match gift_card_data {
GiftCardData::PaySafeCard {} => Ok(AdyenPaymentMethod::PaySafeCard),
GiftCardData::Givex(givex_data) => {
let gift_card_pm = AdyenGiftCardData {
brand: GiftCardBrand::Givex,
number: givex_data.number.clone(),
cvc: givex_data.cvc.clone(),
};
Ok(AdyenPaymentMethod::AdyenGiftCard(Box::new(gift_card_pm)))
}
GiftCardData::BhnCardNetwork(_) => Err(errors::ConnectorError::NotImplemented(
utils::get_unimplemented_payment_method_error_message("Adyen"),
)
.into()),
}
}
}
fn get_adyen_card_network(card_network: common_enums::CardNetwork) -> Option<CardBrand> {
match card_network {
common_enums::CardNetwork::Visa => Some(CardBrand::Visa),
common_enums::CardNetwork::Mastercard => Some(CardBrand::MC),
common_enums::CardNetwork::CartesBancaires => Some(CardBrand::Cartebancaire),
common_enums::CardNetwork::AmericanExpress => Some(CardBrand::Amex),
common_enums::CardNetwork::JCB => Some(CardBrand::Jcb),
common_enums::CardNetwork::DinersClub => Some(CardBrand::Diners),
common_enums::CardNetwork::Discover => Some(CardBrand::Discover),
common_enums::CardNetwork::UnionPay => Some(CardBrand::Cup),
common_enums::CardNetwork::RuPay => Some(CardBrand::Rupay),
common_enums::CardNetwork::Maestro => Some(CardBrand::Maestro),
common_enums::CardNetwork::Star => Some(CardBrand::Star),
common_enums::CardNetwork::Accel => Some(CardBrand::Accel),
common_enums::CardNetwork::Pulse => Some(CardBrand::Pulse),
common_enums::CardNetwork::Nyce => Some(CardBrand::Nyce),
common_enums::CardNetwork::Interac => None,
}
}
impl TryFrom<(&Card, Option<Secret<String>>)> for AdyenPaymentMethod<'_> {
type Error = Error;
fn try_from(
(card, card_holder_name): (&Card, Option<Secret<String>>),
) -> Result<Self, Self::Error> {
let adyen_card = AdyenCard {
number: card.card_number.clone(),
expiry_month: card.card_exp_month.clone(),
expiry_year: card.get_expiry_year_4_digit(),
cvc: Some(card.card_cvc.clone()),
holder_name: card_holder_name,
brand: card.card_network.clone().and_then(get_adyen_card_network),
network_payment_reference: None,
};
Ok(AdyenPaymentMethod::AdyenCard(Box::new(adyen_card)))
}
}
impl TryFrom<&storage_enums::PaymentMethodType> for PaymentType {
type Error = Error;
fn try_from(item: &storage_enums::PaymentMethodType) -> Result<Self, Self::Error> {
match item {
storage_enums::PaymentMethodType::Credit
| storage_enums::PaymentMethodType::Debit
| storage_enums::PaymentMethodType::Klarna
| storage_enums::PaymentMethodType::BancontactCard
| storage_enums::PaymentMethodType::Blik
| storage_enums::PaymentMethodType::Eps
| storage_enums::PaymentMethodType::Ideal
| storage_enums::PaymentMethodType::OnlineBankingCzechRepublic
| storage_enums::PaymentMethodType::OnlineBankingFinland
| storage_enums::PaymentMethodType::OnlineBankingPoland
| storage_enums::PaymentMethodType::OnlineBankingSlovakia
| storage_enums::PaymentMethodType::Trustly
| storage_enums::PaymentMethodType::GooglePay
| storage_enums::PaymentMethodType::AliPay
| storage_enums::PaymentMethodType::ApplePay
| storage_enums::PaymentMethodType::AliPayHk
| storage_enums::PaymentMethodType::MbWay
| storage_enums::PaymentMethodType::MobilePay
| storage_enums::PaymentMethodType::WeChatPay
| storage_enums::PaymentMethodType::SamsungPay
| storage_enums::PaymentMethodType::Affirm
| storage_enums::PaymentMethodType::AfterpayClearpay
| storage_enums::PaymentMethodType::PayBright
| storage_enums::PaymentMethodType::Walley => Ok(Self::Scheme),
storage_enums::PaymentMethodType::Sepa => Ok(Self::SepaDirectDebit),
storage_enums::PaymentMethodType::Bacs => Ok(Self::BacsDirectDebit),
storage_enums::PaymentMethodType::Ach => Ok(Self::AchDirectDebit),
storage_enums::PaymentMethodType::Paypal => Ok(Self::Paypal),
_ => Err(errors::ConnectorError::NotImplemented(
utils::get_unimplemented_payment_method_error_message("Adyen"),
))?,
}
}
}
impl TryFrom<&utils::CardIssuer> for CardBrand {
type Error = Error;
fn try_from(card_issuer: &utils::CardIssuer) -> Result<Self, Self::Error> {
match card_issuer {
utils::CardIssuer::AmericanExpress => Ok(Self::Amex),
utils::CardIssuer::Master => Ok(Self::MC),
utils::CardIssuer::Visa => Ok(Self::Visa),
utils::CardIssuer::Maestro => Ok(Self::Maestro),
utils::CardIssuer::Discover => Ok(Self::Discover),
utils::CardIssuer::DinersClub => Ok(Self::Diners),
utils::CardIssuer::JCB => Ok(Self::Jcb),
utils::CardIssuer::CarteBlanche => Ok(Self::Cartebancaire),
utils::CardIssuer::CartesBancaires => Ok(Self::Cartebancaire),
utils::CardIssuer::UnionPay => Ok(Self::Cup),
}
}
}
impl TryFrom<(&WalletData, &PaymentsAuthorizeRouterData)> for AdyenPaymentMethod<'_> {
type Error = Error;
fn try_from(value: (&WalletData, &PaymentsAuthorizeRouterData)) -> Result<Self, Self::Error> {
let (wallet_data, item) = value;
match wallet_data {
WalletData::GooglePay(data) => {
let gpay_data = AdyenGPay {
google_pay_token: Secret::new(
data.tokenization_data
.get_encrypted_google_pay_token()
.change_context(errors::ConnectorError::MissingRequiredField {
field_name: "gpay wallet_token",
})?
.to_owned(),
),
};
Ok(AdyenPaymentMethod::Gpay(Box::new(gpay_data)))
}
WalletData::ApplePay(data) => {
if let Some(PaymentMethodToken::ApplePayDecrypt(apple_pay_decrypte)) =
item.payment_method_token.clone()
{
let expiry_year_4_digit = apple_pay_decrypte.get_four_digit_expiry_year();
let exp_month = apple_pay_decrypte.get_expiry_month().change_context(
errors::ConnectorError::InvalidDataFormat {
field_name: "expiration_month",
},
)?;
let apple_pay_decrypted_data = AdyenApplePayDecryptData {
number: apple_pay_decrypte.application_primary_account_number,
expiry_month: exp_month,
expiry_year: expiry_year_4_digit,
brand: data.payment_method.network.clone(),
payment_type: PaymentType::Scheme,
};
Ok(AdyenPaymentMethod::ApplePayDecrypt(Box::new(
apple_pay_decrypted_data,
)))
} else {
let apple_pay_encrypted_data = data
.payment_data
.get_encrypted_apple_pay_payment_data_mandatory()
.change_context(errors::ConnectorError::MissingRequiredField {
field_name: "Apple pay encrypted data",
})?;
let apple_pay_data = AdyenApplePay {
apple_pay_token: Secret::new(apple_pay_encrypted_data.to_string()),
};
Ok(AdyenPaymentMethod::ApplePay(Box::new(apple_pay_data)))
}
}
WalletData::PaypalRedirect(_) => Ok(AdyenPaymentMethod::AdyenPaypal),
WalletData::AliPayRedirect(_) => Ok(AdyenPaymentMethod::AliPay),
WalletData::AliPayHkRedirect(_) => Ok(AdyenPaymentMethod::AliPayHk),
WalletData::GoPayRedirect(_) => {
let go_pay_data = GoPayData {};
Ok(AdyenPaymentMethod::GoPay(Box::new(go_pay_data)))
}
WalletData::KakaoPayRedirect(_) => {
let kakao_pay_data = KakaoPayData {};
Ok(AdyenPaymentMethod::Kakaopay(Box::new(kakao_pay_data)))
}
WalletData::GcashRedirect(_) => {
let gcash_data = GcashData {};
Ok(AdyenPaymentMethod::Gcash(Box::new(gcash_data)))
}
WalletData::MomoRedirect(_) => {
let momo_data = MomoData {};
Ok(AdyenPaymentMethod::Momo(Box::new(momo_data)))
}
WalletData::TouchNGoRedirect(_) => {
let touch_n_go_data = TouchNGoData {};
Ok(AdyenPaymentMethod::TouchNGo(Box::new(touch_n_go_data)))
}
WalletData::MbWayRedirect(_) => {
let phone_details = item.get_billing_phone()?;
let mbway_data = MbwayData {
telephone_number: phone_details.get_number_with_country_code()?,
};
Ok(AdyenPaymentMethod::Mbway(Box::new(mbway_data)))
}
WalletData::MobilePayRedirect(_) => Ok(AdyenPaymentMethod::MobilePay),
WalletData::WeChatPayRedirect(_) => Ok(AdyenPaymentMethod::WeChatPayWeb),
WalletData::SamsungPay(samsung_data) => {
let data = SamsungPayPmData {
samsung_pay_token: samsung_data.payment_credential.token_data.data.to_owned(),
};
Ok(AdyenPaymentMethod::SamsungPay(Box::new(data)))
}
WalletData::Paze(_) => match item.payment_method_token.clone() {
Some(PaymentMethodToken::PazeDecrypt(paze_decrypted_data)) => {
let data = AdyenPazeData {
number: paze_decrypted_data.token.payment_token,
expiry_month: paze_decrypted_data.token.token_expiration_month,
expiry_year: paze_decrypted_data.token.token_expiration_year,
cvc: None,
holder_name: paze_decrypted_data
.billing_address
.name
.or(item.get_optional_billing_full_name()),
brand: Some(paze_decrypted_data.payment_card_network.clone())
.and_then(get_adyen_card_network),
network_payment_reference: None,
};
Ok(AdyenPaymentMethod::AdyenPaze(Box::new(data)))
}
_ => Err(errors::ConnectorError::NotImplemented(
utils::get_unimplemented_payment_method_error_message("Cybersource"),
)
.into()),
},
WalletData::TwintRedirect { .. } => Ok(AdyenPaymentMethod::Twint),
WalletData::VippsRedirect { .. } => Ok(AdyenPaymentMethod::Vipps),
WalletData::DanaRedirect { .. } => Ok(AdyenPaymentMethod::Dana),
WalletData::SwishQr(_) => Ok(AdyenPaymentMethod::Swish),
WalletData::AliPayQr(_)
| WalletData::AmazonPayRedirect(_)
| WalletData::Paysera(_)
| WalletData::Skrill(_)
| WalletData::ApplePayRedirect(_)
| WalletData::ApplePayThirdPartySdk(_)
| WalletData::GooglePayRedirect(_)
| WalletData::GooglePayThirdPartySdk(_)
| WalletData::BluecodeRedirect {}
| WalletData::AmazonPay(_)
| WalletData::PaypalSdk(_)
| WalletData::WeChatPayQr(_)
| WalletData::CashappQr(_)
| WalletData::Mifinity(_)
| WalletData::RevolutPay(_) => Err(errors::ConnectorError::NotImplemented(
utils::get_unimplemented_payment_method_error_message("Adyen"),
)
.into()),
}
}
}
pub fn check_required_field<'a, T>(
field: &'a Option<T>,
message: &'static str,
) -> Result<&'a T, errors::ConnectorError> {
field
.as_ref()
.ok_or(errors::ConnectorError::MissingRequiredField {
field_name: message,
})
}
impl
TryFrom<(
&PayLaterData,
&Option<storage_enums::CountryAlpha2>,
&Option<Email>,
&Option<String>,
&Option<ShopperName>,
&Option<Secret<String>>,
&Option<Address>,
&Option<Address>,
)> for AdyenPaymentMethod<'_>
{
type Error = Error;
fn try_from(
value: (
&PayLaterData,
&Option<storage_enums::CountryAlpha2>,
&Option<Email>,
&Option<String>,
&Option<ShopperName>,
&Option<Secret<String>>,
&Option<Address>,
&Option<Address>,
),
) -> Result<Self, Self::Error> {
let (
pay_later_data,
country_code,
shopper_email,
shopper_reference,
shopper_name,
telephone_number,
billing_address,
delivery_address,
) = value;
match pay_later_data {
PayLaterData::KlarnaRedirect { .. } => {
check_required_field(shopper_email, "email")?;
check_required_field(shopper_reference, "customer_id")?;
check_required_field(country_code, "billing.country")?;
Ok(AdyenPaymentMethod::AdyenKlarna)
}
PayLaterData::AffirmRedirect { .. } => {
check_required_field(shopper_email, "email")?;
check_required_field(shopper_name, "billing.first_name, billing.last_name")?;
check_required_field(telephone_number, "billing.phone")?;
check_required_field(billing_address, "billing")?;
Ok(AdyenPaymentMethod::AdyenAffirm)
}
PayLaterData::AfterpayClearpayRedirect { .. } => {
check_required_field(shopper_email, "email")?;
check_required_field(shopper_name, "billing.first_name, billing.last_name")?;
check_required_field(delivery_address, "shipping")?;
check_required_field(billing_address, "billing")?;
if let Some(country) = country_code {
match country {
storage_enums::CountryAlpha2::IT
| storage_enums::CountryAlpha2::FR
| storage_enums::CountryAlpha2::ES
| storage_enums::CountryAlpha2::GB => Ok(AdyenPaymentMethod::ClearPay),
_ => Ok(AdyenPaymentMethod::AfterPay),
}
} else {
Err(errors::ConnectorError::MissingRequiredField {
field_name: "country",
})?
}
}
PayLaterData::PayBrightRedirect { .. } => {
check_required_field(shopper_name, "billing.first_name, billing.last_name")?;
check_required_field(telephone_number, "billing.phone")?;
check_required_field(shopper_email, "email")?;
check_required_field(billing_address, "billing")?;
check_required_field(delivery_address, "shipping")?;
check_required_field(country_code, "billing.country")?;
Ok(AdyenPaymentMethod::PayBright)
}
PayLaterData::WalleyRedirect { .. } => {
//[TODO: Line items specific sub-fields are mandatory]
check_required_field(telephone_number, "billing.phone")?;
check_required_field(shopper_email, "email")?;
Ok(AdyenPaymentMethod::Walley)
}
PayLaterData::AlmaRedirect { .. } => {
check_required_field(telephone_number, "billing.phone")?;
check_required_field(shopper_email, "email")?;
check_required_field(billing_address, "billing")?;
check_required_field(delivery_address, "shipping")?;
Ok(AdyenPaymentMethod::AlmaPayLater)
}
PayLaterData::AtomeRedirect { .. } => {
check_required_field(shopper_email, "email")?;
check_required_field(shopper_name, "billing.first_name, billing.last_name")?;
check_required_field(telephone_number, "billing.phone")?;
check_required_field(billing_address, "billing")?;
Ok(AdyenPaymentMethod::Atome)
}
PayLaterData::KlarnaSdk { .. }
| PayLaterData::BreadpayRedirect {}
| PayLaterData::FlexitiRedirect {} => Err(errors::ConnectorError::NotImplemented(
utils::get_unimplemented_payment_method_error_message("Adyen"),
)
.into()),
}
}
}
impl TryFrom<(&BankRedirectData, &PaymentsAuthorizeRouterData)> for AdyenPaymentMethod<'_> {
type Error = Error;
fn try_from(
(bank_redirect_data, item): (&BankRedirectData, &PaymentsAuthorizeRouterData),
) -> Result<Self, Self::Error> {
match bank_redirect_data {
BankRedirectData::BancontactCard {
card_number,
card_exp_month,
card_exp_year,
..
} => {
let testing_data = item
.request
.get_connector_testing_data()
.map(AdyenTestingData::try_from)
.transpose()?;
let test_holder_name = testing_data.and_then(|test_data| test_data.holder_name);
Ok(AdyenPaymentMethod::BancontactCard(Box::new(AdyenCard {
brand: Some(CardBrand::Bcmc),
number: card_number
.as_ref()
.ok_or(errors::ConnectorError::MissingRequiredField {
field_name: "bancontact_card.card_number",
})?
.clone(),
expiry_month: card_exp_month
.as_ref()
.ok_or(errors::ConnectorError::MissingRequiredField {
field_name: "bancontact_card.card_exp_month",
})?
.clone(),
expiry_year: card_exp_year
.as_ref()
.ok_or(errors::ConnectorError::MissingRequiredField {
field_name: "bancontact_card.card_exp_year",
})?
.clone(),
holder_name: test_holder_name.or(Some(item.get_billing_full_name()?)),
cvc: None,
network_payment_reference: None,
})))
}
BankRedirectData::Bizum { .. } => Ok(AdyenPaymentMethod::Bizum),
BankRedirectData::Blik { blik_code } => {
Ok(AdyenPaymentMethod::Blik(Box::new(BlikRedirectionData {
blik_code: Secret::new(blik_code.clone().ok_or(
errors::ConnectorError::MissingRequiredField {
field_name: "blik_code",
},
)?),
})))
}
BankRedirectData::Eps { bank_name, .. } => Ok(AdyenPaymentMethod::Eps(Box::new(
BankRedirectionWithIssuer {
issuer: Some(
AdyenTestBankNames::try_from(&bank_name.ok_or(
errors::ConnectorError::MissingRequiredField {
field_name: "eps.bank_name",
},
)?)?
.0,
),
},
))),
BankRedirectData::Ideal { .. } => Ok(AdyenPaymentMethod::Ideal),
BankRedirectData::OnlineBankingCzechRepublic { issuer } => {
Ok(AdyenPaymentMethod::OnlineBankingCzechRepublic(Box::new(
OnlineBankingCzechRepublicData {
issuer: OnlineBankingCzechRepublicBanks::try_from(issuer)?,
},
)))
}
BankRedirectData::OnlineBankingFinland { .. } => {
Ok(AdyenPaymentMethod::OnlineBankingFinland)
}
BankRedirectData::OnlineBankingPoland { issuer } => Ok(
AdyenPaymentMethod::OnlineBankingPoland(Box::new(OnlineBankingPolandData {
issuer: OnlineBankingPolandBanks::try_from(issuer)?,
})),
),
BankRedirectData::OnlineBankingSlovakia { issuer } => Ok(
AdyenPaymentMethod::OnlineBankingSlovakia(Box::new(OnlineBankingSlovakiaData {
issuer: OnlineBankingSlovakiaBanks::try_from(issuer)?,
})),
),
BankRedirectData::OnlineBankingFpx { issuer } => Ok(
AdyenPaymentMethod::OnlineBankingFpx(Box::new(OnlineBankingFpxData {
issuer: OnlineBankingFpxIssuer::try_from(issuer)?,
})),
),
BankRedirectData::OnlineBankingThailand { issuer } => Ok(
AdyenPaymentMethod::OnlineBankingThailand(Box::new(OnlineBankingThailandData {
issuer: OnlineBankingThailandIssuer::try_from(issuer)?,
})),
),
BankRedirectData::OpenBankingUk { issuer, .. } => Ok(
AdyenPaymentMethod::OpenBankingUK(Box::new(OpenBankingUKData {
issuer: match issuer {
Some(bank_name) => Some(OpenBankingUKIssuer::try_from(bank_name)?),
None => None,
},
})),
),
BankRedirectData::Trustly { .. } => Ok(AdyenPaymentMethod::Trustly),
BankRedirectData::Giropay { .. }
| BankRedirectData::Eft { .. }
| BankRedirectData::Interac { .. }
| BankRedirectData::LocalBankRedirect {}
| BankRedirectData::Przelewy24 { .. }
| BankRedirectData::Sofort { .. } => Err(errors::ConnectorError::NotImplemented(
utils::get_unimplemented_payment_method_error_message("Adyen"),
)
.into()),
}
}
}
impl TryFrom<(&BankTransferData, &PaymentsAuthorizeRouterData)> for AdyenPaymentMethod<'_> {
type Error = Error;
fn try_from(
(bank_transfer_data, item): (&BankTransferData, &PaymentsAuthorizeRouterData),
) -> Result<Self, Self::Error> {
match bank_transfer_data {
BankTransferData::PermataBankTransfer {} => Ok(
AdyenPaymentMethod::PermataBankTransfer(Box::new(DokuBankData::try_from(item)?)),
),
BankTransferData::BcaBankTransfer {} => Ok(AdyenPaymentMethod::BcaBankTransfer(
Box::new(DokuBankData::try_from(item)?),
)),
BankTransferData::BniVaBankTransfer {} => Ok(AdyenPaymentMethod::BniVa(Box::new(
DokuBankData::try_from(item)?,
))),
BankTransferData::BriVaBankTransfer {} => Ok(AdyenPaymentMethod::BriVa(Box::new(
DokuBankData::try_from(item)?,
))),
BankTransferData::CimbVaBankTransfer {} => Ok(AdyenPaymentMethod::CimbVa(Box::new(
DokuBankData::try_from(item)?,
))),
BankTransferData::DanamonVaBankTransfer {} => Ok(AdyenPaymentMethod::DanamonVa(
Box::new(DokuBankData::try_from(item)?),
)),
BankTransferData::MandiriVaBankTransfer {} => Ok(AdyenPaymentMethod::MandiriVa(
Box::new(DokuBankData::try_from(item)?),
)),
BankTransferData::Pix { .. } => Ok(AdyenPaymentMethod::Pix),
BankTransferData::AchBankTransfer { .. }
| BankTransferData::SepaBankTransfer { .. }
| BankTransferData::BacsBankTransfer { .. }
| BankTransferData::MultibancoBankTransfer { .. }
| BankTransferData::LocalBankTransfer { .. }
| BankTransferData::InstantBankTransfer {}
| BankTransferData::InstantBankTransferFinland {}
| BankTransferData::InstantBankTransferPoland {}
| BankTransferData::IndonesianBankTransfer { .. }
| BankTransferData::Pse {} => Err(errors::ConnectorError::NotImplemented(
utils::get_unimplemented_payment_method_error_message("Adyen"),
)
.into()),
}
}
}
impl TryFrom<&PaymentsAuthorizeRouterData> for DokuBankData {
type Error = Error;
fn try_from(item: &PaymentsAuthorizeRouterData) -> Result<Self, Self::Error> {
Ok(Self {
first_name: item.get_billing_first_name()?,
last_name: item.get_optional_billing_last_name(),
shopper_email: item.get_billing_email()?,
})
}
}
impl TryFrom<&CardRedirectData> for AdyenPaymentMethod<'_> {
type Error = Error;
fn try_from(card_redirect_data: &CardRedirectData) -> Result<Self, Self::Error> {
match card_redirect_data {
CardRedirectData::Knet {} => Ok(AdyenPaymentMethod::Knet),
CardRedirectData::Benefit {} => Ok(AdyenPaymentMethod::Benefit),
CardRedirectData::MomoAtm {} => Ok(AdyenPaymentMethod::MomoAtm),
CardRedirectData::CardRedirect {} => Err(errors::ConnectorError::NotImplemented(
utils::get_unimplemented_payment_method_error_message("Adyen"),
)
.into()),
}
}
}
fn get_str(key: &str, riskdata: &serde_json::Value) -> Option<String> {
riskdata
.get(key)
.and_then(|v| v.as_str())
.map(|s| s.to_string())
}
fn get_bool(key: &str, riskdata: &serde_json::Value) -> Option<bool> {
riskdata.get(key).and_then(|v| v.as_bool())
}
pub fn get_risk_data(metadata: serde_json::Value) -> Option<RiskData> {
let item_i_d = get_str("riskdata.basket.item1.itemID", &metadata);
let product_title = get_str("riskdata.basket.item1.productTitle", &metadata);
let amount_per_item = get_str("riskdata.basket.item1.amountPerItem", &metadata);
let currency = get_str("riskdata.basket.item1.currency", &metadata);
let upc = get_str("riskdata.basket.item1.upc", &metadata);
let brand = get_str("riskdata.basket.item1.brand", &metadata);
let manufacturer = get_str("riskdata.basket.item1.manufacturer", &metadata);
let category = get_str("riskdata.basket.item1.category", &metadata);
let quantity = get_str("riskdata.basket.item1.quantity", &metadata);
let color = get_str("riskdata.basket.item1.color", &metadata);
let size = get_str("riskdata.basket.item1.size", &metadata);
let device_country = get_str("riskdata.deviceCountry", &metadata);
let house_numberor_name = get_str("riskdata.houseNumberorName", &metadata);
let account_creation_date = get_str("riskdata.accountCreationDate", &metadata);
let affiliate_channel = get_str("riskdata.affiliateChannel", &metadata);
let avg_order_value = get_str("riskdata.avgOrderValue", &metadata);
let delivery_method = get_str("riskdata.deliveryMethod", &metadata);
let email_name = get_str("riskdata.emailName", &metadata);
let email_domain = get_str("riskdata.emailDomain", &metadata);
let last_order_date = get_str("riskdata.lastOrderDate", &metadata);
let merchant_reference = get_str("riskdata.merchantReference", &metadata);
let payment_method = get_str("riskdata.paymentMethod", &metadata);
let promotion_name = get_str("riskdata.promotionName", &metadata);
let secondary_phone_number = get_str("riskdata.secondaryPhoneNumber", &metadata);
let timefrom_loginto_order = get_str("riskdata.timefromLogintoOrder", &metadata);
let total_session_time = get_str("riskdata.totalSessionTime", &metadata);
let total_authorized_amount_in_last30_days =
get_str("riskdata.totalAuthorizedAmountInLast30Days", &metadata);
let total_order_quantity = get_str("riskdata.totalOrderQuantity", &metadata);
let total_lifetime_value = get_str("riskdata.totalLifetimeValue", &metadata);
let visits_month = get_str("riskdata.visitsMonth", &metadata);
let visits_week = get_str("riskdata.visitsWeek", &metadata);
let visits_year = get_str("riskdata.visitsYear", &metadata);
let ship_to_name = get_str("riskdata.shipToName", &metadata);
let first8charactersof_address_line1_zip =
get_str("riskdata.first8charactersofAddressLine1Zip", &metadata);
let affiliate_order = get_bool("riskdata.affiliateOrder", &metadata);
Some(RiskData {
item_i_d,
product_title,
amount_per_item,
currency,
upc,
brand,
manufacturer,
category,
quantity,
color,
size,
device_country,
house_numberor_name,
account_creation_date,
affiliate_channel,
avg_order_value,
delivery_method,
email_name,
email_domain,
last_order_date,
merchant_reference,
payment_method,
promotion_name,
secondary_phone_number,
timefrom_loginto_order,
total_session_time,
total_authorized_amount_in_last30_days,
total_order_quantity,
total_lifetime_value,
visits_month,
visits_week,
visits_year,
ship_to_name,
first8charactersof_address_line1_zip,
affiliate_order,
})
}
fn get_device_fingerprint(metadata: serde_json::Value) -> Option<Secret<String>> {
metadata
.get("device_fingerprint")
.and_then(|value| value.as_str())
.map(|fingerprint| Secret::new(fingerprint.to_string()))
}
impl
TryFrom<(
&AdyenRouterData<&PaymentsAuthorizeRouterData>,
payments::MandateReferenceId,
)> for AdyenPaymentRequest<'_>
{
type Error = Error;
fn try_from(
value: (
&AdyenRouterData<&PaymentsAuthorizeRouterData>,
payments::MandateReferenceId,
),
) -> Result<Self, Self::Error> {
let (item, mandate_ref_id) = value;
let amount = get_amount_data(item);
let auth_type = AdyenAuthType::try_from(&item.router_data.connector_auth_type)?;
let shopper_interaction = AdyenShopperInteraction::from(item.router_data);
let (recurring_processing_model, store_payment_method, shopper_reference) =
get_recurring_processing_model(item.router_data)?;
let browser_info = None;
let additional_data = get_additional_data(item.router_data);
let return_url = item.router_data.request.get_router_return_url()?;
let payment_method_type = item.router_data.request.payment_method_type;
let testing_data = item
.router_data
.request
.get_connector_testing_data()
.map(AdyenTestingData::try_from)
.transpose()?;
let test_holder_name = testing_data.and_then(|test_data| test_data.holder_name);
let payment_method = match mandate_ref_id {
payments::MandateReferenceId::ConnectorMandateId(connector_mandate_ids) => {
let adyen_mandate = AdyenMandate {
payment_type: match payment_method_type {
Some(pm_type) => PaymentType::try_from(&pm_type)?,
None => PaymentType::Scheme,
},
stored_payment_method_id: Secret::new(
connector_mandate_ids
.get_connector_mandate_id()
.ok_or_else(missing_field_err("mandate_id"))?,
),
holder_name: test_holder_name,
};
Ok::<PaymentMethod<'_>, Self::Error>(PaymentMethod::AdyenMandatePaymentMethod(
Box::new(adyen_mandate),
))
}
payments::MandateReferenceId::NetworkMandateId(network_mandate_id) => {
match item.router_data.request.payment_method_data {
PaymentMethodData::CardDetailsForNetworkTransactionId(
ref card_details_for_network_transaction_id,
) => {
let brand = match card_details_for_network_transaction_id
.card_network
.clone()
.and_then(get_adyen_card_network)
{
Some(card_network) => card_network,
None => CardBrand::try_from(
&card_details_for_network_transaction_id.get_card_issuer()?,
)?,
};
let card_holder_name = item.router_data.get_optional_billing_full_name();
let adyen_card = AdyenCard {
number: card_details_for_network_transaction_id.card_number.clone(),
expiry_month: card_details_for_network_transaction_id
.card_exp_month
.clone(),
expiry_year: card_details_for_network_transaction_id
.get_expiry_year_4_digit()
.clone(),
cvc: None,
holder_name: test_holder_name.or(card_holder_name),
brand: Some(brand),
network_payment_reference: Some(Secret::new(network_mandate_id)),
};
Ok(PaymentMethod::AdyenPaymentMethod(Box::new(
AdyenPaymentMethod::AdyenCard(Box::new(adyen_card)),
)))
}
PaymentMethodData::CardRedirect(_)
| PaymentMethodData::Wallet(_)
| PaymentMethodData::PayLater(_)
| PaymentMethodData::BankRedirect(_)
| PaymentMethodData::BankDebit(_)
| PaymentMethodData::BankTransfer(_)
| PaymentMethodData::Crypto(_)
| PaymentMethodData::MandatePayment
| PaymentMethodData::Reward
| PaymentMethodData::RealTimePayment(_)
| PaymentMethodData::MobilePayment(_)
| PaymentMethodData::Upi(_)
| PaymentMethodData::Voucher(_)
| PaymentMethodData::GiftCard(_)
| PaymentMethodData::OpenBanking(_)
| PaymentMethodData::CardToken(_)
| PaymentMethodData::NetworkToken(_)
| PaymentMethodData::Card(_) => Err(errors::ConnectorError::NotSupported {
message: "Network tokenization for payment method".to_string(),
connector: "Adyen",
})?,
}
}
payments::MandateReferenceId::NetworkTokenWithNTI(network_mandate_id) => {
match item.router_data.request.payment_method_data {
PaymentMethodData::NetworkToken(ref token_data) => {
let card_issuer = token_data.get_card_issuer()?;
let brand = CardBrand::try_from(&card_issuer)?;
let card_holder_name = item.router_data.get_optional_billing_full_name();
let adyen_network_token = AdyenNetworkTokenData {
number: token_data.get_network_token(),
expiry_month: token_data.get_network_token_expiry_month(),
expiry_year: token_data.get_expiry_year_4_digit(),
holder_name: test_holder_name.or(card_holder_name),
brand: Some(brand), // FIXME: Remove hardcoding
network_payment_reference: Some(Secret::new(
network_mandate_id.network_transaction_id,
)),
};
Ok(PaymentMethod::AdyenPaymentMethod(Box::new(
AdyenPaymentMethod::NetworkToken(Box::new(adyen_network_token)),
)))
}
PaymentMethodData::Card(_)
| PaymentMethodData::CardRedirect(_)
| PaymentMethodData::Wallet(_)
| PaymentMethodData::PayLater(_)
| PaymentMethodData::BankRedirect(_)
| PaymentMethodData::BankDebit(_)
| PaymentMethodData::BankTransfer(_)
| PaymentMethodData::Crypto(_)
| PaymentMethodData::MandatePayment
| PaymentMethodData::Reward
| PaymentMethodData::RealTimePayment(_)
| PaymentMethodData::Upi(_)
| PaymentMethodData::Voucher(_)
| PaymentMethodData::GiftCard(_)
| PaymentMethodData::OpenBanking(_)
| PaymentMethodData::CardToken(_)
| PaymentMethodData::MobilePayment(_)
| PaymentMethodData::CardDetailsForNetworkTransactionId(_) => {
Err(errors::ConnectorError::NotSupported {
message: "Network tokenization for payment method".to_string(),
connector: "Adyen",
})?
}
}
} //
}?;
let (store, splits) = match item.router_data.request.split_payments.as_ref() {
Some(common_types::payments::SplitPaymentsRequest::AdyenSplitPayment(
adyen_split_payment,
)) => get_adyen_split_request(adyen_split_payment, item.router_data.request.currency),
_ => (None, None),
};
let device_fingerprint = item
.router_data
.request
.metadata
.clone()
.and_then(get_device_fingerprint);
let billing_address =
get_address_info(item.router_data.get_optional_billing()).and_then(Result::ok);
let delivery_address =
get_address_info(item.router_data.get_optional_shipping()).and_then(Result::ok);
let telephone_number = item.router_data.get_optional_billing_phone_number();
Ok(AdyenPaymentRequest {
amount,
merchant_account: auth_type.merchant_account,
payment_method,
reference: item.router_data.connector_request_reference_id.clone(),
return_url,
shopper_interaction,
recurring_processing_model,
browser_info,
additional_data,
mpi_data: None,
telephone_number,
shopper_name: None,
shopper_email: None,
shopper_locale: item.router_data.request.locale.clone(),
social_security_number: None,
billing_address,
delivery_address,
country_code: None,
line_items: None,
shopper_reference,
store_payment_method,
channel: None,
shopper_statement: item.router_data.request.statement_descriptor.clone(),
shopper_ip: item.router_data.request.get_ip_address_as_optional(),
merchant_order_reference: item.router_data.request.merchant_order_reference_id.clone(),
store,
splits,
device_fingerprint,
session_validity: None,
metadata: item.router_data.request.metadata.clone(),
})
}
}
impl TryFrom<(&AdyenRouterData<&PaymentsAuthorizeRouterData>, &Card)> for AdyenPaymentRequest<'_> {
type Error = Error;
fn try_from(
value: (&AdyenRouterData<&PaymentsAuthorizeRouterData>, &Card),
) -> Result<Self, Self::Error> {
let (item, card_data) = value;
let amount = get_amount_data(item);
let auth_type = AdyenAuthType::try_from(&item.router_data.connector_auth_type)?;
let shopper_interaction = AdyenShopperInteraction::from(item.router_data);
let shopper_reference = build_shopper_reference(item.router_data);
let (recurring_processing_model, store_payment_method, _) =
get_recurring_processing_model(item.router_data)?;
let browser_info = get_browser_info(item.router_data)?;
let billing_address =
get_address_info(item.router_data.get_optional_billing()).and_then(Result::ok);
let country_code = get_country_code(item.router_data.get_optional_billing());
let additional_data = get_additional_data(item.router_data);
let return_url = item.router_data.request.get_router_return_url()?;
let testing_data = item
.router_data
.request
.get_connector_testing_data()
.map(AdyenTestingData::try_from)
.transpose()?;
let test_holder_name = testing_data.and_then(|test_data| test_data.holder_name);
let card_holder_name =
test_holder_name.or(item.router_data.get_optional_billing_full_name());
let payment_method = PaymentMethod::AdyenPaymentMethod(Box::new(
AdyenPaymentMethod::try_from((card_data, card_holder_name))?,
));
let shopper_email = item.router_data.get_optional_billing_email();
let shopper_name = get_shopper_name(item.router_data.get_optional_billing());
let (store, splits) = match item.router_data.request.split_payments.as_ref() {
Some(common_types::payments::SplitPaymentsRequest::AdyenSplitPayment(
adyen_split_payment,
)) => get_adyen_split_request(adyen_split_payment, item.router_data.request.currency),
_ => (None, None),
};
let device_fingerprint = item
.router_data
.request
.metadata
.clone()
.and_then(get_device_fingerprint);
let delivery_address =
get_address_info(item.router_data.get_optional_shipping()).and_then(Result::ok);
let telephone_number = item.router_data.get_optional_billing_phone_number();
Ok(AdyenPaymentRequest {
amount,
merchant_account: auth_type.merchant_account,
payment_method,
reference: item.router_data.connector_request_reference_id.clone(),
return_url,
shopper_interaction,
recurring_processing_model,
browser_info,
additional_data,
mpi_data: None,
telephone_number,
shopper_name,
shopper_email,
shopper_locale: item.router_data.request.locale.clone(),
social_security_number: None,
billing_address,
delivery_address,
country_code,
line_items: None,
shopper_reference,
store_payment_method,
channel: None,
shopper_statement: item.router_data.request.statement_descriptor.clone(),
shopper_ip: item.router_data.request.get_ip_address_as_optional(),
merchant_order_reference: item.router_data.request.merchant_order_reference_id.clone(),
store,
splits,
device_fingerprint,
session_validity: None,
metadata: item.router_data.request.metadata.clone(),
})
}
}
impl
TryFrom<(
&AdyenRouterData<&PaymentsAuthorizeRouterData>,
&BankDebitData,
)> for AdyenPaymentRequest<'_>
{
type Error = Error;
fn try_from(
value: (
&AdyenRouterData<&PaymentsAuthorizeRouterData>,
&BankDebitData,
),
) -> Result<Self, Self::Error> {
let (item, bank_debit_data) = value;
let amount = get_amount_data(item);
let auth_type = AdyenAuthType::try_from(&item.router_data.connector_auth_type)?;
let shopper_interaction = AdyenShopperInteraction::from(item.router_data);
let (recurring_processing_model, store_payment_method, shopper_reference) =
get_recurring_processing_model(item.router_data)?;
let browser_info = get_browser_info(item.router_data)?;
let additional_data = get_additional_data(item.router_data);
let return_url = item.router_data.request.get_router_return_url()?;
let payment_method = PaymentMethod::AdyenPaymentMethod(Box::new(
AdyenPaymentMethod::try_from((bank_debit_data, item.router_data))?,
));
let country_code = get_country_code(item.router_data.get_optional_billing());
let (store, splits) = match item.router_data.request.split_payments.as_ref() {
Some(common_types::payments::SplitPaymentsRequest::AdyenSplitPayment(
adyen_split_payment,
)) => get_adyen_split_request(adyen_split_payment, item.router_data.request.currency),
_ => (None, None),
};
let device_fingerprint = item
.router_data
.request
.metadata
.clone()
.and_then(get_device_fingerprint);
let mut billing_address =
get_address_info(item.router_data.get_optional_billing()).and_then(Result::ok);
let delivery_address =
get_address_info(item.router_data.get_optional_shipping()).and_then(Result::ok);
let telephone_number = item.router_data.get_optional_billing_phone_number();
if let BankDebitData::AchBankDebit { .. } = bank_debit_data {
if let Some(addr) = billing_address.as_mut() {
addr.state_or_province = Some(item.router_data.get_billing_state_code()?);
}
}
let request = AdyenPaymentRequest {
amount,
merchant_account: auth_type.merchant_account,
payment_method,
reference: item.router_data.connector_request_reference_id.clone(),
return_url,
browser_info,
shopper_interaction,
recurring_processing_model,
additional_data,
mpi_data: None,
shopper_name: None,
shopper_locale: item.router_data.request.locale.clone(),
shopper_email: item.router_data.get_optional_billing_email(),
social_security_number: None,
telephone_number,
billing_address,
delivery_address,
country_code,
line_items: None,
shopper_reference,
store_payment_method,
channel: None,
shopper_statement: item.router_data.request.statement_descriptor.clone(),
shopper_ip: item.router_data.request.get_ip_address_as_optional(),
merchant_order_reference: item.router_data.request.merchant_order_reference_id.clone(),
store,
splits,
device_fingerprint,
session_validity: None,
metadata: item.router_data.request.metadata.clone(),
};
Ok(request)
}
}
impl TryFrom<(&AdyenRouterData<&PaymentsAuthorizeRouterData>, &VoucherData)>
for AdyenPaymentRequest<'_>
{
type Error = Error;
fn try_from(
value: (&AdyenRouterData<&PaymentsAuthorizeRouterData>, &VoucherData),
) -> Result<Self, Self::Error> {
let (item, voucher_data) = value;
let amount = get_amount_data(item);
let auth_type = AdyenAuthType::try_from(&item.router_data.connector_auth_type)?;
let shopper_interaction = AdyenShopperInteraction::from(item.router_data);
let recurring_processing_model = get_recurring_processing_model(item.router_data)?.0;
let browser_info = get_browser_info(item.router_data)?;
let additional_data = get_additional_data(item.router_data);
let payment_method = PaymentMethod::AdyenPaymentMethod(Box::new(
AdyenPaymentMethod::try_from((voucher_data, item.router_data))?,
));
let return_url = item.router_data.request.get_router_return_url()?;
let social_security_number = get_social_security_number(voucher_data);
let billing_address =
get_address_info(item.router_data.get_optional_billing()).and_then(Result::ok);
let shopper_name = get_shopper_name(item.router_data.get_optional_billing());
let (store, splits) = match item.router_data.request.split_payments.as_ref() {
Some(common_types::payments::SplitPaymentsRequest::AdyenSplitPayment(
adyen_split_payment,
)) => get_adyen_split_request(adyen_split_payment, item.router_data.request.currency),
_ => (None, None),
};
let device_fingerprint = item
.router_data
.request
.metadata
.clone()
.and_then(get_device_fingerprint);
let delivery_address =
get_address_info(item.router_data.get_optional_shipping()).and_then(Result::ok);
let telephone_number = item.router_data.get_optional_billing_phone_number();
let request = AdyenPaymentRequest {
amount,
merchant_account: auth_type.merchant_account,
payment_method,
reference: item.router_data.connector_request_reference_id.to_string(),
return_url,
browser_info,
shopper_interaction,
recurring_processing_model,
additional_data,
shopper_name,
shopper_locale: item.router_data.request.locale.clone(),
shopper_email: item.router_data.get_optional_billing_email(),
social_security_number,
mpi_data: None,
telephone_number,
billing_address,
delivery_address,
country_code: None,
line_items: None,
shopper_reference: None,
store_payment_method: None,
channel: None,
shopper_statement: item.router_data.request.statement_descriptor.clone(),
shopper_ip: item.router_data.request.get_ip_address_as_optional(),
merchant_order_reference: item.router_data.request.merchant_order_reference_id.clone(),
store,
splits,
device_fingerprint,
session_validity: None,
metadata: item.router_data.request.metadata.clone(),
};
Ok(request)
}
}
impl
TryFrom<(
&AdyenRouterData<&PaymentsAuthorizeRouterData>,
&BankTransferData,
)> for AdyenPaymentRequest<'_>
{
type Error = Error;
fn try_from(
value: (
&AdyenRouterData<&PaymentsAuthorizeRouterData>,
&BankTransferData,
),
) -> Result<Self, Self::Error> {
let (item, bank_transfer_data) = value;
let amount = get_amount_data(item);
let auth_type = AdyenAuthType::try_from(&item.router_data.connector_auth_type)?;
let shopper_interaction = AdyenShopperInteraction::from(item.router_data);
let payment_method = PaymentMethod::AdyenPaymentMethod(Box::new(
AdyenPaymentMethod::try_from((bank_transfer_data, item.router_data))?,
));
let return_url = item.router_data.request.get_router_return_url()?;
let (store, splits) = match item.router_data.request.split_payments.as_ref() {
Some(common_types::payments::SplitPaymentsRequest::AdyenSplitPayment(
adyen_split_payment,
)) => get_adyen_split_request(adyen_split_payment, item.router_data.request.currency),
_ => (None, None),
};
let device_fingerprint = item
.router_data
.request
.metadata
.clone()
.and_then(get_device_fingerprint);
let billing_address =
get_address_info(item.router_data.get_optional_billing()).and_then(Result::ok);
let delivery_address =
get_address_info(item.router_data.get_optional_shipping()).and_then(Result::ok);
let telephone_number = item.router_data.get_optional_billing_phone_number();
let (session_validity, social_security_number) = match bank_transfer_data {
BankTransferData::Pix {
cpf,
cnpj,
expiry_date,
..
} => {
// Validate expiry_date doesn't exceed 5 days from now
if let Some(expiry) = expiry_date {
let now = OffsetDateTime::now_utc();
let max_expiry = now + Duration::days(5);
let max_expiry_primitive =
PrimitiveDateTime::new(max_expiry.date(), max_expiry.time());
if *expiry > max_expiry_primitive {
return Err(report!(errors::ConnectorError::InvalidDataFormat {
field_name: "expiry_date cannot be more than 5 days from now",
}));
}
}
(*expiry_date, cpf.as_ref().or(cnpj.as_ref()).cloned())
}
BankTransferData::LocalBankTransfer { .. } => (None, None),
BankTransferData::AchBankTransfer {}
| BankTransferData::SepaBankTransfer {}
| BankTransferData::BacsBankTransfer {}
| BankTransferData::MultibancoBankTransfer {}
| BankTransferData::PermataBankTransfer {}
| BankTransferData::BcaBankTransfer {}
| BankTransferData::BniVaBankTransfer {}
| BankTransferData::BriVaBankTransfer {}
| BankTransferData::CimbVaBankTransfer {}
| BankTransferData::DanamonVaBankTransfer {}
| BankTransferData::MandiriVaBankTransfer {}
| BankTransferData::Pse {}
| BankTransferData::InstantBankTransfer {}
| BankTransferData::InstantBankTransferFinland {}
| BankTransferData::InstantBankTransferPoland {}
| BankTransferData::IndonesianBankTransfer { .. } => (None, None),
};
let request = AdyenPaymentRequest {
amount,
merchant_account: auth_type.merchant_account,
payment_method,
reference: item.router_data.connector_request_reference_id.to_string(),
return_url,
browser_info: None,
shopper_interaction,
recurring_processing_model: None,
additional_data: None,
mpi_data: None,
shopper_name: None,
shopper_locale: item.router_data.request.locale.clone(),
shopper_email: item.router_data.get_optional_billing_email(),
social_security_number,
telephone_number,
billing_address,
delivery_address,
country_code: None,
line_items: None,
shopper_reference: None,
store_payment_method: None,
channel: None,
shopper_statement: item.router_data.request.statement_descriptor.clone(),
shopper_ip: item.router_data.request.get_ip_address_as_optional(),
merchant_order_reference: item.router_data.request.merchant_order_reference_id.clone(),
store,
splits,
device_fingerprint,
session_validity,
metadata: item.router_data.request.metadata.clone(),
};
Ok(request)
}
}
impl
TryFrom<(
&AdyenRouterData<&PaymentsAuthorizeRouterData>,
&GiftCardData,
)> for AdyenPaymentRequest<'_>
{
type Error = Error;
fn try_from(
value: (
&AdyenRouterData<&PaymentsAuthorizeRouterData>,
&GiftCardData,
),
) -> Result<Self, Self::Error> {
let (item, gift_card_data) = value;
let amount = get_amount_data(item);
let auth_type = AdyenAuthType::try_from(&item.router_data.connector_auth_type)?;
let shopper_interaction = AdyenShopperInteraction::from(item.router_data);
let return_url = item.router_data.request.get_router_return_url()?;
let payment_method = PaymentMethod::AdyenPaymentMethod(Box::new(
AdyenPaymentMethod::try_from(gift_card_data)?,
));
let (store, splits) = match item.router_data.request.split_payments.as_ref() {
Some(common_types::payments::SplitPaymentsRequest::AdyenSplitPayment(
adyen_split_payment,
)) => get_adyen_split_request(adyen_split_payment, item.router_data.request.currency),
_ => (None, None),
};
let device_fingerprint = item
.router_data
.request
.metadata
.clone()
.and_then(get_device_fingerprint);
let billing_address =
get_address_info(item.router_data.get_optional_billing()).and_then(Result::ok);
let delivery_address =
get_address_info(item.router_data.get_optional_shipping()).and_then(Result::ok);
let telephone_number = item.router_data.get_optional_billing_phone_number();
let request = AdyenPaymentRequest {
amount,
merchant_account: auth_type.merchant_account,
payment_method,
reference: item.router_data.connector_request_reference_id.to_string(),
return_url,
browser_info: None,
shopper_interaction,
recurring_processing_model: None,
additional_data: None,
mpi_data: None,
shopper_name: None,
shopper_locale: item.router_data.request.locale.clone(),
shopper_email: item.router_data.get_optional_billing_email(),
telephone_number,
billing_address,
delivery_address,
country_code: None,
line_items: None,
shopper_reference: None,
store_payment_method: None,
channel: None,
social_security_number: None,
shopper_statement: item.router_data.request.statement_descriptor.clone(),
shopper_ip: item.router_data.request.get_ip_address_as_optional(),
merchant_order_reference: item.router_data.request.merchant_order_reference_id.clone(),
store,
splits,
device_fingerprint,
session_validity: None,
metadata: item.router_data.request.metadata.clone(),
};
Ok(request)
}
}
impl
TryFrom<(
&AdyenRouterData<&PaymentsAuthorizeRouterData>,
&BankRedirectData,
)> for AdyenPaymentRequest<'_>
{
type Error = Error;
fn try_from(
value: (
&AdyenRouterData<&PaymentsAuthorizeRouterData>,
&BankRedirectData,
),
) -> Result<Self, Self::Error> {
let (item, bank_redirect_data) = value;
let amount = get_amount_data(item);
let auth_type = AdyenAuthType::try_from(&item.router_data.connector_auth_type)?;
let shopper_interaction = AdyenShopperInteraction::from(item.router_data);
let (recurring_processing_model, store_payment_method, shopper_reference) =
get_recurring_processing_model(item.router_data)?;
let browser_info = get_browser_info(item.router_data)?;
let additional_data = get_additional_data(item.router_data);
let return_url = item.router_data.request.get_router_return_url()?;
let payment_method = PaymentMethod::AdyenPaymentMethod(Box::new(
AdyenPaymentMethod::try_from((bank_redirect_data, item.router_data))?,
));
let (shopper_locale, country) = get_redirect_extra_details(item.router_data)?;
let line_items = Some(get_line_items(item));
let billing_address =
get_address_info(item.router_data.get_optional_billing()).and_then(Result::ok);
let (store, splits) = match item.router_data.request.split_payments.as_ref() {
Some(common_types::payments::SplitPaymentsRequest::AdyenSplitPayment(
adyen_split_payment,
)) => get_adyen_split_request(adyen_split_payment, item.router_data.request.currency),
_ => (None, None),
};
let device_fingerprint = item
.router_data
.request
.metadata
.clone()
.and_then(get_device_fingerprint);
let delivery_address =
get_address_info(item.router_data.get_optional_shipping()).and_then(Result::ok);
let telephone_number = item.router_data.get_optional_billing_phone_number();
Ok(AdyenPaymentRequest {
amount,
merchant_account: auth_type.merchant_account,
payment_method,
reference: item.router_data.connector_request_reference_id.clone(),
return_url,
shopper_interaction,
recurring_processing_model,
browser_info,
additional_data,
mpi_data: None,
telephone_number,
shopper_name: None,
shopper_email: item.router_data.get_optional_billing_email(),
shopper_locale,
social_security_number: None,
billing_address,
delivery_address,
country_code: country,
line_items,
shopper_reference,
store_payment_method,
channel: None,
shopper_statement: item.router_data.request.statement_descriptor.clone(),
shopper_ip: item.router_data.request.get_ip_address_as_optional(),
merchant_order_reference: item.router_data.request.merchant_order_reference_id.clone(),
store,
splits,
device_fingerprint,
session_validity: None,
metadata: item.router_data.request.metadata.clone(),
})
}
}
fn get_redirect_extra_details(
item: &PaymentsAuthorizeRouterData,
) -> CustomResult<(Option<String>, Option<storage_enums::CountryAlpha2>), errors::ConnectorError> {
match item.request.payment_method_data {
PaymentMethodData::BankRedirect(
BankRedirectData::Trustly { .. } | BankRedirectData::OpenBankingUk { .. },
) => {
let country = item.get_optional_billing_country();
Ok((item.request.locale.clone(), country))
}
_ => Ok((None, None)),
}
}
fn get_shopper_email(
item: &PaymentsAuthorizeRouterData,
is_mandate_payment: bool,
) -> CustomResult<Option<Email>, errors::ConnectorError> {
if is_mandate_payment {
let payment_method_type = item
.request
.payment_method_type
.as_ref()
.ok_or(errors::ConnectorError::MissingPaymentMethodType)?;
match payment_method_type {
storage_enums::PaymentMethodType::Paypal => Ok(Some(item.get_billing_email()?)),
_ => Ok(item.get_optional_billing_email()),
}
} else {
Ok(item.get_optional_billing_email())
}
}
impl TryFrom<(&AdyenRouterData<&PaymentsAuthorizeRouterData>, &WalletData)>
for AdyenPaymentRequest<'_>
{
type Error = Error;
fn try_from(
value: (&AdyenRouterData<&PaymentsAuthorizeRouterData>, &WalletData),
) -> Result<Self, Self::Error> {
let (item, wallet_data) = value;
let amount = get_amount_data(item);
let auth_type = AdyenAuthType::try_from(&item.router_data.connector_auth_type)?;
let browser_info = get_browser_info(item.router_data)?;
let additional_data = get_additional_data(item.router_data);
let payment_method = PaymentMethod::AdyenPaymentMethod(Box::new(
AdyenPaymentMethod::try_from((wallet_data, item.router_data))?,
));
let shopper_interaction = AdyenShopperInteraction::from(item.router_data);
let channel = get_channel_type(item.router_data.request.payment_method_type);
let (recurring_processing_model, store_payment_method, shopper_reference) =
get_recurring_processing_model(item.router_data)?;
let return_url = item.router_data.request.get_router_return_url()?;
let shopper_email = get_shopper_email(item.router_data, store_payment_method.is_some())?;
let billing_address =
get_address_info(item.router_data.get_optional_billing()).and_then(Result::ok);
let mpi_data = if matches!(wallet_data, WalletData::Paze(_) | WalletData::ApplePay(_)) {
match item.router_data.payment_method_token.clone() {
Some(PaymentMethodToken::PazeDecrypt(paze_data)) => Some(AdyenMpiData {
directory_response: "Y".to_string(),
authentication_response: "Y".to_string(),
cavv: None,
token_authentication_verification_value: Some(
paze_data.token.payment_account_reference,
),
eci: paze_data.eci,
}),
Some(PaymentMethodToken::ApplePayDecrypt(apple_data)) => Some(AdyenMpiData {
directory_response: "Y".to_string(),
authentication_response: "Y".to_string(),
cavv: Some(apple_data.payment_data.online_payment_cryptogram),
token_authentication_verification_value: None,
eci: apple_data.payment_data.eci_indicator,
}),
_ => None,
}
} else {
None
};
let (store, splits) = match item.router_data.request.split_payments.as_ref() {
Some(common_types::payments::SplitPaymentsRequest::AdyenSplitPayment(
adyen_split_payment,
)) => get_adyen_split_request(adyen_split_payment, item.router_data.request.currency),
_ => (None, None),
};
let device_fingerprint = item
.router_data
.request
.metadata
.clone()
.and_then(get_device_fingerprint);
let delivery_address =
get_address_info(item.router_data.get_optional_shipping()).and_then(Result::ok);
let telephone_number = item.router_data.get_optional_billing_phone_number();
Ok(AdyenPaymentRequest {
amount,
merchant_account: auth_type.merchant_account,
payment_method,
reference: item.router_data.connector_request_reference_id.clone(),
return_url,
shopper_interaction,
recurring_processing_model,
browser_info,
additional_data,
mpi_data,
telephone_number,
shopper_name: None,
shopper_email,
shopper_locale: item.router_data.request.locale.clone(),
social_security_number: None,
billing_address,
delivery_address,
country_code: None,
line_items: None,
shopper_reference,
store_payment_method,
channel,
shopper_statement: item.router_data.request.statement_descriptor.clone(),
shopper_ip: item.router_data.request.get_ip_address_as_optional(),
merchant_order_reference: item.router_data.request.merchant_order_reference_id.clone(),
store,
splits,
device_fingerprint,
session_validity: None,
metadata: item.router_data.request.metadata.clone(),
})
}
}
impl
TryFrom<(
&AdyenRouterData<&PaymentsAuthorizeRouterData>,
&PayLaterData,
)> for AdyenPaymentRequest<'_>
{
type Error = Error;
fn try_from(
value: (
&AdyenRouterData<&PaymentsAuthorizeRouterData>,
&PayLaterData,
),
) -> Result<Self, Self::Error> {
let (item, paylater_data) = value;
let amount = get_amount_data(item);
let auth_type = AdyenAuthType::try_from(&item.router_data.connector_auth_type)?;
let browser_info = get_browser_info(item.router_data)?;
let additional_data = get_additional_data(item.router_data);
let country_code = get_country_code(item.router_data.get_optional_billing());
let shopper_interaction = AdyenShopperInteraction::from(item.router_data);
let shopper_reference = build_shopper_reference(item.router_data);
let (recurring_processing_model, store_payment_method, _) =
get_recurring_processing_model(item.router_data)?;
let return_url = item.router_data.request.get_router_return_url()?;
let shopper_name = get_shopper_name(item.router_data.get_optional_billing());
let shopper_email = item.router_data.get_optional_billing_email();
let billing_address =
get_address_info(item.router_data.get_optional_billing()).and_then(Result::ok);
let delivery_address =
get_address_info(item.router_data.get_optional_shipping()).and_then(Result::ok);
let line_items = Some(get_line_items(item));
let telephone_number = get_telephone_number(item.router_data);
let payment_method =
PaymentMethod::AdyenPaymentMethod(Box::new(AdyenPaymentMethod::try_from((
paylater_data,
&country_code,
&shopper_email,
&shopper_reference,
&shopper_name,
&telephone_number,
&billing_address,
&delivery_address,
))?));
let (store, splits) = match item.router_data.request.split_payments.as_ref() {
Some(common_types::payments::SplitPaymentsRequest::AdyenSplitPayment(
adyen_split_payment,
)) => get_adyen_split_request(adyen_split_payment, item.router_data.request.currency),
_ => (None, None),
};
let device_fingerprint = item
.router_data
.request
.metadata
.clone()
.and_then(get_device_fingerprint);
Ok(AdyenPaymentRequest {
amount,
merchant_account: auth_type.merchant_account,
payment_method,
reference: item.router_data.connector_request_reference_id.clone(),
return_url,
shopper_interaction,
recurring_processing_model,
browser_info,
additional_data,
telephone_number,
shopper_name,
shopper_email,
mpi_data: None,
shopper_locale: item.router_data.request.locale.clone(),
social_security_number: None,
billing_address,
delivery_address,
country_code,
line_items,
shopper_reference,
store_payment_method,
channel: None,
shopper_statement: item.router_data.request.statement_descriptor.clone(),
shopper_ip: item.router_data.request.get_ip_address_as_optional(),
merchant_order_reference: item.router_data.request.merchant_order_reference_id.clone(),
store,
splits,
device_fingerprint,
session_validity: None,
metadata: item.router_data.request.metadata.clone(),
})
}
}
impl
TryFrom<(
&AdyenRouterData<&PaymentsAuthorizeRouterData>,
&CardRedirectData,
)> for AdyenPaymentRequest<'_>
{
type Error = Error;
fn try_from(
value: (
&AdyenRouterData<&PaymentsAuthorizeRouterData>,
&CardRedirectData,
),
) -> Result<Self, Self::Error> {
let (item, card_redirect_data) = value;
let amount = get_amount_data(item);
let auth_type = AdyenAuthType::try_from(&item.router_data.connector_auth_type)?;
let payment_method = PaymentMethod::AdyenPaymentMethod(Box::new(
AdyenPaymentMethod::try_from(card_redirect_data)?,
));
let shopper_interaction = AdyenShopperInteraction::from(item.router_data);
let return_url = item.router_data.request.get_router_return_url()?;
let shopper_name = get_shopper_name(item.router_data.get_optional_billing());
let shopper_email = item.router_data.get_optional_billing_email();
let telephone_number = item
.router_data
.get_billing_phone()
.change_context(errors::ConnectorError::MissingRequiredField {
field_name: "billing.phone",
})?
.number
.to_owned();
let (store, splits) = match item.router_data.request.split_payments.as_ref() {
Some(common_types::payments::SplitPaymentsRequest::AdyenSplitPayment(
adyen_split_payment,
)) => get_adyen_split_request(adyen_split_payment, item.router_data.request.currency),
_ => (None, None),
};
let device_fingerprint = item
.router_data
.request
.metadata
.clone()
.and_then(get_device_fingerprint);
let billing_address =
get_address_info(item.router_data.get_optional_billing()).and_then(Result::ok);
let delivery_address =
get_address_info(item.router_data.get_optional_shipping()).and_then(Result::ok);
Ok(AdyenPaymentRequest {
amount,
merchant_account: auth_type.merchant_account,
payment_method,
reference: item.router_data.connector_request_reference_id.to_string(),
return_url,
shopper_interaction,
recurring_processing_model: None,
browser_info: None,
additional_data: None,
mpi_data: None,
telephone_number,
shopper_name,
shopper_email,
shopper_locale: item.router_data.request.locale.clone(),
billing_address,
delivery_address,
country_code: None,
line_items: None,
shopper_reference: None,
store_payment_method: None,
channel: None,
social_security_number: None,
shopper_statement: item.router_data.request.statement_descriptor.clone(),
shopper_ip: item.router_data.request.get_ip_address_as_optional(),
merchant_order_reference: item.router_data.request.merchant_order_reference_id.clone(),
store,
splits,
device_fingerprint,
session_validity: None,
metadata: item.router_data.request.metadata.clone(),
})
}
}
impl TryFrom<&PaymentsCancelRouterData> for AdyenCancelRequest {
type Error = Error;
fn try_from(item: &PaymentsCancelRouterData) -> Result<Self, Self::Error> {
let auth_type = AdyenAuthType::try_from(&item.connector_auth_type)?;
Ok(Self {
merchant_account: auth_type.merchant_account,
reference: item.connector_request_reference_id.clone(),
})
}
}
fn get_adyen_split_request(
split_request: &common_types::domain::AdyenSplitData,
currency: common_enums::enums::Currency,
) -> (Option<String>, Option<Vec<AdyenSplitData>>) {
let splits = split_request
.split_items
.iter()
.map(|split_item| {
let amount = split_item.amount.map(|value| Amount { currency, value });
AdyenSplitData {
amount,
reference: split_item.reference.clone(),
split_type: split_item.split_type.clone(),
account: split_item.account.clone(),
description: split_item.description.clone(),
}
})
.collect();
(split_request.store.clone(), Some(splits))
}
impl TryFrom<PaymentsCancelResponseRouterData<AdyenCancelResponse>> for PaymentsCancelRouterData {
type Error = Error;
fn try_from(
item: PaymentsCancelResponseRouterData<AdyenCancelResponse>,
) -> Result<Self, Self::Error> {
Ok(Self {
status: storage_enums::AttemptStatus::Pending,
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(
item.response.payment_psp_reference,
),
redirection_data: Box::new(None),
mandate_reference: Box::new(None),
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: Some(item.response.reference),
incremental_authorization_allowed: None,
charges: None,
}),
..item.data
})
}
}
impl<F>
TryFrom<
ResponseRouterData<
F,
AdyenBalanceResponse,
PaymentsPreProcessingData,
PaymentsResponseData,
>,
> for RouterData<F, PaymentsPreProcessingData, PaymentsResponseData>
{
type Error = Error;
fn try_from(
item: ResponseRouterData<
F,
AdyenBalanceResponse,
PaymentsPreProcessingData,
PaymentsResponseData,
>,
) -> Result<Self, Self::Error> {
Ok(Self {
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(item.response.psp_reference),
redirection_data: Box::new(None),
mandate_reference: Box::new(None),
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: None,
incremental_authorization_allowed: None,
charges: None,
}),
payment_method_balance: Some(PaymentMethodBalance {
currency: item.response.balance.currency,
amount: item.response.balance.value,
}),
..item.data
})
}
}
impl
TryFrom<
ResponseRouterData<
GiftCardBalanceCheck,
AdyenBalanceResponse,
GiftCardBalanceCheckRequestData,
GiftCardBalanceCheckResponseData,
>,
>
for RouterData<
GiftCardBalanceCheck,
GiftCardBalanceCheckRequestData,
GiftCardBalanceCheckResponseData,
>
{
type Error = Error;
fn try_from(
item: ResponseRouterData<
GiftCardBalanceCheck,
AdyenBalanceResponse,
GiftCardBalanceCheckRequestData,
GiftCardBalanceCheckResponseData,
>,
) -> Result<Self, Self::Error> {
Ok(Self {
response: Ok(GiftCardBalanceCheckResponseData {
balance: item.response.balance.value,
currency: item.response.balance.currency,
}),
..item.data
})
}
}
fn build_connector_response(status: &AdyenWebhookStatus) -> Option<ConnectorResponseData> {
let extended_authentication_applied = match status {
AdyenWebhookStatus::AdjustedAuthorization => {
Some(common_types::primitive_wrappers::ExtendedAuthorizationAppliedBool::from(true))
}
AdyenWebhookStatus::AdjustAuthorizationFailed => {
Some(common_types::primitive_wrappers::ExtendedAuthorizationAppliedBool::from(false))
}
_ => None,
};
let extend_authorization_response = ExtendedAuthorizationResponseData {
extended_authentication_applied,
capture_before: None,
};
Some(ConnectorResponseData::new(
None,
None,
Some(extend_authorization_response),
))
}
pub fn get_adyen_response(
response: AdyenResponse,
is_capture_manual: bool,
status_code: u16,
pmt: Option<storage_enums::PaymentMethodType>,
) -> CustomResult<AdyenPaymentsResponseData, errors::ConnectorError> {
let status = get_adyen_payment_status(is_capture_manual, response.result_code, pmt);
let error = if response.refusal_reason.is_some()
|| response.refusal_reason_code.is_some()
|| status == storage_enums::AttemptStatus::Failure
{
let (network_decline_code, network_error_message) = response
.additional_data
.as_ref()
.map(|data| {
match (
data.refusal_code_raw.clone(),
data.refusal_reason_raw
.clone()
.or(data.merchant_advice_code.clone()),
) {
(None, Some(reason_raw)) => match reason_raw.split_once(':') {
Some((code, msg)) => {
(Some(code.trim().to_string()), Some(msg.trim().to_string()))
}
None => (None, Some(reason_raw.trim().to_string())),
},
(code, reason) => (code, reason),
}
})
.unwrap_or((None, None));
Some(ErrorResponse {
code: response
.refusal_reason_code
.unwrap_or_else(|| NO_ERROR_CODE.to_string()),
message: response
.refusal_reason
.clone()
.unwrap_or_else(|| NO_ERROR_MESSAGE.to_string()),
reason: response.refusal_reason,
status_code,
attempt_status: None,
connector_transaction_id: Some(response.psp_reference.clone()),
network_advice_code: response
.additional_data
.as_ref()
.and_then(|data| data.extract_network_advice_code()),
network_decline_code,
network_error_message,
connector_metadata: None,
})
} else {
None
};
let mandate_reference = response
.additional_data
.as_ref()
.and_then(|data| data.recurring_detail_reference.to_owned())
.map(|mandate_id| MandateReference {
connector_mandate_id: Some(mandate_id.expose()),
payment_method_id: None,
mandate_metadata: None,
connector_mandate_request_reference_id: None,
});
let network_txn_id = response.additional_data.and_then(|additional_data| {
additional_data
.network_tx_reference
.map(|network_tx_id| network_tx_id.expose())
});
let charges = match &response.splits {
Some(split_items) => Some(construct_charge_response(response.store, split_items)),
None => None,
};
let payments_response_data = PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(response.psp_reference),
redirection_data: Box::new(None),
mandate_reference: Box::new(mandate_reference),
connector_metadata: None,
network_txn_id,
connector_response_reference_id: Some(response.merchant_reference),
incremental_authorization_allowed: None,
charges,
};
let txn_amount = response.amount.map(|amount| amount.value);
Ok(AdyenPaymentsResponseData {
status,
error,
payments_response_data,
txn_amount,
connector_response: None,
})
}
pub struct AdyenPaymentsResponseData {
pub status: storage_enums::AttemptStatus,
pub error: Option<ErrorResponse>,
pub payments_response_data: PaymentsResponseData,
pub txn_amount: Option<MinorUnit>,
pub connector_response: Option<ConnectorResponseData>,
}
pub fn get_webhook_response(
response: AdyenWebhookResponse,
is_capture_manual: bool,
is_multiple_capture_psync_flow: bool,
status_code: u16,
) -> CustomResult<AdyenPaymentsResponseData, errors::ConnectorError> {
let status = storage_enums::AttemptStatus::foreign_try_from((
is_capture_manual,
response.status.clone(),
))?;
let error = if response.refusal_reason.is_some()
|| response.refusal_reason_code.is_some()
|| status == storage_enums::AttemptStatus::Failure
{
let (network_decline_code, network_error_message) = match (
response.refusal_code_raw.clone(),
response.refusal_reason_raw.clone(),
) {
(None, Some(reason_raw)) => match reason_raw.split_once(':') {
Some((code, msg)) => (Some(code.trim().to_string()), Some(msg.trim().to_string())),
None => (None, Some(reason_raw.trim().to_string())),
},
(code, reason) => (code, reason),
};
Some(ErrorResponse {
code: response
.refusal_reason_code
.clone()
.unwrap_or_else(|| NO_ERROR_CODE.to_string()),
message: response
.refusal_reason
.clone()
.unwrap_or_else(|| NO_ERROR_MESSAGE.to_string()),
reason: response.refusal_reason.clone(),
status_code,
attempt_status: None,
connector_transaction_id: Some(response.transaction_id.clone()),
network_advice_code: None,
network_decline_code,
network_error_message,
connector_metadata: None,
})
} else {
None
};
let txn_amount = response.amount.as_ref().map(|amount| amount.value);
let connector_response = build_connector_response(&response.status);
if is_multiple_capture_psync_flow {
let capture_sync_response_list =
utils::construct_captures_response_hashmap(vec![response.clone()])?;
Ok(AdyenPaymentsResponseData {
status,
error,
payments_response_data: PaymentsResponseData::MultipleCaptureResponse {
capture_sync_response_list,
},
txn_amount,
connector_response,
})
} else {
let mandate_reference = response
.recurring_detail_reference
.as_ref()
.map(|mandate_id| MandateReference {
connector_mandate_id: Some(mandate_id.clone().expose()),
payment_method_id: response.recurring_shopper_reference.clone(),
mandate_metadata: None,
connector_mandate_request_reference_id: None,
});
let payments_response_data = PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(
response
.payment_reference
.unwrap_or(response.transaction_id),
),
redirection_data: Box::new(None),
mandate_reference: Box::new(mandate_reference),
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: Some(response.merchant_reference_id),
incremental_authorization_allowed: None,
charges: None,
};
Ok(AdyenPaymentsResponseData {
status,
error,
payments_response_data,
txn_amount,
connector_response,
})
}
}
pub fn get_redirection_response(
response: RedirectionResponse,
is_manual_capture: bool,
status_code: u16,
pmt: Option<storage_enums::PaymentMethodType>,
) -> CustomResult<AdyenPaymentsResponseData, errors::ConnectorError> {
let status = get_adyen_payment_status(is_manual_capture, response.result_code.clone(), pmt);
let error = if response.refusal_reason.is_some()
|| response.refusal_reason_code.is_some()
|| status == storage_enums::AttemptStatus::Failure
{
let (network_decline_code, network_error_message) = response
.additional_data
.as_ref()
.map(|data| {
match (
data.refusal_code_raw.clone(),
data.refusal_reason_raw.clone(),
) {
(None, Some(reason_raw)) => match reason_raw.split_once(':') {
Some((code, msg)) => {
(Some(code.trim().to_string()), Some(msg.trim().to_string()))
}
None => (None, Some(reason_raw.trim().to_string())),
},
(code, reason) => (code, reason),
}
})
.unwrap_or((None, None));
Some(ErrorResponse {
code: response
.refusal_reason_code
.clone()
.unwrap_or_else(|| NO_ERROR_CODE.to_string()),
message: response
.refusal_reason
.clone()
.unwrap_or_else(|| NO_ERROR_MESSAGE.to_string()),
reason: response.refusal_reason.to_owned(),
status_code,
attempt_status: None,
connector_transaction_id: response.psp_reference.clone(),
network_advice_code: None,
network_decline_code,
network_error_message,
connector_metadata: None,
})
} else {
None
};
let redirection_data = response.action.url.clone().map(|url| {
let form_fields = response.action.data.clone().unwrap_or_else(|| {
std::collections::HashMap::from_iter(
url.query_pairs()
.map(|(key, value)| (key.to_string(), value.to_string())),
)
});
RedirectForm::Form {
endpoint: url.to_string(),
method: response.action.method.unwrap_or(Method::Get),
form_fields,
}
});
let connector_metadata = get_wait_screen_metadata(&response)?;
let charges = match &response.splits {
Some(split_items) => Some(construct_charge_response(response.store, split_items)),
None => None,
};
let payments_response_data = PaymentsResponseData::TransactionResponse {
resource_id: match response.psp_reference.as_ref() {
Some(psp) => ResponseId::ConnectorTransactionId(psp.to_string()),
None => ResponseId::NoResponseId,
},
redirection_data: Box::new(redirection_data),
mandate_reference: Box::new(None),
connector_metadata,
network_txn_id: None,
connector_response_reference_id: response
.merchant_reference
.clone()
.or(response.psp_reference),
incremental_authorization_allowed: None,
charges,
};
let txn_amount = response.amount.map(|amount| amount.value);
Ok(AdyenPaymentsResponseData {
status,
error,
payments_response_data,
txn_amount,
connector_response: None,
})
}
pub fn get_present_to_shopper_response(
response: PresentToShopperResponse,
is_manual_capture: bool,
status_code: u16,
pmt: Option<storage_enums::PaymentMethodType>,
) -> CustomResult<AdyenPaymentsResponseData, errors::ConnectorError> {
let status = get_adyen_payment_status(is_manual_capture, response.result_code.clone(), pmt);
let error = if response.refusal_reason.is_some()
|| response.refusal_reason_code.is_some()
|| status == storage_enums::AttemptStatus::Failure
{
Some(ErrorResponse {
code: response
.refusal_reason_code
.clone()
.unwrap_or_else(|| NO_ERROR_CODE.to_string()),
message: response
.refusal_reason
.clone()
.unwrap_or_else(|| NO_ERROR_MESSAGE.to_string()),
reason: response.refusal_reason.to_owned(),
status_code,
attempt_status: None,
connector_transaction_id: response.psp_reference.clone(),
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
connector_metadata: None,
})
} else {
None
};
let charges = match &response.splits {
Some(split_items) => Some(construct_charge_response(
response.store.clone(),
split_items,
)),
None => None,
};
let connector_metadata = get_present_to_shopper_metadata(&response)?;
// We don't get connector transaction id for redirections in Adyen.
let payments_response_data = PaymentsResponseData::TransactionResponse {
resource_id: match response.psp_reference.as_ref() {
Some(psp) => ResponseId::ConnectorTransactionId(psp.to_string()),
None => ResponseId::NoResponseId,
},
redirection_data: Box::new(None),
mandate_reference: Box::new(None),
connector_metadata,
network_txn_id: None,
connector_response_reference_id: response
.merchant_reference
.clone()
.or(response.psp_reference),
incremental_authorization_allowed: None,
charges,
};
let txn_amount = response.amount.map(|amount| amount.value);
Ok(AdyenPaymentsResponseData {
status,
error,
payments_response_data,
txn_amount,
connector_response: None,
})
}
pub fn get_qr_code_response(
response: QrCodeResponseResponse,
is_manual_capture: bool,
status_code: u16,
pmt: Option<storage_enums::PaymentMethodType>,
) -> CustomResult<AdyenPaymentsResponseData, errors::ConnectorError> {
let status = get_adyen_payment_status(is_manual_capture, response.result_code.clone(), pmt);
let error = if response.refusal_reason.is_some()
|| response.refusal_reason_code.is_some()
|| status == storage_enums::AttemptStatus::Failure
{
Some(ErrorResponse {
code: response
.refusal_reason_code
.clone()
.unwrap_or_else(|| NO_ERROR_CODE.to_string()),
message: response
.refusal_reason
.clone()
.unwrap_or_else(|| NO_ERROR_MESSAGE.to_string()),
reason: response.refusal_reason.to_owned(),
status_code,
attempt_status: None,
connector_transaction_id: response.psp_reference.clone(),
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
connector_metadata: None,
})
} else {
None
};
let charges = match &response.splits {
Some(split_items) => Some(construct_charge_response(
response.store.clone(),
split_items,
)),
None => None,
};
let connector_metadata = get_qr_metadata(&response)?;
let payments_response_data = PaymentsResponseData::TransactionResponse {
resource_id: match response.psp_reference.as_ref() {
Some(psp) => ResponseId::ConnectorTransactionId(psp.to_string()),
None => ResponseId::NoResponseId,
},
redirection_data: Box::new(None),
mandate_reference: Box::new(None),
connector_metadata,
network_txn_id: None,
connector_response_reference_id: response
.merchant_reference
.clone()
.or(response.psp_reference),
incremental_authorization_allowed: None,
charges,
};
let txn_amount = response.amount.map(|amount| amount.value);
Ok(AdyenPaymentsResponseData {
status,
error,
payments_response_data,
txn_amount,
connector_response: None,
})
}
pub fn get_redirection_error_response(
response: RedirectionErrorResponse,
is_manual_capture: bool,
status_code: u16,
pmt: Option<storage_enums::PaymentMethodType>,
) -> CustomResult<AdyenPaymentsResponseData, errors::ConnectorError> {
let status = get_adyen_payment_status(is_manual_capture, response.result_code, pmt);
let error = {
let (network_decline_code, network_error_message) = response
.additional_data
.as_ref()
.map(|data| {
match (
data.refusal_code_raw.clone(),
data.refusal_reason_raw.clone(),
) {
(None, Some(reason_raw)) => match reason_raw.split_once(':') {
Some((code, msg)) => {
(Some(code.trim().to_string()), Some(msg.trim().to_string()))
}
None => (None, Some(reason_raw.trim().to_string())),
},
(code, reason) => (code, reason),
}
})
.unwrap_or((None, None));
Some(ErrorResponse {
code: status.to_string(),
message: response
.refusal_reason
.clone()
.unwrap_or_else(|| NO_ERROR_MESSAGE.to_string()),
reason: response.refusal_reason,
status_code,
attempt_status: None,
connector_transaction_id: response.psp_reference.clone(),
network_advice_code: response
.additional_data
.as_ref()
.and_then(|data| data.extract_network_advice_code()),
network_decline_code,
network_error_message,
connector_metadata: None,
})
};
// We don't get connector transaction id for redirections in Adyen.
let payments_response_data = PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::NoResponseId,
redirection_data: Box::new(None),
mandate_reference: Box::new(None),
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: response
.merchant_reference
.clone()
.or(response.psp_reference),
incremental_authorization_allowed: None,
charges: None,
};
Ok(AdyenPaymentsResponseData {
status,
error,
payments_response_data,
txn_amount: None,
connector_response: None,
})
}
pub fn get_qr_metadata(
response: &QrCodeResponseResponse,
) -> CustomResult<Option<serde_json::Value>, errors::ConnectorError> {
let image_data = utils::QrImage::new_from_data(response.action.qr_code_data.clone())
.change_context(errors::ConnectorError::ResponseHandlingFailed)?;
let image_data_url = Url::parse(image_data.data.clone().as_str()).ok();
let qr_code_url = response.action.qr_code_url.clone();
let display_to_timestamp = response
.additional_data
.clone()
.and_then(|additional_data| additional_data.pix_expiration_date)
.map(|time| utils::get_timestamp_in_milliseconds(&time));
if let (Some(image_data_url), Some(qr_code_url)) = (image_data_url.clone(), qr_code_url.clone())
{
let qr_code_info = QrCodeInformation::QrCodeUrl {
image_data_url,
qr_code_url,
display_to_timestamp,
};
Some(qr_code_info.encode_to_value())
.transpose()
.change_context(errors::ConnectorError::ResponseHandlingFailed)
} else if let (None, Some(qr_code_url)) = (image_data_url.clone(), qr_code_url.clone()) {
let qr_code_info = QrCodeInformation::QrCodeImageUrl {
qr_code_url,
display_to_timestamp,
};
Some(qr_code_info.encode_to_value())
.transpose()
.change_context(errors::ConnectorError::ResponseHandlingFailed)
} else if let (Some(image_data_url), None) = (image_data_url, qr_code_url) {
let qr_code_info = QrCodeInformation::QrDataUrl {
image_data_url,
display_to_timestamp,
};
Some(qr_code_info.encode_to_value())
.transpose()
.change_context(errors::ConnectorError::ResponseHandlingFailed)
} else {
Ok(None)
}
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct WaitScreenData {
display_from_timestamp: i128,
display_to_timestamp: Option<i128>,
poll_config: Option<PollConfig>,
}
pub fn get_wait_screen_metadata(
next_action: &RedirectionResponse,
) -> CustomResult<Option<serde_json::Value>, errors::ConnectorError> {
match next_action.action.payment_method_type {
PaymentType::Blik => {
let current_time = OffsetDateTime::now_utc().unix_timestamp_nanos();
Ok(Some(serde_json::json!(WaitScreenData {
display_from_timestamp: current_time,
display_to_timestamp: Some(current_time + Duration::minutes(1).whole_nanoseconds()),
poll_config: None
})))
}
PaymentType::Mbway => {
let current_time = OffsetDateTime::now_utc().unix_timestamp_nanos();
Ok(Some(serde_json::json!(WaitScreenData {
display_from_timestamp: current_time,
display_to_timestamp: None,
poll_config: None
})))
}
PaymentType::Affirm
| PaymentType::Oxxo
| PaymentType::Afterpaytouch
| PaymentType::Alipay
| PaymentType::AlipayHk
| PaymentType::Alfamart
| PaymentType::Alma
| PaymentType::Applepay
| PaymentType::Bizum
| PaymentType::Atome
| PaymentType::BoletoBancario
| PaymentType::ClearPay
| PaymentType::Dana
| PaymentType::Eps
| PaymentType::Gcash
| PaymentType::Googlepay
| PaymentType::GoPay
| PaymentType::Ideal
| PaymentType::Indomaret
| PaymentType::Klarna
| PaymentType::Kakaopay
| PaymentType::MobilePay
| PaymentType::Momo
| PaymentType::MomoAtm
| PaymentType::OnlineBankingCzechRepublic
| PaymentType::OnlineBankingFinland
| PaymentType::OnlineBankingPoland
| PaymentType::OnlineBankingSlovakia
| PaymentType::OnlineBankingFpx
| PaymentType::OnlineBankingThailand
| PaymentType::OpenBankingUK
| PaymentType::PayBright
| PaymentType::Paypal
| PaymentType::Scheme
| PaymentType::NetworkToken
| PaymentType::Trustly
| PaymentType::TouchNGo
| PaymentType::Walley
| PaymentType::WeChatPayWeb
| PaymentType::AchDirectDebit
| PaymentType::SepaDirectDebit
| PaymentType::BacsDirectDebit
| PaymentType::Samsungpay
| PaymentType::Twint
| PaymentType::Vipps
| PaymentType::Swish
| PaymentType::Knet
| PaymentType::Benefit
| PaymentType::PermataBankTransfer
| PaymentType::BcaBankTransfer
| PaymentType::BniVa
| PaymentType::BriVa
| PaymentType::CimbVa
| PaymentType::DanamonVa
| PaymentType::Giftcard
| PaymentType::MandiriVa
| PaymentType::PaySafeCard
| PaymentType::SevenEleven
| PaymentType::JapaneseConvenienceStores
| PaymentType::Pix => Ok(None),
}
}
pub fn get_present_to_shopper_metadata(
response: &PresentToShopperResponse,
) -> CustomResult<Option<serde_json::Value>, errors::ConnectorError> {
let reference = response.action.reference.clone();
let expires_at = response
.action
.expires_at
.map(|time| utils::get_timestamp_in_milliseconds(&time));
match response.action.payment_method_type {
PaymentType::Alfamart
| PaymentType::Indomaret
| PaymentType::BoletoBancario
| PaymentType::Oxxo
| PaymentType::JapaneseConvenienceStores => {
let voucher_data = VoucherNextStepData {
expires_at,
reference,
download_url: response.action.download_url.clone(),
instructions_url: response.action.instructions_url.clone(),
entry_date: None,
digitable_line: None,
};
Some(voucher_data.encode_to_value())
.transpose()
.change_context(errors::ConnectorError::ResponseHandlingFailed)
}
PaymentType::PermataBankTransfer
| PaymentType::BcaBankTransfer
| PaymentType::BniVa
| PaymentType::BriVa
| PaymentType::CimbVa
| PaymentType::DanamonVa
| PaymentType::Giftcard
| PaymentType::MandiriVa => {
let voucher_data = payments::BankTransferInstructions::DokuBankTransferInstructions(
Box::new(payments::DokuBankTransferInstructions {
reference: Secret::new(response.action.reference.clone()),
instructions_url: response.action.instructions_url.clone(),
expires_at,
}),
);
Some(voucher_data.encode_to_value())
.transpose()
.change_context(errors::ConnectorError::ResponseHandlingFailed)
}
PaymentType::Affirm
| PaymentType::Afterpaytouch
| PaymentType::Alipay
| PaymentType::AlipayHk
| PaymentType::Alma
| PaymentType::Applepay
| PaymentType::Bizum
| PaymentType::Atome
| PaymentType::Blik
| PaymentType::ClearPay
| PaymentType::Dana
| PaymentType::Eps
| PaymentType::Gcash
| PaymentType::Googlepay
| PaymentType::GoPay
| PaymentType::Ideal
| PaymentType::Klarna
| PaymentType::Kakaopay
| PaymentType::Mbway
| PaymentType::Knet
| PaymentType::Benefit
| PaymentType::MobilePay
| PaymentType::Momo
| PaymentType::MomoAtm
| PaymentType::OnlineBankingCzechRepublic
| PaymentType::OnlineBankingFinland
| PaymentType::OnlineBankingPoland
| PaymentType::OnlineBankingSlovakia
| PaymentType::OnlineBankingFpx
| PaymentType::OnlineBankingThailand
| PaymentType::OpenBankingUK
| PaymentType::PayBright
| PaymentType::Paypal
| PaymentType::Scheme
| PaymentType::NetworkToken
| PaymentType::Trustly
| PaymentType::TouchNGo
| PaymentType::Walley
| PaymentType::WeChatPayWeb
| PaymentType::AchDirectDebit
| PaymentType::SepaDirectDebit
| PaymentType::BacsDirectDebit
| PaymentType::Samsungpay
| PaymentType::Twint
| PaymentType::Vipps
| PaymentType::Swish
| PaymentType::PaySafeCard
| PaymentType::SevenEleven
| PaymentType::Pix => Ok(None),
}
}
impl<F, Req>
ForeignTryFrom<(
ResponseRouterData<F, AdyenPaymentResponse, Req, PaymentsResponseData>,
Option<storage_enums::CaptureMethod>,
bool,
Option<storage_enums::PaymentMethodType>,
)> for RouterData<F, Req, PaymentsResponseData>
{
type Error = Error;
fn foreign_try_from(
(item, capture_method, is_multiple_capture_psync_flow, pmt): (
ResponseRouterData<F, AdyenPaymentResponse, Req, PaymentsResponseData>,
Option<storage_enums::CaptureMethod>,
bool,
Option<storage_enums::PaymentMethodType>,
),
) -> Result<Self, Self::Error> {
let is_manual_capture = is_manual_capture(capture_method);
let adyen_payments_response_data = match item.response {
AdyenPaymentResponse::Response(response) => {
get_adyen_response(*response, is_manual_capture, item.http_code, pmt)?
}
AdyenPaymentResponse::PresentToShopper(response) => {
get_present_to_shopper_response(*response, is_manual_capture, item.http_code, pmt)?
}
AdyenPaymentResponse::QrCodeResponse(response) => {
get_qr_code_response(*response, is_manual_capture, item.http_code, pmt)?
}
AdyenPaymentResponse::RedirectionResponse(response) => {
get_redirection_response(*response, is_manual_capture, item.http_code, pmt)?
}
AdyenPaymentResponse::RedirectionErrorResponse(response) => {
get_redirection_error_response(*response, is_manual_capture, item.http_code, pmt)?
}
AdyenPaymentResponse::WebhookResponse(response) => get_webhook_response(
*response,
is_manual_capture,
is_multiple_capture_psync_flow,
item.http_code,
)?,
};
let minor_amount_captured = match adyen_payments_response_data.status {
enums::AttemptStatus::Charged
| enums::AttemptStatus::PartialCharged
| enums::AttemptStatus::PartialChargedAndChargeable => {
adyen_payments_response_data.txn_amount
}
_ => None,
};
Ok(Self {
status: adyen_payments_response_data.status,
amount_captured: minor_amount_captured.map(|amount| amount.get_amount_as_i64()),
response: adyen_payments_response_data.error.map_or_else(
|| Ok(adyen_payments_response_data.payments_response_data),
Err,
),
connector_response: adyen_payments_response_data.connector_response,
minor_amount_captured,
..item.data
})
}
}
#[derive(Default, Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct AdyenCaptureRequest {
merchant_account: Secret<String>,
amount: Amount,
reference: String,
}
#[derive(Default, Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct AdyenExtendAuthorizationRequest {
merchant_account: Secret<String>,
amount: Amount,
}
impl TryFrom<&AdyenRouterData<&PaymentsExtendAuthorizationRouterData>>
for AdyenExtendAuthorizationRequest
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: &AdyenRouterData<&PaymentsExtendAuthorizationRouterData>,
) -> Result<Self, Self::Error> {
let auth_type = AdyenAuthType::try_from(&item.router_data.connector_auth_type)?;
let amount = Amount {
currency: item.router_data.request.currency,
value: item.amount,
};
Ok(Self {
merchant_account: auth_type.merchant_account,
amount,
})
}
}
#[derive(Default, Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct AdyenExtendAuthorizationResponse {
merchant_account: Secret<String>,
payment_psp_reference: Option<String>,
psp_reference: Option<String>,
amount: Amount,
}
impl<F>
TryFrom<
ResponseRouterData<
F,
AdyenExtendAuthorizationResponse,
PaymentsExtendAuthorizationData,
PaymentsResponseData,
>,
> for RouterData<F, PaymentsExtendAuthorizationData, PaymentsResponseData>
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: ResponseRouterData<
F,
AdyenExtendAuthorizationResponse,
PaymentsExtendAuthorizationData,
PaymentsResponseData,
>,
) -> Result<Self, Self::Error> {
// Asynchronous authorization adjustment
Ok(Self { ..item.data })
}
}
impl TryFrom<&AdyenRouterData<&PaymentsCaptureRouterData>> for AdyenCaptureRequest {
type Error = Error;
fn try_from(item: &AdyenRouterData<&PaymentsCaptureRouterData>) -> Result<Self, Self::Error> {
let auth_type = AdyenAuthType::try_from(&item.router_data.connector_auth_type)?;
let reference = match item.router_data.request.multiple_capture_data.clone() {
// if multiple capture request, send capture_id as our reference for the capture
Some(multiple_capture_request_data) => multiple_capture_request_data.capture_reference,
// if single capture request, send connector_request_reference_id(attempt_id)
None => item.router_data.connector_request_reference_id.clone(),
};
Ok(Self {
merchant_account: auth_type.merchant_account,
reference,
amount: Amount {
currency: item.router_data.request.currency,
value: item.amount.to_owned(),
},
})
}
}
#[derive(Default, Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct AdyenCaptureResponse {
merchant_account: Secret<String>,
payment_psp_reference: String,
psp_reference: String,
reference: String,
status: String,
amount: Amount,
merchant_reference: Option<String>,
store: Option<String>,
splits: Option<Vec<AdyenSplitData>>,
}
impl TryFrom<PaymentsCaptureResponseRouterData<AdyenCaptureResponse>>
for PaymentsCaptureRouterData
{
type Error = Error;
fn try_from(
item: PaymentsCaptureResponseRouterData<AdyenCaptureResponse>,
) -> Result<Self, Self::Error> {
let connector_transaction_id = if item.data.request.multiple_capture_data.is_some() {
item.response.psp_reference.clone()
} else {
item.response.payment_psp_reference
};
let charges = match &item.response.splits {
Some(split_items) => Some(construct_charge_response(item.response.store, split_items)),
None => None,
};
Ok(Self {
// From the docs, the only value returned is "received", outcome of refund is available
// through refund notification webhook
// For more info: https://docs.adyen.com/online-payments/capture
status: storage_enums::AttemptStatus::Pending,
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(connector_transaction_id),
redirection_data: Box::new(None),
mandate_reference: Box::new(None),
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: Some(item.response.reference),
incremental_authorization_allowed: None,
charges,
}),
amount_captured: Some(0),
..item.data
})
}
}
fn construct_charge_response(
store: Option<String>,
split_item: &[AdyenSplitData],
) -> common_types::payments::ConnectorChargeResponseData {
let splits: Vec<common_types::domain::AdyenSplitItem> = split_item
.iter()
.map(|split_item| common_types::domain::AdyenSplitItem {
amount: split_item.amount.as_ref().map(|amount| amount.value),
reference: split_item.reference.clone(),
split_type: split_item.split_type.clone(),
account: split_item.account.clone(),
description: split_item.description.clone(),
})
.collect();
common_types::payments::ConnectorChargeResponseData::AdyenSplitPayment(
common_types::domain::AdyenSplitData {
store,
split_items: splits,
},
)
}
// Refund Request Transform
impl<F> TryFrom<&AdyenRouterData<&RefundsRouterData<F>>> for AdyenRefundRequest {
type Error = Error;
fn try_from(item: &AdyenRouterData<&RefundsRouterData<F>>) -> Result<Self, Self::Error> {
let auth_type = AdyenAuthType::try_from(&item.router_data.connector_auth_type)?;
let (store, splits) = match item
.router_data
.request
.split_refunds
.as_ref()
{
Some(hyperswitch_domain_models::router_request_types::SplitRefundsRequest::AdyenSplitRefund(adyen_split_data)) => get_adyen_split_request(adyen_split_data, item.router_data.request.currency),
_ => (None, None),
};
Ok(Self {
merchant_account: auth_type.merchant_account,
amount: Amount {
currency: item.router_data.request.currency,
value: item.amount,
},
merchant_refund_reason: item
.router_data
.request
.reason
.as_ref()
.map(|reason| AdyenRefundRequestReason::from_str(reason))
.transpose()?,
reference: item.router_data.request.refund_id.clone(),
store,
splits,
})
}
}
// Refund Response Transform
impl<F> TryFrom<RefundsResponseRouterData<F, AdyenRefundResponse>> for RefundsRouterData<F> {
type Error = Error;
fn try_from(
item: RefundsResponseRouterData<F, AdyenRefundResponse>,
) -> Result<Self, Self::Error> {
Ok(Self {
response: Ok(RefundsResponseData {
connector_refund_id: item.response.psp_reference,
// From the docs, the only value returned is "received", outcome of refund is available
// through refund notification webhook
// For more info: https://docs.adyen.com/online-payments/refund
refund_status: storage_enums::RefundStatus::Pending,
}),
..item.data
})
}
}
#[derive(Debug, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct AdyenErrorResponse {
pub status: i32,
pub error_code: String,
pub message: String,
pub error_type: String,
pub psp_reference: Option<String>,
}
// #[cfg(test)]
// mod test_adyen_transformers {
// use super::*;
// #[test]
// fn verify_transform_from_router_to_adyen_req() {
// let router_req = PaymentsRequest {
// amount: 0.0,
// currency: "None".to_string(),
// ..Default::default()
// };
// println!("{:#?}", &router_req);
// let adyen_req = AdyenPaymentRequest::from(router_req);
// println!("{:#?}", &adyen_req);
// let adyen_req_json: String = serde_json::to_string(&adyen_req).unwrap();
// println!("{}", adyen_req_json);
// assert_eq!(true, true)
// }
// }
#[derive(Debug, Deserialize)]
pub enum DisputeStatus {
Undefended,
Pending,
Lost,
Accepted,
Won,
}
#[derive(Debug, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct AdyenAdditionalDataWH {
pub hmac_signature: Secret<String>,
pub dispute_status: Option<DisputeStatus>,
pub chargeback_reason_code: Option<String>,
#[serde(default, with = "common_utils::custom_serde::iso8601::option")]
pub defense_period_ends_at: Option<PrimitiveDateTime>,
/// Enable recurring details in dashboard to receive this ID, https://docs.adyen.com/online-payments/tokenization/create-and-use-tokens#test-and-go-live
#[serde(rename = "recurring.recurringDetailReference")]
pub recurring_detail_reference: Option<Secret<String>>,
#[serde(rename = "recurring.shopperReference")]
pub recurring_shopper_reference: Option<String>,
pub network_tx_reference: Option<Secret<String>>,
/// [only for cards] Enable raw acquirer from Adyen dashboard to receive this (https://docs.adyen.com/development-resources/raw-acquirer-responses/#search-modal)
pub refusal_reason_raw: Option<String>,
/// [only for cards] This is only available for Visa and Mastercard
pub refusal_code_raw: Option<String>,
#[serde(rename = "shopperEmail")]
pub shopper_email: Option<String>,
#[serde(rename = "shopperReference")]
pub shopper_reference: Option<String>,
}
#[derive(Debug, Deserialize)]
pub struct AdyenAmountWH {
pub value: MinorUnit,
pub currency: storage_enums::Currency,
}
#[derive(Clone, Debug, Deserialize, Serialize, strum::Display, PartialEq)]
#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
#[strum(serialize_all = "SCREAMING_SNAKE_CASE")]
pub enum WebhookEventCode {
Authorisation,
AuthorisationAdjustment,
Refund,
CancelOrRefund,
Cancellation,
Capture,
CaptureFailed,
RefundFailed,
RefundReversed,
NotificationOfChargeback,
Chargeback,
ChargebackReversed,
SecondChargeback,
PrearbitrationWon,
PrearbitrationLost,
OfferClosed,
RecurringContract,
#[cfg(feature = "payouts")]
PayoutThirdparty,
#[cfg(feature = "payouts")]
PayoutDecline,
#[cfg(feature = "payouts")]
PayoutExpire,
#[cfg(feature = "payouts")]
PayoutReversed,
#[serde(other)]
Unknown,
}
pub fn is_transaction_event(event_code: &WebhookEventCode) -> bool {
matches!(
event_code,
WebhookEventCode::Authorisation
| WebhookEventCode::OfferClosed
| WebhookEventCode::RecurringContract
)
}
pub fn is_capture_or_cancel_or_adjust_event(event_code: &WebhookEventCode) -> bool {
matches!(
event_code,
WebhookEventCode::AuthorisationAdjustment
| WebhookEventCode::Capture
| WebhookEventCode::CaptureFailed
| WebhookEventCode::Cancellation
)
}
pub fn is_refund_event(event_code: &WebhookEventCode) -> bool {
matches!(
event_code,
WebhookEventCode::Refund
| WebhookEventCode::CancelOrRefund
| WebhookEventCode::RefundFailed
| WebhookEventCode::RefundReversed
)
}
pub fn is_chargeback_event(event_code: &WebhookEventCode) -> bool {
matches!(
event_code,
WebhookEventCode::NotificationOfChargeback
| WebhookEventCode::Chargeback
| WebhookEventCode::ChargebackReversed
| WebhookEventCode::SecondChargeback
| WebhookEventCode::PrearbitrationWon
| WebhookEventCode::PrearbitrationLost
)
}
#[cfg(feature = "payouts")]
pub fn is_payout_event(event_code: &WebhookEventCode) -> bool {
matches!(
event_code,
WebhookEventCode::PayoutThirdparty
| WebhookEventCode::PayoutDecline
| WebhookEventCode::PayoutExpire
| WebhookEventCode::PayoutReversed
)
}
fn is_success_scenario(is_success: String) -> bool {
is_success.as_str() == "true"
}
pub(crate) fn get_adyen_webhook_event(
code: WebhookEventCode,
is_success: String,
dispute_status: Option<DisputeStatus>,
) -> api_models::webhooks::IncomingWebhookEvent {
match code {
WebhookEventCode::Authorisation => {
if is_success_scenario(is_success) {
api_models::webhooks::IncomingWebhookEvent::PaymentIntentSuccess
} else {
api_models::webhooks::IncomingWebhookEvent::PaymentIntentFailure
}
}
WebhookEventCode::Refund | WebhookEventCode::CancelOrRefund => {
if is_success_scenario(is_success) {
api_models::webhooks::IncomingWebhookEvent::RefundSuccess
} else {
api_models::webhooks::IncomingWebhookEvent::RefundFailure
}
}
WebhookEventCode::Cancellation => {
if is_success_scenario(is_success) {
api_models::webhooks::IncomingWebhookEvent::PaymentIntentCancelled
} else {
api_models::webhooks::IncomingWebhookEvent::PaymentIntentCancelFailure
}
}
WebhookEventCode::AuthorisationAdjustment => {
if is_success_scenario(is_success) {
api_models::webhooks::IncomingWebhookEvent::PaymentIntentExtendAuthorizationSuccess
} else {
api_models::webhooks::IncomingWebhookEvent::PaymentIntentExtendAuthorizationFailure
}
}
WebhookEventCode::RefundFailed | WebhookEventCode::RefundReversed => {
api_models::webhooks::IncomingWebhookEvent::RefundFailure
}
WebhookEventCode::NotificationOfChargeback => {
api_models::webhooks::IncomingWebhookEvent::DisputeOpened
}
WebhookEventCode::Chargeback => match dispute_status {
Some(DisputeStatus::Won) => api_models::webhooks::IncomingWebhookEvent::DisputeWon,
Some(DisputeStatus::Lost) | None => {
api_models::webhooks::IncomingWebhookEvent::DisputeLost
}
Some(_) => api_models::webhooks::IncomingWebhookEvent::DisputeOpened,
},
WebhookEventCode::ChargebackReversed => match dispute_status {
Some(DisputeStatus::Pending) => {
api_models::webhooks::IncomingWebhookEvent::DisputeChallenged
}
_ => api_models::webhooks::IncomingWebhookEvent::DisputeWon,
},
WebhookEventCode::SecondChargeback => {
api_models::webhooks::IncomingWebhookEvent::DisputeLost
}
WebhookEventCode::PrearbitrationWon => match dispute_status {
Some(DisputeStatus::Pending) => {
api_models::webhooks::IncomingWebhookEvent::DisputeOpened
}
_ => api_models::webhooks::IncomingWebhookEvent::DisputeWon,
},
WebhookEventCode::PrearbitrationLost => {
api_models::webhooks::IncomingWebhookEvent::DisputeLost
}
WebhookEventCode::Capture => {
if is_success_scenario(is_success) {
api_models::webhooks::IncomingWebhookEvent::PaymentIntentCaptureSuccess
} else {
api_models::webhooks::IncomingWebhookEvent::PaymentIntentCaptureFailure
}
}
WebhookEventCode::CaptureFailed => {
api_models::webhooks::IncomingWebhookEvent::PaymentIntentCaptureFailure
}
WebhookEventCode::OfferClosed => {
api_models::webhooks::IncomingWebhookEvent::PaymentIntentExpired
}
WebhookEventCode::RecurringContract => {
if is_success_scenario(is_success) {
api_models::webhooks::IncomingWebhookEvent::PaymentIntentSuccess
} else {
api_models::webhooks::IncomingWebhookEvent::PaymentIntentFailure
}
}
#[cfg(feature = "payouts")]
WebhookEventCode::PayoutThirdparty => {
api_models::webhooks::IncomingWebhookEvent::PayoutCreated
}
#[cfg(feature = "payouts")]
WebhookEventCode::PayoutDecline => {
api_models::webhooks::IncomingWebhookEvent::PayoutFailure
}
#[cfg(feature = "payouts")]
WebhookEventCode::PayoutExpire => api_models::webhooks::IncomingWebhookEvent::PayoutExpired,
#[cfg(feature = "payouts")]
WebhookEventCode::PayoutReversed => {
api_models::webhooks::IncomingWebhookEvent::PayoutReversed
}
WebhookEventCode::Unknown => api_models::webhooks::IncomingWebhookEvent::EventNotSupported,
}
}
impl From<WebhookEventCode> for storage_enums::DisputeStage {
fn from(code: WebhookEventCode) -> Self {
match code {
WebhookEventCode::NotificationOfChargeback => Self::PreDispute,
WebhookEventCode::SecondChargeback => Self::PreArbitration,
WebhookEventCode::PrearbitrationWon => Self::PreArbitration,
WebhookEventCode::PrearbitrationLost => Self::PreArbitration,
_ => Self::Dispute,
}
}
}
#[derive(Debug, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct AdyenNotificationRequestItemWH {
pub additional_data: AdyenAdditionalDataWH,
pub amount: AdyenAmountWH,
pub original_reference: Option<String>,
pub psp_reference: String,
pub event_code: WebhookEventCode,
pub merchant_account_code: String,
pub merchant_reference: String,
pub success: String,
pub reason: Option<String>,
#[serde(default, with = "common_utils::custom_serde::iso8601::option")]
pub event_date: Option<PrimitiveDateTime>,
}
#[derive(Debug, Deserialize)]
#[serde(rename_all = "PascalCase")]
pub struct AdyenItemObjectWH {
pub notification_request_item: AdyenNotificationRequestItemWH,
}
#[derive(Debug, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct AdyenIncomingWebhook {
pub notification_items: Vec<AdyenItemObjectWH>,
}
impl From<AdyenNotificationRequestItemWH> for AdyenWebhookResponse {
fn from(notif: AdyenNotificationRequestItemWH) -> Self {
let (refusal_reason, refusal_reason_code) = if !is_success_scenario(notif.success.clone()) {
(
notif.reason.or(Some(NO_ERROR_MESSAGE.to_string())),
Some(NO_ERROR_CODE.to_string()),
)
} else {
(None, None)
};
Self {
transaction_id: notif.psp_reference,
payment_reference: notif.original_reference,
//Translating into custom status so that it can be clearly mapped to out attempt_status
status: match notif.event_code {
WebhookEventCode::Authorisation => {
if is_success_scenario(notif.success) {
AdyenWebhookStatus::Authorised
} else {
AdyenWebhookStatus::AuthorisationFailed
}
}
WebhookEventCode::RecurringContract => {
if is_success_scenario(notif.success) {
AdyenWebhookStatus::Authorised
} else {
AdyenWebhookStatus::AuthorisationFailed
}
}
WebhookEventCode::Cancellation => {
if is_success_scenario(notif.success) {
AdyenWebhookStatus::Cancelled
} else {
AdyenWebhookStatus::CancelFailed
}
}
WebhookEventCode::AuthorisationAdjustment => {
if is_success_scenario(notif.success) {
AdyenWebhookStatus::AdjustedAuthorization
} else {
AdyenWebhookStatus::AdjustAuthorizationFailed
}
}
WebhookEventCode::OfferClosed => AdyenWebhookStatus::Expired,
WebhookEventCode::Capture => {
if is_success_scenario(notif.success) {
AdyenWebhookStatus::Captured
} else {
AdyenWebhookStatus::CaptureFailed
}
}
#[cfg(feature = "payouts")]
WebhookEventCode::PayoutThirdparty => {
if is_success_scenario(notif.success) {
AdyenWebhookStatus::Authorised
} else {
AdyenWebhookStatus::AuthorisationFailed
}
}
#[cfg(feature = "payouts")]
WebhookEventCode::PayoutDecline => AdyenWebhookStatus::Cancelled,
#[cfg(feature = "payouts")]
WebhookEventCode::PayoutExpire => AdyenWebhookStatus::AuthorisationFailed,
#[cfg(feature = "payouts")]
WebhookEventCode::PayoutReversed => AdyenWebhookStatus::Reversed,
WebhookEventCode::CaptureFailed => AdyenWebhookStatus::CaptureFailed,
WebhookEventCode::CancelOrRefund
| WebhookEventCode::Refund
| WebhookEventCode::RefundFailed
| WebhookEventCode::RefundReversed
| WebhookEventCode::NotificationOfChargeback
| WebhookEventCode::Chargeback
| WebhookEventCode::ChargebackReversed
| WebhookEventCode::SecondChargeback
| WebhookEventCode::PrearbitrationWon
| WebhookEventCode::PrearbitrationLost
| WebhookEventCode::Unknown => AdyenWebhookStatus::UnexpectedEvent,
},
amount: Some(Amount {
value: notif.amount.value,
currency: notif.amount.currency,
}),
merchant_reference_id: notif.merchant_reference,
refusal_reason,
refusal_reason_code,
event_code: notif.event_code,
refusal_code_raw: notif.additional_data.refusal_code_raw,
refusal_reason_raw: notif.additional_data.refusal_reason_raw,
recurring_detail_reference: notif.additional_data.recurring_detail_reference,
recurring_shopper_reference: notif.additional_data.recurring_shopper_reference,
}
}
}
//This will be triggered in Psync handler of webhook response
impl utils::MultipleCaptureSyncResponse for AdyenWebhookResponse {
fn get_connector_capture_id(&self) -> String {
self.transaction_id.clone()
}
fn get_capture_attempt_status(&self) -> storage_enums::AttemptStatus {
match self.status {
AdyenWebhookStatus::Captured => storage_enums::AttemptStatus::Charged,
_ => storage_enums::AttemptStatus::CaptureFailed,
}
}
fn is_capture_response(&self) -> bool {
matches!(
self.event_code,
WebhookEventCode::Capture | WebhookEventCode::CaptureFailed
)
}
fn get_connector_reference_id(&self) -> Option<String> {
Some(self.merchant_reference_id.clone())
}
fn get_amount_captured(&self) -> Result<Option<MinorUnit>, error_stack::Report<ParsingError>> {
Ok(self.amount.clone().map(|amount| amount.value))
}
}
// Payouts
#[cfg(feature = "payouts")]
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct AdyenPayoutCreateRequest {
amount: Amount,
recurring: RecurringContract,
merchant_account: Secret<String>,
#[serde(flatten)]
payment_data: PayoutPaymentMethodData,
reference: String,
shopper_reference: String,
shopper_email: Option<Email>,
shopper_name: ShopperName,
date_of_birth: Option<Secret<String>>,
entity_type: Option<storage_enums::PayoutEntityType>,
nationality: Option<storage_enums::CountryAlpha2>,
billing_address: Option<Address>,
}
#[cfg(feature = "payouts")]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum PayoutPaymentMethodData {
PayoutBankData(PayoutBankData),
PayoutWalletData(PayoutWalletData),
}
#[cfg(feature = "payouts")]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct PayoutBankData {
bank: PayoutBankDetails,
}
#[cfg(feature = "payouts")]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct PayoutWalletData {
selected_brand: PayoutBrand,
additional_data: PayoutAdditionalData,
}
#[cfg(feature = "payouts")]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub enum PayoutBrand {
Paypal,
}
#[cfg(feature = "payouts")]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
struct PayoutAdditionalData {
token_data_type: PayoutTokenDataType,
email_id: Email,
}
#[cfg(feature = "payouts")]
#[derive(Debug, Clone, Serialize, Deserialize)]
enum PayoutTokenDataType {
PayPal,
}
#[cfg(feature = "payouts")]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
struct PayoutBankDetails {
iban: Secret<String>,
owner_name: Secret<String>,
bank_city: Option<String>,
bank_name: Option<String>,
bic: Option<Secret<String>>,
country_code: Option<storage_enums::CountryAlpha2>,
tax_id: Option<Secret<String>>,
}
#[cfg(feature = "payouts")]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
struct RecurringContract {
contract: Contract,
}
#[cfg(feature = "payouts")]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "UPPERCASE")]
enum Contract {
Oneclick,
Recurring,
Payout,
}
#[cfg(feature = "payouts")]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct AdyenPayoutResponse {
psp_reference: String,
result_code: Option<AdyenStatus>,
response: Option<AdyenStatus>,
amount: Option<Amount>,
merchant_reference: Option<String>,
refusal_reason: Option<String>,
refusal_reason_code: Option<String>,
additional_data: Option<AdditionalData>,
auth_code: Option<String>,
}
#[cfg(feature = "payouts")]
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct AdyenPayoutEligibilityRequest {
amount: Amount,
merchant_account: Secret<String>,
payment_method: PayoutCardDetails,
reference: String,
shopper_reference: String,
}
#[cfg(feature = "payouts")]
#[derive(Default, Debug, Serialize, Deserialize, Eq, PartialEq)]
#[serde(rename_all = "camelCase")]
pub struct PayoutCardDetails {
#[serde(rename = "type")]
payment_method_type: String,
number: CardNumber,
expiry_month: Secret<String>,
expiry_year: Secret<String>,
holder_name: Secret<String>,
}
#[cfg(feature = "payouts")]
#[derive(Clone, Default, Debug, Serialize, Deserialize, Eq, PartialEq)]
pub enum PayoutEligibility {
#[serde(rename = "Y")]
Yes,
#[serde(rename = "N")]
#[default]
No,
#[serde(rename = "D")]
Domestic,
#[serde(rename = "U")]
Unknown,
}
#[cfg(feature = "payouts")]
#[derive(Debug, Serialize, Deserialize)]
#[serde(untagged)]
pub enum AdyenPayoutFulfillRequest {
GenericFulfillRequest(PayoutFulfillGenericRequest),
Card(Box<PayoutFulfillCardRequest>),
}
#[cfg(feature = "payouts")]
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct PayoutFulfillGenericRequest {
merchant_account: Secret<String>,
original_reference: String,
}
#[cfg(feature = "payouts")]
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct PayoutFulfillCardRequest {
amount: Amount,
card: PayoutCardDetails,
billing_address: Option<Address>,
merchant_account: Secret<String>,
reference: String,
shopper_name: ShopperName,
nationality: Option<storage_enums::CountryAlpha2>,
entity_type: Option<storage_enums::PayoutEntityType>,
}
#[cfg(feature = "payouts")]
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct AdyenPayoutCancelRequest {
original_reference: String,
merchant_account: Secret<String>,
}
#[cfg(feature = "payouts")]
impl TryFrom<&PayoutMethodData> for PayoutCardDetails {
type Error = Error;
fn try_from(item: &PayoutMethodData) -> Result<Self, Self::Error> {
match item {
PayoutMethodData::Card(card) => Ok(Self {
payment_method_type: "scheme".to_string(), // FIXME: Remove hardcoding
number: card.card_number.clone(),
expiry_month: card.expiry_month.clone(),
expiry_year: card.expiry_year.clone(),
holder_name: card
.card_holder_name
.clone()
.get_required_value("card_holder_name")
.change_context(errors::ConnectorError::MissingRequiredField {
field_name: "payout_method_data.card.holder_name",
})?,
}),
_ => Err(errors::ConnectorError::MissingRequiredField {
field_name: "payout_method_data.card",
})?,
}
}
}
// Payouts eligibility request transform
#[cfg(feature = "payouts")]
impl<F> TryFrom<&AdyenRouterData<&PayoutsRouterData<F>>> for AdyenPayoutEligibilityRequest {
type Error = Error;
fn try_from(item: &AdyenRouterData<&PayoutsRouterData<F>>) -> Result<Self, Self::Error> {
let auth_type = AdyenAuthType::try_from(&item.router_data.connector_auth_type)?;
let payout_method_data =
PayoutCardDetails::try_from(&item.router_data.get_payout_method_data()?)?;
Ok(Self {
amount: Amount {
currency: item.router_data.request.destination_currency,
value: item.amount.to_owned(),
},
merchant_account: auth_type.merchant_account,
payment_method: payout_method_data,
reference: item.router_data.connector_request_reference_id.clone(),
shopper_reference: item.router_data.merchant_id.get_string_repr().to_owned(),
})
}
}
// Payouts create request transform
#[cfg(feature = "payouts")]
impl<F> TryFrom<&PayoutsRouterData<F>> for AdyenPayoutCancelRequest {
type Error = Error;
fn try_from(item: &PayoutsRouterData<F>) -> Result<Self, Self::Error> {
let auth_type = AdyenAuthType::try_from(&item.connector_auth_type)?;
let merchant_account = auth_type.merchant_account;
if let Some(id) = &item.request.connector_payout_id {
Ok(Self {
merchant_account,
original_reference: id.to_string(),
})
} else {
Err(errors::ConnectorError::MissingRequiredField {
field_name: "connector_payout_id",
})?
}
}
}
// Payouts cancel request transform
#[cfg(feature = "payouts")]
impl<F> TryFrom<&AdyenRouterData<&PayoutsRouterData<F>>> for AdyenPayoutCreateRequest {
type Error = Error;
fn try_from(item: &AdyenRouterData<&PayoutsRouterData<F>>) -> Result<Self, Self::Error> {
let auth_type = AdyenAuthType::try_from(&item.router_data.connector_auth_type)?;
let merchant_account = auth_type.merchant_account;
let (owner_name, customer_email) = item
.router_data
.request
.customer_details
.to_owned()
.map_or((None, None), |c| (c.name, c.email));
let owner_name = owner_name.get_required_value("owner_name").change_context(
errors::ConnectorError::MissingRequiredField {
field_name: "payout_method_data.bank.owner_name",
},
)?;
match item.router_data.get_payout_method_data()? {
PayoutMethodData::Card(_) => Err(errors::ConnectorError::NotSupported {
message: "Card payout creation is not supported".to_string(),
connector: "Adyen",
})?,
PayoutMethodData::Bank(bd) => {
let bank_details = match bd {
payouts::Bank::Sepa(b) => PayoutBankDetails {
bank_name: b.bank_name,
country_code: b.bank_country_code,
bank_city: b.bank_city,
owner_name,
bic: b.bic,
iban: b.iban,
tax_id: None,
},
payouts::Bank::Ach(..) => Err(errors::ConnectorError::NotSupported {
message: "Bank transfer via ACH is not supported".to_string(),
connector: "Adyen",
})?,
payouts::Bank::Bacs(..) => Err(errors::ConnectorError::NotSupported {
message: "Bank transfer via Bacs is not supported".to_string(),
connector: "Adyen",
})?,
payouts::Bank::Pix(..) => Err(errors::ConnectorError::NotSupported {
message: "Bank transfer via Pix is not supported".to_string(),
connector: "Adyen",
})?,
};
let bank_data = PayoutBankData { bank: bank_details };
let address: &hyperswitch_domain_models::address::AddressDetails =
item.router_data.get_billing_address()?;
Ok(Self {
amount: Amount {
value: item.amount.to_owned(),
currency: item.router_data.request.destination_currency,
},
recurring: RecurringContract {
contract: Contract::Payout,
},
merchant_account,
payment_data: PayoutPaymentMethodData::PayoutBankData(bank_data),
reference: item.router_data.connector_request_reference_id.to_owned(),
shopper_reference: item.router_data.merchant_id.get_string_repr().to_owned(),
shopper_email: customer_email,
shopper_name: ShopperName {
first_name: Some(address.get_first_name()?.to_owned()), // it is a required field for payouts
last_name: Some(address.get_last_name()?.to_owned()), // it is a required field for payouts
},
date_of_birth: None,
entity_type: Some(item.router_data.request.entity_type),
nationality: get_country_code(item.router_data.get_optional_billing()),
billing_address: get_address_info(item.router_data.get_optional_billing())
.transpose()?,
})
}
PayoutMethodData::Wallet(wallet_data) => {
let additional_data = match wallet_data {
payouts::Wallet::Paypal(paypal_data) => PayoutAdditionalData {
token_data_type: PayoutTokenDataType::PayPal,
email_id: paypal_data.email.clone().ok_or(
errors::ConnectorError::MissingRequiredField {
field_name: "email_address",
},
)?,
},
payouts::Wallet::Venmo(_) => Err(errors::ConnectorError::NotSupported {
message: "Venmo Wallet is not supported".to_string(),
connector: "Adyen",
})?,
payouts::Wallet::ApplePayDecrypt(_) => {
Err(errors::ConnectorError::NotSupported {
message: "Apple Pay Decrypt Wallet is not supported".to_string(),
connector: "Adyen",
})?
}
};
let address: &hyperswitch_domain_models::address::AddressDetails =
item.router_data.get_billing_address()?;
let payout_wallet = PayoutWalletData {
selected_brand: PayoutBrand::Paypal,
additional_data,
};
Ok(Self {
amount: Amount {
value: item.amount.to_owned(),
currency: item.router_data.request.destination_currency,
},
recurring: RecurringContract {
contract: Contract::Payout,
},
merchant_account,
payment_data: PayoutPaymentMethodData::PayoutWalletData(payout_wallet),
reference: item.router_data.connector_request_reference_id.clone(),
shopper_reference: item.router_data.merchant_id.get_string_repr().to_owned(),
shopper_email: customer_email,
shopper_name: ShopperName {
first_name: Some(address.get_first_name()?.to_owned()), // it is a required field for payouts
last_name: Some(address.get_last_name()?.to_owned()), // it is a required field for payouts
},
date_of_birth: None,
entity_type: Some(item.router_data.request.entity_type),
nationality: get_country_code(item.router_data.get_optional_billing()),
billing_address: get_address_info(item.router_data.get_optional_billing())
.transpose()?,
})
}
PayoutMethodData::BankRedirect(_) => Err(errors::ConnectorError::NotSupported {
message: "Bank redirect payout creation is not supported".to_string(),
connector: "Adyen",
})?,
}
}
}
// Payouts fulfill request transform
#[cfg(feature = "payouts")]
impl<F> TryFrom<&AdyenRouterData<&PayoutsRouterData<F>>> for AdyenPayoutFulfillRequest {
type Error = Error;
fn try_from(item: &AdyenRouterData<&PayoutsRouterData<F>>) -> Result<Self, Self::Error> {
let auth_type = AdyenAuthType::try_from(&item.router_data.connector_auth_type)?;
let payout_type = item.router_data.request.get_payout_type()?;
let merchant_account = auth_type.merchant_account;
match payout_type {
storage_enums::PayoutType::Bank
| storage_enums::PayoutType::Wallet
| storage_enums::PayoutType::BankRedirect => {
Ok(Self::GenericFulfillRequest(PayoutFulfillGenericRequest {
merchant_account,
original_reference: item
.router_data
.request
.connector_payout_id
.clone()
.ok_or(errors::ConnectorError::MissingRequiredField {
field_name: "connector_payout_id",
})?,
}))
}
storage_enums::PayoutType::Card => {
let address = item.router_data.get_billing_address()?;
Ok(Self::Card(Box::new(PayoutFulfillCardRequest {
amount: Amount {
value: item.amount.to_owned(),
currency: item.router_data.request.destination_currency,
},
card: PayoutCardDetails::try_from(&item.router_data.get_payout_method_data()?)?,
billing_address: get_address_info(item.router_data.get_billing().ok())
.transpose()?,
merchant_account,
reference: item.router_data.connector_request_reference_id.clone(),
shopper_name: ShopperName {
first_name: Some(address.get_first_name()?.to_owned()), // it is a required field for payouts
last_name: Some(address.get_last_name()?.to_owned()), // it is a required field for payouts
},
nationality: get_country_code(item.router_data.get_optional_billing()),
entity_type: Some(item.router_data.request.entity_type),
})))
}
}
}
}
// Payouts response transform
#[cfg(feature = "payouts")]
impl<F> TryFrom<PayoutsResponseRouterData<F, AdyenPayoutResponse>> for PayoutsRouterData<F> {
type Error = Error;
fn try_from(
item: PayoutsResponseRouterData<F, AdyenPayoutResponse>,
) -> Result<Self, Self::Error> {
let response: AdyenPayoutResponse = item.response;
let payout_eligible = response
.additional_data
.and_then(|pa| pa.payout_eligible)
.map(|pe| pe == PayoutEligibility::Yes || pe == PayoutEligibility::Domestic);
let status = payout_eligible.map_or(
{
response.result_code.map_or(
response.response.map(storage_enums::PayoutStatus::from),
|rc| Some(storage_enums::PayoutStatus::from(rc)),
)
},
|pe| {
if pe {
Some(storage_enums::PayoutStatus::RequiresFulfillment)
} else {
Some(storage_enums::PayoutStatus::Ineligible)
}
},
);
Ok(Self {
response: Ok(PayoutsResponseData {
status,
connector_payout_id: Some(response.psp_reference),
payout_eligible,
should_add_next_step_to_process_tracker: false,
error_code: None,
error_message: None,
payout_connector_metadata: None,
}),
..item.data
})
}
}
#[cfg(feature = "payouts")]
impl From<AdyenStatus> for storage_enums::PayoutStatus {
fn from(adyen_status: AdyenStatus) -> Self {
match adyen_status {
AdyenStatus::Authorised => Self::Success,
AdyenStatus::PayoutConfirmReceived => Self::Initiated,
AdyenStatus::Cancelled | AdyenStatus::PayoutDeclineReceived => Self::Cancelled,
AdyenStatus::Error => Self::Failed,
AdyenStatus::Pending => Self::Pending,
AdyenStatus::PayoutSubmitReceived => Self::RequiresFulfillment,
_ => Self::Ineligible,
}
}
}
fn get_merchant_account_code(
auth_type: &ConnectorAuthType,
) -> CustomResult<Secret<String>, errors::ConnectorError> {
let auth = AdyenAuthType::try_from(auth_type)
.change_context(errors::ConnectorError::FailedToObtainAuthType)?;
Ok(auth.merchant_account.clone())
}
#[derive(Default, Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct AdyenAcceptDisputeRequest {
dispute_psp_reference: String,
merchant_account_code: Secret<String>,
}
#[derive(Default, Debug, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct AdyenDisputeResponse {
pub error_message: Option<String>,
pub success: bool,
}
impl TryFrom<&AcceptDisputeRouterData> for AdyenAcceptDisputeRequest {
type Error = Error;
fn try_from(item: &AcceptDisputeRouterData) -> Result<Self, Self::Error> {
let merchant_account_code = get_merchant_account_code(&item.connector_auth_type)?;
Ok(Self {
dispute_psp_reference: item.clone().request.connector_dispute_id,
merchant_account_code,
})
}
}
#[derive(Default, Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct AdyenDefendDisputeRequest {
dispute_psp_reference: String,
merchant_account_code: Secret<String>,
defense_reason_code: String,
}
impl TryFrom<&DefendDisputeRouterData> for AdyenDefendDisputeRequest {
type Error = Error;
fn try_from(item: &DefendDisputeRouterData) -> Result<Self, Self::Error> {
let merchant_account_code = get_merchant_account_code(&item.connector_auth_type)?;
Ok(Self {
dispute_psp_reference: item.request.connector_dispute_id.clone(),
merchant_account_code,
defense_reason_code: "SupplyDefenseMaterial".into(),
})
}
}
#[derive(Default, Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct Evidence {
defense_documents: Vec<DefenseDocuments>,
merchant_account_code: Secret<String>,
dispute_psp_reference: String,
}
#[derive(Default, Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct DefenseDocuments {
content: Secret<String>,
content_type: Option<String>,
defense_document_type_code: String,
}
#[derive(Debug, Deserialize)]
pub struct AdyenTestingData {
holder_name: Option<Secret<String>>,
}
impl TryFrom<common_utils::pii::SecretSerdeValue> for AdyenTestingData {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(testing_data: common_utils::pii::SecretSerdeValue) -> Result<Self, Self::Error> {
let testing_data = testing_data
.expose()
.parse_value::<Self>("AdyenTestingData")
.change_context(errors::ConnectorError::InvalidDataFormat {
field_name: "connector_metadata.adyen.testing",
})?;
Ok(testing_data)
}
}
impl TryFrom<&SubmitEvidenceRouterData> for Evidence {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(item: &SubmitEvidenceRouterData) -> Result<Self, Self::Error> {
let merchant_account_code = get_merchant_account_code(&item.connector_auth_type)?;
let submit_evidence_request_data = item.request.clone();
Ok(Self {
defense_documents: get_defence_documents(submit_evidence_request_data).ok_or(
errors::ConnectorError::MissingRequiredField {
field_name: "Missing Defence Documents",
},
)?,
merchant_account_code,
dispute_psp_reference: item.request.connector_dispute_id.clone(),
})
}
}
fn get_defence_documents(item: SubmitEvidenceRequestData) -> Option<Vec<DefenseDocuments>> {
let mut defense_documents: Vec<DefenseDocuments> = Vec::new();
if let Some(shipping_documentation) = item.shipping_documentation {
defense_documents.push(DefenseDocuments {
content: get_content(shipping_documentation).into(),
content_type: item.receipt_file_type,
defense_document_type_code: "DefenseMaterial".into(),
})
}
if let Some(receipt) = item.receipt {
defense_documents.push(DefenseDocuments {
content: get_content(receipt).into(),
content_type: item.shipping_documentation_file_type,
defense_document_type_code: "DefenseMaterial".into(),
})
}
if let Some(invoice_showing_distinct_transactions) = item.invoice_showing_distinct_transactions
{
defense_documents.push(DefenseDocuments {
content: get_content(invoice_showing_distinct_transactions).into(),
content_type: item.invoice_showing_distinct_transactions_file_type,
defense_document_type_code: "DefenseMaterial".into(),
})
}
if let Some(customer_communication) = item.customer_communication {
defense_documents.push(DefenseDocuments {
content: get_content(customer_communication).into(),
content_type: item.customer_communication_file_type,
defense_document_type_code: "DefenseMaterial".into(),
})
}
if let Some(refund_policy) = item.refund_policy {
defense_documents.push(DefenseDocuments {
content: get_content(refund_policy).into(),
content_type: item.refund_policy_file_type,
defense_document_type_code: "DefenseMaterial".into(),
})
}
if let Some(recurring_transaction_agreement) = item.recurring_transaction_agreement {
defense_documents.push(DefenseDocuments {
content: get_content(recurring_transaction_agreement).into(),
content_type: item.recurring_transaction_agreement_file_type,
defense_document_type_code: "DefenseMaterial".into(),
})
}
if let Some(uncategorized_file) = item.uncategorized_file {
defense_documents.push(DefenseDocuments {
content: get_content(uncategorized_file).into(),
content_type: item.uncategorized_file_type,
defense_document_type_code: "DefenseMaterial".into(),
})
}
if let Some(cancellation_policy) = item.cancellation_policy {
defense_documents.push(DefenseDocuments {
content: get_content(cancellation_policy).into(),
content_type: item.cancellation_policy_file_type,
defense_document_type_code: "DefenseMaterial".into(),
})
}
if let Some(customer_signature) = item.customer_signature {
defense_documents.push(DefenseDocuments {
content: get_content(customer_signature).into(),
content_type: item.customer_signature_file_type,
defense_document_type_code: "DefenseMaterial".into(),
})
}
if let Some(service_documentation) = item.service_documentation {
defense_documents.push(DefenseDocuments {
content: get_content(service_documentation).into(),
content_type: item.service_documentation_file_type,
defense_document_type_code: "DefenseMaterial".into(),
})
}
if defense_documents.is_empty() {
None
} else {
Some(defense_documents)
}
}
fn get_content(item: Vec<u8>) -> String {
String::from_utf8_lossy(&item).to_string()
}
impl ForeignTryFrom<(&Self, AdyenDisputeResponse)> for AcceptDisputeRouterData {
type Error = errors::ConnectorError;
fn foreign_try_from(item: (&Self, AdyenDisputeResponse)) -> Result<Self, Self::Error> {
let (data, response) = item;
if response.success {
Ok(AcceptDisputeRouterData {
response: Ok(AcceptDisputeResponse {
dispute_status: storage_enums::DisputeStatus::DisputeAccepted,
connector_status: None,
}),
..data.clone()
})
} else {
Ok(AcceptDisputeRouterData {
response: Err(ErrorResponse {
code: response
.error_message
.clone()
.unwrap_or_else(|| NO_ERROR_CODE.to_string()),
message: response
.error_message
.clone()
.unwrap_or_else(|| NO_ERROR_MESSAGE.to_string()),
reason: response.error_message,
status_code: data.connector_http_status_code.ok_or(
errors::ConnectorError::MissingRequiredField {
field_name: "http code",
},
)?,
attempt_status: None,
connector_transaction_id: None,
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
connector_metadata: None,
}),
..data.clone()
})
}
}
}
impl ForeignTryFrom<(&Self, AdyenDisputeResponse)> for SubmitEvidenceRouterData {
type Error = errors::ConnectorError;
fn foreign_try_from(item: (&Self, AdyenDisputeResponse)) -> Result<Self, Self::Error> {
let (data, response) = item;
if response.success {
Ok(SubmitEvidenceRouterData {
response: Ok(SubmitEvidenceResponse {
dispute_status: storage_enums::DisputeStatus::DisputeChallenged,
connector_status: None,
}),
..data.clone()
})
} else {
Ok(SubmitEvidenceRouterData {
response: Err(ErrorResponse {
code: response
.error_message
.clone()
.unwrap_or_else(|| NO_ERROR_CODE.to_string()),
message: response
.error_message
.clone()
.unwrap_or_else(|| NO_ERROR_MESSAGE.to_string()),
reason: response.error_message,
status_code: data.connector_http_status_code.ok_or(
errors::ConnectorError::MissingRequiredField {
field_name: "http code",
},
)?,
attempt_status: None,
connector_transaction_id: None,
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
connector_metadata: None,
}),
..data.clone()
})
}
}
}
impl ForeignTryFrom<(&Self, AdyenDisputeResponse)> for DefendDisputeRouterData {
type Error = errors::ConnectorError;
fn foreign_try_from(item: (&Self, AdyenDisputeResponse)) -> Result<Self, Self::Error> {
let (data, response) = item;
if response.success {
Ok(DefendDisputeRouterData {
response: Ok(DefendDisputeResponse {
dispute_status: storage_enums::DisputeStatus::DisputeChallenged,
connector_status: None,
}),
..data.clone()
})
} else {
Ok(DefendDisputeRouterData {
response: Err(ErrorResponse {
code: response
.error_message
.clone()
.unwrap_or_else(|| NO_ERROR_CODE.to_string()),
message: response
.error_message
.clone()
.unwrap_or_else(|| NO_ERROR_MESSAGE.to_string()),
reason: response.error_message,
status_code: data.connector_http_status_code.ok_or(
errors::ConnectorError::MissingRequiredField {
field_name: "http code",
},
)?,
attempt_status: None,
connector_transaction_id: None,
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
connector_metadata: None,
}),
..data.clone()
})
}
}
}
impl TryFrom<(&NetworkTokenData, Option<Secret<String>>)> for AdyenPaymentMethod<'_> {
type Error = Error;
fn try_from(
(token_data, card_holder_name): (&NetworkTokenData, Option<Secret<String>>),
) -> Result<Self, Self::Error> {
let adyen_network_token = AdyenNetworkTokenData {
number: token_data.get_network_token(),
expiry_month: token_data.get_network_token_expiry_month(),
expiry_year: token_data.get_expiry_year_4_digit(),
holder_name: card_holder_name,
brand: None, // FIXME: Remove hardcoding
network_payment_reference: None,
};
Ok(AdyenPaymentMethod::NetworkToken(Box::new(
adyen_network_token,
)))
}
}
impl
TryFrom<(
&AdyenRouterData<&PaymentsAuthorizeRouterData>,
&NetworkTokenData,
)> for AdyenPaymentRequest<'_>
{
type Error = Error;
fn try_from(
value: (
&AdyenRouterData<&PaymentsAuthorizeRouterData>,
&NetworkTokenData,
),
) -> Result<Self, Self::Error> {
let (item, token_data) = value;
let amount = get_amount_data(item);
let auth_type = AdyenAuthType::try_from(&item.router_data.connector_auth_type)?;
let shopper_interaction = AdyenShopperInteraction::from(item.router_data);
let shopper_reference = build_shopper_reference(item.router_data);
let (recurring_processing_model, store_payment_method, _) =
get_recurring_processing_model(item.router_data)?;
let browser_info = get_browser_info(item.router_data)?;
let billing_address =
get_address_info(item.router_data.get_optional_billing()).transpose()?;
let country_code = get_country_code(item.router_data.get_optional_billing());
let additional_data = get_additional_data(item.router_data);
let return_url = item.router_data.request.get_router_return_url()?;
let testing_data = item
.router_data
.request
.get_connector_testing_data()
.map(AdyenTestingData::try_from)
.transpose()?;
let test_holder_name = testing_data.and_then(|test_data| test_data.holder_name);
let card_holder_name =
test_holder_name.or(item.router_data.get_optional_billing_full_name());
let payment_method = PaymentMethod::AdyenPaymentMethod(Box::new(
AdyenPaymentMethod::try_from((token_data, card_holder_name))?,
));
let shopper_email = item.router_data.request.email.clone();
let shopper_name = get_shopper_name(item.router_data.get_optional_billing());
let mpi_data = AdyenMpiData {
directory_response: "Y".to_string(),
authentication_response: "Y".to_string(),
cavv: None,
token_authentication_verification_value: Some(
token_data.get_cryptogram().clone().unwrap_or_default(),
),
eci: Some("02".to_string()),
};
let (store, splits) = match item.router_data.request.split_payments.as_ref() {
Some(common_types::payments::SplitPaymentsRequest::AdyenSplitPayment(
adyen_split_payment,
)) => get_adyen_split_request(adyen_split_payment, item.router_data.request.currency),
_ => (None, None),
};
let device_fingerprint = item
.router_data
.request
.metadata
.clone()
.and_then(get_device_fingerprint);
let delivery_address =
get_address_info(item.router_data.get_optional_shipping()).and_then(Result::ok);
let telephone_number = item.router_data.get_optional_billing_phone_number();
Ok(AdyenPaymentRequest {
amount,
merchant_account: auth_type.merchant_account,
payment_method,
reference: item.router_data.connector_request_reference_id.clone(),
return_url,
shopper_interaction,
recurring_processing_model,
browser_info,
additional_data,
telephone_number,
shopper_name,
shopper_email,
shopper_locale: item.router_data.request.locale.clone(),
social_security_number: None,
billing_address,
delivery_address,
country_code,
line_items: None,
shopper_reference,
store_payment_method,
channel: None,
shopper_statement: item.router_data.request.statement_descriptor.clone(),
shopper_ip: item.router_data.request.get_ip_address_as_optional(),
merchant_order_reference: item.router_data.request.merchant_order_reference_id.clone(),
mpi_data: Some(mpi_data),
store,
splits,
device_fingerprint,
session_validity: None,
metadata: item.router_data.request.metadata.clone(),
})
}
}
impl AdditionalData {
// Split merchant advice code into at most 2 parts and get the first part and trim spaces,
// Return the first part as a String.
pub fn extract_network_advice_code(&self) -> Option<String> {
self.merchant_advice_code.as_ref().and_then(|code| {
let mut parts = code.splitn(2, ':');
let first_part = parts.next()?.trim();
// Ensure there is a second part (meaning ':' was present).
parts.next()?;
Some(first_part.to_string())
})
}
}
|
{
"crate": "hyperswitch_connectors",
"file": "crates/hyperswitch_connectors/src/connectors/adyen/transformers.rs",
"file_size": null,
"is_async": null,
"is_pub": null,
"num_enums": 30,
"num_structs": 90,
"num_tables": null,
"score": null,
"total_crates": null
}
|
file_hyperswitch_connectors_-4636795424571586811
|
clm
|
file
|
// Repository: hyperswitch
// Crate: hyperswitch_connectors
// File: crates/hyperswitch_connectors/src/connectors/opennode/transformers.rs
// Contains: 8 structs, 2 enums
use std::collections::HashMap;
use common_enums::{enums, AttemptStatus};
use common_utils::{request::Method, types::MinorUnit};
use hyperswitch_domain_models::{
router_data::{ConnectorAuthType, RouterData},
router_flow_types::refunds::{Execute, RSync},
router_request_types::ResponseId,
router_response_types::{PaymentsResponseData, RedirectForm, RefundsResponseData},
types::{PaymentsAuthorizeRouterData, RefundsRouterData},
};
use hyperswitch_interfaces::errors;
use masking::Secret;
use serde::{Deserialize, Serialize};
use crate::{
types::{RefundsResponseRouterData, ResponseRouterData},
utils::{PaymentsAuthorizeRequestData, RouterData as OtherRouterData},
};
#[derive(Debug, Serialize)]
pub struct OpennodeRouterData<T> {
pub amount: MinorUnit,
pub router_data: T,
}
impl<T> TryFrom<(MinorUnit, T)> for OpennodeRouterData<T> {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from((amount, router_data): (MinorUnit, T)) -> Result<Self, Self::Error> {
Ok(Self {
amount,
router_data,
})
}
}
//TODO: Fill the struct with respective fields
#[derive(Default, Debug, Serialize, Eq, PartialEq)]
pub struct OpennodePaymentsRequest {
amount: MinorUnit,
currency: String,
description: String,
auto_settle: bool,
success_url: String,
callback_url: String,
order_id: String,
}
impl TryFrom<&OpennodeRouterData<&PaymentsAuthorizeRouterData>> for OpennodePaymentsRequest {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: &OpennodeRouterData<&PaymentsAuthorizeRouterData>,
) -> Result<Self, Self::Error> {
get_crypto_specific_payment_data(item)
}
}
//TODO: Fill the struct with respective fields
// Auth Struct
pub struct OpennodeAuthType {
pub(super) api_key: Secret<String>,
}
impl TryFrom<&ConnectorAuthType> for OpennodeAuthType {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(auth_type: &ConnectorAuthType) -> Result<Self, Self::Error> {
match auth_type {
ConnectorAuthType::HeaderKey { api_key } => Ok(Self {
api_key: api_key.to_owned(),
}),
_ => Err(errors::ConnectorError::FailedToObtainAuthType.into()),
}
}
}
// PaymentsResponse
//TODO: Append the remaining status flags
#[derive(Debug, Clone, Default, Serialize, Deserialize, PartialEq)]
#[serde(rename_all = "lowercase")]
pub enum OpennodePaymentStatus {
Unpaid,
Paid,
Expired,
#[default]
Processing,
Underpaid,
Refunded,
#[serde(other)]
Unknown,
}
impl From<OpennodePaymentStatus> for AttemptStatus {
fn from(item: OpennodePaymentStatus) -> Self {
match item {
OpennodePaymentStatus::Unpaid => Self::AuthenticationPending,
OpennodePaymentStatus::Paid => Self::Charged,
OpennodePaymentStatus::Expired => Self::Failure,
OpennodePaymentStatus::Underpaid => Self::Unresolved,
_ => Self::Pending,
}
}
}
#[derive(Default, Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct OpennodePaymentsResponseData {
id: String,
hosted_checkout_url: String,
status: OpennodePaymentStatus,
order_id: Option<String>,
}
//TODO: Fill the struct with respective fields
#[derive(Default, Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct OpennodePaymentsResponse {
data: OpennodePaymentsResponseData,
}
impl<F, T> TryFrom<ResponseRouterData<F, OpennodePaymentsResponse, T, PaymentsResponseData>>
for RouterData<F, T, PaymentsResponseData>
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: ResponseRouterData<F, OpennodePaymentsResponse, T, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
let form_fields = HashMap::new();
let redirection_data = RedirectForm::Form {
endpoint: item.response.data.hosted_checkout_url.to_string(),
method: Method::Get,
form_fields,
};
let connector_id = ResponseId::ConnectorTransactionId(item.response.data.id);
let attempt_status = item.response.data.status;
let response_data = if attempt_status != OpennodePaymentStatus::Underpaid {
Ok(PaymentsResponseData::TransactionResponse {
resource_id: connector_id,
redirection_data: Box::new(Some(redirection_data)),
mandate_reference: Box::new(None),
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: item.response.data.order_id,
incremental_authorization_allowed: None,
charges: None,
})
} else {
Ok(PaymentsResponseData::TransactionUnresolvedResponse {
resource_id: connector_id,
reason: Some(api_models::enums::UnresolvedResponseReason {
code: "UNDERPAID".to_string(),
message:
"Please check the transaction in opennode dashboard and resolve manually"
.to_string(),
}),
connector_response_reference_id: item.response.data.order_id,
})
};
Ok(Self {
status: AttemptStatus::from(attempt_status),
response: response_data,
..item.data
})
}
}
//TODO: Fill the struct with respective fields
// REFUND :
// Type definition for RefundRequest
#[derive(Default, Debug, Serialize)]
pub struct OpennodeRefundRequest {
pub amount: i64,
}
impl<F> TryFrom<&OpennodeRouterData<&RefundsRouterData<F>>> for OpennodeRefundRequest {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(item: &OpennodeRouterData<&RefundsRouterData<F>>) -> Result<Self, Self::Error> {
Ok(Self {
amount: item.router_data.request.refund_amount,
})
}
}
// Type definition for Refund Response
#[allow(dead_code)]
#[derive(Debug, Serialize, Default, Deserialize, Clone)]
pub enum RefundStatus {
Refunded,
#[default]
Processing,
}
impl From<RefundStatus> for enums::RefundStatus {
fn from(item: RefundStatus) -> Self {
match item {
RefundStatus::Refunded => Self::Success,
RefundStatus::Processing => Self::Pending,
}
}
}
//TODO: Fill the struct with respective fields
#[derive(Default, Debug, Clone, Serialize, Deserialize)]
pub struct RefundResponse {
id: String,
status: RefundStatus,
}
impl TryFrom<RefundsResponseRouterData<Execute, RefundResponse>> for RefundsRouterData<Execute> {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: RefundsResponseRouterData<Execute, RefundResponse>,
) -> Result<Self, Self::Error> {
Ok(Self {
response: Ok(RefundsResponseData {
connector_refund_id: item.response.id.to_string(),
refund_status: enums::RefundStatus::from(item.response.status),
}),
..item.data
})
}
}
impl TryFrom<RefundsResponseRouterData<RSync, RefundResponse>> for RefundsRouterData<RSync> {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: RefundsResponseRouterData<RSync, RefundResponse>,
) -> Result<Self, Self::Error> {
Ok(Self {
response: Ok(RefundsResponseData {
connector_refund_id: item.response.id.to_string(),
refund_status: enums::RefundStatus::from(item.response.status),
}),
..item.data
})
}
}
//TODO: Fill the struct with respective fields
#[derive(Debug, Deserialize, Serialize)]
pub struct OpennodeErrorResponse {
pub message: String,
}
fn get_crypto_specific_payment_data(
item: &OpennodeRouterData<&PaymentsAuthorizeRouterData>,
) -> Result<OpennodePaymentsRequest, error_stack::Report<errors::ConnectorError>> {
let amount = item.amount;
let currency = item.router_data.request.currency.to_string();
let description = item.router_data.get_description()?;
let auto_settle = true;
let success_url = item.router_data.request.get_router_return_url()?;
let callback_url = item.router_data.request.get_webhook_url()?;
let order_id = item.router_data.connector_request_reference_id.clone();
Ok(OpennodePaymentsRequest {
amount,
currency,
description,
auto_settle,
success_url,
callback_url,
order_id,
})
}
#[derive(Debug, Serialize, Deserialize)]
pub struct OpennodeWebhookDetails {
pub id: String,
pub callback_url: String,
pub success_url: String,
pub status: OpennodePaymentStatus,
pub payment_method: String,
pub missing_amt: String,
pub order_id: String,
pub description: String,
pub price: String,
pub fee: String,
pub auto_settle: String,
pub fiat_value: String,
pub net_fiat_value: String,
pub overpaid_by: String,
pub hashed_order: String,
}
|
{
"crate": "hyperswitch_connectors",
"file": "crates/hyperswitch_connectors/src/connectors/opennode/transformers.rs",
"file_size": null,
"is_async": null,
"is_pub": null,
"num_enums": 2,
"num_structs": 8,
"num_tables": null,
"score": null,
"total_crates": null
}
|
file_hyperswitch_connectors_-4270818187477181265
|
clm
|
file
|
// Repository: hyperswitch
// Crate: hyperswitch_connectors
// File: crates/hyperswitch_connectors/src/connectors/fiservemea/transformers.rs
// Contains: 19 structs, 7 enums
use common_enums::enums;
use common_utils::types::StringMajorUnit;
use hyperswitch_domain_models::{
payment_method_data::PaymentMethodData,
router_data::{ConnectorAuthType, RouterData},
router_flow_types::refunds::{Execute, RSync},
router_request_types::ResponseId,
router_response_types::{PaymentsResponseData, RefundsResponseData},
types::{
PaymentsAuthorizeRouterData, PaymentsCancelRouterData, PaymentsCaptureRouterData,
RefundsRouterData,
},
};
use hyperswitch_interfaces::errors;
use masking::Secret;
use serde::{Deserialize, Serialize};
use crate::{
types::{RefundsResponseRouterData, ResponseRouterData},
utils::CardData as _,
};
//TODO: Fill the struct with respective fields
pub struct FiservemeaRouterData<T> {
pub amount: StringMajorUnit, // The type of amount that a connector accepts, for example, String, i64, f64, etc.
pub router_data: T,
}
impl<T> From<(StringMajorUnit, T)> for FiservemeaRouterData<T> {
fn from((amount, item): (StringMajorUnit, T)) -> Self {
//Todo : use utils to convert the amount to the type of amount that a connector accepts
Self {
amount,
router_data: item,
}
}
}
#[derive(Debug, Serialize)]
pub struct FiservemeaTransactionAmount {
total: StringMajorUnit,
currency: common_enums::Currency,
}
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct FiservemeaOrder {
order_id: String,
}
#[derive(Debug, Serialize)]
pub enum FiservemeaRequestType {
PaymentCardSaleTransaction,
PaymentCardPreAuthTransaction,
PostAuthTransaction,
VoidPreAuthTransactions,
ReturnTransaction,
}
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct FiservemeaExpiryDate {
month: Secret<String>,
year: Secret<String>,
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct FiservemeaPaymentCard {
number: cards::CardNumber,
expiry_date: FiservemeaExpiryDate,
security_code: Secret<String>,
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub enum FiservemeaPaymentMethods {
PaymentCard(FiservemeaPaymentCard),
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct FiservemeaPaymentsRequest {
request_type: FiservemeaRequestType,
merchant_transaction_id: String,
transaction_amount: FiservemeaTransactionAmount,
order: FiservemeaOrder,
payment_method: FiservemeaPaymentMethods,
}
impl TryFrom<&FiservemeaRouterData<&PaymentsAuthorizeRouterData>> for FiservemeaPaymentsRequest {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: &FiservemeaRouterData<&PaymentsAuthorizeRouterData>,
) -> Result<Self, Self::Error> {
match item.router_data.request.payment_method_data.clone() {
PaymentMethodData::Card(req_card) => {
let card = FiservemeaPaymentCard {
number: req_card.card_number.clone(),
expiry_date: FiservemeaExpiryDate {
month: req_card.card_exp_month.clone(),
year: req_card.get_card_expiry_year_2_digit()?,
},
security_code: req_card.card_cvc,
};
let request_type = if matches!(
item.router_data.request.capture_method,
Some(enums::CaptureMethod::Automatic)
| Some(enums::CaptureMethod::SequentialAutomatic)
) {
FiservemeaRequestType::PaymentCardSaleTransaction
} else {
FiservemeaRequestType::PaymentCardPreAuthTransaction
};
Ok(Self {
request_type,
merchant_transaction_id: item
.router_data
.request
.merchant_order_reference_id
.clone()
.unwrap_or(item.router_data.connector_request_reference_id.clone()),
transaction_amount: FiservemeaTransactionAmount {
total: item.amount.clone(),
currency: item.router_data.request.currency,
},
order: FiservemeaOrder {
order_id: item.router_data.connector_request_reference_id.clone(),
},
payment_method: FiservemeaPaymentMethods::PaymentCard(card),
})
}
_ => Err(errors::ConnectorError::NotImplemented(
"Selected payment method through fiservemea".to_string(),
)
.into()),
}
}
}
// Auth Struct
#[derive(Clone)]
pub struct FiservemeaAuthType {
pub(super) api_key: Secret<String>,
pub(super) secret_key: Secret<String>,
}
impl TryFrom<&ConnectorAuthType> for FiservemeaAuthType {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(auth_type: &ConnectorAuthType) -> Result<Self, Self::Error> {
match auth_type {
ConnectorAuthType::BodyKey { api_key, key1 } => Ok(Self {
api_key: api_key.to_owned(),
secret_key: key1.to_owned(),
}),
_ => Err(errors::ConnectorError::FailedToObtainAuthType.into()),
}
}
}
// PaymentsResponse
#[derive(Debug, Serialize, Deserialize)]
pub enum ResponseType {
BadRequest,
Unauthenticated,
Unauthorized,
NotFound,
GatewayDeclined,
EndpointDeclined,
ServerError,
EndpointCommunicationError,
UnsupportedMediaType,
}
#[derive(Debug, Serialize, Deserialize, PartialEq)]
#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
pub enum FiservemeaTransactionType {
Sale,
Preauth,
Credit,
ForcedTicket,
Void,
Return,
Postauth,
PayerAuth,
Disbursement,
}
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "UPPERCASE")]
pub enum FiservemeaTransactionOrigin {
Ecom,
Moto,
Mail,
Phone,
Retail,
}
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
pub enum FiservemeaPaymentStatus {
Approved,
Waiting,
Partial,
ValidationFailed,
ProcessingFailed,
Declined,
}
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
pub enum FiservemeaPaymentResult {
Approved,
Declined,
Failed,
Waiting,
Partial,
Fraud,
}
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct FiservemeaPaymentCardResponse {
expiry_date: Option<FiservemeaExpiryDate>,
bin: Option<String>,
last4: Option<String>,
brand: Option<String>,
}
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct FiservemeaPaymentMethodDetails {
payment_card: Option<FiservemeaPaymentCardResponse>,
payment_method_type: Option<String>,
payment_method_brand: Option<String>,
}
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Components {
subtotal: Option<f64>,
}
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct AmountDetails {
total: Option<f64>,
currency: Option<common_enums::Currency>,
components: Option<Components>,
}
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct AvsResponse {
street_match: Option<String>,
postal_code_match: Option<String>,
}
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Processor {
reference_number: Option<String>,
authorization_code: Option<String>,
response_code: Option<String>,
response_message: Option<String>,
avs_response: Option<AvsResponse>,
security_code_response: Option<String>,
}
fn map_status(
fiservemea_status: Option<FiservemeaPaymentStatus>,
fiservemea_result: Option<FiservemeaPaymentResult>,
transaction_type: FiservemeaTransactionType,
) -> common_enums::AttemptStatus {
match fiservemea_status {
Some(status) => match status {
FiservemeaPaymentStatus::Approved => match transaction_type {
FiservemeaTransactionType::Preauth => common_enums::AttemptStatus::Authorized,
FiservemeaTransactionType::Void => common_enums::AttemptStatus::Voided,
FiservemeaTransactionType::Sale | FiservemeaTransactionType::Postauth => {
common_enums::AttemptStatus::Charged
}
FiservemeaTransactionType::Credit
| FiservemeaTransactionType::ForcedTicket
| FiservemeaTransactionType::Return
| FiservemeaTransactionType::PayerAuth
| FiservemeaTransactionType::Disbursement => common_enums::AttemptStatus::Failure,
},
FiservemeaPaymentStatus::Waiting => common_enums::AttemptStatus::Pending,
FiservemeaPaymentStatus::Partial => common_enums::AttemptStatus::PartialCharged,
FiservemeaPaymentStatus::ValidationFailed
| FiservemeaPaymentStatus::ProcessingFailed
| FiservemeaPaymentStatus::Declined => common_enums::AttemptStatus::Failure,
},
None => match fiservemea_result {
Some(result) => match result {
FiservemeaPaymentResult::Approved => match transaction_type {
FiservemeaTransactionType::Preauth => common_enums::AttemptStatus::Authorized,
FiservemeaTransactionType::Void => common_enums::AttemptStatus::Voided,
FiservemeaTransactionType::Sale | FiservemeaTransactionType::Postauth => {
common_enums::AttemptStatus::Charged
}
FiservemeaTransactionType::Credit
| FiservemeaTransactionType::ForcedTicket
| FiservemeaTransactionType::Return
| FiservemeaTransactionType::PayerAuth
| FiservemeaTransactionType::Disbursement => {
common_enums::AttemptStatus::Failure
}
},
FiservemeaPaymentResult::Waiting => common_enums::AttemptStatus::Pending,
FiservemeaPaymentResult::Partial => common_enums::AttemptStatus::PartialCharged,
FiservemeaPaymentResult::Declined
| FiservemeaPaymentResult::Failed
| FiservemeaPaymentResult::Fraud => common_enums::AttemptStatus::Failure,
},
None => common_enums::AttemptStatus::Pending,
},
}
}
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct FiservemeaPaymentsResponse {
response_type: Option<ResponseType>,
#[serde(rename = "type")]
fiservemea_type: Option<String>,
client_request_id: Option<String>,
api_trace_id: Option<String>,
ipg_transaction_id: String,
order_id: Option<String>,
transaction_type: FiservemeaTransactionType,
transaction_origin: Option<FiservemeaTransactionOrigin>,
payment_method_details: Option<FiservemeaPaymentMethodDetails>,
country: Option<Secret<String>>,
terminal_id: Option<String>,
merchant_id: Option<String>,
merchant_transaction_id: Option<String>,
transaction_time: Option<i64>,
approved_amount: Option<AmountDetails>,
transaction_amount: Option<AmountDetails>,
transaction_status: Option<FiservemeaPaymentStatus>, // FiservEMEA Docs mention that this field is deprecated. We are using it for now because transaction_result is not present in the response.
transaction_result: Option<FiservemeaPaymentResult>,
approval_code: Option<String>,
error_message: Option<String>,
transaction_state: Option<String>,
scheme_transaction_id: Option<String>,
processor: Option<Processor>,
}
impl<F, T> TryFrom<ResponseRouterData<F, FiservemeaPaymentsResponse, T, PaymentsResponseData>>
for RouterData<F, T, PaymentsResponseData>
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: ResponseRouterData<F, FiservemeaPaymentsResponse, T, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
Ok(Self {
status: map_status(
item.response.transaction_status,
item.response.transaction_result,
item.response.transaction_type,
),
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(item.response.ipg_transaction_id),
redirection_data: Box::new(None),
mandate_reference: Box::new(None),
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: item.response.order_id,
incremental_authorization_allowed: None,
charges: None,
}),
..item.data
})
}
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct FiservemeaCaptureRequest {
request_type: FiservemeaRequestType,
transaction_amount: FiservemeaTransactionAmount,
}
impl TryFrom<&FiservemeaRouterData<&PaymentsCaptureRouterData>> for FiservemeaCaptureRequest {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: &FiservemeaRouterData<&PaymentsCaptureRouterData>,
) -> Result<Self, Self::Error> {
Ok(Self {
request_type: FiservemeaRequestType::PostAuthTransaction,
transaction_amount: FiservemeaTransactionAmount {
total: item.amount.clone(),
currency: item.router_data.request.currency,
},
})
}
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct FiservemeaVoidRequest {
request_type: FiservemeaRequestType,
}
impl TryFrom<&PaymentsCancelRouterData> for FiservemeaVoidRequest {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(_item: &PaymentsCancelRouterData) -> Result<Self, Self::Error> {
Ok(Self {
request_type: FiservemeaRequestType::VoidPreAuthTransactions,
})
}
}
// REFUND :
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct FiservemeaRefundRequest {
request_type: FiservemeaRequestType,
transaction_amount: FiservemeaTransactionAmount,
}
impl<F> TryFrom<&FiservemeaRouterData<&RefundsRouterData<F>>> for FiservemeaRefundRequest {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(item: &FiservemeaRouterData<&RefundsRouterData<F>>) -> Result<Self, Self::Error> {
Ok(Self {
request_type: FiservemeaRequestType::ReturnTransaction,
transaction_amount: FiservemeaTransactionAmount {
total: item.amount.clone(),
currency: item.router_data.request.currency,
},
})
}
}
fn map_refund_status(
fiservemea_status: Option<FiservemeaPaymentStatus>,
fiservemea_result: Option<FiservemeaPaymentResult>,
) -> Result<enums::RefundStatus, errors::ConnectorError> {
match fiservemea_status {
Some(status) => match status {
FiservemeaPaymentStatus::Approved => Ok(enums::RefundStatus::Success),
FiservemeaPaymentStatus::Partial | FiservemeaPaymentStatus::Waiting => {
Ok(enums::RefundStatus::Pending)
}
FiservemeaPaymentStatus::ValidationFailed
| FiservemeaPaymentStatus::ProcessingFailed
| FiservemeaPaymentStatus::Declined => Ok(enums::RefundStatus::Failure),
},
None => match fiservemea_result {
Some(result) => match result {
FiservemeaPaymentResult::Approved => Ok(enums::RefundStatus::Success),
FiservemeaPaymentResult::Partial | FiservemeaPaymentResult::Waiting => {
Ok(enums::RefundStatus::Pending)
}
FiservemeaPaymentResult::Declined
| FiservemeaPaymentResult::Failed
| FiservemeaPaymentResult::Fraud => Ok(enums::RefundStatus::Failure),
},
None => Err(errors::ConnectorError::MissingRequiredField {
field_name: "transactionResult",
}),
},
}
}
impl TryFrom<RefundsResponseRouterData<Execute, FiservemeaPaymentsResponse>>
for RefundsRouterData<Execute>
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: RefundsResponseRouterData<Execute, FiservemeaPaymentsResponse>,
) -> Result<Self, Self::Error> {
Ok(Self {
response: Ok(RefundsResponseData {
connector_refund_id: item.response.ipg_transaction_id,
refund_status: map_refund_status(
item.response.transaction_status,
item.response.transaction_result,
)?,
}),
..item.data
})
}
}
impl TryFrom<RefundsResponseRouterData<RSync, FiservemeaPaymentsResponse>>
for RefundsRouterData<RSync>
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: RefundsResponseRouterData<RSync, FiservemeaPaymentsResponse>,
) -> Result<Self, Self::Error> {
Ok(Self {
response: Ok(RefundsResponseData {
connector_refund_id: item.response.ipg_transaction_id,
refund_status: map_refund_status(
item.response.transaction_status,
item.response.transaction_result,
)?,
}),
..item.data
})
}
}
#[derive(Debug, Serialize, Deserialize)]
pub struct ErrorDetails {
pub field: Option<String>,
pub message: Option<String>,
}
#[derive(Debug, Serialize, Deserialize)]
pub struct FiservemeaError {
pub code: Option<String>,
pub message: Option<String>,
pub details: Option<Vec<ErrorDetails>>,
}
#[derive(Debug, Serialize, Deserialize)]
pub struct FiservemeaErrorResponse {
#[serde(rename = "type")]
fiservemea_type: Option<String>,
client_request_id: Option<String>,
api_trace_id: Option<String>,
pub response_type: Option<String>,
pub error: Option<FiservemeaError>,
}
|
{
"crate": "hyperswitch_connectors",
"file": "crates/hyperswitch_connectors/src/connectors/fiservemea/transformers.rs",
"file_size": null,
"is_async": null,
"is_pub": null,
"num_enums": 7,
"num_structs": 19,
"num_tables": null,
"score": null,
"total_crates": null
}
|
file_hyperswitch_connectors_-2889474629620841961
|
clm
|
file
|
// Repository: hyperswitch
// Crate: hyperswitch_connectors
// File: crates/hyperswitch_connectors/src/connectors/boku/transformers.rs
// Contains: 17 structs, 5 enums
use std::fmt;
use common_enums::enums;
use common_utils::{request::Method, types::MinorUnit};
use hyperswitch_domain_models::{
payment_method_data::{PaymentMethodData, WalletData},
router_data::{ConnectorAuthType, RouterData},
router_flow_types::refunds::{Execute, RSync},
router_request_types::ResponseId,
router_response_types::{PaymentsResponseData, RedirectForm, RefundsResponseData},
types::{self, RefundsRouterData},
};
use hyperswitch_interfaces::errors;
use masking::Secret;
use serde::{Deserialize, Serialize};
use url::Url;
use uuid::Uuid;
use crate::{
types::{RefundsResponseRouterData, ResponseRouterData},
utils::{self, AddressDetailsData, RouterData as _},
};
#[derive(Debug, Serialize)]
pub struct BokuRouterData<T> {
pub amount: MinorUnit,
pub router_data: T,
}
impl<T> From<(MinorUnit, T)> for BokuRouterData<T> {
fn from((amount, router_data): (MinorUnit, T)) -> Self {
Self {
amount,
router_data,
}
}
}
#[derive(Debug, Clone, Serialize)]
#[serde(rename_all = "kebab-case")]
pub enum BokuPaymentsRequest {
BeginSingleCharge(SingleChargeData),
}
#[derive(Debug, Clone, Serialize)]
#[serde(rename_all = "kebab-case")]
pub struct SingleChargeData {
total_amount: MinorUnit,
currency: String,
country: String,
merchant_id: Secret<String>,
merchant_transaction_id: Secret<String>,
merchant_request_id: String,
merchant_item_description: String,
notification_url: Option<String>,
payment_method: String,
charge_type: String,
hosted: Option<BokuHostedData>,
}
#[derive(Debug, Clone, Serialize)]
pub enum BokuPaymentType {
Dana,
Momo,
Gcash,
GoPay,
Kakaopay,
}
impl fmt::Display for BokuPaymentType {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
Self::Dana => write!(f, "Dana"),
Self::Momo => write!(f, "Momo"),
Self::Gcash => write!(f, "Gcash"),
Self::GoPay => write!(f, "GoPay"),
Self::Kakaopay => write!(f, "Kakaopay"),
}
}
}
#[derive(Debug, Clone, Serialize)]
pub enum BokuChargeType {
Hosted,
}
impl fmt::Display for BokuChargeType {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
Self::Hosted => write!(f, "hosted"),
}
}
}
#[derive(Debug, Clone, Serialize)]
#[serde(rename_all = "kebab-case")]
struct BokuHostedData {
forward_url: String,
}
impl TryFrom<&BokuRouterData<&types::PaymentsAuthorizeRouterData>> for BokuPaymentsRequest {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: &BokuRouterData<&types::PaymentsAuthorizeRouterData>,
) -> Result<Self, Self::Error> {
match item.router_data.request.payment_method_data.clone() {
PaymentMethodData::Wallet(wallet_data) => Self::try_from((item, &wallet_data)),
PaymentMethodData::Card(_)
| PaymentMethodData::CardRedirect(_)
| PaymentMethodData::PayLater(_)
| PaymentMethodData::BankRedirect(_)
| PaymentMethodData::BankDebit(_)
| PaymentMethodData::BankTransfer(_)
| PaymentMethodData::Crypto(_)
| PaymentMethodData::MandatePayment
| PaymentMethodData::Reward
| PaymentMethodData::RealTimePayment(_)
| PaymentMethodData::MobilePayment(_)
| PaymentMethodData::Upi(_)
| PaymentMethodData::Voucher(_)
| PaymentMethodData::GiftCard(_)
| PaymentMethodData::OpenBanking(_)
| PaymentMethodData::CardToken(_)
| PaymentMethodData::NetworkToken(_)
| PaymentMethodData::CardDetailsForNetworkTransactionId(_) => {
Err(errors::ConnectorError::NotImplemented(
utils::get_unimplemented_payment_method_error_message("boku"),
))?
}
}
}
}
impl
TryFrom<(
&BokuRouterData<&types::PaymentsAuthorizeRouterData>,
&WalletData,
)> for BokuPaymentsRequest
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
value: (
&BokuRouterData<&types::PaymentsAuthorizeRouterData>,
&WalletData,
),
) -> Result<Self, Self::Error> {
let (item_router_data, wallet_data) = value;
let item = item_router_data.router_data;
let address = item.get_billing_address()?;
let country = address.get_country()?.to_string();
let payment_method = get_wallet_type(wallet_data)?;
let hosted = get_hosted_data(item);
let auth_type = BokuAuthType::try_from(&item.connector_auth_type)?;
let merchant_item_description = item.get_description()?;
let payment_data = SingleChargeData {
total_amount: item_router_data.amount,
currency: item.request.currency.to_string(),
country,
merchant_id: auth_type.merchant_id,
merchant_transaction_id: Secret::new(item.payment_id.to_string()),
merchant_request_id: Uuid::new_v4().to_string(),
merchant_item_description,
notification_url: item.request.webhook_url.clone(),
payment_method,
charge_type: BokuChargeType::Hosted.to_string(),
hosted,
};
Ok(Self::BeginSingleCharge(payment_data))
}
}
fn get_wallet_type(wallet_data: &WalletData) -> Result<String, errors::ConnectorError> {
match wallet_data {
WalletData::DanaRedirect { .. } => Ok(BokuPaymentType::Dana.to_string()),
WalletData::MomoRedirect { .. } => Ok(BokuPaymentType::Momo.to_string()),
WalletData::GcashRedirect { .. } => Ok(BokuPaymentType::Gcash.to_string()),
WalletData::GoPayRedirect { .. } => Ok(BokuPaymentType::GoPay.to_string()),
WalletData::KakaoPayRedirect { .. } => Ok(BokuPaymentType::Kakaopay.to_string()),
WalletData::AliPayQr(_)
| WalletData::AliPayRedirect(_)
| WalletData::AliPayHkRedirect(_)
| WalletData::AmazonPay(_)
| WalletData::AmazonPayRedirect(_)
| WalletData::Paysera(_)
| WalletData::Skrill(_)
| WalletData::BluecodeRedirect {}
| WalletData::ApplePay(_)
| WalletData::ApplePayRedirect(_)
| WalletData::ApplePayThirdPartySdk(_)
| WalletData::GooglePay(_)
| WalletData::GooglePayRedirect(_)
| WalletData::GooglePayThirdPartySdk(_)
| WalletData::MbWayRedirect(_)
| WalletData::MobilePayRedirect(_)
| WalletData::PaypalRedirect(_)
| WalletData::PaypalSdk(_)
| WalletData::Paze(_)
| WalletData::SamsungPay(_)
| WalletData::TwintRedirect {}
| WalletData::VippsRedirect {}
| WalletData::TouchNGoRedirect(_)
| WalletData::WeChatPayRedirect(_)
| WalletData::WeChatPayQr(_)
| WalletData::CashappQr(_)
| WalletData::SwishQr(_)
| WalletData::Mifinity(_)
| WalletData::RevolutPay(_) => Err(errors::ConnectorError::NotImplemented(
utils::get_unimplemented_payment_method_error_message("boku"),
)),
}
}
pub struct BokuAuthType {
pub(super) merchant_id: Secret<String>,
pub(super) key_id: Secret<String>,
}
impl TryFrom<&ConnectorAuthType> for BokuAuthType {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(auth_type: &ConnectorAuthType) -> Result<Self, Self::Error> {
match auth_type {
ConnectorAuthType::BodyKey { api_key, key1 } => Ok(Self {
merchant_id: key1.to_owned(),
key_id: api_key.to_owned(),
}),
_ => Err(errors::ConnectorError::FailedToObtainAuthType.into()),
}
}
}
#[derive(Debug, Clone, Serialize)]
#[serde(rename = "query-charge-request")]
#[serde(rename_all = "kebab-case")]
pub struct BokuPsyncRequest {
country: String,
merchant_id: Secret<String>,
merchant_transaction_id: Secret<String>,
}
impl TryFrom<&types::PaymentsSyncRouterData> for BokuPsyncRequest {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(item: &types::PaymentsSyncRouterData) -> Result<Self, Self::Error> {
let address = item.get_billing_address()?;
let country = address.get_country()?.to_string();
let auth_type = BokuAuthType::try_from(&item.connector_auth_type)?;
Ok(Self {
country,
merchant_id: auth_type.merchant_id,
merchant_transaction_id: Secret::new(item.payment_id.to_string()),
})
}
}
// Connector Meta Data
#[derive(Debug, Clone, Deserialize)]
pub struct BokuMetaData {
pub(super) country: String,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(rename_all = "kebab-case")]
pub enum BokuResponse {
BeginSingleChargeResponse(BokuPaymentsResponse),
QueryChargeResponse(BokuPsyncResponse),
}
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(rename_all = "kebab-case")]
pub struct BokuPaymentsResponse {
charge_status: String, // xml parse only string to fields
charge_id: String,
hosted: Option<HostedUrlResponse>,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(rename_all = "kebab-case")]
pub struct HostedUrlResponse {
redirect_url: Option<Url>,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(rename = "query-charge-response")]
#[serde(rename_all = "kebab-case")]
pub struct BokuPsyncResponse {
charges: ChargeResponseData,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(rename_all = "kebab-case")]
pub struct ChargeResponseData {
charge: SingleChargeResponseData,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(rename_all = "kebab-case")]
pub struct SingleChargeResponseData {
charge_status: String,
charge_id: String,
}
impl<F, T> TryFrom<ResponseRouterData<F, BokuResponse, T, PaymentsResponseData>>
for RouterData<F, T, PaymentsResponseData>
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: ResponseRouterData<F, BokuResponse, T, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
let (status, transaction_id, redirection_data) = match item.response {
BokuResponse::BeginSingleChargeResponse(response) => get_authorize_response(response),
BokuResponse::QueryChargeResponse(response) => get_psync_response(response),
}?;
Ok(Self {
status,
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(transaction_id),
redirection_data: Box::new(redirection_data),
mandate_reference: Box::new(None),
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: None,
incremental_authorization_allowed: None,
charges: None,
}),
..item.data
})
}
}
fn get_response_status(status: String) -> enums::AttemptStatus {
match status.as_str() {
"Success" => enums::AttemptStatus::Charged,
"Failure" => enums::AttemptStatus::Failure,
_ => enums::AttemptStatus::Pending,
}
}
fn get_authorize_response(
response: BokuPaymentsResponse,
) -> Result<(enums::AttemptStatus, String, Option<RedirectForm>), errors::ConnectorError> {
let status = get_response_status(response.charge_status);
let redirection_data = match response.hosted {
Some(hosted_value) => Ok(hosted_value
.redirect_url
.map(|url| RedirectForm::from((url, Method::Get)))),
None => Err(errors::ConnectorError::MissingConnectorRedirectionPayload {
field_name: "redirect_url",
}),
}?;
Ok((status, response.charge_id, redirection_data))
}
fn get_psync_response(
response: BokuPsyncResponse,
) -> Result<(enums::AttemptStatus, String, Option<RedirectForm>), errors::ConnectorError> {
let status = get_response_status(response.charges.charge.charge_status);
Ok((status, response.charges.charge.charge_id, None))
}
// REFUND :
#[derive(Debug, Clone, Serialize)]
#[serde(rename = "refund-charge-request")]
pub struct BokuRefundRequest {
refund_amount: MinorUnit,
merchant_id: Secret<String>,
merchant_request_id: String,
merchant_refund_id: Secret<String>,
charge_id: String,
reason_code: String,
}
#[derive(Debug, Clone, Serialize)]
pub enum BokuRefundReasonCode {
NonFulfillment,
}
impl fmt::Display for BokuRefundReasonCode {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
Self::NonFulfillment => write!(f, "8"),
}
}
}
impl<F> TryFrom<&BokuRouterData<&RefundsRouterData<F>>> for BokuRefundRequest {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(item: &BokuRouterData<&RefundsRouterData<F>>) -> Result<Self, Self::Error> {
let auth_type = BokuAuthType::try_from(&item.router_data.connector_auth_type)?;
let payment_data = Self {
refund_amount: item.amount,
merchant_id: auth_type.merchant_id,
merchant_refund_id: Secret::new(item.router_data.request.refund_id.to_string()),
merchant_request_id: Uuid::new_v4().to_string(),
charge_id: item
.router_data
.request
.connector_transaction_id
.to_string(),
reason_code: BokuRefundReasonCode::NonFulfillment.to_string(),
};
Ok(payment_data)
}
}
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(rename = "refund-charge-response")]
pub struct RefundResponse {
charge_id: String,
refund_status: String,
}
fn get_refund_status(status: String) -> enums::RefundStatus {
match status.as_str() {
"Success" => enums::RefundStatus::Success,
"Failure" => enums::RefundStatus::Failure,
_ => enums::RefundStatus::Pending,
}
}
impl TryFrom<RefundsResponseRouterData<Execute, RefundResponse>> for RefundsRouterData<Execute> {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: RefundsResponseRouterData<Execute, RefundResponse>,
) -> Result<Self, Self::Error> {
Ok(Self {
response: Ok(RefundsResponseData {
connector_refund_id: item.response.charge_id,
refund_status: get_refund_status(item.response.refund_status),
}),
..item.data
})
}
}
#[derive(Debug, Clone, Serialize)]
#[serde(rename = "query-refund-request")]
#[serde(rename_all = "kebab-case")]
pub struct BokuRsyncRequest {
country: String,
merchant_id: Secret<String>,
merchant_transaction_id: Secret<String>,
}
impl TryFrom<&types::RefundSyncRouterData> for BokuRsyncRequest {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(item: &types::RefundSyncRouterData) -> Result<Self, Self::Error> {
let address = item.get_billing_address()?;
let country = address.get_country()?.to_string();
let auth_type = BokuAuthType::try_from(&item.connector_auth_type)?;
Ok(Self {
country,
merchant_id: auth_type.merchant_id,
merchant_transaction_id: Secret::new(item.payment_id.to_string()),
})
}
}
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(rename = "query-refund-response")]
#[serde(rename_all = "kebab-case")]
pub struct BokuRsyncResponse {
refunds: RefundResponseData,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(rename_all = "kebab-case")]
pub struct RefundResponseData {
refund: SingleRefundResponseData,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(rename_all = "kebab-case")]
pub struct SingleRefundResponseData {
refund_status: String, // quick-xml only parse string as a field
refund_id: String,
}
impl TryFrom<RefundsResponseRouterData<RSync, BokuRsyncResponse>> for RefundsRouterData<RSync> {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: RefundsResponseRouterData<RSync, BokuRsyncResponse>,
) -> Result<Self, Self::Error> {
Ok(Self {
response: Ok(RefundsResponseData {
connector_refund_id: item.response.refunds.refund.refund_id,
refund_status: get_refund_status(item.response.refunds.refund.refund_status),
}),
..item.data
})
}
}
#[derive(Default, Debug, Serialize, Deserialize, PartialEq)]
pub struct BokuErrorResponse {
pub status_code: u16,
pub code: String,
pub message: String,
pub reason: Option<String>,
}
fn get_hosted_data(item: &types::PaymentsAuthorizeRouterData) -> Option<BokuHostedData> {
item.request
.router_return_url
.clone()
.map(|url| BokuHostedData { forward_url: url })
}
|
{
"crate": "hyperswitch_connectors",
"file": "crates/hyperswitch_connectors/src/connectors/boku/transformers.rs",
"file_size": null,
"is_async": null,
"is_pub": null,
"num_enums": 5,
"num_structs": 17,
"num_tables": null,
"score": null,
"total_crates": null
}
|
file_hyperswitch_connectors_-6752871801894633542
|
clm
|
file
|
// Repository: hyperswitch
// Crate: hyperswitch_connectors
// File: crates/hyperswitch_connectors/src/connectors/coinbase/transformers.rs
// Contains: 23 structs, 4 enums
use std::collections::HashMap;
use common_enums::enums;
use common_utils::{pii, request::Method, types::StringMajorUnit};
use error_stack::ResultExt;
use hyperswitch_domain_models::{
router_data::{ConnectorAuthType, RouterData},
router_flow_types::refunds::{Execute, RSync},
router_request_types::ResponseId,
router_response_types::{PaymentsResponseData, RedirectForm},
types::{self, PaymentsAuthorizeRouterData},
};
use hyperswitch_interfaces::errors;
use masking::Secret;
use serde::{Deserialize, Serialize};
use crate::{
types::{RefundsResponseRouterData, ResponseRouterData},
utils::{
self, AddressDetailsData, PaymentsAuthorizeRequestData, RouterData as OtherRouterData,
},
};
#[derive(Debug, Serialize)]
pub struct CoinbaseRouterData<T> {
amount: StringMajorUnit,
router_data: T,
}
impl<T> From<(StringMajorUnit, T)> for CoinbaseRouterData<T> {
fn from((amount, item): (StringMajorUnit, T)) -> Self {
Self {
amount,
router_data: item,
}
}
}
#[derive(Debug, Default, Eq, PartialEq, Serialize)]
pub struct LocalPrice {
pub amount: StringMajorUnit,
pub currency: String,
}
#[derive(Debug, Default, Eq, PartialEq, Serialize, Deserialize)]
pub struct Metadata {
pub customer_id: Option<String>,
pub customer_name: Option<Secret<String>>,
}
#[derive(Default, Debug, Serialize, Eq, PartialEq)]
pub struct CoinbasePaymentsRequest {
pub name: Option<Secret<String>>,
pub description: Option<String>,
pub pricing_type: String,
pub local_price: LocalPrice,
pub redirect_url: String,
pub cancel_url: String,
}
impl TryFrom<&CoinbaseRouterData<&PaymentsAuthorizeRouterData>> for CoinbasePaymentsRequest {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: &CoinbaseRouterData<&PaymentsAuthorizeRouterData>,
) -> Result<Self, Self::Error> {
get_crypto_specific_payment_data(item)
}
}
// Auth Struct
pub struct CoinbaseAuthType {
pub(super) api_key: Secret<String>,
}
impl TryFrom<&ConnectorAuthType> for CoinbaseAuthType {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(_auth_type: &ConnectorAuthType) -> Result<Self, Self::Error> {
if let ConnectorAuthType::HeaderKey { api_key } = _auth_type {
Ok(Self {
api_key: api_key.to_owned(),
})
} else {
Err(errors::ConnectorError::FailedToObtainAuthType.into())
}
}
}
// PaymentsResponse
#[derive(Debug, Clone, Default, Serialize, Deserialize, PartialEq)]
#[serde(rename_all = "UPPERCASE")]
pub enum CoinbasePaymentStatus {
New,
#[default]
Pending,
Completed,
Expired,
Unresolved,
Resolved,
Canceled,
#[serde(rename = "PENDING REFUND")]
PendingRefund,
Refunded,
}
impl From<CoinbasePaymentStatus> for enums::AttemptStatus {
fn from(item: CoinbasePaymentStatus) -> Self {
match item {
CoinbasePaymentStatus::Completed | CoinbasePaymentStatus::Resolved => Self::Charged,
CoinbasePaymentStatus::Expired => Self::Failure,
CoinbasePaymentStatus::New => Self::AuthenticationPending,
CoinbasePaymentStatus::Unresolved => Self::Unresolved,
CoinbasePaymentStatus::Canceled => Self::Voided,
_ => Self::Pending,
}
}
}
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, strum::Display)]
#[serde(rename_all = "UPPERCASE")]
#[strum(serialize_all = "UPPERCASE")]
pub enum UnResolvedContext {
Underpaid,
Overpaid,
Delayed,
}
#[derive(Default, Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct Timeline {
status: CoinbasePaymentStatus,
context: Option<UnResolvedContext>,
time: String,
pub payment: Option<TimelinePayment>,
}
#[derive(Default, Debug, Serialize, Deserialize)]
pub struct CoinbasePaymentsResponse {
// status: CoinbasePaymentStatus,
// id: String,
data: CoinbasePaymentResponseData,
}
impl<F, T> TryFrom<ResponseRouterData<F, CoinbasePaymentsResponse, T, PaymentsResponseData>>
for RouterData<F, T, PaymentsResponseData>
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: ResponseRouterData<F, CoinbasePaymentsResponse, T, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
let form_fields = HashMap::new();
let redirection_data = RedirectForm::Form {
endpoint: item.response.data.hosted_url.to_string(),
method: Method::Get,
form_fields,
};
let timeline = item
.response
.data
.timeline
.last()
.ok_or(errors::ConnectorError::ResponseHandlingFailed)?
.clone();
let connector_id = ResponseId::ConnectorTransactionId(item.response.data.id.clone());
let attempt_status = timeline.status.clone();
let response_data = timeline.context.map_or(
Ok(PaymentsResponseData::TransactionResponse {
resource_id: connector_id.clone(),
redirection_data: Box::new(Some(redirection_data)),
mandate_reference: Box::new(None),
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: Some(item.response.data.id.clone()),
incremental_authorization_allowed: None,
charges: None,
}),
|context| {
Ok(PaymentsResponseData::TransactionUnresolvedResponse{
resource_id: connector_id,
reason: Some(api_models::enums::UnresolvedResponseReason {
code: context.to_string(),
message: "Please check the transaction in coinbase dashboard and resolve manually"
.to_string(),
}),
connector_response_reference_id: Some(item.response.data.id),
})
},
);
Ok(Self {
status: enums::AttemptStatus::from(attempt_status),
response: response_data,
..item.data
})
}
}
// REFUND :
// Type definition for RefundRequest
#[derive(Default, Debug, Serialize)]
pub struct CoinbaseRefundRequest {}
impl<F> TryFrom<&types::RefundsRouterData<F>> for CoinbaseRefundRequest {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(_item: &types::RefundsRouterData<F>) -> Result<Self, Self::Error> {
Err(errors::ConnectorError::NotImplemented("try_from RefundsRouterData".to_string()).into())
}
}
// Type definition for Refund Response
#[allow(dead_code)]
#[derive(Debug, Serialize, Default, Deserialize, Clone)]
pub enum RefundStatus {
Succeeded,
Failed,
#[default]
Processing,
}
impl From<RefundStatus> for enums::RefundStatus {
fn from(item: RefundStatus) -> Self {
match item {
RefundStatus::Succeeded => Self::Success,
RefundStatus::Failed => Self::Failure,
RefundStatus::Processing => Self::Pending,
}
}
}
#[derive(Default, Debug, Clone, Serialize, Deserialize)]
pub struct RefundResponse {}
impl TryFrom<RefundsResponseRouterData<Execute, RefundResponse>>
for types::RefundsRouterData<Execute>
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
_item: RefundsResponseRouterData<Execute, RefundResponse>,
) -> Result<Self, Self::Error> {
Err(errors::ConnectorError::NotImplemented(
"try_from RefundsResponseRouterData".to_string(),
)
.into())
}
}
impl TryFrom<RefundsResponseRouterData<RSync, RefundResponse>> for types::RefundsRouterData<RSync> {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
_item: RefundsResponseRouterData<RSync, RefundResponse>,
) -> Result<Self, Self::Error> {
Err(errors::ConnectorError::NotImplemented(
"try_from RefundsResponseRouterData".to_string(),
)
.into())
}
}
#[derive(Debug, Deserialize, Serialize)]
pub struct CoinbaseErrorData {
#[serde(rename = "type")]
pub error_type: String,
pub message: String,
pub code: Option<String>,
}
#[derive(Debug, Deserialize, Serialize)]
pub struct CoinbaseErrorResponse {
pub error: CoinbaseErrorData,
}
#[derive(Default, Debug, Deserialize, PartialEq)]
pub struct CoinbaseConnectorMeta {
pub pricing_type: String,
}
impl TryFrom<&Option<pii::SecretSerdeValue>> for CoinbaseConnectorMeta {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(meta_data: &Option<pii::SecretSerdeValue>) -> Result<Self, Self::Error> {
utils::to_connector_meta_from_secret(meta_data.clone())
.change_context(errors::ConnectorError::InvalidConnectorConfig { config: "metadata" })
}
}
fn get_crypto_specific_payment_data(
item: &CoinbaseRouterData<&PaymentsAuthorizeRouterData>,
) -> Result<CoinbasePaymentsRequest, error_stack::Report<errors::ConnectorError>> {
let billing_address = item
.router_data
.get_billing()
.ok()
.and_then(|billing_address| billing_address.address.as_ref());
let name =
billing_address.and_then(|add| add.get_first_name().ok().map(|name| name.to_owned()));
let description = item.router_data.get_description().ok();
let connector_meta = CoinbaseConnectorMeta::try_from(&item.router_data.connector_meta_data)
.change_context(errors::ConnectorError::InvalidConnectorConfig {
config: "Merchant connector account metadata",
})?;
let pricing_type = connector_meta.pricing_type;
let local_price = get_local_price(item);
let redirect_url = item.router_data.request.get_router_return_url()?;
let cancel_url = item.router_data.request.get_router_return_url()?;
Ok(CoinbasePaymentsRequest {
name,
description,
pricing_type,
local_price,
redirect_url,
cancel_url,
})
}
fn get_local_price(item: &CoinbaseRouterData<&PaymentsAuthorizeRouterData>) -> LocalPrice {
LocalPrice {
amount: item.amount.clone(),
currency: item.router_data.request.currency.to_string(),
}
}
#[derive(Debug, Serialize, Deserialize)]
pub struct CoinbaseWebhookDetails {
pub attempt_number: i64,
pub event: Event,
pub id: String,
pub scheduled_for: String,
}
#[derive(Debug, Serialize, Deserialize)]
pub struct Event {
pub api_version: String,
pub created_at: String,
pub data: CoinbasePaymentResponseData,
pub id: String,
pub resource: String,
#[serde(rename = "type")]
pub event_type: WebhookEventType,
}
#[derive(Debug, Serialize, Deserialize)]
pub enum WebhookEventType {
#[serde(rename = "charge:confirmed")]
Confirmed,
#[serde(rename = "charge:created")]
Created,
#[serde(rename = "charge:pending")]
Pending,
#[serde(rename = "charge:failed")]
Failed,
#[serde(rename = "charge:resolved")]
Resolved,
#[serde(other)]
Unknown,
}
#[derive(Debug, Default, Serialize, Deserialize)]
pub struct Redirects {
cancel_url: Option<String>,
success_url: Option<String>,
will_redirect_after_success: bool,
}
#[derive(Debug, Default, Serialize, Deserialize)]
pub struct CoinbasePaymentResponseData {
pub id: String,
pub code: String,
pub name: Option<Secret<String>>,
pub utxo: Option<bool>,
pub pricing: HashMap<String, OverpaymentAbsoluteThreshold>,
pub fee_rate: Option<f64>,
pub logo_url: Option<String>,
pub metadata: Option<Metadata>,
pub payments: Vec<PaymentElement>,
pub resource: Option<String>,
pub timeline: Vec<Timeline>,
pub pwcb_only: bool,
pub created_at: String,
pub expires_at: String,
pub hosted_url: String,
pub brand_color: String,
pub description: Option<String>,
pub confirmed_at: Option<String>,
pub fees_settled: Option<bool>,
pub pricing_type: String,
pub redirects: Redirects,
pub support_email: pii::Email,
pub brand_logo_url: String,
pub offchain_eligible: Option<bool>,
pub organization_name: String,
pub payment_threshold: Option<PaymentThreshold>,
pub coinbase_managed_merchant: Option<bool>,
}
#[derive(Debug, Serialize, Default, Deserialize)]
pub struct PaymentThreshold {
pub overpayment_absolute_threshold: OverpaymentAbsoluteThreshold,
pub overpayment_relative_threshold: String,
pub underpayment_absolute_threshold: OverpaymentAbsoluteThreshold,
pub underpayment_relative_threshold: String,
}
#[derive(Debug, Clone, Serialize, Default, Deserialize, PartialEq, Eq)]
pub struct OverpaymentAbsoluteThreshold {
pub amount: StringMajorUnit,
pub currency: String,
}
#[derive(Debug, Serialize, Deserialize)]
pub struct PaymentElement {
pub net: CoinbaseProcessingFee,
pub block: Block,
pub value: CoinbaseProcessingFee,
pub status: String,
pub network: String,
pub deposited: Deposited,
pub payment_id: String,
pub detected_at: String,
pub transaction_id: String,
pub coinbase_processing_fee: CoinbaseProcessingFee,
}
#[derive(Debug, Serialize, Deserialize)]
pub struct Block {
pub hash: Option<String>,
pub height: Option<i64>,
pub confirmations: Option<i64>,
pub confirmations_required: Option<i64>,
}
#[derive(Debug, Serialize, Deserialize)]
pub struct CoinbaseProcessingFee {
pub local: Option<OverpaymentAbsoluteThreshold>,
pub crypto: OverpaymentAbsoluteThreshold,
}
#[derive(Debug, Serialize, Deserialize)]
pub struct Deposited {
pub amount: Amount,
pub status: String,
pub destination: String,
pub exchange_rate: Option<serde_json::Value>,
pub autoconversion_status: String,
pub autoconversion_enabled: bool,
}
#[derive(Debug, Serialize, Deserialize)]
pub struct Amount {
pub net: CoinbaseProcessingFee,
pub gross: CoinbaseProcessingFee,
pub coinbase_fee: CoinbaseProcessingFee,
}
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
pub struct TimelinePayment {
pub value: OverpaymentAbsoluteThreshold,
pub network: String,
pub transaction_id: String,
}
|
{
"crate": "hyperswitch_connectors",
"file": "crates/hyperswitch_connectors/src/connectors/coinbase/transformers.rs",
"file_size": null,
"is_async": null,
"is_pub": null,
"num_enums": 4,
"num_structs": 23,
"num_tables": null,
"score": null,
"total_crates": null
}
|
file_hyperswitch_connectors_-5376113245993945753
|
clm
|
file
|
// Repository: hyperswitch
// Crate: hyperswitch_connectors
// File: crates/hyperswitch_connectors/src/connectors/zsl/transformers.rs
// Contains: 5 structs, 6 enums
use std::collections::HashMap;
use base64::Engine;
use common_enums::enums;
use common_utils::{crypto::GenerateDigest, date_time, pii::Email, request::Method};
use error_stack::ResultExt;
use hyperswitch_domain_models::{
payment_method_data::{BankTransferData, PaymentMethodData},
router_data::{ConnectorAuthType, ErrorResponse, RouterData},
router_request_types::{PaymentsSyncData, ResponseId},
router_response_types::{PaymentsResponseData, RedirectForm},
types,
};
use hyperswitch_interfaces::{api, consts::NO_ERROR_CODE, errors};
use masking::{ExposeInterface, Secret};
use ring::digest;
use serde::{Deserialize, Serialize};
use crate::{
types::ResponseRouterData,
utils::{
get_amount_as_string, get_unimplemented_payment_method_error_message,
PaymentsAuthorizeRequestData, RouterData as _,
},
};
mod auth_error {
pub const INVALID_SIGNATURE: &str = "INVALID_SIGNATURE";
}
mod zsl_version {
pub const VERSION_1: &str = "1";
}
pub struct ZslRouterData<T> {
pub amount: String,
pub router_data: T,
}
impl<T> TryFrom<(&api::CurrencyUnit, enums::Currency, i64, T)> for ZslRouterData<T> {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
(currency_unit, currency, txn_amount, item): (&api::CurrencyUnit, enums::Currency, i64, T),
) -> Result<Self, Self::Error> {
let amount = get_amount_as_string(currency_unit, txn_amount, currency)?;
Ok(Self {
amount,
router_data: item,
})
}
}
pub struct ZslAuthType {
pub(super) api_key: Secret<String>,
pub(super) merchant_id: Secret<String>,
}
impl TryFrom<&ConnectorAuthType> for ZslAuthType {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(auth_type: &ConnectorAuthType) -> Result<Self, Self::Error> {
match auth_type {
ConnectorAuthType::BodyKey { api_key, key1 } => Ok(Self {
api_key: api_key.to_owned(),
merchant_id: key1.clone(),
}),
_ => Err(errors::ConnectorError::FailedToObtainAuthType.into()),
}
}
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ZslPaymentsRequest {
process_type: ProcessType,
process_code: ProcessCode,
txn_amt: String,
ccy: api_models::enums::Currency,
mer_ref: String,
mer_txn_date: String,
mer_id: Secret<String>,
lang: String,
success_url: String,
failure_url: String,
success_s2s_url: String,
failure_s2s_url: String,
enctype: EncodingType,
signature: Secret<String>,
country: api_models::enums::CountryAlpha2,
verno: String,
service_code: ServiceCode,
cust_tag: String,
#[serde(flatten)]
payment_method: ZslPaymentMethods,
name: Option<Secret<String>>,
family_name: Option<Secret<String>>,
tel_phone: Option<Secret<String>>,
email: Option<Email>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum ZslPaymentMethods {
LocalBankTransfer(LocalBankTransaferRequest),
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct LocalBankTransaferRequest {
bank_code: Option<String>,
pay_method: Option<String>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum ProcessType {
#[serde(rename = "0200")]
PaymentRequest,
#[serde(rename = "0208")]
PaymentResponse,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum ProcessCode {
#[serde(rename = "200002")]
API,
#[serde(rename = "200003")]
CallBack,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum EncodingType {
#[serde(rename = "1")]
MD5,
#[serde(rename = "2")]
Sha1,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "UPPERCASE")]
pub enum ServiceCode {
MPG,
}
impl TryFrom<&ZslRouterData<&types::PaymentsAuthorizeRouterData>> for ZslPaymentsRequest {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: &ZslRouterData<&types::PaymentsAuthorizeRouterData>,
) -> Result<Self, Self::Error> {
let payment_method = match item.router_data.request.payment_method_data.clone() {
PaymentMethodData::BankTransfer(bank_transfer_data) => match *bank_transfer_data {
BankTransferData::LocalBankTransfer { bank_code } => Ok(
ZslPaymentMethods::LocalBankTransfer(LocalBankTransaferRequest {
bank_code,
pay_method: None,
}),
),
BankTransferData::AchBankTransfer { .. }
| BankTransferData::SepaBankTransfer { .. }
| BankTransferData::BacsBankTransfer { .. }
| BankTransferData::MultibancoBankTransfer { .. }
| BankTransferData::PermataBankTransfer { .. }
| BankTransferData::BcaBankTransfer { .. }
| BankTransferData::BniVaBankTransfer { .. }
| BankTransferData::BriVaBankTransfer { .. }
| BankTransferData::CimbVaBankTransfer { .. }
| BankTransferData::DanamonVaBankTransfer { .. }
| BankTransferData::MandiriVaBankTransfer { .. }
| BankTransferData::Pix { .. }
| BankTransferData::Pse {}
| BankTransferData::InstantBankTransferFinland {}
| BankTransferData::InstantBankTransferPoland {}
| BankTransferData::IndonesianBankTransfer { .. }
| BankTransferData::InstantBankTransfer {} => {
Err(errors::ConnectorError::NotImplemented(
get_unimplemented_payment_method_error_message(
item.router_data.connector.as_str(),
),
))
}
},
PaymentMethodData::Card(_)
| PaymentMethodData::CardRedirect(_)
| PaymentMethodData::Wallet(_)
| PaymentMethodData::PayLater(_)
| PaymentMethodData::BankRedirect(_)
| PaymentMethodData::BankDebit(_)
| PaymentMethodData::Crypto(_)
| PaymentMethodData::MandatePayment
| PaymentMethodData::Reward
| PaymentMethodData::RealTimePayment(_)
| PaymentMethodData::MobilePayment(_)
| PaymentMethodData::Upi(_)
| PaymentMethodData::Voucher(_)
| PaymentMethodData::GiftCard(_)
| PaymentMethodData::CardToken(_)
| PaymentMethodData::NetworkToken(_)
| PaymentMethodData::CardDetailsForNetworkTransactionId(_)
| PaymentMethodData::OpenBanking(_) => Err(errors::ConnectorError::NotImplemented(
get_unimplemented_payment_method_error_message(item.router_data.connector.as_str()),
)),
}?;
let auth_type = ZslAuthType::try_from(&item.router_data.connector_auth_type)?;
let key: Secret<String> = auth_type.api_key;
let mer_id = auth_type.merchant_id;
let mer_txn_date =
date_time::format_date(date_time::now(), date_time::DateFormat::YYYYMMDDHHmmss)
.change_context(errors::ConnectorError::RequestEncodingFailed)?;
let txn_amt = item.amount.clone();
let ccy = item.router_data.request.currency;
let mer_ref = item.router_data.connector_request_reference_id.clone();
let signature = calculate_signature(
EncodingType::MD5,
ZslSignatureType::RequestSignature {
txn_amt: txn_amt.clone(),
ccy: ccy.to_string(),
mer_ref: mer_ref.clone(),
mer_id: mer_id.clone().expose(),
mer_txn_date: mer_txn_date.clone(),
key: key.expose(),
},
)?;
let tel_phone = item.router_data.get_optional_billing_phone_number();
let email = item.router_data.get_optional_billing_email();
let name = item.router_data.get_optional_billing_first_name();
let family_name = item.router_data.get_optional_billing_last_name();
let router_url = item.router_data.request.get_router_return_url()?;
let webhook_url = item.router_data.request.get_webhook_url()?;
let billing_country = item.router_data.get_billing_country()?;
let lang = item
.router_data
.request
.browser_info
.as_ref()
.and_then(|browser_data| {
browser_data.language.as_ref().map(|language| {
language
.split_once('-')
.map_or(language.to_uppercase(), |(lang, _)| lang.to_uppercase())
})
})
.ok_or(errors::ConnectorError::MissingRequiredField {
field_name: "browser_info.language",
})?;
let cust_tag = item
.router_data
.customer_id
.clone()
.and_then(|customer_id| {
let cust_id = customer_id.get_string_repr().replace(['_', '-'], "");
let id_len = cust_id.len();
if id_len > 10 {
cust_id.get(id_len - 10..id_len).map(|id| id.to_string())
} else {
Some(cust_id)
}
})
.ok_or(errors::ConnectorError::MissingRequiredField {
field_name: "customer_id",
})?;
Ok(Self {
process_type: ProcessType::PaymentRequest,
process_code: ProcessCode::API,
txn_amt,
ccy,
mer_ref,
mer_txn_date,
mer_id,
lang,
success_url: router_url.clone(),
failure_url: router_url.clone(),
success_s2s_url: webhook_url.clone(),
failure_s2s_url: webhook_url.clone(),
enctype: EncodingType::MD5,
signature,
verno: zsl_version::VERSION_1.to_owned(),
service_code: ServiceCode::MPG,
country: billing_country,
payment_method,
name,
family_name,
tel_phone,
email,
cust_tag,
})
}
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ZslPaymentsResponse {
process_type: ProcessType,
process_code: ProcessCode,
status: String,
mer_ref: String,
mer_id: String,
enctype: EncodingType,
txn_url: String,
signature: Secret<String>,
}
impl<F, T> TryFrom<ResponseRouterData<F, ZslPaymentsResponse, T, PaymentsResponseData>>
for RouterData<F, T, PaymentsResponseData>
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: ResponseRouterData<F, ZslPaymentsResponse, T, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
if item.response.status.eq("0") && !item.response.txn_url.is_empty() {
let auth_type = ZslAuthType::try_from(&item.data.connector_auth_type)?;
let key: Secret<String> = auth_type.api_key;
let mer_id = auth_type.merchant_id;
let calculated_signature = calculate_signature(
item.response.enctype,
ZslSignatureType::ResponseSignature {
status: item.response.status.clone(),
txn_url: item.response.txn_url.clone(),
mer_ref: item.response.mer_ref.clone(),
mer_id: mer_id.clone().expose(),
key: key.expose(),
},
)?;
if calculated_signature.clone().eq(&item.response.signature) {
let decoded_redirect_url_bytes: Vec<u8> = base64::engine::general_purpose::STANDARD
.decode(item.response.txn_url.clone())
.change_context(errors::ConnectorError::RequestEncodingFailed)?;
let redirect_url = String::from_utf8(decoded_redirect_url_bytes)
.change_context(errors::ConnectorError::RequestEncodingFailed)?;
Ok(Self {
status: enums::AttemptStatus::AuthenticationPending, // Redirect is always expected after success response
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::NoResponseId,
redirection_data: Box::new(Some(RedirectForm::Form {
endpoint: redirect_url,
method: Method::Get,
form_fields: HashMap::new(),
})),
mandate_reference: Box::new(None),
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: Some(item.response.mer_ref.clone()),
incremental_authorization_allowed: None,
charges: None,
}),
..item.data
})
} else {
// When the signature check fails
Ok(Self {
status: enums::AttemptStatus::Failure,
response: Err(ErrorResponse {
code: NO_ERROR_CODE.to_string(),
message: auth_error::INVALID_SIGNATURE.to_string(),
reason: Some(auth_error::INVALID_SIGNATURE.to_string()),
status_code: item.http_code,
attempt_status: Some(enums::AttemptStatus::Failure),
connector_transaction_id: Some(item.response.mer_ref.clone()),
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
connector_metadata: None,
}),
..item.data
})
}
} else {
let error_reason =
ZslResponseStatus::try_from(item.response.status.clone())?.to_string();
Ok(Self {
status: enums::AttemptStatus::Failure,
response: Err(ErrorResponse {
code: item.response.status.clone(),
message: error_reason.clone(),
reason: Some(error_reason.clone()),
status_code: item.http_code,
attempt_status: Some(enums::AttemptStatus::Failure),
connector_transaction_id: Some(item.response.mer_ref.clone()),
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
connector_metadata: None,
}),
..item.data
})
}
}
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ZslWebhookResponse {
pub process_type: ProcessType,
pub process_code: ProcessCode,
pub status: String,
pub txn_id: String,
pub txn_date: String,
pub paid_ccy: api_models::enums::Currency,
pub paid_amt: String,
pub consr_paid_ccy: Option<api_models::enums::Currency>,
pub consr_paid_amt: String,
pub service_fee_ccy: Option<api_models::enums::Currency>,
pub service_fee: Option<String>,
pub txn_amt: String,
pub ccy: String,
pub mer_ref: String,
pub mer_txn_date: String,
pub mer_id: String,
pub enctype: EncodingType,
pub signature: Secret<String>,
}
pub(crate) fn get_status(status: String) -> api_models::webhooks::IncomingWebhookEvent {
match status.as_str() {
//any response with status != 0 are a failed deposit transaction
"0" => api_models::webhooks::IncomingWebhookEvent::PaymentIntentSuccess,
_ => api_models::webhooks::IncomingWebhookEvent::PaymentIntentFailure,
}
}
impl<F> TryFrom<ResponseRouterData<F, ZslWebhookResponse, PaymentsSyncData, PaymentsResponseData>>
for RouterData<F, PaymentsSyncData, PaymentsResponseData>
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: ResponseRouterData<F, ZslWebhookResponse, PaymentsSyncData, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
let paid_amount = item
.response
.consr_paid_amt
.parse::<i64>()
.change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
if item.response.status == "0" {
Ok(Self {
status: enums::AttemptStatus::Charged,
amount_captured: Some(paid_amount),
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(item.response.txn_id.clone()),
redirection_data: Box::new(None),
mandate_reference: Box::new(None),
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: Some(item.response.mer_ref.clone()),
incremental_authorization_allowed: None,
charges: None,
}),
..item.data
})
} else {
let error_reason =
ZslResponseStatus::try_from(item.response.status.clone())?.to_string();
Ok(Self {
status: enums::AttemptStatus::Failure,
response: Err(ErrorResponse {
code: item.response.status.clone(),
message: error_reason.clone(),
reason: Some(error_reason.clone()),
status_code: item.http_code,
attempt_status: Some(enums::AttemptStatus::Failure),
connector_transaction_id: Some(item.response.mer_ref.clone()),
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
connector_metadata: None,
}),
..item.data
})
}
}
}
impl TryFrom<String> for ZslResponseStatus {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(status: String) -> Result<Self, Self::Error> {
match status.as_str() {
"0" => Ok(Self::Normal),
"1000" => Ok(Self::InternalError),
"1001" => Ok(Self::BreakDownMessageError),
"1002" => Ok(Self::FormatError),
"1004" => Ok(Self::InvalidTransaction),
"1005" => Ok(Self::TransactionCountryNotFound),
"1006" => Ok(Self::MerchantIdNotFound),
"1007" => Ok(Self::AccountDisabled),
"1008" => Ok(Self::DuplicateMerchantReference),
"1009" => Ok(Self::InvalidPayAmount),
"1010" => Ok(Self::PayAmountNotFound),
"1011" => Ok(Self::InvalidCurrencyCode),
"1012" => Ok(Self::CurrencyCodeNotFound),
"1013" => Ok(Self::ReferenceNotFound),
"1014" => Ok(Self::TransmissionTimeNotFound),
"1015" => Ok(Self::PayMethodNotFound),
"1016" => Ok(Self::BankCodeNotFound),
"1017" => Ok(Self::InvalidShowPayPage),
"1018" => Ok(Self::ShowPayPageNotFound),
"1019" => Ok(Self::SuccessUrlNotFound),
"1020" => Ok(Self::SuccessCallbackUrlNotFound),
"1021" => Ok(Self::FailUrlNotFound),
"1022" => Ok(Self::FailCallbackUrlNotFound),
"1023" => Ok(Self::MacNotFound),
"1025" => Ok(Self::OriginalTransactionNotFound),
"1026" => Ok(Self::DeblockDataError),
"1028" => Ok(Self::PspAckNotYetReturn),
"1029" => Ok(Self::BankBranchNameNotFound),
"1030" => Ok(Self::BankAccountIDNotFound),
"1031" => Ok(Self::BankAccountNameNotFound),
"1032" => Ok(Self::IdentityIDNotFound),
"1033" => Ok(Self::ErrorConnectingToPsp),
"1034" => Ok(Self::CountryPspNotAvailable),
"1035" => Ok(Self::UnsupportedPayAmount),
"1036" => Ok(Self::RecordMismatch),
"1037" => Ok(Self::NoRecord),
"1038" => Ok(Self::PspError),
"1039" => Ok(Self::UnsupportedEncryptionType),
"1040" => Ok(Self::ExceedTransactionLimitCount),
"1041" => Ok(Self::ExceedTransactionLimitAmount),
"1042" => Ok(Self::ExceedTransactionAccountLimitCount),
"1043" => Ok(Self::ExceedTransactionAccountLimitAmount),
"1044" => Ok(Self::ExchangeRateError),
"1045" => Ok(Self::InvalidEncoding),
"1046" => Ok(Self::CustomerNameNotFound),
"1047" => Ok(Self::CustomerFamilyNameNotFound),
"1048" => Ok(Self::CustomerTelPhoneNotFound),
"1049" => Ok(Self::InsufficientFund),
"1050" => Ok(Self::ServiceCodeIsMissing),
"1051" => Ok(Self::CurrencyIdNotMatch),
"1052" => Ok(Self::NoPendingRecord),
"1053" => Ok(Self::NoLoadBalancerRuleDefineForTransaction),
"1054" => Ok(Self::NoPaymentProviderAvailable),
"1055" => Ok(Self::UnsupportedPayMethod),
"1056" => Ok(Self::PendingTransaction),
"1057" => Ok(Self::OtherError1059),
"1058" => Ok(Self::OtherError1058),
"1059" => Ok(Self::OtherError1059),
"1084" => Ok(Self::InvalidRequestId),
"5043" => Ok(Self::BeneficiaryBankAccountIsNotAvailable),
"5053" => Ok(Self::BaidNotFound),
"5057" => Ok(Self::InvalidBaid),
"5059" => Ok(Self::InvalidBaidStatus),
"5107" => Ok(Self::AutoUploadBankDisabled),
"5108" => Ok(Self::InvalidNature),
"5109" => Ok(Self::SmsCreateDateNotFound),
"5110" => Ok(Self::InvalidSmsCreateDate),
"5111" => Ok(Self::RecordNotFound),
"5112" => Ok(Self::InsufficientBaidAvailableBalance),
"5113" => Ok(Self::ExceedTxnAmountLimit),
"5114" => Ok(Self::BaidBalanceNotFound),
"5115" => Ok(Self::AutoUploadIndicatorNotFound),
"5116" => Ok(Self::InvalidBankAcctStatus),
"5117" => Ok(Self::InvalidAutoUploadIndicator),
"5118" => Ok(Self::InvalidPidStatus),
"5119" => Ok(Self::InvalidProviderStatus),
"5120" => Ok(Self::InvalidBankAccountSystemSwitchEnabled),
"5121" => Ok(Self::AutoUploadProviderDisabled),
"5122" => Ok(Self::AutoUploadBankNotFound),
"5123" => Ok(Self::AutoUploadBankAcctNotFound),
"5124" => Ok(Self::AutoUploadProviderNotFound),
"5125" => Ok(Self::UnsupportedBankCode),
"5126" => Ok(Self::BalanceOverrideIndicatorNotFound),
"5127" => Ok(Self::InvalidBalanceOverrideIndicator),
"10000" => Ok(Self::VernoInvalid),
"10001" => Ok(Self::ServiceCodeInvalid),
"10002" => Ok(Self::PspResponseSignatureIsNotValid),
"10003" => Ok(Self::ProcessTypeNotFound),
"10004" => Ok(Self::ProcessCodeNotFound),
"10005" => Ok(Self::EnctypeNotFound),
"10006" => Ok(Self::VernoNotFound),
"10007" => Ok(Self::DepositBankNotFound),
"10008" => Ok(Self::DepositFlowNotFound),
"10009" => Ok(Self::CustDepositDateNotFound),
"10010" => Ok(Self::CustTagNotFound),
"10011" => Ok(Self::CountryValueInvalid),
"10012" => Ok(Self::CurrencyCodeValueInvalid),
"10013" => Ok(Self::MerTxnDateInvalid),
"10014" => Ok(Self::CustDepositDateInvalid),
"10015" => Ok(Self::TxnAmtInvalid),
"10016" => Ok(Self::SuccessCallbackUrlInvalid),
"10017" => Ok(Self::DepositFlowInvalid),
"10018" => Ok(Self::ProcessTypeInvalid),
"10019" => Ok(Self::ProcessCodeInvalid),
"10020" => Ok(Self::UnsupportedMerRefLength),
"10021" => Ok(Self::DepositBankLengthOverLimit),
"10022" => Ok(Self::CustTagLengthOverLimit),
"10023" => Ok(Self::SignatureLengthOverLimit),
"10024" => Ok(Self::RequestContainInvalidTag),
"10025" => Ok(Self::RequestSignatureNotMatch),
"10026" => Ok(Self::InvalidCustomer),
"10027" => Ok(Self::SchemeNotFound),
"10028" => Ok(Self::PspResponseFieldsMissing),
"10029" => Ok(Self::PspResponseMerRefNotMatchWithRequestMerRef),
"10030" => Ok(Self::PspResponseMerIdNotMatchWithRequestMerId),
"10031" => Ok(Self::UpdateDepositFailAfterResponse),
"10032" => Ok(Self::UpdateUsedLimitTransactionCountFailAfterSuccessResponse),
"10033" => Ok(Self::UpdateCustomerLastDepositRecordAfterSuccessResponse),
"10034" => Ok(Self::CreateDepositFail),
"10035" => Ok(Self::CreateDepositMsgFail),
"10036" => Ok(Self::UpdateStatusSubStatusFail),
"10037" => Ok(Self::AddDepositRecordToSchemeAccount),
"10038" => Ok(Self::EmptyResponse),
"10039" => Ok(Self::AubConfirmErrorFromPh),
"10040" => Ok(Self::ProviderEmailAddressNotFound),
"10041" => Ok(Self::AubConnectionTimeout),
"10042" => Ok(Self::AubConnectionIssue),
"10043" => Ok(Self::AubMsgTypeMissing),
"10044" => Ok(Self::AubMsgCodeMissing),
"10045" => Ok(Self::AubVersionMissing),
"10046" => Ok(Self::AubEncTypeMissing),
"10047" => Ok(Self::AubSignMissing),
"10048" => Ok(Self::AubInfoMissing),
"10049" => Ok(Self::AubErrorCodeMissing),
"10050" => Ok(Self::AubMsgTypeInvalid),
"10051" => Ok(Self::AubMsgCodeInvalid),
"10052" => Ok(Self::AubBaidMissing),
"10053" => Ok(Self::AubResponseSignNotMatch),
"10054" => Ok(Self::SmsConnectionTimeout),
"10055" => Ok(Self::SmsConnectionIssue),
"10056" => Ok(Self::SmsConfirmErrorFromPh),
"10057" => Ok(Self::SmsMsgTypeMissing),
"10058" => Ok(Self::SmsMsgCodeMissing),
"10059" => Ok(Self::SmsVersionMissing),
"10060" => Ok(Self::SmsEncTypeMissing),
"10061" => Ok(Self::SmsSignMissing),
"10062" => Ok(Self::SmsInfoMissing),
"10063" => Ok(Self::SmsErrorCodeMissing),
"10064" => Ok(Self::SmsMsgTypeInvalid),
"10065" => Ok(Self::SmsMsgCodeInvalid),
"10066" => Ok(Self::SmsResponseSignNotMatch),
"10067" => Ok(Self::SmsRequestReachMaximumLimit),
"10068" => Ok(Self::SyncConnectionTimeout),
"10069" => Ok(Self::SyncConnectionIssue),
"10070" => Ok(Self::SyncConfirmErrorFromPh),
"10071" => Ok(Self::SyncMsgTypeMissing),
"10072" => Ok(Self::SyncMsgCodeMissing),
"10073" => Ok(Self::SyncVersionMissing),
"10074" => Ok(Self::SyncEncTypeMissing),
"10075" => Ok(Self::SyncSignMissing),
"10076" => Ok(Self::SyncInfoMissing),
"10077" => Ok(Self::SyncErrorCodeMissing),
"10078" => Ok(Self::SyncMsgTypeInvalid),
"10079" => Ok(Self::SyncMsgCodeInvalid),
"10080" => Ok(Self::SyncResponseSignNotMatch),
"10081" => Ok(Self::AccountExpired),
"10082" => Ok(Self::ExceedMaxMinAmount),
"10083" => Ok(Self::WholeNumberAmountLessThanOne),
"10084" => Ok(Self::AddDepositRecordToSchemeChannel),
"10085" => Ok(Self::UpdateUtilizedAmountFailAfterSuccessResponse),
"10086" => Ok(Self::PidResponseInvalidFormat),
"10087" => Ok(Self::PspNameNotFound),
"10088" => Ok(Self::LangIsMissing),
"10089" => Ok(Self::FailureCallbackUrlInvalid),
"10090" => Ok(Self::SuccessRedirectUrlInvalid),
"10091" => Ok(Self::FailureRedirectUrlInvalid),
"10092" => Ok(Self::LangValueInvalid),
"10093" => Ok(Self::OnlineDepositSessionTimeout),
"10094" => Ok(Self::AccessPaymentPageRouteFieldMissing),
"10095" => Ok(Self::AmountNotMatch),
"10096" => Ok(Self::PidCallbackFieldsMissing),
"10097" => Ok(Self::TokenNotMatch),
"10098" => Ok(Self::OperationDuplicated),
"10099" => Ok(Self::PayPageDomainNotAvailable),
"10100" => Ok(Self::PayPageConfirmSignatureNotMatch),
"10101" => Ok(Self::PaymentPageConfirmationFieldMissing),
"10102" => Ok(Self::MultipleCallbackFromPsp),
"10103" => Ok(Self::PidNotAvailable),
"10104" => Ok(Self::PidDepositUrlNotValidOrEmp),
"10105" => Ok(Self::PspSelfRedirectTagNotValid),
"20000" => Ok(Self::InternalError20000),
"20001" => Ok(Self::DepositTimeout),
_ => Err(errors::ConnectorError::ResponseHandlingFailed.into()),
}
}
}
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, strum::Display)]
#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
pub enum ZslResponseStatus {
Normal,
InternalError,
BreakDownMessageError,
FormatError,
InvalidTransaction,
TransactionCountryNotFound,
MerchantIdNotFound,
AccountDisabled,
DuplicateMerchantReference,
InvalidPayAmount,
PayAmountNotFound,
InvalidCurrencyCode,
CurrencyCodeNotFound,
ReferenceNotFound,
TransmissionTimeNotFound,
PayMethodNotFound,
BankCodeNotFound,
InvalidShowPayPage,
ShowPayPageNotFound,
SuccessUrlNotFound,
SuccessCallbackUrlNotFound,
FailUrlNotFound,
FailCallbackUrlNotFound,
MacNotFound,
OriginalTransactionNotFound,
DeblockDataError,
PspAckNotYetReturn,
BankBranchNameNotFound,
BankAccountIDNotFound,
BankAccountNameNotFound,
IdentityIDNotFound,
ErrorConnectingToPsp,
CountryPspNotAvailable,
UnsupportedPayAmount,
RecordMismatch,
NoRecord,
PspError,
UnsupportedEncryptionType,
ExceedTransactionLimitCount,
ExceedTransactionLimitAmount,
ExceedTransactionAccountLimitCount,
ExceedTransactionAccountLimitAmount,
ExchangeRateError,
InvalidEncoding,
CustomerNameNotFound,
CustomerFamilyNameNotFound,
CustomerTelPhoneNotFound,
InsufficientFund,
ServiceCodeIsMissing,
CurrencyIdNotMatch,
NoPendingRecord,
NoLoadBalancerRuleDefineForTransaction,
NoPaymentProviderAvailable,
UnsupportedPayMethod,
PendingTransaction,
OtherError1059,
OtherError1058,
InvalidRequestId,
BeneficiaryBankAccountIsNotAvailable,
BaidNotFound,
InvalidBaid,
InvalidBaidStatus,
AutoUploadBankDisabled,
InvalidNature,
SmsCreateDateNotFound,
InvalidSmsCreateDate,
RecordNotFound,
InsufficientBaidAvailableBalance,
ExceedTxnAmountLimit,
BaidBalanceNotFound,
AutoUploadIndicatorNotFound,
InvalidBankAcctStatus,
InvalidAutoUploadIndicator,
InvalidPidStatus,
InvalidProviderStatus,
InvalidBankAccountSystemSwitchEnabled,
AutoUploadProviderDisabled,
AutoUploadBankNotFound,
AutoUploadBankAcctNotFound,
AutoUploadProviderNotFound,
UnsupportedBankCode,
BalanceOverrideIndicatorNotFound,
InvalidBalanceOverrideIndicator,
VernoInvalid,
ServiceCodeInvalid,
PspResponseSignatureIsNotValid,
ProcessTypeNotFound,
ProcessCodeNotFound,
EnctypeNotFound,
VernoNotFound,
DepositBankNotFound,
DepositFlowNotFound,
CustDepositDateNotFound,
CustTagNotFound,
CountryValueInvalid,
CurrencyCodeValueInvalid,
MerTxnDateInvalid,
CustDepositDateInvalid,
TxnAmtInvalid,
SuccessCallbackUrlInvalid,
DepositFlowInvalid,
ProcessTypeInvalid,
ProcessCodeInvalid,
UnsupportedMerRefLength,
DepositBankLengthOverLimit,
CustTagLengthOverLimit,
SignatureLengthOverLimit,
RequestContainInvalidTag,
RequestSignatureNotMatch,
InvalidCustomer,
SchemeNotFound,
PspResponseFieldsMissing,
PspResponseMerRefNotMatchWithRequestMerRef,
PspResponseMerIdNotMatchWithRequestMerId,
UpdateDepositFailAfterResponse,
UpdateUsedLimitTransactionCountFailAfterSuccessResponse,
UpdateCustomerLastDepositRecordAfterSuccessResponse,
CreateDepositFail,
CreateDepositMsgFail,
UpdateStatusSubStatusFail,
AddDepositRecordToSchemeAccount,
EmptyResponse,
AubConfirmErrorFromPh,
ProviderEmailAddressNotFound,
AubConnectionTimeout,
AubConnectionIssue,
AubMsgTypeMissing,
AubMsgCodeMissing,
AubVersionMissing,
AubEncTypeMissing,
AubSignMissing,
AubInfoMissing,
AubErrorCodeMissing,
AubMsgTypeInvalid,
AubMsgCodeInvalid,
AubBaidMissing,
AubResponseSignNotMatch,
SmsConnectionTimeout,
SmsConnectionIssue,
SmsConfirmErrorFromPh,
SmsMsgTypeMissing,
SmsMsgCodeMissing,
SmsVersionMissing,
SmsEncTypeMissing,
SmsSignMissing,
SmsInfoMissing,
SmsErrorCodeMissing,
SmsMsgTypeInvalid,
SmsMsgCodeInvalid,
SmsResponseSignNotMatch,
SmsRequestReachMaximumLimit,
SyncConnectionTimeout,
SyncConnectionIssue,
SyncConfirmErrorFromPh,
SyncMsgTypeMissing,
SyncMsgCodeMissing,
SyncVersionMissing,
SyncEncTypeMissing,
SyncSignMissing,
SyncInfoMissing,
SyncErrorCodeMissing,
SyncMsgTypeInvalid,
SyncMsgCodeInvalid,
SyncResponseSignNotMatch,
AccountExpired,
ExceedMaxMinAmount,
WholeNumberAmountLessThanOne,
AddDepositRecordToSchemeChannel,
UpdateUtilizedAmountFailAfterSuccessResponse,
PidResponseInvalidFormat,
PspNameNotFound,
LangIsMissing,
FailureCallbackUrlInvalid,
SuccessRedirectUrlInvalid,
FailureRedirectUrlInvalid,
LangValueInvalid,
OnlineDepositSessionTimeout,
AccessPaymentPageRouteFieldMissing,
AmountNotMatch,
PidCallbackFieldsMissing,
TokenNotMatch,
OperationDuplicated,
PayPageDomainNotAvailable,
PayPageConfirmSignatureNotMatch,
PaymentPageConfirmationFieldMissing,
MultipleCallbackFromPsp,
PidNotAvailable,
PidDepositUrlNotValidOrEmp,
PspSelfRedirectTagNotValid,
InternalError20000,
DepositTimeout,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ZslErrorResponse {
pub status: String,
}
pub enum ZslSignatureType {
RequestSignature {
txn_amt: String,
ccy: String,
mer_ref: String,
mer_id: String,
mer_txn_date: String,
key: String,
},
ResponseSignature {
status: String,
txn_url: String,
mer_ref: String,
mer_id: String,
key: String,
},
WebhookSignature {
status: String,
txn_id: String,
txn_date: String,
paid_ccy: String,
paid_amt: String,
mer_ref: String,
mer_id: String,
key: String,
},
}
pub fn calculate_signature(
enctype: EncodingType,
signature_data: ZslSignatureType,
) -> Result<Secret<String>, error_stack::Report<errors::ConnectorError>> {
let signature_data = match signature_data {
ZslSignatureType::RequestSignature {
txn_amt,
ccy,
mer_ref,
mer_id,
mer_txn_date,
key,
} => format!("{txn_amt}{ccy}{mer_ref}{mer_id}{mer_txn_date}{key}"),
ZslSignatureType::ResponseSignature {
status,
txn_url,
mer_ref,
mer_id,
key,
} => {
format!("{status}{txn_url}{mer_ref}{mer_id}{key}")
}
ZslSignatureType::WebhookSignature {
status,
txn_id,
txn_date,
paid_ccy,
paid_amt,
mer_ref,
mer_id,
key,
} => format!("{status}{txn_id}{txn_date}{paid_ccy}{paid_amt}{mer_ref}{mer_id}{key}"),
};
let message = signature_data.as_bytes();
let encoded_data = match enctype {
EncodingType::MD5 => hex::encode(
common_utils::crypto::Md5
.generate_digest(message)
.change_context(errors::ConnectorError::RequestEncodingFailed)?,
),
EncodingType::Sha1 => {
hex::encode(digest::digest(&digest::SHA1_FOR_LEGACY_USE_ONLY, message))
}
};
Ok(Secret::new(encoded_data))
}
|
{
"crate": "hyperswitch_connectors",
"file": "crates/hyperswitch_connectors/src/connectors/zsl/transformers.rs",
"file_size": null,
"is_async": null,
"is_pub": null,
"num_enums": 6,
"num_structs": 5,
"num_tables": null,
"score": null,
"total_crates": null
}
|
file_hyperswitch_connectors_5120971919137586254
|
clm
|
file
|
// Repository: hyperswitch
// Crate: hyperswitch_connectors
// File: crates/hyperswitch_connectors/src/connectors/iatapay/transformers.rs
// Contains: 15 structs, 6 enums
use std::collections::HashMap;
use api_models::webhooks::IncomingWebhookEvent;
use common_enums::enums;
use common_utils::{
errors::CustomResult, ext_traits::Encode, request::Method, types::FloatMajorUnit,
};
use error_stack::ResultExt;
use hyperswitch_domain_models::{
payment_method_data::{BankRedirectData, PaymentMethodData, RealTimePaymentData, UpiData},
router_data::{AccessToken, ConnectorAuthType, ErrorResponse, RouterData},
router_flow_types::{
refunds::{Execute, RSync},
Authorize,
},
router_request_types::{PaymentsAuthorizeData, ResponseId},
router_response_types::{PaymentsResponseData, RedirectForm, RefundsResponseData},
types::{self, RefundsRouterData},
};
use hyperswitch_interfaces::{
consts::{NO_ERROR_CODE, NO_ERROR_MESSAGE},
errors,
};
use masking::{Secret, SwitchStrategy};
use serde::{Deserialize, Serialize};
use crate::{
types::{RefundsResponseRouterData, ResponseRouterData},
utils::{
get_unimplemented_payment_method_error_message, is_payment_failure, is_refund_failure,
PaymentsAuthorizeRequestData, RefundsRequestData,
},
};
type Error = error_stack::Report<errors::ConnectorError>;
// Every access token will be valid for 5 minutes. It contains grant_type and scope for different type of access, but for our usecases it should be only 'client_credentials' and 'payment' resp(as per doc) for all type of api call.
#[derive(Debug, Serialize)]
pub struct IatapayAuthUpdateRequest {
grant_type: String,
scope: String,
}
impl TryFrom<&types::RefreshTokenRouterData> for IatapayAuthUpdateRequest {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(_item: &types::RefreshTokenRouterData) -> Result<Self, Self::Error> {
Ok(Self {
grant_type: "client_credentials".to_string(),
scope: "payment".to_string(),
})
}
}
#[derive(Debug, Serialize)]
pub struct IatapayRouterData<T> {
amount: FloatMajorUnit,
router_data: T,
}
impl<T> TryFrom<(FloatMajorUnit, T)> for IatapayRouterData<T> {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from((amount, item): (FloatMajorUnit, T)) -> Result<Self, Self::Error> {
Ok(Self {
amount,
router_data: item,
})
}
}
#[derive(Debug, Deserialize, Serialize)]
pub struct IatapayAuthUpdateResponse {
pub access_token: Secret<String>,
pub expires_in: i64,
}
impl<F, T> TryFrom<ResponseRouterData<F, IatapayAuthUpdateResponse, T, AccessToken>>
for RouterData<F, T, AccessToken>
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: ResponseRouterData<F, IatapayAuthUpdateResponse, T, AccessToken>,
) -> Result<Self, Self::Error> {
Ok(Self {
response: Ok(AccessToken {
token: item.response.access_token,
expires: item.response.expires_in,
}),
..item.data
})
}
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct RedirectUrls {
success_url: String,
failure_url: String,
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct PayerInfo {
token_id: Secret<String>,
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "UPPERCASE")]
pub enum PreferredCheckoutMethod {
Vpa, //Passing this in UPI_COLLECT will trigger an S2S payment call which is not required.
Qr,
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct IatapayPaymentsRequest {
merchant_id: Secret<String>,
merchant_payment_id: Option<String>,
amount: FloatMajorUnit,
currency: common_enums::Currency,
country: common_enums::CountryAlpha2,
locale: String,
redirect_urls: RedirectUrls,
notification_url: String,
#[serde(skip_serializing_if = "Option::is_none")]
payer_info: Option<PayerInfo>,
#[serde(skip_serializing_if = "Option::is_none")]
preferred_checkout_method: Option<PreferredCheckoutMethod>,
}
impl
TryFrom<&IatapayRouterData<&RouterData<Authorize, PaymentsAuthorizeData, PaymentsResponseData>>>
for IatapayPaymentsRequest
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: &IatapayRouterData<
&RouterData<Authorize, PaymentsAuthorizeData, PaymentsResponseData>,
>,
) -> Result<Self, Self::Error> {
let return_url = item.router_data.request.get_router_return_url()?;
// Iatapay processes transactions through the payment method selected based on the country
let (country, payer_info, preferred_checkout_method) = match item
.router_data
.request
.payment_method_data
.clone()
{
PaymentMethodData::Upi(upi_type) => match upi_type {
UpiData::UpiCollect(upi_data) => (
common_enums::CountryAlpha2::IN,
upi_data.vpa_id.map(|id| PayerInfo {
token_id: id.switch_strategy(),
}),
None,
),
UpiData::UpiIntent(_) | UpiData::UpiQr(_) => (
common_enums::CountryAlpha2::IN,
None,
Some(PreferredCheckoutMethod::Qr),
),
},
PaymentMethodData::BankRedirect(bank_redirect_data) => match bank_redirect_data {
BankRedirectData::Ideal { .. } => (common_enums::CountryAlpha2::NL, None, None),
BankRedirectData::LocalBankRedirect {} => {
(common_enums::CountryAlpha2::AT, None, None)
}
BankRedirectData::BancontactCard { .. }
| BankRedirectData::Bizum {}
| BankRedirectData::Blik { .. }
| BankRedirectData::Eft { .. }
| BankRedirectData::Eps { .. }
| BankRedirectData::Giropay { .. }
| BankRedirectData::Interac { .. }
| BankRedirectData::OnlineBankingCzechRepublic { .. }
| BankRedirectData::OnlineBankingFinland { .. }
| BankRedirectData::OnlineBankingPoland { .. }
| BankRedirectData::OnlineBankingSlovakia { .. }
| BankRedirectData::OpenBankingUk { .. }
| BankRedirectData::Przelewy24 { .. }
| BankRedirectData::Sofort { .. }
| BankRedirectData::Trustly { .. }
| BankRedirectData::OnlineBankingFpx { .. }
| BankRedirectData::OnlineBankingThailand { .. } => {
Err(errors::ConnectorError::NotImplemented(
get_unimplemented_payment_method_error_message("iatapay"),
))?
}
},
PaymentMethodData::RealTimePayment(real_time_payment_data) => {
match *real_time_payment_data {
RealTimePaymentData::DuitNow {} => {
(common_enums::CountryAlpha2::MY, None, None)
}
RealTimePaymentData::Fps {} => (common_enums::CountryAlpha2::HK, None, None),
RealTimePaymentData::PromptPay {} => {
(common_enums::CountryAlpha2::TH, None, None)
}
RealTimePaymentData::VietQr {} => (common_enums::CountryAlpha2::VN, None, None),
}
}
PaymentMethodData::Card(_)
| PaymentMethodData::CardRedirect(_)
| PaymentMethodData::Wallet(_)
| PaymentMethodData::PayLater(_)
| PaymentMethodData::BankDebit(_)
| PaymentMethodData::BankTransfer(_)
| PaymentMethodData::Crypto(_)
| PaymentMethodData::MandatePayment
| PaymentMethodData::Reward
| PaymentMethodData::MobilePayment(_)
| PaymentMethodData::Voucher(_)
| PaymentMethodData::GiftCard(_)
| PaymentMethodData::CardToken(_)
| PaymentMethodData::OpenBanking(_)
| PaymentMethodData::NetworkToken(_)
| PaymentMethodData::CardDetailsForNetworkTransactionId(_) => {
Err(errors::ConnectorError::NotImplemented(
get_unimplemented_payment_method_error_message("iatapay"),
))?
}
};
let payload = Self {
merchant_id: IatapayAuthType::try_from(&item.router_data.connector_auth_type)?
.merchant_id,
merchant_payment_id: Some(item.router_data.connector_request_reference_id.clone()),
amount: item.amount,
currency: item.router_data.request.currency,
country,
locale: format!("en-{country}"),
redirect_urls: get_redirect_url(return_url),
payer_info,
notification_url: item.router_data.request.get_webhook_url()?,
preferred_checkout_method,
};
Ok(payload)
}
}
fn get_redirect_url(return_url: String) -> RedirectUrls {
RedirectUrls {
success_url: return_url.clone(),
failure_url: return_url,
}
}
// Auth Struct
pub struct IatapayAuthType {
pub(super) client_id: Secret<String>,
pub(super) merchant_id: Secret<String>,
pub(super) client_secret: Secret<String>,
}
impl TryFrom<&ConnectorAuthType> for IatapayAuthType {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(auth_type: &ConnectorAuthType) -> Result<Self, Self::Error> {
match auth_type {
ConnectorAuthType::SignatureKey {
api_key,
key1,
api_secret,
} => Ok(Self {
client_id: api_key.to_owned(),
merchant_id: key1.to_owned(),
client_secret: api_secret.to_owned(),
}),
_ => Err(errors::ConnectorError::FailedToObtainAuthType)?,
}
}
}
// PaymentsResponse
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "UPPERCASE")]
pub enum IatapayPaymentStatus {
#[default]
Created,
Initiated,
Authorized,
Settled,
Cleared,
Failed,
#[serde(rename = "UNEXPECTED SETTLED")]
UnexpectedSettled,
}
impl From<IatapayPaymentStatus> for enums::AttemptStatus {
fn from(item: IatapayPaymentStatus) -> Self {
match item {
IatapayPaymentStatus::Authorized
| IatapayPaymentStatus::Settled
| IatapayPaymentStatus::Cleared => Self::Charged,
IatapayPaymentStatus::Failed | IatapayPaymentStatus::UnexpectedSettled => Self::Failure,
IatapayPaymentStatus::Created => Self::AuthenticationPending,
IatapayPaymentStatus::Initiated => Self::Pending,
}
}
}
#[derive(Default, Debug, Clone, Serialize, Deserialize, PartialEq)]
#[serde(rename_all = "camelCase")]
pub struct RedirectUrl {
pub redirect_url: String,
}
#[derive(Debug, Serialize, Deserialize)]
pub struct CheckoutMethod {
pub redirect: RedirectUrl,
}
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct IatapayPaymentsResponse {
pub status: IatapayPaymentStatus,
pub iata_payment_id: Option<String>,
pub iata_refund_id: Option<String>,
pub merchant_id: Option<Secret<String>>,
pub merchant_payment_id: Option<String>,
pub amount: FloatMajorUnit,
pub currency: String,
pub checkout_methods: Option<CheckoutMethod>,
pub failure_code: Option<String>,
pub failure_details: Option<String>,
}
fn get_iatpay_response(
response: IatapayPaymentsResponse,
status_code: u16,
) -> CustomResult<
(
enums::AttemptStatus,
Option<ErrorResponse>,
PaymentsResponseData,
),
errors::ConnectorError,
> {
let status = enums::AttemptStatus::from(response.status);
let error = if is_payment_failure(status) {
Some(ErrorResponse {
code: response
.failure_code
.unwrap_or_else(|| NO_ERROR_CODE.to_string()),
message: response
.failure_details
.clone()
.unwrap_or_else(|| NO_ERROR_MESSAGE.to_string()),
reason: response.failure_details,
status_code,
attempt_status: Some(status),
connector_transaction_id: response.iata_payment_id.clone(),
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
connector_metadata: None,
})
} else {
None
};
let form_fields = HashMap::new();
let id = match response.iata_payment_id.clone() {
Some(s) => ResponseId::ConnectorTransactionId(s),
None => ResponseId::NoResponseId,
};
let connector_response_reference_id = response.merchant_payment_id.or(response.iata_payment_id);
let payment_response_data = match response.checkout_methods {
Some(checkout_methods) => {
let (connector_metadata, redirection_data) =
match checkout_methods.redirect.redirect_url.ends_with("qr") {
true => {
let qr_code_info = api_models::payments::FetchQrCodeInformation {
qr_code_fetch_url: url::Url::parse(
&checkout_methods.redirect.redirect_url,
)
.change_context(errors::ConnectorError::ResponseHandlingFailed)?,
};
(
Some(qr_code_info.encode_to_value())
.transpose()
.change_context(errors::ConnectorError::ResponseHandlingFailed)?,
None,
)
}
false => (
None,
Some(RedirectForm::Form {
endpoint: checkout_methods.redirect.redirect_url,
method: Method::Get,
form_fields,
}),
),
};
PaymentsResponseData::TransactionResponse {
resource_id: id,
redirection_data: Box::new(redirection_data),
mandate_reference: Box::new(None),
connector_metadata,
network_txn_id: None,
connector_response_reference_id: connector_response_reference_id.clone(),
incremental_authorization_allowed: None,
charges: None,
}
}
None => PaymentsResponseData::TransactionResponse {
resource_id: id.clone(),
redirection_data: Box::new(None),
mandate_reference: Box::new(None),
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: connector_response_reference_id.clone(),
incremental_authorization_allowed: None,
charges: None,
},
};
Ok((status, error, payment_response_data))
}
impl<F, T> TryFrom<ResponseRouterData<F, IatapayPaymentsResponse, T, PaymentsResponseData>>
for RouterData<F, T, PaymentsResponseData>
{
type Error = Error;
fn try_from(
item: ResponseRouterData<F, IatapayPaymentsResponse, T, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
let (status, error, payment_response_data) =
get_iatpay_response(item.response, item.http_code)?;
Ok(Self {
status,
response: error.map_or_else(|| Ok(payment_response_data), Err),
..item.data
})
}
}
// REFUND :
// Type definition for RefundRequest
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct IatapayRefundRequest {
pub merchant_id: Secret<String>,
pub merchant_refund_id: Option<String>,
pub amount: FloatMajorUnit,
pub currency: String,
pub bank_transfer_description: Option<String>,
pub notification_url: String,
}
impl<F> TryFrom<&IatapayRouterData<&RefundsRouterData<F>>> for IatapayRefundRequest {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(item: &IatapayRouterData<&RefundsRouterData<F>>) -> Result<Self, Self::Error> {
Ok(Self {
amount: item.amount,
merchant_id: IatapayAuthType::try_from(&item.router_data.connector_auth_type)?
.merchant_id,
merchant_refund_id: Some(item.router_data.request.refund_id.clone()),
currency: item.router_data.request.currency.to_string(),
bank_transfer_description: item.router_data.request.reason.clone(),
notification_url: item.router_data.request.get_webhook_url()?,
})
}
}
// Type definition for Refund Response
#[allow(dead_code)]
#[derive(Debug, Serialize, Default, Deserialize)]
#[serde(rename_all = "UPPERCASE")]
pub enum RefundStatus {
#[default]
Created,
Locked,
Initiated,
Authorized,
Settled,
Cleared,
Failed,
}
impl From<RefundStatus> for enums::RefundStatus {
fn from(item: RefundStatus) -> Self {
match item {
RefundStatus::Created => Self::Pending,
RefundStatus::Failed => Self::Failure,
RefundStatus::Locked => Self::Pending,
RefundStatus::Initiated => Self::Pending,
RefundStatus::Authorized => Self::Pending,
RefundStatus::Settled => Self::Success,
RefundStatus::Cleared => Self::Success,
}
}
}
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct RefundResponse {
iata_refund_id: String,
status: RefundStatus,
merchant_refund_id: String,
amount: FloatMajorUnit,
currency: String,
bank_transfer_description: Option<String>,
failure_code: Option<String>,
failure_details: Option<String>,
lock_reason: Option<String>,
creation_date_time: Option<String>,
finish_date_time: Option<String>,
update_date_time: Option<String>,
clearance_date_time: Option<String>,
iata_payment_id: Option<String>,
merchant_payment_id: Option<String>,
payment_amount: Option<FloatMajorUnit>,
merchant_id: Option<Secret<String>>,
account_country: Option<String>,
}
impl TryFrom<RefundsResponseRouterData<Execute, RefundResponse>> for RefundsRouterData<Execute> {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: RefundsResponseRouterData<Execute, RefundResponse>,
) -> Result<Self, Self::Error> {
let refund_status = enums::RefundStatus::from(item.response.status);
let response = if is_refund_failure(refund_status) {
Err(ErrorResponse {
code: item
.response
.failure_code
.unwrap_or_else(|| NO_ERROR_CODE.to_string()),
message: item
.response
.failure_details
.clone()
.unwrap_or_else(|| NO_ERROR_MESSAGE.to_string()),
reason: item.response.failure_details,
status_code: item.http_code,
attempt_status: None,
connector_transaction_id: Some(item.response.iata_refund_id.clone()),
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
connector_metadata: None,
})
} else {
Ok(RefundsResponseData {
connector_refund_id: item.response.iata_refund_id.to_string(),
refund_status,
})
};
Ok(Self {
response,
..item.data
})
}
}
impl TryFrom<RefundsResponseRouterData<RSync, RefundResponse>> for RefundsRouterData<RSync> {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: RefundsResponseRouterData<RSync, RefundResponse>,
) -> Result<Self, Self::Error> {
let refund_status = enums::RefundStatus::from(item.response.status);
let response = if is_refund_failure(refund_status) {
Err(ErrorResponse {
code: item
.response
.failure_code
.unwrap_or_else(|| NO_ERROR_CODE.to_string()),
message: item
.response
.failure_details
.clone()
.unwrap_or_else(|| NO_ERROR_MESSAGE.to_string()),
reason: item.response.failure_details,
status_code: item.http_code,
attempt_status: None,
connector_transaction_id: Some(item.response.iata_refund_id.clone()),
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
connector_metadata: None,
})
} else {
Ok(RefundsResponseData {
connector_refund_id: item.response.iata_refund_id.to_string(),
refund_status,
})
};
Ok(Self {
response,
..item.data
})
}
}
#[derive(Debug, Deserialize, Serialize)]
pub struct IatapayErrorResponse {
pub status: Option<u16>,
pub error: String,
pub message: Option<String>,
pub reason: Option<String>,
}
#[derive(Deserialize, Debug, Serialize)]
pub struct IatapayAccessTokenErrorResponse {
pub error: String,
pub path: Option<String>,
}
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct IatapayPaymentWebhookBody {
pub status: IatapayWebhookStatus,
pub iata_payment_id: String,
pub merchant_payment_id: Option<String>,
pub failure_code: Option<String>,
pub failure_details: Option<String>,
pub amount: FloatMajorUnit,
pub currency: String,
pub checkout_methods: Option<CheckoutMethod>,
}
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct IatapayRefundWebhookBody {
pub status: IatapayRefundWebhookStatus,
pub iata_refund_id: String,
pub merchant_refund_id: Option<String>,
pub failure_code: Option<String>,
pub failure_details: Option<String>,
pub amount: FloatMajorUnit,
pub currency: String,
}
#[derive(Debug, Serialize, Deserialize)]
#[serde(untagged)]
pub enum IatapayWebhookResponse {
IatapayPaymentWebhookBody(IatapayPaymentWebhookBody),
IatapayRefundWebhookBody(IatapayRefundWebhookBody),
}
impl TryFrom<IatapayWebhookResponse> for IncomingWebhookEvent {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(payload: IatapayWebhookResponse) -> CustomResult<Self, errors::ConnectorError> {
match payload {
IatapayWebhookResponse::IatapayPaymentWebhookBody(wh_body) => match wh_body.status {
IatapayWebhookStatus::Authorized | IatapayWebhookStatus::Settled => {
Ok(Self::PaymentIntentSuccess)
}
IatapayWebhookStatus::Initiated => Ok(Self::PaymentIntentProcessing),
IatapayWebhookStatus::Failed => Ok(Self::PaymentIntentFailure),
IatapayWebhookStatus::Created
| IatapayWebhookStatus::Cleared
| IatapayWebhookStatus::Tobeinvestigated
| IatapayWebhookStatus::Blocked
| IatapayWebhookStatus::UnexpectedSettled
| IatapayWebhookStatus::Unknown => Ok(Self::EventNotSupported),
},
IatapayWebhookResponse::IatapayRefundWebhookBody(wh_body) => match wh_body.status {
IatapayRefundWebhookStatus::Cleared
| IatapayRefundWebhookStatus::Authorized
| IatapayRefundWebhookStatus::Settled => Ok(Self::RefundSuccess),
IatapayRefundWebhookStatus::Failed => Ok(Self::RefundFailure),
IatapayRefundWebhookStatus::Created
| IatapayRefundWebhookStatus::Locked
| IatapayRefundWebhookStatus::Initiated
| IatapayRefundWebhookStatus::Unknown => Ok(Self::EventNotSupported),
},
}
}
}
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "UPPERCASE")]
pub enum IatapayWebhookStatus {
Created,
Initiated,
Authorized,
Settled,
Cleared,
Failed,
Tobeinvestigated,
Blocked,
#[serde(rename = "UNEXPECTED SETTLED")]
UnexpectedSettled,
#[serde(other)]
Unknown,
}
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "UPPERCASE")]
pub enum IatapayRefundWebhookStatus {
Created,
Initiated,
Authorized,
Settled,
Failed,
Cleared,
Locked,
#[serde(other)]
Unknown,
}
|
{
"crate": "hyperswitch_connectors",
"file": "crates/hyperswitch_connectors/src/connectors/iatapay/transformers.rs",
"file_size": null,
"is_async": null,
"is_pub": null,
"num_enums": 6,
"num_structs": 15,
"num_tables": null,
"score": null,
"total_crates": null
}
|
file_hyperswitch_connectors_-8188544935081629816
|
clm
|
file
|
// Repository: hyperswitch
// Crate: hyperswitch_connectors
// File: crates/hyperswitch_connectors/src/connectors/square/transformers.rs
// Contains: 16 structs, 4 enums
use api_models::webhooks::IncomingWebhookEvent;
use common_enums::enums;
use error_stack::ResultExt;
use hyperswitch_domain_models::{
payment_method_data::{BankDebitData, Card, PayLaterData, PaymentMethodData, WalletData},
router_data::{ConnectorAuthType, PaymentMethodToken, RouterData},
router_flow_types::{refunds::Execute, RSync},
router_request_types::ResponseId,
router_response_types::{PaymentsResponseData, RefundsResponseData},
types,
};
use hyperswitch_interfaces::errors;
use masking::{ExposeInterface, PeekInterface, Secret};
use serde::{Deserialize, Serialize};
use crate::{
types::{RefundsResponseRouterData, ResponseRouterData},
unimplemented_payment_method,
utils::{self, CardData, PaymentsAuthorizeRequestData, RouterData as _},
};
impl TryFrom<(&types::TokenizationRouterData, BankDebitData)> for SquareTokenRequest {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
value: (&types::TokenizationRouterData, BankDebitData),
) -> Result<Self, Self::Error> {
let (_item, bank_debit_data) = value;
match bank_debit_data {
BankDebitData::AchBankDebit { .. }
| BankDebitData::SepaBankDebit { .. }
| BankDebitData::BecsBankDebit { .. }
| BankDebitData::BacsBankDebit { .. }
| BankDebitData::SepaGuarenteedBankDebit { .. } => {
Err(errors::ConnectorError::NotImplemented(
utils::get_unimplemented_payment_method_error_message("Square"),
))?
}
}
}
}
impl TryFrom<(&types::TokenizationRouterData, Card)> for SquareTokenRequest {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(value: (&types::TokenizationRouterData, Card)) -> Result<Self, Self::Error> {
let (item, card_data) = value;
let auth = SquareAuthType::try_from(&item.connector_auth_type)
.change_context(errors::ConnectorError::FailedToObtainAuthType)?;
let exp_year = Secret::new(
card_data
.get_expiry_year_4_digit()
.peek()
.parse::<u16>()
.change_context(errors::ConnectorError::DateFormattingFailed)?,
);
let exp_month = Secret::new(
card_data
.card_exp_month
.peek()
.parse::<u16>()
.change_context(errors::ConnectorError::DateFormattingFailed)?,
);
//The below error will never happen because if session-id is not generated it would give error in execute_pretasks itself.
let session_id = Secret::new(
item.session_token
.clone()
.ok_or(errors::ConnectorError::RequestEncodingFailed)?,
);
Ok(Self::Card(SquareTokenizeData {
client_id: auth.key1,
session_id,
card_data: SquareCardData {
exp_year,
exp_month,
number: card_data.card_number,
cvv: card_data.card_cvc,
},
}))
}
}
impl TryFrom<(&types::TokenizationRouterData, PayLaterData)> for SquareTokenRequest {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
value: (&types::TokenizationRouterData, PayLaterData),
) -> Result<Self, Self::Error> {
let (_item, pay_later_data) = value;
match pay_later_data {
PayLaterData::AfterpayClearpayRedirect { .. }
| PayLaterData::KlarnaRedirect { .. }
| PayLaterData::KlarnaSdk { .. }
| PayLaterData::AffirmRedirect { .. }
| PayLaterData::PayBrightRedirect { .. }
| PayLaterData::WalleyRedirect { .. }
| PayLaterData::AlmaRedirect { .. }
| PayLaterData::FlexitiRedirect { .. }
| PayLaterData::AtomeRedirect { .. }
| PayLaterData::BreadpayRedirect { .. } => {
Err(errors::ConnectorError::NotImplemented(
utils::get_unimplemented_payment_method_error_message("Square"),
))?
}
}
}
}
impl TryFrom<(&types::TokenizationRouterData, WalletData)> for SquareTokenRequest {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(value: (&types::TokenizationRouterData, WalletData)) -> Result<Self, Self::Error> {
let (_item, wallet_data) = value;
match wallet_data {
WalletData::AmazonPay(_)
| WalletData::ApplePay(_)
| WalletData::GooglePay(_)
| WalletData::BluecodeRedirect {}
| WalletData::AliPayQr(_)
| WalletData::AliPayRedirect(_)
| WalletData::AliPayHkRedirect(_)
| WalletData::AmazonPayRedirect(_)
| WalletData::Paysera(_)
| WalletData::Skrill(_)
| WalletData::MomoRedirect(_)
| WalletData::KakaoPayRedirect(_)
| WalletData::GoPayRedirect(_)
| WalletData::GcashRedirect(_)
| WalletData::ApplePayRedirect(_)
| WalletData::ApplePayThirdPartySdk(_)
| WalletData::DanaRedirect {}
| WalletData::GooglePayRedirect(_)
| WalletData::GooglePayThirdPartySdk(_)
| WalletData::MbWayRedirect(_)
| WalletData::MobilePayRedirect(_)
| WalletData::PaypalRedirect(_)
| WalletData::PaypalSdk(_)
| WalletData::Paze(_)
| WalletData::SamsungPay(_)
| WalletData::TwintRedirect {}
| WalletData::VippsRedirect {}
| WalletData::TouchNGoRedirect(_)
| WalletData::WeChatPayRedirect(_)
| WalletData::WeChatPayQr(_)
| WalletData::CashappQr(_)
| WalletData::SwishQr(_)
| WalletData::Mifinity(_)
| WalletData::RevolutPay(_) => Err(errors::ConnectorError::NotImplemented(
utils::get_unimplemented_payment_method_error_message("Square"),
))?,
}
}
}
#[derive(Debug, Serialize)]
pub struct SquareCardData {
cvv: Secret<String>,
exp_month: Secret<u16>,
exp_year: Secret<u16>,
number: cards::CardNumber,
}
#[derive(Debug, Serialize)]
pub struct SquareTokenizeData {
client_id: Secret<String>,
session_id: Secret<String>,
card_data: SquareCardData,
}
#[derive(Debug, Serialize)]
#[serde(untagged)]
pub enum SquareTokenRequest {
Card(SquareTokenizeData),
}
impl TryFrom<&types::TokenizationRouterData> for SquareTokenRequest {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(item: &types::TokenizationRouterData) -> Result<Self, Self::Error> {
match item.request.payment_method_data.clone() {
PaymentMethodData::BankDebit(bank_debit_data) => {
Self::try_from((item, bank_debit_data))
}
PaymentMethodData::Card(card_data) => Self::try_from((item, card_data)),
PaymentMethodData::Wallet(wallet_data) => Self::try_from((item, wallet_data)),
PaymentMethodData::PayLater(pay_later_data) => Self::try_from((item, pay_later_data)),
PaymentMethodData::GiftCard(_)
| PaymentMethodData::BankRedirect(_)
| PaymentMethodData::BankTransfer(_)
| PaymentMethodData::CardRedirect(_)
| PaymentMethodData::Crypto(_)
| PaymentMethodData::MandatePayment
| PaymentMethodData::Reward
| PaymentMethodData::RealTimePayment(_)
| PaymentMethodData::MobilePayment(_)
| PaymentMethodData::Upi(_)
| PaymentMethodData::Voucher(_)
| PaymentMethodData::OpenBanking(_)
| PaymentMethodData::CardToken(_)
| PaymentMethodData::NetworkToken(_)
| PaymentMethodData::CardDetailsForNetworkTransactionId(_) => {
Err(errors::ConnectorError::NotImplemented(
utils::get_unimplemented_payment_method_error_message("Square"),
))?
}
}
}
}
#[derive(Debug, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct SquareSessionResponse {
session_id: Secret<String>,
}
impl<F, T> TryFrom<ResponseRouterData<F, SquareSessionResponse, T, PaymentsResponseData>>
for RouterData<F, T, PaymentsResponseData>
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: ResponseRouterData<F, SquareSessionResponse, T, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
Ok(Self {
status: enums::AttemptStatus::Pending,
session_token: Some(item.response.session_id.clone().expose()),
response: Ok(PaymentsResponseData::SessionTokenResponse {
session_token: item.response.session_id.expose(),
}),
..item.data
})
}
}
#[derive(Debug, Deserialize, Serialize)]
pub struct SquareTokenResponse {
card_nonce: Secret<String>,
}
impl<F, T> TryFrom<ResponseRouterData<F, SquareTokenResponse, T, PaymentsResponseData>>
for RouterData<F, T, PaymentsResponseData>
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: ResponseRouterData<F, SquareTokenResponse, T, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
Ok(Self {
response: Ok(PaymentsResponseData::TokenizationResponse {
token: item.response.card_nonce.expose(),
}),
..item.data
})
}
}
#[derive(Debug, Deserialize, Serialize)]
pub struct SquarePaymentsAmountData {
amount: i64,
currency: enums::Currency,
}
#[derive(Debug, Serialize)]
pub struct SquarePaymentsRequestExternalDetails {
source: String,
#[serde(rename = "type")]
source_type: String,
}
#[derive(Debug, Serialize)]
pub struct SquarePaymentsRequest {
amount_money: SquarePaymentsAmountData,
idempotency_key: Secret<String>,
source_id: Secret<String>,
autocomplete: bool,
external_details: SquarePaymentsRequestExternalDetails,
}
impl TryFrom<&types::PaymentsAuthorizeRouterData> for SquarePaymentsRequest {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(item: &types::PaymentsAuthorizeRouterData) -> Result<Self, Self::Error> {
let autocomplete = item.request.is_auto_capture()?;
match item.request.payment_method_data.clone() {
PaymentMethodData::Card(_) => {
let pm_token = item.get_payment_method_token()?;
Ok(Self {
idempotency_key: Secret::new(item.attempt_id.clone()),
source_id: match pm_token {
PaymentMethodToken::Token(token) => token,
PaymentMethodToken::ApplePayDecrypt(_) => Err(
unimplemented_payment_method!("Apple Pay", "Simplified", "Square"),
)?,
PaymentMethodToken::PazeDecrypt(_) => {
Err(unimplemented_payment_method!("Paze", "Square"))?
}
PaymentMethodToken::GooglePayDecrypt(_) => {
Err(unimplemented_payment_method!("Google Pay", "Square"))?
}
},
amount_money: SquarePaymentsAmountData {
amount: item.request.amount,
currency: item.request.currency,
},
autocomplete,
external_details: SquarePaymentsRequestExternalDetails {
source: "Hyperswitch".to_string(),
source_type: "Card".to_string(),
},
})
}
PaymentMethodData::BankDebit(_)
| PaymentMethodData::GiftCard(_)
| PaymentMethodData::PayLater(_)
| PaymentMethodData::Wallet(_)
| PaymentMethodData::BankRedirect(_)
| PaymentMethodData::BankTransfer(_)
| PaymentMethodData::CardRedirect(_)
| PaymentMethodData::Crypto(_)
| PaymentMethodData::MandatePayment
| PaymentMethodData::Reward
| PaymentMethodData::RealTimePayment(_)
| PaymentMethodData::MobilePayment(_)
| PaymentMethodData::Upi(_)
| PaymentMethodData::Voucher(_)
| PaymentMethodData::OpenBanking(_)
| PaymentMethodData::CardToken(_)
| PaymentMethodData::NetworkToken(_)
| PaymentMethodData::CardDetailsForNetworkTransactionId(_) => {
Err(errors::ConnectorError::NotImplemented(
utils::get_unimplemented_payment_method_error_message("Square"),
))?
}
}
}
}
// Auth Struct
pub struct SquareAuthType {
pub(super) api_key: Secret<String>,
pub(super) key1: Secret<String>,
}
impl TryFrom<&ConnectorAuthType> for SquareAuthType {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(auth_type: &ConnectorAuthType) -> Result<Self, Self::Error> {
match auth_type {
ConnectorAuthType::BodyKey { api_key, key1, .. } => Ok(Self {
api_key: api_key.to_owned(),
key1: key1.to_owned(),
}),
ConnectorAuthType::HeaderKey { .. }
| ConnectorAuthType::SignatureKey { .. }
| ConnectorAuthType::MultiAuthKey { .. }
| ConnectorAuthType::CurrencyAuthKey { .. }
| ConnectorAuthType::TemporaryAuth
| ConnectorAuthType::NoKey
| ConnectorAuthType::CertificateAuth { .. } => {
Err(errors::ConnectorError::FailedToObtainAuthType.into())
}
}
}
}
// PaymentsResponse
#[derive(Debug, Deserialize, Serialize)]
#[serde(rename_all = "UPPERCASE")]
pub enum SquarePaymentStatus {
Completed,
Failed,
Approved,
Canceled,
Pending,
}
impl From<SquarePaymentStatus> for enums::AttemptStatus {
fn from(item: SquarePaymentStatus) -> Self {
match item {
SquarePaymentStatus::Completed => Self::Charged,
SquarePaymentStatus::Approved => Self::Authorized,
SquarePaymentStatus::Failed => Self::Failure,
SquarePaymentStatus::Canceled => Self::Voided,
SquarePaymentStatus::Pending => Self::Pending,
}
}
}
#[derive(Debug, Deserialize, Serialize)]
pub struct SquarePaymentsResponseDetails {
status: SquarePaymentStatus,
id: String,
amount_money: SquarePaymentsAmountData,
reference_id: Option<String>,
}
#[derive(Debug, Deserialize, Serialize)]
pub struct SquarePaymentsResponse {
payment: SquarePaymentsResponseDetails,
}
impl<F, T> TryFrom<ResponseRouterData<F, SquarePaymentsResponse, T, PaymentsResponseData>>
for RouterData<F, T, PaymentsResponseData>
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: ResponseRouterData<F, SquarePaymentsResponse, T, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
//Since this try_from is being used in Authorize, Sync, Capture & Void flow. Field amount_captured should only be updated in case of Charged status.
let status = enums::AttemptStatus::from(item.response.payment.status);
let mut amount_captured = None;
if status == enums::AttemptStatus::Charged {
amount_captured = Some(item.response.payment.amount_money.amount)
};
Ok(Self {
status,
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(item.response.payment.id),
redirection_data: Box::new(None),
mandate_reference: Box::new(None),
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: item.response.payment.reference_id,
incremental_authorization_allowed: None,
charges: None,
}),
amount_captured,
..item.data
})
}
}
// REFUND :
// Type definition for RefundRequest
#[derive(Debug, Serialize)]
pub struct SquareRefundRequest {
amount_money: SquarePaymentsAmountData,
idempotency_key: Secret<String>,
payment_id: Secret<String>,
}
impl<F> TryFrom<&types::RefundsRouterData<F>> for SquareRefundRequest {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(item: &types::RefundsRouterData<F>) -> Result<Self, Self::Error> {
Ok(Self {
amount_money: SquarePaymentsAmountData {
amount: item.request.refund_amount,
currency: item.request.currency,
},
idempotency_key: Secret::new(item.request.refund_id.clone()),
payment_id: Secret::new(item.request.connector_transaction_id.clone()),
})
}
}
#[derive(Debug, Deserialize, Serialize)]
#[serde(rename_all = "UPPERCASE")]
pub enum RefundStatus {
Completed,
Failed,
Pending,
Rejected,
}
impl From<RefundStatus> for enums::RefundStatus {
fn from(item: RefundStatus) -> Self {
match item {
RefundStatus::Completed => Self::Success,
RefundStatus::Failed | RefundStatus::Rejected => Self::Failure,
RefundStatus::Pending => Self::Pending,
}
}
}
#[derive(Debug, Deserialize, Serialize)]
pub struct SquareRefundResponseDetails {
status: RefundStatus,
id: String,
}
#[derive(Debug, Deserialize, Serialize)]
pub struct RefundResponse {
refund: SquareRefundResponseDetails,
}
impl TryFrom<RefundsResponseRouterData<Execute, RefundResponse>>
for types::RefundsRouterData<Execute>
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: RefundsResponseRouterData<Execute, RefundResponse>,
) -> Result<Self, Self::Error> {
Ok(Self {
response: Ok(RefundsResponseData {
connector_refund_id: item.response.refund.id,
refund_status: enums::RefundStatus::from(item.response.refund.status),
}),
..item.data
})
}
}
impl TryFrom<RefundsResponseRouterData<RSync, RefundResponse>> for types::RefundsRouterData<RSync> {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: RefundsResponseRouterData<RSync, RefundResponse>,
) -> Result<Self, Self::Error> {
Ok(Self {
response: Ok(RefundsResponseData {
connector_refund_id: item.response.refund.id,
refund_status: enums::RefundStatus::from(item.response.refund.status),
}),
..item.data
})
}
}
#[derive(Clone, Default, Debug, Serialize, Deserialize, PartialEq)]
pub struct SquareErrorDetails {
pub category: Option<String>,
pub code: Option<String>,
pub detail: Option<String>,
}
#[derive(Clone, Default, Debug, Serialize, Deserialize, PartialEq)]
pub struct SquareErrorResponse {
pub errors: Vec<SquareErrorDetails>,
}
#[derive(Debug, Deserialize)]
#[serde(rename_all = "lowercase")]
pub enum SquareWebhookObject {
Payment(SquarePaymentsResponseDetails),
Refund(SquareRefundResponseDetails),
}
#[derive(Debug, Deserialize)]
pub struct SquareWebhookData {
pub id: String,
pub object: SquareWebhookObject,
}
#[derive(Debug, Deserialize)]
pub struct SquareWebhookBody {
#[serde(rename = "type")]
pub webhook_type: String,
pub data: SquareWebhookData,
}
impl From<SquareWebhookObject> for IncomingWebhookEvent {
fn from(item: SquareWebhookObject) -> Self {
match item {
SquareWebhookObject::Payment(payment_data) => match payment_data.status {
SquarePaymentStatus::Completed => Self::PaymentIntentSuccess,
SquarePaymentStatus::Failed => Self::PaymentIntentFailure,
SquarePaymentStatus::Pending => Self::PaymentIntentProcessing,
SquarePaymentStatus::Approved | SquarePaymentStatus::Canceled => {
Self::EventNotSupported
}
},
SquareWebhookObject::Refund(refund_data) => match refund_data.status {
RefundStatus::Completed => Self::RefundSuccess,
RefundStatus::Failed | RefundStatus::Rejected => Self::RefundFailure,
RefundStatus::Pending => Self::EventNotSupported,
},
}
}
}
|
{
"crate": "hyperswitch_connectors",
"file": "crates/hyperswitch_connectors/src/connectors/square/transformers.rs",
"file_size": null,
"is_async": null,
"is_pub": null,
"num_enums": 4,
"num_structs": 16,
"num_tables": null,
"score": null,
"total_crates": null
}
|
file_hyperswitch_connectors_-479147043207761970
|
clm
|
file
|
// Repository: hyperswitch
// Crate: hyperswitch_connectors
// File: crates/hyperswitch_connectors/src/connectors/payone/transformers.rs
// Contains: 8 structs, 2 enums
#[cfg(feature = "payouts")]
use api_models::payouts::PayoutMethodData;
#[cfg(feature = "payouts")]
use cards::CardNumber;
#[cfg(feature = "payouts")]
use common_enums::{PayoutStatus, PayoutType};
use common_utils::types::MinorUnit;
#[cfg(feature = "payouts")]
use common_utils::{ext_traits::OptionExt, transformers::ForeignFrom};
#[cfg(feature = "payouts")]
use error_stack::ResultExt;
use hyperswitch_domain_models::router_data::ConnectorAuthType;
#[cfg(feature = "payouts")]
use hyperswitch_domain_models::{
router_flow_types::PoFulfill,
types::{PayoutsResponseData, PayoutsRouterData},
};
use hyperswitch_interfaces::errors::ConnectorError;
use masking::Secret;
use serde::{Deserialize, Serialize};
#[cfg(feature = "payouts")]
use crate::utils::CardData as _;
use crate::utils::{
get_unimplemented_payment_method_error_message, CardIssuer, ErrorCodeAndMessage,
};
#[cfg(feature = "payouts")]
use crate::{
types::PayoutsResponseRouterData,
utils::{PayoutsData, RouterData},
};
#[cfg(feature = "payouts")]
type Error = error_stack::Report<ConnectorError>;
use serde_repr::{Deserialize_repr, Serialize_repr};
pub struct PayoneRouterData<T> {
pub amount: MinorUnit,
pub router_data: T,
}
impl<T> From<(MinorUnit, T)> for PayoneRouterData<T> {
fn from((amount, item): (MinorUnit, T)) -> Self {
Self {
amount,
router_data: item,
}
}
}
#[derive(Debug, Deserialize, Serialize)]
pub struct ErrorResponse {
pub errors: Option<Vec<SubError>>,
pub error_id: Option<i32>,
}
#[derive(Debug, Deserialize, Serialize, Clone)]
pub struct SubError {
pub code: String,
pub message: String,
pub http_status_code: u16,
}
impl From<SubError> for ErrorCodeAndMessage {
fn from(error: SubError) -> Self {
Self {
error_code: error.code.to_string(),
error_message: error.code.to_string(),
}
}
}
// Auth Struct
pub struct PayoneAuthType {
pub(super) api_key: Secret<String>,
pub merchant_account: Secret<String>,
pub api_secret: Secret<String>,
}
impl TryFrom<&ConnectorAuthType> for PayoneAuthType {
type Error = error_stack::Report<ConnectorError>;
fn try_from(auth_type: &ConnectorAuthType) -> Result<Self, Self::Error> {
match auth_type {
ConnectorAuthType::SignatureKey {
api_key,
key1,
api_secret,
} => Ok(Self {
api_key: api_key.to_owned(),
merchant_account: key1.to_owned(),
api_secret: api_secret.to_owned(),
}),
_ => Err(ConnectorError::FailedToObtainAuthType)?,
}
}
}
#[cfg(feature = "payouts")]
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct PayonePayoutFulfillRequest {
amount_of_money: AmountOfMoney,
card_payout_method_specific_input: CardPayoutMethodSpecificInput,
}
#[cfg(feature = "payouts")]
#[derive(Debug, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct AmountOfMoney {
amount: MinorUnit,
currency_code: String,
}
#[cfg(feature = "payouts")]
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct CardPayoutMethodSpecificInput {
card: Card,
payment_product_id: PaymentProductId,
}
#[cfg(feature = "payouts")]
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct Card {
card_holder_name: Secret<String>,
card_number: CardNumber,
expiry_date: Secret<String>,
}
#[cfg(feature = "payouts")]
impl TryFrom<PayoneRouterData<&PayoutsRouterData<PoFulfill>>> for PayonePayoutFulfillRequest {
type Error = Error;
fn try_from(
item: PayoneRouterData<&PayoutsRouterData<PoFulfill>>,
) -> Result<Self, Self::Error> {
let request = item.router_data.request.to_owned();
let payout_type = request.get_payout_type()?;
match payout_type {
PayoutType::Card => {
let amount_of_money: AmountOfMoney = AmountOfMoney {
amount: item.amount,
currency_code: item.router_data.request.destination_currency.to_string(),
};
let card_payout_method_specific_input = match item
.router_data
.get_payout_method_data()?
{
PayoutMethodData::Card(card_data) => CardPayoutMethodSpecificInput {
card: Card {
card_number: card_data.card_number.clone(),
card_holder_name: card_data
.card_holder_name
.clone()
.get_required_value("card_holder_name")
.change_context(ConnectorError::MissingRequiredField {
field_name: "payout_method_data.card.holder_name",
})?,
expiry_date: card_data
.get_card_expiry_month_year_2_digit_with_delimiter(
"".to_string(),
)?,
},
payment_product_id: PaymentProductId::try_from(
card_data.get_card_issuer()?,
)?,
},
PayoutMethodData::Bank(_)
| PayoutMethodData::Wallet(_)
| PayoutMethodData::BankRedirect(_) => Err(ConnectorError::NotImplemented(
get_unimplemented_payment_method_error_message("Payone"),
))?,
};
Ok(Self {
amount_of_money,
card_payout_method_specific_input,
})
}
PayoutType::Wallet | PayoutType::Bank | PayoutType::BankRedirect => {
Err(ConnectorError::NotImplemented(
get_unimplemented_payment_method_error_message("Payone"),
))?
}
}
}
}
#[derive(Clone, Debug, Eq, Hash, PartialEq, Serialize_repr, Deserialize_repr)]
#[repr(i32)]
pub enum PaymentProductId {
Visa = 1,
MasterCard = 3,
}
impl TryFrom<CardIssuer> for PaymentProductId {
type Error = error_stack::Report<ConnectorError>;
fn try_from(issuer: CardIssuer) -> Result<Self, Self::Error> {
match issuer {
CardIssuer::Master => Ok(Self::MasterCard),
CardIssuer::Visa => Ok(Self::Visa),
CardIssuer::AmericanExpress
| CardIssuer::Maestro
| CardIssuer::Discover
| CardIssuer::DinersClub
| CardIssuer::JCB
| CardIssuer::CarteBlanche
| CardIssuer::UnionPay
| CardIssuer::CartesBancaires => Err(ConnectorError::NotImplemented(
get_unimplemented_payment_method_error_message("payone"),
)
.into()),
}
}
}
#[cfg(feature = "payouts")]
#[derive(Debug, Default, Clone, Deserialize, Serialize)]
#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
pub enum PayoneStatus {
Created,
#[default]
PendingApproval,
Rejected,
PayoutRequested,
AccountCredited,
RejectedCredit,
Cancelled,
Reversed,
}
#[cfg(feature = "payouts")]
#[derive(Debug, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct PayonePayoutFulfillResponse {
id: String,
payout_output: PayoutOutput,
status: PayoneStatus,
}
#[cfg(feature = "payouts")]
#[derive(Debug, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct PayoutOutput {
amount_of_money: AmountOfMoney,
}
#[cfg(feature = "payouts")]
impl ForeignFrom<PayoneStatus> for PayoutStatus {
fn foreign_from(payone_status: PayoneStatus) -> Self {
match payone_status {
PayoneStatus::AccountCredited => Self::Success,
PayoneStatus::RejectedCredit | PayoneStatus::Rejected => Self::Failed,
PayoneStatus::Cancelled | PayoneStatus::Reversed => Self::Cancelled,
PayoneStatus::Created
| PayoneStatus::PendingApproval
| PayoneStatus::PayoutRequested => Self::Pending,
}
}
}
#[cfg(feature = "payouts")]
impl<F> TryFrom<PayoutsResponseRouterData<F, PayonePayoutFulfillResponse>>
for PayoutsRouterData<F>
{
type Error = Error;
fn try_from(
item: PayoutsResponseRouterData<F, PayonePayoutFulfillResponse>,
) -> Result<Self, Self::Error> {
let response: PayonePayoutFulfillResponse = item.response;
Ok(Self {
response: Ok(PayoutsResponseData {
status: Some(PayoutStatus::foreign_from(response.status)),
connector_payout_id: Some(response.id),
payout_eligible: None,
should_add_next_step_to_process_tracker: false,
error_code: None,
error_message: None,
payout_connector_metadata: None,
}),
..item.data
})
}
}
|
{
"crate": "hyperswitch_connectors",
"file": "crates/hyperswitch_connectors/src/connectors/payone/transformers.rs",
"file_size": null,
"is_async": null,
"is_pub": null,
"num_enums": 2,
"num_structs": 8,
"num_tables": null,
"score": null,
"total_crates": null
}
|
file_hyperswitch_connectors_-4281283553099387307
|
clm
|
file
|
// Repository: hyperswitch
// Crate: hyperswitch_connectors
// File: crates/hyperswitch_connectors/src/connectors/worldpayvantiv/transformers.rs
// Contains: 41 structs, 11 enums
use common_utils::{
ext_traits::Encode,
types::{MinorUnit, StringMajorUnit, StringMinorUnitForConnector},
};
use error_stack::ResultExt;
use hyperswitch_domain_models::{
payment_method_data::PaymentMethodData,
router_data::{
AdditionalPaymentMethodConnectorResponse, ConnectorAuthType, ConnectorResponseData,
ErrorResponse, RouterData,
},
router_flow_types::{
refunds::{Execute, RSync},
Dsync, Fetch, Retrieve, Upload,
},
router_request_types::{
DisputeSyncData, FetchDisputesRequestData, PaymentsAuthorizeData, PaymentsCancelData,
PaymentsCancelPostCaptureData, PaymentsCaptureData, PaymentsSyncData, ResponseId,
RetrieveFileRequestData, SetupMandateRequestData, UploadFileRequestData,
},
router_response_types::{
DisputeSyncResponse, FetchDisputesResponse, MandateReference, PaymentsResponseData,
RefundsResponseData, RetrieveFileResponse, UploadFileResponse,
},
types::{
PaymentsAuthorizeRouterData, PaymentsCancelPostCaptureRouterData, PaymentsCancelRouterData,
PaymentsCaptureRouterData, RefundsRouterData, SetupMandateRouterData,
},
};
use hyperswitch_interfaces::{consts, errors};
use masking::{ExposeInterface, PeekInterface, Secret};
use serde::{Deserialize, Serialize};
use crate::{
types::{
AcceptDisputeRouterData, DisputeSyncRouterData, FetchDisputeRouterData,
RefundsResponseRouterData, ResponseRouterData, RetrieveFileRouterData,
SubmitEvidenceRouterData,
},
utils::{
self as connector_utils, CardData, PaymentsAuthorizeRequestData,
PaymentsSetupMandateRequestData, RouterData as UtilsRouterData,
},
};
pub mod worldpayvantiv_constants {
pub const WORLDPAYVANTIV_VERSION: &str = "12.23";
pub const XML_VERSION: &str = "1.0";
pub const XML_ENCODING: &str = "UTF-8";
pub const XMLNS: &str = "http://www.vantivcnp.com/schema";
pub const MAX_PAYMENT_REFERENCE_ID_LENGTH: usize = 28;
pub const XML_STANDALONE: &str = "yes";
pub const XML_CHARGEBACK: &str = "http://www.vantivcnp.com/chargebacks";
pub const MAC_FIELD_NUMBER: &str = "39";
pub const CUSTOMER_ID_MAX_LENGTH: usize = 50;
pub const CUSTOMER_REFERENCE_MAX_LENGTH: usize = 17;
}
pub struct WorldpayvantivRouterData<T> {
pub amount: MinorUnit,
pub router_data: T,
}
impl<T> From<(MinorUnit, T)> for WorldpayvantivRouterData<T> {
fn from((amount, item): (MinorUnit, T)) -> Self {
Self {
amount,
router_data: item,
}
}
}
pub struct WorldpayvantivAuthType {
pub(super) user: Secret<String>,
pub(super) password: Secret<String>,
pub(super) merchant_id: Secret<String>,
}
impl TryFrom<&ConnectorAuthType> for WorldpayvantivAuthType {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(auth_type: &ConnectorAuthType) -> Result<Self, Self::Error> {
match auth_type {
ConnectorAuthType::SignatureKey {
api_key,
api_secret,
key1,
} => Ok(Self {
user: api_key.to_owned(),
password: api_secret.to_owned(),
merchant_id: key1.to_owned(),
}),
_ => Err(errors::ConnectorError::FailedToObtainAuthType.into()),
}
}
}
#[derive(Debug, strum::Display, Serialize, Deserialize, PartialEq, Clone, Copy)]
#[strum(serialize_all = "lowercase")]
pub enum OperationId {
Sale,
Auth,
Capture,
Void,
// VoidPostCapture
VoidPC,
Refund,
}
// Represents the payment metadata for Worldpay Vantiv.
// The `report_group` field is an Option<String> to account for cases where the report group might not be provided in the metadata.
#[derive(Debug, Default, Serialize, Deserialize)]
pub struct WorldpayvantivPaymentMetadata {
pub report_group: Option<String>,
}
// Represents the merchant connector account metadata for Worldpay Vantiv
#[derive(Debug, Default, Serialize, Deserialize)]
pub struct WorldpayvantivMetadataObject {
pub report_group: String,
pub merchant_config_currency: common_enums::Currency,
}
impl TryFrom<&Option<common_utils::pii::SecretSerdeValue>> for WorldpayvantivMetadataObject {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
meta_data: &Option<common_utils::pii::SecretSerdeValue>,
) -> Result<Self, Self::Error> {
let metadata = connector_utils::to_connector_meta_from_secret::<Self>(meta_data.clone())
.change_context(errors::ConnectorError::InvalidConnectorConfig {
config: "metadata",
})?;
Ok(metadata)
}
}
#[derive(Debug, Serialize)]
#[serde(rename = "cnpOnlineRequest", rename_all = "camelCase")]
pub struct CnpOnlineRequest {
#[serde(rename = "@version")]
pub version: String,
#[serde(rename = "@xmlns")]
pub xmlns: String,
#[serde(rename = "@merchantId")]
pub merchant_id: Secret<String>,
pub authentication: Authentication,
#[serde(skip_serializing_if = "Option::is_none")]
pub authorization: Option<Authorization>,
#[serde(skip_serializing_if = "Option::is_none")]
pub sale: Option<Sale>,
#[serde(skip_serializing_if = "Option::is_none")]
pub capture: Option<Capture>,
#[serde(skip_serializing_if = "Option::is_none")]
pub auth_reversal: Option<AuthReversal>,
#[serde(skip_serializing_if = "Option::is_none")]
pub void: Option<Void>,
#[serde(skip_serializing_if = "Option::is_none")]
pub credit: Option<RefundRequest>,
}
#[derive(Debug, Serialize)]
pub struct Authentication {
pub user: Secret<String>,
pub password: Secret<String>,
}
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Void {
#[serde(rename = "@id")]
pub id: String,
#[serde(rename = "@reportGroup")]
pub report_group: String,
pub cnp_txn_id: String,
}
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct AuthReversal {
#[serde(rename = "@id")]
pub id: String,
#[serde(rename = "@reportGroup")]
pub report_group: String,
pub cnp_txn_id: String,
}
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Capture {
#[serde(rename = "@id")]
pub id: String,
#[serde(rename = "@reportGroup")]
pub report_group: String,
pub cnp_txn_id: String,
pub amount: MinorUnit,
}
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct VantivAddressData {
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<Secret<String>>,
#[serde(skip_serializing_if = "Option::is_none")]
pub address_line1: Option<Secret<String>>,
#[serde(skip_serializing_if = "Option::is_none")]
pub address_line2: Option<Secret<String>>,
#[serde(skip_serializing_if = "Option::is_none")]
pub address_line3: Option<Secret<String>>,
#[serde(skip_serializing_if = "Option::is_none")]
pub city: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub state: Option<Secret<String>>,
#[serde(skip_serializing_if = "Option::is_none")]
pub zip: Option<Secret<String>>,
#[serde(skip_serializing_if = "Option::is_none")]
pub email: Option<common_utils::pii::Email>,
#[serde(skip_serializing_if = "Option::is_none")]
pub country: Option<common_enums::CountryAlpha2>,
#[serde(skip_serializing_if = "Option::is_none")]
pub phone: Option<Secret<String>>,
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub enum VantivProcessingType {
InitialCOF,
MerchantInitiatedCOF,
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct Authorization {
#[serde(rename = "@id")]
pub id: String,
#[serde(rename = "@reportGroup")]
pub report_group: String,
#[serde(rename = "@customerId", skip_serializing_if = "Option::is_none")]
pub customer_id: Option<String>,
pub order_id: String,
pub amount: MinorUnit,
pub order_source: OrderSource,
#[serde(skip_serializing_if = "Option::is_none")]
pub bill_to_address: Option<VantivAddressData>,
#[serde(skip_serializing_if = "Option::is_none")]
pub ship_to_address: Option<VantivAddressData>,
#[serde(skip_serializing_if = "Option::is_none")]
pub card: Option<WorldpayvantivCardData>,
#[serde(skip_serializing_if = "Option::is_none")]
pub token: Option<TokenizationData>,
#[serde(skip_serializing_if = "Option::is_none")]
pub enhanced_data: Option<EnhancedData>,
#[serde(skip_serializing_if = "Option::is_none")]
pub processing_type: Option<VantivProcessingType>,
#[serde(skip_serializing_if = "Option::is_none")]
pub original_network_transaction_id: Option<Secret<String>>,
#[serde(skip_serializing_if = "Option::is_none")]
pub allow_partial_auth: Option<bool>,
#[serde(skip_serializing_if = "Option::is_none")]
pub cardholder_authentication: Option<CardholderAuthentication>,
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct CardholderAuthentication {
authentication_value: Secret<String>,
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct Sale {
#[serde(rename = "@id")]
pub id: String,
#[serde(rename = "@reportGroup")]
pub report_group: String,
#[serde(rename = "@customerId", skip_serializing_if = "Option::is_none")]
pub customer_id: Option<String>,
pub order_id: String,
pub amount: MinorUnit,
pub order_source: OrderSource,
#[serde(skip_serializing_if = "Option::is_none")]
pub bill_to_address: Option<VantivAddressData>,
#[serde(skip_serializing_if = "Option::is_none")]
pub ship_to_address: Option<VantivAddressData>,
#[serde(skip_serializing_if = "Option::is_none")]
pub card: Option<WorldpayvantivCardData>,
#[serde(skip_serializing_if = "Option::is_none")]
pub token: Option<TokenizationData>,
#[serde(skip_serializing_if = "Option::is_none")]
pub enhanced_data: Option<EnhancedData>,
#[serde(skip_serializing_if = "Option::is_none")]
pub processing_type: Option<VantivProcessingType>,
#[serde(skip_serializing_if = "Option::is_none")]
pub original_network_transaction_id: Option<Secret<String>>,
#[serde(skip_serializing_if = "Option::is_none")]
pub allow_partial_auth: Option<bool>,
}
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct EnhancedData {
#[serde(skip_serializing_if = "Option::is_none")]
pub customer_reference: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub sales_tax: Option<MinorUnit>,
#[serde(skip_serializing_if = "Option::is_none")]
pub tax_exempt: Option<bool>,
#[serde(skip_serializing_if = "Option::is_none")]
pub discount_amount: Option<MinorUnit>,
#[serde(skip_serializing_if = "Option::is_none")]
pub shipping_amount: Option<MinorUnit>,
#[serde(skip_serializing_if = "Option::is_none")]
pub duty_amount: Option<MinorUnit>,
#[serde(skip_serializing_if = "Option::is_none")]
pub ship_from_postal_code: Option<Secret<String>>,
#[serde(skip_serializing_if = "Option::is_none")]
pub destination_postal_code: Option<Secret<String>>,
#[serde(skip_serializing_if = "Option::is_none")]
pub destination_country_code: Option<common_enums::CountryAlpha2>,
#[serde(skip_serializing_if = "Option::is_none")]
pub detail_tax: Option<DetailTax>,
#[serde(skip_serializing_if = "Option::is_none")]
pub line_item_data: Option<Vec<LineItemData>>,
}
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct DetailTax {
#[serde(skip_serializing_if = "Option::is_none")]
pub tax_included_in_total: Option<bool>,
#[serde(skip_serializing_if = "Option::is_none")]
pub tax_amount: Option<MinorUnit>,
#[serde(skip_serializing_if = "Option::is_none")]
pub card_acceptor_tax_id: Option<Secret<String>>,
}
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct LineItemData {
#[serde(skip_serializing_if = "Option::is_none")]
pub item_sequence_number: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub item_description: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub product_code: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub quantity: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub unit_of_measure: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub tax_amount: Option<MinorUnit>,
#[serde(skip_serializing_if = "Option::is_none")]
pub line_item_total: Option<MinorUnit>,
#[serde(skip_serializing_if = "Option::is_none")]
pub line_item_total_with_tax: Option<MinorUnit>,
#[serde(skip_serializing_if = "Option::is_none")]
pub item_discount_amount: Option<MinorUnit>,
#[serde(skip_serializing_if = "Option::is_none")]
pub commodity_code: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub unit_cost: Option<MinorUnit>,
}
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct RefundRequest {
#[serde(rename = "@reportGroup")]
pub report_group: String,
#[serde(rename = "@id")]
pub id: String,
#[serde(rename = "@customerId", skip_serializing_if = "Option::is_none")]
pub customer_id: Option<String>,
pub cnp_txn_id: String,
pub amount: MinorUnit,
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "lowercase")]
pub enum OrderSource {
Ecommerce,
ApplePay,
MailOrder,
Telephone,
AndroidPay,
}
#[derive(Debug, Clone, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct TokenizationData {
cnp_token: Secret<String>,
exp_date: Secret<String>,
}
#[derive(Debug)]
struct VantivMandateDetail {
processing_type: Option<VantivProcessingType>,
network_transaction_id: Option<Secret<String>>,
token: Option<TokenizationData>,
}
#[derive(Debug, Clone, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct WorldpayvantivCardData {
#[serde(rename = "type")]
pub card_type: WorldpayvativCardType,
pub number: cards::CardNumber,
pub exp_date: Secret<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub card_validation_num: Option<Secret<String>>,
}
#[derive(Debug, Clone, Serialize)]
pub enum WorldpayvativCardType {
#[serde(rename = "VI")]
Visa,
#[serde(rename = "MC")]
MasterCard,
#[serde(rename = "AX")]
AmericanExpress,
#[serde(rename = "DI")]
Discover,
#[serde(rename = "DC")]
DinersClub,
#[serde(rename = "JC")]
JCB,
#[serde(rename = "")]
UnionPay,
}
#[derive(Debug, Clone, Serialize, strum::EnumString)]
pub enum WorldPayVativApplePayNetwork {
Visa,
MasterCard,
AmEx,
Discover,
DinersClub,
JCB,
UnionPay,
}
impl From<WorldPayVativApplePayNetwork> for WorldpayvativCardType {
fn from(network: WorldPayVativApplePayNetwork) -> Self {
match network {
WorldPayVativApplePayNetwork::Visa => Self::Visa,
WorldPayVativApplePayNetwork::MasterCard => Self::MasterCard,
WorldPayVativApplePayNetwork::AmEx => Self::AmericanExpress,
WorldPayVativApplePayNetwork::Discover => Self::Discover,
WorldPayVativApplePayNetwork::DinersClub => Self::DinersClub,
WorldPayVativApplePayNetwork::JCB => Self::JCB,
WorldPayVativApplePayNetwork::UnionPay => Self::UnionPay,
}
}
}
#[derive(Debug, Clone, Serialize, strum::EnumString)]
#[serde(rename_all = "UPPERCASE")]
#[strum(ascii_case_insensitive)]
pub enum WorldPayVativGooglePayNetwork {
Visa,
Mastercard,
Amex,
Discover,
Dinersclub,
Jcb,
Unionpay,
}
impl From<WorldPayVativGooglePayNetwork> for WorldpayvativCardType {
fn from(network: WorldPayVativGooglePayNetwork) -> Self {
match network {
WorldPayVativGooglePayNetwork::Visa => Self::Visa,
WorldPayVativGooglePayNetwork::Mastercard => Self::MasterCard,
WorldPayVativGooglePayNetwork::Amex => Self::AmericanExpress,
WorldPayVativGooglePayNetwork::Discover => Self::Discover,
WorldPayVativGooglePayNetwork::Dinersclub => Self::DinersClub,
WorldPayVativGooglePayNetwork::Jcb => Self::JCB,
WorldPayVativGooglePayNetwork::Unionpay => Self::UnionPay,
}
}
}
impl TryFrom<common_enums::CardNetwork> for WorldpayvativCardType {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(card_network: common_enums::CardNetwork) -> Result<Self, Self::Error> {
match card_network {
common_enums::CardNetwork::Visa => Ok(Self::Visa),
common_enums::CardNetwork::Mastercard => Ok(Self::MasterCard),
common_enums::CardNetwork::AmericanExpress => Ok(Self::AmericanExpress),
common_enums::CardNetwork::Discover => Ok(Self::Discover),
common_enums::CardNetwork::DinersClub => Ok(Self::DinersClub),
common_enums::CardNetwork::JCB => Ok(Self::JCB),
common_enums::CardNetwork::UnionPay => Ok(Self::UnionPay),
_ => Err(errors::ConnectorError::NotSupported {
message: "Card network".to_string(),
connector: "worldpayvantiv",
}
.into()),
}
}
}
impl TryFrom<&connector_utils::CardIssuer> for WorldpayvativCardType {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(card_issuer: &connector_utils::CardIssuer) -> Result<Self, Self::Error> {
match card_issuer {
connector_utils::CardIssuer::Visa => Ok(Self::Visa),
connector_utils::CardIssuer::Master => Ok(Self::MasterCard),
connector_utils::CardIssuer::AmericanExpress => Ok(Self::AmericanExpress),
connector_utils::CardIssuer::Discover => Ok(Self::Discover),
connector_utils::CardIssuer::DinersClub => Ok(Self::DinersClub),
connector_utils::CardIssuer::JCB => Ok(Self::JCB),
_ => Err(errors::ConnectorError::NotSupported {
message: "Card network".to_string(),
connector: "worldpayvantiv",
}
.into()),
}
}
}
impl<F> TryFrom<ResponseRouterData<F, VantivSyncResponse, PaymentsSyncData, PaymentsResponseData>>
for RouterData<F, PaymentsSyncData, PaymentsResponseData>
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: ResponseRouterData<F, VantivSyncResponse, PaymentsSyncData, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
let status = determine_attempt_status(&item)?;
if connector_utils::is_payment_failure(status) {
let error_code = item
.response
.payment_detail
.as_ref()
.and_then(|detail| detail.response_reason_code.clone())
.unwrap_or(consts::NO_ERROR_CODE.to_string());
let error_message = item
.response
.payment_detail
.as_ref()
.and_then(|detail| detail.response_reason_message.clone())
.unwrap_or(item.response.payment_status.to_string());
let connector_transaction_id = item
.response
.payment_detail
.as_ref()
.and_then(|detail| detail.payment_id.map(|id| id.to_string()));
Ok(Self {
status,
response: Err(ErrorResponse {
code: error_code.clone(),
message: error_message.clone(),
reason: Some(error_message.clone()),
status_code: item.http_code,
attempt_status: None,
connector_transaction_id,
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
connector_metadata: None,
}),
..item.data
})
} else {
let required_conversion_type = common_utils::types::StringMajorUnitForConnector;
let minor_amount_captured = item
.response
.payment_detail
.and_then(|details| {
details.amount.map(|amount| {
common_utils::types::AmountConvertor::convert_back(
&required_conversion_type,
amount,
item.data.request.currency,
)
})
})
.transpose()
.change_context(errors::ConnectorError::ResponseHandlingFailed)?;
Ok(Self {
status,
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(
item.response.payment_id.to_string(),
),
redirection_data: Box::new(None),
mandate_reference: Box::new(None),
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: None,
incremental_authorization_allowed: None,
charges: None,
}),
minor_amount_captured,
..item.data
})
}
}
}
fn get_bill_to_address<T>(item: &T) -> Option<VantivAddressData>
where
T: UtilsRouterData,
{
let billing_address = item.get_optional_billing();
billing_address.and_then(|billing_address| {
billing_address
.address
.clone()
.map(|address| VantivAddressData {
name: address.get_optional_full_name(),
address_line1: item.get_optional_billing_line1(),
address_line2: item.get_optional_billing_line2(),
address_line3: item.get_optional_billing_line3(),
city: item.get_optional_billing_city(),
state: item.get_optional_billing_state(),
zip: item.get_optional_billing_zip(),
email: item.get_optional_billing_email(),
country: item.get_optional_billing_country(),
phone: item.get_optional_billing_phone_number(),
})
})
}
fn extract_customer_id<T>(item: &T) -> Option<String>
where
T: UtilsRouterData,
{
item.get_optional_customer_id().and_then(|customer_id| {
let customer_id_str = customer_id.get_string_repr().to_string();
if customer_id_str.len() <= worldpayvantiv_constants::CUSTOMER_ID_MAX_LENGTH {
Some(customer_id_str)
} else {
None
}
})
}
fn get_valid_transaction_id(
id: String,
error_field_name: &str,
) -> Result<String, error_stack::Report<errors::ConnectorError>> {
if id.len() <= worldpayvantiv_constants::MAX_PAYMENT_REFERENCE_ID_LENGTH {
Ok(id.clone())
} else {
Err(errors::ConnectorError::MaxFieldLengthViolated {
connector: "Worldpayvantiv".to_string(),
field_name: error_field_name.to_string(),
max_length: worldpayvantiv_constants::MAX_PAYMENT_REFERENCE_ID_LENGTH,
received_length: id.len(),
}
.into())
}
}
fn get_ship_to_address<T>(item: &T) -> Option<VantivAddressData>
where
T: UtilsRouterData,
{
let shipping_address = item.get_optional_shipping();
shipping_address.and_then(|shipping_address| {
shipping_address
.address
.clone()
.map(|address| VantivAddressData {
name: address.get_optional_full_name(),
address_line1: item.get_optional_shipping_line1(),
address_line2: item.get_optional_shipping_line2(),
address_line3: item.get_optional_shipping_line3(),
city: item.get_optional_shipping_city(),
state: item.get_optional_shipping_state(),
zip: item.get_optional_shipping_zip(),
email: item.get_optional_shipping_email(),
country: item.get_optional_shipping_country(),
phone: item.get_optional_shipping_phone_number(),
})
})
}
impl TryFrom<&WorldpayvantivRouterData<&PaymentsAuthorizeRouterData>> for CnpOnlineRequest {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: &WorldpayvantivRouterData<&PaymentsAuthorizeRouterData>,
) -> Result<Self, Self::Error> {
if item.router_data.is_three_ds()
&& matches!(
item.router_data.request.payment_method_data,
PaymentMethodData::Card(_)
)
{
Err(errors::ConnectorError::NotSupported {
message: "Card 3DS".to_string(),
connector: "Worldpayvantiv",
})?
}
let worldpayvantiv_metadata =
WorldpayvantivMetadataObject::try_from(&item.router_data.connector_meta_data)?;
if worldpayvantiv_metadata.merchant_config_currency != item.router_data.request.currency {
Err(errors::ConnectorError::CurrencyNotSupported {
message: item.router_data.request.currency.to_string(),
connector: "Worldpayvantiv",
})?
};
let (card, cardholder_authentication) = get_vantiv_card_data(
&item.router_data.request.payment_method_data,
item.router_data.payment_method_token.clone(),
)?;
let report_group = item
.router_data
.request
.metadata
.clone()
.map(|payment_metadata| {
connector_utils::to_connector_meta::<WorldpayvantivPaymentMetadata>(Some(
payment_metadata,
))
})
.transpose()?
.and_then(|worldpayvantiv_metadata| worldpayvantiv_metadata.report_group)
.unwrap_or(worldpayvantiv_metadata.report_group);
let worldpayvantiv_auth_type =
WorldpayvantivAuthType::try_from(&item.router_data.connector_auth_type)?;
let authentication = Authentication {
user: worldpayvantiv_auth_type.user,
password: worldpayvantiv_auth_type.password,
};
let customer_id = extract_customer_id(item.router_data);
let bill_to_address = get_bill_to_address(item.router_data);
let ship_to_address = get_ship_to_address(item.router_data);
let processing_info = get_processing_info(&item.router_data.request)?;
let enhanced_data = get_enhanced_data(item.router_data)?;
let order_source = OrderSource::from((
item.router_data.request.payment_method_data.clone(),
item.router_data.request.payment_channel.clone(),
));
let (authorization, sale) =
if item.router_data.request.is_auto_capture()? && item.amount != MinorUnit::zero() {
let merchant_txn_id = get_valid_transaction_id(
item.router_data.connector_request_reference_id.clone(),
"sale.id",
)?;
(
None,
Some(Sale {
id: format!("{}_{merchant_txn_id}", OperationId::Sale),
report_group: report_group.clone(),
customer_id,
order_id: item.router_data.connector_request_reference_id.clone(),
amount: item.amount,
order_source,
bill_to_address,
ship_to_address,
card: card.clone(),
token: processing_info.token,
processing_type: processing_info.processing_type,
original_network_transaction_id: processing_info.network_transaction_id,
enhanced_data,
allow_partial_auth: item
.router_data
.request
.enable_partial_authorization
.and_then(|enable_partial_authorization| {
enable_partial_authorization.then_some(true)
}),
}),
)
} else {
let operation_id = if item.router_data.request.is_auto_capture()? {
OperationId::Sale
} else {
OperationId::Auth
};
let merchant_txn_id = get_valid_transaction_id(
item.router_data.connector_request_reference_id.clone(),
"authorization.id",
)?;
(
Some(Authorization {
id: format!("{operation_id}_{merchant_txn_id}"),
report_group: report_group.clone(),
customer_id,
order_id: item.router_data.connector_request_reference_id.clone(),
amount: item.amount,
order_source,
bill_to_address,
ship_to_address,
card: card.clone(),
token: processing_info.token,
processing_type: processing_info.processing_type,
original_network_transaction_id: processing_info.network_transaction_id,
cardholder_authentication,
enhanced_data,
allow_partial_auth: item
.router_data
.request
.enable_partial_authorization
.and_then(|enable_partial_authorization| {
enable_partial_authorization.then_some(true)
}),
}),
None,
)
};
Ok(Self {
version: worldpayvantiv_constants::WORLDPAYVANTIV_VERSION.to_string(),
xmlns: worldpayvantiv_constants::XMLNS.to_string(),
merchant_id: worldpayvantiv_auth_type.merchant_id,
authentication,
authorization,
sale,
capture: None,
auth_reversal: None,
credit: None,
void: None,
})
}
}
impl TryFrom<&SetupMandateRouterData> for CnpOnlineRequest {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(item: &SetupMandateRouterData) -> Result<Self, Self::Error> {
if item.is_three_ds()
&& matches!(item.request.payment_method_data, PaymentMethodData::Card(_))
{
Err(errors::ConnectorError::NotSupported {
message: "Card 3DS".to_string(),
connector: "Worldpayvantiv",
})?
}
let worldpayvantiv_metadata =
WorldpayvantivMetadataObject::try_from(&item.connector_meta_data)?;
if worldpayvantiv_metadata.merchant_config_currency != item.request.currency {
Err(errors::ConnectorError::CurrencyNotSupported {
message: item.request.currency.to_string(),
connector: "Worldpayvantiv",
})?
};
let (card, cardholder_authentication) = get_vantiv_card_data(
&item.request.payment_method_data,
item.payment_method_token.clone(),
)?;
let report_group = item
.request
.metadata
.clone()
.map(|payment_metadata| {
connector_utils::to_connector_meta::<WorldpayvantivPaymentMetadata>(Some(
payment_metadata.expose(),
))
})
.transpose()?
.and_then(|worldpayvantiv_metadata| worldpayvantiv_metadata.report_group)
.unwrap_or(worldpayvantiv_metadata.report_group);
let worldpayvantiv_auth_type = WorldpayvantivAuthType::try_from(&item.connector_auth_type)?;
let authentication = Authentication {
user: worldpayvantiv_auth_type.user,
password: worldpayvantiv_auth_type.password,
};
let customer_id = extract_customer_id(item);
let bill_to_address = get_bill_to_address(item);
let ship_to_address = get_ship_to_address(item);
let processing_type = if item.request.is_customer_initiated_mandate_payment() {
Some(VantivProcessingType::InitialCOF)
} else {
None
};
let enhanced_data = get_enhanced_data(item)?;
let order_source = OrderSource::from((
item.request.payment_method_data.clone(),
item.request.payment_channel.clone(),
));
let merchant_txn_id = get_valid_transaction_id(
item.connector_request_reference_id.clone(),
"authorization.id",
)?;
let authorization_data = Authorization {
id: format!("{}_{merchant_txn_id}", OperationId::Sale),
report_group: report_group.clone(),
customer_id,
order_id: item.connector_request_reference_id.clone(),
amount: MinorUnit::zero(),
order_source,
bill_to_address,
ship_to_address,
card: card.clone(),
token: None,
processing_type,
original_network_transaction_id: None,
cardholder_authentication,
enhanced_data,
allow_partial_auth: item.request.enable_partial_authorization.and_then(
|enable_partial_authorization| enable_partial_authorization.then_some(true),
),
};
Ok(Self {
version: worldpayvantiv_constants::WORLDPAYVANTIV_VERSION.to_string(),
xmlns: worldpayvantiv_constants::XMLNS.to_string(),
merchant_id: worldpayvantiv_auth_type.merchant_id,
authentication,
authorization: Some(authorization_data),
sale: None,
capture: None,
auth_reversal: None,
credit: None,
void: None,
})
}
}
impl From<(PaymentMethodData, Option<common_enums::PaymentChannel>)> for OrderSource {
fn from(
(payment_method_data, payment_channel): (
PaymentMethodData,
Option<common_enums::PaymentChannel>,
),
) -> Self {
if let PaymentMethodData::Wallet(
hyperswitch_domain_models::payment_method_data::WalletData::ApplePay(_),
) = &payment_method_data
{
return Self::ApplePay;
}
if let PaymentMethodData::Wallet(
hyperswitch_domain_models::payment_method_data::WalletData::GooglePay(_),
) = &payment_method_data
{
return Self::AndroidPay;
}
match payment_channel {
Some(common_enums::PaymentChannel::Ecommerce)
| Some(common_enums::PaymentChannel::Other(_))
| None => Self::Ecommerce,
Some(common_enums::PaymentChannel::MailOrder) => Self::MailOrder,
Some(common_enums::PaymentChannel::TelephoneOrder) => Self::Telephone,
}
}
}
fn get_enhanced_data<T>(
item: &T,
) -> Result<Option<EnhancedData>, error_stack::Report<errors::ConnectorError>>
where
T: UtilsRouterData,
{
let l2_l3_data = item.get_optional_l2_l3_data();
if let Some(l2_l3_data) = l2_l3_data {
let line_item_data = l2_l3_data.order_details.as_ref().map(|order_details| {
order_details
.iter()
.enumerate()
.map(|(i, order)| LineItemData {
item_sequence_number: Some((i + 1).to_string()),
item_description: order
.description
.as_ref()
.map(|desc| desc.chars().take(19).collect::<String>()),
product_code: order.product_id.clone(),
quantity: Some(order.quantity.to_string().clone()),
unit_of_measure: order.unit_of_measure.clone(),
tax_amount: order.total_tax_amount,
line_item_total: Some(order.amount),
line_item_total_with_tax: order.total_tax_amount.map(|tax| tax + order.amount),
item_discount_amount: order.unit_discount_amount,
commodity_code: order.commodity_code.clone(),
unit_cost: Some(order.amount),
})
.collect()
});
let tax_exempt = match l2_l3_data.tax_status {
Some(common_enums::TaxStatus::Exempt) => Some(true),
Some(common_enums::TaxStatus::Taxable) => Some(false),
None => None,
};
let customer_reference =
get_vantiv_customer_reference(&l2_l3_data.merchant_order_reference_id);
let detail_tax: Option<DetailTax> = if l2_l3_data.merchant_tax_registration_id.is_some()
&& l2_l3_data.order_details.is_some()
{
Some(DetailTax {
tax_included_in_total: match tax_exempt {
Some(false) => Some(true),
Some(true) | None => Some(false),
},
card_acceptor_tax_id: l2_l3_data.merchant_tax_registration_id.clone(),
tax_amount: l2_l3_data.order_details.as_ref().map(|orders| {
orders
.iter()
.filter_map(|order| order.total_tax_amount)
.fold(MinorUnit::zero(), |acc, tax| acc + tax)
}),
})
} else {
None
};
let enhanced_data = EnhancedData {
customer_reference,
sales_tax: l2_l3_data.order_tax_amount,
tax_exempt,
discount_amount: l2_l3_data.discount_amount,
shipping_amount: l2_l3_data.shipping_cost,
duty_amount: l2_l3_data.duty_amount,
ship_from_postal_code: l2_l3_data.get_shipping_origin_zip(),
destination_postal_code: l2_l3_data.get_shipping_zip(),
destination_country_code: l2_l3_data.get_shipping_country(),
detail_tax,
line_item_data,
};
Ok(Some(enhanced_data))
} else {
Ok(None)
}
}
fn get_processing_info(
request: &PaymentsAuthorizeData,
) -> Result<VantivMandateDetail, error_stack::Report<errors::ConnectorError>> {
if request.is_customer_initiated_mandate_payment() {
Ok(VantivMandateDetail {
processing_type: Some(VantivProcessingType::InitialCOF),
network_transaction_id: None,
token: None,
})
} else {
match request
.mandate_id
.as_ref()
.and_then(|mandate| mandate.mandate_reference_id.clone())
{
Some(api_models::payments::MandateReferenceId::NetworkMandateId(
network_transaction_id,
)) => Ok(VantivMandateDetail {
processing_type: Some(VantivProcessingType::MerchantInitiatedCOF),
network_transaction_id: Some(network_transaction_id.into()),
token: None,
}),
Some(api_models::payments::MandateReferenceId::ConnectorMandateId(mandate_data)) => {
let card_mandate_data = request.get_card_mandate_info()?;
Ok(VantivMandateDetail {
processing_type: None,
network_transaction_id: None,
token: Some(TokenizationData {
cnp_token: mandate_data
.get_connector_mandate_id()
.ok_or(errors::ConnectorError::MissingConnectorMandateID)?
.into(),
exp_date: format!(
"{}{}",
card_mandate_data.card_exp_month.peek(),
card_mandate_data.card_exp_year.peek()
)
.into(),
}),
})
}
_ => Ok(VantivMandateDetail {
processing_type: None,
network_transaction_id: None,
token: None,
}),
}
}
}
impl TryFrom<&WorldpayvantivRouterData<&PaymentsCaptureRouterData>> for CnpOnlineRequest {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: &WorldpayvantivRouterData<&PaymentsCaptureRouterData>,
) -> Result<Self, Self::Error> {
let report_group_metadata: WorldpayvantivPaymentMetadata =
connector_utils::to_connector_meta(item.router_data.request.connector_meta.clone())?;
let report_group = report_group_metadata.report_group.clone().ok_or(
errors::ConnectorError::RequestEncodingFailedWithReason(
"Failed to obtain report_group from metadata".to_string(),
),
)?;
let merchant_txn_id = get_valid_transaction_id(
item.router_data.connector_request_reference_id.clone(),
"capture.id",
)?;
let capture = Some(Capture {
id: format!("{}_{}", OperationId::Capture, merchant_txn_id),
report_group,
cnp_txn_id: item.router_data.request.connector_transaction_id.clone(),
amount: item.amount,
});
let worldpayvantiv_auth_type =
WorldpayvantivAuthType::try_from(&item.router_data.connector_auth_type)?;
let authentication = Authentication {
user: worldpayvantiv_auth_type.user,
password: worldpayvantiv_auth_type.password,
};
Ok(Self {
version: worldpayvantiv_constants::WORLDPAYVANTIV_VERSION.to_string(),
xmlns: worldpayvantiv_constants::XMLNS.to_string(),
merchant_id: worldpayvantiv_auth_type.merchant_id,
authentication,
authorization: None,
sale: None,
capture,
auth_reversal: None,
credit: None,
void: None,
})
}
}
impl<F> TryFrom<&WorldpayvantivRouterData<&RefundsRouterData<F>>> for CnpOnlineRequest {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: &WorldpayvantivRouterData<&RefundsRouterData<F>>,
) -> Result<Self, Self::Error> {
let report_group_metadata: WorldpayvantivPaymentMetadata =
connector_utils::to_connector_meta(
item.router_data.request.connector_metadata.clone(),
)?;
let report_group = report_group_metadata.report_group.clone().ok_or(
errors::ConnectorError::RequestEncodingFailedWithReason(
"Failed to obtain report_group from metadata".to_string(),
),
)?;
let customer_id = extract_customer_id(item.router_data);
let merchant_txn_id = get_valid_transaction_id(
item.router_data.connector_request_reference_id.clone(),
"credit.id",
)?;
let credit = Some(RefundRequest {
id: format!("{}_{merchant_txn_id}", OperationId::Refund),
report_group,
customer_id,
cnp_txn_id: item.router_data.request.connector_transaction_id.clone(),
amount: item.amount,
});
let worldpayvantiv_auth_type =
WorldpayvantivAuthType::try_from(&item.router_data.connector_auth_type)?;
let authentication = Authentication {
user: worldpayvantiv_auth_type.user,
password: worldpayvantiv_auth_type.password,
};
Ok(Self {
version: worldpayvantiv_constants::WORLDPAYVANTIV_VERSION.to_string(),
xmlns: worldpayvantiv_constants::XMLNS.to_string(),
merchant_id: worldpayvantiv_auth_type.merchant_id,
authentication,
authorization: None,
sale: None,
capture: None,
auth_reversal: None,
credit,
void: None,
})
}
}
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct VantivSyncErrorResponse {
pub error_messages: Vec<String>,
}
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename = "errorResponse")]
pub struct VantivDisputeErrorResponse {
#[serde(rename = "@xmlns")]
pub xmlns: String,
pub errors: Vec<VantivDisputeErrors>,
}
#[derive(Debug, Serialize, Deserialize)]
pub struct VantivDisputeErrors {
pub error: String,
}
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename = "cnpOnlineResponse", rename_all = "camelCase")]
pub struct CnpOnlineResponse {
#[serde(rename = "@version")]
pub version: String,
#[serde(rename = "@response")]
pub response_code: String,
#[serde(rename = "@message")]
pub message: String,
pub authorization_response: Option<PaymentResponse>,
pub sale_response: Option<PaymentResponse>,
pub capture_response: Option<CaptureResponse>,
pub auth_reversal_response: Option<AuthReversalResponse>,
pub void_response: Option<VoidResponse>,
pub credit_response: Option<CreditResponse>,
}
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct VantivSyncResponse {
pub payment_id: u64,
pub request_uuid: String,
pub payment_status: PaymentStatus,
pub payment_detail: Option<PaymentDetail>,
}
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct PaymentDetail {
pub payment_id: Option<u64>,
pub batch_id: Option<u64>,
pub session_id: Option<u64>,
pub response_reason_code: Option<String>,
pub response_reason_message: Option<String>,
pub reject_type: Option<String>,
pub dupe_txn_id: Option<u64>,
pub amount: Option<StringMajorUnit>,
pub purchase_currency: Option<String>,
pub post_day: Option<String>,
pub reported_timestamp: Option<String>,
pub payment_type: Option<String>,
pub merchant_order_number: Option<String>,
pub merchant_txn_id: Option<String>,
pub parent_id: Option<u64>,
pub reporting_group: Option<String>,
}
#[derive(Debug, strum::Display, Serialize, Deserialize, PartialEq, Eq)]
#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
pub enum PaymentStatus {
NotYetProcessed,
ProcessedSuccessfully,
TransactionDeclined,
StatusUnavailable,
PaymentStatusNotFound,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct CaptureResponse {
#[serde(rename = "@id")]
pub id: String,
#[serde(rename = "@reportGroup")]
pub report_group: String,
#[serde(rename = "@customerId", skip_serializing_if = "Option::is_none")]
pub customer_id: Option<String>,
#[serde(rename = "cnpTxnId")]
pub cnp_txn_id: String,
pub response: WorldpayvantivResponseCode,
pub response_time: String,
pub message: String,
pub location: Option<String>,
}
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
#[serde(rename_all = "camelCase")]
pub struct FraudResult {
pub avs_result: Option<String>,
pub card_validation_result: Option<String>,
pub authentication_result: Option<String>,
pub advanced_a_v_s_result: Option<String>,
pub advanced_fraud_results: Option<AdvancedFraudResults>,
}
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
#[serde(rename_all = "camelCase")]
pub struct AdvancedFraudResults {
pub device_review_status: Option<String>,
pub device_reputation_score: Option<String>,
pub triggered_rule: Option<Vec<String>>,
}
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
#[serde(rename_all = "camelCase")]
pub struct PaymentResponse {
#[serde(rename = "@id")]
pub id: String,
#[serde(rename = "@reportGroup")]
pub report_group: String,
#[serde(rename = "@customerId", skip_serializing_if = "Option::is_none")]
pub customer_id: Option<String>,
pub cnp_txn_id: String,
pub order_id: String,
pub response: WorldpayvantivResponseCode,
pub message: String,
pub response_time: String,
pub auth_code: Option<Secret<String>>,
pub fraud_result: Option<FraudResult>,
pub token_response: Option<TokenResponse>,
pub network_transaction_id: Option<Secret<String>>,
pub approved_amount: Option<MinorUnit>,
pub enhanced_auth_response: Option<EnhancedAuthResponse>,
}
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
#[serde(rename_all = "camelCase")]
pub struct EnhancedAuthResponse {
pub network_response: Option<NetworkResponse>,
}
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
#[serde(rename_all = "camelCase")]
pub struct NetworkResponse {
pub endpoint: Option<String>,
#[serde(default)]
#[serde(rename = "networkField")]
pub network_fields: Vec<NetworkField>,
}
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
#[serde(rename_all = "camelCase")]
pub struct NetworkField {
#[serde(rename = "@fieldNumber")]
pub field_number: String,
#[serde(rename = "@fieldName", skip_serializing_if = "Option::is_none")]
pub field_name: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub field_value: Option<String>,
#[serde(default)]
#[serde(rename = "networkSubField")]
pub network_sub_fields: Vec<NetworkSubField>,
}
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
#[serde(rename_all = "camelCase")]
pub struct NetworkSubField {
#[serde(rename = "@fieldNumber")]
pub field_number: String,
pub field_value: String,
}
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
#[serde(rename_all = "camelCase")]
pub struct TokenResponse {
pub cnp_token: Secret<String>,
pub token_response_code: String,
pub token_message: String,
#[serde(rename = "type")]
pub card_type: Option<String>,
pub bin: Option<String>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct AuthReversalResponse {
#[serde(rename = "@id")]
pub id: String,
#[serde(rename = "@reportGroup")]
pub report_group: String,
#[serde(rename = "@customerId", skip_serializing_if = "Option::is_none")]
pub customer_id: Option<String>,
pub cnp_txn_id: String,
pub response: WorldpayvantivResponseCode,
pub response_time: String,
pub post_date: Option<String>,
pub message: String,
pub location: Option<String>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct VoidResponse {
#[serde(rename = "@id")]
pub id: String,
#[serde(rename = "@reportGroup")]
pub report_group: String,
pub cnp_txn_id: String,
pub response: WorldpayvantivResponseCode,
pub response_time: String,
pub post_date: Option<String>,
pub message: String,
pub location: Option<String>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct CreditResponse {
#[serde(rename = "@id")]
pub id: String,
#[serde(rename = "@reportGroup")]
pub report_group: String,
#[serde(rename = "@customerId", skip_serializing_if = "Option::is_none")]
pub customer_id: Option<String>,
pub cnp_txn_id: String,
pub response: WorldpayvantivResponseCode,
pub response_time: String,
pub message: String,
pub location: Option<String>,
}
impl<F> TryFrom<ResponseRouterData<F, CnpOnlineResponse, PaymentsCaptureData, PaymentsResponseData>>
for RouterData<F, PaymentsCaptureData, PaymentsResponseData>
where
F: Send,
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: ResponseRouterData<F, CnpOnlineResponse, PaymentsCaptureData, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
match item.response.capture_response {
Some(capture_response) => {
let status = get_attempt_status(
WorldpayvantivPaymentFlow::Capture,
capture_response.response,
)?;
if connector_utils::is_payment_failure(status) {
let network_decline_code = item
.response
.sale_response
.as_ref()
.and_then(|pr| pr.enhanced_auth_response.as_ref())
.and_then(|ea| ea.network_response.as_ref())
.and_then(|nr| {
nr.network_fields
.iter()
.find(|f| {
f.field_number == *worldpayvantiv_constants::MAC_FIELD_NUMBER
})
.and_then(|f| f.field_value.clone())
});
let network_error_message = network_decline_code
.as_ref()
.map(|_| capture_response.message.clone());
Ok(Self {
status,
response: Err(ErrorResponse {
code: capture_response.response.to_string(),
message: capture_response.message.clone(),
reason: Some(capture_response.message.clone()),
status_code: item.http_code,
attempt_status: None,
connector_transaction_id: Some(capture_response.cnp_txn_id),
network_advice_code: None,
network_decline_code,
network_error_message,
connector_metadata: None,
}),
..item.data
})
} else {
Ok(Self {
status,
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(
capture_response.cnp_txn_id,
),
redirection_data: Box::new(None),
mandate_reference: Box::new(None),
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: None,
incremental_authorization_allowed: None,
charges: None,
}),
..item.data
})
}
}
None => {
let network_decline_code = item
.response
.sale_response
.as_ref()
.and_then(|pr| pr.enhanced_auth_response.as_ref())
.and_then(|ea| ea.network_response.as_ref())
.and_then(|nr| {
nr.network_fields
.iter()
.find(|f| f.field_number == *worldpayvantiv_constants::MAC_FIELD_NUMBER)
.and_then(|f| f.field_value.clone())
});
let network_error_message = network_decline_code
.as_ref()
.map(|_| item.response.message.clone());
Ok(Self {
status: common_enums::AttemptStatus::CaptureFailed,
response: Err(ErrorResponse {
code: item.response.response_code,
message: item.response.message.clone(),
reason: Some(item.response.message.clone()),
status_code: item.http_code,
attempt_status: None,
connector_transaction_id: None,
network_advice_code: None,
network_decline_code,
network_error_message,
connector_metadata: None,
}),
..item.data
})
}
}
}
}
fn get_vantiv_customer_reference(customer_id: &Option<String>) -> Option<String> {
customer_id.clone().and_then(|id| {
if id.len() <= worldpayvantiv_constants::CUSTOMER_REFERENCE_MAX_LENGTH {
Some(id)
} else {
None
}
})
}
impl<F> TryFrom<ResponseRouterData<F, CnpOnlineResponse, PaymentsCancelData, PaymentsResponseData>>
for RouterData<F, PaymentsCancelData, PaymentsResponseData>
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: ResponseRouterData<F, CnpOnlineResponse, PaymentsCancelData, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
match item.response.auth_reversal_response {
Some(auth_reversal_response) => {
let status = get_attempt_status(
WorldpayvantivPaymentFlow::Void,
auth_reversal_response.response,
)?;
if connector_utils::is_payment_failure(status) {
let network_decline_code = item
.response
.sale_response
.as_ref()
.and_then(|pr| pr.enhanced_auth_response.as_ref())
.and_then(|ea| ea.network_response.as_ref())
.and_then(|nr| {
nr.network_fields
.iter()
.find(|f| {
f.field_number == *worldpayvantiv_constants::MAC_FIELD_NUMBER
})
.and_then(|f| f.field_value.clone())
});
let network_error_message = network_decline_code
.as_ref()
.map(|_| auth_reversal_response.message.clone());
Ok(Self {
status,
response: Err(ErrorResponse {
code: auth_reversal_response.response.to_string(),
message: auth_reversal_response.message.clone(),
reason: Some(auth_reversal_response.message.clone()),
status_code: item.http_code,
attempt_status: None,
connector_transaction_id: Some(auth_reversal_response.cnp_txn_id),
network_advice_code: None,
network_decline_code,
network_error_message,
connector_metadata: None,
}),
..item.data
})
} else {
Ok(Self {
status,
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(
auth_reversal_response.cnp_txn_id,
),
redirection_data: Box::new(None),
mandate_reference: Box::new(None),
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: None,
incremental_authorization_allowed: None,
charges: None,
}),
..item.data
})
}
}
None => {
let network_decline_code = item
.response
.sale_response
.as_ref()
.and_then(|pr| pr.enhanced_auth_response.as_ref())
.and_then(|ea| ea.network_response.as_ref())
.and_then(|nr| {
nr.network_fields
.iter()
.find(|f| f.field_number == *worldpayvantiv_constants::MAC_FIELD_NUMBER)
.and_then(|f| f.field_value.clone())
});
let network_error_message = network_decline_code
.as_ref()
.map(|_| item.response.message.clone());
Ok(Self {
// Incase of API failure
status: common_enums::AttemptStatus::VoidFailed,
response: Err(ErrorResponse {
code: item.response.response_code,
message: item.response.message.clone(),
reason: Some(item.response.message.clone()),
status_code: item.http_code,
attempt_status: None,
connector_transaction_id: None, // Transaction id not created at connector
network_advice_code: None,
network_decline_code,
network_error_message,
connector_metadata: None,
}),
..item.data
})
}
}
}
}
impl<F>
TryFrom<
ResponseRouterData<
F,
CnpOnlineResponse,
PaymentsCancelPostCaptureData,
PaymentsResponseData,
>,
> for RouterData<F, PaymentsCancelPostCaptureData, PaymentsResponseData>
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: ResponseRouterData<
F,
CnpOnlineResponse,
PaymentsCancelPostCaptureData,
PaymentsResponseData,
>,
) -> Result<Self, Self::Error> {
match item.response.void_response {
Some(void_response) => {
let status =
get_attempt_status(WorldpayvantivPaymentFlow::VoidPC, void_response.response)?;
if connector_utils::is_payment_failure(status) {
Ok(Self {
status,
response: Err(ErrorResponse {
code: void_response.response.to_string(),
message: void_response.message.clone(),
reason: Some(void_response.message.clone()),
status_code: item.http_code,
attempt_status: None,
connector_transaction_id: Some(void_response.cnp_txn_id),
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
connector_metadata: None,
}),
..item.data
})
} else {
Ok(Self {
status,
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(
void_response.cnp_txn_id,
),
redirection_data: Box::new(None),
mandate_reference: Box::new(None),
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: None,
incremental_authorization_allowed: None,
charges: None,
}),
..item.data
})
}
}
None => Ok(Self {
// Incase of API failure
status: common_enums::AttemptStatus::VoidFailed,
response: Err(ErrorResponse {
code: item.response.response_code,
message: item.response.message.clone(),
reason: Some(item.response.message.clone()),
status_code: item.http_code,
attempt_status: None,
connector_transaction_id: None,
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
connector_metadata: None,
}),
..item.data
}),
}
}
}
impl TryFrom<RefundsResponseRouterData<Execute, CnpOnlineResponse>> for RefundsRouterData<Execute> {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: RefundsResponseRouterData<Execute, CnpOnlineResponse>,
) -> Result<Self, Self::Error> {
match item.response.credit_response {
Some(credit_response) => {
let refund_status = get_refund_status(credit_response.response)?;
if connector_utils::is_refund_failure(refund_status) {
let network_decline_code = item
.response
.sale_response
.as_ref()
.and_then(|pr| pr.enhanced_auth_response.as_ref())
.and_then(|ea| ea.network_response.as_ref())
.and_then(|nr| {
nr.network_fields
.iter()
.find(|f| {
f.field_number == *worldpayvantiv_constants::MAC_FIELD_NUMBER
})
.and_then(|f| f.field_value.clone())
});
let network_error_message = network_decline_code
.as_ref()
.map(|_| credit_response.message.clone());
Ok(Self {
response: Err(ErrorResponse {
code: credit_response.response.to_string(),
message: credit_response.message.clone(),
reason: Some(credit_response.message.clone()),
status_code: item.http_code,
attempt_status: None,
connector_transaction_id: None,
network_advice_code: None,
network_decline_code,
network_error_message,
connector_metadata: None,
}),
..item.data
})
} else {
Ok(Self {
response: Ok(RefundsResponseData {
connector_refund_id: credit_response.cnp_txn_id,
refund_status,
}),
..item.data
})
}
}
None => {
let network_decline_code = item
.response
.sale_response
.as_ref()
.and_then(|pr| pr.enhanced_auth_response.as_ref())
.and_then(|ea| ea.network_response.as_ref())
.and_then(|nr| {
nr.network_fields
.iter()
.find(|f| f.field_number == *worldpayvantiv_constants::MAC_FIELD_NUMBER)
.and_then(|f| f.field_value.clone())
});
let network_error_message = network_decline_code
.as_ref()
.map(|_| item.response.message.clone());
Ok(Self {
response: Err(ErrorResponse {
code: item.response.response_code,
message: item.response.message.clone(),
reason: Some(item.response.message.clone()),
status_code: item.http_code,
attempt_status: None,
connector_transaction_id: None,
network_advice_code: None,
network_decline_code,
network_error_message,
connector_metadata: None,
}),
..item.data
})
}
}
}
}
impl TryFrom<&PaymentsCancelRouterData> for CnpOnlineRequest {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(item: &PaymentsCancelRouterData) -> Result<Self, Self::Error> {
let report_group_metadata: WorldpayvantivPaymentMetadata =
connector_utils::to_connector_meta(item.request.connector_meta.clone())?;
let report_group = report_group_metadata.report_group.clone().ok_or(
errors::ConnectorError::RequestEncodingFailedWithReason(
"Failed to obtain report_group from metadata".to_string(),
),
)?;
let merchant_txn_id = get_valid_transaction_id(
item.connector_request_reference_id.clone(),
"authReversal.id",
)?;
let auth_reversal = Some(AuthReversal {
id: format!("{}_{merchant_txn_id}", OperationId::Void),
report_group,
cnp_txn_id: item.request.connector_transaction_id.clone(),
});
let worldpayvantiv_auth_type = WorldpayvantivAuthType::try_from(&item.connector_auth_type)?;
let authentication = Authentication {
user: worldpayvantiv_auth_type.user,
password: worldpayvantiv_auth_type.password,
};
Ok(Self {
version: worldpayvantiv_constants::WORLDPAYVANTIV_VERSION.to_string(),
xmlns: worldpayvantiv_constants::XMLNS.to_string(),
merchant_id: worldpayvantiv_auth_type.merchant_id,
authentication,
authorization: None,
sale: None,
capture: None,
auth_reversal,
credit: None,
void: None,
})
}
}
impl TryFrom<&PaymentsCancelPostCaptureRouterData> for CnpOnlineRequest {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(item: &PaymentsCancelPostCaptureRouterData) -> Result<Self, Self::Error> {
let report_group_metadata: WorldpayvantivPaymentMetadata =
connector_utils::to_connector_meta(item.request.connector_meta.clone())?;
let report_group = report_group_metadata.report_group.clone().ok_or(
errors::ConnectorError::RequestEncodingFailedWithReason(
"Failed to obtain report_group from metadata".to_string(),
),
)?;
let merchant_txn_id =
get_valid_transaction_id(item.connector_request_reference_id.clone(), "void.id")?;
let void = Some(Void {
id: format!("{}_{merchant_txn_id}", OperationId::VoidPC,),
report_group,
cnp_txn_id: item.request.connector_transaction_id.clone(),
});
let worldpayvantiv_auth_type = WorldpayvantivAuthType::try_from(&item.connector_auth_type)?;
let authentication = Authentication {
user: worldpayvantiv_auth_type.user,
password: worldpayvantiv_auth_type.password,
};
Ok(Self {
version: worldpayvantiv_constants::WORLDPAYVANTIV_VERSION.to_string(),
xmlns: worldpayvantiv_constants::XMLNS.to_string(),
merchant_id: worldpayvantiv_auth_type.merchant_id,
authentication,
authorization: None,
sale: None,
capture: None,
void,
auth_reversal: None,
credit: None,
})
}
}
impl<F>
TryFrom<ResponseRouterData<F, CnpOnlineResponse, PaymentsAuthorizeData, PaymentsResponseData>>
for RouterData<F, PaymentsAuthorizeData, PaymentsResponseData>
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: ResponseRouterData<F, CnpOnlineResponse, PaymentsAuthorizeData, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
match (item.response.sale_response.as_ref(), item.response.authorization_response.as_ref()) {
(Some(sale_response), None) => {
let status = get_attempt_status(WorldpayvantivPaymentFlow::Sale, sale_response.response)?;
if connector_utils::is_payment_failure(status) {
let network_decline_code = item
.response
.sale_response
.as_ref()
.and_then(|pr| pr.enhanced_auth_response.as_ref())
.and_then(|ea| ea.network_response.as_ref())
.and_then(|nr| {
nr.network_fields
.iter()
.find(|f| f.field_number == *worldpayvantiv_constants::MAC_FIELD_NUMBER)
.and_then(|f| f.field_value.clone())
});
let network_error_message = network_decline_code
.as_ref()
.map(|_| sale_response.message.clone());
Ok(Self {
status,
response: Err(ErrorResponse {
code: sale_response.response.to_string(),
message: sale_response.message.clone(),
reason: Some(sale_response.message.clone()),
status_code: item.http_code,
attempt_status: None,
connector_transaction_id: Some(sale_response.cnp_txn_id.clone()),
network_advice_code: None,
network_decline_code,
network_error_message,
connector_metadata: None,
}),
..item.data
})
} else {
let report_group = WorldpayvantivPaymentMetadata {
report_group: Some(sale_response.report_group.clone()),
};
let connector_metadata = Some(report_group.encode_to_value()
.change_context(errors::ConnectorError::ResponseHandlingFailed)?);
let mandate_reference_data = sale_response.token_response.clone().map(MandateReference::from);
let connector_response = sale_response.fraud_result.as_ref().map(get_connector_response);
Ok(Self {
status,
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(sale_response.cnp_txn_id.clone()),
redirection_data: Box::new(None),
mandate_reference: Box::new(mandate_reference_data),
connector_metadata,
network_txn_id: sale_response.network_transaction_id.clone().map(|network_transaction_id| network_transaction_id.expose()),
connector_response_reference_id: Some(sale_response.order_id.clone()),
incremental_authorization_allowed: None,
charges: None,
}),
connector_response,
amount_captured: sale_response.approved_amount.map(MinorUnit::get_amount_as_i64),
minor_amount_captured: sale_response.approved_amount,
..item.data
})
}
},
(None, Some(auth_response)) => {
let payment_flow_type = if item.data.request.is_auto_capture()? {
WorldpayvantivPaymentFlow::Sale
} else {
WorldpayvantivPaymentFlow::Auth
};
let status = get_attempt_status(payment_flow_type, auth_response.response)?;
if connector_utils::is_payment_failure(status) {
let network_decline_code = item
.response
.authorization_response
.as_ref()
.and_then(|pr| pr.enhanced_auth_response.as_ref())
.and_then(|ea| ea.network_response.as_ref())
.and_then(|nr| {
nr.network_fields
.iter()
.find(|f| f.field_number == *worldpayvantiv_constants::MAC_FIELD_NUMBER)
.and_then(|f| f.field_value.clone())
});
let network_error_message = network_decline_code
.as_ref()
.map(|_| auth_response.message.clone());
Ok(Self {
status,
response: Err(ErrorResponse {
code: auth_response.response.to_string(),
message: auth_response.message.clone(),
reason: Some(auth_response.message.clone()),
status_code: item.http_code,
attempt_status: None,
connector_transaction_id: Some(auth_response.cnp_txn_id.clone()),
network_advice_code: None,
network_decline_code,
network_error_message,
connector_metadata: None,
}),
..item.data
})
} else {
let report_group = WorldpayvantivPaymentMetadata {
report_group: Some(auth_response.report_group.clone()),
};
let connector_metadata = Some(report_group.encode_to_value()
.change_context(errors::ConnectorError::ResponseHandlingFailed)?);
let mandate_reference_data = auth_response.token_response.clone().map(MandateReference::from);
let connector_response = auth_response.fraud_result.as_ref().map(get_connector_response);
Ok(Self {
status,
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(auth_response.cnp_txn_id.clone()),
redirection_data: Box::new(None),
mandate_reference: Box::new(mandate_reference_data),
connector_metadata,
network_txn_id: auth_response.network_transaction_id.clone().map(|network_transaction_id| network_transaction_id.expose()),
connector_response_reference_id: Some(auth_response.order_id.clone()),
incremental_authorization_allowed: None,
charges: None,
}),
connector_response,
amount_captured: if payment_flow_type == WorldpayvantivPaymentFlow::Sale {
auth_response.approved_amount.map(MinorUnit::get_amount_as_i64)
} else {
None
},
minor_amount_capturable: if payment_flow_type == WorldpayvantivPaymentFlow::Auth {
auth_response.approved_amount
} else {
None
},
minor_amount_captured: if payment_flow_type == WorldpayvantivPaymentFlow::Sale {
auth_response.approved_amount
} else {
None
},
..item.data
})
}
},
(None, None) => {
Ok(Self {
status: common_enums::AttemptStatus::Failure,
response: Err(ErrorResponse {
code: item.response.response_code.clone(),
message: item.response.message.clone(),
reason: Some(item.response.message.clone()),
status_code: item.http_code,
attempt_status: None,
connector_transaction_id: None, // Transaction id not created at connector
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
connector_metadata: None,
}),
..item.data
})},
(_, _) => { Err(errors::ConnectorError::UnexpectedResponseError(
bytes::Bytes::from("Only one of 'sale_response' or 'authorisation_response' is expected, but both were received".to_string()),
))?
},
}
}
}
impl<F>
TryFrom<ResponseRouterData<F, CnpOnlineResponse, SetupMandateRequestData, PaymentsResponseData>>
for RouterData<F, SetupMandateRequestData, PaymentsResponseData>
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: ResponseRouterData<
F,
CnpOnlineResponse,
SetupMandateRequestData,
PaymentsResponseData,
>,
) -> Result<Self, Self::Error> {
match item.response.authorization_response.as_ref() {
Some(auth_response) => {
let status =
get_attempt_status(WorldpayvantivPaymentFlow::Sale, auth_response.response)?;
if connector_utils::is_payment_failure(status) {
let network_decline_code = item
.response
.authorization_response
.as_ref()
.and_then(|pr| pr.enhanced_auth_response.as_ref())
.and_then(|ea| ea.network_response.as_ref())
.and_then(|nr| {
nr.network_fields
.iter()
.find(|f| {
f.field_number == *worldpayvantiv_constants::MAC_FIELD_NUMBER
})
.and_then(|f| f.field_value.clone())
});
let network_error_message = network_decline_code
.as_ref()
.map(|_| auth_response.message.clone());
Ok(Self {
status,
response: Err(ErrorResponse {
code: auth_response.response.to_string(),
message: auth_response.message.clone(),
reason: Some(auth_response.message.clone()),
status_code: item.http_code,
attempt_status: None,
connector_transaction_id: Some(auth_response.order_id.clone()),
network_advice_code: None,
network_decline_code,
network_error_message,
connector_metadata: None,
}),
..item.data
})
} else {
let report_group = WorldpayvantivPaymentMetadata {
report_group: Some(auth_response.report_group.clone()),
};
let connector_metadata = Some(
report_group
.encode_to_value()
.change_context(errors::ConnectorError::ResponseHandlingFailed)?,
);
let mandate_reference_data = auth_response
.token_response
.clone()
.map(MandateReference::from);
let connector_response = auth_response
.fraud_result
.as_ref()
.map(get_connector_response);
Ok(Self {
status,
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(
auth_response.cnp_txn_id.clone(),
),
redirection_data: Box::new(None),
mandate_reference: Box::new(mandate_reference_data),
connector_metadata,
network_txn_id: auth_response
.network_transaction_id
.clone()
.map(|network_transaction_id| network_transaction_id.expose()),
connector_response_reference_id: Some(auth_response.order_id.clone()),
incremental_authorization_allowed: None,
charges: None,
}),
connector_response,
..item.data
})
}
}
None => Ok(Self {
status: common_enums::AttemptStatus::Failure,
response: Err(ErrorResponse {
code: item.response.response_code.clone(),
message: item.response.message.clone(),
reason: Some(item.response.message.clone()),
status_code: item.http_code,
attempt_status: None,
connector_transaction_id: None,
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
connector_metadata: None,
}),
..item.data
}),
}
}
}
impl From<TokenResponse> for MandateReference {
fn from(token_data: TokenResponse) -> Self {
Self {
connector_mandate_id: Some(token_data.cnp_token.expose()),
payment_method_id: None,
mandate_metadata: None,
connector_mandate_request_reference_id: None,
}
}
}
impl TryFrom<RefundsResponseRouterData<RSync, VantivSyncResponse>> for RefundsRouterData<RSync> {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: RefundsResponseRouterData<RSync, VantivSyncResponse>,
) -> Result<Self, Self::Error> {
let refund_status = get_refund_status_for_rsync(item.response.payment_status)?;
if connector_utils::is_refund_failure(refund_status) {
let error_code = item
.response
.payment_detail
.as_ref()
.and_then(|detail| detail.response_reason_code.clone())
.unwrap_or(consts::NO_ERROR_CODE.to_string());
let error_message = item
.response
.payment_detail
.as_ref()
.and_then(|detail| detail.response_reason_message.clone())
.unwrap_or(consts::NO_ERROR_MESSAGE.to_string());
let connector_transaction_id = item
.response
.payment_detail
.as_ref()
.and_then(|detail| detail.payment_id.map(|id| id.to_string()));
Ok(Self {
response: Err(ErrorResponse {
code: error_code.clone(),
message: error_message.clone(),
reason: Some(error_message.clone()),
status_code: item.http_code,
attempt_status: None,
connector_transaction_id,
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
connector_metadata: None,
}),
..item.data
})
} else {
Ok(Self {
response: Ok(RefundsResponseData {
connector_refund_id: item.response.payment_id.to_string(),
refund_status,
}),
..item.data
})
}
}
}
fn determine_attempt_status<F>(
item: &ResponseRouterData<F, VantivSyncResponse, PaymentsSyncData, PaymentsResponseData>,
) -> Result<common_enums::AttemptStatus, errors::ConnectorError> {
if let Some(merchant_txn_id) = item
.response
.payment_detail
.as_ref()
.and_then(|payment_detail| payment_detail.merchant_txn_id.clone())
{
let flow_type = get_payment_flow_type(&merchant_txn_id)?;
match item.response.payment_status {
PaymentStatus::ProcessedSuccessfully => match flow_type {
WorldpayvantivPaymentFlow::Sale | WorldpayvantivPaymentFlow::Capture => {
Ok(common_enums::AttemptStatus::Charged)
}
WorldpayvantivPaymentFlow::Auth => Ok(common_enums::AttemptStatus::Authorized),
WorldpayvantivPaymentFlow::Void => Ok(common_enums::AttemptStatus::Voided),
WorldpayvantivPaymentFlow::VoidPC => {
Ok(common_enums::AttemptStatus::VoidedPostCharge)
}
},
PaymentStatus::TransactionDeclined => match flow_type {
WorldpayvantivPaymentFlow::Sale | WorldpayvantivPaymentFlow::Capture => {
Ok(common_enums::AttemptStatus::Failure)
}
WorldpayvantivPaymentFlow::Auth => {
Ok(common_enums::AttemptStatus::AuthorizationFailed)
}
WorldpayvantivPaymentFlow::Void => Ok(common_enums::AttemptStatus::VoidFailed),
WorldpayvantivPaymentFlow::VoidPC => Ok(common_enums::AttemptStatus::VoidFailed),
},
PaymentStatus::PaymentStatusNotFound
| PaymentStatus::NotYetProcessed
| PaymentStatus::StatusUnavailable => Ok(item.data.status),
}
} else {
Ok(item.data.status)
}
}
fn get_refund_status_for_rsync(
vantiv_status: PaymentStatus,
) -> Result<common_enums::RefundStatus, errors::ConnectorError> {
match vantiv_status {
PaymentStatus::ProcessedSuccessfully => Ok(common_enums::RefundStatus::Success),
PaymentStatus::TransactionDeclined => Ok(common_enums::RefundStatus::Failure),
PaymentStatus::NotYetProcessed
| PaymentStatus::StatusUnavailable
| PaymentStatus::PaymentStatusNotFound => Ok(common_enums::RefundStatus::Pending),
}
}
#[derive(Debug, strum::Display, Serialize, Deserialize, PartialEq, Clone, Copy)]
pub enum WorldpayvantivResponseCode {
#[serde(rename = "001")]
#[strum(serialize = "001")]
TransactionReceived,
#[serde(rename = "000")]
#[strum(serialize = "000")]
Approved,
#[serde(rename = "010")]
#[strum(serialize = "010")]
PartiallyApproved,
#[serde(rename = "011")]
#[strum(serialize = "011")]
OfflineApproval,
#[serde(rename = "013")]
#[strum(serialize = "013")]
OfflineApprovalUnableToGoOnline,
#[serde(rename = "015")]
#[strum(serialize = "015")]
PendingShopperCheckoutCompletion,
#[serde(rename = "016")]
#[strum(serialize = "016")]
ShopperCheckoutExpired,
#[serde(rename = "100")]
#[strum(serialize = "100")]
ProcessingNetworkUnavailable,
#[serde(rename = "101")]
#[strum(serialize = "101")]
IssuerUnavailable,
#[serde(rename = "102")]
#[strum(serialize = "102")]
ReSubmitTransaction,
#[serde(rename = "103")]
#[strum(serialize = "103")]
MerchantNotConfiguredForProcessingAtThisSite,
#[serde(rename = "108")]
#[strum(serialize = "108")]
TryAgainLater,
#[serde(rename = "110")]
#[strum(serialize = "110")]
InsufficientFunds,
#[serde(rename = "111")]
#[strum(serialize = "111")]
AuthorizationAmountHasAlreadyBeenDepleted,
#[serde(rename = "112")]
#[strum(serialize = "112")]
InsufficientFundsRetryAfter1Hour,
#[serde(rename = "113")]
#[strum(serialize = "113")]
InsufficientFundsRetryAfter24Hour,
#[serde(rename = "114")]
#[strum(serialize = "114")]
InsufficientFundsRetryAfter2Days,
#[serde(rename = "115")]
#[strum(serialize = "115")]
InsufficientFundsRetryAfter4Days,
#[serde(rename = "116")]
#[strum(serialize = "116")]
InsufficientFundsRetryAfter6Days,
#[serde(rename = "117")]
#[strum(serialize = "117")]
InsufficientFundsRetryAfter8Days,
#[serde(rename = "118")]
#[strum(serialize = "118")]
InsufficientFundsRetryAfter10Days,
#[serde(rename = "120")]
#[strum(serialize = "120")]
CallIssuer,
#[serde(rename = "121")]
#[strum(serialize = "121")]
CallAmex,
#[serde(rename = "122")]
#[strum(serialize = "122")]
CallDinersClub,
#[serde(rename = "123")]
#[strum(serialize = "123")]
CallDiscover,
#[serde(rename = "124")]
#[strum(serialize = "124")]
CallJbs,
#[serde(rename = "125")]
#[strum(serialize = "125")]
CallVisaMastercard,
#[serde(rename = "126")]
#[strum(serialize = "126")]
CallIssuerUpdateCardholderData,
#[serde(rename = "127")]
#[strum(serialize = "127")]
ExceedsApprovalAmountLimit,
#[serde(rename = "130")]
#[strum(serialize = "130")]
CallIndicatedNumber,
#[serde(rename = "131")]
#[strum(serialize = "131")]
UnacceptablePinTransactionDeclinedRetry,
#[serde(rename = "132")]
#[strum(serialize = "132")]
PinNotChanged,
#[serde(rename = "137")]
#[strum(serialize = "137")]
ConsumerMultiUseVirtualCardNumberSoftDecline,
#[serde(rename = "138")]
#[strum(serialize = "138")]
ConsumerNonReloadablePrepaidCardSoftDecline,
#[serde(rename = "139")]
#[strum(serialize = "139")]
ConsumerSingleUseVirtualCardNumberSoftDecline,
#[serde(rename = "140")]
#[strum(serialize = "140")]
UpdateCardholderData,
#[serde(rename = "141")]
#[strum(serialize = "141")]
ConsumerNonReloadablePrepaidCardApproved,
#[serde(rename = "142")]
#[strum(serialize = "142")]
ConsumerSingleUseVirtualCardNumberApproved,
#[serde(rename = "143")]
#[strum(serialize = "143")]
MerchantDoesntQualifyForProductCode,
#[serde(rename = "145")]
#[strum(serialize = "145")]
Lifecycle,
#[serde(rename = "146")]
#[strum(serialize = "146")]
Policy,
#[serde(rename = "147")]
#[strum(serialize = "147")]
FraudSecurity,
#[serde(rename = "148")]
#[strum(serialize = "148")]
InvalidOrExpiredCardContactCardholderToUpdate,
#[serde(rename = "149")]
#[strum(serialize = "149")]
InvalidTransactionOrCardRestrictionVerifyInformationAndResubmit,
#[serde(rename = "154")]
#[strum(serialize = "154")]
AtLeastOneOfOrigIdOrOrigCnpTxnIdIsRequired,
#[serde(rename = "155")]
#[strum(serialize = "155")]
OrigCnpTxnIdIsRequiredWhenShowStatusOnlyIsUsed,
#[serde(rename = "156")]
#[strum(serialize = "156")]
IncrementalAuthNotSupported,
#[serde(rename = "157")]
#[strum(serialize = "157")]
SetAuthIndicatorToIncremental,
#[serde(rename = "158")]
#[strum(serialize = "158")]
IncrementalValueForAuthIndicatorNotAllowedInThisAuthStructure,
#[serde(rename = "159")]
#[strum(serialize = "159")]
CannotRequestAnIncrementalAuthIfOriginalAuthNotSetToEstimated,
#[serde(rename = "161")]
#[strum(serialize = "161")]
TransactionMustReferenceTheEstimatedAuth,
#[serde(rename = "162")]
#[strum(serialize = "162")]
IncrementedAuthExceedsMaxTransactionAmount,
#[serde(rename = "170")]
#[strum(serialize = "170")]
SubmittedMccNotAllowed,
#[serde(rename = "192")]
#[strum(serialize = "192")]
MerchantNotCertifiedEnabledForIias,
#[serde(rename = "206")]
#[strum(serialize = "206")]
IssuerGeneratedError,
#[serde(rename = "207")]
#[strum(serialize = "207")]
PickupCardOtherThanLostStolen,
#[serde(rename = "209")]
#[strum(serialize = "209")]
InvalidAmountHardDecline,
#[serde(rename = "211")]
#[strum(serialize = "211")]
ReversalUnsuccessful,
#[serde(rename = "212")]
#[strum(serialize = "212")]
MissingData,
#[serde(rename = "213")]
#[strum(serialize = "213")]
PickupCardLostCard,
#[serde(rename = "214")]
#[strum(serialize = "214")]
PickupCardStolenCard,
#[serde(rename = "215")]
#[strum(serialize = "215")]
RestrictedCard,
#[serde(rename = "216")]
#[strum(serialize = "216")]
InvalidDeactivate,
#[serde(rename = "217")]
#[strum(serialize = "217")]
CardAlreadyActive,
#[serde(rename = "218")]
#[strum(serialize = "218")]
CardNotActive,
#[serde(rename = "219")]
#[strum(serialize = "219")]
CardAlreadyDeactivate,
#[serde(rename = "221")]
#[strum(serialize = "221")]
OverMaxBalance,
#[serde(rename = "222")]
#[strum(serialize = "222")]
InvalidActivate,
#[serde(rename = "223")]
#[strum(serialize = "223")]
NoTransactionFoundForReversal,
#[serde(rename = "226")]
#[strum(serialize = "226")]
IncorrectCvv,
#[serde(rename = "229")]
#[strum(serialize = "229")]
IllegalTransaction,
#[serde(rename = "251")]
#[strum(serialize = "251")]
DuplicateTransaction,
#[serde(rename = "252")]
#[strum(serialize = "252")]
SystemError,
#[serde(rename = "253")]
#[strum(serialize = "253")]
DeconvertedBin,
#[serde(rename = "254")]
#[strum(serialize = "254")]
MerchantDepleted,
#[serde(rename = "255")]
#[strum(serialize = "255")]
GiftCardEscheated,
#[serde(rename = "256")]
#[strum(serialize = "256")]
InvalidReversalTypeForCreditCardTransaction,
#[serde(rename = "257")]
#[strum(serialize = "257")]
SystemErrorMessageFormatError,
#[serde(rename = "258")]
#[strum(serialize = "258")]
SystemErrorCannotProcess,
#[serde(rename = "271")]
#[strum(serialize = "271")]
RefundRejectedDueToPendingDepositStatus,
#[serde(rename = "272")]
#[strum(serialize = "272")]
RefundRejectedDueToDeclinedDepositStatus,
#[serde(rename = "273")]
#[strum(serialize = "273")]
RefundRejectedByTheProcessingNetwork,
#[serde(rename = "284")]
#[strum(serialize = "284")]
CaptureCreditAndAuthReversalTagsCannotBeUsedForGiftCardTransactions,
#[serde(rename = "301")]
#[strum(serialize = "301")]
InvalidAccountNumber,
#[serde(rename = "302")]
#[strum(serialize = "302")]
AccountNumberDoesNotMatchPaymentType,
#[serde(rename = "303")]
#[strum(serialize = "303")]
PickUpCard,
#[serde(rename = "304")]
#[strum(serialize = "304")]
LostStolenCard,
#[serde(rename = "305")]
#[strum(serialize = "305")]
ExpiredCard,
#[serde(rename = "306")]
#[strum(serialize = "306")]
AuthorizationHasExpiredNoNeedToReverse,
#[serde(rename = "307")]
#[strum(serialize = "307")]
RestrictedCardSoftDecline,
#[serde(rename = "308")]
#[strum(serialize = "308")]
RestrictedCardChargeback,
#[serde(rename = "309")]
#[strum(serialize = "309")]
RestrictedCardPrepaidCardFilteringService,
#[serde(rename = "310")]
#[strum(serialize = "310")]
InvalidTrackData,
#[serde(rename = "311")]
#[strum(serialize = "311")]
DepositIsAlreadyReferencedByAChargeback,
#[serde(rename = "312")]
#[strum(serialize = "312")]
RestrictedCardInternationalCardFilteringService,
#[serde(rename = "313")]
#[strum(serialize = "313")]
InternationalFilteringForIssuingCardCountry,
#[serde(rename = "315")]
#[strum(serialize = "315")]
RestrictedCardAuthFraudVelocityFilteringService,
#[serde(rename = "316")]
#[strum(serialize = "316")]
AutomaticRefundAlreadyIssued,
#[serde(rename = "317")]
#[strum(serialize = "317")]
RestrictedCardCardUnderSanction,
#[serde(rename = "318")]
#[strum(serialize = "318")]
RestrictedCardAuthFraudAdviceFilteringService,
#[serde(rename = "319")]
#[strum(serialize = "319")]
RestrictedCardFraudAvsFilteringService,
#[serde(rename = "320")]
#[strum(serialize = "320")]
InvalidExpirationDate,
#[serde(rename = "321")]
#[strum(serialize = "321")]
InvalidMerchant,
#[serde(rename = "322")]
#[strum(serialize = "322")]
InvalidTransaction,
#[serde(rename = "323")]
#[strum(serialize = "323")]
NoSuchIssuer,
#[serde(rename = "324")]
#[strum(serialize = "324")]
InvalidPin,
#[serde(rename = "325")]
#[strum(serialize = "325")]
TransactionNotAllowedAtTerminal,
#[serde(rename = "326")]
#[strum(serialize = "326")]
ExceedsNumberOfPinEntries,
#[serde(rename = "327")]
#[strum(serialize = "327")]
CardholderTransactionNotPermitted,
#[serde(rename = "328")]
#[strum(serialize = "328")]
CardholderRequestedThatRecurringOrInstallmentPaymentBeStopped,
#[serde(rename = "330")]
#[strum(serialize = "330")]
InvalidPaymentType,
#[serde(rename = "331")]
#[strum(serialize = "331")]
InvalidPosCapabilityForCardholderAuthorizedTerminalTransaction,
#[serde(rename = "332")]
#[strum(serialize = "332")]
InvalidPosCardholderIdForCardholderAuthorizedTerminalTransaction,
#[serde(rename = "335")]
#[strum(serialize = "335")]
ThisMethodOfPaymentDoesNotSupportAuthorizationReversals,
#[serde(rename = "336")]
#[strum(serialize = "336")]
ReversalAmountDoesNotMatchAuthorizationAmount,
#[serde(rename = "337")]
#[strum(serialize = "337")]
TransactionDidNotConvertToPinless,
#[serde(rename = "340")]
#[strum(serialize = "340")]
InvalidAmountSoftDecline,
#[serde(rename = "341")]
#[strum(serialize = "341")]
InvalidHealthcareAmounts,
#[serde(rename = "346")]
#[strum(serialize = "346")]
InvalidBillingDescriptorPrefix,
#[serde(rename = "347")]
#[strum(serialize = "347")]
InvalidBillingDescriptor,
#[serde(rename = "348")]
#[strum(serialize = "348")]
InvalidReportGroup,
#[serde(rename = "349")]
#[strum(serialize = "349")]
DoNotHonor,
#[serde(rename = "350")]
#[strum(serialize = "350")]
GenericDecline, // Soft or Hard Decline
#[serde(rename = "351")]
#[strum(serialize = "351")]
DeclineRequestPositiveId,
#[serde(rename = "352")]
#[strum(serialize = "352")]
DeclineCvv2CidFail,
#[serde(rename = "354")]
#[strum(serialize = "354")]
ThreeDSecureTransactionNotSupportedByMerchant,
#[serde(rename = "356")]
#[strum(serialize = "356")]
InvalidPurchaseLevelIiiTheTransactionContainedBadOrMissingData,
#[serde(rename = "357")]
#[strum(serialize = "357")]
MissingHealthcareIiasTagForAnFsaTransaction,
#[serde(rename = "358")]
#[strum(serialize = "358")]
RestrictedByVantivDueToSecurityCodeMismatch,
#[serde(rename = "360")]
#[strum(serialize = "360")]
NoTransactionFoundWithSpecifiedTransactionId,
#[serde(rename = "361")]
#[strum(serialize = "361")]
AuthorizationNoLongerAvailable,
#[serde(rename = "362")]
#[strum(serialize = "362")]
TransactionNotVoidedAlreadySettled,
#[serde(rename = "363")]
#[strum(serialize = "363")]
AutoVoidOnRefund,
#[serde(rename = "364")]
#[strum(serialize = "364")]
InvalidAccountNumberOriginalOrNocUpdatedECheckAccountRequired,
#[serde(rename = "365")]
#[strum(serialize = "365")]
TotalCreditAmountExceedsCaptureAmount,
#[serde(rename = "366")]
#[strum(serialize = "366")]
ExceedTheThresholdForSendingRedeposits,
#[serde(rename = "367")]
#[strum(serialize = "367")]
DepositHasNotBeenReturnedForInsufficientNonSufficientFunds,
#[serde(rename = "368")]
#[strum(serialize = "368")]
InvalidCheckNumber,
#[serde(rename = "369")]
#[strum(serialize = "369")]
RedepositAgainstInvalidTransactionType,
#[serde(rename = "370")]
#[strum(serialize = "370")]
InternalSystemErrorCallVantiv,
#[serde(rename = "371")]
#[strum(serialize = "371")]
OriginalTransactionHasBeenProcessedFutureRedepositsCanceled,
#[serde(rename = "372")]
#[strum(serialize = "372")]
SoftDeclineAutoRecyclingInProgress,
#[serde(rename = "373")]
#[strum(serialize = "373")]
HardDeclineAutoRecyclingComplete,
#[serde(rename = "375")]
#[strum(serialize = "375")]
MerchantIsNotEnabledForSurcharging,
#[serde(rename = "376")]
#[strum(serialize = "376")]
ThisMethodOfPaymentDoesNotSupportSurcharging,
#[serde(rename = "377")]
#[strum(serialize = "377")]
SurchargeIsNotValidForDebitOrPrepaidCards,
#[serde(rename = "378")]
#[strum(serialize = "378")]
SurchargeCannotExceedsTheMaximumAllowedLimit,
#[serde(rename = "379")]
#[strum(serialize = "379")]
TransactionDeclinedByTheProcessingNetwork,
#[serde(rename = "380")]
#[strum(serialize = "380")]
SecondaryAmountCannotExceedTheSaleAmount,
#[serde(rename = "381")]
#[strum(serialize = "381")]
ThisMethodOfPaymentDoesNotSupportSecondaryAmount,
#[serde(rename = "382")]
#[strum(serialize = "382")]
SecondaryAmountCannotBeLessThanZero,
#[serde(rename = "383")]
#[strum(serialize = "383")]
PartialTransactionIsNotSupportedWhenIncludingASecondaryAmount,
#[serde(rename = "384")]
#[strum(serialize = "384")]
SecondaryAmountRequiredOnPartialRefundWhenUsedOnDeposit,
#[serde(rename = "385")]
#[strum(serialize = "385")]
SecondaryAmountNotAllowedOnRefundIfNotIncludedOnDeposit,
#[serde(rename = "386")]
#[strum(serialize = "386")]
ProcessingNetworkError,
#[serde(rename = "401")]
#[strum(serialize = "401")]
InvalidEMail,
#[serde(rename = "466")]
#[strum(serialize = "466")]
InvalidCombinationOfAccountFundingTransactionTypeAndMcc,
#[serde(rename = "467")]
#[strum(serialize = "467")]
InvalidAccountFundingTransactionTypeForThisMethodOfPayment,
#[serde(rename = "468")]
#[strum(serialize = "468")]
MissingOneOrMoreReceiverFieldsForAccountFundingTransaction,
#[serde(rename = "469")]
#[strum(serialize = "469")]
InvalidRecurringRequestSeeRecurringResponseForDetails,
#[serde(rename = "470")]
#[strum(serialize = "470")]
ApprovedRecurringSubscriptionCreated,
#[serde(rename = "471")]
#[strum(serialize = "471")]
ParentTransactionDeclinedRecurringSubscriptionNotCreated,
#[serde(rename = "472")]
#[strum(serialize = "472")]
InvalidPlanCode,
#[serde(rename = "473")]
#[strum(serialize = "473")]
ScheduledRecurringPaymentProcessed,
#[serde(rename = "475")]
#[strum(serialize = "475")]
InvalidSubscriptionId,
#[serde(rename = "476")]
#[strum(serialize = "476")]
AddOnCodeAlreadyExists,
#[serde(rename = "477")]
#[strum(serialize = "477")]
DuplicateAddOnCodesInRequests,
#[serde(rename = "478")]
#[strum(serialize = "478")]
NoMatchingAddOnCodeForTheSubscription,
#[serde(rename = "480")]
#[strum(serialize = "480")]
NoMatchingDiscountCodeForTheSubscription,
#[serde(rename = "481")]
#[strum(serialize = "481")]
DuplicateDiscountCodesInRequest,
#[serde(rename = "482")]
#[strum(serialize = "482")]
InvalidStartDate,
#[serde(rename = "483")]
#[strum(serialize = "483")]
MerchantNotRegisteredForRecurringEngine,
#[serde(rename = "484")]
#[strum(serialize = "484")]
InsufficientDataToUpdateSubscription,
#[serde(rename = "485")]
#[strum(serialize = "485")]
InvalidBillingDate,
#[serde(rename = "486")]
#[strum(serialize = "486")]
DiscountCodeAlreadyExists,
#[serde(rename = "487")]
#[strum(serialize = "487")]
PlanCodeAlreadyExists,
#[serde(rename = "500")]
#[strum(serialize = "500")]
TheAccountNumberWasChanged,
#[serde(rename = "501")]
#[strum(serialize = "501")]
TheAccountWasClosed,
#[serde(rename = "502")]
#[strum(serialize = "502")]
TheExpirationDateWasChanged,
#[serde(rename = "503")]
#[strum(serialize = "503")]
TheIssuingBankDoesNotParticipateInTheUpdateProgram,
#[serde(rename = "504")]
#[strum(serialize = "504")]
ContactTheCardholderForUpdatedInformation,
#[serde(rename = "507")]
#[strum(serialize = "507")]
TheCardholderHasOptedOutOfTheUpdateProgram,
#[serde(rename = "521")]
#[strum(serialize = "521")]
SoftDeclineCardReaderDecryptionServiceIsNotAvailable,
#[serde(rename = "523")]
#[strum(serialize = "523")]
SoftDeclineDecryptionFailed,
#[serde(rename = "524")]
#[strum(serialize = "524")]
HardDeclineInputDataIsInvalid,
#[serde(rename = "530")]
#[strum(serialize = "530")]
ApplePayKeyMismatch,
#[serde(rename = "531")]
#[strum(serialize = "531")]
ApplePayDecryptionFailed,
#[serde(rename = "540")]
#[strum(serialize = "540")]
HardDeclineDecryptionFailed,
#[serde(rename = "550")]
#[strum(serialize = "550")]
AdvancedFraudFilterScoreBelowThreshold,
#[serde(rename = "555")]
#[strum(serialize = "555")]
SuspectedFraud,
#[serde(rename = "560")]
#[strum(serialize = "560")]
SystemErrorContactWorldpayRepresentative,
#[serde(rename = "561")]
#[strum(serialize = "561")]
AmazonPayAmazonUnavailable,
#[serde(rename = "562")]
#[strum(serialize = "562")]
AmazonPayAmazonDeclined,
#[serde(rename = "563")]
#[strum(serialize = "563")]
AmazonPayInvalidToken,
#[serde(rename = "564")]
#[strum(serialize = "564")]
MerchantNotEnabledForAmazonPay,
#[serde(rename = "565")]
#[strum(serialize = "565")]
TransactionNotSupportedBlockedByIssuer,
#[serde(rename = "566")]
#[strum(serialize = "566")]
BlockedByCardholderContactCardholder,
#[serde(rename = "601")]
#[strum(serialize = "601")]
SoftDeclinePrimaryFundingSourceFailed,
#[serde(rename = "602")]
#[strum(serialize = "602")]
SoftDeclineBuyerHasAlternateFundingSource,
#[serde(rename = "610")]
#[strum(serialize = "610")]
HardDeclineInvalidBillingAgreementId,
#[serde(rename = "611")]
#[strum(serialize = "611")]
HardDeclinePrimaryFundingSourceFailed,
#[serde(rename = "612")]
#[strum(serialize = "612")]
HardDeclineIssueWithPaypalAccount,
#[serde(rename = "613")]
#[strum(serialize = "613")]
HardDeclinePayPalAuthorizationIdMissing,
#[serde(rename = "614")]
#[strum(serialize = "614")]
HardDeclineConfirmedEmailAddressIsNotAvailable,
#[serde(rename = "615")]
#[strum(serialize = "615")]
HardDeclinePayPalBuyerAccountDenied,
#[serde(rename = "616")]
#[strum(serialize = "616")]
HardDeclinePayPalBuyerAccountRestricted,
#[serde(rename = "617")]
#[strum(serialize = "617")]
HardDeclinePayPalOrderHasBeenVoidedExpiredOrCompleted,
#[serde(rename = "618")]
#[strum(serialize = "618")]
HardDeclineIssueWithPayPalRefund,
#[serde(rename = "619")]
#[strum(serialize = "619")]
HardDeclinePayPalCredentialsIssue,
#[serde(rename = "620")]
#[strum(serialize = "620")]
HardDeclinePayPalAuthorizationVoidedOrExpired,
#[serde(rename = "621")]
#[strum(serialize = "621")]
HardDeclineRequiredPayPalParameterMissing,
#[serde(rename = "622")]
#[strum(serialize = "622")]
HardDeclinePayPalTransactionIdOrAuthIdIsInvalid,
#[serde(rename = "623")]
#[strum(serialize = "623")]
HardDeclineExceededMaximumNumberOfPayPalAuthorizationAttempts,
#[serde(rename = "624")]
#[strum(serialize = "624")]
HardDeclineTransactionAmountExceedsMerchantsPayPalAccountLimit,
#[serde(rename = "625")]
#[strum(serialize = "625")]
HardDeclinePayPalFundingSourcesUnavailable,
#[serde(rename = "626")]
#[strum(serialize = "626")]
HardDeclineIssueWithPayPalPrimaryFundingSource,
#[serde(rename = "627")]
#[strum(serialize = "627")]
HardDeclinePayPalProfileDoesNotAllowThisTransactionType,
#[serde(rename = "628")]
#[strum(serialize = "628")]
InternalSystemErrorWithPayPalContactVantiv,
#[serde(rename = "629")]
#[strum(serialize = "629")]
HardDeclineContactPayPalConsumerForAnotherPaymentMethod,
#[serde(rename = "637")]
#[strum(serialize = "637")]
InvalidTerminalId,
#[serde(rename = "640")]
#[strum(serialize = "640")]
PinlessDebitProcessingNotSupportedForNonRecurringTransactions,
#[serde(rename = "641")]
#[strum(serialize = "641")]
PinlessDebitProcessingNotSupportedForPartialAuths,
#[serde(rename = "642")]
#[strum(serialize = "642")]
MerchantNotConfiguredForPinlessDebitProcessing,
#[serde(rename = "651")]
#[strum(serialize = "651")]
DeclineCustomerCancellation,
#[serde(rename = "652")]
#[strum(serialize = "652")]
DeclineReTryTransaction,
#[serde(rename = "653")]
#[strum(serialize = "653")]
DeclineUnableToLocateRecordOnFile,
#[serde(rename = "654")]
#[strum(serialize = "654")]
DeclineFileUpdateFieldEditError,
#[serde(rename = "655")]
#[strum(serialize = "655")]
RemoteFunctionUnknown,
#[serde(rename = "656")]
#[strum(serialize = "656")]
DeclinedExceedsWithdrawalFrequencyLimit,
#[serde(rename = "657")]
#[strum(serialize = "657")]
DeclineCardRecordNotAvailable,
#[serde(rename = "658")]
#[strum(serialize = "658")]
InvalidAuthorizationCode,
#[serde(rename = "659")]
#[strum(serialize = "659")]
ReconciliationError,
#[serde(rename = "660")]
#[strum(serialize = "660")]
PreferredDebitRoutingDenialCreditTransactionCanBeDebit,
#[serde(rename = "661")]
#[strum(serialize = "661")]
DeclinedCurrencyConversionCompleteNoAuthPerformed,
#[serde(rename = "662")]
#[strum(serialize = "662")]
DeclinedMultiCurrencyDccFail,
#[serde(rename = "663")]
#[strum(serialize = "663")]
DeclinedMultiCurrencyInvertFail,
#[serde(rename = "664")]
#[strum(serialize = "664")]
Invalid3DSecurePassword,
#[serde(rename = "665")]
#[strum(serialize = "665")]
InvalidSocialSecurityNumber,
#[serde(rename = "666")]
#[strum(serialize = "666")]
InvalidMothersMaidenName,
#[serde(rename = "667")]
#[strum(serialize = "667")]
EnrollmentInquiryDeclined,
#[serde(rename = "668")]
#[strum(serialize = "668")]
SocialSecurityNumberNotAvailable,
#[serde(rename = "669")]
#[strum(serialize = "669")]
MothersMaidenNameNotAvailable,
#[serde(rename = "670")]
#[strum(serialize = "670")]
PinAlreadyExistsOnDatabase,
#[serde(rename = "701")]
#[strum(serialize = "701")]
Under18YearsOld,
#[serde(rename = "702")]
#[strum(serialize = "702")]
BillToOutsideUsa,
#[serde(rename = "703")]
#[strum(serialize = "703")]
BillToAddressIsNotEqualToShipToAddress,
#[serde(rename = "704")]
#[strum(serialize = "704")]
DeclinedForeignCurrencyMustBeUsd,
#[serde(rename = "705")]
#[strum(serialize = "705")]
OnNegativeFile,
#[serde(rename = "706")]
#[strum(serialize = "706")]
BlockedAgreement,
#[serde(rename = "707")]
#[strum(serialize = "707")]
InsufficientBuyingPower,
#[serde(rename = "708")]
#[strum(serialize = "708")]
InvalidData,
#[serde(rename = "709")]
#[strum(serialize = "709")]
InvalidDataDataElementsMissing,
#[serde(rename = "710")]
#[strum(serialize = "710")]
InvalidDataDataFormatError,
#[serde(rename = "711")]
#[strum(serialize = "711")]
InvalidDataInvalidTCVersion,
#[serde(rename = "712")]
#[strum(serialize = "712")]
DuplicateTransactionPaypalCredit,
#[serde(rename = "713")]
#[strum(serialize = "713")]
VerifyBillingAddress,
#[serde(rename = "714")]
#[strum(serialize = "714")]
InactiveAccount,
#[serde(rename = "716")]
#[strum(serialize = "716")]
InvalidAuth,
#[serde(rename = "717")]
#[strum(serialize = "717")]
AuthorizationAlreadyExistsForTheOrder,
#[serde(rename = "730")]
#[strum(serialize = "730")]
LodgingTransactionsAreNotAllowedForThisMcc,
#[serde(rename = "731")]
#[strum(serialize = "731")]
DurationCannotBeNegative,
#[serde(rename = "732")]
#[strum(serialize = "732")]
HotelFolioNumberCannotBeBlank,
#[serde(rename = "733")]
#[strum(serialize = "733")]
InvalidCheckInDate,
#[serde(rename = "734")]
#[strum(serialize = "734")]
InvalidCheckOutDate,
#[serde(rename = "735")]
#[strum(serialize = "735")]
InvalidCheckInOrCheckOutDate,
#[serde(rename = "736")]
#[strum(serialize = "736")]
CheckOutDateCannotBeBeforeCheckInDate,
#[serde(rename = "737")]
#[strum(serialize = "737")]
NumberOfAdultsCannotBeNegative,
#[serde(rename = "738")]
#[strum(serialize = "738")]
RoomRateCannotBeNegative,
#[serde(rename = "739")]
#[strum(serialize = "739")]
RoomTaxCannotBeNegative,
#[serde(rename = "740")]
#[strum(serialize = "740")]
DurationCanOnlyBeFrom0To99ForVisa,
#[serde(rename = "801")]
#[strum(serialize = "801")]
AccountNumberWasSuccessfullyRegistered,
#[serde(rename = "802")]
#[strum(serialize = "802")]
AccountNumberWasPreviouslyRegistered,
#[serde(rename = "803")]
#[strum(serialize = "803")]
ValidToken,
#[serde(rename = "820")]
#[strum(serialize = "820")]
CreditCardNumberWasInvalid,
#[serde(rename = "821")]
#[strum(serialize = "821")]
MerchantIsNotAuthorizedForTokens,
#[serde(rename = "822")]
#[strum(serialize = "822")]
TokenWasNotFound,
#[serde(rename = "823")]
#[strum(serialize = "823")]
TokenInvalid,
#[serde(rename = "825")]
#[strum(serialize = "825")]
MerchantNotAuthorizedForECheckTokens,
#[serde(rename = "826")]
#[strum(serialize = "826")]
CheckoutIdWasInvalid,
#[serde(rename = "827")]
#[strum(serialize = "827")]
CheckoutIdWasNotFound,
#[serde(rename = "828")]
#[strum(serialize = "828")]
GenericCheckoutIdError,
#[serde(rename = "835")]
#[strum(serialize = "835")]
CaptureAmountCanNotBeMoreThanAuthorizedAmount,
#[serde(rename = "850")]
#[strum(serialize = "850")]
TaxBillingOnlyAllowedForMcc9311,
#[serde(rename = "851")]
#[strum(serialize = "851")]
Mcc9311RequiresTaxTypeElement,
#[serde(rename = "852")]
#[strum(serialize = "852")]
DebtRepaymentOnlyAllowedForViTransactionsOnMccs6012And6051,
#[serde(rename = "861")]
#[strum(serialize = "861")]
RoutingNumberDidNotMatchOneOnFileForToken,
#[serde(rename = "877")]
#[strum(serialize = "877")]
InvalidPayPageRegistrationId,
#[serde(rename = "878")]
#[strum(serialize = "878")]
ExpiredPayPageRegistrationId,
#[serde(rename = "879")]
#[strum(serialize = "879")]
MerchantIsNotAuthorizedForPayPage,
#[serde(rename = "890")]
#[strum(serialize = "890")]
MaximumNumberOfUpdatesForThisTokenExceeded,
#[serde(rename = "891")]
#[strum(serialize = "891")]
TooManyTokensCreatedForExistingNamespace,
#[serde(rename = "895")]
#[strum(serialize = "895")]
PinValidationNotPossible,
#[serde(rename = "898")]
#[strum(serialize = "898")]
GenericTokenRegistrationError,
#[serde(rename = "899")]
#[strum(serialize = "899")]
GenericTokenUseError,
#[serde(rename = "900")]
#[strum(serialize = "900")]
InvalidBankRoutingNumber,
#[serde(rename = "901")]
#[strum(serialize = "901")]
MissingName,
#[serde(rename = "902")]
#[strum(serialize = "902")]
InvalidName,
#[serde(rename = "903")]
#[strum(serialize = "903")]
MissingBillingCountryCode,
#[serde(rename = "904")]
#[strum(serialize = "904")]
InvalidIban,
#[serde(rename = "905")]
#[strum(serialize = "905")]
MissingEmailAddress,
#[serde(rename = "906")]
#[strum(serialize = "906")]
MissingMandateReference,
#[serde(rename = "907")]
#[strum(serialize = "907")]
InvalidMandateReference,
#[serde(rename = "908")]
#[strum(serialize = "908")]
MissingMandateUrl,
#[serde(rename = "909")]
#[strum(serialize = "909")]
InvalidMandateUrl,
#[serde(rename = "911")]
#[strum(serialize = "911")]
MissingMandateSignatureDate,
#[serde(rename = "912")]
#[strum(serialize = "912")]
InvalidMandateSignatureDate,
#[serde(rename = "913")]
#[strum(serialize = "913")]
RecurringMandateAlreadyExists,
#[serde(rename = "914")]
#[strum(serialize = "914")]
RecurringMandateWasNotFound,
#[serde(rename = "915")]
#[strum(serialize = "915")]
FinalRecurringWasAlreadyReceivedUsingThisMandate,
#[serde(rename = "916")]
#[strum(serialize = "916")]
IbanDidNotMatchOneOnFileForMandate,
#[serde(rename = "917")]
#[strum(serialize = "917")]
InvalidBillingCountry,
#[serde(rename = "922")]
#[strum(serialize = "922")]
ExpirationDateRequiredForInteracTransaction,
#[serde(rename = "923")]
#[strum(serialize = "923")]
TransactionTypeIsNotSupportedWithThisMethodOfPayment,
#[serde(rename = "924")]
#[strum(serialize = "924")]
UnreferencedOrphanRefundsAreNotAllowed,
#[serde(rename = "939")]
#[strum(serialize = "939")]
UnableToVoidATransactionWithAHeldState,
#[serde(rename = "940")]
#[strum(serialize = "940")]
ThisFundingInstructionResultsInANegativeAccountBalance,
#[serde(rename = "941")]
#[strum(serialize = "941")]
AccountBalanceInformationUnavailableAtThisTime,
#[serde(rename = "942")]
#[strum(serialize = "942")]
TheSubmittedCardIsNotEligibleForFastAccessFunding,
#[serde(rename = "943")]
#[strum(serialize = "943")]
TransactionCannotUseBothCcdPaymentInformationAndCtxPaymentInformation,
#[serde(rename = "944")]
#[strum(serialize = "944")]
ProcessingError,
#[serde(rename = "945")]
#[strum(serialize = "945")]
ThisFundingInstructionTypeIsInvalidForCanadianMerchants,
#[serde(rename = "946")]
#[strum(serialize = "946")]
CtxAndCcdRecordsAreNotAllowedForCanadianMerchants,
#[serde(rename = "947")]
#[strum(serialize = "947")]
CanadianAccountNumberCannotExceed12Digits,
#[serde(rename = "948")]
#[strum(serialize = "948")]
ThisFundingInstructionTypeIsInvalid,
#[serde(rename = "950")]
#[strum(serialize = "950")]
DeclineNegativeInformationOnFile,
#[serde(rename = "951")]
#[strum(serialize = "951")]
AbsoluteDecline,
#[serde(rename = "952")]
#[strum(serialize = "952")]
TheMerchantProfileDoesNotAllowTheRequestedOperation,
#[serde(rename = "953")]
#[strum(serialize = "953")]
TheAccountCannotAcceptAchTransactions,
#[serde(rename = "954")]
#[strum(serialize = "954")]
TheAccountCannotAcceptAchTransactionsOrSiteDrafts,
#[serde(rename = "955")]
#[strum(serialize = "955")]
AmountGreaterThanLimitSpecifiedInTheMerchantProfile,
#[serde(rename = "956")]
#[strum(serialize = "956")]
MerchantIsNotAuthorizedToPerformECheckVerificationTransactions,
#[serde(rename = "957")]
#[strum(serialize = "957")]
FirstNameAndLastNameRequiredForECheckVerifications,
#[serde(rename = "958")]
#[strum(serialize = "958")]
CompanyNameRequiredForCorporateAccountForECheckVerifications,
#[serde(rename = "959")]
#[strum(serialize = "959")]
PhoneNumberRequiredForECheckVerifications,
#[serde(rename = "961")]
#[strum(serialize = "961")]
CardBrandTokenNotSupported,
#[serde(rename = "962")]
#[strum(serialize = "962")]
PrivateLabelCardNotSupported,
#[serde(rename = "965")]
#[strum(serialize = "965")]
AllowedDailyDirectDebitCaptureECheckSaleLimitExceeded,
#[serde(rename = "966")]
#[strum(serialize = "966")]
AllowedDailyDirectDebitCreditECheckCreditLimitExceeded,
#[serde(rename = "973")]
#[strum(serialize = "973")]
AccountNotEligibleForRtp,
#[serde(rename = "980")]
#[strum(serialize = "980")]
SoftDeclineCustomerAuthenticationRequired,
#[serde(rename = "981")]
#[strum(serialize = "981")]
TransactionNotReversedVoidWorkflowNeedToBeInvoked,
#[serde(rename = "982")]
#[strum(serialize = "982")]
TransactionReversalNotSupportedForTheCoreMerchants,
#[serde(rename = "983")]
#[strum(serialize = "983")]
NoValidParentDepositOrParentRefundFound,
#[serde(rename = "984")]
#[strum(serialize = "984")]
TransactionReversalNotEnabledForVisa,
#[serde(rename = "985")]
#[strum(serialize = "985")]
TransactionReversalNotEnabledForMastercard,
#[serde(rename = "986")]
#[strum(serialize = "986")]
TransactionReversalNotEnabledForAmEx,
#[serde(rename = "987")]
#[strum(serialize = "987")]
TransactionReversalNotEnabledForDiscover,
#[serde(rename = "988")]
#[strum(serialize = "988")]
TransactionReversalNotSupported,
#[serde(rename = "990")]
#[strum(serialize = "990")]
FundingInstructionHeldPleaseContactYourRelationshipManager,
#[serde(rename = "991")]
#[strum(serialize = "991")]
MissingAddressInformation,
#[serde(rename = "992")]
#[strum(serialize = "992")]
CryptographicFailure,
#[serde(rename = "993")]
#[strum(serialize = "993")]
InvalidRegionCode,
#[serde(rename = "994")]
#[strum(serialize = "994")]
InvalidCountryCode,
#[serde(rename = "995")]
#[strum(serialize = "995")]
InvalidCreditAccount,
#[serde(rename = "996")]
#[strum(serialize = "996")]
InvalidCheckingAccount,
#[serde(rename = "997")]
#[strum(serialize = "997")]
InvalidSavingsAccount,
#[serde(rename = "998")]
#[strum(serialize = "998")]
InvalidUseOfMccCorrectAndReattempt,
#[serde(rename = "999")]
#[strum(serialize = "999")]
ExceedsRtpTransactionLimit,
}
#[derive(Debug, Serialize, Deserialize, PartialEq, Clone, Copy)]
#[serde(rename_all = "lowercase")]
pub enum WorldpayvantivPaymentFlow {
Sale,
Auth,
Capture,
Void,
//VoidPostCapture
VoidPC,
}
fn get_payment_flow_type(input: &str) -> Result<WorldpayvantivPaymentFlow, errors::ConnectorError> {
if input.contains("auth") {
Ok(WorldpayvantivPaymentFlow::Auth)
} else if input.contains("sale") {
Ok(WorldpayvantivPaymentFlow::Sale)
} else if input.contains("voidpc") {
Ok(WorldpayvantivPaymentFlow::VoidPC)
} else if input.contains("void") {
Ok(WorldpayvantivPaymentFlow::Void)
} else if input.contains("capture") {
Ok(WorldpayvantivPaymentFlow::Capture)
} else {
Err(errors::ConnectorError::UnexpectedResponseError(
bytes::Bytes::from("Invalid merchantTxnId".to_string()),
))
}
}
fn get_attempt_status(
flow: WorldpayvantivPaymentFlow,
response: WorldpayvantivResponseCode,
) -> Result<common_enums::AttemptStatus, errors::ConnectorError> {
match response {
WorldpayvantivResponseCode::Approved
| WorldpayvantivResponseCode::PartiallyApproved
| WorldpayvantivResponseCode::OfflineApproval
| WorldpayvantivResponseCode::OfflineApprovalUnableToGoOnline
| WorldpayvantivResponseCode::ConsumerNonReloadablePrepaidCardApproved
| WorldpayvantivResponseCode::ConsumerSingleUseVirtualCardNumberApproved
| WorldpayvantivResponseCode::ScheduledRecurringPaymentProcessed
| WorldpayvantivResponseCode::ApprovedRecurringSubscriptionCreated
| WorldpayvantivResponseCode::PendingShopperCheckoutCompletion
| WorldpayvantivResponseCode::TransactionReceived
| WorldpayvantivResponseCode::AccountNumberWasSuccessfullyRegistered
| WorldpayvantivResponseCode::AccountNumberWasPreviouslyRegistered
| WorldpayvantivResponseCode::ValidToken
=> match flow {
WorldpayvantivPaymentFlow::Sale => Ok(common_enums::AttemptStatus::Pending),
WorldpayvantivPaymentFlow::Auth => Ok(common_enums::AttemptStatus::Authorizing),
WorldpayvantivPaymentFlow::Capture => Ok(common_enums::AttemptStatus::CaptureInitiated),
WorldpayvantivPaymentFlow::Void => Ok(common_enums::AttemptStatus::VoidInitiated),
WorldpayvantivPaymentFlow::VoidPC => {
Ok(common_enums::AttemptStatus::VoidInitiated)
}
},
WorldpayvantivResponseCode::ShopperCheckoutExpired
| WorldpayvantivResponseCode::ProcessingNetworkUnavailable
| WorldpayvantivResponseCode::IssuerUnavailable
| WorldpayvantivResponseCode::ReSubmitTransaction
| WorldpayvantivResponseCode::TryAgainLater
| WorldpayvantivResponseCode::InsufficientFunds
| WorldpayvantivResponseCode::AuthorizationAmountHasAlreadyBeenDepleted
| WorldpayvantivResponseCode::InsufficientFundsRetryAfter1Hour
| WorldpayvantivResponseCode::InsufficientFundsRetryAfter24Hour
| WorldpayvantivResponseCode::InsufficientFundsRetryAfter2Days
| WorldpayvantivResponseCode::InsufficientFundsRetryAfter4Days
| WorldpayvantivResponseCode::InsufficientFundsRetryAfter6Days
| WorldpayvantivResponseCode::InsufficientFundsRetryAfter8Days
| WorldpayvantivResponseCode::InsufficientFundsRetryAfter10Days
| WorldpayvantivResponseCode::CallIssuer
| WorldpayvantivResponseCode::CallAmex
| WorldpayvantivResponseCode::CallDinersClub
| WorldpayvantivResponseCode::CallDiscover
| WorldpayvantivResponseCode::CallJbs
| WorldpayvantivResponseCode::CallVisaMastercard
| WorldpayvantivResponseCode::CallIssuerUpdateCardholderData
| WorldpayvantivResponseCode::ExceedsApprovalAmountLimit
| WorldpayvantivResponseCode::CallIndicatedNumber
| WorldpayvantivResponseCode::UnacceptablePinTransactionDeclinedRetry
| WorldpayvantivResponseCode::PinNotChanged
| WorldpayvantivResponseCode::ConsumerMultiUseVirtualCardNumberSoftDecline
| WorldpayvantivResponseCode::ConsumerNonReloadablePrepaidCardSoftDecline
| WorldpayvantivResponseCode::ConsumerSingleUseVirtualCardNumberSoftDecline
| WorldpayvantivResponseCode::UpdateCardholderData
| WorldpayvantivResponseCode::MerchantDoesntQualifyForProductCode
| WorldpayvantivResponseCode::Lifecycle
| WorldpayvantivResponseCode::Policy
| WorldpayvantivResponseCode::FraudSecurity
| WorldpayvantivResponseCode::InvalidOrExpiredCardContactCardholderToUpdate
| WorldpayvantivResponseCode::InvalidTransactionOrCardRestrictionVerifyInformationAndResubmit
| WorldpayvantivResponseCode::AtLeastOneOfOrigIdOrOrigCnpTxnIdIsRequired
| WorldpayvantivResponseCode::OrigCnpTxnIdIsRequiredWhenShowStatusOnlyIsUsed
| WorldpayvantivResponseCode::IncrementalAuthNotSupported
| WorldpayvantivResponseCode::SetAuthIndicatorToIncremental
| WorldpayvantivResponseCode::IncrementalValueForAuthIndicatorNotAllowedInThisAuthStructure
| WorldpayvantivResponseCode::CannotRequestAnIncrementalAuthIfOriginalAuthNotSetToEstimated
| WorldpayvantivResponseCode::TransactionMustReferenceTheEstimatedAuth
| WorldpayvantivResponseCode::IncrementedAuthExceedsMaxTransactionAmount
| WorldpayvantivResponseCode::SubmittedMccNotAllowed
| WorldpayvantivResponseCode::MerchantNotCertifiedEnabledForIias
| WorldpayvantivResponseCode::IssuerGeneratedError
| WorldpayvantivResponseCode::PickupCardOtherThanLostStolen
| WorldpayvantivResponseCode::InvalidAmountHardDecline
| WorldpayvantivResponseCode::ReversalUnsuccessful
| WorldpayvantivResponseCode::MissingData
| WorldpayvantivResponseCode::PickupCardLostCard
| WorldpayvantivResponseCode::PickupCardStolenCard
| WorldpayvantivResponseCode::RestrictedCard
| WorldpayvantivResponseCode::InvalidDeactivate
| WorldpayvantivResponseCode::CardAlreadyActive
| WorldpayvantivResponseCode::CardNotActive
| WorldpayvantivResponseCode::CardAlreadyDeactivate
| WorldpayvantivResponseCode::OverMaxBalance
| WorldpayvantivResponseCode::InvalidActivate
| WorldpayvantivResponseCode::NoTransactionFoundForReversal
| WorldpayvantivResponseCode::IncorrectCvv
| WorldpayvantivResponseCode::IllegalTransaction
| WorldpayvantivResponseCode::DuplicateTransaction
| WorldpayvantivResponseCode::SystemError
| WorldpayvantivResponseCode::DeconvertedBin
| WorldpayvantivResponseCode::MerchantDepleted
| WorldpayvantivResponseCode::GiftCardEscheated
| WorldpayvantivResponseCode::InvalidReversalTypeForCreditCardTransaction
| WorldpayvantivResponseCode::SystemErrorMessageFormatError
| WorldpayvantivResponseCode::SystemErrorCannotProcess
| WorldpayvantivResponseCode::RefundRejectedDueToPendingDepositStatus
| WorldpayvantivResponseCode::RefundRejectedDueToDeclinedDepositStatus
| WorldpayvantivResponseCode::RefundRejectedByTheProcessingNetwork
| WorldpayvantivResponseCode::CaptureCreditAndAuthReversalTagsCannotBeUsedForGiftCardTransactions
| WorldpayvantivResponseCode::InvalidAccountNumber
| WorldpayvantivResponseCode::AccountNumberDoesNotMatchPaymentType
| WorldpayvantivResponseCode::PickUpCard
| WorldpayvantivResponseCode::LostStolenCard
| WorldpayvantivResponseCode::ExpiredCard
| WorldpayvantivResponseCode::AuthorizationHasExpiredNoNeedToReverse
| WorldpayvantivResponseCode::RestrictedCardSoftDecline
| WorldpayvantivResponseCode::RestrictedCardChargeback
| WorldpayvantivResponseCode::RestrictedCardPrepaidCardFilteringService
| WorldpayvantivResponseCode::InvalidTrackData
| WorldpayvantivResponseCode::DepositIsAlreadyReferencedByAChargeback
| WorldpayvantivResponseCode::RestrictedCardInternationalCardFilteringService
| WorldpayvantivResponseCode::InternationalFilteringForIssuingCardCountry
| WorldpayvantivResponseCode::RestrictedCardAuthFraudVelocityFilteringService
| WorldpayvantivResponseCode::AutomaticRefundAlreadyIssued
| WorldpayvantivResponseCode::RestrictedCardAuthFraudAdviceFilteringService
| WorldpayvantivResponseCode::RestrictedCardFraudAvsFilteringService
| WorldpayvantivResponseCode::InvalidExpirationDate
| WorldpayvantivResponseCode::InvalidMerchant
| WorldpayvantivResponseCode::InvalidTransaction
| WorldpayvantivResponseCode::NoSuchIssuer
| WorldpayvantivResponseCode::InvalidPin
| WorldpayvantivResponseCode::TransactionNotAllowedAtTerminal
| WorldpayvantivResponseCode::ExceedsNumberOfPinEntries
| WorldpayvantivResponseCode::CardholderTransactionNotPermitted
| WorldpayvantivResponseCode::CardholderRequestedThatRecurringOrInstallmentPaymentBeStopped
| WorldpayvantivResponseCode::InvalidPaymentType
| WorldpayvantivResponseCode::InvalidPosCapabilityForCardholderAuthorizedTerminalTransaction
| WorldpayvantivResponseCode::InvalidPosCardholderIdForCardholderAuthorizedTerminalTransaction
| WorldpayvantivResponseCode::ThisMethodOfPaymentDoesNotSupportAuthorizationReversals
| WorldpayvantivResponseCode::ReversalAmountDoesNotMatchAuthorizationAmount
| WorldpayvantivResponseCode::TransactionDidNotConvertToPinless
| WorldpayvantivResponseCode::InvalidAmountSoftDecline
| WorldpayvantivResponseCode::InvalidHealthcareAmounts
| WorldpayvantivResponseCode::InvalidBillingDescriptorPrefix
| WorldpayvantivResponseCode::InvalidBillingDescriptor
| WorldpayvantivResponseCode::InvalidReportGroup
| WorldpayvantivResponseCode::DoNotHonor
| WorldpayvantivResponseCode::GenericDecline
| WorldpayvantivResponseCode::DeclineRequestPositiveId
| WorldpayvantivResponseCode::DeclineCvv2CidFail
| WorldpayvantivResponseCode::ThreeDSecureTransactionNotSupportedByMerchant
| WorldpayvantivResponseCode::InvalidPurchaseLevelIiiTheTransactionContainedBadOrMissingData
| WorldpayvantivResponseCode::MissingHealthcareIiasTagForAnFsaTransaction
| WorldpayvantivResponseCode::RestrictedByVantivDueToSecurityCodeMismatch
| WorldpayvantivResponseCode::NoTransactionFoundWithSpecifiedTransactionId
| WorldpayvantivResponseCode::AuthorizationNoLongerAvailable
| WorldpayvantivResponseCode::TransactionNotVoidedAlreadySettled
| WorldpayvantivResponseCode::AutoVoidOnRefund
| WorldpayvantivResponseCode::InvalidAccountNumberOriginalOrNocUpdatedECheckAccountRequired
| WorldpayvantivResponseCode::TotalCreditAmountExceedsCaptureAmount
| WorldpayvantivResponseCode::ExceedTheThresholdForSendingRedeposits
| WorldpayvantivResponseCode::DepositHasNotBeenReturnedForInsufficientNonSufficientFunds
| WorldpayvantivResponseCode::InvalidCheckNumber
| WorldpayvantivResponseCode::RedepositAgainstInvalidTransactionType
| WorldpayvantivResponseCode::InternalSystemErrorCallVantiv
| WorldpayvantivResponseCode::OriginalTransactionHasBeenProcessedFutureRedepositsCanceled
| WorldpayvantivResponseCode::SoftDeclineAutoRecyclingInProgress
| WorldpayvantivResponseCode::HardDeclineAutoRecyclingComplete
| WorldpayvantivResponseCode::RestrictedCardCardUnderSanction
| WorldpayvantivResponseCode::MerchantIsNotEnabledForSurcharging
| WorldpayvantivResponseCode::ThisMethodOfPaymentDoesNotSupportSurcharging
| WorldpayvantivResponseCode::SurchargeIsNotValidForDebitOrPrepaidCards
| WorldpayvantivResponseCode::SurchargeCannotExceedsTheMaximumAllowedLimit
| WorldpayvantivResponseCode::TransactionDeclinedByTheProcessingNetwork
| WorldpayvantivResponseCode::SecondaryAmountCannotExceedTheSaleAmount
| WorldpayvantivResponseCode::ThisMethodOfPaymentDoesNotSupportSecondaryAmount
| WorldpayvantivResponseCode::SecondaryAmountCannotBeLessThanZero
| WorldpayvantivResponseCode::PartialTransactionIsNotSupportedWhenIncludingASecondaryAmount
| WorldpayvantivResponseCode::SecondaryAmountRequiredOnPartialRefundWhenUsedOnDeposit
| WorldpayvantivResponseCode::SecondaryAmountNotAllowedOnRefundIfNotIncludedOnDeposit
| WorldpayvantivResponseCode::ProcessingNetworkError
| WorldpayvantivResponseCode::InvalidEMail
| WorldpayvantivResponseCode::InvalidCombinationOfAccountFundingTransactionTypeAndMcc
| WorldpayvantivResponseCode::InvalidAccountFundingTransactionTypeForThisMethodOfPayment
| WorldpayvantivResponseCode::MissingOneOrMoreReceiverFieldsForAccountFundingTransaction
| WorldpayvantivResponseCode::InvalidRecurringRequestSeeRecurringResponseForDetails
| WorldpayvantivResponseCode::ParentTransactionDeclinedRecurringSubscriptionNotCreated
| WorldpayvantivResponseCode::InvalidPlanCode
| WorldpayvantivResponseCode::InvalidSubscriptionId
| WorldpayvantivResponseCode::AddOnCodeAlreadyExists
| WorldpayvantivResponseCode::DuplicateAddOnCodesInRequests
| WorldpayvantivResponseCode::NoMatchingAddOnCodeForTheSubscription
| WorldpayvantivResponseCode::NoMatchingDiscountCodeForTheSubscription
| WorldpayvantivResponseCode::DuplicateDiscountCodesInRequest
| WorldpayvantivResponseCode::InvalidStartDate
| WorldpayvantivResponseCode::MerchantNotRegisteredForRecurringEngine
| WorldpayvantivResponseCode::InsufficientDataToUpdateSubscription
| WorldpayvantivResponseCode::InvalidBillingDate
| WorldpayvantivResponseCode::DiscountCodeAlreadyExists
| WorldpayvantivResponseCode::PlanCodeAlreadyExists
| WorldpayvantivResponseCode::TheAccountNumberWasChanged
| WorldpayvantivResponseCode::TheAccountWasClosed
| WorldpayvantivResponseCode::TheExpirationDateWasChanged
| WorldpayvantivResponseCode::TheIssuingBankDoesNotParticipateInTheUpdateProgram
| WorldpayvantivResponseCode::ContactTheCardholderForUpdatedInformation
| WorldpayvantivResponseCode::TheCardholderHasOptedOutOfTheUpdateProgram
| WorldpayvantivResponseCode::SoftDeclineCardReaderDecryptionServiceIsNotAvailable
| WorldpayvantivResponseCode::SoftDeclineDecryptionFailed
| WorldpayvantivResponseCode::HardDeclineInputDataIsInvalid
| WorldpayvantivResponseCode::ApplePayKeyMismatch
| WorldpayvantivResponseCode::ApplePayDecryptionFailed
| WorldpayvantivResponseCode::HardDeclineDecryptionFailed
| WorldpayvantivResponseCode::MerchantNotConfiguredForProcessingAtThisSite
| WorldpayvantivResponseCode::AdvancedFraudFilterScoreBelowThreshold
| WorldpayvantivResponseCode::SuspectedFraud
| WorldpayvantivResponseCode::SystemErrorContactWorldpayRepresentative
| WorldpayvantivResponseCode::AmazonPayAmazonUnavailable
| WorldpayvantivResponseCode::AmazonPayAmazonDeclined
| WorldpayvantivResponseCode::AmazonPayInvalidToken
| WorldpayvantivResponseCode::MerchantNotEnabledForAmazonPay
| WorldpayvantivResponseCode::TransactionNotSupportedBlockedByIssuer
| WorldpayvantivResponseCode::BlockedByCardholderContactCardholder
| WorldpayvantivResponseCode::SoftDeclinePrimaryFundingSourceFailed
| WorldpayvantivResponseCode::SoftDeclineBuyerHasAlternateFundingSource
| WorldpayvantivResponseCode::HardDeclineInvalidBillingAgreementId
| WorldpayvantivResponseCode::HardDeclinePrimaryFundingSourceFailed
| WorldpayvantivResponseCode::HardDeclineIssueWithPaypalAccount
| WorldpayvantivResponseCode::HardDeclinePayPalAuthorizationIdMissing
| WorldpayvantivResponseCode::HardDeclineConfirmedEmailAddressIsNotAvailable
| WorldpayvantivResponseCode::HardDeclinePayPalBuyerAccountDenied
| WorldpayvantivResponseCode::HardDeclinePayPalBuyerAccountRestricted
| WorldpayvantivResponseCode::HardDeclinePayPalOrderHasBeenVoidedExpiredOrCompleted
| WorldpayvantivResponseCode::HardDeclineIssueWithPayPalRefund
| WorldpayvantivResponseCode::HardDeclinePayPalCredentialsIssue
| WorldpayvantivResponseCode::HardDeclinePayPalAuthorizationVoidedOrExpired
| WorldpayvantivResponseCode::HardDeclineRequiredPayPalParameterMissing
| WorldpayvantivResponseCode::HardDeclinePayPalTransactionIdOrAuthIdIsInvalid
| WorldpayvantivResponseCode::HardDeclineExceededMaximumNumberOfPayPalAuthorizationAttempts
| WorldpayvantivResponseCode::HardDeclineTransactionAmountExceedsMerchantsPayPalAccountLimit
| WorldpayvantivResponseCode::HardDeclinePayPalFundingSourcesUnavailable
| WorldpayvantivResponseCode::HardDeclineIssueWithPayPalPrimaryFundingSource
| WorldpayvantivResponseCode::HardDeclinePayPalProfileDoesNotAllowThisTransactionType
| WorldpayvantivResponseCode::InternalSystemErrorWithPayPalContactVantiv
| WorldpayvantivResponseCode::HardDeclineContactPayPalConsumerForAnotherPaymentMethod
| WorldpayvantivResponseCode::InvalidTerminalId
| WorldpayvantivResponseCode::PinlessDebitProcessingNotSupportedForNonRecurringTransactions
| WorldpayvantivResponseCode::PinlessDebitProcessingNotSupportedForPartialAuths
| WorldpayvantivResponseCode::MerchantNotConfiguredForPinlessDebitProcessing
| WorldpayvantivResponseCode::DeclineCustomerCancellation
| WorldpayvantivResponseCode::DeclineReTryTransaction
| WorldpayvantivResponseCode::DeclineUnableToLocateRecordOnFile
| WorldpayvantivResponseCode::DeclineFileUpdateFieldEditError
| WorldpayvantivResponseCode::RemoteFunctionUnknown
| WorldpayvantivResponseCode::DeclinedExceedsWithdrawalFrequencyLimit
| WorldpayvantivResponseCode::DeclineCardRecordNotAvailable
| WorldpayvantivResponseCode::InvalidAuthorizationCode
| WorldpayvantivResponseCode::ReconciliationError
| WorldpayvantivResponseCode::PreferredDebitRoutingDenialCreditTransactionCanBeDebit
| WorldpayvantivResponseCode::DeclinedCurrencyConversionCompleteNoAuthPerformed
| WorldpayvantivResponseCode::DeclinedMultiCurrencyDccFail
| WorldpayvantivResponseCode::DeclinedMultiCurrencyInvertFail
| WorldpayvantivResponseCode::Invalid3DSecurePassword
| WorldpayvantivResponseCode::InvalidSocialSecurityNumber
| WorldpayvantivResponseCode::InvalidMothersMaidenName
| WorldpayvantivResponseCode::EnrollmentInquiryDeclined
| WorldpayvantivResponseCode::SocialSecurityNumberNotAvailable
| WorldpayvantivResponseCode::MothersMaidenNameNotAvailable
| WorldpayvantivResponseCode::PinAlreadyExistsOnDatabase
| WorldpayvantivResponseCode::Under18YearsOld
| WorldpayvantivResponseCode::BillToOutsideUsa
| WorldpayvantivResponseCode::BillToAddressIsNotEqualToShipToAddress
| WorldpayvantivResponseCode::DeclinedForeignCurrencyMustBeUsd
| WorldpayvantivResponseCode::OnNegativeFile
| WorldpayvantivResponseCode::BlockedAgreement
| WorldpayvantivResponseCode::InsufficientBuyingPower
| WorldpayvantivResponseCode::InvalidData
| WorldpayvantivResponseCode::InvalidDataDataElementsMissing
| WorldpayvantivResponseCode::InvalidDataDataFormatError
| WorldpayvantivResponseCode::InvalidDataInvalidTCVersion
| WorldpayvantivResponseCode::DuplicateTransactionPaypalCredit
| WorldpayvantivResponseCode::VerifyBillingAddress
| WorldpayvantivResponseCode::InactiveAccount
| WorldpayvantivResponseCode::InvalidAuth
| WorldpayvantivResponseCode::AuthorizationAlreadyExistsForTheOrder
| WorldpayvantivResponseCode::LodgingTransactionsAreNotAllowedForThisMcc
| WorldpayvantivResponseCode::DurationCannotBeNegative
| WorldpayvantivResponseCode::HotelFolioNumberCannotBeBlank
| WorldpayvantivResponseCode::InvalidCheckInDate
| WorldpayvantivResponseCode::InvalidCheckOutDate
| WorldpayvantivResponseCode::InvalidCheckInOrCheckOutDate
| WorldpayvantivResponseCode::CheckOutDateCannotBeBeforeCheckInDate
| WorldpayvantivResponseCode::NumberOfAdultsCannotBeNegative
| WorldpayvantivResponseCode::RoomRateCannotBeNegative
| WorldpayvantivResponseCode::RoomTaxCannotBeNegative
| WorldpayvantivResponseCode::DurationCanOnlyBeFrom0To99ForVisa
| WorldpayvantivResponseCode::MerchantIsNotAuthorizedForTokens
| WorldpayvantivResponseCode::CreditCardNumberWasInvalid
| WorldpayvantivResponseCode::TokenWasNotFound
| WorldpayvantivResponseCode::TokenInvalid
| WorldpayvantivResponseCode::MerchantNotAuthorizedForECheckTokens
| WorldpayvantivResponseCode::CheckoutIdWasInvalid
| WorldpayvantivResponseCode::CheckoutIdWasNotFound
| WorldpayvantivResponseCode::GenericCheckoutIdError
| WorldpayvantivResponseCode::CaptureAmountCanNotBeMoreThanAuthorizedAmount
| WorldpayvantivResponseCode::TaxBillingOnlyAllowedForMcc9311
| WorldpayvantivResponseCode::Mcc9311RequiresTaxTypeElement
| WorldpayvantivResponseCode::DebtRepaymentOnlyAllowedForViTransactionsOnMccs6012And6051
| WorldpayvantivResponseCode::RoutingNumberDidNotMatchOneOnFileForToken
| WorldpayvantivResponseCode::InvalidPayPageRegistrationId
| WorldpayvantivResponseCode::ExpiredPayPageRegistrationId
| WorldpayvantivResponseCode::MerchantIsNotAuthorizedForPayPage
| WorldpayvantivResponseCode::MaximumNumberOfUpdatesForThisTokenExceeded
| WorldpayvantivResponseCode::TooManyTokensCreatedForExistingNamespace
| WorldpayvantivResponseCode::PinValidationNotPossible
| WorldpayvantivResponseCode::GenericTokenRegistrationError
| WorldpayvantivResponseCode::GenericTokenUseError
| WorldpayvantivResponseCode::InvalidBankRoutingNumber
| WorldpayvantivResponseCode::MissingName
| WorldpayvantivResponseCode::InvalidName
| WorldpayvantivResponseCode::MissingBillingCountryCode
| WorldpayvantivResponseCode::InvalidIban
| WorldpayvantivResponseCode::MissingEmailAddress
| WorldpayvantivResponseCode::MissingMandateReference
| WorldpayvantivResponseCode::InvalidMandateReference
| WorldpayvantivResponseCode::MissingMandateUrl
| WorldpayvantivResponseCode::InvalidMandateUrl
| WorldpayvantivResponseCode::MissingMandateSignatureDate
| WorldpayvantivResponseCode::InvalidMandateSignatureDate
| WorldpayvantivResponseCode::RecurringMandateAlreadyExists
| WorldpayvantivResponseCode::RecurringMandateWasNotFound
| WorldpayvantivResponseCode::FinalRecurringWasAlreadyReceivedUsingThisMandate
| WorldpayvantivResponseCode::IbanDidNotMatchOneOnFileForMandate
| WorldpayvantivResponseCode::InvalidBillingCountry
| WorldpayvantivResponseCode::ExpirationDateRequiredForInteracTransaction
| WorldpayvantivResponseCode::TransactionTypeIsNotSupportedWithThisMethodOfPayment
| WorldpayvantivResponseCode::UnreferencedOrphanRefundsAreNotAllowed
| WorldpayvantivResponseCode::UnableToVoidATransactionWithAHeldState
| WorldpayvantivResponseCode::ThisFundingInstructionResultsInANegativeAccountBalance
| WorldpayvantivResponseCode::AccountBalanceInformationUnavailableAtThisTime
| WorldpayvantivResponseCode::TheSubmittedCardIsNotEligibleForFastAccessFunding
| WorldpayvantivResponseCode::TransactionCannotUseBothCcdPaymentInformationAndCtxPaymentInformation
| WorldpayvantivResponseCode::ProcessingError
| WorldpayvantivResponseCode::ThisFundingInstructionTypeIsInvalidForCanadianMerchants
| WorldpayvantivResponseCode::CtxAndCcdRecordsAreNotAllowedForCanadianMerchants
| WorldpayvantivResponseCode::CanadianAccountNumberCannotExceed12Digits
| WorldpayvantivResponseCode::ThisFundingInstructionTypeIsInvalid
| WorldpayvantivResponseCode::DeclineNegativeInformationOnFile
| WorldpayvantivResponseCode::AbsoluteDecline
| WorldpayvantivResponseCode::TheMerchantProfileDoesNotAllowTheRequestedOperation
| WorldpayvantivResponseCode::TheAccountCannotAcceptAchTransactions
| WorldpayvantivResponseCode::TheAccountCannotAcceptAchTransactionsOrSiteDrafts
| WorldpayvantivResponseCode::AmountGreaterThanLimitSpecifiedInTheMerchantProfile
| WorldpayvantivResponseCode::MerchantIsNotAuthorizedToPerformECheckVerificationTransactions
| WorldpayvantivResponseCode::FirstNameAndLastNameRequiredForECheckVerifications
| WorldpayvantivResponseCode::CompanyNameRequiredForCorporateAccountForECheckVerifications
| WorldpayvantivResponseCode::PhoneNumberRequiredForECheckVerifications
| WorldpayvantivResponseCode::CardBrandTokenNotSupported
| WorldpayvantivResponseCode::PrivateLabelCardNotSupported
| WorldpayvantivResponseCode::AllowedDailyDirectDebitCaptureECheckSaleLimitExceeded
| WorldpayvantivResponseCode::AllowedDailyDirectDebitCreditECheckCreditLimitExceeded
| WorldpayvantivResponseCode::AccountNotEligibleForRtp
| WorldpayvantivResponseCode::SoftDeclineCustomerAuthenticationRequired
| WorldpayvantivResponseCode::TransactionNotReversedVoidWorkflowNeedToBeInvoked
| WorldpayvantivResponseCode::TransactionReversalNotSupportedForTheCoreMerchants
| WorldpayvantivResponseCode::NoValidParentDepositOrParentRefundFound
| WorldpayvantivResponseCode::TransactionReversalNotEnabledForVisa
| WorldpayvantivResponseCode::TransactionReversalNotEnabledForMastercard
| WorldpayvantivResponseCode::TransactionReversalNotEnabledForAmEx
| WorldpayvantivResponseCode::TransactionReversalNotEnabledForDiscover
| WorldpayvantivResponseCode::TransactionReversalNotSupported
| WorldpayvantivResponseCode::FundingInstructionHeldPleaseContactYourRelationshipManager
| WorldpayvantivResponseCode::MissingAddressInformation
| WorldpayvantivResponseCode::CryptographicFailure
| WorldpayvantivResponseCode::InvalidRegionCode
| WorldpayvantivResponseCode::InvalidCountryCode
| WorldpayvantivResponseCode::InvalidCreditAccount
| WorldpayvantivResponseCode::InvalidCheckingAccount
| WorldpayvantivResponseCode::InvalidSavingsAccount
| WorldpayvantivResponseCode::InvalidUseOfMccCorrectAndReattempt
| WorldpayvantivResponseCode::ExceedsRtpTransactionLimit
=> match flow {
WorldpayvantivPaymentFlow::Sale => Ok(common_enums::AttemptStatus::Failure),
WorldpayvantivPaymentFlow::Auth => Ok(common_enums::AttemptStatus::AuthorizationFailed),
WorldpayvantivPaymentFlow::Capture => Ok(common_enums::AttemptStatus::CaptureFailed),
WorldpayvantivPaymentFlow::Void => Ok(common_enums::AttemptStatus::VoidFailed),
WorldpayvantivPaymentFlow::VoidPC => Ok(common_enums::AttemptStatus::VoidFailed)
}
}
}
fn get_refund_status(
response: WorldpayvantivResponseCode,
) -> Result<common_enums::RefundStatus, errors::ConnectorError> {
match response {
WorldpayvantivResponseCode::Approved
| WorldpayvantivResponseCode::PartiallyApproved
| WorldpayvantivResponseCode::OfflineApproval
| WorldpayvantivResponseCode::OfflineApprovalUnableToGoOnline => {
Ok(common_enums::RefundStatus::Pending)
},
WorldpayvantivResponseCode::TransactionReceived => Ok(common_enums::RefundStatus::Pending),
WorldpayvantivResponseCode::ProcessingNetworkUnavailable
| WorldpayvantivResponseCode::IssuerUnavailable
| WorldpayvantivResponseCode::ReSubmitTransaction
| WorldpayvantivResponseCode::MerchantNotConfiguredForProcessingAtThisSite
| WorldpayvantivResponseCode::TryAgainLater
| WorldpayvantivResponseCode::InsufficientFunds
| WorldpayvantivResponseCode::AuthorizationAmountHasAlreadyBeenDepleted
| WorldpayvantivResponseCode::InsufficientFundsRetryAfter1Hour
| WorldpayvantivResponseCode::InsufficientFundsRetryAfter24Hour
| WorldpayvantivResponseCode::InsufficientFundsRetryAfter2Days
| WorldpayvantivResponseCode::InsufficientFundsRetryAfter4Days
| WorldpayvantivResponseCode::InsufficientFundsRetryAfter6Days
| WorldpayvantivResponseCode::InsufficientFundsRetryAfter8Days
| WorldpayvantivResponseCode::InsufficientFundsRetryAfter10Days
| WorldpayvantivResponseCode::CallIssuer
| WorldpayvantivResponseCode::CallAmex
| WorldpayvantivResponseCode::CallDinersClub
| WorldpayvantivResponseCode::CallDiscover
| WorldpayvantivResponseCode::CallJbs
| WorldpayvantivResponseCode::CallVisaMastercard
| WorldpayvantivResponseCode::ExceedsApprovalAmountLimit
| WorldpayvantivResponseCode::CallIndicatedNumber
| WorldpayvantivResponseCode::ConsumerMultiUseVirtualCardNumberSoftDecline
| WorldpayvantivResponseCode::ConsumerNonReloadablePrepaidCardSoftDecline
| WorldpayvantivResponseCode::ConsumerSingleUseVirtualCardNumberSoftDecline
| WorldpayvantivResponseCode::MerchantDoesntQualifyForProductCode
| WorldpayvantivResponseCode::Lifecycle
| WorldpayvantivResponseCode::Policy
| WorldpayvantivResponseCode::InvalidOrExpiredCardContactCardholderToUpdate
| WorldpayvantivResponseCode::InvalidTransactionOrCardRestrictionVerifyInformationAndResubmit
| WorldpayvantivResponseCode::AtLeastOneOfOrigIdOrOrigCnpTxnIdIsRequired
| WorldpayvantivResponseCode::OrigCnpTxnIdIsRequiredWhenShowStatusOnlyIsUsed
| WorldpayvantivResponseCode::TransactionMustReferenceTheEstimatedAuth
| WorldpayvantivResponseCode::IncrementedAuthExceedsMaxTransactionAmount
| WorldpayvantivResponseCode::SubmittedMccNotAllowed
| WorldpayvantivResponseCode::MerchantNotCertifiedEnabledForIias
| WorldpayvantivResponseCode::IssuerGeneratedError
| WorldpayvantivResponseCode::InvalidAmountHardDecline
| WorldpayvantivResponseCode::ReversalUnsuccessful
| WorldpayvantivResponseCode::MissingData
| WorldpayvantivResponseCode::InvalidDeactivate
| WorldpayvantivResponseCode::OverMaxBalance
| WorldpayvantivResponseCode::InvalidActivate
| WorldpayvantivResponseCode::NoTransactionFoundForReversal
| WorldpayvantivResponseCode::IllegalTransaction
| WorldpayvantivResponseCode::DuplicateTransaction
| WorldpayvantivResponseCode::SystemError
| WorldpayvantivResponseCode::MerchantDepleted
| WorldpayvantivResponseCode::InvalidReversalTypeForCreditCardTransaction
| WorldpayvantivResponseCode::SystemErrorMessageFormatError
| WorldpayvantivResponseCode::SystemErrorCannotProcess
| WorldpayvantivResponseCode::RefundRejectedDueToPendingDepositStatus
| WorldpayvantivResponseCode::RefundRejectedDueToDeclinedDepositStatus
| WorldpayvantivResponseCode::RefundRejectedByTheProcessingNetwork
| WorldpayvantivResponseCode::CaptureCreditAndAuthReversalTagsCannotBeUsedForGiftCardTransactions
| WorldpayvantivResponseCode::InvalidAccountNumber
| WorldpayvantivResponseCode::AuthorizationHasExpiredNoNeedToReverse
| WorldpayvantivResponseCode::InvalidTrackData
| WorldpayvantivResponseCode::DepositIsAlreadyReferencedByAChargeback
| WorldpayvantivResponseCode::AutomaticRefundAlreadyIssued
| WorldpayvantivResponseCode::InvalidMerchant
| WorldpayvantivResponseCode::InvalidTransaction
| WorldpayvantivResponseCode::TransactionNotAllowedAtTerminal
| WorldpayvantivResponseCode::ThisMethodOfPaymentDoesNotSupportAuthorizationReversals
| WorldpayvantivResponseCode::ReversalAmountDoesNotMatchAuthorizationAmount
| WorldpayvantivResponseCode::InvalidAmountSoftDecline
| WorldpayvantivResponseCode::InvalidReportGroup
| WorldpayvantivResponseCode::DoNotHonor
| WorldpayvantivResponseCode::GenericDecline
| WorldpayvantivResponseCode::DeclineRequestPositiveId
| WorldpayvantivResponseCode::ThreeDSecureTransactionNotSupportedByMerchant
| WorldpayvantivResponseCode::RestrictedByVantivDueToSecurityCodeMismatch
| WorldpayvantivResponseCode::NoTransactionFoundWithSpecifiedTransactionId
| WorldpayvantivResponseCode::AuthorizationNoLongerAvailable
| WorldpayvantivResponseCode::TransactionNotVoidedAlreadySettled
| WorldpayvantivResponseCode::AutoVoidOnRefund
| WorldpayvantivResponseCode::InvalidAccountNumberOriginalOrNocUpdatedECheckAccountRequired
| WorldpayvantivResponseCode::TotalCreditAmountExceedsCaptureAmount
| WorldpayvantivResponseCode::ExceedTheThresholdForSendingRedeposits
| WorldpayvantivResponseCode::DepositHasNotBeenReturnedForInsufficientNonSufficientFunds
| WorldpayvantivResponseCode::RedepositAgainstInvalidTransactionType
| WorldpayvantivResponseCode::InternalSystemErrorCallVantiv
| WorldpayvantivResponseCode::OriginalTransactionHasBeenProcessedFutureRedepositsCanceled
| WorldpayvantivResponseCode::SoftDeclineAutoRecyclingInProgress
| WorldpayvantivResponseCode::HardDeclineAutoRecyclingComplete
| WorldpayvantivResponseCode::TransactionDeclinedByTheProcessingNetwork
| WorldpayvantivResponseCode::SecondaryAmountCannotExceedTheSaleAmount
| WorldpayvantivResponseCode::ThisMethodOfPaymentDoesNotSupportSecondaryAmount
| WorldpayvantivResponseCode::SecondaryAmountCannotBeLessThanZero
| WorldpayvantivResponseCode::PartialTransactionIsNotSupportedWhenIncludingASecondaryAmount
| WorldpayvantivResponseCode::SecondaryAmountRequiredOnPartialRefundWhenUsedOnDeposit
| WorldpayvantivResponseCode::SecondaryAmountNotAllowedOnRefundIfNotIncludedOnDeposit
| WorldpayvantivResponseCode::ProcessingNetworkError
| WorldpayvantivResponseCode::InvalidEMail
| WorldpayvantivResponseCode::InvalidCombinationOfAccountFundingTransactionTypeAndMcc
| WorldpayvantivResponseCode::InvalidAccountFundingTransactionTypeForThisMethodOfPayment
| WorldpayvantivResponseCode::MissingOneOrMoreReceiverFieldsForAccountFundingTransaction
| WorldpayvantivResponseCode::SoftDeclineDecryptionFailed
| WorldpayvantivResponseCode::HardDeclineInputDataIsInvalid
| WorldpayvantivResponseCode::HardDeclineDecryptionFailed
| WorldpayvantivResponseCode::SuspectedFraud
| WorldpayvantivResponseCode::SystemErrorContactWorldpayRepresentative
| WorldpayvantivResponseCode::InvalidTerminalId
| WorldpayvantivResponseCode::DeclineReTryTransaction
| WorldpayvantivResponseCode::RemoteFunctionUnknown
| WorldpayvantivResponseCode::InvalidData
| WorldpayvantivResponseCode::InvalidDataDataElementsMissing
| WorldpayvantivResponseCode::InvalidDataDataFormatError
| WorldpayvantivResponseCode::VerifyBillingAddress
| WorldpayvantivResponseCode::InactiveAccount
| WorldpayvantivResponseCode::InvalidAuth
| WorldpayvantivResponseCode::CheckoutIdWasInvalid
| WorldpayvantivResponseCode::CheckoutIdWasNotFound
| WorldpayvantivResponseCode::TransactionTypeIsNotSupportedWithThisMethodOfPayment
| WorldpayvantivResponseCode::UnreferencedOrphanRefundsAreNotAllowed
| WorldpayvantivResponseCode::ThisFundingInstructionResultsInANegativeAccountBalance
| WorldpayvantivResponseCode::ProcessingError
| WorldpayvantivResponseCode::ThisFundingInstructionTypeIsInvalidForCanadianMerchants
| WorldpayvantivResponseCode::ThisFundingInstructionTypeIsInvalid
| WorldpayvantivResponseCode::AbsoluteDecline
| WorldpayvantivResponseCode::TheMerchantProfileDoesNotAllowTheRequestedOperation
| WorldpayvantivResponseCode::AmountGreaterThanLimitSpecifiedInTheMerchantProfile
| WorldpayvantivResponseCode::AccountNotEligibleForRtp
| WorldpayvantivResponseCode::NoValidParentDepositOrParentRefundFound
| WorldpayvantivResponseCode::FundingInstructionHeldPleaseContactYourRelationshipManager
| WorldpayvantivResponseCode::InvalidCreditAccount => Ok(common_enums::RefundStatus::Failure),
_ => {
Err(errors::ConnectorError::UnexpectedResponseError(
bytes::Bytes::from("Invalid response code for refund".to_string()),
))
}
}
}
fn get_vantiv_card_data(
payment_method_data: &PaymentMethodData,
payment_method_token: Option<hyperswitch_domain_models::router_data::PaymentMethodToken>,
) -> Result<
(
Option<WorldpayvantivCardData>,
Option<CardholderAuthentication>,
),
error_stack::Report<errors::ConnectorError>,
> {
match payment_method_data {
PaymentMethodData::Card(card) => {
let card_type = match card.card_network.clone() {
Some(card_type) => WorldpayvativCardType::try_from(card_type)?,
None => WorldpayvativCardType::try_from(&card.get_card_issuer()?)?,
};
let exp_date = card.get_expiry_date_as_mmyy()?;
Ok((
Some(WorldpayvantivCardData {
card_type,
number: card.card_number.clone(),
exp_date,
card_validation_num: Some(card.card_cvc.clone()),
}),
None,
))
}
PaymentMethodData::CardDetailsForNetworkTransactionId(card_data) => {
let card_type = match card_data.card_network.clone() {
Some(card_type) => WorldpayvativCardType::try_from(card_type)?,
None => WorldpayvativCardType::try_from(&card_data.get_card_issuer()?)?,
};
let exp_date = card_data.get_expiry_date_as_mmyy()?;
Ok((
Some(WorldpayvantivCardData {
card_type,
number: card_data.card_number.clone(),
exp_date,
card_validation_num: None,
}),
None,
))
}
PaymentMethodData::MandatePayment => Ok((None, None)),
PaymentMethodData::Wallet(wallet_data) => match wallet_data {
hyperswitch_domain_models::payment_method_data::WalletData::ApplePay(
apple_pay_data,
) => match payment_method_token.clone() {
Some(
hyperswitch_domain_models::router_data::PaymentMethodToken::ApplePayDecrypt(
apple_pay_decrypted_data,
),
) => {
let number = apple_pay_decrypted_data
.application_primary_account_number
.clone();
let exp_date = apple_pay_decrypted_data
.get_expiry_date_as_mmyy()
.change_context(errors::ConnectorError::InvalidDataFormat {
field_name: "payment_method_data.card.card_exp_month",
})?;
let cardholder_authentication = CardholderAuthentication {
authentication_value: apple_pay_decrypted_data
.payment_data
.online_payment_cryptogram
.clone(),
};
let apple_pay_network = apple_pay_data
.payment_method
.network
.parse::<WorldPayVativApplePayNetwork>()
.map_err(|_| {
error_stack::Report::new(errors::ConnectorError::NotSupported {
message: format!(
"Invalid Apple Pay network '{}'. Supported networks: Visa,MasterCard,AmEx,Discover,DinersClub,JCB,UnionPay",
apple_pay_data.payment_method.network
),
connector: "worldpay_vativ"
})
})?;
Ok((
(Some(WorldpayvantivCardData {
card_type: apple_pay_network.into(),
number,
exp_date,
card_validation_num: None,
})),
Some(cardholder_authentication),
))
}
_ => Err(
errors::ConnectorError::NotImplemented("Payment method type".to_string())
.into(),
),
},
hyperswitch_domain_models::payment_method_data::WalletData::GooglePay(
google_pay_data,
) => match payment_method_token.clone() {
Some(
hyperswitch_domain_models::router_data::PaymentMethodToken::GooglePayDecrypt(
google_pay_decrypted_data,
),
) => {
let number = google_pay_decrypted_data
.application_primary_account_number
.clone();
let exp_date = google_pay_decrypted_data
.get_expiry_date_as_mmyy()
.change_context(errors::ConnectorError::InvalidDataFormat {
field_name: "payment_method_data.card.card_exp_month",
})?;
let cardholder_authentication = CardholderAuthentication {
authentication_value: google_pay_decrypted_data
.cryptogram
.clone()
.ok_or_else(|| errors::ConnectorError::MissingRequiredField {
field_name: "cryptogram",
})?,
};
let google_pay_network = google_pay_data
.info
.card_network
.parse::<WorldPayVativGooglePayNetwork>()
.map_err(|_| {
error_stack::Report::new(errors::ConnectorError::NotSupported {
message: format!(
"Invalid Google Pay card network '{}'. Supported networks: VISA, MASTERCARD, AMEX, DISCOVER, JCB, UNIONPAY",
google_pay_data.info.card_network
),
connector: "worldpay_vativ"
})
})?;
Ok((
(Some(WorldpayvantivCardData {
card_type: google_pay_network.into(),
number,
exp_date,
card_validation_num: None,
})),
Some(cardholder_authentication),
))
}
_ => {
Err(errors::ConnectorError::NotImplemented("Payment method".to_string()).into())
}
},
_ => Err(errors::ConnectorError::NotImplemented("Payment method".to_string()).into()),
},
_ => Err(errors::ConnectorError::NotImplemented("Payment method".to_string()).into()),
}
}
fn get_connector_response(payment_response: &FraudResult) -> ConnectorResponseData {
let payment_checks = Some(serde_json::json!({
"avs_result": payment_response.avs_result,
"card_validation_result": payment_response.card_validation_result,
"authentication_result": payment_response.authentication_result,
"advanced_a_v_s_result": payment_response.advanced_a_v_s_result,
}));
ConnectorResponseData::with_additional_payment_method_data(
AdditionalPaymentMethodConnectorResponse::Card {
authentication_data: None,
payment_checks,
card_network: None,
domestic_network: None,
},
)
}
#[derive(Debug, Deserialize, Serialize)]
#[serde(rename = "chargebackRetrievalResponse", rename_all = "camelCase")]
pub struct ChargebackRetrievalResponse {
#[serde(rename = "@xmlns")]
pub xmlns: String,
pub transaction_id: String,
pub chargeback_case: Option<Vec<ChargebackCase>>,
}
#[derive(Debug, Deserialize, Serialize, Clone)]
#[serde(rename_all = "camelCase")]
pub struct ChargebackCase {
pub case_id: String,
pub merchant_id: String,
pub day_issued_by_bank: Option<String>,
pub date_received_by_vantiv_cnp: Option<String>,
pub vantiv_cnp_txn_id: String,
pub cycle: String,
pub order_id: String,
pub card_number_last4: Option<String>,
pub card_type: Option<String>,
pub chargeback_amount: MinorUnit,
pub chargeback_currency_type: common_enums::enums::Currency,
pub original_txn_day: Option<String>,
pub chargeback_type: Option<String>,
pub reason_code: Option<String>,
pub reason_code_description: Option<String>,
pub current_queue: Option<String>,
pub acquirer_reference_number: Option<String>,
pub chargeback_reference_number: Option<String>,
pub bin: Option<String>,
pub payment_amount: Option<MinorUnit>,
pub reply_by_day: Option<String>,
pub pre_arbitration_amount: Option<MinorUnit>,
pub pre_arbitration_currency_type: Option<common_enums::enums::Currency>,
pub activity: Vec<Activity>,
}
#[derive(Debug, Deserialize, Serialize, Clone)]
#[serde(rename_all = "camelCase")]
pub struct Activity {
pub activity_date: Option<String>,
pub activity_type: Option<String>,
pub from_queue: Option<String>,
pub to_queue: Option<String>,
pub notes: Option<String>,
}
impl
TryFrom<
ResponseRouterData<
Fetch,
ChargebackRetrievalResponse,
FetchDisputesRequestData,
FetchDisputesResponse,
>,
> for RouterData<Fetch, FetchDisputesRequestData, FetchDisputesResponse>
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: ResponseRouterData<
Fetch,
ChargebackRetrievalResponse,
FetchDisputesRequestData,
FetchDisputesResponse,
>,
) -> Result<Self, Self::Error> {
let dispute_list = item
.response
.chargeback_case
.unwrap_or_default()
.into_iter()
.map(DisputeSyncResponse::try_from)
.collect::<Result<Vec<_>, _>>()?;
Ok(FetchDisputeRouterData {
response: Ok(dispute_list),
..item.data
})
}
}
impl
TryFrom<
ResponseRouterData<
Dsync,
ChargebackRetrievalResponse,
DisputeSyncData,
DisputeSyncResponse,
>,
> for RouterData<Dsync, DisputeSyncData, DisputeSyncResponse>
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: ResponseRouterData<
Dsync,
ChargebackRetrievalResponse,
DisputeSyncData,
DisputeSyncResponse,
>,
) -> Result<Self, Self::Error> {
let dispute_response = item
.response
.chargeback_case
.and_then(|chargeback_case| chargeback_case.first().cloned())
.ok_or(errors::ConnectorError::RequestEncodingFailedWithReason(
"Could not find chargeback case".to_string(),
))?;
let dispute_sync_response = DisputeSyncResponse::try_from(dispute_response.clone())?;
Ok(DisputeSyncRouterData {
response: Ok(dispute_sync_response),
..item.data
})
}
}
fn get_dispute_stage(
dispute_cycle: String,
) -> Result<common_enums::enums::DisputeStage, error_stack::Report<errors::ConnectorError>> {
match connector_utils::normalize_string(dispute_cycle.clone())
.change_context(errors::ConnectorError::RequestEncodingFailed)?
.as_str()
{
"arbitration"
| "arbitrationmastercard"
| "arbitrationchargeback"
| "arbitrationlost"
| "arbitrationsplit"
| "arbitrationwon" => Ok(common_enums::enums::DisputeStage::Arbitration),
"chargebackreversal" | "firstchargeback" | "rapiddisputeresolution" | "representment" => {
Ok(common_enums::enums::DisputeStage::Dispute)
}
"issueracceptedprearbitration"
| "issuerarbitration"
| "issuerdeclinedprearbitration"
| "prearbitration"
| "responsetoissuerarbitration" => Ok(common_enums::enums::DisputeStage::PreArbitration),
"retrievalrequest" => Ok(common_enums::enums::DisputeStage::PreDispute),
_ => Err(errors::ConnectorError::NotSupported {
message: format!("Dispute stage {dispute_cycle}",),
connector: "worldpayvantiv",
}
.into()),
}
}
pub fn get_dispute_status(
dispute_cycle: String,
dispute_activities: Vec<Activity>,
) -> Result<common_enums::DisputeStatus, error_stack::Report<errors::ConnectorError>> {
if let Some(activity) = get_last_non_auxiliary_activity_type(dispute_activities) {
match activity.as_ref() {
"Merchant Accept"
| "Issuer Accepted Pre-Arbitration"
| "Vantiv Accept"
| "Sent Credit" => Ok(common_enums::DisputeStatus::DisputeAccepted),
"Merchant Represent"
| "Respond to Dispute"
| "Respond to PreArb"
| "Request Arbitration"
| "Request Pre-Arbitration"
| "Create Arbitration"
| "Record Arbitration"
| "Create Pre-Arbitration"
| "File Arbitration"
| "File Pre-Arbitration"
| "File Visa Pre-Arbitration"
| "Send Representment"
| "Send Response"
| "Arbitration"
| "Arbitration (Mastercard)"
| "Arbitration Chargeback"
| "Issuer Declined Pre-Arbitration"
| "Issuer Arbitration"
| "Request Response to Pre-Arbitration"
| "Vantiv Represent"
| "Vantiv Respond"
| "Auto Represent"
| "Arbitration Ruling" => Ok(common_enums::DisputeStatus::DisputeChallenged),
"Arbitration Lost" | "Unsuccessful Arbitration" | "Unsuccessful Pre-Arbitration" => {
Ok(common_enums::DisputeStatus::DisputeLost)
}
"Arbitration Won"
| "Arbitration Split"
| "Successful Arbitration"
| "Successful Pre-Arbitration" => Ok(common_enums::DisputeStatus::DisputeWon),
"Chargeback Reversal" => Ok(common_enums::DisputeStatus::DisputeCancelled),
"Receive Network Transaction" => Ok(common_enums::DisputeStatus::DisputeOpened),
"Unaccept" | "Unrepresent" => Ok(common_enums::DisputeStatus::DisputeOpened),
unexpected_activity => Err(errors::ConnectorError::UnexpectedResponseError(
bytes::Bytes::from(format!("Dispute Activity: {unexpected_activity})")),
)
.into()),
}
} else {
match connector_utils::normalize_string(dispute_cycle.clone())
.change_context(errors::ConnectorError::RequestEncodingFailed)?
.as_str()
{
"arbitration"
| "arbitrationmastercard"
| "arbitrationsplit"
| "representment"
| "issuerarbitration"
| "prearbitration"
| "responsetoissuerarbitration"
| "arbitrationchargeback" => Ok(api_models::enums::DisputeStatus::DisputeChallenged),
"chargebackreversal" | "issueracceptedprearbitration" | "arbitrationwon" => {
Ok(api_models::enums::DisputeStatus::DisputeWon)
}
"arbitrationlost" | "issuerdeclinedprearbitration" => {
Ok(api_models::enums::DisputeStatus::DisputeLost)
}
"firstchargeback" | "retrievalrequest" | "rapiddisputeresolution" => {
Ok(api_models::enums::DisputeStatus::DisputeOpened)
}
dispute_cycle => Err(errors::ConnectorError::UnexpectedResponseError(
bytes::Bytes::from(format!("Dispute Stage: {dispute_cycle}")),
)
.into()),
}
}
}
fn convert_string_to_primitive_date(
item: Option<String>,
) -> Result<Option<time::PrimitiveDateTime>, error_stack::Report<errors::ConnectorError>> {
item.map(|day| {
let full_datetime_str = format!("{day}T00:00:00");
let format =
time::macros::format_description!("[year]-[month]-[day]T[hour]:[minute]:[second]");
time::PrimitiveDateTime::parse(&full_datetime_str, &format)
})
.transpose()
.change_context(errors::ConnectorError::ParsingFailed)
}
impl TryFrom<ChargebackCase> for DisputeSyncResponse {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(item: ChargebackCase) -> Result<Self, Self::Error> {
let amount = connector_utils::convert_amount(
&StringMinorUnitForConnector,
item.chargeback_amount,
item.chargeback_currency_type,
)?;
Ok(Self {
object_reference_id: api_models::webhooks::ObjectReferenceId::PaymentId(
api_models::payments::PaymentIdType::ConnectorTransactionId(item.vantiv_cnp_txn_id),
),
amount,
currency: item.chargeback_currency_type,
dispute_stage: get_dispute_stage(item.cycle.clone())?,
dispute_status: get_dispute_status(item.cycle.clone(), item.activity)?,
connector_status: item.cycle.clone(),
connector_dispute_id: item.case_id.clone(),
connector_reason: item.reason_code_description.clone(),
connector_reason_code: item.reason_code.clone(),
challenge_required_by: convert_string_to_primitive_date(item.reply_by_day.clone())?,
created_at: convert_string_to_primitive_date(item.date_received_by_vantiv_cnp.clone())?,
updated_at: None,
})
}
}
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
pub enum ActivityType {
MerchantAcceptsLiability,
MerchantRepresent,
}
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename = "chargebackUpdateRequest", rename_all = "camelCase")]
pub struct ChargebackUpdateRequest {
#[serde(rename = "@xmlns")]
xmlns: String,
activity_type: ActivityType,
}
impl From<&SubmitEvidenceRouterData> for ChargebackUpdateRequest {
fn from(_item: &SubmitEvidenceRouterData) -> Self {
Self {
xmlns: worldpayvantiv_constants::XML_CHARGEBACK.to_string(),
activity_type: ActivityType::MerchantRepresent,
}
}
}
impl From<&AcceptDisputeRouterData> for ChargebackUpdateRequest {
fn from(_item: &AcceptDisputeRouterData) -> Self {
Self {
xmlns: worldpayvantiv_constants::XML_CHARGEBACK.to_string(),
activity_type: ActivityType::MerchantAcceptsLiability,
}
}
}
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename = "chargebackDocumentUploadResponse", rename_all = "camelCase")]
pub struct ChargebackDocumentUploadResponse {
#[serde(rename = "@xmlns")]
pub xmlns: String,
pub merchant_id: String,
pub case_id: String,
pub document_id: Option<String>,
pub response_code: WorldpayvantivFileUploadResponseCode,
pub response_message: String,
}
#[derive(Debug, strum::Display, Serialize, Deserialize, PartialEq, Clone, Copy)]
pub enum WorldpayvantivFileUploadResponseCode {
#[serde(rename = "000")]
#[strum(serialize = "000")]
Success,
#[serde(rename = "001")]
#[strum(serialize = "001")]
InvalidMerchant,
#[serde(rename = "002")]
#[strum(serialize = "002")]
FutureUse002,
#[serde(rename = "003")]
#[strum(serialize = "003")]
CaseNotFound,
#[serde(rename = "004")]
#[strum(serialize = "004")]
CaseNotInMerchantQueue,
#[serde(rename = "005")]
#[strum(serialize = "005")]
DocumentAlreadyExists,
#[serde(rename = "006")]
#[strum(serialize = "006")]
InternalError,
#[serde(rename = "007")]
#[strum(serialize = "007")]
FutureUse007,
#[serde(rename = "008")]
#[strum(serialize = "008")]
MaxDocumentLimitReached,
#[serde(rename = "009")]
#[strum(serialize = "009")]
DocumentNotFound,
#[serde(rename = "010")]
#[strum(serialize = "010")]
CaseNotInValidCycle,
#[serde(rename = "011")]
#[strum(serialize = "011")]
ServerBusy,
#[serde(rename = "012")]
#[strum(serialize = "012")]
FileSizeExceedsLimit,
#[serde(rename = "013")]
#[strum(serialize = "013")]
InvalidFileContent,
#[serde(rename = "014")]
#[strum(serialize = "014")]
UnableToConvert,
#[serde(rename = "015")]
#[strum(serialize = "015")]
InvalidImageSize,
#[serde(rename = "016")]
#[strum(serialize = "016")]
MaxDocumentPageCountReached,
}
fn is_file_uploaded(vantiv_file_upload_status: WorldpayvantivFileUploadResponseCode) -> bool {
match vantiv_file_upload_status {
WorldpayvantivFileUploadResponseCode::Success
| WorldpayvantivFileUploadResponseCode::FutureUse002
| WorldpayvantivFileUploadResponseCode::FutureUse007 => true,
WorldpayvantivFileUploadResponseCode::InvalidMerchant
| WorldpayvantivFileUploadResponseCode::CaseNotFound
| WorldpayvantivFileUploadResponseCode::CaseNotInMerchantQueue
| WorldpayvantivFileUploadResponseCode::DocumentAlreadyExists
| WorldpayvantivFileUploadResponseCode::InternalError
| WorldpayvantivFileUploadResponseCode::MaxDocumentLimitReached
| WorldpayvantivFileUploadResponseCode::DocumentNotFound
| WorldpayvantivFileUploadResponseCode::CaseNotInValidCycle
| WorldpayvantivFileUploadResponseCode::ServerBusy
| WorldpayvantivFileUploadResponseCode::FileSizeExceedsLimit
| WorldpayvantivFileUploadResponseCode::InvalidFileContent
| WorldpayvantivFileUploadResponseCode::UnableToConvert
| WorldpayvantivFileUploadResponseCode::InvalidImageSize
| WorldpayvantivFileUploadResponseCode::MaxDocumentPageCountReached => false,
}
}
impl
TryFrom<
ResponseRouterData<
Upload,
ChargebackDocumentUploadResponse,
UploadFileRequestData,
UploadFileResponse,
>,
> for RouterData<Upload, UploadFileRequestData, UploadFileResponse>
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: ResponseRouterData<
Upload,
ChargebackDocumentUploadResponse,
UploadFileRequestData,
UploadFileResponse,
>,
) -> Result<Self, Self::Error> {
let response = if is_file_uploaded(item.response.response_code) {
let provider_file_id = item
.response
.document_id
.ok_or(errors::ConnectorError::MissingConnectorTransactionID)?;
Ok(UploadFileResponse { provider_file_id })
} else {
Err(ErrorResponse {
code: item.response.response_code.to_string(),
message: item.response.response_message.clone(),
reason: Some(item.response.response_message.clone()),
status_code: item.http_code,
attempt_status: None,
connector_transaction_id: None,
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
connector_metadata: None,
})
};
Ok(Self {
response,
..item.data
})
}
}
impl
TryFrom<
ResponseRouterData<
Retrieve,
ChargebackDocumentUploadResponse,
RetrieveFileRequestData,
RetrieveFileResponse,
>,
> for RouterData<Retrieve, RetrieveFileRequestData, RetrieveFileResponse>
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: ResponseRouterData<
Retrieve,
ChargebackDocumentUploadResponse,
RetrieveFileRequestData,
RetrieveFileResponse,
>,
) -> Result<Self, Self::Error> {
Ok(RetrieveFileRouterData {
response: Err(ErrorResponse {
code: item.response.response_code.to_string(),
message: item.response.response_message.clone(),
reason: Some(item.response.response_message.clone()),
status_code: item.http_code,
attempt_status: None,
connector_transaction_id: None,
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
connector_metadata: None,
}),
..item.data.clone()
})
}
}
fn get_last_non_auxiliary_activity_type(activities: Vec<Activity>) -> Option<String> {
let auxiliary_activities: std::collections::HashSet<&'static str> = [
"Add Note",
"Attach Document",
"Attempted Attach Document",
"Delete Document",
"Update Document",
"Move To Error Queue",
"Assign to Vantiv",
"Assign To Merchant",
"Merchant Auto Assign",
"Issuer Recalled",
"Network Decision",
"Request Declined",
"Sent Gift",
"Successful PayPal",
]
.iter()
.copied()
.collect();
let mut last_non_auxiliary_activity = None;
for activity in activities {
let auxiliary_activity = activity
.activity_type
.as_deref()
.map(|activity_type| auxiliary_activities.contains(activity_type))
.unwrap_or(false);
if !auxiliary_activity {
last_non_auxiliary_activity = activity.activity_type.clone()
}
}
last_non_auxiliary_activity
}
|
{
"crate": "hyperswitch_connectors",
"file": "crates/hyperswitch_connectors/src/connectors/worldpayvantiv/transformers.rs",
"file_size": null,
"is_async": null,
"is_pub": null,
"num_enums": 11,
"num_structs": 41,
"num_tables": null,
"score": null,
"total_crates": null
}
|
file_hyperswitch_connectors_8387514333068475853
|
clm
|
file
|
// Repository: hyperswitch
// Crate: hyperswitch_connectors
// File: crates/hyperswitch_connectors/src/connectors/opayo/transformers.rs
// Contains: 7 structs, 2 enums
use common_enums::enums;
use common_utils::types::MinorUnit;
use hyperswitch_domain_models::{
payment_method_data::PaymentMethodData,
router_data::{ConnectorAuthType, RouterData},
router_flow_types::{Execute, RSync},
router_request_types::ResponseId,
router_response_types::{PaymentsResponseData, RefundsResponseData},
types::{PaymentsAuthorizeRouterData, RefundsRouterData},
};
use hyperswitch_interfaces::errors;
use masking::Secret;
use serde::{Deserialize, Serialize};
use crate::{
types::{RefundsResponseRouterData, ResponseRouterData},
utils::{PaymentsAuthorizeRequestData, RouterData as OtherRouterData},
};
#[derive(Debug, Serialize)]
pub struct OpayoRouterData<T> {
pub amount: MinorUnit,
pub router_data: T,
}
impl<T> From<(MinorUnit, T)> for OpayoRouterData<T> {
fn from((amount, router_data): (MinorUnit, T)) -> Self {
Self {
amount,
router_data,
}
}
}
#[derive(Default, Debug, Serialize, Eq, PartialEq)]
pub struct OpayoPaymentsRequest {
amount: MinorUnit,
card: OpayoCard,
}
#[derive(Default, Debug, Serialize, Eq, PartialEq)]
pub struct OpayoCard {
name: Secret<String>,
number: cards::CardNumber,
expiry_month: Secret<String>,
expiry_year: Secret<String>,
cvc: Secret<String>,
complete: bool,
}
impl TryFrom<&OpayoRouterData<&PaymentsAuthorizeRouterData>> for OpayoPaymentsRequest {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item_data: &OpayoRouterData<&PaymentsAuthorizeRouterData>,
) -> Result<Self, Self::Error> {
let item = item_data.router_data.clone();
match item.request.payment_method_data.clone() {
PaymentMethodData::Card(req_card) => {
let card = OpayoCard {
name: item
.get_optional_billing_full_name()
.unwrap_or(Secret::new("".to_string())),
number: req_card.card_number,
expiry_month: req_card.card_exp_month,
expiry_year: req_card.card_exp_year,
cvc: req_card.card_cvc,
complete: item.request.is_auto_capture()?,
};
Ok(Self {
amount: item_data.amount,
card,
})
}
PaymentMethodData::CardRedirect(_)
| PaymentMethodData::Wallet(_)
| PaymentMethodData::PayLater(_)
| PaymentMethodData::BankRedirect(_)
| PaymentMethodData::BankDebit(_)
| PaymentMethodData::BankTransfer(_)
| PaymentMethodData::Crypto(_)
| PaymentMethodData::MandatePayment
| PaymentMethodData::Reward
| PaymentMethodData::RealTimePayment(_)
| PaymentMethodData::MobilePayment(_)
| PaymentMethodData::Upi(_)
| PaymentMethodData::Voucher(_)
| PaymentMethodData::GiftCard(_)
| PaymentMethodData::OpenBanking(_)
| PaymentMethodData::CardToken(_)
| PaymentMethodData::NetworkToken(_)
| PaymentMethodData::CardDetailsForNetworkTransactionId(_) => {
Err(errors::ConnectorError::NotImplemented(
crate::utils::get_unimplemented_payment_method_error_message("Opayo"),
)
.into())
}
}
}
}
// Auth Struct
pub struct OpayoAuthType {
pub(super) api_key: Secret<String>,
}
impl TryFrom<&ConnectorAuthType> for OpayoAuthType {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(auth_type: &ConnectorAuthType) -> Result<Self, Self::Error> {
match auth_type {
ConnectorAuthType::HeaderKey { api_key } => Ok(Self {
api_key: api_key.to_owned(),
}),
_ => Err(errors::ConnectorError::FailedToObtainAuthType.into()),
}
}
}
// PaymentsResponse
#[derive(Debug, Clone, Default, Serialize, Deserialize, PartialEq)]
#[serde(rename_all = "lowercase")]
pub enum OpayoPaymentStatus {
Succeeded,
Failed,
#[default]
Processing,
}
impl From<OpayoPaymentStatus> for enums::AttemptStatus {
fn from(item: OpayoPaymentStatus) -> Self {
match item {
OpayoPaymentStatus::Succeeded => Self::Charged,
OpayoPaymentStatus::Failed => Self::Failure,
OpayoPaymentStatus::Processing => Self::Authorizing,
}
}
}
#[derive(Default, Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct OpayoPaymentsResponse {
status: OpayoPaymentStatus,
id: String,
transaction_id: String,
}
impl<F, T> TryFrom<ResponseRouterData<F, OpayoPaymentsResponse, T, PaymentsResponseData>>
for RouterData<F, T, PaymentsResponseData>
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: ResponseRouterData<F, OpayoPaymentsResponse, T, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
Ok(Self {
status: enums::AttemptStatus::from(item.response.status),
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(
item.response.transaction_id.clone(),
),
redirection_data: Box::new(None),
mandate_reference: Box::new(None),
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: Some(item.response.transaction_id),
incremental_authorization_allowed: None,
charges: None,
}),
..item.data
})
}
}
// REFUND :
// Type definition for RefundRequest
#[derive(Default, Debug, Serialize)]
pub struct OpayoRefundRequest {
pub amount: MinorUnit,
}
impl<F> TryFrom<&OpayoRouterData<&RefundsRouterData<F>>> for OpayoRefundRequest {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(item: &OpayoRouterData<&RefundsRouterData<F>>) -> Result<Self, Self::Error> {
Ok(Self {
amount: item.amount,
})
}
}
// Type definition for Refund Response
#[allow(dead_code)]
#[derive(Debug, Serialize, Default, Deserialize, Clone)]
pub enum RefundStatus {
Succeeded,
Failed,
#[default]
Processing,
}
impl From<RefundStatus> for enums::RefundStatus {
fn from(item: RefundStatus) -> Self {
match item {
RefundStatus::Succeeded => Self::Success,
RefundStatus::Failed => Self::Failure,
RefundStatus::Processing => Self::Pending,
//TODO: Review mapping
}
}
}
#[derive(Default, Debug, Clone, Serialize, Deserialize)]
pub struct RefundResponse {
id: String,
status: RefundStatus,
}
impl TryFrom<RefundsResponseRouterData<Execute, RefundResponse>> for RefundsRouterData<Execute> {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: RefundsResponseRouterData<Execute, RefundResponse>,
) -> Result<Self, Self::Error> {
Ok(Self {
response: Ok(RefundsResponseData {
connector_refund_id: item.response.id.to_string(),
refund_status: enums::RefundStatus::from(item.response.status),
}),
..item.data
})
}
}
impl TryFrom<RefundsResponseRouterData<RSync, RefundResponse>> for RefundsRouterData<RSync> {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: RefundsResponseRouterData<RSync, RefundResponse>,
) -> Result<Self, Self::Error> {
Ok(Self {
response: Ok(RefundsResponseData {
connector_refund_id: item.response.id.to_string(),
refund_status: enums::RefundStatus::from(item.response.status),
}),
..item.data
})
}
}
#[derive(Default, Debug, Serialize, Deserialize, PartialEq)]
pub struct OpayoErrorResponse {
pub status_code: u16,
pub code: String,
pub message: String,
pub reason: Option<String>,
}
|
{
"crate": "hyperswitch_connectors",
"file": "crates/hyperswitch_connectors/src/connectors/opayo/transformers.rs",
"file_size": null,
"is_async": null,
"is_pub": null,
"num_enums": 2,
"num_structs": 7,
"num_tables": null,
"score": null,
"total_crates": null
}
|
file_hyperswitch_connectors_4717103170352456414
|
clm
|
file
|
// Repository: hyperswitch
// Crate: hyperswitch_connectors
// File: crates/hyperswitch_connectors/src/connectors/gpayments/transformers.rs
// Contains: 1 structs, 0 enums
use api_models::payments::DeviceChannel;
use base64::Engine;
use common_utils::{consts::BASE64_ENGINE, date_time, types::MinorUnit};
use error_stack::ResultExt;
use hyperswitch_domain_models::{
router_data::{ConnectorAuthType, ErrorResponse},
router_flow_types::authentication::{
Authentication, PreAuthentication, PreAuthenticationVersionCall,
},
router_request_types::{
authentication::{
AuthNFlowType, ChallengeParams, ConnectorAuthenticationRequestData, MessageCategory,
PreAuthNRequestData,
},
BrowserInformation,
},
router_response_types::AuthenticationResponseData,
};
use hyperswitch_interfaces::errors::ConnectorError;
use masking::{ExposeInterface, Secret};
use serde::Deserialize;
use serde_json::to_string;
use super::gpayments_types::{
self, AuthStatus, BrowserInfoCollected, GpaymentsAuthenticationSuccessResponse,
GpaymentsPreAuthVersionCallResponse,
};
use crate::{
types::{
ConnectorAuthenticationRouterData, PreAuthNRouterData, PreAuthNVersionCallRouterData,
ResponseRouterData,
},
utils::{get_card_details, to_connector_meta_from_secret, CardData as _},
};
pub struct GpaymentsRouterData<T> {
pub amount: MinorUnit, // The type of amount that a connector accepts, for example, String, i64, f64, etc.
pub router_data: T,
}
impl<T> From<(MinorUnit, T)> for GpaymentsRouterData<T> {
fn from((amount, item): (MinorUnit, T)) -> Self {
Self {
amount,
router_data: item,
}
}
}
// Auth Struct
pub struct GpaymentsAuthType {
/// base64 encoded certificate
pub certificate: Secret<String>,
/// base64 encoded private_key
pub private_key: Secret<String>,
}
impl TryFrom<&ConnectorAuthType> for GpaymentsAuthType {
type Error = error_stack::Report<ConnectorError>;
fn try_from(auth_type: &ConnectorAuthType) -> Result<Self, Self::Error> {
match auth_type.to_owned() {
ConnectorAuthType::CertificateAuth {
certificate,
private_key,
} => Ok(Self {
certificate,
private_key,
}),
_ => Err(ConnectorError::FailedToObtainAuthType.into()),
}
}
}
impl TryFrom<&GpaymentsRouterData<&PreAuthNVersionCallRouterData>>
for gpayments_types::GpaymentsPreAuthVersionCallRequest
{
type Error = error_stack::Report<ConnectorError>;
fn try_from(
value: &GpaymentsRouterData<&PreAuthNVersionCallRouterData>,
) -> Result<Self, Self::Error> {
let router_data = value.router_data;
let metadata = GpaymentsMetaData::try_from(&router_data.connector_meta_data)?;
Ok(Self {
acct_number: router_data.request.card.card_number.clone(),
merchant_id: metadata.merchant_id,
})
}
}
#[derive(Deserialize, PartialEq)]
pub struct GpaymentsMetaData {
pub endpoint_prefix: String,
pub merchant_id: common_utils::id_type::MerchantId,
}
impl TryFrom<&Option<common_utils::pii::SecretSerdeValue>> for GpaymentsMetaData {
type Error = error_stack::Report<ConnectorError>;
fn try_from(
meta_data: &Option<common_utils::pii::SecretSerdeValue>,
) -> Result<Self, Self::Error> {
let metadata: Self = to_connector_meta_from_secret::<Self>(meta_data.clone())
.change_context(ConnectorError::InvalidConnectorConfig { config: "metadata" })?;
Ok(metadata)
}
}
impl
TryFrom<
ResponseRouterData<
PreAuthenticationVersionCall,
GpaymentsPreAuthVersionCallResponse,
PreAuthNRequestData,
AuthenticationResponseData,
>,
> for PreAuthNVersionCallRouterData
{
type Error = error_stack::Report<ConnectorError>;
fn try_from(
item: ResponseRouterData<
PreAuthenticationVersionCall,
GpaymentsPreAuthVersionCallResponse,
PreAuthNRequestData,
AuthenticationResponseData,
>,
) -> Result<Self, Self::Error> {
let version_response = item.response;
let response = Ok(AuthenticationResponseData::PreAuthVersionCallResponse {
maximum_supported_3ds_version: version_response
.supported_message_versions
.and_then(|supported_version| supported_version.iter().max().cloned()) // if no version is returned for the card number, then
.unwrap_or(common_utils::types::SemanticVersion::new(0, 0, 0)),
});
Ok(Self {
response,
..item.data.clone()
})
}
}
impl TryFrom<&GpaymentsRouterData<&PreAuthNRouterData>>
for gpayments_types::GpaymentsPreAuthenticationRequest
{
type Error = error_stack::Report<ConnectorError>;
fn try_from(value: &GpaymentsRouterData<&PreAuthNRouterData>) -> Result<Self, Self::Error> {
let router_data = value.router_data;
let metadata = GpaymentsMetaData::try_from(&router_data.connector_meta_data)?;
Ok(Self {
acct_number: router_data.request.card.card_number.clone(),
card_scheme: None,
challenge_window_size: Some(gpayments_types::ChallengeWindowSize::FullScreen),
event_callback_url: "https://webhook.site/55e3db24-7c4e-4432-9941-d806f68d210b"
.to_string(),
merchant_id: metadata.merchant_id,
skip_auto_browser_info_collect: Some(true),
// should auto generate this id.
three_ds_requestor_trans_id: uuid::Uuid::new_v4().hyphenated().to_string(),
})
}
}
impl TryFrom<&GpaymentsRouterData<&ConnectorAuthenticationRouterData>>
for gpayments_types::GpaymentsAuthenticationRequest
{
type Error = error_stack::Report<ConnectorError>;
fn try_from(
item: &GpaymentsRouterData<&ConnectorAuthenticationRouterData>,
) -> Result<Self, Self::Error> {
let request = &item.router_data.request;
let browser_details = match request.browser_details.clone() {
Some(details) => Ok::<Option<BrowserInformation>, Self::Error>(Some(details)),
None => {
if request.device_channel == DeviceChannel::Browser {
Err(ConnectorError::MissingRequiredField {
field_name: "browser_info",
})?
} else {
Ok(None)
}
}
}?;
let card_details = get_card_details(request.payment_method_data.clone(), "gpayments")?;
let metadata = GpaymentsMetaData::try_from(&item.router_data.connector_meta_data)?;
Ok(Self {
acct_number: card_details.card_number.clone(),
authentication_ind: "01".into(),
card_expiry_date: card_details.get_expiry_date_as_yymm()?.expose(),
merchant_id: metadata.merchant_id,
message_category: match item.router_data.request.message_category.clone() {
MessageCategory::Payment => "01".into(),
MessageCategory::NonPayment => "02".into(),
},
notification_url: request
.return_url
.clone()
.ok_or(ConnectorError::RequestEncodingFailed)
.attach_printable("missing return_url")?,
three_ds_comp_ind: request.threeds_method_comp_ind.clone(),
purchase_amount: item.amount.to_string(),
purchase_date: date_time::DateTime::<date_time::YYYYMMDDHHmmss>::from(date_time::now())
.to_string(),
three_ds_server_trans_id: request
.pre_authentication_data
.threeds_server_transaction_id
.clone(),
browser_info_collected: BrowserInfoCollected {
browser_javascript_enabled: browser_details
.as_ref()
.and_then(|details| details.java_script_enabled),
browser_accept_header: browser_details
.as_ref()
.and_then(|details| details.accept_header.clone()),
browser_ip: browser_details
.clone()
.and_then(|details| details.ip_address.map(|ip| Secret::new(ip.to_string()))),
browser_java_enabled: browser_details
.as_ref()
.and_then(|details| details.java_enabled),
browser_language: browser_details
.as_ref()
.and_then(|details| details.language.clone()),
browser_color_depth: browser_details
.as_ref()
.and_then(|details| details.color_depth.map(|a| a.to_string())),
browser_screen_height: browser_details
.as_ref()
.and_then(|details| details.screen_height.map(|a| a.to_string())),
browser_screen_width: browser_details
.as_ref()
.and_then(|details| details.screen_width.map(|a| a.to_string())),
browser_tz: browser_details
.as_ref()
.and_then(|details| details.time_zone.map(|a| a.to_string())),
browser_user_agent: browser_details
.as_ref()
.and_then(|details| details.user_agent.clone().map(|a| a.to_string())),
},
})
}
}
impl
TryFrom<
ResponseRouterData<
Authentication,
GpaymentsAuthenticationSuccessResponse,
ConnectorAuthenticationRequestData,
AuthenticationResponseData,
>,
> for ConnectorAuthenticationRouterData
{
type Error = error_stack::Report<ConnectorError>;
fn try_from(
item: ResponseRouterData<
Authentication,
GpaymentsAuthenticationSuccessResponse,
ConnectorAuthenticationRequestData,
AuthenticationResponseData,
>,
) -> Result<Self, Self::Error> {
let response_auth = item.response;
let creq = serde_json::json!({
"threeDSServerTransID": response_auth.three_ds_server_trans_id,
"acsTransID": response_auth.acs_trans_id,
"messageVersion": response_auth.message_version,
"messageType": "CReq",
"challengeWindowSize": "01",
});
let creq_str = to_string(&creq)
.change_context(ConnectorError::ResponseDeserializationFailed)
.attach_printable("error while constructing creq_str")?;
let creq_base64 = Engine::encode(&BASE64_ENGINE, creq_str)
.trim_end_matches('=')
.to_owned();
let response: Result<AuthenticationResponseData, ErrorResponse> =
Ok(AuthenticationResponseData::AuthNResponse {
trans_status: response_auth.trans_status.clone().into(),
authn_flow_type: if response_auth.trans_status == AuthStatus::C {
AuthNFlowType::Challenge(Box::new(ChallengeParams {
acs_url: response_auth.acs_url,
challenge_request: Some(creq_base64),
acs_reference_number: Some(response_auth.acs_reference_number.clone()),
acs_trans_id: Some(response_auth.acs_trans_id.clone()),
three_dsserver_trans_id: Some(response_auth.three_ds_server_trans_id),
acs_signed_content: None,
challenge_request_key: None,
}))
} else {
AuthNFlowType::Frictionless
},
authentication_value: response_auth.authentication_value,
ds_trans_id: Some(response_auth.ds_trans_id),
connector_metadata: None,
eci: None,
challenge_code: None,
challenge_cancel: None,
challenge_code_reason: None,
message_extension: None,
});
Ok(Self {
response,
..item.data.clone()
})
}
}
impl
TryFrom<
ResponseRouterData<
PreAuthentication,
gpayments_types::GpaymentsPreAuthenticationResponse,
PreAuthNRequestData,
AuthenticationResponseData,
>,
> for PreAuthNRouterData
{
type Error = error_stack::Report<ConnectorError>;
fn try_from(
item: ResponseRouterData<
PreAuthentication,
gpayments_types::GpaymentsPreAuthenticationResponse,
PreAuthNRequestData,
AuthenticationResponseData,
>,
) -> Result<Self, Self::Error> {
let threeds_method_response = item.response;
let three_ds_method_data = threeds_method_response
.three_ds_method_url
.as_ref()
.map(|_| {
let three_ds_method_data_json = serde_json::json!({
"threeDSServerTransID": threeds_method_response.three_ds_server_trans_id,
"threeDSMethodNotificationURL": "https://webhook.site/bd06863d-82c2-42ea-b35b-5ffd5ecece71"
});
to_string(&three_ds_method_data_json)
.change_context(ConnectorError::ResponseDeserializationFailed)
.attach_printable("error while constructing three_ds_method_data_str")
.map(|three_ds_method_data_string| {
Engine::encode(&BASE64_ENGINE, three_ds_method_data_string)
})
})
.transpose()?;
let connector_metadata = Some(serde_json::json!(
gpayments_types::GpaymentsConnectorMetaData {
authentication_url: threeds_method_response.auth_url,
three_ds_requestor_trans_id: None,
}
));
let response: Result<AuthenticationResponseData, ErrorResponse> = Ok(
AuthenticationResponseData::PreAuthThreeDsMethodCallResponse {
threeds_server_transaction_id: threeds_method_response
.three_ds_server_trans_id
.clone(),
three_ds_method_data,
three_ds_method_url: threeds_method_response.three_ds_method_url,
connector_metadata,
},
);
Ok(Self {
response,
..item.data.clone()
})
}
}
|
{
"crate": "hyperswitch_connectors",
"file": "crates/hyperswitch_connectors/src/connectors/gpayments/transformers.rs",
"file_size": null,
"is_async": null,
"is_pub": null,
"num_enums": 0,
"num_structs": 1,
"num_tables": null,
"score": null,
"total_crates": null
}
|
file_hyperswitch_connectors_6357774953059182051
|
clm
|
file
|
// Repository: hyperswitch
// Crate: hyperswitch_connectors
// File: crates/hyperswitch_connectors/src/connectors/gpayments/gpayments_types.rs
// Contains: 10 structs, 5 enums
use api_models::payments::ThreeDsCompletionIndicator;
use cards::CardNumber;
use common_utils::types;
use masking::{Deserialize, Secret, Serialize};
#[derive(Debug, Serialize, Deserialize)]
pub struct GpaymentsConnectorMetaData {
pub authentication_url: String,
pub three_ds_requestor_trans_id: Option<String>,
}
#[derive(Serialize, Deserialize, Debug, Clone)]
#[serde(rename_all = "camelCase")]
pub struct GpaymentsPreAuthVersionCallRequest {
pub acct_number: CardNumber,
pub merchant_id: common_utils::id_type::MerchantId,
}
#[derive(Serialize, Deserialize, Debug, Clone)]
#[serde(rename_all = "camelCase")]
pub struct GpaymentsPreAuthVersionCallResponse {
pub enrolment_status: EnrollmentStatus,
pub supported_message_versions: Option<Vec<types::SemanticVersion>>,
}
#[derive(Serialize, Deserialize, Debug, Clone)]
pub enum EnrollmentStatus {
#[serde(rename = "00")]
NotEnrolled,
#[serde(rename = "01")]
Enrolled,
}
#[derive(Serialize, Deserialize, Debug, Clone)]
#[serde(rename_all = "camelCase")]
pub struct TDS2ApiError {
pub error_code: String,
pub error_component: Option<String>,
pub error_description: String,
pub error_detail: Option<String>,
pub error_message_type: Option<String>,
/// Always returns 'Error' to indicate that this message is an error.
///
/// Example: "Error"
pub message_type: String,
pub message_version: Option<String>,
#[serde(rename = "sdkTransID")]
pub sdk_trans_id: Option<String>,
#[serde(rename = "threeDSServerTransID")]
pub three_ds_server_trans_id: Option<String>,
}
#[derive(Serialize, Deserialize, Debug, Clone)]
#[serde(rename_all = "camelCase")]
pub struct GpaymentsPreAuthenticationRequest {
pub acct_number: CardNumber,
pub card_scheme: Option<CardScheme>,
pub challenge_window_size: Option<ChallengeWindowSize>,
/// URL where the 3DS requestor receives events during authentication.
/// ActiveServer calls this URL through the iframe to notify events occurring during authentication.
///
/// Example: "https://example.requestor.com/3ds-notify"
/// Length: Maximum 2000 characters
pub event_callback_url: String,
/// Merchant identifier assigned by the acquirer.
/// This may be the same value used in authorization requests sent on behalf of the 3DS Requestor.
///
/// Example: "1234567890123456789012345678901234"
/// Length: Maximum 35 characters
pub merchant_id: common_utils::id_type::MerchantId,
/// Optional boolean. If set to true, ActiveServer will not collect the browser information automatically.
/// The requestor must have a backend implementation to collect browser information.
pub skip_auto_browser_info_collect: Option<bool>,
/// Universal unique transaction identifier assigned by the 3DS Requestor to identify a single transaction.
///
/// Example: "6afa6072-9412-446b-9673-2f98b3ee98a2"
/// Length: 36 characters
#[serde(rename = "threeDSRequestorTransID")]
pub three_ds_requestor_trans_id: String,
}
#[derive(Serialize, Deserialize, Debug, Clone)]
pub enum ChallengeWindowSize {
#[serde(rename = "01")]
Size250x400,
#[serde(rename = "02")]
Size390x400,
#[serde(rename = "03")]
Size500x600,
#[serde(rename = "04")]
Size600x400,
#[serde(rename = "05")]
FullScreen,
}
#[derive(Serialize, Deserialize, Debug, Clone)]
#[serde(rename_all = "UPPERCASE")]
pub enum CardScheme {
Visa,
MasterCard,
AmericanExpress,
JCB,
Discover,
UnionPay,
Mir,
Eftpos,
BCard,
}
#[derive(Serialize, Deserialize, Debug, Clone)]
#[serde(rename_all = "camelCase")]
pub struct GpaymentsPreAuthenticationResponse {
pub auth_url: String,
pub mon_url: Option<String>,
pub resolved_card_scheme: Option<CardScheme>,
#[serde(rename = "threeDSMethodAvailable")]
pub three_ds_method_available: Option<bool>,
#[serde(rename = "threeDSMethodUrl")]
pub three_ds_method_url: Option<String>,
#[serde(rename = "threeDSServerCallbackUrl")]
pub three_ds_server_callback_url: Option<String>,
#[serde(rename = "threeDSServerTransID")]
pub three_ds_server_trans_id: String,
}
#[derive(Serialize, Deserialize, Debug, Clone)]
#[serde(rename_all = "camelCase")]
pub struct GpaymentsAuthenticationRequest {
pub acct_number: CardNumber,
pub authentication_ind: String,
pub browser_info_collected: BrowserInfoCollected,
pub card_expiry_date: String,
#[serde(rename = "notificationURL")]
pub notification_url: String,
pub merchant_id: common_utils::id_type::MerchantId,
#[serde(rename = "threeDSCompInd")]
pub three_ds_comp_ind: ThreeDsCompletionIndicator,
pub message_category: String,
pub purchase_amount: String,
pub purchase_date: String,
#[serde(rename = "threeDSServerTransID")]
pub three_ds_server_trans_id: String,
}
#[derive(Serialize, Deserialize, Debug, Clone)]
#[serde(rename_all = "camelCase")]
pub struct BrowserInfoCollected {
pub browser_accept_header: Option<String>,
pub browser_color_depth: Option<String>,
#[serde(rename = "browserIP")]
pub browser_ip: Option<Secret<String, common_utils::pii::IpAddress>>,
pub browser_javascript_enabled: Option<bool>,
pub browser_java_enabled: Option<bool>,
pub browser_language: Option<String>,
pub browser_screen_height: Option<String>,
pub browser_screen_width: Option<String>,
#[serde(rename = "browserTZ")]
pub browser_tz: Option<String>,
pub browser_user_agent: Option<String>,
}
#[derive(Serialize, Deserialize, Debug, Clone)]
pub enum AuthenticationInd {
#[serde(rename = "01")]
PaymentTransaction,
#[serde(rename = "02")]
RecurringTransaction,
#[serde(rename = "03")]
InstalmentTransaction,
#[serde(rename = "04")]
AddCard,
#[serde(rename = "05")]
MaintainCard,
#[serde(rename = "06")]
CardholderVerification,
}
#[derive(Serialize, Deserialize, Debug, Clone)]
#[serde(rename_all = "camelCase")]
pub struct GpaymentsAuthenticationSuccessResponse {
#[serde(rename = "dsReferenceNumber")]
pub ds_reference_number: String,
#[serde(rename = "dsTransID")]
pub ds_trans_id: String,
#[serde(rename = "threeDSServerTransID")]
pub three_ds_server_trans_id: String,
#[serde(rename = "messageVersion")]
pub message_version: String,
#[serde(rename = "transStatus")]
pub trans_status: AuthStatus,
#[serde(rename = "acsTransID")]
pub acs_trans_id: String,
#[serde(rename = "challengeUrl")]
pub acs_url: Option<url::Url>,
#[serde(rename = "acsReferenceNumber")]
pub acs_reference_number: String,
pub authentication_value: Option<Secret<String>>,
}
#[derive(Deserialize, Debug, Clone, Serialize, PartialEq)]
pub enum AuthStatus {
/// Authentication/ Account Verification Successful
Y,
/// Not Authenticated /Account Not Verified; Transaction denied
N,
/// Authentication/ Account Verification Could Not Be Performed; Technical or other problem, as indicated in ARes or RReq
U,
/// Attempts Processing Performed; Not Authenticated/Verified , but a proof of attempted authentication/verification is provided
A,
/// Authentication/ Account Verification Rejected; Issuer is rejecting authentication/verification and request that authorisation not be attempted.
R,
/// Challenge required
C,
}
impl From<AuthStatus> for common_enums::TransactionStatus {
fn from(value: AuthStatus) -> Self {
match value {
AuthStatus::Y => Self::Success,
AuthStatus::N => Self::Failure,
AuthStatus::U => Self::VerificationNotPerformed,
AuthStatus::A => Self::NotVerified,
AuthStatus::R => Self::Rejected,
AuthStatus::C => Self::ChallengeRequired,
}
}
}
#[derive(Debug, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct GpaymentsPostAuthenticationResponse {
pub authentication_value: Option<Secret<String>>,
pub trans_status: AuthStatus,
pub eci: Option<String>,
}
|
{
"crate": "hyperswitch_connectors",
"file": "crates/hyperswitch_connectors/src/connectors/gpayments/gpayments_types.rs",
"file_size": null,
"is_async": null,
"is_pub": null,
"num_enums": 5,
"num_structs": 10,
"num_tables": null,
"score": null,
"total_crates": null
}
|
file_hyperswitch_connectors_-4559165214396327886
|
clm
|
file
|
// Repository: hyperswitch
// Crate: hyperswitch_connectors
// File: crates/hyperswitch_connectors/src/connectors/authorizedotnet/transformers.rs
// Contains: 41 structs, 13 enums
use std::collections::BTreeMap;
use api_models::{payments::AdditionalPaymentData, webhooks::IncomingWebhookEvent};
use common_enums::enums;
use common_utils::{
errors::CustomResult,
ext_traits::{Encode, OptionExt, ValueExt},
id_type::CustomerId,
pii::Email,
request::Method,
types::FloatMajorUnit,
};
use error_stack::ResultExt;
use hyperswitch_domain_models::{
payment_method_data::{Card, PaymentMethodData, WalletData},
router_data::{
AdditionalPaymentMethodConnectorResponse, ConnectorAuthType, ConnectorResponseData,
ErrorResponse, RouterData,
},
router_flow_types::RSync,
router_request_types::ResponseId,
router_response_types::{
ConnectorCustomerResponseData, MandateReference, PaymentsResponseData, RedirectForm,
RefundsResponseData,
},
types::{
ConnectorCustomerRouterData, PaymentsAuthorizeRouterData, PaymentsCancelRouterData,
PaymentsCaptureRouterData, PaymentsCompleteAuthorizeRouterData, PaymentsSyncRouterData,
RefundsRouterData, SetupMandateRouterData,
},
};
use hyperswitch_interfaces::errors;
use masking::{ExposeInterface, PeekInterface, Secret, StrongSecret};
use rand::distributions::{Alphanumeric, DistString};
use regex::Regex;
use serde::{Deserialize, Serialize};
use serde_json::Value;
use crate::{
types::{RefundsResponseRouterData, ResponseRouterData},
utils::{
self, CardData, ForeignTryFrom, PaymentsAuthorizeRequestData, PaymentsSyncRequestData,
RefundsRequestData, RouterData as OtherRouterData, WalletData as OtherWalletData,
},
};
const MAX_ID_LENGTH: usize = 20;
fn get_random_string() -> String {
Alphanumeric.sample_string(&mut rand::thread_rng(), MAX_ID_LENGTH)
}
#[derive(Debug, Serialize)]
pub enum TransactionType {
#[serde(rename = "authCaptureTransaction")]
Payment,
#[serde(rename = "authOnlyTransaction")]
Authorization,
#[serde(rename = "priorAuthCaptureTransaction")]
Capture,
#[serde(rename = "refundTransaction")]
Refund,
#[serde(rename = "voidTransaction")]
Void,
#[serde(rename = "authOnlyContinueTransaction")]
ContinueAuthorization,
#[serde(rename = "authCaptureContinueTransaction")]
ContinueCapture,
}
#[derive(Debug, Serialize)]
pub struct AuthorizedotnetRouterData<T> {
pub amount: FloatMajorUnit,
pub router_data: T,
}
impl<T> TryFrom<(FloatMajorUnit, T)> for AuthorizedotnetRouterData<T> {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from((amount, item): (FloatMajorUnit, T)) -> Result<Self, Self::Error> {
Ok(Self {
amount,
router_data: item,
})
}
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct AuthorizedotnetAuthType {
name: Secret<String>,
transaction_key: Secret<String>,
}
impl TryFrom<&ConnectorAuthType> for AuthorizedotnetAuthType {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(auth_type: &ConnectorAuthType) -> Result<Self, Self::Error> {
if let ConnectorAuthType::BodyKey { api_key, key1 } = auth_type {
Ok(Self {
name: api_key.to_owned(),
transaction_key: key1.to_owned(),
})
} else {
Err(errors::ConnectorError::FailedToObtainAuthType)?
}
}
}
#[derive(Serialize, Deserialize, Debug)]
#[serde(rename_all = "camelCase")]
struct CreditCardDetails {
card_number: StrongSecret<String, cards::CardNumberStrategy>,
expiration_date: Secret<String>,
#[serde(skip_serializing_if = "Option::is_none")]
card_code: Option<Secret<String>>,
}
#[derive(Serialize, Deserialize, Debug)]
#[serde(rename_all = "camelCase")]
enum PaymentDetails {
CreditCard(CreditCardDetails),
OpaqueData(WalletDetails),
PayPal(PayPalDetails),
}
#[derive(Serialize, Deserialize, Debug)]
#[serde(rename_all = "camelCase")]
pub struct PayPalDetails {
pub success_url: Option<String>,
pub cancel_url: Option<String>,
}
#[derive(Serialize, Debug, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct WalletDetails {
pub data_descriptor: WalletMethod,
pub data_value: Secret<String>,
}
#[derive(Serialize, Debug, Deserialize)]
pub enum WalletMethod {
#[serde(rename = "COMMON.GOOGLE.INAPP.PAYMENT")]
Googlepay,
#[serde(rename = "COMMON.APPLE.INAPP.PAYMENT")]
Applepay,
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
struct TransactionRequest {
transaction_type: TransactionType,
amount: FloatMajorUnit,
currency_code: common_enums::Currency,
#[serde(skip_serializing_if = "Option::is_none")]
payment: Option<PaymentDetails>,
#[serde(skip_serializing_if = "Option::is_none")]
profile: Option<ProfileDetails>,
order: Order,
#[serde(skip_serializing_if = "Option::is_none")]
customer: Option<CustomerDetails>,
#[serde(skip_serializing_if = "Option::is_none")]
bill_to: Option<BillTo>,
#[serde(skip_serializing_if = "Option::is_none")]
user_fields: Option<UserFields>,
#[serde(skip_serializing_if = "Option::is_none")]
processing_options: Option<ProcessingOptions>,
#[serde(skip_serializing_if = "Option::is_none")]
subsequent_auth_information: Option<SubsequentAuthInformation>,
authorization_indicator_type: Option<AuthorizationIndicator>,
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct UserFields {
user_field: Vec<UserField>,
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct UserField {
name: String,
value: String,
}
#[derive(Serialize, Deserialize, Debug)]
#[serde(untagged)]
enum ProfileDetails {
CreateProfileDetails(CreateProfileDetails),
CustomerProfileDetails(CustomerProfileDetails),
}
#[derive(Serialize, Deserialize, Debug)]
#[serde(rename_all = "camelCase")]
pub struct CreateProfileDetails {
create_profile: bool,
#[serde(skip_serializing_if = "Option::is_none")]
customer_profile_id: Option<Secret<String>>,
}
#[derive(Serialize, Deserialize, Debug)]
#[serde(rename_all = "camelCase")]
struct CustomerProfileDetails {
customer_profile_id: Secret<String>,
payment_profile: PaymentProfileDetails,
}
#[derive(Serialize, Deserialize, Debug)]
#[serde(rename_all = "camelCase")]
struct PaymentProfileDetails {
payment_profile_id: Secret<String>,
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct CustomerDetails {
id: String,
email: Option<Email>,
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ProcessingOptions {
is_subsequent_auth: bool,
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct BillTo {
first_name: Option<Secret<String>>,
last_name: Option<Secret<String>>,
address: Option<Secret<String>>,
city: Option<String>,
state: Option<Secret<String>>,
zip: Option<Secret<String>>,
country: Option<enums::CountryAlpha2>,
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct Order {
invoice_number: String,
description: String,
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct SubsequentAuthInformation {
original_network_trans_id: Secret<String>,
// original_auth_amount: String, Required for Discover, Diners Club, JCB, and China Union Pay transactions.
reason: Reason,
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "lowercase")]
pub enum Reason {
Resubmission,
#[serde(rename = "delayedCharge")]
DelayedCharge,
Reauthorization,
#[serde(rename = "noShow")]
NoShow,
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
struct AuthorizationIndicator {
authorization_indicator: AuthorizationType,
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
struct TransactionVoidOrCaptureRequest {
transaction_type: TransactionType,
#[serde(skip_serializing_if = "Option::is_none")]
amount: Option<FloatMajorUnit>,
ref_trans_id: String,
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct AuthorizedotnetPaymentsRequest {
merchant_authentication: AuthorizedotnetAuthType,
ref_id: Option<String>,
transaction_request: TransactionRequest,
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct AuthorizedotnetPaymentCancelOrCaptureRequest {
merchant_authentication: AuthorizedotnetAuthType,
transaction_request: TransactionVoidOrCaptureRequest,
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
// The connector enforces field ordering, it expects fields to be in the same order as in their API documentation
pub struct CustomerRequest {
create_customer_profile_request: CreateCustomerRequest,
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct CreateCustomerRequest {
merchant_authentication: AuthorizedotnetAuthType,
profile: Profile,
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct CreateCustomerPaymentProfileRequest {
create_customer_payment_profile_request: AuthorizedotnetPaymentProfileRequest,
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct AuthorizedotnetPaymentProfileRequest {
merchant_authentication: AuthorizedotnetAuthType,
customer_profile_id: Secret<String>,
payment_profile: PaymentProfile,
validation_mode: ValidationMode,
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ShipToList {
#[serde(skip_serializing_if = "Option::is_none")]
first_name: Option<Secret<String>>,
#[serde(skip_serializing_if = "Option::is_none")]
last_name: Option<Secret<String>>,
#[serde(skip_serializing_if = "Option::is_none")]
address: Option<Secret<String>>,
#[serde(skip_serializing_if = "Option::is_none")]
city: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
state: Option<Secret<String>>,
#[serde(skip_serializing_if = "Option::is_none")]
zip: Option<Secret<String>>,
#[serde(skip_serializing_if = "Option::is_none")]
country: Option<enums::CountryAlpha2>,
#[serde(skip_serializing_if = "Option::is_none")]
phone_number: Option<Secret<String>>,
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
struct Profile {
#[serde(skip_serializing_if = "Option::is_none")]
merchant_customer_id: Option<CustomerId>,
#[serde(skip_serializing_if = "Option::is_none")]
description: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
email: Option<Email>,
#[serde(skip_serializing_if = "Option::is_none")]
payment_profiles: Option<PaymentProfiles>,
#[serde(skip_serializing_if = "Option::is_none")]
ship_to_list: Option<Vec<ShipToList>>,
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
struct PaymentProfiles {
customer_type: CustomerType,
#[serde(skip_serializing_if = "Option::is_none")]
bill_to: Option<BillTo>,
payment: PaymentDetails,
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
struct PaymentProfile {
#[serde(skip_serializing_if = "Option::is_none")]
bill_to: Option<BillTo>,
payment: PaymentDetails,
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "lowercase")]
pub enum CustomerType {
Individual,
Business,
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub enum ValidationMode {
// testMode performs a Luhn mod-10 check on the card number, without further validation at connector.
TestMode,
// liveMode submits a zero-dollar or one-cent transaction (depending on card type and processor support) to confirm that the card number belongs to an active credit or debit account.
LiveMode,
}
impl ForeignTryFrom<Value> for Vec<UserField> {
type Error = error_stack::Report<errors::ConnectorError>;
fn foreign_try_from(metadata: Value) -> Result<Self, Self::Error> {
let hashmap: BTreeMap<String, Value> = serde_json::from_str(&metadata.to_string())
.change_context(errors::ConnectorError::RequestEncodingFailedWithReason(
"Failed to serialize request metadata".to_owned(),
))
.attach_printable("")?;
let mut vector: Self = Self::new();
for (key, value) in hashmap {
vector.push(UserField {
name: key,
value: value.to_string(),
});
}
Ok(vector)
}
}
impl TryFrom<&ConnectorCustomerRouterData> for CustomerRequest {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(item: &ConnectorCustomerRouterData) -> Result<Self, Self::Error> {
let merchant_authentication = AuthorizedotnetAuthType::try_from(&item.connector_auth_type)?;
let ship_to_list = item.get_optional_shipping().and_then(|shipping| {
shipping.address.as_ref().map(|address| {
vec![ShipToList {
first_name: address.first_name.clone(),
last_name: address.last_name.clone(),
address: address.line1.clone(),
city: address.city.clone(),
state: address.state.clone(),
zip: address.zip.clone(),
country: address.country,
phone_number: shipping
.phone
.as_ref()
.and_then(|phone| phone.number.as_ref().map(|number| number.to_owned())),
}]
})
});
let merchant_customer_id = match item.customer_id.as_ref() {
Some(cid) if cid.get_string_repr().len() <= MAX_ID_LENGTH => Some(cid.clone()),
_ => None,
};
Ok(Self {
create_customer_profile_request: CreateCustomerRequest {
merchant_authentication,
profile: Profile {
merchant_customer_id,
description: None,
email: item.request.email.clone(),
payment_profiles: None,
ship_to_list,
},
},
})
}
}
impl TryFrom<&SetupMandateRouterData> for CreateCustomerPaymentProfileRequest {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(item: &SetupMandateRouterData) -> Result<Self, Self::Error> {
let merchant_authentication = AuthorizedotnetAuthType::try_from(&item.connector_auth_type)?;
let validation_mode = match item.test_mode {
Some(true) | None => ValidationMode::TestMode,
Some(false) => ValidationMode::LiveMode,
};
let customer_profile_id = item.get_connector_customer_id()?.into();
let bill_to = item
.get_optional_billing()
.and_then(|billing_address| billing_address.address.as_ref())
.map(|address| BillTo {
first_name: address.first_name.clone(),
last_name: address.last_name.clone(),
address: address.line1.clone(),
city: address.city.clone(),
state: address.state.clone(),
zip: address.zip.clone(),
country: address.country,
});
let payment_profile = match item.request.payment_method_data.clone() {
PaymentMethodData::Card(ccard) => Ok(PaymentProfile {
bill_to,
payment: PaymentDetails::CreditCard(CreditCardDetails {
card_number: (*ccard.card_number).clone(),
expiration_date: ccard.get_expiry_date_as_yyyymm("-"),
card_code: Some(ccard.card_cvc.clone()),
}),
}),
PaymentMethodData::Wallet(wallet_data) => match wallet_data {
WalletData::GooglePay(_) => Ok(PaymentProfile {
bill_to,
payment: PaymentDetails::OpaqueData(WalletDetails {
data_descriptor: WalletMethod::Googlepay,
data_value: Secret::new(wallet_data.get_encoded_wallet_token()?),
}),
}),
WalletData::ApplePay(applepay_token) => {
let apple_pay_encrypted_data = applepay_token
.payment_data
.get_encrypted_apple_pay_payment_data_mandatory()
.change_context(errors::ConnectorError::MissingRequiredField {
field_name: "Apple pay encrypted data",
})?;
Ok(PaymentProfile {
bill_to,
payment: PaymentDetails::OpaqueData(WalletDetails {
data_descriptor: WalletMethod::Applepay,
data_value: Secret::new(apple_pay_encrypted_data.clone()),
}),
})
}
WalletData::AliPayQr(_)
| WalletData::AliPayRedirect(_)
| WalletData::AliPayHkRedirect(_)
| WalletData::AmazonPayRedirect(_)
| WalletData::Paysera(_)
| WalletData::BluecodeRedirect {}
| WalletData::Skrill(_)
| WalletData::MomoRedirect(_)
| WalletData::KakaoPayRedirect(_)
| WalletData::GoPayRedirect(_)
| WalletData::GcashRedirect(_)
| WalletData::ApplePayRedirect(_)
| WalletData::ApplePayThirdPartySdk(_)
| WalletData::DanaRedirect {}
| WalletData::GooglePayRedirect(_)
| WalletData::GooglePayThirdPartySdk(_)
| WalletData::MbWayRedirect(_)
| WalletData::MobilePayRedirect(_)
| WalletData::PaypalRedirect(_)
| WalletData::AmazonPay(_)
| WalletData::PaypalSdk(_)
| WalletData::Paze(_)
| WalletData::SamsungPay(_)
| WalletData::TwintRedirect {}
| WalletData::VippsRedirect {}
| WalletData::TouchNGoRedirect(_)
| WalletData::WeChatPayRedirect(_)
| WalletData::WeChatPayQr(_)
| WalletData::CashappQr(_)
| WalletData::SwishQr(_)
| WalletData::Mifinity(_)
| WalletData::RevolutPay(_) => Err(errors::ConnectorError::NotImplemented(
utils::get_unimplemented_payment_method_error_message("authorizedotnet"),
)),
},
PaymentMethodData::CardRedirect(_)
| PaymentMethodData::PayLater(_)
| PaymentMethodData::BankRedirect(_)
| PaymentMethodData::BankDebit(_)
| PaymentMethodData::BankTransfer(_)
| PaymentMethodData::Crypto(_)
| PaymentMethodData::MandatePayment
| PaymentMethodData::Reward
| PaymentMethodData::RealTimePayment(_)
| PaymentMethodData::MobilePayment(_)
| PaymentMethodData::Upi(_)
| PaymentMethodData::Voucher(_)
| PaymentMethodData::GiftCard(_)
| PaymentMethodData::OpenBanking(_)
| PaymentMethodData::CardToken(_)
| PaymentMethodData::NetworkToken(_)
| PaymentMethodData::CardDetailsForNetworkTransactionId(_) => {
Err(errors::ConnectorError::NotImplemented(
utils::get_unimplemented_payment_method_error_message("authorizedotnet"),
))
}
}?;
Ok(Self {
create_customer_payment_profile_request: AuthorizedotnetPaymentProfileRequest {
merchant_authentication,
customer_profile_id,
payment_profile,
validation_mode,
},
})
}
}
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct AuthorizedotnetSetupMandateResponse {
#[serde(default, skip_serializing_if = "Vec::is_empty")]
customer_payment_profile_id_list: Vec<String>,
customer_profile_id: Option<String>,
#[serde(rename = "customerPaymentProfileId")]
customer_payment_profile_id: Option<String>,
validation_direct_response_list: Option<Vec<Secret<String>>>,
pub messages: ResponseMessages,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct AuthorizedotnetCustomerResponse {
customer_profile_id: Option<String>,
#[serde(default, skip_serializing_if = "Vec::is_empty")]
customer_payment_profile_id_list: Vec<String>,
#[serde(default, skip_serializing_if = "Vec::is_empty")]
customer_shipping_address_id_list: Vec<String>,
pub messages: ResponseMessages,
}
fn extract_customer_id(text: &str) -> Option<String> {
let re = Regex::new(r"ID (\d+)").ok()?;
re.captures(text)
.and_then(|captures| captures.get(1))
.map(|capture_match| capture_match.as_str().to_string())
}
impl<F, T> TryFrom<ResponseRouterData<F, AuthorizedotnetCustomerResponse, T, PaymentsResponseData>>
for RouterData<F, T, PaymentsResponseData>
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: ResponseRouterData<F, AuthorizedotnetCustomerResponse, T, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
match item.response.messages.result_code {
ResultCode::Ok => match item.response.customer_profile_id.clone() {
Some(connector_customer_id) => Ok(Self {
response: Ok(PaymentsResponseData::ConnectorCustomerResponse(
ConnectorCustomerResponseData::new_with_customer_id(connector_customer_id),
)),
..item.data
}),
None => Err(
errors::ConnectorError::UnexpectedResponseError(bytes::Bytes::from(
"Missing customer profile id from Authorizedotnet".to_string(),
))
.into(),
),
},
ResultCode::Error => {
let error_message = item.response.messages.message.first();
if let Some(connector_customer_id) =
error_message.and_then(|error| extract_customer_id(&error.text))
{
Ok(Self {
response: Ok(PaymentsResponseData::ConnectorCustomerResponse(
ConnectorCustomerResponseData::new_with_customer_id(
connector_customer_id,
),
)),
..item.data
})
} else {
let error_code = error_message.map(|error| error.code.clone());
let error_code = error_code.unwrap_or_else(|| {
hyperswitch_interfaces::consts::NO_ERROR_CODE.to_string()
});
let error_reason = item
.response
.messages
.message
.iter()
.map(|error: &ResponseMessage| error.text.clone())
.collect::<Vec<String>>()
.join(" ");
let response = Err(ErrorResponse {
code: error_code,
message: item.response.messages.result_code.to_string(),
reason: Some(error_reason),
status_code: item.http_code,
attempt_status: None,
connector_transaction_id: None,
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
connector_metadata: None,
});
Ok(Self {
response,
status: enums::AttemptStatus::Failure,
..item.data
})
}
}
}
}
}
// zero dollar response
impl<F, T>
TryFrom<ResponseRouterData<F, AuthorizedotnetSetupMandateResponse, T, PaymentsResponseData>>
for RouterData<F, T, PaymentsResponseData>
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: ResponseRouterData<F, AuthorizedotnetSetupMandateResponse, T, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
let connector_customer_id = item.data.get_connector_customer_id()?;
if item.response.customer_profile_id.is_some() {
Ok(Self {
status: enums::AttemptStatus::Charged,
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::NoResponseId,
redirection_data: Box::new(None),
mandate_reference: Box::new(Some(MandateReference {
connector_mandate_id: item
.response
.customer_payment_profile_id_list
.first()
.or(item.response.customer_payment_profile_id.as_ref())
.map(|payment_profile_id| {
format!("{connector_customer_id}-{payment_profile_id}")
}),
payment_method_id: None,
mandate_metadata: None,
connector_mandate_request_reference_id: None,
})),
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: None,
incremental_authorization_allowed: None,
charges: None,
}),
..item.data
})
} else {
let error_message = item.response.messages.message.first();
let error_code = error_message.map(|error| error.code.clone());
let error_code = error_code
.unwrap_or_else(|| hyperswitch_interfaces::consts::NO_ERROR_CODE.to_string());
let error_reason = item
.response
.messages
.message
.iter()
.map(|error: &ResponseMessage| error.text.clone())
.collect::<Vec<String>>()
.join(" ");
let response = Err(ErrorResponse {
code: error_code,
message: item.response.messages.result_code.to_string(),
reason: Some(error_reason),
status_code: item.http_code,
attempt_status: None,
connector_transaction_id: None,
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
connector_metadata: None,
});
Ok(Self {
response,
status: enums::AttemptStatus::Failure,
..item.data
})
}
}
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
// The connector enforces field ordering, it expects fields to be in the same order as in their API documentation
pub struct CreateTransactionRequest {
create_transaction_request: AuthorizedotnetPaymentsRequest,
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct CancelOrCaptureTransactionRequest {
create_transaction_request: AuthorizedotnetPaymentCancelOrCaptureRequest,
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "lowercase")]
pub enum AuthorizationType {
Final,
Pre,
}
impl TryFrom<enums::CaptureMethod> for AuthorizationType {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(capture_method: enums::CaptureMethod) -> Result<Self, Self::Error> {
match capture_method {
enums::CaptureMethod::Manual => Ok(Self::Pre),
enums::CaptureMethod::SequentialAutomatic | enums::CaptureMethod::Automatic => {
Ok(Self::Final)
}
enums::CaptureMethod::ManualMultiple | enums::CaptureMethod::Scheduled => Err(
utils::construct_not_supported_error_report(capture_method, "authorizedotnet"),
)?,
}
}
}
impl TryFrom<&AuthorizedotnetRouterData<&PaymentsAuthorizeRouterData>>
for CreateTransactionRequest
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: &AuthorizedotnetRouterData<&PaymentsAuthorizeRouterData>,
) -> Result<Self, Self::Error> {
let merchant_authentication =
AuthorizedotnetAuthType::try_from(&item.router_data.connector_auth_type)?;
let ref_id = if item.router_data.connector_request_reference_id.len() <= MAX_ID_LENGTH {
Some(item.router_data.connector_request_reference_id.clone())
} else {
None
};
let transaction_request = match item
.router_data
.request
.mandate_id
.clone()
.and_then(|mandate_ids| mandate_ids.mandate_reference_id)
{
Some(api_models::payments::MandateReferenceId::NetworkMandateId(network_trans_id)) => {
TransactionRequest::try_from((item, network_trans_id))?
}
Some(api_models::payments::MandateReferenceId::ConnectorMandateId(
connector_mandate_id,
)) => TransactionRequest::try_from((item, connector_mandate_id))?,
Some(api_models::payments::MandateReferenceId::NetworkTokenWithNTI(_)) => {
Err(errors::ConnectorError::NotImplemented(
utils::get_unimplemented_payment_method_error_message("authorizedotnet"),
))?
}
None => {
match &item.router_data.request.payment_method_data {
PaymentMethodData::Card(ccard) => TransactionRequest::try_from((item, ccard)),
PaymentMethodData::Wallet(wallet_data) => {
TransactionRequest::try_from((item, wallet_data))
}
PaymentMethodData::CardRedirect(_)
| PaymentMethodData::PayLater(_)
| PaymentMethodData::BankRedirect(_)
| PaymentMethodData::BankDebit(_)
| PaymentMethodData::BankTransfer(_)
| PaymentMethodData::Crypto(_)
| PaymentMethodData::MandatePayment
| PaymentMethodData::Reward
| PaymentMethodData::RealTimePayment(_)
| PaymentMethodData::MobilePayment(_)
| PaymentMethodData::Upi(_)
| PaymentMethodData::Voucher(_)
| PaymentMethodData::GiftCard(_)
| PaymentMethodData::OpenBanking(_)
| PaymentMethodData::CardToken(_)
| PaymentMethodData::NetworkToken(_)
| PaymentMethodData::CardDetailsForNetworkTransactionId(_) => {
Err(errors::ConnectorError::NotImplemented(
utils::get_unimplemented_payment_method_error_message(
"authorizedotnet",
),
))?
}
}
}?,
};
Ok(Self {
create_transaction_request: AuthorizedotnetPaymentsRequest {
merchant_authentication,
ref_id,
transaction_request,
},
})
}
}
impl
TryFrom<(
&AuthorizedotnetRouterData<&PaymentsAuthorizeRouterData>,
String,
)> for TransactionRequest
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
(item, network_trans_id): (
&AuthorizedotnetRouterData<&PaymentsAuthorizeRouterData>,
String,
),
) -> Result<Self, Self::Error> {
Ok(Self {
transaction_type: TransactionType::try_from(item.router_data.request.capture_method)?,
amount: item.amount,
currency_code: item.router_data.request.currency,
payment: Some(match item.router_data.request.payment_method_data {
PaymentMethodData::Card(ref ccard) => {
PaymentDetails::CreditCard(CreditCardDetails {
card_number: (*ccard.card_number).clone(),
expiration_date: ccard.get_expiry_date_as_yyyymm("-"),
card_code: None,
})
}
PaymentMethodData::CardRedirect(_)
| PaymentMethodData::Wallet(_)
| PaymentMethodData::PayLater(_)
| PaymentMethodData::BankRedirect(_)
| PaymentMethodData::BankDebit(_)
| PaymentMethodData::BankTransfer(_)
| PaymentMethodData::Crypto(_)
| PaymentMethodData::MandatePayment
| PaymentMethodData::Reward
| PaymentMethodData::RealTimePayment(_)
| PaymentMethodData::MobilePayment(_)
| PaymentMethodData::Upi(_)
| PaymentMethodData::Voucher(_)
| PaymentMethodData::GiftCard(_)
| PaymentMethodData::OpenBanking(_)
| PaymentMethodData::CardToken(_)
| PaymentMethodData::NetworkToken(_)
| PaymentMethodData::CardDetailsForNetworkTransactionId(_) => {
Err(errors::ConnectorError::NotImplemented(
utils::get_unimplemented_payment_method_error_message("authorizedotnet"),
))?
}
}),
profile: None,
order: Order {
invoice_number: match &item.router_data.request.merchant_order_reference_id {
Some(merchant_order_reference_id) => {
if merchant_order_reference_id.len() <= MAX_ID_LENGTH {
merchant_order_reference_id.to_string()
} else {
get_random_string()
}
}
None => get_random_string(),
},
description: item.router_data.connector_request_reference_id.clone(),
},
customer: Some(CustomerDetails {
id: if item.router_data.payment_id.len() <= MAX_ID_LENGTH {
item.router_data.payment_id.clone()
} else {
get_random_string()
},
email: item.router_data.request.get_optional_email(),
}),
bill_to: item
.router_data
.get_optional_billing()
.and_then(|billing_address| billing_address.address.as_ref())
.map(|address| BillTo {
first_name: address.first_name.clone(),
last_name: address.last_name.clone(),
address: address.line1.clone(),
city: address.city.clone(),
state: address.state.clone(),
zip: address.zip.clone(),
country: address.country,
}),
user_fields: match item.router_data.request.metadata.clone() {
Some(metadata) => Some(UserFields {
user_field: Vec::<UserField>::foreign_try_from(metadata)?,
}),
None => None,
},
processing_options: Some(ProcessingOptions {
is_subsequent_auth: true,
}),
subsequent_auth_information: Some(SubsequentAuthInformation {
original_network_trans_id: Secret::new(network_trans_id),
reason: Reason::Resubmission,
}),
authorization_indicator_type: match item.router_data.request.capture_method {
Some(capture_method) => Some(AuthorizationIndicator {
authorization_indicator: capture_method.try_into()?,
}),
None => None,
},
})
}
}
impl
TryFrom<(
&AuthorizedotnetRouterData<&PaymentsAuthorizeRouterData>,
api_models::payments::ConnectorMandateReferenceId,
)> for TransactionRequest
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
(item, connector_mandate_id): (
&AuthorizedotnetRouterData<&PaymentsAuthorizeRouterData>,
api_models::payments::ConnectorMandateReferenceId,
),
) -> Result<Self, Self::Error> {
let mandate_id = connector_mandate_id
.get_connector_mandate_id()
.ok_or(errors::ConnectorError::MissingConnectorMandateID)?;
Ok(Self {
transaction_type: TransactionType::try_from(item.router_data.request.capture_method)?,
amount: item.amount,
currency_code: item.router_data.request.currency,
payment: None,
profile: mandate_id
.split_once('-')
.map(|(customer_profile_id, payment_profile_id)| {
ProfileDetails::CustomerProfileDetails(CustomerProfileDetails {
customer_profile_id: Secret::from(customer_profile_id.to_string()),
payment_profile: PaymentProfileDetails {
payment_profile_id: Secret::from(payment_profile_id.to_string()),
},
})
}),
order: Order {
invoice_number: match &item.router_data.request.merchant_order_reference_id {
Some(merchant_order_reference_id) => {
if merchant_order_reference_id.len() <= MAX_ID_LENGTH {
merchant_order_reference_id.to_string()
} else {
get_random_string()
}
}
None => get_random_string(),
},
description: item.router_data.connector_request_reference_id.clone(),
},
customer: None,
bill_to: None,
user_fields: match item.router_data.request.metadata.clone() {
Some(metadata) => Some(UserFields {
user_field: Vec::<UserField>::foreign_try_from(metadata)?,
}),
None => None,
},
processing_options: Some(ProcessingOptions {
is_subsequent_auth: true,
}),
subsequent_auth_information: None,
authorization_indicator_type: match item.router_data.request.capture_method {
Some(capture_method) => Some(AuthorizationIndicator {
authorization_indicator: capture_method.try_into()?,
}),
None => None,
},
})
}
}
impl
TryFrom<(
&AuthorizedotnetRouterData<&PaymentsAuthorizeRouterData>,
&Card,
)> for TransactionRequest
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
(item, ccard): (
&AuthorizedotnetRouterData<&PaymentsAuthorizeRouterData>,
&Card,
),
) -> Result<Self, Self::Error> {
let profile = if item
.router_data
.request
.is_customer_initiated_mandate_payment()
{
let connector_customer_id =
Secret::new(item.router_data.connector_customer.clone().ok_or(
errors::ConnectorError::MissingConnectorRelatedTransactionID {
id: "connector_customer_id".to_string(),
},
)?);
Some(ProfileDetails::CreateProfileDetails(CreateProfileDetails {
create_profile: true,
customer_profile_id: Some(connector_customer_id),
}))
} else {
None
};
let customer = if !item
.router_data
.request
.is_customer_initiated_mandate_payment()
{
item.router_data.customer_id.as_ref().and_then(|customer| {
let customer_id = customer.get_string_repr();
(customer_id.len() <= MAX_ID_LENGTH).then_some(CustomerDetails {
id: customer_id.to_string(),
email: item.router_data.request.get_optional_email(),
})
})
} else {
None
};
Ok(Self {
transaction_type: TransactionType::try_from(item.router_data.request.capture_method)?,
amount: item.amount,
currency_code: item.router_data.request.currency,
payment: Some(PaymentDetails::CreditCard(CreditCardDetails {
card_number: (*ccard.card_number).clone(),
expiration_date: ccard.get_expiry_date_as_yyyymm("-"),
card_code: Some(ccard.card_cvc.clone()),
})),
profile,
order: Order {
invoice_number: match &item.router_data.request.merchant_order_reference_id {
Some(merchant_order_reference_id) => {
if merchant_order_reference_id.len() <= MAX_ID_LENGTH {
merchant_order_reference_id.to_string()
} else {
get_random_string()
}
}
None => get_random_string(),
},
description: item.router_data.connector_request_reference_id.clone(),
},
customer,
bill_to: item
.router_data
.get_optional_billing()
.and_then(|billing_address| billing_address.address.as_ref())
.map(|address| BillTo {
first_name: address.first_name.clone(),
last_name: address.last_name.clone(),
address: address.line1.clone(),
city: address.city.clone(),
state: address.state.clone(),
zip: address.zip.clone(),
country: address.country,
}),
user_fields: match item.router_data.request.metadata.clone() {
Some(metadata) => Some(UserFields {
user_field: Vec::<UserField>::foreign_try_from(metadata)?,
}),
None => None,
},
processing_options: None,
subsequent_auth_information: None,
authorization_indicator_type: match item.router_data.request.capture_method {
Some(capture_method) => Some(AuthorizationIndicator {
authorization_indicator: capture_method.try_into()?,
}),
None => None,
},
})
}
}
impl
TryFrom<(
&AuthorizedotnetRouterData<&PaymentsAuthorizeRouterData>,
&WalletData,
)> for TransactionRequest
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
(item, wallet_data): (
&AuthorizedotnetRouterData<&PaymentsAuthorizeRouterData>,
&WalletData,
),
) -> Result<Self, Self::Error> {
let profile = if item
.router_data
.request
.is_customer_initiated_mandate_payment()
{
let connector_customer_id =
Secret::new(item.router_data.connector_customer.clone().ok_or(
errors::ConnectorError::MissingConnectorRelatedTransactionID {
id: "connector_customer_id".to_string(),
},
)?);
Some(ProfileDetails::CreateProfileDetails(CreateProfileDetails {
create_profile: true,
customer_profile_id: Some(connector_customer_id),
}))
} else {
None
};
let customer = if !item
.router_data
.request
.is_customer_initiated_mandate_payment()
{
item.router_data.customer_id.as_ref().and_then(|customer| {
let customer_id = customer.get_string_repr();
(customer_id.len() <= MAX_ID_LENGTH).then_some(CustomerDetails {
id: customer_id.to_string(),
email: item.router_data.request.get_optional_email(),
})
})
} else {
None
};
Ok(Self {
transaction_type: TransactionType::try_from(item.router_data.request.capture_method)?,
amount: item.amount,
currency_code: item.router_data.request.currency,
payment: Some(get_wallet_data(
wallet_data,
&item.router_data.request.complete_authorize_url,
)?),
profile,
order: Order {
invoice_number: match &item.router_data.request.merchant_order_reference_id {
Some(merchant_order_reference_id) => {
if merchant_order_reference_id.len() <= MAX_ID_LENGTH {
merchant_order_reference_id.to_string()
} else {
get_random_string()
}
}
None => get_random_string(),
},
description: item.router_data.connector_request_reference_id.clone(),
},
customer,
bill_to: item
.router_data
.get_optional_billing()
.and_then(|billing_address| billing_address.address.as_ref())
.map(|address| BillTo {
first_name: address.first_name.clone(),
last_name: address.last_name.clone(),
address: address.line1.clone(),
city: address.city.clone(),
state: address.state.clone(),
zip: address.zip.clone(),
country: address.country,
}),
user_fields: match item.router_data.request.metadata.clone() {
Some(metadata) => Some(UserFields {
user_field: Vec::<UserField>::foreign_try_from(metadata)?,
}),
None => None,
},
processing_options: None,
subsequent_auth_information: None,
authorization_indicator_type: match item.router_data.request.capture_method {
Some(capture_method) => Some(AuthorizationIndicator {
authorization_indicator: capture_method.try_into()?,
}),
None => None,
},
})
}
}
impl TryFrom<&PaymentsCancelRouterData> for CancelOrCaptureTransactionRequest {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(item: &PaymentsCancelRouterData) -> Result<Self, Self::Error> {
let transaction_request = TransactionVoidOrCaptureRequest {
amount: None, //amount is not required for void
transaction_type: TransactionType::Void,
ref_trans_id: item.request.connector_transaction_id.to_string(),
};
let merchant_authentication = AuthorizedotnetAuthType::try_from(&item.connector_auth_type)?;
Ok(Self {
create_transaction_request: AuthorizedotnetPaymentCancelOrCaptureRequest {
merchant_authentication,
transaction_request,
},
})
}
}
impl TryFrom<&AuthorizedotnetRouterData<&PaymentsCaptureRouterData>>
for CancelOrCaptureTransactionRequest
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: &AuthorizedotnetRouterData<&PaymentsCaptureRouterData>,
) -> Result<Self, Self::Error> {
let transaction_request = TransactionVoidOrCaptureRequest {
amount: Some(item.amount),
transaction_type: TransactionType::Capture,
ref_trans_id: item
.router_data
.request
.connector_transaction_id
.to_string(),
};
let merchant_authentication =
AuthorizedotnetAuthType::try_from(&item.router_data.connector_auth_type)?;
Ok(Self {
create_transaction_request: AuthorizedotnetPaymentCancelOrCaptureRequest {
merchant_authentication,
transaction_request,
},
})
}
}
#[derive(Debug, Clone, Default, serde::Deserialize, serde::Serialize)]
pub enum AuthorizedotnetPaymentStatus {
#[serde(rename = "1")]
Approved,
#[serde(rename = "2")]
Declined,
#[serde(rename = "3")]
Error,
#[serde(rename = "4")]
#[default]
HeldForReview,
#[serde(rename = "5")]
RequiresAction,
}
#[derive(Debug, Clone, serde::Deserialize, Serialize)]
pub enum AuthorizedotnetRefundStatus {
#[serde(rename = "1")]
Approved,
#[serde(rename = "2")]
Declined,
#[serde(rename = "3")]
Error,
#[serde(rename = "4")]
HeldForReview,
}
fn get_payment_status(
(item, auto_capture): (AuthorizedotnetPaymentStatus, bool),
) -> enums::AttemptStatus {
match item {
AuthorizedotnetPaymentStatus::Approved => {
if auto_capture {
enums::AttemptStatus::Charged
} else {
enums::AttemptStatus::Authorized
}
}
AuthorizedotnetPaymentStatus::Declined | AuthorizedotnetPaymentStatus::Error => {
enums::AttemptStatus::Failure
}
AuthorizedotnetPaymentStatus::RequiresAction => enums::AttemptStatus::AuthenticationPending,
AuthorizedotnetPaymentStatus::HeldForReview => enums::AttemptStatus::Pending,
}
}
#[derive(Debug, Default, Clone, Deserialize, PartialEq, Serialize)]
pub struct ResponseMessage {
code: String,
pub text: String,
}
#[derive(Debug, Default, Clone, Deserialize, PartialEq, Serialize, strum::Display)]
enum ResultCode {
#[default]
Ok,
Error,
}
#[derive(Debug, Default, Clone, Deserialize, PartialEq, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ResponseMessages {
result_code: ResultCode,
pub message: Vec<ResponseMessage>,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ErrorMessage {
pub error_code: String,
pub error_text: String,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(untagged)]
pub enum TransactionResponse {
AuthorizedotnetTransactionResponse(Box<AuthorizedotnetTransactionResponse>),
AuthorizedotnetTransactionResponseError(Box<AuthorizedotnetTransactionResponseError>),
}
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(rename_all = "PascalCase")]
pub struct AuthorizedotnetTransactionResponseError {
_supplemental_data_qualification_indicator: i64,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct AuthorizedotnetTransactionResponse {
response_code: AuthorizedotnetPaymentStatus,
#[serde(rename = "transId")]
transaction_id: String,
network_trans_id: Option<Secret<String>>,
pub(super) account_number: Option<Secret<String>>,
pub(super) errors: Option<Vec<ErrorMessage>>,
secure_acceptance: Option<SecureAcceptance>,
avs_result_code: Option<String>,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct RefundResponse {
response_code: AuthorizedotnetRefundStatus,
#[serde(rename = "transId")]
transaction_id: String,
#[allow(dead_code)]
network_trans_id: Option<Secret<String>>,
pub account_number: Option<Secret<String>>,
pub errors: Option<Vec<ErrorMessage>>,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(rename_all = "PascalCase")]
pub struct SecureAcceptance {
secure_acceptance_url: Option<url::Url>,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct AuthorizedotnetPaymentsResponse {
pub transaction_response: Option<TransactionResponse>,
pub profile_response: Option<AuthorizedotnetNonZeroMandateResponse>,
pub messages: ResponseMessages,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct AuthorizedotnetNonZeroMandateResponse {
customer_profile_id: Option<String>,
customer_payment_profile_id_list: Option<Vec<String>>,
pub messages: ResponseMessages,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct AuthorizedotnetVoidResponse {
pub transaction_response: Option<VoidResponse>,
pub messages: ResponseMessages,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct VoidResponse {
response_code: AuthorizedotnetVoidStatus,
#[serde(rename = "transId")]
transaction_id: String,
network_trans_id: Option<Secret<String>>,
pub account_number: Option<Secret<String>>,
pub errors: Option<Vec<ErrorMessage>>,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub enum AuthorizedotnetVoidStatus {
#[serde(rename = "1")]
Approved,
#[serde(rename = "2")]
Declined,
#[serde(rename = "3")]
Error,
#[serde(rename = "4")]
HeldForReview,
}
impl From<AuthorizedotnetVoidStatus> for enums::AttemptStatus {
fn from(item: AuthorizedotnetVoidStatus) -> Self {
match item {
AuthorizedotnetVoidStatus::Approved => Self::Voided,
AuthorizedotnetVoidStatus::Declined | AuthorizedotnetVoidStatus::Error => {
Self::VoidFailed
}
AuthorizedotnetVoidStatus::HeldForReview => Self::VoidInitiated,
}
}
}
fn get_avs_response_description(code: &str) -> Option<&'static str> {
match code {
"A" => Some("The street address matched, but the postal code did not."),
"B" => Some("No address information was provided."),
"E" => Some(
"AVS data provided is invalid or AVS is not allowed for the card type that was used.",
),
"G" => Some("The card was issued by a bank outside the U.S. and does not support AVS."),
"N" => Some("Neither the street address nor postal code matched."),
"P" => Some("AVS is not applicable for this transaction."),
"R" => Some("Retry — AVS was unavailable or timed out."),
"S" => Some("AVS is not supported by card issuer."),
"U" => Some("Address information is unavailable."),
"W" => Some("The US ZIP+4 code matches, but the street address does not."),
"X" => Some("Both the street address and the US ZIP+4 code matched."),
"Y" => Some("The street address and postal code matched."),
"Z" => Some("The postal code matched, but the street address did not."),
_ => None,
}
}
fn convert_to_additional_payment_method_connector_response(
transaction_response: &AuthorizedotnetTransactionResponse,
) -> Option<AdditionalPaymentMethodConnectorResponse> {
match transaction_response.avs_result_code.as_deref() {
Some("P") | None => None,
Some(code) => {
let description = get_avs_response_description(code);
let payment_checks = serde_json::json!({
"avs_result_code": code,
"description": description
});
Some(AdditionalPaymentMethodConnectorResponse::Card {
authentication_data: None,
payment_checks: Some(payment_checks),
card_network: None,
domestic_network: None,
})
}
}
}
impl<F, T>
ForeignTryFrom<(
ResponseRouterData<F, AuthorizedotnetPaymentsResponse, T, PaymentsResponseData>,
bool,
)> for RouterData<F, T, PaymentsResponseData>
{
type Error = error_stack::Report<errors::ConnectorError>;
fn foreign_try_from(
(item, is_auto_capture): (
ResponseRouterData<F, AuthorizedotnetPaymentsResponse, T, PaymentsResponseData>,
bool,
),
) -> Result<Self, Self::Error> {
match &item.response.transaction_response {
Some(TransactionResponse::AuthorizedotnetTransactionResponse(transaction_response)) => {
let status = get_payment_status((
transaction_response.response_code.clone(),
is_auto_capture,
));
let error = transaction_response.errors.as_ref().and_then(|errors| {
errors.iter().next().map(|error| ErrorResponse {
code: error.error_code.clone(),
message: error.error_text.clone(),
reason: Some(error.error_text.clone()),
status_code: item.http_code,
attempt_status: None,
connector_transaction_id: Some(transaction_response.transaction_id.clone()),
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
connector_metadata: None,
})
});
let metadata = transaction_response
.account_number
.as_ref()
.map(|acc_no| {
construct_refund_payment_details(PaymentDetailAccountNumber::Masked(
acc_no.clone().expose(),
))
.encode_to_value()
})
.transpose()
.change_context(errors::ConnectorError::MissingRequiredField {
field_name: "connector_metadata",
})?;
let connector_response_data =
convert_to_additional_payment_method_connector_response(transaction_response)
.map(ConnectorResponseData::with_additional_payment_method_data);
let url = transaction_response
.secure_acceptance
.as_ref()
.and_then(|x| x.secure_acceptance_url.to_owned());
let redirection_data = url.map(|url| RedirectForm::from((url, Method::Get)));
let mandate_reference = item.response.profile_response.map(|profile_response| {
let payment_profile_id = profile_response
.customer_payment_profile_id_list
.and_then(|customer_payment_profile_id_list| {
customer_payment_profile_id_list.first().cloned()
});
MandateReference {
connector_mandate_id: profile_response.customer_profile_id.and_then(
|customer_profile_id| {
payment_profile_id.map(|payment_profile_id| {
format!("{customer_profile_id}-{payment_profile_id}")
})
},
),
payment_method_id: None,
mandate_metadata: None,
connector_mandate_request_reference_id: None,
}
});
Ok(Self {
status,
response: match error {
Some(err) => Err(err),
None => Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(
transaction_response.transaction_id.clone(),
),
redirection_data: Box::new(redirection_data),
mandate_reference: Box::new(mandate_reference),
connector_metadata: metadata,
network_txn_id: transaction_response
.network_trans_id
.clone()
.map(|network_trans_id| network_trans_id.expose()),
connector_response_reference_id: Some(
transaction_response.transaction_id.clone(),
),
incremental_authorization_allowed: None,
charges: None,
}),
},
connector_response: connector_response_data,
..item.data
})
}
Some(TransactionResponse::AuthorizedotnetTransactionResponseError(_)) | None => {
Ok(Self {
status: enums::AttemptStatus::Failure,
response: Err(get_err_response(item.http_code, item.response.messages)?),
..item.data
})
}
}
}
}
impl<F, T> TryFrom<ResponseRouterData<F, AuthorizedotnetVoidResponse, T, PaymentsResponseData>>
for RouterData<F, T, PaymentsResponseData>
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: ResponseRouterData<F, AuthorizedotnetVoidResponse, T, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
match &item.response.transaction_response {
Some(transaction_response) => {
let status = enums::AttemptStatus::from(transaction_response.response_code.clone());
let error = transaction_response.errors.as_ref().and_then(|errors| {
errors.iter().next().map(|error| ErrorResponse {
code: error.error_code.clone(),
message: error.error_text.clone(),
reason: Some(error.error_text.clone()),
status_code: item.http_code,
attempt_status: None,
connector_transaction_id: Some(transaction_response.transaction_id.clone()),
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
connector_metadata: None,
})
});
let metadata = transaction_response
.account_number
.as_ref()
.map(|acc_no| {
construct_refund_payment_details(PaymentDetailAccountNumber::Masked(
acc_no.clone().expose(),
))
.encode_to_value()
})
.transpose()
.change_context(errors::ConnectorError::MissingRequiredField {
field_name: "connector_metadata",
})?;
Ok(Self {
status,
response: match error {
Some(err) => Err(err),
None => Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(
transaction_response.transaction_id.clone(),
),
redirection_data: Box::new(None),
mandate_reference: Box::new(None),
connector_metadata: metadata,
network_txn_id: transaction_response
.network_trans_id
.clone()
.map(|network_trans_id| network_trans_id.expose()),
connector_response_reference_id: Some(
transaction_response.transaction_id.clone(),
),
incremental_authorization_allowed: None,
charges: None,
}),
},
..item.data
})
}
None => Ok(Self {
status: enums::AttemptStatus::Failure,
response: Err(get_err_response(item.http_code, item.response.messages)?),
..item.data
}),
}
}
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
struct RefundTransactionRequest {
transaction_type: TransactionType,
amount: FloatMajorUnit,
currency_code: String,
payment: PaymentDetails,
#[serde(rename = "refTransId")]
reference_transaction_id: String,
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct AuthorizedotnetRefundRequest {
merchant_authentication: AuthorizedotnetAuthType,
transaction_request: RefundTransactionRequest,
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
// The connector enforces field ordering, it expects fields to be in the same order as in their API documentation
pub struct CreateRefundRequest {
create_transaction_request: AuthorizedotnetRefundRequest,
}
impl<F> TryFrom<&AuthorizedotnetRouterData<&RefundsRouterData<F>>> for CreateRefundRequest {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: &AuthorizedotnetRouterData<&RefundsRouterData<F>>,
) -> Result<Self, Self::Error> {
let merchant_authentication =
AuthorizedotnetAuthType::try_from(&item.router_data.connector_auth_type)?;
let transaction_request = RefundTransactionRequest {
transaction_type: TransactionType::Refund,
amount: item.amount,
payment: get_refund_metadata(
&item.router_data.request.connector_metadata,
&item.router_data.request.additional_payment_method_data,
)?,
currency_code: item.router_data.request.currency.to_string(),
reference_transaction_id: item.router_data.request.connector_transaction_id.clone(),
};
Ok(Self {
create_transaction_request: AuthorizedotnetRefundRequest {
merchant_authentication,
transaction_request,
},
})
}
}
fn get_refund_metadata(
connector_metadata: &Option<Value>,
additional_payment_method: &Option<AdditionalPaymentData>,
) -> Result<PaymentDetails, error_stack::Report<errors::ConnectorError>> {
let payment_details_from_metadata = connector_metadata
.as_ref()
.get_required_value("connector_metadata")
.ok()
.and_then(|value| {
value
.clone()
.parse_value::<PaymentDetails>("PaymentDetails")
.ok()
});
let payment_details_from_additional_payment_method = match additional_payment_method {
Some(AdditionalPaymentData::Card(additional_card_info)) => {
additional_card_info.last4.clone().map(|last4| {
construct_refund_payment_details(PaymentDetailAccountNumber::UnMasked(
last4.to_string(),
))
})
}
_ => None,
};
match (
payment_details_from_metadata,
payment_details_from_additional_payment_method,
) {
(Some(payment_detail), _) => Ok(payment_detail),
(_, Some(payment_detail)) => Ok(payment_detail),
(None, None) => Err(errors::ConnectorError::MissingRequiredField {
field_name: "payment_details",
}
.into()),
}
}
impl From<AuthorizedotnetRefundStatus> for enums::RefundStatus {
fn from(item: AuthorizedotnetRefundStatus) -> Self {
match item {
AuthorizedotnetRefundStatus::Declined | AuthorizedotnetRefundStatus::Error => {
Self::Failure
}
AuthorizedotnetRefundStatus::Approved | AuthorizedotnetRefundStatus::HeldForReview => {
Self::Pending
}
}
}
}
#[derive(Debug, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct AuthorizedotnetRefundResponse {
pub transaction_response: RefundResponse,
pub messages: ResponseMessages,
}
impl<F> TryFrom<RefundsResponseRouterData<F, AuthorizedotnetRefundResponse>>
for RefundsRouterData<F>
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: RefundsResponseRouterData<F, AuthorizedotnetRefundResponse>,
) -> Result<Self, Self::Error> {
let transaction_response = &item.response.transaction_response;
let refund_status = enums::RefundStatus::from(transaction_response.response_code.clone());
let error = transaction_response.errors.clone().and_then(|errors| {
errors.first().map(|error| ErrorResponse {
code: error.error_code.clone(),
message: error.error_text.clone(),
reason: Some(error.error_text.clone()),
status_code: item.http_code,
attempt_status: None,
connector_transaction_id: Some(transaction_response.transaction_id.clone()),
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
connector_metadata: None,
})
});
Ok(Self {
response: match error {
Some(err) => Err(err),
None => Ok(RefundsResponseData {
connector_refund_id: transaction_response.transaction_id.clone(),
refund_status,
}),
},
..item.data
})
}
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct TransactionDetails {
merchant_authentication: AuthorizedotnetAuthType,
#[serde(rename = "transId")]
transaction_id: Option<String>,
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct AuthorizedotnetCreateSyncRequest {
get_transaction_details_request: TransactionDetails,
}
impl<F> TryFrom<&AuthorizedotnetRouterData<&RefundsRouterData<F>>>
for AuthorizedotnetCreateSyncRequest
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: &AuthorizedotnetRouterData<&RefundsRouterData<F>>,
) -> Result<Self, Self::Error> {
let transaction_id = item.router_data.request.get_connector_refund_id()?;
let merchant_authentication =
AuthorizedotnetAuthType::try_from(&item.router_data.connector_auth_type)?;
let payload = Self {
get_transaction_details_request: TransactionDetails {
merchant_authentication,
transaction_id: Some(transaction_id),
},
};
Ok(payload)
}
}
impl TryFrom<&PaymentsSyncRouterData> for AuthorizedotnetCreateSyncRequest {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(item: &PaymentsSyncRouterData) -> Result<Self, Self::Error> {
let transaction_id = Some(
item.request
.get_connector_transaction_id()
.change_context(errors::ConnectorError::MissingConnectorTransactionID)?,
);
let merchant_authentication = AuthorizedotnetAuthType::try_from(&item.connector_auth_type)?;
let payload = Self {
get_transaction_details_request: TransactionDetails {
merchant_authentication,
transaction_id,
},
};
Ok(payload)
}
}
#[derive(Debug, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub enum SyncStatus {
RefundSettledSuccessfully,
RefundPendingSettlement,
AuthorizedPendingCapture,
CapturedPendingSettlement,
SettledSuccessfully,
Declined,
Voided,
CouldNotVoid,
GeneralError,
#[serde(rename = "FDSPendingReview")]
FDSPendingReview,
}
#[derive(Debug, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub enum RSyncStatus {
RefundSettledSuccessfully,
RefundPendingSettlement,
Declined,
GeneralError,
Voided,
}
#[derive(Debug, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct SyncTransactionResponse {
#[serde(rename = "transId")]
transaction_id: String,
transaction_status: SyncStatus,
}
#[derive(Debug, Deserialize, Serialize)]
pub struct AuthorizedotnetSyncResponse {
transaction: Option<SyncTransactionResponse>,
messages: ResponseMessages,
}
#[derive(Debug, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct RSyncTransactionResponse {
#[serde(rename = "transId")]
transaction_id: String,
transaction_status: RSyncStatus,
}
#[derive(Debug, Deserialize, Serialize)]
pub struct AuthorizedotnetRSyncResponse {
transaction: Option<RSyncTransactionResponse>,
messages: ResponseMessages,
}
impl From<SyncStatus> for enums::AttemptStatus {
fn from(transaction_status: SyncStatus) -> Self {
match transaction_status {
SyncStatus::SettledSuccessfully | SyncStatus::CapturedPendingSettlement => {
Self::Charged
}
SyncStatus::AuthorizedPendingCapture => Self::Authorized,
SyncStatus::Declined => Self::AuthenticationFailed,
SyncStatus::Voided => Self::Voided,
SyncStatus::CouldNotVoid => Self::VoidFailed,
SyncStatus::GeneralError => Self::Failure,
SyncStatus::RefundSettledSuccessfully
| SyncStatus::RefundPendingSettlement
| SyncStatus::FDSPendingReview => Self::Pending,
}
}
}
impl From<RSyncStatus> for enums::RefundStatus {
fn from(transaction_status: RSyncStatus) -> Self {
match transaction_status {
RSyncStatus::RefundSettledSuccessfully => Self::Success,
RSyncStatus::RefundPendingSettlement => Self::Pending,
RSyncStatus::Declined | RSyncStatus::GeneralError | RSyncStatus::Voided => {
Self::Failure
}
}
}
}
impl TryFrom<RefundsResponseRouterData<RSync, AuthorizedotnetRSyncResponse>>
for RefundsRouterData<RSync>
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: RefundsResponseRouterData<RSync, AuthorizedotnetRSyncResponse>,
) -> Result<Self, Self::Error> {
match item.response.transaction {
Some(transaction) => {
let refund_status = enums::RefundStatus::from(transaction.transaction_status);
Ok(Self {
response: Ok(RefundsResponseData {
connector_refund_id: transaction.transaction_id,
refund_status,
}),
..item.data
})
}
None => Ok(Self {
response: Err(get_err_response(item.http_code, item.response.messages)?),
..item.data
}),
}
}
}
impl<F, Req> TryFrom<ResponseRouterData<F, AuthorizedotnetSyncResponse, Req, PaymentsResponseData>>
for RouterData<F, Req, PaymentsResponseData>
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: ResponseRouterData<F, AuthorizedotnetSyncResponse, Req, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
match item.response.transaction {
Some(transaction) => {
let payment_status = enums::AttemptStatus::from(transaction.transaction_status);
Ok(Self {
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(
transaction.transaction_id.clone(),
),
redirection_data: Box::new(None),
mandate_reference: Box::new(None),
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: Some(transaction.transaction_id.clone()),
incremental_authorization_allowed: None,
charges: None,
}),
status: payment_status,
..item.data
})
}
// E00053 indicates "server too busy"
// If the server is too busy, we return the already available data
None => match item
.response
.messages
.message
.iter()
.find(|msg| msg.code == "E00053")
{
Some(_) => Ok(item.data),
None => Ok(Self {
response: Err(get_err_response(item.http_code, item.response.messages)?),
..item.data
}),
},
}
}
}
#[derive(Debug, Default, Deserialize, Serialize)]
pub struct ErrorDetails {
pub code: Option<String>,
#[serde(rename = "type")]
pub error_type: Option<String>,
pub message: Option<String>,
pub param: Option<String>,
}
#[derive(Default, Debug, Deserialize, Serialize)]
pub struct AuthorizedotnetErrorResponse {
pub error: ErrorDetails,
}
enum PaymentDetailAccountNumber {
Masked(String),
UnMasked(String),
}
fn construct_refund_payment_details(detail: PaymentDetailAccountNumber) -> PaymentDetails {
PaymentDetails::CreditCard(CreditCardDetails {
card_number: match detail {
PaymentDetailAccountNumber::Masked(masked) => masked.into(),
PaymentDetailAccountNumber::UnMasked(unmasked) => format!("XXXX{:}", unmasked).into(),
},
expiration_date: "XXXX".to_string().into(),
card_code: None,
})
}
impl TryFrom<Option<enums::CaptureMethod>> for TransactionType {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(capture_method: Option<enums::CaptureMethod>) -> Result<Self, Self::Error> {
match capture_method {
Some(enums::CaptureMethod::Manual) => Ok(Self::Authorization),
Some(enums::CaptureMethod::SequentialAutomatic)
| Some(enums::CaptureMethod::Automatic)
| None => Ok(Self::Payment),
Some(enums::CaptureMethod::ManualMultiple) => {
Err(utils::construct_not_supported_error_report(
enums::CaptureMethod::ManualMultiple,
"authorizedotnet",
))?
}
Some(enums::CaptureMethod::Scheduled) => {
Err(utils::construct_not_supported_error_report(
enums::CaptureMethod::Scheduled,
"authorizedotnet",
))?
}
}
}
}
fn get_err_response(
status_code: u16,
message: ResponseMessages,
) -> Result<ErrorResponse, errors::ConnectorError> {
let response_message = message
.message
.first()
.ok_or(errors::ConnectorError::ResponseDeserializationFailed)?;
Ok(ErrorResponse {
code: response_message.code.clone(),
message: response_message.text.clone(),
reason: Some(response_message.text.clone()),
status_code,
attempt_status: None,
connector_transaction_id: None,
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
connector_metadata: None,
})
}
#[derive(Debug, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct AuthorizedotnetWebhookObjectId {
pub webhook_id: String,
pub event_type: AuthorizedotnetWebhookEvent,
pub payload: AuthorizedotnetWebhookPayload,
}
#[derive(Debug, Deserialize)]
pub struct AuthorizedotnetWebhookPayload {
pub id: Option<String>,
}
#[derive(Debug, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct AuthorizedotnetWebhookEventType {
pub event_type: AuthorizedotnetIncomingWebhookEventType,
}
#[derive(Debug, Deserialize)]
pub enum AuthorizedotnetWebhookEvent {
#[serde(rename = "net.authorize.payment.authorization.created")]
AuthorizationCreated,
#[serde(rename = "net.authorize.payment.priorAuthCapture.created")]
PriorAuthCapture,
#[serde(rename = "net.authorize.payment.authcapture.created")]
AuthCapCreated,
#[serde(rename = "net.authorize.payment.capture.created")]
CaptureCreated,
#[serde(rename = "net.authorize.payment.void.created")]
VoidCreated,
#[serde(rename = "net.authorize.payment.refund.created")]
RefundCreated,
}
///Including Unknown to map unknown webhook events
#[derive(Debug, Deserialize)]
pub enum AuthorizedotnetIncomingWebhookEventType {
#[serde(rename = "net.authorize.payment.authorization.created")]
AuthorizationCreated,
#[serde(rename = "net.authorize.payment.priorAuthCapture.created")]
PriorAuthCapture,
#[serde(rename = "net.authorize.payment.authcapture.created")]
AuthCapCreated,
#[serde(rename = "net.authorize.payment.capture.created")]
CaptureCreated,
#[serde(rename = "net.authorize.payment.void.created")]
VoidCreated,
#[serde(rename = "net.authorize.payment.refund.created")]
RefundCreated,
#[serde(other)]
Unknown,
}
impl From<AuthorizedotnetIncomingWebhookEventType> for IncomingWebhookEvent {
fn from(event_type: AuthorizedotnetIncomingWebhookEventType) -> Self {
match event_type {
AuthorizedotnetIncomingWebhookEventType::AuthorizationCreated
| AuthorizedotnetIncomingWebhookEventType::PriorAuthCapture
| AuthorizedotnetIncomingWebhookEventType::AuthCapCreated
| AuthorizedotnetIncomingWebhookEventType::CaptureCreated
| AuthorizedotnetIncomingWebhookEventType::VoidCreated => Self::PaymentIntentSuccess,
AuthorizedotnetIncomingWebhookEventType::RefundCreated => Self::RefundSuccess,
AuthorizedotnetIncomingWebhookEventType::Unknown => Self::EventNotSupported,
}
}
}
impl From<AuthorizedotnetWebhookEvent> for SyncStatus {
// status mapping reference https://developer.authorize.net/api/reference/features/webhooks.html#Event_Types_and_Payloads
fn from(event_type: AuthorizedotnetWebhookEvent) -> Self {
match event_type {
AuthorizedotnetWebhookEvent::AuthorizationCreated => Self::AuthorizedPendingCapture,
AuthorizedotnetWebhookEvent::CaptureCreated
| AuthorizedotnetWebhookEvent::AuthCapCreated => Self::CapturedPendingSettlement,
AuthorizedotnetWebhookEvent::PriorAuthCapture => Self::SettledSuccessfully,
AuthorizedotnetWebhookEvent::VoidCreated => Self::Voided,
AuthorizedotnetWebhookEvent::RefundCreated => Self::RefundSettledSuccessfully,
}
}
}
pub fn get_trans_id(
details: &AuthorizedotnetWebhookObjectId,
) -> Result<String, errors::ConnectorError> {
details
.payload
.id
.clone()
.ok_or(errors::ConnectorError::WebhookReferenceIdNotFound)
}
impl TryFrom<AuthorizedotnetWebhookObjectId> for AuthorizedotnetSyncResponse {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(item: AuthorizedotnetWebhookObjectId) -> Result<Self, Self::Error> {
Ok(Self {
transaction: Some(SyncTransactionResponse {
transaction_id: get_trans_id(&item)?,
transaction_status: SyncStatus::from(item.event_type),
}),
messages: ResponseMessages {
..Default::default()
},
})
}
}
fn get_wallet_data(
wallet_data: &WalletData,
return_url: &Option<String>,
) -> CustomResult<PaymentDetails, errors::ConnectorError> {
match wallet_data {
WalletData::GooglePay(_) => Ok(PaymentDetails::OpaqueData(WalletDetails {
data_descriptor: WalletMethod::Googlepay,
data_value: Secret::new(wallet_data.get_encoded_wallet_token()?),
})),
WalletData::ApplePay(applepay_token) => {
let apple_pay_encrypted_data = applepay_token
.payment_data
.get_encrypted_apple_pay_payment_data_mandatory()
.change_context(errors::ConnectorError::MissingRequiredField {
field_name: "Apple pay encrypted data",
})?;
Ok(PaymentDetails::OpaqueData(WalletDetails {
data_descriptor: WalletMethod::Applepay,
data_value: Secret::new(apple_pay_encrypted_data.clone()),
}))
}
WalletData::PaypalRedirect(_) => Ok(PaymentDetails::PayPal(PayPalDetails {
success_url: return_url.to_owned(),
cancel_url: return_url.to_owned(),
})),
WalletData::AliPayQr(_)
| WalletData::AliPayRedirect(_)
| WalletData::AliPayHkRedirect(_)
| WalletData::AmazonPay(_)
| WalletData::AmazonPayRedirect(_)
| WalletData::Paysera(_)
| WalletData::Skrill(_)
| WalletData::BluecodeRedirect {}
| WalletData::MomoRedirect(_)
| WalletData::KakaoPayRedirect(_)
| WalletData::GoPayRedirect(_)
| WalletData::GcashRedirect(_)
| WalletData::ApplePayRedirect(_)
| WalletData::ApplePayThirdPartySdk(_)
| WalletData::DanaRedirect {}
| WalletData::GooglePayRedirect(_)
| WalletData::GooglePayThirdPartySdk(_)
| WalletData::MbWayRedirect(_)
| WalletData::MobilePayRedirect(_)
| WalletData::PaypalSdk(_)
| WalletData::Paze(_)
| WalletData::SamsungPay(_)
| WalletData::TwintRedirect {}
| WalletData::VippsRedirect {}
| WalletData::TouchNGoRedirect(_)
| WalletData::WeChatPayRedirect(_)
| WalletData::WeChatPayQr(_)
| WalletData::CashappQr(_)
| WalletData::SwishQr(_)
| WalletData::Mifinity(_)
| WalletData::RevolutPay(_) => Err(errors::ConnectorError::NotImplemented(
utils::get_unimplemented_payment_method_error_message("authorizedotnet"),
))?,
}
}
#[derive(Debug, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct AuthorizedotnetQueryParams {
payer_id: String,
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct PaypalConfirmRequest {
create_transaction_request: PaypalConfirmTransactionRequest,
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct PaypalConfirmTransactionRequest {
merchant_authentication: AuthorizedotnetAuthType,
transaction_request: TransactionConfirmRequest,
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct TransactionConfirmRequest {
transaction_type: TransactionType,
payment: PaypalPaymentConfirm,
ref_trans_id: Option<String>,
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct PaypalPaymentConfirm {
pay_pal: Paypal,
}
#[derive(Debug, Serialize, Deserialize)]
pub struct Paypal {
#[serde(rename = "payerID")]
payer_id: Option<Secret<String>>,
}
#[derive(Debug, Serialize, Deserialize)]
pub struct PaypalQueryParams {
#[serde(rename = "PayerID")]
payer_id: Option<Secret<String>>,
}
impl TryFrom<&AuthorizedotnetRouterData<&PaymentsCompleteAuthorizeRouterData>>
for PaypalConfirmRequest
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: &AuthorizedotnetRouterData<&PaymentsCompleteAuthorizeRouterData>,
) -> Result<Self, Self::Error> {
let params = item
.router_data
.request
.redirect_response
.as_ref()
.and_then(|redirect_response| redirect_response.params.as_ref())
.ok_or(errors::ConnectorError::ResponseDeserializationFailed)?;
let query_params: PaypalQueryParams = serde_urlencoded::from_str(params.peek())
.change_context(errors::ConnectorError::ResponseDeserializationFailed)
.attach_printable("Failed to parse connector response")?;
let payer_id = query_params.payer_id;
let transaction_type = match item.router_data.request.capture_method {
Some(enums::CaptureMethod::Manual) => Ok(TransactionType::ContinueAuthorization),
Some(enums::CaptureMethod::SequentialAutomatic)
| Some(enums::CaptureMethod::Automatic)
| None => Ok(TransactionType::ContinueCapture),
Some(enums::CaptureMethod::ManualMultiple) => {
Err(errors::ConnectorError::NotSupported {
message: enums::CaptureMethod::ManualMultiple.to_string(),
connector: "authorizedotnet",
})
}
Some(enums::CaptureMethod::Scheduled) => Err(errors::ConnectorError::NotSupported {
message: enums::CaptureMethod::Scheduled.to_string(),
connector: "authorizedotnet",
}),
}?;
let transaction_request = TransactionConfirmRequest {
transaction_type,
payment: PaypalPaymentConfirm {
pay_pal: Paypal { payer_id },
},
ref_trans_id: item.router_data.request.connector_transaction_id.clone(),
};
let merchant_authentication =
AuthorizedotnetAuthType::try_from(&item.router_data.connector_auth_type)?;
Ok(Self {
create_transaction_request: PaypalConfirmTransactionRequest {
merchant_authentication,
transaction_request,
},
})
}
}
|
{
"crate": "hyperswitch_connectors",
"file": "crates/hyperswitch_connectors/src/connectors/authorizedotnet/transformers.rs",
"file_size": null,
"is_async": null,
"is_pub": null,
"num_enums": 13,
"num_structs": 41,
"num_tables": null,
"score": null,
"total_crates": null
}
|
file_hyperswitch_connectors_2890180685102846358
|
clm
|
file
|
// Repository: hyperswitch
// Crate: hyperswitch_connectors
// File: crates/hyperswitch_connectors/src/connectors/archipel/transformers.rs
// Contains: 11 structs, 5 enums
use bytes::Bytes;
use common_enums::{
self, AttemptStatus, AuthorizationStatus, CaptureMethod, Currency, FutureUsage,
PaymentMethodStatus, RefundStatus,
};
use common_utils::{date_time, ext_traits::Encode, pii, types::MinorUnit};
use error_stack::ResultExt;
use hyperswitch_domain_models::{
address::AddressDetails,
payment_method_data::{Card, PaymentMethodData, WalletData},
router_data::{ConnectorAuthType, ErrorResponse, PaymentMethodToken, RouterData},
router_flow_types::refunds::{Execute, RSync},
router_request_types::{
AuthenticationData, PaymentsAuthorizeData, PaymentsCancelData, PaymentsCaptureData,
PaymentsIncrementalAuthorizationData, PaymentsSyncData, ResponseId,
SetupMandateRequestData,
},
router_response_types::{PaymentsResponseData, RefundsResponseData},
types::{
PaymentsAuthorizeRouterData, PaymentsCancelRouterData, PaymentsCaptureRouterData,
PaymentsIncrementalAuthorizationRouterData, RefundsRouterData, SetupMandateRouterData,
},
};
use hyperswitch_interfaces::{consts, errors};
use masking::Secret;
use serde::{Deserialize, Serialize};
use crate::{
types::{RefundsResponseRouterData, ResponseRouterData},
unimplemented_payment_method,
utils::{
self, AddressData, AddressDetailsData, CardData, CardIssuer, PaymentsAuthorizeRequestData,
RouterData as _,
},
};
const THREE_DS_MAX_SUPPORTED_VERSION: &str = "2.2.0";
#[derive(Debug, Deserialize, Serialize, Eq, PartialEq, Clone)]
#[serde(transparent)]
pub struct ArchipelTenantId(pub String);
impl From<String> for ArchipelTenantId {
fn from(value: String) -> Self {
Self(value)
}
}
pub struct ArchipelRouterData<T> {
pub amount: MinorUnit,
pub tenant_id: ArchipelTenantId,
pub router_data: T,
}
impl<T> From<(MinorUnit, ArchipelTenantId, T)> for ArchipelRouterData<T> {
fn from((amount, tenant_id, router_data): (MinorUnit, ArchipelTenantId, T)) -> Self {
Self {
amount,
tenant_id,
router_data,
}
}
}
pub struct ArchipelAuthType {
pub(super) ca_certificate: Option<Secret<String>>,
}
impl TryFrom<&ConnectorAuthType> for ArchipelAuthType {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(auth_type: &ConnectorAuthType) -> Result<Self, Self::Error> {
match auth_type {
ConnectorAuthType::HeaderKey { api_key } => Ok(Self {
ca_certificate: Some(api_key.to_owned()),
}),
_ => Err(errors::ConnectorError::FailedToObtainAuthType.into()),
}
}
}
#[derive(Debug, Deserialize, Serialize, Eq, PartialEq)]
pub struct ArchipelConfigData {
pub tenant_id: ArchipelTenantId,
pub platform_url: String,
}
impl TryFrom<&Option<pii::SecretSerdeValue>> for ArchipelConfigData {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(connector_metadata: &Option<pii::SecretSerdeValue>) -> Result<Self, Self::Error> {
let config_data = utils::to_connector_meta_from_secret::<Self>(connector_metadata.clone())
.change_context(errors::ConnectorError::InvalidConnectorConfig {
config: "metadata. Required fields: tenant_id, platform_url",
})?;
Ok(config_data)
}
}
#[derive(Debug, Default, Serialize, Eq, PartialEq, Clone)]
#[serde(rename_all = "UPPERCASE")]
pub enum ArchipelPaymentInitiator {
#[default]
Customer,
Merchant,
}
#[derive(Debug, Serialize, Eq, PartialEq, Clone)]
#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
pub enum ArchipelWalletProvider {
ApplePay,
GooglePay,
SamsungPay,
}
#[derive(Debug, Default, Serialize, Eq, PartialEq)]
#[serde(rename_all = "UPPERCASE")]
pub enum ArchipelPaymentCertainty {
#[default]
Final,
Estimated,
}
#[derive(Debug, Serialize, Eq, PartialEq)]
#[serde(rename_all = "camelCase")]
pub struct ArchipelOrderRequest {
amount: MinorUnit,
currency: String,
certainty: ArchipelPaymentCertainty,
initiator: ArchipelPaymentInitiator,
}
#[derive(Debug, Serialize, Eq, PartialEq, Clone)]
pub struct CardExpiryDate {
month: Secret<String>,
year: Secret<String>,
}
#[derive(Debug, Serialize, Default, Eq, PartialEq, Clone)]
#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
pub enum ApplicationSelectionIndicator {
#[default]
ByDefault,
CustomerChoice,
}
#[derive(Debug, Serialize, Eq, PartialEq)]
#[serde(rename_all = "camelCase")]
pub struct Archipel3DS {
#[serde(rename = "acsTransID")]
acs_trans_id: Option<Secret<String>>,
#[serde(rename = "dsTransID")]
ds_trans_id: Option<Secret<String>>,
#[serde(rename = "3DSRequestorName")]
three_ds_requestor_name: Option<Secret<String>>,
#[serde(rename = "3DSAuthDate")]
three_ds_auth_date: Option<String>,
#[serde(rename = "3DSAuthAmt")]
three_ds_auth_amt: Option<MinorUnit>,
#[serde(rename = "3DSAuthStatus")]
three_ds_auth_status: Option<String>,
#[serde(rename = "3DSMaxSupportedVersion")]
three_ds_max_supported_version: String,
#[serde(rename = "3DSVersion")]
three_ds_version: Option<common_utils::types::SemanticVersion>,
authentication_value: Secret<String>,
authentication_method: Option<Secret<String>>,
eci: Option<String>,
}
impl From<AuthenticationData> for Archipel3DS {
fn from(three_ds_data: AuthenticationData) -> Self {
let now = date_time::date_as_yyyymmddthhmmssmmmz().ok();
Self {
acs_trans_id: None,
ds_trans_id: three_ds_data.ds_trans_id.map(Secret::new),
three_ds_requestor_name: None,
three_ds_auth_date: now,
three_ds_auth_amt: None,
three_ds_auth_status: None,
three_ds_max_supported_version: THREE_DS_MAX_SUPPORTED_VERSION.into(),
three_ds_version: three_ds_data.message_version,
authentication_value: three_ds_data.cavv,
authentication_method: None,
eci: three_ds_data.eci,
}
}
}
#[derive(Clone, Debug, Serialize, Eq, PartialEq)]
#[serde(rename_all = "camelCase")]
pub struct ArchipelCardHolder {
billing_address: Option<ArchipelBillingAddress>,
}
impl From<Option<ArchipelBillingAddress>> for ArchipelCardHolder {
fn from(value: Option<ArchipelBillingAddress>) -> Self {
Self {
billing_address: value,
}
}
}
#[derive(Clone, Debug, Serialize, Eq, PartialEq)]
#[serde(rename_all = "camelCase")]
pub struct ArchipelBillingAddress {
address: Option<Secret<String>>,
postal_code: Option<Secret<String>>,
}
pub trait ToArchipelBillingAddress {
fn to_archipel_billing_address(&self) -> Option<ArchipelBillingAddress>;
}
impl ToArchipelBillingAddress for AddressDetails {
fn to_archipel_billing_address(&self) -> Option<ArchipelBillingAddress> {
let address = self.get_combined_address_line().ok();
let postal_code = self.get_optional_zip();
match (address, postal_code) {
(None, None) => None,
(addr, zip) => Some(ArchipelBillingAddress {
address: addr,
postal_code: zip,
}),
}
}
}
#[derive(Debug, Serialize, Eq, PartialEq, Clone)]
#[serde(rename_all = "UPPERCASE")]
pub enum ArchipelCredentialIndicatorStatus {
Initial,
Subsequent,
}
#[derive(Debug, Serialize, Eq, PartialEq)]
#[serde(rename_all = "camelCase")]
pub struct ArchipelCredentialIndicator {
status: ArchipelCredentialIndicatorStatus,
recurring: Option<bool>,
transaction_id: Option<String>,
}
#[derive(Debug, Serialize, Eq, PartialEq, Clone)]
#[serde(rename_all = "camelCase")]
pub struct TokenizedCardData {
card_data: ArchipelTokenizedCard,
wallet_information: ArchipelWalletInformation,
}
impl TryFrom<(&WalletData, &Option<PaymentMethodToken>)> for TokenizedCardData {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
(wallet_data, pm_token): (&WalletData, &Option<PaymentMethodToken>),
) -> Result<Self, Self::Error> {
let WalletData::ApplePay(apple_pay_data) = wallet_data else {
return Err(error_stack::Report::from(
errors::ConnectorError::NotSupported {
message: "Wallet type used".to_string(),
connector: "Archipel",
},
));
};
let Some(PaymentMethodToken::ApplePayDecrypt(apple_pay_decrypt_data)) = pm_token else {
return Err(error_stack::Report::from(unimplemented_payment_method!(
"Apple Pay",
"Manual",
"Archipel"
)));
};
let card_number = apple_pay_decrypt_data
.application_primary_account_number
.clone();
let expiry_year_2_digit = apple_pay_decrypt_data
.get_two_digit_expiry_year()
.change_context(errors::ConnectorError::MissingRequiredField {
field_name: "Apple pay expiry year",
})?;
let expiry_month = apple_pay_decrypt_data.get_expiry_month().change_context(
errors::ConnectorError::InvalidDataFormat {
field_name: "expiration_month",
},
)?;
Ok(Self {
card_data: ArchipelTokenizedCard {
expiry: CardExpiryDate {
year: expiry_year_2_digit,
month: expiry_month,
},
number: card_number,
scheme: ArchipelCardScheme::from(apple_pay_data.payment_method.network.as_str()),
},
wallet_information: {
ArchipelWalletInformation {
wallet_provider: ArchipelWalletProvider::ApplePay,
wallet_indicator: apple_pay_decrypt_data.payment_data.eci_indicator.clone(),
wallet_cryptogram: apple_pay_decrypt_data
.payment_data
.online_payment_cryptogram
.clone(),
}
},
})
}
}
#[derive(Debug, Serialize, Eq, PartialEq, Clone)]
#[serde(rename_all = "camelCase")]
pub struct ArchipelTokenizedCard {
number: cards::CardNumber,
expiry: CardExpiryDate,
scheme: ArchipelCardScheme,
}
#[derive(Debug, Serialize, Eq, PartialEq, Clone)]
#[serde(rename_all = "camelCase")]
pub struct ArchipelCard {
number: cards::CardNumber,
expiry: CardExpiryDate,
security_code: Option<Secret<String>>,
card_holder_name: Option<Secret<String>>,
application_selection_indicator: ApplicationSelectionIndicator,
scheme: ArchipelCardScheme,
}
impl TryFrom<(Option<Secret<String>>, Option<ArchipelCardHolder>, &Card)> for ArchipelCard {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
(card_holder_name, card_holder_billing, ccard): (
Option<Secret<String>>,
Option<ArchipelCardHolder>,
&Card,
),
) -> Result<Self, Self::Error> {
// NOTE: Archipel does not accept `card.card_holder_name` field without `cardholder` field.
// So if `card_holder` is None, `card.card_holder_name` must also be None.
// However, the reverse is allowed — the `cardholder` field can exist without `card.card_holder_name`.
let card_holder_name = card_holder_billing
.as_ref()
.and_then(|_| ccard.card_holder_name.clone().or(card_holder_name.clone()));
let scheme: ArchipelCardScheme = ccard.get_card_issuer().ok().into();
Ok(Self {
number: ccard.card_number.clone(),
expiry: CardExpiryDate {
month: ccard.card_exp_month.clone(),
year: ccard.get_card_expiry_year_2_digit()?,
},
security_code: Some(ccard.card_cvc.clone()),
application_selection_indicator: ApplicationSelectionIndicator::ByDefault,
card_holder_name,
scheme,
})
}
}
impl
TryFrom<(
Option<Secret<String>>,
Option<ArchipelCardHolder>,
&hyperswitch_domain_models::payment_method_data::CardDetailsForNetworkTransactionId,
)> for ArchipelCard
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
(card_holder_name, card_holder_billing, card_details): (
Option<Secret<String>>,
Option<ArchipelCardHolder>,
&hyperswitch_domain_models::payment_method_data::CardDetailsForNetworkTransactionId,
),
) -> Result<Self, Self::Error> {
// NOTE: Archipel does not accept `card.card_holder_name` field without `cardholder` field.
// So if `card_holder` is None, `card.card_holder_name` must also be None.
// However, the reverse is allowed — the `cardholder` field can exist without `card.card_holder_name`.
let card_holder_name = card_holder_billing.as_ref().and_then(|_| {
card_details
.card_holder_name
.clone()
.or(card_holder_name.clone())
});
let scheme: ArchipelCardScheme = card_details.get_card_issuer().ok().into();
Ok(Self {
number: card_details.card_number.clone(),
expiry: CardExpiryDate {
month: card_details.card_exp_month.clone(),
year: card_details.get_card_expiry_year_2_digit()?,
},
security_code: None,
application_selection_indicator: ApplicationSelectionIndicator::ByDefault,
card_holder_name,
scheme,
})
}
}
#[derive(Debug, Serialize, Eq, PartialEq, Clone)]
#[serde(rename_all = "camelCase")]
pub struct ArchipelWalletInformation {
wallet_indicator: Option<String>,
wallet_provider: ArchipelWalletProvider,
wallet_cryptogram: Secret<String>,
}
#[derive(Debug, Serialize, Eq, PartialEq)]
#[serde(rename_all = "camelCase")]
pub struct ArchipelPaymentInformation {
order: ArchipelOrderRequest,
cardholder: Option<ArchipelCardHolder>,
card_holder_name: Option<Secret<String>>,
credential_indicator: Option<ArchipelCredentialIndicator>,
stored_on_file: bool,
}
#[derive(Debug, Serialize, Eq, PartialEq)]
#[serde(rename_all = "camelCase")]
pub struct ArchipelWalletAuthorizationRequest {
order: ArchipelOrderRequest,
card: ArchipelTokenizedCard,
cardholder: Option<ArchipelCardHolder>,
wallet: ArchipelWalletInformation,
#[serde(rename = "3DS")]
three_ds: Option<Archipel3DS>,
credential_indicator: Option<ArchipelCredentialIndicator>,
stored_on_file: bool,
tenant_id: ArchipelTenantId,
}
#[derive(Debug, Serialize, Eq, PartialEq)]
#[serde(rename_all = "camelCase")]
pub struct ArchipelCardAuthorizationRequest {
order: ArchipelOrderRequest,
card: ArchipelCard,
cardholder: Option<ArchipelCardHolder>,
#[serde(rename = "3DS")]
three_ds: Option<Archipel3DS>,
credential_indicator: Option<ArchipelCredentialIndicator>,
stored_on_file: bool,
tenant_id: ArchipelTenantId,
}
// PaymentsResponse
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
#[serde(rename_all = "UPPERCASE")]
pub enum ArchipelCardScheme {
Amex,
Mastercard,
Visa,
Discover,
Diners,
Unknown,
}
impl From<&str> for ArchipelCardScheme {
fn from(input: &str) -> Self {
match input {
"Visa" => Self::Visa,
"Amex" => Self::Amex,
"Diners" => Self::Diners,
"MasterCard" => Self::Mastercard,
"Discover" => Self::Discover,
_ => Self::Unknown,
}
}
}
impl From<Option<CardIssuer>> for ArchipelCardScheme {
fn from(card_issuer: Option<CardIssuer>) -> Self {
match card_issuer {
Some(CardIssuer::Visa) => Self::Visa,
Some(CardIssuer::Master | CardIssuer::Maestro) => Self::Mastercard,
Some(CardIssuer::AmericanExpress) => Self::Amex,
Some(CardIssuer::Discover) => Self::Discover,
Some(CardIssuer::DinersClub) => Self::Diners,
_ => Self::Unknown,
}
}
}
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Default)]
#[serde(rename_all = "lowercase")]
pub enum ArchipelPaymentStatus {
#[default]
Succeeded,
Failed,
}
impl TryFrom<(AttemptStatus, CaptureMethod)> for ArchipelPaymentFlow {
type Error = errors::ConnectorError;
fn try_from(
(status, capture_method): (AttemptStatus, CaptureMethod),
) -> Result<Self, Self::Error> {
let is_auto_capture = matches!(capture_method, CaptureMethod::Automatic);
match status {
AttemptStatus::AuthenticationFailed => Ok(Self::Verify),
AttemptStatus::Authorizing
| AttemptStatus::Authorized
| AttemptStatus::AuthorizationFailed => Ok(Self::Authorize),
AttemptStatus::Voided | AttemptStatus::VoidInitiated | AttemptStatus::VoidFailed => {
Ok(Self::Cancel)
}
AttemptStatus::CaptureInitiated | AttemptStatus::CaptureFailed => {
if is_auto_capture {
Ok(Self::Pay)
} else {
Ok(Self::Capture)
}
}
AttemptStatus::PaymentMethodAwaited | AttemptStatus::ConfirmationAwaited => {
if is_auto_capture {
Ok(Self::Pay)
} else {
Ok(Self::Authorize)
}
}
_ => Err(errors::ConnectorError::ProcessingStepFailed(Some(
Bytes::from_static(
"Impossible to determine Archipel flow from AttemptStatus".as_bytes(),
),
))),
}
}
}
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub enum ArchipelPaymentFlow {
Verify,
Authorize,
Pay,
Capture,
Cancel,
}
struct ArchipelFlowStatus {
status: ArchipelPaymentStatus,
flow: ArchipelPaymentFlow,
}
impl ArchipelFlowStatus {
fn new(status: ArchipelPaymentStatus, flow: ArchipelPaymentFlow) -> Self {
Self { status, flow }
}
}
impl From<ArchipelFlowStatus> for AttemptStatus {
fn from(ArchipelFlowStatus { status, flow }: ArchipelFlowStatus) -> Self {
match status {
ArchipelPaymentStatus::Succeeded => match flow {
ArchipelPaymentFlow::Authorize => Self::Authorized,
ArchipelPaymentFlow::Pay
| ArchipelPaymentFlow::Verify
| ArchipelPaymentFlow::Capture => Self::Charged,
ArchipelPaymentFlow::Cancel => Self::Voided,
},
ArchipelPaymentStatus::Failed => match flow {
ArchipelPaymentFlow::Authorize | ArchipelPaymentFlow::Pay => {
Self::AuthorizationFailed
}
ArchipelPaymentFlow::Verify => Self::AuthenticationFailed,
ArchipelPaymentFlow::Capture => Self::CaptureFailed,
ArchipelPaymentFlow::Cancel => Self::VoidFailed,
},
}
}
}
#[derive(Debug, Serialize, Deserialize, Eq, PartialEq, Clone)]
#[serde(rename_all = "camelCase")]
pub struct ArchipelOrderResponse {
id: String,
amount: Option<i64>,
currency: Option<Currency>,
captured_amount: Option<i64>,
authorized_amount: Option<i64>,
}
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct ArchipelErrorMessage {
pub code: String,
pub description: Option<String>,
}
impl Default for ArchipelErrorMessage {
fn default() -> Self {
Self {
code: consts::NO_ERROR_CODE.to_string(),
description: Some(consts::NO_ERROR_MESSAGE.to_string()),
}
}
}
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
struct ArchipelErrorMessageWithHttpCode {
error_message: ArchipelErrorMessage,
http_code: u16,
}
impl ArchipelErrorMessageWithHttpCode {
fn new(error_message: ArchipelErrorMessage, http_code: u16) -> Self {
Self {
error_message,
http_code,
}
}
}
#[derive(Debug, Serialize, Deserialize, Eq, PartialEq, Default)]
#[serde(rename_all = "camelCase")]
pub struct ArchipelTransactionMetadata {
pub transaction_id: String,
pub transaction_date: String,
pub financial_network_code: Option<String>,
pub issuer_transaction_id: Option<String>,
pub response_code: Option<String>,
pub authorization_code: Option<String>,
pub payment_account_reference: Option<Secret<String>>,
}
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
#[serde(rename_all = "camelCase")]
pub struct ArchipelPaymentsResponse {
order: ArchipelOrderResponse,
transaction_id: String,
transaction_date: String,
transaction_result: ArchipelPaymentStatus,
error: Option<ArchipelErrorMessage>,
financial_network_code: Option<String>,
issuer_transaction_id: Option<String>,
response_code: Option<String>,
authorization_code: Option<String>,
payment_account_reference: Option<Secret<String>>,
}
impl From<&ArchipelPaymentsResponse> for ArchipelTransactionMetadata {
fn from(payment_response: &ArchipelPaymentsResponse) -> Self {
Self {
transaction_id: payment_response.transaction_id.clone(),
transaction_date: payment_response.transaction_date.clone(),
financial_network_code: payment_response.financial_network_code.clone(),
issuer_transaction_id: payment_response.issuer_transaction_id.clone(),
response_code: payment_response.response_code.clone(),
authorization_code: payment_response.authorization_code.clone(),
payment_account_reference: payment_response.payment_account_reference.clone(),
}
}
}
// AUTHORIZATION FLOW
impl TryFrom<(MinorUnit, &PaymentsAuthorizeRouterData)> for ArchipelPaymentInformation {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
(amount, router_data): (MinorUnit, &PaymentsAuthorizeRouterData),
) -> Result<Self, Self::Error> {
let is_recurring_payment = router_data
.request
.mandate_id
.as_ref()
.and_then(|mandate_ids| mandate_ids.mandate_id.as_ref())
.is_some();
let is_subsequent_trx = router_data
.request
.mandate_id
.as_ref()
.and_then(|mandate_ids| mandate_ids.mandate_reference_id.as_ref())
.is_some();
let is_saved_card_payment = (router_data.request.is_mandate_payment())
| (router_data.request.setup_future_usage == Some(FutureUsage::OnSession))
| (router_data.payment_method_status == Some(PaymentMethodStatus::Active));
let certainty = if router_data.request.request_incremental_authorization {
if is_recurring_payment {
ArchipelPaymentCertainty::Final
} else {
ArchipelPaymentCertainty::Estimated
}
} else {
ArchipelPaymentCertainty::Final
};
let transaction_initiator = if is_recurring_payment {
ArchipelPaymentInitiator::Merchant
} else {
ArchipelPaymentInitiator::Customer
};
let order = ArchipelOrderRequest {
amount,
currency: router_data.request.currency.to_string(),
certainty,
initiator: transaction_initiator.clone(),
};
let cardholder = router_data
.get_billing_address()
.ok()
.and_then(|address| address.to_archipel_billing_address())
.map(|billing_address| ArchipelCardHolder {
billing_address: Some(billing_address),
});
// NOTE: Archipel does not accept `card.card_holder_name` field without `cardholder` field.
// So if `card_holder` is None, `card.card_holder_name` must also be None.
// However, the reverse is allowed — the `cardholder` field can exist without `card.card_holder_name`.
let card_holder_name = cardholder.as_ref().and_then(|_| {
router_data
.get_billing()
.ok()
.and_then(|billing| billing.get_optional_full_name())
});
let indicator_status = if is_subsequent_trx {
ArchipelCredentialIndicatorStatus::Subsequent
} else {
ArchipelCredentialIndicatorStatus::Initial
};
let stored_on_file =
is_saved_card_payment | router_data.request.is_customer_initiated_mandate_payment();
let credential_indicator = stored_on_file.then(|| ArchipelCredentialIndicator {
status: indicator_status.clone(),
recurring: Some(is_recurring_payment),
transaction_id: match indicator_status {
ArchipelCredentialIndicatorStatus::Initial => None,
ArchipelCredentialIndicatorStatus::Subsequent => {
router_data.request.get_optional_network_transaction_id()
}
},
});
Ok(Self {
order,
cardholder,
card_holder_name,
credential_indicator,
stored_on_file,
})
}
}
impl TryFrom<ArchipelRouterData<&PaymentsAuthorizeRouterData>>
for ArchipelCardAuthorizationRequest
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: ArchipelRouterData<&PaymentsAuthorizeRouterData>,
) -> Result<Self, Self::Error> {
let ArchipelRouterData {
amount,
tenant_id,
router_data,
} = item;
let payment_information: ArchipelPaymentInformation =
ArchipelPaymentInformation::try_from((amount, router_data))?;
let payment_method_data = match &item.router_data.request.payment_method_data {
PaymentMethodData::Card(ccard) => ArchipelCard::try_from((
payment_information.card_holder_name,
payment_information.cardholder.clone(),
ccard,
))?,
PaymentMethodData::CardDetailsForNetworkTransactionId(card_details) => {
ArchipelCard::try_from((
payment_information.card_holder_name,
payment_information.cardholder.clone(),
card_details,
))?
}
PaymentMethodData::CardRedirect(..)
| PaymentMethodData::Wallet(..)
| PaymentMethodData::PayLater(..)
| PaymentMethodData::BankRedirect(..)
| PaymentMethodData::BankDebit(..)
| PaymentMethodData::BankTransfer(..)
| PaymentMethodData::Crypto(..)
| PaymentMethodData::MandatePayment
| PaymentMethodData::Reward
| PaymentMethodData::RealTimePayment(..)
| PaymentMethodData::Upi(..)
| PaymentMethodData::Voucher(..)
| PaymentMethodData::GiftCard(..)
| PaymentMethodData::CardToken(..)
| PaymentMethodData::OpenBanking(..)
| PaymentMethodData::NetworkToken(..)
| PaymentMethodData::MobilePayment(..) => Err(errors::ConnectorError::NotImplemented(
utils::get_unimplemented_payment_method_error_message("Archipel"),
))?,
};
let three_ds: Option<Archipel3DS> = if item.router_data.is_three_ds() {
let auth_data = item
.router_data
.request
.get_authentication_data()
.change_context(errors::ConnectorError::NotSupported {
message: "Selected 3DS authentication method".to_string(),
connector: "archipel",
})?;
Some(Archipel3DS::from(auth_data))
} else {
None
};
Ok(Self {
order: payment_information.order,
cardholder: payment_information.cardholder,
card: payment_method_data,
three_ds,
credential_indicator: payment_information.credential_indicator,
stored_on_file: payment_information.stored_on_file,
tenant_id,
})
}
}
impl TryFrom<ArchipelRouterData<&PaymentsAuthorizeRouterData>>
for ArchipelWalletAuthorizationRequest
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: ArchipelRouterData<&PaymentsAuthorizeRouterData>,
) -> Result<Self, Self::Error> {
let ArchipelRouterData {
amount,
tenant_id,
router_data,
} = item;
let payment_information = ArchipelPaymentInformation::try_from((amount, router_data))?;
let payment_method_data = match &item.router_data.request.payment_method_data {
PaymentMethodData::Wallet(wallet_data) => {
TokenizedCardData::try_from((wallet_data, &item.router_data.payment_method_token))?
}
PaymentMethodData::Card(..)
| PaymentMethodData::CardDetailsForNetworkTransactionId(..)
| PaymentMethodData::CardRedirect(..)
| PaymentMethodData::PayLater(..)
| PaymentMethodData::BankRedirect(..)
| PaymentMethodData::BankDebit(..)
| PaymentMethodData::BankTransfer(..)
| PaymentMethodData::Crypto(..)
| PaymentMethodData::MandatePayment
| PaymentMethodData::Reward
| PaymentMethodData::RealTimePayment(..)
| PaymentMethodData::Upi(..)
| PaymentMethodData::Voucher(..)
| PaymentMethodData::GiftCard(..)
| PaymentMethodData::CardToken(..)
| PaymentMethodData::OpenBanking(..)
| PaymentMethodData::NetworkToken(..)
| PaymentMethodData::MobilePayment(..) => Err(errors::ConnectorError::NotImplemented(
utils::get_unimplemented_payment_method_error_message("Archipel"),
))?,
};
Ok(Self {
order: payment_information.order,
cardholder: payment_information.cardholder,
card: payment_method_data.card_data.clone(),
wallet: payment_method_data.wallet_information.clone(),
three_ds: None,
credential_indicator: payment_information.credential_indicator,
stored_on_file: payment_information.stored_on_file,
tenant_id,
})
}
}
// Responses for AUTHORIZATION FLOW
impl<F>
TryFrom<
ResponseRouterData<
F,
ArchipelPaymentsResponse,
PaymentsAuthorizeData,
PaymentsResponseData,
>,
> for RouterData<F, PaymentsAuthorizeData, PaymentsResponseData>
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: ResponseRouterData<
F,
ArchipelPaymentsResponse,
PaymentsAuthorizeData,
PaymentsResponseData,
>,
) -> Result<Self, Self::Error> {
if let Some(error) = item.response.error {
return Ok(Self {
response: Err(ArchipelErrorMessageWithHttpCode::new(error, item.http_code).into()),
..item.data
});
};
let capture_method = item
.data
.request
.capture_method
.ok_or_else(|| errors::ConnectorError::CaptureMethodNotSupported)?;
let (archipel_flow, is_incremental_allowed) = match capture_method {
CaptureMethod::Automatic => (ArchipelPaymentFlow::Pay, false),
_ => (
ArchipelPaymentFlow::Authorize,
item.data.request.request_incremental_authorization,
),
};
let connector_metadata: Option<serde_json::Value> =
ArchipelTransactionMetadata::from(&item.response)
.encode_to_value()
.ok();
let status: AttemptStatus =
ArchipelFlowStatus::new(item.response.transaction_result, archipel_flow).into();
Ok(Self {
status,
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(item.response.order.id),
charges: None,
redirection_data: Box::new(None),
mandate_reference: Box::new(None),
connector_metadata,
// Save archipel initial transaction uuid for network transaction mit/cit
network_txn_id: item
.data
.request
.is_customer_initiated_mandate_payment()
.then_some(item.response.transaction_id),
connector_response_reference_id: None,
incremental_authorization_allowed: Some(is_incremental_allowed),
}),
..item.data
})
}
}
// PSYNC FLOW
impl<F>
TryFrom<ResponseRouterData<F, ArchipelPaymentsResponse, PaymentsSyncData, PaymentsResponseData>>
for RouterData<F, PaymentsSyncData, PaymentsResponseData>
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: ResponseRouterData<
F,
ArchipelPaymentsResponse,
PaymentsSyncData,
PaymentsResponseData,
>,
) -> Result<Self, Self::Error> {
if let Some(error) = item.response.error {
return Ok(Self {
response: Err(ArchipelErrorMessageWithHttpCode::new(error, item.http_code).into()),
..item.data
});
};
let connector_metadata: Option<serde_json::Value> =
ArchipelTransactionMetadata::from(&item.response)
.encode_to_value()
.ok();
let capture_method = item
.data
.request
.capture_method
.ok_or_else(|| errors::ConnectorError::CaptureMethodNotSupported)?;
let archipel_flow: ArchipelPaymentFlow = (item.data.status, capture_method).try_into()?;
let status: AttemptStatus =
ArchipelFlowStatus::new(item.response.transaction_result, archipel_flow).into();
Ok(Self {
status,
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(item.response.order.id),
charges: None,
redirection_data: Box::new(None),
mandate_reference: Box::new(None),
connector_metadata,
network_txn_id: None,
connector_response_reference_id: None,
incremental_authorization_allowed: None,
}),
..item.data
})
}
}
/* CAPTURE FLOW */
#[derive(Debug, Serialize, Eq, PartialEq)]
pub struct ArchipelCaptureRequest {
order: ArchipelCaptureOrderRequest,
}
#[derive(Debug, Serialize, Eq, PartialEq)]
pub struct ArchipelCaptureOrderRequest {
amount: MinorUnit,
}
impl From<ArchipelRouterData<&PaymentsCaptureRouterData>> for ArchipelCaptureRequest {
fn from(item: ArchipelRouterData<&PaymentsCaptureRouterData>) -> Self {
Self {
order: ArchipelCaptureOrderRequest {
amount: item.amount,
},
}
}
}
impl<F>
TryFrom<
ResponseRouterData<F, ArchipelPaymentsResponse, PaymentsCaptureData, PaymentsResponseData>,
> for RouterData<F, PaymentsCaptureData, PaymentsResponseData>
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: ResponseRouterData<
F,
ArchipelPaymentsResponse,
PaymentsCaptureData,
PaymentsResponseData,
>,
) -> Result<Self, Self::Error> {
if let Some(error) = item.response.error {
return Ok(Self {
response: Err(ArchipelErrorMessageWithHttpCode::new(error, item.http_code).into()),
..item.data
});
};
let connector_metadata: Option<serde_json::Value> =
ArchipelTransactionMetadata::from(&item.response)
.encode_to_value()
.ok();
let status: AttemptStatus = ArchipelFlowStatus::new(
item.response.transaction_result,
ArchipelPaymentFlow::Capture,
)
.into();
Ok(Self {
status,
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(item.response.order.id),
charges: None,
redirection_data: Box::new(None),
mandate_reference: Box::new(None),
connector_metadata,
network_txn_id: None,
connector_response_reference_id: None,
incremental_authorization_allowed: None,
}),
..item.data
})
}
}
// Setup Mandate FLow
impl TryFrom<ArchipelRouterData<&SetupMandateRouterData>> for ArchipelCardAuthorizationRequest {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(item: ArchipelRouterData<&SetupMandateRouterData>) -> Result<Self, Self::Error> {
let order = ArchipelOrderRequest {
amount: item.amount,
currency: item.router_data.request.currency.to_string(),
certainty: ArchipelPaymentCertainty::Final,
initiator: ArchipelPaymentInitiator::Customer,
};
let cardholder = Some(ArchipelCardHolder {
billing_address: item
.router_data
.get_billing_address()
.ok()
.and_then(|address| address.to_archipel_billing_address()),
});
// NOTE: Archipel does not accept `card.card_holder_name` field without `cardholder` field.
// So if `card_holder` is None, `card.card_holder_name` must also be None.
// However, the reverse is allowed — the `cardholder` field can exist without `card.card_holder_name`.
let card_holder_name = cardholder.as_ref().and_then(|_| {
item.router_data
.get_billing()
.ok()
.and_then(|billing| billing.get_optional_full_name())
});
let stored_on_file = true;
let credential_indicator = Some(ArchipelCredentialIndicator {
status: ArchipelCredentialIndicatorStatus::Initial,
recurring: Some(false),
transaction_id: None,
});
let payment_information = ArchipelPaymentInformation {
order,
cardholder,
card_holder_name,
stored_on_file,
credential_indicator,
};
let card_data = match &item.router_data.request.payment_method_data {
PaymentMethodData::Card(ccard) => ArchipelCard::try_from((
payment_information.card_holder_name,
payment_information.cardholder.clone(),
ccard,
))?,
_ => Err(errors::ConnectorError::NotImplemented(
utils::get_unimplemented_payment_method_error_message("Archipel"),
))?,
};
Ok(Self {
order: payment_information.order,
cardholder: payment_information.cardholder.clone(),
card: card_data,
three_ds: None,
credential_indicator: payment_information.credential_indicator,
stored_on_file: payment_information.stored_on_file,
tenant_id: item.tenant_id,
})
}
}
impl<F>
TryFrom<
ResponseRouterData<
F,
ArchipelPaymentsResponse,
SetupMandateRequestData,
PaymentsResponseData,
>,
> for RouterData<F, SetupMandateRequestData, PaymentsResponseData>
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: ResponseRouterData<
F,
ArchipelPaymentsResponse,
SetupMandateRequestData,
PaymentsResponseData,
>,
) -> Result<Self, Self::Error> {
if let Some(error) = item.response.error {
return Ok(Self {
response: Err(ArchipelErrorMessageWithHttpCode::new(error, item.http_code).into()),
..item.data
});
};
let connector_metadata: Option<serde_json::Value> =
ArchipelTransactionMetadata::from(&item.response)
.encode_to_value()
.ok();
let status: AttemptStatus = ArchipelFlowStatus::new(
item.response.transaction_result,
ArchipelPaymentFlow::Verify,
)
.into();
Ok(Self {
status,
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(item.response.order.id),
charges: None,
redirection_data: Box::new(None),
mandate_reference: Box::new(None),
connector_metadata,
network_txn_id: Some(item.response.transaction_id.clone()),
connector_response_reference_id: Some(item.response.transaction_id),
incremental_authorization_allowed: Some(false),
}),
..item.data
})
}
}
// Void Flow => /cancel/{order_id}
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
#[serde(rename_all = "camelCase")]
pub struct ArchipelPaymentsCancelRequest {
tenant_id: ArchipelTenantId,
}
impl From<ArchipelRouterData<&PaymentsCancelRouterData>> for ArchipelPaymentsCancelRequest {
fn from(item: ArchipelRouterData<&PaymentsCancelRouterData>) -> Self {
Self {
tenant_id: item.tenant_id,
}
}
}
impl<F>
TryFrom<
ResponseRouterData<F, ArchipelPaymentsResponse, PaymentsCancelData, PaymentsResponseData>,
> for RouterData<F, PaymentsCancelData, PaymentsResponseData>
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: ResponseRouterData<
F,
ArchipelPaymentsResponse,
PaymentsCancelData,
PaymentsResponseData,
>,
) -> Result<Self, Self::Error> {
if let Some(error) = item.response.error {
return Ok(Self {
response: Err(ArchipelErrorMessageWithHttpCode::new(error, item.http_code).into()),
..item.data
});
};
let connector_metadata: Option<serde_json::Value> =
ArchipelTransactionMetadata::from(&item.response)
.encode_to_value()
.ok();
let status: AttemptStatus = ArchipelFlowStatus::new(
item.response.transaction_result,
ArchipelPaymentFlow::Cancel,
)
.into();
Ok(Self {
status,
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(item.response.order.id),
charges: None,
redirection_data: Box::new(None),
mandate_reference: Box::new(None),
connector_metadata,
network_txn_id: None,
connector_response_reference_id: None,
incremental_authorization_allowed: None,
}),
..item.data
})
}
}
#[derive(Debug, Serialize, Eq, PartialEq)]
#[serde(rename_all = "camelCase")]
pub struct ArchipelIncrementalAuthorizationRequest {
order: ArchipelOrderRequest,
tenant_id: ArchipelTenantId,
}
// Incremental Authorization status mapping
impl From<ArchipelPaymentStatus> for AuthorizationStatus {
fn from(status: ArchipelPaymentStatus) -> Self {
match status {
ArchipelPaymentStatus::Succeeded => Self::Success,
ArchipelPaymentStatus::Failed => Self::Failure,
}
}
}
impl From<ArchipelRouterData<&PaymentsIncrementalAuthorizationRouterData>>
for ArchipelIncrementalAuthorizationRequest
{
fn from(item: ArchipelRouterData<&PaymentsIncrementalAuthorizationRouterData>) -> Self {
Self {
order: ArchipelOrderRequest {
amount: item.amount,
currency: item.router_data.request.currency.to_string(),
certainty: ArchipelPaymentCertainty::Estimated,
initiator: ArchipelPaymentInitiator::Customer,
},
tenant_id: item.tenant_id,
}
}
}
impl<F>
TryFrom<
ResponseRouterData<
F,
ArchipelPaymentsResponse,
PaymentsIncrementalAuthorizationData,
PaymentsResponseData,
>,
> for RouterData<F, PaymentsIncrementalAuthorizationData, PaymentsResponseData>
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: ResponseRouterData<
F,
ArchipelPaymentsResponse,
PaymentsIncrementalAuthorizationData,
PaymentsResponseData,
>,
) -> Result<Self, Self::Error> {
let status = AuthorizationStatus::from(item.response.transaction_result);
let (error_code, error_message) = match (&status, item.response.error) {
(AuthorizationStatus::Success, _) | (_, None) => (None, None),
(_, Some(err)) => (Some(err.code), err.description),
};
Ok(Self {
response: Ok(PaymentsResponseData::IncrementalAuthorizationResponse {
status,
error_code,
error_message,
connector_authorization_id: None,
}),
..item.data
})
}
}
/* REFUND FLOW */
#[derive(Debug, Serialize)]
pub struct ArchipelRefundOrder {
pub amount: MinorUnit,
pub currency: Currency,
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ArchipelRefundRequest {
pub order: ArchipelRefundOrder,
pub tenant_id: ArchipelTenantId,
}
impl<F> From<ArchipelRouterData<&RefundsRouterData<F>>> for ArchipelRefundRequest {
fn from(item: ArchipelRouterData<&RefundsRouterData<F>>) -> Self {
Self {
order: ArchipelRefundOrder {
amount: item.amount,
currency: item.router_data.request.currency,
},
tenant_id: item.tenant_id,
}
}
}
// Type definition for Refund Response
#[derive(Debug, Serialize, Default, Deserialize, Clone)]
#[serde(rename_all = "UPPERCASE")]
pub enum ArchipelRefundStatus {
Accepted,
Failed,
#[default]
Pending,
}
impl From<ArchipelPaymentStatus> for RefundStatus {
fn from(item: ArchipelPaymentStatus) -> Self {
match item {
ArchipelPaymentStatus::Succeeded => Self::Success,
ArchipelPaymentStatus::Failed => Self::Failure,
}
}
}
#[derive(Default, Debug, Clone, Serialize, Deserialize)]
pub struct ArchipelRefundOrderResponse {
id: String,
}
#[derive(Default, Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ArchipelRefundResponse {
order: ArchipelRefundOrderResponse,
status: ArchipelRefundStatus,
transaction_result: ArchipelPaymentStatus,
transaction_id: Option<String>,
transaction_date: Option<String>,
error: Option<ArchipelErrorMessage>,
}
impl TryFrom<ArchipelRefundResponse> for RefundsResponseData {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(resp: ArchipelRefundResponse) -> Result<Self, Self::Error> {
Ok(Self {
connector_refund_id: resp
.transaction_id
.ok_or_else(|| errors::ConnectorError::ParsingFailed)?,
refund_status: RefundStatus::from(resp.transaction_result),
})
}
}
impl TryFrom<RefundsResponseRouterData<Execute, ArchipelRefundResponse>>
for RefundsRouterData<Execute>
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: RefundsResponseRouterData<Execute, ArchipelRefundResponse>,
) -> Result<Self, Self::Error> {
let response = match item.response.error {
None => Ok(RefundsResponseData::try_from(item.response)?),
Some(error) => Err(ArchipelErrorMessageWithHttpCode::new(error, item.http_code).into()),
};
Ok(Self {
response,
..item.data
})
}
}
impl TryFrom<RefundsResponseRouterData<RSync, ArchipelRefundResponse>>
for RefundsRouterData<RSync>
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: RefundsResponseRouterData<RSync, ArchipelRefundResponse>,
) -> Result<Self, Self::Error> {
let response = match item.response.error {
None => Ok(RefundsResponseData::try_from(item.response)?),
Some(error) => Err(ArchipelErrorMessageWithHttpCode::new(error, item.http_code).into()),
};
Ok(Self {
response,
..item.data
})
}
}
impl From<ArchipelErrorMessageWithHttpCode> for ErrorResponse {
fn from(
ArchipelErrorMessageWithHttpCode {
error_message,
http_code,
}: ArchipelErrorMessageWithHttpCode,
) -> Self {
Self {
status_code: http_code,
code: error_message.code,
attempt_status: None,
connector_transaction_id: None,
message: error_message
.description
.clone()
.unwrap_or(consts::NO_ERROR_MESSAGE.to_string()),
reason: error_message.description,
network_decline_code: None,
network_advice_code: None,
network_error_message: None,
connector_metadata: None,
}
}
}
|
{
"crate": "hyperswitch_connectors",
"file": "crates/hyperswitch_connectors/src/connectors/archipel/transformers.rs",
"file_size": null,
"is_async": null,
"is_pub": null,
"num_enums": 5,
"num_structs": 11,
"num_tables": null,
"score": null,
"total_crates": null
}
|
file_hyperswitch_connectors_342137946840194187
|
clm
|
file
|
// Repository: hyperswitch
// Crate: hyperswitch_connectors
// File: crates/hyperswitch_connectors/src/connectors/payload/transformers.rs
// Contains: 2 structs, 0 enums
use std::collections::HashMap;
use api_models::webhooks::IncomingWebhookEvent;
use common_enums::enums;
use common_utils::{ext_traits::ValueExt, types::StringMajorUnit};
use error_stack::ResultExt;
use hyperswitch_domain_models::{
address::AddressDetails,
payment_method_data::PaymentMethodData,
router_data::{ConnectorAuthType, ErrorResponse, RouterData},
router_flow_types::refunds::{Execute, RSync},
router_request_types::ResponseId,
router_response_types::{MandateReference, PaymentsResponseData, RefundsResponseData},
types::{
PaymentsAuthorizeRouterData, PaymentsCaptureRouterData, RefundsRouterData,
SetupMandateRouterData,
},
};
use hyperswitch_interfaces::{
consts::{NO_ERROR_CODE, NO_ERROR_MESSAGE},
errors,
};
use masking::{ExposeOptionInterface, Secret};
use serde::Deserialize;
use super::{requests, responses};
use crate::{
types::{RefundsResponseRouterData, ResponseRouterData},
utils::{
get_unimplemented_payment_method_error_message, is_manual_capture, AddressDetailsData,
CardData, PaymentsAuthorizeRequestData, PaymentsSetupMandateRequestData,
RouterData as OtherRouterData,
},
};
type Error = error_stack::Report<errors::ConnectorError>;
fn build_payload_cards_request_data(
payment_method_data: &PaymentMethodData,
connector_auth_type: &ConnectorAuthType,
currency: enums::Currency,
amount: StringMajorUnit,
billing_address: &AddressDetails,
capture_method: Option<enums::CaptureMethod>,
is_mandate: bool,
) -> Result<requests::PayloadCardsRequestData, Error> {
if let PaymentMethodData::Card(req_card) = payment_method_data {
let payload_auth = PayloadAuth::try_from((connector_auth_type, currency))?;
let card = requests::PayloadCard {
number: req_card.clone().card_number,
expiry: req_card
.clone()
.get_card_expiry_month_year_2_digit_with_delimiter("/".to_owned())?,
cvc: req_card.card_cvc.clone(),
};
let city = billing_address.get_city()?.to_owned();
let country = billing_address.get_country()?.to_owned();
let postal_code = billing_address.get_zip()?.to_owned();
let state_province = billing_address.get_state()?.to_owned();
let street_address = billing_address.get_line1()?.to_owned();
let billing_address = requests::BillingAddress {
city,
country,
postal_code,
state_province,
street_address,
};
// For manual capture, set status to "authorized"
let status = if is_manual_capture(capture_method) {
Some(responses::PayloadPaymentStatus::Authorized)
} else {
None
};
Ok(requests::PayloadCardsRequestData {
amount,
card,
transaction_types: requests::TransactionTypes::Payment,
payment_method_type: "card".to_string(),
status,
billing_address,
processing_id: payload_auth.processing_account_id,
keep_active: is_mandate,
})
} else {
Err(
errors::ConnectorError::NotImplemented(get_unimplemented_payment_method_error_message(
"Payload",
))
.into(),
)
}
}
pub struct PayloadRouterData<T> {
pub amount: StringMajorUnit,
pub router_data: T,
}
impl<T> From<(StringMajorUnit, T)> for PayloadRouterData<T> {
fn from((amount, item): (StringMajorUnit, T)) -> Self {
Self {
amount,
router_data: item,
}
}
}
// Auth Struct
#[derive(Debug, Clone, Deserialize)]
pub struct PayloadAuth {
pub api_key: Secret<String>,
pub processing_account_id: Option<Secret<String>>,
}
#[derive(Debug, Clone)]
pub struct PayloadAuthType {
pub auths: HashMap<enums::Currency, PayloadAuth>,
}
impl TryFrom<(&ConnectorAuthType, enums::Currency)> for PayloadAuth {
type Error = Error;
fn try_from(value: (&ConnectorAuthType, enums::Currency)) -> Result<Self, Self::Error> {
let (auth_type, currency) = value;
match auth_type {
ConnectorAuthType::CurrencyAuthKey { auth_key_map } => {
let auth_key = auth_key_map.get(¤cy).ok_or(
errors::ConnectorError::CurrencyNotSupported {
message: currency.to_string(),
connector: "Payload",
},
)?;
auth_key
.to_owned()
.parse_value("PayloadAuth")
.change_context(errors::ConnectorError::FailedToObtainAuthType)
}
_ => Err(errors::ConnectorError::FailedToObtainAuthType.into()),
}
}
}
impl TryFrom<&ConnectorAuthType> for PayloadAuthType {
type Error = Error;
fn try_from(auth_type: &ConnectorAuthType) -> Result<Self, Self::Error> {
match auth_type {
ConnectorAuthType::CurrencyAuthKey { auth_key_map } => {
let auths = auth_key_map
.iter()
.map(|(currency, auth_key)| {
let auth: PayloadAuth = auth_key
.to_owned()
.parse_value("PayloadAuth")
.change_context(errors::ConnectorError::InvalidDataFormat {
field_name: "auth_key_map",
})?;
Ok((*currency, auth))
})
.collect::<Result<_, Self::Error>>()?;
Ok(Self { auths })
}
_ => Err(errors::ConnectorError::FailedToObtainAuthType.into()),
}
}
}
impl TryFrom<&SetupMandateRouterData> for requests::PayloadCardsRequestData {
type Error = Error;
fn try_from(item: &SetupMandateRouterData) -> Result<Self, Self::Error> {
match item.request.amount {
Some(amount) if amount > 0 => Err(errors::ConnectorError::FlowNotSupported {
flow: "Setup mandate with non zero amount".to_string(),
connector: "Payload".to_string(),
}
.into()),
_ => {
let billing_address = item.get_billing_address()?;
let is_mandate = item.request.is_customer_initiated_mandate_payment();
build_payload_cards_request_data(
&item.request.payment_method_data,
&item.connector_auth_type,
item.request.currency,
StringMajorUnit::zero(),
billing_address,
item.request.capture_method,
is_mandate,
)
}
}
}
}
impl TryFrom<&PayloadRouterData<&PaymentsAuthorizeRouterData>>
for requests::PayloadPaymentsRequest
{
type Error = Error;
fn try_from(
item: &PayloadRouterData<&PaymentsAuthorizeRouterData>,
) -> Result<Self, Self::Error> {
if item.router_data.is_three_ds() {
Err(errors::ConnectorError::NotSupported {
message: "Cards 3DS".to_string(),
connector: "Payload",
})?
}
match item.router_data.request.payment_method_data.clone() {
PaymentMethodData::Card(_) => {
let billing_address = item.router_data.get_billing_address()?;
let is_mandate = item.router_data.request.is_mandate_payment();
let cards_data = build_payload_cards_request_data(
&item.router_data.request.payment_method_data,
&item.router_data.connector_auth_type,
item.router_data.request.currency,
item.amount.clone(),
billing_address,
item.router_data.request.capture_method,
is_mandate,
)?;
Ok(Self::PayloadCardsRequest(Box::new(cards_data)))
}
PaymentMethodData::MandatePayment => {
// For manual capture, set status to "authorized"
let status = if is_manual_capture(item.router_data.request.capture_method) {
Some(responses::PayloadPaymentStatus::Authorized)
} else {
None
};
Ok(Self::PayloadMandateRequest(Box::new(
requests::PayloadMandateRequestData {
amount: item.amount.clone(),
transaction_types: requests::TransactionTypes::Payment,
payment_method_id: Secret::new(
item.router_data.request.get_connector_mandate_id()?,
),
status,
},
)))
}
_ => Err(errors::ConnectorError::NotImplemented("Payment method".to_string()).into()),
}
}
}
impl From<responses::PayloadPaymentStatus> for common_enums::AttemptStatus {
fn from(item: responses::PayloadPaymentStatus) -> Self {
match item {
responses::PayloadPaymentStatus::Authorized => Self::Authorized,
responses::PayloadPaymentStatus::Processed => Self::Charged,
responses::PayloadPaymentStatus::Processing => Self::Pending,
responses::PayloadPaymentStatus::Rejected
| responses::PayloadPaymentStatus::Declined => Self::Failure,
responses::PayloadPaymentStatus::Voided => Self::Voided,
}
}
}
impl<F: 'static, T>
TryFrom<ResponseRouterData<F, responses::PayloadPaymentsResponse, T, PaymentsResponseData>>
for RouterData<F, T, PaymentsResponseData>
where
T: 'static,
{
type Error = Error;
fn try_from(
item: ResponseRouterData<F, responses::PayloadPaymentsResponse, T, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
match item.response.clone() {
responses::PayloadPaymentsResponse::PayloadCardsResponse(response) => {
let status = enums::AttemptStatus::from(response.status);
let router_data: &dyn std::any::Any = &item.data;
let is_mandate_payment = router_data
.downcast_ref::<PaymentsAuthorizeRouterData>()
.is_some_and(|router_data| router_data.request.is_mandate_payment())
|| router_data
.downcast_ref::<SetupMandateRouterData>()
.is_some();
let mandate_reference = if is_mandate_payment {
let connector_payment_method_id =
response.connector_payment_method_id.clone().expose_option();
if connector_payment_method_id.is_some() {
Some(MandateReference {
connector_mandate_id: connector_payment_method_id,
payment_method_id: None,
mandate_metadata: None,
connector_mandate_request_reference_id: None,
})
} else {
None
}
} else {
None
};
let response_result = if status == enums::AttemptStatus::Failure {
Err(ErrorResponse {
attempt_status: None,
code: response
.status_code
.clone()
.unwrap_or_else(|| NO_ERROR_CODE.to_string()),
message: response
.status_message
.clone()
.unwrap_or_else(|| NO_ERROR_MESSAGE.to_string()),
reason: response.status_message,
status_code: item.http_code,
connector_transaction_id: Some(response.transaction_id.clone()),
network_decline_code: None,
network_advice_code: None,
network_error_message: None,
connector_metadata: None,
})
} else {
Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(response.transaction_id),
redirection_data: Box::new(None),
mandate_reference: Box::new(mandate_reference),
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: response.ref_number,
incremental_authorization_allowed: None,
charges: None,
})
};
Ok(Self {
status,
response: response_result,
..item.data
})
}
}
}
}
impl<T> TryFrom<&PayloadRouterData<T>> for requests::PayloadCancelRequest {
type Error = Error;
fn try_from(_item: &PayloadRouterData<T>) -> Result<Self, Self::Error> {
Ok(Self {
status: responses::PayloadPaymentStatus::Voided,
})
}
}
impl TryFrom<&PayloadRouterData<&PaymentsCaptureRouterData>> for requests::PayloadCaptureRequest {
type Error = Error;
fn try_from(
_item: &PayloadRouterData<&PaymentsCaptureRouterData>,
) -> Result<Self, Self::Error> {
Ok(Self {
status: responses::PayloadPaymentStatus::Processed,
})
}
}
impl<F> TryFrom<&PayloadRouterData<&RefundsRouterData<F>>> for requests::PayloadRefundRequest {
type Error = Error;
fn try_from(item: &PayloadRouterData<&RefundsRouterData<F>>) -> Result<Self, Self::Error> {
let connector_transaction_id = item.router_data.request.connector_transaction_id.clone();
Ok(Self {
transaction_type: requests::TransactionTypes::Refund,
amount: item.amount.to_owned(),
ledger_assoc_transaction_id: connector_transaction_id,
})
}
}
impl From<responses::RefundStatus> for enums::RefundStatus {
fn from(item: responses::RefundStatus) -> Self {
match item {
responses::RefundStatus::Processed => Self::Success,
responses::RefundStatus::Processing => Self::Pending,
responses::RefundStatus::Declined | responses::RefundStatus::Rejected => Self::Failure,
}
}
}
impl TryFrom<RefundsResponseRouterData<Execute, responses::PayloadRefundResponse>>
for RefundsRouterData<Execute>
{
type Error = Error;
fn try_from(
item: RefundsResponseRouterData<Execute, responses::PayloadRefundResponse>,
) -> Result<Self, Self::Error> {
Ok(Self {
response: Ok(RefundsResponseData {
connector_refund_id: item.response.transaction_id.to_string(),
refund_status: enums::RefundStatus::from(item.response.status),
}),
..item.data
})
}
}
impl TryFrom<RefundsResponseRouterData<RSync, responses::PayloadRefundResponse>>
for RefundsRouterData<RSync>
{
type Error = Error;
fn try_from(
item: RefundsResponseRouterData<RSync, responses::PayloadRefundResponse>,
) -> Result<Self, Self::Error> {
Ok(Self {
response: Ok(RefundsResponseData {
connector_refund_id: item.response.transaction_id.to_string(),
refund_status: enums::RefundStatus::from(item.response.status),
}),
..item.data
})
}
}
// Webhook transformations
impl From<responses::PayloadWebhooksTrigger> for IncomingWebhookEvent {
fn from(trigger: responses::PayloadWebhooksTrigger) -> Self {
match trigger {
// Payment Success Events
responses::PayloadWebhooksTrigger::Processed => Self::PaymentIntentSuccess,
responses::PayloadWebhooksTrigger::Authorized => {
Self::PaymentIntentAuthorizationSuccess
}
// Payment Processing Events
responses::PayloadWebhooksTrigger::Payment
| responses::PayloadWebhooksTrigger::AutomaticPayment => Self::PaymentIntentProcessing,
// Payment Failure Events
responses::PayloadWebhooksTrigger::Decline
| responses::PayloadWebhooksTrigger::Reject
| responses::PayloadWebhooksTrigger::BankAccountReject => Self::PaymentIntentFailure,
responses::PayloadWebhooksTrigger::Void
| responses::PayloadWebhooksTrigger::Reversal => Self::PaymentIntentCancelled,
// Refund Events
responses::PayloadWebhooksTrigger::Refund => Self::RefundSuccess,
// Dispute Events
responses::PayloadWebhooksTrigger::Chargeback => Self::DisputeOpened,
responses::PayloadWebhooksTrigger::ChargebackReversal => Self::DisputeWon,
// Other payment-related events
// Events not supported by our standard flows
responses::PayloadWebhooksTrigger::PaymentActivationStatus
| responses::PayloadWebhooksTrigger::Credit
| responses::PayloadWebhooksTrigger::Deposit
| responses::PayloadWebhooksTrigger::PaymentLinkStatus
| responses::PayloadWebhooksTrigger::ProcessingStatus
| responses::PayloadWebhooksTrigger::TransactionOperation
| responses::PayloadWebhooksTrigger::TransactionOperationClear => {
Self::EventNotSupported
}
}
}
}
|
{
"crate": "hyperswitch_connectors",
"file": "crates/hyperswitch_connectors/src/connectors/payload/transformers.rs",
"file_size": null,
"is_async": null,
"is_pub": null,
"num_enums": 0,
"num_structs": 2,
"num_tables": null,
"score": null,
"total_crates": null
}
|
file_hyperswitch_connectors_5907666064514190682
|
clm
|
file
|
// Repository: hyperswitch
// Crate: hyperswitch_connectors
// File: crates/hyperswitch_connectors/src/connectors/payload/responses.rs
// Contains: 6 structs, 5 enums
use masking::Secret;
use serde::{Deserialize, Serialize};
// PaymentsResponse
#[derive(Default, Debug, Clone, Copy, Serialize, Deserialize, PartialEq)]
#[serde(rename_all = "lowercase")]
pub enum PayloadPaymentStatus {
Authorized,
Declined,
Processed,
#[default]
Processing,
Rejected,
Voided,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum PayloadPaymentsResponse {
PayloadCardsResponse(PayloadCardsResponseData),
}
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum AvsResponse {
Unknown,
NoMatch,
Zip,
Street,
StreetAndZip,
}
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct PayloadCardsResponseData {
pub amount: f64,
pub avs: Option<AvsResponse>,
pub customer_id: Option<Secret<String>>,
#[serde(rename = "id")]
pub transaction_id: String,
#[serde(rename = "payment_method_id")]
pub connector_payment_method_id: Option<Secret<String>>,
pub processing_id: Option<Secret<String>>,
pub processing_method_id: Option<String>,
pub ref_number: Option<String>,
pub status: PayloadPaymentStatus,
pub status_code: Option<String>,
pub status_message: Option<String>,
#[serde(rename = "type")]
pub response_type: Option<String>,
}
// Type definition for Refund Response
// Added based on assumptions since this is not provided in the documentation
#[derive(Debug, Copy, Serialize, Default, Deserialize, Clone)]
#[serde(rename_all = "snake_case")]
pub enum RefundStatus {
Declined,
Processed,
#[default]
Processing,
Rejected,
}
#[derive(Default, Debug, Clone, Serialize, Deserialize)]
pub struct RefundsLedger {
pub amount: f64,
#[serde(rename = "assoc_transaction_id")]
pub associated_transaction_id: String, // Connector transaction id
#[serde(rename = "id")]
pub ledger_id: Secret<String>,
}
#[derive(Default, Debug, Clone, Serialize, Deserialize)]
pub struct PayloadRefundResponse {
pub amount: f64,
#[serde(rename = "id")]
pub transaction_id: String,
pub ledger: Vec<RefundsLedger>,
#[serde(rename = "payment_method_id")]
pub connector_payment_method_id: Option<Secret<String>>,
pub processing_id: Option<Secret<String>>,
pub ref_number: Option<String>,
pub status: RefundStatus,
pub status_code: Option<String>,
pub status_message: Option<String>,
}
#[derive(Default, Debug, Serialize, Deserialize, PartialEq)]
pub struct PayloadErrorResponse {
pub error_type: String,
pub error_description: String,
pub object: String,
/// Payload returns arbitrary details in JSON format
pub details: Option<serde_json::Value>,
}
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum PayloadWebhooksTrigger {
Payment,
Processed,
Authorized,
Credit,
Refund,
Reversal,
Void,
AutomaticPayment,
Decline,
Deposit,
Reject,
#[serde(rename = "payment_activation:status")]
PaymentActivationStatus,
#[serde(rename = "payment_link:status")]
PaymentLinkStatus,
ProcessingStatus,
BankAccountReject,
Chargeback,
ChargebackReversal,
#[serde(rename = "transaction:operation")]
TransactionOperation,
#[serde(rename = "transaction:operation:clear")]
TransactionOperationClear,
}
// Webhook response structures
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct PayloadWebhookEvent {
pub object: String, // Added to match actual webhook structure
pub trigger: PayloadWebhooksTrigger,
pub webhook_id: String,
pub triggered_at: String, // Added to match actual webhook structure
// Webhooks Payload
pub triggered_on: PayloadEventDetails,
pub url: String,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct PayloadEventDetails {
#[serde(rename = "id")]
pub transaction_id: Option<String>,
pub object: String,
pub value: Option<serde_json::Value>, // Changed to handle any value type including null
}
|
{
"crate": "hyperswitch_connectors",
"file": "crates/hyperswitch_connectors/src/connectors/payload/responses.rs",
"file_size": null,
"is_async": null,
"is_pub": null,
"num_enums": 5,
"num_structs": 6,
"num_tables": null,
"score": null,
"total_crates": null
}
|
file_hyperswitch_connectors_-856701275811408427
|
clm
|
file
|
// Repository: hyperswitch
// Crate: hyperswitch_connectors
// File: crates/hyperswitch_connectors/src/connectors/payload/requests.rs
// Contains: 7 structs, 2 enums
use common_utils::types::StringMajorUnit;
use masking::Secret;
use serde::{Deserialize, Serialize};
use crate::connectors::payload::responses;
#[derive(Debug, Serialize, PartialEq)]
#[serde(untagged)]
pub enum PayloadPaymentsRequest {
PayloadCardsRequest(Box<PayloadCardsRequestData>),
PayloadMandateRequest(Box<PayloadMandateRequestData>),
}
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum TransactionTypes {
Credit,
Chargeback,
ChargebackReversal,
Deposit,
Payment,
Refund,
Reversal,
}
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct BillingAddress {
#[serde(rename = "payment_method[billing_address][city]")]
pub city: String,
#[serde(rename = "payment_method[billing_address][country_code]")]
pub country: common_enums::CountryAlpha2,
#[serde(rename = "payment_method[billing_address][postal_code]")]
pub postal_code: Secret<String>,
#[serde(rename = "payment_method[billing_address][state_province]")]
pub state_province: Secret<String>,
#[serde(rename = "payment_method[billing_address][street_address]")]
pub street_address: Secret<String>,
}
#[derive(Debug, Clone, Serialize, PartialEq)]
pub struct PayloadCardsRequestData {
pub amount: StringMajorUnit,
#[serde(flatten)]
pub card: PayloadCard,
#[serde(rename = "type")]
pub transaction_types: TransactionTypes,
// For manual capture, set status to "authorized", otherwise omit
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<responses::PayloadPaymentStatus>,
#[serde(rename = "payment_method[type]")]
pub payment_method_type: String,
// Billing address fields are for AVS validation
#[serde(flatten)]
pub billing_address: BillingAddress,
pub processing_id: Option<Secret<String>>,
/// Allows one-time payment by customer without saving their payment method
/// This is true by default
#[serde(rename = "payment_method[keep_active]")]
pub keep_active: bool,
}
#[derive(Debug, Clone, Serialize, PartialEq)]
pub struct PayloadMandateRequestData {
pub amount: StringMajorUnit,
#[serde(rename = "type")]
pub transaction_types: TransactionTypes,
// Based on the connectors' response, we can do recurring payment either based on a default payment method id saved in the customer profile or a specific payment method id
// Connector by default, saves every payment method
pub payment_method_id: Secret<String>,
// For manual capture, set status to "authorized", otherwise omit
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<responses::PayloadPaymentStatus>,
}
#[derive(Default, Clone, Debug, Serialize, Eq, PartialEq)]
pub struct PayloadCard {
#[serde(rename = "payment_method[card][card_number]")]
pub number: cards::CardNumber,
#[serde(rename = "payment_method[card][expiry]")]
pub expiry: Secret<String>,
#[serde(rename = "payment_method[card][card_code]")]
pub cvc: Secret<String>,
}
#[derive(Clone, Debug, Serialize, PartialEq)]
pub struct PayloadCancelRequest {
pub status: responses::PayloadPaymentStatus,
}
// Type definition for CaptureRequest
#[derive(Clone, Debug, Serialize, PartialEq)]
pub struct PayloadCaptureRequest {
pub status: responses::PayloadPaymentStatus,
}
// Type definition for RefundRequest
#[derive(Debug, Serialize)]
pub struct PayloadRefundRequest {
#[serde(rename = "type")]
pub transaction_type: TransactionTypes,
pub amount: StringMajorUnit,
#[serde(rename = "ledger[0][assoc_transaction_id]")]
pub ledger_assoc_transaction_id: String,
}
|
{
"crate": "hyperswitch_connectors",
"file": "crates/hyperswitch_connectors/src/connectors/payload/requests.rs",
"file_size": null,
"is_async": null,
"is_pub": null,
"num_enums": 2,
"num_structs": 7,
"num_tables": null,
"score": null,
"total_crates": null
}
|
file_hyperswitch_connectors_-1871564639368736403
|
clm
|
file
|
// Repository: hyperswitch
// Crate: hyperswitch_connectors
// File: crates/hyperswitch_connectors/src/connectors/wellsfargopayout/transformers.rs
// Contains: 6 structs, 2 enums
use common_enums::{AttemptStatus, RefundStatus};
use common_utils::types::StringMinorUnit;
use hyperswitch_domain_models::{
payment_method_data::PaymentMethodData,
router_data::{ConnectorAuthType, RouterData},
router_flow_types::{Execute, RSync},
router_request_types::ResponseId,
router_response_types::{PaymentsResponseData, RefundsResponseData},
types::{PaymentsAuthorizeRouterData, RefundsRouterData},
};
use hyperswitch_interfaces::errors::ConnectorError;
use masking::Secret;
use serde::{Deserialize, Serialize};
use crate::{
types::{RefundsResponseRouterData, ResponseRouterData},
utils::PaymentsAuthorizeRequestData as _,
};
//TODO: Fill the struct with respective fields
pub struct WellsfargopayoutRouterData<T> {
pub amount: StringMinorUnit, // The type of amount that a connector accepts, for example, String, i64, f64, etc.
pub router_data: T,
}
impl<T> From<(StringMinorUnit, T)> for WellsfargopayoutRouterData<T> {
fn from((amount, item): (StringMinorUnit, T)) -> Self {
//Todo : use utils to convert the amount to the type of amount that a connector accepts
Self {
amount,
router_data: item,
}
}
}
//TODO: Fill the struct with respective fields
#[derive(Default, Debug, Serialize, PartialEq)]
pub struct WellsfargopayoutPaymentsRequest {
amount: StringMinorUnit,
card: WellsfargopayoutCard,
}
#[derive(Default, Debug, Serialize, Eq, PartialEq)]
pub struct WellsfargopayoutCard {
number: cards::CardNumber,
expiry_month: Secret<String>,
expiry_year: Secret<String>,
cvc: Secret<String>,
complete: bool,
}
impl TryFrom<&WellsfargopayoutRouterData<&PaymentsAuthorizeRouterData>>
for WellsfargopayoutPaymentsRequest
{
type Error = error_stack::Report<ConnectorError>;
fn try_from(
item: &WellsfargopayoutRouterData<&PaymentsAuthorizeRouterData>,
) -> Result<Self, Self::Error> {
match item.router_data.request.payment_method_data.clone() {
PaymentMethodData::Card(req_card) => {
let card = WellsfargopayoutCard {
number: req_card.card_number,
expiry_month: req_card.card_exp_month,
expiry_year: req_card.card_exp_year,
cvc: req_card.card_cvc,
complete: item.router_data.request.is_auto_capture()?,
};
Ok(Self {
amount: item.amount.clone(),
card,
})
}
_ => Err(ConnectorError::NotImplemented("Payment methods".to_string()).into()),
}
}
}
//TODO: Fill the struct with respective fields
// Auth Struct
pub struct WellsfargopayoutAuthType {
pub(super) api_key: Secret<String>,
}
impl TryFrom<&ConnectorAuthType> for WellsfargopayoutAuthType {
type Error = error_stack::Report<ConnectorError>;
fn try_from(auth_type: &ConnectorAuthType) -> Result<Self, Self::Error> {
match auth_type {
ConnectorAuthType::HeaderKey { api_key } => Ok(Self {
api_key: api_key.to_owned(),
}),
_ => Err(ConnectorError::FailedToObtainAuthType.into()),
}
}
}
// PaymentsResponse
//TODO: Append the remaining status flags
#[derive(Debug, Clone, Default, Serialize, Deserialize, PartialEq)]
#[serde(rename_all = "lowercase")]
pub enum WellsfargopayoutPaymentStatus {
Succeeded,
Failed,
#[default]
Processing,
}
impl From<WellsfargopayoutPaymentStatus> for AttemptStatus {
fn from(item: WellsfargopayoutPaymentStatus) -> Self {
match item {
WellsfargopayoutPaymentStatus::Succeeded => Self::Charged,
WellsfargopayoutPaymentStatus::Failed => Self::Failure,
WellsfargopayoutPaymentStatus::Processing => Self::Authorizing,
}
}
}
//TODO: Fill the struct with respective fields
#[derive(Default, Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct WellsfargopayoutPaymentsResponse {
status: WellsfargopayoutPaymentStatus,
id: String,
}
impl<F, T> TryFrom<ResponseRouterData<F, WellsfargopayoutPaymentsResponse, T, PaymentsResponseData>>
for RouterData<F, T, PaymentsResponseData>
{
type Error = error_stack::Report<ConnectorError>;
fn try_from(
item: ResponseRouterData<F, WellsfargopayoutPaymentsResponse, T, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
Ok(Self {
status: AttemptStatus::from(item.response.status),
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(item.response.id),
redirection_data: Box::new(None),
mandate_reference: Box::new(None),
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: None,
incremental_authorization_allowed: None,
charges: None,
}),
..item.data
})
}
}
//TODO: Fill the struct with respective fields
// REFUND :
// Type definition for RefundRequest
#[derive(Default, Debug, Serialize)]
pub struct WellsfargopayoutRefundRequest {
pub amount: StringMinorUnit,
}
impl<F> TryFrom<&WellsfargopayoutRouterData<&RefundsRouterData<F>>>
for WellsfargopayoutRefundRequest
{
type Error = error_stack::Report<ConnectorError>;
fn try_from(
item: &WellsfargopayoutRouterData<&RefundsRouterData<F>>,
) -> Result<Self, Self::Error> {
Ok(Self {
amount: item.amount.to_owned(),
})
}
}
// Type definition for Refund Response
#[allow(dead_code)]
#[derive(Debug, Serialize, Default, Deserialize, Clone)]
pub enum WellsfargopayoutRefundStatus {
Succeeded,
Failed,
#[default]
Processing,
}
impl From<WellsfargopayoutRefundStatus> for RefundStatus {
fn from(item: WellsfargopayoutRefundStatus) -> Self {
match item {
WellsfargopayoutRefundStatus::Succeeded => Self::Success,
WellsfargopayoutRefundStatus::Failed => Self::Failure,
WellsfargopayoutRefundStatus::Processing => Self::Pending,
//TODO: Review mapping
}
}
}
//TODO: Fill the struct with respective fields
#[derive(Default, Debug, Clone, Serialize, Deserialize)]
pub struct RefundResponse {
id: String,
status: WellsfargopayoutRefundStatus,
}
impl TryFrom<RefundsResponseRouterData<Execute, RefundResponse>> for RefundsRouterData<Execute> {
type Error = error_stack::Report<ConnectorError>;
fn try_from(
item: RefundsResponseRouterData<Execute, RefundResponse>,
) -> Result<Self, Self::Error> {
Ok(Self {
response: Ok(RefundsResponseData {
connector_refund_id: item.response.id.to_string(),
refund_status: RefundStatus::from(item.response.status),
}),
..item.data
})
}
}
impl TryFrom<RefundsResponseRouterData<RSync, RefundResponse>> for RefundsRouterData<RSync> {
type Error = error_stack::Report<ConnectorError>;
fn try_from(
item: RefundsResponseRouterData<RSync, RefundResponse>,
) -> Result<Self, Self::Error> {
Ok(Self {
response: Ok(RefundsResponseData {
connector_refund_id: item.response.id.to_string(),
refund_status: RefundStatus::from(item.response.status),
}),
..item.data
})
}
}
//TODO: Fill the struct with respective fields
#[derive(Default, Debug, Serialize, Deserialize, PartialEq)]
pub struct WellsfargopayoutErrorResponse {
pub status_code: u16,
pub code: String,
pub message: String,
pub reason: Option<String>,
}
|
{
"crate": "hyperswitch_connectors",
"file": "crates/hyperswitch_connectors/src/connectors/wellsfargopayout/transformers.rs",
"file_size": null,
"is_async": null,
"is_pub": null,
"num_enums": 2,
"num_structs": 6,
"num_tables": null,
"score": null,
"total_crates": null
}
|
file_hyperswitch_connectors_-1557110485074266657
|
clm
|
file
|
// Repository: hyperswitch
// Crate: hyperswitch_connectors
// File: crates/hyperswitch_connectors/src/connectors/globepay/transformers.rs
// Contains: 8 structs, 5 enums
use common_enums::enums;
use common_utils::{ext_traits::Encode, types::MinorUnit};
use error_stack::ResultExt;
use hyperswitch_domain_models::{
payment_method_data::{PaymentMethodData, WalletData},
router_data::{ConnectorAuthType, ErrorResponse, RouterData},
router_request_types::ResponseId,
router_response_types::{PaymentsResponseData, RefundsResponseData},
types::{self, RefundsRouterData},
};
use hyperswitch_interfaces::{consts, errors};
use masking::Secret;
use serde::{Deserialize, Serialize};
use crate::{
types::{RefundsResponseRouterData, ResponseRouterData},
utils::{get_unimplemented_payment_method_error_message, RouterData as _},
};
type Error = error_stack::Report<errors::ConnectorError>;
#[derive(Debug, Serialize)]
pub struct GlobepayRouterData<T> {
pub amount: MinorUnit,
pub router_data: T,
}
impl<T> From<(MinorUnit, T)> for GlobepayRouterData<T> {
fn from((amount, router_data): (MinorUnit, T)) -> Self {
Self {
amount,
router_data,
}
}
}
#[derive(Debug, Serialize)]
pub struct GlobepayPaymentsRequest {
price: MinorUnit,
description: String,
currency: enums::Currency,
channel: GlobepayChannel,
}
#[derive(Debug, Serialize)]
pub enum GlobepayChannel {
Alipay,
Wechat,
}
impl TryFrom<&GlobepayRouterData<&types::PaymentsAuthorizeRouterData>> for GlobepayPaymentsRequest {
type Error = Error;
fn try_from(
item_data: &GlobepayRouterData<&types::PaymentsAuthorizeRouterData>,
) -> Result<Self, Self::Error> {
let item = item_data.router_data.clone();
let channel: GlobepayChannel = match &item.request.payment_method_data {
PaymentMethodData::Wallet(ref wallet_data) => match wallet_data {
WalletData::AliPayQr(_) => GlobepayChannel::Alipay,
WalletData::WeChatPayQr(_) => GlobepayChannel::Wechat,
WalletData::AliPayRedirect(_)
| WalletData::AliPayHkRedirect(_)
| WalletData::AmazonPay(_)
| WalletData::AmazonPayRedirect(_)
| WalletData::Paysera(_)
| WalletData::Skrill(_)
| WalletData::BluecodeRedirect {}
| WalletData::MomoRedirect(_)
| WalletData::KakaoPayRedirect(_)
| WalletData::GoPayRedirect(_)
| WalletData::GcashRedirect(_)
| WalletData::ApplePay(_)
| WalletData::ApplePayRedirect(_)
| WalletData::ApplePayThirdPartySdk(_)
| WalletData::DanaRedirect {}
| WalletData::GooglePay(_)
| WalletData::GooglePayRedirect(_)
| WalletData::GooglePayThirdPartySdk(_)
| WalletData::MbWayRedirect(_)
| WalletData::MobilePayRedirect(_)
| WalletData::PaypalRedirect(_)
| WalletData::PaypalSdk(_)
| WalletData::Paze(_)
| WalletData::SamsungPay(_)
| WalletData::TwintRedirect {}
| WalletData::VippsRedirect {}
| WalletData::TouchNGoRedirect(_)
| WalletData::WeChatPayRedirect(_)
| WalletData::CashappQr(_)
| WalletData::SwishQr(_)
| WalletData::Mifinity(_)
| WalletData::RevolutPay(_) => Err(errors::ConnectorError::NotImplemented(
get_unimplemented_payment_method_error_message("globepay"),
))?,
},
PaymentMethodData::Card(_)
| PaymentMethodData::CardRedirect(_)
| PaymentMethodData::PayLater(_)
| PaymentMethodData::BankRedirect(_)
| PaymentMethodData::BankDebit(_)
| PaymentMethodData::BankTransfer(_)
| PaymentMethodData::Crypto(_)
| PaymentMethodData::MandatePayment
| PaymentMethodData::Reward
| PaymentMethodData::RealTimePayment(_)
| PaymentMethodData::MobilePayment(_)
| PaymentMethodData::Upi(_)
| PaymentMethodData::Voucher(_)
| PaymentMethodData::GiftCard(_)
| PaymentMethodData::OpenBanking(_)
| PaymentMethodData::CardToken(_)
| PaymentMethodData::NetworkToken(_)
| PaymentMethodData::CardDetailsForNetworkTransactionId(_) => {
Err(errors::ConnectorError::NotImplemented(
get_unimplemented_payment_method_error_message("globepay"),
))?
}
};
let description = item.get_description()?;
Ok(Self {
price: item_data.amount,
description,
currency: item.request.currency,
channel,
})
}
}
pub struct GlobepayAuthType {
pub(super) partner_code: Secret<String>,
pub(super) credential_code: Secret<String>,
}
impl TryFrom<&ConnectorAuthType> for GlobepayAuthType {
type Error = Error;
fn try_from(auth_type: &ConnectorAuthType) -> Result<Self, Self::Error> {
match auth_type {
ConnectorAuthType::BodyKey { api_key, key1 } => Ok(Self {
partner_code: api_key.to_owned(),
credential_code: key1.to_owned(),
}),
_ => Err(errors::ConnectorError::FailedToObtainAuthType.into()),
}
}
}
#[derive(Debug, Deserialize, Serialize)]
#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
pub enum GlobepayPaymentStatus {
Success,
Exists,
}
impl From<GlobepayPaymentStatus> for enums::AttemptStatus {
fn from(item: GlobepayPaymentStatus) -> Self {
match item {
GlobepayPaymentStatus::Success => Self::AuthenticationPending, // this connector only have redirection flows so "Success" is mapped to authenticatoin pending ,ref = "https://pay.globepay.co/docs/en/#api-QRCode-NewQRCode"
GlobepayPaymentStatus::Exists => Self::Failure,
}
}
}
#[derive(Debug, Deserialize, Serialize)]
pub struct GlobepayConnectorMetadata {
image_data_url: url::Url,
}
#[derive(Debug, Deserialize, Serialize)]
pub struct GlobepayPaymentsResponse {
result_code: Option<GlobepayPaymentStatus>,
order_id: Option<String>,
qrcode_img: Option<url::Url>,
return_code: GlobepayReturnCode, //Execution result
return_msg: Option<String>,
}
#[derive(Debug, Deserialize, PartialEq, strum::Display, Serialize)]
#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
pub enum GlobepayReturnCode {
Success,
OrderNotExist,
OrderMismatch,
Systemerror,
InvalidShortId,
SignTimeout,
InvalidSign,
ParamInvalid,
NotPermitted,
InvalidChannel,
DuplicateOrderId,
OrderNotPaid,
}
impl<F, T> TryFrom<ResponseRouterData<F, GlobepayPaymentsResponse, T, PaymentsResponseData>>
for RouterData<F, T, PaymentsResponseData>
{
type Error = Error;
fn try_from(
item: ResponseRouterData<F, GlobepayPaymentsResponse, T, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
if item.response.return_code == GlobepayReturnCode::Success {
let globepay_metadata = GlobepayConnectorMetadata {
image_data_url: item
.response
.qrcode_img
.ok_or(errors::ConnectorError::ResponseHandlingFailed)?,
};
let connector_metadata = Some(globepay_metadata.encode_to_value())
.transpose()
.change_context(errors::ConnectorError::ResponseHandlingFailed)?;
let globepay_status = item
.response
.result_code
.ok_or(errors::ConnectorError::ResponseHandlingFailed)?;
Ok(Self {
status: enums::AttemptStatus::from(globepay_status),
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(
item.response
.order_id
.ok_or(errors::ConnectorError::ResponseHandlingFailed)?,
),
redirection_data: Box::new(None),
mandate_reference: Box::new(None),
connector_metadata,
network_txn_id: None,
connector_response_reference_id: None,
incremental_authorization_allowed: None,
charges: None,
}),
..item.data
})
} else {
Ok(Self {
status: enums::AttemptStatus::Failure, //As this connector gives 200 in failed scenarios . if return_code is not success status is mapped to failure. ref = "https://pay.globepay.co/docs/en/#api-QRCode-NewQRCode"
response: Err(get_error_response(
item.response.return_code,
item.response.return_msg,
item.http_code,
)),
..item.data
})
}
}
}
#[derive(Debug, Deserialize, Serialize)]
pub struct GlobepaySyncResponse {
pub result_code: Option<GlobepayPaymentPsyncStatus>,
pub order_id: Option<String>,
pub return_code: GlobepayReturnCode,
pub return_msg: Option<String>,
}
#[derive(Debug, Deserialize, Serialize)]
#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
pub enum GlobepayPaymentPsyncStatus {
Paying,
CreateFail,
Closed,
PayFail,
PaySuccess,
}
impl From<GlobepayPaymentPsyncStatus> for enums::AttemptStatus {
fn from(item: GlobepayPaymentPsyncStatus) -> Self {
match item {
GlobepayPaymentPsyncStatus::PaySuccess => Self::Charged,
GlobepayPaymentPsyncStatus::PayFail
| GlobepayPaymentPsyncStatus::CreateFail
| GlobepayPaymentPsyncStatus::Closed => Self::Failure,
GlobepayPaymentPsyncStatus::Paying => Self::AuthenticationPending,
}
}
}
impl<F, T> TryFrom<ResponseRouterData<F, GlobepaySyncResponse, T, PaymentsResponseData>>
for RouterData<F, T, PaymentsResponseData>
{
type Error = Error;
fn try_from(
item: ResponseRouterData<F, GlobepaySyncResponse, T, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
if item.response.return_code == GlobepayReturnCode::Success {
let globepay_status = item
.response
.result_code
.ok_or(errors::ConnectorError::ResponseHandlingFailed)?;
let globepay_id = item
.response
.order_id
.ok_or(errors::ConnectorError::ResponseHandlingFailed)?;
Ok(Self {
status: enums::AttemptStatus::from(globepay_status),
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(globepay_id),
redirection_data: Box::new(None),
mandate_reference: Box::new(None),
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: None,
incremental_authorization_allowed: None,
charges: None,
}),
..item.data
})
} else {
Ok(Self {
status: enums::AttemptStatus::Failure, //As this connector gives 200 in failed scenarios . if return_code is not success status is mapped to failure. ref = "https://pay.globepay.co/docs/en/#api-QRCode-NewQRCode"
response: Err(get_error_response(
item.response.return_code,
item.response.return_msg,
item.http_code,
)),
..item.data
})
}
}
}
fn get_error_response(
return_code: GlobepayReturnCode,
return_msg: Option<String>,
status_code: u16,
) -> ErrorResponse {
ErrorResponse {
code: return_code.to_string(),
message: consts::NO_ERROR_MESSAGE.to_string(),
reason: return_msg,
status_code,
attempt_status: None,
connector_transaction_id: None,
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
connector_metadata: None,
}
}
#[derive(Debug, Serialize)]
pub struct GlobepayRefundRequest {
pub fee: MinorUnit,
}
impl<F> TryFrom<&GlobepayRouterData<&RefundsRouterData<F>>> for GlobepayRefundRequest {
type Error = Error;
fn try_from(item: &GlobepayRouterData<&RefundsRouterData<F>>) -> Result<Self, Self::Error> {
Ok(Self { fee: item.amount })
}
}
#[derive(Debug, Deserialize, Serialize)]
pub enum GlobepayRefundStatus {
Waiting,
CreateFailed,
Failed,
Success,
Finished,
Change,
}
impl From<GlobepayRefundStatus> for enums::RefundStatus {
fn from(item: GlobepayRefundStatus) -> Self {
match item {
GlobepayRefundStatus::Finished => Self::Success, //FINISHED: Refund success(funds has already been returned to user's account)
GlobepayRefundStatus::Failed
| GlobepayRefundStatus::CreateFailed
| GlobepayRefundStatus::Change => Self::Failure, //CHANGE: Refund can not return to user's account. Manual operation is required
GlobepayRefundStatus::Waiting | GlobepayRefundStatus::Success => Self::Pending, // SUCCESS: Submission succeeded, but refund is not yet complete. Waiting = Submission succeeded, but refund is not yet complete.
}
}
}
#[derive(Debug, Deserialize, Serialize)]
pub struct GlobepayRefundResponse {
pub result_code: Option<GlobepayRefundStatus>,
pub refund_id: Option<String>,
pub return_code: GlobepayReturnCode,
pub return_msg: Option<String>,
}
impl<T> TryFrom<RefundsResponseRouterData<T, GlobepayRefundResponse>> for RefundsRouterData<T> {
type Error = Error;
fn try_from(
item: RefundsResponseRouterData<T, GlobepayRefundResponse>,
) -> Result<Self, Self::Error> {
if item.response.return_code == GlobepayReturnCode::Success {
let globepay_refund_id = item
.response
.refund_id
.ok_or(errors::ConnectorError::ResponseHandlingFailed)?;
let globepay_refund_status = item
.response
.result_code
.ok_or(errors::ConnectorError::ResponseHandlingFailed)?;
Ok(Self {
response: Ok(RefundsResponseData {
connector_refund_id: globepay_refund_id,
refund_status: enums::RefundStatus::from(globepay_refund_status),
}),
..item.data
})
} else {
Ok(Self {
response: Err(get_error_response(
item.response.return_code,
item.response.return_msg,
item.http_code,
)),
..item.data
})
}
}
}
#[derive(Debug, Deserialize, Serialize)]
pub struct GlobepayErrorResponse {
pub return_msg: String,
pub return_code: GlobepayReturnCode,
pub message: String,
}
|
{
"crate": "hyperswitch_connectors",
"file": "crates/hyperswitch_connectors/src/connectors/globepay/transformers.rs",
"file_size": null,
"is_async": null,
"is_pub": null,
"num_enums": 5,
"num_structs": 8,
"num_tables": null,
"score": null,
"total_crates": null
}
|
file_hyperswitch_connectors_-1081944583188912041
|
clm
|
file
|
// Repository: hyperswitch
// Crate: hyperswitch_connectors
// File: crates/hyperswitch_connectors/src/connectors/forte/transformers.rs
// Contains: 21 structs, 5 enums
use cards::CardNumber;
use common_enums::enums;
use common_utils::types::FloatMajorUnit;
use hyperswitch_domain_models::{
payment_method_data::PaymentMethodData,
router_data::{ConnectorAuthType, RouterData},
router_flow_types::refunds::{Execute, RSync},
router_request_types::ResponseId,
router_response_types::{PaymentsResponseData, RefundsResponseData},
types,
};
use hyperswitch_interfaces::errors;
use masking::{PeekInterface, Secret};
use serde::{Deserialize, Serialize};
use crate::{
types::{PaymentsCaptureResponseRouterData, RefundsResponseRouterData, ResponseRouterData},
utils::{
self, AddressDetailsData, CardData as _PaymentsAuthorizeRequestData,
PaymentsAuthorizeRequestData, RouterData as _,
},
};
#[derive(Debug, Serialize)]
pub struct ForteRouterData<T> {
pub amount: FloatMajorUnit,
pub router_data: T,
}
impl<T> From<(FloatMajorUnit, T)> for ForteRouterData<T> {
fn from((amount, router_data): (FloatMajorUnit, T)) -> Self {
Self {
amount,
router_data,
}
}
}
#[derive(Debug, Serialize)]
pub struct FortePaymentsRequest {
action: ForteAction,
authorization_amount: FloatMajorUnit,
billing_address: BillingAddress,
card: Card,
}
#[derive(Debug, Serialize, Deserialize)]
pub struct BillingAddress {
first_name: Secret<String>,
last_name: Secret<String>,
}
#[derive(Debug, Serialize)]
pub struct Card {
card_type: ForteCardType,
name_on_card: Secret<String>,
account_number: CardNumber,
expire_month: Secret<String>,
expire_year: Secret<String>,
card_verification_value: Secret<String>,
}
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum ForteCardType {
Visa,
MasterCard,
Amex,
Discover,
DinersClub,
Jcb,
}
impl TryFrom<utils::CardIssuer> for ForteCardType {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(issuer: utils::CardIssuer) -> Result<Self, Self::Error> {
match issuer {
utils::CardIssuer::AmericanExpress => Ok(Self::Amex),
utils::CardIssuer::Master => Ok(Self::MasterCard),
utils::CardIssuer::Discover => Ok(Self::Discover),
utils::CardIssuer::Visa => Ok(Self::Visa),
utils::CardIssuer::DinersClub => Ok(Self::DinersClub),
utils::CardIssuer::JCB => Ok(Self::Jcb),
_ => Err(errors::ConnectorError::NotImplemented(
utils::get_unimplemented_payment_method_error_message("Forte"),
)
.into()),
}
}
}
impl TryFrom<&ForteRouterData<&types::PaymentsAuthorizeRouterData>> for FortePaymentsRequest {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item_data: &ForteRouterData<&types::PaymentsAuthorizeRouterData>,
) -> Result<Self, Self::Error> {
let item = item_data.router_data;
if item.request.currency != enums::Currency::USD {
Err(errors::ConnectorError::NotImplemented(
utils::get_unimplemented_payment_method_error_message("Forte"),
))?
}
match item.request.payment_method_data {
PaymentMethodData::Card(ref ccard) => {
let action = match item.request.is_auto_capture()? {
true => ForteAction::Sale,
false => ForteAction::Authorize,
};
let card_type = ForteCardType::try_from(ccard.get_card_issuer()?)?;
let address = item.get_billing_address()?;
let card = Card {
card_type,
name_on_card: item
.get_optional_billing_full_name()
.unwrap_or(Secret::new("".to_string())),
account_number: ccard.card_number.clone(),
expire_month: ccard.card_exp_month.clone(),
expire_year: ccard.card_exp_year.clone(),
card_verification_value: ccard.card_cvc.clone(),
};
let first_name = address.get_first_name()?;
let billing_address = BillingAddress {
first_name: first_name.clone(),
last_name: address.get_last_name().unwrap_or(first_name).clone(),
};
let authorization_amount = item_data.amount;
Ok(Self {
action,
authorization_amount,
billing_address,
card,
})
}
PaymentMethodData::CardRedirect(_)
| PaymentMethodData::Wallet(_)
| PaymentMethodData::PayLater(_)
| PaymentMethodData::BankRedirect(_)
| PaymentMethodData::BankDebit(_)
| PaymentMethodData::BankTransfer(_)
| PaymentMethodData::Crypto(_)
| PaymentMethodData::MandatePayment
| PaymentMethodData::Reward
| PaymentMethodData::RealTimePayment(_)
| PaymentMethodData::MobilePayment(_)
| PaymentMethodData::Upi(_)
| PaymentMethodData::Voucher(_)
| PaymentMethodData::GiftCard(_)
| PaymentMethodData::OpenBanking(_)
| PaymentMethodData::CardToken(_)
| PaymentMethodData::NetworkToken(_)
| PaymentMethodData::CardDetailsForNetworkTransactionId(_) => {
Err(errors::ConnectorError::NotImplemented(
utils::get_unimplemented_payment_method_error_message("Forte"),
))?
}
}
}
}
// Auth Struct
pub struct ForteAuthType {
pub(super) api_access_id: Secret<String>,
pub(super) organization_id: Secret<String>,
pub(super) location_id: Secret<String>,
pub(super) api_secret_key: Secret<String>,
}
impl TryFrom<&ConnectorAuthType> for ForteAuthType {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(auth_type: &ConnectorAuthType) -> Result<Self, Self::Error> {
match auth_type {
ConnectorAuthType::MultiAuthKey {
api_key,
key1,
api_secret,
key2,
} => Ok(Self {
api_access_id: api_key.to_owned(),
organization_id: Secret::new(format!("org_{}", key1.peek())),
location_id: Secret::new(format!("loc_{}", key2.peek())),
api_secret_key: api_secret.to_owned(),
}),
_ => Err(errors::ConnectorError::FailedToObtainAuthType)?,
}
}
}
// PaymentsResponse
#[derive(Debug, Deserialize, Serialize)]
#[serde(rename_all = "lowercase")]
pub enum FortePaymentStatus {
Complete,
Failed,
Authorized,
Ready,
Voided,
Settled,
}
impl From<FortePaymentStatus> for enums::AttemptStatus {
fn from(item: FortePaymentStatus) -> Self {
match item {
FortePaymentStatus::Complete | FortePaymentStatus::Settled => Self::Charged,
FortePaymentStatus::Failed => Self::Failure,
FortePaymentStatus::Ready => Self::Pending,
FortePaymentStatus::Authorized => Self::Authorized,
FortePaymentStatus::Voided => Self::Voided,
}
}
}
fn get_status(response_code: ForteResponseCode, action: ForteAction) -> enums::AttemptStatus {
match response_code {
ForteResponseCode::A01 => match action {
ForteAction::Authorize => enums::AttemptStatus::Authorized,
ForteAction::Sale => enums::AttemptStatus::Pending,
ForteAction::Verify | ForteAction::Capture => enums::AttemptStatus::Charged,
},
ForteResponseCode::A05 | ForteResponseCode::A06 => enums::AttemptStatus::Authorizing,
_ => enums::AttemptStatus::Failure,
}
}
#[derive(Debug, Deserialize, Serialize)]
pub struct CardResponse {
pub name_on_card: Option<Secret<String>>,
pub last_4_account_number: String,
pub masked_account_number: String,
pub card_type: Option<String>,
}
#[derive(Debug, Deserialize, Serialize)]
pub enum ForteResponseCode {
A01,
A05,
A06,
U13,
U14,
U18,
U20,
}
impl From<ForteResponseCode> for enums::AttemptStatus {
fn from(item: ForteResponseCode) -> Self {
match item {
ForteResponseCode::A01 | ForteResponseCode::A05 | ForteResponseCode::A06 => {
Self::Pending
}
_ => Self::Failure,
}
}
}
#[derive(Debug, Deserialize, Serialize)]
pub struct ResponseStatus {
pub environment: String,
pub response_type: String,
pub response_code: ForteResponseCode,
pub response_desc: String,
pub authorization_code: String,
pub avs_result: Option<String>,
pub cvv_result: Option<String>,
}
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "lowercase")]
pub enum ForteAction {
Sale,
Authorize,
Verify,
Capture,
}
#[derive(Debug, Deserialize, Serialize)]
pub struct FortePaymentsResponse {
pub transaction_id: String,
pub location_id: Secret<String>,
pub action: ForteAction,
pub authorization_amount: Option<FloatMajorUnit>,
pub authorization_code: String,
pub entered_by: String,
pub billing_address: Option<BillingAddress>,
pub card: Option<CardResponse>,
pub response: ResponseStatus,
}
#[derive(Debug, Serialize, Deserialize)]
pub struct ForteMeta {
pub auth_id: String,
}
impl<F, T> TryFrom<ResponseRouterData<F, FortePaymentsResponse, T, PaymentsResponseData>>
for RouterData<F, T, PaymentsResponseData>
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: ResponseRouterData<F, FortePaymentsResponse, T, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
let response_code = item.response.response.response_code;
let action = item.response.action;
let transaction_id = &item.response.transaction_id;
Ok(Self {
status: get_status(response_code, action),
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(transaction_id.to_string()),
redirection_data: Box::new(None),
mandate_reference: Box::new(None),
connector_metadata: Some(serde_json::json!(ForteMeta {
auth_id: item.response.authorization_code,
})),
network_txn_id: None,
connector_response_reference_id: Some(transaction_id.to_string()),
incremental_authorization_allowed: None,
charges: None,
}),
..item.data
})
}
}
//PsyncResponse
#[derive(Debug, Deserialize, Serialize)]
pub struct FortePaymentsSyncResponse {
pub transaction_id: String,
pub organization_id: Secret<String>,
pub location_id: Secret<String>,
pub original_transaction_id: Option<String>,
pub status: FortePaymentStatus,
pub action: ForteAction,
pub authorization_code: String,
pub authorization_amount: Option<FloatMajorUnit>,
pub billing_address: Option<BillingAddress>,
pub entered_by: String,
pub received_date: String,
pub origination_date: Option<String>,
pub card: Option<CardResponse>,
pub attempt_number: i64,
pub response: ResponseStatus,
pub links: ForteLink,
pub biller_name: Option<String>,
}
#[derive(Debug, Deserialize, Serialize)]
pub struct ForteLink {
pub disputes: String,
pub settlements: String,
#[serde(rename = "self")]
pub self_url: String,
}
impl<F, T> TryFrom<ResponseRouterData<F, FortePaymentsSyncResponse, T, PaymentsResponseData>>
for RouterData<F, T, PaymentsResponseData>
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: ResponseRouterData<F, FortePaymentsSyncResponse, T, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
let transaction_id = &item.response.transaction_id;
Ok(Self {
status: enums::AttemptStatus::from(item.response.status),
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(transaction_id.to_string()),
redirection_data: Box::new(None),
mandate_reference: Box::new(None),
connector_metadata: Some(serde_json::json!(ForteMeta {
auth_id: item.response.authorization_code,
})),
network_txn_id: None,
connector_response_reference_id: Some(transaction_id.to_string()),
incremental_authorization_allowed: None,
charges: None,
}),
..item.data
})
}
}
// Capture
#[derive(Debug, Serialize)]
pub struct ForteCaptureRequest {
action: String,
transaction_id: String,
authorization_code: String,
}
impl TryFrom<&types::PaymentsCaptureRouterData> for ForteCaptureRequest {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(item: &types::PaymentsCaptureRouterData) -> Result<Self, Self::Error> {
let trn_id = item.request.connector_transaction_id.clone();
let connector_auth_id: ForteMeta =
utils::to_connector_meta(item.request.connector_meta.clone())?;
let auth_code = connector_auth_id.auth_id;
Ok(Self {
action: "capture".to_string(),
transaction_id: trn_id,
authorization_code: auth_code,
})
}
}
#[derive(Debug, Deserialize, Serialize)]
pub struct CaptureResponseStatus {
pub environment: String,
pub response_type: String,
pub response_code: ForteResponseCode,
pub response_desc: String,
pub authorization_code: String,
}
// Capture Response
#[derive(Debug, Deserialize, Serialize)]
pub struct ForteCaptureResponse {
pub transaction_id: String,
pub original_transaction_id: String,
pub entered_by: String,
pub authorization_code: String,
pub response: CaptureResponseStatus,
}
impl TryFrom<PaymentsCaptureResponseRouterData<ForteCaptureResponse>>
for types::PaymentsCaptureRouterData
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: PaymentsCaptureResponseRouterData<ForteCaptureResponse>,
) -> Result<Self, Self::Error> {
let transaction_id = &item.response.transaction_id;
Ok(Self {
status: enums::AttemptStatus::from(item.response.response.response_code),
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(transaction_id.clone()),
redirection_data: Box::new(None),
mandate_reference: Box::new(None),
connector_metadata: Some(serde_json::json!(ForteMeta {
auth_id: item.response.authorization_code,
})),
network_txn_id: None,
connector_response_reference_id: Some(item.response.transaction_id.to_string()),
incremental_authorization_allowed: None,
charges: None,
}),
amount_captured: None,
..item.data
})
}
}
//Cancel
#[derive(Debug, Serialize)]
pub struct ForteCancelRequest {
action: String,
authorization_code: String,
}
impl TryFrom<&types::PaymentsCancelRouterData> for ForteCancelRequest {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(item: &types::PaymentsCancelRouterData) -> Result<Self, Self::Error> {
let action = "void".to_string();
let connector_auth_id: ForteMeta =
utils::to_connector_meta(item.request.connector_meta.clone())?;
let authorization_code = connector_auth_id.auth_id;
Ok(Self {
action,
authorization_code,
})
}
}
#[derive(Debug, Deserialize, Serialize)]
pub struct CancelResponseStatus {
pub response_type: String,
pub response_code: ForteResponseCode,
pub response_desc: String,
pub authorization_code: String,
}
#[derive(Debug, Deserialize, Serialize)]
pub struct ForteCancelResponse {
pub transaction_id: String,
pub location_id: Secret<String>,
pub action: String,
pub authorization_code: String,
pub entered_by: String,
pub response: CancelResponseStatus,
}
impl<F, T> TryFrom<ResponseRouterData<F, ForteCancelResponse, T, PaymentsResponseData>>
for RouterData<F, T, PaymentsResponseData>
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: ResponseRouterData<F, ForteCancelResponse, T, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
let transaction_id = &item.response.transaction_id;
Ok(Self {
status: enums::AttemptStatus::from(item.response.response.response_code),
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(transaction_id.to_string()),
redirection_data: Box::new(None),
mandate_reference: Box::new(None),
connector_metadata: Some(serde_json::json!(ForteMeta {
auth_id: item.response.authorization_code,
})),
network_txn_id: None,
connector_response_reference_id: Some(transaction_id.to_string()),
incremental_authorization_allowed: None,
charges: None,
}),
..item.data
})
}
}
// REFUND :
#[derive(Default, Debug, Serialize)]
pub struct ForteRefundRequest {
action: String,
authorization_amount: FloatMajorUnit,
original_transaction_id: String,
authorization_code: String,
}
impl<F> TryFrom<&ForteRouterData<&types::RefundsRouterData<F>>> for ForteRefundRequest {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item_data: &ForteRouterData<&types::RefundsRouterData<F>>,
) -> Result<Self, Self::Error> {
let item = item_data.router_data;
let trn_id = item.request.connector_transaction_id.clone();
let connector_auth_id: ForteMeta =
utils::to_connector_meta(item.request.connector_metadata.clone())?;
let auth_code = connector_auth_id.auth_id;
let authorization_amount = item_data.amount;
Ok(Self {
action: "reverse".to_string(),
authorization_amount,
original_transaction_id: trn_id,
authorization_code: auth_code,
})
}
}
#[derive(Debug, Deserialize, Serialize)]
#[serde(rename_all = "lowercase")]
pub enum RefundStatus {
Complete,
Ready,
Failed,
}
impl From<RefundStatus> for enums::RefundStatus {
fn from(item: RefundStatus) -> Self {
match item {
RefundStatus::Complete => Self::Success,
RefundStatus::Ready => Self::Pending,
RefundStatus::Failed => Self::Failure,
}
}
}
impl From<ForteResponseCode> for enums::RefundStatus {
fn from(item: ForteResponseCode) -> Self {
match item {
ForteResponseCode::A01 | ForteResponseCode::A05 | ForteResponseCode::A06 => {
Self::Pending
}
_ => Self::Failure,
}
}
}
#[derive(Debug, Deserialize, Serialize)]
pub struct RefundResponse {
pub transaction_id: String,
pub original_transaction_id: String,
pub action: String,
pub authorization_amount: Option<FloatMajorUnit>,
pub authorization_code: String,
pub response: ResponseStatus,
}
impl TryFrom<RefundsResponseRouterData<Execute, RefundResponse>>
for types::RefundsRouterData<Execute>
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: RefundsResponseRouterData<Execute, RefundResponse>,
) -> Result<Self, Self::Error> {
Ok(Self {
response: Ok(RefundsResponseData {
connector_refund_id: item.response.transaction_id,
refund_status: enums::RefundStatus::from(item.response.response.response_code),
}),
..item.data
})
}
}
#[derive(Debug, Deserialize, Serialize)]
pub struct RefundSyncResponse {
status: RefundStatus,
transaction_id: String,
}
impl TryFrom<RefundsResponseRouterData<RSync, RefundSyncResponse>>
for types::RefundsRouterData<RSync>
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: RefundsResponseRouterData<RSync, RefundSyncResponse>,
) -> Result<Self, Self::Error> {
Ok(Self {
response: Ok(RefundsResponseData {
connector_refund_id: item.response.transaction_id,
refund_status: enums::RefundStatus::from(item.response.status),
}),
..item.data
})
}
}
#[derive(Debug, Deserialize, Serialize)]
pub struct ErrorResponseStatus {
pub environment: String,
pub response_type: Option<String>,
pub response_code: Option<String>,
pub response_desc: String,
}
#[derive(Debug, Deserialize, Serialize)]
pub struct ForteErrorResponse {
pub response: ErrorResponseStatus,
}
|
{
"crate": "hyperswitch_connectors",
"file": "crates/hyperswitch_connectors/src/connectors/forte/transformers.rs",
"file_size": null,
"is_async": null,
"is_pub": null,
"num_enums": 5,
"num_structs": 21,
"num_tables": null,
"score": null,
"total_crates": null
}
|
file_hyperswitch_connectors_-6747233942983860525
|
clm
|
file
|
// Repository: hyperswitch
// Crate: hyperswitch_connectors
// File: crates/hyperswitch_connectors/src/connectors/fiuu/transformers.rs
// Contains: 35 structs, 22 enums
use std::collections::HashMap;
use api_models::payments;
use cards::CardNumber;
use common_enums::{enums, BankNames, CaptureMethod, Currency};
use common_types::payments::ApplePayPredecryptData;
use common_utils::{
crypto::{self, GenerateDigest},
errors::CustomResult,
ext_traits::Encode,
pii::Email,
request::Method,
types::{AmountConvertor, StringMajorUnit, StringMajorUnitForConnector},
};
use error_stack::{Report, ResultExt};
use hyperswitch_domain_models::{
payment_method_data::{
BankRedirectData, Card, CardDetailsForNetworkTransactionId, GooglePayWalletData,
PaymentMethodData, RealTimePaymentData, WalletData,
},
router_data::{ConnectorAuthType, ErrorResponse, PaymentMethodToken, RouterData},
router_flow_types::refunds::{Execute, RSync},
router_request_types::{PaymentsAuthorizeData, ResponseId},
router_response_types::{
MandateReference, PaymentsResponseData, RedirectForm, RefundsResponseData,
},
types::{
PaymentsAuthorizeRouterData, PaymentsCancelRouterData, PaymentsCaptureRouterData,
PaymentsSyncRouterData, RefundSyncRouterData, RefundsRouterData,
},
};
use hyperswitch_interfaces::{consts, errors};
use masking::{ExposeInterface, PeekInterface, Secret};
use serde::{Deserialize, Serialize};
use strum::Display;
use url::Url;
// These needs to be accepted from SDK, need to be done after 1.0.0 stability as API contract will change
const GOOGLEPAY_API_VERSION_MINOR: u8 = 0;
const GOOGLEPAY_API_VERSION: u8 = 2;
use crate::{
constants,
types::{
PaymentsCancelResponseRouterData, PaymentsCaptureResponseRouterData,
PaymentsSyncResponseRouterData, RefundsResponseRouterData, ResponseRouterData,
},
unimplemented_payment_method,
utils::{self, PaymentsAuthorizeRequestData, QrImage, RefundsRequestData, RouterData as _},
};
pub struct FiuuRouterData<T> {
pub amount: StringMajorUnit,
pub router_data: T,
}
impl<T> From<(StringMajorUnit, T)> for FiuuRouterData<T> {
fn from((amount, item): (StringMajorUnit, T)) -> Self {
Self {
amount,
router_data: item,
}
}
}
pub struct FiuuAuthType {
pub(super) merchant_id: Secret<String>,
pub(super) verify_key: Secret<String>,
pub(super) secret_key: Secret<String>,
}
impl TryFrom<&ConnectorAuthType> for FiuuAuthType {
type Error = Report<errors::ConnectorError>;
fn try_from(auth_type: &ConnectorAuthType) -> Result<Self, Self::Error> {
match auth_type {
ConnectorAuthType::SignatureKey {
api_key,
key1,
api_secret,
} => Ok(Self {
merchant_id: key1.to_owned(),
verify_key: api_key.to_owned(),
secret_key: api_secret.to_owned(),
}),
_ => Err(errors::ConnectorError::FailedToObtainAuthType.into()),
}
}
}
#[derive(Serialize, Deserialize, Debug, Clone)]
#[serde(rename_all = "UPPERCASE")]
pub enum TxnType {
Sals,
Auts,
}
impl TryFrom<Option<CaptureMethod>> for TxnType {
type Error = Report<errors::ConnectorError>;
fn try_from(capture_method: Option<CaptureMethod>) -> Result<Self, Self::Error> {
match capture_method {
Some(CaptureMethod::Automatic) | Some(CaptureMethod::SequentialAutomatic) | None => {
Ok(Self::Sals)
}
Some(CaptureMethod::Manual) => Ok(Self::Auts),
_ => Err(errors::ConnectorError::CaptureMethodNotSupported.into()),
}
}
}
#[derive(Serialize, Deserialize, Display, Debug, Clone)]
enum TxnChannel {
#[serde(rename = "CREDITAN")]
#[strum(serialize = "CREDITAN")]
Creditan,
#[serde(rename = "RPP_DUITNOWQR")]
#[strum(serialize = "RPP_DUITNOWQR")]
RppDuitNowQr,
}
#[derive(Serialize, Deserialize, Display, Debug, Clone)]
#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
#[strum(serialize_all = "SCREAMING_SNAKE_CASE")]
pub enum FPXTxnChannel {
FpxAbb,
FpxUob,
FpxAbmb,
FpxScb,
FpxBsn,
FpxKfh,
FpxBmmb,
FpxBkrm,
FpxHsbc,
FpxAgrobank,
FpxBocm,
FpxMb2u,
FpxCimbclicks,
FpxAmb,
FpxHlb,
FpxPbb,
FpxRhb,
FpxBimb,
FpxOcbc,
}
#[derive(Debug, Clone, Serialize)]
pub enum BankCode {
PHBMMYKL,
AGOBMYK1,
MFBBMYKL,
ARBKMYKL,
BKCHMYKL,
BIMBMYKL,
BMMBMYKL,
BKRMMYK1,
BSNAMYK1,
CIBBMYKL,
HLBBMYKL,
HBMBMYKL,
KFHOMYKL,
MBBEMYKL,
PBBEMYKL,
RHBBMYKL,
SCBLMYKX,
UOVBMYKL,
OCBCMYKL,
}
impl TryFrom<BankNames> for BankCode {
type Error = Report<errors::ConnectorError>;
fn try_from(bank: BankNames) -> Result<Self, Self::Error> {
match bank {
BankNames::AffinBank => Ok(Self::PHBMMYKL),
BankNames::AgroBank => Ok(Self::AGOBMYK1),
BankNames::AllianceBank => Ok(Self::MFBBMYKL),
BankNames::AmBank => Ok(Self::ARBKMYKL),
BankNames::BankOfChina => Ok(Self::BKCHMYKL),
BankNames::BankIslam => Ok(Self::BIMBMYKL),
BankNames::BankMuamalat => Ok(Self::BMMBMYKL),
BankNames::BankRakyat => Ok(Self::BKRMMYK1),
BankNames::BankSimpananNasional => Ok(Self::BSNAMYK1),
BankNames::CimbBank => Ok(Self::CIBBMYKL),
BankNames::HongLeongBank => Ok(Self::HLBBMYKL),
BankNames::HsbcBank => Ok(Self::HBMBMYKL),
BankNames::KuwaitFinanceHouse => Ok(Self::KFHOMYKL),
BankNames::Maybank => Ok(Self::MBBEMYKL),
BankNames::PublicBank => Ok(Self::PBBEMYKL),
BankNames::RhbBank => Ok(Self::RHBBMYKL),
BankNames::StandardCharteredBank => Ok(Self::SCBLMYKX),
BankNames::UobBank => Ok(Self::UOVBMYKL),
BankNames::OcbcBank => Ok(Self::OCBCMYKL),
bank => Err(errors::ConnectorError::NotSupported {
message: format!("Invalid BankName for FPX Refund: {bank:?}"),
connector: "Fiuu",
})?,
}
}
}
impl TryFrom<BankNames> for FPXTxnChannel {
type Error = Report<errors::ConnectorError>;
fn try_from(bank_names: BankNames) -> Result<Self, Self::Error> {
match bank_names {
BankNames::AffinBank => Ok(Self::FpxAbb),
BankNames::AgroBank => Ok(Self::FpxAgrobank),
BankNames::AllianceBank => Ok(Self::FpxAbmb),
BankNames::AmBank => Ok(Self::FpxAmb),
BankNames::BankOfChina => Ok(Self::FpxBocm),
BankNames::BankIslam => Ok(Self::FpxBimb),
BankNames::BankMuamalat => Ok(Self::FpxBmmb),
BankNames::BankRakyat => Ok(Self::FpxBkrm),
BankNames::BankSimpananNasional => Ok(Self::FpxBsn),
BankNames::CimbBank => Ok(Self::FpxCimbclicks),
BankNames::HongLeongBank => Ok(Self::FpxHlb),
BankNames::HsbcBank => Ok(Self::FpxHsbc),
BankNames::KuwaitFinanceHouse => Ok(Self::FpxKfh),
BankNames::Maybank => Ok(Self::FpxMb2u),
BankNames::PublicBank => Ok(Self::FpxPbb),
BankNames::RhbBank => Ok(Self::FpxRhb),
BankNames::StandardCharteredBank => Ok(Self::FpxScb),
BankNames::UobBank => Ok(Self::FpxUob),
BankNames::OcbcBank => Ok(Self::FpxOcbc),
_ => Err(errors::ConnectorError::NotImplemented(
utils::get_unimplemented_payment_method_error_message("Fiuu"),
))?,
}
}
}
#[derive(Serialize, Debug, Clone)]
pub struct FiuuMandateRequest {
#[serde(rename = "0")]
mandate_request: Secret<String>,
}
#[derive(Serialize, Debug, Clone)]
pub struct FiuuRecurringRequest {
record_type: FiuuRecordType,
merchant_id: Secret<String>,
token: Secret<String>,
order_id: String,
currency: Currency,
amount: StringMajorUnit,
billing_name: Secret<String>,
email: Email,
verify_key: Secret<String>,
}
#[derive(Serialize, Debug, Clone, strum::Display)]
pub enum FiuuRecordType {
T,
}
impl TryFrom<&FiuuRouterData<&PaymentsAuthorizeRouterData>> for FiuuMandateRequest {
type Error = Report<errors::ConnectorError>;
fn try_from(item: &FiuuRouterData<&PaymentsAuthorizeRouterData>) -> Result<Self, Self::Error> {
let auth: FiuuAuthType = FiuuAuthType::try_from(&item.router_data.connector_auth_type)?;
let record_type = FiuuRecordType::T;
let merchant_id = auth.merchant_id;
let order_id = item.router_data.connector_request_reference_id.clone();
let currency = item.router_data.request.currency;
let amount = item.amount.clone();
let billing_name = item
.router_data
.request
.get_card_holder_name_from_additional_payment_method_data()?;
let email = item.router_data.get_billing_email()?;
let token = Secret::new(item.router_data.request.get_connector_mandate_id()?);
let verify_key = auth.verify_key;
let recurring_request = FiuuRecurringRequest {
record_type: record_type.clone(),
merchant_id: merchant_id.clone(),
token: token.clone(),
order_id: order_id.clone(),
currency,
amount: amount.clone(),
billing_name: billing_name.clone(),
email: email.clone(),
verify_key: verify_key.clone(),
};
let check_sum = calculate_check_sum(recurring_request)?;
let mandate_request = format!(
"{}|{}||{}|{}|{}|{}|{}|{}|||{}",
record_type,
merchant_id.peek(),
token.peek(),
order_id,
currency,
amount.get_amount_as_string(),
billing_name.peek(),
email.peek(),
check_sum.peek()
);
Ok(Self {
mandate_request: mandate_request.into(),
})
}
}
pub fn calculate_check_sum(
req: FiuuRecurringRequest,
) -> CustomResult<Secret<String>, errors::ConnectorError> {
let formatted_string = format!(
"{}{}{}{}{}{}{}",
req.record_type,
req.merchant_id.peek(),
req.token.peek(),
req.order_id,
req.currency,
req.amount.get_amount_as_string(),
req.verify_key.peek()
);
Ok(Secret::new(hex::encode(
crypto::Md5
.generate_digest(formatted_string.as_bytes())
.change_context(errors::ConnectorError::RequestEncodingFailed)?,
)))
}
#[derive(Serialize, Debug, Clone)]
#[serde(rename_all = "PascalCase")]
pub struct FiuuPaymentRequest {
#[serde(rename = "MerchantID")]
merchant_id: Secret<String>,
reference_no: String,
txn_type: TxnType,
txn_currency: Currency,
txn_amount: StringMajorUnit,
signature: Secret<String>,
#[serde(rename = "ReturnURL")]
return_url: Option<String>,
#[serde(rename = "NotificationURL")]
notification_url: Option<Url>,
#[serde(flatten)]
payment_method_data: FiuuPaymentMethodData,
}
#[derive(Serialize, Debug, Clone)]
#[serde(untagged)]
pub enum FiuuPaymentMethodData {
FiuuQRData(Box<FiuuQRData>),
FiuuCardData(Box<FiuuCardData>),
FiuuCardWithNTI(Box<FiuuCardWithNTI>),
FiuuFpxData(Box<FiuuFPXData>),
FiuuGooglePayData(Box<FiuuGooglePayData>),
FiuuApplePayData(Box<FiuuApplePayData>),
}
#[derive(Serialize, Debug, Clone)]
#[serde(rename_all = "PascalCase")]
pub struct FiuuFPXData {
#[serde(rename = "non_3DS")]
non_3ds: i32,
txn_channel: FPXTxnChannel,
}
#[derive(Serialize, Debug, Clone)]
#[serde(rename_all = "PascalCase")]
pub struct FiuuQRData {
txn_channel: TxnChannel,
}
#[derive(Serialize, Debug, Clone)]
#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
pub struct FiuuCardData {
#[serde(rename = "non_3DS")]
non_3ds: i32,
#[serde(rename = "TxnChannel")]
txn_channel: TxnChannel,
cc_pan: CardNumber,
cc_cvv2: Secret<String>,
cc_month: Secret<String>,
cc_year: Secret<String>,
#[serde(rename = "mpstokenstatus")]
mps_token_status: Option<i32>,
#[serde(rename = "CustEmail")]
customer_email: Option<Email>,
}
#[derive(Serialize, Debug, Clone)]
#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
pub struct FiuuCardWithNTI {
#[serde(rename = "TxnChannel")]
txn_channel: TxnChannel,
cc_pan: CardNumber,
cc_month: Secret<String>,
cc_year: Secret<String>,
#[serde(rename = "OriginalSchemeID")]
original_scheme_id: Secret<String>,
}
#[derive(Serialize, Debug, Clone)]
#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
pub struct FiuuApplePayData {
#[serde(rename = "TxnChannel")]
txn_channel: TxnChannel,
cc_month: Secret<String>,
cc_year: Secret<String>,
cc_token: CardNumber,
eci: Option<String>,
token_cryptogram: Secret<String>,
token_type: FiuuTokenType,
#[serde(rename = "non_3DS")]
non_3ds: i32,
}
#[derive(Serialize, Debug, Clone)]
#[serde(rename_all = "PascalCase")]
pub enum FiuuTokenType {
ApplePay,
GooglePay,
}
#[derive(Serialize, Debug, Clone)]
#[serde(rename_all = "PascalCase")]
pub struct FiuuGooglePayData {
txn_channel: TxnChannel,
#[serde(rename = "GooglePay[apiVersion]")]
api_version: u8,
#[serde(rename = "GooglePay[apiVersionMinor]")]
api_version_minor: u8,
#[serde(rename = "GooglePay[paymentMethodData][info][assuranceDetails][accountVerified]")]
account_verified: Option<bool>,
#[serde(
rename = "GooglePay[paymentMethodData][info][assuranceDetails][cardHolderAuthenticated]"
)]
card_holder_authenticated: Option<bool>,
#[serde(rename = "GooglePay[paymentMethodData][info][cardDetails]")]
card_details: String,
#[serde(rename = "GooglePay[paymentMethodData][info][cardNetwork]")]
card_network: String,
#[serde(rename = "GooglePay[paymentMethodData][tokenizationData][token]")]
token: Secret<String>,
#[serde(rename = "GooglePay[paymentMethodData][tokenizationData][type]")]
tokenization_data_type: Secret<String>,
#[serde(rename = "GooglePay[paymentMethodData][type]")]
pm_type: String,
#[serde(rename = "SCREAMING_SNAKE_CASE")]
token_type: FiuuTokenType,
#[serde(rename = "non_3DS")]
non_3ds: i32,
}
pub fn calculate_signature(
signature_data: String,
) -> Result<Secret<String>, Report<errors::ConnectorError>> {
let message = signature_data.as_bytes();
let encoded_data = hex::encode(
crypto::Md5
.generate_digest(message)
.change_context(errors::ConnectorError::RequestEncodingFailed)?,
);
Ok(Secret::new(encoded_data))
}
impl TryFrom<&FiuuRouterData<&PaymentsAuthorizeRouterData>> for FiuuPaymentRequest {
type Error = Report<errors::ConnectorError>;
fn try_from(item: &FiuuRouterData<&PaymentsAuthorizeRouterData>) -> Result<Self, Self::Error> {
let auth = FiuuAuthType::try_from(&item.router_data.connector_auth_type)?;
let merchant_id = auth.merchant_id.peek().to_string();
let txn_currency = item.router_data.request.currency;
let txn_amount = item.amount.clone();
let reference_no = item.router_data.connector_request_reference_id.clone();
let verify_key = auth.verify_key.peek().to_string();
let signature = calculate_signature(format!(
"{}{merchant_id}{reference_no}{verify_key}",
txn_amount.get_amount_as_string()
))?;
let txn_type = match item.router_data.request.is_auto_capture()? {
true => TxnType::Sals,
false => TxnType::Auts,
};
let return_url = item.router_data.request.router_return_url.clone();
let non_3ds = match item.router_data.is_three_ds() {
false => 1,
true => 0,
};
let notification_url = Some(
Url::parse(&item.router_data.request.get_webhook_url()?)
.change_context(errors::ConnectorError::RequestEncodingFailed)?,
);
let payment_method_data = match item
.router_data
.request
.mandate_id
.clone()
.and_then(|mandate_id| mandate_id.mandate_reference_id)
{
None => match item.router_data.request.payment_method_data {
PaymentMethodData::Card(ref card) => {
FiuuPaymentMethodData::try_from((card, item.router_data))
}
PaymentMethodData::RealTimePayment(ref real_time_payment_data) => {
match *real_time_payment_data.clone() {
RealTimePaymentData::DuitNow {} => {
Ok(FiuuPaymentMethodData::FiuuQRData(Box::new(FiuuQRData {
txn_channel: TxnChannel::RppDuitNowQr,
})))
}
RealTimePaymentData::Fps {}
| RealTimePaymentData::PromptPay {}
| RealTimePaymentData::VietQr {} => {
Err(errors::ConnectorError::NotImplemented(
utils::get_unimplemented_payment_method_error_message("fiuu"),
)
.into())
}
}
}
PaymentMethodData::BankRedirect(ref bank_redirect_data) => match bank_redirect_data
{
BankRedirectData::OnlineBankingFpx { ref issuer } => {
Ok(FiuuPaymentMethodData::FiuuFpxData(Box::new(FiuuFPXData {
txn_channel: FPXTxnChannel::try_from(*issuer)?,
non_3ds,
})))
}
BankRedirectData::BancontactCard { .. }
| BankRedirectData::Bizum {}
| BankRedirectData::Blik { .. }
| BankRedirectData::Eft { .. }
| BankRedirectData::Eps { .. }
| BankRedirectData::Giropay { .. }
| BankRedirectData::Ideal { .. }
| BankRedirectData::Interac { .. }
| BankRedirectData::OnlineBankingCzechRepublic { .. }
| BankRedirectData::OnlineBankingFinland { .. }
| BankRedirectData::OnlineBankingPoland { .. }
| BankRedirectData::OnlineBankingSlovakia { .. }
| BankRedirectData::OpenBankingUk { .. }
| BankRedirectData::Przelewy24 { .. }
| BankRedirectData::Sofort { .. }
| BankRedirectData::Trustly { .. }
| BankRedirectData::OnlineBankingThailand { .. }
| BankRedirectData::LocalBankRedirect {} => {
Err(errors::ConnectorError::NotImplemented(
utils::get_unimplemented_payment_method_error_message("fiuu"),
)
.into())
}
},
PaymentMethodData::Wallet(ref wallet_data) => match wallet_data {
WalletData::GooglePay(google_pay_data) => {
FiuuPaymentMethodData::try_from(google_pay_data)
}
WalletData::ApplePay(_apple_pay_data) => {
let payment_method_token = item.router_data.get_payment_method_token()?;
match payment_method_token {
PaymentMethodToken::Token(_) => {
Err(unimplemented_payment_method!("Apple Pay", "Manual", "Fiuu"))?
}
PaymentMethodToken::ApplePayDecrypt(decrypt_data) => {
FiuuPaymentMethodData::try_from(decrypt_data)
}
PaymentMethodToken::PazeDecrypt(_) => {
Err(unimplemented_payment_method!("Paze", "Fiuu"))?
}
PaymentMethodToken::GooglePayDecrypt(_) => {
Err(unimplemented_payment_method!("Google Pay", "Fiuu"))?
}
}
}
WalletData::AliPayQr(_)
| WalletData::AliPayRedirect(_)
| WalletData::AliPayHkRedirect(_)
| WalletData::AmazonPayRedirect(_)
| WalletData::Paysera(_)
| WalletData::Skrill(_)
| WalletData::BluecodeRedirect {}
| WalletData::MomoRedirect(_)
| WalletData::KakaoPayRedirect(_)
| WalletData::GoPayRedirect(_)
| WalletData::GcashRedirect(_)
| WalletData::ApplePayRedirect(_)
| WalletData::ApplePayThirdPartySdk(_)
| WalletData::DanaRedirect {}
| WalletData::GooglePayRedirect(_)
| WalletData::GooglePayThirdPartySdk(_)
| WalletData::MbWayRedirect(_)
| WalletData::MobilePayRedirect(_)
| WalletData::PaypalRedirect(_)
| WalletData::AmazonPay(_)
| WalletData::PaypalSdk(_)
| WalletData::Paze(_)
| WalletData::SamsungPay(_)
| WalletData::TwintRedirect {}
| WalletData::VippsRedirect {}
| WalletData::TouchNGoRedirect(_)
| WalletData::WeChatPayRedirect(_)
| WalletData::WeChatPayQr(_)
| WalletData::CashappQr(_)
| WalletData::SwishQr(_)
| WalletData::Mifinity(_)
| WalletData::RevolutPay(_) => Err(errors::ConnectorError::NotImplemented(
utils::get_unimplemented_payment_method_error_message("fiuu"),
)
.into()),
},
PaymentMethodData::CardRedirect(_)
| PaymentMethodData::PayLater(_)
| PaymentMethodData::BankDebit(_)
| PaymentMethodData::BankTransfer(_)
| PaymentMethodData::Crypto(_)
| PaymentMethodData::MandatePayment
| PaymentMethodData::MobilePayment(_)
| PaymentMethodData::Reward
| PaymentMethodData::Upi(_)
| PaymentMethodData::Voucher(_)
| PaymentMethodData::GiftCard(_)
| PaymentMethodData::CardToken(_)
| PaymentMethodData::OpenBanking(_)
| PaymentMethodData::NetworkToken(_)
| PaymentMethodData::CardDetailsForNetworkTransactionId(_) => {
Err(errors::ConnectorError::NotImplemented(
utils::get_unimplemented_payment_method_error_message("fiuu"),
)
.into())
}
},
// Card payments using network transaction ID
Some(payments::MandateReferenceId::NetworkMandateId(network_transaction_id)) => {
match item.router_data.request.payment_method_data {
PaymentMethodData::CardDetailsForNetworkTransactionId(ref raw_card_details) => {
FiuuPaymentMethodData::try_from((raw_card_details, network_transaction_id))
}
_ => Err(errors::ConnectorError::NotImplemented(
utils::get_unimplemented_payment_method_error_message("fiuu"),
)
.into()),
}
}
_ => Err(errors::ConnectorError::NotImplemented(
utils::get_unimplemented_payment_method_error_message("fiuu"),
)
.into()),
}?;
Ok(Self {
merchant_id: auth.merchant_id,
reference_no,
txn_type,
txn_currency,
txn_amount,
return_url,
payment_method_data,
signature,
notification_url,
})
}
}
impl TryFrom<(&Card, &PaymentsAuthorizeRouterData)> for FiuuPaymentMethodData {
type Error = Report<errors::ConnectorError>;
fn try_from(
(req_card, item): (&Card, &PaymentsAuthorizeRouterData),
) -> Result<Self, Self::Error> {
let (mps_token_status, customer_email) =
if item.request.is_customer_initiated_mandate_payment() {
(Some(1), Some(item.get_billing_email()?))
} else {
(Some(3), None)
};
let non_3ds = match item.is_three_ds() {
false => 1,
true => 0,
};
Ok(Self::FiuuCardData(Box::new(FiuuCardData {
txn_channel: TxnChannel::Creditan,
non_3ds,
cc_pan: req_card.card_number.clone(),
cc_cvv2: req_card.card_cvc.clone(),
cc_month: req_card.card_exp_month.clone(),
cc_year: req_card.card_exp_year.clone(),
mps_token_status,
customer_email,
})))
}
}
impl TryFrom<(&CardDetailsForNetworkTransactionId, String)> for FiuuPaymentMethodData {
type Error = Report<errors::ConnectorError>;
fn try_from(
(raw_card_data, network_transaction_id): (&CardDetailsForNetworkTransactionId, String),
) -> Result<Self, Self::Error> {
Ok(Self::FiuuCardWithNTI(Box::new(FiuuCardWithNTI {
txn_channel: TxnChannel::Creditan,
cc_pan: raw_card_data.card_number.clone(),
cc_month: raw_card_data.card_exp_month.clone(),
cc_year: raw_card_data.card_exp_year.clone(),
original_scheme_id: Secret::new(network_transaction_id),
})))
}
}
impl TryFrom<&GooglePayWalletData> for FiuuPaymentMethodData {
type Error = Report<errors::ConnectorError>;
fn try_from(data: &GooglePayWalletData) -> Result<Self, Self::Error> {
Ok(Self::FiuuGooglePayData(Box::new(FiuuGooglePayData {
txn_channel: TxnChannel::Creditan,
api_version: GOOGLEPAY_API_VERSION,
api_version_minor: GOOGLEPAY_API_VERSION_MINOR,
account_verified: data
.info
.assurance_details
.as_ref()
.map(|details| details.account_verified),
card_holder_authenticated: data
.info
.assurance_details
.as_ref()
.map(|details| details.card_holder_authenticated),
card_details: data.info.card_details.clone(),
card_network: data.info.card_network.clone(),
token: data
.tokenization_data
.get_encrypted_google_pay_token()
.change_context(errors::ConnectorError::MissingRequiredField {
field_name: "gpay wallet_token",
})?
.clone()
.into(),
tokenization_data_type: data
.tokenization_data
.get_encrypted_token_type()
.change_context(errors::ConnectorError::MissingRequiredField {
field_name: "gpay wallet token type",
})?
.clone()
.into(),
pm_type: data.pm_type.clone(),
token_type: FiuuTokenType::GooglePay,
// non_3ds field Applicable to card processing via specific processor using specific currency for pre-approved partner only.
// Equal to 0 by default and 1 for non-3DS transaction, That is why it is hardcoded to 1 for googlepay transactions.
non_3ds: 1,
})))
}
}
impl TryFrom<Box<ApplePayPredecryptData>> for FiuuPaymentMethodData {
type Error = Report<errors::ConnectorError>;
fn try_from(decrypt_data: Box<ApplePayPredecryptData>) -> Result<Self, Self::Error> {
Ok(Self::FiuuApplePayData(Box::new(FiuuApplePayData {
txn_channel: TxnChannel::Creditan,
cc_month: decrypt_data.get_expiry_month().change_context(
errors::ConnectorError::InvalidDataFormat {
field_name: "expiration_month",
},
)?,
cc_year: decrypt_data.get_four_digit_expiry_year(),
cc_token: decrypt_data.application_primary_account_number,
eci: decrypt_data.payment_data.eci_indicator,
token_cryptogram: decrypt_data.payment_data.online_payment_cryptogram,
token_type: FiuuTokenType::ApplePay,
// non_3ds field Applicable to card processing via specific processor using specific currency for pre-approved partner only.
// Equal to 0 by default and 1 for non-3DS transaction, That is why it is hardcoded to 1 for apple pay decrypt flow transactions.
non_3ds: 1,
})))
}
}
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "PascalCase")]
pub struct PaymentsResponse {
pub reference_no: String,
#[serde(rename = "TxnID")]
pub txn_id: String,
pub txn_type: TxnType,
pub txn_currency: Currency,
pub txn_amount: StringMajorUnit,
pub txn_channel: String,
pub txn_data: TxnData,
}
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "PascalCase")]
pub struct DuitNowQrCodeResponse {
pub reference_no: String,
pub txn_type: TxnType,
pub txn_currency: Currency,
pub txn_amount: StringMajorUnit,
pub txn_channel: String,
#[serde(rename = "TxnID")]
pub txn_id: String,
pub txn_data: QrTxnData,
}
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "PascalCase")]
pub struct QrTxnData {
pub request_data: QrRequestData,
}
#[derive(Debug, Serialize, Deserialize)]
pub struct QrRequestData {
pub qr_data: Secret<String>,
}
#[derive(Debug, Serialize, Deserialize)]
#[serde(untagged)]
pub enum FiuuPaymentsResponse {
PaymentResponse(Box<PaymentsResponse>),
QRPaymentResponse(Box<DuitNowQrCodeResponse>),
Error(FiuuErrorResponse),
RecurringResponse(Vec<Box<FiuuRecurringResponse>>),
}
#[derive(Debug, Serialize, Deserialize)]
pub struct FiuuRecurringResponse {
status: FiuuRecurringStautus,
#[serde(rename = "orderid")]
order_id: String,
#[serde(rename = "tranID")]
tran_id: Option<String>,
reason: Option<String>,
}
#[derive(Debug, Serialize, Deserialize, Clone)]
#[serde(rename_all = "snake_case")]
pub enum FiuuRecurringStautus {
Accepted,
Failed,
}
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "PascalCase")]
pub struct TxnData {
#[serde(rename = "RequestURL")]
pub request_url: String,
pub request_type: RequestType,
pub request_data: RequestData,
pub request_method: String,
}
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "UPPERCASE")]
pub enum RequestType {
Redirect,
Response,
}
#[derive(Debug, Serialize, Deserialize)]
#[serde(untagged)]
pub enum RequestData {
NonThreeDS(NonThreeDSResponseData),
RedirectData(Option<HashMap<String, String>>),
}
#[derive(Debug, Serialize, Deserialize)]
pub struct QrCodeData {
#[serde(rename = "tranID")]
pub tran_id: String,
pub status: String,
}
#[derive(Debug, Serialize, Deserialize)]
pub struct NonThreeDSResponseData {
#[serde(rename = "tranID")]
pub tran_id: String,
pub status: String,
#[serde(rename = "extraP")]
pub extra_parameters: Option<ExtraParameters>,
pub error_code: Option<String>,
pub error_desc: Option<String>,
}
#[derive(Debug, Serialize, Deserialize, Clone)]
pub struct ExtraParameters {
pub token: Option<Secret<String>>,
}
impl<F>
TryFrom<
ResponseRouterData<F, FiuuPaymentsResponse, PaymentsAuthorizeData, PaymentsResponseData>,
> for RouterData<F, PaymentsAuthorizeData, PaymentsResponseData>
{
type Error = Report<errors::ConnectorError>;
fn try_from(
item: ResponseRouterData<
F,
FiuuPaymentsResponse,
PaymentsAuthorizeData,
PaymentsResponseData,
>,
) -> Result<Self, Self::Error> {
match item.response {
FiuuPaymentsResponse::QRPaymentResponse(ref response) => Ok(Self {
status: enums::AttemptStatus::AuthenticationPending,
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(response.txn_id.clone()),
redirection_data: Box::new(None),
mandate_reference: Box::new(None),
connector_metadata: get_qr_metadata(response)?,
network_txn_id: None,
connector_response_reference_id: None,
incremental_authorization_allowed: None,
charges: None,
}),
..item.data
}),
FiuuPaymentsResponse::Error(error) => Ok(Self {
response: Err(ErrorResponse {
code: error.error_code.clone(),
message: error.error_desc.clone(),
reason: Some(error.error_desc),
status_code: item.http_code,
attempt_status: None,
connector_transaction_id: None,
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
connector_metadata: None,
}),
..item.data
}),
FiuuPaymentsResponse::PaymentResponse(data) => match data.txn_data.request_data {
RequestData::RedirectData(redirection_data) => {
let redirection_data = Some(RedirectForm::Form {
endpoint: data.txn_data.request_url.to_string(),
method: if data.txn_data.request_method.as_str() == "POST" {
Method::Post
} else {
Method::Get
},
form_fields: redirection_data.unwrap_or_default(),
});
Ok(Self {
status: enums::AttemptStatus::AuthenticationPending,
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(data.txn_id),
redirection_data: Box::new(redirection_data),
mandate_reference: Box::new(None),
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: None,
incremental_authorization_allowed: None,
charges: None,
}),
..item.data
})
}
RequestData::NonThreeDS(non_threeds_data) => {
let mandate_reference =
non_threeds_data
.extra_parameters
.as_ref()
.and_then(|extra_p| {
extra_p.token.as_ref().map(|token| MandateReference {
connector_mandate_id: Some(token.clone().expose()),
payment_method_id: None,
mandate_metadata: None,
connector_mandate_request_reference_id: None,
})
});
let status = match non_threeds_data.status.as_str() {
"00" => {
if item.data.request.is_auto_capture()? {
Ok(enums::AttemptStatus::Charged)
} else {
Ok(enums::AttemptStatus::Authorized)
}
}
"11" => Ok(enums::AttemptStatus::Failure),
"22" => Ok(enums::AttemptStatus::Pending),
other => Err(errors::ConnectorError::UnexpectedResponseError(
bytes::Bytes::from(other.to_owned()),
)),
}?;
let response = if status == enums::AttemptStatus::Failure {
Err(ErrorResponse {
code: non_threeds_data
.error_code
.clone()
.unwrap_or_else(|| consts::NO_ERROR_CODE.to_string()),
message: non_threeds_data
.error_desc
.clone()
.unwrap_or_else(|| consts::NO_ERROR_MESSAGE.to_string()),
reason: non_threeds_data.error_desc.clone(),
status_code: item.http_code,
attempt_status: None,
connector_transaction_id: Some(data.txn_id),
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
connector_metadata: None,
})
} else {
Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(data.txn_id.clone()),
redirection_data: Box::new(None),
mandate_reference: Box::new(mandate_reference),
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: None,
incremental_authorization_allowed: None,
charges: None,
})
};
Ok(Self {
status,
response,
..item.data
})
}
},
FiuuPaymentsResponse::RecurringResponse(ref recurring_response_vec) => {
let recurring_response_item = recurring_response_vec.first();
let router_data_response = match recurring_response_item {
Some(recurring_response) => {
let status =
common_enums::AttemptStatus::from(recurring_response.status.clone());
let connector_transaction_id = recurring_response
.tran_id
.as_ref()
.map_or(ResponseId::NoResponseId, |tran_id| {
ResponseId::ConnectorTransactionId(tran_id.clone())
});
let response = if status == common_enums::AttemptStatus::Failure {
Err(ErrorResponse {
code: recurring_response
.reason
.clone()
.unwrap_or_else(|| consts::NO_ERROR_CODE.to_string()),
message: recurring_response
.reason
.clone()
.unwrap_or_else(|| consts::NO_ERROR_MESSAGE.to_string()),
reason: recurring_response.reason.clone(),
status_code: item.http_code,
attempt_status: None,
connector_transaction_id: recurring_response.tran_id.clone(),
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
connector_metadata: None,
})
} else {
Ok(PaymentsResponseData::TransactionResponse {
resource_id: connector_transaction_id,
redirection_data: Box::new(None),
mandate_reference: Box::new(None),
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: None,
incremental_authorization_allowed: None,
charges: None,
})
};
Self {
status,
response,
..item.data
}
}
None => {
// It is not expected to get empty response from the connnector, if we get we are not updating the payment response since we don't have any info in the authorize response.
let response = Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::NoResponseId,
redirection_data: Box::new(None),
mandate_reference: Box::new(None),
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: None,
incremental_authorization_allowed: None,
charges: None,
});
Self {
response,
..item.data
}
}
};
Ok(router_data_response)
}
}
}
}
impl From<FiuuRecurringStautus> for common_enums::AttemptStatus {
fn from(status: FiuuRecurringStautus) -> Self {
match status {
FiuuRecurringStautus::Accepted => Self::Charged,
FiuuRecurringStautus::Failed => Self::Failure,
}
}
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "PascalCase")]
pub struct FiuuRefundRequest {
pub refund_type: RefundType,
#[serde(rename = "MerchantID")]
pub merchant_id: Secret<String>,
#[serde(rename = "RefID")]
pub ref_id: String,
#[serde(rename = "TxnID")]
pub txn_id: String,
pub amount: StringMajorUnit,
pub signature: Secret<String>,
#[serde(rename = "notify_url")]
pub notify_url: Option<Url>,
}
#[derive(Debug, Serialize, Display)]
pub enum RefundType {
#[serde(rename = "P")]
#[strum(serialize = "P")]
Partial,
}
impl TryFrom<&FiuuRouterData<&RefundsRouterData<Execute>>> for FiuuRefundRequest {
type Error = Report<errors::ConnectorError>;
fn try_from(item: &FiuuRouterData<&RefundsRouterData<Execute>>) -> Result<Self, Self::Error> {
let auth: FiuuAuthType = FiuuAuthType::try_from(&item.router_data.connector_auth_type)?;
let merchant_id = auth.merchant_id.peek().to_string();
let txn_amount = item.amount.clone();
let reference_no = item.router_data.connector_request_reference_id.clone();
let txn_id = item.router_data.request.connector_transaction_id.clone();
let secret_key = auth.secret_key.peek().to_string();
Ok(Self {
refund_type: RefundType::Partial,
merchant_id: auth.merchant_id,
ref_id: reference_no.clone(),
txn_id: txn_id.clone(),
amount: txn_amount.clone(),
signature: calculate_signature(format!(
"{}{merchant_id}{reference_no}{txn_id}{}{secret_key}",
RefundType::Partial,
txn_amount.get_amount_as_string()
))?,
notify_url: Some(
Url::parse(&item.router_data.request.get_webhook_url()?)
.change_context(errors::ConnectorError::RequestEncodingFailed)?,
),
})
}
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "PascalCase")]
pub struct FiuuRefundSuccessResponse {
#[serde(rename = "RefundID")]
refund_id: i64,
status: String,
#[serde(rename = "reason")]
reason: Option<String>,
}
#[derive(Debug, Serialize, Deserialize)]
#[serde(untagged)]
pub enum FiuuRefundResponse {
Success(FiuuRefundSuccessResponse),
Error(FiuuErrorResponse),
}
impl TryFrom<RefundsResponseRouterData<Execute, FiuuRefundResponse>>
for RefundsRouterData<Execute>
{
type Error = Report<errors::ConnectorError>;
fn try_from(
item: RefundsResponseRouterData<Execute, FiuuRefundResponse>,
) -> Result<Self, Self::Error> {
match item.response {
FiuuRefundResponse::Error(error) => Ok(Self {
response: Err(ErrorResponse {
code: error.error_code.clone(),
message: error.error_desc.clone(),
reason: Some(error.error_desc),
status_code: item.http_code,
attempt_status: None,
connector_transaction_id: None,
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
connector_metadata: None,
}),
..item.data
}),
FiuuRefundResponse::Success(refund_data) => {
let refund_status = match refund_data.status.as_str() {
"00" => Ok(enums::RefundStatus::Success),
"11" => Ok(enums::RefundStatus::Failure),
"22" => Ok(enums::RefundStatus::Pending),
other => Err(errors::ConnectorError::UnexpectedResponseError(
bytes::Bytes::from(other.to_owned()),
)),
}?;
if refund_status == enums::RefundStatus::Failure {
Ok(Self {
response: Err(ErrorResponse {
code: refund_data.status.clone(),
message: refund_data
.reason
.clone()
.unwrap_or(consts::NO_ERROR_MESSAGE.to_string()),
reason: refund_data.reason.clone(),
status_code: item.http_code,
attempt_status: None,
connector_transaction_id: Some(refund_data.refund_id.to_string()),
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
connector_metadata: None,
}),
..item.data
})
} else {
Ok(Self {
response: Ok(RefundsResponseData {
connector_refund_id: refund_data.refund_id.clone().to_string(),
refund_status,
}),
..item.data
})
}
}
}
}
}
#[derive(Debug, Serialize, Deserialize)]
pub struct FiuuErrorResponse {
pub error_code: String,
pub error_desc: String,
}
#[derive(Debug, Serialize, Deserialize)]
pub struct FiuuPaymentSyncRequest {
amount: StringMajorUnit,
#[serde(rename = "txID")]
tx_id: String,
domain: String,
skey: Secret<String>,
}
#[derive(Debug, Serialize, Deserialize, Clone)]
#[serde(untagged)]
pub enum FiuuPaymentResponse {
FiuuPaymentSyncResponse(FiuuPaymentSyncResponse),
FiuuWebhooksPaymentResponse(FiuuWebhooksPaymentResponse),
}
#[derive(Debug, Serialize, Deserialize, Clone)]
#[serde(rename_all = "PascalCase")]
pub struct FiuuPaymentSyncResponse {
stat_code: StatCode,
stat_name: StatName,
#[serde(rename = "TranID")]
tran_id: String,
error_code: Option<String>,
error_desc: Option<String>,
#[serde(rename = "miscellaneous")]
miscellaneous: Option<HashMap<String, Secret<String>>>,
#[serde(rename = "SchemeTransactionID")]
scheme_transaction_id: Option<Secret<String>>,
}
#[derive(Debug, Serialize, Deserialize, Display, Clone, PartialEq)]
pub enum StatCode {
#[serde(rename = "00")]
Success,
#[serde(rename = "11")]
Failure,
#[serde(rename = "22")]
Pending,
}
#[derive(Debug, Serialize, Deserialize, Display, Clone, Copy, PartialEq)]
#[serde(rename_all = "lowercase")]
pub enum StatName {
Captured,
Settled,
Authorized,
Failed,
Cancelled,
Chargeback,
Release,
#[serde(rename = "reject/hold")]
RejectHold,
Blocked,
#[serde(rename = "ReqCancel")]
ReqCancel,
#[serde(rename = "ReqChargeback")]
ReqChargeback,
#[serde(rename = "Pending")]
Pending,
#[serde(rename = "Unknown")]
Unknown,
}
impl TryFrom<&PaymentsSyncRouterData> for FiuuPaymentSyncRequest {
type Error = Report<errors::ConnectorError>;
fn try_from(item: &PaymentsSyncRouterData) -> Result<Self, Self::Error> {
let auth = FiuuAuthType::try_from(&item.connector_auth_type)?;
let txn_id = item
.request
.connector_transaction_id
.get_connector_transaction_id()
.change_context(errors::ConnectorError::MissingConnectorTransactionID)?;
let merchant_id = auth.merchant_id.peek().to_string();
let verify_key = auth.verify_key.peek().to_string();
let amount = StringMajorUnitForConnector
.convert(item.request.amount, item.request.currency)
.change_context(errors::ConnectorError::AmountConversionFailed)?;
Ok(Self {
amount: amount.clone(),
tx_id: txn_id.clone(),
domain: merchant_id.clone(),
skey: calculate_signature(format!(
"{txn_id}{merchant_id}{verify_key}{}",
amount.get_amount_as_string()
))?,
})
}
}
struct ErrorInputs {
encoded_data: Option<String>,
response_error_code: Option<String>,
response_error_desc: Option<String>,
}
struct ErrorDetails {
pub code: String,
pub message: String,
pub reason: Option<String>,
}
impl TryFrom<ErrorInputs> for ErrorDetails {
type Error = Report<errors::ConnectorError>;
fn try_from(value: ErrorInputs) -> Result<Self, Self::Error> {
let query_params = value
.encoded_data
.as_ref()
.map(|encoded_data| {
serde_urlencoded::from_str::<FiuuPaymentRedirectResponse>(encoded_data)
})
.transpose()
.change_context(errors::ConnectorError::ResponseDeserializationFailed)
.attach_printable("Failed to deserialize FiuuPaymentRedirectResponse")?;
let error_message = value
.response_error_desc
.as_ref()
.filter(|s| !s.is_empty())
.cloned()
.or_else(|| {
query_params
.as_ref()
.and_then(|qp| qp.error_desc.as_ref())
.filter(|s| !s.is_empty())
.cloned()
});
let error_code = value
.response_error_code
.as_ref()
.filter(|s| !s.is_empty())
.cloned()
.or_else(|| {
query_params
.as_ref()
.and_then(|qp| qp.error_code.as_ref())
.filter(|s| !s.is_empty())
.cloned()
})
.unwrap_or_else(|| consts::NO_ERROR_CODE.to_owned());
Ok(Self {
code: error_code,
message: error_message
.clone()
.unwrap_or_else(|| consts::NO_ERROR_MESSAGE.to_owned()),
reason: error_message,
})
}
}
impl TryFrom<PaymentsSyncResponseRouterData<FiuuPaymentResponse>> for PaymentsSyncRouterData {
type Error = Report<errors::ConnectorError>;
fn try_from(
item: PaymentsSyncResponseRouterData<FiuuPaymentResponse>,
) -> Result<Self, Self::Error> {
match item.response {
FiuuPaymentResponse::FiuuPaymentSyncResponse(response) => {
let stat_name = response.stat_name;
let stat_code = response.stat_code.clone();
let txn_id = response.tran_id;
let status = enums::AttemptStatus::try_from(FiuuSyncStatus {
stat_name,
stat_code,
})?;
let error_response = if status == enums::AttemptStatus::Failure {
let error_details = ErrorDetails::try_from(ErrorInputs {
encoded_data: item.data.request.encoded_data.clone(),
response_error_code: response.error_code.clone(),
response_error_desc: response.error_desc.clone(),
})?;
Some(ErrorResponse {
status_code: item.http_code,
code: error_details.code,
message: error_details.message,
reason: error_details.reason,
attempt_status: Some(enums::AttemptStatus::Failure),
connector_transaction_id: Some(txn_id.clone()),
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
connector_metadata: None,
})
} else {
None
};
let payments_response_data = PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(txn_id.clone().to_string()),
redirection_data: Box::new(None),
mandate_reference: Box::new(None),
connector_metadata: None,
network_txn_id: response
.scheme_transaction_id
.as_ref()
.map(|id| id.clone().expose()),
connector_response_reference_id: None,
incremental_authorization_allowed: None,
charges: None,
};
Ok(Self {
status,
response: error_response.map_or_else(|| Ok(payments_response_data), Err),
..item.data
})
}
FiuuPaymentResponse::FiuuWebhooksPaymentResponse(response) => {
let status = enums::AttemptStatus::try_from(FiuuWebhookStatus {
capture_method: item.data.request.capture_method,
status: response.status,
})?;
let txn_id = response.tran_id;
let mandate_reference = response.extra_parameters.as_ref().and_then(|extra_p| {
let mandate_token: Result<ExtraParameters, _> = serde_json::from_str(&extra_p.clone().expose());
match mandate_token {
Ok(token) => {
token.token.as_ref().map(|token| MandateReference {
connector_mandate_id: Some(token.clone().expose()),
payment_method_id: None,
mandate_metadata: None,
connector_mandate_request_reference_id:None
})
}
Err(err) => {
router_env::logger::warn!(
"Failed to convert 'extraP' from fiuu webhook response to fiuu::ExtraParameters. \
Input: '{:?}', Error: {}",
extra_p,
err
);
None
}
}
});
let error_response = if status == enums::AttemptStatus::Failure {
let error_details = ErrorDetails::try_from(ErrorInputs {
encoded_data: item.data.request.encoded_data.clone(),
response_error_code: response.error_code.clone(),
response_error_desc: response.error_desc.clone(),
})?;
Some(ErrorResponse {
status_code: item.http_code,
code: error_details.code,
message: error_details.message,
reason: error_details.reason,
attempt_status: Some(enums::AttemptStatus::Failure),
connector_transaction_id: Some(txn_id.clone()),
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
connector_metadata: None,
})
} else {
None
};
let payments_response_data = PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(txn_id.clone().to_string()),
redirection_data: Box::new(None),
mandate_reference: Box::new(mandate_reference),
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: None,
incremental_authorization_allowed: None,
charges: None,
};
Ok(Self {
status,
response: error_response.map_or_else(|| Ok(payments_response_data), Err),
..item.data
})
}
}
}
}
pub struct FiuuWebhookStatus {
pub capture_method: Option<CaptureMethod>,
pub status: FiuuPaymentWebhookStatus,
}
impl TryFrom<FiuuWebhookStatus> for enums::AttemptStatus {
type Error = Report<errors::ConnectorError>;
fn try_from(webhook_status: FiuuWebhookStatus) -> Result<Self, Self::Error> {
match webhook_status.status {
FiuuPaymentWebhookStatus::Success => match webhook_status.capture_method {
Some(CaptureMethod::Automatic) | Some(CaptureMethod::SequentialAutomatic) => {
Ok(Self::Charged)
}
Some(CaptureMethod::Manual) => Ok(Self::Authorized),
_ => Err(errors::ConnectorError::UnexpectedResponseError(
bytes::Bytes::from(webhook_status.status.to_string()),
))?,
},
FiuuPaymentWebhookStatus::Failure => Ok(Self::Failure),
FiuuPaymentWebhookStatus::Pending => Ok(Self::AuthenticationPending),
}
}
}
#[derive(Debug, Serialize, Deserialize)]
pub struct PaymentCaptureRequest {
domain: String,
#[serde(rename = "tranID")]
tran_id: String,
amount: StringMajorUnit,
#[serde(rename = "RefID")]
ref_id: String,
skey: Secret<String>,
}
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "PascalCase")]
pub struct PaymentCaptureResponse {
#[serde(rename = "TranID")]
tran_id: String,
stat_code: String,
}
pub struct FiuuSyncStatus {
pub stat_name: StatName,
pub stat_code: StatCode,
}
impl TryFrom<FiuuSyncStatus> for enums::AttemptStatus {
type Error = errors::ConnectorError;
fn try_from(sync_status: FiuuSyncStatus) -> Result<Self, Self::Error> {
match (sync_status.stat_code, sync_status.stat_name) {
(StatCode::Success, StatName::Captured | StatName::Settled) => Ok(Self::Charged), // For Success as StatCode we can only expect Captured,Settled and Authorized as StatName.
(StatCode::Success, StatName::Authorized) => Ok(Self::Authorized),
(StatCode::Pending, StatName::Pending) => Ok(Self::AuthenticationPending), // For Pending as StatCode we can only expect Pending and Unknown as StatName.
(StatCode::Pending, StatName::Unknown) => Ok(Self::Pending),
(StatCode::Failure, StatName::Cancelled) | (StatCode::Failure, StatName::ReqCancel) => {
Ok(Self::Voided)
}
(StatCode::Failure, _) => Ok(Self::Failure),
(other, _) => Err(errors::ConnectorError::UnexpectedResponseError(
bytes::Bytes::from(other.to_string()),
)),
}
}
}
impl TryFrom<&FiuuRouterData<&PaymentsCaptureRouterData>> for PaymentCaptureRequest {
type Error = Report<errors::ConnectorError>;
fn try_from(item: &FiuuRouterData<&PaymentsCaptureRouterData>) -> Result<Self, Self::Error> {
let auth = FiuuAuthType::try_from(&item.router_data.connector_auth_type)?;
let merchant_id = auth.merchant_id.peek().to_string();
let amount = item.amount.clone();
let txn_id = item.router_data.request.connector_transaction_id.clone();
let verify_key = auth.verify_key.peek().to_string();
let signature = calculate_signature(format!(
"{txn_id}{}{merchant_id}{verify_key}",
amount.get_amount_as_string()
))?;
Ok(Self {
domain: merchant_id,
tran_id: txn_id,
amount,
ref_id: item.router_data.connector_request_reference_id.clone(),
skey: signature,
})
}
}
fn capture_status_codes() -> HashMap<&'static str, &'static str> {
[
("00", "Capture successful"),
("11", "Capture failed"),
("12", "Invalid or unmatched security hash string"),
("13", "Not a credit card transaction"),
("15", "Requested day is on settlement day"),
("16", "Forbidden transaction"),
("17", "Transaction not found"),
("18", "Missing required parameter"),
("19", "Domain not found"),
("20", "Temporary out of service"),
("21", "Authorization expired"),
("23", "Partial capture not allowed"),
("24", "Transaction already captured"),
("25", "Requested amount exceeds available capture amount"),
("99", "General error (contact payment gateway support)"),
]
.into_iter()
.collect()
}
impl TryFrom<PaymentsCaptureResponseRouterData<PaymentCaptureResponse>>
for PaymentsCaptureRouterData
{
type Error = Report<errors::ConnectorError>;
fn try_from(
item: PaymentsCaptureResponseRouterData<PaymentCaptureResponse>,
) -> Result<Self, Self::Error> {
let status_code = item.response.stat_code;
let status = match status_code.as_str() {
"00" => Ok(enums::AttemptStatus::Charged),
"22" => Ok(enums::AttemptStatus::Pending),
"11" | "12" | "13" | "15" | "16" | "17" | "18" | "19" | "20" | "21" | "23" | "24"
| "25" | "99" => Ok(enums::AttemptStatus::Failure),
other => Err(errors::ConnectorError::UnexpectedResponseError(
bytes::Bytes::from(other.to_owned()),
)),
}?;
let capture_message_status = capture_status_codes();
let error_response = if status == enums::AttemptStatus::Failure {
let optional_message = capture_message_status
.get(status_code.as_str())
.copied()
.map(String::from);
Some(ErrorResponse {
status_code: item.http_code,
code: status_code.to_owned(),
message: optional_message
.clone()
.unwrap_or_else(|| consts::NO_ERROR_MESSAGE.to_string()),
reason: optional_message,
attempt_status: None,
connector_transaction_id: Some(item.response.tran_id.clone()),
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
connector_metadata: None,
})
} else {
None
};
let payments_response_data = PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(
item.response.tran_id.clone().to_string(),
),
redirection_data: Box::new(None),
mandate_reference: Box::new(None),
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: None,
incremental_authorization_allowed: None,
charges: None,
};
Ok(Self {
status,
response: error_response.map_or_else(|| Ok(payments_response_data), Err),
..item.data
})
}
}
#[derive(Debug, Serialize, Deserialize)]
pub struct FiuuPaymentCancelRequest {
#[serde(rename = "txnID")]
txn_id: String,
domain: String,
skey: Secret<String>,
}
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "PascalCase")]
pub struct FiuuPaymentCancelResponse {
#[serde(rename = "TranID")]
tran_id: String,
stat_code: String,
#[serde(rename = "miscellaneous")]
miscellaneous: Option<HashMap<String, Secret<String>>>,
}
impl TryFrom<&PaymentsCancelRouterData> for FiuuPaymentCancelRequest {
type Error = Report<errors::ConnectorError>;
fn try_from(item: &PaymentsCancelRouterData) -> Result<Self, Self::Error> {
let auth = FiuuAuthType::try_from(&item.connector_auth_type)?;
let txn_id = item.request.connector_transaction_id.clone();
let merchant_id = auth.merchant_id.peek().to_string();
let secret_key = auth.secret_key.peek().to_string();
Ok(Self {
txn_id: txn_id.clone(),
domain: merchant_id.clone(),
skey: calculate_signature(format!("{txn_id}{merchant_id}{secret_key}"))?,
})
}
}
fn void_status_codes() -> HashMap<&'static str, &'static str> {
[
("00", "Success (will proceed the request)"),
("11", "Failure"),
("12", "Invalid or unmatched security hash string"),
("13", "Not a refundable transaction"),
("14", "Transaction date more than 180 days"),
("15", "Requested day is on settlement day"),
("16", "Forbidden transaction"),
("17", "Transaction not found"),
("18", "Duplicate partial refund request"),
("19", "Merchant not found"),
("20", "Missing required parameter"),
(
"21",
"Transaction must be in authorized/captured/settled status",
),
]
.into_iter()
.collect()
}
impl TryFrom<PaymentsCancelResponseRouterData<FiuuPaymentCancelResponse>>
for PaymentsCancelRouterData
{
type Error = Report<errors::ConnectorError>;
fn try_from(
item: PaymentsCancelResponseRouterData<FiuuPaymentCancelResponse>,
) -> Result<Self, Self::Error> {
let status_code = item.response.stat_code;
let status = match status_code.as_str() {
"00" => Ok(enums::AttemptStatus::Voided),
"11" | "12" | "13" | "14" | "15" | "16" | "17" | "18" | "19" | "20" | "21" => {
Ok(enums::AttemptStatus::VoidFailed)
}
other => Err(errors::ConnectorError::UnexpectedResponseError(
bytes::Bytes::from(other.to_owned()),
)),
}?;
let void_message_status = void_status_codes();
let error_response = if status == enums::AttemptStatus::VoidFailed {
let optional_message = void_message_status
.get(status_code.as_str())
.copied()
.map(String::from);
Some(ErrorResponse {
status_code: item.http_code,
code: status_code.to_owned(),
message: optional_message
.clone()
.unwrap_or_else(|| consts::NO_ERROR_MESSAGE.to_string()),
reason: optional_message,
attempt_status: None,
connector_transaction_id: Some(item.response.tran_id.clone()),
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
connector_metadata: None,
})
} else {
None
};
let payments_response_data = PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(
item.response.tran_id.clone().to_string(),
),
redirection_data: Box::new(None),
mandate_reference: Box::new(None),
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: None,
incremental_authorization_allowed: None,
charges: None,
};
Ok(Self {
status,
response: error_response.map_or_else(|| Ok(payments_response_data), Err),
..item.data
})
}
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "PascalCase")]
pub struct FiuuRefundSyncRequest {
#[serde(rename = "TxnID")]
txn_id: String,
#[serde(rename = "MerchantID")]
merchant_id: Secret<String>,
signature: Secret<String>,
}
impl TryFrom<&RefundSyncRouterData> for FiuuRefundSyncRequest {
type Error = Report<errors::ConnectorError>;
fn try_from(item: &RefundSyncRouterData) -> Result<Self, Self::Error> {
let auth = FiuuAuthType::try_from(&item.connector_auth_type)?;
let (txn_id, merchant_id, verify_key) = (
item.request.connector_transaction_id.clone(),
auth.merchant_id.peek().to_string(),
auth.verify_key.peek().to_string(),
);
let signature = calculate_signature(format!("{txn_id}{merchant_id}{verify_key}"))?;
Ok(Self {
txn_id,
merchant_id: auth.merchant_id,
signature,
})
}
}
#[derive(Debug, Serialize, Deserialize)]
#[serde(untagged)]
pub enum FiuuRefundSyncResponse {
Success(Vec<RefundData>),
Error(FiuuErrorResponse),
Webhook(FiuuWebhooksRefundResponse),
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "PascalCase")]
pub struct RefundData {
#[serde(rename = "RefundID")]
refund_id: String,
status: RefundStatus,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "lowercase")]
pub enum RefundStatus {
Success,
Pending,
Rejected,
Processing,
}
impl TryFrom<RefundsResponseRouterData<RSync, FiuuRefundSyncResponse>>
for RefundsRouterData<RSync>
{
type Error = Report<errors::ConnectorError>;
fn try_from(
item: RefundsResponseRouterData<RSync, FiuuRefundSyncResponse>,
) -> Result<Self, Self::Error> {
match item.response {
FiuuRefundSyncResponse::Error(error) => Ok(Self {
response: Err(ErrorResponse {
code: error.error_code.clone(),
message: error.error_desc.clone(),
reason: Some(error.error_desc),
status_code: item.http_code,
attempt_status: None,
connector_transaction_id: None,
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
connector_metadata: None,
}),
..item.data
}),
FiuuRefundSyncResponse::Success(refund_data) => {
let refund = refund_data
.iter()
.find(|refund| {
Some(refund.refund_id.clone()) == item.data.request.connector_refund_id
})
.ok_or_else(|| errors::ConnectorError::MissingConnectorRefundID)?;
Ok(Self {
response: Ok(RefundsResponseData {
connector_refund_id: refund.refund_id.clone(),
refund_status: enums::RefundStatus::from(refund.status.clone()),
}),
..item.data
})
}
FiuuRefundSyncResponse::Webhook(fiuu_webhooks_refund_response) => Ok(Self {
response: Ok(RefundsResponseData {
connector_refund_id: fiuu_webhooks_refund_response.refund_id,
refund_status: enums::RefundStatus::from(
fiuu_webhooks_refund_response.status.clone(),
),
}),
..item.data
}),
}
}
}
impl From<RefundStatus> for enums::RefundStatus {
fn from(item: RefundStatus) -> Self {
match item {
RefundStatus::Pending => Self::Pending,
RefundStatus::Success => Self::Success,
RefundStatus::Rejected => Self::Failure,
RefundStatus::Processing => Self::Pending,
}
}
}
pub fn get_qr_metadata(
response: &DuitNowQrCodeResponse,
) -> CustomResult<Option<serde_json::Value>, errors::ConnectorError> {
let image_data = QrImage::new_colored_from_data(
response.txn_data.request_data.qr_data.peek().clone(),
constants::DUIT_NOW_BRAND_COLOR,
)
.change_context(errors::ConnectorError::ResponseHandlingFailed)?;
let image_data_url = Url::parse(image_data.data.clone().as_str()).ok();
let display_to_timestamp = None;
if let Some(color_image_data_url) = image_data_url {
let qr_code_info = payments::QrCodeInformation::QrColorDataUrl {
color_image_data_url,
display_to_timestamp,
display_text: Some(constants::DUIT_NOW_BRAND_TEXT.to_string()),
border_color: Some(constants::DUIT_NOW_BRAND_COLOR.to_string()),
};
Some(qr_code_info.encode_to_value())
.transpose()
.change_context(errors::ConnectorError::ResponseHandlingFailed)
} else {
Ok(None)
}
}
#[derive(Debug, Deserialize, Serialize, Clone)]
#[serde(untagged)]
pub enum FiuuWebhooksResponse {
FiuuWebhookPaymentResponse(FiuuWebhooksPaymentResponse),
FiuuWebhookRefundResponse(FiuuWebhooksRefundResponse),
}
#[derive(Debug, Deserialize, Serialize, Clone)]
pub struct FiuuWebhooksPaymentResponse {
pub skey: Secret<String>,
pub status: FiuuPaymentWebhookStatus,
#[serde(rename = "orderid")]
pub order_id: String,
#[serde(rename = "tranID")]
pub tran_id: String,
pub nbcb: String,
pub amount: StringMajorUnit,
pub currency: String,
pub domain: Secret<String>,
pub appcode: Option<Secret<String>>,
pub paydate: String,
pub channel: String,
pub error_desc: Option<String>,
pub error_code: Option<String>,
#[serde(rename = "extraP")]
pub extra_parameters: Option<Secret<String>>,
}
#[derive(Debug, Deserialize, Serialize, Clone)]
pub struct FiuuPaymentRedirectResponse {
pub skey: Secret<String>,
#[serde(rename = "tranID")]
pub tran_id: String,
pub status: FiuuPaymentWebhookStatus,
pub appcode: Option<String>,
pub error_code: Option<String>,
pub error_desc: Option<String>,
}
#[derive(Debug, Deserialize, Serialize, Clone)]
#[serde(rename_all = "PascalCase")]
pub struct FiuuWebhooksRefundResponse {
pub refund_type: FiuuWebhooksRefundType,
#[serde(rename = "MerchantID")]
pub merchant_id: Secret<String>,
#[serde(rename = "RefID")]
pub ref_id: String,
#[serde(rename = "RefundID")]
pub refund_id: String,
#[serde(rename = "TxnID")]
pub txn_id: String,
pub amount: StringMajorUnit,
pub status: FiuuRefundsWebhookStatus,
pub signature: Secret<String>,
}
#[derive(Debug, Deserialize, Serialize, Clone, strum::Display)]
pub enum FiuuRefundsWebhookStatus {
#[strum(serialize = "00")]
#[serde(rename = "00")]
RefundSuccess,
#[strum(serialize = "11")]
#[serde(rename = "11")]
RefundFailure,
#[strum(serialize = "22")]
#[serde(rename = "22")]
RefundPending,
}
#[derive(Debug, Deserialize, Serialize, Clone, strum::Display)]
pub enum FiuuWebhooksRefundType {
P,
}
#[derive(Debug, Deserialize, Serialize, Clone)]
pub struct FiuuWebhookSignature {
pub skey: Secret<String>,
}
#[derive(Debug, Deserialize, Serialize, Clone)]
pub struct FiuuWebhookResourceId {
pub skey: Secret<String>,
}
#[derive(Debug, Deserialize, Serialize, Clone)]
pub struct FiuWebhookEvent {
pub status: FiuuPaymentWebhookStatus,
}
#[derive(Debug, Deserialize, Serialize, Clone, strum::Display)]
pub enum FiuuPaymentWebhookStatus {
#[strum(serialize = "00")]
#[serde(rename = "00")]
Success,
#[strum(serialize = "11")]
#[serde(rename = "11")]
Failure,
#[strum(serialize = "22")]
#[serde(rename = "22")]
Pending,
}
impl From<FiuuPaymentWebhookStatus> for StatCode {
fn from(value: FiuuPaymentWebhookStatus) -> Self {
match value {
FiuuPaymentWebhookStatus::Success => Self::Success,
FiuuPaymentWebhookStatus::Failure => Self::Failure,
FiuuPaymentWebhookStatus::Pending => Self::Pending,
}
}
}
impl From<FiuuPaymentWebhookStatus> for api_models::webhooks::IncomingWebhookEvent {
fn from(value: FiuuPaymentWebhookStatus) -> Self {
match value {
FiuuPaymentWebhookStatus::Success => Self::PaymentIntentSuccess,
FiuuPaymentWebhookStatus::Failure => Self::PaymentIntentFailure,
FiuuPaymentWebhookStatus::Pending => Self::PaymentIntentProcessing,
}
}
}
impl From<FiuuRefundsWebhookStatus> for api_models::webhooks::IncomingWebhookEvent {
fn from(value: FiuuRefundsWebhookStatus) -> Self {
match value {
FiuuRefundsWebhookStatus::RefundSuccess => Self::RefundSuccess,
FiuuRefundsWebhookStatus::RefundFailure => Self::RefundFailure,
FiuuRefundsWebhookStatus::RefundPending => Self::EventNotSupported,
}
}
}
impl From<FiuuRefundsWebhookStatus> for enums::RefundStatus {
fn from(value: FiuuRefundsWebhookStatus) -> Self {
match value {
FiuuRefundsWebhookStatus::RefundFailure => Self::Failure,
FiuuRefundsWebhookStatus::RefundSuccess => Self::Success,
FiuuRefundsWebhookStatus::RefundPending => Self::Pending,
}
}
}
|
{
"crate": "hyperswitch_connectors",
"file": "crates/hyperswitch_connectors/src/connectors/fiuu/transformers.rs",
"file_size": null,
"is_async": null,
"is_pub": null,
"num_enums": 22,
"num_structs": 35,
"num_tables": null,
"score": null,
"total_crates": null
}
|
file_hyperswitch_connectors_4300195556613668630
|
clm
|
file
|
// Repository: hyperswitch
// Crate: hyperswitch_connectors
// File: crates/hyperswitch_connectors/src/connectors/peachpayments/transformers.rs
// Contains: 27 structs, 11 enums
use std::str::FromStr;
use cards::CardNumber;
use common_enums::enums as storage_enums;
use common_utils::{errors::CustomResult, pii, types::MinorUnit};
use error_stack::ResultExt;
use hyperswitch_domain_models::{
network_tokenization::NetworkTokenNumber,
payment_method_data::{Card, NetworkTokenData, PaymentMethodData},
router_data::{ConnectorAuthType, ErrorResponse, RouterData},
router_flow_types::refunds::{Execute, RSync},
router_request_types::{RefundsData, ResponseId},
router_response_types::{PaymentsResponseData, RefundsResponseData},
types::{
PaymentsAuthorizeRouterData, PaymentsCancelRouterData, PaymentsCaptureRouterData,
RefundsRouterData,
},
};
use hyperswitch_interfaces::{
consts::{NO_ERROR_CODE, NO_ERROR_MESSAGE},
errors,
};
use masking::Secret;
use serde::{Deserialize, Serialize};
use time::{format_description::well_known::Rfc3339, OffsetDateTime};
use crate::{
types::ResponseRouterData,
utils::{self, CardData, NetworkTokenData as _, RouterData as OtherRouterData},
};
//TODO: Fill the struct with respective fields
pub struct PeachpaymentsRouterData<T> {
pub amount: MinorUnit, // The type of amount that a connector accepts, for example, String, i64, f64, etc.
pub router_data: T,
}
impl<T> From<(MinorUnit, T)> for PeachpaymentsRouterData<T> {
fn from((amount, item): (MinorUnit, T)) -> Self {
//Todo : use utils to convert the amount to the type of amount that a connector accepts
Self {
amount,
router_data: item,
}
}
}
impl TryFrom<&Option<pii::SecretSerdeValue>> for PeachPaymentsConnectorMetadataObject {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(meta_data: &Option<pii::SecretSerdeValue>) -> Result<Self, Self::Error> {
let metadata = utils::to_connector_meta_from_secret::<Self>(meta_data.clone())
.change_context(errors::ConnectorError::InvalidConnectorConfig {
config: "metadata",
})?;
Ok(metadata)
}
}
const COF_DATA_TYPE: &str = "adhoc";
const COF_DATA_SOURCE: &str = "cit";
const COF_DATA_MODE: &str = "initial";
// Card Gateway API Transaction Request
#[derive(Debug, Serialize, PartialEq)]
#[serde(rename_all = "camelCase")]
pub struct PeachpaymentsPaymentsCardRequest {
pub charge_method: String,
pub reference_id: String,
pub ecommerce_card_payment_only_transaction_data: EcommercePaymentOnlyTransactionData,
#[serde(skip_serializing_if = "Option::is_none")]
pub pos_data: Option<serde_json::Value>,
pub send_date_time: String,
}
#[derive(Debug, Serialize, PartialEq)]
#[serde(rename_all = "camelCase")]
pub struct PeachpaymentsPaymentsNTRequest {
pub payment_method: String,
pub reference_id: String,
pub ecommerce_card_payment_only_transaction_data: EcommercePaymentOnlyTransactionData,
pub send_date_time: String,
}
#[derive(Debug, Serialize, PartialEq)]
#[serde(untagged)]
pub enum PeachpaymentsPaymentsRequest {
Card(PeachpaymentsPaymentsCardRequest),
NetworkToken(PeachpaymentsPaymentsNTRequest),
}
#[derive(Debug, Serialize, PartialEq)]
#[serde(rename_all = "camelCase")]
pub struct CardOnFileData {
#[serde(rename = "type")]
pub _type: String,
pub source: String,
pub mode: String,
}
#[derive(Debug, Serialize, PartialEq)]
#[serde(rename_all = "camelCase")]
pub struct EcommerceCardPaymentOnlyTransactionData {
pub merchant_information: MerchantInformation,
pub routing: Routing,
pub card: CardDetails,
pub amount: AmountDetails,
pub rrn: Option<String>,
}
#[derive(Debug, Serialize, PartialEq)]
#[serde(rename_all = "camelCase")]
pub struct EcommerceNetworkTokenPaymentOnlyTransactionData {
pub merchant_information: MerchantInformation,
pub routing: Routing,
pub network_token_data: NetworkTokenDetails,
pub amount: AmountDetails,
pub cof_data: CardOnFileData,
}
#[derive(Debug, Serialize, PartialEq)]
#[serde(untagged)]
pub enum EcommercePaymentOnlyTransactionData {
Card(EcommerceCardPaymentOnlyTransactionData),
NetworkToken(EcommerceNetworkTokenPaymentOnlyTransactionData),
}
#[derive(Debug, Serialize, Deserialize, PartialEq)]
#[serde(rename_all = "camelCase")]
pub struct MerchantInformation {
pub client_merchant_reference_id: Secret<String>,
pub name: Secret<String>,
pub mcc: Secret<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub phone: Option<Secret<String>>,
#[serde(skip_serializing_if = "Option::is_none")]
pub email: Option<pii::Email>,
#[serde(skip_serializing_if = "Option::is_none")]
pub mobile: Option<Secret<String>>,
#[serde(skip_serializing_if = "Option::is_none")]
pub address: Option<Secret<String>>,
#[serde(skip_serializing_if = "Option::is_none")]
pub city: Option<Secret<String>>,
#[serde(skip_serializing_if = "Option::is_none")]
pub postal_code: Option<Secret<String>>,
#[serde(skip_serializing_if = "Option::is_none")]
pub region_code: Option<Secret<String>>,
#[serde(skip_serializing_if = "Option::is_none")]
pub merchant_type: Option<MerchantType>,
#[serde(skip_serializing_if = "Option::is_none")]
pub website_url: Option<url::Url>,
}
#[derive(Debug, Serialize, Deserialize, PartialEq)]
#[serde(rename_all = "lowercase")]
pub enum MerchantType {
Standard,
Sub,
Iso,
}
#[derive(Debug, Serialize, Deserialize, PartialEq)]
#[serde(rename_all = "camelCase")]
pub struct Routing {
pub route: Route,
pub mid: Secret<String>,
pub tid: Secret<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub visa_payment_facilitator_id: Option<Secret<String>>,
#[serde(skip_serializing_if = "Option::is_none")]
pub master_card_payment_facilitator_id: Option<Secret<String>>,
#[serde(skip_serializing_if = "Option::is_none")]
pub sub_mid: Option<Secret<String>>,
#[serde(skip_serializing_if = "Option::is_none")]
pub amex_id: Option<Secret<String>>,
}
#[derive(Debug, Serialize, Deserialize, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum Route {
ExipayEmulator,
AbsaBase24,
NedbankPostbridge,
AbsaPostbridgeEcentric,
PostbridgeDirecttransact,
PostbridgeEfficacy,
FiservLloyds,
NfsIzwe,
AbsaHpsZambia,
EcentricEcommerce,
UnitTestEmptyConfig,
}
#[derive(Debug, Serialize, PartialEq)]
#[serde(rename_all = "camelCase")]
pub struct CardDetails {
pub pan: CardNumber,
#[serde(skip_serializing_if = "Option::is_none")]
pub cardholder_name: Option<Secret<String>>,
pub expiry_year: Secret<String>,
pub expiry_month: Secret<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub cvv: Option<Secret<String>>,
}
#[derive(Debug, Serialize, PartialEq)]
#[serde(rename_all = "camelCase")]
pub struct NetworkTokenDetails {
pub token: NetworkTokenNumber,
pub expiry_year: Secret<String>,
pub expiry_month: Secret<String>,
pub cryptogram: Option<Secret<String>>,
pub eci: Option<String>,
pub scheme: Option<CardNetworkLowercase>,
}
#[derive(Debug, Serialize, PartialEq)]
#[serde(rename_all = "lowercase")]
pub enum CardNetworkLowercase {
Visa,
Mastercard,
Amex,
Discover,
Jcb,
Diners,
CartesBancaires,
UnionPay,
Interac,
RuPay,
Maestro,
Star,
Pulse,
Accel,
Nyce,
}
impl From<common_enums::CardNetwork> for CardNetworkLowercase {
fn from(value: common_enums::CardNetwork) -> Self {
match value {
common_enums::CardNetwork::Visa => Self::Visa,
common_enums::CardNetwork::Mastercard => Self::Mastercard,
common_enums::CardNetwork::AmericanExpress => Self::Amex,
common_enums::CardNetwork::Discover => Self::Discover,
common_enums::CardNetwork::JCB => Self::Jcb,
common_enums::CardNetwork::DinersClub => Self::Diners,
common_enums::CardNetwork::CartesBancaires => Self::CartesBancaires,
common_enums::CardNetwork::UnionPay => Self::UnionPay,
common_enums::CardNetwork::Interac => Self::Interac,
common_enums::CardNetwork::RuPay => Self::RuPay,
common_enums::CardNetwork::Maestro => Self::Maestro,
common_enums::CardNetwork::Star => Self::Star,
common_enums::CardNetwork::Pulse => Self::Pulse,
common_enums::CardNetwork::Accel => Self::Accel,
common_enums::CardNetwork::Nyce => Self::Nyce,
}
}
}
#[derive(Debug, Serialize, Deserialize, Clone, PartialEq)]
#[serde(rename_all = "camelCase")]
pub struct AmountDetails {
pub amount: MinorUnit,
pub currency_code: String,
#[serde(skip_serializing_if = "Option::is_none")]
pub display_amount: Option<String>,
}
// Confirm Transaction Request (for capture)
#[derive(Debug, Serialize, PartialEq)]
#[serde(rename_all = "camelCase")]
pub struct PeachpaymentsConfirmRequest {
pub ecommerce_card_payment_only_confirmation_data: EcommerceCardPaymentOnlyConfirmationData,
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct PeachpaymentsRefundRequest {
pub reference_id: String,
pub ecommerce_card_payment_only_transaction_data: PeachpaymentsRefundTransactionData,
#[serde(skip_serializing_if = "Option::is_none")]
pub pos_data: Option<PosData>,
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct PosData {
pub referral: String,
}
#[derive(Debug, Serialize, PartialEq)]
#[serde(rename_all = "camelCase")]
pub struct PeachpaymentsRefundTransactionData {
pub amount: AmountDetails,
}
impl TryFrom<&RefundsRouterData<Execute>> for PeachpaymentsRefundRequest {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(item: &RefundsRouterData<Execute>) -> Result<Self, Self::Error> {
let amount = AmountDetails {
amount: item.request.minor_refund_amount,
currency_code: item.request.currency.to_string(),
display_amount: None,
};
let ecommerce_card_payment_only_transaction_data =
PeachpaymentsRefundTransactionData { amount };
Ok(Self {
reference_id: item.request.refund_id.clone(),
ecommerce_card_payment_only_transaction_data,
pos_data: None,
})
}
}
#[derive(Debug, Serialize, PartialEq)]
pub struct EcommerceCardPaymentOnlyConfirmationData {
pub amount: AmountDetails,
}
// Void Transaction Request
#[derive(Debug, Serialize, PartialEq)]
#[serde(rename_all = "camelCase")]
pub struct PeachpaymentsVoidRequest {
pub payment_method: PaymentMethod,
pub send_date_time: String,
pub failure_reason: FailureReason,
}
#[derive(Debug, Serialize, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum PaymentMethod {
EcommerceCardPaymentOnly,
}
impl TryFrom<&PeachpaymentsRouterData<&PaymentsCaptureRouterData>> for PeachpaymentsConfirmRequest {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: &PeachpaymentsRouterData<&PaymentsCaptureRouterData>,
) -> Result<Self, Self::Error> {
let amount_in_cents = item.amount;
let amount = AmountDetails {
amount: amount_in_cents,
currency_code: item.router_data.request.currency.to_string(),
display_amount: None,
};
let confirmation_data = EcommerceCardPaymentOnlyConfirmationData { amount };
Ok(Self {
ecommerce_card_payment_only_confirmation_data: confirmation_data,
})
}
}
#[derive(Default, Debug, Serialize, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum FailureReason {
UnableToSend,
#[default]
Timeout,
SecurityError,
IssuerUnavailable,
TooLateResponse,
Malfunction,
UnableToComplete,
OnlineDeclined,
SuspectedFraud,
CardDeclined,
Partial,
OfflineDeclined,
CustomerCancel,
}
impl FromStr for FailureReason {
type Err = error_stack::Report<errors::ConnectorError>;
fn from_str(value: &str) -> Result<Self, Self::Err> {
match value.to_lowercase().as_str() {
"unable_to_send" => Ok(Self::UnableToSend),
"timeout" => Ok(Self::Timeout),
"security_error" => Ok(Self::SecurityError),
"issuer_unavailable" => Ok(Self::IssuerUnavailable),
"too_late_response" => Ok(Self::TooLateResponse),
"malfunction" => Ok(Self::Malfunction),
"unable_to_complete" => Ok(Self::UnableToComplete),
"online_declined" => Ok(Self::OnlineDeclined),
"suspected_fraud" => Ok(Self::SuspectedFraud),
"card_declined" => Ok(Self::CardDeclined),
"partial" => Ok(Self::Partial),
"offline_declined" => Ok(Self::OfflineDeclined),
"customer_cancel" => Ok(Self::CustomerCancel),
_ => Ok(Self::Timeout),
}
}
}
impl TryFrom<&PaymentsCancelRouterData> for PeachpaymentsVoidRequest {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(item: &PaymentsCancelRouterData) -> Result<Self, Self::Error> {
let send_date_time = OffsetDateTime::now_utc()
.format(&Rfc3339)
.map_err(|_| errors::ConnectorError::ParsingFailed)?;
Ok(Self {
payment_method: PaymentMethod::EcommerceCardPaymentOnly,
send_date_time,
failure_reason: item
.request
.cancellation_reason
.as_ref()
.map(|reason| FailureReason::from_str(reason))
.transpose()?
.unwrap_or(FailureReason::Timeout),
})
}
}
#[derive(Debug, Serialize, Deserialize)]
pub struct PeachPaymentsConnectorMetadataObject {
pub client_merchant_reference_id: Secret<String>,
pub name: Secret<String>,
pub mcc: Secret<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub phone: Option<Secret<String>>,
#[serde(skip_serializing_if = "Option::is_none")]
pub email: Option<pii::Email>,
#[serde(skip_serializing_if = "Option::is_none")]
pub mobile: Option<Secret<String>>,
#[serde(skip_serializing_if = "Option::is_none")]
pub address: Option<Secret<String>>,
#[serde(skip_serializing_if = "Option::is_none")]
pub city: Option<Secret<String>>,
#[serde(skip_serializing_if = "Option::is_none")]
pub postal_code: Option<Secret<String>>,
#[serde(skip_serializing_if = "Option::is_none")]
pub region_code: Option<Secret<String>>,
#[serde(skip_serializing_if = "Option::is_none")]
pub merchant_type: Option<MerchantType>,
#[serde(skip_serializing_if = "Option::is_none")]
pub website_url: Option<url::Url>,
pub route: Route,
pub mid: Secret<String>,
pub tid: Secret<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub visa_payment_facilitator_id: Option<Secret<String>>,
#[serde(skip_serializing_if = "Option::is_none")]
pub master_card_payment_facilitator_id: Option<Secret<String>>,
#[serde(skip_serializing_if = "Option::is_none")]
pub sub_mid: Option<Secret<String>>,
#[serde(skip_serializing_if = "Option::is_none")]
pub amex_id: Option<Secret<String>>,
}
impl TryFrom<&PeachpaymentsRouterData<&PaymentsAuthorizeRouterData>>
for PeachpaymentsPaymentsRequest
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: &PeachpaymentsRouterData<&PaymentsAuthorizeRouterData>,
) -> Result<Self, Self::Error> {
if item.router_data.is_three_ds() {
return Err(errors::ConnectorError::NotSupported {
message: "3DS flow".to_string(),
connector: "Peachpayments",
}
.into());
}
match item.router_data.request.payment_method_data.clone() {
PaymentMethodData::Card(req_card) => Self::try_from((item, req_card)),
PaymentMethodData::NetworkToken(token_data) => Self::try_from((item, token_data)),
_ => Err(errors::ConnectorError::NotImplemented("Payment method".to_string()).into()),
}
}
}
impl
TryFrom<(
&PeachpaymentsRouterData<&PaymentsAuthorizeRouterData>,
NetworkTokenData,
)> for PeachpaymentsPaymentsRequest
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
(item, token_data): (
&PeachpaymentsRouterData<&PaymentsAuthorizeRouterData>,
NetworkTokenData,
),
) -> Result<Self, Self::Error> {
let amount_in_cents = item.amount;
let connector_merchant_config =
PeachPaymentsConnectorMetadataObject::try_from(&item.router_data.connector_meta_data)?;
let merchant_information = MerchantInformation {
client_merchant_reference_id: connector_merchant_config.client_merchant_reference_id,
name: connector_merchant_config.name,
mcc: connector_merchant_config.mcc,
phone: connector_merchant_config.phone,
email: connector_merchant_config.email,
mobile: connector_merchant_config.mobile,
address: connector_merchant_config.address,
city: connector_merchant_config.city,
postal_code: connector_merchant_config.postal_code,
region_code: connector_merchant_config.region_code,
merchant_type: connector_merchant_config.merchant_type,
website_url: connector_merchant_config.website_url,
};
// Get routing configuration from metadata
let routing = Routing {
route: connector_merchant_config.route,
mid: connector_merchant_config.mid,
tid: connector_merchant_config.tid,
visa_payment_facilitator_id: connector_merchant_config.visa_payment_facilitator_id,
master_card_payment_facilitator_id: connector_merchant_config
.master_card_payment_facilitator_id,
sub_mid: connector_merchant_config.sub_mid,
amex_id: connector_merchant_config.amex_id,
};
let network_token_data = NetworkTokenDetails {
token: token_data.get_network_token(),
expiry_year: token_data.get_token_expiry_year_2_digit()?,
expiry_month: token_data.get_network_token_expiry_month(),
cryptogram: token_data.get_cryptogram(),
eci: token_data.eci.clone(),
scheme: Some(CardNetworkLowercase::from(
token_data.card_network.clone().ok_or(
errors::ConnectorError::MissingRequiredField {
field_name: "card_network",
},
)?,
)),
};
let amount = AmountDetails {
amount: amount_in_cents,
currency_code: item.router_data.request.currency.to_string(),
display_amount: None,
};
let ecommerce_data = EcommercePaymentOnlyTransactionData::NetworkToken(
EcommerceNetworkTokenPaymentOnlyTransactionData {
merchant_information,
routing,
network_token_data,
amount,
cof_data: CardOnFileData {
_type: COF_DATA_TYPE.to_string(),
source: COF_DATA_SOURCE.to_string(),
mode: COF_DATA_MODE.to_string(),
},
},
);
// Generate current timestamp for sendDateTime (ISO 8601 format: YYYY-MM-DDTHH:MM:SSZ)
let send_date_time = OffsetDateTime::now_utc()
.format(&time::format_description::well_known::Iso8601::DEFAULT)
.map_err(|_| errors::ConnectorError::RequestEncodingFailed)?;
Ok(Self::NetworkToken(PeachpaymentsPaymentsNTRequest {
payment_method: "ecommerce_card_payment_only".to_string(),
reference_id: item.router_data.connector_request_reference_id.clone(),
ecommerce_card_payment_only_transaction_data: ecommerce_data,
send_date_time: send_date_time.clone(),
}))
}
}
impl TryFrom<(&PeachpaymentsRouterData<&PaymentsAuthorizeRouterData>, Card)>
for PeachpaymentsPaymentsRequest
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
(item, req_card): (&PeachpaymentsRouterData<&PaymentsAuthorizeRouterData>, Card),
) -> Result<Self, Self::Error> {
let amount_in_cents = item.amount;
let connector_merchant_config =
PeachPaymentsConnectorMetadataObject::try_from(&item.router_data.connector_meta_data)?;
let merchant_information = MerchantInformation {
client_merchant_reference_id: connector_merchant_config.client_merchant_reference_id,
name: connector_merchant_config.name,
mcc: connector_merchant_config.mcc,
phone: connector_merchant_config.phone,
email: connector_merchant_config.email,
mobile: connector_merchant_config.mobile,
address: connector_merchant_config.address,
city: connector_merchant_config.city,
postal_code: connector_merchant_config.postal_code,
region_code: connector_merchant_config.region_code,
merchant_type: connector_merchant_config.merchant_type,
website_url: connector_merchant_config.website_url,
};
// Get routing configuration from metadata
let routing = Routing {
route: connector_merchant_config.route,
mid: connector_merchant_config.mid,
tid: connector_merchant_config.tid,
visa_payment_facilitator_id: connector_merchant_config.visa_payment_facilitator_id,
master_card_payment_facilitator_id: connector_merchant_config
.master_card_payment_facilitator_id,
sub_mid: connector_merchant_config.sub_mid,
amex_id: connector_merchant_config.amex_id,
};
let card = CardDetails {
pan: req_card.card_number.clone(),
cardholder_name: req_card.card_holder_name.clone(),
expiry_year: req_card.get_card_expiry_year_2_digit()?,
expiry_month: req_card.card_exp_month.clone(),
cvv: Some(req_card.card_cvc.clone()),
};
let amount = AmountDetails {
amount: amount_in_cents,
currency_code: item.router_data.request.currency.to_string(),
display_amount: None,
};
let ecommerce_data =
EcommercePaymentOnlyTransactionData::Card(EcommerceCardPaymentOnlyTransactionData {
merchant_information,
routing,
card,
amount,
rrn: item.router_data.request.merchant_order_reference_id.clone(),
});
// Generate current timestamp for sendDateTime (ISO 8601 format: YYYY-MM-DDTHH:MM:SSZ)
let send_date_time = OffsetDateTime::now_utc()
.format(&time::format_description::well_known::Iso8601::DEFAULT)
.map_err(|_| errors::ConnectorError::RequestEncodingFailed)?;
Ok(Self::Card(PeachpaymentsPaymentsCardRequest {
charge_method: "ecommerce_card_payment_only".to_string(),
reference_id: item.router_data.connector_request_reference_id.clone(),
ecommerce_card_payment_only_transaction_data: ecommerce_data,
pos_data: None,
send_date_time,
}))
}
}
// Auth Struct for Card Gateway API
pub struct PeachpaymentsAuthType {
pub(crate) api_key: Secret<String>,
pub(crate) tenant_id: Secret<String>,
}
impl TryFrom<&ConnectorAuthType> for PeachpaymentsAuthType {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(auth_type: &ConnectorAuthType) -> Result<Self, Self::Error> {
if let ConnectorAuthType::BodyKey { api_key, key1 } = auth_type {
Ok(Self {
api_key: api_key.clone(),
tenant_id: key1.clone(),
})
} else {
Err(errors::ConnectorError::FailedToObtainAuthType)?
}
}
}
// Card Gateway API Response
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum PeachpaymentsPaymentStatus {
Successful,
Pending,
Authorized,
Approved,
ApprovedConfirmed,
Declined,
Failed,
Reversed,
ThreedsRequired,
Voided,
}
impl From<PeachpaymentsPaymentStatus> for common_enums::AttemptStatus {
fn from(item: PeachpaymentsPaymentStatus) -> Self {
match item {
// PENDING means authorized but not yet captured - requires confirmation
PeachpaymentsPaymentStatus::Pending
| PeachpaymentsPaymentStatus::Authorized
| PeachpaymentsPaymentStatus::Approved => Self::Authorized,
PeachpaymentsPaymentStatus::Declined | PeachpaymentsPaymentStatus::Failed => {
Self::Failure
}
PeachpaymentsPaymentStatus::Voided | PeachpaymentsPaymentStatus::Reversed => {
Self::Voided
}
PeachpaymentsPaymentStatus::ThreedsRequired => Self::AuthenticationPending,
PeachpaymentsPaymentStatus::ApprovedConfirmed
| PeachpaymentsPaymentStatus::Successful => Self::Charged,
}
}
}
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(untagged)]
pub enum PeachpaymentsPaymentsResponse {
Response(Box<PeachpaymentsPaymentsData>),
WebhookResponse(Box<PeachpaymentsIncomingWebhook>),
}
impl From<PeachpaymentsRefundStatus> for common_enums::RefundStatus {
fn from(item: PeachpaymentsRefundStatus) -> Self {
match item {
PeachpaymentsRefundStatus::ApprovedConfirmed => Self::Success,
PeachpaymentsRefundStatus::Failed | PeachpaymentsRefundStatus::Declined => {
Self::Failure
}
}
}
}
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
#[serde(rename_all = "camelCase")]
pub struct PeachpaymentsPaymentsData {
pub transaction_id: String,
pub response_code: Option<ResponseCode>,
pub transaction_result: PeachpaymentsPaymentStatus,
pub ecommerce_card_payment_only_transaction_data: Option<EcommerceCardPaymentOnlyResponseData>,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct PeachpaymentsRsyncResponse {
pub transaction_id: String,
pub transaction_result: PeachpaymentsRefundStatus,
pub response_code: Option<ResponseCode>,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct PeachpaymentsRefundResponse {
pub transaction_id: String,
pub original_transaction_id: Option<String>,
pub reference_id: String,
pub transaction_result: PeachpaymentsRefundStatus,
pub response_code: Option<ResponseCode>,
pub refund_balance_data: Option<RefundBalanceData>,
}
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum PeachpaymentsRefundStatus {
ApprovedConfirmed,
Declined,
Failed,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct RefundBalanceData {
pub amount: AmountDetails,
pub balance: AmountDetails,
pub refund_history: Vec<RefundHistory>,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct RefundHistory {
pub transaction_id: String,
pub reference_id: String,
pub amount: AmountDetails,
}
impl<F>
TryFrom<ResponseRouterData<F, PeachpaymentsRefundResponse, RefundsData, RefundsResponseData>>
for RouterData<F, RefundsData, RefundsResponseData>
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: ResponseRouterData<F, PeachpaymentsRefundResponse, RefundsData, RefundsResponseData>,
) -> Result<Self, Self::Error> {
let refund_status = common_enums::RefundStatus::from(item.response.transaction_result);
let response = if refund_status == storage_enums::RefundStatus::Failure {
Err(ErrorResponse {
code: get_error_code(item.response.response_code.as_ref()),
message: get_error_message(item.response.response_code.as_ref()),
reason: None,
status_code: item.http_code,
attempt_status: None,
connector_transaction_id: Some(item.response.transaction_id),
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
connector_metadata: None,
})
} else {
Ok(RefundsResponseData {
connector_refund_id: item.response.transaction_id,
refund_status,
})
};
Ok(Self {
response,
..item.data
})
}
}
impl
TryFrom<ResponseRouterData<RSync, PeachpaymentsRsyncResponse, RefundsData, RefundsResponseData>>
for RefundsRouterData<RSync>
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: ResponseRouterData<
RSync,
PeachpaymentsRsyncResponse,
RefundsData,
RefundsResponseData,
>,
) -> Result<Self, Self::Error> {
let refund_status = item.response.transaction_result.into();
let response = if refund_status == storage_enums::RefundStatus::Failure {
Err(ErrorResponse {
code: get_error_code(item.response.response_code.as_ref()),
message: get_error_message(item.response.response_code.as_ref()),
reason: None,
status_code: item.http_code,
attempt_status: None,
connector_transaction_id: Some(item.response.transaction_id),
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
connector_metadata: None,
})
} else {
Ok(RefundsResponseData {
connector_refund_id: item.response.transaction_id,
refund_status,
})
};
Ok(Self {
response,
..item.data
})
}
}
// Confirm Transaction Response
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
#[serde(rename_all = "camelCase")]
pub struct PeachpaymentsConfirmResponse {
pub transaction_id: String,
pub response_code: Option<ResponseCode>,
pub transaction_result: PeachpaymentsPaymentStatus,
pub authorization_code: Option<String>,
}
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
#[serde(rename_all = "camelCase")]
#[serde(untagged)]
pub enum ResponseCode {
Text(String),
Structured {
value: String,
description: String,
terminal_outcome_string: Option<String>,
receipt_string: Option<String>,
},
}
impl ResponseCode {
pub fn value(&self) -> Option<&String> {
match self {
Self::Structured { value, .. } => Some(value),
_ => None,
}
}
pub fn description(&self) -> Option<&String> {
match self {
Self::Structured { description, .. } => Some(description),
_ => None,
}
}
pub fn as_text(&self) -> Option<&String> {
match self {
Self::Text(s) => Some(s),
_ => None,
}
}
}
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
#[serde(rename_all = "camelCase")]
pub struct EcommerceCardPaymentOnlyResponseData {
pub amount: Option<AmountDetails>,
pub stan: Option<Secret<String>>,
pub rrn: Option<Secret<String>>,
pub approval_code: Option<String>,
pub merchant_advice_code: Option<String>,
pub description: Option<String>,
pub trace_id: Option<String>,
}
fn is_payment_success(value: Option<&String>) -> bool {
if let Some(val) = value {
val == "00" || val == "08" || val == "X94"
} else {
false
}
}
fn get_error_code(response_code: Option<&ResponseCode>) -> String {
response_code
.and_then(|code| code.value())
.map(|val| val.to_string())
.unwrap_or(
response_code
.and_then(|code| code.as_text())
.map(|text| text.to_string())
.unwrap_or(NO_ERROR_CODE.to_string()),
)
}
fn get_error_message(response_code: Option<&ResponseCode>) -> String {
response_code
.and_then(|code| code.description())
.map(|desc| desc.to_string())
.unwrap_or(
response_code
.and_then(|code| code.as_text())
.map(|text| text.to_string())
.unwrap_or(NO_ERROR_MESSAGE.to_string()),
)
}
pub fn get_peachpayments_response(
response: PeachpaymentsPaymentsData,
status_code: u16,
) -> CustomResult<
(
storage_enums::AttemptStatus,
Result<PaymentsResponseData, ErrorResponse>,
),
errors::ConnectorError,
> {
let status = common_enums::AttemptStatus::from(response.transaction_result);
let payments_response = if !is_payment_success(
response
.response_code
.as_ref()
.and_then(|code| code.value()),
) {
Err(ErrorResponse {
code: get_error_code(response.response_code.as_ref()),
message: get_error_message(response.response_code.as_ref()),
reason: response
.ecommerce_card_payment_only_transaction_data
.and_then(|data| data.description),
status_code,
attempt_status: Some(status),
connector_transaction_id: Some(response.transaction_id.clone()),
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
connector_metadata: None,
})
} else {
Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(response.transaction_id.clone()),
redirection_data: Box::new(None),
mandate_reference: Box::new(None),
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: Some(response.transaction_id),
incremental_authorization_allowed: None,
charges: None,
})
};
Ok((status, payments_response))
}
pub fn get_webhook_response(
response: PeachpaymentsIncomingWebhook,
status_code: u16,
) -> CustomResult<
(
storage_enums::AttemptStatus,
Result<PaymentsResponseData, ErrorResponse>,
),
errors::ConnectorError,
> {
let transaction = response
.transaction
.ok_or(errors::ConnectorError::WebhookResourceObjectNotFound)?;
let status = common_enums::AttemptStatus::from(transaction.transaction_result);
let webhook_response = if !is_payment_success(
transaction
.response_code
.as_ref()
.and_then(|code| code.value()),
) {
Err(ErrorResponse {
code: get_error_code(transaction.response_code.as_ref()),
message: get_error_message(transaction.response_code.as_ref()),
reason: transaction
.ecommerce_card_payment_only_transaction_data
.and_then(|data| data.description),
status_code,
attempt_status: Some(status),
connector_transaction_id: Some(transaction.transaction_id.clone()),
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
connector_metadata: None,
})
} else {
Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(
transaction
.original_transaction_id
.unwrap_or(transaction.transaction_id.clone()),
),
redirection_data: Box::new(None),
mandate_reference: Box::new(None),
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: Some(transaction.transaction_id.clone()),
incremental_authorization_allowed: None,
charges: None,
})
};
Ok((status, webhook_response))
}
impl<F, T> TryFrom<ResponseRouterData<F, PeachpaymentsPaymentsResponse, T, PaymentsResponseData>>
for RouterData<F, T, PaymentsResponseData>
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: ResponseRouterData<F, PeachpaymentsPaymentsResponse, T, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
let (status, response) = match item.response {
PeachpaymentsPaymentsResponse::Response(response) => {
get_peachpayments_response(*response, item.http_code)?
}
PeachpaymentsPaymentsResponse::WebhookResponse(response) => {
get_webhook_response(*response, item.http_code)?
}
};
Ok(Self {
status,
response,
..item.data
})
}
}
// TryFrom implementation for confirm response
impl<F, T> TryFrom<ResponseRouterData<F, PeachpaymentsConfirmResponse, T, PaymentsResponseData>>
for RouterData<F, T, PaymentsResponseData>
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: ResponseRouterData<F, PeachpaymentsConfirmResponse, T, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
let status = common_enums::AttemptStatus::from(item.response.transaction_result);
// Check if it's an error response
let response = if !is_payment_success(
item.response
.response_code
.as_ref()
.and_then(|code| code.value()),
) {
Err(ErrorResponse {
code: get_error_code(item.response.response_code.as_ref()),
message: get_error_message(item.response.response_code.as_ref()),
reason: None,
status_code: item.http_code,
attempt_status: Some(status),
connector_transaction_id: Some(item.response.transaction_id.clone()),
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
connector_metadata: None,
})
} else {
Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(
item.response.transaction_id.clone(),
),
redirection_data: Box::new(None),
mandate_reference: Box::new(None),
connector_metadata: item.response.authorization_code.map(|auth_code| {
serde_json::json!({
"authorization_code": auth_code
})
}),
network_txn_id: None,
connector_response_reference_id: Some(item.response.transaction_id),
incremental_authorization_allowed: None,
charges: None,
})
};
Ok(Self {
status,
response,
..item.data
})
}
}
impl TryFrom<&PeachpaymentsRouterData<&PaymentsAuthorizeRouterData>>
for PeachpaymentsConfirmRequest
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: &PeachpaymentsRouterData<&PaymentsAuthorizeRouterData>,
) -> Result<Self, Self::Error> {
let amount_in_cents = item.amount;
let amount = AmountDetails {
amount: amount_in_cents,
currency_code: item.router_data.request.currency.to_string(),
display_amount: None,
};
let confirmation_data = EcommerceCardPaymentOnlyConfirmationData { amount };
Ok(Self {
ecommerce_card_payment_only_confirmation_data: confirmation_data,
})
}
}
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
#[serde(rename_all = "camelCase")]
pub struct PeachpaymentsIncomingWebhook {
pub webhook_id: String,
pub webhook_type: String,
pub reversal_failure_reason: Option<String>,
pub transaction: Option<WebhookTransaction>,
}
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
#[serde(rename_all = "camelCase")]
pub struct WebhookTransaction {
pub transaction_id: String,
pub original_transaction_id: Option<String>,
pub reference_id: String,
pub transaction_result: PeachpaymentsPaymentStatus,
pub error_message: Option<String>,
pub response_code: Option<ResponseCode>,
pub ecommerce_card_payment_only_transaction_data: Option<EcommerceCardPaymentOnlyResponseData>,
pub payment_method: Secret<String>,
}
// Error Response
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct PeachpaymentsErrorResponse {
pub error_ref: String,
pub message: String,
}
impl TryFrom<ErrorResponse> for PeachpaymentsErrorResponse {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(error_response: ErrorResponse) -> Result<Self, Self::Error> {
Ok(Self {
error_ref: error_response.code,
message: error_response.message,
})
}
}
|
{
"crate": "hyperswitch_connectors",
"file": "crates/hyperswitch_connectors/src/connectors/peachpayments/transformers.rs",
"file_size": null,
"is_async": null,
"is_pub": null,
"num_enums": 11,
"num_structs": 27,
"num_tables": null,
"score": null,
"total_crates": null
}
|
file_hyperswitch_connectors_-6116885759985841990
|
clm
|
file
|
// Repository: hyperswitch
// Crate: hyperswitch_connectors
// File: crates/hyperswitch_connectors/src/connectors/aci/transformers.rs
// Contains: 32 structs, 13 enums
use std::str::FromStr;
use common_enums::enums;
use common_utils::{id_type, pii::Email, request::Method, types::StringMajorUnit};
use error_stack::report;
use hyperswitch_domain_models::{
network_tokenization::NetworkTokenNumber,
payment_method_data::{
BankRedirectData, Card, NetworkTokenData, PayLaterData, PaymentMethodData, WalletData,
},
router_data::{ConnectorAuthType, ErrorResponse, RouterData},
router_flow_types::SetupMandate,
router_request_types::{
PaymentsAuthorizeData, PaymentsCancelData, PaymentsSyncData, ResponseId,
SetupMandateRequestData,
},
router_response_types::{
MandateReference, PaymentsResponseData, RedirectForm, RefundsResponseData,
},
types::{
PaymentsAuthorizeRouterData, PaymentsCancelRouterData, PaymentsCaptureRouterData,
RefundsRouterData,
},
};
use hyperswitch_interfaces::errors;
use masking::{ExposeInterface, Secret};
use serde::{Deserialize, Serialize};
use url::Url;
use super::aci_result_codes::{FAILURE_CODES, PENDING_CODES, SUCCESSFUL_CODES};
use crate::{
types::{RefundsResponseRouterData, ResponseRouterData},
utils::{
self, CardData, NetworkTokenData as NetworkTokenDataTrait, PaymentsAuthorizeRequestData,
PhoneDetailsData, RouterData as _,
},
};
type Error = error_stack::Report<errors::ConnectorError>;
trait GetCaptureMethod {
fn get_capture_method(&self) -> Option<enums::CaptureMethod>;
}
impl GetCaptureMethod for PaymentsAuthorizeData {
fn get_capture_method(&self) -> Option<enums::CaptureMethod> {
self.capture_method
}
}
impl GetCaptureMethod for PaymentsSyncData {
fn get_capture_method(&self) -> Option<enums::CaptureMethod> {
self.capture_method
}
}
impl GetCaptureMethod for PaymentsCancelData {
fn get_capture_method(&self) -> Option<enums::CaptureMethod> {
None
}
}
#[derive(Debug, Serialize)]
pub struct AciRouterData<T> {
pub amount: StringMajorUnit,
pub router_data: T,
}
impl<T> From<(StringMajorUnit, T)> for AciRouterData<T> {
fn from((amount, item): (StringMajorUnit, T)) -> Self {
Self {
amount,
router_data: item,
}
}
}
pub struct AciAuthType {
pub api_key: Secret<String>,
pub entity_id: Secret<String>,
}
impl TryFrom<&ConnectorAuthType> for AciAuthType {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(item: &ConnectorAuthType) -> Result<Self, Self::Error> {
if let ConnectorAuthType::BodyKey { api_key, key1 } = item {
Ok(Self {
api_key: api_key.to_owned(),
entity_id: key1.to_owned(),
})
} else {
Err(errors::ConnectorError::FailedToObtainAuthType)?
}
}
}
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "UPPERCASE")]
pub enum AciRecurringType {
Initial,
Repeated,
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct AciPaymentsRequest {
#[serde(flatten)]
pub txn_details: TransactionDetails,
#[serde(flatten)]
pub payment_method: PaymentDetails,
#[serde(flatten)]
pub instruction: Option<Instruction>,
pub shopper_result_url: Option<String>,
#[serde(rename = "customParameters[3DS2_enrolled]")]
pub three_ds_two_enrolled: Option<bool>,
pub recurring_type: Option<AciRecurringType>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct TransactionDetails {
pub entity_id: Secret<String>,
pub amount: StringMajorUnit,
pub currency: String,
pub payment_type: AciPaymentType,
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct AciCancelRequest {
pub entity_id: Secret<String>,
pub payment_type: AciPaymentType,
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct AciMandateRequest {
pub entity_id: Secret<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub payment_brand: Option<PaymentBrand>,
#[serde(flatten)]
pub payment_details: PaymentDetails,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct AciMandateResponse {
pub id: String,
pub result: ResultCode,
pub build_number: String,
pub timestamp: String,
}
#[derive(Debug, Clone, Serialize)]
#[serde(untagged)]
pub enum PaymentDetails {
#[serde(rename = "card")]
AciCard(Box<CardDetails>),
BankRedirect(Box<BankRedirectionPMData>),
Wallet(Box<WalletPMData>),
Klarna,
Mandate,
AciNetworkToken(Box<AciNetworkTokenData>),
}
impl TryFrom<(&WalletData, &PaymentsAuthorizeRouterData)> for PaymentDetails {
type Error = Error;
fn try_from(value: (&WalletData, &PaymentsAuthorizeRouterData)) -> Result<Self, Self::Error> {
let (wallet_data, item) = value;
let payment_data = match wallet_data {
WalletData::MbWayRedirect(_) => {
let phone_details = item.get_billing_phone()?;
Self::Wallet(Box::new(WalletPMData {
payment_brand: PaymentBrand::Mbway,
account_id: Some(phone_details.get_number_with_hash_country_code()?),
}))
}
WalletData::AliPayRedirect { .. } => Self::Wallet(Box::new(WalletPMData {
payment_brand: PaymentBrand::AliPay,
account_id: None,
})),
WalletData::AliPayHkRedirect(_)
| WalletData::AmazonPayRedirect(_)
| WalletData::Paysera(_)
| WalletData::Skrill(_)
| WalletData::MomoRedirect(_)
| WalletData::KakaoPayRedirect(_)
| WalletData::GoPayRedirect(_)
| WalletData::GcashRedirect(_)
| WalletData::AmazonPay(_)
| WalletData::ApplePay(_)
| WalletData::ApplePayThirdPartySdk(_)
| WalletData::DanaRedirect { .. }
| WalletData::GooglePay(_)
| WalletData::BluecodeRedirect {}
| WalletData::GooglePayThirdPartySdk(_)
| WalletData::MobilePayRedirect(_)
| WalletData::PaypalRedirect(_)
| WalletData::PaypalSdk(_)
| WalletData::Paze(_)
| WalletData::SamsungPay(_)
| WalletData::TwintRedirect { .. }
| WalletData::VippsRedirect { .. }
| WalletData::TouchNGoRedirect(_)
| WalletData::WeChatPayRedirect(_)
| WalletData::WeChatPayQr(_)
| WalletData::CashappQr(_)
| WalletData::SwishQr(_)
| WalletData::AliPayQr(_)
| WalletData::ApplePayRedirect(_)
| WalletData::GooglePayRedirect(_)
| WalletData::Mifinity(_)
| WalletData::RevolutPay(_) => Err(errors::ConnectorError::NotImplemented(
"Payment method".to_string(),
))?,
};
Ok(payment_data)
}
}
impl
TryFrom<(
&AciRouterData<&PaymentsAuthorizeRouterData>,
&BankRedirectData,
)> for PaymentDetails
{
type Error = Error;
fn try_from(
value: (
&AciRouterData<&PaymentsAuthorizeRouterData>,
&BankRedirectData,
),
) -> Result<Self, Self::Error> {
let (item, bank_redirect_data) = value;
let payment_data = match bank_redirect_data {
BankRedirectData::Eps { .. } => Self::BankRedirect(Box::new(BankRedirectionPMData {
payment_brand: PaymentBrand::Eps,
bank_account_country: Some(item.router_data.get_billing_country()?),
bank_account_bank_name: None,
bank_account_bic: None,
bank_account_iban: None,
billing_country: None,
merchant_customer_id: None,
merchant_transaction_id: None,
customer_email: None,
})),
BankRedirectData::Eft { .. } => Self::BankRedirect(Box::new(BankRedirectionPMData {
payment_brand: PaymentBrand::Eft,
bank_account_country: Some(item.router_data.get_billing_country()?),
bank_account_bank_name: None,
bank_account_bic: None,
bank_account_iban: None,
billing_country: None,
merchant_customer_id: None,
merchant_transaction_id: None,
customer_email: None,
})),
BankRedirectData::Giropay {
bank_account_bic,
bank_account_iban,
..
} => Self::BankRedirect(Box::new(BankRedirectionPMData {
payment_brand: PaymentBrand::Giropay,
bank_account_country: Some(item.router_data.get_billing_country()?),
bank_account_bank_name: None,
bank_account_bic: bank_account_bic.clone(),
bank_account_iban: bank_account_iban.clone(),
billing_country: None,
merchant_customer_id: None,
merchant_transaction_id: None,
customer_email: None,
})),
BankRedirectData::Ideal { bank_name, .. } => {
Self::BankRedirect(Box::new(BankRedirectionPMData {
payment_brand: PaymentBrand::Ideal,
bank_account_country: Some(item.router_data.get_billing_country()?),
bank_account_bank_name: Some(bank_name.ok_or(
errors::ConnectorError::MissingRequiredField {
field_name: "ideal.bank_name",
},
)?),
bank_account_bic: None,
bank_account_iban: None,
billing_country: None,
merchant_customer_id: None,
merchant_transaction_id: None,
customer_email: None,
}))
}
BankRedirectData::Sofort { .. } => {
Self::BankRedirect(Box::new(BankRedirectionPMData {
payment_brand: PaymentBrand::Sofortueberweisung,
bank_account_country: Some(item.router_data.get_billing_country()?),
bank_account_bank_name: None,
bank_account_bic: None,
bank_account_iban: None,
billing_country: None,
merchant_customer_id: None,
merchant_transaction_id: None,
customer_email: None,
}))
}
BankRedirectData::Przelewy24 { .. } => {
Self::BankRedirect(Box::new(BankRedirectionPMData {
payment_brand: PaymentBrand::Przelewy,
bank_account_country: None,
bank_account_bank_name: None,
bank_account_bic: None,
bank_account_iban: None,
billing_country: None,
merchant_customer_id: None,
merchant_transaction_id: None,
customer_email: Some(item.router_data.get_billing_email()?),
}))
}
BankRedirectData::Interac { .. } => {
Self::BankRedirect(Box::new(BankRedirectionPMData {
payment_brand: PaymentBrand::InteracOnline,
bank_account_country: Some(item.router_data.get_billing_country()?),
bank_account_bank_name: None,
bank_account_bic: None,
bank_account_iban: None,
billing_country: None,
merchant_customer_id: None,
merchant_transaction_id: None,
customer_email: Some(item.router_data.get_billing_email()?),
}))
}
BankRedirectData::Trustly { .. } => {
Self::BankRedirect(Box::new(BankRedirectionPMData {
payment_brand: PaymentBrand::Trustly,
bank_account_country: None,
bank_account_bank_name: None,
bank_account_bic: None,
bank_account_iban: None,
billing_country: Some(item.router_data.get_billing_country()?),
merchant_customer_id: Some(Secret::new(item.router_data.get_customer_id()?)),
merchant_transaction_id: Some(Secret::new(
item.router_data.connector_request_reference_id.clone(),
)),
customer_email: None,
}))
}
BankRedirectData::Bizum { .. }
| BankRedirectData::Blik { .. }
| BankRedirectData::BancontactCard { .. }
| BankRedirectData::OnlineBankingCzechRepublic { .. }
| BankRedirectData::OnlineBankingFinland { .. }
| BankRedirectData::OnlineBankingFpx { .. }
| BankRedirectData::OnlineBankingPoland { .. }
| BankRedirectData::OnlineBankingSlovakia { .. }
| BankRedirectData::OnlineBankingThailand { .. }
| BankRedirectData::LocalBankRedirect {}
| BankRedirectData::OpenBankingUk { .. } => Err(
errors::ConnectorError::NotImplemented("Payment method".to_string()),
)?,
};
Ok(payment_data)
}
}
fn get_aci_payment_brand(
card_network: Option<common_enums::CardNetwork>,
is_network_token_flow: bool,
) -> Result<PaymentBrand, Error> {
match card_network {
Some(common_enums::CardNetwork::Visa) => Ok(PaymentBrand::Visa),
Some(common_enums::CardNetwork::Mastercard) => Ok(PaymentBrand::Mastercard),
Some(common_enums::CardNetwork::AmericanExpress) => Ok(PaymentBrand::AmericanExpress),
Some(common_enums::CardNetwork::JCB) => Ok(PaymentBrand::Jcb),
Some(common_enums::CardNetwork::DinersClub) => Ok(PaymentBrand::DinersClub),
Some(common_enums::CardNetwork::Discover) => Ok(PaymentBrand::Discover),
Some(common_enums::CardNetwork::UnionPay) => Ok(PaymentBrand::UnionPay),
Some(common_enums::CardNetwork::Maestro) => Ok(PaymentBrand::Maestro),
Some(unsupported_network) => Err(errors::ConnectorError::NotSupported {
message: format!("Card network {unsupported_network} is not supported by ACI"),
connector: "ACI",
})?,
None => {
if is_network_token_flow {
Ok(PaymentBrand::Visa)
} else {
Err(errors::ConnectorError::MissingRequiredField {
field_name: "card.card_network",
}
.into())
}
}
}
}
impl TryFrom<(Card, Option<Secret<String>>)> for PaymentDetails {
type Error = Error;
fn try_from(
(card_data, card_holder_name): (Card, Option<Secret<String>>),
) -> Result<Self, Self::Error> {
let card_expiry_year = card_data.get_expiry_year_4_digit();
let payment_brand = get_aci_payment_brand(card_data.card_network, false).ok();
Ok(Self::AciCard(Box::new(CardDetails {
card_number: card_data.card_number,
card_holder: card_holder_name.ok_or(errors::ConnectorError::MissingRequiredField {
field_name: "card_holder_name",
})?,
card_expiry_month: card_data.card_exp_month.clone(),
card_expiry_year,
card_cvv: card_data.card_cvc,
payment_brand,
})))
}
}
impl
TryFrom<(
&AciRouterData<&PaymentsAuthorizeRouterData>,
&NetworkTokenData,
)> for PaymentDetails
{
type Error = Error;
fn try_from(
value: (
&AciRouterData<&PaymentsAuthorizeRouterData>,
&NetworkTokenData,
),
) -> Result<Self, Self::Error> {
let (_item, network_token_data) = value;
let token_number = network_token_data.get_network_token();
let payment_brand = get_aci_payment_brand(network_token_data.card_network.clone(), true)?;
let aci_network_token_data = AciNetworkTokenData {
token_type: AciTokenAccountType::Network,
token_number,
token_expiry_month: network_token_data.get_network_token_expiry_month(),
token_expiry_year: network_token_data.get_expiry_year_4_digit(),
token_cryptogram: Some(
network_token_data
.get_cryptogram()
.clone()
.unwrap_or_default(),
),
payment_brand,
};
Ok(Self::AciNetworkToken(Box::new(aci_network_token_data)))
}
}
#[derive(Debug, Clone, Serialize)]
#[serde(rename_all = "UPPERCASE")]
pub enum AciTokenAccountType {
Network,
}
#[derive(Debug, Clone, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct AciNetworkTokenData {
#[serde(rename = "tokenAccount.type")]
pub token_type: AciTokenAccountType,
#[serde(rename = "tokenAccount.number")]
pub token_number: NetworkTokenNumber,
#[serde(rename = "tokenAccount.expiryMonth")]
pub token_expiry_month: Secret<String>,
#[serde(rename = "tokenAccount.expiryYear")]
pub token_expiry_year: Secret<String>,
#[serde(rename = "tokenAccount.cryptogram")]
pub token_cryptogram: Option<Secret<String>>,
#[serde(rename = "paymentBrand")]
pub payment_brand: PaymentBrand,
}
#[derive(Debug, Clone, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct BankRedirectionPMData {
payment_brand: PaymentBrand,
#[serde(rename = "bankAccount.country")]
bank_account_country: Option<api_models::enums::CountryAlpha2>,
#[serde(rename = "bankAccount.bankName")]
bank_account_bank_name: Option<common_enums::BankNames>,
#[serde(rename = "bankAccount.bic")]
bank_account_bic: Option<Secret<String>>,
#[serde(rename = "bankAccount.iban")]
bank_account_iban: Option<Secret<String>>,
#[serde(rename = "billing.country")]
billing_country: Option<api_models::enums::CountryAlpha2>,
#[serde(rename = "customer.email")]
customer_email: Option<Email>,
#[serde(rename = "customer.merchantCustomerId")]
merchant_customer_id: Option<Secret<id_type::CustomerId>>,
merchant_transaction_id: Option<Secret<String>>,
}
#[derive(Debug, Clone, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct WalletPMData {
payment_brand: PaymentBrand,
#[serde(rename = "virtualAccount.accountId")]
account_id: Option<Secret<String>>,
}
#[derive(Debug, Clone, Eq, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
pub enum PaymentBrand {
Eps,
Eft,
Ideal,
Giropay,
Sofortueberweisung,
InteracOnline,
Przelewy,
Trustly,
Mbway,
#[serde(rename = "ALIPAY")]
AliPay,
// Card network brands
#[serde(rename = "VISA")]
Visa,
#[serde(rename = "MASTER")]
Mastercard,
#[serde(rename = "AMEX")]
AmericanExpress,
#[serde(rename = "JCB")]
Jcb,
#[serde(rename = "DINERS")]
DinersClub,
#[serde(rename = "DISCOVER")]
Discover,
#[serde(rename = "UNIONPAY")]
UnionPay,
#[serde(rename = "MAESTRO")]
Maestro,
}
#[derive(Debug, Clone, Eq, PartialEq, Serialize)]
pub struct CardDetails {
#[serde(rename = "card.number")]
pub card_number: cards::CardNumber,
#[serde(rename = "card.holder")]
pub card_holder: Secret<String>,
#[serde(rename = "card.expiryMonth")]
pub card_expiry_month: Secret<String>,
#[serde(rename = "card.expiryYear")]
pub card_expiry_year: Secret<String>,
#[serde(rename = "card.cvv")]
pub card_cvv: Secret<String>,
#[serde(rename = "paymentBrand")]
#[serde(skip_serializing_if = "Option::is_none")]
pub payment_brand: Option<PaymentBrand>,
}
#[derive(Debug, Clone, Serialize)]
#[serde(rename_all = "UPPERCASE")]
pub enum InstructionMode {
Initial,
Repeated,
}
#[derive(Debug, Clone, Serialize)]
#[serde(rename_all = "UPPERCASE")]
pub enum InstructionType {
Unscheduled,
}
#[derive(Debug, Clone, Serialize)]
pub enum InstructionSource {
#[serde(rename = "CIT")]
CardholderInitiatedTransaction,
#[serde(rename = "MIT")]
MerchantInitiatedTransaction,
}
#[derive(Debug, Clone, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct Instruction {
#[serde(rename = "standingInstruction.mode")]
mode: InstructionMode,
#[serde(rename = "standingInstruction.type")]
transaction_type: InstructionType,
#[serde(rename = "standingInstruction.source")]
source: InstructionSource,
create_registration: Option<bool>,
}
#[derive(Debug, Clone, Eq, PartialEq, Serialize)]
pub struct BankDetails {
#[serde(rename = "bankAccount.holder")]
pub account_holder: Secret<String>,
}
#[allow(dead_code)]
#[derive(Debug, Default, Clone, Eq, PartialEq, Serialize, Deserialize)]
pub enum AciPaymentType {
#[serde(rename = "PA")]
Preauthorization,
#[default]
#[serde(rename = "DB")]
Debit,
#[serde(rename = "CD")]
Credit,
#[serde(rename = "CP")]
Capture,
#[serde(rename = "RV")]
Reversal,
#[serde(rename = "RF")]
Refund,
}
impl TryFrom<&AciRouterData<&PaymentsAuthorizeRouterData>> for AciPaymentsRequest {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(item: &AciRouterData<&PaymentsAuthorizeRouterData>) -> Result<Self, Self::Error> {
match item.router_data.request.payment_method_data.clone() {
PaymentMethodData::Card(ref card_data) => Self::try_from((item, card_data)),
PaymentMethodData::NetworkToken(ref network_token_data) => {
Self::try_from((item, network_token_data))
}
PaymentMethodData::Wallet(ref wallet_data) => Self::try_from((item, wallet_data)),
PaymentMethodData::PayLater(ref pay_later_data) => {
Self::try_from((item, pay_later_data))
}
PaymentMethodData::BankRedirect(ref bank_redirect_data) => {
Self::try_from((item, bank_redirect_data))
}
PaymentMethodData::MandatePayment => {
let mandate_id = item.router_data.request.mandate_id.clone().ok_or(
errors::ConnectorError::MissingRequiredField {
field_name: "mandate_id",
},
)?;
Self::try_from((item, mandate_id))
}
PaymentMethodData::Crypto(_)
| PaymentMethodData::BankDebit(_)
| PaymentMethodData::BankTransfer(_)
| PaymentMethodData::Reward
| PaymentMethodData::RealTimePayment(_)
| PaymentMethodData::MobilePayment(_)
| PaymentMethodData::GiftCard(_)
| PaymentMethodData::CardRedirect(_)
| PaymentMethodData::Upi(_)
| PaymentMethodData::Voucher(_)
| PaymentMethodData::OpenBanking(_)
| PaymentMethodData::CardToken(_)
| PaymentMethodData::CardDetailsForNetworkTransactionId(_) => {
Err(errors::ConnectorError::NotImplemented(
utils::get_unimplemented_payment_method_error_message("Aci"),
))?
}
}
}
}
impl TryFrom<(&AciRouterData<&PaymentsAuthorizeRouterData>, &WalletData)> for AciPaymentsRequest {
type Error = Error;
fn try_from(
value: (&AciRouterData<&PaymentsAuthorizeRouterData>, &WalletData),
) -> Result<Self, Self::Error> {
let (item, wallet_data) = value;
let txn_details = get_transaction_details(item)?;
let payment_method = PaymentDetails::try_from((wallet_data, item.router_data))?;
Ok(Self {
txn_details,
payment_method,
instruction: None,
shopper_result_url: item.router_data.request.router_return_url.clone(),
three_ds_two_enrolled: None,
recurring_type: None,
})
}
}
impl
TryFrom<(
&AciRouterData<&PaymentsAuthorizeRouterData>,
&BankRedirectData,
)> for AciPaymentsRequest
{
type Error = Error;
fn try_from(
value: (
&AciRouterData<&PaymentsAuthorizeRouterData>,
&BankRedirectData,
),
) -> Result<Self, Self::Error> {
let (item, bank_redirect_data) = value;
let txn_details = get_transaction_details(item)?;
let payment_method = PaymentDetails::try_from((item, bank_redirect_data))?;
Ok(Self {
txn_details,
payment_method,
instruction: None,
shopper_result_url: item.router_data.request.router_return_url.clone(),
three_ds_two_enrolled: None,
recurring_type: None,
})
}
}
impl TryFrom<(&AciRouterData<&PaymentsAuthorizeRouterData>, &PayLaterData)> for AciPaymentsRequest {
type Error = Error;
fn try_from(
value: (&AciRouterData<&PaymentsAuthorizeRouterData>, &PayLaterData),
) -> Result<Self, Self::Error> {
let (item, _pay_later_data) = value;
let txn_details = get_transaction_details(item)?;
let payment_method = PaymentDetails::Klarna;
Ok(Self {
txn_details,
payment_method,
instruction: None,
shopper_result_url: item.router_data.request.router_return_url.clone(),
three_ds_two_enrolled: None,
recurring_type: None,
})
}
}
impl TryFrom<(&AciRouterData<&PaymentsAuthorizeRouterData>, &Card)> for AciPaymentsRequest {
type Error = Error;
fn try_from(
value: (&AciRouterData<&PaymentsAuthorizeRouterData>, &Card),
) -> Result<Self, Self::Error> {
let (item, card_data) = value;
let card_holder_name = item.router_data.get_optional_billing_full_name();
let txn_details = get_transaction_details(item)?;
let payment_method = PaymentDetails::try_from((card_data.clone(), card_holder_name))?;
let instruction = get_instruction_details(item);
let recurring_type = get_recurring_type(item);
let three_ds_two_enrolled = item
.router_data
.is_three_ds()
.then_some(item.router_data.request.enrolled_for_3ds);
Ok(Self {
txn_details,
payment_method,
instruction,
shopper_result_url: item.router_data.request.router_return_url.clone(),
three_ds_two_enrolled,
recurring_type,
})
}
}
impl
TryFrom<(
&AciRouterData<&PaymentsAuthorizeRouterData>,
&NetworkTokenData,
)> for AciPaymentsRequest
{
type Error = Error;
fn try_from(
value: (
&AciRouterData<&PaymentsAuthorizeRouterData>,
&NetworkTokenData,
),
) -> Result<Self, Self::Error> {
let (item, network_token_data) = value;
let txn_details = get_transaction_details(item)?;
let payment_method = PaymentDetails::try_from((item, network_token_data))?;
let instruction = get_instruction_details(item);
Ok(Self {
txn_details,
payment_method,
instruction,
shopper_result_url: item.router_data.request.router_return_url.clone(),
three_ds_two_enrolled: None,
recurring_type: None,
})
}
}
impl
TryFrom<(
&AciRouterData<&PaymentsAuthorizeRouterData>,
api_models::payments::MandateIds,
)> for AciPaymentsRequest
{
type Error = Error;
fn try_from(
value: (
&AciRouterData<&PaymentsAuthorizeRouterData>,
api_models::payments::MandateIds,
),
) -> Result<Self, Self::Error> {
let (item, _mandate_data) = value;
let instruction = get_instruction_details(item);
let txn_details = get_transaction_details(item)?;
let recurring_type = get_recurring_type(item);
Ok(Self {
txn_details,
payment_method: PaymentDetails::Mandate,
instruction,
shopper_result_url: item.router_data.request.router_return_url.clone(),
three_ds_two_enrolled: None,
recurring_type,
})
}
}
fn get_transaction_details(
item: &AciRouterData<&PaymentsAuthorizeRouterData>,
) -> Result<TransactionDetails, error_stack::Report<errors::ConnectorError>> {
let auth = AciAuthType::try_from(&item.router_data.connector_auth_type)?;
let payment_type = if item.router_data.request.is_auto_capture()? {
AciPaymentType::Debit
} else {
AciPaymentType::Preauthorization
};
Ok(TransactionDetails {
entity_id: auth.entity_id,
amount: item.amount.to_owned(),
currency: item.router_data.request.currency.to_string(),
payment_type,
})
}
fn get_instruction_details(
item: &AciRouterData<&PaymentsAuthorizeRouterData>,
) -> Option<Instruction> {
if item.router_data.request.customer_acceptance.is_some()
&& item.router_data.request.setup_future_usage == Some(enums::FutureUsage::OffSession)
{
return Some(Instruction {
mode: InstructionMode::Initial,
transaction_type: InstructionType::Unscheduled,
source: InstructionSource::CardholderInitiatedTransaction,
create_registration: Some(true),
});
} else if item.router_data.request.mandate_id.is_some() {
return Some(Instruction {
mode: InstructionMode::Repeated,
transaction_type: InstructionType::Unscheduled,
source: InstructionSource::MerchantInitiatedTransaction,
create_registration: None,
});
}
None
}
fn get_recurring_type(
item: &AciRouterData<&PaymentsAuthorizeRouterData>,
) -> Option<AciRecurringType> {
if item.router_data.request.mandate_id.is_some() {
Some(AciRecurringType::Repeated)
} else if item.router_data.request.customer_acceptance.is_some()
&& item.router_data.request.setup_future_usage == Some(enums::FutureUsage::OffSession)
{
Some(AciRecurringType::Initial)
} else {
None
}
}
impl TryFrom<&PaymentsCancelRouterData> for AciCancelRequest {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(item: &PaymentsCancelRouterData) -> Result<Self, Self::Error> {
let auth = AciAuthType::try_from(&item.connector_auth_type)?;
let aci_payment_request = Self {
entity_id: auth.entity_id,
payment_type: AciPaymentType::Reversal,
};
Ok(aci_payment_request)
}
}
impl TryFrom<&RouterData<SetupMandate, SetupMandateRequestData, PaymentsResponseData>>
for AciMandateRequest
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: &RouterData<SetupMandate, SetupMandateRequestData, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
let auth = AciAuthType::try_from(&item.connector_auth_type)?;
let (payment_brand, payment_details) = match &item.request.payment_method_data {
PaymentMethodData::Card(card_data) => {
let brand = get_aci_payment_brand(card_data.card_network.clone(), false).ok();
match brand.as_ref() {
Some(PaymentBrand::Visa)
| Some(PaymentBrand::Mastercard)
| Some(PaymentBrand::AmericanExpress) => (),
Some(_) => {
return Err(errors::ConnectorError::NotSupported {
message: "Payment method not supported for mandate setup".to_string(),
connector: "ACI",
}
.into());
}
None => (),
};
let details = PaymentDetails::AciCard(Box::new(CardDetails {
card_number: card_data.card_number.clone(),
card_expiry_month: card_data.card_exp_month.clone(),
card_expiry_year: card_data.get_expiry_year_4_digit(),
card_cvv: card_data.card_cvc.clone(),
card_holder: card_data.card_holder_name.clone().ok_or(
errors::ConnectorError::MissingRequiredField {
field_name: "card_holder_name",
},
)?,
payment_brand: brand.clone(),
}));
(brand, details)
}
_ => {
return Err(errors::ConnectorError::NotSupported {
message: "Payment method not supported for mandate setup".to_string(),
connector: "ACI",
}
.into());
}
};
Ok(Self {
entity_id: auth.entity_id,
payment_brand,
payment_details,
})
}
}
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
#[serde(rename_all = "lowercase")]
pub enum AciPaymentStatus {
Succeeded,
Failed,
#[default]
Pending,
RedirectShopper,
}
fn map_aci_attempt_status(item: AciPaymentStatus, auto_capture: bool) -> enums::AttemptStatus {
match item {
AciPaymentStatus::Succeeded => {
if auto_capture {
enums::AttemptStatus::Charged
} else {
enums::AttemptStatus::Authorized
}
}
AciPaymentStatus::Failed => enums::AttemptStatus::Failure,
AciPaymentStatus::Pending => enums::AttemptStatus::Authorizing,
AciPaymentStatus::RedirectShopper => enums::AttemptStatus::AuthenticationPending,
}
}
impl FromStr for AciPaymentStatus {
type Err = error_stack::Report<errors::ConnectorError>;
fn from_str(s: &str) -> Result<Self, Self::Err> {
if FAILURE_CODES.contains(&s) {
Ok(Self::Failed)
} else if PENDING_CODES.contains(&s) {
Ok(Self::Pending)
} else if SUCCESSFUL_CODES.contains(&s) {
Ok(Self::Succeeded)
} else {
Err(report!(errors::ConnectorError::UnexpectedResponseError(
bytes::Bytes::from(s.to_owned())
)))
}
}
}
#[derive(Debug, Default, Clone, Deserialize, PartialEq, Eq, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct AciPaymentsResponse {
id: String,
registration_id: Option<Secret<String>>,
ndc: String,
timestamp: String,
build_number: String,
pub(super) result: ResultCode,
pub(super) redirect: Option<AciRedirectionData>,
}
#[derive(Debug, Default, Clone, Deserialize, PartialEq, Eq, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct AciErrorResponse {
ndc: String,
timestamp: String,
build_number: String,
pub(super) result: ResultCode,
}
#[derive(Clone, Debug, Deserialize, PartialEq, Eq, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct AciRedirectionData {
pub method: Option<Method>,
pub parameters: Vec<Parameters>,
pub url: Url,
pub preconditions: Option<Vec<PreconditionData>>,
}
#[derive(Clone, Debug, Deserialize, PartialEq, Eq, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct PreconditionData {
pub method: Option<Method>,
pub parameters: Vec<Parameters>,
pub url: Url,
}
#[derive(Clone, Debug, Deserialize, PartialEq, Eq, Serialize)]
pub struct Parameters {
pub name: String,
pub value: String,
}
#[derive(Default, Debug, Clone, Deserialize, PartialEq, Eq, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ResultCode {
pub(super) code: String,
pub(super) description: String,
pub(super) parameter_errors: Option<Vec<ErrorParameters>>,
}
#[derive(Default, Debug, Clone, Deserialize, PartialEq, Eq, Serialize)]
pub struct ErrorParameters {
pub(super) name: String,
pub(super) value: Option<String>,
pub(super) message: String,
}
impl<F, Req> TryFrom<ResponseRouterData<F, AciPaymentsResponse, Req, PaymentsResponseData>>
for RouterData<F, Req, PaymentsResponseData>
where
Req: GetCaptureMethod,
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: ResponseRouterData<F, AciPaymentsResponse, Req, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
let redirection_data = item.response.redirect.map(|data| {
let mut form_fields = std::collections::HashMap::<_, _>::from_iter(
data.parameters
.iter()
.map(|parameter| (parameter.name.clone(), parameter.value.clone())),
);
if let Some(preconditions) = data.preconditions {
if let Some(first_precondition) = preconditions.first() {
for param in &first_precondition.parameters {
form_fields.insert(param.name.clone(), param.value.clone());
}
}
}
// If method is Get, parameters are appended to URL
// If method is post, we http Post the method to URL
RedirectForm::Form {
endpoint: data.url.to_string(),
// Handles method for Bank redirects currently.
// 3DS response have method within preconditions. That would require replacing below line with a function.
method: data.method.unwrap_or(Method::Post),
form_fields,
}
});
let mandate_reference = item
.response
.registration_id
.clone()
.map(|id| MandateReference {
connector_mandate_id: Some(id.expose()),
payment_method_id: None,
mandate_metadata: None,
connector_mandate_request_reference_id: None,
});
let auto_capture = matches!(
item.data.request.get_capture_method(),
Some(enums::CaptureMethod::Automatic) | None
);
let status = if redirection_data.is_some() {
map_aci_attempt_status(AciPaymentStatus::RedirectShopper, auto_capture)
} else {
map_aci_attempt_status(
AciPaymentStatus::from_str(&item.response.result.code)?,
auto_capture,
)
};
let response = if status == enums::AttemptStatus::Failure {
Err(ErrorResponse {
code: item.response.result.code.clone(),
message: item.response.result.description.clone(),
reason: Some(item.response.result.description),
status_code: item.http_code,
attempt_status: Some(status),
connector_transaction_id: Some(item.response.id.clone()),
network_decline_code: None,
network_advice_code: None,
network_error_message: None,
connector_metadata: None,
})
} else {
Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(item.response.id.clone()),
redirection_data: Box::new(redirection_data),
mandate_reference: Box::new(mandate_reference),
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: Some(item.response.id),
incremental_authorization_allowed: None,
charges: None,
})
};
Ok(Self {
status,
response,
..item.data
})
}
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct AciCaptureRequest {
#[serde(flatten)]
pub txn_details: TransactionDetails,
}
impl TryFrom<&AciRouterData<&PaymentsCaptureRouterData>> for AciCaptureRequest {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(item: &AciRouterData<&PaymentsCaptureRouterData>) -> Result<Self, Self::Error> {
let auth = AciAuthType::try_from(&item.router_data.connector_auth_type)?;
Ok(Self {
txn_details: TransactionDetails {
entity_id: auth.entity_id,
amount: item.amount.to_owned(),
currency: item.router_data.request.currency.to_string(),
payment_type: AciPaymentType::Capture,
},
})
}
}
#[derive(Debug, Default, Clone, Deserialize, PartialEq, Eq, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct AciCaptureResponse {
id: String,
referenced_id: String,
payment_type: AciPaymentType,
amount: StringMajorUnit,
currency: String,
descriptor: String,
result: AciCaptureResult,
result_details: Option<AciCaptureResultDetails>,
build_number: String,
timestamp: String,
ndc: Secret<String>,
source: Option<Secret<String>>,
payment_method: Option<String>,
short_id: Option<String>,
}
#[derive(Debug, Default, Clone, Deserialize, PartialEq, Eq, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct AciCaptureResult {
code: String,
description: String,
}
#[derive(Debug, Default, Clone, Deserialize, PartialEq, Eq, Serialize)]
#[serde(rename_all = "PascalCase")]
pub struct AciCaptureResultDetails {
extended_description: String,
#[serde(rename = "clearingInstituteName")]
clearing_institute_name: Option<String>,
connector_tx_i_d1: Option<String>,
connector_tx_i_d3: Option<String>,
connector_tx_i_d2: Option<String>,
acquirer_response: Option<String>,
}
#[derive(Debug, Default, Clone, Deserialize)]
pub enum AciStatus {
Succeeded,
Failed,
#[default]
Pending,
}
impl FromStr for AciStatus {
type Err = error_stack::Report<errors::ConnectorError>;
fn from_str(s: &str) -> Result<Self, Self::Err> {
if FAILURE_CODES.contains(&s) {
Ok(Self::Failed)
} else if PENDING_CODES.contains(&s) {
Ok(Self::Pending)
} else if SUCCESSFUL_CODES.contains(&s) {
Ok(Self::Succeeded)
} else {
Err(report!(errors::ConnectorError::UnexpectedResponseError(
bytes::Bytes::from(s.to_owned())
)))
}
}
}
fn map_aci_capture_status(item: AciStatus) -> enums::AttemptStatus {
match item {
AciStatus::Succeeded => enums::AttemptStatus::Charged,
AciStatus::Failed => enums::AttemptStatus::Failure,
AciStatus::Pending => enums::AttemptStatus::Pending,
}
}
impl<F, T> TryFrom<ResponseRouterData<F, AciCaptureResponse, T, PaymentsResponseData>>
for RouterData<F, T, PaymentsResponseData>
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: ResponseRouterData<F, AciCaptureResponse, T, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
let status = map_aci_capture_status(AciStatus::from_str(&item.response.result.code)?);
let response = if status == enums::AttemptStatus::Failure {
Err(ErrorResponse {
code: item.response.result.code.clone(),
message: item.response.result.description.clone(),
reason: Some(item.response.result.description),
status_code: item.http_code,
attempt_status: Some(status),
connector_transaction_id: Some(item.response.id.clone()),
network_decline_code: None,
network_advice_code: None,
network_error_message: None,
connector_metadata: None,
})
} else {
Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(item.response.id.clone()),
redirection_data: Box::new(None),
mandate_reference: Box::new(None),
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: Some(item.response.referenced_id.clone()),
incremental_authorization_allowed: None,
charges: None,
})
};
Ok(Self {
status,
response,
reference_id: Some(item.response.referenced_id),
..item.data
})
}
}
#[derive(Debug, Default, Clone, Deserialize, PartialEq, Eq, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct AciVoidResponse {
id: String,
referenced_id: String,
payment_type: AciPaymentType,
amount: StringMajorUnit,
currency: String,
descriptor: String,
result: AciCaptureResult,
result_details: Option<AciCaptureResultDetails>,
build_number: String,
timestamp: String,
ndc: Secret<String>,
}
fn map_aci_void_status(item: AciStatus) -> enums::AttemptStatus {
match item {
AciStatus::Succeeded => enums::AttemptStatus::Voided,
AciStatus::Failed => enums::AttemptStatus::VoidFailed,
AciStatus::Pending => enums::AttemptStatus::VoidInitiated,
}
}
impl<F, T> TryFrom<ResponseRouterData<F, AciVoidResponse, T, PaymentsResponseData>>
for RouterData<F, T, PaymentsResponseData>
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: ResponseRouterData<F, AciVoidResponse, T, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
let status = map_aci_void_status(AciStatus::from_str(&item.response.result.code)?);
let response = if status == enums::AttemptStatus::Failure {
Err(ErrorResponse {
code: item.response.result.code.clone(),
message: item.response.result.description.clone(),
reason: Some(item.response.result.description),
status_code: item.http_code,
attempt_status: Some(status),
connector_transaction_id: Some(item.response.id.clone()),
..Default::default()
})
} else {
Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(item.response.id.clone()),
redirection_data: Box::new(None),
mandate_reference: Box::new(None),
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: Some(item.response.referenced_id.clone()),
incremental_authorization_allowed: None,
charges: None,
})
};
Ok(Self {
status,
response,
reference_id: Some(item.response.referenced_id),
..item.data
})
}
}
#[derive(Default, Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct AciRefundRequest {
pub amount: StringMajorUnit,
pub currency: String,
pub payment_type: AciPaymentType,
pub entity_id: Secret<String>,
}
impl<F> TryFrom<&AciRouterData<&RefundsRouterData<F>>> for AciRefundRequest {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(item: &AciRouterData<&RefundsRouterData<F>>) -> Result<Self, Self::Error> {
let amount = item.amount.to_owned();
let currency = item.router_data.request.currency;
let payment_type = AciPaymentType::Refund;
let auth = AciAuthType::try_from(&item.router_data.connector_auth_type)?;
Ok(Self {
amount,
currency: currency.to_string(),
payment_type,
entity_id: auth.entity_id,
})
}
}
#[derive(Debug, Default, Deserialize, Clone)]
pub enum AciRefundStatus {
Succeeded,
Failed,
#[default]
Pending,
}
impl FromStr for AciRefundStatus {
type Err = error_stack::Report<errors::ConnectorError>;
fn from_str(s: &str) -> Result<Self, Self::Err> {
if FAILURE_CODES.contains(&s) {
Ok(Self::Failed)
} else if PENDING_CODES.contains(&s) {
Ok(Self::Pending)
} else if SUCCESSFUL_CODES.contains(&s) {
Ok(Self::Succeeded)
} else {
Err(report!(errors::ConnectorError::UnexpectedResponseError(
bytes::Bytes::from(s.to_owned())
)))
}
}
}
impl From<AciRefundStatus> for enums::RefundStatus {
fn from(item: AciRefundStatus) -> Self {
match item {
AciRefundStatus::Succeeded => Self::Success,
AciRefundStatus::Failed => Self::Failure,
AciRefundStatus::Pending => Self::Pending,
}
}
}
#[allow(dead_code)]
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct AciRefundResponse {
id: String,
ndc: String,
timestamp: String,
build_number: String,
pub(super) result: ResultCode,
}
impl<F> TryFrom<RefundsResponseRouterData<F, AciRefundResponse>> for RefundsRouterData<F> {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: RefundsResponseRouterData<F, AciRefundResponse>,
) -> Result<Self, Self::Error> {
let refund_status =
enums::RefundStatus::from(AciRefundStatus::from_str(&item.response.result.code)?);
let response = if refund_status == enums::RefundStatus::Failure {
Err(ErrorResponse {
code: item.response.result.code.clone(),
message: item.response.result.description.clone(),
reason: Some(item.response.result.description),
status_code: item.http_code,
attempt_status: None,
connector_transaction_id: Some(item.response.id.clone()),
network_decline_code: None,
network_advice_code: None,
network_error_message: None,
connector_metadata: None,
})
} else {
Ok(RefundsResponseData {
connector_refund_id: item.response.id,
refund_status,
})
};
Ok(Self {
response,
..item.data
})
}
}
impl
TryFrom<
ResponseRouterData<
SetupMandate,
AciMandateResponse,
SetupMandateRequestData,
PaymentsResponseData,
>,
> for RouterData<SetupMandate, SetupMandateRequestData, PaymentsResponseData>
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: ResponseRouterData<
SetupMandate,
AciMandateResponse,
SetupMandateRequestData,
PaymentsResponseData,
>,
) -> Result<Self, Self::Error> {
let mandate_reference = Some(MandateReference {
connector_mandate_id: Some(item.response.id.clone()),
payment_method_id: None,
mandate_metadata: None,
connector_mandate_request_reference_id: None,
});
let status = if SUCCESSFUL_CODES.contains(&item.response.result.code.as_str()) {
enums::AttemptStatus::Charged
} else if FAILURE_CODES.contains(&item.response.result.code.as_str()) {
enums::AttemptStatus::Failure
} else {
enums::AttemptStatus::Pending
};
let response = if status == enums::AttemptStatus::Failure {
Err(ErrorResponse {
code: item.response.result.code.clone(),
message: item.response.result.description.clone(),
reason: Some(item.response.result.description),
status_code: item.http_code,
attempt_status: Some(status),
connector_transaction_id: Some(item.response.id.clone()),
network_decline_code: None,
network_advice_code: None,
network_error_message: None,
connector_metadata: None,
})
} else {
Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(item.response.id.clone()),
redirection_data: Box::new(None),
mandate_reference: Box::new(mandate_reference),
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: Some(item.response.id),
incremental_authorization_allowed: None,
charges: None,
})
};
Ok(Self {
status,
response,
..item.data
})
}
}
#[derive(Debug, Clone, Deserialize, Serialize, PartialEq, Eq)]
pub enum AciWebhookEventType {
Payment,
}
#[derive(Debug, Clone, Deserialize, Serialize, PartialEq, Eq)]
pub enum AciWebhookAction {
Created,
Updated,
Deleted,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct AciWebhookCardDetails {
pub bin: Option<String>,
#[serde(rename = "last4Digits")]
pub last4_digits: Option<String>,
pub holder: Option<String>,
pub expiry_month: Option<Secret<String>>,
pub expiry_year: Option<Secret<String>>,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct AciWebhookCustomerDetails {
#[serde(rename = "givenName")]
pub given_name: Option<Secret<String>>,
pub surname: Option<Secret<String>>,
#[serde(rename = "merchantCustomerId")]
pub merchant_customer_id: Option<Secret<String>>,
pub sex: Option<Secret<String>>,
pub email: Option<Email>,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct AciWebhookAuthenticationDetails {
#[serde(rename = "entityId")]
pub entity_id: Secret<String>,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct AciWebhookRiskDetails {
pub score: Option<String>,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct AciPaymentWebhookPayload {
pub id: String,
pub payment_type: String,
pub payment_brand: String,
pub amount: StringMajorUnit,
pub currency: String,
pub presentation_amount: Option<StringMajorUnit>,
pub presentation_currency: Option<String>,
pub descriptor: Option<String>,
pub result: ResultCode,
pub authentication: Option<AciWebhookAuthenticationDetails>,
pub card: Option<AciWebhookCardDetails>,
pub customer: Option<AciWebhookCustomerDetails>,
#[serde(rename = "customParameters")]
pub custom_parameters: Option<serde_json::Value>,
pub risk: Option<AciWebhookRiskDetails>,
pub build_number: Option<String>,
pub timestamp: String,
pub ndc: String,
#[serde(rename = "channelName")]
pub channel_name: Option<String>,
pub source: Option<String>,
pub payment_method: Option<String>,
#[serde(rename = "shortId")]
pub short_id: Option<String>,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct AciWebhookNotification {
#[serde(rename = "type")]
pub event_type: AciWebhookEventType,
pub action: Option<AciWebhookAction>,
pub payload: serde_json::Value,
}
|
{
"crate": "hyperswitch_connectors",
"file": "crates/hyperswitch_connectors/src/connectors/aci/transformers.rs",
"file_size": null,
"is_async": null,
"is_pub": null,
"num_enums": 13,
"num_structs": 32,
"num_tables": null,
"score": null,
"total_crates": null
}
|
file_hyperswitch_connectors_-7390701435317249910
|
clm
|
file
|
// Repository: hyperswitch
// Crate: hyperswitch_connectors
// File: crates/hyperswitch_connectors/src/connectors/loonio/transformers.rs
// Contains: 12 structs, 7 enums
use std::collections::HashMap;
#[cfg(feature = "payouts")]
use api_models::payouts::{BankRedirect, PayoutMethodData};
use api_models::webhooks;
use common_enums::{enums, Currency};
use common_utils::{id_type, pii::Email, request::Method, types::FloatMajorUnit};
use hyperswitch_domain_models::{
payment_method_data::{BankRedirectData, PaymentMethodData},
router_data::{ConnectorAuthType, RouterData},
router_flow_types::refunds::{Execute, RSync},
router_request_types::ResponseId,
router_response_types::{PaymentsResponseData, RedirectForm, RefundsResponseData},
types::{PaymentsAuthorizeRouterData, RefundsRouterData},
};
#[cfg(feature = "payouts")]
use hyperswitch_domain_models::{
router_flow_types::PoFulfill, router_response_types::PayoutsResponseData,
types::PayoutsRouterData,
};
use hyperswitch_interfaces::errors;
use masking::Secret;
use serde::{Deserialize, Serialize};
#[cfg(feature = "payouts")]
use crate::types::PayoutsResponseRouterData;
use crate::{
types::{RefundsResponseRouterData, ResponseRouterData},
utils::{self, PaymentsAuthorizeRequestData, RouterData as _},
};
pub struct LoonioRouterData<T> {
pub amount: FloatMajorUnit,
pub router_data: T,
}
impl<T> From<(FloatMajorUnit, T)> for LoonioRouterData<T> {
fn from((amount, item): (FloatMajorUnit, T)) -> Self {
Self {
amount,
router_data: item,
}
}
}
// Auth Struct
pub struct LoonioAuthType {
pub(super) merchant_id: Secret<String>,
pub(super) merchant_token: Secret<String>,
}
impl TryFrom<&ConnectorAuthType> for LoonioAuthType {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(auth_type: &ConnectorAuthType) -> Result<Self, Self::Error> {
match auth_type {
ConnectorAuthType::BodyKey { api_key, key1 } => Ok(Self {
merchant_id: api_key.to_owned(),
merchant_token: key1.to_owned(),
}),
_ => Err(errors::ConnectorError::FailedToObtainAuthType.into()),
}
}
}
#[derive(Debug, Serialize)]
pub struct LoonioPaymentRequest {
pub currency_code: Currency,
pub customer_profile: LoonioCustomerProfile,
pub amount: FloatMajorUnit,
pub customer_id: id_type::CustomerId,
pub transaction_id: String,
pub payment_method_type: InteracPaymentMethodType,
#[serde(skip_serializing_if = "Option::is_none")]
pub redirect_url: Option<LoonioRedirectUrl>,
#[serde(skip_serializing_if = "Option::is_none")]
pub webhook_url: Option<String>,
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
pub enum InteracPaymentMethodType {
InteracEtransfer,
}
#[derive(Debug, Serialize)]
pub struct LoonioCustomerProfile {
pub first_name: Secret<String>,
pub last_name: Secret<String>,
pub email: Email,
}
#[derive(Debug, Serialize)]
pub struct LoonioRedirectUrl {
pub success_url: String,
pub failed_url: String,
}
impl TryFrom<&LoonioRouterData<&PaymentsAuthorizeRouterData>> for LoonioPaymentRequest {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: &LoonioRouterData<&PaymentsAuthorizeRouterData>,
) -> Result<Self, Self::Error> {
match item.router_data.request.payment_method_data.clone() {
PaymentMethodData::BankRedirect(BankRedirectData::Interac { .. }) => {
let transaction_id = item.router_data.connector_request_reference_id.clone();
let customer_profile = LoonioCustomerProfile {
first_name: item.router_data.get_billing_first_name()?,
last_name: item.router_data.get_billing_last_name()?,
email: item.router_data.get_billing_email()?,
};
let redirect_url = LoonioRedirectUrl {
success_url: item.router_data.request.get_router_return_url()?,
failed_url: item.router_data.request.get_router_return_url()?,
};
Ok(Self {
currency_code: item.router_data.request.currency,
customer_profile,
amount: item.amount,
customer_id: item.router_data.get_customer_id()?,
transaction_id,
payment_method_type: InteracPaymentMethodType::InteracEtransfer,
redirect_url: Some(redirect_url),
webhook_url: Some(item.router_data.request.get_webhook_url()?),
})
}
PaymentMethodData::BankRedirect(_) => Err(errors::ConnectorError::NotImplemented(
utils::get_unimplemented_payment_method_error_message("Loonio"),
))?,
_ => Err(errors::ConnectorError::NotImplemented(
utils::get_unimplemented_payment_method_error_message("Loonio"),
)
.into()),
}
}
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct LoonioPaymentsResponse {
pub payment_form: String,
}
impl<F, T> TryFrom<ResponseRouterData<F, LoonioPaymentsResponse, T, PaymentsResponseData>>
for RouterData<F, T, PaymentsResponseData>
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: ResponseRouterData<F, LoonioPaymentsResponse, T, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
Ok(Self {
status: enums::AttemptStatus::AuthenticationPending,
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(
item.data.connector_request_reference_id.clone(),
),
redirection_data: Box::new(Some(RedirectForm::Form {
endpoint: item.response.payment_form,
method: Method::Get,
form_fields: HashMap::new(),
})),
mandate_reference: Box::new(None),
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: None,
incremental_authorization_allowed: None,
charges: None,
}),
..item.data
})
}
}
#[derive(Debug, Clone, Copy, Serialize, Deserialize)]
#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
pub enum LoonioTransactionStatus {
Created,
Prepared,
Pending,
Settled,
Available,
Abandoned,
Rejected,
Failed,
Rollback,
Returned,
Nsf,
}
impl From<LoonioTransactionStatus> for enums::AttemptStatus {
fn from(item: LoonioTransactionStatus) -> Self {
match item {
LoonioTransactionStatus::Created => Self::AuthenticationPending,
LoonioTransactionStatus::Prepared | LoonioTransactionStatus::Pending => Self::Pending,
LoonioTransactionStatus::Settled | LoonioTransactionStatus::Available => Self::Charged,
LoonioTransactionStatus::Abandoned
| LoonioTransactionStatus::Rejected
| LoonioTransactionStatus::Failed
| LoonioTransactionStatus::Returned
| LoonioTransactionStatus::Nsf => Self::Failure,
LoonioTransactionStatus::Rollback => Self::Voided,
}
}
}
// Sync Response Structures
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct LoonioTransactionSyncResponse {
pub transaction_id: String,
pub state: LoonioTransactionStatus,
}
#[derive(Default, Debug, Serialize)]
pub struct LoonioRefundRequest {
pub amount: FloatMajorUnit,
}
impl<F> TryFrom<&LoonioRouterData<&RefundsRouterData<F>>> for LoonioRefundRequest {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(item: &LoonioRouterData<&RefundsRouterData<F>>) -> Result<Self, Self::Error> {
Ok(Self {
amount: item.amount.to_owned(),
})
}
}
impl<F, T> TryFrom<ResponseRouterData<F, LoonioPaymentResponseData, T, PaymentsResponseData>>
for RouterData<F, T, PaymentsResponseData>
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: ResponseRouterData<F, LoonioPaymentResponseData, T, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
match item.response {
LoonioPaymentResponseData::Sync(sync_response) => Ok(Self {
status: enums::AttemptStatus::from(sync_response.state),
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(sync_response.transaction_id),
redirection_data: Box::new(None),
mandate_reference: Box::new(None),
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: None,
incremental_authorization_allowed: None,
charges: None,
}),
..item.data
}),
LoonioPaymentResponseData::Webhook(webhook_body) => {
let payment_status = enums::AttemptStatus::from(&webhook_body.event_code);
Ok(Self {
status: payment_status,
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(
webhook_body.api_transaction_id,
),
redirection_data: Box::new(None),
mandate_reference: Box::new(None),
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: None,
incremental_authorization_allowed: None,
charges: None,
}),
..item.data
})
}
}
}
}
// Type definition for Refund Response
#[allow(dead_code)]
#[derive(Debug, Copy, Serialize, Default, Deserialize, Clone)]
pub enum RefundStatus {
Succeeded,
Failed,
#[default]
Processing,
}
impl From<RefundStatus> for enums::RefundStatus {
fn from(item: RefundStatus) -> Self {
match item {
RefundStatus::Succeeded => Self::Success,
RefundStatus::Failed => Self::Failure,
RefundStatus::Processing => Self::Pending,
//TODO: Review mapping
}
}
}
//TODO: Fill the struct with respective fields
#[derive(Default, Debug, Clone, Serialize, Deserialize)]
pub struct RefundResponse {
id: String,
status: RefundStatus,
}
impl TryFrom<RefundsResponseRouterData<Execute, RefundResponse>> for RefundsRouterData<Execute> {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: RefundsResponseRouterData<Execute, RefundResponse>,
) -> Result<Self, Self::Error> {
Ok(Self {
response: Ok(RefundsResponseData {
connector_refund_id: item.response.id.to_string(),
refund_status: enums::RefundStatus::from(item.response.status),
}),
..item.data
})
}
}
impl TryFrom<RefundsResponseRouterData<RSync, RefundResponse>> for RefundsRouterData<RSync> {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: RefundsResponseRouterData<RSync, RefundResponse>,
) -> Result<Self, Self::Error> {
Ok(Self {
response: Ok(RefundsResponseData {
connector_refund_id: item.response.id.to_string(),
refund_status: enums::RefundStatus::from(item.response.status),
}),
..item.data
})
}
}
//TODO: Fill the struct with respective fields
#[derive(Default, Debug, Serialize, Deserialize)]
pub struct LoonioErrorResponse {
pub status: u16,
pub error_code: Option<String>,
pub message: String,
}
// Webhook related structs
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
pub enum LoonioWebhookEventCode {
TransactionPrepared,
TransactionPending,
TransactionAvailable,
TransactionSettled,
TransactionFailed,
TransactionRejected,
#[serde(rename = "TRANSACTION_WAITING_STATUS_FILE")]
TransactionWaitingStatusFile,
#[serde(rename = "TRANSACTION_STATUS_FILE_RECEIVED")]
TransactionStatusFileReceived,
#[serde(rename = "TRANSACTION_STATUS_FILE_FAILED")]
TransactionStatusFileFailed,
#[serde(rename = "TRANSACTION_RETURNED")]
TransactionReturned,
#[serde(rename = "TRANSACTION_WRONG_DESTINATION")]
TransactionWrongDestination,
#[serde(rename = "TRANSACTION_NSF")]
TransactionNsf,
}
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
pub enum LoonioWebhookTransactionType {
Incoming,
OutgoingVerified,
OutgoingNotVerified,
OutgoingCustomerDefined,
}
#[derive(Debug, Serialize, Deserialize)]
pub struct LoonioWebhookBody {
pub amount: FloatMajorUnit,
pub api_transaction_id: String,
pub signature: Option<String>,
pub event_code: LoonioWebhookEventCode,
pub id: i32,
#[serde(rename = "type")]
pub transaction_type: LoonioWebhookTransactionType,
}
#[derive(Debug, Serialize, Deserialize)]
#[serde(untagged)]
pub enum LoonioPaymentResponseData {
Sync(LoonioTransactionSyncResponse),
Webhook(LoonioWebhookBody),
}
impl From<&LoonioWebhookEventCode> for webhooks::IncomingWebhookEvent {
fn from(event_code: &LoonioWebhookEventCode) -> Self {
match event_code {
LoonioWebhookEventCode::TransactionSettled
| LoonioWebhookEventCode::TransactionAvailable => Self::PaymentIntentSuccess,
LoonioWebhookEventCode::TransactionPending
| LoonioWebhookEventCode::TransactionPrepared => Self::PaymentIntentProcessing,
LoonioWebhookEventCode::TransactionFailed
// deprecated
| LoonioWebhookEventCode::TransactionRejected
| LoonioWebhookEventCode::TransactionStatusFileFailed
| LoonioWebhookEventCode::TransactionReturned
| LoonioWebhookEventCode::TransactionWrongDestination
| LoonioWebhookEventCode::TransactionNsf => Self::PaymentIntentFailure,
_ => Self::EventNotSupported,
}
}
}
impl From<&LoonioWebhookEventCode> for enums::AttemptStatus {
fn from(event_code: &LoonioWebhookEventCode) -> Self {
match event_code {
LoonioWebhookEventCode::TransactionSettled
| LoonioWebhookEventCode::TransactionAvailable => Self::Charged,
LoonioWebhookEventCode::TransactionPending
| LoonioWebhookEventCode::TransactionPrepared => Self::Pending,
LoonioWebhookEventCode::TransactionFailed
| LoonioWebhookEventCode::TransactionRejected
| LoonioWebhookEventCode::TransactionStatusFileFailed
| LoonioWebhookEventCode::TransactionReturned
| LoonioWebhookEventCode::TransactionWrongDestination
| LoonioWebhookEventCode::TransactionNsf => Self::Failure,
_ => Self::Pending,
}
}
}
// Payout Structures
#[cfg(feature = "payouts")]
#[derive(Debug, Serialize)]
pub struct LoonioPayoutFulfillRequest {
pub currency_code: Currency,
pub customer_profile: LoonioCustomerProfile,
pub amount: FloatMajorUnit,
pub customer_id: id_type::CustomerId,
pub transaction_id: String,
#[serde(skip_serializing_if = "Option::is_none")]
pub webhook_url: Option<String>,
}
#[cfg(feature = "payouts")]
impl TryFrom<&LoonioRouterData<&PayoutsRouterData<PoFulfill>>> for LoonioPayoutFulfillRequest {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: &LoonioRouterData<&PayoutsRouterData<PoFulfill>>,
) -> Result<Self, Self::Error> {
match item.router_data.get_payout_method_data()? {
PayoutMethodData::BankRedirect(BankRedirect::Interac(interac_data)) => {
let customer_profile = LoonioCustomerProfile {
first_name: item.router_data.get_billing_first_name()?,
last_name: item.router_data.get_billing_last_name()?,
email: interac_data.email,
};
Ok(Self {
currency_code: item.router_data.request.destination_currency,
customer_profile,
amount: item.amount,
customer_id: item.router_data.get_customer_id()?,
transaction_id: item.router_data.connector_request_reference_id.clone(),
webhook_url: item.router_data.request.webhook_url.clone(),
})
}
PayoutMethodData::Card(_) | PayoutMethodData::Bank(_) | PayoutMethodData::Wallet(_) => {
Err(errors::ConnectorError::NotSupported {
message: "Payment Method Not Supported".to_string(),
connector: "Loonio",
})?
}
}
}
}
#[cfg(feature = "payouts")]
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct LoonioPayoutFulfillResponse {
pub id: i64,
pub api_transaction_id: String,
#[serde(rename = "type")]
pub transaction_type: String,
pub state: LoonioPayoutStatus,
}
#[cfg(feature = "payouts")]
#[derive(Debug, Clone, Copy, Serialize, Deserialize)]
#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
pub enum LoonioPayoutStatus {
Created,
Prepared,
Pending,
Settled,
Available,
Rejected,
Abandoned,
ConnectedAbandoned,
ConnectedInsufficientFunds,
Failed,
Nsf,
Returned,
Rollback,
}
#[cfg(feature = "payouts")]
impl From<LoonioPayoutStatus> for enums::PayoutStatus {
fn from(item: LoonioPayoutStatus) -> Self {
match item {
LoonioPayoutStatus::Created | LoonioPayoutStatus::Prepared => Self::Initiated,
LoonioPayoutStatus::Pending => Self::Pending,
LoonioPayoutStatus::Settled | LoonioPayoutStatus::Available => Self::Success,
LoonioPayoutStatus::Rejected
| LoonioPayoutStatus::Abandoned
| LoonioPayoutStatus::ConnectedAbandoned
| LoonioPayoutStatus::ConnectedInsufficientFunds
| LoonioPayoutStatus::Failed
| LoonioPayoutStatus::Nsf
| LoonioPayoutStatus::Returned
| LoonioPayoutStatus::Rollback => Self::Failed,
}
}
}
#[cfg(feature = "payouts")]
impl<F> TryFrom<PayoutsResponseRouterData<F, LoonioPayoutFulfillResponse>>
for PayoutsRouterData<F>
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: PayoutsResponseRouterData<F, LoonioPayoutFulfillResponse>,
) -> Result<Self, Self::Error> {
Ok(Self {
response: Ok(PayoutsResponseData {
status: Some(enums::PayoutStatus::from(item.response.state)),
connector_payout_id: Some(item.response.api_transaction_id),
payout_eligible: None,
should_add_next_step_to_process_tracker: false,
error_code: None,
error_message: None,
payout_connector_metadata: None,
}),
..item.data
})
}
}
#[cfg(feature = "payouts")]
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct LoonioPayoutSyncResponse {
pub transaction_id: String,
pub state: LoonioPayoutStatus,
}
#[cfg(feature = "payouts")]
impl<F> TryFrom<PayoutsResponseRouterData<F, LoonioPayoutSyncResponse>> for PayoutsRouterData<F> {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: PayoutsResponseRouterData<F, LoonioPayoutSyncResponse>,
) -> Result<Self, Self::Error> {
Ok(Self {
response: Ok(PayoutsResponseData {
status: Some(enums::PayoutStatus::from(item.response.state)),
connector_payout_id: Some(item.response.transaction_id.to_string()),
payout_eligible: None,
should_add_next_step_to_process_tracker: false,
error_code: None,
error_message: None,
payout_connector_metadata: None,
}),
..item.data
})
}
}
|
{
"crate": "hyperswitch_connectors",
"file": "crates/hyperswitch_connectors/src/connectors/loonio/transformers.rs",
"file_size": null,
"is_async": null,
"is_pub": null,
"num_enums": 7,
"num_structs": 12,
"num_tables": null,
"score": null,
"total_crates": null
}
|
file_hyperswitch_connectors_-997721921930727814
|
clm
|
file
|
// Repository: hyperswitch
// Crate: hyperswitch_connectors
// File: crates/hyperswitch_connectors/src/connectors/fiserv/transformers.rs
// Contains: 50 structs, 15 enums
use api_models::payments::{
ApplePayCombinedMetadata, ApplepayCombinedSessionTokenData, ApplepaySessionTokenData,
ApplepaySessionTokenMetadata,
};
use base64::Engine;
use common_enums::{enums, Currency};
use common_utils::{
consts::BASE64_ENGINE, ext_traits::ValueExt, pii, request::Method, types::FloatMajorUnit,
};
use error_stack::ResultExt;
use hyperswitch_domain_models::{
payment_method_data::{PaymentMethodData, WalletData},
router_data::{ConnectorAuthType, PaymentMethodToken, RouterData},
router_flow_types::refunds::{Execute, RSync},
router_request_types::ResponseId,
router_response_types::{PaymentsResponseData, RedirectForm, RefundsResponseData},
types,
};
use hyperswitch_interfaces::errors;
use masking::{ExposeInterface, Secret};
use serde::{ser::Serializer, Deserialize, Serialize};
use crate::{
types::{RefundsResponseRouterData, ResponseRouterData},
utils::{
self, CardData as _, PaymentsCancelRequestData, PaymentsSyncRequestData, RouterData as _,
},
};
#[derive(Debug, Serialize)]
pub struct FiservRouterData<T> {
pub amount: FloatMajorUnit,
pub router_data: T,
}
impl<T> TryFrom<(FloatMajorUnit, T)> for FiservRouterData<T> {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from((amount, router_data): (FloatMajorUnit, T)) -> Result<Self, Self::Error> {
Ok(Self {
amount,
router_data,
})
}
}
impl Serialize for FiservCheckoutChargesRequest {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: Serializer,
{
match self {
Self::Checkout(inner) => inner.serialize(serializer),
Self::Charges(inner) => inner.serialize(serializer),
}
}
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct FiservPaymentsRequest {
amount: Amount,
merchant_details: MerchantDetails,
#[serde(flatten)]
checkout_charges_request: FiservCheckoutChargesRequest,
}
#[derive(Debug)]
pub enum FiservCheckoutChargesRequest {
Checkout(CheckoutPaymentsRequest),
Charges(ChargesPaymentRequest),
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct CheckoutPaymentsRequest {
order: FiservOrder,
payment_method: FiservPaymentMethod,
interactions: FiservInteractions,
transaction_details: TransactionDetails,
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "UPPERCASE")]
pub enum FiservChannel {
Web,
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "UPPERCASE")]
pub enum FiservPaymentInitiator {
Merchant,
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
pub enum FiservCustomerConfirmation {
ReviewAndPay,
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct FiservInteractions {
channel: FiservChannel,
customer_confirmation: FiservCustomerConfirmation,
payment_initiator: FiservPaymentInitiator,
return_urls: FiservReturnUrls,
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct FiservReturnUrls {
success_url: String,
cancel_url: String,
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct FiservPaymentMethod {
provider: FiservWallet,
#[serde(rename = "type")]
wallet_type: FiservWalletType,
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct FiservOrder {
intent: FiservIntent,
}
#[derive(Debug, Serialize, Clone, Deserialize)]
#[serde(rename_all = "UPPERCASE")]
pub enum FiservIntent {
Authorize,
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ChargesPaymentRequest {
source: Source,
transaction_interaction: Option<TransactionInteraction>,
transaction_details: TransactionDetails,
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "UPPERCASE")]
pub enum FiservWallet {
ApplePay,
GooglePay,
PayPal,
}
#[derive(Debug, Serialize)]
#[serde(tag = "sourceType")]
pub enum Source {
#[serde(rename = "GooglePay")]
GooglePay(GooglePayData),
#[serde(rename = "PaymentCard")]
PaymentCard { card: CardData },
#[serde(rename = "ApplePay")]
ApplePay(ApplePayWalletDetails),
#[serde(rename = "DecryptedWallet")]
DecryptedWallet(DecryptedWalletDetails),
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ApplePayWalletDetails {
pub data: Secret<String>,
pub header: ApplePayHeader,
pub signature: Secret<String>,
pub version: Secret<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub application_data: Option<Secret<String>>,
pub apple_pay_merchant_id: Secret<String>,
}
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ApplePayHeader {
#[serde(skip_serializing_if = "Option::is_none")]
pub application_data_hash: Option<Secret<String>>,
pub ephemeral_public_key: Secret<String>,
pub public_key_hash: Secret<String>,
pub transaction_id: Secret<String>,
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct DecryptedWalletDetails {
pub card: WalletCardData,
#[serde(rename = "cavv")]
pub cryptogram: Secret<String>,
#[serde(rename = "xid")]
pub transaction_id: Secret<String>,
pub wallet_type: FiservWalletType,
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "UPPERCASE")]
pub enum FiservWalletType {
ApplePay,
GooglePay,
PaypalWallet,
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct GooglePayData {
data: Secret<String>,
signature: Secret<String>,
version: String,
intermediate_signing_key: IntermediateSigningKey,
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct CardData {
card_data: cards::CardNumber,
expiration_month: Secret<String>,
expiration_year: Secret<String>,
#[serde(skip_serializing_if = "Option::is_none")]
security_code: Option<Secret<String>>,
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct WalletCardData {
card_data: cards::CardNumber,
expiration_month: Secret<String>,
expiration_year: Secret<String>,
}
#[derive(Default, Debug, Serialize)]
pub struct Amount {
total: FloatMajorUnit,
currency: String,
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct TransactionDetails {
#[serde(skip_serializing_if = "Option::is_none")]
capture_flag: Option<bool>,
#[serde(skip_serializing_if = "Option::is_none")]
reversal_reason_code: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
merchant_transaction_id: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
operation_type: Option<OperationType>,
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "UPPERCASE")]
pub enum OperationType {
Create,
Capture,
Authorize,
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct MerchantDetails {
merchant_id: Secret<String>,
terminal_id: Option<Secret<String>>,
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct TransactionInteraction {
origin: TransactionInteractionOrigin,
eci_indicator: TransactionInteractionEciIndicator,
pos_condition_code: TransactionInteractionPosConditionCode,
}
#[derive(Default, Debug, Serialize)]
#[serde(rename_all = "UPPERCASE")]
pub enum TransactionInteractionOrigin {
#[default]
Ecom,
}
#[derive(Default, Debug, Serialize)]
#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
pub enum TransactionInteractionEciIndicator {
#[default]
ChannelEncrypted,
}
#[derive(Default, Debug, Serialize)]
#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
pub enum TransactionInteractionPosConditionCode {
#[default]
CardNotPresentEcom,
}
#[derive(Debug, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct IntermediateSigningKey {
signed_key: Secret<String>,
signatures: Vec<Secret<String>>,
}
#[derive(Debug, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct SignedKey {
key_value: String,
key_expiration: String,
}
#[derive(Debug, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct SignedMessage {
encrypted_message: String,
ephemeral_public_key: String,
tag: String,
}
#[derive(Debug, Default)]
pub struct FullyParsedGooglePayToken {
pub signature: Secret<String>,
pub protocol_version: String,
pub encrypted_message: String,
pub ephemeral_public_key: String,
pub tag: String,
pub key_value: String,
pub key_expiration: String,
pub signatures: Vec<String>,
}
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct RawGooglePayToken {
pub signature: Secret<String>,
pub protocol_version: String,
pub signed_message: Secret<String>,
pub intermediate_signing_key: IntermediateSigningKey,
}
#[derive(Debug, Serialize, Deserialize)]
pub struct ApplePayDecryptedData {
pub data: Secret<String>,
pub signature: Secret<String>,
pub version: Secret<String>,
pub header: ApplePayHeader,
}
pub fn parse_googlepay_token_safely(token_json_str: &str) -> FullyParsedGooglePayToken {
let mut result = FullyParsedGooglePayToken::default();
if let Ok(raw_token) = serde_json::from_str::<RawGooglePayToken>(token_json_str) {
result.signature = raw_token.signature;
result.protocol_version = raw_token.protocol_version;
result.signatures = raw_token
.intermediate_signing_key
.signatures
.into_iter()
.map(|s| s.expose().to_owned())
.collect();
if let Ok(key) = serde_json::from_str::<SignedKey>(
&raw_token.intermediate_signing_key.signed_key.expose(),
) {
result.key_value = key.key_value;
result.key_expiration = key.key_expiration;
}
if let Ok(message) =
serde_json::from_str::<SignedMessage>(&raw_token.signed_message.expose())
{
result.encrypted_message = message.encrypted_message;
result.ephemeral_public_key = message.ephemeral_public_key;
result.tag = message.tag;
}
}
result
}
impl TryFrom<&FiservRouterData<&types::PaymentsAuthorizeRouterData>> for FiservPaymentsRequest {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: &FiservRouterData<&types::PaymentsAuthorizeRouterData>,
) -> Result<Self, Self::Error> {
let auth: FiservAuthType = FiservAuthType::try_from(&item.router_data.connector_auth_type)?;
let amount = Amount {
total: item.amount,
currency: item.router_data.request.currency.to_string(),
};
let metadata = item.router_data.get_connector_meta()?.clone();
let session: FiservSessionObject = metadata
.expose()
.parse_value("FiservSessionObject")
.change_context(errors::ConnectorError::InvalidConnectorConfig {
config: "Merchant connector account metadata",
})?;
let merchant_details = MerchantDetails {
merchant_id: auth.merchant_account,
terminal_id: Some(session.terminal_id),
};
let checkout_charges_request = match item.router_data.request.payment_method_data.clone() {
PaymentMethodData::Card(ref ccard) => {
Ok(FiservCheckoutChargesRequest::Charges(
ChargesPaymentRequest {
source: Source::PaymentCard {
card: CardData {
card_data: ccard.card_number.clone(),
expiration_month: ccard.card_exp_month.clone(),
expiration_year: ccard.get_expiry_year_4_digit(),
security_code: Some(ccard.card_cvc.clone()),
},
},
transaction_details: TransactionDetails {
capture_flag: Some(matches!(
item.router_data.request.capture_method,
Some(enums::CaptureMethod::Automatic)
| Some(enums::CaptureMethod::SequentialAutomatic)
| None
)),
reversal_reason_code: None,
merchant_transaction_id: Some(
item.router_data.connector_request_reference_id.clone(),
),
operation_type: None,
},
transaction_interaction: Some(TransactionInteraction {
//Payment is being made in online mode, card not present
origin: TransactionInteractionOrigin::Ecom,
// transaction encryption such as SSL/TLS, but authentication was not performed
eci_indicator: TransactionInteractionEciIndicator::ChannelEncrypted,
//card not present in online transaction
pos_condition_code:
TransactionInteractionPosConditionCode::CardNotPresentEcom,
}),
},
))
}
PaymentMethodData::Wallet(wallet_data) => match wallet_data {
WalletData::GooglePay(data) => {
let token_string = data
.tokenization_data
.get_encrypted_google_pay_token()
.change_context(errors::ConnectorError::MissingRequiredField {
field_name: "gpay wallet_token",
})?
.to_owned();
let parsed = parse_googlepay_token_safely(&token_string);
Ok(FiservCheckoutChargesRequest::Charges(
ChargesPaymentRequest {
source: Source::GooglePay(GooglePayData {
data: Secret::new(parsed.encrypted_message),
signature: Secret::new(parsed.signature.expose().to_owned()),
version: parsed.protocol_version,
intermediate_signing_key: IntermediateSigningKey {
signed_key: Secret::new(
serde_json::json!({
"keyValue": parsed.key_value,
"keyExpiration": parsed.key_expiration
})
.to_string(),
),
signatures: parsed
.signatures
.into_iter()
.map(|s| Secret::new(s.to_owned()))
.collect(),
},
}),
transaction_details: TransactionDetails {
capture_flag: Some(matches!(
item.router_data.request.capture_method,
Some(enums::CaptureMethod::Automatic)
| Some(enums::CaptureMethod::SequentialAutomatic)
| None
)),
reversal_reason_code: None,
merchant_transaction_id: Some(
item.router_data.connector_request_reference_id.clone(),
),
operation_type: None,
},
transaction_interaction: None,
},
))
}
WalletData::PaypalRedirect(_) => {
let return_url = item
.router_data
.request
.complete_authorize_url
.clone()
.ok_or(errors::ConnectorError::MissingRequiredField {
field_name: "return_url",
})?;
Ok(FiservCheckoutChargesRequest::Checkout(
CheckoutPaymentsRequest {
payment_method: FiservPaymentMethod {
provider: FiservWallet::PayPal,
wallet_type: FiservWalletType::PaypalWallet,
},
order: FiservOrder {
intent: FiservIntent::Authorize,
},
interactions: FiservInteractions {
channel: FiservChannel::Web,
customer_confirmation: FiservCustomerConfirmation::ReviewAndPay,
payment_initiator: FiservPaymentInitiator::Merchant,
return_urls: FiservReturnUrls {
success_url: return_url.clone(),
cancel_url: return_url,
},
},
transaction_details: TransactionDetails {
operation_type: Some(OperationType::Create),
capture_flag: Some(matches!(
item.router_data.request.capture_method,
Some(enums::CaptureMethod::Automatic)
| Some(enums::CaptureMethod::SequentialAutomatic)
| None
)),
reversal_reason_code: None,
merchant_transaction_id: Some(
item.router_data.connector_request_reference_id.clone(),
),
},
},
))
}
WalletData::ApplePay(apple_pay_data) => match item
.router_data
.payment_method_token
.clone()
{
Some(PaymentMethodToken::ApplePayDecrypt(pre_decrypt_data)) => Ok(
FiservCheckoutChargesRequest::Charges(ChargesPaymentRequest {
source: Source::DecryptedWallet(DecryptedWalletDetails {
wallet_type: FiservWalletType::ApplePay,
cryptogram: pre_decrypt_data
.payment_data
.online_payment_cryptogram
.clone(),
transaction_id: Secret::new(apple_pay_data.transaction_identifier),
card: WalletCardData {
card_data: pre_decrypt_data
.application_primary_account_number
.clone(),
expiration_month: pre_decrypt_data
.get_expiry_month()
.change_context(
errors::ConnectorError::MissingRequiredField {
field_name: "apple_pay_expiry_month",
},
)?,
expiration_year: pre_decrypt_data.get_four_digit_expiry_year(),
},
}),
transaction_details: TransactionDetails {
capture_flag: Some(matches!(
item.router_data.request.capture_method,
Some(enums::CaptureMethod::Automatic)
| Some(enums::CaptureMethod::SequentialAutomatic)
| None
)),
reversal_reason_code: None,
merchant_transaction_id: Some(
item.router_data.connector_request_reference_id.clone(),
),
operation_type: None,
},
transaction_interaction: None,
}),
),
_ => {
let decoded_bytes = match apple_pay_data.payment_data {
common_types::payments::ApplePayPaymentData::Encrypted(
ref encrypted_str,
) => BASE64_ENGINE
.decode(encrypted_str)
.change_context(errors::ConnectorError::ParsingFailed)?,
_ => {
return Err(errors::ConnectorError::ParsingFailed.into());
}
};
let payment_data_decoded: ApplePayDecryptedData =
serde_json::from_slice(&decoded_bytes)
.change_context(errors::ConnectorError::ParsingFailed)?;
let data = payment_data_decoded.data;
let signature = payment_data_decoded.signature;
let version = payment_data_decoded.version;
let header = ApplePayHeader {
ephemeral_public_key: payment_data_decoded.header.ephemeral_public_key,
public_key_hash: payment_data_decoded.header.public_key_hash,
transaction_id: payment_data_decoded.header.transaction_id,
application_data_hash: None,
};
let apple_pay_metadata = item.router_data.get_connector_meta()?.expose();
let applepay_metadata = apple_pay_metadata
.clone()
.parse_value::<ApplepayCombinedSessionTokenData>(
"ApplepayCombinedSessionTokenData",
)
.map(|combined_metadata| {
ApplepaySessionTokenMetadata::ApplePayCombined(
combined_metadata.apple_pay_combined,
)
})
.or_else(|_| {
apple_pay_metadata
.parse_value::<ApplepaySessionTokenData>(
"ApplepaySessionTokenData",
)
.map(|old_metadata| {
ApplepaySessionTokenMetadata::ApplePay(
old_metadata.apple_pay,
)
})
})
.change_context(errors::ConnectorError::ParsingFailed)?;
let merchant_identifier = match applepay_metadata {
ApplepaySessionTokenMetadata::ApplePayCombined(ref combined) => {
match combined {
ApplePayCombinedMetadata::Simplified { .. } => {
return Err(
errors::ConnectorError::MissingApplePayTokenData.into(),
)
}
ApplePayCombinedMetadata::Manual {
session_token_data, ..
} => &session_token_data.merchant_identifier,
}
}
ApplepaySessionTokenMetadata::ApplePay(ref data) => {
&data.session_token_data.merchant_identifier
}
};
Ok(FiservCheckoutChargesRequest::Charges(
ChargesPaymentRequest {
source: Source::ApplePay(ApplePayWalletDetails {
data,
header,
signature,
version,
application_data: None,
apple_pay_merchant_id: Secret::new(
merchant_identifier.to_owned(),
),
}),
transaction_details: TransactionDetails {
capture_flag: Some(matches!(
item.router_data.request.capture_method,
Some(enums::CaptureMethod::Automatic)
| Some(enums::CaptureMethod::SequentialAutomatic)
| None
)),
reversal_reason_code: None,
merchant_transaction_id: Some(
item.router_data.connector_request_reference_id.clone(),
),
operation_type: None,
},
transaction_interaction: None,
},
))
}
},
_ => Err(error_stack::report!(
errors::ConnectorError::NotImplemented(
utils::get_unimplemented_payment_method_error_message("fiserv"),
)
)),
},
PaymentMethodData::PayLater(_)
| PaymentMethodData::BankRedirect(_)
| PaymentMethodData::BankDebit(_)
| PaymentMethodData::CardRedirect(_)
| PaymentMethodData::BankTransfer(_)
| PaymentMethodData::Crypto(_)
| PaymentMethodData::MandatePayment
| PaymentMethodData::Reward
| PaymentMethodData::RealTimePayment(_)
| PaymentMethodData::Upi(_)
| PaymentMethodData::MobilePayment(_)
| PaymentMethodData::Voucher(_)
| PaymentMethodData::GiftCard(_)
| PaymentMethodData::OpenBanking(_)
| PaymentMethodData::CardToken(_)
| PaymentMethodData::NetworkToken(_)
| PaymentMethodData::CardDetailsForNetworkTransactionId(_) => Err(
error_stack::report!(errors::ConnectorError::NotImplemented(
utils::get_unimplemented_payment_method_error_message("fiserv"),
)),
),
}?;
Ok(Self {
amount,
checkout_charges_request,
merchant_details,
})
}
}
pub struct FiservAuthType {
pub(super) api_key: Secret<String>,
pub(super) merchant_account: Secret<String>,
pub(super) api_secret: Secret<String>,
}
impl TryFrom<&ConnectorAuthType> for FiservAuthType {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(auth_type: &ConnectorAuthType) -> Result<Self, Self::Error> {
if let ConnectorAuthType::SignatureKey {
api_key,
key1,
api_secret,
} = auth_type
{
Ok(Self {
api_key: api_key.to_owned(),
merchant_account: key1.to_owned(),
api_secret: api_secret.to_owned(),
})
} else {
Err(errors::ConnectorError::FailedToObtainAuthType)?
}
}
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct FiservCancelRequest {
transaction_details: TransactionDetails,
merchant_details: MerchantDetails,
reference_transaction_details: ReferenceTransactionDetails,
}
impl TryFrom<&types::PaymentsCancelRouterData> for FiservCancelRequest {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(item: &types::PaymentsCancelRouterData) -> Result<Self, Self::Error> {
let auth: FiservAuthType = FiservAuthType::try_from(&item.connector_auth_type)?;
let metadata = item.get_connector_meta()?.clone();
let session: FiservSessionObject = metadata
.expose()
.parse_value("FiservSessionObject")
.change_context(errors::ConnectorError::InvalidConnectorConfig {
config: "Merchant connector account metadata",
})?;
Ok(Self {
merchant_details: MerchantDetails {
merchant_id: auth.merchant_account,
terminal_id: Some(session.terminal_id),
},
reference_transaction_details: ReferenceTransactionDetails {
reference_transaction_id: item.request.connector_transaction_id.to_string(),
},
transaction_details: TransactionDetails {
capture_flag: None,
reversal_reason_code: Some(item.request.get_cancellation_reason()?),
merchant_transaction_id: Some(item.connector_request_reference_id.clone()),
operation_type: None,
},
})
}
}
#[derive(Debug, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ErrorResponse {
pub error: Option<Vec<ErrorDetails>>,
}
#[derive(Debug, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ErrorDetails {
#[serde(rename = "type")]
pub error_type: Option<String>,
pub code: Option<String>,
pub field: Option<String>,
pub message: Option<String>,
pub additional_info: Option<String>,
}
#[derive(Default, Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "UPPERCASE")]
pub enum FiservPaymentStatus {
Succeeded,
Failed,
Captured,
Declined,
Voided,
Authorized,
#[default]
Processing,
Created,
}
impl From<FiservPaymentStatus> for enums::AttemptStatus {
fn from(item: FiservPaymentStatus) -> Self {
match item {
FiservPaymentStatus::Captured | FiservPaymentStatus::Succeeded => Self::Charged,
FiservPaymentStatus::Declined | FiservPaymentStatus::Failed => Self::Failure,
FiservPaymentStatus::Processing => Self::Authorizing,
FiservPaymentStatus::Voided => Self::Voided,
FiservPaymentStatus::Authorized => Self::Authorized,
FiservPaymentStatus::Created => Self::AuthenticationPending,
}
}
}
impl From<FiservPaymentStatus> for enums::RefundStatus {
fn from(item: FiservPaymentStatus) -> Self {
match item {
FiservPaymentStatus::Succeeded
| FiservPaymentStatus::Authorized
| FiservPaymentStatus::Captured => Self::Success,
FiservPaymentStatus::Declined | FiservPaymentStatus::Failed => Self::Failure,
FiservPaymentStatus::Voided
| FiservPaymentStatus::Processing
| FiservPaymentStatus::Created => Self::Pending,
}
}
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ProcessorResponseDetails {
pub approval_status: Option<String>,
pub approval_code: Option<String>,
pub reference_number: Option<String>,
pub processor: Option<String>,
pub host: Option<String>,
pub network_routed: Option<String>,
pub network_international_id: Option<String>,
pub response_code: Option<String>,
pub response_message: Option<String>,
pub host_response_code: Option<String>,
pub host_response_message: Option<String>,
pub additional_info: Option<Vec<AdditionalInfo>>,
pub bank_association_details: Option<BankAssociationDetails>,
pub response_indicators: Option<ResponseIndicators>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct AdditionalInfo {
pub name: Option<String>,
pub value: Option<String>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct BankAssociationDetails {
pub association_response_code: Option<String>,
pub avs_security_code_response: Option<AvsSecurityCodeResponse>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct AvsSecurityCodeResponse {
pub street_match: Option<String>,
pub postal_code_match: Option<String>,
pub security_code_match: Option<String>,
pub association: Option<Association>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Association {
pub avs_code: Option<String>,
pub security_code_response: Option<String>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ResponseIndicators {
pub alternate_route_debit_indicator: Option<bool>,
pub signature_line_indicator: Option<bool>,
pub signature_debit_route_indicator: Option<bool>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct FiservChargesResponse {
pub gateway_response: GatewayResponse,
pub payment_receipt: PaymentReceipt,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct FiservCheckoutResponse {
pub gateway_response: GatewayResponse,
pub payment_receipt: PaymentReceipt,
pub interactions: FiservResponseInteractions,
pub order: Option<FiservResponseOrders>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct FiservResponseInteractions {
actions: FiservResponseActions,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct FiservResponseActions {
#[serde(rename = "type")]
action_type: String,
url: url::Url,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct FiservResponseOrders {
intent: FiservIntent,
order_id: String,
order_status: FiservOrderStatus,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "UPPERCASE")]
pub enum FiservOrderStatus {
PayerActionRequired,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum FiservPaymentsResponse {
Charges(FiservChargesResponse),
Checkout(FiservCheckoutResponse),
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct PaymentReceipt {
pub approved_amount: ApprovedAmount,
pub processor_response_details: Option<ProcessorResponseDetails>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ApprovedAmount {
pub total: FloatMajorUnit,
pub currency: Currency,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
#[serde(transparent)]
pub struct FiservSyncResponse {
pub sync_responses: Vec<FiservPaymentsResponse>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct GatewayResponse {
gateway_transaction_id: Option<String>,
transaction_state: FiservPaymentStatus,
transaction_processing_details: TransactionProcessingDetails,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct TransactionProcessingDetails {
order_id: String,
transaction_id: String,
}
impl<F, T> TryFrom<ResponseRouterData<F, FiservPaymentsResponse, T, PaymentsResponseData>>
for RouterData<F, T, PaymentsResponseData>
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: ResponseRouterData<F, FiservPaymentsResponse, T, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
let (gateway_resp, redirect_url, order_id) = match &item.response {
FiservPaymentsResponse::Charges(res) => (res.gateway_response.clone(), None, None),
FiservPaymentsResponse::Checkout(res) => (
res.gateway_response.clone(),
Some(res.interactions.actions.url.clone()),
res.order.as_ref().map(|o| o.order_id.clone()),
),
};
let redirection_data = redirect_url.map(|url| RedirectForm::from((url, Method::Get)));
let connector_metadata: Option<serde_json::Value> = Some(serde_json::json!({
"order_id": order_id,
}));
Ok(Self {
status: enums::AttemptStatus::from(gateway_resp.transaction_state),
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(
gateway_resp.transaction_processing_details.transaction_id,
),
redirection_data: Box::new(redirection_data),
mandate_reference: Box::new(None),
connector_metadata,
network_txn_id: None,
connector_response_reference_id: Some(
gateway_resp.transaction_processing_details.order_id,
),
incremental_authorization_allowed: None,
charges: None,
}),
..item.data
})
}
}
impl<F, T> TryFrom<ResponseRouterData<F, FiservSyncResponse, T, PaymentsResponseData>>
for RouterData<F, T, PaymentsResponseData>
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: ResponseRouterData<F, FiservSyncResponse, T, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
let gateway_resp = match item.response.sync_responses.first() {
Some(gateway_response) => gateway_response,
None => Err(errors::ConnectorError::ResponseHandlingFailed)?,
};
let connector_response_reference_id = match gateway_resp {
FiservPaymentsResponse::Charges(res) => {
&res.gateway_response.transaction_processing_details.order_id
}
FiservPaymentsResponse::Checkout(res) => {
&res.gateway_response.transaction_processing_details.order_id
}
};
let transaction_id = match gateway_resp {
FiservPaymentsResponse::Charges(res) => {
&res.gateway_response
.transaction_processing_details
.transaction_id
}
FiservPaymentsResponse::Checkout(res) => {
&res.gateway_response
.transaction_processing_details
.transaction_id
}
};
let transaction_state = match gateway_resp {
FiservPaymentsResponse::Charges(res) => &res.gateway_response.transaction_state,
FiservPaymentsResponse::Checkout(res) => &res.gateway_response.transaction_state,
};
Ok(Self {
status: enums::AttemptStatus::from(transaction_state.clone()),
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(transaction_id.to_string()),
redirection_data: Box::new(None),
mandate_reference: Box::new(None),
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: Some(connector_response_reference_id.to_string()),
incremental_authorization_allowed: None,
charges: None,
}),
..item.data
})
}
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct FiservCaptureRequest {
amount: Amount,
transaction_details: TransactionDetails,
merchant_details: MerchantDetails,
reference_transaction_details: ReferenceTransactionDetails,
#[serde(skip_serializing_if = "Option::is_none")]
order: Option<FiservOrderRequest>,
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct FiservOrderRequest {
order_id: Option<String>,
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ReferenceTransactionDetails {
reference_transaction_id: String,
}
#[derive(Debug, Serialize, Deserialize)]
pub struct FiservSessionObject {
pub terminal_id: Secret<String>,
}
impl TryFrom<&Option<pii::SecretSerdeValue>> for FiservSessionObject {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(meta_data: &Option<pii::SecretSerdeValue>) -> Result<Self, Self::Error> {
let metadata: Self = utils::to_connector_meta_from_secret::<Self>(meta_data.clone())
.change_context(errors::ConnectorError::InvalidConnectorConfig {
config: "metadata",
})?;
Ok(metadata)
}
}
impl TryFrom<&FiservRouterData<&types::PaymentsCaptureRouterData>> for FiservCaptureRequest {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: &FiservRouterData<&types::PaymentsCaptureRouterData>,
) -> Result<Self, Self::Error> {
let auth: FiservAuthType = FiservAuthType::try_from(&item.router_data.connector_auth_type)?;
let metadata = item
.router_data
.connector_meta_data
.clone()
.ok_or(errors::ConnectorError::RequestEncodingFailed)?;
let session: FiservSessionObject = metadata
.expose()
.parse_value("FiservSessionObject")
.change_context(errors::ConnectorError::InvalidConnectorConfig {
config: "Merchant connector account metadata",
})?;
let order_id = item
.router_data
.request
.connector_meta
.as_ref()
.and_then(|v| v.get("order_id"))
.and_then(|v| v.as_str())
.map(|s| s.to_string());
Ok(Self {
amount: Amount {
total: item.amount,
currency: item.router_data.request.currency.to_string(),
},
order: Some(FiservOrderRequest { order_id }),
transaction_details: TransactionDetails {
capture_flag: Some(true),
reversal_reason_code: None,
merchant_transaction_id: Some(
item.router_data.connector_request_reference_id.clone(),
),
operation_type: Some(OperationType::Capture),
},
merchant_details: MerchantDetails {
merchant_id: auth.merchant_account,
terminal_id: Some(session.terminal_id),
},
reference_transaction_details: ReferenceTransactionDetails {
reference_transaction_id: item
.router_data
.request
.connector_transaction_id
.to_string(),
},
})
}
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct FiservSyncRequest {
merchant_details: MerchantDetails,
reference_transaction_details: ReferenceTransactionDetails,
}
impl TryFrom<&types::PaymentsSyncRouterData> for FiservSyncRequest {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(item: &types::PaymentsSyncRouterData) -> Result<Self, Self::Error> {
let auth: FiservAuthType = FiservAuthType::try_from(&item.connector_auth_type)?;
Ok(Self {
merchant_details: MerchantDetails {
merchant_id: auth.merchant_account,
terminal_id: None,
},
reference_transaction_details: ReferenceTransactionDetails {
reference_transaction_id: item
.request
.get_connector_transaction_id()
.change_context(errors::ConnectorError::MissingConnectorTransactionID)?,
},
})
}
}
impl TryFrom<&types::RefundSyncRouterData> for FiservSyncRequest {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(item: &types::RefundSyncRouterData) -> Result<Self, Self::Error> {
let auth: FiservAuthType = FiservAuthType::try_from(&item.connector_auth_type)?;
Ok(Self {
merchant_details: MerchantDetails {
merchant_id: auth.merchant_account,
terminal_id: None,
},
reference_transaction_details: ReferenceTransactionDetails {
reference_transaction_id: item
.request
.connector_refund_id
.clone()
.ok_or(errors::ConnectorError::RequestEncodingFailed)?,
},
})
}
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct FiservRefundRequest {
amount: Amount,
merchant_details: MerchantDetails,
reference_transaction_details: ReferenceTransactionDetails,
}
impl<F> TryFrom<&FiservRouterData<&types::RefundsRouterData<F>>> for FiservRefundRequest {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: &FiservRouterData<&types::RefundsRouterData<F>>,
) -> Result<Self, Self::Error> {
let auth: FiservAuthType = FiservAuthType::try_from(&item.router_data.connector_auth_type)?;
let metadata = item
.router_data
.connector_meta_data
.clone()
.ok_or(errors::ConnectorError::RequestEncodingFailed)?;
let session: FiservSessionObject = metadata
.expose()
.parse_value("FiservSessionObject")
.change_context(errors::ConnectorError::InvalidConnectorConfig {
config: "Merchant connector account metadata",
})?;
Ok(Self {
amount: Amount {
total: item.amount,
currency: item.router_data.request.currency.to_string(),
},
merchant_details: MerchantDetails {
merchant_id: auth.merchant_account,
terminal_id: Some(session.terminal_id),
},
reference_transaction_details: ReferenceTransactionDetails {
reference_transaction_id: item
.router_data
.request
.connector_transaction_id
.to_string(),
},
})
}
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct RefundResponse {
pub gateway_response: GatewayResponse,
pub payment_receipt: PaymentReceipt,
}
impl TryFrom<RefundsResponseRouterData<Execute, RefundResponse>>
for types::RefundsRouterData<Execute>
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: RefundsResponseRouterData<Execute, RefundResponse>,
) -> Result<Self, Self::Error> {
Ok(Self {
response: Ok(RefundsResponseData {
connector_refund_id: item
.response
.gateway_response
.transaction_processing_details
.transaction_id,
refund_status: enums::RefundStatus::from(
item.response.gateway_response.transaction_state,
),
}),
..item.data
})
}
}
impl TryFrom<RefundsResponseRouterData<RSync, FiservSyncResponse>>
for types::RefundsRouterData<RSync>
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: RefundsResponseRouterData<RSync, FiservSyncResponse>,
) -> Result<Self, Self::Error> {
let gateway_resp = item
.response
.sync_responses
.first()
.ok_or(errors::ConnectorError::ResponseHandlingFailed)?;
let transaction_id = match gateway_resp {
FiservPaymentsResponse::Charges(res) => {
&res.gateway_response
.transaction_processing_details
.transaction_id
}
FiservPaymentsResponse::Checkout(res) => {
&res.gateway_response
.transaction_processing_details
.transaction_id
}
};
let transaction_state = match gateway_resp {
FiservPaymentsResponse::Charges(res) => &res.gateway_response.transaction_state,
FiservPaymentsResponse::Checkout(res) => &res.gateway_response.transaction_state,
};
Ok(Self {
response: Ok(RefundsResponseData {
connector_refund_id: transaction_id.clone(),
refund_status: enums::RefundStatus::from(transaction_state.clone()),
}),
..item.data
})
}
}
|
{
"crate": "hyperswitch_connectors",
"file": "crates/hyperswitch_connectors/src/connectors/fiserv/transformers.rs",
"file_size": null,
"is_async": null,
"is_pub": null,
"num_enums": 15,
"num_structs": 50,
"num_tables": null,
"score": null,
"total_crates": null
}
|
file_hyperswitch_connectors_-4459703554890260148
|
clm
|
file
|
// Repository: hyperswitch
// Crate: hyperswitch_connectors
// File: crates/hyperswitch_connectors/src/connectors/shift4/transformers.rs
// Contains: 30 structs, 7 enums
use api_models::webhooks::IncomingWebhookEvent;
use cards::CardNumber;
use common_enums::enums;
use common_utils::{
pii::{self, SecretSerdeValue},
request::Method,
types::MinorUnit,
};
use error_stack::ResultExt;
use hyperswitch_domain_models::{
payment_method_data::{
BankRedirectData, BankTransferData, Card as CardData, CryptoData, GiftCardData,
PayLaterData, PaymentMethodData, VoucherData, WalletData,
},
router_data::{ConnectorAuthType, RouterData},
router_flow_types::refunds::{Execute, RSync},
router_request_types::{
CompleteAuthorizeData, PaymentsAuthorizeData, PaymentsPreProcessingData, ResponseId,
},
router_response_types::{PaymentsResponseData, RedirectForm, RefundsResponseData},
types::{PaymentsPreProcessingRouterData, RefundsRouterData},
};
use hyperswitch_interfaces::errors;
use masking::Secret;
use serde::{Deserialize, Serialize};
use url::Url;
use crate::{
types::{
PaymentsPreprocessingResponseRouterData, RefundsResponseRouterData, ResponseRouterData,
},
utils::{
self, to_connector_meta, PaymentsAuthorizeRequestData,
PaymentsCompleteAuthorizeRequestData, PaymentsPreProcessingRequestData, RouterData as _,
},
};
type Error = error_stack::Report<errors::ConnectorError>;
trait Shift4AuthorizePreprocessingCommon {
fn is_automatic_capture(&self) -> Result<bool, Error>;
fn get_router_return_url(&self) -> Option<String>;
fn get_email_optional(&self) -> Option<pii::Email>;
fn get_complete_authorize_url(&self) -> Option<String>;
fn get_currency_required(&self) -> Result<enums::Currency, Error>;
fn get_metadata(&self) -> Result<Option<serde_json::Value>, Error>;
fn get_payment_method_data_required(&self) -> Result<PaymentMethodData, Error>;
}
pub struct Shift4RouterData<T> {
pub amount: MinorUnit,
pub router_data: T,
}
impl<T> TryFrom<(MinorUnit, T)> for Shift4RouterData<T> {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from((amount, item): (MinorUnit, T)) -> Result<Self, Self::Error> {
Ok(Self {
amount,
router_data: item,
})
}
}
impl Shift4AuthorizePreprocessingCommon for PaymentsAuthorizeData {
fn get_email_optional(&self) -> Option<pii::Email> {
self.email.clone()
}
fn get_complete_authorize_url(&self) -> Option<String> {
self.complete_authorize_url.clone()
}
fn get_currency_required(
&self,
) -> Result<enums::Currency, error_stack::Report<errors::ConnectorError>> {
Ok(self.currency)
}
fn get_payment_method_data_required(
&self,
) -> Result<PaymentMethodData, error_stack::Report<errors::ConnectorError>> {
Ok(self.payment_method_data.clone())
}
fn is_automatic_capture(&self) -> Result<bool, Error> {
self.is_auto_capture()
}
fn get_router_return_url(&self) -> Option<String> {
self.router_return_url.clone()
}
fn get_metadata(
&self,
) -> Result<Option<serde_json::Value>, error_stack::Report<errors::ConnectorError>> {
Ok(self.metadata.clone())
}
}
impl Shift4AuthorizePreprocessingCommon for PaymentsPreProcessingData {
fn get_email_optional(&self) -> Option<pii::Email> {
self.email.clone()
}
fn get_complete_authorize_url(&self) -> Option<String> {
self.complete_authorize_url.clone()
}
fn get_currency_required(&self) -> Result<enums::Currency, Error> {
self.get_currency()
}
fn get_payment_method_data_required(&self) -> Result<PaymentMethodData, Error> {
self.payment_method_data.clone().ok_or(
errors::ConnectorError::MissingRequiredField {
field_name: "payment_method_data",
}
.into(),
)
}
fn is_automatic_capture(&self) -> Result<bool, Error> {
self.is_auto_capture()
}
fn get_router_return_url(&self) -> Option<String> {
self.router_return_url.clone()
}
fn get_metadata(
&self,
) -> Result<Option<serde_json::Value>, error_stack::Report<errors::ConnectorError>> {
Ok(None)
}
}
#[derive(Debug, Serialize)]
pub struct Shift4PaymentsRequest {
amount: MinorUnit,
currency: enums::Currency,
captured: bool,
metadata: Option<serde_json::Value>,
#[serde(flatten)]
payment_method: Shift4PaymentMethod,
}
#[derive(Debug, Serialize)]
#[serde(untagged)]
pub enum Shift4PaymentMethod {
CardsNon3DSRequest(Box<CardsNon3DSRequest>),
BankRedirectRequest(Box<BankRedirectRequest>),
Cards3DSRequest(Box<Cards3DSRequest>),
VoucherRequest(Box<VoucherRequest>),
WalletRequest(Box<WalletRequest>),
PayLaterRequest(Box<PayLaterRequest>),
CryptoRequest(Box<CryptoRequest>),
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct WalletRequest {
flow: Flow,
payment_method: PaymentMethod,
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct PayLaterRequest {
flow: Flow,
payment_method: PaymentMethod,
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct CryptoRequest {
flow: Flow,
payment_method: PaymentMethod,
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct VoucherRequest {
flow: Flow,
payment_method: PaymentMethod,
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct BankRedirectRequest {
payment_method: PaymentMethod,
flow: Flow,
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct Cards3DSRequest {
#[serde(rename = "card[number]")]
pub card_number: CardNumber,
#[serde(rename = "card[expMonth]")]
pub card_exp_month: Secret<String>,
#[serde(rename = "card[expYear]")]
pub card_exp_year: Secret<String>,
return_url: String,
}
#[serde_with::skip_serializing_none]
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct CardsNon3DSRequest {
card: CardPayment,
description: Option<String>,
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct Flow {
pub return_url: String,
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "snake_case")]
pub enum PaymentMethodType {
Eps,
Giropay,
Ideal,
Sofort,
Boleto,
Trustly,
Alipay,
Wechatpay,
Blik,
KlarnaDebitRisk,
Bitpay,
Paysera,
Skrill,
}
#[derive(Debug, Serialize)]
pub struct PaymentMethod {
#[serde(rename = "type")]
method_type: PaymentMethodType,
billing: Billing,
}
#[derive(Debug, Serialize)]
pub struct Billing {
name: Option<Secret<String>>,
email: Option<pii::Email>,
address: Option<Address>,
#[serde(skip_serializing_if = "Option::is_none")]
vat: Option<Secret<String>>,
}
#[derive(Debug, Serialize)]
pub struct Address {
line1: Option<Secret<String>>,
line2: Option<Secret<String>>,
zip: Option<Secret<String>>,
state: Option<Secret<String>>,
city: Option<String>,
country: Option<api_models::enums::CountryAlpha2>,
}
#[derive(Default, Debug, Serialize, Eq, PartialEq)]
pub struct DeviceData;
#[derive(Default, Debug, Serialize, Eq, PartialEq)]
#[serde(rename_all = "camelCase")]
pub struct Card {
pub number: CardNumber,
pub exp_month: Secret<String>,
pub exp_year: Secret<String>,
pub cardholder_name: Secret<String>,
}
#[derive(Debug, Serialize, Eq, PartialEq)]
#[serde(untagged)]
pub enum CardPayment {
RawCard(Box<Card>),
CardToken(Secret<String>),
}
impl<T, Req> TryFrom<&Shift4RouterData<&RouterData<T, Req, PaymentsResponseData>>>
for Shift4PaymentsRequest
where
Req: Shift4AuthorizePreprocessingCommon,
{
type Error = Error;
fn try_from(
item: &Shift4RouterData<&RouterData<T, Req, PaymentsResponseData>>,
) -> Result<Self, Self::Error> {
let submit_for_settlement = item.router_data.request.is_automatic_capture()?;
let amount = item.amount.to_owned();
let currency = item.router_data.request.get_currency_required()?;
let metadata = item.router_data.request.get_metadata()?;
let payment_method = Shift4PaymentMethod::try_from(item.router_data)?;
Ok(Self {
amount,
currency,
captured: submit_for_settlement,
metadata,
payment_method,
})
}
}
impl TryFrom<&PayLaterData> for PaymentMethodType {
type Error = Error;
fn try_from(value: &PayLaterData) -> Result<Self, Self::Error> {
match value {
PayLaterData::KlarnaRedirect { .. } => Ok(Self::KlarnaDebitRisk),
PayLaterData::AffirmRedirect { .. }
| PayLaterData::AfterpayClearpayRedirect { .. }
| PayLaterData::PayBrightRedirect { .. }
| PayLaterData::WalleyRedirect { .. }
| PayLaterData::AlmaRedirect { .. }
| PayLaterData::AtomeRedirect { .. }
| PayLaterData::FlexitiRedirect { .. }
| PayLaterData::KlarnaSdk { .. }
| PayLaterData::BreadpayRedirect { .. } => Err(errors::ConnectorError::NotImplemented(
utils::get_unimplemented_payment_method_error_message("Shift4"),
)
.into()),
}
}
}
impl<T, Req> TryFrom<(&RouterData<T, Req, PaymentsResponseData>, &PayLaterData)>
for Shift4PaymentMethod
where
Req: Shift4AuthorizePreprocessingCommon,
{
type Error = Error;
fn try_from(
(item, pay_later_data): (&RouterData<T, Req, PaymentsResponseData>, &PayLaterData),
) -> Result<Self, Self::Error> {
let flow = Flow::try_from(item.request.get_router_return_url())?;
let method_type = PaymentMethodType::try_from(pay_later_data)?;
let billing = Billing::try_from(item)?;
let payment_method = PaymentMethod {
method_type,
billing,
};
Ok(Self::BankRedirectRequest(Box::new(BankRedirectRequest {
payment_method,
flow,
})))
}
}
impl<T, Req> TryFrom<&RouterData<T, Req, PaymentsResponseData>> for Shift4PaymentMethod
where
Req: Shift4AuthorizePreprocessingCommon,
{
type Error = Error;
fn try_from(item: &RouterData<T, Req, PaymentsResponseData>) -> Result<Self, Self::Error> {
match item.request.get_payment_method_data_required()? {
PaymentMethodData::Card(ref ccard) => Self::try_from((item, ccard)),
PaymentMethodData::BankRedirect(ref redirect) => Self::try_from((item, redirect)),
PaymentMethodData::Wallet(ref wallet_data) => Self::try_from((item, wallet_data)),
PaymentMethodData::BankTransfer(ref bank_transfer_data) => {
Self::try_from(bank_transfer_data.as_ref())
}
PaymentMethodData::Voucher(ref voucher_data) => Self::try_from((item, voucher_data)),
PaymentMethodData::GiftCard(ref giftcard_data) => {
Self::try_from(giftcard_data.as_ref())
}
PaymentMethodData::PayLater(ref pay_later_data) => {
Self::try_from((item, pay_later_data))
}
PaymentMethodData::Crypto(ref crypto_data) => Self::try_from((item, crypto_data)),
PaymentMethodData::CardRedirect(_)
| PaymentMethodData::BankDebit(_)
| PaymentMethodData::MandatePayment
| PaymentMethodData::Reward
| PaymentMethodData::RealTimePayment(_)
| PaymentMethodData::MobilePayment(_)
| PaymentMethodData::Upi(_)
| PaymentMethodData::OpenBanking(_)
| PaymentMethodData::CardToken(_)
| PaymentMethodData::NetworkToken(_)
| PaymentMethodData::CardDetailsForNetworkTransactionId(_) => {
Err(errors::ConnectorError::NotImplemented(
utils::get_unimplemented_payment_method_error_message("Shift4"),
)
.into())
}
}
}
}
impl TryFrom<&WalletData> for PaymentMethodType {
type Error = Error;
fn try_from(value: &WalletData) -> Result<Self, Self::Error> {
match value {
WalletData::AliPayRedirect { .. } => Ok(Self::Alipay),
WalletData::WeChatPayRedirect { .. } => Ok(Self::Wechatpay),
WalletData::Paysera(_) => Ok(Self::Paysera),
WalletData::Skrill(_) => Ok(Self::Skrill),
WalletData::AliPayQr(_)
| WalletData::AmazonPay(_)
| WalletData::AliPayHkRedirect(_)
| WalletData::AmazonPayRedirect(_)
| WalletData::MomoRedirect(_)
| WalletData::KakaoPayRedirect(_)
| WalletData::GoPayRedirect(_)
| WalletData::GcashRedirect(_)
| WalletData::ApplePay(_)
| WalletData::ApplePayRedirect(_)
| WalletData::ApplePayThirdPartySdk(_)
| WalletData::DanaRedirect {}
| WalletData::GooglePayRedirect(_)
| WalletData::GooglePayThirdPartySdk(_)
| WalletData::GooglePay(_)
| WalletData::BluecodeRedirect {}
| WalletData::PaypalRedirect(_)
| WalletData::MbWayRedirect(_)
| WalletData::MobilePayRedirect(_)
| WalletData::PaypalSdk(_)
| WalletData::Paze(_)
| WalletData::SamsungPay(_)
| WalletData::TwintRedirect {}
| WalletData::VippsRedirect {}
| WalletData::TouchNGoRedirect(_)
| WalletData::WeChatPayQr(_)
| WalletData::CashappQr(_)
| WalletData::SwishQr(_)
| WalletData::Mifinity(_)
| WalletData::RevolutPay(_) => Err(errors::ConnectorError::NotImplemented(
utils::get_unimplemented_payment_method_error_message("Shift4"),
)
.into()),
}
}
}
impl<T, Req> TryFrom<(&RouterData<T, Req, PaymentsResponseData>, &WalletData)>
for Shift4PaymentMethod
where
Req: Shift4AuthorizePreprocessingCommon,
{
type Error = Error;
fn try_from(
(item, wallet_data): (&RouterData<T, Req, PaymentsResponseData>, &WalletData),
) -> Result<Self, Self::Error> {
let flow = Flow::try_from(item.request.get_router_return_url())?;
let method_type = PaymentMethodType::try_from(wallet_data)?;
let billing = Billing::try_from(item)?;
let payment_method = PaymentMethod {
method_type,
billing,
};
Ok(Self::WalletRequest(Box::new(WalletRequest {
payment_method,
flow,
})))
}
}
impl TryFrom<&BankTransferData> for Shift4PaymentMethod {
type Error = Error;
fn try_from(bank_transfer_data: &BankTransferData) -> Result<Self, Self::Error> {
match bank_transfer_data {
BankTransferData::MultibancoBankTransfer { .. }
| BankTransferData::AchBankTransfer { .. }
| BankTransferData::SepaBankTransfer { .. }
| BankTransferData::BacsBankTransfer { .. }
| BankTransferData::PermataBankTransfer { .. }
| BankTransferData::BcaBankTransfer { .. }
| BankTransferData::BniVaBankTransfer { .. }
| BankTransferData::BriVaBankTransfer { .. }
| BankTransferData::CimbVaBankTransfer { .. }
| BankTransferData::DanamonVaBankTransfer { .. }
| BankTransferData::MandiriVaBankTransfer { .. }
| BankTransferData::Pix { .. }
| BankTransferData::Pse {}
| BankTransferData::InstantBankTransfer {}
| BankTransferData::InstantBankTransferFinland { .. }
| BankTransferData::InstantBankTransferPoland { .. }
| BankTransferData::IndonesianBankTransfer { .. }
| BankTransferData::LocalBankTransfer { .. } => {
Err(errors::ConnectorError::NotImplemented(
utils::get_unimplemented_payment_method_error_message("Shift4"),
)
.into())
}
}
}
}
impl TryFrom<&VoucherData> for PaymentMethodType {
type Error = Error;
fn try_from(value: &VoucherData) -> Result<Self, Self::Error> {
match value {
VoucherData::Boleto { .. } => Ok(Self::Boleto),
VoucherData::Alfamart { .. }
| VoucherData::Indomaret { .. }
| VoucherData::Efecty
| VoucherData::PagoEfectivo
| VoucherData::RedCompra
| VoucherData::Oxxo
| VoucherData::RedPagos
| VoucherData::SevenEleven { .. }
| VoucherData::Lawson { .. }
| VoucherData::MiniStop { .. }
| VoucherData::FamilyMart { .. }
| VoucherData::Seicomart { .. }
| VoucherData::PayEasy { .. } => Err(errors::ConnectorError::NotImplemented(
utils::get_unimplemented_payment_method_error_message("Shift4"),
)
.into()),
}
}
}
impl<T, Req> TryFrom<(&RouterData<T, Req, PaymentsResponseData>, &VoucherData)>
for Shift4PaymentMethod
where
Req: Shift4AuthorizePreprocessingCommon,
{
type Error = Error;
fn try_from(
(item, voucher_data): (&RouterData<T, Req, PaymentsResponseData>, &VoucherData),
) -> Result<Self, Self::Error> {
let mut billing = Billing::try_from(item)?;
match voucher_data {
VoucherData::Boleto(boleto_data) => {
billing.vat = boleto_data.social_security_number.clone();
}
_ => {
billing.vat = None;
}
};
let method_type = PaymentMethodType::try_from(voucher_data)?;
let payment_method_details = PaymentMethod {
method_type,
billing,
};
let flow = Flow::try_from(item.request.get_router_return_url())?;
Ok(Self::VoucherRequest(Box::new(VoucherRequest {
payment_method: payment_method_details,
flow,
})))
}
}
impl TryFrom<&GiftCardData> for Shift4PaymentMethod {
type Error = Error;
fn try_from(gift_card_data: &GiftCardData) -> Result<Self, Self::Error> {
match gift_card_data {
GiftCardData::Givex(_)
| GiftCardData::PaySafeCard {}
| GiftCardData::BhnCardNetwork(_) => Err(errors::ConnectorError::NotImplemented(
utils::get_unimplemented_payment_method_error_message("Shift4"),
)
.into()),
}
}
}
impl<T, Req> TryFrom<(&RouterData<T, Req, PaymentsResponseData>, &CardData)> for Shift4PaymentMethod
where
Req: Shift4AuthorizePreprocessingCommon,
{
type Error = Error;
fn try_from(
(item, card): (&RouterData<T, Req, PaymentsResponseData>, &CardData),
) -> Result<Self, Self::Error> {
let card_object = Card {
number: card.card_number.clone(),
exp_month: card.card_exp_month.clone(),
exp_year: card.card_exp_year.clone(),
cardholder_name: item
.get_optional_billing_full_name()
.unwrap_or(Secret::new("".to_string())),
};
if item.is_three_ds() {
Ok(Self::Cards3DSRequest(Box::new(Cards3DSRequest {
card_number: card_object.number,
card_exp_month: card_object.exp_month,
card_exp_year: card_object.exp_year,
return_url: item
.request
.get_complete_authorize_url()
.clone()
.ok_or_else(|| errors::ConnectorError::RequestEncodingFailed)?,
})))
} else {
Ok(Self::CardsNon3DSRequest(Box::new(CardsNon3DSRequest {
card: CardPayment::RawCard(Box::new(card_object)),
description: item.description.clone(),
})))
}
}
}
impl<T, Req> TryFrom<(&RouterData<T, Req, PaymentsResponseData>, &BankRedirectData)>
for Shift4PaymentMethod
where
Req: Shift4AuthorizePreprocessingCommon,
{
type Error = Error;
fn try_from(
(item, redirect_data): (&RouterData<T, Req, PaymentsResponseData>, &BankRedirectData),
) -> Result<Self, Self::Error> {
let flow = Flow::try_from(item.request.get_router_return_url())?;
let method_type = PaymentMethodType::try_from(redirect_data)?;
let billing = Billing::try_from(item)?;
let payment_method = PaymentMethod {
method_type,
billing,
};
Ok(Self::BankRedirectRequest(Box::new(BankRedirectRequest {
payment_method,
flow,
})))
}
}
impl TryFrom<&CryptoData> for PaymentMethodType {
type Error = Error;
fn try_from(_value: &CryptoData) -> Result<Self, Self::Error> {
Ok(Self::Bitpay)
}
}
impl<T, Req> TryFrom<(&RouterData<T, Req, PaymentsResponseData>, &CryptoData)>
for Shift4PaymentMethod
where
Req: Shift4AuthorizePreprocessingCommon,
{
type Error = Error;
fn try_from(
(item, redirect_data): (&RouterData<T, Req, PaymentsResponseData>, &CryptoData),
) -> Result<Self, Self::Error> {
let flow = Flow::try_from(item.request.get_router_return_url())?;
let method_type = PaymentMethodType::try_from(redirect_data)?;
let billing = Billing::try_from(item)?;
let payment_method = PaymentMethod {
method_type,
billing,
};
Ok(Self::CryptoRequest(Box::new(CryptoRequest {
payment_method,
flow,
})))
}
}
impl<T> TryFrom<&Shift4RouterData<&RouterData<T, CompleteAuthorizeData, PaymentsResponseData>>>
for Shift4PaymentsRequest
{
type Error = Error;
fn try_from(
item: &Shift4RouterData<&RouterData<T, CompleteAuthorizeData, PaymentsResponseData>>,
) -> Result<Self, Self::Error> {
match &item.router_data.request.payment_method_data {
Some(PaymentMethodData::Card(_)) => {
let card_token: Shift4CardToken =
to_connector_meta(item.router_data.request.connector_meta.clone())?;
let metadata = item.router_data.request.metadata.clone();
Ok(Self {
amount: item.amount.to_owned(),
currency: item.router_data.request.currency,
metadata,
payment_method: Shift4PaymentMethod::CardsNon3DSRequest(Box::new(
CardsNon3DSRequest {
card: CardPayment::CardToken(card_token.id),
description: item.router_data.description.clone(),
},
)),
captured: item.router_data.request.is_auto_capture()?,
})
}
Some(PaymentMethodData::Wallet(_))
| Some(PaymentMethodData::GiftCard(_))
| Some(PaymentMethodData::CardRedirect(_))
| Some(PaymentMethodData::PayLater(_))
| Some(PaymentMethodData::BankDebit(_))
| Some(PaymentMethodData::BankRedirect(_))
| Some(PaymentMethodData::BankTransfer(_))
| Some(PaymentMethodData::Crypto(_))
| Some(PaymentMethodData::MandatePayment)
| Some(PaymentMethodData::Voucher(_))
| Some(PaymentMethodData::Reward)
| Some(PaymentMethodData::RealTimePayment(_))
| Some(PaymentMethodData::MobilePayment(_))
| Some(PaymentMethodData::Upi(_))
| Some(PaymentMethodData::OpenBanking(_))
| Some(PaymentMethodData::CardToken(_))
| Some(PaymentMethodData::NetworkToken(_))
| Some(PaymentMethodData::CardDetailsForNetworkTransactionId(_))
| None => Err(errors::ConnectorError::NotImplemented(
utils::get_unimplemented_payment_method_error_message("Shift4"),
)
.into()),
}
}
}
impl TryFrom<&BankRedirectData> for PaymentMethodType {
type Error = Error;
fn try_from(value: &BankRedirectData) -> Result<Self, Self::Error> {
match value {
BankRedirectData::Eps { .. } => Ok(Self::Eps),
BankRedirectData::Giropay { .. } => Ok(Self::Giropay),
BankRedirectData::Ideal { .. } => Ok(Self::Ideal),
BankRedirectData::Sofort { .. } => Ok(Self::Sofort),
BankRedirectData::Trustly { .. } => Ok(Self::Trustly),
BankRedirectData::Blik { .. } => Ok(Self::Blik),
BankRedirectData::BancontactCard { .. }
| BankRedirectData::Eft { .. }
| BankRedirectData::Przelewy24 { .. }
| BankRedirectData::Bizum {}
| BankRedirectData::Interac { .. }
| BankRedirectData::OnlineBankingCzechRepublic { .. }
| BankRedirectData::OnlineBankingFinland { .. }
| BankRedirectData::OnlineBankingPoland { .. }
| BankRedirectData::OnlineBankingSlovakia { .. }
| BankRedirectData::OpenBankingUk { .. }
| BankRedirectData::OnlineBankingFpx { .. }
| BankRedirectData::OnlineBankingThailand { .. }
| BankRedirectData::LocalBankRedirect {} => {
Err(errors::ConnectorError::NotImplemented(
utils::get_unimplemented_payment_method_error_message("Shift4"),
)
.into())
}
}
}
}
impl TryFrom<Option<String>> for Flow {
type Error = Error;
fn try_from(router_return_url: Option<String>) -> Result<Self, Self::Error> {
Ok(Self {
return_url: router_return_url.ok_or(errors::ConnectorError::RequestEncodingFailed)?,
})
}
}
impl<T, Req> TryFrom<&RouterData<T, Req, PaymentsResponseData>> for Billing
where
Req: Shift4AuthorizePreprocessingCommon,
{
type Error = Error;
fn try_from(item: &RouterData<T, Req, PaymentsResponseData>) -> Result<Self, Self::Error> {
let billing_details = item.get_optional_billing();
let address_details_model = billing_details.as_ref().and_then(|b| b.address.as_ref());
let address = get_address_details(address_details_model);
Ok(Self {
name: item.get_optional_billing_full_name(),
email: item.request.get_email_optional(),
address,
vat: None,
})
}
}
fn get_address_details(
address_details: Option<&hyperswitch_domain_models::address::AddressDetails>,
) -> Option<Address> {
address_details.map(|address| Address {
line1: address.line1.clone(),
line2: address.line1.clone(),
zip: address.zip.clone(),
state: address.state.clone(),
city: address.city.clone(),
country: address.country,
})
}
// Auth Struct
pub struct Shift4AuthType {
pub(super) api_key: Secret<String>,
}
impl TryFrom<&ConnectorAuthType> for Shift4AuthType {
type Error = Error;
fn try_from(item: &ConnectorAuthType) -> Result<Self, Self::Error> {
if let ConnectorAuthType::HeaderKey { api_key } = item {
Ok(Self {
api_key: api_key.to_owned(),
})
} else {
Err(errors::ConnectorError::FailedToObtainAuthType)?
}
}
}
// PaymentsResponse
#[derive(Debug, Clone, Default, Serialize, Deserialize, Eq, PartialEq)]
#[serde(rename_all = "lowercase")]
pub enum Shift4PaymentStatus {
Successful,
Failed,
#[default]
Pending,
}
fn get_status(
captured: bool,
next_action: Option<&NextAction>,
payment_status: Shift4PaymentStatus,
) -> enums::AttemptStatus {
match payment_status {
Shift4PaymentStatus::Successful => {
if captured {
enums::AttemptStatus::Charged
} else {
enums::AttemptStatus::Authorized
}
}
Shift4PaymentStatus::Failed => enums::AttemptStatus::Failure,
Shift4PaymentStatus::Pending => match next_action {
Some(NextAction::Redirect) => enums::AttemptStatus::AuthenticationPending,
Some(NextAction::Wait) | Some(NextAction::None) | None => enums::AttemptStatus::Pending,
},
}
}
#[derive(Debug, Deserialize)]
pub struct Shift4WebhookObjectEventType {
#[serde(rename = "type")]
pub event_type: Shift4WebhookEvent,
}
#[derive(Debug, Deserialize)]
#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
pub enum Shift4WebhookEvent {
ChargeSucceeded,
ChargeFailed,
ChargeUpdated,
ChargeCaptured,
ChargeRefunded,
#[serde(other)]
Unknown,
}
#[derive(Debug, Deserialize)]
pub struct Shift4WebhookObjectData {
pub id: String,
pub refunds: Option<Vec<RefundIdObject>>,
}
#[derive(Debug, Deserialize)]
pub struct RefundIdObject {
pub id: String,
}
#[derive(Debug, Deserialize)]
pub struct Shift4WebhookObjectId {
#[serde(rename = "type")]
pub event_type: Shift4WebhookEvent,
pub data: Shift4WebhookObjectData,
}
#[derive(Debug, Deserialize)]
pub struct Shift4WebhookObjectResource {
pub data: serde_json::Value,
}
#[derive(Default, Debug, Deserialize, Serialize)]
pub struct Shift4NonThreeDsResponse {
pub id: String,
pub currency: String,
pub amount: u32,
pub status: Shift4PaymentStatus,
pub captured: bool,
pub refunded: bool,
pub flow: Option<FlowResponse>,
}
#[derive(Default, Debug, Deserialize, Serialize)]
pub struct Shift4ThreeDsResponse {
pub enrolled: bool,
pub version: Option<String>,
#[serde(rename = "redirectUrl")]
pub redirect_url: Option<Url>,
pub token: Token,
}
#[derive(Default, Debug, Deserialize, Serialize)]
pub struct Token {
pub id: Secret<String>,
pub created: i64,
#[serde(rename = "objectType")]
pub object_type: String,
pub first6: String,
pub last4: String,
pub fingerprint: Secret<String>,
pub brand: String,
#[serde(rename = "type")]
pub token_type: String,
pub country: String,
pub used: bool,
#[serde(rename = "threeDSecureInfo")]
pub three_d_secure_info: ThreeDSecureInfo,
}
#[derive(Default, Debug, Deserialize, Serialize)]
pub struct ThreeDSecureInfo {
pub amount: MinorUnit,
pub currency: String,
pub enrolled: bool,
#[serde(rename = "liabilityShift")]
pub liability_shift: Option<String>,
pub version: String,
#[serde(rename = "authenticationFlow")]
pub authentication_flow: Option<SecretSerdeValue>,
}
#[derive(Debug, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct FlowResponse {
pub next_action: Option<NextAction>,
pub redirect: Option<Redirect>,
pub return_url: Option<Url>,
}
#[derive(Debug, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct Redirect {
pub redirect_url: Option<Url>,
}
#[derive(Debug, Deserialize, Serialize)]
#[serde(rename_all = "lowercase")]
pub enum NextAction {
Redirect,
Wait,
None,
}
#[derive(Debug, Serialize, Deserialize)]
pub struct Shift4CardToken {
pub id: Secret<String>,
}
impl TryFrom<PaymentsPreprocessingResponseRouterData<Shift4ThreeDsResponse>>
for PaymentsPreProcessingRouterData
{
type Error = Error;
fn try_from(
item: PaymentsPreprocessingResponseRouterData<Shift4ThreeDsResponse>,
) -> Result<Self, Self::Error> {
let redirection_data = item
.response
.redirect_url
.map(|url| RedirectForm::from((url, Method::Get)));
Ok(Self {
status: if redirection_data.is_some() {
enums::AttemptStatus::AuthenticationPending
} else {
enums::AttemptStatus::Pending
},
request: PaymentsPreProcessingData {
enrolled_for_3ds: item.response.enrolled,
..item.data.request
},
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::NoResponseId,
redirection_data: Box::new(redirection_data),
mandate_reference: Box::new(None),
connector_metadata: Some(
serde_json::to_value(Shift4CardToken {
id: item.response.token.id,
})
.change_context(errors::ConnectorError::ResponseDeserializationFailed)?,
),
network_txn_id: None,
connector_response_reference_id: None,
incremental_authorization_allowed: None,
charges: None,
}),
..item.data
})
}
}
impl<T, F> TryFrom<ResponseRouterData<F, Shift4NonThreeDsResponse, T, PaymentsResponseData>>
for RouterData<F, T, PaymentsResponseData>
{
type Error = Error;
fn try_from(
item: ResponseRouterData<F, Shift4NonThreeDsResponse, T, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
let connector_id = ResponseId::ConnectorTransactionId(item.response.id.clone());
Ok(Self {
status: get_status(
item.response.captured,
item.response
.flow
.as_ref()
.and_then(|flow| flow.next_action.as_ref()),
item.response.status,
),
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: connector_id,
redirection_data: Box::new(
item.response
.flow
.and_then(|flow| flow.redirect)
.and_then(|redirect| redirect.redirect_url)
.map(|url| RedirectForm::from((url, Method::Get))),
),
mandate_reference: Box::new(None),
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: Some(item.response.id),
incremental_authorization_allowed: None,
charges: None,
}),
..item.data
})
}
}
// REFUND :
// Type definition for RefundRequest
#[derive(Default, Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct Shift4RefundRequest {
charge_id: String,
amount: MinorUnit,
}
impl<F> TryFrom<&Shift4RouterData<&RefundsRouterData<F>>> for Shift4RefundRequest {
type Error = Error;
fn try_from(item: &Shift4RouterData<&RefundsRouterData<F>>) -> Result<Self, Self::Error> {
Ok(Self {
charge_id: item.router_data.request.connector_transaction_id.clone(),
amount: item.amount.to_owned(),
})
}
}
impl From<Shift4RefundStatus> for enums::RefundStatus {
fn from(item: Shift4RefundStatus) -> Self {
match item {
Shift4RefundStatus::Successful => Self::Success,
Shift4RefundStatus::Failed => Self::Failure,
Shift4RefundStatus::Processing => Self::Pending,
}
}
}
#[derive(Default, Debug, Clone, Serialize, Deserialize)]
pub struct RefundResponse {
pub id: String,
pub amount: i64,
pub currency: String,
pub charge: String,
pub status: Shift4RefundStatus,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, Eq, PartialEq)]
#[serde(rename_all = "lowercase")]
pub enum Shift4RefundStatus {
Successful,
Processing,
#[default]
Failed,
}
impl TryFrom<RefundsResponseRouterData<Execute, RefundResponse>> for RefundsRouterData<Execute> {
type Error = Error;
fn try_from(
item: RefundsResponseRouterData<Execute, RefundResponse>,
) -> Result<Self, Self::Error> {
let refund_status = enums::RefundStatus::from(item.response.status);
Ok(Self {
response: Ok(RefundsResponseData {
connector_refund_id: item.response.id,
refund_status,
}),
..item.data
})
}
}
impl TryFrom<RefundsResponseRouterData<RSync, RefundResponse>> for RefundsRouterData<RSync> {
type Error = Error;
fn try_from(
item: RefundsResponseRouterData<RSync, RefundResponse>,
) -> Result<Self, Self::Error> {
let refund_status = enums::RefundStatus::from(item.response.status);
Ok(Self {
response: Ok(RefundsResponseData {
connector_refund_id: item.response.id,
refund_status,
}),
..item.data
})
}
}
#[derive(Debug, Default, Deserialize, Serialize)]
pub struct ErrorResponse {
pub error: ApiErrorResponse,
}
#[derive(Default, Debug, Clone, Deserialize, Eq, PartialEq, Serialize)]
pub struct ApiErrorResponse {
pub code: Option<String>,
pub message: String,
}
pub fn is_transaction_event(event: &Shift4WebhookEvent) -> bool {
matches!(
event,
Shift4WebhookEvent::ChargeCaptured
| Shift4WebhookEvent::ChargeFailed
| Shift4WebhookEvent::ChargeSucceeded
| Shift4WebhookEvent::ChargeUpdated
)
}
pub fn is_refund_event(event: &Shift4WebhookEvent) -> bool {
matches!(event, Shift4WebhookEvent::ChargeRefunded)
}
impl From<Shift4WebhookEvent> for IncomingWebhookEvent {
fn from(event: Shift4WebhookEvent) -> Self {
match event {
Shift4WebhookEvent::ChargeSucceeded | Shift4WebhookEvent::ChargeUpdated => {
//reference : https://dev.shift4.com/docs/api#event-types
Self::PaymentIntentProcessing
}
Shift4WebhookEvent::ChargeCaptured => Self::PaymentIntentSuccess,
Shift4WebhookEvent::ChargeFailed => Self::PaymentIntentFailure,
Shift4WebhookEvent::ChargeRefunded => Self::RefundSuccess,
Shift4WebhookEvent::Unknown => Self::EventNotSupported,
}
}
}
|
{
"crate": "hyperswitch_connectors",
"file": "crates/hyperswitch_connectors/src/connectors/shift4/transformers.rs",
"file_size": null,
"is_async": null,
"is_pub": null,
"num_enums": 7,
"num_structs": 30,
"num_tables": null,
"score": null,
"total_crates": null
}
|
file_hyperswitch_connectors_-774656055052936905
|
clm
|
file
|
// Repository: hyperswitch
// Crate: hyperswitch_connectors
// File: crates/hyperswitch_connectors/src/connectors/checkout/transformers.rs
// Contains: 47 structs, 14 enums
use common_enums::{
enums::{self, AttemptStatus, PaymentChannel},
CountryAlpha2,
};
use common_utils::{
errors::{CustomResult, ParsingError},
ext_traits::ByteSliceExt,
request::{Method, RequestContent},
types::MinorUnit,
};
use error_stack::ResultExt;
use hyperswitch_domain_models::{
payment_method_data::{PaymentMethodData, WalletData},
payment_methods::storage_enums::MitCategory,
router_data::{
AdditionalPaymentMethodConnectorResponse, ConnectorAuthType, ConnectorResponseData,
ErrorResponse, PaymentMethodToken, RouterData,
},
router_flow_types::{Execute, RSync, SetupMandate},
router_request_types::{ResponseId, SetupMandateRequestData},
router_response_types::{
MandateReference, PaymentsResponseData, RedirectForm, RefundsResponseData,
},
types::{
PaymentsAuthorizeRouterData, PaymentsCancelRouterData, PaymentsCaptureRouterData,
PaymentsSyncRouterData, RefundsRouterData, TokenizationRouterData,
},
};
use hyperswitch_interfaces::{consts, errors, webhooks};
use masking::{ExposeInterface, Secret};
use serde::{Deserialize, Serialize};
use serde_with::skip_serializing_none;
use time::PrimitiveDateTime;
use url::Url;
use crate::{
types::{
PaymentsCancelResponseRouterData, PaymentsCaptureResponseRouterData,
PaymentsResponseRouterData, PaymentsSyncResponseRouterData, RefundsResponseRouterData,
ResponseRouterData, SubmitEvidenceRouterData, UploadFileRouterData,
},
unimplemented_payment_method,
utils::{
self, PaymentsAuthorizeRequestData, PaymentsCaptureRequestData, PaymentsSyncRequestData,
RouterData as OtherRouterData, WalletData as OtherWalletData,
},
};
#[derive(Debug, Serialize)]
pub struct CheckoutRouterData<T> {
pub amount: MinorUnit,
pub router_data: T,
}
impl<T> From<(MinorUnit, T)> for CheckoutRouterData<T> {
fn from((amount, item): (MinorUnit, T)) -> Self {
Self {
amount,
router_data: item,
}
}
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "lowercase")]
#[serde(tag = "type", content = "token_data")]
pub enum TokenRequest {
Googlepay(CheckoutGooglePayData),
Applepay(CheckoutApplePayData),
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "lowercase")]
#[serde(tag = "type", content = "token_data")]
pub enum PreDecryptedTokenRequest {
Applepay(Box<CheckoutApplePayData>),
}
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct CheckoutGooglePayData {
protocol_version: Secret<String>,
signature: Secret<String>,
signed_message: Secret<String>,
}
#[derive(Debug, Serialize, Deserialize)]
pub struct CheckoutApplePayData {
version: Secret<String>,
data: Secret<String>,
signature: Secret<String>,
header: CheckoutApplePayHeader,
}
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct CheckoutApplePayHeader {
ephemeral_public_key: Secret<String>,
public_key_hash: Secret<String>,
transaction_id: Secret<String>,
}
impl TryFrom<&TokenizationRouterData> for TokenRequest {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(item: &TokenizationRouterData) -> Result<Self, Self::Error> {
match item.request.payment_method_data.clone() {
PaymentMethodData::Wallet(wallet_data) => match wallet_data.clone() {
WalletData::GooglePay(_data) => {
let json_wallet_data: CheckoutGooglePayData =
wallet_data.get_wallet_token_as_json("Google Pay".to_string())?;
Ok(Self::Googlepay(json_wallet_data))
}
WalletData::ApplePay(_data) => {
let json_wallet_data: CheckoutApplePayData =
wallet_data.get_wallet_token_as_json("Apple Pay".to_string())?;
Ok(Self::Applepay(json_wallet_data))
}
WalletData::AliPayQr(_)
| WalletData::AliPayRedirect(_)
| WalletData::AliPayHkRedirect(_)
| WalletData::AmazonPay(_)
| WalletData::AmazonPayRedirect(_)
| WalletData::Paysera(_)
| WalletData::Skrill(_)
| WalletData::BluecodeRedirect {}
| WalletData::MomoRedirect(_)
| WalletData::KakaoPayRedirect(_)
| WalletData::GoPayRedirect(_)
| WalletData::GcashRedirect(_)
| WalletData::ApplePayRedirect(_)
| WalletData::ApplePayThirdPartySdk(_)
| WalletData::DanaRedirect {}
| WalletData::GooglePayRedirect(_)
| WalletData::GooglePayThirdPartySdk(_)
| WalletData::MbWayRedirect(_)
| WalletData::MobilePayRedirect(_)
| WalletData::PaypalRedirect(_)
| WalletData::PaypalSdk(_)
| WalletData::Paze(_)
| WalletData::SamsungPay(_)
| WalletData::TwintRedirect {}
| WalletData::VippsRedirect {}
| WalletData::TouchNGoRedirect(_)
| WalletData::WeChatPayRedirect(_)
| WalletData::CashappQr(_)
| WalletData::SwishQr(_)
| WalletData::WeChatPayQr(_)
| WalletData::Mifinity(_)
| WalletData::RevolutPay(_) => Err(errors::ConnectorError::NotImplemented(
utils::get_unimplemented_payment_method_error_message("checkout"),
)
.into()),
},
PaymentMethodData::Card(_)
| PaymentMethodData::PayLater(_)
| PaymentMethodData::BankRedirect(_)
| PaymentMethodData::BankDebit(_)
| PaymentMethodData::BankTransfer(_)
| PaymentMethodData::Crypto(_)
| PaymentMethodData::MandatePayment
| PaymentMethodData::Reward
| PaymentMethodData::RealTimePayment(_)
| PaymentMethodData::MobilePayment(_)
| PaymentMethodData::Upi(_)
| PaymentMethodData::Voucher(_)
| PaymentMethodData::CardRedirect(_)
| PaymentMethodData::GiftCard(_)
| PaymentMethodData::OpenBanking(_)
| PaymentMethodData::CardToken(_)
| PaymentMethodData::NetworkToken(_)
| PaymentMethodData::CardDetailsForNetworkTransactionId(_) => {
Err(errors::ConnectorError::NotImplemented(
utils::get_unimplemented_payment_method_error_message("checkout"),
)
.into())
}
}
}
}
#[derive(Debug, Eq, PartialEq, Deserialize, Serialize)]
pub struct CheckoutTokenResponse {
token: Secret<String>,
}
impl<F, T> TryFrom<ResponseRouterData<F, CheckoutTokenResponse, T, PaymentsResponseData>>
for RouterData<F, T, PaymentsResponseData>
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: ResponseRouterData<F, CheckoutTokenResponse, T, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
Ok(Self {
response: Ok(PaymentsResponseData::TokenizationResponse {
token: item.response.token.expose(),
}),
..item.data
})
}
}
#[skip_serializing_none]
#[derive(Debug, Serialize)]
pub struct CheckoutAddress {
pub address_line1: Option<Secret<String>>,
pub address_line2: Option<Secret<String>>,
pub city: Option<String>,
pub state: Option<Secret<String>>,
pub zip: Option<Secret<String>>,
pub country: Option<CountryAlpha2>,
}
#[skip_serializing_none]
#[derive(Debug, Serialize)]
pub struct CheckoutAccountHolderDetails {
pub first_name: Option<Secret<String>>,
pub last_name: Option<Secret<String>>,
}
#[derive(Debug, Serialize)]
pub struct CardSource {
#[serde(rename = "type")]
pub source_type: CheckoutSourceTypes,
pub number: cards::CardNumber,
pub expiry_month: Secret<String>,
pub expiry_year: Secret<String>,
pub cvv: Option<Secret<String>>,
pub billing_address: Option<CheckoutAddress>,
pub account_holder: Option<CheckoutAccountHolderDetails>,
}
#[derive(Debug, Serialize)]
pub struct WalletSource {
#[serde(rename = "type")]
pub source_type: CheckoutSourceTypes,
pub token: Secret<String>,
pub billing_address: Option<CheckoutAddress>,
}
#[derive(Debug, Serialize)]
pub struct MandateSource {
#[serde(rename = "type")]
pub source_type: CheckoutSourceTypes,
#[serde(rename = "id")]
pub source_id: Option<String>,
pub billing_address: Option<CheckoutAddress>,
}
#[derive(Debug, Serialize)]
#[serde(untagged)]
pub enum PaymentSource {
Card(CardSource),
Wallets(WalletSource),
ApplePayPredecrypt(Box<ApplePayPredecrypt>),
MandatePayment(MandateSource),
GooglePayPredecrypt(Box<GooglePayPredecrypt>),
}
#[derive(Debug, Serialize)]
pub struct GooglePayPredecrypt {
#[serde(rename = "type")]
_type: String,
token: cards::CardNumber,
token_type: String,
expiry_month: Secret<String>,
expiry_year: Secret<String>,
eci: String,
cryptogram: Option<Secret<String>>,
pub billing_address: Option<CheckoutAddress>,
}
#[derive(Debug, Serialize)]
pub struct ApplePayPredecrypt {
token: cards::CardNumber,
#[serde(rename = "type")]
decrypt_type: String,
token_type: String,
expiry_month: Secret<String>,
expiry_year: Secret<String>,
eci: Option<String>,
cryptogram: Secret<String>,
pub billing_address: Option<CheckoutAddress>,
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "lowercase")]
pub enum CheckoutSourceTypes {
Card,
Token,
#[serde(rename = "id")]
SourceId,
}
#[derive(Debug, Serialize)]
pub enum CheckoutPaymentType {
Regular,
Unscheduled,
#[serde(rename = "MOTO")]
Moto,
Installment,
Recurring,
}
pub struct CheckoutAuthType {
pub(super) api_key: Secret<String>,
pub(super) processing_channel_id: Secret<String>,
pub(super) api_secret: Secret<String>,
}
#[derive(Debug, Serialize)]
pub struct ReturnUrl {
pub success_url: Option<String>,
pub failure_url: Option<String>,
}
#[skip_serializing_none]
#[derive(Debug, Default, Serialize)]
pub struct CheckoutCustomer {
pub name: Option<Secret<String>>,
pub email: Option<common_utils::pii::Email>,
pub phone: Option<CheckoutPhoneDetails>,
pub tax_number: Option<Secret<String>>,
}
#[skip_serializing_none]
#[derive(Debug, Default, Serialize)]
pub struct CheckoutPhoneDetails {
pub country_code: Option<String>,
pub number: Option<Secret<String>>,
}
#[skip_serializing_none]
#[derive(Debug, Default, Serialize)]
pub struct CheckoutProcessing {
pub order_id: Option<String>,
pub tax_amount: Option<MinorUnit>,
pub discount_amount: Option<MinorUnit>,
pub duty_amount: Option<MinorUnit>,
pub shipping_amount: Option<MinorUnit>,
pub shipping_tax_amount: Option<MinorUnit>,
}
#[skip_serializing_none]
#[derive(Debug, Default, Serialize)]
pub struct CheckoutShipping {
pub address: Option<CheckoutAddress>,
pub from_address_zip: Option<String>,
}
#[skip_serializing_none]
#[derive(Debug, Default, Serialize)]
pub struct CheckoutLineItem {
pub commodity_code: Option<String>,
pub discount_amount: Option<MinorUnit>,
pub name: Option<String>,
pub quantity: Option<u16>,
pub reference: Option<String>,
pub tax_exempt: Option<bool>,
pub tax_amount: Option<MinorUnit>,
pub total_amount: Option<MinorUnit>,
pub unit_of_measure: Option<String>,
pub unit_price: Option<MinorUnit>,
}
#[skip_serializing_none]
#[derive(Debug, Serialize)]
pub struct PaymentsRequest {
pub source: PaymentSource,
pub amount: MinorUnit,
pub currency: String,
pub processing_channel_id: Secret<String>,
#[serde(rename = "3ds")]
pub three_ds: CheckoutThreeDS,
#[serde(flatten)]
pub return_url: ReturnUrl,
pub capture: bool,
pub reference: String,
pub metadata: Option<Secret<serde_json::Value>>,
pub payment_type: CheckoutPaymentType,
pub merchant_initiated: Option<bool>,
pub previous_payment_id: Option<String>,
pub store_for_future_use: Option<bool>,
// Level 2/3 data fields
pub customer: Option<CheckoutCustomer>,
pub processing: Option<CheckoutProcessing>,
pub shipping: Option<CheckoutShipping>,
pub items: Option<Vec<CheckoutLineItem>>,
pub partial_authorization: Option<CheckoutPartialAuthorization>,
pub payment_ip: Option<Secret<String, common_utils::pii::IpAddress>>,
}
#[skip_serializing_none]
#[derive(Debug, Default, Serialize)]
pub struct CheckoutPartialAuthorization {
pub enabled: bool,
}
#[derive(Debug, Serialize, Deserialize)]
pub struct CheckoutMeta {
pub psync_flow: CheckoutPaymentIntent,
}
#[derive(Debug, Clone, Serialize, Deserialize, Eq, PartialEq)]
pub enum CheckoutPaymentIntent {
Capture,
Authorize,
}
#[derive(Debug, Clone, Serialize, Deserialize, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum CheckoutChallengeIndicator {
NoPreference,
ChallengeRequestedMandate,
ChallengeRequested,
NoChallengeRequested,
}
#[derive(Debug, Serialize)]
pub struct CheckoutThreeDS {
enabled: bool,
force_3ds: bool,
eci: Option<String>,
cryptogram: Option<Secret<String>>,
xid: Option<String>,
version: Option<String>,
challenge_indicator: CheckoutChallengeIndicator,
}
impl TryFrom<&ConnectorAuthType> for CheckoutAuthType {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(auth_type: &ConnectorAuthType) -> Result<Self, Self::Error> {
if let ConnectorAuthType::SignatureKey {
api_key,
api_secret,
key1,
} = auth_type
{
Ok(Self {
api_key: api_key.to_owned(),
api_secret: api_secret.to_owned(),
processing_channel_id: key1.to_owned(),
})
} else {
Err(errors::ConnectorError::FailedToObtainAuthType.into())
}
}
}
fn split_account_holder_name(
card_holder_name: Option<Secret<String>>,
) -> (Option<Secret<String>>, Option<Secret<String>>) {
let account_holder_name = card_holder_name
.as_ref()
.map(|name| name.clone().expose().trim().to_string());
match account_holder_name {
Some(name) if !name.is_empty() => match name.rsplit_once(' ') {
Some((first, last)) => (
Some(Secret::new(first.to_string())),
Some(Secret::new(last.to_string())),
),
None => (Some(Secret::new(name)), None),
},
_ => (None, None),
}
}
impl TryFrom<&CheckoutRouterData<&PaymentsAuthorizeRouterData>> for PaymentsRequest {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: &CheckoutRouterData<&PaymentsAuthorizeRouterData>,
) -> Result<Self, Self::Error> {
let capture = matches!(
item.router_data.request.capture_method,
Some(enums::CaptureMethod::Automatic)
);
let payment_type = if matches!(
item.router_data.request.payment_channel,
Some(PaymentChannel::MailOrder | PaymentChannel::TelephoneOrder)
) {
CheckoutPaymentType::Moto
} else if item.router_data.request.is_mandate_payment() {
CheckoutPaymentType::Unscheduled
} else {
CheckoutPaymentType::Regular
};
let (challenge_indicator, store_for_future_use) =
if item.router_data.request.is_mandate_payment() {
(
CheckoutChallengeIndicator::ChallengeRequestedMandate,
Some(true),
)
} else {
(CheckoutChallengeIndicator::ChallengeRequested, None)
};
let billing_details = Some(CheckoutAddress {
city: item.router_data.get_optional_billing_city(),
address_line1: item.router_data.get_optional_billing_line1(),
address_line2: item.router_data.get_optional_billing_line2(),
state: item.router_data.get_optional_billing_state(),
zip: item.router_data.get_optional_billing_zip(),
country: item.router_data.get_optional_billing_country(),
});
let (
source_var,
previous_payment_id,
merchant_initiated,
payment_type,
store_for_future_use,
) = match item.router_data.request.payment_method_data.clone() {
PaymentMethodData::Card(ccard) => {
let (first_name, last_name) = split_account_holder_name(ccard.card_holder_name);
let payment_source = PaymentSource::Card(CardSource {
source_type: CheckoutSourceTypes::Card,
number: ccard.card_number.clone(),
expiry_month: ccard.card_exp_month.clone(),
expiry_year: ccard.card_exp_year.clone(),
cvv: Some(ccard.card_cvc),
billing_address: billing_details,
account_holder: Some(CheckoutAccountHolderDetails {
first_name,
last_name,
}),
});
Ok((
payment_source,
None,
Some(false),
payment_type,
store_for_future_use,
))
}
PaymentMethodData::Wallet(wallet_data) => match wallet_data {
WalletData::GooglePay(_) => {
let p_source = match item.router_data.get_payment_method_token()? {
PaymentMethodToken::Token(token) => PaymentSource::Wallets(WalletSource {
source_type: CheckoutSourceTypes::Token,
token,
billing_address: billing_details,
}),
PaymentMethodToken::ApplePayDecrypt(_) => Err(
unimplemented_payment_method!("Apple Pay", "Simplified", "Checkout"),
)?,
PaymentMethodToken::PazeDecrypt(_) => {
Err(unimplemented_payment_method!("Paze", "Checkout"))?
}
PaymentMethodToken::GooglePayDecrypt(google_pay_decrypted_data) => {
let token = google_pay_decrypted_data
.application_primary_account_number
.clone();
let expiry_month = google_pay_decrypted_data
.get_expiry_month()
.change_context(errors::ConnectorError::InvalidDataFormat {
field_name: "payment_method_data.card.card_exp_month",
})?;
let expiry_year = google_pay_decrypted_data
.get_four_digit_expiry_year()
.change_context(errors::ConnectorError::InvalidDataFormat {
field_name: "payment_method_data.card.card_exp_year",
})?;
let cryptogram = google_pay_decrypted_data.cryptogram.clone();
PaymentSource::GooglePayPredecrypt(Box::new(GooglePayPredecrypt {
_type: "network_token".to_string(),
token,
token_type: "googlepay".to_string(),
expiry_month,
expiry_year,
eci: "06".to_string(),
cryptogram,
billing_address: billing_details,
}))
}
};
Ok((
p_source,
None,
Some(false),
payment_type,
store_for_future_use,
))
}
WalletData::ApplePay(_) => {
let payment_method_token = item.router_data.get_payment_method_token()?;
match payment_method_token {
PaymentMethodToken::Token(apple_pay_payment_token) => {
let p_source = PaymentSource::Wallets(WalletSource {
source_type: CheckoutSourceTypes::Token,
token: apple_pay_payment_token,
billing_address: billing_details,
});
Ok((
p_source,
None,
Some(false),
payment_type,
store_for_future_use,
))
}
PaymentMethodToken::ApplePayDecrypt(decrypt_data) => {
let exp_month = decrypt_data.get_expiry_month().change_context(
errors::ConnectorError::InvalidDataFormat {
field_name: "expiration_month",
},
)?;
let expiry_year_4_digit = decrypt_data.get_four_digit_expiry_year();
let p_source =
PaymentSource::ApplePayPredecrypt(Box::new(ApplePayPredecrypt {
token: decrypt_data.application_primary_account_number,
decrypt_type: "network_token".to_string(),
token_type: "applepay".to_string(),
expiry_month: exp_month,
expiry_year: expiry_year_4_digit,
eci: decrypt_data.payment_data.eci_indicator,
cryptogram: decrypt_data.payment_data.online_payment_cryptogram,
billing_address: billing_details,
}));
Ok((
p_source,
None,
Some(false),
payment_type,
store_for_future_use,
))
}
PaymentMethodToken::PazeDecrypt(_) => {
Err(unimplemented_payment_method!("Paze", "Checkout"))?
}
PaymentMethodToken::GooglePayDecrypt(_) => {
Err(unimplemented_payment_method!("Google Pay", "Checkout"))?
}
}
}
_ => Err(errors::ConnectorError::NotImplemented(
utils::get_unimplemented_payment_method_error_message("checkout"),
)),
},
PaymentMethodData::MandatePayment => {
let mandate_source = PaymentSource::MandatePayment(MandateSource {
source_type: CheckoutSourceTypes::SourceId,
source_id: item.router_data.request.connector_mandate_id(),
billing_address: billing_details,
});
let previous_id = Some(
item.router_data
.request
.get_connector_mandate_request_reference_id()?,
);
let p_type = match item.router_data.request.mit_category {
Some(MitCategory::Installment) => CheckoutPaymentType::Installment,
Some(MitCategory::Recurring) => CheckoutPaymentType::Recurring,
Some(MitCategory::Unscheduled) | None => CheckoutPaymentType::Unscheduled,
_ => CheckoutPaymentType::Unscheduled,
};
Ok((mandate_source, previous_id, Some(true), p_type, None))
}
PaymentMethodData::CardDetailsForNetworkTransactionId(ccard) => {
let (first_name, last_name) = split_account_holder_name(ccard.card_holder_name);
let payment_source = PaymentSource::Card(CardSource {
source_type: CheckoutSourceTypes::Card,
number: ccard.card_number.clone(),
expiry_month: ccard.card_exp_month.clone(),
expiry_year: ccard.card_exp_year.clone(),
cvv: None,
billing_address: billing_details,
account_holder: Some(CheckoutAccountHolderDetails {
first_name,
last_name,
}),
});
let previous_id = Some(
item.router_data
.request
.get_optional_network_transaction_id()
.ok_or_else(utils::missing_field_err("network_transaction_id"))
.attach_printable("Checkout unable to find NTID for MIT")?,
);
let p_type = match item.router_data.request.mit_category {
Some(MitCategory::Installment) => CheckoutPaymentType::Installment,
Some(MitCategory::Recurring) => CheckoutPaymentType::Recurring,
Some(MitCategory::Unscheduled) | None => CheckoutPaymentType::Unscheduled,
_ => CheckoutPaymentType::Unscheduled,
};
Ok((payment_source, previous_id, Some(true), p_type, None))
}
_ => Err(errors::ConnectorError::NotImplemented(
utils::get_unimplemented_payment_method_error_message("checkout"),
)),
}?;
let authentication_data = item.router_data.request.authentication_data.as_ref();
let three_ds = match item.router_data.auth_type {
enums::AuthenticationType::ThreeDs => CheckoutThreeDS {
enabled: true,
force_3ds: true,
eci: authentication_data.and_then(|auth| auth.eci.clone()),
cryptogram: authentication_data.map(|auth| auth.cavv.clone()),
xid: authentication_data
.and_then(|auth| auth.threeds_server_transaction_id.clone()),
version: authentication_data.and_then(|auth| {
auth.message_version
.clone()
.map(|version| version.to_string())
}),
challenge_indicator,
},
enums::AuthenticationType::NoThreeDs => CheckoutThreeDS {
enabled: false,
force_3ds: false,
eci: None,
cryptogram: None,
xid: None,
version: None,
challenge_indicator: CheckoutChallengeIndicator::NoPreference,
},
};
let return_url = ReturnUrl {
success_url: item
.router_data
.request
.router_return_url
.as_ref()
.map(|return_url| format!("{return_url}?status=success")),
failure_url: item
.router_data
.request
.router_return_url
.as_ref()
.map(|return_url| format!("{return_url}?status=failure")),
};
let connector_auth = &item.router_data.connector_auth_type;
let auth_type: CheckoutAuthType = connector_auth.try_into()?;
let processing_channel_id = auth_type.processing_channel_id;
let metadata = item.router_data.request.metadata.clone().map(Into::into);
let (customer, processing, shipping, items) = if let Some(l2l3_data) =
&item.router_data.l2_l3_data
{
(
Some(CheckoutCustomer {
name: l2l3_data.customer_name.clone(),
email: l2l3_data.customer_email.clone(),
phone: Some(CheckoutPhoneDetails {
country_code: l2l3_data.customer_phone_country_code.clone(),
number: l2l3_data.customer_phone_number.clone(),
}),
tax_number: l2l3_data.customer_tax_registration_id.clone(),
}),
Some(CheckoutProcessing {
order_id: l2l3_data.merchant_order_reference_id.clone(),
tax_amount: l2l3_data.order_tax_amount,
discount_amount: l2l3_data.discount_amount,
duty_amount: l2l3_data.duty_amount,
shipping_amount: l2l3_data.shipping_cost,
shipping_tax_amount: l2l3_data.shipping_amount_tax,
}),
Some(CheckoutShipping {
address: Some(CheckoutAddress {
country: l2l3_data.get_shipping_country(),
address_line1: l2l3_data.get_shipping_address_line1(),
address_line2: l2l3_data.get_shipping_address_line2(),
city: l2l3_data.get_shipping_city(),
state: l2l3_data.get_shipping_state(),
zip: l2l3_data.get_shipping_zip(),
}),
from_address_zip: l2l3_data.get_shipping_origin_zip().map(|zip| zip.expose()),
}),
l2l3_data.order_details.as_ref().map(|details| {
details
.iter()
.map(|item| CheckoutLineItem {
commodity_code: item.commodity_code.clone(),
discount_amount: item.unit_discount_amount,
name: Some(item.product_name.clone()),
quantity: Some(item.quantity),
reference: item.product_id.clone(),
tax_exempt: None,
tax_amount: item.total_tax_amount,
total_amount: item.total_amount,
unit_of_measure: item.unit_of_measure.clone(),
unit_price: Some(item.amount),
})
.collect()
}),
)
} else {
(None, None, None, None)
};
let partial_authorization = item.router_data.request.enable_partial_authorization.map(
|enable_partial_authorization| CheckoutPartialAuthorization {
enabled: *enable_partial_authorization,
},
);
let payment_ip = item.router_data.request.get_ip_address_as_optional();
let request = Self {
source: source_var,
amount: item.amount.to_owned(),
currency: item.router_data.request.currency.to_string(),
processing_channel_id,
three_ds,
return_url,
capture,
reference: item.router_data.connector_request_reference_id.clone(),
metadata,
payment_type,
merchant_initiated,
previous_payment_id,
store_for_future_use,
customer,
processing,
shipping,
items,
partial_authorization,
payment_ip,
};
Ok(request)
}
}
#[derive(Default, Clone, Debug, Eq, PartialEq, Deserialize, Serialize)]
pub enum CheckoutPaymentStatus {
Authorized,
#[default]
Pending,
#[serde(rename = "Card Verified")]
CardVerified,
Declined,
Captured,
#[serde(rename = "Retry Scheduled")]
RetryScheduled,
Voided,
#[serde(rename = "Partially Captured")]
PartiallyCaptured,
#[serde(rename = "Partially Refunded")]
PartiallyRefunded,
Refunded,
Canceled,
Expired,
}
impl TryFrom<CheckoutWebhookEventType> for CheckoutPaymentStatus {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(value: CheckoutWebhookEventType) -> Result<Self, Self::Error> {
match value {
CheckoutWebhookEventType::PaymentApproved => Ok(Self::Authorized),
CheckoutWebhookEventType::PaymentCaptured => Ok(Self::Captured),
CheckoutWebhookEventType::PaymentDeclined => Ok(Self::Declined),
CheckoutWebhookEventType::AuthenticationStarted
| CheckoutWebhookEventType::AuthenticationApproved
| CheckoutWebhookEventType::AuthenticationAttempted => Ok(Self::Pending),
CheckoutWebhookEventType::AuthenticationExpired
| CheckoutWebhookEventType::AuthenticationFailed
| CheckoutWebhookEventType::PaymentAuthenticationFailed
| CheckoutWebhookEventType::PaymentCaptureDeclined => Ok(Self::Declined),
CheckoutWebhookEventType::PaymentCanceled => Ok(Self::Canceled),
CheckoutWebhookEventType::PaymentVoided => Ok(Self::Voided),
CheckoutWebhookEventType::PaymentRefunded
| CheckoutWebhookEventType::PaymentRefundDeclined
| CheckoutWebhookEventType::DisputeReceived
| CheckoutWebhookEventType::DisputeExpired
| CheckoutWebhookEventType::DisputeAccepted
| CheckoutWebhookEventType::DisputeCanceled
| CheckoutWebhookEventType::DisputeEvidenceSubmitted
| CheckoutWebhookEventType::DisputeEvidenceAcknowledgedByScheme
| CheckoutWebhookEventType::DisputeEvidenceRequired
| CheckoutWebhookEventType::DisputeArbitrationLost
| CheckoutWebhookEventType::DisputeArbitrationWon
| CheckoutWebhookEventType::DisputeWon
| CheckoutWebhookEventType::DisputeLost
| CheckoutWebhookEventType::Unknown => {
Err(errors::ConnectorError::WebhookEventTypeNotFound.into())
}
}
}
}
fn get_attempt_status_cap(
item: (CheckoutPaymentStatus, Option<enums::CaptureMethod>),
) -> AttemptStatus {
let (status, capture_method) = item;
match status {
CheckoutPaymentStatus::Authorized => {
if capture_method == Some(enums::CaptureMethod::Automatic) || capture_method.is_none() {
AttemptStatus::Charged
} else {
AttemptStatus::Authorized
}
}
CheckoutPaymentStatus::Captured
| CheckoutPaymentStatus::PartiallyRefunded
| CheckoutPaymentStatus::Refunded
| CheckoutPaymentStatus::CardVerified => AttemptStatus::Charged,
CheckoutPaymentStatus::PartiallyCaptured => AttemptStatus::PartialCharged,
CheckoutPaymentStatus::Declined
| CheckoutPaymentStatus::Expired
| CheckoutPaymentStatus::Canceled => AttemptStatus::Failure,
CheckoutPaymentStatus::Pending => AttemptStatus::AuthenticationPending,
CheckoutPaymentStatus::RetryScheduled => AttemptStatus::Pending,
CheckoutPaymentStatus::Voided => AttemptStatus::Voided,
}
}
fn get_attempt_status_intent(
item: (CheckoutPaymentStatus, CheckoutPaymentIntent),
) -> AttemptStatus {
let (status, psync_flow) = item;
match status {
CheckoutPaymentStatus::Authorized => {
if psync_flow == CheckoutPaymentIntent::Capture {
AttemptStatus::Charged
} else {
AttemptStatus::Authorized
}
}
CheckoutPaymentStatus::Captured
| CheckoutPaymentStatus::PartiallyRefunded
| CheckoutPaymentStatus::Refunded
| CheckoutPaymentStatus::CardVerified => AttemptStatus::Charged,
CheckoutPaymentStatus::PartiallyCaptured => AttemptStatus::PartialCharged,
CheckoutPaymentStatus::Declined
| CheckoutPaymentStatus::Expired
| CheckoutPaymentStatus::Canceled => AttemptStatus::Failure,
CheckoutPaymentStatus::Pending => AttemptStatus::AuthenticationPending,
CheckoutPaymentStatus::RetryScheduled => AttemptStatus::Pending,
CheckoutPaymentStatus::Voided => AttemptStatus::Voided,
}
}
fn get_attempt_status_bal(item: (CheckoutPaymentStatus, Option<Balances>)) -> AttemptStatus {
let (status, balances) = item;
match status {
CheckoutPaymentStatus::Authorized => {
if let Some(Balances {
available_to_capture: 0,
}) = balances
{
AttemptStatus::Charged
} else {
AttemptStatus::Authorized
}
}
CheckoutPaymentStatus::Captured
| CheckoutPaymentStatus::PartiallyRefunded
| CheckoutPaymentStatus::Refunded => AttemptStatus::Charged,
CheckoutPaymentStatus::PartiallyCaptured => AttemptStatus::PartialCharged,
CheckoutPaymentStatus::Declined
| CheckoutPaymentStatus::Expired
| CheckoutPaymentStatus::Canceled => AttemptStatus::Failure,
CheckoutPaymentStatus::Pending => AttemptStatus::AuthenticationPending,
CheckoutPaymentStatus::CardVerified | CheckoutPaymentStatus::RetryScheduled => {
AttemptStatus::Pending
}
CheckoutPaymentStatus::Voided => AttemptStatus::Voided,
}
}
#[derive(Clone, Debug, Eq, PartialEq, Deserialize, Serialize)]
pub struct Href {
#[serde(rename = "href")]
redirection_url: Url,
}
#[derive(Clone, Debug, Default, Eq, PartialEq, Deserialize, Serialize)]
pub struct Links {
redirect: Option<Href>,
}
#[derive(Clone, Debug, Default, Eq, PartialEq, Deserialize, Serialize)]
pub struct Source {
id: Option<String>,
avs_check: Option<String>,
cvv_check: Option<String>,
}
#[derive(Clone, Debug, Default, Eq, PartialEq, Deserialize, Serialize)]
pub struct PaymentsResponse {
id: String,
amount: Option<MinorUnit>,
currency: Option<String>,
scheme_id: Option<String>,
processing: Option<PaymentProcessingDetails>,
action_id: Option<String>,
status: CheckoutPaymentStatus,
#[serde(rename = "_links")]
links: Links,
balances: Option<Balances>,
reference: Option<String>,
response_code: Option<String>,
response_summary: Option<String>,
approved: Option<bool>,
processed_on: Option<String>,
source: Option<Source>,
}
#[derive(Clone, Debug, Default, Eq, PartialEq, Deserialize, Serialize)]
pub struct PaymentProcessingDetails {
/// The Merchant Advice Code (MAC) provided by Mastercard, which contains additional information about the transaction.
pub partner_merchant_advice_code: Option<String>,
/// The original authorization response code sent by the scheme.
pub partner_response_code: Option<String>,
}
#[derive(Debug, Deserialize, Serialize)]
#[serde(untagged)]
pub enum PaymentsResponseEnum {
ActionResponse(Vec<ActionResponse>),
PaymentResponse(Box<PaymentsResponse>),
}
#[derive(Clone, Debug, Default, Eq, PartialEq, Deserialize, Serialize)]
pub struct Balances {
available_to_capture: i32,
}
fn get_connector_meta(
capture_method: enums::CaptureMethod,
) -> CustomResult<serde_json::Value, errors::ConnectorError> {
match capture_method {
enums::CaptureMethod::Automatic | enums::CaptureMethod::SequentialAutomatic => {
Ok(serde_json::json!(CheckoutMeta {
psync_flow: CheckoutPaymentIntent::Capture,
}))
}
enums::CaptureMethod::Manual | enums::CaptureMethod::ManualMultiple => {
Ok(serde_json::json!(CheckoutMeta {
psync_flow: CheckoutPaymentIntent::Authorize,
}))
}
enums::CaptureMethod::Scheduled => {
Err(errors::ConnectorError::CaptureMethodNotSupported.into())
}
}
}
impl TryFrom<PaymentsResponseRouterData<PaymentsResponse>> for PaymentsAuthorizeRouterData {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(item: PaymentsResponseRouterData<PaymentsResponse>) -> Result<Self, Self::Error> {
let status =
get_attempt_status_cap((item.response.status, item.data.request.capture_method));
if status == AttemptStatus::Failure {
let error_response = ErrorResponse {
status_code: item.http_code,
code: item
.response
.response_code
.unwrap_or_else(|| consts::NO_ERROR_CODE.to_string()),
message: item
.response
.response_summary
.clone()
.unwrap_or_else(|| consts::NO_ERROR_MESSAGE.to_string()),
reason: item.response.response_summary,
attempt_status: None,
connector_transaction_id: Some(item.response.id.clone()),
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
connector_metadata: None,
};
return Ok(Self {
status,
response: Err(error_response),
..item.data
});
}
let connector_meta =
get_connector_meta(item.data.request.capture_method.unwrap_or_default())?;
let redirection_data = item
.response
.links
.redirect
.map(|href| RedirectForm::from((href.redirection_url, Method::Get)));
let mandate_reference = if item.data.request.is_mandate_payment() {
item.response
.source
.as_ref()
.and_then(|src| src.id.clone())
.map(|id| MandateReference {
connector_mandate_id: Some(id),
payment_method_id: None,
mandate_metadata: None,
connector_mandate_request_reference_id: Some(item.response.id.clone()),
})
} else {
None
};
let additional_information =
convert_to_additional_payment_method_connector_response(item.response.source.as_ref())
.map(ConnectorResponseData::with_additional_payment_method_data);
let payments_response_data = PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(item.response.id.clone()),
redirection_data: Box::new(redirection_data),
mandate_reference: Box::new(mandate_reference),
connector_metadata: Some(connector_meta),
network_txn_id: item.response.scheme_id.clone(),
connector_response_reference_id: Some(
item.response.reference.unwrap_or(item.response.id),
),
incremental_authorization_allowed: None,
charges: None,
};
let (amount_captured, minor_amount_capturable) = match item.data.request.capture_method {
Some(enums::CaptureMethod::Manual) | Some(enums::CaptureMethod::ManualMultiple) => {
(None, item.response.amount)
}
_ => (item.response.amount.map(MinorUnit::get_amount_as_i64), None),
};
let authorized_amount = item
.data
.request
.enable_partial_authorization
.filter(|flag| flag.is_true())
.and(item.response.amount);
Ok(Self {
status,
response: Ok(payments_response_data),
connector_response: additional_information,
authorized_amount,
amount_captured,
minor_amount_capturable,
..item.data
})
}
}
impl
TryFrom<
ResponseRouterData<
SetupMandate,
PaymentsResponse,
SetupMandateRequestData,
PaymentsResponseData,
>,
> for RouterData<SetupMandate, SetupMandateRequestData, PaymentsResponseData>
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: ResponseRouterData<
SetupMandate,
PaymentsResponse,
SetupMandateRequestData,
PaymentsResponseData,
>,
) -> Result<Self, Self::Error> {
let connector_meta =
get_connector_meta(item.data.request.capture_method.unwrap_or_default())?;
let redirection_data = item
.response
.links
.redirect
.map(|href| RedirectForm::from((href.redirection_url, Method::Get)));
let status =
get_attempt_status_cap((item.response.status, item.data.request.capture_method));
let network_advice_code = item
.response
.processing
.as_ref()
.and_then(|processing| {
processing
.partner_merchant_advice_code
.as_ref()
.or(processing.partner_response_code.as_ref())
})
.cloned();
let error_response = if status == AttemptStatus::Failure {
Some(ErrorResponse {
status_code: item.http_code,
code: item
.response
.response_code
.unwrap_or_else(|| consts::NO_ERROR_CODE.to_string()),
message: item
.response
.response_summary
.clone()
.unwrap_or_else(|| consts::NO_ERROR_MESSAGE.to_string()),
reason: item.response.response_summary,
attempt_status: None,
connector_transaction_id: Some(item.response.id.clone()),
network_advice_code,
network_decline_code: None,
network_error_message: None,
connector_metadata: None,
})
} else {
None
};
let mandate_reference = item
.response
.source
.as_ref()
.and_then(|src| src.id.clone())
.map(|id| MandateReference {
connector_mandate_id: Some(id),
payment_method_id: None,
mandate_metadata: None,
connector_mandate_request_reference_id: Some(item.response.id.clone()),
});
let payments_response_data = PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(item.response.id.clone()),
redirection_data: Box::new(redirection_data),
mandate_reference: Box::new(mandate_reference),
connector_metadata: Some(connector_meta),
network_txn_id: item.response.scheme_id.clone(),
connector_response_reference_id: Some(
item.response.reference.unwrap_or(item.response.id),
),
incremental_authorization_allowed: None,
charges: None,
};
Ok(Self {
status,
response: error_response.map_or_else(|| Ok(payments_response_data), Err),
..item.data
})
}
}
impl TryFrom<PaymentsSyncResponseRouterData<PaymentsResponse>> for PaymentsSyncRouterData {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: PaymentsSyncResponseRouterData<PaymentsResponse>,
) -> Result<Self, Self::Error> {
let redirection_data = item
.response
.links
.redirect
.map(|href| RedirectForm::from((href.redirection_url, Method::Get)));
let checkout_meta: CheckoutMeta =
utils::to_connector_meta(item.data.request.connector_meta.clone())?;
let status = get_attempt_status_intent((item.response.status, checkout_meta.psync_flow));
let error_response = if status == AttemptStatus::Failure {
Some(ErrorResponse {
status_code: item.http_code,
code: item
.response
.response_code
.unwrap_or_else(|| consts::NO_ERROR_CODE.to_string()),
message: item
.response
.response_summary
.clone()
.unwrap_or_else(|| consts::NO_ERROR_MESSAGE.to_string()),
reason: item.response.response_summary,
attempt_status: None,
connector_transaction_id: Some(item.response.id.clone()),
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
connector_metadata: None,
})
} else {
None
};
let mandate_reference = if item.data.request.is_mandate_payment() {
item.response
.source
.as_ref()
.and_then(|src| src.id.clone())
.map(|id| MandateReference {
connector_mandate_id: Some(id),
payment_method_id: None,
mandate_metadata: None,
connector_mandate_request_reference_id: Some(item.response.id.clone()),
})
} else {
None
};
let additional_information =
convert_to_additional_payment_method_connector_response(item.response.source.as_ref())
.map(ConnectorResponseData::with_additional_payment_method_data);
let payments_response_data = PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(item.response.id.clone()),
redirection_data: Box::new(redirection_data),
mandate_reference: Box::new(mandate_reference),
connector_metadata: None,
network_txn_id: item.response.scheme_id.clone(),
connector_response_reference_id: Some(
item.response.reference.unwrap_or(item.response.id),
),
incremental_authorization_allowed: None,
charges: None,
};
Ok(Self {
status,
response: error_response.map_or_else(|| Ok(payments_response_data), Err),
connector_response: additional_information,
..item.data
})
}
}
impl TryFrom<PaymentsSyncResponseRouterData<PaymentsResponseEnum>> for PaymentsSyncRouterData {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: PaymentsSyncResponseRouterData<PaymentsResponseEnum>,
) -> Result<Self, Self::Error> {
let capture_sync_response_list = match item.response {
PaymentsResponseEnum::PaymentResponse(payments_response) => {
// for webhook consumption flow
utils::construct_captures_response_hashmap(vec![payments_response])?
}
PaymentsResponseEnum::ActionResponse(action_list) => {
// for captures sync
utils::construct_captures_response_hashmap(action_list)?
}
};
Ok(Self {
response: Ok(PaymentsResponseData::MultipleCaptureResponse {
capture_sync_response_list,
}),
..item.data
})
}
}
#[derive(Clone, Default, Debug, Eq, PartialEq, Serialize)]
pub struct PaymentVoidRequest {
reference: String,
}
#[derive(Clone, Default, Debug, Eq, PartialEq, Deserialize, Serialize)]
pub struct PaymentVoidResponse {
#[serde(skip)]
pub(super) status: u16,
action_id: String,
reference: String,
scheme_id: Option<String>,
}
impl From<&PaymentVoidResponse> for AttemptStatus {
fn from(item: &PaymentVoidResponse) -> Self {
if item.status == 202 {
Self::Voided
} else {
Self::VoidFailed
}
}
}
impl TryFrom<PaymentsCancelResponseRouterData<PaymentVoidResponse>> for PaymentsCancelRouterData {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: PaymentsCancelResponseRouterData<PaymentVoidResponse>,
) -> Result<Self, Self::Error> {
let response = &item.response;
Ok(Self {
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(response.action_id.clone()),
redirection_data: Box::new(None),
mandate_reference: Box::new(None),
connector_metadata: None,
network_txn_id: item.response.scheme_id.clone(),
connector_response_reference_id: None,
incremental_authorization_allowed: None,
charges: None,
}),
status: response.into(),
..item.data
})
}
}
impl TryFrom<&PaymentsCancelRouterData> for PaymentVoidRequest {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(item: &PaymentsCancelRouterData) -> Result<Self, Self::Error> {
Ok(Self {
reference: item.request.connector_transaction_id.clone(),
})
}
}
#[derive(Debug, Serialize)]
pub enum CaptureType {
Final,
NonFinal,
}
#[derive(Debug, Serialize)]
pub struct PaymentCaptureRequest {
pub amount: Option<MinorUnit>,
pub capture_type: Option<CaptureType>,
pub processing_channel_id: Secret<String>,
pub reference: Option<String>,
}
impl TryFrom<&CheckoutRouterData<&PaymentsCaptureRouterData>> for PaymentCaptureRequest {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: &CheckoutRouterData<&PaymentsCaptureRouterData>,
) -> Result<Self, Self::Error> {
let connector_auth = &item.router_data.connector_auth_type;
let auth_type: CheckoutAuthType = connector_auth.try_into()?;
let processing_channel_id = auth_type.processing_channel_id;
let capture_type = if item.router_data.request.is_multiple_capture() {
CaptureType::NonFinal
} else {
CaptureType::Final
};
let reference = item
.router_data
.request
.multiple_capture_data
.as_ref()
.map(|multiple_capture_data| multiple_capture_data.capture_reference.clone());
Ok(Self {
amount: Some(item.amount.to_owned()),
capture_type: Some(capture_type),
processing_channel_id,
reference, // hyperswitch's reference for this capture
})
}
}
#[derive(Debug, Deserialize, Serialize)]
pub struct PaymentCaptureResponse {
pub action_id: String,
pub reference: Option<String>,
pub scheme_id: Option<String>,
}
impl TryFrom<PaymentsCaptureResponseRouterData<PaymentCaptureResponse>>
for PaymentsCaptureRouterData
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: PaymentsCaptureResponseRouterData<PaymentCaptureResponse>,
) -> Result<Self, Self::Error> {
let connector_meta = serde_json::json!(CheckoutMeta {
psync_flow: CheckoutPaymentIntent::Capture,
});
let (status, amount_captured) = if item.http_code == 202 {
(
AttemptStatus::Charged,
Some(item.data.request.amount_to_capture),
)
} else {
(AttemptStatus::Pending, None)
};
// if multiple capture request, return capture action_id so that it will be updated in the captures table.
// else return previous connector_transaction_id.
let resource_id = if item.data.request.is_multiple_capture() {
item.response.action_id
} else {
item.data.request.connector_transaction_id.to_owned()
};
Ok(Self {
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(resource_id),
redirection_data: Box::new(None),
mandate_reference: Box::new(None),
connector_metadata: Some(connector_meta),
network_txn_id: item.response.scheme_id.clone(),
connector_response_reference_id: item.response.reference,
incremental_authorization_allowed: None,
charges: None,
}),
status,
amount_captured,
..item.data
})
}
}
#[derive(Clone, Debug, Serialize, Deserialize)]
pub struct RefundRequest {
amount: Option<MinorUnit>,
reference: String,
}
impl<F> TryFrom<&CheckoutRouterData<&RefundsRouterData<F>>> for RefundRequest {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(item: &CheckoutRouterData<&RefundsRouterData<F>>) -> Result<Self, Self::Error> {
let reference = item.router_data.request.refund_id.clone();
Ok(Self {
amount: Some(item.amount.to_owned()),
reference,
})
}
}
#[allow(dead_code)]
#[derive(Deserialize, Debug, Serialize)]
pub struct RefundResponse {
action_id: String,
reference: String,
}
#[derive(Deserialize)]
pub struct CheckoutRefundResponse {
pub(super) status: u16,
pub(super) response: RefundResponse,
}
impl From<&CheckoutRefundResponse> for enums::RefundStatus {
fn from(item: &CheckoutRefundResponse) -> Self {
if item.status == 202 {
Self::Success
} else {
Self::Failure
}
}
}
impl TryFrom<RefundsResponseRouterData<Execute, CheckoutRefundResponse>>
for RefundsRouterData<Execute>
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: RefundsResponseRouterData<Execute, CheckoutRefundResponse>,
) -> Result<Self, Self::Error> {
let refund_status = enums::RefundStatus::from(&item.response);
Ok(Self {
response: Ok(RefundsResponseData {
connector_refund_id: item.response.response.action_id.clone(),
refund_status,
}),
..item.data
})
}
}
impl TryFrom<RefundsResponseRouterData<RSync, CheckoutRefundResponse>>
for RefundsRouterData<RSync>
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: RefundsResponseRouterData<RSync, CheckoutRefundResponse>,
) -> Result<Self, Self::Error> {
let refund_status = enums::RefundStatus::from(&item.response);
Ok(Self {
response: Ok(RefundsResponseData {
connector_refund_id: item.response.response.action_id.clone(),
refund_status,
}),
..item.data
})
}
}
#[derive(Debug, Default, Eq, PartialEq, Deserialize, Serialize)]
pub struct CheckoutErrorResponse {
pub request_id: Option<String>,
pub error_type: Option<String>,
pub error_codes: Option<Vec<String>>,
}
#[derive(Deserialize, Debug, PartialEq, Serialize)]
pub enum ActionType {
Authorization,
Void,
Capture,
Refund,
Payout,
Return,
#[serde(rename = "Card Verification")]
CardVerification,
}
#[derive(Deserialize, Debug, Serialize)]
pub struct ActionResponse {
#[serde(rename = "id")]
pub action_id: String,
pub amount: MinorUnit,
#[serde(rename = "type")]
pub action_type: ActionType,
pub approved: Option<bool>,
pub reference: Option<String>,
}
impl From<&ActionResponse> for enums::RefundStatus {
fn from(item: &ActionResponse) -> Self {
match item.approved {
Some(true) => Self::Success,
Some(false) => Self::Failure,
None => Self::Pending,
}
}
}
impl utils::MultipleCaptureSyncResponse for ActionResponse {
fn get_connector_capture_id(&self) -> String {
self.action_id.clone()
}
fn get_capture_attempt_status(&self) -> AttemptStatus {
match self.approved {
Some(true) => AttemptStatus::Charged,
Some(false) => AttemptStatus::Failure,
None => AttemptStatus::Pending,
}
}
fn get_connector_reference_id(&self) -> Option<String> {
self.reference.clone()
}
fn is_capture_response(&self) -> bool {
self.action_type == ActionType::Capture
}
fn get_amount_captured(&self) -> Result<Option<MinorUnit>, error_stack::Report<ParsingError>> {
Ok(Some(self.amount))
}
}
impl utils::MultipleCaptureSyncResponse for Box<PaymentsResponse> {
fn get_connector_capture_id(&self) -> String {
self.action_id.clone().unwrap_or("".into())
}
fn get_capture_attempt_status(&self) -> AttemptStatus {
get_attempt_status_bal((self.status.clone(), self.balances.clone()))
}
fn get_connector_reference_id(&self) -> Option<String> {
self.reference.clone()
}
fn is_capture_response(&self) -> bool {
self.status == CheckoutPaymentStatus::Captured
}
fn get_amount_captured(&self) -> Result<Option<MinorUnit>, error_stack::Report<ParsingError>> {
Ok(self.amount)
}
}
#[derive(Debug, Clone, serde::Deserialize, Eq, PartialEq)]
#[serde(rename_all = "lowercase")]
pub enum CheckoutRedirectResponseStatus {
Success,
Failure,
}
#[derive(Debug, Clone, serde::Deserialize, Eq, PartialEq)]
pub struct CheckoutRedirectResponse {
pub status: Option<CheckoutRedirectResponseStatus>,
#[serde(rename = "cko-session-id")]
pub cko_session_id: Option<String>,
}
impl TryFrom<RefundsResponseRouterData<Execute, &ActionResponse>> for RefundsRouterData<Execute> {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: RefundsResponseRouterData<Execute, &ActionResponse>,
) -> Result<Self, Self::Error> {
let refund_status = enums::RefundStatus::from(item.response);
Ok(Self {
response: Ok(RefundsResponseData {
connector_refund_id: item.response.action_id.clone(),
refund_status,
}),
..item.data
})
}
}
impl TryFrom<RefundsResponseRouterData<RSync, &ActionResponse>> for RefundsRouterData<RSync> {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: RefundsResponseRouterData<RSync, &ActionResponse>,
) -> Result<Self, Self::Error> {
let refund_status = enums::RefundStatus::from(item.response);
Ok(Self {
response: Ok(RefundsResponseData {
connector_refund_id: item.response.action_id.clone(),
refund_status,
}),
..item.data
})
}
}
impl From<CheckoutRedirectResponseStatus> for AttemptStatus {
fn from(item: CheckoutRedirectResponseStatus) -> Self {
match item {
CheckoutRedirectResponseStatus::Success => Self::AuthenticationSuccessful,
CheckoutRedirectResponseStatus::Failure => Self::Failure,
}
}
}
pub fn is_refund_event(event_code: &CheckoutWebhookEventType) -> bool {
matches!(
event_code,
CheckoutWebhookEventType::PaymentRefunded | CheckoutWebhookEventType::PaymentRefundDeclined
)
}
pub fn is_chargeback_event(event_code: &CheckoutWebhookEventType) -> bool {
matches!(
event_code,
CheckoutWebhookEventType::DisputeReceived
| CheckoutWebhookEventType::DisputeExpired
| CheckoutWebhookEventType::DisputeAccepted
| CheckoutWebhookEventType::DisputeCanceled
| CheckoutWebhookEventType::DisputeEvidenceSubmitted
| CheckoutWebhookEventType::DisputeEvidenceAcknowledgedByScheme
| CheckoutWebhookEventType::DisputeEvidenceRequired
| CheckoutWebhookEventType::DisputeArbitrationLost
| CheckoutWebhookEventType::DisputeArbitrationWon
| CheckoutWebhookEventType::DisputeWon
| CheckoutWebhookEventType::DisputeLost
)
}
#[derive(Debug, Deserialize, strum::Display, Clone)]
#[serde(rename_all = "snake_case")]
pub enum CheckoutWebhookEventType {
AuthenticationStarted,
AuthenticationApproved,
AuthenticationAttempted,
AuthenticationExpired,
AuthenticationFailed,
PaymentApproved,
PaymentCaptured,
PaymentDeclined,
PaymentRefunded,
PaymentRefundDeclined,
PaymentAuthenticationFailed,
PaymentCanceled,
PaymentCaptureDeclined,
PaymentVoided,
DisputeReceived,
DisputeExpired,
DisputeAccepted,
DisputeCanceled,
DisputeEvidenceSubmitted,
DisputeEvidenceAcknowledgedByScheme,
DisputeEvidenceRequired,
DisputeArbitrationLost,
DisputeArbitrationWon,
DisputeWon,
DisputeLost,
#[serde(other)]
Unknown,
}
#[derive(Debug, Deserialize)]
pub struct CheckoutWebhookEventTypeBody {
#[serde(rename = "type")]
pub transaction_type: CheckoutWebhookEventType,
}
#[derive(Debug, Deserialize)]
pub struct CheckoutWebhookData {
pub id: String,
pub payment_id: Option<String>,
pub action_id: Option<String>,
pub reference: Option<String>,
pub amount: MinorUnit,
pub balances: Option<Balances>,
pub response_code: Option<String>,
pub response_summary: Option<String>,
pub currency: String,
pub processed_on: Option<String>,
pub approved: Option<bool>,
}
#[derive(Debug, Deserialize)]
pub struct CheckoutWebhookBody {
#[serde(rename = "type")]
pub transaction_type: CheckoutWebhookEventType,
pub data: CheckoutWebhookData,
#[serde(rename = "_links")]
pub links: Links,
pub source: Option<Source>,
}
#[derive(Debug, Serialize, Deserialize)]
pub struct CheckoutDisputeWebhookData {
pub id: String,
pub payment_id: Option<String>,
pub action_id: Option<String>,
pub amount: MinorUnit,
pub currency: enums::Currency,
#[serde(default, with = "common_utils::custom_serde::iso8601::option")]
pub evidence_required_by: Option<PrimitiveDateTime>,
pub reason_code: Option<String>,
#[serde(default, with = "common_utils::custom_serde::iso8601::option")]
pub date: Option<PrimitiveDateTime>,
}
#[derive(Debug, Deserialize)]
pub struct CheckoutDisputeWebhookBody {
#[serde(rename = "type")]
pub transaction_type: CheckoutDisputeTransactionType,
pub data: CheckoutDisputeWebhookData,
#[serde(default, with = "common_utils::custom_serde::iso8601::option")]
pub created_on: Option<PrimitiveDateTime>,
}
#[derive(Debug, Deserialize, strum::Display, Clone)]
#[serde(rename_all = "snake_case")]
pub enum CheckoutDisputeTransactionType {
DisputeReceived,
DisputeExpired,
DisputeAccepted,
DisputeCanceled,
DisputeEvidenceSubmitted,
DisputeEvidenceAcknowledgedByScheme,
DisputeEvidenceRequired,
DisputeArbitrationLost,
DisputeArbitrationWon,
DisputeWon,
DisputeLost,
}
impl From<CheckoutWebhookEventType> for api_models::webhooks::IncomingWebhookEvent {
fn from(transaction_type: CheckoutWebhookEventType) -> Self {
match transaction_type {
CheckoutWebhookEventType::AuthenticationStarted
| CheckoutWebhookEventType::AuthenticationApproved
| CheckoutWebhookEventType::AuthenticationAttempted => Self::EventNotSupported,
CheckoutWebhookEventType::AuthenticationExpired
| CheckoutWebhookEventType::AuthenticationFailed
| CheckoutWebhookEventType::PaymentAuthenticationFailed => {
Self::PaymentIntentAuthorizationFailure
}
CheckoutWebhookEventType::PaymentApproved => Self::EventNotSupported,
CheckoutWebhookEventType::PaymentCaptured => Self::PaymentIntentSuccess,
CheckoutWebhookEventType::PaymentDeclined => Self::PaymentIntentFailure,
CheckoutWebhookEventType::PaymentRefunded => Self::RefundSuccess,
CheckoutWebhookEventType::PaymentRefundDeclined => Self::RefundFailure,
CheckoutWebhookEventType::PaymentCanceled => Self::PaymentIntentCancelFailure,
CheckoutWebhookEventType::PaymentCaptureDeclined => Self::PaymentIntentCaptureFailure,
CheckoutWebhookEventType::PaymentVoided => Self::PaymentIntentCancelled,
CheckoutWebhookEventType::DisputeReceived
| CheckoutWebhookEventType::DisputeEvidenceRequired => Self::DisputeOpened,
CheckoutWebhookEventType::DisputeExpired => Self::DisputeExpired,
CheckoutWebhookEventType::DisputeAccepted => Self::DisputeAccepted,
CheckoutWebhookEventType::DisputeCanceled => Self::DisputeCancelled,
CheckoutWebhookEventType::DisputeEvidenceSubmitted
| CheckoutWebhookEventType::DisputeEvidenceAcknowledgedByScheme => {
Self::DisputeChallenged
}
CheckoutWebhookEventType::DisputeWon
| CheckoutWebhookEventType::DisputeArbitrationWon => Self::DisputeWon,
CheckoutWebhookEventType::DisputeLost
| CheckoutWebhookEventType::DisputeArbitrationLost => Self::DisputeLost,
CheckoutWebhookEventType::Unknown => Self::EventNotSupported,
}
}
}
impl From<CheckoutDisputeTransactionType> for api_models::enums::DisputeStage {
fn from(code: CheckoutDisputeTransactionType) -> Self {
match code {
CheckoutDisputeTransactionType::DisputeArbitrationLost
| CheckoutDisputeTransactionType::DisputeArbitrationWon => Self::PreArbitration,
CheckoutDisputeTransactionType::DisputeReceived
| CheckoutDisputeTransactionType::DisputeExpired
| CheckoutDisputeTransactionType::DisputeAccepted
| CheckoutDisputeTransactionType::DisputeCanceled
| CheckoutDisputeTransactionType::DisputeEvidenceSubmitted
| CheckoutDisputeTransactionType::DisputeEvidenceAcknowledgedByScheme
| CheckoutDisputeTransactionType::DisputeEvidenceRequired
| CheckoutDisputeTransactionType::DisputeWon
| CheckoutDisputeTransactionType::DisputeLost => Self::Dispute,
}
}
}
#[derive(Debug, Deserialize)]
pub struct CheckoutWebhookObjectResource {
pub data: serde_json::Value,
}
#[derive(Debug, Serialize)]
pub struct CheckoutFileRequest {
pub purpose: &'static str,
#[serde(skip)]
pub file: Vec<u8>,
#[serde(skip)]
pub file_key: String,
#[serde(skip)]
pub file_type: String,
}
pub fn construct_file_upload_request(
file_upload_router_data: UploadFileRouterData,
) -> CustomResult<RequestContent, errors::ConnectorError> {
let request = file_upload_router_data.request;
let checkout_file_request = CheckoutFileRequest {
purpose: "dispute_evidence",
file: request.file.clone(),
file_key: request.file_key.clone(),
file_type: request.file_type.to_string(),
};
let mut multipart = reqwest::multipart::Form::new();
multipart = multipart.text("purpose", "dispute_evidence");
let file_data = reqwest::multipart::Part::bytes(request.file)
.file_name(format!(
"{}.{}",
request.file_key,
request
.file_type
.as_ref()
.split('/')
.next_back()
.unwrap_or_default()
))
.mime_str(request.file_type.as_ref())
.change_context(errors::ConnectorError::RequestEncodingFailed)
.attach_printable("Failure in constructing file data")?;
multipart = multipart.part("file", file_data);
Ok(RequestContent::FormData((
multipart,
Box::new(checkout_file_request),
)))
}
#[derive(Debug, Deserialize, Serialize)]
pub struct FileUploadResponse {
#[serde(rename = "id")]
pub file_id: String,
}
#[derive(Default, Debug, Serialize)]
pub struct Evidence {
pub proof_of_delivery_or_service_file: Option<String>,
pub invoice_or_receipt_file: Option<String>,
pub invoice_showing_distinct_transactions_file: Option<String>,
pub customer_communication_file: Option<String>,
pub refund_or_cancellation_policy_file: Option<String>,
pub recurring_transaction_agreement_file: Option<String>,
pub additional_evidence_file: Option<String>,
}
impl TryFrom<&webhooks::IncomingWebhookRequestDetails<'_>> for PaymentsResponse {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
request: &webhooks::IncomingWebhookRequestDetails<'_>,
) -> Result<Self, Self::Error> {
let details: CheckoutWebhookBody = request
.body
.parse_struct("CheckoutWebhookBody")
.change_context(errors::ConnectorError::WebhookBodyDecodingFailed)?;
let data = details.data;
let psync_struct = Self {
id: data.payment_id.unwrap_or(data.id),
amount: Some(data.amount),
status: CheckoutPaymentStatus::try_from(details.transaction_type)?,
links: details.links,
balances: data.balances,
reference: data.reference,
response_code: data.response_code,
response_summary: data.response_summary,
action_id: data.action_id,
currency: Some(data.currency),
processed_on: data.processed_on,
approved: data.approved,
source: Some(Source {
id: details.source.clone().and_then(|src| src.id),
avs_check: details.source.clone().and_then(|src| src.avs_check),
cvv_check: details.source.clone().and_then(|src| src.cvv_check),
}),
scheme_id: None,
processing: None,
};
Ok(psync_struct)
}
}
impl TryFrom<&webhooks::IncomingWebhookRequestDetails<'_>> for RefundResponse {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
request: &webhooks::IncomingWebhookRequestDetails<'_>,
) -> Result<Self, Self::Error> {
let details: CheckoutWebhookBody = request
.body
.parse_struct("CheckoutWebhookBody")
.change_context(errors::ConnectorError::WebhookBodyDecodingFailed)?;
let data = details.data;
let refund_struct = Self {
action_id: data
.action_id
.ok_or(errors::ConnectorError::WebhookBodyDecodingFailed)?,
reference: data
.reference
.ok_or(errors::ConnectorError::WebhookBodyDecodingFailed)?,
};
Ok(refund_struct)
}
}
impl TryFrom<&SubmitEvidenceRouterData> for Evidence {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(item: &SubmitEvidenceRouterData) -> Result<Self, Self::Error> {
let submit_evidence_request_data = item.request.clone();
Ok(Self {
proof_of_delivery_or_service_file: submit_evidence_request_data
.shipping_documentation_provider_file_id,
invoice_or_receipt_file: submit_evidence_request_data.receipt_provider_file_id,
invoice_showing_distinct_transactions_file: submit_evidence_request_data
.invoice_showing_distinct_transactions_provider_file_id,
customer_communication_file: submit_evidence_request_data
.customer_communication_provider_file_id,
refund_or_cancellation_policy_file: submit_evidence_request_data
.refund_policy_provider_file_id,
recurring_transaction_agreement_file: submit_evidence_request_data
.recurring_transaction_agreement_provider_file_id,
additional_evidence_file: submit_evidence_request_data
.uncategorized_file_provider_file_id,
})
}
}
impl From<String> for utils::ErrorCodeAndMessage {
fn from(error: String) -> Self {
Self {
error_code: error.clone(),
error_message: error,
}
}
}
fn convert_to_additional_payment_method_connector_response(
source: Option<&Source>,
) -> Option<AdditionalPaymentMethodConnectorResponse> {
source.map(|code| {
let payment_checks = serde_json::json!({
"avs_result": code.avs_check,
"card_validation_result": code.cvv_check,
});
AdditionalPaymentMethodConnectorResponse::Card {
authentication_data: None,
payment_checks: Some(payment_checks),
card_network: None,
domestic_network: None,
}
})
}
|
{
"crate": "hyperswitch_connectors",
"file": "crates/hyperswitch_connectors/src/connectors/checkout/transformers.rs",
"file_size": null,
"is_async": null,
"is_pub": null,
"num_enums": 14,
"num_structs": 47,
"num_tables": null,
"score": null,
"total_crates": null
}
|
file_hyperswitch_connectors_6672435177927477036
|
clm
|
file
|
// Repository: hyperswitch
// Crate: hyperswitch_connectors
// File: crates/hyperswitch_connectors/src/connectors/katapult/transformers.rs
// Contains: 6 structs, 2 enums
use common_enums::enums;
use common_utils::types::StringMinorUnit;
use hyperswitch_domain_models::{
payment_method_data::PaymentMethodData,
router_data::{ConnectorAuthType, RouterData},
router_flow_types::refunds::{Execute, RSync},
router_request_types::ResponseId,
router_response_types::{PaymentsResponseData, RefundsResponseData},
types::{PaymentsAuthorizeRouterData, RefundsRouterData},
};
use hyperswitch_interfaces::errors;
use masking::Secret;
use serde::{Deserialize, Serialize};
use crate::types::{RefundsResponseRouterData, ResponseRouterData};
//TODO: Fill the struct with respective fields
pub struct KatapultRouterData<T> {
pub amount: StringMinorUnit, // The type of amount that a connector accepts, for example, String, i64, f64, etc.
pub router_data: T,
}
impl<T> From<(StringMinorUnit, T)> for KatapultRouterData<T> {
fn from((amount, item): (StringMinorUnit, T)) -> Self {
//Todo : use utils to convert the amount to the type of amount that a connector accepts
Self {
amount,
router_data: item,
}
}
}
//TODO: Fill the struct with respective fields
#[derive(Default, Debug, Serialize, PartialEq)]
pub struct KatapultPaymentsRequest {
amount: StringMinorUnit,
card: KatapultCard,
}
#[derive(Default, Debug, Serialize, Eq, PartialEq)]
pub struct KatapultCard {
number: cards::CardNumber,
expiry_month: Secret<String>,
expiry_year: Secret<String>,
cvc: Secret<String>,
complete: bool,
}
impl TryFrom<&KatapultRouterData<&PaymentsAuthorizeRouterData>> for KatapultPaymentsRequest {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: &KatapultRouterData<&PaymentsAuthorizeRouterData>,
) -> Result<Self, Self::Error> {
match item.router_data.request.payment_method_data.clone() {
PaymentMethodData::Card(_) => Err(errors::ConnectorError::NotImplemented(
"Card payment method not implemented".to_string(),
)
.into()),
_ => Err(errors::ConnectorError::NotImplemented("Payment method".to_string()).into()),
}
}
}
//TODO: Fill the struct with respective fields
// Auth Struct
pub struct KatapultAuthType {
pub(super) api_key: Secret<String>,
}
impl TryFrom<&ConnectorAuthType> for KatapultAuthType {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(auth_type: &ConnectorAuthType) -> Result<Self, Self::Error> {
match auth_type {
ConnectorAuthType::HeaderKey { api_key } => Ok(Self {
api_key: api_key.to_owned(),
}),
_ => Err(errors::ConnectorError::FailedToObtainAuthType.into()),
}
}
}
// PaymentsResponse
//TODO: Append the remaining status flags
#[derive(Debug, Clone, Copy, Default, Serialize, Deserialize, PartialEq)]
#[serde(rename_all = "lowercase")]
pub enum KatapultPaymentStatus {
Succeeded,
Failed,
#[default]
Processing,
}
impl From<KatapultPaymentStatus> for common_enums::AttemptStatus {
fn from(item: KatapultPaymentStatus) -> Self {
match item {
KatapultPaymentStatus::Succeeded => Self::Charged,
KatapultPaymentStatus::Failed => Self::Failure,
KatapultPaymentStatus::Processing => Self::Authorizing,
}
}
}
//TODO: Fill the struct with respective fields
#[derive(Default, Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct KatapultPaymentsResponse {
status: KatapultPaymentStatus,
id: String,
}
impl<F, T> TryFrom<ResponseRouterData<F, KatapultPaymentsResponse, T, PaymentsResponseData>>
for RouterData<F, T, PaymentsResponseData>
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: ResponseRouterData<F, KatapultPaymentsResponse, T, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
Ok(Self {
status: common_enums::AttemptStatus::from(item.response.status),
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(item.response.id),
redirection_data: Box::new(None),
mandate_reference: Box::new(None),
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: None,
incremental_authorization_allowed: None,
charges: None,
}),
..item.data
})
}
}
//TODO: Fill the struct with respective fields
// REFUND :
// Type definition for RefundRequest
#[derive(Default, Debug, Serialize)]
pub struct KatapultRefundRequest {
pub amount: StringMinorUnit,
}
impl<F> TryFrom<&KatapultRouterData<&RefundsRouterData<F>>> for KatapultRefundRequest {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(item: &KatapultRouterData<&RefundsRouterData<F>>) -> Result<Self, Self::Error> {
Ok(Self {
amount: item.amount.to_owned(),
})
}
}
// Type definition for Refund Response
#[allow(dead_code)]
#[derive(Debug, Copy, Serialize, Default, Deserialize, Clone)]
pub enum RefundStatus {
Succeeded,
Failed,
#[default]
Processing,
}
impl From<RefundStatus> for enums::RefundStatus {
fn from(item: RefundStatus) -> Self {
match item {
RefundStatus::Succeeded => Self::Success,
RefundStatus::Failed => Self::Failure,
RefundStatus::Processing => Self::Pending,
//TODO: Review mapping
}
}
}
//TODO: Fill the struct with respective fields
#[derive(Default, Debug, Clone, Serialize, Deserialize)]
pub struct RefundResponse {
id: String,
status: RefundStatus,
}
impl TryFrom<RefundsResponseRouterData<Execute, RefundResponse>> for RefundsRouterData<Execute> {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: RefundsResponseRouterData<Execute, RefundResponse>,
) -> Result<Self, Self::Error> {
Ok(Self {
response: Ok(RefundsResponseData {
connector_refund_id: item.response.id.to_string(),
refund_status: enums::RefundStatus::from(item.response.status),
}),
..item.data
})
}
}
impl TryFrom<RefundsResponseRouterData<RSync, RefundResponse>> for RefundsRouterData<RSync> {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: RefundsResponseRouterData<RSync, RefundResponse>,
) -> Result<Self, Self::Error> {
Ok(Self {
response: Ok(RefundsResponseData {
connector_refund_id: item.response.id.to_string(),
refund_status: enums::RefundStatus::from(item.response.status),
}),
..item.data
})
}
}
//TODO: Fill the struct with respective fields
#[derive(Default, Debug, Serialize, Deserialize, PartialEq)]
pub struct KatapultErrorResponse {
pub status_code: u16,
pub code: String,
pub message: String,
pub reason: Option<String>,
pub network_advice_code: Option<String>,
pub network_decline_code: Option<String>,
pub network_error_message: Option<String>,
}
|
{
"crate": "hyperswitch_connectors",
"file": "crates/hyperswitch_connectors/src/connectors/katapult/transformers.rs",
"file_size": null,
"is_async": null,
"is_pub": null,
"num_enums": 2,
"num_structs": 6,
"num_tables": null,
"score": null,
"total_crates": null
}
|
file_hyperswitch_connectors_6811277563981188279
|
clm
|
file
|
// Repository: hyperswitch
// Crate: hyperswitch_connectors
// File: crates/hyperswitch_connectors/src/connectors/zen/transformers.rs
// Contains: 23 structs, 9 enums
use cards::CardNumber;
use common_enums::enums;
use common_utils::{
errors::CustomResult,
ext_traits::{OptionExt, ValueExt},
pii::{self},
request::Method,
};
use error_stack::ResultExt;
use hyperswitch_domain_models::{
payment_method_data::{
BankDebitData, BankRedirectData, BankTransferData, Card, CardRedirectData, GiftCardData,
PayLaterData, PaymentMethodData, VoucherData, WalletData,
},
router_data::{ConnectorAuthType, ErrorResponse, RouterData},
router_flow_types::refunds::{Execute, RSync},
router_request_types::{BrowserInformation, ResponseId},
router_response_types::{PaymentsResponseData, RedirectForm, RefundsResponseData},
types,
};
use hyperswitch_interfaces::{
api,
consts::{NO_ERROR_CODE, NO_ERROR_MESSAGE},
errors,
};
use masking::{ExposeInterface, PeekInterface, Secret};
use ring::digest;
use serde::{Deserialize, Serialize};
use strum::Display;
use crate::{
types::{RefundsResponseRouterData, ResponseRouterData},
utils::{
self, BrowserInformationData, CardData, ForeignTryFrom, PaymentsAuthorizeRequestData,
RouterData as _,
},
};
#[derive(Debug, Serialize)]
pub struct ZenRouterData<T> {
pub amount: String,
pub router_data: T,
}
impl<T> TryFrom<(&api::CurrencyUnit, enums::Currency, i64, T)> for ZenRouterData<T> {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
(currency_unit, currency, amount, item): (&api::CurrencyUnit, enums::Currency, i64, T),
) -> Result<Self, Self::Error> {
let amount = utils::get_amount_as_string(currency_unit, amount, currency)?;
Ok(Self {
amount,
router_data: item,
})
}
}
// Auth Struct
pub struct ZenAuthType {
pub(super) api_key: Secret<String>,
}
impl TryFrom<&ConnectorAuthType> for ZenAuthType {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(auth_type: &ConnectorAuthType) -> Result<Self, Self::Error> {
if let ConnectorAuthType::HeaderKey { api_key } = auth_type {
Ok(Self {
api_key: api_key.to_owned(),
})
} else {
Err(errors::ConnectorError::FailedToObtainAuthType.into())
}
}
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ApiRequest {
merchant_transaction_id: String,
payment_channel: ZenPaymentChannels,
amount: String,
currency: enums::Currency,
payment_specific_data: ZenPaymentSpecificData,
customer: ZenCustomerDetails,
custom_ipn_url: String,
items: Vec<ZenItemObject>,
}
#[derive(Debug, Serialize)]
#[serde(untagged)]
pub enum ZenPaymentsRequest {
ApiRequest(Box<ApiRequest>),
CheckoutRequest(Box<CheckoutRequest>),
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct CheckoutRequest {
amount: String,
currency: enums::Currency,
custom_ipn_url: String,
items: Vec<ZenItemObject>,
merchant_transaction_id: String,
signature: Option<Secret<String>>,
specified_payment_channel: ZenPaymentChannels,
terminal_uuid: Secret<String>,
url_redirect: String,
}
#[derive(Clone, Debug, Display, Serialize)]
#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
#[allow(clippy::enum_variant_names)]
pub enum ZenPaymentChannels {
PclCard,
PclGooglepay,
PclApplepay,
PclBoacompraBoleto,
PclBoacompraEfecty,
PclBoacompraMultibanco,
PclBoacompraPagoefectivo,
PclBoacompraPix,
PclBoacompraPse,
PclBoacompraRedcompra,
PclBoacompraRedpagos,
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ZenCustomerDetails {
email: pii::Email,
ip: Secret<String, pii::IpAddress>,
}
#[derive(Debug, Serialize)]
#[serde(untagged)]
pub enum ZenPaymentSpecificData {
ZenOnetimePayment(Box<ZenPaymentData>),
ZenGeneralPayment(ZenGeneralPaymentData),
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ZenPaymentData {
browser_details: ZenBrowserDetails,
#[serde(rename = "type")]
payment_type: ZenPaymentTypes,
#[serde(skip_serializing_if = "Option::is_none")]
token: Option<Secret<String>>,
#[serde(skip_serializing_if = "Option::is_none")]
card: Option<ZenCardDetails>,
descriptor: String,
return_verify_url: Option<String>,
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ZenGeneralPaymentData {
#[serde(rename = "type")]
payment_type: ZenPaymentTypes,
return_url: String,
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ZenBrowserDetails {
color_depth: String,
java_enabled: bool,
lang: String,
screen_height: String,
screen_width: String,
timezone: String,
accept_header: String,
window_size: String,
user_agent: String,
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "snake_case")]
pub enum ZenPaymentTypes {
Onetime,
General,
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ZenCardDetails {
number: CardNumber,
expiry_date: Secret<String>,
cvv: Secret<String>,
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ZenItemObject {
name: String,
price: String,
quantity: u16,
line_amount_total: String,
}
#[derive(Debug, Serialize, Deserialize)]
pub struct SessionObject {
pub apple_pay: Option<WalletSessionData>,
pub google_pay: Option<WalletSessionData>,
}
#[derive(Debug, Serialize, Deserialize)]
pub struct WalletSessionData {
pub terminal_uuid: Option<Secret<String>>,
pub pay_wall_secret: Option<Secret<String>>,
}
impl TryFrom<(&ZenRouterData<&types::PaymentsAuthorizeRouterData>, &Card)> for ZenPaymentsRequest {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
value: (&ZenRouterData<&types::PaymentsAuthorizeRouterData>, &Card),
) -> Result<Self, Self::Error> {
let (item, ccard) = value;
let browser_info = item.router_data.request.get_browser_info()?;
let ip = browser_info.get_ip_address()?;
let browser_details = get_browser_details(&browser_info)?;
let amount = item.amount.to_owned();
let payment_specific_data =
ZenPaymentSpecificData::ZenOnetimePayment(Box::new(ZenPaymentData {
browser_details,
//Connector Specific for cards
payment_type: ZenPaymentTypes::Onetime,
token: None,
card: Some(ZenCardDetails {
number: ccard.card_number.clone(),
expiry_date: ccard
.get_card_expiry_month_year_2_digit_with_delimiter("".to_owned())?,
cvv: ccard.card_cvc.clone(),
}),
descriptor: item
.router_data
.get_description()?
.chars()
.take(24)
.collect(),
return_verify_url: item.router_data.request.router_return_url.clone(),
}));
Ok(Self::ApiRequest(Box::new(ApiRequest {
merchant_transaction_id: item.router_data.connector_request_reference_id.clone(),
payment_channel: ZenPaymentChannels::PclCard,
currency: item.router_data.request.currency,
payment_specific_data,
customer: get_customer(item.router_data, ip)?,
custom_ipn_url: item.router_data.request.get_webhook_url()?,
items: get_item_object(item.router_data)?,
amount,
})))
}
}
impl
TryFrom<(
&ZenRouterData<&types::PaymentsAuthorizeRouterData>,
&VoucherData,
)> for ZenPaymentsRequest
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
value: (
&ZenRouterData<&types::PaymentsAuthorizeRouterData>,
&VoucherData,
),
) -> Result<Self, Self::Error> {
let (item, voucher_data) = value;
let browser_info = item.router_data.request.get_browser_info()?;
let ip = browser_info.get_ip_address()?;
let amount = item.amount.to_owned();
let payment_specific_data =
ZenPaymentSpecificData::ZenGeneralPayment(ZenGeneralPaymentData {
//Connector Specific for Latam Methods
payment_type: ZenPaymentTypes::General,
return_url: item.router_data.request.get_router_return_url()?,
});
let payment_channel = match voucher_data {
VoucherData::Boleto { .. } => ZenPaymentChannels::PclBoacompraBoleto,
VoucherData::Efecty => ZenPaymentChannels::PclBoacompraEfecty,
VoucherData::PagoEfectivo => ZenPaymentChannels::PclBoacompraPagoefectivo,
VoucherData::RedCompra => ZenPaymentChannels::PclBoacompraRedcompra,
VoucherData::RedPagos => ZenPaymentChannels::PclBoacompraRedpagos,
VoucherData::Oxxo
| VoucherData::Alfamart { .. }
| VoucherData::Indomaret { .. }
| VoucherData::SevenEleven { .. }
| VoucherData::Lawson { .. }
| VoucherData::MiniStop { .. }
| VoucherData::FamilyMart { .. }
| VoucherData::Seicomart { .. }
| VoucherData::PayEasy { .. } => Err(errors::ConnectorError::NotImplemented(
utils::get_unimplemented_payment_method_error_message("Zen"),
))?,
};
Ok(Self::ApiRequest(Box::new(ApiRequest {
merchant_transaction_id: item.router_data.connector_request_reference_id.clone(),
payment_channel,
currency: item.router_data.request.currency,
payment_specific_data,
customer: get_customer(item.router_data, ip)?,
custom_ipn_url: item.router_data.request.get_webhook_url()?,
items: get_item_object(item.router_data)?,
amount,
})))
}
}
impl
TryFrom<(
&ZenRouterData<&types::PaymentsAuthorizeRouterData>,
&Box<BankTransferData>,
)> for ZenPaymentsRequest
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
value: (
&ZenRouterData<&types::PaymentsAuthorizeRouterData>,
&Box<BankTransferData>,
),
) -> Result<Self, Self::Error> {
let (item, bank_transfer_data) = value;
let browser_info = item.router_data.request.get_browser_info()?;
let ip = browser_info.get_ip_address()?;
let amount = item.amount.to_owned();
let payment_specific_data =
ZenPaymentSpecificData::ZenGeneralPayment(ZenGeneralPaymentData {
//Connector Specific for Latam Methods
payment_type: ZenPaymentTypes::General,
return_url: item.router_data.request.get_router_return_url()?,
});
let payment_channel = match **bank_transfer_data {
BankTransferData::MultibancoBankTransfer { .. } => {
ZenPaymentChannels::PclBoacompraMultibanco
}
BankTransferData::Pix { .. } => ZenPaymentChannels::PclBoacompraPix,
BankTransferData::Pse { .. } => ZenPaymentChannels::PclBoacompraPse,
BankTransferData::SepaBankTransfer { .. }
| BankTransferData::AchBankTransfer { .. }
| BankTransferData::BacsBankTransfer { .. }
| BankTransferData::PermataBankTransfer { .. }
| BankTransferData::BcaBankTransfer { .. }
| BankTransferData::BniVaBankTransfer { .. }
| BankTransferData::BriVaBankTransfer { .. }
| BankTransferData::CimbVaBankTransfer { .. }
| BankTransferData::DanamonVaBankTransfer { .. }
| BankTransferData::LocalBankTransfer { .. }
| BankTransferData::InstantBankTransfer {}
| BankTransferData::InstantBankTransferFinland { .. }
| BankTransferData::InstantBankTransferPoland { .. }
| BankTransferData::IndonesianBankTransfer { .. }
| BankTransferData::MandiriVaBankTransfer { .. } => {
Err(errors::ConnectorError::NotImplemented(
utils::get_unimplemented_payment_method_error_message("Zen"),
))?
}
};
Ok(Self::ApiRequest(Box::new(ApiRequest {
merchant_transaction_id: item.router_data.connector_request_reference_id.clone(),
payment_channel,
currency: item.router_data.request.currency,
payment_specific_data,
customer: get_customer(item.router_data, ip)?,
custom_ipn_url: item.router_data.request.get_webhook_url()?,
items: get_item_object(item.router_data)?,
amount,
})))
}
}
/*
impl TryFrom<(&types::PaymentsAuthorizeRouterData, &GooglePayWalletData)> for ZenPaymentsRequest {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
(item, gpay_pay_redirect_data): (&types::PaymentsAuthorizeRouterData, &GooglePayWalletData),
) -> Result<Self, Self::Error> {
let amount = utils::to_currency_base_unit(item.request.amount, item.request.currency)?;
let browser_info = item.request.get_browser_info()?;
let browser_details = get_browser_details(&browser_info)?;
let ip = browser_info.get_ip_address()?;
let payment_specific_data = ZenPaymentData {
browser_details,
//Connector Specific for wallet
payment_type: ZenPaymentTypes::ExternalPaymentToken,
token: Some(Secret::new(
gpay_pay_redirect_data.tokenization_data.token.clone(),
)),
card: None,
descriptor: item.get_description()?.chars().take(24).collect(),
return_verify_url: item.request.router_return_url.clone(),
};
Ok(Self::ApiRequest(Box::new(ApiRequest {
merchant_transaction_id: item.attempt_id.clone(),
payment_channel: ZenPaymentChannels::PclGooglepay,
currency: item.request.currency,
payment_specific_data,
customer: get_customer(item, ip)?,
custom_ipn_url: item.request.get_webhook_url()?,
items: get_item_object(item, amount.clone())?,
amount,
})))
}
}
*/
/*
impl
TryFrom<(
&types::PaymentsAuthorizeRouterData,
&Box<ApplePayRedirectData>,
)> for ZenPaymentsRequest
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
(item, _apple_pay_redirect_data): (
&types::PaymentsAuthorizeRouterData,
&Box<ApplePayRedirectData>,
),
) -> Result<Self, Self::Error> {
let amount = utils::to_currency_base_unit(item.request.amount, item.request.currency)?;
let connector_meta = item.get_connector_meta()?;
let session: SessionObject = connector_meta
.parse_value("SessionObject")
.change_context(errors::ConnectorError::RequestEncodingFailed)?;
let applepay_session_data = session
.apple_pay
.ok_or(errors::ConnectorError::RequestEncodingFailed)?;
let terminal_uuid = applepay_session_data
.terminal_uuid
.clone()
.ok_or(errors::ConnectorError::RequestEncodingFailed)?;
let mut checkout_request = CheckoutRequest {
merchant_transaction_id: item.attempt_id.clone(),
specified_payment_channel: ZenPaymentChannels::PclApplepay,
currency: item.request.currency,
custom_ipn_url: item.request.get_webhook_url()?,
items: get_item_object(item, amount.clone())?,
amount,
terminal_uuid: Secret::new(terminal_uuid),
signature: None,
url_redirect: item.request.get_return_url()?,
};
checkout_request.signature = Some(get_checkout_signature(
&checkout_request,
&applepay_session_data,
)?);
Ok(Self::CheckoutRequest(Box::new(checkout_request)))
}
}
*/
impl
TryFrom<(
&ZenRouterData<&types::PaymentsAuthorizeRouterData>,
&WalletData,
)> for ZenPaymentsRequest
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
(item, wallet_data): (
&ZenRouterData<&types::PaymentsAuthorizeRouterData>,
&WalletData,
),
) -> Result<Self, Self::Error> {
let amount = item.amount.to_owned();
let connector_meta = item.router_data.get_connector_meta()?;
let session: SessionObject = connector_meta
.parse_value("SessionObject")
.change_context(errors::ConnectorError::RequestEncodingFailed)?;
let (specified_payment_channel, session_data) = match wallet_data {
WalletData::ApplePayRedirect(_) => (
ZenPaymentChannels::PclApplepay,
session
.apple_pay
.ok_or(errors::ConnectorError::InvalidWalletToken {
wallet_name: "Apple Pay".to_string(),
})?,
),
WalletData::GooglePayRedirect(_) => (
ZenPaymentChannels::PclGooglepay,
session
.google_pay
.ok_or(errors::ConnectorError::InvalidWalletToken {
wallet_name: "Google Pay".to_string(),
})?,
),
WalletData::WeChatPayRedirect(_)
| WalletData::PaypalRedirect(_)
| WalletData::AmazonPay(_)
| WalletData::ApplePay(_)
| WalletData::GooglePay(_)
| WalletData::BluecodeRedirect {}
| WalletData::AliPayQr(_)
| WalletData::AliPayRedirect(_)
| WalletData::AliPayHkRedirect(_)
| WalletData::AmazonPayRedirect(_)
| WalletData::Paysera(_)
| WalletData::Skrill(_)
| WalletData::MomoRedirect(_)
| WalletData::KakaoPayRedirect(_)
| WalletData::GoPayRedirect(_)
| WalletData::GcashRedirect(_)
| WalletData::ApplePayThirdPartySdk(_)
| WalletData::DanaRedirect {}
| WalletData::GooglePayThirdPartySdk(_)
| WalletData::MbWayRedirect(_)
| WalletData::MobilePayRedirect(_)
| WalletData::PaypalSdk(_)
| WalletData::Paze(_)
| WalletData::SamsungPay(_)
| WalletData::TwintRedirect {}
| WalletData::VippsRedirect {}
| WalletData::TouchNGoRedirect(_)
| WalletData::CashappQr(_)
| WalletData::SwishQr(_)
| WalletData::WeChatPayQr(_)
| WalletData::Mifinity(_)
| WalletData::RevolutPay(_) => Err(errors::ConnectorError::NotImplemented(
utils::get_unimplemented_payment_method_error_message("Zen"),
))?,
};
let terminal_uuid = session_data
.terminal_uuid
.clone()
.ok_or(errors::ConnectorError::RequestEncodingFailed)?
.expose();
let mut checkout_request = CheckoutRequest {
merchant_transaction_id: item.router_data.connector_request_reference_id.clone(),
specified_payment_channel,
currency: item.router_data.request.currency,
custom_ipn_url: item.router_data.request.get_webhook_url()?,
items: get_item_object(item.router_data)?,
amount,
terminal_uuid: Secret::new(terminal_uuid),
signature: None,
url_redirect: item.router_data.request.get_router_return_url()?,
};
checkout_request.signature =
Some(get_checkout_signature(&checkout_request, &session_data)?);
Ok(Self::CheckoutRequest(Box::new(checkout_request)))
}
}
fn get_checkout_signature(
checkout_request: &CheckoutRequest,
session: &WalletSessionData,
) -> Result<Secret<String>, error_stack::Report<errors::ConnectorError>> {
let pay_wall_secret = session
.pay_wall_secret
.clone()
.ok_or(errors::ConnectorError::RequestEncodingFailed)?;
let mut signature_data = get_signature_data(checkout_request)?;
signature_data.push_str(&pay_wall_secret.expose());
let payload_digest = digest::digest(&digest::SHA256, signature_data.as_bytes());
let mut signature = hex::encode(payload_digest);
signature.push_str(";sha256");
Ok(Secret::new(signature))
}
/// Fields should be in alphabetical order
fn get_signature_data(
checkout_request: &CheckoutRequest,
) -> Result<String, errors::ConnectorError> {
let specified_payment_channel = match checkout_request.specified_payment_channel {
ZenPaymentChannels::PclCard => "pcl_card",
ZenPaymentChannels::PclGooglepay => "pcl_googlepay",
ZenPaymentChannels::PclApplepay => "pcl_applepay",
ZenPaymentChannels::PclBoacompraBoleto => "pcl_boacompra_boleto",
ZenPaymentChannels::PclBoacompraEfecty => "pcl_boacompra_efecty",
ZenPaymentChannels::PclBoacompraMultibanco => "pcl_boacompra_multibanco",
ZenPaymentChannels::PclBoacompraPagoefectivo => "pcl_boacompra_pagoefectivo",
ZenPaymentChannels::PclBoacompraPix => "pcl_boacompra_pix",
ZenPaymentChannels::PclBoacompraPse => "pcl_boacompra_pse",
ZenPaymentChannels::PclBoacompraRedcompra => "pcl_boacompra_redcompra",
ZenPaymentChannels::PclBoacompraRedpagos => "pcl_boacompra_redpagos",
};
let mut signature_data = vec![
format!("amount={}", checkout_request.amount),
format!("currency={}", checkout_request.currency),
format!("customipnurl={}", checkout_request.custom_ipn_url),
];
for index in 0..checkout_request.items.len() {
let prefix = format!("items[{index}].");
let checkout_request_items = checkout_request
.items
.get(index)
.ok_or(errors::ConnectorError::RequestEncodingFailed)?;
signature_data.push(format!(
"{prefix}lineamounttotal={}",
checkout_request_items.line_amount_total
));
signature_data.push(format!("{prefix}name={}", checkout_request_items.name));
signature_data.push(format!("{prefix}price={}", checkout_request_items.price));
signature_data.push(format!(
"{prefix}quantity={}",
checkout_request_items.quantity
));
}
signature_data.push(format!(
"merchanttransactionid={}",
checkout_request.merchant_transaction_id
));
signature_data.push(format!(
"specifiedpaymentchannel={specified_payment_channel}"
));
signature_data.push(format!(
"terminaluuid={}",
checkout_request.terminal_uuid.peek()
));
signature_data.push(format!("urlredirect={}", checkout_request.url_redirect));
let signature = signature_data.join("&");
Ok(signature.to_lowercase())
}
fn get_customer(
item: &types::PaymentsAuthorizeRouterData,
ip: Secret<String, pii::IpAddress>,
) -> Result<ZenCustomerDetails, error_stack::Report<errors::ConnectorError>> {
Ok(ZenCustomerDetails {
email: item.request.get_email()?,
ip,
})
}
fn get_item_object(
item: &types::PaymentsAuthorizeRouterData,
) -> Result<Vec<ZenItemObject>, error_stack::Report<errors::ConnectorError>> {
let order_details = item.request.get_order_details()?;
order_details
.iter()
.map(|data| {
Ok(ZenItemObject {
name: data.product_name.clone(),
quantity: data.quantity,
price: utils::to_currency_base_unit_with_zero_decimal_check(
data.amount.get_amount_as_i64(), // This should be changed to MinorUnit when we implement amount conversion for this connector. Additionally, the function get_amount_as_i64() should be avoided in the future.
item.request.currency,
)?,
line_amount_total: (f64::from(data.quantity)
* utils::to_currency_base_unit_asf64(
data.amount.get_amount_as_i64(), // This should be changed to MinorUnit when we implement amount conversion for this connector. Additionally, the function get_amount_as_i64() should be avoided in the future.
item.request.currency,
)?)
.to_string(),
})
})
.collect::<Result<_, _>>()
}
fn get_browser_details(
browser_info: &BrowserInformation,
) -> CustomResult<ZenBrowserDetails, errors::ConnectorError> {
let screen_height = browser_info
.screen_height
.get_required_value("screen_height")
.change_context(errors::ConnectorError::MissingRequiredField {
field_name: "screen_height",
})?;
let screen_width = browser_info
.screen_width
.get_required_value("screen_width")
.change_context(errors::ConnectorError::MissingRequiredField {
field_name: "screen_width",
})?;
let window_size = match (screen_height, screen_width) {
(250, 400) => "01",
(390, 400) => "02",
(500, 600) => "03",
(600, 400) => "04",
_ => "05",
}
.to_string();
Ok(ZenBrowserDetails {
color_depth: browser_info.get_color_depth()?.to_string(),
java_enabled: browser_info.get_java_enabled()?,
lang: browser_info.get_language()?,
screen_height: screen_height.to_string(),
screen_width: screen_width.to_string(),
timezone: browser_info.get_time_zone()?.to_string(),
accept_header: browser_info.get_accept_header()?,
user_agent: browser_info.get_user_agent()?,
window_size,
})
}
impl TryFrom<&ZenRouterData<&types::PaymentsAuthorizeRouterData>> for ZenPaymentsRequest {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: &ZenRouterData<&types::PaymentsAuthorizeRouterData>,
) -> Result<Self, Self::Error> {
match &item.router_data.request.payment_method_data {
PaymentMethodData::Card(card) => Self::try_from((item, card)),
PaymentMethodData::Wallet(wallet_data) => Self::try_from((item, wallet_data)),
PaymentMethodData::Voucher(voucher_data) => Self::try_from((item, voucher_data)),
PaymentMethodData::BankTransfer(bank_transfer_data) => {
Self::try_from((item, bank_transfer_data))
}
PaymentMethodData::BankRedirect(bank_redirect_data) => {
Self::try_from(bank_redirect_data)
}
PaymentMethodData::PayLater(paylater_data) => Self::try_from(paylater_data),
PaymentMethodData::BankDebit(bank_debit_data) => Self::try_from(bank_debit_data),
PaymentMethodData::CardRedirect(car_redirect_data) => Self::try_from(car_redirect_data),
PaymentMethodData::GiftCard(gift_card_data) => Self::try_from(gift_card_data.as_ref()),
PaymentMethodData::Crypto(_)
| PaymentMethodData::MandatePayment
| PaymentMethodData::Reward
| PaymentMethodData::RealTimePayment(_)
| PaymentMethodData::MobilePayment(_)
| PaymentMethodData::Upi(_)
| PaymentMethodData::OpenBanking(_)
| PaymentMethodData::CardToken(_)
| PaymentMethodData::NetworkToken(_)
| PaymentMethodData::CardDetailsForNetworkTransactionId(_) => {
Err(errors::ConnectorError::NotImplemented(
utils::get_unimplemented_payment_method_error_message("Zen"),
))?
}
}
}
}
impl TryFrom<&BankRedirectData> for ZenPaymentsRequest {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(value: &BankRedirectData) -> Result<Self, Self::Error> {
match value {
BankRedirectData::Ideal { .. }
| BankRedirectData::Sofort { .. }
| BankRedirectData::BancontactCard { .. }
| BankRedirectData::Blik { .. }
| BankRedirectData::Trustly { .. }
| BankRedirectData::Eft { .. }
| BankRedirectData::Eps { .. }
| BankRedirectData::Giropay { .. }
| BankRedirectData::Przelewy24 { .. }
| BankRedirectData::Bizum {}
| BankRedirectData::Interac { .. }
| BankRedirectData::OnlineBankingCzechRepublic { .. }
| BankRedirectData::OnlineBankingFinland { .. }
| BankRedirectData::OnlineBankingPoland { .. }
| BankRedirectData::OnlineBankingSlovakia { .. }
| BankRedirectData::OpenBankingUk { .. }
| BankRedirectData::OnlineBankingFpx { .. }
| BankRedirectData::OnlineBankingThailand { .. }
| BankRedirectData::LocalBankRedirect {} => {
Err(errors::ConnectorError::NotImplemented(
utils::get_unimplemented_payment_method_error_message("Zen"),
)
.into())
}
}
}
}
impl TryFrom<&PayLaterData> for ZenPaymentsRequest {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(value: &PayLaterData) -> Result<Self, Self::Error> {
match value {
PayLaterData::KlarnaRedirect { .. }
| PayLaterData::KlarnaSdk { .. }
| PayLaterData::AffirmRedirect {}
| PayLaterData::AfterpayClearpayRedirect { .. }
| PayLaterData::PayBrightRedirect {}
| PayLaterData::WalleyRedirect {}
| PayLaterData::AlmaRedirect {}
| PayLaterData::FlexitiRedirect {}
| PayLaterData::AtomeRedirect {}
| PayLaterData::BreadpayRedirect {} => Err(errors::ConnectorError::NotImplemented(
utils::get_unimplemented_payment_method_error_message("Zen"),
)
.into()),
}
}
}
impl TryFrom<&BankDebitData> for ZenPaymentsRequest {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(value: &BankDebitData) -> Result<Self, Self::Error> {
match value {
BankDebitData::AchBankDebit { .. }
| BankDebitData::SepaBankDebit { .. }
| BankDebitData::BecsBankDebit { .. }
| BankDebitData::BacsBankDebit { .. }
| BankDebitData::SepaGuarenteedBankDebit { .. } => {
Err(errors::ConnectorError::NotImplemented(
utils::get_unimplemented_payment_method_error_message("Zen"),
)
.into())
}
}
}
}
impl TryFrom<&CardRedirectData> for ZenPaymentsRequest {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(value: &CardRedirectData) -> Result<Self, Self::Error> {
match value {
CardRedirectData::Knet {}
| CardRedirectData::Benefit {}
| CardRedirectData::MomoAtm {}
| CardRedirectData::CardRedirect {} => Err(errors::ConnectorError::NotImplemented(
utils::get_unimplemented_payment_method_error_message("Zen"),
)
.into()),
}
}
}
impl TryFrom<&GiftCardData> for ZenPaymentsRequest {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(value: &GiftCardData) -> Result<Self, Self::Error> {
match value {
GiftCardData::PaySafeCard {}
| GiftCardData::Givex(_)
| GiftCardData::BhnCardNetwork(_) => Err(errors::ConnectorError::NotImplemented(
utils::get_unimplemented_payment_method_error_message("Zen"),
)
.into()),
}
}
}
// PaymentsResponse
#[derive(Debug, Default, Deserialize, Clone, strum::Display, Serialize)]
#[serde(rename_all = "UPPERCASE")]
pub enum ZenPaymentStatus {
Authorized,
Accepted,
#[default]
Pending,
Rejected,
Canceled,
}
impl ForeignTryFrom<(ZenPaymentStatus, Option<ZenActions>)> for enums::AttemptStatus {
type Error = error_stack::Report<errors::ConnectorError>;
fn foreign_try_from(item: (ZenPaymentStatus, Option<ZenActions>)) -> Result<Self, Self::Error> {
let (item_txn_status, item_action_status) = item;
Ok(match item_txn_status {
// Payment has been authorized at connector end, They will send webhook when it gets accepted
ZenPaymentStatus::Authorized => Self::Pending,
ZenPaymentStatus::Accepted => Self::Charged,
ZenPaymentStatus::Pending => {
item_action_status.map_or(Self::Pending, |action| match action {
ZenActions::Redirect => Self::AuthenticationPending,
})
}
ZenPaymentStatus::Rejected => Self::Failure,
ZenPaymentStatus::Canceled => Self::Voided,
})
}
}
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ApiResponse {
status: ZenPaymentStatus,
id: String,
// merchant_transaction_id: Option<String>,
merchant_action: Option<ZenMerchantAction>,
reject_code: Option<String>,
reject_reason: Option<String>,
}
#[derive(Debug, Deserialize, Serialize)]
#[serde(untagged)]
pub enum ZenPaymentsResponse {
ApiResponse(ApiResponse),
CheckoutResponse(CheckoutResponse),
}
#[derive(Debug, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct CheckoutResponse {
redirect_url: url::Url,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ZenMerchantAction {
action: ZenActions,
data: ZenMerchantActionData,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "UPPERCASE")]
pub enum ZenActions {
Redirect,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ZenMerchantActionData {
redirect_url: url::Url,
}
impl<F, T> TryFrom<ResponseRouterData<F, ZenPaymentsResponse, T, PaymentsResponseData>>
for RouterData<F, T, PaymentsResponseData>
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: ResponseRouterData<F, ZenPaymentsResponse, T, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
match item.response {
ZenPaymentsResponse::ApiResponse(response) => Self::try_from(ResponseRouterData {
response,
data: item.data,
http_code: item.http_code,
}),
ZenPaymentsResponse::CheckoutResponse(response) => Self::try_from(ResponseRouterData {
response,
data: item.data,
http_code: item.http_code,
}),
}
}
}
fn get_zen_response(
response: ApiResponse,
status_code: u16,
) -> CustomResult<
(
enums::AttemptStatus,
Option<ErrorResponse>,
PaymentsResponseData,
),
errors::ConnectorError,
> {
let redirection_data_action = response.merchant_action.map(|merchant_action| {
(
RedirectForm::from((merchant_action.data.redirect_url, Method::Get)),
merchant_action.action,
)
});
let (redirection_data, action) = match redirection_data_action {
Some((redirect_form, action)) => (Some(redirect_form), Some(action)),
None => (None, None),
};
let status = enums::AttemptStatus::foreign_try_from((response.status, action))?;
let error = if utils::is_payment_failure(status) {
Some(ErrorResponse {
code: response
.reject_code
.unwrap_or_else(|| NO_ERROR_CODE.to_string()),
message: response
.reject_reason
.clone()
.unwrap_or_else(|| NO_ERROR_MESSAGE.to_string()),
reason: response.reject_reason,
status_code,
attempt_status: Some(status),
connector_transaction_id: Some(response.id.clone()),
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
connector_metadata: None,
})
} else {
None
};
let payment_response_data = PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(response.id.clone()),
redirection_data: Box::new(redirection_data),
mandate_reference: Box::new(None),
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: None,
incremental_authorization_allowed: None,
charges: None,
};
Ok((status, error, payment_response_data))
}
impl<F, T> TryFrom<ResponseRouterData<F, ApiResponse, T, PaymentsResponseData>>
for RouterData<F, T, PaymentsResponseData>
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
value: ResponseRouterData<F, ApiResponse, T, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
let (status, error, payment_response_data) =
get_zen_response(value.response.clone(), value.http_code)?;
Ok(Self {
status,
response: error.map_or_else(|| Ok(payment_response_data), Err),
..value.data
})
}
}
impl<F, T> TryFrom<ResponseRouterData<F, CheckoutResponse, T, PaymentsResponseData>>
for RouterData<F, T, PaymentsResponseData>
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
value: ResponseRouterData<F, CheckoutResponse, T, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
let redirection_data = Some(RedirectForm::from((
value.response.redirect_url,
Method::Get,
)));
Ok(Self {
status: enums::AttemptStatus::AuthenticationPending,
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::NoResponseId,
redirection_data: Box::new(redirection_data),
mandate_reference: Box::new(None),
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: None,
incremental_authorization_allowed: None,
charges: None,
}),
..value.data
})
}
}
#[derive(Default, Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ZenRefundRequest {
amount: String,
transaction_id: String,
currency: enums::Currency,
merchant_transaction_id: String,
}
impl<F> TryFrom<&ZenRouterData<&types::RefundsRouterData<F>>> for ZenRefundRequest {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(item: &ZenRouterData<&types::RefundsRouterData<F>>) -> Result<Self, Self::Error> {
Ok(Self {
amount: item.amount.to_owned(),
transaction_id: item.router_data.request.connector_transaction_id.clone(),
currency: item.router_data.request.currency,
merchant_transaction_id: item.router_data.request.refund_id.clone(),
})
}
}
#[derive(Debug, Default, Deserialize, Serialize)]
#[serde(rename_all = "UPPERCASE")]
pub enum RefundStatus {
Authorized,
Accepted,
#[default]
Pending,
Rejected,
}
impl From<RefundStatus> for enums::RefundStatus {
fn from(item: RefundStatus) -> Self {
match item {
RefundStatus::Accepted => Self::Success,
RefundStatus::Pending | RefundStatus::Authorized => Self::Pending,
RefundStatus::Rejected => Self::Failure,
}
}
}
#[derive(Default, Debug, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct RefundResponse {
id: String,
status: RefundStatus,
reject_code: Option<String>,
reject_reason: Option<String>,
}
impl TryFrom<RefundsResponseRouterData<Execute, RefundResponse>>
for types::RefundsRouterData<Execute>
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: RefundsResponseRouterData<Execute, RefundResponse>,
) -> Result<Self, Self::Error> {
let (error, refund_response_data) = get_zen_refund_response(item.response, item.http_code)?;
Ok(Self {
response: error.map_or_else(|| Ok(refund_response_data), Err),
..item.data
})
}
}
fn get_zen_refund_response(
response: RefundResponse,
status_code: u16,
) -> CustomResult<(Option<ErrorResponse>, RefundsResponseData), errors::ConnectorError> {
let refund_status = enums::RefundStatus::from(response.status);
let error = if utils::is_refund_failure(refund_status) {
Some(ErrorResponse {
code: response
.reject_code
.unwrap_or_else(|| NO_ERROR_CODE.to_string()),
message: response
.reject_reason
.clone()
.unwrap_or_else(|| NO_ERROR_MESSAGE.to_string()),
reason: response.reject_reason,
status_code,
attempt_status: None,
connector_transaction_id: Some(response.id.clone()),
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
connector_metadata: None,
})
} else {
None
};
let refund_response_data = RefundsResponseData {
connector_refund_id: response.id,
refund_status,
};
Ok((error, refund_response_data))
}
impl TryFrom<RefundsResponseRouterData<RSync, RefundResponse>> for types::RefundsRouterData<RSync> {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: RefundsResponseRouterData<RSync, RefundResponse>,
) -> Result<Self, Self::Error> {
let refund_status = enums::RefundStatus::from(item.response.status);
Ok(Self {
response: Ok(RefundsResponseData {
connector_refund_id: item.response.id,
refund_status,
}),
..item.data
})
}
}
#[derive(Debug, Clone, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ZenWebhookBody {
#[serde(rename = "transactionId")]
pub id: String,
pub merchant_transaction_id: String,
pub amount: String,
pub currency: String,
pub status: ZenPaymentStatus,
}
#[derive(Debug, Clone, Deserialize)]
pub struct ZenWebhookSignature {
pub hash: String,
}
#[derive(Debug, Clone, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ZenWebhookObjectReference {
#[serde(rename = "type")]
pub transaction_type: ZenWebhookTxnType,
pub transaction_id: String,
pub merchant_transaction_id: String,
}
#[derive(Debug, Clone, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ZenWebhookEventType {
#[serde(rename = "type")]
pub transaction_type: ZenWebhookTxnType,
pub transaction_id: String,
pub status: ZenPaymentStatus,
}
#[derive(Debug, Clone, Deserialize)]
#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
pub enum ZenWebhookTxnType {
TrtPurchase,
TrtRefund,
#[serde(other)]
Unknown,
}
#[derive(Debug, Deserialize, Serialize)]
pub struct ZenErrorResponse {
pub error: Option<ZenErrorBody>,
pub message: Option<String>,
}
#[derive(Debug, Deserialize, Clone, Serialize)]
pub struct ZenErrorBody {
pub message: String,
pub code: String,
}
|
{
"crate": "hyperswitch_connectors",
"file": "crates/hyperswitch_connectors/src/connectors/zen/transformers.rs",
"file_size": null,
"is_async": null,
"is_pub": null,
"num_enums": 9,
"num_structs": 23,
"num_tables": null,
"score": null,
"total_crates": null
}
|
file_hyperswitch_connectors_-1971566405649292957
|
clm
|
file
|
// Repository: hyperswitch
// Crate: hyperswitch_connectors
// File: crates/hyperswitch_connectors/src/connectors/unified_authentication_service/transformers.rs
// Contains: 35 structs, 6 enums
use common_enums::{enums, MerchantCategoryCode};
use common_types::payments::MerchantCountryCode;
use common_utils::{ext_traits::OptionExt as _, types::FloatMajorUnit};
use hyperswitch_domain_models::{
router_data::{ConnectorAuthType, RouterData},
router_request_types::{
authentication::{AuthNFlowType, ChallengeParams},
unified_authentication_service::{
AuthenticationInfo, DynamicData, PostAuthenticationDetails, PreAuthenticationDetails,
TokenDetails, UasAuthenticationResponseData,
},
},
types::{
UasAuthenticationConfirmationRouterData, UasAuthenticationRouterData,
UasPostAuthenticationRouterData, UasPreAuthenticationRouterData,
},
};
use hyperswitch_interfaces::errors;
use masking::Secret;
use serde::{Deserialize, Serialize};
use time::PrimitiveDateTime;
use crate::types::ResponseRouterData;
//TODO: Fill the struct with respective fields
pub struct UnifiedAuthenticationServiceRouterData<T> {
pub amount: FloatMajorUnit, // The type of amount that a connector accepts, for example, String, i64, f64, etc.
pub router_data: T,
}
impl<T> From<(FloatMajorUnit, T)> for UnifiedAuthenticationServiceRouterData<T> {
fn from((amount, item): (FloatMajorUnit, T)) -> Self {
//Todo : use utils to convert the amount to the type of amount that a connector accepts
Self {
amount,
router_data: item,
}
}
}
use error_stack::ResultExt;
#[derive(Debug, Serialize)]
pub struct UnifiedAuthenticationServicePreAuthenticateRequest {
pub authenticate_by: String,
pub session_id: common_utils::id_type::AuthenticationId,
pub source_authentication_id: common_utils::id_type::AuthenticationId,
pub authentication_info: Option<AuthenticationInfo>,
pub service_details: Option<CtpServiceDetails>,
pub customer_details: Option<CustomerDetails>,
pub pmt_details: Option<PaymentDetails>,
pub auth_creds: UnifiedAuthenticationServiceAuthType,
pub transaction_details: Option<TransactionDetails>,
pub acquirer_details: Option<Acquirer>,
pub billing_address: Option<Address>,
}
#[derive(Debug, Serialize)]
pub struct UnifiedAuthenticationServiceAuthenticateConfirmationRequest {
pub authenticate_by: String,
pub source_authentication_id: common_utils::id_type::AuthenticationId,
pub auth_creds: UnifiedAuthenticationServiceAuthType,
pub x_src_flow_id: Option<String>,
pub transaction_amount: Option<FloatMajorUnit>,
pub transaction_currency: Option<enums::Currency>,
pub checkout_event_type: Option<String>,
pub checkout_event_status: Option<String>,
pub confirmation_status: Option<String>,
pub confirmation_reason: Option<String>,
pub confirmation_timestamp: Option<String>,
pub network_authorization_code: Option<String>,
pub network_transaction_identifier: Option<String>,
pub correlation_id: Option<String>,
pub merchant_transaction_id: Option<String>,
}
#[derive(Debug, Serialize, PartialEq, Deserialize)]
pub struct UnifiedAuthenticationServiceAuthenticateConfirmationResponse {
status: String,
}
impl<F, T>
TryFrom<
ResponseRouterData<
F,
UnifiedAuthenticationServiceAuthenticateConfirmationResponse,
T,
UasAuthenticationResponseData,
>,
> for RouterData<F, T, UasAuthenticationResponseData>
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: ResponseRouterData<
F,
UnifiedAuthenticationServiceAuthenticateConfirmationResponse,
T,
UasAuthenticationResponseData,
>,
) -> Result<Self, Self::Error> {
Ok(Self {
response: Ok(UasAuthenticationResponseData::Confirmation {}),
..item.data
})
}
}
#[derive(Default, Debug, Serialize, PartialEq)]
pub struct PaymentDetails {
pub pan: cards::CardNumber,
pub digital_card_id: Option<String>,
pub payment_data_type: Option<common_enums::PaymentMethodType>,
pub encrypted_src_card_details: Option<String>,
pub card_expiry_month: Secret<String>,
pub card_expiry_year: Secret<String>,
pub cardholder_name: Option<Secret<String>>,
pub card_token_number: Option<Secret<String>>,
pub account_type: Option<common_enums::PaymentMethodType>,
pub card_cvc: Option<Secret<String>>,
}
#[derive(Default, Clone, Debug, Serialize, Deserialize)]
pub struct TransactionDetails {
pub amount: FloatMajorUnit,
pub currency: enums::Currency,
pub date: Option<PrimitiveDateTime>,
pub pan_source: Option<String>,
pub protection_type: Option<String>,
pub entry_mode: Option<String>,
pub transaction_type: Option<String>,
pub otp_value: Option<String>,
pub three_ds_data: Option<ThreeDSData>,
pub message_category: Option<MessageCategory>,
}
#[derive(Clone, Debug, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum MessageCategory {
Payment,
NonPayment,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ThreeDSData {
pub preferred_protocol_version: common_utils::types::SemanticVersion,
pub threeds_method_comp_ind: api_models::payments::ThreeDsCompletionIndicator,
}
#[derive(Default, Clone, Debug, Serialize, Deserialize, PartialEq)]
pub struct Acquirer {
pub acquirer_merchant_id: Option<String>,
pub acquirer_bin: Option<String>,
pub acquirer_country_code: Option<String>,
}
#[derive(Default, Debug, Serialize, PartialEq, Clone, Deserialize)]
pub struct BrowserInfo {
pub color_depth: Option<u8>,
pub java_enabled: Option<bool>,
pub java_script_enabled: Option<bool>,
pub language: Option<String>,
pub screen_height: Option<u32>,
pub screen_width: Option<u32>,
pub time_zone: Option<i32>,
pub ip_address: Option<std::net::IpAddr>,
pub accept_header: Option<String>,
pub user_agent: Option<String>,
pub os_type: Option<String>,
pub os_version: Option<String>,
pub device_model: Option<String>,
pub accept_language: Option<String>,
}
#[derive(Default, Debug, Serialize, PartialEq)]
pub struct CtpServiceDetails {
pub service_session_ids: Option<ServiceSessionIds>,
pub merchant_details: Option<MerchantDetails>,
}
#[derive(Default, Debug, Serialize, PartialEq)]
pub struct ServiceSessionIds {
pub client_id: Option<String>,
pub service_id: Option<String>,
pub correlation_id: Option<String>,
pub client_reference_id: Option<String>,
pub merchant_transaction_id: Option<String>,
pub x_src_flow_id: Option<String>,
}
#[derive(Default, Debug, Serialize, PartialEq)]
pub struct MerchantDetails {
pub merchant_id: Option<String>,
pub merchant_name: Option<String>,
pub merchant_category_code: Option<MerchantCategoryCode>,
pub configuration_id: Option<String>,
pub endpoint_prefix: Option<String>,
pub three_ds_requestor_url: Option<String>,
pub three_ds_requestor_id: Option<String>,
pub three_ds_requestor_name: Option<String>,
pub merchant_country_code: Option<MerchantCountryCode>,
pub notification_url: Option<url::Url>,
}
#[derive(Default, Clone, Debug, Serialize, PartialEq, Deserialize)]
pub struct Address {
pub city: Option<String>,
pub country: Option<common_enums::CountryAlpha2>,
pub line1: Option<Secret<String>>,
pub line2: Option<Secret<String>>,
pub line3: Option<Secret<String>>,
pub post_code: Option<Secret<String>>,
pub state: Option<Secret<String>>,
}
#[derive(Default, Clone, Debug, Serialize, PartialEq, Deserialize)]
pub struct CustomerDetails {
pub name: Secret<String>,
pub email: Option<Secret<String>>,
pub phone_number: Option<Secret<String>>,
pub customer_id: String,
#[serde(rename = "type")]
pub customer_type: Option<String>,
pub billing_address: Address,
pub shipping_address: Address,
pub wallet_account_id: Secret<String>,
pub email_hash: Secret<String>,
pub country_code: String,
pub national_identifier: String,
}
#[derive(Default, Debug, Serialize, Eq, PartialEq)]
pub struct UnifiedAuthenticationServiceCard {
number: cards::CardNumber,
expiry_month: Secret<String>,
expiry_year: Secret<String>,
cvc: Secret<String>,
complete: bool,
}
impl TryFrom<&UnifiedAuthenticationServiceRouterData<&UasPreAuthenticationRouterData>>
for UnifiedAuthenticationServicePreAuthenticateRequest
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: &UnifiedAuthenticationServiceRouterData<&UasPreAuthenticationRouterData>,
) -> Result<Self, Self::Error> {
let authentication_id = item.router_data.authentication_id.clone().ok_or(
errors::ConnectorError::MissingRequiredField {
field_name: "authentication_id",
},
)?;
let authentication_info = item.router_data.request.authentication_info.clone();
let auth_type =
UnifiedAuthenticationServiceAuthType::try_from(&item.router_data.connector_auth_type)?;
Ok(Self {
authenticate_by: item.router_data.connector.clone(),
session_id: authentication_id.clone(),
source_authentication_id: authentication_id,
authentication_info,
service_details: Some(CtpServiceDetails {
service_session_ids: item.router_data.request.service_details.clone().map(
|service_details| ServiceSessionIds {
client_id: None,
service_id: None,
correlation_id: service_details
.service_session_ids
.clone()
.and_then(|service_session_ids| service_session_ids.correlation_id),
client_reference_id: None,
merchant_transaction_id: service_details
.service_session_ids
.clone()
.and_then(|service_session_ids| {
service_session_ids.merchant_transaction_id
}),
x_src_flow_id: service_details
.service_session_ids
.clone()
.and_then(|service_session_ids| service_session_ids.x_src_flow_id),
},
),
merchant_details: None,
}),
customer_details: None,
pmt_details: None,
auth_creds: auth_type,
acquirer_details: None,
billing_address: None,
transaction_details: Some(TransactionDetails {
amount: item.amount,
currency: item
.router_data
.request
.transaction_details
.clone()
.ok_or(errors::ConnectorError::MissingRequiredField {
field_name: "transaction_details",
})?
.currency
.ok_or(errors::ConnectorError::MissingRequiredField {
field_name: "currency",
})?,
date: None,
pan_source: None,
protection_type: None,
entry_mode: None,
transaction_type: None,
otp_value: None,
three_ds_data: None,
message_category: None,
}),
})
}
}
#[derive(Serialize, Deserialize, Debug, Clone)]
#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
pub enum UnifiedAuthenticationServicePreAuthenticateStatus {
ACKSUCCESS,
ACKFAILURE,
}
#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct UnifiedAuthenticationServicePreAuthenticateResponse {
status: UnifiedAuthenticationServicePreAuthenticateStatus,
pub eligibility: Option<Eligibility>,
}
impl<F, T>
TryFrom<
ResponseRouterData<
F,
UnifiedAuthenticationServicePreAuthenticateResponse,
T,
UasAuthenticationResponseData,
>,
> for RouterData<F, T, UasAuthenticationResponseData>
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: ResponseRouterData<
F,
UnifiedAuthenticationServicePreAuthenticateResponse,
T,
UasAuthenticationResponseData,
>,
) -> Result<Self, Self::Error> {
let three_ds_eligibility_response = if let Some(Eligibility::ThreeDsEligibilityResponse {
three_ds_eligibility_response,
}) = item.response.eligibility
{
Some(three_ds_eligibility_response)
} else {
None
};
let max_acs_protocol_version = three_ds_eligibility_response
.as_ref()
.and_then(|response| response.get_max_acs_protocol_version_if_available());
let maximum_supported_3ds_version = max_acs_protocol_version
.as_ref()
.map(|acs_protocol_version| acs_protocol_version.version.clone());
let three_ds_method_data =
three_ds_eligibility_response
.as_ref()
.and_then(|three_ds_eligibility_response| {
three_ds_eligibility_response
.three_ds_method_data_form
.as_ref()
.and_then(|form| form.three_ds_method_data.clone())
});
let three_ds_method_url = max_acs_protocol_version
.and_then(|acs_protocol_version| acs_protocol_version.three_ds_method_url);
Ok(Self {
response: Ok(UasAuthenticationResponseData::PreAuthentication {
authentication_details: PreAuthenticationDetails {
threeds_server_transaction_id: three_ds_eligibility_response
.as_ref()
.map(|response| response.three_ds_server_trans_id.clone()),
maximum_supported_3ds_version: maximum_supported_3ds_version.clone(),
connector_authentication_id: three_ds_eligibility_response
.as_ref()
.map(|response| response.three_ds_server_trans_id.clone()),
three_ds_method_data,
three_ds_method_url,
message_version: maximum_supported_3ds_version,
connector_metadata: None,
directory_server_id: three_ds_eligibility_response
.and_then(|response| response.directory_server_id),
},
}),
..item.data
})
}
}
#[derive(Debug, Serialize)]
pub struct UnifiedAuthenticationServicePostAuthenticateRequest {
pub authenticate_by: String,
pub source_authentication_id: common_utils::id_type::AuthenticationId,
pub auth_creds: ConnectorAuthType,
}
#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct UnifiedAuthenticationServicePostAuthenticateResponse {
pub authentication_details: AuthenticationDetails,
}
#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct AuthenticationDetails {
pub eci: Option<String>,
pub token_details: Option<UasTokenDetails>,
pub dynamic_data_details: Option<UasDynamicData>,
pub trans_status: Option<common_enums::TransactionStatus>,
}
#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct UasTokenDetails {
pub payment_token: cards::CardNumber,
pub payment_account_reference: String,
pub token_expiration_month: Secret<String>,
pub token_expiration_year: Secret<String>,
}
#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct UasDynamicData {
pub dynamic_data_value: Option<Secret<String>>,
pub dynamic_data_type: Option<String>,
pub ds_trans_id: Option<String>,
}
impl TryFrom<&UasPostAuthenticationRouterData>
for UnifiedAuthenticationServicePostAuthenticateRequest
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(item: &UasPostAuthenticationRouterData) -> Result<Self, Self::Error> {
Ok(Self {
authenticate_by: item.connector.clone(),
source_authentication_id: item.authentication_id.clone().ok_or(
errors::ConnectorError::MissingRequiredField {
field_name: "authentication_id",
},
)?,
auth_creds: item.connector_auth_type.clone(),
})
}
}
impl<F, T>
TryFrom<
ResponseRouterData<
F,
UnifiedAuthenticationServicePostAuthenticateResponse,
T,
UasAuthenticationResponseData,
>,
> for RouterData<F, T, UasAuthenticationResponseData>
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: ResponseRouterData<
F,
UnifiedAuthenticationServicePostAuthenticateResponse,
T,
UasAuthenticationResponseData,
>,
) -> Result<Self, Self::Error> {
Ok(Self {
response: Ok(UasAuthenticationResponseData::PostAuthentication {
authentication_details: PostAuthenticationDetails {
eci: item.response.authentication_details.eci,
token_details: item.response.authentication_details.token_details.map(
|token_details| TokenDetails {
payment_token: token_details.payment_token,
payment_account_reference: token_details.payment_account_reference,
token_expiration_month: token_details.token_expiration_month,
token_expiration_year: token_details.token_expiration_year,
},
),
dynamic_data_details: item
.response
.authentication_details
.dynamic_data_details
.map(|dynamic_data| DynamicData {
dynamic_data_value: dynamic_data.dynamic_data_value,
dynamic_data_type: dynamic_data.dynamic_data_type,
ds_trans_id: dynamic_data.ds_trans_id,
}),
trans_status: item.response.authentication_details.trans_status,
challenge_cancel: None,
challenge_code_reason: None,
},
}),
..item.data
})
}
}
//TODO: Fill the struct with respective fields
#[derive(Default, Debug, Serialize, Deserialize, PartialEq, Clone)]
pub struct UnifiedAuthenticationServiceErrorResponse {
pub error: String,
}
impl TryFrom<&UnifiedAuthenticationServiceRouterData<&UasAuthenticationConfirmationRouterData>>
for UnifiedAuthenticationServiceAuthenticateConfirmationRequest
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: &UnifiedAuthenticationServiceRouterData<&UasAuthenticationConfirmationRouterData>,
) -> Result<Self, Self::Error> {
let authentication_id = item.router_data.authentication_id.clone().ok_or(
errors::ConnectorError::MissingRequiredField {
field_name: "authentication_id",
},
)?;
let auth_type =
UnifiedAuthenticationServiceAuthType::try_from(&item.router_data.connector_auth_type)?;
Ok(Self {
authenticate_by: item.router_data.connector.clone(),
auth_creds: auth_type,
source_authentication_id: authentication_id,
x_src_flow_id: item.router_data.request.x_src_flow_id.clone(),
transaction_amount: Some(item.amount),
transaction_currency: Some(item.router_data.request.transaction_currency),
checkout_event_type: item.router_data.request.checkout_event_type.clone(),
checkout_event_status: item.router_data.request.checkout_event_status.clone(),
confirmation_status: item.router_data.request.confirmation_status.clone(),
confirmation_reason: item.router_data.request.confirmation_reason.clone(),
confirmation_timestamp: item.router_data.request.confirmation_timestamp.clone(),
network_authorization_code: item.router_data.request.network_authorization_code.clone(),
network_transaction_identifier: item
.router_data
.request
.network_transaction_identifier
.clone(),
correlation_id: item.router_data.request.correlation_id.clone(),
merchant_transaction_id: item.router_data.request.merchant_transaction_id.clone(),
})
}
}
// ThreeDs request
impl TryFrom<&UasPreAuthenticationRouterData>
for UnifiedAuthenticationServicePreAuthenticateRequest
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(item: &UasPreAuthenticationRouterData) -> Result<Self, Self::Error> {
let auth_type = UnifiedAuthenticationServiceAuthType::try_from(&item.connector_auth_type)?;
let authentication_id =
item.authentication_id
.clone()
.ok_or(errors::ConnectorError::MissingRequiredField {
field_name: "authentication_id",
})?;
let merchant_data = item.request.merchant_details.clone().ok_or(
errors::ConnectorError::MissingRequiredField {
field_name: "merchant_details",
},
)?;
let merchant_details = MerchantDetails {
merchant_id: merchant_data.merchant_id,
merchant_name: merchant_data.merchant_name,
merchant_category_code: merchant_data.merchant_category_code,
merchant_country_code: merchant_data.merchant_country_code.clone(),
endpoint_prefix: merchant_data.endpoint_prefix,
three_ds_requestor_url: merchant_data.three_ds_requestor_url,
three_ds_requestor_id: merchant_data.three_ds_requestor_id,
three_ds_requestor_name: merchant_data.three_ds_requestor_name,
configuration_id: None,
notification_url: merchant_data.notification_url,
};
let acquirer = Acquirer {
acquirer_bin: item.request.acquirer_bin.clone(),
acquirer_merchant_id: item.request.acquirer_merchant_id.clone(),
acquirer_country_code: merchant_data
.merchant_country_code
.map(|code| code.get_country_code()),
};
let service_details = Some(CtpServiceDetails {
service_session_ids: None,
merchant_details: Some(merchant_details),
});
let billing_address = item
.request
.billing_address
.clone()
.map(|address_wrap| Address {
city: address_wrap
.address
.clone()
.and_then(|address| address.city),
country: address_wrap
.address
.clone()
.and_then(|address| address.country),
line1: address_wrap
.address
.clone()
.and_then(|address| address.line1),
line2: address_wrap
.address
.clone()
.and_then(|address| address.line2),
line3: address_wrap
.address
.clone()
.and_then(|address| address.line3),
post_code: address_wrap.address.clone().and_then(|address| address.zip),
state: address_wrap.address.and_then(|address| address.state),
});
Ok(Self {
authenticate_by: item.connector.clone(),
session_id: authentication_id.clone(),
source_authentication_id: authentication_id,
authentication_info: None,
service_details,
customer_details: None,
pmt_details: item
.request
.payment_details
.clone()
.map(|details| PaymentDetails {
pan: details.pan,
digital_card_id: details.digital_card_id,
payment_data_type: details.payment_data_type,
encrypted_src_card_details: details.encrypted_src_card_details,
cardholder_name: details.cardholder_name,
card_token_number: details.card_token_number,
account_type: details.account_type,
card_expiry_month: details.card_expiry_month,
card_expiry_year: details.card_expiry_year,
card_cvc: details.card_cvc,
}),
auth_creds: auth_type,
transaction_details: None,
acquirer_details: Some(acquirer),
billing_address,
})
}
}
#[derive(Debug, Serialize, PartialEq)]
#[serde(tag = "auth_type")]
pub enum UnifiedAuthenticationServiceAuthType {
HeaderKey {
api_key: Secret<String>,
},
CertificateAuth {
certificate: Secret<String>,
private_key: Secret<String>,
},
SignatureKey {
api_key: Secret<String>,
key1: Secret<String>,
api_secret: Secret<String>,
},
NoKey,
}
impl TryFrom<&ConnectorAuthType> for UnifiedAuthenticationServiceAuthType {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(auth_type: &ConnectorAuthType) -> Result<Self, Self::Error> {
match auth_type {
ConnectorAuthType::HeaderKey { api_key } => Ok(Self::HeaderKey {
api_key: api_key.clone(),
}),
ConnectorAuthType::SignatureKey {
api_key,
key1,
api_secret,
} => Ok(Self::SignatureKey {
api_key: api_key.clone(),
key1: key1.clone(),
api_secret: api_secret.clone(),
}),
ConnectorAuthType::CertificateAuth {
certificate,
private_key,
} => Ok(Self::CertificateAuth {
certificate: certificate.clone(),
private_key: private_key.clone(),
}),
ConnectorAuthType::NoKey => Ok(Self::NoKey),
_ => Err(errors::ConnectorError::FailedToObtainAuthType.into()),
}
}
}
#[derive(Serialize, Deserialize, Debug, Clone)]
#[serde(tag = "eligibility")]
pub enum Eligibility {
None,
TokenEligibilityResponse {
token_eligibility_response: Box<TokenEligibilityResponse>,
},
ThreeDsEligibilityResponse {
three_ds_eligibility_response: Box<ThreeDsEligibilityResponse>,
},
}
#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct TokenEligibilityResponse {
pub network_request_id: Option<String>,
pub network_client_id: Option<String>,
pub nonce: Option<String>,
pub payment_method_details: Option<PaymentMethodDetails>,
pub network_pan_enrollment_id: Option<String>,
pub ignore_00_field: Option<String>,
pub token_details: Option<TokenDetails>,
pub network_provisioned_token_id: Option<String>,
}
#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct PaymentMethodDetails {
pub ignore_01_field: String,
pub cvv2_printed_ind: String,
pub last4: String,
pub exp_date_printed_ind: String,
pub payment_account_reference: String,
pub exp_year: String,
pub exp_month: String,
pub verification_results: VerificationResults,
pub enabled_services: EnabledServices,
}
#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct VerificationResults {
pub address_verification_code: String,
pub cvv2_verification_code: String,
}
#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct EnabledServices {
pub merchant_presented_qr: String,
}
#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct ThreeDsEligibilityResponse {
pub three_ds_server_trans_id: String,
pub scheme_id: Option<String>,
pub acs_protocol_versions: Option<Vec<AcsProtocolVersion>>,
pub ds_protocol_versions: Option<Vec<String>>,
pub three_ds_method_data_form: Option<ThreeDsMethodDataForm>,
pub three_ds_method_data: Option<ThreeDsMethodData>,
pub error_details: Option<String>,
pub is_card_found_in_2x_ranges: bool,
pub directory_server_id: Option<String>,
}
impl ThreeDsEligibilityResponse {
pub fn get_max_acs_protocol_version_if_available(&self) -> Option<AcsProtocolVersion> {
let max_acs_version =
self.acs_protocol_versions
.as_ref()
.and_then(|acs_protocol_versions| {
acs_protocol_versions
.iter()
.max_by_key(|acs_protocol_versions| acs_protocol_versions.version.clone())
});
max_acs_version.cloned()
}
}
#[derive(Clone, Serialize, Deserialize, Debug)]
pub struct AcsProtocolVersion {
pub version: common_utils::types::SemanticVersion,
pub acs_info_ind: Vec<String>,
pub three_ds_method_url: Option<String>,
pub supported_msg_ext: Option<Vec<SupportedMsgExt>>,
}
#[derive(Clone, Serialize, Deserialize, Debug)]
pub struct SupportedMsgExt {
pub id: String,
pub version: String,
}
#[derive(Clone, Serialize, Deserialize, Debug, Default)]
pub struct ThreeDsMethodDataForm {
pub three_ds_method_data: Option<String>,
}
#[derive(Default, Clone, Serialize, Deserialize, Debug)]
pub struct ThreeDsMethodData {
pub three_ds_method_notification_url: String,
pub server_transaction_id: String,
}
#[derive(Serialize, Debug)]
pub struct UnifiedAuthenticationServiceAuthenticateRequest {
pub authenticate_by: String,
pub source_authentication_id: common_utils::id_type::AuthenticationId,
pub transaction_details: TransactionDetails,
pub device_details: DeviceDetails,
pub customer_details: Option<CustomerDetails>,
pub auth_creds: UnifiedAuthenticationServiceAuthType,
}
#[derive(Default, Debug, Serialize, PartialEq)]
pub struct ServiceDetails {
pub service_session_ids: Option<ServiceSessionIds>,
pub merchant_details: Option<MerchantDetails>,
}
#[derive(Serialize, Debug, Clone, Deserialize)]
#[serde(untagged)]
pub enum UnifiedAuthenticationServiceAuthenticateResponse {
Success(Box<ThreeDsResponseData>),
Failure(UnifiedAuthenticationServiceErrorResponse),
}
#[derive(Serialize, Debug, Clone, Deserialize)]
pub struct ThreeDsResponseData {
pub three_ds_auth_response: ThreeDsAuthDetails,
}
#[derive(Serialize, Debug, Clone, Deserialize)]
pub struct ThreeDsAuthDetails {
pub three_ds_server_trans_id: String,
pub acs_trans_id: String,
pub acs_reference_number: String,
pub acs_operator_id: Option<String>,
pub ds_reference_number: Option<String>,
pub ds_trans_id: String,
pub sdk_trans_id: Option<String>,
pub trans_status: common_enums::TransactionStatus,
pub acs_challenge_mandated: Option<ACSChallengeMandatedEnum>,
pub message_type: Option<String>,
pub message_version: Option<String>,
pub acs_url: Option<url::Url>,
pub challenge_request: Option<String>,
pub challenge_request_key: Option<String>,
pub acs_signed_content: Option<String>,
pub authentication_value: Option<Secret<String>>,
pub eci: Option<String>,
pub challenge_code: Option<String>,
pub challenge_cancel: Option<String>,
pub challenge_code_reason: Option<String>,
pub message_extension: Option<common_utils::pii::SecretSerdeValue>,
}
#[derive(Debug, Serialize, Clone, Copy, Deserialize)]
pub enum ACSChallengeMandatedEnum {
/// Challenge is mandated
Y,
/// Challenge is not mandated
N,
}
#[derive(Clone, Serialize, Debug)]
pub struct DeviceDetails {
pub device_channel: api_models::payments::DeviceChannel,
pub browser_info: Option<BrowserInfo>,
pub sdk_info: Option<api_models::payments::SdkInformation>,
}
impl TryFrom<&UnifiedAuthenticationServiceRouterData<&UasAuthenticationRouterData>>
for UnifiedAuthenticationServiceAuthenticateRequest
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: &UnifiedAuthenticationServiceRouterData<&UasAuthenticationRouterData>,
) -> Result<Self, Self::Error> {
let authentication_id = item.router_data.authentication_id.clone().ok_or(
errors::ConnectorError::MissingRequiredField {
field_name: "authentication_id",
},
)?;
let browser_info =
if let Some(browser_details) = item.router_data.request.browser_details.clone() {
BrowserInfo {
color_depth: browser_details.color_depth,
java_enabled: browser_details.java_enabled,
java_script_enabled: browser_details.java_script_enabled,
language: browser_details.language,
screen_height: browser_details.screen_height,
screen_width: browser_details.screen_width,
time_zone: browser_details.time_zone,
ip_address: browser_details.ip_address,
accept_header: browser_details.accept_header,
user_agent: browser_details.user_agent,
os_type: browser_details.os_type,
os_version: browser_details.os_version,
device_model: browser_details.device_model,
accept_language: browser_details.accept_language,
}
} else {
BrowserInfo::default()
};
let three_ds_data = ThreeDSData {
preferred_protocol_version: item
.router_data
.request
.pre_authentication_data
.message_version
.clone(),
threeds_method_comp_ind: item.router_data.request.threeds_method_comp_ind.clone(),
};
let device_details = DeviceDetails {
device_channel: item
.router_data
.request
.transaction_details
.device_channel
.clone()
.ok_or(errors::ConnectorError::MissingRequiredField {
field_name: "device_channel",
})?,
browser_info: Some(browser_info),
sdk_info: item.router_data.request.sdk_information.clone(),
};
let message_category = item.router_data.request.transaction_details.message_category.clone().map(|category| match category {
hyperswitch_domain_models::router_request_types::authentication::MessageCategory::Payment => MessageCategory::Payment ,
hyperswitch_domain_models::router_request_types::authentication::MessageCategory::NonPayment => MessageCategory::NonPayment,
});
let transaction_details = TransactionDetails {
amount: item.amount,
currency: item
.router_data
.request
.transaction_details
.currency
.get_required_value("currency")
.change_context(errors::ConnectorError::InSufficientBalanceInPaymentMethod)?,
date: None,
pan_source: None,
protection_type: None,
entry_mode: None,
transaction_type: None,
otp_value: None,
three_ds_data: Some(three_ds_data),
message_category,
};
let auth_type =
UnifiedAuthenticationServiceAuthType::try_from(&item.router_data.connector_auth_type)?;
Ok(Self {
authenticate_by: item.router_data.connector.clone(),
source_authentication_id: authentication_id,
transaction_details,
auth_creds: auth_type,
device_details,
customer_details: None,
})
}
}
impl<F, T>
TryFrom<
ResponseRouterData<
F,
UnifiedAuthenticationServiceAuthenticateResponse,
T,
UasAuthenticationResponseData,
>,
> for RouterData<F, T, UasAuthenticationResponseData>
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: ResponseRouterData<
F,
UnifiedAuthenticationServiceAuthenticateResponse,
T,
UasAuthenticationResponseData,
>,
) -> Result<Self, Self::Error> {
let response = match item.response {
UnifiedAuthenticationServiceAuthenticateResponse::Success(auth_response) => {
let authn_flow_type = match auth_response.three_ds_auth_response.trans_status {
common_enums::TransactionStatus::ChallengeRequired => {
AuthNFlowType::Challenge(Box::new(ChallengeParams {
acs_url: auth_response.three_ds_auth_response.acs_url.clone(),
challenge_request: auth_response
.three_ds_auth_response
.challenge_request,
challenge_request_key: auth_response
.three_ds_auth_response
.challenge_request_key,
acs_reference_number: Some(
auth_response.three_ds_auth_response.acs_reference_number,
),
acs_trans_id: Some(auth_response.three_ds_auth_response.acs_trans_id),
three_dsserver_trans_id: Some(
auth_response
.three_ds_auth_response
.three_ds_server_trans_id,
),
acs_signed_content: auth_response
.three_ds_auth_response
.acs_signed_content,
}))
}
_ => AuthNFlowType::Frictionless,
};
Ok(UasAuthenticationResponseData::Authentication {
authentication_details: hyperswitch_domain_models::router_request_types::unified_authentication_service::AuthenticationDetails {
authn_flow_type,
authentication_value: auth_response.three_ds_auth_response.authentication_value,
trans_status: auth_response.three_ds_auth_response.trans_status,
connector_metadata: None,
ds_trans_id: Some(auth_response.three_ds_auth_response.ds_trans_id),
eci: auth_response.three_ds_auth_response.eci,
challenge_code: auth_response.three_ds_auth_response.challenge_code,
challenge_cancel: auth_response.three_ds_auth_response.challenge_cancel,
challenge_code_reason: auth_response.three_ds_auth_response.challenge_code_reason,
message_extension: auth_response.three_ds_auth_response.message_extension,
},
})
}
UnifiedAuthenticationServiceAuthenticateResponse::Failure(error_response) => {
Err(hyperswitch_domain_models::router_data::ErrorResponse {
code: hyperswitch_interfaces::consts::NO_ERROR_CODE.to_string(),
message: error_response.error.clone(),
reason: None,
status_code: item.http_code,
attempt_status: None,
connector_transaction_id: None,
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
connector_metadata: None,
})
}
};
Ok(Self {
response,
..item.data
})
}
}
|
{
"crate": "hyperswitch_connectors",
"file": "crates/hyperswitch_connectors/src/connectors/unified_authentication_service/transformers.rs",
"file_size": null,
"is_async": null,
"is_pub": null,
"num_enums": 6,
"num_structs": 35,
"num_tables": null,
"score": null,
"total_crates": null
}
|
file_hyperswitch_connectors_-1426619501499976843
|
clm
|
file
|
// Repository: hyperswitch
// Crate: hyperswitch_connectors
// File: crates/hyperswitch_connectors/src/connectors/redsys/transformers.rs
// Contains: 30 structs, 6 enums
use base64::Engine;
use common_enums::enums;
use common_utils::{
consts::BASE64_ENGINE,
crypto::{EncodeMessage, SignMessage},
ext_traits::{Encode, ValueExt},
types::StringMinorUnit,
};
use error_stack::ResultExt;
use hyperswitch_domain_models::{
address::Address,
payment_method_data::PaymentMethodData,
router_data::{ConnectorAuthType, ErrorResponse, RouterData},
router_flow_types::refunds::{Execute, RSync},
router_request_types::{
BrowserInformation, CompleteAuthorizeData, PaymentsAuthorizeData, PaymentsCancelData,
PaymentsCaptureData, PaymentsPreProcessingData, PaymentsSyncData, ResponseId,
},
router_response_types::{PaymentsResponseData, RedirectForm, RefundsResponseData},
types::{
PaymentsAuthorizeRouterData, PaymentsCancelRouterData, PaymentsCaptureRouterData,
PaymentsCompleteAuthorizeRouterData, PaymentsPreProcessingRouterData,
PaymentsSyncRouterData, RefundSyncRouterData, RefundsRouterData,
},
};
use hyperswitch_interfaces::errors;
use masking::{ExposeInterface, PeekInterface, Secret};
use serde::{Deserialize, Serialize};
use crate::{
types::{RefundsResponseRouterData, ResponseRouterData},
utils::{
self as connector_utils, AddressDetailsData, BrowserInformationData, CardData,
PaymentsAuthorizeRequestData, PaymentsCompleteAuthorizeRequestData,
PaymentsPreProcessingRequestData, RouterData as _,
},
};
type Error = error_stack::Report<errors::ConnectorError>;
const DS_VERSION: &str = "0.0";
const SIGNATURE_VERSION: &str = "HMAC_SHA256_V1";
const XMLNS_WEB_URL: &str = "http://webservices.apl02.redsys.es";
pub const REDSYS_SOAP_ACTION: &str = "consultaOperaciones";
// Specifies the type of transaction for XML requests
pub mod transaction_type {
pub const PAYMENT: &str = "0";
pub const PREAUTHORIZATION: &str = "1";
pub const CONFIRMATION: &str = "2";
pub const REFUND: &str = "3";
pub const CANCELLATION: &str = "9";
}
pub struct RedsysRouterData<T> {
pub amount: StringMinorUnit,
pub currency: api_models::enums::Currency,
pub router_data: T,
}
impl<T> From<(StringMinorUnit, T, api_models::enums::Currency)> for RedsysRouterData<T> {
fn from((amount, item, currency): (StringMinorUnit, T, api_models::enums::Currency)) -> Self {
Self {
amount,
currency,
router_data: item,
}
}
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
pub struct PaymentsRequest {
ds_merchant_emv3ds: Option<EmvThreedsData>,
ds_merchant_transactiontype: RedsysTransactionType,
ds_merchant_currency: String,
ds_merchant_pan: cards::CardNumber,
ds_merchant_merchantcode: Secret<String>,
ds_merchant_terminal: Secret<String>,
ds_merchant_order: String,
ds_merchant_amount: StringMinorUnit,
ds_merchant_expirydate: Secret<String>,
ds_merchant_cvv2: Secret<String>,
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct EmvThreedsData {
three_d_s_info: RedsysThreeDsInfo,
protocol_version: Option<String>,
browser_accept_header: Option<String>,
browser_user_agent: Option<String>,
browser_java_enabled: Option<bool>,
browser_javascript_enabled: Option<bool>,
browser_language: Option<String>,
browser_color_depth: Option<String>,
browser_screen_height: Option<String>,
browser_screen_width: Option<String>,
browser_t_z: Option<String>,
browser_i_p: Option<Secret<String, common_utils::pii::IpAddress>>,
three_d_s_server_trans_i_d: Option<String>,
notification_u_r_l: Option<String>,
three_d_s_comp_ind: Option<ThreeDSCompInd>,
cres: Option<String>,
#[serde(flatten)]
billing_data: Option<BillingData>,
#[serde(flatten)]
shipping_data: Option<ShippingData>,
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct BillingData {
bill_addr_city: Option<String>,
bill_addr_country: Option<String>,
bill_addr_line1: Option<Secret<String>>,
bill_addr_line2: Option<Secret<String>>,
bill_addr_line3: Option<Secret<String>>,
bill_addr_postal_code: Option<Secret<String>>,
bill_addr_state: Option<Secret<String>>,
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ShippingData {
ship_addr_city: Option<String>,
ship_addr_country: Option<String>,
ship_addr_line1: Option<Secret<String>>,
ship_addr_line2: Option<Secret<String>>,
ship_addr_line3: Option<Secret<String>>,
ship_addr_postal_code: Option<Secret<String>>,
ship_addr_state: Option<Secret<String>>,
}
impl EmvThreedsData {
pub fn new(three_d_s_info: RedsysThreeDsInfo) -> Self {
Self {
three_d_s_info,
protocol_version: None,
browser_accept_header: None,
browser_user_agent: None,
browser_java_enabled: None,
browser_javascript_enabled: None,
browser_language: None,
browser_color_depth: None,
browser_screen_height: None,
browser_screen_width: None,
browser_t_z: None,
browser_i_p: None,
three_d_s_server_trans_i_d: None,
notification_u_r_l: None,
three_d_s_comp_ind: None,
cres: None,
billing_data: None,
shipping_data: None,
}
}
pub fn add_browser_data(mut self, browser_info: BrowserInformation) -> Result<Self, Error> {
self.browser_accept_header = Some(browser_info.get_accept_header()?);
self.browser_user_agent = Some(browser_info.get_user_agent()?);
self.browser_java_enabled = Some(browser_info.get_java_enabled()?);
self.browser_javascript_enabled = browser_info.get_java_script_enabled().ok();
self.browser_language = Some(browser_info.get_language()?);
self.browser_color_depth = Some(browser_info.get_color_depth()?.to_string());
self.browser_screen_height = Some(browser_info.get_screen_height()?.to_string());
self.browser_screen_width = Some(browser_info.get_screen_width()?.to_string());
self.browser_t_z = Some(browser_info.get_time_zone()?.to_string());
self.browser_i_p = Some(browser_info.get_ip_address()?);
Ok(self)
}
pub fn set_three_d_s_server_trans_i_d(mut self, three_d_s_server_trans_i_d: String) -> Self {
self.three_d_s_server_trans_i_d = Some(three_d_s_server_trans_i_d);
self
}
pub fn set_protocol_version(mut self, protocol_version: String) -> Self {
self.protocol_version = Some(protocol_version);
self
}
pub fn set_notification_u_r_l(mut self, notification_u_r_l: String) -> Self {
self.notification_u_r_l = Some(notification_u_r_l);
self
}
pub fn set_three_d_s_comp_ind(mut self, three_d_s_comp_ind: ThreeDSCompInd) -> Self {
self.three_d_s_comp_ind = Some(three_d_s_comp_ind);
self
}
pub fn set_three_d_s_cres(mut self, cres: String) -> Self {
self.cres = Some(cres);
self
}
fn get_state_code(state: Secret<String>) -> Result<Secret<String>, Error> {
let state = connector_utils::normalize_string(state.expose())
.change_context(errors::ConnectorError::RequestEncodingFailed)?;
let addr_state_value = if state.len() > 3 {
let addr_state = match state.as_str() {
"acoruna" | "lacoruna" | "esc" => Ok("C"),
"alacant" | "esa" | "alicante" => Ok("A"),
"albacete" | "esab" => Ok("AB"),
"almeria" | "esal" => Ok("AL"),
"andalucia" | "esan" => Ok("AN"),
"araba" | "esvi" => Ok("VI"),
"aragon" | "esar" => Ok("AR"),
"asturias" | "eso" => Ok("O"),
"asturiasprincipadode" | "principadodeasturias" | "esas" => Ok("AS"),
"badajoz" | "esba" => Ok("BA"),
"barcelona" | "esb" => Ok("B"),
"bizkaia" | "esbi" => Ok("BI"),
"burgos" | "esbu" => Ok("BU"),
"canarias" | "escn" => Ok("CN"),
"cantabria" | "ess" => Ok("S"),
"castello" | "escs" => Ok("CS"),
"castellon" => Ok("C"),
"castillayleon" | "escl" => Ok("CL"),
"castillalamancha" | "escm" => Ok("CM"),
"cataluna" | "catalunya" | "esct" => Ok("CT"),
"ceuta" | "esce" => Ok("CE"),
"ciudadreal" | "escr" | "ciudad" => Ok("CR"),
"cuenca" | "escu" => Ok("CU"),
"caceres" | "escc" => Ok("CC"),
"cadiz" | "esca" => Ok("CA"),
"cordoba" | "esco" => Ok("CO"),
"euskalherria" | "espv" => Ok("PV"),
"extremadura" | "esex" => Ok("EX"),
"galicia" | "esga" => Ok("GA"),
"gipuzkoa" | "esss" => Ok("SS"),
"girona" | "esgi" | "gerona" => Ok("GI"),
"granada" | "esgr" => Ok("GR"),
"guadalajara" | "esgu" => Ok("GU"),
"huelva" | "esh" => Ok("H"),
"huesca" | "eshu" => Ok("HU"),
"illesbalears" | "islasbaleares" | "espm" => Ok("PM"),
"esib" => Ok("IB"),
"jaen" | "esj" => Ok("J"),
"larioja" | "eslo" => Ok("LO"),
"esri" => Ok("RI"),
"laspalmas" | "palmas" | "esgc" => Ok("GC"),
"leon" => Ok("LE"),
"lleida" | "lerida" | "esl" => Ok("L"),
"lugo" | "eslu" => Ok("LU"),
"madrid" | "esm" => Ok("M"),
"comunidaddemadrid" | "madridcomunidadde" | "esmd" => Ok("MD"),
"melilla" | "esml" => Ok("ML"),
"murcia" | "esmu" => Ok("MU"),
"murciaregionde" | "regiondemurcia" | "esmc" => Ok("MC"),
"malaga" | "esma" => Ok("MA"),
"nafarroa" | "esnc" => Ok("NC"),
"nafarroakoforukomunitatea" | "esna" => Ok("NA"),
"navarra" => Ok("NA"),
"navarracomunidadforalde" | "comunidadforaldenavarra" => Ok("NC"),
"ourense" | "orense" | "esor" => Ok("OR"),
"palencia" | "esp" => Ok("P"),
"paisvasco" => Ok("PV"),
"pontevedra" | "espo" => Ok("PO"),
"salamanca" | "essa" => Ok("SA"),
"santacruzdetenerife" | "estf" => Ok("TF"),
"segovia" | "essg" => Ok("SG"),
"sevilla" | "esse" => Ok("SE"),
"soria" | "esso" => Ok("SO"),
"tarragona" | "est" => Ok("T"),
"teruel" | "este" => Ok("TE"),
"toledo" | "esto" => Ok("TO"),
"valencia" | "esv" => Ok("V"),
"valencianacomunidad" | "esvc" => Ok("VC"),
"valencianacomunitat" => Ok("V"),
"valladolid" | "esva" => Ok("VA"),
"zamora" | "esza" => Ok("ZA"),
"zaragoza" | "esz" => Ok("Z"),
"alava" => Ok("VI"),
"avila" | "esav" => Ok("AV"),
_ => Err(errors::ConnectorError::InvalidDataFormat {
field_name: "address.state",
}),
}?;
addr_state.to_string()
} else {
state.to_string()
};
Ok(Secret::new(addr_state_value))
}
pub fn set_billing_data(mut self, address: Option<&Address>) -> Result<Self, Error> {
self.billing_data = address
.and_then(|address| {
address.address.as_ref().map(|address_details| {
let state = address_details
.get_optional_state()
.map(Self::get_state_code)
.transpose();
match state {
Ok(bill_addr_state) => Ok(BillingData {
bill_addr_city: address_details.get_optional_city(),
bill_addr_country: address_details.get_optional_country().map(
|country| {
common_enums::CountryAlpha2::from_alpha2_to_alpha3(country)
.to_string()
},
),
bill_addr_line1: address_details.get_optional_line1(),
bill_addr_line2: address_details.get_optional_line2(),
bill_addr_line3: address_details.get_optional_line3(),
bill_addr_postal_code: address_details.get_optional_zip(),
bill_addr_state,
}),
Err(err) => Err(err),
}
})
})
.transpose()?;
Ok(self)
}
pub fn set_shipping_data(mut self, address: Option<&Address>) -> Result<Self, Error> {
self.shipping_data = address
.and_then(|address| {
address.address.as_ref().map(|address_details| {
let state = address_details
.get_optional_state()
.map(Self::get_state_code)
.transpose();
match state {
Ok(ship_addr_state) => Ok(ShippingData {
ship_addr_city: address_details.get_optional_city(),
ship_addr_country: address_details.get_optional_country().map(
|country| {
common_enums::CountryAlpha2::from_alpha2_to_alpha3(country)
.to_string()
},
),
ship_addr_line1: address_details.get_optional_line1(),
ship_addr_line2: address_details.get_optional_line2(),
ship_addr_line3: address_details.get_optional_line3(),
ship_addr_postal_code: address_details.get_optional_zip(),
ship_addr_state,
}),
Err(err) => Err(err),
}
})
})
.transpose()?;
Ok(self)
}
}
#[derive(Debug)]
pub struct RedsysCardData {
card_number: cards::CardNumber,
expiry_date: Secret<String>,
cvv2: Secret<String>,
}
impl TryFrom<&Option<PaymentMethodData>> for RedsysCardData {
type Error = Error;
fn try_from(payment_method_data: &Option<PaymentMethodData>) -> Result<Self, Self::Error> {
match payment_method_data {
Some(PaymentMethodData::Card(card)) => {
let year = card.get_card_expiry_year_2_digit()?.expose();
let month = card.get_card_expiry_month_2_digit()?.expose();
let expiry_date = Secret::new(format!("{year}{month}"));
Ok(Self {
card_number: card.card_number.clone(),
expiry_date,
cvv2: card.card_cvc.clone(),
})
}
Some(PaymentMethodData::Wallet(..))
| Some(PaymentMethodData::PayLater(..))
| Some(PaymentMethodData::BankDebit(..))
| Some(PaymentMethodData::BankRedirect(..))
| Some(PaymentMethodData::BankTransfer(..))
| Some(PaymentMethodData::Crypto(..))
| Some(PaymentMethodData::MandatePayment)
| Some(PaymentMethodData::GiftCard(..))
| Some(PaymentMethodData::Voucher(..))
| Some(PaymentMethodData::CardRedirect(..))
| Some(PaymentMethodData::Reward)
| Some(PaymentMethodData::RealTimePayment(..))
| Some(PaymentMethodData::MobilePayment(..))
| Some(PaymentMethodData::Upi(..))
| Some(PaymentMethodData::OpenBanking(_))
| Some(PaymentMethodData::CardToken(..))
| Some(PaymentMethodData::NetworkToken(..))
| Some(PaymentMethodData::CardDetailsForNetworkTransactionId(_))
| None => Err(errors::ConnectorError::NotImplemented(
connector_utils::get_unimplemented_payment_method_error_message("redsys"),
)
.into()),
}
}
}
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "PascalCase")]
pub enum RedsysThreeDsInfo {
CardData,
CardConfiguration,
ChallengeRequest,
ChallengeResponse,
AuthenticationData,
}
#[derive(Debug, Serialize, Deserialize)]
pub enum RedsysTransactionType {
#[serde(rename = "0")]
Payment,
#[serde(rename = "1")]
Preauthorization,
#[serde(rename = "2")]
Confirmation,
#[serde(rename = "3")]
Refund,
#[serde(rename = "9")]
Cancellation,
}
pub struct RedsysAuthType {
pub(super) merchant_id: Secret<String>,
pub(super) terminal_id: Secret<String>,
pub(super) sha256_pwd: Secret<String>,
}
impl TryFrom<&ConnectorAuthType> for RedsysAuthType {
type Error = Error;
fn try_from(auth_type: &ConnectorAuthType) -> Result<Self, Self::Error> {
if let ConnectorAuthType::SignatureKey {
api_key,
key1,
api_secret,
} = auth_type
{
Ok(Self {
merchant_id: api_key.to_owned(),
terminal_id: key1.to_owned(),
sha256_pwd: api_secret.to_owned(),
})
} else {
Err(errors::ConnectorError::FailedToObtainAuthType)?
}
}
}
impl TryFrom<&RedsysRouterData<&PaymentsPreProcessingRouterData>> for RedsysTransaction {
type Error = Error;
fn try_from(
item: &RedsysRouterData<&PaymentsPreProcessingRouterData>,
) -> Result<Self, Self::Error> {
let auth = RedsysAuthType::try_from(&item.router_data.connector_auth_type)?;
if !item.router_data.is_three_ds() {
Err(errors::ConnectorError::NotSupported {
message: "PreProcessing flow for no-3ds cards".to_string(),
connector: "redsys",
})?
};
let redsys_preprocessing_request = if item.router_data.auth_type
== enums::AuthenticationType::ThreeDs
{
let ds_merchant_emv3ds = Some(EmvThreedsData::new(RedsysThreeDsInfo::CardData));
let ds_merchant_transactiontype = if item.router_data.request.is_auto_capture()? {
RedsysTransactionType::Payment
} else {
RedsysTransactionType::Preauthorization
};
let ds_merchant_order = if item.router_data.connector_request_reference_id.len() <= 12 {
Ok(item.router_data.connector_request_reference_id.clone())
} else {
Err(errors::ConnectorError::MaxFieldLengthViolated {
connector: "Redsys".to_string(),
field_name: "ds_merchant_order".to_string(),
max_length: 12,
received_length: item.router_data.connector_request_reference_id.len(),
})
}?;
let card_data =
RedsysCardData::try_from(&item.router_data.request.payment_method_data)?;
Ok(PaymentsRequest {
ds_merchant_emv3ds,
ds_merchant_transactiontype,
ds_merchant_currency: item.currency.iso_4217().to_owned(),
ds_merchant_pan: card_data.card_number,
ds_merchant_merchantcode: auth.merchant_id.clone(),
ds_merchant_terminal: auth.terminal_id.clone(),
ds_merchant_order,
ds_merchant_amount: item.amount.clone(),
ds_merchant_expirydate: card_data.expiry_date,
ds_merchant_cvv2: card_data.cvv2,
})
} else {
Err(errors::ConnectorError::FlowNotSupported {
flow: "PreProcessing".to_string(),
connector: "redsys".to_string(),
})
}?;
Self::try_from((&redsys_preprocessing_request, &auth))
}
}
#[derive(Debug, Deserialize, Serialize, Clone)]
#[serde(untagged)]
pub enum RedsysResponse {
RedsysResponse(RedsysTransaction),
RedsysErrorResponse(RedsysErrorResponse),
}
#[derive(Debug, Serialize, Deserialize, Clone)]
#[serde(rename_all = "camelCase")]
pub struct RedsysErrorResponse {
pub error_code: String,
}
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
pub enum CardPSD2 {
Y,
N,
}
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
pub enum ThreeDSCompInd {
Y,
N,
}
#[derive(Debug, Serialize, Deserialize)]
pub struct RedsysPaymentsResponse {
#[serde(rename = "Ds_Order")]
ds_order: String,
#[serde(rename = "Ds_EMV3DS")]
ds_emv3ds: Option<RedsysEmv3DSData>,
#[serde(rename = "Ds_Card_PSD2")]
ds_card_psd2: Option<CardPSD2>,
#[serde(rename = "Ds_Response")]
ds_response: Option<DsResponse>,
#[serde(rename = "Ds_AuthorisationCode")]
ds_authorisation_code: Option<String>,
}
#[derive(Debug, Serialize, Deserialize, Clone)]
pub struct DsResponse(String);
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct RedsysEmv3DSData {
protocol_version: String,
three_d_s_server_trans_i_d: Option<String>,
three_d_s_info: Option<RedsysThreeDsInfo>,
three_d_s_method_u_r_l: Option<String>,
acs_u_r_l: Option<String>,
creq: Option<String>,
}
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ThreedsInvokeRequest {
three_d_s_server_trans_i_d: String,
three_d_s_method_notification_u_r_l: String,
}
#[derive(Debug, Serialize, Deserialize)]
pub struct RedsysThreeDsInvokeData {
pub three_ds_method_url: String,
pub three_ds_method_data: String,
pub message_version: String,
pub directory_server_id: String,
pub three_ds_method_data_submission: bool,
}
#[derive(Debug, Serialize, Deserialize)]
pub struct ThreeDsInvokeExempt {
pub three_d_s_server_trans_i_d: String,
pub message_version: String,
}
#[derive(Debug, Serialize, Deserialize, Clone)]
pub struct RedsysTransaction {
#[serde(rename = "Ds_SignatureVersion")]
ds_signature_version: String,
#[serde(rename = "Ds_MerchantParameters")]
ds_merchant_parameters: Secret<String>,
#[serde(rename = "Ds_Signature")]
ds_signature: Secret<String>,
}
fn to_connector_response_data<T>(connector_response: &str) -> Result<T, Error>
where
T: serde::de::DeserializeOwned,
{
let decoded_bytes = BASE64_ENGINE
.decode(connector_response)
.change_context(errors::ConnectorError::ResponseDeserializationFailed)
.attach_printable("Failed to decode Base64")?;
let response_data: T = serde_json::from_slice(&decoded_bytes)
.change_context(errors::ConnectorError::ResponseHandlingFailed)?;
Ok(response_data)
}
impl<F>
TryFrom<ResponseRouterData<F, RedsysResponse, PaymentsPreProcessingData, PaymentsResponseData>>
for RouterData<F, PaymentsPreProcessingData, PaymentsResponseData>
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: ResponseRouterData<
F,
RedsysResponse,
PaymentsPreProcessingData,
PaymentsResponseData,
>,
) -> Result<Self, Self::Error> {
match item.response.clone() {
RedsysResponse::RedsysResponse(response) => {
let response_data: RedsysPaymentsResponse =
to_connector_response_data(&response.ds_merchant_parameters.clone().expose())?;
handle_redsys_preprocessing_response(item, &response_data)
}
RedsysResponse::RedsysErrorResponse(response) => {
let response = Err(ErrorResponse {
code: response.error_code.clone(),
message: response.error_code.clone(),
reason: Some(response.error_code.clone()),
status_code: item.http_code,
attempt_status: None,
connector_transaction_id: None,
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
connector_metadata: None,
});
Ok(Self {
status: enums::AttemptStatus::Failure,
response,
..item.data
})
}
}
}
}
fn handle_redsys_preprocessing_response<F>(
item: ResponseRouterData<F, RedsysResponse, PaymentsPreProcessingData, PaymentsResponseData>,
response_data: &RedsysPaymentsResponse,
) -> Result<
RouterData<F, PaymentsPreProcessingData, PaymentsResponseData>,
error_stack::Report<errors::ConnectorError>,
> {
match (
response_data
.ds_emv3ds
.as_ref()
.and_then(|emv3ds_data| emv3ds_data.three_d_s_method_u_r_l.clone()),
response_data
.ds_emv3ds
.as_ref()
.and_then(|emv3ds_data| emv3ds_data.three_d_s_server_trans_i_d.clone()),
response_data
.ds_emv3ds
.as_ref()
.map(|emv3ds_data| emv3ds_data.protocol_version.clone()),
) {
(
Some(three_d_s_method_u_r_l),
Some(three_d_s_server_trans_i_d),
Some(protocol_version),
) => handle_threeds_invoke(
item,
response_data,
three_d_s_method_u_r_l,
three_d_s_server_trans_i_d,
protocol_version,
),
(None, Some(three_d_s_server_trans_i_d), Some(protocol_version)) => {
handle_threeds_invoke_exempt(
item,
response_data,
three_d_s_server_trans_i_d,
protocol_version,
)
}
_ => Err(errors::ConnectorError::NotSupported {
message: "3DS payment with a non-3DS card".to_owned(),
connector: "redsys",
}
.into()),
}
}
fn handle_threeds_invoke<F>(
item: ResponseRouterData<F, RedsysResponse, PaymentsPreProcessingData, PaymentsResponseData>,
response_data: &RedsysPaymentsResponse,
three_d_s_method_u_r_l: String,
three_d_s_server_trans_i_d: String,
protocol_version: String,
) -> Result<
RouterData<F, PaymentsPreProcessingData, PaymentsResponseData>,
error_stack::Report<errors::ConnectorError>,
> {
let three_d_s_method_notification_u_r_l = item.data.request.get_webhook_url()?;
let threeds_invoke_data = ThreedsInvokeRequest {
three_d_s_server_trans_i_d: three_d_s_method_u_r_l.clone(),
three_d_s_method_notification_u_r_l,
};
let three_ds_data_string = threeds_invoke_data
.encode_to_string_of_json()
.change_context(errors::ConnectorError::RequestEncodingFailed)?;
let three_ds_method_data = BASE64_ENGINE.encode(&three_ds_data_string);
let three_ds_data = RedsysThreeDsInvokeData {
three_ds_method_url: three_d_s_method_u_r_l,
three_ds_method_data,
message_version: protocol_version.clone(),
directory_server_id: three_d_s_server_trans_i_d,
three_ds_method_data_submission: true,
};
let connector_metadata = Some(
serde_json::to_value(&three_ds_data)
.change_context(errors::ConnectorError::RequestEncodingFailed)
.attach_printable("Failed to serialize ThreeDsData")?,
);
Ok(RouterData {
status: enums::AttemptStatus::AuthenticationPending,
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(response_data.ds_order.clone()),
redirection_data: Box::new(None),
mandate_reference: Box::new(None),
connector_metadata,
network_txn_id: None,
connector_response_reference_id: Some(response_data.ds_order.clone()),
incremental_authorization_allowed: None,
charges: None,
}),
..item.data
})
}
fn handle_threeds_invoke_exempt<F>(
item: ResponseRouterData<F, RedsysResponse, PaymentsPreProcessingData, PaymentsResponseData>,
response_data: &RedsysPaymentsResponse,
three_d_s_server_trans_i_d: String,
protocol_version: String,
) -> Result<
RouterData<F, PaymentsPreProcessingData, PaymentsResponseData>,
error_stack::Report<errors::ConnectorError>,
> {
let three_ds_data = ThreeDsInvokeExempt {
message_version: protocol_version.clone(),
three_d_s_server_trans_i_d,
};
let connector_metadata = Some(
serde_json::to_value(&three_ds_data)
.change_context(errors::ConnectorError::RequestEncodingFailed)
.attach_printable("Failed to serialize ThreeDsData")?,
);
Ok(RouterData {
status: enums::AttemptStatus::AuthenticationPending,
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(response_data.ds_order.clone()),
redirection_data: Box::new(None),
mandate_reference: Box::new(None),
connector_metadata,
network_txn_id: None,
connector_response_reference_id: Some(response_data.ds_order.clone()),
incremental_authorization_allowed: None,
charges: None,
}),
..item.data
})
}
fn des_encrypt(
message: &str,
key: &str,
) -> Result<Vec<u8>, error_stack::Report<errors::ConnectorError>> {
// Connector decrypts the signature using an initialization vector (IV) set to all zeros
let iv_array = [0u8; common_utils::crypto::TripleDesEde3CBC::TRIPLE_DES_IV_LENGTH];
let iv = iv_array.to_vec();
let key_bytes = BASE64_ENGINE
.decode(key)
.change_context(errors::ConnectorError::RequestEncodingFailed)
.attach_printable("Base64 decoding failed")?;
let triple_des =
common_utils::crypto::TripleDesEde3CBC::new(Some(enums::CryptoPadding::ZeroPadding), iv)
.change_context(errors::ConnectorError::RequestEncodingFailed)
.attach_printable("Triple DES encryption failed")?;
let encrypted = triple_des
.encode_message(&key_bytes, message.as_bytes())
.change_context(errors::ConnectorError::RequestEncodingFailed)
.attach_printable("Triple DES encryption failed")?;
let expected_len =
encrypted.len() - common_utils::crypto::TripleDesEde3CBC::TRIPLE_DES_IV_LENGTH;
let encrypted_trimmed = encrypted
.get(..expected_len)
.ok_or(errors::ConnectorError::RequestEncodingFailed)
.attach_printable("Failed to trim encrypted data to the expected length")?;
Ok(encrypted_trimmed.to_vec())
}
fn get_signature(
order_id: &str,
params: &str,
key: &str,
) -> Result<String, error_stack::Report<errors::ConnectorError>> {
let secret_ko = des_encrypt(order_id, key)?;
let result = common_utils::crypto::HmacSha256::sign_message(
&common_utils::crypto::HmacSha256,
&secret_ko,
params.as_bytes(),
)
.map_err(|_| errors::ConnectorError::RequestEncodingFailed)?;
let encoded = BASE64_ENGINE.encode(result);
Ok(encoded)
}
pub trait SignatureCalculationData {
fn get_merchant_parameters(&self) -> Result<String, Error>;
fn get_order_id(&self) -> String;
}
impl SignatureCalculationData for PaymentsRequest {
fn get_merchant_parameters(&self) -> Result<String, Error> {
self.encode_to_string_of_json()
.change_context(errors::ConnectorError::RequestEncodingFailed)
}
fn get_order_id(&self) -> String {
self.ds_merchant_order.clone()
}
}
impl SignatureCalculationData for RedsysOperationRequest {
fn get_merchant_parameters(&self) -> Result<String, Error> {
self.encode_to_string_of_json()
.change_context(errors::ConnectorError::RequestEncodingFailed)
}
fn get_order_id(&self) -> String {
self.ds_merchant_order.clone()
}
}
impl<T> TryFrom<(&T, &RedsysAuthType)> for RedsysTransaction
where
T: SignatureCalculationData,
{
type Error = Error;
fn try_from(data: (&T, &RedsysAuthType)) -> Result<Self, Self::Error> {
let (request_data, auth) = data;
let merchant_parameters = request_data.get_merchant_parameters()?;
let ds_merchant_parameters = BASE64_ENGINE.encode(&merchant_parameters);
let sha256_pwd = auth.sha256_pwd.clone().expose();
let ds_merchant_order = request_data.get_order_id();
let signature = get_signature(&ds_merchant_order, &ds_merchant_parameters, &sha256_pwd)?;
Ok(Self {
ds_signature_version: SIGNATURE_VERSION.to_string(),
ds_merchant_parameters: Secret::new(ds_merchant_parameters),
ds_signature: Secret::new(signature),
})
}
}
fn get_redsys_attempt_status(
ds_response: DsResponse,
capture_method: Option<enums::CaptureMethod>,
) -> Result<enums::AttemptStatus, error_stack::Report<errors::ConnectorError>> {
// Redsys consistently provides a 4-digit response code, where numbers ranging from 0000 to 0099 indicate successful transactions
if ds_response.0.starts_with("00") {
match capture_method {
Some(enums::CaptureMethod::Automatic) | None => Ok(enums::AttemptStatus::Charged),
Some(enums::CaptureMethod::Manual) => Ok(enums::AttemptStatus::Authorized),
_ => Err(errors::ConnectorError::CaptureMethodNotSupported.into()),
}
} else {
match ds_response.0.as_str() {
"0900" => Ok(enums::AttemptStatus::Charged),
"0400" => Ok(enums::AttemptStatus::Voided),
"0950" => Ok(enums::AttemptStatus::VoidFailed),
"9998" => Ok(enums::AttemptStatus::AuthenticationPending),
"9256" | "9257" | "0184" => Ok(enums::AttemptStatus::AuthenticationFailed),
"0101" | "0102" | "0106" | "0125" | "0129" | "0172" | "0173" | "0174" | "0180"
| "0190" | "0191" | "0195" | "0202" | "0904" | "0909" | "0913" | "0944" | "9912"
| "0912" | "9064" | "9078" | "9093" | "9094" | "9104" | "9218" | "9253" | "9261"
| "9915" | "9997" | "9999" => Ok(enums::AttemptStatus::Failure),
error => Err(errors::ConnectorError::ResponseHandlingFailed)
.attach_printable(format!("Received Unknown Status:{error}"))?,
}
}
}
impl TryFrom<&RedsysRouterData<&PaymentsAuthorizeRouterData>> for RedsysTransaction {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: &RedsysRouterData<&PaymentsAuthorizeRouterData>,
) -> Result<Self, Self::Error> {
if !item.router_data.is_three_ds() {
Err(errors::ConnectorError::NotSupported {
message: "No-3DS cards".to_string(),
connector: "redsys",
})?
};
let auth = RedsysAuthType::try_from(&item.router_data.connector_auth_type)?;
let ds_merchant_transactiontype = if item.router_data.request.is_auto_capture()? {
RedsysTransactionType::Payment
} else {
RedsysTransactionType::Preauthorization
};
let card_data =
RedsysCardData::try_from(&Some(item.router_data.request.payment_method_data.clone()))?;
let (connector_meta_data, ds_merchant_order) = match &item.router_data.response {
Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(order_id),
connector_metadata,
..
}) => (connector_metadata.clone(), order_id.clone()),
_ => Err(errors::ConnectorError::ResponseHandlingFailed)?,
};
let threeds_meta_data =
connector_utils::to_connector_meta::<ThreeDsInvokeExempt>(connector_meta_data.clone())?;
let emv3ds_data = EmvThreedsData::new(RedsysThreeDsInfo::AuthenticationData)
.set_three_d_s_server_trans_i_d(threeds_meta_data.three_d_s_server_trans_i_d)
.set_protocol_version(threeds_meta_data.message_version)
.set_notification_u_r_l(item.router_data.request.get_complete_authorize_url()?)
.add_browser_data(item.router_data.request.get_browser_info()?)?
.set_three_d_s_comp_ind(ThreeDSCompInd::N)
.set_billing_data(item.router_data.get_optional_billing())?
.set_shipping_data(item.router_data.get_optional_shipping())?;
let payment_authorize_request = PaymentsRequest {
ds_merchant_emv3ds: Some(emv3ds_data),
ds_merchant_transactiontype,
ds_merchant_currency: item.currency.iso_4217().to_owned(),
ds_merchant_pan: card_data.card_number,
ds_merchant_merchantcode: auth.merchant_id.clone(),
ds_merchant_terminal: auth.terminal_id.clone(),
ds_merchant_order,
ds_merchant_amount: item.amount.clone(),
ds_merchant_expirydate: card_data.expiry_date,
ds_merchant_cvv2: card_data.cvv2,
};
Self::try_from((&payment_authorize_request, &auth))
}
}
fn build_threeds_form(ds_emv3ds: &RedsysEmv3DSData) -> Result<RedirectForm, Error> {
let creq = ds_emv3ds
.creq
.clone()
.ok_or(errors::ConnectorError::ResponseDeserializationFailed)?;
let endpoint = ds_emv3ds
.acs_u_r_l
.clone()
.ok_or(errors::ConnectorError::ResponseDeserializationFailed)?;
let mut form_fields = std::collections::HashMap::new();
form_fields.insert("creq".to_string(), creq);
Ok(RedirectForm::Form {
endpoint,
method: common_utils::request::Method::Post,
form_fields,
})
}
impl<F> TryFrom<ResponseRouterData<F, RedsysResponse, PaymentsAuthorizeData, PaymentsResponseData>>
for RouterData<F, PaymentsAuthorizeData, PaymentsResponseData>
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: ResponseRouterData<F, RedsysResponse, PaymentsAuthorizeData, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
let (response, status) = match item.response.clone() {
RedsysResponse::RedsysResponse(transaction_response) => {
let connector_metadata = match item.data.response {
Ok(PaymentsResponseData::TransactionResponse {
connector_metadata, ..
}) => connector_metadata,
_ => None,
};
let response_data: RedsysPaymentsResponse = to_connector_response_data(
&transaction_response.ds_merchant_parameters.clone().expose(),
)?;
get_payments_response(
response_data,
item.data.request.capture_method,
connector_metadata,
item.http_code,
)?
}
RedsysResponse::RedsysErrorResponse(response) => {
let response = Err(ErrorResponse {
code: response.error_code.clone(),
message: response.error_code.clone(),
reason: Some(response.error_code.clone()),
status_code: item.http_code,
attempt_status: None,
connector_transaction_id: None,
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
connector_metadata: None,
});
(response, enums::AttemptStatus::Failure)
}
};
Ok(Self {
status,
response,
..item.data
})
}
}
#[derive(Debug, Serialize, Deserialize)]
pub struct ThreedsChallengeResponse {
cres: String,
}
impl TryFrom<&RedsysRouterData<&PaymentsCompleteAuthorizeRouterData>> for RedsysTransaction {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: &RedsysRouterData<&PaymentsCompleteAuthorizeRouterData>,
) -> Result<Self, Self::Error> {
if !item.router_data.is_three_ds() {
Err(errors::ConnectorError::NotSupported {
message: "PaymentsComplete flow for no-3ds cards".to_string(),
connector: "redsys",
})?
};
let card_data =
RedsysCardData::try_from(&item.router_data.request.payment_method_data.clone())?;
let auth = RedsysAuthType::try_from(&item.router_data.connector_auth_type)?;
let redirect_response = item
.router_data
.request
.get_redirect_response_payload()
.ok()
.clone()
.map(|payload_data| {
payload_data
.parse_value::<ThreedsChallengeResponse>("Redsys ThreedsChallengeResponse")
.change_context(errors::ConnectorError::ResponseDeserializationFailed)
})
.transpose()?;
let billing_data = item.router_data.get_optional_billing();
let shipping_data = item.router_data.get_optional_shipping();
let emv3ds_data = match redirect_response {
Some(payload) => {
if let Ok(threeds_invoke_meta_data) =
connector_utils::to_connector_meta::<RedsysThreeDsInvokeData>(
item.router_data.request.connector_meta.clone(),
)
{
EmvThreedsData::new(RedsysThreeDsInfo::ChallengeResponse)
.set_protocol_version(threeds_invoke_meta_data.message_version)
.set_three_d_s_cres(payload.cres)
.set_billing_data(billing_data)?
.set_shipping_data(shipping_data)?
} else if let Ok(threeds_meta_data) =
connector_utils::to_connector_meta::<ThreeDsInvokeExempt>(
item.router_data.request.connector_meta.clone(),
)
{
EmvThreedsData::new(RedsysThreeDsInfo::ChallengeResponse)
.set_protocol_version(threeds_meta_data.message_version)
.set_three_d_s_cres(payload.cres)
.set_billing_data(billing_data)?
.set_shipping_data(shipping_data)?
} else {
Err(errors::ConnectorError::RequestEncodingFailed)?
}
}
None => {
if let Ok(threeds_invoke_meta_data) =
connector_utils::to_connector_meta::<RedsysThreeDsInvokeData>(
item.router_data.request.connector_meta.clone(),
)
{
let three_d_s_comp_ind = ThreeDSCompInd::from(
item.router_data.request.get_threeds_method_comp_ind()?,
);
let browser_info = item.router_data.request.get_browser_info()?;
let complete_authorize_url =
item.router_data.request.get_complete_authorize_url()?;
EmvThreedsData::new(RedsysThreeDsInfo::AuthenticationData)
.set_three_d_s_server_trans_i_d(
threeds_invoke_meta_data.directory_server_id,
)
.set_protocol_version(threeds_invoke_meta_data.message_version)
.set_three_d_s_comp_ind(three_d_s_comp_ind)
.add_browser_data(browser_info)?
.set_notification_u_r_l(complete_authorize_url)
.set_billing_data(billing_data)?
.set_shipping_data(shipping_data)?
} else {
Err(errors::ConnectorError::NoConnectorMetaData)?
}
}
};
let ds_merchant_transactiontype = if item.router_data.request.is_auto_capture()? {
RedsysTransactionType::Payment
} else {
RedsysTransactionType::Preauthorization
};
let ds_merchant_order = item
.router_data
.request
.connector_transaction_id
.clone()
.ok_or(errors::ConnectorError::RequestEncodingFailed)
.attach_printable("Missing connector_transaction_id")?;
let complete_authorize_response = PaymentsRequest {
ds_merchant_emv3ds: Some(emv3ds_data),
ds_merchant_transactiontype,
ds_merchant_currency: item.currency.iso_4217().to_owned(),
ds_merchant_pan: card_data.card_number,
ds_merchant_merchantcode: auth.merchant_id.clone(),
ds_merchant_terminal: auth.terminal_id.clone(),
ds_merchant_order,
ds_merchant_amount: item.amount.clone(),
ds_merchant_expirydate: card_data.expiry_date,
ds_merchant_cvv2: card_data.cvv2,
};
Self::try_from((&complete_authorize_response, &auth))
}
}
impl<F> TryFrom<ResponseRouterData<F, RedsysResponse, CompleteAuthorizeData, PaymentsResponseData>>
for RouterData<F, CompleteAuthorizeData, PaymentsResponseData>
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: ResponseRouterData<F, RedsysResponse, CompleteAuthorizeData, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
let (response, status) = match item.response.clone() {
RedsysResponse::RedsysResponse(transaction_response) => {
let response_data: RedsysPaymentsResponse = to_connector_response_data(
&transaction_response.ds_merchant_parameters.clone().expose(),
)?;
get_payments_response(
response_data,
item.data.request.capture_method,
None,
item.http_code,
)?
}
RedsysResponse::RedsysErrorResponse(response) => {
let response = Err(ErrorResponse {
code: response.error_code.clone(),
message: response.error_code.clone(),
reason: Some(response.error_code.clone()),
status_code: item.http_code,
attempt_status: None,
connector_transaction_id: None,
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
connector_metadata: None,
});
(response, enums::AttemptStatus::Failure)
}
};
Ok(Self {
status,
response,
..item.data
})
}
}
impl From<api_models::payments::ThreeDsCompletionIndicator> for ThreeDSCompInd {
fn from(threeds_compl_flag: api_models::payments::ThreeDsCompletionIndicator) -> Self {
match threeds_compl_flag {
api_models::payments::ThreeDsCompletionIndicator::Success => Self::Y,
api_models::payments::ThreeDsCompletionIndicator::Failure
| api_models::payments::ThreeDsCompletionIndicator::NotAvailable => Self::N,
}
}
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
pub struct RedsysOperationRequest {
ds_merchant_order: String,
ds_merchant_merchantcode: Secret<String>,
ds_merchant_terminal: Secret<String>,
ds_merchant_currency: String,
ds_merchant_transactiontype: RedsysTransactionType,
ds_merchant_amount: StringMinorUnit,
}
#[derive(Debug, Serialize, Deserialize)]
pub struct RedsysOperationsResponse {
#[serde(rename = "Ds_Order")]
ds_order: String,
#[serde(rename = "Ds_Response")]
ds_response: DsResponse,
#[serde(rename = "Ds_AuthorisationCode")]
ds_authorisation_code: Option<String>,
}
#[derive(Debug, Deserialize, Serialize, Clone)]
#[serde(untagged)]
pub enum RedsysOperationResponse {
RedsysOperationResponse(RedsysTransaction),
RedsysOperationsErrorResponse(RedsysErrorResponse),
}
impl TryFrom<&RedsysRouterData<&PaymentsCaptureRouterData>> for RedsysTransaction {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(item: &RedsysRouterData<&PaymentsCaptureRouterData>) -> Result<Self, Self::Error> {
let auth = RedsysAuthType::try_from(&item.router_data.connector_auth_type)?;
let redys_capture_request = RedsysOperationRequest {
ds_merchant_order: item.router_data.request.connector_transaction_id.clone(),
ds_merchant_merchantcode: auth.merchant_id.clone(),
ds_merchant_terminal: auth.terminal_id.clone(),
ds_merchant_currency: item.router_data.request.currency.iso_4217().to_owned(),
ds_merchant_transactiontype: RedsysTransactionType::Confirmation,
ds_merchant_amount: item.amount.clone(),
};
Self::try_from((&redys_capture_request, &auth))
}
}
impl<F> TryFrom<ResponseRouterData<F, RedsysResponse, PaymentsCaptureData, PaymentsResponseData>>
for RouterData<F, PaymentsCaptureData, PaymentsResponseData>
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: ResponseRouterData<F, RedsysResponse, PaymentsCaptureData, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
let (response, status) = match item.response {
RedsysResponse::RedsysResponse(redsys_transaction_response) => {
let response_data: RedsysOperationsResponse = to_connector_response_data(
&redsys_transaction_response
.ds_merchant_parameters
.clone()
.expose(),
)?;
let status = get_redsys_attempt_status(response_data.ds_response.clone(), None)?;
let response = if connector_utils::is_payment_failure(status) {
Err(ErrorResponse {
code: response_data.ds_response.0.clone(),
message: response_data.ds_response.0.clone(),
reason: Some(response_data.ds_response.0.clone()),
status_code: item.http_code,
attempt_status: None,
connector_transaction_id: Some(response_data.ds_order.clone()),
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
connector_metadata: None,
})
} else {
Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(
response_data.ds_order.clone(),
),
redirection_data: Box::new(None),
mandate_reference: Box::new(None),
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: Some(response_data.ds_order.clone()),
incremental_authorization_allowed: None,
charges: None,
})
};
(response, status)
}
RedsysResponse::RedsysErrorResponse(error_response) => {
let response = Err(ErrorResponse {
code: error_response.error_code.clone(),
message: error_response.error_code.clone(),
reason: Some(error_response.error_code.clone()),
status_code: item.http_code,
attempt_status: None,
connector_transaction_id: None,
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
connector_metadata: None,
});
(response, enums::AttemptStatus::Failure)
}
};
Ok(Self {
status,
response,
..item.data
})
}
}
impl TryFrom<&RedsysRouterData<&PaymentsCancelRouterData>> for RedsysTransaction {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(item: &RedsysRouterData<&PaymentsCancelRouterData>) -> Result<Self, Self::Error> {
let auth = RedsysAuthType::try_from(&item.router_data.connector_auth_type)?;
let redsys_cancel_request = RedsysOperationRequest {
ds_merchant_order: item.router_data.request.connector_transaction_id.clone(),
ds_merchant_merchantcode: auth.merchant_id.clone(),
ds_merchant_terminal: auth.terminal_id.clone(),
ds_merchant_currency: item.currency.iso_4217().to_owned(),
ds_merchant_transactiontype: RedsysTransactionType::Cancellation,
ds_merchant_amount: item.amount.clone(),
};
Self::try_from((&redsys_cancel_request, &auth))
}
}
impl<F> TryFrom<&RedsysRouterData<&RefundsRouterData<F>>> for RedsysTransaction {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(item: &RedsysRouterData<&RefundsRouterData<F>>) -> Result<Self, Self::Error> {
let auth = RedsysAuthType::try_from(&item.router_data.connector_auth_type)?;
let redsys_refund_request = RedsysOperationRequest {
ds_merchant_order: item.router_data.request.connector_transaction_id.clone(),
ds_merchant_merchantcode: auth.merchant_id.clone(),
ds_merchant_terminal: auth.terminal_id.clone(),
ds_merchant_currency: item.currency.iso_4217().to_owned(),
ds_merchant_transactiontype: RedsysTransactionType::Refund,
ds_merchant_amount: item.amount.clone(),
};
Self::try_from((&redsys_refund_request, &auth))
}
}
impl<F> TryFrom<ResponseRouterData<F, RedsysResponse, PaymentsCancelData, PaymentsResponseData>>
for RouterData<F, PaymentsCancelData, PaymentsResponseData>
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: ResponseRouterData<F, RedsysResponse, PaymentsCancelData, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
let (response, status) = match item.response {
RedsysResponse::RedsysResponse(redsys_transaction_response) => {
let response_data: RedsysOperationsResponse = to_connector_response_data(
&redsys_transaction_response
.ds_merchant_parameters
.clone()
.expose(),
)?;
let status = get_redsys_attempt_status(response_data.ds_response.clone(), None)?;
let response = if connector_utils::is_payment_failure(status) {
Err(ErrorResponse {
code: response_data.ds_response.0.clone(),
message: response_data.ds_response.0.clone(),
reason: Some(response_data.ds_response.0.clone()),
status_code: item.http_code,
attempt_status: None,
connector_transaction_id: Some(response_data.ds_order.clone()),
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
connector_metadata: None,
})
} else {
Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(
response_data.ds_order.clone(),
),
redirection_data: Box::new(None),
mandate_reference: Box::new(None),
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: Some(response_data.ds_order.clone()),
incremental_authorization_allowed: None,
charges: None,
})
};
(response, status)
}
RedsysResponse::RedsysErrorResponse(error_response) => {
let response = Err(ErrorResponse {
code: error_response.error_code.clone(),
message: error_response.error_code.clone(),
reason: Some(error_response.error_code.clone()),
status_code: item.http_code,
attempt_status: None,
connector_transaction_id: None,
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
connector_metadata: None,
});
(response, enums::AttemptStatus::VoidFailed)
}
};
Ok(Self {
status,
response,
..item.data
})
}
}
impl TryFrom<DsResponse> for enums::RefundStatus {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(ds_response: DsResponse) -> Result<Self, Self::Error> {
match ds_response.0.as_str() {
"0900" => Ok(Self::Success),
"9999" => Ok(Self::Pending),
"0950" | "0172" | "174" => Ok(Self::Failure),
unknown_status => Err(errors::ConnectorError::ResponseHandlingFailed)
.attach_printable(format!("Received unknown status:{unknown_status}"))?,
}
}
}
impl TryFrom<RefundsResponseRouterData<Execute, RedsysResponse>> for RefundsRouterData<Execute> {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: RefundsResponseRouterData<Execute, RedsysResponse>,
) -> Result<Self, Self::Error> {
let response = match item.response {
RedsysResponse::RedsysResponse(redsys_transaction) => {
let response_data: RedsysOperationsResponse = to_connector_response_data(
&redsys_transaction.ds_merchant_parameters.clone().expose(),
)?;
let refund_status =
enums::RefundStatus::try_from(response_data.ds_response.clone())?;
if connector_utils::is_refund_failure(refund_status) {
Err(ErrorResponse {
code: response_data.ds_response.0.clone(),
message: response_data.ds_response.0.clone(),
reason: Some(response_data.ds_response.0.clone()),
status_code: item.http_code,
attempt_status: None,
connector_transaction_id: None,
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
connector_metadata: None,
})
} else {
Ok(RefundsResponseData {
connector_refund_id: response_data.ds_order,
refund_status,
})
}
}
RedsysResponse::RedsysErrorResponse(redsys_error_response) => Err(ErrorResponse {
code: redsys_error_response.error_code.clone(),
message: redsys_error_response.error_code.clone(),
reason: Some(redsys_error_response.error_code.clone()),
status_code: item.http_code,
attempt_status: None,
connector_transaction_id: None,
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
connector_metadata: None,
}),
};
Ok(Self {
response,
..item.data
})
}
}
fn get_payments_response(
redsys_payments_response: RedsysPaymentsResponse,
capture_method: Option<enums::CaptureMethod>,
connector_metadata: Option<josekit::Value>,
http_code: u16,
) -> Result<
(
Result<PaymentsResponseData, ErrorResponse>,
enums::AttemptStatus,
),
Error,
> {
if let Some(ds_response) = redsys_payments_response.ds_response {
let status = get_redsys_attempt_status(ds_response.clone(), capture_method)?;
let response = if connector_utils::is_payment_failure(status) {
Err(ErrorResponse {
code: ds_response.0.clone(),
message: ds_response.0.clone(),
reason: Some(ds_response.0.clone()),
status_code: http_code,
attempt_status: None,
connector_transaction_id: Some(redsys_payments_response.ds_order.clone()),
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
connector_metadata: None,
})
} else {
Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(
redsys_payments_response.ds_order.clone(),
),
redirection_data: Box::new(None),
mandate_reference: Box::new(None),
connector_metadata,
network_txn_id: None,
connector_response_reference_id: Some(redsys_payments_response.ds_order.clone()),
incremental_authorization_allowed: None,
charges: None,
})
};
Ok((response, status))
} else {
let redirection_form = redsys_payments_response
.ds_emv3ds
.map(|ds_emv3ds| build_threeds_form(&ds_emv3ds))
.transpose()?;
let response = Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(
redsys_payments_response.ds_order.clone(),
),
redirection_data: Box::new(redirection_form),
mandate_reference: Box::new(None),
connector_metadata,
network_txn_id: None,
connector_response_reference_id: Some(redsys_payments_response.ds_order.clone()),
incremental_authorization_allowed: None,
charges: None,
});
Ok((response, enums::AttemptStatus::AuthenticationPending))
}
}
#[derive(Debug, Serialize)]
pub struct Messages {
#[serde(rename = "Version")]
version: VersionData,
#[serde(rename = "Signature")]
signature: String,
#[serde(rename = "SignatureVersion")]
signature_version: String,
}
#[derive(Debug, Serialize)]
#[serde(rename = "Version")]
pub struct VersionData {
#[serde(rename = "@Ds_Version")]
ds_version: String,
#[serde(rename = "Message")]
message: Message,
}
#[derive(Debug, Serialize)]
pub struct Message {
#[serde(rename = "Transaction")]
transaction: RedsysSyncRequest,
}
#[derive(Debug, Serialize)]
#[serde(rename = "Transaction")]
pub struct RedsysSyncRequest {
#[serde(rename = "Ds_MerchantCode")]
ds_merchant_code: Secret<String>,
#[serde(rename = "Ds_Terminal")]
ds_terminal: Secret<String>,
#[serde(rename = "Ds_Order")]
ds_order: String,
#[serde(rename = "Ds_TransactionType")]
ds_transaction_type: String,
}
fn get_transaction_type(
status: enums::AttemptStatus,
capture_method: Option<enums::CaptureMethod>,
) -> Result<String, errors::ConnectorError> {
match status {
enums::AttemptStatus::AuthenticationPending
| enums::AttemptStatus::AuthenticationSuccessful
| enums::AttemptStatus::Started
| enums::AttemptStatus::Authorizing
| enums::AttemptStatus::Authorized
| enums::AttemptStatus::DeviceDataCollectionPending => match capture_method {
Some(enums::CaptureMethod::Automatic) | None => {
Ok(transaction_type::PAYMENT.to_owned())
}
Some(enums::CaptureMethod::Manual) => Ok(transaction_type::PREAUTHORIZATION.to_owned()),
Some(capture_method) => Err(errors::ConnectorError::NotSupported {
message: capture_method.to_string(),
connector: "redsys",
}),
},
enums::AttemptStatus::VoidInitiated => Ok(transaction_type::CANCELLATION.to_owned()),
enums::AttemptStatus::PartialChargedAndChargeable
| enums::AttemptStatus::CaptureInitiated => Ok(transaction_type::CONFIRMATION.to_owned()),
enums::AttemptStatus::Pending => match capture_method {
Some(enums::CaptureMethod::Automatic) | None => {
Ok(transaction_type::PAYMENT.to_owned())
}
Some(enums::CaptureMethod::Manual) => Ok(transaction_type::CONFIRMATION.to_owned()),
Some(capture_method) => Err(errors::ConnectorError::NotSupported {
message: capture_method.to_string(),
connector: "redsys",
}),
},
other_attempt_status => Err(errors::ConnectorError::NotSupported {
message: format!("Payment sync after terminal status: {other_attempt_status} payment"),
connector: "redsys",
}),
}
}
fn construct_sync_request(
order_id: String,
transaction_type: String,
auth: RedsysAuthType,
) -> Result<Vec<u8>, Error> {
let transaction_data = RedsysSyncRequest {
ds_merchant_code: auth.merchant_id,
ds_terminal: auth.terminal_id,
ds_transaction_type: transaction_type,
ds_order: order_id.clone(),
};
let version = VersionData {
ds_version: DS_VERSION.to_owned(),
message: Message {
transaction: transaction_data,
},
};
let version_data = quick_xml::se::to_string(&version)
.change_context(errors::ConnectorError::RequestEncodingFailed)?;
let signature = get_signature(&order_id, &version_data, auth.sha256_pwd.peek())?;
let messages = Messages {
version,
signature,
signature_version: SIGNATURE_VERSION.to_owned(),
};
let cdata = quick_xml::se::to_string(&messages)
.change_context(errors::ConnectorError::RequestEncodingFailed)?;
let body = format!(
r#"<soapenv:Envelope xmlns:soapenv="{}" xmlns:web="{}"><soapenv:Header/><soapenv:Body><web:consultaOperaciones><cadenaXML><![CDATA[{}]]></cadenaXML></web:consultaOperaciones></soapenv:Body></soapenv:Envelope>"#,
common_utils::consts::SOAP_ENV_NAMESPACE,
XMLNS_WEB_URL,
cdata
);
Ok(body.as_bytes().to_vec())
}
pub fn build_payment_sync_request(item: &PaymentsSyncRouterData) -> Result<Vec<u8>, Error> {
let transaction_type = get_transaction_type(item.status, item.request.capture_method)?;
let auth = RedsysAuthType::try_from(&item.connector_auth_type)?;
let connector_transaction_id = item
.request
.connector_transaction_id
.get_connector_transaction_id()
.change_context(errors::ConnectorError::MissingConnectorTransactionID)?;
construct_sync_request(connector_transaction_id, transaction_type, auth)
}
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename = "soapenv:envelope")]
pub struct RedsysSyncResponse {
#[serde(rename = "@xmlns:soapenv")]
xmlns_soapenv: String,
#[serde(rename = "@xmlns:soapenc")]
xmlns_soapenc: String,
#[serde(rename = "@xmlns:xsd")]
xmlns_xsd: String,
#[serde(rename = "@xmlns:xsi")]
xmlns_xsi: String,
#[serde(rename = "header")]
header: Option<SoapHeader>,
#[serde(rename = "body")]
body: SyncResponseBody,
}
#[derive(Debug, Serialize, Deserialize)]
pub struct SoapHeader {}
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "lowercase")]
pub struct SyncResponseBody {
consultaoperacionesresponse: ConsultaOperacionesResponse,
}
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "lowercase")]
pub struct ConsultaOperacionesResponse {
#[serde(rename = "@xmlns:p259")]
xmlns_p259: String,
consultaoperacionesreturn: ConsultaOperacionesReturn,
}
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "lowercase")]
pub struct ConsultaOperacionesReturn {
messages: MessagesResponseData,
}
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "lowercase")]
pub struct MessagesResponseData {
version: VersionResponseData,
}
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "lowercase")]
pub struct VersionResponseData {
#[serde(rename = "@ds_version")]
ds_version: String,
message: MessageResponseType,
}
// The response will contain either a sync transaction data or error data.
// Since the XML parser does not support enums for this case, we use Option to handle both scenarios.
// If both are present or both are absent, an error is thrown.
#[derive(Debug, Serialize, Deserialize)]
pub struct MessageResponseType {
response: Option<RedsysSyncResponseData>,
errormsg: Option<SyncErrorCode>,
}
#[derive(Debug, Serialize, Deserialize)]
pub struct SyncErrorCode {
ds_errorcode: String,
}
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub struct RedsysSyncResponseData {
ds_order: String,
ds_transactiontype: String,
ds_amount: Option<String>,
ds_currency: Option<String>,
ds_securepayment: Option<String>,
ds_state: Option<String>,
ds_response: Option<DsResponse>,
}
impl<F> TryFrom<ResponseRouterData<F, RedsysSyncResponse, PaymentsSyncData, PaymentsResponseData>>
for RouterData<F, PaymentsSyncData, PaymentsResponseData>
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: ResponseRouterData<F, RedsysSyncResponse, PaymentsSyncData, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
let message_data = item
.response
.body
.consultaoperacionesresponse
.consultaoperacionesreturn
.messages
.version
.message;
let (status, response) = match (message_data.response, message_data.errormsg) {
(Some(response), None) => {
if let Some(ds_response) = response.ds_response {
let status = get_redsys_attempt_status(
ds_response.clone(),
item.data.request.capture_method,
)?;
if connector_utils::is_payment_failure(status) {
let payment_response = Err(ErrorResponse {
status_code: item.http_code,
code: ds_response.0.clone(),
message: ds_response.0.clone(),
reason: Some(ds_response.0.clone()),
attempt_status: None,
connector_transaction_id: None,
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
connector_metadata: None,
});
(status, payment_response)
} else {
let payment_response = Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(
response.ds_order.clone(),
),
redirection_data: Box::new(None),
mandate_reference: Box::new(None),
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: Some(response.ds_order.clone()),
incremental_authorization_allowed: None,
charges: None,
});
(status, payment_response)
}
} else {
// When the payment is in authentication or still processing
let payment_response = Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(response.ds_order.clone()),
redirection_data: Box::new(None),
mandate_reference: Box::new(None),
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: Some(response.ds_order.clone()),
incremental_authorization_allowed: None,
charges: None,
});
(item.data.status, payment_response)
}
}
(None, Some(errormsg)) => {
let error_code = errormsg.ds_errorcode.clone();
let response = Err(ErrorResponse {
code: error_code.clone(),
message: error_code.clone(),
reason: Some(error_code),
status_code: item.http_code,
attempt_status: None,
connector_transaction_id: None,
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
connector_metadata: None,
});
(item.data.status, response)
}
(Some(_), Some(_)) | (None, None) => {
Err(errors::ConnectorError::ResponseHandlingFailed)?
}
};
Ok(Self {
status,
response,
..item.data
})
}
}
pub fn build_refund_sync_request(item: &RefundSyncRouterData) -> Result<Vec<u8>, Error> {
let transaction_type = transaction_type::REFUND.to_owned();
let auth = RedsysAuthType::try_from(&item.connector_auth_type)?;
let connector_transaction_id = item.request.connector_transaction_id.clone();
construct_sync_request(connector_transaction_id, transaction_type, auth)
}
impl TryFrom<RefundsResponseRouterData<RSync, RedsysSyncResponse>> for RefundsRouterData<RSync> {
type Error = Error;
fn try_from(
item: RefundsResponseRouterData<RSync, RedsysSyncResponse>,
) -> Result<Self, Self::Error> {
let message_data = item
.response
.body
.consultaoperacionesresponse
.consultaoperacionesreturn
.messages
.version
.message;
let response = match (message_data.response, message_data.errormsg) {
(None, Some(errormsg)) => {
let error_code = errormsg.ds_errorcode.clone();
Err(ErrorResponse {
code: error_code.clone(),
message: error_code.clone(),
reason: Some(error_code),
status_code: item.http_code,
attempt_status: None,
connector_transaction_id: None,
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
connector_metadata: None,
})
}
(Some(response), None) => {
if let Some(ds_response) = response.ds_response {
let refund_status = enums::RefundStatus::try_from(ds_response.clone())?;
if connector_utils::is_refund_failure(refund_status) {
Err(ErrorResponse {
status_code: item.http_code,
code: ds_response.0.clone(),
message: ds_response.0.clone(),
reason: Some(ds_response.0.clone()),
attempt_status: None,
connector_transaction_id: None,
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
connector_metadata: None,
})
} else {
Ok(RefundsResponseData {
connector_refund_id: response.ds_order,
refund_status,
})
}
} else {
// When the refund is pending
Ok(RefundsResponseData {
connector_refund_id: response.ds_order,
refund_status: enums::RefundStatus::Pending,
})
}
}
(Some(_), Some(_)) | (None, None) => {
Err(errors::ConnectorError::ResponseHandlingFailed)?
}
};
Ok(Self {
response,
..item.data
})
}
}
|
{
"crate": "hyperswitch_connectors",
"file": "crates/hyperswitch_connectors/src/connectors/redsys/transformers.rs",
"file_size": null,
"is_async": null,
"is_pub": null,
"num_enums": 6,
"num_structs": 30,
"num_tables": null,
"score": null,
"total_crates": null
}
|
file_hyperswitch_connectors_-3199355361800483370
|
clm
|
file
|
// Repository: hyperswitch
// Crate: hyperswitch_connectors
// File: crates/hyperswitch_connectors/src/connectors/facilitapay/transformers.rs
// Contains: 2 structs, 0 enums
use api_models::payments::QrCodeInformation;
use common_enums::{enums, PaymentMethod};
use common_utils::{
errors::CustomResult,
ext_traits::{BytesExt, Encode},
new_type::MaskedBankAccount,
pii,
types::StringMajorUnit,
};
use error_stack::ResultExt;
use hyperswitch_domain_models::{
payment_method_data::{BankTransferData, PaymentMethodData},
router_data::{AccessToken, ConnectorAuthType, ErrorResponse, RouterData},
router_flow_types::{
payments::Void,
refunds::{Execute, RSync},
},
router_request_types::{PaymentsCancelData, ResponseId},
router_response_types::{
ConnectorCustomerResponseData, PaymentsResponseData, RefundsResponseData,
},
types,
};
use hyperswitch_interfaces::{
consts, errors, events::connector_api_logs::ConnectorEvent, types::Response,
};
use masking::{ExposeInterface, Secret};
use serde::{Deserialize, Serialize};
use time::PrimitiveDateTime;
use url::Url;
use super::{
requests::{
DocumentType, FacilitapayAuthRequest, FacilitapayCredentials, FacilitapayCustomerRequest,
FacilitapayPaymentsRequest, FacilitapayPerson, FacilitapayRouterData,
FacilitapayTransactionRequest, PixTransactionRequest,
},
responses::{
FacilitapayAuthResponse, FacilitapayCustomerResponse, FacilitapayPaymentStatus,
FacilitapayPaymentsResponse, FacilitapayRefundResponse, FacilitapayVoidResponse,
},
};
use crate::{
types::{RefreshTokenRouterData, RefundsResponseRouterData, ResponseRouterData},
utils::{self, is_payment_failure, missing_field_err, QrImage, RouterData as OtherRouterData},
};
type Error = error_stack::Report<errors::ConnectorError>;
impl<T> From<(StringMajorUnit, T)> for FacilitapayRouterData<T> {
fn from((amount, item): (StringMajorUnit, T)) -> Self {
Self {
amount,
router_data: item,
}
}
}
// Auth Struct
#[derive(Debug, Clone)]
pub struct FacilitapayAuthType {
pub(super) username: Secret<String>,
pub(super) password: Secret<String>,
}
#[derive(Debug, Serialize, Deserialize)]
pub struct FacilitapayConnectorMetadataObject {
// pub destination_account_number: Secret<String>,
pub destination_account_number: MaskedBankAccount,
}
// Helper to build the request from Hyperswitch Auth Type
impl FacilitapayAuthRequest {
fn from_auth_type(auth: &FacilitapayAuthType) -> Self {
Self {
user: FacilitapayCredentials {
username: auth.username.clone(),
password: auth.password.clone(),
},
}
}
}
impl TryFrom<&ConnectorAuthType> for FacilitapayAuthType {
type Error = Error;
fn try_from(auth_type: &ConnectorAuthType) -> Result<Self, Self::Error> {
match auth_type {
ConnectorAuthType::BodyKey { api_key, key1 } => Ok(Self {
username: key1.to_owned(),
password: api_key.to_owned(),
}),
_ => Err(errors::ConnectorError::FailedToObtainAuthType.into()),
}
}
}
impl TryFrom<&RefreshTokenRouterData> for FacilitapayAuthRequest {
type Error = Error;
fn try_from(item: &RefreshTokenRouterData) -> Result<Self, Self::Error> {
let auth_type = FacilitapayAuthType::try_from(&item.connector_auth_type)?;
Ok(Self::from_auth_type(&auth_type))
}
}
impl TryFrom<&Option<pii::SecretSerdeValue>> for FacilitapayConnectorMetadataObject {
type Error = Error;
fn try_from(meta_data: &Option<pii::SecretSerdeValue>) -> Result<Self, Self::Error> {
let metadata: Self = utils::to_connector_meta_from_secret(meta_data.clone())
.change_context(errors::ConnectorError::InvalidConnectorConfig {
config: "merchant_connector_account.metadata",
})?;
Ok(metadata)
}
}
impl TryFrom<&FacilitapayRouterData<&types::PaymentsAuthorizeRouterData>>
for FacilitapayPaymentsRequest
{
type Error = Error;
fn try_from(
item: &FacilitapayRouterData<&types::PaymentsAuthorizeRouterData>,
) -> Result<Self, Self::Error> {
let metadata =
FacilitapayConnectorMetadataObject::try_from(&item.router_data.connector_meta_data)?;
match item.router_data.request.payment_method_data.clone() {
PaymentMethodData::BankTransfer(bank_transfer_data) => match *bank_transfer_data {
BankTransferData::Pix {
source_bank_account_id,
..
} => {
// Set expiry time to 15 minutes from now
let dynamic_pix_expires_at = {
let now = time::OffsetDateTime::now_utc();
let expires_at = now + time::Duration::minutes(15);
PrimitiveDateTime::new(expires_at.date(), expires_at.time())
};
let transaction_data =
FacilitapayTransactionRequest::Pix(PixTransactionRequest {
// subject id must be generated by pre-process step and link with customer id
// might require discussions to be done
subject_id: item.router_data.get_connector_customer_id()?.into(),
from_bank_account_id: source_bank_account_id.clone().ok_or(
errors::ConnectorError::MissingRequiredField {
field_name: "source bank account id",
},
)?,
to_bank_account_id: metadata.destination_account_number,
currency: item.router_data.request.currency,
exchange_currency: item.router_data.request.currency,
value: item.amount.clone(),
use_dynamic_pix: true,
// Format: YYYY-MM-DDThh:mm:ssZ
dynamic_pix_expires_at,
});
Ok(Self {
transaction: transaction_data,
})
}
BankTransferData::AchBankTransfer {}
| BankTransferData::SepaBankTransfer {}
| BankTransferData::BacsBankTransfer {}
| BankTransferData::MultibancoBankTransfer {}
| BankTransferData::PermataBankTransfer {}
| BankTransferData::BcaBankTransfer {}
| BankTransferData::BniVaBankTransfer {}
| BankTransferData::BriVaBankTransfer {}
| BankTransferData::CimbVaBankTransfer {}
| BankTransferData::DanamonVaBankTransfer {}
| BankTransferData::MandiriVaBankTransfer {}
| BankTransferData::Pse {}
| BankTransferData::InstantBankTransfer {}
| BankTransferData::InstantBankTransferFinland {}
| BankTransferData::InstantBankTransferPoland {}
| BankTransferData::IndonesianBankTransfer { .. }
| BankTransferData::LocalBankTransfer { .. } => {
Err(errors::ConnectorError::NotImplemented(
"Selected payment method through Facilitapay".to_string(),
)
.into())
}
},
PaymentMethodData::Card(_)
| PaymentMethodData::CardRedirect(_)
| PaymentMethodData::Wallet(_)
| PaymentMethodData::PayLater(_)
| PaymentMethodData::BankRedirect(_)
| PaymentMethodData::BankDebit(_)
| PaymentMethodData::Crypto(_)
| PaymentMethodData::MandatePayment
| PaymentMethodData::Reward
| PaymentMethodData::RealTimePayment(_)
| PaymentMethodData::MobilePayment(_)
| PaymentMethodData::Upi(_)
| PaymentMethodData::Voucher(_)
| PaymentMethodData::GiftCard(_)
| PaymentMethodData::CardToken(_)
| PaymentMethodData::OpenBanking(_)
| PaymentMethodData::NetworkToken(_)
| PaymentMethodData::CardDetailsForNetworkTransactionId(_) => {
Err(errors::ConnectorError::NotImplemented(
"Selected payment method through Facilitapay".to_string(),
)
.into())
}
}
}
}
fn convert_to_document_type(document_type: &str) -> Result<DocumentType, errors::ConnectorError> {
match document_type.to_lowercase().as_str() {
"cc" => Ok(DocumentType::CedulaDeCiudadania),
"cnpj" => Ok(DocumentType::CadastroNacionaldaPessoaJurídica),
"cpf" => Ok(DocumentType::CadastrodePessoasFísicas),
"curp" => Ok(DocumentType::ClaveÚnicadeRegistrodePoblación),
"nit" => Ok(DocumentType::NúmerodeIdentificaciónTributaria),
"passport" => Ok(DocumentType::Passport),
"rfc" => Ok(DocumentType::RegistroFederaldeContribuyentes),
"rut" => Ok(DocumentType::RolUnicoTributario),
"tax_id" | "taxid" => Ok(DocumentType::TaxId),
_ => Err(errors::ConnectorError::NotSupported {
message: format!("Document type '{document_type}'"),
connector: "Facilitapay",
}),
}
}
pub fn parse_facilitapay_error_response(
res: Response,
event_builder: Option<&mut ConnectorEvent>,
) -> CustomResult<ErrorResponse, errors::ConnectorError> {
let status_code = res.status_code;
let response_body_bytes = res.response.clone();
let (message, raw_error) =
match response_body_bytes.parse_struct::<serde_json::Value>("FacilitapayErrorResponse") {
Ok(json_value) => {
event_builder.map(|i| i.set_response_body(&json_value));
let message = extract_message_from_json(&json_value);
(
message,
serde_json::to_string(&json_value).unwrap_or_default(),
)
}
Err(_) => match String::from_utf8(response_body_bytes.to_vec()) {
Ok(text) => {
event_builder.map(|i| i.set_response_body(&text));
(text.clone(), text)
}
Err(_) => (
"Invalid response format received".to_string(),
format!(
"Unable to parse response as JSON or UTF-8 string. Status code: {status_code}",
),
),
},
};
Ok(ErrorResponse {
status_code,
code: consts::NO_ERROR_CODE.to_string(),
message,
reason: Some(raw_error),
attempt_status: None,
connector_transaction_id: None,
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
connector_metadata: None,
})
}
// Helper function to extract a readable message from JSON error
fn extract_message_from_json(json: &serde_json::Value) -> String {
if let Some(obj) = json.as_object() {
if let Some(error) = obj.get("error").and_then(|e| e.as_str()) {
return error.to_string();
}
if obj.contains_key("errors") {
return "Validation error occurred".to_string();
}
if !obj.is_empty() {
return obj
.iter()
.next()
.map(|(k, v)| format!("{k}: {v}"))
.unwrap_or_else(|| "Unknown error".to_string());
}
} else if let Some(s) = json.as_str() {
return s.to_string();
}
"Unknown error format".to_string()
}
impl TryFrom<&types::ConnectorCustomerRouterData> for FacilitapayCustomerRequest {
type Error = Error;
fn try_from(item: &types::ConnectorCustomerRouterData) -> Result<Self, Self::Error> {
let email = item.request.email.clone();
let social_name = item.get_billing_full_name()?;
let (document_type, document_number) = match item.request.payment_method_data.clone() {
Some(PaymentMethodData::BankTransfer(bank_transfer_data)) => {
match *bank_transfer_data {
BankTransferData::Pix { cpf, .. } => {
// Extract only digits from the CPF string
let document_number =
cpf.ok_or_else(missing_field_err("cpf"))?.map(|cpf_number| {
cpf_number
.chars()
.filter(|chars| chars.is_ascii_digit())
.collect::<String>()
});
let document_type = convert_to_document_type("cpf")?;
(document_type, document_number)
}
_ => {
return Err(errors::ConnectorError::NotImplemented(
"Selected payment method through Facilitapay".to_string(),
)
.into())
}
}
}
_ => {
return Err(errors::ConnectorError::NotImplemented(
"Selected payment method through Facilitapay".to_string(),
)
.into())
}
};
let fiscal_country = item.get_billing_country()?;
let person = FacilitapayPerson {
document_number,
document_type,
social_name,
fiscal_country,
email,
birth_date: None,
phone_country_code: None,
phone_area_code: None,
phone_number: None,
address_city: None,
address_state: None,
address_complement: None,
address_country: None,
address_number: None,
address_postal_code: None,
address_street: None,
net_monthly_average_income: None,
};
Ok(Self { person })
}
}
impl<F, T> TryFrom<ResponseRouterData<F, FacilitapayCustomerResponse, T, PaymentsResponseData>>
for RouterData<F, T, PaymentsResponseData>
{
type Error = Error;
fn try_from(
item: ResponseRouterData<F, FacilitapayCustomerResponse, T, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
Ok(Self {
response: Ok(PaymentsResponseData::ConnectorCustomerResponse(
ConnectorCustomerResponseData::new_with_customer_id(
item.response.data.customer_id.expose(),
),
)),
..item.data
})
}
}
impl From<FacilitapayPaymentStatus> for common_enums::AttemptStatus {
fn from(item: FacilitapayPaymentStatus) -> Self {
match item {
FacilitapayPaymentStatus::Pending => Self::Pending,
FacilitapayPaymentStatus::Identified
| FacilitapayPaymentStatus::Exchanged
| FacilitapayPaymentStatus::Wired => Self::Charged,
FacilitapayPaymentStatus::Cancelled => Self::Failure,
}
}
}
impl<F, T> TryFrom<ResponseRouterData<F, FacilitapayAuthResponse, T, AccessToken>>
for RouterData<F, T, AccessToken>
{
type Error = Error;
fn try_from(
item: ResponseRouterData<F, FacilitapayAuthResponse, T, AccessToken>,
) -> Result<Self, Self::Error> {
Ok(Self {
response: Ok(AccessToken {
token: item.response.jwt,
expires: 86400, // Facilitapay docs say 24 hours validity. 24 * 60 * 60 = 86400 seconds.
}),
..item.data
})
}
}
impl<F, T> TryFrom<ResponseRouterData<F, FacilitapayPaymentsResponse, T, PaymentsResponseData>>
for RouterData<F, T, PaymentsResponseData>
{
type Error = Error;
fn try_from(
item: ResponseRouterData<F, FacilitapayPaymentsResponse, T, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
let status = if item.data.payment_method == PaymentMethod::BankTransfer
&& item.response.data.status == FacilitapayPaymentStatus::Identified
{
if item.response.data.currency != item.response.data.exchange_currency {
// Cross-currency: Identified is not terminal
common_enums::AttemptStatus::Pending
} else {
// Local currency: Identified is terminal
common_enums::AttemptStatus::Charged
}
} else {
common_enums::AttemptStatus::from(item.response.data.status.clone())
};
Ok(Self {
status,
response: if is_payment_failure(status) {
Err(ErrorResponse {
code: item.response.data.status.clone().to_string(),
message: item.response.data.status.clone().to_string(),
reason: item.response.data.cancelled_reason,
status_code: item.http_code,
attempt_status: None,
connector_transaction_id: Some(item.response.data.transaction_id),
network_decline_code: None,
network_advice_code: None,
network_error_message: None,
connector_metadata: None,
})
} else {
Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(
item.response.data.transaction_id.clone(),
),
redirection_data: Box::new(None),
mandate_reference: Box::new(None),
connector_metadata: get_qr_code_data(&item.response)?,
network_txn_id: None,
connector_response_reference_id: Some(item.response.data.transaction_id),
incremental_authorization_allowed: None,
charges: None,
})
},
..item.data
})
}
}
fn get_qr_code_data(
response: &FacilitapayPaymentsResponse,
) -> CustomResult<Option<serde_json::Value>, errors::ConnectorError> {
let expiration_time: i64 = if let Some(meta) = &response.data.meta {
if let Some(due_date_str) = meta
.get("dynamic_pix_due_date")
.and_then(|due_date_value| due_date_value.as_str())
{
let datetime = time::OffsetDateTime::parse(
due_date_str,
&time::format_description::well_known::Rfc3339,
)
.map_err(|_| errors::ConnectorError::ResponseHandlingFailed)?;
datetime.unix_timestamp() * 1000
} else {
// If dynamic_pix_due_date isn't present, use current time + 15 minutes
let now = time::OffsetDateTime::now_utc();
let expires_at = now + time::Duration::minutes(15);
expires_at.unix_timestamp() * 1000
}
} else {
// If meta is null, use current time + 15 minutes
let now = time::OffsetDateTime::now_utc();
let expires_at = now + time::Duration::minutes(15);
expires_at.unix_timestamp() * 1000
};
let dynamic_pix_code = response.data.dynamic_pix_code.as_ref().ok_or_else(|| {
errors::ConnectorError::MissingRequiredField {
field_name: "dynamic_pix_code",
}
})?;
let image_data = QrImage::new_from_data(dynamic_pix_code.clone())
.change_context(errors::ConnectorError::ResponseHandlingFailed)?;
let image_data_url = Url::parse(image_data.data.clone().as_str())
.change_context(errors::ConnectorError::ResponseHandlingFailed)?;
let qr_code_info = QrCodeInformation::QrDataUrl {
image_data_url,
display_to_timestamp: Some(expiration_time),
};
Some(qr_code_info.encode_to_value())
.transpose()
.change_context(errors::ConnectorError::ResponseHandlingFailed)
}
impl From<FacilitapayPaymentStatus> for enums::RefundStatus {
fn from(item: FacilitapayPaymentStatus) -> Self {
match item {
FacilitapayPaymentStatus::Identified
| FacilitapayPaymentStatus::Exchanged
| FacilitapayPaymentStatus::Wired => Self::Success,
FacilitapayPaymentStatus::Cancelled => Self::Failure,
FacilitapayPaymentStatus::Pending => Self::Pending,
}
}
}
// Void (cancel unprocessed payment) transformer
impl
TryFrom<
ResponseRouterData<Void, FacilitapayVoidResponse, PaymentsCancelData, PaymentsResponseData>,
> for RouterData<Void, PaymentsCancelData, PaymentsResponseData>
{
type Error = Error;
fn try_from(
item: ResponseRouterData<
Void,
FacilitapayVoidResponse,
PaymentsCancelData,
PaymentsResponseData,
>,
) -> Result<Self, Self::Error> {
let status = common_enums::AttemptStatus::from(item.response.data.status.clone());
Ok(Self {
status,
response: if is_payment_failure(status) {
Err(ErrorResponse {
code: item.response.data.status.clone().to_string(),
message: item.response.data.status.clone().to_string(),
reason: item.response.data.reason,
status_code: item.http_code,
attempt_status: None,
connector_transaction_id: Some(item.response.data.void_id.clone()),
network_decline_code: None,
network_advice_code: None,
network_error_message: None,
connector_metadata: None,
})
} else {
Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(
item.response.data.void_id.clone(),
),
redirection_data: Box::new(None),
mandate_reference: Box::new(None),
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: Some(item.response.data.void_id),
incremental_authorization_allowed: None,
charges: None,
})
},
..item.data
})
}
}
impl TryFrom<RefundsResponseRouterData<Execute, FacilitapayRefundResponse>>
for types::RefundsRouterData<Execute>
{
type Error = Error;
fn try_from(
item: RefundsResponseRouterData<Execute, FacilitapayRefundResponse>,
) -> Result<Self, Self::Error> {
Ok(Self {
response: Ok(RefundsResponseData {
connector_refund_id: item.response.data.transaction_id.clone(),
refund_status: enums::RefundStatus::from(item.response.data.status),
}),
..item.data
})
}
}
impl TryFrom<RefundsResponseRouterData<RSync, FacilitapayRefundResponse>>
for types::RefundsRouterData<RSync>
{
type Error = Error;
fn try_from(
item: RefundsResponseRouterData<RSync, FacilitapayRefundResponse>,
) -> Result<Self, Self::Error> {
Ok(Self {
response: Ok(RefundsResponseData {
connector_refund_id: item.response.data.transaction_id.clone(),
refund_status: enums::RefundStatus::from(item.response.data.status),
}),
..item.data
})
}
}
|
{
"crate": "hyperswitch_connectors",
"file": "crates/hyperswitch_connectors/src/connectors/facilitapay/transformers.rs",
"file_size": null,
"is_async": null,
"is_pub": null,
"num_enums": 0,
"num_structs": 2,
"num_tables": null,
"score": null,
"total_crates": null
}
|
file_hyperswitch_connectors_4231903204286979468
|
clm
|
file
|
// Repository: hyperswitch
// Crate: hyperswitch_connectors
// File: crates/hyperswitch_connectors/src/connectors/facilitapay/responses.rs
// Contains: 5 structs, 2 enums
use common_utils::{pii, types::StringMajorUnit};
use masking::Secret;
use serde::{Deserialize, Serialize};
use super::requests::DocumentType;
// Response body for POST /sign_in
#[derive(Debug, Deserialize, Serialize)]
pub struct FacilitapayAuthResponse {
username: Secret<String>,
name: Secret<String>,
pub jwt: Secret<String>,
}
#[derive(Debug, Deserialize, Serialize, Clone, PartialEq, Eq)]
#[serde(rename_all = "snake_case")]
pub enum SubjectKycStatus {
// Customer is able to send/receive money through the platform. No action is needed on your side.
Approved,
// Customer is required to upload documents or uploaded documents have been rejected by KYC.
Reproved,
// Customer has uploaded KYC documents but awaiting analysis from the backoffice. No action is needed on your side.
WaitingApproval,
}
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
#[serde(rename_all = "snake_case")]
pub struct FacilitapaySubject {
pub social_name: Secret<String>,
pub document_type: DocumentType,
pub document_number: Secret<String>,
// In documentation, both CountryAlpha2 and String are used. We cannot rely on CountryAlpha2.
pub fiscal_country: String,
pub updated_at: Option<String>,
pub status: SubjectKycStatus,
#[serde(rename = "id")]
pub customer_id: Secret<String>,
pub birth_date: Option<time::Date>,
pub email: Option<pii::Email>,
pub phone_country_code: Option<Secret<String>>,
pub phone_area_code: Option<Secret<String>>,
pub phone_number: Option<Secret<String>>,
pub address_street: Option<Secret<String>>,
pub address_number: Option<Secret<String>>,
pub address_complement: Option<Secret<String>>,
pub address_city: Option<String>,
pub address_state: Option<String>,
pub address_postal_code: Option<Secret<String>>,
pub address_country: Option<String>,
pub address_neighborhood: Option<Secret<String>>,
pub net_monthly_average_income: Option<StringMajorUnit>,
pub clearance_level: Option<i32>,
pub required_clearance_level: Option<i32>,
pub inserted_at: Option<String>,
pub references: Option<Vec<serde_json::Value>>,
pub rfc_pf: Option<Secret<String>>, // 13-digit RFC, specific to Mexico users
pub documents: Option<Vec<serde_json::Value>>,
}
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
#[serde(rename_all = "snake_case")]
pub struct FacilitapayCustomerResponse {
pub data: FacilitapaySubject,
}
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct PixInfo {
#[serde(rename = "type")]
pub key_type: String,
pub key: Secret<String>,
}
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct CreditCardResponseInfo {
pub id: String,
pub status: Option<String>,
pub document_type: String,
pub document_number: Secret<String>,
pub birthdate: Option<String>,
pub phone_country_code: Option<String>,
pub phone_area_code: Option<String>,
pub phone_number: Option<Secret<String>>,
pub inserted_at: Option<String>,
}
// PaymentsResponse
#[derive(Debug, Clone, Default, Serialize, Deserialize, PartialEq, Eq)]
#[serde(rename_all = "snake_case")]
#[derive(strum::Display)]
pub enum FacilitapayPaymentStatus {
/// Transaction has been created but it is waiting for an incoming TED/Wire.
/// This is the first recorded status in production mode.
#[default]
Pending,
/// Incoming TED/Wire has been identified into Facilita´s bank account.
/// When it is a deposit into an internal bank account and there is no
/// conversion involved (BRL to BRL for instance), that is the final state.
Identified,
/// The conversion rate has been closed and therefore the exchanged value
/// is defined - when it is a deposit into an internal bank account, that is the final state.
Exchanged,
/// The exchanged value has been wired to its destination (a real bank account) - that is also a final state.
Wired,
/// When for any reason the transaction cannot be concluded or need to be reversed, it is canceled.
#[serde(rename = "canceled")]
Cancelled,
}
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct FacilitapayPaymentsResponse {
pub data: TransactionData,
}
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct OwnerCompany {
pub social_name: Option<Secret<String>>,
#[serde(rename = "id")]
pub company_id: Option<String>,
pub document_type: DocumentType,
pub document_number: Secret<String>,
}
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct BankInfo {
pub swift: Option<Secret<String>>,
pub name: Option<String>,
#[serde(rename = "id")]
pub bank_id: Secret<String>,
pub code: Option<Secret<String>>,
}
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct BankAccountDetail {
pub routing_number: Option<Secret<String>>,
pub pix_info: Option<PixInfo>,
pub owner_name: Option<Secret<String>>,
pub owner_document_type: Option<String>,
pub owner_document_number: Option<Secret<String>>,
pub owner_company: Option<OwnerCompany>,
pub internal: Option<bool>,
pub intermediary_bank_account: Option<Secret<String>>,
pub intermediary_bank_account_id: Option<Secret<String>>,
#[serde(rename = "id")]
pub bank_account_id: Secret<String>,
pub iban: Option<Secret<String>>,
pub flow_type: Option<String>,
pub currency: api_models::enums::Currency,
pub branch_number: Option<Secret<String>>,
pub branch_country: Option<String>,
pub bank: Option<BankInfo>,
pub account_type: Option<String>,
pub account_number: Option<Secret<String>>,
pub aba: Option<String>,
}
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct TransactionData {
#[serde(rename = "id")]
pub transaction_id: String,
pub value: StringMajorUnit,
pub status: FacilitapayPaymentStatus,
pub currency: api_models::enums::Currency,
pub exchange_currency: api_models::enums::Currency,
// Details about the destination account (Required)
pub to_bank_account: BankAccountDetail,
// Details about the source - mutually exclusive
pub from_credit_card: Option<CreditCardResponseInfo>,
pub from_bank_account: Option<BankAccountDetail>, // Populated for PIX
// Subject information (customer)
pub subject_id: String,
pub subject: Option<FacilitapaySubject>,
pub subject_is_receiver: Option<bool>,
// Source identification (potentially redundant with subject or card/bank info)
pub source_name: Option<Secret<String>>,
pub source_document_type: DocumentType,
pub source_document_number: Secret<String>,
// Timestamps and flags
pub inserted_at: Option<String>,
pub for_exchange: Option<bool>,
pub exchange_under_request: Option<bool>,
pub estimated_value_until_exchange: Option<bool>,
pub cleared: Option<bool>,
// PIX specific field
pub dynamic_pix_code: Option<String>, // QR code string for PIX
// Exchange details
pub exchanged_value: Option<StringMajorUnit>,
// Cancelation details
#[serde(rename = "canceled_reason")]
pub cancelled_reason: Option<String>,
#[serde(rename = "canceled_at")]
pub cancelled_at: Option<String>,
// Other fields
pub bank_transaction: Option<Secret<serde_json::Value>>,
pub meta: Option<serde_json::Value>,
}
// Void response structures (for /refund endpoint)
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct VoidBankTransaction {
#[serde(rename = "id")]
pub transaction_id: String,
pub value: StringMajorUnit,
pub currency: api_models::enums::Currency,
pub iof_value: Option<StringMajorUnit>,
pub fx_value: Option<StringMajorUnit>,
pub exchange_rate: Option<StringMajorUnit>,
pub exchange_currency: api_models::enums::Currency,
pub exchanged_value: StringMajorUnit,
pub exchange_approved: bool,
pub wire_id: Option<String>,
pub exchange_id: Option<String>,
pub movement_date: String,
pub source_name: Secret<String>,
pub source_document_number: Secret<String>,
pub source_document_type: String,
pub source_id: String,
pub source_type: String,
pub source_description: String,
pub source_bank: Option<String>,
pub source_branch: Option<String>,
pub source_account: Option<String>,
pub source_bank_ispb: Option<String>,
pub company_id: String,
pub company_name: String,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct VoidData {
#[serde(rename = "id")]
pub void_id: String,
pub reason: Option<String>,
pub inserted_at: String,
pub status: FacilitapayPaymentStatus,
pub transaction_kind: String,
pub bank_transaction: VoidBankTransaction,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct FacilitapayVoidResponse {
pub data: VoidData,
}
// Refund response uses the same TransactionData structure as payments
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct FacilitapayRefundResponse {
pub data: TransactionData,
}
// Webhook structures
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct FacilitapayWebhookNotification {
pub notification: FacilitapayWebhookBody,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub struct FacilitapayWebhookBody {
#[serde(rename = "type")]
pub event_type: FacilitapayWebhookEventType,
pub secret: Secret<String>,
#[serde(flatten)]
pub data: FacilitapayWebhookData,
}
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum FacilitapayWebhookEventType {
ExchangeCreated,
Identified,
PaymentApproved,
PaymentExpired,
PaymentFailed,
PaymentRefunded,
WireCreated,
WireWaitingCorrection,
}
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
#[serde(rename_all = "UPPERCASE")]
pub enum FacilitapayWebhookErrorCode {
/// Creditor account number invalid or missing (branch_number or account_number incorrect)
Ac03,
/// Creditor account type missing or invalid (account_type incorrect)
Ac14,
/// Value in Creditor Identifier is incorrect (owner_document_number incorrect)
Ch11,
/// Transaction type not supported/authorized on this account (account rejected the payment)
Ag03,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum FacilitapayWebhookData {
CardPayment {
transaction_id: String,
checkout_id: Option<String>,
},
Exchange {
exchange_id: String,
transaction_ids: Vec<String>,
},
Transaction {
transaction_id: String,
},
Wire {
wire_id: String,
transaction_ids: Vec<String>,
},
WireError {
error_code: FacilitapayWebhookErrorCode,
error_description: String,
bank_account_owner_id: String,
bank_account_id: String,
transaction_ids: Vec<String>,
wire_id: String,
},
}
|
{
"crate": "hyperswitch_connectors",
"file": "crates/hyperswitch_connectors/src/connectors/facilitapay/responses.rs",
"file_size": null,
"is_async": null,
"is_pub": null,
"num_enums": 2,
"num_structs": 5,
"num_tables": null,
"score": null,
"total_crates": null
}
|
file_hyperswitch_connectors_-2299534735645046501
|
clm
|
file
|
// Repository: hyperswitch
// Crate: hyperswitch_connectors
// File: crates/hyperswitch_connectors/src/connectors/facilitapay/requests.rs
// Contains: 7 structs, 2 enums
use common_enums::CountryAlpha2;
use common_utils::{new_type::MaskedBankAccount, pii, types::StringMajorUnit};
use masking::Secret;
use serde::{Deserialize, Serialize};
use time::PrimitiveDateTime;
pub struct FacilitapayRouterData<T> {
pub amount: StringMajorUnit,
pub router_data: T,
}
#[derive(Debug, Serialize)]
pub struct FacilitapayAuthRequest {
pub user: FacilitapayCredentials,
}
#[derive(Debug, Serialize)]
pub struct FacilitapayCredentials {
pub username: Secret<String>, // email_id
pub password: Secret<String>,
}
#[derive(Debug, Serialize, PartialEq)]
pub struct FacilitapayCardDetails {
#[serde(rename = "card_number")]
pub number: cards::CardNumber,
#[serde(rename = "card_expiration_date")]
pub expiry_date: Secret<String>, // Format: "MM/YYYY"
#[serde(rename = "card_security_code")]
pub cvc: Secret<String>,
#[serde(rename = "card_brand")]
pub brand: String,
pub fullname: Secret<String>,
}
#[derive(Debug, Serialize, PartialEq)]
pub struct CardTransactionRequest {
pub currency: api_models::enums::Currency,
pub exchange_currency: api_models::enums::Currency,
pub value: StringMajorUnit,
pub from_credit_card: FacilitapayCardDetails,
pub to_bank_account_id: Secret<String>, // UUID
pub subject_id: String, // UUID
}
#[derive(Debug, Serialize, PartialEq)]
pub struct PixTransactionRequest {
pub subject_id: Secret<String>, // Customer ID (UUID)
pub from_bank_account_id: MaskedBankAccount, // UUID
pub to_bank_account_id: MaskedBankAccount, // UUID
pub currency: api_models::enums::Currency,
pub exchange_currency: api_models::enums::Currency,
pub value: StringMajorUnit,
pub use_dynamic_pix: bool,
#[serde(default, with = "common_utils::custom_serde::iso8601")]
pub dynamic_pix_expires_at: PrimitiveDateTime,
}
#[derive(Debug, Serialize, PartialEq)]
#[serde(untagged)]
pub enum FacilitapayTransactionRequest {
#[allow(dead_code)]
Card(CardTransactionRequest),
Pix(PixTransactionRequest),
}
#[derive(Debug, Serialize, PartialEq)]
pub struct FacilitapayPaymentsRequest {
pub transaction: FacilitapayTransactionRequest,
}
#[derive(Debug, Serialize, PartialEq)]
#[serde(rename_all = "snake_case")]
pub struct FacilitapayCustomerRequest {
pub person: FacilitapayPerson,
}
#[derive(Debug, Serialize, Clone, Deserialize, PartialEq, Eq)]
#[serde(rename_all = "snake_case")]
pub enum DocumentType {
/// CC is the Cedula de Ciudadania, is a 10-digit number, which is the national identity card for Colombian citizens.
/// It is used for citizen identification purposes.
#[serde(rename = "cc")]
CedulaDeCiudadania,
/// CNPJ stands for Cadastro Nacional da Pessoa Jurídica, is a 14-digit number,
/// which is the national registry of legal entities in Brazil used as a unique identifier for Brazilian companies.
#[serde(rename = "cnpj")]
CadastroNacionaldaPessoaJurídica,
/// CPF stands for Cadastro de Pessoas Físicas, is a 11-digit number,
/// which is the national registry of natural persons in Brazil used as a unique identifier for Brazilian citizens.
#[serde(rename = "cpf")]
CadastrodePessoasFísicas,
/// CURP stands for Clave Única de Registro de Población,is a 18-digit number used as a unique identifier for Mexican citizens.
/// It is used to track tax information and other identification purposes by the government.
#[serde(rename = "curp")]
ClaveÚnicadeRegistrodePoblación,
/// NIT is the Número de Identificación Tributaria, is a 10-digit number, which is the tax identification number in Colombia. Used for companies.
#[serde(rename = "nit")]
NúmerodeIdentificaciónTributaria,
/// Passport is the travel document usually issued by a country's government
Passport,
/// RFC stands for Registro Federal de Contribuyentes, is a 13-digit number used as a unique identifier for Mexican companies.
#[serde(rename = "rfc")]
RegistroFederaldeContribuyentes,
/// RUT stands for Rol Unico Tributario, is a 9-digit number used as a unique identifier for Chilean citizens and companies.
#[serde(rename = "rut")]
RolUnicoTributario,
/// A Taxpayer Identification Number is an identifying number used for tax purposes
TaxId,
}
#[derive(Debug, Serialize, PartialEq)]
#[serde(rename_all = "snake_case")]
pub struct FacilitapayPerson {
pub document_number: Secret<String>,
pub document_type: DocumentType,
pub social_name: Secret<String>,
pub fiscal_country: CountryAlpha2,
#[serde(skip_serializing_if = "Option::is_none")]
pub email: Option<pii::Email>,
#[serde(skip_serializing_if = "Option::is_none")]
pub birth_date: Option<time::Date>,
#[serde(skip_serializing_if = "Option::is_none")]
pub phone_country_code: Option<Secret<String>>,
#[serde(skip_serializing_if = "Option::is_none")]
pub phone_area_code: Option<Secret<String>>,
#[serde(skip_serializing_if = "Option::is_none")]
pub phone_number: Option<Secret<String>>,
#[serde(skip_serializing_if = "Option::is_none")]
pub address_city: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub address_state: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub address_complement: Option<Secret<String>>,
#[serde(skip_serializing_if = "Option::is_none")]
pub address_country: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub address_number: Option<Secret<String>>,
#[serde(skip_serializing_if = "Option::is_none")]
pub address_postal_code: Option<Secret<String>>,
#[serde(skip_serializing_if = "Option::is_none")]
pub address_street: Option<Secret<String>>,
pub net_monthly_average_income: Option<StringMajorUnit>,
}
|
{
"crate": "hyperswitch_connectors",
"file": "crates/hyperswitch_connectors/src/connectors/facilitapay/requests.rs",
"file_size": null,
"is_async": null,
"is_pub": null,
"num_enums": 2,
"num_structs": 7,
"num_tables": null,
"score": null,
"total_crates": null
}
|
file_hyperswitch_connectors_3137688691015931280
|
clm
|
file
|
// Repository: hyperswitch
// Crate: hyperswitch_connectors
// File: crates/hyperswitch_connectors/src/connectors/digitalvirgo/transformers.rs
// Contains: 9 structs, 3 enums
use common_enums::enums;
use common_utils::types::FloatMajorUnit;
use error_stack::ResultExt;
use hyperswitch_domain_models::{
payment_method_data::{MobilePaymentData, PaymentMethodData},
router_data::{ConnectorAuthType, RouterData},
router_flow_types::refunds::{Execute, RSync},
router_request_types::ResponseId,
router_response_types::{PaymentsResponseData, RefundsResponseData},
types::{PaymentsAuthorizeRouterData, PaymentsCompleteAuthorizeRouterData, RefundsRouterData},
};
use hyperswitch_interfaces::errors;
use masking::{ExposeInterface, Secret};
use serde::{Deserialize, Serialize};
use crate::{
types::{RefundsResponseRouterData, ResponseRouterData},
utils::{PaymentsAuthorizeRequestData, PaymentsCompleteAuthorizeRequestData},
};
pub struct DigitalvirgoRouterData<T> {
pub amount: FloatMajorUnit,
pub surcharge_amount: Option<FloatMajorUnit>,
pub router_data: T,
}
impl<T> From<(FloatMajorUnit, Option<FloatMajorUnit>, T)> for DigitalvirgoRouterData<T> {
fn from((amount, surcharge_amount, item): (FloatMajorUnit, Option<FloatMajorUnit>, T)) -> Self {
Self {
amount,
surcharge_amount,
router_data: item,
}
}
}
#[derive(Default, Debug, Serialize, PartialEq)]
#[serde(rename_all = "camelCase")]
pub struct DigitalvirgoPaymentsRequest {
amount: FloatMajorUnit,
amount_surcharge: Option<FloatMajorUnit>,
client_uid: Option<String>,
msisdn: String,
product_name: String,
description: Option<String>,
partner_transaction_id: String,
}
impl TryFrom<&DigitalvirgoRouterData<&PaymentsAuthorizeRouterData>>
for DigitalvirgoPaymentsRequest
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: &DigitalvirgoRouterData<&PaymentsAuthorizeRouterData>,
) -> Result<Self, Self::Error> {
match item.router_data.request.payment_method_data.clone() {
PaymentMethodData::MobilePayment(mobile_payment_data) => match mobile_payment_data {
MobilePaymentData::DirectCarrierBilling { msisdn, client_uid } => {
let order_details = item.router_data.request.get_order_details()?;
let product_name = order_details
.first()
.map(|order| order.product_name.to_owned())
.ok_or(errors::ConnectorError::MissingRequiredField {
field_name: "product_name",
})?;
Ok(Self {
amount: item.amount.to_owned(),
amount_surcharge: item.surcharge_amount.to_owned(),
client_uid,
msisdn,
product_name,
description: item.router_data.description.to_owned(),
partner_transaction_id: item
.router_data
.connector_request_reference_id
.to_owned(),
})
}
},
_ => Err(errors::ConnectorError::NotImplemented("Payment method".to_string()).into()),
}
}
}
pub struct DigitalvirgoAuthType {
pub(super) username: Secret<String>,
pub(super) password: Secret<String>,
}
impl TryFrom<&ConnectorAuthType> for DigitalvirgoAuthType {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(auth_type: &ConnectorAuthType) -> Result<Self, Self::Error> {
match auth_type {
ConnectorAuthType::BodyKey { api_key, key1 } => Ok(Self {
username: key1.to_owned(),
password: api_key.to_owned(),
}),
_ => Err(errors::ConnectorError::FailedToObtainAuthType.into()),
}
}
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
pub enum DigitalvirgoPaymentStatus {
Ok,
ConfirmPayment,
}
impl From<DigitalvirgoPaymentStatus> for common_enums::AttemptStatus {
fn from(item: DigitalvirgoPaymentStatus) -> Self {
match item {
DigitalvirgoPaymentStatus::Ok => Self::Charged,
DigitalvirgoPaymentStatus::ConfirmPayment => Self::AuthenticationPending,
}
}
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct DigitalvirgoPaymentsResponse {
state: DigitalvirgoPaymentStatus,
transaction_id: String,
consent: Option<DigitalvirgoConsentStatus>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DigitalvirgoConsentStatus {
required: Option<bool>,
}
impl<F, T> TryFrom<ResponseRouterData<F, DigitalvirgoPaymentsResponse, T, PaymentsResponseData>>
for RouterData<F, T, PaymentsResponseData>
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: ResponseRouterData<F, DigitalvirgoPaymentsResponse, T, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
// show if consent is required in next action
let connector_metadata = item
.response
.consent
.and_then(|consent_status| {
consent_status.required.map(|consent_required| {
if consent_required {
serde_json::json!({
"consent_data_required": "consent_required",
})
} else {
serde_json::json!({
"consent_data_required": "consent_not_required",
})
}
})
})
.or(Some(serde_json::json!({
"consent_data_required": "consent_not_required",
})));
Ok(Self {
status: common_enums::AttemptStatus::from(item.response.state),
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(item.response.transaction_id),
redirection_data: Box::new(None),
mandate_reference: Box::new(None),
connector_metadata,
network_txn_id: None,
connector_response_reference_id: None,
incremental_authorization_allowed: None,
charges: None,
}),
..item.data
})
}
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
pub enum DigitalvirgoPaymentSyncStatus {
Accepted,
Payed,
Pending,
Cancelled,
Rejected,
Locked,
}
impl From<DigitalvirgoPaymentSyncStatus> for common_enums::AttemptStatus {
fn from(item: DigitalvirgoPaymentSyncStatus) -> Self {
match item {
DigitalvirgoPaymentSyncStatus::Accepted => Self::AuthenticationPending,
DigitalvirgoPaymentSyncStatus::Payed => Self::Charged,
DigitalvirgoPaymentSyncStatus::Pending | DigitalvirgoPaymentSyncStatus::Locked => {
Self::Pending
}
DigitalvirgoPaymentSyncStatus::Cancelled => Self::Voided,
DigitalvirgoPaymentSyncStatus::Rejected => Self::Failure,
}
}
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct DigitalvirgoPaymentSyncResponse {
payment_status: DigitalvirgoPaymentSyncStatus,
transaction_id: String,
}
impl<F, T> TryFrom<ResponseRouterData<F, DigitalvirgoPaymentSyncResponse, T, PaymentsResponseData>>
for RouterData<F, T, PaymentsResponseData>
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: ResponseRouterData<F, DigitalvirgoPaymentSyncResponse, T, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
Ok(Self {
status: common_enums::AttemptStatus::from(item.response.payment_status),
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(item.response.transaction_id),
redirection_data: Box::new(None),
mandate_reference: Box::new(None),
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: None,
incremental_authorization_allowed: None,
charges: None,
}),
..item.data
})
}
}
#[derive(Default, Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct DigitalvirgoConfirmRequest {
transaction_id: String,
token: Secret<String>,
}
#[derive(Default, Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct DigitalvirgoRedirectResponseData {
otp: Secret<String>,
}
impl TryFrom<&PaymentsCompleteAuthorizeRouterData> for DigitalvirgoConfirmRequest {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(item: &PaymentsCompleteAuthorizeRouterData) -> Result<Self, Self::Error> {
let payload_data = item.request.get_redirect_response_payload()?.expose();
let otp_data: DigitalvirgoRedirectResponseData = serde_json::from_value(payload_data)
.change_context(errors::ConnectorError::MissingConnectorRedirectionPayload {
field_name: "otp for transaction",
})?;
Ok(Self {
transaction_id: item
.request
.connector_transaction_id
.clone()
.ok_or(errors::ConnectorError::MissingConnectorTransactionID)?,
token: otp_data.otp,
})
}
}
#[derive(Default, Debug, Serialize)]
pub struct DigitalvirgoRefundRequest {
pub amount: FloatMajorUnit,
}
impl<F> TryFrom<&DigitalvirgoRouterData<&RefundsRouterData<F>>> for DigitalvirgoRefundRequest {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(item: &DigitalvirgoRouterData<&RefundsRouterData<F>>) -> Result<Self, Self::Error> {
Ok(Self {
amount: item.amount.to_owned(),
})
}
}
#[allow(dead_code)]
#[derive(Debug, Serialize, Default, Deserialize, Clone)]
pub enum RefundStatus {
Succeeded,
Failed,
#[default]
Processing,
}
impl From<RefundStatus> for enums::RefundStatus {
fn from(item: RefundStatus) -> Self {
match item {
RefundStatus::Succeeded => Self::Success,
RefundStatus::Failed => Self::Failure,
RefundStatus::Processing => Self::Pending,
}
}
}
#[derive(Default, Debug, Clone, Serialize, Deserialize)]
pub struct RefundResponse {
id: String,
status: RefundStatus,
}
impl TryFrom<RefundsResponseRouterData<Execute, RefundResponse>> for RefundsRouterData<Execute> {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: RefundsResponseRouterData<Execute, RefundResponse>,
) -> Result<Self, Self::Error> {
Ok(Self {
response: Ok(RefundsResponseData {
connector_refund_id: item.response.id.to_string(),
refund_status: enums::RefundStatus::from(item.response.status),
}),
..item.data
})
}
}
impl TryFrom<RefundsResponseRouterData<RSync, RefundResponse>> for RefundsRouterData<RSync> {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: RefundsResponseRouterData<RSync, RefundResponse>,
) -> Result<Self, Self::Error> {
Ok(Self {
response: Ok(RefundsResponseData {
connector_refund_id: item.response.id.to_string(),
refund_status: enums::RefundStatus::from(item.response.status),
}),
..item.data
})
}
}
#[derive(Default, Debug, Serialize, Deserialize, PartialEq)]
pub struct DigitalvirgoErrorResponse {
pub cause: Option<String>,
pub operation_error: Option<String>,
pub description: Option<String>,
}
|
{
"crate": "hyperswitch_connectors",
"file": "crates/hyperswitch_connectors/src/connectors/digitalvirgo/transformers.rs",
"file_size": null,
"is_async": null,
"is_pub": null,
"num_enums": 3,
"num_structs": 9,
"num_tables": null,
"score": null,
"total_crates": null
}
|
file_hyperswitch_connectors_-6785959817493661253
|
clm
|
file
|
// Repository: hyperswitch
// Crate: hyperswitch_connectors
// File: crates/hyperswitch_connectors/src/connectors/breadpay/transformers.rs
// Contains: 9 structs, 3 enums
use common_enums::enums;
use common_utils::{request::Method, types::StringMinorUnit};
use hyperswitch_domain_models::{
payment_method_data::PaymentMethodData,
router_data::{ConnectorAuthType, RouterData},
router_flow_types::refunds::{Execute, RSync},
router_request_types::ResponseId,
router_response_types::{PaymentsResponseData, RedirectForm, RefundsResponseData},
types::{PaymentsAuthorizeRouterData, RefundsRouterData},
};
use hyperswitch_interfaces::errors;
use masking::Secret;
use serde::{Deserialize, Serialize};
use crate::{
types::{RefundsResponseRouterData, ResponseRouterData},
utils::{self, PaymentsAuthorizeRequestData},
};
pub struct BreadpayRouterData<T> {
pub amount: StringMinorUnit, // The type of amount that a connector accepts, for example, String, i64, f64, etc.
pub router_data: T,
}
impl<T> From<(StringMinorUnit, T)> for BreadpayRouterData<T> {
fn from((amount, item): (StringMinorUnit, T)) -> Self {
Self {
amount,
router_data: item,
}
}
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct BreadpayCartRequest {
custom_total: StringMinorUnit,
options: Option<BreadpayCartOptions>,
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct BreadpayCartOptions {
order_ref: Option<String>,
complete_url: String,
callback_url: String,
// billing_contact: Option<BillingContact>,
}
// #[derive(Debug, Serialize)]
// #[serde(rename_all = "camelCase")]
// pub struct BillingContact {
// first_name: Secret<String>,
// last_name: Secret<String>,
// email: Option<Email>,
// address: Secret<String>,
// city: Secret<String>,
// state: Secret<String>,
// }
impl TryFrom<&BreadpayRouterData<&PaymentsAuthorizeRouterData>> for BreadpayCartRequest {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: &BreadpayRouterData<&PaymentsAuthorizeRouterData>,
) -> Result<Self, Self::Error> {
let request = match item.router_data.request.payment_method_data.clone() {
PaymentMethodData::PayLater(pay_later_data) => match pay_later_data{
hyperswitch_domain_models::payment_method_data::PayLaterData::BreadpayRedirect { } => {
// let billing_contact = BillingContact {
// first_name: item.router_data.get_billing_first_name()?,
// last_name: item.router_data.get_billing_last_name()?,
// email: item.router_data.get_optional_billing_email(),
// address: item.router_data.get_billing_line1()?,
// city: item.router_data.get_billing_city()?.into(),
// state: item.router_data.get_billing_state()?,
// };
let options = Some({
BreadpayCartOptions {
order_ref: item.router_data.request.merchant_order_reference_id.clone(),
complete_url: item.router_data.request.get_complete_authorize_url()?,
callback_url: item.router_data.request.get_router_return_url()?
// billing_contact: Some(billing_contact)
}
});
Self{
custom_total: item.amount.clone(),
options,
}
},
hyperswitch_domain_models::payment_method_data::PayLaterData::KlarnaRedirect { } |
hyperswitch_domain_models::payment_method_data::PayLaterData::WalleyRedirect { } |
hyperswitch_domain_models::payment_method_data::PayLaterData::KlarnaSdk { .. } |
hyperswitch_domain_models::payment_method_data::PayLaterData::AffirmRedirect { } |
hyperswitch_domain_models::payment_method_data::PayLaterData::FlexitiRedirect { } |
hyperswitch_domain_models::payment_method_data::PayLaterData::AfterpayClearpayRedirect { } |
hyperswitch_domain_models::payment_method_data::PayLaterData::PayBrightRedirect { } |
hyperswitch_domain_models::payment_method_data::PayLaterData::AlmaRedirect { } |
hyperswitch_domain_models::payment_method_data::PayLaterData::AtomeRedirect { } => {
Err(errors::ConnectorError::NotImplemented(
utils::get_unimplemented_payment_method_error_message("breadpay"),
))
}?,
},
PaymentMethodData::Card(_)
| PaymentMethodData::CardDetailsForNetworkTransactionId(
_,
)
| PaymentMethodData::CardRedirect(_)
| PaymentMethodData::Wallet(_)
| PaymentMethodData::BankRedirect(_)
| PaymentMethodData::BankDebit(_)
| PaymentMethodData::BankTransfer(_)
| PaymentMethodData::Crypto(_)
| PaymentMethodData::MandatePayment
| PaymentMethodData::Reward
| PaymentMethodData::RealTimePayment(_)
| PaymentMethodData::Upi(_)
| PaymentMethodData::Voucher(_)
| PaymentMethodData::GiftCard(_)
| PaymentMethodData::CardToken(_)
| PaymentMethodData::OpenBanking(_)
| PaymentMethodData::NetworkToken(_)
| PaymentMethodData::MobilePayment(_) => {
Err(errors::ConnectorError::NotImplemented(
utils::get_unimplemented_payment_method_error_message("breadpay"),
))
}?
};
Ok(request)
}
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct BreadpayTransactionRequest {
#[serde(rename = "type")]
pub transaction_type: BreadpayTransactionType,
}
#[derive(Debug, Serialize)]
pub enum BreadpayTransactionType {
Authorize,
Settle,
Cancel,
Refund,
}
// Auth Struct
pub struct BreadpayAuthType {
pub(super) api_key: Secret<String>,
pub(super) api_secret: Secret<String>,
}
impl TryFrom<&ConnectorAuthType> for BreadpayAuthType {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(auth_type: &ConnectorAuthType) -> Result<Self, Self::Error> {
match auth_type {
ConnectorAuthType::BodyKey { api_key, key1 } => Ok(Self {
api_key: api_key.to_owned(),
api_secret: key1.to_owned(),
}),
_ => Err(errors::ConnectorError::FailedToObtainAuthType.into()),
}
}
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct BreadpayTransactionResponse {
status: TransactionStatus,
bread_transactin_id: String,
merchant_order_id: String,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
pub enum TransactionStatus {
Pending,
Canceled,
Refunded,
Expired,
Authorized,
Settled,
}
impl<F, T> TryFrom<ResponseRouterData<F, BreadpayTransactionResponse, T, PaymentsResponseData>>
for RouterData<F, T, PaymentsResponseData>
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: ResponseRouterData<F, BreadpayTransactionResponse, T, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
Ok(Self {
status: enums::AttemptStatus::from(item.response.status.clone()),
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(item.response.bread_transactin_id),
redirection_data: Box::new(None),
mandate_reference: Box::new(None),
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: None,
incremental_authorization_allowed: None,
charges: None,
}),
..item.data
})
}
}
impl From<TransactionStatus> for enums::AttemptStatus {
fn from(item: TransactionStatus) -> Self {
match item {
TransactionStatus::Pending => Self::Pending,
TransactionStatus::Authorized => Self::Authorized,
TransactionStatus::Canceled => Self::Voided,
TransactionStatus::Refunded => Self::AutoRefunded,
TransactionStatus::Expired => Self::Failure,
TransactionStatus::Settled => Self::Charged,
}
}
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct BreadpayPaymentsResponse {
url: url::Url,
}
impl<F, T> TryFrom<ResponseRouterData<F, BreadpayPaymentsResponse, T, PaymentsResponseData>>
for RouterData<F, T, PaymentsResponseData>
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: ResponseRouterData<F, BreadpayPaymentsResponse, T, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
Ok(Self {
// As per documentation, the first call is cart creation where we don't get any status only get the customer redirection url.
status: common_enums::AttemptStatus::AuthenticationPending,
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::NoResponseId,
redirection_data: Box::new(Some(RedirectForm::from((
item.response.url,
Method::Get,
)))),
mandate_reference: Box::new(None),
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: None,
incremental_authorization_allowed: None,
charges: None,
}),
..item.data
})
}
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct CallBackResponse {
pub transaction_id: String,
pub order_ref: String,
}
// REFUND :
// Type definition for RefundRequest
#[derive(Debug, Serialize)]
pub struct BreadpayRefundRequest {
pub amount: StringMinorUnit,
#[serde(rename = "type")]
pub transaction_type: BreadpayTransactionType,
}
impl<F> TryFrom<&BreadpayRouterData<&RefundsRouterData<F>>> for BreadpayRefundRequest {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(item: &BreadpayRouterData<&RefundsRouterData<F>>) -> Result<Self, Self::Error> {
Ok(Self {
amount: item.amount.to_owned(),
transaction_type: BreadpayTransactionType::Refund,
})
}
}
// Type definition for Refund Response
#[allow(dead_code)]
#[derive(Debug, Copy, Serialize, Default, Deserialize, Clone)]
pub enum RefundStatus {
Succeeded,
Failed,
#[default]
Processing,
}
impl From<RefundStatus> for enums::RefundStatus {
fn from(item: RefundStatus) -> Self {
match item {
RefundStatus::Succeeded => Self::Success,
RefundStatus::Failed => Self::Failure,
RefundStatus::Processing => Self::Pending,
//TODO: Review mapping
}
}
}
//TODO: Fill the struct with respective fields
#[derive(Default, Debug, Clone, Serialize, Deserialize)]
pub struct RefundResponse {
id: String,
status: RefundStatus,
}
impl TryFrom<RefundsResponseRouterData<Execute, RefundResponse>> for RefundsRouterData<Execute> {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: RefundsResponseRouterData<Execute, RefundResponse>,
) -> Result<Self, Self::Error> {
Ok(Self {
response: Ok(RefundsResponseData {
connector_refund_id: item.response.id.to_string(),
refund_status: enums::RefundStatus::from(item.response.status),
}),
..item.data
})
}
}
impl TryFrom<RefundsResponseRouterData<RSync, RefundResponse>> for RefundsRouterData<RSync> {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: RefundsResponseRouterData<RSync, RefundResponse>,
) -> Result<Self, Self::Error> {
Ok(Self {
response: Ok(RefundsResponseData {
connector_refund_id: item.response.id.to_string(),
refund_status: enums::RefundStatus::from(item.response.status),
}),
..item.data
})
}
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct BreadpayErrorResponse {
/// Human-readable error description
pub description: String,
/// Error type classification
#[serde(rename = "type")]
pub error_type: String,
}
|
{
"crate": "hyperswitch_connectors",
"file": "crates/hyperswitch_connectors/src/connectors/breadpay/transformers.rs",
"file_size": null,
"is_async": null,
"is_pub": null,
"num_enums": 3,
"num_structs": 9,
"num_tables": null,
"score": null,
"total_crates": null
}
|
file_hyperswitch_connectors_-8434409694711799105
|
clm
|
file
|
// Repository: hyperswitch
// Crate: hyperswitch_connectors
// File: crates/hyperswitch_connectors/src/connectors/dummyconnector/transformers.rs
// Contains: 9 structs, 10 enums
use common_enums::{AttemptStatus, Currency, RefundStatus};
use common_utils::{pii, request::Method, types::MinorUnit};
use hyperswitch_domain_models::{
payment_method_data::{
Card, PayLaterData, PaymentMethodData, UpiCollectData, UpiData, WalletData,
},
router_data::{ConnectorAuthType, RouterData},
router_flow_types::{Execute, RSync},
router_request_types::ResponseId,
router_response_types::{PaymentsResponseData, RedirectForm, RefundsResponseData},
types::{PaymentsAuthorizeRouterData, RefundsRouterData},
};
use hyperswitch_interfaces::errors::ConnectorError;
use masking::Secret;
use serde::{Deserialize, Serialize};
use url::Url;
use crate::{
types::{RefundsResponseRouterData, ResponseRouterData},
utils::RouterData as _,
};
#[derive(Debug, Serialize)]
pub struct DummyConnectorRouterData<T> {
pub amount: MinorUnit,
pub router_data: T,
}
impl<T> From<(MinorUnit, T)> for DummyConnectorRouterData<T> {
fn from((amount, router_data): (MinorUnit, T)) -> Self {
Self {
amount,
router_data,
}
}
}
#[derive(Debug, Serialize, strum::Display, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
#[strum(serialize_all = "snake_case")]
pub enum DummyConnectors {
#[serde(rename = "phonypay")]
#[strum(serialize = "phonypay")]
PhonyPay,
#[serde(rename = "fauxpay")]
#[strum(serialize = "fauxpay")]
FauxPay,
#[serde(rename = "pretendpay")]
#[strum(serialize = "pretendpay")]
PretendPay,
StripeTest,
AdyenTest,
CheckoutTest,
PaypalTest,
}
impl DummyConnectors {
pub fn get_dummy_connector_id(self) -> &'static str {
match self {
Self::PhonyPay => "phonypay",
Self::FauxPay => "fauxpay",
Self::PretendPay => "pretendpay",
Self::StripeTest => "stripe_test",
Self::AdyenTest => "adyen_test",
Self::CheckoutTest => "checkout_test",
Self::PaypalTest => "paypal_test",
}
}
}
impl From<u8> for DummyConnectors {
fn from(value: u8) -> Self {
match value {
1 => Self::PhonyPay,
2 => Self::FauxPay,
3 => Self::PretendPay,
4 => Self::StripeTest,
5 => Self::AdyenTest,
6 => Self::CheckoutTest,
7 => Self::PaypalTest,
_ => Self::PhonyPay,
}
}
}
#[derive(Debug, Serialize, Eq, PartialEq)]
pub struct DummyConnectorPaymentsRequest<const T: u8> {
amount: MinorUnit,
currency: Currency,
payment_method_data: DummyPaymentMethodData,
return_url: Option<String>,
connector: DummyConnectors,
}
#[derive(Clone, Debug, Serialize, Deserialize, Eq, PartialEq)]
#[serde(rename_all = "lowercase")]
pub enum DummyPaymentMethodData {
Card(DummyConnectorCard),
Wallet(DummyConnectorWallet),
PayLater(DummyConnectorPayLater),
Upi(DummyConnectorUpi),
}
#[derive(Clone, Debug, serde::Serialize, Eq, PartialEq, serde::Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum DummyConnectorUpi {
UpiCollect(DummyConnectorUpiCollect),
}
#[derive(Clone, Debug, Serialize, Deserialize, Eq, PartialEq)]
pub struct DummyConnectorUpiCollect {
vpa_id: Secret<String, pii::UpiVpaMaskingStrategy>,
}
impl TryFrom<UpiCollectData> for DummyConnectorUpi {
type Error = error_stack::Report<ConnectorError>;
fn try_from(value: UpiCollectData) -> Result<Self, Self::Error> {
Ok(Self::UpiCollect(DummyConnectorUpiCollect {
vpa_id: value.vpa_id.ok_or(ConnectorError::MissingRequiredField {
field_name: "vpa_id",
})?,
}))
}
}
#[derive(Clone, Debug, Serialize, Deserialize, Eq, PartialEq)]
pub struct DummyConnectorCard {
name: Secret<String>,
number: cards::CardNumber,
expiry_month: Secret<String>,
expiry_year: Secret<String>,
cvc: Secret<String>,
}
impl TryFrom<(Card, Option<Secret<String>>)> for DummyConnectorCard {
type Error = error_stack::Report<ConnectorError>;
fn try_from(
(value, card_holder_name): (Card, Option<Secret<String>>),
) -> Result<Self, Self::Error> {
Ok(Self {
name: card_holder_name.unwrap_or(Secret::new("".to_string())),
number: value.card_number,
expiry_month: value.card_exp_month,
expiry_year: value.card_exp_year,
cvc: value.card_cvc,
})
}
}
#[derive(Debug, Clone, Serialize, Deserialize, Eq, PartialEq)]
pub enum DummyConnectorWallet {
GooglePay,
Paypal,
WeChatPay,
MbWay,
AliPay,
AliPayHK,
}
impl TryFrom<WalletData> for DummyConnectorWallet {
type Error = error_stack::Report<ConnectorError>;
fn try_from(value: WalletData) -> Result<Self, Self::Error> {
match value {
WalletData::GooglePayRedirect(_) => Ok(Self::GooglePay),
WalletData::PaypalRedirect(_) => Ok(Self::Paypal),
WalletData::WeChatPayRedirect(_) => Ok(Self::WeChatPay),
WalletData::MbWayRedirect(_) => Ok(Self::MbWay),
WalletData::AliPayRedirect(_) => Ok(Self::AliPay),
WalletData::AliPayHkRedirect(_) => Ok(Self::AliPayHK),
_ => Err(ConnectorError::NotImplemented("Dummy wallet".to_string()).into()),
}
}
}
#[derive(Debug, Clone, Serialize, Deserialize, Eq, PartialEq)]
pub enum DummyConnectorPayLater {
Klarna,
Affirm,
AfterPayClearPay,
}
impl TryFrom<PayLaterData> for DummyConnectorPayLater {
type Error = error_stack::Report<ConnectorError>;
fn try_from(value: PayLaterData) -> Result<Self, Self::Error> {
match value {
PayLaterData::KlarnaRedirect { .. } => Ok(Self::Klarna),
PayLaterData::AffirmRedirect {} => Ok(Self::Affirm),
PayLaterData::AfterpayClearpayRedirect { .. } => Ok(Self::AfterPayClearPay),
_ => Err(ConnectorError::NotImplemented("Dummy pay later".to_string()).into()),
}
}
}
impl<const T: u8> TryFrom<&DummyConnectorRouterData<&PaymentsAuthorizeRouterData>>
for DummyConnectorPaymentsRequest<T>
{
type Error = error_stack::Report<ConnectorError>;
fn try_from(
item: &DummyConnectorRouterData<&PaymentsAuthorizeRouterData>,
) -> Result<Self, Self::Error> {
let payment_method_data: Result<DummyPaymentMethodData, Self::Error> =
match item.router_data.request.payment_method_data {
PaymentMethodData::Card(ref req_card) => {
let card_holder_name = item.router_data.get_optional_billing_full_name();
Ok(DummyPaymentMethodData::Card(DummyConnectorCard::try_from(
(req_card.clone(), card_holder_name),
)?))
}
PaymentMethodData::Upi(ref req_upi_data) => match req_upi_data {
UpiData::UpiCollect(data) => Ok(DummyPaymentMethodData::Upi(
DummyConnectorUpi::try_from(data.clone())?,
)),
UpiData::UpiIntent(_) | UpiData::UpiQr(_) => {
Err(ConnectorError::NotImplemented("UPI flow".to_string()).into())
}
},
PaymentMethodData::Wallet(ref wallet_data) => Ok(DummyPaymentMethodData::Wallet(
wallet_data.clone().try_into()?,
)),
PaymentMethodData::PayLater(ref pay_later_data) => Ok(
DummyPaymentMethodData::PayLater(pay_later_data.clone().try_into()?),
),
_ => Err(ConnectorError::NotImplemented("Payment methods".to_string()).into()),
};
Ok(Self {
amount: item.router_data.request.minor_amount,
currency: item.router_data.request.currency,
payment_method_data: payment_method_data?,
return_url: item.router_data.request.router_return_url.clone(),
connector: Into::<DummyConnectors>::into(T),
})
}
}
// Auth Struct
pub struct DummyConnectorAuthType {
pub(super) api_key: Secret<String>,
}
impl TryFrom<&ConnectorAuthType> for DummyConnectorAuthType {
type Error = error_stack::Report<ConnectorError>;
fn try_from(auth_type: &ConnectorAuthType) -> Result<Self, Self::Error> {
match auth_type {
ConnectorAuthType::HeaderKey { api_key } => Ok(Self {
api_key: api_key.to_owned(),
}),
_ => Err(ConnectorError::FailedToObtainAuthType.into()),
}
}
}
// PaymentsResponse
//TODO: Append the remaining status flags
#[derive(Debug, Clone, Default, Serialize, Deserialize, PartialEq)]
#[serde(rename_all = "lowercase")]
pub enum DummyConnectorPaymentStatus {
Succeeded,
Failed,
#[default]
Processing,
}
impl From<DummyConnectorPaymentStatus> for AttemptStatus {
fn from(item: DummyConnectorPaymentStatus) -> Self {
match item {
DummyConnectorPaymentStatus::Succeeded => Self::Charged,
DummyConnectorPaymentStatus::Failed => Self::Failure,
DummyConnectorPaymentStatus::Processing => Self::AuthenticationPending,
}
}
}
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct PaymentsResponse {
status: DummyConnectorPaymentStatus,
id: String,
amount: MinorUnit,
currency: Currency,
created: String,
payment_method_type: PaymentMethodType,
next_action: Option<DummyConnectorNextAction>,
}
#[derive(Clone, Debug, Serialize, Deserialize, Eq, PartialEq)]
#[serde(rename_all = "lowercase")]
pub enum PaymentMethodType {
Card,
Upi(DummyConnectorUpiType),
Wallet(DummyConnectorWallet),
PayLater(DummyConnectorPayLater),
}
#[derive(Debug, Clone, Serialize, Deserialize, Eq, PartialEq)]
pub enum DummyConnectorUpiType {
UpiCollect,
}
impl<F, T> TryFrom<ResponseRouterData<F, PaymentsResponse, T, PaymentsResponseData>>
for RouterData<F, T, PaymentsResponseData>
{
type Error = error_stack::Report<ConnectorError>;
fn try_from(
item: ResponseRouterData<F, PaymentsResponse, T, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
let redirection_data = item
.response
.next_action
.and_then(|redirection_data| redirection_data.get_url())
.map(|redirection_url| RedirectForm::from((redirection_url, Method::Get)));
Ok(Self {
status: AttemptStatus::from(item.response.status),
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(item.response.id),
redirection_data: Box::new(redirection_data),
mandate_reference: Box::new(None),
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: None,
incremental_authorization_allowed: None,
charges: None,
}),
..item.data
})
}
}
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum DummyConnectorNextAction {
RedirectToUrl(Url),
}
impl DummyConnectorNextAction {
fn get_url(&self) -> Option<Url> {
match self {
Self::RedirectToUrl(redirect_to_url) => Some(redirect_to_url.to_owned()),
}
}
}
// REFUND :
// Type definition for RefundRequest
#[derive(Default, Debug, Serialize)]
pub struct DummyConnectorRefundRequest {
pub amount: MinorUnit,
}
impl<F> TryFrom<&DummyConnectorRouterData<&RefundsRouterData<F>>> for DummyConnectorRefundRequest {
type Error = error_stack::Report<ConnectorError>;
fn try_from(
item: &DummyConnectorRouterData<&RefundsRouterData<F>>,
) -> Result<Self, Self::Error> {
Ok(Self {
amount: item.router_data.request.minor_refund_amount,
})
}
}
// Type definition for Refund Response
#[allow(dead_code)]
#[derive(Debug, Serialize, Default, Deserialize, Clone)]
#[serde(rename_all = "lowercase")]
pub enum DummyRefundStatus {
Succeeded,
Failed,
#[default]
Processing,
}
impl From<DummyRefundStatus> for RefundStatus {
fn from(item: DummyRefundStatus) -> Self {
match item {
DummyRefundStatus::Succeeded => Self::Success,
DummyRefundStatus::Failed => Self::Failure,
DummyRefundStatus::Processing => Self::Pending,
//TODO: Review mapping
}
}
}
#[derive(Default, Debug, Clone, Serialize, Deserialize)]
pub struct RefundResponse {
id: String,
status: DummyRefundStatus,
currency: Currency,
created: String,
payment_amount: MinorUnit,
refund_amount: MinorUnit,
}
impl TryFrom<RefundsResponseRouterData<Execute, RefundResponse>> for RefundsRouterData<Execute> {
type Error = error_stack::Report<ConnectorError>;
fn try_from(
item: RefundsResponseRouterData<Execute, RefundResponse>,
) -> Result<Self, Self::Error> {
Ok(Self {
response: Ok(RefundsResponseData {
connector_refund_id: item.response.id.to_string(),
refund_status: RefundStatus::from(item.response.status),
}),
..item.data
})
}
}
impl TryFrom<RefundsResponseRouterData<RSync, RefundResponse>> for RefundsRouterData<RSync> {
type Error = error_stack::Report<ConnectorError>;
fn try_from(
item: RefundsResponseRouterData<RSync, RefundResponse>,
) -> Result<Self, Self::Error> {
Ok(Self {
response: Ok(RefundsResponseData {
connector_refund_id: item.response.id.to_string(),
refund_status: RefundStatus::from(item.response.status),
}),
..item.data
})
}
}
#[derive(Default, Debug, Serialize, Deserialize, PartialEq)]
pub struct DummyConnectorErrorResponse {
pub error: ErrorData,
}
#[derive(Default, Debug, Serialize, Deserialize, PartialEq)]
pub struct ErrorData {
pub code: String,
pub message: String,
pub reason: Option<String>,
}
|
{
"crate": "hyperswitch_connectors",
"file": "crates/hyperswitch_connectors/src/connectors/dummyconnector/transformers.rs",
"file_size": null,
"is_async": null,
"is_pub": null,
"num_enums": 10,
"num_structs": 9,
"num_tables": null,
"score": null,
"total_crates": null
}
|
file_hyperswitch_connectors_-7082072274881873452
|
clm
|
file
|
// Repository: hyperswitch
// Crate: hyperswitch_connectors
// File: crates/hyperswitch_connectors/src/connectors/bankofamerica/transformers.rs
// Contains: 74 structs, 13 enums
use base64::Engine;
use common_enums::{enums, FutureUsage};
use common_types::payments::ApplePayPredecryptData;
use common_utils::{consts, ext_traits::OptionExt, pii, types::StringMajorUnit};
use hyperswitch_domain_models::{
payment_method_data::{
ApplePayWalletData, GooglePayWalletData, PaymentMethodData, SamsungPayWalletData,
WalletData,
},
router_data::{
AdditionalPaymentMethodConnectorResponse, ConnectorAuthType, ConnectorResponseData,
ErrorResponse, PaymentMethodToken, RouterData,
},
router_flow_types::refunds::{Execute, RSync},
router_request_types::{
PaymentsAuthorizeData, PaymentsCancelData, PaymentsCaptureData, PaymentsSyncData,
ResponseId,
},
router_response_types::{MandateReference, PaymentsResponseData, RefundsResponseData},
types::{
PaymentsAuthorizeRouterData, PaymentsCancelRouterData, PaymentsCaptureRouterData,
RefundsRouterData, SetupMandateRouterData,
},
};
use hyperswitch_interfaces::{api, errors};
use masking::{ExposeInterface, PeekInterface, Secret};
use serde::{Deserialize, Serialize};
use serde_json::Value;
use crate::{
constants,
types::{RefundsResponseRouterData, ResponseRouterData},
unimplemented_payment_method,
utils::{
self, AddressDetailsData, CardData, PaymentsAuthorizeRequestData,
PaymentsSetupMandateRequestData, PaymentsSyncRequestData, RecurringMandateData,
RouterData as OtherRouterData,
},
};
pub struct BankOfAmericaAuthType {
pub(super) api_key: Secret<String>,
pub(super) merchant_account: Secret<String>,
pub(super) api_secret: Secret<String>,
}
impl TryFrom<&ConnectorAuthType> for BankOfAmericaAuthType {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(auth_type: &ConnectorAuthType) -> Result<Self, Self::Error> {
if let ConnectorAuthType::SignatureKey {
api_key,
key1,
api_secret,
} = auth_type
{
Ok(Self {
api_key: api_key.to_owned(),
merchant_account: key1.to_owned(),
api_secret: api_secret.to_owned(),
})
} else {
Err(errors::ConnectorError::FailedToObtainAuthType)?
}
}
}
pub struct BankOfAmericaRouterData<T> {
pub amount: StringMajorUnit,
pub router_data: T,
}
impl<T> TryFrom<(StringMajorUnit, T)> for BankOfAmericaRouterData<T> {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from((amount, item): (StringMajorUnit, T)) -> Result<Self, Self::Error> {
Ok(Self {
amount,
router_data: item,
})
}
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct BankOfAmericaPaymentsRequest {
processing_information: ProcessingInformation,
payment_information: PaymentInformation,
order_information: OrderInformationWithBill,
client_reference_information: ClientReferenceInformation,
#[serde(skip_serializing_if = "Option::is_none")]
consumer_authentication_information: Option<BankOfAmericaConsumerAuthInformation>,
#[serde(skip_serializing_if = "Option::is_none")]
merchant_defined_information: Option<Vec<MerchantDefinedInformation>>,
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ProcessingInformation {
action_list: Option<Vec<BankOfAmericaActionsList>>,
action_token_types: Option<Vec<BankOfAmericaActionsTokenType>>,
authorization_options: Option<BankOfAmericaAuthorizationOptions>,
commerce_indicator: String,
capture: Option<bool>,
capture_options: Option<CaptureOptions>,
payment_solution: Option<String>,
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
pub enum BankOfAmericaActionsList {
TokenCreate,
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub enum BankOfAmericaActionsTokenType {
PaymentInstrument,
Customer,
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct BankOfAmericaAuthorizationOptions {
initiator: Option<BankOfAmericaPaymentInitiator>,
merchant_intitiated_transaction: Option<MerchantInitiatedTransaction>,
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct BankOfAmericaPaymentInitiator {
#[serde(rename = "type")]
initiator_type: Option<BankOfAmericaPaymentInitiatorTypes>,
credential_stored_on_file: Option<bool>,
stored_credential_used: Option<bool>,
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub enum BankOfAmericaPaymentInitiatorTypes {
Customer,
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct MerchantInitiatedTransaction {
reason: Option<String>,
//Required for recurring mandates payment
original_authorized_amount: Option<String>,
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct MerchantDefinedInformation {
key: u8,
value: String,
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct BankOfAmericaConsumerAuthInformation {
ucaf_collection_indicator: Option<String>,
cavv: Option<String>,
ucaf_authentication_data: Option<Secret<String>>,
xid: Option<String>,
directory_server_transaction_id: Option<Secret<String>>,
specification_version: Option<String>,
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct CaptureOptions {
capture_sequence_number: u32,
total_capture_count: u32,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct BankOfAmericaPaymentInstrument {
id: Secret<String>,
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct CardPaymentInformation {
card: Card,
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct GooglePayPaymentInformation {
fluid_data: FluidData,
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ApplePayTokenizedCard {
transaction_type: TransactionType,
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ApplePayTokenPaymentInformation {
fluid_data: FluidData,
tokenized_card: ApplePayTokenizedCard,
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ApplePayPaymentInformation {
tokenized_card: TokenizedCard,
}
#[derive(Debug, Serialize)]
#[serde(untagged)]
pub enum PaymentInformation {
Cards(Box<CardPaymentInformation>),
GooglePay(Box<GooglePayPaymentInformation>),
ApplePay(Box<ApplePayPaymentInformation>),
ApplePayToken(Box<ApplePayTokenPaymentInformation>),
MandatePayment(Box<MandatePaymentInformation>),
SamsungPay(Box<SamsungPayPaymentInformation>),
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct MandatePaymentInformation {
payment_instrument: BankOfAmericaPaymentInstrument,
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct Card {
number: cards::CardNumber,
expiration_month: Secret<String>,
expiration_year: Secret<String>,
security_code: Secret<String>,
#[serde(rename = "type")]
card_type: Option<String>,
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct TokenizedCard {
number: cards::CardNumber,
expiration_month: Secret<String>,
expiration_year: Secret<String>,
cryptogram: Secret<String>,
transaction_type: TransactionType,
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct FluidData {
value: Secret<String>,
#[serde(skip_serializing_if = "Option::is_none")]
descriptor: Option<String>,
}
pub const FLUID_DATA_DESCRIPTOR_FOR_SAMSUNG_PAY: &str = "FID=COMMON.SAMSUNG.INAPP.PAYMENT";
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct OrderInformationWithBill {
amount_details: Amount,
bill_to: Option<BillTo>,
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct Amount {
total_amount: StringMajorUnit,
currency: api_models::enums::Currency,
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct BillTo {
first_name: Option<Secret<String>>,
last_name: Option<Secret<String>>,
address1: Option<Secret<String>>,
locality: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
administrative_area: Option<Secret<String>>,
#[serde(skip_serializing_if = "Option::is_none")]
postal_code: Option<Secret<String>>,
country: Option<enums::CountryAlpha2>,
email: pii::Email,
}
impl TryFrom<&SetupMandateRouterData> for BankOfAmericaPaymentsRequest {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(item: &SetupMandateRouterData) -> Result<Self, Self::Error> {
match item.request.payment_method_data.clone() {
PaymentMethodData::Card(card_data) => Self::try_from((item, card_data)),
PaymentMethodData::Wallet(wallet_data) => match wallet_data {
WalletData::ApplePay(apple_pay_data) => Self::try_from((item, apple_pay_data)),
WalletData::GooglePay(google_pay_data) => Self::try_from((item, google_pay_data)),
WalletData::AliPayQr(_)
| WalletData::AliPayRedirect(_)
| WalletData::AliPayHkRedirect(_)
| WalletData::AmazonPayRedirect(_)
| WalletData::Paysera(_)
| WalletData::Skrill(_)
| WalletData::BluecodeRedirect {}
| WalletData::MomoRedirect(_)
| WalletData::KakaoPayRedirect(_)
| WalletData::GoPayRedirect(_)
| WalletData::GcashRedirect(_)
| WalletData::ApplePayRedirect(_)
| WalletData::ApplePayThirdPartySdk(_)
| WalletData::DanaRedirect {}
| WalletData::GooglePayRedirect(_)
| WalletData::GooglePayThirdPartySdk(_)
| WalletData::MbWayRedirect(_)
| WalletData::MobilePayRedirect(_)
| WalletData::PaypalRedirect(_)
| WalletData::PaypalSdk(_)
| WalletData::Paze(_)
| WalletData::SamsungPay(_)
| WalletData::AmazonPay(_)
| WalletData::TwintRedirect {}
| WalletData::VippsRedirect {}
| WalletData::TouchNGoRedirect(_)
| WalletData::WeChatPayRedirect(_)
| WalletData::WeChatPayQr(_)
| WalletData::CashappQr(_)
| WalletData::SwishQr(_)
| WalletData::Mifinity(_)
| WalletData::RevolutPay(_) => Err(errors::ConnectorError::NotImplemented(
utils::get_unimplemented_payment_method_error_message("BankOfAmerica"),
))?,
},
PaymentMethodData::CardRedirect(_)
| PaymentMethodData::PayLater(_)
| PaymentMethodData::BankRedirect(_)
| PaymentMethodData::BankDebit(_)
| PaymentMethodData::BankTransfer(_)
| PaymentMethodData::Crypto(_)
| PaymentMethodData::MandatePayment
| PaymentMethodData::Reward
| PaymentMethodData::RealTimePayment(_)
| PaymentMethodData::MobilePayment(_)
| PaymentMethodData::Upi(_)
| PaymentMethodData::Voucher(_)
| PaymentMethodData::GiftCard(_)
| PaymentMethodData::OpenBanking(_)
| PaymentMethodData::CardToken(_)
| PaymentMethodData::NetworkToken(_)
| PaymentMethodData::CardDetailsForNetworkTransactionId(_) => {
Err(errors::ConnectorError::NotImplemented(
utils::get_unimplemented_payment_method_error_message("BankOfAmerica"),
))?
}
}
}
}
impl<F, T>
TryFrom<ResponseRouterData<F, BankOfAmericaSetupMandatesResponse, T, PaymentsResponseData>>
for RouterData<F, T, PaymentsResponseData>
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: ResponseRouterData<F, BankOfAmericaSetupMandatesResponse, T, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
match item.response {
BankOfAmericaSetupMandatesResponse::ClientReferenceInformation(info_response) => {
let mandate_reference =
info_response
.token_information
.clone()
.map(|token_info| MandateReference {
connector_mandate_id: token_info
.payment_instrument
.map(|payment_instrument| payment_instrument.id.expose()),
payment_method_id: None,
mandate_metadata: None,
connector_mandate_request_reference_id: None,
});
let mut mandate_status =
map_boa_attempt_status((info_response.status.clone(), false));
if matches!(mandate_status, enums::AttemptStatus::Authorized) {
//In case of zero auth mandates we want to make the payment reach the terminal status so we are converting the authorized status to charged as well.
mandate_status = enums::AttemptStatus::Charged
}
let error_response =
get_error_response_if_failure((&info_response, mandate_status, item.http_code));
let connector_response = match item.data.payment_method {
common_enums::PaymentMethod::Card => info_response
.processor_information
.as_ref()
.and_then(|processor_information| {
info_response
.consumer_authentication_information
.as_ref()
.map(|consumer_auth_information| {
convert_to_additional_payment_method_connector_response(
processor_information,
consumer_auth_information,
)
})
})
.map(ConnectorResponseData::with_additional_payment_method_data),
common_enums::PaymentMethod::CardRedirect
| common_enums::PaymentMethod::PayLater
| common_enums::PaymentMethod::Wallet
| common_enums::PaymentMethod::BankRedirect
| common_enums::PaymentMethod::BankTransfer
| common_enums::PaymentMethod::Crypto
| common_enums::PaymentMethod::BankDebit
| common_enums::PaymentMethod::Reward
| common_enums::PaymentMethod::RealTimePayment
| common_enums::PaymentMethod::MobilePayment
| common_enums::PaymentMethod::Upi
| common_enums::PaymentMethod::Voucher
| common_enums::PaymentMethod::OpenBanking
| common_enums::PaymentMethod::GiftCard => None,
};
Ok(Self {
status: mandate_status,
response: match error_response {
Some(error) => Err(error),
None => Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(
info_response.id.clone(),
),
redirection_data: Box::new(None),
mandate_reference: Box::new(mandate_reference),
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: Some(
info_response
.client_reference_information
.code
.clone()
.unwrap_or(info_response.id),
),
incremental_authorization_allowed: None,
charges: None,
}),
},
connector_response,
..item.data
})
}
BankOfAmericaSetupMandatesResponse::ErrorInformation(error_response) => {
let response = Err(convert_to_error_response_from_error_info(
&error_response,
item.http_code,
));
Ok(Self {
response,
status: enums::AttemptStatus::Failure,
..item.data
})
}
}
}
}
// for bankofamerica each item in Billing is mandatory
// fn build_bill_to(
// address_details: &payments::Address,
// email: pii::Email,
// ) -> Result<BillTo, error_stack::Report<errors::ConnectorError>> {
// let address = address_details
// .address
// .as_ref()
// .ok_or_else(utils::missing_field_err("billing.address"))?;
// let country = address.get_country()?.to_owned();
// let first_name = address.get_first_name()?;
// let (administrative_area, postal_code) =
// if country == api_enums::CountryAlpha2::US || country == api_enums::CountryAlpha2::CA {
// let mut state = address.to_state_code()?.peek().clone();
// state.truncate(20);
// (
// Some(Secret::from(state)),
// Some(address.get_zip()?.to_owned()),
// )
// } else {
// let zip = address.zip.clone();
// let mut_state = address.state.clone().map(|state| state.expose());
// match mut_state {
// Some(mut state) => {
// state.truncate(20);
// (Some(Secret::from(state)), zip)
// }
// None => (None, zip),
// }
// };
// Ok(BillTo {
// first_name: first_name.clone(),
// last_name: address.get_last_name().unwrap_or(first_name).clone(),
// address1: address.get_line1()?.to_owned(),
// locality: Secret::new(address.get_city()?.to_owned()),
// administrative_area,
// postal_code,
// country,
// email,
// })
// }
fn build_bill_to(
address_details: Option<&hyperswitch_domain_models::address::Address>,
email: pii::Email,
) -> Result<BillTo, error_stack::Report<errors::ConnectorError>> {
let default_address = BillTo {
first_name: None,
last_name: None,
address1: None,
locality: None,
administrative_area: None,
postal_code: None,
country: None,
email: email.clone(),
};
Ok(address_details
.and_then(|addr| {
addr.address.as_ref().map(|addr| {
let administrative_area = addr.to_state_code_as_optional().unwrap_or_else(|_| {
addr.state
.clone()
.map(|state| Secret::new(format!("{:.20}", state.expose())))
});
BillTo {
first_name: addr.first_name.clone(),
last_name: addr.last_name.clone(),
address1: addr.line1.clone(),
locality: addr.city.clone(),
administrative_area,
postal_code: addr.zip.clone(),
country: addr.country,
email,
}
})
})
.unwrap_or(default_address))
}
fn get_boa_card_type(card_network: common_enums::CardNetwork) -> Option<&'static str> {
match card_network {
common_enums::CardNetwork::Visa => Some("001"),
common_enums::CardNetwork::Mastercard => Some("002"),
common_enums::CardNetwork::AmericanExpress => Some("003"),
common_enums::CardNetwork::JCB => Some("007"),
common_enums::CardNetwork::DinersClub => Some("005"),
common_enums::CardNetwork::Discover => Some("004"),
common_enums::CardNetwork::CartesBancaires => Some("006"),
common_enums::CardNetwork::UnionPay => Some("062"),
//"042" is the type code for Masetro Cards(International). For Maestro Cards(UK-Domestic) the mapping should be "024"
common_enums::CardNetwork::Maestro => Some("042"),
common_enums::CardNetwork::Interac
| common_enums::CardNetwork::RuPay
| common_enums::CardNetwork::Star
| common_enums::CardNetwork::Accel
| common_enums::CardNetwork::Pulse
| common_enums::CardNetwork::Nyce => None,
}
}
#[derive(Debug, Serialize)]
pub enum PaymentSolution {
ApplePay,
GooglePay,
SamsungPay,
}
impl From<PaymentSolution> for String {
fn from(solution: PaymentSolution) -> Self {
let payment_solution = match solution {
PaymentSolution::ApplePay => "001",
PaymentSolution::GooglePay => "012",
PaymentSolution::SamsungPay => "008",
};
payment_solution.to_string()
}
}
#[derive(Debug, Serialize)]
pub enum TransactionType {
#[serde(rename = "1")]
ApplePay,
#[serde(rename = "1")]
SamsungPay,
}
impl
From<(
&BankOfAmericaRouterData<&PaymentsAuthorizeRouterData>,
Option<BillTo>,
)> for OrderInformationWithBill
{
fn from(
(item, bill_to): (
&BankOfAmericaRouterData<&PaymentsAuthorizeRouterData>,
Option<BillTo>,
),
) -> Self {
Self {
amount_details: Amount {
total_amount: item.amount.to_owned(),
currency: item.router_data.request.currency,
},
bill_to,
}
}
}
impl
TryFrom<(
&BankOfAmericaRouterData<&PaymentsAuthorizeRouterData>,
Option<PaymentSolution>,
Option<String>,
)> for ProcessingInformation
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
(item, solution, network): (
&BankOfAmericaRouterData<&PaymentsAuthorizeRouterData>,
Option<PaymentSolution>,
Option<String>,
),
) -> Result<Self, Self::Error> {
let (action_list, action_token_types, authorization_options) =
if item.router_data.request.setup_future_usage == Some(FutureUsage::OffSession)
&& (item.router_data.request.customer_acceptance.is_some()
|| item
.router_data
.request
.setup_mandate_details
.clone()
.is_some_and(|mandate_details| {
mandate_details.customer_acceptance.is_some()
}))
{
get_boa_mandate_action_details()
} else if item.router_data.request.connector_mandate_id().is_some() {
let original_amount = item
.router_data
.get_recurring_mandate_payment_data()?
.get_original_payment_amount()?;
let original_currency = item
.router_data
.get_recurring_mandate_payment_data()?
.get_original_payment_currency()?;
(
None,
None,
Some(BankOfAmericaAuthorizationOptions {
initiator: None,
merchant_intitiated_transaction: Some(MerchantInitiatedTransaction {
reason: None,
original_authorized_amount: Some(utils::get_amount_as_string(
&api::CurrencyUnit::Base,
original_amount,
original_currency,
)?),
}),
}),
)
} else {
(None, None, None)
};
let commerce_indicator = get_commerce_indicator(network);
Ok(Self {
capture: Some(matches!(
item.router_data.request.capture_method,
Some(enums::CaptureMethod::Automatic) | None
)),
payment_solution: solution.map(String::from),
action_list,
action_token_types,
authorization_options,
capture_options: None,
commerce_indicator,
})
}
}
impl From<&BankOfAmericaRouterData<&PaymentsAuthorizeRouterData>> for ClientReferenceInformation {
fn from(item: &BankOfAmericaRouterData<&PaymentsAuthorizeRouterData>) -> Self {
Self {
code: Some(item.router_data.connector_request_reference_id.clone()),
}
}
}
impl From<&SetupMandateRouterData> for ClientReferenceInformation {
fn from(item: &SetupMandateRouterData) -> Self {
Self {
code: Some(item.connector_request_reference_id.clone()),
}
}
}
fn convert_metadata_to_merchant_defined_info(metadata: Value) -> Vec<MerchantDefinedInformation> {
let hashmap: std::collections::BTreeMap<String, Value> =
serde_json::from_str(&metadata.to_string()).unwrap_or(std::collections::BTreeMap::new());
let mut vector = Vec::new();
let mut iter = 1;
for (key, value) in hashmap {
vector.push(MerchantDefinedInformation {
key: iter,
value: format!("{key}={value}"),
});
iter += 1;
}
vector
}
#[derive(Clone, Debug, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ClientReferenceInformation {
code: Option<String>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ClientProcessorInformation {
avs: Option<Avs>,
card_verification: Option<CardVerification>,
processor: Option<ProcessorResponse>,
network_transaction_id: Option<Secret<String>>,
approval_code: Option<String>,
merchant_advice: Option<MerchantAdvice>,
response_code: Option<String>,
ach_verification: Option<AchVerification>,
system_trace_audit_number: Option<String>,
event_status: Option<String>,
retrieval_reference_number: Option<String>,
consumer_authentication_response: Option<ConsumerAuthenticationResponse>,
response_details: Option<String>,
transaction_id: Option<Secret<String>>,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct MerchantAdvice {
code: Option<String>,
code_raw: Option<String>,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ConsumerAuthenticationResponse {
code: Option<String>,
code_raw: Option<String>,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct AchVerification {
result_code_raw: Option<String>,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ProcessorResponse {
name: Option<String>,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct CardVerification {
result_code: Option<String>,
result_code_raw: Option<String>,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ClientRiskInformation {
rules: Option<Vec<ClientRiskInformationRules>>,
profile: Option<Profile>,
score: Option<Score>,
info_codes: Option<InfoCodes>,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct InfoCodes {
address: Option<Vec<String>>,
identity_change: Option<Vec<String>>,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct Score {
factor_codes: Option<Vec<String>>,
result: Option<RiskResult>,
model_used: Option<String>,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(untagged)]
pub enum RiskResult {
StringVariant(String),
IntVariant(u64),
}
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct Profile {
early_decision: Option<String>,
name: Option<String>,
decision: Option<String>,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct ClientRiskInformationRules {
name: Option<Secret<String>>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Avs {
code: Option<String>,
code_raw: Option<String>,
}
impl
TryFrom<(
&BankOfAmericaRouterData<&PaymentsAuthorizeRouterData>,
hyperswitch_domain_models::payment_method_data::Card,
)> for BankOfAmericaPaymentsRequest
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
(item, ccard): (
&BankOfAmericaRouterData<&PaymentsAuthorizeRouterData>,
hyperswitch_domain_models::payment_method_data::Card,
),
) -> Result<Self, Self::Error> {
if item.router_data.is_three_ds() {
Err(errors::ConnectorError::NotSupported {
message: "Card 3DS".to_string(),
connector: "BankOfAmerica",
})?
};
let email = item.router_data.request.get_email()?;
let bill_to = build_bill_to(item.router_data.get_optional_billing(), email)?;
let order_information = OrderInformationWithBill::from((item, Some(bill_to)));
let payment_information = PaymentInformation::try_from(&ccard)?;
let processing_information = ProcessingInformation::try_from((item, None, None))?;
let client_reference_information = ClientReferenceInformation::from(item);
let merchant_defined_information = item
.router_data
.request
.metadata
.clone()
.map(convert_metadata_to_merchant_defined_info);
Ok(Self {
processing_information,
payment_information,
order_information,
client_reference_information,
merchant_defined_information,
consumer_authentication_information: None,
})
}
}
impl
TryFrom<(
&BankOfAmericaRouterData<&PaymentsAuthorizeRouterData>,
Box<ApplePayPredecryptData>,
ApplePayWalletData,
)> for BankOfAmericaPaymentsRequest
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
(item, apple_pay_data, apple_pay_wallet_data): (
&BankOfAmericaRouterData<&PaymentsAuthorizeRouterData>,
Box<ApplePayPredecryptData>,
ApplePayWalletData,
),
) -> Result<Self, Self::Error> {
let email = item.router_data.request.get_email()?;
let bill_to = build_bill_to(item.router_data.get_optional_billing(), email)?;
let order_information = OrderInformationWithBill::from((item, Some(bill_to)));
let processing_information = ProcessingInformation::try_from((
item,
Some(PaymentSolution::ApplePay),
Some(apple_pay_wallet_data.payment_method.network.clone()),
))?;
let client_reference_information = ClientReferenceInformation::from(item);
let payment_information = PaymentInformation::try_from(&apple_pay_data)?;
let merchant_defined_information = item
.router_data
.request
.metadata
.clone()
.map(convert_metadata_to_merchant_defined_info);
let ucaf_collection_indicator = match apple_pay_wallet_data
.payment_method
.network
.to_lowercase()
.as_str()
{
"mastercard" => Some("2".to_string()),
_ => None,
};
Ok(Self {
processing_information,
payment_information,
order_information,
client_reference_information,
merchant_defined_information,
consumer_authentication_information: Some(BankOfAmericaConsumerAuthInformation {
ucaf_collection_indicator,
cavv: None,
ucaf_authentication_data: None,
xid: None,
directory_server_transaction_id: None,
specification_version: None,
}),
})
}
}
impl
TryFrom<(
&BankOfAmericaRouterData<&PaymentsAuthorizeRouterData>,
GooglePayWalletData,
)> for BankOfAmericaPaymentsRequest
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
(item, google_pay_data): (
&BankOfAmericaRouterData<&PaymentsAuthorizeRouterData>,
GooglePayWalletData,
),
) -> Result<Self, Self::Error> {
let email = item.router_data.request.get_email()?;
let bill_to = build_bill_to(item.router_data.get_optional_billing(), email)?;
let order_information = OrderInformationWithBill::from((item, Some(bill_to)));
let payment_information = PaymentInformation::try_from(&google_pay_data)?;
let processing_information =
ProcessingInformation::try_from((item, Some(PaymentSolution::GooglePay), None))?;
let client_reference_information = ClientReferenceInformation::from(item);
let merchant_defined_information = item
.router_data
.request
.metadata
.clone()
.map(convert_metadata_to_merchant_defined_info);
Ok(Self {
processing_information,
payment_information,
order_information,
client_reference_information,
merchant_defined_information,
consumer_authentication_information: None,
})
}
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct SamsungPayTokenizedCard {
transaction_type: TransactionType,
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct SamsungPayPaymentInformation {
fluid_data: FluidData,
tokenized_card: SamsungPayTokenizedCard,
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct SamsungPayFluidDataValue {
public_key_hash: Secret<String>,
version: String,
data: Secret<String>,
}
impl TryFrom<&BankOfAmericaRouterData<&PaymentsAuthorizeRouterData>>
for BankOfAmericaPaymentsRequest
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: &BankOfAmericaRouterData<&PaymentsAuthorizeRouterData>,
) -> Result<Self, Self::Error> {
match item.router_data.request.connector_mandate_id() {
Some(connector_mandate_id) => Self::try_from((item, connector_mandate_id)),
None => {
match item.router_data.request.payment_method_data.clone() {
PaymentMethodData::Card(ccard) => Self::try_from((item, ccard)),
PaymentMethodData::Wallet(wallet_data) => match wallet_data {
WalletData::ApplePay(apple_pay_data) => {
match item.router_data.payment_method_token.clone() {
Some(payment_method_token) => match payment_method_token {
PaymentMethodToken::ApplePayDecrypt(decrypt_data) => {
Self::try_from((item, decrypt_data, apple_pay_data))
}
PaymentMethodToken::Token(_) => {
Err(unimplemented_payment_method!(
"Apple Pay",
"Manual",
"Bank Of America"
))?
}
PaymentMethodToken::PazeDecrypt(_) => Err(
unimplemented_payment_method!("Paze", "Bank Of America"),
)?,
PaymentMethodToken::GooglePayDecrypt(_) => {
Err(unimplemented_payment_method!(
"Google Pay",
"Bank Of America"
))?
}
},
None => {
let email = item.router_data.request.get_email()?;
let bill_to = build_bill_to(
item.router_data.get_optional_billing(),
email,
)?;
let order_information: OrderInformationWithBill =
OrderInformationWithBill::from((item, Some(bill_to)));
let processing_information =
ProcessingInformation::try_from((
item,
Some(PaymentSolution::ApplePay),
Some(apple_pay_data.payment_method.network.clone()),
))?;
let client_reference_information =
ClientReferenceInformation::from(item);
let payment_information =
PaymentInformation::try_from(&apple_pay_data)?;
let merchant_defined_information = item
.router_data
.request
.metadata
.clone()
.map(convert_metadata_to_merchant_defined_info);
let ucaf_collection_indicator = match apple_pay_data
.payment_method
.network
.to_lowercase()
.as_str()
{
"mastercard" => Some("2".to_string()),
_ => None,
};
Ok(Self {
processing_information,
payment_information,
order_information,
merchant_defined_information,
client_reference_information,
consumer_authentication_information: Some(
BankOfAmericaConsumerAuthInformation {
ucaf_collection_indicator,
cavv: None,
ucaf_authentication_data: None,
xid: None,
directory_server_transaction_id: None,
specification_version: None,
},
),
})
}
}
}
WalletData::GooglePay(google_pay_data) => {
Self::try_from((item, google_pay_data))
}
WalletData::SamsungPay(samsung_pay_data) => {
Self::try_from((item, samsung_pay_data))
}
WalletData::AliPayQr(_)
| WalletData::AliPayRedirect(_)
| WalletData::AliPayHkRedirect(_)
| WalletData::AmazonPayRedirect(_)
| WalletData::Paysera(_)
| WalletData::Skrill(_)
| WalletData::BluecodeRedirect {}
| WalletData::MomoRedirect(_)
| WalletData::KakaoPayRedirect(_)
| WalletData::GoPayRedirect(_)
| WalletData::GcashRedirect(_)
| WalletData::ApplePayRedirect(_)
| WalletData::ApplePayThirdPartySdk(_)
| WalletData::DanaRedirect {}
| WalletData::GooglePayRedirect(_)
| WalletData::GooglePayThirdPartySdk(_)
| WalletData::MbWayRedirect(_)
| WalletData::MobilePayRedirect(_)
| WalletData::PaypalRedirect(_)
| WalletData::PaypalSdk(_)
| WalletData::Paze(_)
| WalletData::AmazonPay(_)
| WalletData::TwintRedirect {}
| WalletData::VippsRedirect {}
| WalletData::TouchNGoRedirect(_)
| WalletData::WeChatPayRedirect(_)
| WalletData::WeChatPayQr(_)
| WalletData::CashappQr(_)
| WalletData::SwishQr(_)
| WalletData::Mifinity(_)
| WalletData::RevolutPay(_) => Err(errors::ConnectorError::NotImplemented(
utils::get_unimplemented_payment_method_error_message(
"Bank of America",
),
)
.into()),
},
// If connector_mandate_id is present MandatePayment will be the PMD, the case will be handled in the first `if` clause.
// This is a fallback implementation in the event of catastrophe.
PaymentMethodData::MandatePayment => {
let connector_mandate_id =
item.router_data.request.connector_mandate_id().ok_or(
errors::ConnectorError::MissingRequiredField {
field_name: "connector_mandate_id",
},
)?;
Self::try_from((item, connector_mandate_id))
}
PaymentMethodData::CardRedirect(_)
| PaymentMethodData::PayLater(_)
| PaymentMethodData::BankRedirect(_)
| PaymentMethodData::BankDebit(_)
| PaymentMethodData::BankTransfer(_)
| PaymentMethodData::Crypto(_)
| PaymentMethodData::Reward
| PaymentMethodData::RealTimePayment(_)
| PaymentMethodData::MobilePayment(_)
| PaymentMethodData::Upi(_)
| PaymentMethodData::Voucher(_)
| PaymentMethodData::GiftCard(_)
| PaymentMethodData::OpenBanking(_)
| PaymentMethodData::CardToken(_)
| PaymentMethodData::NetworkToken(_)
| PaymentMethodData::CardDetailsForNetworkTransactionId(_) => {
Err(errors::ConnectorError::NotImplemented(
utils::get_unimplemented_payment_method_error_message(
"Bank of America",
),
)
.into())
}
}
}
}
}
}
fn get_samsung_pay_fluid_data_value(
samsung_pay_token_data: &hyperswitch_domain_models::payment_method_data::SamsungPayTokenData,
) -> Result<SamsungPayFluidDataValue, error_stack::Report<errors::ConnectorError>> {
let samsung_pay_header =
josekit::jwt::decode_header(samsung_pay_token_data.data.clone().peek())
.change_context(errors::ConnectorError::RequestEncodingFailed)
.attach_printable("Failed to decode samsung pay header")?;
let samsung_pay_kid_optional = samsung_pay_header.claim("kid").and_then(|kid| kid.as_str());
let samsung_pay_fluid_data_value = SamsungPayFluidDataValue {
public_key_hash: Secret::new(
samsung_pay_kid_optional
.get_required_value("samsung pay public_key_hash")
.change_context(errors::ConnectorError::RequestEncodingFailed)?
.to_string(),
),
version: samsung_pay_token_data.version.clone(),
data: Secret::new(consts::BASE64_ENGINE.encode(samsung_pay_token_data.data.peek())),
};
Ok(samsung_pay_fluid_data_value)
}
use error_stack::ResultExt;
impl
TryFrom<(
&BankOfAmericaRouterData<&PaymentsAuthorizeRouterData>,
Box<SamsungPayWalletData>,
)> for BankOfAmericaPaymentsRequest
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
(item, samsung_pay_data): (
&BankOfAmericaRouterData<&PaymentsAuthorizeRouterData>,
Box<SamsungPayWalletData>,
),
) -> Result<Self, Self::Error> {
let email = item
.router_data
.get_billing_email()
.or(item.router_data.request.get_email())?;
let bill_to = build_bill_to(item.router_data.get_optional_billing(), email)?;
let order_information = OrderInformationWithBill::from((item, Some(bill_to)));
let samsung_pay_fluid_data_value =
get_samsung_pay_fluid_data_value(&samsung_pay_data.payment_credential.token_data)?;
let samsung_pay_fluid_data_str = serde_json::to_string(&samsung_pay_fluid_data_value)
.change_context(errors::ConnectorError::RequestEncodingFailed)
.attach_printable("Failed to serialize samsung pay fluid data")?;
let payment_information =
PaymentInformation::SamsungPay(Box::new(SamsungPayPaymentInformation {
fluid_data: FluidData {
value: Secret::new(consts::BASE64_ENGINE.encode(samsung_pay_fluid_data_str)),
descriptor: Some(
consts::BASE64_ENGINE.encode(FLUID_DATA_DESCRIPTOR_FOR_SAMSUNG_PAY),
),
},
tokenized_card: SamsungPayTokenizedCard {
transaction_type: TransactionType::SamsungPay,
},
}));
let processing_information = ProcessingInformation::try_from((
item,
Some(PaymentSolution::SamsungPay),
Some(samsung_pay_data.payment_credential.card_brand.to_string()),
))?;
let client_reference_information = ClientReferenceInformation::from(item);
let merchant_defined_information = item
.router_data
.request
.metadata
.clone()
.map(convert_metadata_to_merchant_defined_info);
Ok(Self {
processing_information,
payment_information,
order_information,
client_reference_information,
consumer_authentication_information: None,
merchant_defined_information,
})
}
}
impl
TryFrom<(
&BankOfAmericaRouterData<&PaymentsAuthorizeRouterData>,
String,
)> for BankOfAmericaPaymentsRequest
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
(item, connector_mandate_id): (
&BankOfAmericaRouterData<&PaymentsAuthorizeRouterData>,
String,
),
) -> Result<Self, Self::Error> {
let processing_information = ProcessingInformation::try_from((item, None, None))?;
let payment_instrument = BankOfAmericaPaymentInstrument {
id: connector_mandate_id.into(),
};
let bill_to =
item.router_data.request.get_email().ok().and_then(|email| {
build_bill_to(item.router_data.get_optional_billing(), email).ok()
});
let order_information = OrderInformationWithBill::from((item, bill_to));
let payment_information =
PaymentInformation::MandatePayment(Box::new(MandatePaymentInformation {
payment_instrument,
}));
let client_reference_information = ClientReferenceInformation::from(item);
let merchant_defined_information = item
.router_data
.request
.metadata
.clone()
.map(convert_metadata_to_merchant_defined_info);
Ok(Self {
processing_information,
payment_information,
order_information,
client_reference_information,
merchant_defined_information,
consumer_authentication_information: None,
})
}
}
#[derive(Clone, Debug, Deserialize, Serialize)]
#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
pub enum BankofamericaPaymentStatus {
Authorized,
Succeeded,
Failed,
Voided,
Reversed,
Pending,
Declined,
Rejected,
Challenge,
AuthorizedPendingReview,
AuthorizedRiskDeclined,
Transmitted,
InvalidRequest,
ServerError,
PendingAuthentication,
PendingReview,
Accepted,
Cancelled,
//PartialAuthorized, not being consumed yet.
}
fn map_boa_attempt_status(
(status, auto_capture): (BankofamericaPaymentStatus, bool),
) -> enums::AttemptStatus {
match status {
BankofamericaPaymentStatus::Authorized
| BankofamericaPaymentStatus::AuthorizedPendingReview => {
if auto_capture {
// Because BankOfAmerica will return Payment Status as Authorized even in AutoCapture Payment
enums::AttemptStatus::Charged
} else {
enums::AttemptStatus::Authorized
}
}
BankofamericaPaymentStatus::Pending => {
if auto_capture {
enums::AttemptStatus::Charged
} else {
enums::AttemptStatus::Pending
}
}
BankofamericaPaymentStatus::Succeeded | BankofamericaPaymentStatus::Transmitted => {
enums::AttemptStatus::Charged
}
BankofamericaPaymentStatus::Voided
| BankofamericaPaymentStatus::Reversed
| BankofamericaPaymentStatus::Cancelled => enums::AttemptStatus::Voided,
BankofamericaPaymentStatus::Failed
| BankofamericaPaymentStatus::Declined
| BankofamericaPaymentStatus::AuthorizedRiskDeclined
| BankofamericaPaymentStatus::InvalidRequest
| BankofamericaPaymentStatus::Rejected
| BankofamericaPaymentStatus::ServerError => enums::AttemptStatus::Failure,
BankofamericaPaymentStatus::PendingAuthentication => {
enums::AttemptStatus::AuthenticationPending
}
BankofamericaPaymentStatus::PendingReview
| BankofamericaPaymentStatus::Challenge
| BankofamericaPaymentStatus::Accepted => enums::AttemptStatus::Pending,
}
}
#[derive(Debug, Deserialize, Serialize)]
#[serde(untagged)]
pub enum BankOfAmericaPaymentsResponse {
ClientReferenceInformation(Box<BankOfAmericaClientReferenceResponse>),
ErrorInformation(Box<BankOfAmericaErrorInformationResponse>),
}
#[derive(Debug, Deserialize, Serialize)]
#[serde(untagged)]
pub enum BankOfAmericaSetupMandatesResponse {
ClientReferenceInformation(Box<BankOfAmericaClientReferenceResponse>),
ErrorInformation(Box<BankOfAmericaErrorInformationResponse>),
}
#[derive(Clone, Debug, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct BankOfAmericaClientReferenceResponse {
id: String,
status: BankofamericaPaymentStatus,
client_reference_information: ClientReferenceInformation,
processor_information: Option<ClientProcessorInformation>,
processing_information: Option<ProcessingInformationResponse>,
payment_information: Option<PaymentInformationResponse>,
payment_insights_information: Option<PaymentInsightsInformation>,
risk_information: Option<ClientRiskInformation>,
token_information: Option<BankOfAmericaTokenInformation>,
error_information: Option<BankOfAmericaErrorInformation>,
issuer_information: Option<IssuerInformation>,
sender_information: Option<SenderInformation>,
payment_account_information: Option<PaymentAccountInformation>,
reconciliation_id: Option<String>,
consumer_authentication_information: Option<ConsumerAuthenticationInformation>,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ConsumerAuthenticationInformation {
eci_raw: Option<String>,
eci: Option<String>,
acs_transaction_id: Option<String>,
cavv: Option<String>,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct SenderInformation {
payment_information: Option<PaymentInformationResponse>,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct PaymentInsightsInformation {
response_insights: Option<ResponseInsights>,
rule_results: Option<RuleResults>,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ResponseInsights {
category_code: Option<String>,
category: Option<String>,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct RuleResults {
id: Option<String>,
decision: Option<String>,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct PaymentInformationResponse {
tokenized_card: Option<CardResponseObject>,
customer: Option<CustomerResponseObject>,
card: Option<CardResponseObject>,
scheme: Option<String>,
bin: Option<String>,
account_type: Option<String>,
issuer: Option<String>,
bin_country: Option<enums::CountryAlpha2>,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct CustomerResponseObject {
customer_id: Option<String>,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct PaymentAccountInformation {
card: Option<PaymentAccountCardInformation>,
features: Option<PaymentAccountFeatureInformation>,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct PaymentAccountFeatureInformation {
health_card: Option<String>,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct PaymentAccountCardInformation {
#[serde(rename = "type")]
card_type: Option<String>,
hashed_number: Option<String>,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ProcessingInformationResponse {
payment_solution: Option<String>,
commerce_indicator: Option<String>,
commerce_indicator_label: Option<String>,
authorization_options: Option<AuthorizationOptions>,
ecommerce_indicator: Option<String>,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct AuthorizationOptions {
auth_type: Option<String>,
initiator: Option<Initiator>,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct Initiator {
merchant_initiated_transaction: Option<MerchantInitiatedTransactionResponse>,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct MerchantInitiatedTransactionResponse {
agreement_id: Option<String>,
previous_transaction_id: Option<String>,
original_authorized_amount: Option<StringMajorUnit>,
reason: Option<String>,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct BankOfAmericaTokenInformation {
payment_instrument: Option<BankOfAmericaPaymentInstrument>,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct IssuerInformation {
country: Option<enums::CountryAlpha2>,
discretionary_data: Option<String>,
country_specific_discretionary_data: Option<String>,
response_code: Option<String>,
pin_request_indicator: Option<String>,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct CardResponseObject {
suffix: Option<String>,
prefix: Option<String>,
expiration_month: Option<Secret<String>>,
expiration_year: Option<Secret<String>>,
#[serde(rename = "type")]
card_type: Option<String>,
}
#[derive(Clone, Debug, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct BankOfAmericaErrorInformationResponse {
id: String,
error_information: BankOfAmericaErrorInformation,
}
#[derive(Clone, Debug, Deserialize, Serialize)]
pub struct BankOfAmericaErrorInformation {
reason: Option<String>,
message: Option<String>,
details: Option<Vec<Details>>,
}
fn map_error_response<F, T>(
error_response: &BankOfAmericaErrorInformationResponse,
item: ResponseRouterData<F, BankOfAmericaPaymentsResponse, T, PaymentsResponseData>,
transaction_status: Option<enums::AttemptStatus>,
) -> RouterData<F, T, PaymentsResponseData> {
let detailed_error_info = error_response
.error_information
.details
.as_ref()
.map(|details| {
details
.iter()
.map(|details| format!("{} : {}", details.field, details.reason))
.collect::<Vec<_>>()
.join(", ")
});
let reason = get_error_reason(
error_response.error_information.message.clone(),
detailed_error_info,
None,
);
let response = Err(ErrorResponse {
code: error_response
.error_information
.reason
.clone()
.unwrap_or(hyperswitch_interfaces::consts::NO_ERROR_CODE.to_string()),
message: error_response
.error_information
.reason
.clone()
.unwrap_or(hyperswitch_interfaces::consts::NO_ERROR_MESSAGE.to_string()),
reason,
status_code: item.http_code,
attempt_status: None,
connector_transaction_id: Some(error_response.id.clone()),
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
connector_metadata: None,
});
match transaction_status {
Some(status) => RouterData {
response,
status,
..item.data
},
None => RouterData {
response,
..item.data
},
}
}
fn get_error_response_if_failure(
(info_response, status, http_code): (
&BankOfAmericaClientReferenceResponse,
enums::AttemptStatus,
u16,
),
) -> Option<ErrorResponse> {
if utils::is_payment_failure(status) {
Some(get_error_response(
&info_response.error_information,
&info_response.processor_information,
&info_response.risk_information,
Some(status),
http_code,
info_response.id.clone(),
))
} else {
None
}
}
fn get_payment_response(
(info_response, status, http_code): (
&BankOfAmericaClientReferenceResponse,
enums::AttemptStatus,
u16,
),
) -> Result<PaymentsResponseData, Box<ErrorResponse>> {
let error_response = get_error_response_if_failure((info_response, status, http_code));
match error_response {
Some(error) => Err(Box::new(error)),
None => {
let mandate_reference =
info_response
.token_information
.clone()
.map(|token_info| MandateReference {
connector_mandate_id: token_info
.payment_instrument
.map(|payment_instrument| payment_instrument.id.expose()),
payment_method_id: None,
mandate_metadata: None,
connector_mandate_request_reference_id: None,
});
Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(info_response.id.clone()),
redirection_data: Box::new(None),
mandate_reference: Box::new(mandate_reference),
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: Some(
info_response
.client_reference_information
.code
.clone()
.unwrap_or(info_response.id.clone()),
),
incremental_authorization_allowed: None,
charges: None,
})
}
}
}
impl<F>
TryFrom<
ResponseRouterData<
F,
BankOfAmericaPaymentsResponse,
PaymentsAuthorizeData,
PaymentsResponseData,
>,
> for RouterData<F, PaymentsAuthorizeData, PaymentsResponseData>
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: ResponseRouterData<
F,
BankOfAmericaPaymentsResponse,
PaymentsAuthorizeData,
PaymentsResponseData,
>,
) -> Result<Self, Self::Error> {
match item.response {
BankOfAmericaPaymentsResponse::ClientReferenceInformation(info_response) => {
let status = map_boa_attempt_status((
info_response.status.clone(),
item.data.request.is_auto_capture()?,
));
let response = get_payment_response((&info_response, status, item.http_code))
.map_err(|err| *err);
let connector_response = match item.data.payment_method {
common_enums::PaymentMethod::Card => info_response
.processor_information
.as_ref()
.and_then(|processor_information| {
info_response
.consumer_authentication_information
.as_ref()
.map(|consumer_auth_information| {
convert_to_additional_payment_method_connector_response(
processor_information,
consumer_auth_information,
)
})
})
.map(ConnectorResponseData::with_additional_payment_method_data),
common_enums::PaymentMethod::CardRedirect
| common_enums::PaymentMethod::PayLater
| common_enums::PaymentMethod::Wallet
| common_enums::PaymentMethod::BankRedirect
| common_enums::PaymentMethod::BankTransfer
| common_enums::PaymentMethod::Crypto
| common_enums::PaymentMethod::BankDebit
| common_enums::PaymentMethod::Reward
| common_enums::PaymentMethod::RealTimePayment
| common_enums::PaymentMethod::MobilePayment
| common_enums::PaymentMethod::Upi
| common_enums::PaymentMethod::Voucher
| common_enums::PaymentMethod::OpenBanking
| common_enums::PaymentMethod::GiftCard => None,
};
Ok(Self {
status,
response,
connector_response,
..item.data
})
}
BankOfAmericaPaymentsResponse::ErrorInformation(ref error_response) => {
Ok(map_error_response(
&error_response.clone(),
item,
Some(enums::AttemptStatus::Failure),
))
}
}
}
}
fn convert_to_additional_payment_method_connector_response(
processor_information: &ClientProcessorInformation,
consumer_authentication_information: &ConsumerAuthenticationInformation,
) -> AdditionalPaymentMethodConnectorResponse {
let payment_checks = Some(serde_json::json!({
"avs_response": processor_information.avs,
"card_verification": processor_information.card_verification,
"approval_code": processor_information.approval_code,
"consumer_authentication_response": processor_information.consumer_authentication_response,
"cavv": consumer_authentication_information.cavv,
"eci": consumer_authentication_information.eci,
"eci_raw": consumer_authentication_information.eci_raw,
}));
let authentication_data = Some(serde_json::json!({
"retrieval_reference_number": processor_information.retrieval_reference_number,
"acs_transaction_id": consumer_authentication_information.acs_transaction_id,
"system_trace_audit_number": processor_information.system_trace_audit_number,
}));
AdditionalPaymentMethodConnectorResponse::Card {
authentication_data,
payment_checks,
card_network: None,
domestic_network: None,
}
}
impl<F>
TryFrom<
ResponseRouterData<
F,
BankOfAmericaPaymentsResponse,
PaymentsCaptureData,
PaymentsResponseData,
>,
> for RouterData<F, PaymentsCaptureData, PaymentsResponseData>
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: ResponseRouterData<
F,
BankOfAmericaPaymentsResponse,
PaymentsCaptureData,
PaymentsResponseData,
>,
) -> Result<Self, Self::Error> {
match item.response {
BankOfAmericaPaymentsResponse::ClientReferenceInformation(info_response) => {
let status = map_boa_attempt_status((info_response.status.clone(), true));
let response = get_payment_response((&info_response, status, item.http_code))
.map_err(|err| *err);
Ok(Self {
status,
response,
..item.data
})
}
BankOfAmericaPaymentsResponse::ErrorInformation(ref error_response) => {
Ok(map_error_response(&error_response.clone(), item, None))
}
}
}
}
impl<F>
TryFrom<
ResponseRouterData<
F,
BankOfAmericaPaymentsResponse,
PaymentsCancelData,
PaymentsResponseData,
>,
> for RouterData<F, PaymentsCancelData, PaymentsResponseData>
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: ResponseRouterData<
F,
BankOfAmericaPaymentsResponse,
PaymentsCancelData,
PaymentsResponseData,
>,
) -> Result<Self, Self::Error> {
match item.response {
BankOfAmericaPaymentsResponse::ClientReferenceInformation(info_response) => {
let status = map_boa_attempt_status((info_response.status.clone(), false));
let response = get_payment_response((&info_response, status, item.http_code))
.map_err(|err| *err);
Ok(Self {
status,
response,
..item.data
})
}
BankOfAmericaPaymentsResponse::ErrorInformation(ref error_response) => {
Ok(map_error_response(&error_response.clone(), item, None))
}
}
}
}
#[derive(Debug, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct BankOfAmericaTransactionResponse {
id: String,
application_information: ApplicationInformation,
client_reference_information: Option<ClientReferenceInformation>,
processor_information: Option<ClientProcessorInformation>,
processing_information: Option<ProcessingInformationResponse>,
payment_information: Option<PaymentInformationResponse>,
payment_insights_information: Option<PaymentInsightsInformation>,
error_information: Option<BankOfAmericaErrorInformation>,
fraud_marking_information: Option<FraudMarkingInformation>,
risk_information: Option<ClientRiskInformation>,
token_information: Option<BankOfAmericaTokenInformation>,
reconciliation_id: Option<String>,
consumer_authentication_information: Option<ConsumerAuthenticationInformation>,
}
#[derive(Debug, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct FraudMarkingInformation {
reason: Option<String>,
}
#[derive(Debug, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ApplicationInformation {
status: Option<BankofamericaPaymentStatus>,
}
impl<F>
TryFrom<
ResponseRouterData<
F,
BankOfAmericaTransactionResponse,
PaymentsSyncData,
PaymentsResponseData,
>,
> for RouterData<F, PaymentsSyncData, PaymentsResponseData>
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: ResponseRouterData<
F,
BankOfAmericaTransactionResponse,
PaymentsSyncData,
PaymentsResponseData,
>,
) -> Result<Self, Self::Error> {
match item.response.application_information.status {
Some(app_status) => {
let status =
map_boa_attempt_status((app_status, item.data.request.is_auto_capture()?));
let connector_response = match item.data.payment_method {
common_enums::PaymentMethod::Card => item
.response
.processor_information
.as_ref()
.and_then(|processor_information| {
item.response
.consumer_authentication_information
.as_ref()
.map(|consumer_auth_information| {
convert_to_additional_payment_method_connector_response(
processor_information,
consumer_auth_information,
)
})
})
.map(ConnectorResponseData::with_additional_payment_method_data),
common_enums::PaymentMethod::CardRedirect
| common_enums::PaymentMethod::PayLater
| common_enums::PaymentMethod::Wallet
| common_enums::PaymentMethod::BankRedirect
| common_enums::PaymentMethod::BankTransfer
| common_enums::PaymentMethod::Crypto
| common_enums::PaymentMethod::BankDebit
| common_enums::PaymentMethod::Reward
| common_enums::PaymentMethod::RealTimePayment
| common_enums::PaymentMethod::MobilePayment
| common_enums::PaymentMethod::Upi
| common_enums::PaymentMethod::Voucher
| common_enums::PaymentMethod::OpenBanking
| common_enums::PaymentMethod::GiftCard => None,
};
let risk_info: Option<ClientRiskInformation> = None;
if utils::is_payment_failure(status) {
Ok(Self {
response: Err(get_error_response(
&item.response.error_information,
&item.response.processor_information,
&risk_info,
Some(status),
item.http_code,
item.response.id.clone(),
)),
status: enums::AttemptStatus::Failure,
connector_response,
..item.data
})
} else {
Ok(Self {
status,
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(
item.response.id.clone(),
),
redirection_data: Box::new(None),
mandate_reference: Box::new(None),
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: item
.response
.client_reference_information
.map(|cref| cref.code)
.unwrap_or(Some(item.response.id)),
incremental_authorization_allowed: None,
charges: None,
}),
connector_response,
..item.data
})
}
}
None => Ok(Self {
status: item.data.status,
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(item.response.id.clone()),
redirection_data: Box::new(None),
mandate_reference: Box::new(None),
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: Some(item.response.id),
incremental_authorization_allowed: None,
charges: None,
}),
..item.data
}),
}
}
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct OrderInformation {
amount_details: Amount,
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct BankOfAmericaCaptureRequest {
order_information: OrderInformation,
client_reference_information: ClientReferenceInformation,
#[serde(skip_serializing_if = "Option::is_none")]
merchant_defined_information: Option<Vec<MerchantDefinedInformation>>,
}
impl TryFrom<&BankOfAmericaRouterData<&PaymentsCaptureRouterData>> for BankOfAmericaCaptureRequest {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
value: &BankOfAmericaRouterData<&PaymentsCaptureRouterData>,
) -> Result<Self, Self::Error> {
let merchant_defined_information = value
.router_data
.request
.metadata
.clone()
.map(convert_metadata_to_merchant_defined_info);
Ok(Self {
order_information: OrderInformation {
amount_details: Amount {
total_amount: value.amount.to_owned(),
currency: value.router_data.request.currency,
},
},
client_reference_information: ClientReferenceInformation {
code: Some(value.router_data.connector_request_reference_id.clone()),
},
merchant_defined_information,
})
}
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct BankOfAmericaVoidRequest {
client_reference_information: ClientReferenceInformation,
reversal_information: ReversalInformation,
#[serde(skip_serializing_if = "Option::is_none")]
merchant_defined_information: Option<Vec<MerchantDefinedInformation>>,
// The connector documentation does not mention the merchantDefinedInformation field for Void requests. But this has been still added because it works!
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ReversalInformation {
amount_details: Amount,
reason: String,
}
impl TryFrom<&BankOfAmericaRouterData<&PaymentsCancelRouterData>> for BankOfAmericaVoidRequest {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
value: &BankOfAmericaRouterData<&PaymentsCancelRouterData>,
) -> Result<Self, Self::Error> {
let merchant_defined_information = value
.router_data
.request
.metadata
.clone()
.map(convert_metadata_to_merchant_defined_info);
Ok(Self {
client_reference_information: ClientReferenceInformation {
code: Some(value.router_data.connector_request_reference_id.clone()),
},
reversal_information: ReversalInformation {
amount_details: Amount {
total_amount: value.amount.to_owned(),
currency: value.router_data.request.currency.ok_or(
errors::ConnectorError::MissingRequiredField {
field_name: "Currency",
},
)?,
},
reason: value
.router_data
.request
.cancellation_reason
.clone()
.ok_or(errors::ConnectorError::MissingRequiredField {
field_name: "Cancellation Reason",
})?,
},
merchant_defined_information,
})
}
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct BankOfAmericaRefundRequest {
order_information: OrderInformation,
client_reference_information: ClientReferenceInformation,
}
impl<F> TryFrom<&BankOfAmericaRouterData<&RefundsRouterData<F>>> for BankOfAmericaRefundRequest {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: &BankOfAmericaRouterData<&RefundsRouterData<F>>,
) -> Result<Self, Self::Error> {
Ok(Self {
order_information: OrderInformation {
amount_details: Amount {
total_amount: item.amount.clone(),
currency: item.router_data.request.currency,
},
},
client_reference_information: ClientReferenceInformation {
code: Some(item.router_data.request.refund_id.clone()),
},
})
}
}
impl From<BankOfAmericaRefundResponse> for enums::RefundStatus {
fn from(item: BankOfAmericaRefundResponse) -> Self {
let error_reason = item
.error_information
.and_then(|error_info| error_info.reason);
match item.status {
BankofamericaRefundStatus::Succeeded | BankofamericaRefundStatus::Transmitted => {
Self::Success
}
BankofamericaRefundStatus::Cancelled
| BankofamericaRefundStatus::Failed
| BankofamericaRefundStatus::Voided => Self::Failure,
BankofamericaRefundStatus::Pending => Self::Pending,
BankofamericaRefundStatus::TwoZeroOne => {
if error_reason == Some("PROCESSOR_DECLINED".to_string()) {
Self::Failure
} else {
Self::Pending
}
}
}
}
}
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct BankOfAmericaRefundResponse {
id: String,
status: BankofamericaRefundStatus,
error_information: Option<BankOfAmericaErrorInformation>,
}
impl TryFrom<RefundsResponseRouterData<Execute, BankOfAmericaRefundResponse>>
for RefundsRouterData<Execute>
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: RefundsResponseRouterData<Execute, BankOfAmericaRefundResponse>,
) -> Result<Self, Self::Error> {
let refund_status = enums::RefundStatus::from(item.response.clone());
let response = if utils::is_refund_failure(refund_status) {
Err(get_error_response(
&item.response.error_information,
&None,
&None,
None,
item.http_code,
item.response.id,
))
} else {
Ok(RefundsResponseData {
connector_refund_id: item.response.id,
refund_status,
})
};
Ok(Self {
response,
..item.data
})
}
}
#[derive(Debug, Clone, PartialEq, Deserialize, Serialize)]
#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
pub enum BankofamericaRefundStatus {
Succeeded,
Transmitted,
Failed,
Pending,
Voided,
Cancelled,
#[serde(rename = "201")]
TwoZeroOne,
}
#[derive(Debug, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct RsyncApplicationInformation {
status: Option<BankofamericaRefundStatus>,
}
#[derive(Debug, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct BankOfAmericaRsyncResponse {
id: String,
application_information: Option<RsyncApplicationInformation>,
error_information: Option<BankOfAmericaErrorInformation>,
}
impl TryFrom<RefundsResponseRouterData<RSync, BankOfAmericaRsyncResponse>>
for RefundsRouterData<RSync>
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: RefundsResponseRouterData<RSync, BankOfAmericaRsyncResponse>,
) -> Result<Self, Self::Error> {
let response = match item
.response
.application_information
.and_then(|application_information| application_information.status)
{
Some(status) => {
let error_reason = item
.response
.error_information
.clone()
.and_then(|error_info| error_info.reason);
let refund_status = match status {
BankofamericaRefundStatus::Succeeded
| BankofamericaRefundStatus::Transmitted => enums::RefundStatus::Success,
BankofamericaRefundStatus::Cancelled
| BankofamericaRefundStatus::Failed
| BankofamericaRefundStatus::Voided => enums::RefundStatus::Failure,
BankofamericaRefundStatus::Pending => enums::RefundStatus::Pending,
BankofamericaRefundStatus::TwoZeroOne => {
if error_reason == Some("PROCESSOR_DECLINED".to_string()) {
enums::RefundStatus::Failure
} else {
enums::RefundStatus::Pending
}
}
};
if utils::is_refund_failure(refund_status) {
if status == BankofamericaRefundStatus::Voided {
Err(get_error_response(
&Some(BankOfAmericaErrorInformation {
message: Some(constants::REFUND_VOIDED.to_string()),
reason: Some(constants::REFUND_VOIDED.to_string()),
details: None,
}),
&None,
&None,
None,
item.http_code,
item.response.id.clone(),
))
} else {
Err(get_error_response(
&item.response.error_information,
&None,
&None,
None,
item.http_code,
item.response.id.clone(),
))
}
} else {
Ok(RefundsResponseData {
connector_refund_id: item.response.id,
refund_status,
})
}
}
None => Ok(RefundsResponseData {
connector_refund_id: item.response.id.clone(),
refund_status: match item.data.response {
Ok(response) => response.refund_status,
Err(_) => common_enums::RefundStatus::Pending,
},
}),
};
Ok(Self {
response,
..item.data
})
}
}
#[derive(Debug, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct BankOfAmericaStandardErrorResponse {
pub error_information: Option<ErrorInformation>,
pub status: Option<String>,
pub message: Option<String>,
pub reason: Option<String>,
pub details: Option<Vec<Details>>,
}
#[derive(Debug, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct BankOfAmericaServerErrorResponse {
pub status: Option<String>,
pub message: Option<String>,
pub reason: Option<Reason>,
}
#[derive(Debug, Deserialize, Serialize)]
#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
pub enum Reason {
SystemError,
ServerTimeout,
ServiceTimeout,
}
#[derive(Debug, Deserialize, Serialize)]
pub struct BankOfAmericaAuthenticationErrorResponse {
pub response: AuthenticationErrorInformation,
}
#[derive(Debug, Deserialize, Serialize)]
#[serde(untagged)]
pub enum BankOfAmericaErrorResponse {
AuthenticationError(BankOfAmericaAuthenticationErrorResponse),
StandardError(BankOfAmericaStandardErrorResponse),
}
#[derive(Debug, Deserialize, Clone, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct Details {
pub field: String,
pub reason: String,
}
#[derive(Debug, Default, Deserialize, Serialize)]
pub struct ErrorInformation {
pub message: String,
pub reason: String,
pub details: Option<Vec<Details>>,
}
#[derive(Debug, Default, Deserialize, Serialize)]
pub struct AuthenticationErrorInformation {
pub rmsg: String,
}
fn get_error_response(
error_data: &Option<BankOfAmericaErrorInformation>,
processor_information: &Option<ClientProcessorInformation>,
risk_information: &Option<ClientRiskInformation>,
attempt_status: Option<enums::AttemptStatus>,
status_code: u16,
transaction_id: String,
) -> ErrorResponse {
let avs_message = risk_information
.clone()
.map(|client_risk_information| {
client_risk_information.rules.map(|rules| {
rules
.iter()
.map(|risk_info| {
risk_info.name.clone().map_or("".to_string(), |name| {
format!(" , {}", name.clone().expose())
})
})
.collect::<Vec<String>>()
.join("")
})
})
.unwrap_or(Some("".to_string()));
let detailed_error_info = error_data.to_owned().and_then(|error_info| {
error_info.details.map(|error_details| {
error_details
.iter()
.map(|details| format!("{} : {}", details.field, details.reason))
.collect::<Vec<_>>()
.join(", ")
})
});
let network_decline_code = processor_information
.as_ref()
.and_then(|info| info.response_code.clone());
let network_advice_code = processor_information.as_ref().and_then(|info| {
info.merchant_advice
.as_ref()
.and_then(|merchant_advice| merchant_advice.code_raw.clone())
});
let reason = get_error_reason(
error_data
.clone()
.and_then(|error_details| error_details.message),
detailed_error_info,
avs_message,
);
let error_message = error_data
.clone()
.and_then(|error_details| error_details.reason);
ErrorResponse {
code: error_message
.clone()
.unwrap_or(hyperswitch_interfaces::consts::NO_ERROR_CODE.to_string()),
message: error_message
.clone()
.unwrap_or(hyperswitch_interfaces::consts::NO_ERROR_MESSAGE.to_string()),
reason,
status_code,
attempt_status,
connector_transaction_id: Some(transaction_id.clone()),
network_advice_code,
network_decline_code,
network_error_message: None,
connector_metadata: None,
}
}
impl
TryFrom<(
&SetupMandateRouterData,
hyperswitch_domain_models::payment_method_data::Card,
)> for BankOfAmericaPaymentsRequest
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
(item, ccard): (
&SetupMandateRouterData,
hyperswitch_domain_models::payment_method_data::Card,
),
) -> Result<Self, Self::Error> {
if item.is_three_ds() {
Err(errors::ConnectorError::NotSupported {
message: "Card 3DS".to_string(),
connector: "BankOfAmerica",
})?
};
let order_information = OrderInformationWithBill::try_from(item)?;
let client_reference_information = ClientReferenceInformation::from(item);
let merchant_defined_information =
item.request.metadata.clone().map(|metadata| {
convert_metadata_to_merchant_defined_info(metadata.peek().to_owned())
});
let payment_information = PaymentInformation::try_from(&ccard)?;
let processing_information = ProcessingInformation::try_from((None, None))?;
Ok(Self {
processing_information,
payment_information,
order_information,
client_reference_information,
consumer_authentication_information: None,
merchant_defined_information,
})
}
}
impl TryFrom<(&SetupMandateRouterData, ApplePayWalletData)> for BankOfAmericaPaymentsRequest {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
(item, apple_pay_data): (&SetupMandateRouterData, ApplePayWalletData),
) -> Result<Self, Self::Error> {
let order_information = OrderInformationWithBill::try_from(item)?;
let client_reference_information = ClientReferenceInformation::from(item);
let merchant_defined_information =
item.request.metadata.clone().map(|metadata| {
convert_metadata_to_merchant_defined_info(metadata.peek().to_owned())
});
let payment_information = match item.payment_method_token.clone() {
Some(payment_method_token) => match payment_method_token {
PaymentMethodToken::ApplePayDecrypt(decrypt_data) => {
PaymentInformation::try_from(&decrypt_data)?
}
PaymentMethodToken::Token(_) => Err(unimplemented_payment_method!(
"Apple Pay",
"Manual",
"Bank Of America"
))?,
PaymentMethodToken::PazeDecrypt(_) => {
Err(unimplemented_payment_method!("Paze", "Bank Of America"))?
}
PaymentMethodToken::GooglePayDecrypt(_) => Err(unimplemented_payment_method!(
"Google Pay",
"Bank Of America"
))?,
},
None => PaymentInformation::try_from(&apple_pay_data)?,
};
let processing_information = ProcessingInformation::try_from((
Some(PaymentSolution::ApplePay),
Some(apple_pay_data.payment_method.network.clone()),
))?;
let ucaf_collection_indicator = match apple_pay_data
.payment_method
.network
.to_lowercase()
.as_str()
{
"mastercard" => Some("2".to_string()),
_ => None,
};
let consumer_authentication_information = Some(BankOfAmericaConsumerAuthInformation {
ucaf_collection_indicator,
cavv: None,
ucaf_authentication_data: None,
xid: None,
directory_server_transaction_id: None,
specification_version: None,
});
Ok(Self {
processing_information,
payment_information,
order_information,
client_reference_information,
merchant_defined_information,
consumer_authentication_information,
})
}
}
impl TryFrom<(&SetupMandateRouterData, GooglePayWalletData)> for BankOfAmericaPaymentsRequest {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
(item, google_pay_data): (&SetupMandateRouterData, GooglePayWalletData),
) -> Result<Self, Self::Error> {
let order_information = OrderInformationWithBill::try_from(item)?;
let client_reference_information = ClientReferenceInformation::from(item);
let merchant_defined_information =
item.request.metadata.clone().map(|metadata| {
convert_metadata_to_merchant_defined_info(metadata.peek().to_owned())
});
let payment_information = PaymentInformation::try_from(&google_pay_data)?;
let processing_information =
ProcessingInformation::try_from((Some(PaymentSolution::GooglePay), None))?;
Ok(Self {
processing_information,
payment_information,
order_information,
client_reference_information,
merchant_defined_information,
consumer_authentication_information: None,
})
}
}
// specific for setupMandate flow
impl TryFrom<(Option<PaymentSolution>, Option<String>)> for ProcessingInformation {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
(solution, network): (Option<PaymentSolution>, Option<String>),
) -> Result<Self, Self::Error> {
let (action_list, action_token_types, authorization_options) =
get_boa_mandate_action_details();
let commerce_indicator = get_commerce_indicator(network);
Ok(Self {
capture: Some(false),
capture_options: None,
action_list,
action_token_types,
authorization_options,
commerce_indicator,
payment_solution: solution.map(String::from),
})
}
}
impl TryFrom<&SetupMandateRouterData> for OrderInformationWithBill {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(item: &SetupMandateRouterData) -> Result<Self, Self::Error> {
let email = item.request.get_email()?;
let bill_to = build_bill_to(item.get_optional_billing(), email)?;
Ok(Self {
amount_details: Amount {
total_amount: StringMajorUnit::zero(),
currency: item.request.currency,
},
bill_to: Some(bill_to),
})
}
}
impl TryFrom<&hyperswitch_domain_models::payment_method_data::Card> for PaymentInformation {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
ccard: &hyperswitch_domain_models::payment_method_data::Card,
) -> Result<Self, Self::Error> {
let card_type = match ccard.card_network.clone().and_then(get_boa_card_type) {
Some(card_network) => Some(card_network.to_string()),
None => ccard.get_card_issuer().ok().map(String::from),
};
Ok(Self::Cards(Box::new(CardPaymentInformation {
card: Card {
number: ccard.card_number.clone(),
expiration_month: ccard.card_exp_month.clone(),
expiration_year: ccard.card_exp_year.clone(),
security_code: ccard.card_cvc.clone(),
card_type,
},
})))
}
}
impl TryFrom<&Box<ApplePayPredecryptData>> for PaymentInformation {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(apple_pay_data: &Box<ApplePayPredecryptData>) -> Result<Self, Self::Error> {
let expiration_month = apple_pay_data.get_expiry_month().change_context(
errors::ConnectorError::InvalidDataFormat {
field_name: "expiration_month",
},
)?;
let expiration_year = apple_pay_data.get_four_digit_expiry_year();
Ok(Self::ApplePay(Box::new(ApplePayPaymentInformation {
tokenized_card: TokenizedCard {
number: apple_pay_data.application_primary_account_number.clone(),
cryptogram: apple_pay_data
.payment_data
.online_payment_cryptogram
.clone(),
transaction_type: TransactionType::ApplePay,
expiration_year,
expiration_month,
},
})))
}
}
impl TryFrom<&ApplePayWalletData> for PaymentInformation {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(apple_pay_data: &ApplePayWalletData) -> Result<Self, Self::Error> {
let apple_pay_encrypted_data = apple_pay_data
.payment_data
.get_encrypted_apple_pay_payment_data_mandatory()
.change_context(errors::ConnectorError::MissingRequiredField {
field_name: "Apple pay encrypted data",
})?;
Ok(Self::ApplePayToken(Box::new(
ApplePayTokenPaymentInformation {
fluid_data: FluidData {
value: Secret::from(apple_pay_encrypted_data.clone()),
descriptor: None,
},
tokenized_card: ApplePayTokenizedCard {
transaction_type: TransactionType::ApplePay,
},
},
)))
}
}
impl TryFrom<&GooglePayWalletData> for PaymentInformation {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(google_pay_data: &GooglePayWalletData) -> Result<Self, Self::Error> {
Ok(Self::GooglePay(Box::new(GooglePayPaymentInformation {
fluid_data: FluidData {
value: Secret::from(
consts::BASE64_ENGINE.encode(
google_pay_data
.tokenization_data
.get_encrypted_google_pay_token()
.change_context(errors::ConnectorError::MissingRequiredField {
field_name: "gpay wallet_token",
})?
.clone(),
),
),
descriptor: None,
},
})))
}
}
fn convert_to_error_response_from_error_info(
error_response: &BankOfAmericaErrorInformationResponse,
status_code: u16,
) -> ErrorResponse {
let detailed_error_info =
error_response
.error_information
.to_owned()
.details
.map(|error_details| {
error_details
.iter()
.map(|details| format!("{} : {}", details.field, details.reason))
.collect::<Vec<_>>()
.join(", ")
});
let reason = get_error_reason(
error_response.error_information.message.to_owned(),
detailed_error_info,
None,
);
ErrorResponse {
code: error_response
.error_information
.reason
.clone()
.unwrap_or(hyperswitch_interfaces::consts::NO_ERROR_CODE.to_string()),
message: error_response
.error_information
.reason
.clone()
.unwrap_or(hyperswitch_interfaces::consts::NO_ERROR_MESSAGE.to_string()),
reason,
status_code,
attempt_status: None,
connector_transaction_id: Some(error_response.id.clone()),
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
connector_metadata: None,
}
}
fn get_boa_mandate_action_details() -> (
Option<Vec<BankOfAmericaActionsList>>,
Option<Vec<BankOfAmericaActionsTokenType>>,
Option<BankOfAmericaAuthorizationOptions>,
) {
(
Some(vec![BankOfAmericaActionsList::TokenCreate]),
Some(vec![
BankOfAmericaActionsTokenType::PaymentInstrument,
BankOfAmericaActionsTokenType::Customer,
]),
Some(BankOfAmericaAuthorizationOptions {
initiator: Some(BankOfAmericaPaymentInitiator {
initiator_type: Some(BankOfAmericaPaymentInitiatorTypes::Customer),
credential_stored_on_file: Some(true),
stored_credential_used: None,
}),
merchant_intitiated_transaction: None,
}),
)
}
fn get_commerce_indicator(network: Option<String>) -> String {
match network {
Some(card_network) => match card_network.to_lowercase().as_str() {
"amex" => "aesk",
"discover" => "dipb",
"mastercard" => "spa",
"visa" => "internet",
_ => "internet",
},
None => "internet",
}
.to_string()
}
pub fn get_error_reason(
error_info: Option<String>,
detailed_error_info: Option<String>,
avs_error_info: Option<String>,
) -> Option<String> {
match (error_info, detailed_error_info, avs_error_info) {
(Some(message), Some(details), Some(avs_message)) => Some(format!(
"{message}, detailed_error_information: {details}, avs_message: {avs_message}",
)),
(Some(message), Some(details), None) => {
Some(format!("{message}, detailed_error_information: {details}"))
}
(Some(message), None, Some(avs_message)) => {
Some(format!("{message}, avs_message: {avs_message}"))
}
(None, Some(details), Some(avs_message)) => {
Some(format!("{details}, avs_message: {avs_message}"))
}
(Some(message), None, None) => Some(message),
(None, Some(details), None) => Some(details),
(None, None, Some(avs_message)) => Some(avs_message),
(None, None, None) => None,
}
}
|
{
"crate": "hyperswitch_connectors",
"file": "crates/hyperswitch_connectors/src/connectors/bankofamerica/transformers.rs",
"file_size": null,
"is_async": null,
"is_pub": null,
"num_enums": 13,
"num_structs": 74,
"num_tables": null,
"score": null,
"total_crates": null
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.