rust/hyperswitch
1
0
Fork 0
mirror of https://github.com/juspay/hyperswitch.git synced 2025-11-02 04:04:43 +08:00
Code Issues Packages Projects Releases Wiki Activity

feat(connector): [ProphetPay] Template generation (#2610)

Browse Source 
Co-authored-by: Arjun Karthik <m.arjunkarthik@gmail.com>
This commit is contained in:
Sakil Mostak
2023-10-19 13:20:40 +05:30
committed by GitHub
parent 6494e8a6e4
commit 7e6207e6ca
16 changed files with 1226 additions and 6 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
crates/router/src/configs/settings.rs
View File

@ -559,6 +559,7 @@ pub struct Connectors {
pub paypal: ConnectorParams,
pub payu: ConnectorParams,
pub powertranz: ConnectorParams,
pub prophetpay: ConnectorParams,
pub rapyd: ConnectorParams,
pub shift4: ConnectorParams,
pub square: ConnectorParams,

7
crates/router/src/connector.rs
View File

@ -36,6 +36,7 @@ pub mod payme;
pub mod paypal;
pub mod payu;
pub mod powertranz;
pub mod prophetpay;
pub mod rapyd;
pub mod shift4;
pub mod square;
@ -60,7 +61,7 @@ pub use self::{
globepay::Globepay, gocardless::Gocardless, helcim::Helcim, iatapay::Iatapay, klarna::Klarna,
mollie::Mollie, multisafepay::Multisafepay, nexinets::Nexinets, nmi::Nmi, noon::Noon,
nuvei::Nuvei, opayo::Opayo, opennode::Opennode, payeezy::Payeezy, payme::Payme, paypal::Paypal,
payu::Payu, powertranz::Powertranz, rapyd::Rapyd, shift4::Shift4, square::Square, stax::Stax,
stripe::Stripe, trustpay::Trustpay, tsys::Tsys, volt::Volt, wise::Wise, worldline::Worldline,
worldpay::Worldpay, zen::Zen,
payu::Payu, powertranz::Powertranz, prophetpay::Prophetpay, rapyd::Rapyd, shift4::Shift4,
square::Square, stax::Stax, stripe::Stripe, trustpay::Trustpay, tsys::Tsys, volt::Volt,
wise::Wise, worldline::Worldline, worldpay::Worldpay, zen::Zen,
};

534
crates/router/src/connector/prophetpay.rs Normal file
View File

@ -0,0 +1,534 @@
pub mod transformers;
use std::fmt::Debug;
use error_stack::{IntoReport, ResultExt};
use masking::ExposeInterface;
use transformers as prophetpay;
use crate::{
configs::settings,
core::errors::{self, CustomResult},
headers,
services::{
self,
request::{self, Mask},
ConnectorIntegration, ConnectorValidation,
},
types::{
self,
api::{self, ConnectorCommon, ConnectorCommonExt},
ErrorResponse, Response,
},
utils::{self, BytesExt},
};
#[derive(Debug, Clone)]
pub struct Prophetpay;
impl api::payments::MandateSetup for Prophetpay {}
impl api::Payment for Prophetpay {}
impl api::PaymentSession for Prophetpay {}
impl api::ConnectorAccessToken for Prophetpay {}
impl api::PaymentAuthorize for Prophetpay {}
impl api::PaymentSync for Prophetpay {}
impl api::PaymentCapture for Prophetpay {}
impl api::PaymentVoid for Prophetpay {}
impl api::Refund for Prophetpay {}
impl api::RefundExecute for Prophetpay {}
impl api::RefundSync for Prophetpay {}
impl api::PaymentToken for Prophetpay {}
impl
ConnectorIntegration<
api::PaymentMethodToken,
types::PaymentMethodTokenizationData,
types::PaymentsResponseData,
> for Prophetpay
{
// Not Implemented (R)
}
impl<Flow, Request, Response> ConnectorCommonExt<Flow, Request, Response> for Prophetpay
where
Self: ConnectorIntegration<Flow, Request, Response>,
{
fn build_headers(
&self,
req: &types::RouterData<Flow, Request, Response>,
_connectors: &settings::Connectors,
) -> CustomResult<Vec<(String, request::Maskable<String>)>, errors::ConnectorError> {
let mut header = vec![(
headers::CONTENT_TYPE.to_string(),
self.get_content_type().to_string().into(),
)];
let mut api_key = self.get_auth_header(&req.connector_auth_type)?;
header.append(&mut api_key);
Ok(header)
}
}
impl ConnectorCommon for Prophetpay {
fn id(&self) -> &'static str {
"prophetpay"
}
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 settings::Connectors) -> &'a str {
connectors.prophetpay.base_url.as_ref()
}
fn get_auth_header(
&self,
auth_type: &types::ConnectorAuthType,
) -> CustomResult<Vec<(String, request::Maskable<String>)>, errors::ConnectorError> {
let auth = prophetpay::ProphetpayAuthType::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,
) -> CustomResult<ErrorResponse, errors::ConnectorError> {
let response: prophetpay::ProphetpayErrorResponse = res
.response
.parse_struct("ProphetpayErrorResponse")
.change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
Ok(ErrorResponse {
status_code: res.status_code,
code: response.code,
message: response.message,
reason: response.reason,
})
}
}
impl ConnectorValidation for Prophetpay {
//TODO: implement functions when support enabled
}
impl ConnectorIntegration<api::Session, types::PaymentsSessionData, types::PaymentsResponseData>
for Prophetpay
{
//TODO: implement sessions flow
}
impl ConnectorIntegration<api::AccessTokenAuth, types::AccessTokenRequestData, types::AccessToken>
for Prophetpay
{
}
impl
ConnectorIntegration<
api::SetupMandate,
types::SetupMandateRequestData,
types::PaymentsResponseData,
> for Prophetpay
{
}
impl ConnectorIntegration<api::Authorize, types::PaymentsAuthorizeData, types::PaymentsResponseData>
for Prophetpay
{
fn get_headers(
&self,
req: &types::PaymentsAuthorizeRouterData,
connectors: &settings::Connectors,
) -> CustomResult<Vec<(String, request::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: &types::PaymentsAuthorizeRouterData,
_connectors: &settings::Connectors,
) -> CustomResult<String, errors::ConnectorError> {
Err(errors::ConnectorError::NotImplemented("get_url method".to_string()).into())
}
fn get_request_body(
&self,
req: &types::PaymentsAuthorizeRouterData,
) -> CustomResult<Option<types::RequestBody>, errors::ConnectorError> {
let connector_router_data = prophetpay::ProphetpayRouterData::try_from((
&self.get_currency_unit(),
req.request.currency,
req.request.amount,
req,
))?;
let req_obj = prophetpay::ProphetpayPaymentsRequest::try_from(&connector_router_data)?;
let prophetpay_req = types::RequestBody::log_and_get_request_body(
&req_obj,
utils::Encode::<prophetpay::ProphetpayPaymentsRequest>::encode_to_string_of_json,
)
.change_context(errors::ConnectorError::RequestEncodingFailed)?;
Ok(Some(prophetpay_req))
}
fn build_request(
&self,
req: &types::PaymentsAuthorizeRouterData,
connectors: &settings::Connectors,
) -> CustomResult<Option<services::Request>, errors::ConnectorError> {
Ok(Some(
services::RequestBuilder::new()
.method(services::Method::Post)
.url(&types::PaymentsAuthorizeType::get_url(
self, req, connectors,
)?)
.attach_default_headers()
.headers(types::PaymentsAuthorizeType::get_headers(
self, req, connectors,
)?)
.body(types::PaymentsAuthorizeType::get_request_body(self, req)?)
.build(),
))
}
fn handle_response(
&self,
data: &types::PaymentsAuthorizeRouterData,
res: Response,
) -> CustomResult<types::PaymentsAuthorizeRouterData, errors::ConnectorError> {
let response: prophetpay::ProphetpayPaymentsResponse = res
.response
.parse_struct("Prophetpay PaymentsAuthorizeResponse")
.change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
types::RouterData::try_from(types::ResponseRouterData {
response,
data: data.clone(),
http_code: res.status_code,
})
}
fn get_error_response(
&self,
res: Response,
) -> CustomResult<ErrorResponse, errors::ConnectorError> {
self.build_error_response(res)
}
}
impl ConnectorIntegration<api::PSync, types::PaymentsSyncData, types::PaymentsResponseData>
for Prophetpay
{
fn get_headers(
&self,
req: &types::PaymentsSyncRouterData,
connectors: &settings::Connectors,
) -> CustomResult<Vec<(String, request::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: &types::PaymentsSyncRouterData,
_connectors: &settings::Connectors,
) -> CustomResult<String, errors::ConnectorError> {
Err(errors::ConnectorError::NotImplemented("get_url method".to_string()).into())
}
fn build_request(
&self,
req: &types::PaymentsSyncRouterData,
connectors: &settings::Connectors,
) -> CustomResult<Option<services::Request>, errors::ConnectorError> {
Ok(Some(
services::RequestBuilder::new()
.method(services::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: &types::PaymentsSyncRouterData,
res: Response,
) -> CustomResult<types::PaymentsSyncRouterData, errors::ConnectorError> {
let response: prophetpay::ProphetpayPaymentsResponse = res
.response
.parse_struct("prophetpay PaymentsSyncResponse")
.change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
types::RouterData::try_from(types::ResponseRouterData {
response,
data: data.clone(),
http_code: res.status_code,
})
}
fn get_error_response(
&self,
res: Response,
) -> CustomResult<ErrorResponse, errors::ConnectorError> {
self.build_error_response(res)
}
}
impl ConnectorIntegration<api::Capture, types::PaymentsCaptureData, types::PaymentsResponseData>
for Prophetpay
{
fn get_headers(
&self,
req: &types::PaymentsCaptureRouterData,
connectors: &settings::Connectors,
) -> CustomResult<Vec<(String, request::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: &types::PaymentsCaptureRouterData,
_connectors: &settings::Connectors,
) -> CustomResult<String, errors::ConnectorError> {
Err(errors::ConnectorError::NotImplemented("get_url method".to_string()).into())
}
fn get_request_body(
&self,
_req: &types::PaymentsCaptureRouterData,
) -> CustomResult<Option<types::RequestBody>, errors::ConnectorError> {
Err(errors::ConnectorError::NotImplemented("get_request_body method".to_string()).into())
}
fn build_request(
&self,
req: &types::PaymentsCaptureRouterData,
connectors: &settings::Connectors,
) -> CustomResult<Option<services::Request>, errors::ConnectorError> {
Ok(Some(
services::RequestBuilder::new()
.method(services::Method::Post)
.url(&types::PaymentsCaptureType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(types::PaymentsCaptureType::get_headers(
self, req, connectors,
)?)
.body(types::PaymentsCaptureType::get_request_body(self, req)?)
.build(),
))
}
fn handle_response(
&self,
data: &types::PaymentsCaptureRouterData,
res: Response,
) -> CustomResult<types::PaymentsCaptureRouterData, errors::ConnectorError> {
let response: prophetpay::ProphetpayPaymentsResponse = res
.response
.parse_struct("Prophetpay PaymentsCaptureResponse")
.change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
types::RouterData::try_from(types::ResponseRouterData {
response,
data: data.clone(),
http_code: res.status_code,
})
}
fn get_error_response(
&self,
res: Response,
) -> CustomResult<ErrorResponse, errors::ConnectorError> {
self.build_error_response(res)
}
}
impl ConnectorIntegration<api::Void, types::PaymentsCancelData, types::PaymentsResponseData>
for Prophetpay
{
}
impl ConnectorIntegration<api::Execute, types::RefundsData, types::RefundsResponseData>
for Prophetpay
{
fn get_headers(
&self,
req: &types::RefundsRouterData<api::Execute>,
connectors: &settings::Connectors,
) -> CustomResult<Vec<(String, request::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: &types::RefundsRouterData<api::Execute>,
_connectors: &settings::Connectors,
) -> CustomResult<String, errors::ConnectorError> {
Err(errors::ConnectorError::NotImplemented("get_url method".to_string()).into())
}
fn get_request_body(
&self,
req: &types::RefundsRouterData<api::Execute>,
) -> CustomResult<Option<types::RequestBody>, errors::ConnectorError> {
let connector_router_data = prophetpay::ProphetpayRouterData::try_from((
&self.get_currency_unit(),
req.request.currency,
req.request.refund_amount,
req,
))?;
let req_obj = prophetpay::ProphetpayRefundRequest::try_from(&connector_router_data)?;
let prophetpay_req = types::RequestBody::log_and_get_request_body(
&req_obj,
utils::Encode::<prophetpay::ProphetpayRefundRequest>::encode_to_string_of_json,
)
.change_context(errors::ConnectorError::RequestEncodingFailed)?;
Ok(Some(prophetpay_req))
}
fn build_request(
&self,
req: &types::RefundsRouterData<api::Execute>,
connectors: &settings::Connectors,
) -> CustomResult<Option<services::Request>, errors::ConnectorError> {
let request = services::RequestBuilder::new()
.method(services::Method::Post)
.url(&types::RefundExecuteType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(types::RefundExecuteType::get_headers(
self, req, connectors,
)?)
.body(types::RefundExecuteType::get_request_body(self, req)?)
.build();
Ok(Some(request))
}
fn handle_response(
&self,
data: &types::RefundsRouterData<api::Execute>,
res: Response,
) -> CustomResult<types::RefundsRouterData<api::Execute>, errors::ConnectorError> {
let response: prophetpay::RefundResponse = res
.response
.parse_struct("prophetpay RefundResponse")
.change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
types::RouterData::try_from(types::ResponseRouterData {
response,
data: data.clone(),
http_code: res.status_code,
})
}
fn get_error_response(
&self,
res: Response,
) -> CustomResult<ErrorResponse, errors::ConnectorError> {
self.build_error_response(res)
}
}
impl ConnectorIntegration<api::RSync, types::RefundsData, types::RefundsResponseData>
for Prophetpay
{
fn get_headers(
&self,
req: &types::RefundSyncRouterData,
connectors: &settings::Connectors,
) -> CustomResult<Vec<(String, request::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: &types::RefundSyncRouterData,
_connectors: &settings::Connectors,
) -> CustomResult<String, errors::ConnectorError> {
Err(errors::ConnectorError::NotImplemented("get_url method".to_string()).into())
}
fn build_request(
&self,
req: &types::RefundSyncRouterData,
connectors: &settings::Connectors,
) -> CustomResult<Option<services::Request>, errors::ConnectorError> {
Ok(Some(
services::RequestBuilder::new()
.method(services::Method::Get)
.url(&types::RefundSyncType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(types::RefundSyncType::get_headers(self, req, connectors)?)
.body(types::RefundSyncType::get_request_body(self, req)?)
.build(),
))
}
fn handle_response(
&self,
data: &types::RefundSyncRouterData,
res: Response,
) -> CustomResult<types::RefundSyncRouterData, errors::ConnectorError> {
let response: prophetpay::RefundResponse = res
.response
.parse_struct("prophetpay RefundSyncResponse")
.change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
types::RouterData::try_from(types::ResponseRouterData {
response,
data: data.clone(),
http_code: res.status_code,
})
}
fn get_error_response(
&self,
res: Response,
) -> CustomResult<ErrorResponse, errors::ConnectorError> {
self.build_error_response(res)
}
}
#[async_trait::async_trait]
impl api::IncomingWebhook for Prophetpay {
fn get_webhook_object_reference_id(
&self,
_request: &api::IncomingWebhookRequestDetails<'_>,
) -> CustomResult<api::webhooks::ObjectReferenceId, errors::ConnectorError> {
Err(errors::ConnectorError::WebhooksNotImplemented).into_report()
}
fn get_webhook_event_type(
&self,
_request: &api::IncomingWebhookRequestDetails<'_>,
) -> CustomResult<api::IncomingWebhookEvent, errors::ConnectorError> {
Err(errors::ConnectorError::WebhooksNotImplemented).into_report()
}
fn get_webhook_resource_object(
&self,
_request: &api::IncomingWebhookRequestDetails<'_>,
) -> CustomResult<serde_json::Value, errors::ConnectorError> {
Err(errors::ConnectorError::WebhooksNotImplemented).into_report()
}
}

233
crates/router/src/connector/prophetpay/transformers.rs Normal file
View File

@ -0,0 +1,233 @@
use masking::Secret;
use serde::{Deserialize, Serialize};
use crate::{
connector::utils::PaymentsAuthorizeRequestData,
core::errors,
types::{self, api, storage::enums},
};
pub struct ProphetpayRouterData<T> {
pub amount: i64, // The type of amount that a connector accepts, for example, String, i64, f64, etc.
pub router_data: T,
}
impl<T>
TryFrom<(
&types::api::CurrencyUnit,
types::storage::enums::Currency,
i64,
T,
)> for ProphetpayRouterData<T>
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
(_currency_unit, _currency, amount, item): (
&types::api::CurrencyUnit,
types::storage::enums::Currency,
i64,
T,
),
) -> Result<Self, Self::Error> {
Ok(Self {
amount,
router_data: item,
})
}
}
#[derive(Default, Debug, Serialize, Eq, PartialEq)]
pub struct ProphetpayPaymentsRequest {
amount: i64,
card: ProphetpayCard,
}
#[derive(Default, Debug, Serialize, Eq, PartialEq)]
pub struct ProphetpayCard {
name: Secret<String>,
number: cards::CardNumber,
expiry_month: Secret<String>,
expiry_year: Secret<String>,
cvc: Secret<String>,
complete: bool,
}
impl TryFrom<&ProphetpayRouterData<&types::PaymentsAuthorizeRouterData>>
for ProphetpayPaymentsRequest
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: &ProphetpayRouterData<&types::PaymentsAuthorizeRouterData>,
) -> Result<Self, Self::Error> {
match item.router_data.request.payment_method_data.clone() {
api::PaymentMethodData::Card(req_card) => {
let card = ProphetpayCard {
name: req_card.card_holder_name,
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.to_owned(),
card,
})
}
_ => Err(errors::ConnectorError::NotImplemented("Payment methods".to_string()).into()),
}
}
}
pub struct ProphetpayAuthType {
pub(super) api_key: Secret<String>,
}
impl TryFrom<&types::ConnectorAuthType> for ProphetpayAuthType {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(auth_type: &types::ConnectorAuthType) -> Result<Self, Self::Error> {
match auth_type {
types::ConnectorAuthType::HeaderKey { api_key } => Ok(Self {
api_key: api_key.to_owned(),
}),
_ => Err(errors::ConnectorError::FailedToObtainAuthType.into()),
}
}
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, PartialEq)]
#[serde(rename_all = "lowercase")]
pub enum ProphetpayPaymentStatus {
Succeeded,
Failed,
#[default]
Processing,
}
impl From<ProphetpayPaymentStatus> for enums::AttemptStatus {
fn from(item: ProphetpayPaymentStatus) -> Self {
match item {
ProphetpayPaymentStatus::Succeeded => Self::Charged,
ProphetpayPaymentStatus::Failed => Self::Failure,
ProphetpayPaymentStatus::Processing => Self::Authorizing,
}
}
}
#[derive(Default, Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct ProphetpayPaymentsResponse {
status: ProphetpayPaymentStatus,
id: String,
}
impl<F, T>
TryFrom<
types::ResponseRouterData<F, ProphetpayPaymentsResponse, T, types::PaymentsResponseData>,
> for types::RouterData<F, T, types::PaymentsResponseData>
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: types::ResponseRouterData<
F,
ProphetpayPaymentsResponse,
T,
types::PaymentsResponseData,
>,
) -> Result<Self, Self::Error> {
Ok(Self {
status: enums::AttemptStatus::from(item.response.status),
response: Ok(types::PaymentsResponseData::TransactionResponse {
resource_id: types::ResponseId::ConnectorTransactionId(item.response.id),
redirection_data: None,
mandate_reference: None,
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: None,
}),
..item.data
})
}
}
#[derive(Default, Debug, Serialize)]
pub struct ProphetpayRefundRequest {
pub amount: i64,
}
impl<F> TryFrom<&ProphetpayRouterData<&types::RefundsRouterData<F>>> for ProphetpayRefundRequest {
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: &ProphetpayRouterData<&types::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<types::RefundsResponseRouterData<api::Execute, RefundResponse>>
for types::RefundsRouterData<api::Execute>
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: types::RefundsResponseRouterData<api::Execute, RefundResponse>,
) -> Result<Self, Self::Error> {
Ok(Self {
response: Ok(types::RefundsResponseData {
connector_refund_id: item.response.id.to_string(),
refund_status: enums::RefundStatus::from(item.response.status),
}),
..item.data
})
}
}
impl TryFrom<types::RefundsResponseRouterData<api::RSync, RefundResponse>>
for types::RefundsRouterData<api::RSync>
{
type Error = error_stack::Report<errors::ConnectorError>;
fn try_from(
item: types::RefundsResponseRouterData<api::RSync, RefundResponse>,
) -> Result<Self, Self::Error> {
Ok(Self {
response: Ok(types::RefundsResponseData {
connector_refund_id: item.response.id.to_string(),
refund_status: enums::RefundStatus::from(item.response.status),
}),
..item.data
})
}
}
#[derive(Default, Debug, Serialize, Deserialize, PartialEq)]
pub struct ProphetpayErrorResponse {
pub status_code: u16,
pub code: String,
pub message: String,
pub reason: Option<String>,
}

19
crates/router/src/core/payments/flows.rs
View File

@ -167,6 +167,7 @@ default_imp_for_complete_authorize!(
connector::Opennode,
connector::Payeezy,
connector::Payu,
connector::Prophetpay,
connector::Rapyd,
connector::Square,
connector::Stax,
@ -241,6 +242,7 @@ default_imp_for_webhook_source_verification!(
connector::Payme,
connector::Payu,
connector::Powertranz,
connector::Prophetpay,
connector::Rapyd,
connector::Shift4,
connector::Square,
@ -318,6 +320,7 @@ default_imp_for_create_customer!(
connector::Payme,
connector::Payu,
connector::Powertranz,
connector::Prophetpay,
connector::Rapyd,
connector::Shift4,
connector::Square,
@ -384,6 +387,7 @@ default_imp_for_connector_redirect_response!(
connector::Payeezy,
connector::Payu,
connector::Powertranz,
connector::Prophetpay,
connector::Rapyd,
connector::Shift4,
connector::Square,
@ -441,6 +445,7 @@ default_imp_for_connector_request_id!(
connector::Paypal,
connector::Payu,
connector::Powertranz,
connector::Prophetpay,
connector::Rapyd,
connector::Shift4,
connector::Square,
@ -521,6 +526,7 @@ default_imp_for_accept_dispute!(
connector::Payme,
connector::Payu,
connector::Powertranz,
connector::Prophetpay,
connector::Rapyd,
connector::Shift4,
connector::Square,
@ -619,6 +625,7 @@ default_imp_for_file_upload!(
connector::Payme,
connector::Payu,
connector::Powertranz,
connector::Prophetpay,
connector::Rapyd,
connector::Shift4,
connector::Square,
@ -695,6 +702,7 @@ default_imp_for_submit_evidence!(
connector::Payme,
connector::Payu,
connector::Powertranz,
connector::Prophetpay,
connector::Rapyd,
connector::Shift4,
connector::Square,
@ -771,6 +779,7 @@ default_imp_for_defend_dispute!(
connector::Payme,
connector::Payu,
connector::Powertranz,
connector::Prophetpay,
connector::Rapyd,
connector::Shift4,
connector::Square,
@ -848,6 +857,7 @@ default_imp_for_pre_processing_steps!(
connector::Paypal,
connector::Payu,
connector::Powertranz,
connector::Prophetpay,
connector::Rapyd,
connector::Shift4,
connector::Square,
@ -907,6 +917,7 @@ default_imp_for_payouts!(
connector::Paypal,
connector::Payu,
connector::Powertranz,
connector::Prophetpay,
connector::Rapyd,
connector::Square,
connector::Stax,
@ -984,6 +995,7 @@ default_imp_for_payouts_create!(
connector::Paypal,
connector::Payu,
connector::Powertranz,
connector::Prophetpay,
connector::Rapyd,
connector::Square,
connector::Stax,
@ -1064,6 +1076,7 @@ default_imp_for_payouts_eligibility!(
connector::Paypal,
connector::Payu,
connector::Powertranz,
connector::Prophetpay,
connector::Rapyd,
connector::Square,
connector::Stax,
@ -1141,6 +1154,7 @@ default_imp_for_payouts_fulfill!(
connector::Paypal,
connector::Payu,
connector::Powertranz,
connector::Prophetpay,
connector::Rapyd,
connector::Square,
connector::Stax,
@ -1218,6 +1232,7 @@ default_imp_for_payouts_cancel!(
connector::Paypal,
connector::Payu,
connector::Powertranz,
connector::Prophetpay,
connector::Rapyd,
connector::Square,
connector::Stax,
@ -1296,6 +1311,7 @@ default_imp_for_payouts_quote!(
connector::Paypal,
connector::Payu,
connector::Powertranz,
connector::Prophetpay,
connector::Rapyd,
connector::Square,
connector::Stax,
@ -1374,6 +1390,7 @@ default_imp_for_payouts_recipient!(
connector::Paypal,
connector::Payu,
connector::Powertranz,
connector::Prophetpay,
connector::Rapyd,
connector::Square,
connector::Stax,
@ -1451,6 +1468,7 @@ default_imp_for_approve!(
connector::Paypal,
connector::Payu,
connector::Powertranz,
connector::Prophetpay,
connector::Rapyd,
connector::Square,
connector::Stax,
@ -1529,6 +1547,7 @@ default_imp_for_reject!(
connector::Paypal,
connector::Payu,
connector::Powertranz,
connector::Prophetpay,
connector::Rapyd,
connector::Square,
connector::Stax,

1
crates/router/src/types/api.rs
View File

@ -342,6 +342,7 @@ impl ConnectorData {
enums::Connector::Payme => Ok(Box::new(&connector::Payme)),
enums::Connector::Payu => Ok(Box::new(&connector::Payu)),
enums::Connector::Powertranz => Ok(Box::new(&connector::Powertranz)),
// enums::Connector::Prophetpay => Ok(Box::new(&connector::Prophetpay)),
enums::Connector::Rapyd => Ok(Box::new(&connector::Rapyd)),
enums::Connector::Shift4 => Ok(Box::new(&connector::Shift4)),
enums::Connector::Square => Ok(Box::new(&connector::Square)),