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

refactor(router): move db models into separate crate and refactoring around it (#125)

Browse Source
This commit is contained in:
ItsMeShashank
2022-12-13 12:00:27 +05:30
committed by GitHub
parent fc670ea0da
commit eb4fe6f46b
106 changed files with 4013 additions and 3387 deletions
Download Patch File Download Diff File Expand all files Collapse all files

17
crates/router/src/core/payments/helpers.rs
View File

@ -24,6 +24,7 @@ use crate::{
self,
api::{self, enums as api_enums, CustomerAcceptanceExt, MandateValidationFieldsExt},
storage::{self, enums as storage_enums, ephemeral_key},
transformers::ForeignInto,
},
utils::{
self,
@ -44,7 +45,7 @@ pub async fn get_address_for_payment_request(
Some(address) => {
match address_id {
Some(id) => Some(
db.update_address(id.to_owned(), address.into())
db.update_address(id.to_owned(), address.foreign_into())
.await
.map_err(|err| {
err.to_not_found_response(errors::ApiErrorResponse::AddressNotFound)
@ -119,7 +120,7 @@ pub async fn get_token_pm_type_mandate_details(
.get_required_value("mandate_data")?;
Ok((
request.payment_token.to_owned(),
request.payment_method.map(Into::into),
request.payment_method.map(ForeignInto::foreign_into),
Some(setup_mandate),
))
}
@ -130,7 +131,7 @@ pub async fn get_token_pm_type_mandate_details(
}
None => Ok((
request.payment_token.to_owned(),
request.payment_method.map(Into::into),
request.payment_method.map(ForeignInto::foreign_into),
request.mandate_data.clone(),
)),
}
@ -184,7 +185,7 @@ pub async fn get_token_for_recurring_mandate(
let _ = cards::get_lookup_key_from_locker(state, &token, &payment_method).await?;
if let Some(payment_method_from_request) = req.payment_method {
let pm: storage_enums::PaymentMethodType = payment_method_from_request.into();
let pm: storage_enums::PaymentMethodType = payment_method_from_request.foreign_into();
if pm != payment_method.payment_method {
Err(report!(errors::ApiErrorResponse::PreconditionFailed {
message: "payment method in request does not match previously provided payment \
@ -464,7 +465,7 @@ pub(crate) async fn call_payment_method(
let customer_id = customer.customer_id.clone();
let payment_method_request = api::CreatePaymentMethod {
merchant_id: Some(merchant_id.to_string()),
payment_method: payment_method_type.into(),
payment_method: payment_method_type.foreign_into(),
payment_method_type: None,
payment_method_issuer: None,
payment_method_issuer_code: None,
@ -496,7 +497,7 @@ pub(crate) async fn call_payment_method(
_ => {
let payment_method_request = api::CreatePaymentMethod {
merchant_id: Some(merchant_id.to_string()),
payment_method: payment_method_type.into(),
payment_method: payment_method_type.foreign_into(),
payment_method_type: None,
payment_method_issuer: None,
payment_method_issuer_code: None,
@ -1160,14 +1161,14 @@ pub fn generate_mandate(
Some(match data.mandate_type {
api::MandateType::SingleUse(data) => new_mandate
.set_mandate_amount(Some(data.amount))
.set_mandate_currency(Some(data.currency.into()))
.set_mandate_currency(Some(data.currency.foreign_into()))
.set_mandate_type(storage_enums::MandateType::SingleUse)
.to_owned(),
api::MandateType::MultiUse(op_data) => match op_data {
Some(data) => new_mandate
.set_mandate_amount(Some(data.amount))
.set_mandate_currency(Some(data.currency.into())),
.set_mandate_currency(Some(data.currency.foreign_into())),
None => &mut new_mandate,
}
.set_mandate_type(storage_enums::MandateType::MultiUse)

5
crates/router/src/core/payments/operations/payment_capture.rs
View File

@ -15,6 +15,7 @@ use crate::{
types::{
api::{self, PaymentIdTypeExt, PaymentsCaptureRequest},
storage::{self, enums},
transformers::ForeignInto,
},
utils::OptionExt,
};
@ -128,8 +129,8 @@ impl<F: Send + Clone> GetTracker<F, payments::PaymentData<F>, api::PaymentsCaptu
setup_mandate: None,
token: None,
address: payments::PaymentAddress {
shipping: shipping_address.as_ref().map(|a| a.into()),
billing: billing_address.as_ref().map(|a| a.into()),
shipping: shipping_address.as_ref().map(|a| a.foreign_into()),
billing: billing_address.as_ref().map(|a| a.foreign_into()),
},
confirm: None,
payment_method_data: None,

5
crates/router/src/core/payments/operations/payment_confirm.rs
View File

@ -18,6 +18,7 @@ use crate::{
self,
api::{self, PaymentIdTypeExt},
storage::{self, enums},
transformers::ForeignInto,
},
utils::{self, OptionExt},
};
@ -147,8 +148,8 @@ impl<F: Send + Clone> GetTracker<F, PaymentData<F>, api::PaymentsRequest> for Pa
setup_mandate,
token,
address: PaymentAddress {
shipping: shipping_address.as_ref().map(|a| a.into()),
billing: billing_address.as_ref().map(|a| a.into()),
shipping: shipping_address.as_ref().map(|a| a.foreign_into()),
billing: billing_address.as_ref().map(|a| a.foreign_into()),
},
confirm: request.confirm,
payment_method_data: request.payment_method_data.clone(),

43
crates/router/src/core/payments/operations/payment_create.rs
View File

@ -23,6 +23,7 @@ use crate::{
self,
enums::{self, IntentStatus},
},
transformers::ForeignInto,
},
utils::OptionExt,
};
@ -107,8 +108,8 @@ impl<F: Send + Clone> GetTracker<F, PaymentData<F>, api::PaymentsRequest> for Pa
{
Ok(payment_attempt) => Ok(payment_attempt),
Err(err) => match err.current_context() {
errors::StorageError::DatabaseError(errors::DatabaseError::UniqueViolation) => {
Err(err) => {
if err.current_context().is_db_unique_violation() {
is_update = true;
db.find_payment_attempt_by_payment_id_merchant_id(
&payment_id,
@ -119,10 +120,12 @@ impl<F: Send + Clone> GetTracker<F, PaymentData<F>, api::PaymentsRequest> for Pa
.map_err(|error| {
error.to_not_found_response(errors::ApiErrorResponse::PaymentNotFound)
})
} else {
Err(err).change_context(errors::ApiErrorResponse::InternalServerError)
}
_ => Err(err).change_context(errors::ApiErrorResponse::InternalServerError),
},
}
}?;
payment_intent = match db
.insert_payment_intent(
Self::make_payment_intent(
@ -139,8 +142,8 @@ impl<F: Send + Clone> GetTracker<F, PaymentData<F>, api::PaymentsRequest> for Pa
{
Ok(payment_intent) => Ok(payment_intent),
Err(err) => match err.current_context() {
errors::StorageError::DatabaseError(errors::DatabaseError::UniqueViolation) => {
Err(err) => {
if err.current_context().is_db_unique_violation() {
is_update = true;
db.find_payment_intent_by_payment_id_merchant_id(
&payment_id,
@ -151,9 +154,10 @@ impl<F: Send + Clone> GetTracker<F, PaymentData<F>, api::PaymentsRequest> for Pa
.map_err(|error| {
error.to_not_found_response(errors::ApiErrorResponse::PaymentNotFound)
})
} else {
Err(err).change_context(errors::ApiErrorResponse::InternalServerError)
}
_ => Err(err).change_context(errors::ApiErrorResponse::InternalServerError),
},
}
}?;
connector_response = match db
@ -164,16 +168,17 @@ impl<F: Send + Clone> GetTracker<F, PaymentData<F>, api::PaymentsRequest> for Pa
.await
{
Ok(connector_resp) => Ok(connector_resp),
Err(err) => match err.current_context() {
errors::StorageError::DatabaseError(errors::DatabaseError::UniqueViolation) => {
Err(err) => {
if err.current_context().is_db_unique_violation() {
Err(err)
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("Duplicate connector response in the database")
} else {
Err(err)
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("Error occured when inserting connector response")
}
_ => Err(err)
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("Error occured when inserting connector response")?,
},
}
}?;
let operation = payments::if_not_create_change_operation::<_, F>(
@ -194,8 +199,8 @@ impl<F: Send + Clone> GetTracker<F, PaymentData<F>, api::PaymentsRequest> for Pa
setup_mandate,
token,
address: PaymentAddress {
shipping: shipping_address.as_ref().map(|a| a.into()),
billing: billing_address.as_ref().map(|a| a.into()),
shipping: shipping_address.as_ref().map(|a| a.foreign_into()),
billing: billing_address.as_ref().map(|a| a.foreign_into()),
},
confirm: request.confirm,
payment_method_data: request.payment_method_data.clone(),
@ -341,13 +346,13 @@ impl PaymentCreate {
amount: amount.into(),
currency,
payment_method,
capture_method: request.capture_method.map(Into::into),
capture_method: request.capture_method.map(ForeignInto::foreign_into),
capture_on: request.capture_on,
confirm: request.confirm.unwrap_or(false),
created_at,
modified_at,
last_synced,
authentication_type: request.authentication_type.map(Into::into),
authentication_type: request.authentication_type.map(ForeignInto::foreign_into),
browser_info,
..storage::PaymentAttemptNew::default()
}
@ -379,7 +384,7 @@ impl PaymentCreate {
modified_at,
last_synced,
client_secret: Some(client_secret),
setup_future_usage: request.setup_future_usage.map(Into::into),
setup_future_usage: request.setup_future_usage.map(ForeignInto::foreign_into),
off_session: request.off_session,
return_url: request.return_url.clone(),
shipping_address_id,

5
crates/router/src/core/payments/operations/payment_method_validate.rs
View File

@ -21,6 +21,7 @@ use crate::{
self,
api::{self, enums as api_enums, PaymentIdTypeExt},
storage::{self, enums as storage_enums},
transformers::ForeignInto,
},
utils,
};
@ -284,7 +285,7 @@ impl PaymentMethodValidate {
amount: 0,
currency: Default::default(),
connector: None,
payment_method: payment_method.map(Into::into),
payment_method: payment_method.map(ForeignInto::foreign_into),
confirm: true,
created_at,
modified_at,
@ -314,7 +315,7 @@ impl PaymentMethodValidate {
modified_at,
last_synced,
client_secret: Some(client_secret),
setup_future_usage: request.setup_future_usage.map(Into::into),
setup_future_usage: request.setup_future_usage.map(ForeignInto::foreign_into),
off_session: request.off_session,
..Default::default()
}

3
crates/router/src/core/payments/operations/payment_response.rs
View File

@ -13,6 +13,7 @@ use crate::{
types::{
self, api,
storage::{self, enums},
transformers::ForeignInto,
},
utils,
};
@ -259,7 +260,7 @@ async fn payment_response_update_tracker<F: Clone, T>(
status: enums::IntentStatus::Failed,
},
Ok(_) => storage::PaymentIntentUpdate::ResponseUpdate {
status: router_data.status.into(),
status: router_data.status.foreign_into(),
return_url: router_data.return_url,
amount_captured: None,
},

5
crates/router/src/core/payments/operations/payment_session.rs
View File

@ -16,6 +16,7 @@ use crate::{
types::{
api::{self, PaymentIdTypeExt},
storage::{self, enums},
transformers::ForeignInto,
},
utils::OptionExt,
};
@ -126,8 +127,8 @@ impl<F: Send + Clone> GetTracker<F, PaymentData<F>, api::PaymentsSessionRequest>
token: None,
setup_mandate: None,
address: payments::PaymentAddress {
shipping: shipping_address.as_ref().map(|a| a.into()),
billing: billing_address.as_ref().map(|a| a.into()),
shipping: shipping_address.as_ref().map(|a| a.foreign_into()),
billing: billing_address.as_ref().map(|a| a.foreign_into()),
},
confirm: None,
payment_method_data: None,

5
crates/router/src/core/payments/operations/payment_start.rs
View File

@ -16,6 +16,7 @@ use crate::{
types::{
api::{self, PaymentIdTypeExt},
storage::{self, enums, Customer},
transformers::ForeignInto,
},
utils::OptionExt,
};
@ -131,8 +132,8 @@ impl<F: Send + Clone> GetTracker<F, PaymentData<F>, api::PaymentsStartRequest> f
setup_mandate: None,
token: None,
address: PaymentAddress {
shipping: shipping_address.as_ref().map(|a| a.into()),
billing: billing_address.as_ref().map(|a| a.into()),
shipping: shipping_address.as_ref().map(|a| a.foreign_into()),
billing: billing_address.as_ref().map(|a| a.foreign_into()),
},
confirm: Some(payment_attempt.confirm),
payment_attempt,

5
crates/router/src/core/payments/operations/payment_status.rs
View File

@ -16,6 +16,7 @@ use crate::{
types::{
api,
storage::{self, enums},
transformers::ForeignInto,
},
utils::{self, OptionExt},
};
@ -201,8 +202,8 @@ async fn get_tracker_for_sync<
setup_mandate: None,
token: None,
address: PaymentAddress {
shipping: shipping_address.as_ref().map(|a| a.into()),
billing: billing_address.as_ref().map(|a| a.into()),
shipping: shipping_address.as_ref().map(|a| a.foreign_into()),
billing: billing_address.as_ref().map(|a| a.foreign_into()),
},
confirm: Some(request.force_sync),
payment_method_data: None,

5
crates/router/src/core/payments/operations/payment_update.rs
View File

@ -17,6 +17,7 @@ use crate::{
types::{
api::{self, PaymentIdTypeExt},
storage::{self, enums},
transformers::ForeignInto,
},
utils::{OptionExt, StringExt},
};
@ -147,8 +148,8 @@ impl<F: Send + Clone> GetTracker<F, PaymentData<F>, api::PaymentsRequest> for Pa
token,
setup_mandate,
address: PaymentAddress {
shipping: shipping_address.as_ref().map(|a| a.into()),
billing: billing_address.as_ref().map(|a| a.into()),
shipping: shipping_address.as_ref().map(|a| a.foreign_into()),
billing: billing_address.as_ref().map(|a| a.foreign_into()),
},
confirm: request.confirm,
payment_method_data: request.payment_method_data.clone(),

40
crates/router/src/core/payments/transformers.rs
View File

@ -16,6 +16,7 @@ use crate::{
self,
api::{self, NextAction, PaymentsResponse},
storage::{self, enums},
transformers::ForeignInto,
},
utils::{OptionExt, ValueExt},
};
@ -196,7 +197,10 @@ where
.as_ref()
.and_then(|cus| cus.phone.as_ref().map(|s| s.to_owned())),
mandate_id: data.mandate_id,
payment_method: data.payment_attempt.payment_method.map(Into::into),
payment_method: data
.payment_attempt
.payment_method
.map(ForeignInto::foreign_into),
payment_method_data: data
.payment_method_data
.map(api::PaymentMethodDataResponse::from),
@ -237,7 +241,7 @@ where
let refunds_response = if refunds.is_empty() {
None
} else {
Some(refunds.into_iter().map(From::from).collect())
Some(refunds.into_iter().map(ForeignInto::foreign_into).collect())
};
Ok(match payment_request {
@ -265,7 +269,7 @@ where
response
.set_payment_id(Some(payment_attempt.payment_id))
.set_merchant_id(Some(payment_attempt.merchant_id))
.set_status(payment_intent.status.into())
.set_status(payment_intent.status.foreign_into())
.set_amount(payment_attempt.amount)
.set_amount_capturable(None)
.set_amount_received(payment_intent.amount_captured)
@ -292,7 +296,9 @@ where
.set_description(payment_intent.description)
.set_refunds(refunds_response) // refunds.iter().map(refund_to_refund_response),
.set_payment_method(
payment_attempt.payment_method.map(Into::into),
payment_attempt
.payment_method
.map(ForeignInto::foreign_into),
auth_flow == services::AuthFlow::Merchant,
)
.set_payment_method_data(
@ -306,12 +312,22 @@ where
.set_next_action(next_action_response)
.set_return_url(payment_intent.return_url)
.set_authentication_type(
payment_attempt.authentication_type.map(Into::into),
payment_attempt
.authentication_type
.map(ForeignInto::foreign_into),
)
.set_statement_descriptor_name(payment_intent.statement_descriptor_name)
.set_statement_descriptor_suffix(payment_intent.statement_descriptor_suffix)
.set_setup_future_usage(payment_intent.setup_future_usage.map(Into::into))
.set_capture_method(payment_attempt.capture_method.map(Into::into))
.set_setup_future_usage(
payment_intent
.setup_future_usage
.map(ForeignInto::foreign_into),
)
.set_capture_method(
payment_attempt
.capture_method
.map(ForeignInto::foreign_into),
)
.to_owned(),
)
}
@ -319,7 +335,7 @@ where
None => services::BachResponse::Json(PaymentsResponse {
payment_id: Some(payment_attempt.payment_id),
merchant_id: Some(payment_attempt.merchant_id),
status: payment_intent.status.into(),
status: payment_intent.status.foreign_into(),
amount: payment_attempt.amount,
amount_capturable: None,
amount_received: payment_intent.amount_captured,
@ -329,8 +345,12 @@ where
customer_id: payment_intent.customer_id,
description: payment_intent.description,
refunds: refunds_response,
payment_method: payment_attempt.payment_method.map(Into::into),
capture_method: payment_attempt.capture_method.map(Into::into),
payment_method: payment_attempt
.payment_method
.map(ForeignInto::foreign_into),
capture_method: payment_attempt
.capture_method
.map(ForeignInto::foreign_into),
error_message: payment_attempt.error_message,
payment_method_data: payment_method_data.map(api::PaymentMethodDataResponse::from),
email: customer