text stringlengths 70 351k | source stringclasses 4 values |
|---|---|
<file_sep path="hyperswitch/crates/diesel_models/src/enums.rs" crate="diesel_models" role="use_site">
#[doc(hidden)]
pub mod diesel_exports {
pub use super::{
DbApiVersion as ApiVersion, DbAttemptStatus as AttemptStatus,
DbAuthenticationType as AuthenticationType, DbBlocklistDataKind as BlocklistDataKind,
DbCaptureMethod as CaptureMethod, DbCaptureStatus as CaptureStatus,
DbCardDiscovery as CardDiscovery, DbConnectorStatus as ConnectorStatus,
DbConnectorType as ConnectorType, DbCountryAlpha2 as CountryAlpha2, DbCurrency as Currency,
DbDashboardMetadata as DashboardMetadata, DbDeleteStatus as DeleteStatus,
DbDisputeStage as DisputeStage, DbDisputeStatus as DisputeStatus,
DbEventClass as EventClass, DbEventObjectType as EventObjectType, DbEventType as EventType,
DbFraudCheckStatus as FraudCheckStatus, DbFraudCheckType as FraudCheckType,
DbFutureUsage as FutureUsage, DbGenericLinkType as GenericLinkType,
DbIntentStatus as IntentStatus, DbMandateStatus as MandateStatus,
DbMandateType as MandateType, DbMerchantStorageScheme as MerchantStorageScheme,
DbOrderFulfillmentTimeOrigin as OrderFulfillmentTimeOrigin,
DbPaymentMethodIssuerCode as PaymentMethodIssuerCode, DbPaymentSource as PaymentSource,
DbPaymentType as PaymentType, DbPayoutStatus as PayoutStatus, DbPayoutType as PayoutType,
DbProcessTrackerStatus as ProcessTrackerStatus, DbReconStatus as ReconStatus,
DbRefundStatus as RefundStatus, DbRefundType as RefundType, DbRelayStatus as RelayStatus,
DbRelayType as RelayType,
DbRequestIncrementalAuthorization as RequestIncrementalAuthorization,
DbRoleScope as RoleScope, DbRoutingAlgorithmKind as RoutingAlgorithmKind,
DbScaExemptionType as ScaExemptionType,
DbSuccessBasedRoutingConclusiveState as SuccessBasedRoutingConclusiveState,
DbTotpStatus as TotpStatus, DbTransactionType as TransactionType,
DbUserRoleVersion as UserRoleVersion, DbUserStatus as UserStatus,
DbWebhookDeliveryAttempt as WebhookDeliveryAttempt,
};
}
pub use common_enums::*;
use common_utils::pii;
use diesel::{deserialize::FromSqlRow, expression::AsExpression, sql_types::Jsonb};
use router_derive::diesel_enum;
use time::PrimitiveDateTime;
#[derive(
Clone,
Copy,
Debug,
Eq,
PartialEq,
serde::Deserialize,
serde::Serialize,
strum::Display,
strum::EnumString,
)]
#[diesel_enum(storage_type = "db_enum")]
#[serde(rename_all = "snake_case")]
#[strum(serialize_all = "snake_case")]
pub enum RoutingAlgorithmKind {
Single,
Priority,
VolumeSplit,
Advanced,
Dynamic,
}
#[derive(
Clone,
Copy,
Debug,
Eq,
PartialEq,
serde::Deserialize,
serde::Serialize,
strum::Display,
strum::EnumString,
)]
#[diesel_enum(storage_type = "db_enum")]
#[serde(rename_all = "snake_case")]
#[strum(serialize_all = "snake_case")]
pub enum EventObjectType {
PaymentDetails,
RefundDetails,
DisputeDetails,
MandateDetails,
PayoutDetails,
}
// Refund
#[derive(
Clone,
Copy,
Debug,
Default,
Eq,
PartialEq,
serde::Serialize,
serde::Deserialize,
strum::Display,
strum::EnumString,
)]
#[diesel_enum(storage_type = "db_enum")]
#[strum(serialize_all = "snake_case")]
#[serde(rename_all = "snake_case")]
pub enum RefundType {
InstantRefund,
#[default]
RegularRefund,
RetryRefund,
}
// Mandate
#[derive(
Clone,
Copy,
Debug,
Eq,
PartialEq,
Default,
serde::Deserialize,
serde::Serialize,
strum::Display,
strum::EnumString,
)]
#[diesel_enum(storage_type = "db_enum")]
#[serde(rename_all = "snake_case")]
#[strum(serialize_all = "snake_case")]
pub enum MandateType {
SingleUse,
#[default]
MultiUse,
}
#[derive(
serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, FromSqlRow, AsExpression,
)]
#[diesel(sql_type = Jsonb)]
#[serde(rename_all = "snake_case")]
pub struct MandateDetails {
pub update_mandate_id: Option<String>,
}
common_utils::impl_to_sql_from_sql_json!(MandateDetails);
#[derive(
serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, FromSqlRow, AsExpression,
)]
#[diesel(sql_type = Jsonb)]
#[serde(rename_all = "snake_case")]
pub enum MandateDataType {
SingleUse(MandateAmountData),
MultiUse(Option<MandateAmountData>),
}
common_utils::impl_to_sql_from_sql_json!(MandateDataType);
#[derive(Clone, Debug, serde::Serialize, serde::Deserialize, PartialEq, Eq)]
pub struct MandateAmountData {
pub amount: common_utils::types::MinorUnit,
pub currency: Currency,
pub start_date: Option<PrimitiveDateTime>,
pub end_date: Option<PrimitiveDateTime>,
pub metadata: Option<pii::SecretSerdeValue>,
}
#[derive(
Clone,
Copy,
Debug,
Eq,
PartialEq,
serde::Serialize,
serde::Deserialize,
strum::Display,
strum::EnumString,
)]
#[diesel_enum(storage_type = "db_enum")]
#[serde(rename_all = "snake_case")]
#[strum(serialize_all = "snake_case")]
pub enum FraudCheckType {
PreFrm,
PostFrm,
}
#[derive(
Clone,
Copy,
Debug,
Default,
Eq,
PartialEq,
serde::Serialize,
serde::Deserialize,
strum::Display,
strum::EnumString,
)]
#[diesel_enum(storage_type = "text")]
#[strum(serialize_all = "snake_case")]
pub enum FraudCheckLastStep {
#[default]
Processing,
CheckoutOrSale,
TransactionOrRecordRefund,
Fulfillment,
}
#[derive(
Clone,
Copy,
Debug,
Default,
Eq,
PartialEq,
serde::Serialize,
serde::Deserialize,
strum::Display,
strum::EnumString,
)]
#[diesel_enum(storage_type = "db_enum")]
#[serde(rename_all = "snake_case")]
#[strum(serialize_all = "snake_case")]
pub enum UserStatus {
Active,
#[default]
InvitationSent,
}
#[derive(
Clone,
Copy,
Debug,
Eq,
PartialEq,
serde::Deserialize,
serde::Serialize,
strum::Display,
strum::EnumString,
)]
#[router_derive::diesel_enum(storage_type = "db_enum")]
#[serde(rename_all = "snake_case")]
#[strum(serialize_all = "snake_case")]
pub enum DashboardMetadata {
ProductionAgreement,
SetupProcessor,
ConfigureEndpoint,
SetupComplete,
FirstProcessorConnected,
SecondProcessorConnected,
ConfiguredRouting,
TestPayment,
IntegrationMethod,
ConfigurationType,
IntegrationCompleted,
StripeConnected,
PaypalConnected,
SpRoutingConfigured,
Feedback,
ProdIntent,
SpTestPayment,
DownloadWoocom,
ConfigureWoocom,
SetupWoocomWebhook,
IsMultipleConfiguration,
IsChangePasswordRequired,
OnboardingSurvey,
ReconStatus,
}
#[derive(
Clone,
Copy,
Debug,
Default,
Eq,
PartialEq,
serde::Serialize,
serde::Deserialize,
strum::Display,
strum::EnumString,
)]
#[diesel_enum(storage_type = "db_enum")]
#[serde(rename_all = "snake_case")]
#[strum(serialize_all = "snake_case")]
pub enum TotpStatus {
Set,
InProgress,
#[default]
NotSet,
}
#[derive(
Clone,
Copy,
Debug,
Default,
Eq,
PartialEq,
serde::Serialize,
serde::Deserialize,
strum::EnumString,
strum::Display,
)]
#[diesel_enum(storage_type = "db_enum")]
#[serde(rename_all = "snake_case")]
#[strum(serialize_all = "snake_case")]
pub enum UserRoleVersion {
#[default]
V1,
V2,
}
<file_sep path="hyperswitch/crates/diesel_models/src/enums.rs" crate="diesel_models" role="use_site">
#[doc(hidden)]
pub mod diesel_exports {
pub use super::{
DbApiVersion as ApiVersion, DbAttemptStatus as AttemptStatus,
DbAuthenticationType as AuthenticationType, DbBlocklistDataKind as BlocklistDataKind,
DbCaptureMethod as CaptureMethod, DbCaptureStatus as CaptureStatus,
DbCardDiscovery as CardDiscovery, DbConnectorStatus as ConnectorStatus,
DbConnectorType as ConnectorType, DbCountryAlpha2 as CountryAlpha2, DbCurrency as Currency,
DbDashboardMetadata as DashboardMetadata, DbDeleteStatus as DeleteStatus,
DbDisputeStage as DisputeStage, DbDisputeStatus as DisputeStatus,
DbEventClass as EventClass, DbEventObjectType as EventObjectType, DbEventType as EventType,
DbFraudCheckStatus as FraudCheckStatus, DbFraudCheckType as FraudCheckType,
DbFutureUsage as FutureUsage, DbGenericLinkType as GenericLinkType,
DbIntentStatus as IntentStatus, DbMandateStatus as MandateStatus,
DbMandateType as MandateType, DbMerchantStorageScheme as MerchantStorageScheme,
DbOrderFulfillmentTimeOrigin as OrderFulfillmentTimeOrigin,
DbPaymentMethodIssuerCode as PaymentMethodIssuerCode, DbPaymentSource as PaymentSource,
DbPaymentType as PaymentType, DbPayoutStatus as PayoutStatus, DbPayoutType as PayoutType,
DbProcessTrackerStatus as ProcessTrackerStatus, DbReconStatus as ReconStatus,
DbRefundStatus as RefundStatus, DbRefundType as RefundType, DbRelayStatus as RelayStatus,
DbRelayType as RelayType,
DbRequestIncrementalAuthorization as RequestIncrementalAuthorization,
DbRoleScope as RoleScope, DbRoutingAlgorithmKind as RoutingAlgorithmKind,
DbScaExemptionType as ScaExemptionType,
DbSuccessBasedRoutingConclusiveState as SuccessBasedRoutingConclusiveState,
DbTotpStatus as TotpStatus, DbTransactionType as TransactionType,
DbUserRoleVersion as UserRoleVersion, DbUserStatus as UserStatus,
DbWebhookDeliveryAttempt as WebhookDeliveryAttempt,
};
}
pub use common_enums::*;
use common_utils::pii;
use diesel::{deserialize::FromSqlRow, expression::AsExpression, sql_types::Jsonb};
use router_derive::diesel_enum;
use time::PrimitiveDateTime;
#[derive(
Clone,
Copy,
Debug,
Eq,
PartialEq,
serde::Deserialize,
serde::Serialize,
strum::Display,
strum::EnumString,
)]
#[diesel_enum(storage_type = "db_enum")]
#[serde(rename_all = "snake_case")]
#[strum(serialize_all = "snake_case")]
pub enum RoutingAlgorithmKind {
Single,
Priority,
VolumeSplit,
Advanced,
Dynamic,
}
#[derive(
Clone,
Copy,
Debug,
Eq,
PartialEq,
serde::Deserialize,
serde::Serialize,
strum::Display,
strum::EnumString,
)]
#[diesel_enum(storage_type = "db_enum")]
#[serde(rename_all = "snake_case")]
#[strum(serialize_all = "snake_case")]
pub enum EventObjectType {
PaymentDetails,
RefundDetails,
DisputeDetails,
MandateDetails,
PayoutDetails,
}
// Refund
#[derive(
Clone,
Copy,
Debug,
Default,
Eq,
PartialEq,
serde::Serialize,
serde::Deserialize,
strum::Display,
strum::EnumString,
)]
#[diesel_enum(storage_type = "db_enum")]
#[strum(serialize_all = "snake_case")]
#[serde(rename_all = "snake_case")]
pub enum RefundType {
InstantRefund,
#[default]
RegularRefund,
RetryRefund,
}
// Mandate
#[derive(
Clone,
Copy,
Debug,
Eq,
PartialEq,
Default,
serde::Deserialize,
serde::Serialize,
strum::Display,
strum::EnumString,
)]
#[diesel_enum(storage_type = "db_enum")]
#[serde(rename_all = "snake_case")]
#[strum(serialize_all = "snake_case")]
pub enum MandateType {
SingleUse,
#[default]
MultiUse,
}
#[derive(
serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, FromSqlRow, AsExpression,
)]
#[diesel(sql_type = Jsonb)]
#[serde(rename_all = "snake_case")]
pub struct MandateDetails {
pub update_mandate_id: Option<String>,
}
common_utils::impl_to_sql_from_sql_json!(MandateDetails);
#[derive(
serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, FromSqlRow, AsExpression,
)]
#[diesel(sql_type = Jsonb)]
#[serde(rename_all = "snake_case")]
pub enum MandateDataType {
SingleUse(MandateAmountData),
MultiUse(Option<MandateAmountData>),
}
common_utils::impl_to_sql_from_sql_json!(MandateDataType);
#[derive(Clone, Debug, serde::Serialize, serde::Deserialize, PartialEq, Eq)]
pub struct MandateAmountData {
pub amount: common_utils::types::MinorUnit,
pub currency: Currency,
pub start_date: Option<PrimitiveDateTime>,
pub end_date: Option<PrimitiveDateTime>,
pub metadata: Option<pii::SecretSerdeValue>,
}
#[derive(
Clone,
Copy,
Debug,
Eq,
PartialEq,
serde::Serialize,
serde::Deserialize,
strum::Display,
strum::EnumString,
)]
#[diesel_enum(storage_type = "db_enum")]
#[serde(rename_all = "snake_case")]
#[strum(serialize_all = "snake_case")]
pub enum FraudCheckType {
PreFrm,
PostFrm,
}
#[derive(
Clone,
Copy,
Debug,
Default,
Eq,
PartialEq,
serde::Serialize,
serde::Deserialize,
strum::Display,
strum::EnumString,
)]
#[diesel_enum(storage_type = "text")]
#[strum(serialize_all = "snake_case")]
pub enum FraudCheckLastStep {
#[default]
Processing,
CheckoutOrSale,
TransactionOrRecordRefund,
Fulfillment,
}
#[derive(
Clone,
Copy,
Debug,
Default,
Eq,
PartialEq,
serde::Serialize,
serde::Deserialize,
strum::Display,
strum::EnumString,
)]
#[diesel_enum(storage_type = "db_enum")]
#[serde(rename_all = "snake_case")]
#[strum(serialize_all = "snake_case")]
pub enum UserStatus {
Active,
#[default]
InvitationSent,
}
#[derive(
Clone,
Copy,
Debug,
Eq,
PartialEq,
serde::Deserialize,
serde::Serialize,
strum::Display,
strum::EnumString,
)]
#[router_derive::diesel_enum(storage_type = "db_enum")]
#[serde(rename_all = "snake_case")]
#[strum(serialize_all = "snake_case")]
pub enum DashboardMetadata {
ProductionAgreement,
SetupProcessor,
ConfigureEndpoint,
SetupComplete,
FirstProcessorConnected,
SecondProcessorConnected,
ConfiguredRouting,
TestPayment,
IntegrationMethod,
ConfigurationType,
IntegrationCompleted,
StripeConnected,
PaypalConnected,
SpRoutingConfigured,
Feedback,
ProdIntent,
SpTestPayment,
DownloadWoocom,
ConfigureWoocom,
SetupWoocomWebhook,
IsMultipleConfiguration,
IsChangePasswordRequired,
OnboardingSurvey,
ReconStatus,
}
#[derive(
Clone,
Copy,
Debug,
Default,
Eq,
PartialEq,
serde::Serialize,
serde::Deserialize,
strum::Display,
strum::EnumString,
)]
#[diesel_enum(storage_type = "db_enum")]
#[serde(rename_all = "snake_case")]
#[strum(serialize_all = "snake_case")]
pub enum TotpStatus {
Set,
InProgress,
#[default]
NotSet,
}
#[derive(
Clone,
Copy,
Debug,
Default,
Eq,
PartialEq,
serde::Serialize,
serde::Deserialize,
strum::EnumString,
strum::Display,
)]
#[diesel_enum(storage_type = "db_enum")]
#[serde(rename_all = "snake_case")]
#[strum(serialize_all = "snake_case")]
pub enum UserRoleVersion {
#[default]
V1,
V2,
}
<file_sep path="hyperswitch/crates/router_derive/src/lib.rs" crate="router_derive" role="macro_def">
<|fim_prefix|>
<|meta_start|><|file|> hyperswitch/crates/router_derive/src/lib.rs<|crate|> diesel_models macro=DieselEnum roles=use_site,macro_def use=attribute item=file pack=proc_macro_neighborhoods lang=rust<|meta_end|>
pub fn diesel_enum_derive(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
<|fim_suffix|>
<|fim_middle|>
}
<file_sep path="hyperswitch/crates/router_derive/src/lib.rs" crate="router_derive" role="macro_def">
<|fim_prefix|>
pub fn diesel_enum_derive(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
<|fim_suffix|>
<|fim_middle|>
}
| proc_macro_neighborhoods |
<file_sep path="hyperswitch/crates/diesel_models/src/enums.rs" crate="diesel_models" role="use_site">
#[doc(hidden)]
pub mod diesel_exports {
pub use super::{
DbApiVersion as ApiVersion, DbAttemptStatus as AttemptStatus,
DbAuthenticationType as AuthenticationType, DbBlocklistDataKind as BlocklistDataKind,
DbCaptureMethod as CaptureMethod, DbCaptureStatus as CaptureStatus,
DbCardDiscovery as CardDiscovery, DbConnectorStatus as ConnectorStatus,
DbConnectorType as ConnectorType, DbCountryAlpha2 as CountryAlpha2, DbCurrency as Currency,
DbDashboardMetadata as DashboardMetadata, DbDeleteStatus as DeleteStatus,
DbDisputeStage as DisputeStage, DbDisputeStatus as DisputeStatus,
DbEventClass as EventClass, DbEventObjectType as EventObjectType, DbEventType as EventType,
DbFraudCheckStatus as FraudCheckStatus, DbFraudCheckType as FraudCheckType,
DbFutureUsage as FutureUsage, DbGenericLinkType as GenericLinkType,
DbIntentStatus as IntentStatus, DbMandateStatus as MandateStatus,
DbMandateType as MandateType, DbMerchantStorageScheme as MerchantStorageScheme,
DbOrderFulfillmentTimeOrigin as OrderFulfillmentTimeOrigin,
DbPaymentMethodIssuerCode as PaymentMethodIssuerCode, DbPaymentSource as PaymentSource,
DbPaymentType as PaymentType, DbPayoutStatus as PayoutStatus, DbPayoutType as PayoutType,
DbProcessTrackerStatus as ProcessTrackerStatus, DbReconStatus as ReconStatus,
DbRefundStatus as RefundStatus, DbRefundType as RefundType, DbRelayStatus as RelayStatus,
DbRelayType as RelayType,
DbRequestIncrementalAuthorization as RequestIncrementalAuthorization,
DbRoleScope as RoleScope, DbRoutingAlgorithmKind as RoutingAlgorithmKind,
DbScaExemptionType as ScaExemptionType,
DbSuccessBasedRoutingConclusiveState as SuccessBasedRoutingConclusiveState,
DbTotpStatus as TotpStatus, DbTransactionType as TransactionType,
DbUserRoleVersion as UserRoleVersion, DbUserStatus as UserStatus,
DbWebhookDeliveryAttempt as WebhookDeliveryAttempt,
};
}
pub use common_enums::*;
use common_utils::pii;
use diesel::{deserialize::FromSqlRow, expression::AsExpression, sql_types::Jsonb};
use router_derive::diesel_enum;
use time::PrimitiveDateTime;
#[derive(
Clone,
Copy,
Debug,
Eq,
PartialEq,
serde::Deserialize,
serde::Serialize,
strum::Display,
strum::EnumString,
)]
#[diesel_enum(storage_type = "db_enum")]
#[serde(rename_all = "snake_case")]
#[strum(serialize_all = "snake_case")]
pub enum RoutingAlgorithmKind {
Single,
Priority,
VolumeSplit,
Advanced,
Dynamic,
}
#[derive(
Clone,
Copy,
Debug,
Eq,
PartialEq,
serde::Deserialize,
serde::Serialize,
strum::Display,
strum::EnumString,
)]
#[diesel_enum(storage_type = "db_enum")]
#[serde(rename_all = "snake_case")]
#[strum(serialize_all = "snake_case")]
pub enum EventObjectType {
PaymentDetails,
RefundDetails,
DisputeDetails,
MandateDetails,
PayoutDetails,
}
// Refund
#[derive(
Clone,
Copy,
Debug,
Default,
Eq,
PartialEq,
serde::Serialize,
serde::Deserialize,
strum::Display,
strum::EnumString,
)]
#[diesel_enum(storage_type = "db_enum")]
#[strum(serialize_all = "snake_case")]
#[serde(rename_all = "snake_case")]
pub enum RefundType {
InstantRefund,
#[default]
RegularRefund,
RetryRefund,
}
// Mandate
#[derive(
Clone,
Copy,
Debug,
Eq,
PartialEq,
Default,
serde::Deserialize,
serde::Serialize,
strum::Display,
strum::EnumString,
)]
#[diesel_enum(storage_type = "db_enum")]
#[serde(rename_all = "snake_case")]
#[strum(serialize_all = "snake_case")]
pub enum MandateType {
SingleUse,
#[default]
MultiUse,
}
#[derive(
serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, FromSqlRow, AsExpression,
)]
#[diesel(sql_type = Jsonb)]
#[serde(rename_all = "snake_case")]
pub struct MandateDetails {
pub update_mandate_id: Option<String>,
}
common_utils::impl_to_sql_from_sql_json!(MandateDetails);
#[derive(
serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, FromSqlRow, AsExpression,
)]
#[diesel(sql_type = Jsonb)]
#[serde(rename_all = "snake_case")]
pub enum MandateDataType {
SingleUse(MandateAmountData),
MultiUse(Option<MandateAmountData>),
}
common_utils::impl_to_sql_from_sql_json!(MandateDataType);
#[derive(Clone, Debug, serde::Serialize, serde::Deserialize, PartialEq, Eq)]
pub struct MandateAmountData {
pub amount: common_utils::types::MinorUnit,
pub currency: Currency,
pub start_date: Option<PrimitiveDateTime>,
pub end_date: Option<PrimitiveDateTime>,
pub metadata: Option<pii::SecretSerdeValue>,
}
#[derive(
Clone,
Copy,
Debug,
Eq,
PartialEq,
serde::Serialize,
serde::Deserialize,
strum::Display,
strum::EnumString,
)]
#[diesel_enum(storage_type = "db_enum")]
#[serde(rename_all = "snake_case")]
#[strum(serialize_all = "snake_case")]
pub enum FraudCheckType {
PreFrm,
PostFrm,
}
#[derive(
Clone,
Copy,
Debug,
Default,
Eq,
PartialEq,
serde::Serialize,
serde::Deserialize,
strum::Display,
strum::EnumString,
)]
#[diesel_enum(storage_type = "text")]
#[strum(serialize_all = "snake_case")]
pub enum FraudCheckLastStep {
#[default]
Processing,
CheckoutOrSale,
TransactionOrRecordRefund,
Fulfillment,
}
#[derive(
Clone,
Copy,
Debug,
Default,
Eq,
PartialEq,
serde::Serialize,
serde::Deserialize,
strum::Display,
strum::EnumString,
)]
#[diesel_enum(storage_type = "db_enum")]
#[serde(rename_all = "snake_case")]
#[strum(serialize_all = "snake_case")]
pub enum UserStatus {
Active,
#[default]
InvitationSent,
}
#[derive(
Clone,
Copy,
Debug,
Eq,
PartialEq,
serde::Deserialize,
serde::Serialize,
strum::Display,
strum::EnumString,
)]
#[router_derive::diesel_enum(storage_type = "db_enum")]
#[serde(rename_all = "snake_case")]
#[strum(serialize_all = "snake_case")]
pub enum DashboardMetadata {
ProductionAgreement,
SetupProcessor,
ConfigureEndpoint,
SetupComplete,
FirstProcessorConnected,
SecondProcessorConnected,
ConfiguredRouting,
TestPayment,
IntegrationMethod,
ConfigurationType,
IntegrationCompleted,
StripeConnected,
PaypalConnected,
SpRoutingConfigured,
Feedback,
ProdIntent,
SpTestPayment,
DownloadWoocom,
ConfigureWoocom,
SetupWoocomWebhook,
IsMultipleConfiguration,
IsChangePasswordRequired,
OnboardingSurvey,
ReconStatus,
}
#[derive(
Clone,
Copy,
Debug,
Default,
Eq,
PartialEq,
serde::Serialize,
serde::Deserialize,
strum::Display,
strum::EnumString,
)]
#[diesel_enum(storage_type = "db_enum")]
#[serde(rename_all = "snake_case")]
#[strum(serialize_all = "snake_case")]
pub enum TotpStatus {
Set,
InProgress,
#[default]
NotSet,
}
#[derive(
Clone,
Copy,
Debug,
Default,
Eq,
PartialEq,
serde::Serialize,
serde::Deserialize,
strum::EnumString,
strum::Display,
)]
#[diesel_enum(storage_type = "db_enum")]
#[serde(rename_all = "snake_case")]
#[strum(serialize_all = "snake_case")]
pub enum UserRoleVersion {
#[default]
V1,
V2,
}
<file_sep path="hyperswitch/crates/diesel_models/src/enums.rs" crate="diesel_models" role="use_site">
#[doc(hidden)]
pub mod diesel_exports {
pub use super::{
DbApiVersion as ApiVersion, DbAttemptStatus as AttemptStatus,
DbAuthenticationType as AuthenticationType, DbBlocklistDataKind as BlocklistDataKind,
DbCaptureMethod as CaptureMethod, DbCaptureStatus as CaptureStatus,
DbCardDiscovery as CardDiscovery, DbConnectorStatus as ConnectorStatus,
DbConnectorType as ConnectorType, DbCountryAlpha2 as CountryAlpha2, DbCurrency as Currency,
DbDashboardMetadata as DashboardMetadata, DbDeleteStatus as DeleteStatus,
DbDisputeStage as DisputeStage, DbDisputeStatus as DisputeStatus,
DbEventClass as EventClass, DbEventObjectType as EventObjectType, DbEventType as EventType,
DbFraudCheckStatus as FraudCheckStatus, DbFraudCheckType as FraudCheckType,
DbFutureUsage as FutureUsage, DbGenericLinkType as GenericLinkType,
DbIntentStatus as IntentStatus, DbMandateStatus as MandateStatus,
DbMandateType as MandateType, DbMerchantStorageScheme as MerchantStorageScheme,
DbOrderFulfillmentTimeOrigin as OrderFulfillmentTimeOrigin,
DbPaymentMethodIssuerCode as PaymentMethodIssuerCode, DbPaymentSource as PaymentSource,
DbPaymentType as PaymentType, DbPayoutStatus as PayoutStatus, DbPayoutType as PayoutType,
DbProcessTrackerStatus as ProcessTrackerStatus, DbReconStatus as ReconStatus,
DbRefundStatus as RefundStatus, DbRefundType as RefundType, DbRelayStatus as RelayStatus,
DbRelayType as RelayType,
DbRequestIncrementalAuthorization as RequestIncrementalAuthorization,
DbRoleScope as RoleScope, DbRoutingAlgorithmKind as RoutingAlgorithmKind,
DbScaExemptionType as ScaExemptionType,
DbSuccessBasedRoutingConclusiveState as SuccessBasedRoutingConclusiveState,
DbTotpStatus as TotpStatus, DbTransactionType as TransactionType,
DbUserRoleVersion as UserRoleVersion, DbUserStatus as UserStatus,
DbWebhookDeliveryAttempt as WebhookDeliveryAttempt,
};
}
pub use common_enums::*;
use common_utils::pii;
use diesel::{deserialize::FromSqlRow, expression::AsExpression, sql_types::Jsonb};
use router_derive::diesel_enum;
use time::PrimitiveDateTime;
#[derive(
Clone,
Copy,
Debug,
Eq,
PartialEq,
serde::Deserialize,
serde::Serialize,
strum::Display,
strum::EnumString,
)]
#[diesel_enum(storage_type = "db_enum")]
#[serde(rename_all = "snake_case")]
#[strum(serialize_all = "snake_case")]
pub enum RoutingAlgorithmKind {
Single,
Priority,
VolumeSplit,
Advanced,
Dynamic,
}
#[derive(
Clone,
Copy,
Debug,
Eq,
PartialEq,
serde::Deserialize,
serde::Serialize,
strum::Display,
strum::EnumString,
)]
#[diesel_enum(storage_type = "db_enum")]
#[serde(rename_all = "snake_case")]
#[strum(serialize_all = "snake_case")]
pub enum EventObjectType {
PaymentDetails,
RefundDetails,
DisputeDetails,
MandateDetails,
PayoutDetails,
}
// Refund
#[derive(
Clone,
Copy,
Debug,
Default,
Eq,
PartialEq,
serde::Serialize,
serde::Deserialize,
strum::Display,
strum::EnumString,
)]
#[diesel_enum(storage_type = "db_enum")]
#[strum(serialize_all = "snake_case")]
#[serde(rename_all = "snake_case")]
pub enum RefundType {
InstantRefund,
#[default]
RegularRefund,
RetryRefund,
}
// Mandate
#[derive(
Clone,
Copy,
Debug,
Eq,
PartialEq,
Default,
serde::Deserialize,
serde::Serialize,
strum::Display,
strum::EnumString,
)]
#[diesel_enum(storage_type = "db_enum")]
#[serde(rename_all = "snake_case")]
#[strum(serialize_all = "snake_case")]
pub enum MandateType {
SingleUse,
#[default]
MultiUse,
}
#[derive(
serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, FromSqlRow, AsExpression,
)]
#[diesel(sql_type = Jsonb)]
#[serde(rename_all = "snake_case")]
pub struct MandateDetails {
pub update_mandate_id: Option<String>,
}
common_utils::impl_to_sql_from_sql_json!(MandateDetails);
#[derive(
serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, FromSqlRow, AsExpression,
)]
#[diesel(sql_type = Jsonb)]
#[serde(rename_all = "snake_case")]
pub enum MandateDataType {
SingleUse(MandateAmountData),
MultiUse(Option<MandateAmountData>),
}
common_utils::impl_to_sql_from_sql_json!(MandateDataType);
#[derive(Clone, Debug, serde::Serialize, serde::Deserialize, PartialEq, Eq)]
pub struct MandateAmountData {
pub amount: common_utils::types::MinorUnit,
pub currency: Currency,
pub start_date: Option<PrimitiveDateTime>,
pub end_date: Option<PrimitiveDateTime>,
pub metadata: Option<pii::SecretSerdeValue>,
}
#[derive(
Clone,
Copy,
Debug,
Eq,
PartialEq,
serde::Serialize,
serde::Deserialize,
strum::Display,
strum::EnumString,
)]
#[diesel_enum(storage_type = "db_enum")]
#[serde(rename_all = "snake_case")]
#[strum(serialize_all = "snake_case")]
pub enum FraudCheckType {
PreFrm,
PostFrm,
}
#[derive(
Clone,
Copy,
Debug,
Default,
Eq,
PartialEq,
serde::Serialize,
serde::Deserialize,
strum::Display,
strum::EnumString,
)]
#[diesel_enum(storage_type = "text")]
#[strum(serialize_all = "snake_case")]
pub enum FraudCheckLastStep {
#[default]
Processing,
CheckoutOrSale,
TransactionOrRecordRefund,
Fulfillment,
}
#[derive(
Clone,
Copy,
Debug,
Default,
Eq,
PartialEq,
serde::Serialize,
serde::Deserialize,
strum::Display,
strum::EnumString,
)]
#[diesel_enum(storage_type = "db_enum")]
#[serde(rename_all = "snake_case")]
#[strum(serialize_all = "snake_case")]
pub enum UserStatus {
Active,
#[default]
InvitationSent,
}
#[derive(
Clone,
Copy,
Debug,
Eq,
PartialEq,
serde::Deserialize,
serde::Serialize,
strum::Display,
strum::EnumString,
)]
#[router_derive::diesel_enum(storage_type = "db_enum")]
#[serde(rename_all = "snake_case")]
#[strum(serialize_all = "snake_case")]
pub enum DashboardMetadata {
ProductionAgreement,
SetupProcessor,
ConfigureEndpoint,
SetupComplete,
FirstProcessorConnected,
SecondProcessorConnected,
ConfiguredRouting,
TestPayment,
IntegrationMethod,
ConfigurationType,
IntegrationCompleted,
StripeConnected,
PaypalConnected,
SpRoutingConfigured,
Feedback,
ProdIntent,
SpTestPayment,
DownloadWoocom,
ConfigureWoocom,
SetupWoocomWebhook,
IsMultipleConfiguration,
IsChangePasswordRequired,
OnboardingSurvey,
ReconStatus,
}
#[derive(
Clone,
Copy,
Debug,
Default,
Eq,
PartialEq,
serde::Serialize,
serde::Deserialize,
strum::Display,
strum::EnumString,
)]
#[diesel_enum(storage_type = "db_enum")]
#[serde(rename_all = "snake_case")]
#[strum(serialize_all = "snake_case")]
pub enum TotpStatus {
Set,
InProgress,
#[default]
NotSet,
}
#[derive(
Clone,
Copy,
Debug,
Default,
Eq,
PartialEq,
serde::Serialize,
serde::Deserialize,
strum::EnumString,
strum::Display,
)]
#[diesel_enum(storage_type = "db_enum")]
#[serde(rename_all = "snake_case")]
#[strum(serialize_all = "snake_case")]
pub enum UserRoleVersion {
#[default]
V1,
V2,
}
<file_sep path="hyperswitch/crates/router_derive/src/lib.rs" crate="router_derive" role="macro_def">
<|fim_prefix|>
<|meta_start|><|file|> hyperswitch/crates/router_derive/src/lib.rs<|crate|> diesel_models macro=DieselEnum roles=use_site,macro_def use=attribute item=file pack=proc_macro_neighborhoods lang=rust<|meta_end|>
pub fn diesel_enum_derive(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
<|fim_suffix|>
<|fim_middle|>
}
<file_sep path="hyperswitch/crates/router_derive/src/lib.rs" crate="router_derive" role="macro_def">
<|fim_prefix|>
pub fn diesel_enum_derive(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
<|fim_suffix|>
<|fim_middle|>
}
| proc_macro_neighborhoods |
<file_sep path="hyperswitch/crates/diesel_models/src/enums.rs" crate="diesel_models" role="use_site">
#[doc(hidden)]
pub mod diesel_exports {
pub use super::{
DbApiVersion as ApiVersion, DbAttemptStatus as AttemptStatus,
DbAuthenticationType as AuthenticationType, DbBlocklistDataKind as BlocklistDataKind,
DbCaptureMethod as CaptureMethod, DbCaptureStatus as CaptureStatus,
DbCardDiscovery as CardDiscovery, DbConnectorStatus as ConnectorStatus,
DbConnectorType as ConnectorType, DbCountryAlpha2 as CountryAlpha2, DbCurrency as Currency,
DbDashboardMetadata as DashboardMetadata, DbDeleteStatus as DeleteStatus,
DbDisputeStage as DisputeStage, DbDisputeStatus as DisputeStatus,
DbEventClass as EventClass, DbEventObjectType as EventObjectType, DbEventType as EventType,
DbFraudCheckStatus as FraudCheckStatus, DbFraudCheckType as FraudCheckType,
DbFutureUsage as FutureUsage, DbGenericLinkType as GenericLinkType,
DbIntentStatus as IntentStatus, DbMandateStatus as MandateStatus,
DbMandateType as MandateType, DbMerchantStorageScheme as MerchantStorageScheme,
DbOrderFulfillmentTimeOrigin as OrderFulfillmentTimeOrigin,
DbPaymentMethodIssuerCode as PaymentMethodIssuerCode, DbPaymentSource as PaymentSource,
DbPaymentType as PaymentType, DbPayoutStatus as PayoutStatus, DbPayoutType as PayoutType,
DbProcessTrackerStatus as ProcessTrackerStatus, DbReconStatus as ReconStatus,
DbRefundStatus as RefundStatus, DbRefundType as RefundType, DbRelayStatus as RelayStatus,
DbRelayType as RelayType,
DbRequestIncrementalAuthorization as RequestIncrementalAuthorization,
DbRoleScope as RoleScope, DbRoutingAlgorithmKind as RoutingAlgorithmKind,
DbScaExemptionType as ScaExemptionType,
DbSuccessBasedRoutingConclusiveState as SuccessBasedRoutingConclusiveState,
DbTotpStatus as TotpStatus, DbTransactionType as TransactionType,
DbUserRoleVersion as UserRoleVersion, DbUserStatus as UserStatus,
DbWebhookDeliveryAttempt as WebhookDeliveryAttempt,
};
}
pub use common_enums::*;
use common_utils::pii;
use diesel::{deserialize::FromSqlRow, expression::AsExpression, sql_types::Jsonb};
use router_derive::diesel_enum;
use time::PrimitiveDateTime;
#[derive(
Clone,
Copy,
Debug,
Eq,
PartialEq,
serde::Deserialize,
serde::Serialize,
strum::Display,
strum::EnumString,
)]
#[diesel_enum(storage_type = "db_enum")]
#[serde(rename_all = "snake_case")]
#[strum(serialize_all = "snake_case")]
pub enum RoutingAlgorithmKind {
Single,
Priority,
VolumeSplit,
Advanced,
Dynamic,
}
#[derive(
Clone,
Copy,
Debug,
Eq,
PartialEq,
serde::Deserialize,
serde::Serialize,
strum::Display,
strum::EnumString,
)]
#[diesel_enum(storage_type = "db_enum")]
#[serde(rename_all = "snake_case")]
#[strum(serialize_all = "snake_case")]
pub enum EventObjectType {
PaymentDetails,
RefundDetails,
DisputeDetails,
MandateDetails,
PayoutDetails,
}
// Refund
#[derive(
Clone,
Copy,
Debug,
Default,
Eq,
PartialEq,
serde::Serialize,
serde::Deserialize,
strum::Display,
strum::EnumString,
)]
#[diesel_enum(storage_type = "db_enum")]
#[strum(serialize_all = "snake_case")]
#[serde(rename_all = "snake_case")]
pub enum RefundType {
InstantRefund,
#[default]
RegularRefund,
RetryRefund,
}
// Mandate
#[derive(
Clone,
Copy,
Debug,
Eq,
PartialEq,
Default,
serde::Deserialize,
serde::Serialize,
strum::Display,
strum::EnumString,
)]
#[diesel_enum(storage_type = "db_enum")]
#[serde(rename_all = "snake_case")]
#[strum(serialize_all = "snake_case")]
pub enum MandateType {
SingleUse,
#[default]
MultiUse,
}
#[derive(
serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, FromSqlRow, AsExpression,
)]
#[diesel(sql_type = Jsonb)]
#[serde(rename_all = "snake_case")]
pub struct MandateDetails {
pub update_mandate_id: Option<String>,
}
common_utils::impl_to_sql_from_sql_json!(MandateDetails);
#[derive(
serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, FromSqlRow, AsExpression,
)]
#[diesel(sql_type = Jsonb)]
#[serde(rename_all = "snake_case")]
pub enum MandateDataType {
SingleUse(MandateAmountData),
MultiUse(Option<MandateAmountData>),
}
common_utils::impl_to_sql_from_sql_json!(MandateDataType);
#[derive(Clone, Debug, serde::Serialize, serde::Deserialize, PartialEq, Eq)]
pub struct MandateAmountData {
pub amount: common_utils::types::MinorUnit,
pub currency: Currency,
pub start_date: Option<PrimitiveDateTime>,
pub end_date: Option<PrimitiveDateTime>,
pub metadata: Option<pii::SecretSerdeValue>,
}
#[derive(
Clone,
Copy,
Debug,
Eq,
PartialEq,
serde::Serialize,
serde::Deserialize,
strum::Display,
strum::EnumString,
)]
#[diesel_enum(storage_type = "db_enum")]
#[serde(rename_all = "snake_case")]
#[strum(serialize_all = "snake_case")]
pub enum FraudCheckType {
PreFrm,
PostFrm,
}
#[derive(
Clone,
Copy,
Debug,
Default,
Eq,
PartialEq,
serde::Serialize,
serde::Deserialize,
strum::Display,
strum::EnumString,
)]
#[diesel_enum(storage_type = "text")]
#[strum(serialize_all = "snake_case")]
pub enum FraudCheckLastStep {
#[default]
Processing,
CheckoutOrSale,
TransactionOrRecordRefund,
Fulfillment,
}
#[derive(
Clone,
Copy,
Debug,
Default,
Eq,
PartialEq,
serde::Serialize,
serde::Deserialize,
strum::Display,
strum::EnumString,
)]
#[diesel_enum(storage_type = "db_enum")]
#[serde(rename_all = "snake_case")]
#[strum(serialize_all = "snake_case")]
pub enum UserStatus {
Active,
#[default]
InvitationSent,
}
#[derive(
Clone,
Copy,
Debug,
Eq,
PartialEq,
serde::Deserialize,
serde::Serialize,
strum::Display,
strum::EnumString,
)]
#[router_derive::diesel_enum(storage_type = "db_enum")]
#[serde(rename_all = "snake_case")]
#[strum(serialize_all = "snake_case")]
pub enum DashboardMetadata {
ProductionAgreement,
SetupProcessor,
ConfigureEndpoint,
SetupComplete,
FirstProcessorConnected,
SecondProcessorConnected,
ConfiguredRouting,
TestPayment,
IntegrationMethod,
ConfigurationType,
IntegrationCompleted,
StripeConnected,
PaypalConnected,
SpRoutingConfigured,
Feedback,
ProdIntent,
SpTestPayment,
DownloadWoocom,
ConfigureWoocom,
SetupWoocomWebhook,
IsMultipleConfiguration,
IsChangePasswordRequired,
OnboardingSurvey,
ReconStatus,
}
#[derive(
Clone,
Copy,
Debug,
Default,
Eq,
PartialEq,
serde::Serialize,
serde::Deserialize,
strum::Display,
strum::EnumString,
)]
#[diesel_enum(storage_type = "db_enum")]
#[serde(rename_all = "snake_case")]
#[strum(serialize_all = "snake_case")]
pub enum TotpStatus {
Set,
InProgress,
#[default]
NotSet,
}
#[derive(
Clone,
Copy,
Debug,
Default,
Eq,
PartialEq,
serde::Serialize,
serde::Deserialize,
strum::EnumString,
strum::Display,
)]
#[diesel_enum(storage_type = "db_enum")]
#[serde(rename_all = "snake_case")]
#[strum(serialize_all = "snake_case")]
pub enum UserRoleVersion {
#[default]
V1,
V2,
}
<file_sep path="hyperswitch/crates/diesel_models/src/enums.rs" crate="diesel_models" role="use_site">
#[doc(hidden)]
pub mod diesel_exports {
pub use super::{
DbApiVersion as ApiVersion, DbAttemptStatus as AttemptStatus,
DbAuthenticationType as AuthenticationType, DbBlocklistDataKind as BlocklistDataKind,
DbCaptureMethod as CaptureMethod, DbCaptureStatus as CaptureStatus,
DbCardDiscovery as CardDiscovery, DbConnectorStatus as ConnectorStatus,
DbConnectorType as ConnectorType, DbCountryAlpha2 as CountryAlpha2, DbCurrency as Currency,
DbDashboardMetadata as DashboardMetadata, DbDeleteStatus as DeleteStatus,
DbDisputeStage as DisputeStage, DbDisputeStatus as DisputeStatus,
DbEventClass as EventClass, DbEventObjectType as EventObjectType, DbEventType as EventType,
DbFraudCheckStatus as FraudCheckStatus, DbFraudCheckType as FraudCheckType,
DbFutureUsage as FutureUsage, DbGenericLinkType as GenericLinkType,
DbIntentStatus as IntentStatus, DbMandateStatus as MandateStatus,
DbMandateType as MandateType, DbMerchantStorageScheme as MerchantStorageScheme,
DbOrderFulfillmentTimeOrigin as OrderFulfillmentTimeOrigin,
DbPaymentMethodIssuerCode as PaymentMethodIssuerCode, DbPaymentSource as PaymentSource,
DbPaymentType as PaymentType, DbPayoutStatus as PayoutStatus, DbPayoutType as PayoutType,
DbProcessTrackerStatus as ProcessTrackerStatus, DbReconStatus as ReconStatus,
DbRefundStatus as RefundStatus, DbRefundType as RefundType, DbRelayStatus as RelayStatus,
DbRelayType as RelayType,
DbRequestIncrementalAuthorization as RequestIncrementalAuthorization,
DbRoleScope as RoleScope, DbRoutingAlgorithmKind as RoutingAlgorithmKind,
DbScaExemptionType as ScaExemptionType,
DbSuccessBasedRoutingConclusiveState as SuccessBasedRoutingConclusiveState,
DbTotpStatus as TotpStatus, DbTransactionType as TransactionType,
DbUserRoleVersion as UserRoleVersion, DbUserStatus as UserStatus,
DbWebhookDeliveryAttempt as WebhookDeliveryAttempt,
};
}
pub use common_enums::*;
use common_utils::pii;
use diesel::{deserialize::FromSqlRow, expression::AsExpression, sql_types::Jsonb};
use router_derive::diesel_enum;
use time::PrimitiveDateTime;
#[derive(
Clone,
Copy,
Debug,
Eq,
PartialEq,
serde::Deserialize,
serde::Serialize,
strum::Display,
strum::EnumString,
)]
#[diesel_enum(storage_type = "db_enum")]
#[serde(rename_all = "snake_case")]
#[strum(serialize_all = "snake_case")]
pub enum RoutingAlgorithmKind {
Single,
Priority,
VolumeSplit,
Advanced,
Dynamic,
}
#[derive(
Clone,
Copy,
Debug,
Eq,
PartialEq,
serde::Deserialize,
serde::Serialize,
strum::Display,
strum::EnumString,
)]
#[diesel_enum(storage_type = "db_enum")]
#[serde(rename_all = "snake_case")]
#[strum(serialize_all = "snake_case")]
pub enum EventObjectType {
PaymentDetails,
RefundDetails,
DisputeDetails,
MandateDetails,
PayoutDetails,
}
// Refund
#[derive(
Clone,
Copy,
Debug,
Default,
Eq,
PartialEq,
serde::Serialize,
serde::Deserialize,
strum::Display,
strum::EnumString,
)]
#[diesel_enum(storage_type = "db_enum")]
#[strum(serialize_all = "snake_case")]
#[serde(rename_all = "snake_case")]
pub enum RefundType {
InstantRefund,
#[default]
RegularRefund,
RetryRefund,
}
// Mandate
#[derive(
Clone,
Copy,
Debug,
Eq,
PartialEq,
Default,
serde::Deserialize,
serde::Serialize,
strum::Display,
strum::EnumString,
)]
#[diesel_enum(storage_type = "db_enum")]
#[serde(rename_all = "snake_case")]
#[strum(serialize_all = "snake_case")]
pub enum MandateType {
SingleUse,
#[default]
MultiUse,
}
#[derive(
serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, FromSqlRow, AsExpression,
)]
#[diesel(sql_type = Jsonb)]
#[serde(rename_all = "snake_case")]
pub struct MandateDetails {
pub update_mandate_id: Option<String>,
}
common_utils::impl_to_sql_from_sql_json!(MandateDetails);
#[derive(
serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, FromSqlRow, AsExpression,
)]
#[diesel(sql_type = Jsonb)]
#[serde(rename_all = "snake_case")]
pub enum MandateDataType {
SingleUse(MandateAmountData),
MultiUse(Option<MandateAmountData>),
}
common_utils::impl_to_sql_from_sql_json!(MandateDataType);
#[derive(Clone, Debug, serde::Serialize, serde::Deserialize, PartialEq, Eq)]
pub struct MandateAmountData {
pub amount: common_utils::types::MinorUnit,
pub currency: Currency,
pub start_date: Option<PrimitiveDateTime>,
pub end_date: Option<PrimitiveDateTime>,
pub metadata: Option<pii::SecretSerdeValue>,
}
#[derive(
Clone,
Copy,
Debug,
Eq,
PartialEq,
serde::Serialize,
serde::Deserialize,
strum::Display,
strum::EnumString,
)]
#[diesel_enum(storage_type = "db_enum")]
#[serde(rename_all = "snake_case")]
#[strum(serialize_all = "snake_case")]
pub enum FraudCheckType {
PreFrm,
PostFrm,
}
#[derive(
Clone,
Copy,
Debug,
Default,
Eq,
PartialEq,
serde::Serialize,
serde::Deserialize,
strum::Display,
strum::EnumString,
)]
#[diesel_enum(storage_type = "text")]
#[strum(serialize_all = "snake_case")]
pub enum FraudCheckLastStep {
#[default]
Processing,
CheckoutOrSale,
TransactionOrRecordRefund,
Fulfillment,
}
#[derive(
Clone,
Copy,
Debug,
Default,
Eq,
PartialEq,
serde::Serialize,
serde::Deserialize,
strum::Display,
strum::EnumString,
)]
#[diesel_enum(storage_type = "db_enum")]
#[serde(rename_all = "snake_case")]
#[strum(serialize_all = "snake_case")]
pub enum UserStatus {
Active,
#[default]
InvitationSent,
}
#[derive(
Clone,
Copy,
Debug,
Eq,
PartialEq,
serde::Deserialize,
serde::Serialize,
strum::Display,
strum::EnumString,
)]
#[router_derive::diesel_enum(storage_type = "db_enum")]
#[serde(rename_all = "snake_case")]
#[strum(serialize_all = "snake_case")]
pub enum DashboardMetadata {
ProductionAgreement,
SetupProcessor,
ConfigureEndpoint,
SetupComplete,
FirstProcessorConnected,
SecondProcessorConnected,
ConfiguredRouting,
TestPayment,
IntegrationMethod,
ConfigurationType,
IntegrationCompleted,
StripeConnected,
PaypalConnected,
SpRoutingConfigured,
Feedback,
ProdIntent,
SpTestPayment,
DownloadWoocom,
ConfigureWoocom,
SetupWoocomWebhook,
IsMultipleConfiguration,
IsChangePasswordRequired,
OnboardingSurvey,
ReconStatus,
}
#[derive(
Clone,
Copy,
Debug,
Default,
Eq,
PartialEq,
serde::Serialize,
serde::Deserialize,
strum::Display,
strum::EnumString,
)]
#[diesel_enum(storage_type = "db_enum")]
#[serde(rename_all = "snake_case")]
#[strum(serialize_all = "snake_case")]
pub enum TotpStatus {
Set,
InProgress,
#[default]
NotSet,
}
#[derive(
Clone,
Copy,
Debug,
Default,
Eq,
PartialEq,
serde::Serialize,
serde::Deserialize,
strum::EnumString,
strum::Display,
)]
#[diesel_enum(storage_type = "db_enum")]
#[serde(rename_all = "snake_case")]
#[strum(serialize_all = "snake_case")]
pub enum UserRoleVersion {
#[default]
V1,
V2,
}
<file_sep path="hyperswitch/crates/router_derive/src/lib.rs" crate="router_derive" role="macro_def">
<|fim_prefix|>
<|meta_start|><|file|> hyperswitch/crates/router_derive/src/lib.rs<|crate|> diesel_models macro=DieselEnum roles=use_site,macro_def use=attribute item=file pack=proc_macro_neighborhoods lang=rust<|meta_end|>
pub fn diesel_enum_derive(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
<|fim_suffix|>
<|fim_middle|>
}
<file_sep path="hyperswitch/crates/router_derive/src/lib.rs" crate="router_derive" role="macro_def">
<|fim_prefix|>
pub fn diesel_enum_derive(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
<|fim_suffix|>
<|fim_middle|>
}
| proc_macro_neighborhoods |
<file_sep path="hyperswitch/crates/diesel_models/src/enums.rs" crate="diesel_models" role="use_site">
#[doc(hidden)]
pub mod diesel_exports {
pub use super::{
DbApiVersion as ApiVersion, DbAttemptStatus as AttemptStatus,
DbAuthenticationType as AuthenticationType, DbBlocklistDataKind as BlocklistDataKind,
DbCaptureMethod as CaptureMethod, DbCaptureStatus as CaptureStatus,
DbCardDiscovery as CardDiscovery, DbConnectorStatus as ConnectorStatus,
DbConnectorType as ConnectorType, DbCountryAlpha2 as CountryAlpha2, DbCurrency as Currency,
DbDashboardMetadata as DashboardMetadata, DbDeleteStatus as DeleteStatus,
DbDisputeStage as DisputeStage, DbDisputeStatus as DisputeStatus,
DbEventClass as EventClass, DbEventObjectType as EventObjectType, DbEventType as EventType,
DbFraudCheckStatus as FraudCheckStatus, DbFraudCheckType as FraudCheckType,
DbFutureUsage as FutureUsage, DbGenericLinkType as GenericLinkType,
DbIntentStatus as IntentStatus, DbMandateStatus as MandateStatus,
DbMandateType as MandateType, DbMerchantStorageScheme as MerchantStorageScheme,
DbOrderFulfillmentTimeOrigin as OrderFulfillmentTimeOrigin,
DbPaymentMethodIssuerCode as PaymentMethodIssuerCode, DbPaymentSource as PaymentSource,
DbPaymentType as PaymentType, DbPayoutStatus as PayoutStatus, DbPayoutType as PayoutType,
DbProcessTrackerStatus as ProcessTrackerStatus, DbReconStatus as ReconStatus,
DbRefundStatus as RefundStatus, DbRefundType as RefundType, DbRelayStatus as RelayStatus,
DbRelayType as RelayType,
DbRequestIncrementalAuthorization as RequestIncrementalAuthorization,
DbRoleScope as RoleScope, DbRoutingAlgorithmKind as RoutingAlgorithmKind,
DbScaExemptionType as ScaExemptionType,
DbSuccessBasedRoutingConclusiveState as SuccessBasedRoutingConclusiveState,
DbTotpStatus as TotpStatus, DbTransactionType as TransactionType,
DbUserRoleVersion as UserRoleVersion, DbUserStatus as UserStatus,
DbWebhookDeliveryAttempt as WebhookDeliveryAttempt,
};
}
pub use common_enums::*;
use common_utils::pii;
use diesel::{deserialize::FromSqlRow, expression::AsExpression, sql_types::Jsonb};
use router_derive::diesel_enum;
use time::PrimitiveDateTime;
#[derive(
Clone,
Copy,
Debug,
Eq,
PartialEq,
serde::Deserialize,
serde::Serialize,
strum::Display,
strum::EnumString,
)]
#[diesel_enum(storage_type = "db_enum")]
#[serde(rename_all = "snake_case")]
#[strum(serialize_all = "snake_case")]
pub enum RoutingAlgorithmKind {
Single,
Priority,
VolumeSplit,
Advanced,
Dynamic,
}
#[derive(
Clone,
Copy,
Debug,
Eq,
PartialEq,
serde::Deserialize,
serde::Serialize,
strum::Display,
strum::EnumString,
)]
#[diesel_enum(storage_type = "db_enum")]
#[serde(rename_all = "snake_case")]
#[strum(serialize_all = "snake_case")]
pub enum EventObjectType {
PaymentDetails,
RefundDetails,
DisputeDetails,
MandateDetails,
PayoutDetails,
}
// Refund
#[derive(
Clone,
Copy,
Debug,
Default,
Eq,
PartialEq,
serde::Serialize,
serde::Deserialize,
strum::Display,
strum::EnumString,
)]
#[diesel_enum(storage_type = "db_enum")]
#[strum(serialize_all = "snake_case")]
#[serde(rename_all = "snake_case")]
pub enum RefundType {
InstantRefund,
#[default]
RegularRefund,
RetryRefund,
}
// Mandate
#[derive(
Clone,
Copy,
Debug,
Eq,
PartialEq,
Default,
serde::Deserialize,
serde::Serialize,
strum::Display,
strum::EnumString,
)]
#[diesel_enum(storage_type = "db_enum")]
#[serde(rename_all = "snake_case")]
#[strum(serialize_all = "snake_case")]
pub enum MandateType {
SingleUse,
#[default]
MultiUse,
}
#[derive(
serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, FromSqlRow, AsExpression,
)]
#[diesel(sql_type = Jsonb)]
#[serde(rename_all = "snake_case")]
pub struct MandateDetails {
pub update_mandate_id: Option<String>,
}
common_utils::impl_to_sql_from_sql_json!(MandateDetails);
#[derive(
serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, FromSqlRow, AsExpression,
)]
#[diesel(sql_type = Jsonb)]
#[serde(rename_all = "snake_case")]
pub enum MandateDataType {
SingleUse(MandateAmountData),
MultiUse(Option<MandateAmountData>),
}
common_utils::impl_to_sql_from_sql_json!(MandateDataType);
#[derive(Clone, Debug, serde::Serialize, serde::Deserialize, PartialEq, Eq)]
pub struct MandateAmountData {
pub amount: common_utils::types::MinorUnit,
pub currency: Currency,
pub start_date: Option<PrimitiveDateTime>,
pub end_date: Option<PrimitiveDateTime>,
pub metadata: Option<pii::SecretSerdeValue>,
}
#[derive(
Clone,
Copy,
Debug,
Eq,
PartialEq,
serde::Serialize,
serde::Deserialize,
strum::Display,
strum::EnumString,
)]
#[diesel_enum(storage_type = "db_enum")]
#[serde(rename_all = "snake_case")]
#[strum(serialize_all = "snake_case")]
pub enum FraudCheckType {
PreFrm,
PostFrm,
}
#[derive(
Clone,
Copy,
Debug,
Default,
Eq,
PartialEq,
serde::Serialize,
serde::Deserialize,
strum::Display,
strum::EnumString,
)]
#[diesel_enum(storage_type = "text")]
#[strum(serialize_all = "snake_case")]
pub enum FraudCheckLastStep {
#[default]
Processing,
CheckoutOrSale,
TransactionOrRecordRefund,
Fulfillment,
}
#[derive(
Clone,
Copy,
Debug,
Default,
Eq,
PartialEq,
serde::Serialize,
serde::Deserialize,
strum::Display,
strum::EnumString,
)]
#[diesel_enum(storage_type = "db_enum")]
#[serde(rename_all = "snake_case")]
#[strum(serialize_all = "snake_case")]
pub enum UserStatus {
Active,
#[default]
InvitationSent,
}
#[derive(
Clone,
Copy,
Debug,
Eq,
PartialEq,
serde::Deserialize,
serde::Serialize,
strum::Display,
strum::EnumString,
)]
#[router_derive::diesel_enum(storage_type = "db_enum")]
#[serde(rename_all = "snake_case")]
#[strum(serialize_all = "snake_case")]
pub enum DashboardMetadata {
ProductionAgreement,
SetupProcessor,
ConfigureEndpoint,
SetupComplete,
FirstProcessorConnected,
SecondProcessorConnected,
ConfiguredRouting,
TestPayment,
IntegrationMethod,
ConfigurationType,
IntegrationCompleted,
StripeConnected,
PaypalConnected,
SpRoutingConfigured,
Feedback,
ProdIntent,
SpTestPayment,
DownloadWoocom,
ConfigureWoocom,
SetupWoocomWebhook,
IsMultipleConfiguration,
IsChangePasswordRequired,
OnboardingSurvey,
ReconStatus,
}
#[derive(
Clone,
Copy,
Debug,
Default,
Eq,
PartialEq,
serde::Serialize,
serde::Deserialize,
strum::Display,
strum::EnumString,
)]
#[diesel_enum(storage_type = "db_enum")]
#[serde(rename_all = "snake_case")]
#[strum(serialize_all = "snake_case")]
pub enum TotpStatus {
Set,
InProgress,
#[default]
NotSet,
}
#[derive(
Clone,
Copy,
Debug,
Default,
Eq,
PartialEq,
serde::Serialize,
serde::Deserialize,
strum::EnumString,
strum::Display,
)]
#[diesel_enum(storage_type = "db_enum")]
#[serde(rename_all = "snake_case")]
#[strum(serialize_all = "snake_case")]
pub enum UserRoleVersion {
#[default]
V1,
V2,
}
<file_sep path="hyperswitch/crates/diesel_models/src/enums.rs" crate="diesel_models" role="use_site">
#[doc(hidden)]
pub mod diesel_exports {
pub use super::{
DbApiVersion as ApiVersion, DbAttemptStatus as AttemptStatus,
DbAuthenticationType as AuthenticationType, DbBlocklistDataKind as BlocklistDataKind,
DbCaptureMethod as CaptureMethod, DbCaptureStatus as CaptureStatus,
DbCardDiscovery as CardDiscovery, DbConnectorStatus as ConnectorStatus,
DbConnectorType as ConnectorType, DbCountryAlpha2 as CountryAlpha2, DbCurrency as Currency,
DbDashboardMetadata as DashboardMetadata, DbDeleteStatus as DeleteStatus,
DbDisputeStage as DisputeStage, DbDisputeStatus as DisputeStatus,
DbEventClass as EventClass, DbEventObjectType as EventObjectType, DbEventType as EventType,
DbFraudCheckStatus as FraudCheckStatus, DbFraudCheckType as FraudCheckType,
DbFutureUsage as FutureUsage, DbGenericLinkType as GenericLinkType,
DbIntentStatus as IntentStatus, DbMandateStatus as MandateStatus,
DbMandateType as MandateType, DbMerchantStorageScheme as MerchantStorageScheme,
DbOrderFulfillmentTimeOrigin as OrderFulfillmentTimeOrigin,
DbPaymentMethodIssuerCode as PaymentMethodIssuerCode, DbPaymentSource as PaymentSource,
DbPaymentType as PaymentType, DbPayoutStatus as PayoutStatus, DbPayoutType as PayoutType,
DbProcessTrackerStatus as ProcessTrackerStatus, DbReconStatus as ReconStatus,
DbRefundStatus as RefundStatus, DbRefundType as RefundType, DbRelayStatus as RelayStatus,
DbRelayType as RelayType,
DbRequestIncrementalAuthorization as RequestIncrementalAuthorization,
DbRoleScope as RoleScope, DbRoutingAlgorithmKind as RoutingAlgorithmKind,
DbScaExemptionType as ScaExemptionType,
DbSuccessBasedRoutingConclusiveState as SuccessBasedRoutingConclusiveState,
DbTotpStatus as TotpStatus, DbTransactionType as TransactionType,
DbUserRoleVersion as UserRoleVersion, DbUserStatus as UserStatus,
DbWebhookDeliveryAttempt as WebhookDeliveryAttempt,
};
}
pub use common_enums::*;
use common_utils::pii;
use diesel::{deserialize::FromSqlRow, expression::AsExpression, sql_types::Jsonb};
use router_derive::diesel_enum;
use time::PrimitiveDateTime;
#[derive(
Clone,
Copy,
Debug,
Eq,
PartialEq,
serde::Deserialize,
serde::Serialize,
strum::Display,
strum::EnumString,
)]
#[diesel_enum(storage_type = "db_enum")]
#[serde(rename_all = "snake_case")]
#[strum(serialize_all = "snake_case")]
pub enum RoutingAlgorithmKind {
Single,
Priority,
VolumeSplit,
Advanced,
Dynamic,
}
#[derive(
Clone,
Copy,
Debug,
Eq,
PartialEq,
serde::Deserialize,
serde::Serialize,
strum::Display,
strum::EnumString,
)]
#[diesel_enum(storage_type = "db_enum")]
#[serde(rename_all = "snake_case")]
#[strum(serialize_all = "snake_case")]
pub enum EventObjectType {
PaymentDetails,
RefundDetails,
DisputeDetails,
MandateDetails,
PayoutDetails,
}
// Refund
#[derive(
Clone,
Copy,
Debug,
Default,
Eq,
PartialEq,
serde::Serialize,
serde::Deserialize,
strum::Display,
strum::EnumString,
)]
#[diesel_enum(storage_type = "db_enum")]
#[strum(serialize_all = "snake_case")]
#[serde(rename_all = "snake_case")]
pub enum RefundType {
InstantRefund,
#[default]
RegularRefund,
RetryRefund,
}
// Mandate
#[derive(
Clone,
Copy,
Debug,
Eq,
PartialEq,
Default,
serde::Deserialize,
serde::Serialize,
strum::Display,
strum::EnumString,
)]
#[diesel_enum(storage_type = "db_enum")]
#[serde(rename_all = "snake_case")]
#[strum(serialize_all = "snake_case")]
pub enum MandateType {
SingleUse,
#[default]
MultiUse,
}
#[derive(
serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, FromSqlRow, AsExpression,
)]
#[diesel(sql_type = Jsonb)]
#[serde(rename_all = "snake_case")]
pub struct MandateDetails {
pub update_mandate_id: Option<String>,
}
common_utils::impl_to_sql_from_sql_json!(MandateDetails);
#[derive(
serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, FromSqlRow, AsExpression,
)]
#[diesel(sql_type = Jsonb)]
#[serde(rename_all = "snake_case")]
pub enum MandateDataType {
SingleUse(MandateAmountData),
MultiUse(Option<MandateAmountData>),
}
common_utils::impl_to_sql_from_sql_json!(MandateDataType);
#[derive(Clone, Debug, serde::Serialize, serde::Deserialize, PartialEq, Eq)]
pub struct MandateAmountData {
pub amount: common_utils::types::MinorUnit,
pub currency: Currency,
pub start_date: Option<PrimitiveDateTime>,
pub end_date: Option<PrimitiveDateTime>,
pub metadata: Option<pii::SecretSerdeValue>,
}
#[derive(
Clone,
Copy,
Debug,
Eq,
PartialEq,
serde::Serialize,
serde::Deserialize,
strum::Display,
strum::EnumString,
)]
#[diesel_enum(storage_type = "db_enum")]
#[serde(rename_all = "snake_case")]
#[strum(serialize_all = "snake_case")]
pub enum FraudCheckType {
PreFrm,
PostFrm,
}
#[derive(
Clone,
Copy,
Debug,
Default,
Eq,
PartialEq,
serde::Serialize,
serde::Deserialize,
strum::Display,
strum::EnumString,
)]
#[diesel_enum(storage_type = "text")]
#[strum(serialize_all = "snake_case")]
pub enum FraudCheckLastStep {
#[default]
Processing,
CheckoutOrSale,
TransactionOrRecordRefund,
Fulfillment,
}
#[derive(
Clone,
Copy,
Debug,
Default,
Eq,
PartialEq,
serde::Serialize,
serde::Deserialize,
strum::Display,
strum::EnumString,
)]
#[diesel_enum(storage_type = "db_enum")]
#[serde(rename_all = "snake_case")]
#[strum(serialize_all = "snake_case")]
pub enum UserStatus {
Active,
#[default]
InvitationSent,
}
#[derive(
Clone,
Copy,
Debug,
Eq,
PartialEq,
serde::Deserialize,
serde::Serialize,
strum::Display,
strum::EnumString,
)]
#[router_derive::diesel_enum(storage_type = "db_enum")]
#[serde(rename_all = "snake_case")]
#[strum(serialize_all = "snake_case")]
pub enum DashboardMetadata {
ProductionAgreement,
SetupProcessor,
ConfigureEndpoint,
SetupComplete,
FirstProcessorConnected,
SecondProcessorConnected,
ConfiguredRouting,
TestPayment,
IntegrationMethod,
ConfigurationType,
IntegrationCompleted,
StripeConnected,
PaypalConnected,
SpRoutingConfigured,
Feedback,
ProdIntent,
SpTestPayment,
DownloadWoocom,
ConfigureWoocom,
SetupWoocomWebhook,
IsMultipleConfiguration,
IsChangePasswordRequired,
OnboardingSurvey,
ReconStatus,
}
#[derive(
Clone,
Copy,
Debug,
Default,
Eq,
PartialEq,
serde::Serialize,
serde::Deserialize,
strum::Display,
strum::EnumString,
)]
#[diesel_enum(storage_type = "db_enum")]
#[serde(rename_all = "snake_case")]
#[strum(serialize_all = "snake_case")]
pub enum TotpStatus {
Set,
InProgress,
#[default]
NotSet,
}
#[derive(
Clone,
Copy,
Debug,
Default,
Eq,
PartialEq,
serde::Serialize,
serde::Deserialize,
strum::EnumString,
strum::Display,
)]
#[diesel_enum(storage_type = "db_enum")]
#[serde(rename_all = "snake_case")]
#[strum(serialize_all = "snake_case")]
pub enum UserRoleVersion {
#[default]
V1,
V2,
}
<file_sep path="hyperswitch/crates/router_derive/src/lib.rs" crate="router_derive" role="macro_def">
<|fim_prefix|>
<|meta_start|><|file|> hyperswitch/crates/router_derive/src/lib.rs<|crate|> diesel_models macro=DieselEnum roles=use_site,macro_def use=attribute item=file pack=proc_macro_neighborhoods lang=rust<|meta_end|>
pub fn diesel_enum_derive(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
<|fim_suffix|>
<|fim_middle|>
}
<file_sep path="hyperswitch/crates/router_derive/src/lib.rs" crate="router_derive" role="macro_def">
<|fim_prefix|>
pub fn diesel_enum_derive(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
<|fim_suffix|>
<|fim_middle|>
}
| proc_macro_neighborhoods |
<file_sep path="hyperswitch/crates/diesel_models/src/enums.rs" crate="diesel_models" role="use_site">
#[doc(hidden)]
pub mod diesel_exports {
pub use super::{
DbApiVersion as ApiVersion, DbAttemptStatus as AttemptStatus,
DbAuthenticationType as AuthenticationType, DbBlocklistDataKind as BlocklistDataKind,
DbCaptureMethod as CaptureMethod, DbCaptureStatus as CaptureStatus,
DbCardDiscovery as CardDiscovery, DbConnectorStatus as ConnectorStatus,
DbConnectorType as ConnectorType, DbCountryAlpha2 as CountryAlpha2, DbCurrency as Currency,
DbDashboardMetadata as DashboardMetadata, DbDeleteStatus as DeleteStatus,
DbDisputeStage as DisputeStage, DbDisputeStatus as DisputeStatus,
DbEventClass as EventClass, DbEventObjectType as EventObjectType, DbEventType as EventType,
DbFraudCheckStatus as FraudCheckStatus, DbFraudCheckType as FraudCheckType,
DbFutureUsage as FutureUsage, DbGenericLinkType as GenericLinkType,
DbIntentStatus as IntentStatus, DbMandateStatus as MandateStatus,
DbMandateType as MandateType, DbMerchantStorageScheme as MerchantStorageScheme,
DbOrderFulfillmentTimeOrigin as OrderFulfillmentTimeOrigin,
DbPaymentMethodIssuerCode as PaymentMethodIssuerCode, DbPaymentSource as PaymentSource,
DbPaymentType as PaymentType, DbPayoutStatus as PayoutStatus, DbPayoutType as PayoutType,
DbProcessTrackerStatus as ProcessTrackerStatus, DbReconStatus as ReconStatus,
DbRefundStatus as RefundStatus, DbRefundType as RefundType, DbRelayStatus as RelayStatus,
DbRelayType as RelayType,
DbRequestIncrementalAuthorization as RequestIncrementalAuthorization,
DbRoleScope as RoleScope, DbRoutingAlgorithmKind as RoutingAlgorithmKind,
DbScaExemptionType as ScaExemptionType,
DbSuccessBasedRoutingConclusiveState as SuccessBasedRoutingConclusiveState,
DbTotpStatus as TotpStatus, DbTransactionType as TransactionType,
DbUserRoleVersion as UserRoleVersion, DbUserStatus as UserStatus,
DbWebhookDeliveryAttempt as WebhookDeliveryAttempt,
};
}
pub use common_enums::*;
use common_utils::pii;
use diesel::{deserialize::FromSqlRow, expression::AsExpression, sql_types::Jsonb};
use router_derive::diesel_enum;
use time::PrimitiveDateTime;
#[derive(
Clone,
Copy,
Debug,
Eq,
PartialEq,
serde::Deserialize,
serde::Serialize,
strum::Display,
strum::EnumString,
)]
#[diesel_enum(storage_type = "db_enum")]
#[serde(rename_all = "snake_case")]
#[strum(serialize_all = "snake_case")]
pub enum RoutingAlgorithmKind {
Single,
Priority,
VolumeSplit,
Advanced,
Dynamic,
}
#[derive(
Clone,
Copy,
Debug,
Eq,
PartialEq,
serde::Deserialize,
serde::Serialize,
strum::Display,
strum::EnumString,
)]
#[diesel_enum(storage_type = "db_enum")]
#[serde(rename_all = "snake_case")]
#[strum(serialize_all = "snake_case")]
pub enum EventObjectType {
PaymentDetails,
RefundDetails,
DisputeDetails,
MandateDetails,
PayoutDetails,
}
// Refund
#[derive(
Clone,
Copy,
Debug,
Default,
Eq,
PartialEq,
serde::Serialize,
serde::Deserialize,
strum::Display,
strum::EnumString,
)]
#[diesel_enum(storage_type = "db_enum")]
#[strum(serialize_all = "snake_case")]
#[serde(rename_all = "snake_case")]
pub enum RefundType {
InstantRefund,
#[default]
RegularRefund,
RetryRefund,
}
// Mandate
#[derive(
Clone,
Copy,
Debug,
Eq,
PartialEq,
Default,
serde::Deserialize,
serde::Serialize,
strum::Display,
strum::EnumString,
)]
#[diesel_enum(storage_type = "db_enum")]
#[serde(rename_all = "snake_case")]
#[strum(serialize_all = "snake_case")]
pub enum MandateType {
SingleUse,
#[default]
MultiUse,
}
#[derive(
serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, FromSqlRow, AsExpression,
)]
#[diesel(sql_type = Jsonb)]
#[serde(rename_all = "snake_case")]
pub struct MandateDetails {
pub update_mandate_id: Option<String>,
}
common_utils::impl_to_sql_from_sql_json!(MandateDetails);
#[derive(
serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, FromSqlRow, AsExpression,
)]
#[diesel(sql_type = Jsonb)]
#[serde(rename_all = "snake_case")]
pub enum MandateDataType {
SingleUse(MandateAmountData),
MultiUse(Option<MandateAmountData>),
}
common_utils::impl_to_sql_from_sql_json!(MandateDataType);
#[derive(Clone, Debug, serde::Serialize, serde::Deserialize, PartialEq, Eq)]
pub struct MandateAmountData {
pub amount: common_utils::types::MinorUnit,
pub currency: Currency,
pub start_date: Option<PrimitiveDateTime>,
pub end_date: Option<PrimitiveDateTime>,
pub metadata: Option<pii::SecretSerdeValue>,
}
#[derive(
Clone,
Copy,
Debug,
Eq,
PartialEq,
serde::Serialize,
serde::Deserialize,
strum::Display,
strum::EnumString,
)]
#[diesel_enum(storage_type = "db_enum")]
#[serde(rename_all = "snake_case")]
#[strum(serialize_all = "snake_case")]
pub enum FraudCheckType {
PreFrm,
PostFrm,
}
#[derive(
Clone,
Copy,
Debug,
Default,
Eq,
PartialEq,
serde::Serialize,
serde::Deserialize,
strum::Display,
strum::EnumString,
)]
#[diesel_enum(storage_type = "text")]
#[strum(serialize_all = "snake_case")]
pub enum FraudCheckLastStep {
#[default]
Processing,
CheckoutOrSale,
TransactionOrRecordRefund,
Fulfillment,
}
#[derive(
Clone,
Copy,
Debug,
Default,
Eq,
PartialEq,
serde::Serialize,
serde::Deserialize,
strum::Display,
strum::EnumString,
)]
#[diesel_enum(storage_type = "db_enum")]
#[serde(rename_all = "snake_case")]
#[strum(serialize_all = "snake_case")]
pub enum UserStatus {
Active,
#[default]
InvitationSent,
}
#[derive(
Clone,
Copy,
Debug,
Eq,
PartialEq,
serde::Deserialize,
serde::Serialize,
strum::Display,
strum::EnumString,
)]
#[router_derive::diesel_enum(storage_type = "db_enum")]
#[serde(rename_all = "snake_case")]
#[strum(serialize_all = "snake_case")]
pub enum DashboardMetadata {
ProductionAgreement,
SetupProcessor,
ConfigureEndpoint,
SetupComplete,
FirstProcessorConnected,
SecondProcessorConnected,
ConfiguredRouting,
TestPayment,
IntegrationMethod,
ConfigurationType,
IntegrationCompleted,
StripeConnected,
PaypalConnected,
SpRoutingConfigured,
Feedback,
ProdIntent,
SpTestPayment,
DownloadWoocom,
ConfigureWoocom,
SetupWoocomWebhook,
IsMultipleConfiguration,
IsChangePasswordRequired,
OnboardingSurvey,
ReconStatus,
}
#[derive(
Clone,
Copy,
Debug,
Default,
Eq,
PartialEq,
serde::Serialize,
serde::Deserialize,
strum::Display,
strum::EnumString,
)]
#[diesel_enum(storage_type = "db_enum")]
#[serde(rename_all = "snake_case")]
#[strum(serialize_all = "snake_case")]
pub enum TotpStatus {
Set,
InProgress,
#[default]
NotSet,
}
#[derive(
Clone,
Copy,
Debug,
Default,
Eq,
PartialEq,
serde::Serialize,
serde::Deserialize,
strum::EnumString,
strum::Display,
)]
#[diesel_enum(storage_type = "db_enum")]
#[serde(rename_all = "snake_case")]
#[strum(serialize_all = "snake_case")]
pub enum UserRoleVersion {
#[default]
V1,
V2,
}
<file_sep path="hyperswitch/crates/diesel_models/src/enums.rs" crate="diesel_models" role="use_site">
#[doc(hidden)]
pub mod diesel_exports {
pub use super::{
DbApiVersion as ApiVersion, DbAttemptStatus as AttemptStatus,
DbAuthenticationType as AuthenticationType, DbBlocklistDataKind as BlocklistDataKind,
DbCaptureMethod as CaptureMethod, DbCaptureStatus as CaptureStatus,
DbCardDiscovery as CardDiscovery, DbConnectorStatus as ConnectorStatus,
DbConnectorType as ConnectorType, DbCountryAlpha2 as CountryAlpha2, DbCurrency as Currency,
DbDashboardMetadata as DashboardMetadata, DbDeleteStatus as DeleteStatus,
DbDisputeStage as DisputeStage, DbDisputeStatus as DisputeStatus,
DbEventClass as EventClass, DbEventObjectType as EventObjectType, DbEventType as EventType,
DbFraudCheckStatus as FraudCheckStatus, DbFraudCheckType as FraudCheckType,
DbFutureUsage as FutureUsage, DbGenericLinkType as GenericLinkType,
DbIntentStatus as IntentStatus, DbMandateStatus as MandateStatus,
DbMandateType as MandateType, DbMerchantStorageScheme as MerchantStorageScheme,
DbOrderFulfillmentTimeOrigin as OrderFulfillmentTimeOrigin,
DbPaymentMethodIssuerCode as PaymentMethodIssuerCode, DbPaymentSource as PaymentSource,
DbPaymentType as PaymentType, DbPayoutStatus as PayoutStatus, DbPayoutType as PayoutType,
DbProcessTrackerStatus as ProcessTrackerStatus, DbReconStatus as ReconStatus,
DbRefundStatus as RefundStatus, DbRefundType as RefundType, DbRelayStatus as RelayStatus,
DbRelayType as RelayType,
DbRequestIncrementalAuthorization as RequestIncrementalAuthorization,
DbRoleScope as RoleScope, DbRoutingAlgorithmKind as RoutingAlgorithmKind,
DbScaExemptionType as ScaExemptionType,
DbSuccessBasedRoutingConclusiveState as SuccessBasedRoutingConclusiveState,
DbTotpStatus as TotpStatus, DbTransactionType as TransactionType,
DbUserRoleVersion as UserRoleVersion, DbUserStatus as UserStatus,
DbWebhookDeliveryAttempt as WebhookDeliveryAttempt,
};
}
pub use common_enums::*;
use common_utils::pii;
use diesel::{deserialize::FromSqlRow, expression::AsExpression, sql_types::Jsonb};
use router_derive::diesel_enum;
use time::PrimitiveDateTime;
#[derive(
Clone,
Copy,
Debug,
Eq,
PartialEq,
serde::Deserialize,
serde::Serialize,
strum::Display,
strum::EnumString,
)]
#[diesel_enum(storage_type = "db_enum")]
#[serde(rename_all = "snake_case")]
#[strum(serialize_all = "snake_case")]
pub enum RoutingAlgorithmKind {
Single,
Priority,
VolumeSplit,
Advanced,
Dynamic,
}
#[derive(
Clone,
Copy,
Debug,
Eq,
PartialEq,
serde::Deserialize,
serde::Serialize,
strum::Display,
strum::EnumString,
)]
#[diesel_enum(storage_type = "db_enum")]
#[serde(rename_all = "snake_case")]
#[strum(serialize_all = "snake_case")]
pub enum EventObjectType {
PaymentDetails,
RefundDetails,
DisputeDetails,
MandateDetails,
PayoutDetails,
}
// Refund
#[derive(
Clone,
Copy,
Debug,
Default,
Eq,
PartialEq,
serde::Serialize,
serde::Deserialize,
strum::Display,
strum::EnumString,
)]
#[diesel_enum(storage_type = "db_enum")]
#[strum(serialize_all = "snake_case")]
#[serde(rename_all = "snake_case")]
pub enum RefundType {
InstantRefund,
#[default]
RegularRefund,
RetryRefund,
}
// Mandate
#[derive(
Clone,
Copy,
Debug,
Eq,
PartialEq,
Default,
serde::Deserialize,
serde::Serialize,
strum::Display,
strum::EnumString,
)]
#[diesel_enum(storage_type = "db_enum")]
#[serde(rename_all = "snake_case")]
#[strum(serialize_all = "snake_case")]
pub enum MandateType {
SingleUse,
#[default]
MultiUse,
}
#[derive(
serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, FromSqlRow, AsExpression,
)]
#[diesel(sql_type = Jsonb)]
#[serde(rename_all = "snake_case")]
pub struct MandateDetails {
pub update_mandate_id: Option<String>,
}
common_utils::impl_to_sql_from_sql_json!(MandateDetails);
#[derive(
serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, FromSqlRow, AsExpression,
)]
#[diesel(sql_type = Jsonb)]
#[serde(rename_all = "snake_case")]
pub enum MandateDataType {
SingleUse(MandateAmountData),
MultiUse(Option<MandateAmountData>),
}
common_utils::impl_to_sql_from_sql_json!(MandateDataType);
#[derive(Clone, Debug, serde::Serialize, serde::Deserialize, PartialEq, Eq)]
pub struct MandateAmountData {
pub amount: common_utils::types::MinorUnit,
pub currency: Currency,
pub start_date: Option<PrimitiveDateTime>,
pub end_date: Option<PrimitiveDateTime>,
pub metadata: Option<pii::SecretSerdeValue>,
}
#[derive(
Clone,
Copy,
Debug,
Eq,
PartialEq,
serde::Serialize,
serde::Deserialize,
strum::Display,
strum::EnumString,
)]
#[diesel_enum(storage_type = "db_enum")]
#[serde(rename_all = "snake_case")]
#[strum(serialize_all = "snake_case")]
pub enum FraudCheckType {
PreFrm,
PostFrm,
}
#[derive(
Clone,
Copy,
Debug,
Default,
Eq,
PartialEq,
serde::Serialize,
serde::Deserialize,
strum::Display,
strum::EnumString,
)]
#[diesel_enum(storage_type = "text")]
#[strum(serialize_all = "snake_case")]
pub enum FraudCheckLastStep {
#[default]
Processing,
CheckoutOrSale,
TransactionOrRecordRefund,
Fulfillment,
}
#[derive(
Clone,
Copy,
Debug,
Default,
Eq,
PartialEq,
serde::Serialize,
serde::Deserialize,
strum::Display,
strum::EnumString,
)]
#[diesel_enum(storage_type = "db_enum")]
#[serde(rename_all = "snake_case")]
#[strum(serialize_all = "snake_case")]
pub enum UserStatus {
Active,
#[default]
InvitationSent,
}
#[derive(
Clone,
Copy,
Debug,
Eq,
PartialEq,
serde::Deserialize,
serde::Serialize,
strum::Display,
strum::EnumString,
)]
#[router_derive::diesel_enum(storage_type = "db_enum")]
#[serde(rename_all = "snake_case")]
#[strum(serialize_all = "snake_case")]
pub enum DashboardMetadata {
ProductionAgreement,
SetupProcessor,
ConfigureEndpoint,
SetupComplete,
FirstProcessorConnected,
SecondProcessorConnected,
ConfiguredRouting,
TestPayment,
IntegrationMethod,
ConfigurationType,
IntegrationCompleted,
StripeConnected,
PaypalConnected,
SpRoutingConfigured,
Feedback,
ProdIntent,
SpTestPayment,
DownloadWoocom,
ConfigureWoocom,
SetupWoocomWebhook,
IsMultipleConfiguration,
IsChangePasswordRequired,
OnboardingSurvey,
ReconStatus,
}
#[derive(
Clone,
Copy,
Debug,
Default,
Eq,
PartialEq,
serde::Serialize,
serde::Deserialize,
strum::Display,
strum::EnumString,
)]
#[diesel_enum(storage_type = "db_enum")]
#[serde(rename_all = "snake_case")]
#[strum(serialize_all = "snake_case")]
pub enum TotpStatus {
Set,
InProgress,
#[default]
NotSet,
}
#[derive(
Clone,
Copy,
Debug,
Default,
Eq,
PartialEq,
serde::Serialize,
serde::Deserialize,
strum::EnumString,
strum::Display,
)]
#[diesel_enum(storage_type = "db_enum")]
#[serde(rename_all = "snake_case")]
#[strum(serialize_all = "snake_case")]
pub enum UserRoleVersion {
#[default]
V1,
V2,
}
<file_sep path="hyperswitch/crates/router_derive/src/lib.rs" crate="router_derive" role="macro_def">
<|fim_prefix|>
<|meta_start|><|file|> hyperswitch/crates/router_derive/src/lib.rs<|crate|> diesel_models macro=DieselEnum roles=use_site,macro_def use=attribute item=file pack=proc_macro_neighborhoods lang=rust<|meta_end|>
pub fn diesel_enum_derive(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
<|fim_suffix|>
<|fim_middle|>
}
<file_sep path="hyperswitch/crates/router_derive/src/lib.rs" crate="router_derive" role="macro_def">
<|fim_prefix|>
pub fn diesel_enum_derive(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
<|fim_suffix|>
<|fim_middle|>
}
| proc_macro_neighborhoods |
<file_sep path="hyperswitch/crates/diesel_models/src/enums.rs" crate="diesel_models" role="use_site">
#[doc(hidden)]
pub mod diesel_exports {
pub use super::{
DbApiVersion as ApiVersion, DbAttemptStatus as AttemptStatus,
DbAuthenticationType as AuthenticationType, DbBlocklistDataKind as BlocklistDataKind,
DbCaptureMethod as CaptureMethod, DbCaptureStatus as CaptureStatus,
DbCardDiscovery as CardDiscovery, DbConnectorStatus as ConnectorStatus,
DbConnectorType as ConnectorType, DbCountryAlpha2 as CountryAlpha2, DbCurrency as Currency,
DbDashboardMetadata as DashboardMetadata, DbDeleteStatus as DeleteStatus,
DbDisputeStage as DisputeStage, DbDisputeStatus as DisputeStatus,
DbEventClass as EventClass, DbEventObjectType as EventObjectType, DbEventType as EventType,
DbFraudCheckStatus as FraudCheckStatus, DbFraudCheckType as FraudCheckType,
DbFutureUsage as FutureUsage, DbGenericLinkType as GenericLinkType,
DbIntentStatus as IntentStatus, DbMandateStatus as MandateStatus,
DbMandateType as MandateType, DbMerchantStorageScheme as MerchantStorageScheme,
DbOrderFulfillmentTimeOrigin as OrderFulfillmentTimeOrigin,
DbPaymentMethodIssuerCode as PaymentMethodIssuerCode, DbPaymentSource as PaymentSource,
DbPaymentType as PaymentType, DbPayoutStatus as PayoutStatus, DbPayoutType as PayoutType,
DbProcessTrackerStatus as ProcessTrackerStatus, DbReconStatus as ReconStatus,
DbRefundStatus as RefundStatus, DbRefundType as RefundType, DbRelayStatus as RelayStatus,
DbRelayType as RelayType,
DbRequestIncrementalAuthorization as RequestIncrementalAuthorization,
DbRoleScope as RoleScope, DbRoutingAlgorithmKind as RoutingAlgorithmKind,
DbScaExemptionType as ScaExemptionType,
DbSuccessBasedRoutingConclusiveState as SuccessBasedRoutingConclusiveState,
DbTotpStatus as TotpStatus, DbTransactionType as TransactionType,
DbUserRoleVersion as UserRoleVersion, DbUserStatus as UserStatus,
DbWebhookDeliveryAttempt as WebhookDeliveryAttempt,
};
}
pub use common_enums::*;
use common_utils::pii;
use diesel::{deserialize::FromSqlRow, expression::AsExpression, sql_types::Jsonb};
use router_derive::diesel_enum;
use time::PrimitiveDateTime;
#[derive(
Clone,
Copy,
Debug,
Eq,
PartialEq,
serde::Deserialize,
serde::Serialize,
strum::Display,
strum::EnumString,
)]
#[diesel_enum(storage_type = "db_enum")]
#[serde(rename_all = "snake_case")]
#[strum(serialize_all = "snake_case")]
pub enum RoutingAlgorithmKind {
Single,
Priority,
VolumeSplit,
Advanced,
Dynamic,
}
#[derive(
Clone,
Copy,
Debug,
Eq,
PartialEq,
serde::Deserialize,
serde::Serialize,
strum::Display,
strum::EnumString,
)]
#[diesel_enum(storage_type = "db_enum")]
#[serde(rename_all = "snake_case")]
#[strum(serialize_all = "snake_case")]
pub enum EventObjectType {
PaymentDetails,
RefundDetails,
DisputeDetails,
MandateDetails,
PayoutDetails,
}
// Refund
#[derive(
Clone,
Copy,
Debug,
Default,
Eq,
PartialEq,
serde::Serialize,
serde::Deserialize,
strum::Display,
strum::EnumString,
)]
#[diesel_enum(storage_type = "db_enum")]
#[strum(serialize_all = "snake_case")]
#[serde(rename_all = "snake_case")]
pub enum RefundType {
InstantRefund,
#[default]
RegularRefund,
RetryRefund,
}
// Mandate
#[derive(
Clone,
Copy,
Debug,
Eq,
PartialEq,
Default,
serde::Deserialize,
serde::Serialize,
strum::Display,
strum::EnumString,
)]
#[diesel_enum(storage_type = "db_enum")]
#[serde(rename_all = "snake_case")]
#[strum(serialize_all = "snake_case")]
pub enum MandateType {
SingleUse,
#[default]
MultiUse,
}
#[derive(
serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, FromSqlRow, AsExpression,
)]
#[diesel(sql_type = Jsonb)]
#[serde(rename_all = "snake_case")]
pub struct MandateDetails {
pub update_mandate_id: Option<String>,
}
common_utils::impl_to_sql_from_sql_json!(MandateDetails);
#[derive(
serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, FromSqlRow, AsExpression,
)]
#[diesel(sql_type = Jsonb)]
#[serde(rename_all = "snake_case")]
pub enum MandateDataType {
SingleUse(MandateAmountData),
MultiUse(Option<MandateAmountData>),
}
common_utils::impl_to_sql_from_sql_json!(MandateDataType);
#[derive(Clone, Debug, serde::Serialize, serde::Deserialize, PartialEq, Eq)]
pub struct MandateAmountData {
pub amount: common_utils::types::MinorUnit,
pub currency: Currency,
pub start_date: Option<PrimitiveDateTime>,
pub end_date: Option<PrimitiveDateTime>,
pub metadata: Option<pii::SecretSerdeValue>,
}
#[derive(
Clone,
Copy,
Debug,
Eq,
PartialEq,
serde::Serialize,
serde::Deserialize,
strum::Display,
strum::EnumString,
)]
#[diesel_enum(storage_type = "db_enum")]
#[serde(rename_all = "snake_case")]
#[strum(serialize_all = "snake_case")]
pub enum FraudCheckType {
PreFrm,
PostFrm,
}
#[derive(
Clone,
Copy,
Debug,
Default,
Eq,
PartialEq,
serde::Serialize,
serde::Deserialize,
strum::Display,
strum::EnumString,
)]
#[diesel_enum(storage_type = "text")]
#[strum(serialize_all = "snake_case")]
pub enum FraudCheckLastStep {
#[default]
Processing,
CheckoutOrSale,
TransactionOrRecordRefund,
Fulfillment,
}
#[derive(
Clone,
Copy,
Debug,
Default,
Eq,
PartialEq,
serde::Serialize,
serde::Deserialize,
strum::Display,
strum::EnumString,
)]
#[diesel_enum(storage_type = "db_enum")]
#[serde(rename_all = "snake_case")]
#[strum(serialize_all = "snake_case")]
pub enum UserStatus {
Active,
#[default]
InvitationSent,
}
#[derive(
Clone,
Copy,
Debug,
Eq,
PartialEq,
serde::Deserialize,
serde::Serialize,
strum::Display,
strum::EnumString,
)]
#[router_derive::diesel_enum(storage_type = "db_enum")]
#[serde(rename_all = "snake_case")]
#[strum(serialize_all = "snake_case")]
pub enum DashboardMetadata {
ProductionAgreement,
SetupProcessor,
ConfigureEndpoint,
SetupComplete,
FirstProcessorConnected,
SecondProcessorConnected,
ConfiguredRouting,
TestPayment,
IntegrationMethod,
ConfigurationType,
IntegrationCompleted,
StripeConnected,
PaypalConnected,
SpRoutingConfigured,
Feedback,
ProdIntent,
SpTestPayment,
DownloadWoocom,
ConfigureWoocom,
SetupWoocomWebhook,
IsMultipleConfiguration,
IsChangePasswordRequired,
OnboardingSurvey,
ReconStatus,
}
#[derive(
Clone,
Copy,
Debug,
Default,
Eq,
PartialEq,
serde::Serialize,
serde::Deserialize,
strum::Display,
strum::EnumString,
)]
#[diesel_enum(storage_type = "db_enum")]
#[serde(rename_all = "snake_case")]
#[strum(serialize_all = "snake_case")]
pub enum TotpStatus {
Set,
InProgress,
#[default]
NotSet,
}
#[derive(
Clone,
Copy,
Debug,
Default,
Eq,
PartialEq,
serde::Serialize,
serde::Deserialize,
strum::EnumString,
strum::Display,
)]
#[diesel_enum(storage_type = "db_enum")]
#[serde(rename_all = "snake_case")]
#[strum(serialize_all = "snake_case")]
pub enum UserRoleVersion {
#[default]
V1,
V2,
}
<file_sep path="hyperswitch/crates/diesel_models/src/enums.rs" crate="diesel_models" role="use_site">
#[doc(hidden)]
pub mod diesel_exports {
pub use super::{
DbApiVersion as ApiVersion, DbAttemptStatus as AttemptStatus,
DbAuthenticationType as AuthenticationType, DbBlocklistDataKind as BlocklistDataKind,
DbCaptureMethod as CaptureMethod, DbCaptureStatus as CaptureStatus,
DbCardDiscovery as CardDiscovery, DbConnectorStatus as ConnectorStatus,
DbConnectorType as ConnectorType, DbCountryAlpha2 as CountryAlpha2, DbCurrency as Currency,
DbDashboardMetadata as DashboardMetadata, DbDeleteStatus as DeleteStatus,
DbDisputeStage as DisputeStage, DbDisputeStatus as DisputeStatus,
DbEventClass as EventClass, DbEventObjectType as EventObjectType, DbEventType as EventType,
DbFraudCheckStatus as FraudCheckStatus, DbFraudCheckType as FraudCheckType,
DbFutureUsage as FutureUsage, DbGenericLinkType as GenericLinkType,
DbIntentStatus as IntentStatus, DbMandateStatus as MandateStatus,
DbMandateType as MandateType, DbMerchantStorageScheme as MerchantStorageScheme,
DbOrderFulfillmentTimeOrigin as OrderFulfillmentTimeOrigin,
DbPaymentMethodIssuerCode as PaymentMethodIssuerCode, DbPaymentSource as PaymentSource,
DbPaymentType as PaymentType, DbPayoutStatus as PayoutStatus, DbPayoutType as PayoutType,
DbProcessTrackerStatus as ProcessTrackerStatus, DbReconStatus as ReconStatus,
DbRefundStatus as RefundStatus, DbRefundType as RefundType, DbRelayStatus as RelayStatus,
DbRelayType as RelayType,
DbRequestIncrementalAuthorization as RequestIncrementalAuthorization,
DbRoleScope as RoleScope, DbRoutingAlgorithmKind as RoutingAlgorithmKind,
DbScaExemptionType as ScaExemptionType,
DbSuccessBasedRoutingConclusiveState as SuccessBasedRoutingConclusiveState,
DbTotpStatus as TotpStatus, DbTransactionType as TransactionType,
DbUserRoleVersion as UserRoleVersion, DbUserStatus as UserStatus,
DbWebhookDeliveryAttempt as WebhookDeliveryAttempt,
};
}
pub use common_enums::*;
use common_utils::pii;
use diesel::{deserialize::FromSqlRow, expression::AsExpression, sql_types::Jsonb};
use router_derive::diesel_enum;
use time::PrimitiveDateTime;
#[derive(
Clone,
Copy,
Debug,
Eq,
PartialEq,
serde::Deserialize,
serde::Serialize,
strum::Display,
strum::EnumString,
)]
#[diesel_enum(storage_type = "db_enum")]
#[serde(rename_all = "snake_case")]
#[strum(serialize_all = "snake_case")]
pub enum RoutingAlgorithmKind {
Single,
Priority,
VolumeSplit,
Advanced,
Dynamic,
}
#[derive(
Clone,
Copy,
Debug,
Eq,
PartialEq,
serde::Deserialize,
serde::Serialize,
strum::Display,
strum::EnumString,
)]
#[diesel_enum(storage_type = "db_enum")]
#[serde(rename_all = "snake_case")]
#[strum(serialize_all = "snake_case")]
pub enum EventObjectType {
PaymentDetails,
RefundDetails,
DisputeDetails,
MandateDetails,
PayoutDetails,
}
// Refund
#[derive(
Clone,
Copy,
Debug,
Default,
Eq,
PartialEq,
serde::Serialize,
serde::Deserialize,
strum::Display,
strum::EnumString,
)]
#[diesel_enum(storage_type = "db_enum")]
#[strum(serialize_all = "snake_case")]
#[serde(rename_all = "snake_case")]
pub enum RefundType {
InstantRefund,
#[default]
RegularRefund,
RetryRefund,
}
// Mandate
#[derive(
Clone,
Copy,
Debug,
Eq,
PartialEq,
Default,
serde::Deserialize,
serde::Serialize,
strum::Display,
strum::EnumString,
)]
#[diesel_enum(storage_type = "db_enum")]
#[serde(rename_all = "snake_case")]
#[strum(serialize_all = "snake_case")]
pub enum MandateType {
SingleUse,
#[default]
MultiUse,
}
#[derive(
serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, FromSqlRow, AsExpression,
)]
#[diesel(sql_type = Jsonb)]
#[serde(rename_all = "snake_case")]
pub struct MandateDetails {
pub update_mandate_id: Option<String>,
}
common_utils::impl_to_sql_from_sql_json!(MandateDetails);
#[derive(
serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, FromSqlRow, AsExpression,
)]
#[diesel(sql_type = Jsonb)]
#[serde(rename_all = "snake_case")]
pub enum MandateDataType {
SingleUse(MandateAmountData),
MultiUse(Option<MandateAmountData>),
}
common_utils::impl_to_sql_from_sql_json!(MandateDataType);
#[derive(Clone, Debug, serde::Serialize, serde::Deserialize, PartialEq, Eq)]
pub struct MandateAmountData {
pub amount: common_utils::types::MinorUnit,
pub currency: Currency,
pub start_date: Option<PrimitiveDateTime>,
pub end_date: Option<PrimitiveDateTime>,
pub metadata: Option<pii::SecretSerdeValue>,
}
#[derive(
Clone,
Copy,
Debug,
Eq,
PartialEq,
serde::Serialize,
serde::Deserialize,
strum::Display,
strum::EnumString,
)]
#[diesel_enum(storage_type = "db_enum")]
#[serde(rename_all = "snake_case")]
#[strum(serialize_all = "snake_case")]
pub enum FraudCheckType {
PreFrm,
PostFrm,
}
#[derive(
Clone,
Copy,
Debug,
Default,
Eq,
PartialEq,
serde::Serialize,
serde::Deserialize,
strum::Display,
strum::EnumString,
)]
#[diesel_enum(storage_type = "text")]
#[strum(serialize_all = "snake_case")]
pub enum FraudCheckLastStep {
#[default]
Processing,
CheckoutOrSale,
TransactionOrRecordRefund,
Fulfillment,
}
#[derive(
Clone,
Copy,
Debug,
Default,
Eq,
PartialEq,
serde::Serialize,
serde::Deserialize,
strum::Display,
strum::EnumString,
)]
#[diesel_enum(storage_type = "db_enum")]
#[serde(rename_all = "snake_case")]
#[strum(serialize_all = "snake_case")]
pub enum UserStatus {
Active,
#[default]
InvitationSent,
}
#[derive(
Clone,
Copy,
Debug,
Eq,
PartialEq,
serde::Deserialize,
serde::Serialize,
strum::Display,
strum::EnumString,
)]
#[router_derive::diesel_enum(storage_type = "db_enum")]
#[serde(rename_all = "snake_case")]
#[strum(serialize_all = "snake_case")]
pub enum DashboardMetadata {
ProductionAgreement,
SetupProcessor,
ConfigureEndpoint,
SetupComplete,
FirstProcessorConnected,
SecondProcessorConnected,
ConfiguredRouting,
TestPayment,
IntegrationMethod,
ConfigurationType,
IntegrationCompleted,
StripeConnected,
PaypalConnected,
SpRoutingConfigured,
Feedback,
ProdIntent,
SpTestPayment,
DownloadWoocom,
ConfigureWoocom,
SetupWoocomWebhook,
IsMultipleConfiguration,
IsChangePasswordRequired,
OnboardingSurvey,
ReconStatus,
}
#[derive(
Clone,
Copy,
Debug,
Default,
Eq,
PartialEq,
serde::Serialize,
serde::Deserialize,
strum::Display,
strum::EnumString,
)]
#[diesel_enum(storage_type = "db_enum")]
#[serde(rename_all = "snake_case")]
#[strum(serialize_all = "snake_case")]
pub enum TotpStatus {
Set,
InProgress,
#[default]
NotSet,
}
#[derive(
Clone,
Copy,
Debug,
Default,
Eq,
PartialEq,
serde::Serialize,
serde::Deserialize,
strum::EnumString,
strum::Display,
)]
#[diesel_enum(storage_type = "db_enum")]
#[serde(rename_all = "snake_case")]
#[strum(serialize_all = "snake_case")]
pub enum UserRoleVersion {
#[default]
V1,
V2,
}
<file_sep path="hyperswitch/crates/router_derive/src/lib.rs" crate="router_derive" role="macro_def">
<|fim_prefix|>
<|meta_start|><|file|> hyperswitch/crates/router_derive/src/lib.rs<|crate|> diesel_models macro=DieselEnum roles=use_site,macro_def use=attribute item=file pack=proc_macro_neighborhoods lang=rust<|meta_end|>
pub fn diesel_enum_derive(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
<|fim_suffix|>
<|fim_middle|>
}
<file_sep path="hyperswitch/crates/router_derive/src/lib.rs" crate="router_derive" role="macro_def">
<|fim_prefix|>
pub fn diesel_enum_derive(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
<|fim_suffix|>
<|fim_middle|>
}
| proc_macro_neighborhoods |
<file_sep path="hyperswitch/crates/diesel_models/src/enums.rs" crate="diesel_models" role="use_site">
#[doc(hidden)]
pub mod diesel_exports {
pub use super::{
DbApiVersion as ApiVersion, DbAttemptStatus as AttemptStatus,
DbAuthenticationType as AuthenticationType, DbBlocklistDataKind as BlocklistDataKind,
DbCaptureMethod as CaptureMethod, DbCaptureStatus as CaptureStatus,
DbCardDiscovery as CardDiscovery, DbConnectorStatus as ConnectorStatus,
DbConnectorType as ConnectorType, DbCountryAlpha2 as CountryAlpha2, DbCurrency as Currency,
DbDashboardMetadata as DashboardMetadata, DbDeleteStatus as DeleteStatus,
DbDisputeStage as DisputeStage, DbDisputeStatus as DisputeStatus,
DbEventClass as EventClass, DbEventObjectType as EventObjectType, DbEventType as EventType,
DbFraudCheckStatus as FraudCheckStatus, DbFraudCheckType as FraudCheckType,
DbFutureUsage as FutureUsage, DbGenericLinkType as GenericLinkType,
DbIntentStatus as IntentStatus, DbMandateStatus as MandateStatus,
DbMandateType as MandateType, DbMerchantStorageScheme as MerchantStorageScheme,
DbOrderFulfillmentTimeOrigin as OrderFulfillmentTimeOrigin,
DbPaymentMethodIssuerCode as PaymentMethodIssuerCode, DbPaymentSource as PaymentSource,
DbPaymentType as PaymentType, DbPayoutStatus as PayoutStatus, DbPayoutType as PayoutType,
DbProcessTrackerStatus as ProcessTrackerStatus, DbReconStatus as ReconStatus,
DbRefundStatus as RefundStatus, DbRefundType as RefundType, DbRelayStatus as RelayStatus,
DbRelayType as RelayType,
DbRequestIncrementalAuthorization as RequestIncrementalAuthorization,
DbRoleScope as RoleScope, DbRoutingAlgorithmKind as RoutingAlgorithmKind,
DbScaExemptionType as ScaExemptionType,
DbSuccessBasedRoutingConclusiveState as SuccessBasedRoutingConclusiveState,
DbTotpStatus as TotpStatus, DbTransactionType as TransactionType,
DbUserRoleVersion as UserRoleVersion, DbUserStatus as UserStatus,
DbWebhookDeliveryAttempt as WebhookDeliveryAttempt,
};
}
pub use common_enums::*;
use common_utils::pii;
use diesel::{deserialize::FromSqlRow, expression::AsExpression, sql_types::Jsonb};
use router_derive::diesel_enum;
use time::PrimitiveDateTime;
#[derive(
Clone,
Copy,
Debug,
Eq,
PartialEq,
serde::Deserialize,
serde::Serialize,
strum::Display,
strum::EnumString,
)]
#[diesel_enum(storage_type = "db_enum")]
#[serde(rename_all = "snake_case")]
#[strum(serialize_all = "snake_case")]
pub enum RoutingAlgorithmKind {
Single,
Priority,
VolumeSplit,
Advanced,
Dynamic,
}
#[derive(
Clone,
Copy,
Debug,
Eq,
PartialEq,
serde::Deserialize,
serde::Serialize,
strum::Display,
strum::EnumString,
)]
#[diesel_enum(storage_type = "db_enum")]
#[serde(rename_all = "snake_case")]
#[strum(serialize_all = "snake_case")]
pub enum EventObjectType {
PaymentDetails,
RefundDetails,
DisputeDetails,
MandateDetails,
PayoutDetails,
}
// Refund
#[derive(
Clone,
Copy,
Debug,
Default,
Eq,
PartialEq,
serde::Serialize,
serde::Deserialize,
strum::Display,
strum::EnumString,
)]
#[diesel_enum(storage_type = "db_enum")]
#[strum(serialize_all = "snake_case")]
#[serde(rename_all = "snake_case")]
pub enum RefundType {
InstantRefund,
#[default]
RegularRefund,
RetryRefund,
}
// Mandate
#[derive(
Clone,
Copy,
Debug,
Eq,
PartialEq,
Default,
serde::Deserialize,
serde::Serialize,
strum::Display,
strum::EnumString,
)]
#[diesel_enum(storage_type = "db_enum")]
#[serde(rename_all = "snake_case")]
#[strum(serialize_all = "snake_case")]
pub enum MandateType {
SingleUse,
#[default]
MultiUse,
}
#[derive(
serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, FromSqlRow, AsExpression,
)]
#[diesel(sql_type = Jsonb)]
#[serde(rename_all = "snake_case")]
pub struct MandateDetails {
pub update_mandate_id: Option<String>,
}
common_utils::impl_to_sql_from_sql_json!(MandateDetails);
#[derive(
serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, FromSqlRow, AsExpression,
)]
#[diesel(sql_type = Jsonb)]
#[serde(rename_all = "snake_case")]
pub enum MandateDataType {
SingleUse(MandateAmountData),
MultiUse(Option<MandateAmountData>),
}
common_utils::impl_to_sql_from_sql_json!(MandateDataType);
#[derive(Clone, Debug, serde::Serialize, serde::Deserialize, PartialEq, Eq)]
pub struct MandateAmountData {
pub amount: common_utils::types::MinorUnit,
pub currency: Currency,
pub start_date: Option<PrimitiveDateTime>,
pub end_date: Option<PrimitiveDateTime>,
pub metadata: Option<pii::SecretSerdeValue>,
}
#[derive(
Clone,
Copy,
Debug,
Eq,
PartialEq,
serde::Serialize,
serde::Deserialize,
strum::Display,
strum::EnumString,
)]
#[diesel_enum(storage_type = "db_enum")]
#[serde(rename_all = "snake_case")]
#[strum(serialize_all = "snake_case")]
pub enum FraudCheckType {
PreFrm,
PostFrm,
}
#[derive(
Clone,
Copy,
Debug,
Default,
Eq,
PartialEq,
serde::Serialize,
serde::Deserialize,
strum::Display,
strum::EnumString,
)]
#[diesel_enum(storage_type = "text")]
#[strum(serialize_all = "snake_case")]
pub enum FraudCheckLastStep {
#[default]
Processing,
CheckoutOrSale,
TransactionOrRecordRefund,
Fulfillment,
}
#[derive(
Clone,
Copy,
Debug,
Default,
Eq,
PartialEq,
serde::Serialize,
serde::Deserialize,
strum::Display,
strum::EnumString,
)]
#[diesel_enum(storage_type = "db_enum")]
#[serde(rename_all = "snake_case")]
#[strum(serialize_all = "snake_case")]
pub enum UserStatus {
Active,
#[default]
InvitationSent,
}
#[derive(
Clone,
Copy,
Debug,
Eq,
PartialEq,
serde::Deserialize,
serde::Serialize,
strum::Display,
strum::EnumString,
)]
#[router_derive::diesel_enum(storage_type = "db_enum")]
#[serde(rename_all = "snake_case")]
#[strum(serialize_all = "snake_case")]
pub enum DashboardMetadata {
ProductionAgreement,
SetupProcessor,
ConfigureEndpoint,
SetupComplete,
FirstProcessorConnected,
SecondProcessorConnected,
ConfiguredRouting,
TestPayment,
IntegrationMethod,
ConfigurationType,
IntegrationCompleted,
StripeConnected,
PaypalConnected,
SpRoutingConfigured,
Feedback,
ProdIntent,
SpTestPayment,
DownloadWoocom,
ConfigureWoocom,
SetupWoocomWebhook,
IsMultipleConfiguration,
IsChangePasswordRequired,
OnboardingSurvey,
ReconStatus,
}
#[derive(
Clone,
Copy,
Debug,
Default,
Eq,
PartialEq,
serde::Serialize,
serde::Deserialize,
strum::Display,
strum::EnumString,
)]
#[diesel_enum(storage_type = "db_enum")]
#[serde(rename_all = "snake_case")]
#[strum(serialize_all = "snake_case")]
pub enum TotpStatus {
Set,
InProgress,
#[default]
NotSet,
}
#[derive(
Clone,
Copy,
Debug,
Default,
Eq,
PartialEq,
serde::Serialize,
serde::Deserialize,
strum::EnumString,
strum::Display,
)]
#[diesel_enum(storage_type = "db_enum")]
#[serde(rename_all = "snake_case")]
#[strum(serialize_all = "snake_case")]
pub enum UserRoleVersion {
#[default]
V1,
V2,
}
<file_sep path="hyperswitch/crates/diesel_models/src/enums.rs" crate="diesel_models" role="use_site">
#[doc(hidden)]
pub mod diesel_exports {
pub use super::{
DbApiVersion as ApiVersion, DbAttemptStatus as AttemptStatus,
DbAuthenticationType as AuthenticationType, DbBlocklistDataKind as BlocklistDataKind,
DbCaptureMethod as CaptureMethod, DbCaptureStatus as CaptureStatus,
DbCardDiscovery as CardDiscovery, DbConnectorStatus as ConnectorStatus,
DbConnectorType as ConnectorType, DbCountryAlpha2 as CountryAlpha2, DbCurrency as Currency,
DbDashboardMetadata as DashboardMetadata, DbDeleteStatus as DeleteStatus,
DbDisputeStage as DisputeStage, DbDisputeStatus as DisputeStatus,
DbEventClass as EventClass, DbEventObjectType as EventObjectType, DbEventType as EventType,
DbFraudCheckStatus as FraudCheckStatus, DbFraudCheckType as FraudCheckType,
DbFutureUsage as FutureUsage, DbGenericLinkType as GenericLinkType,
DbIntentStatus as IntentStatus, DbMandateStatus as MandateStatus,
DbMandateType as MandateType, DbMerchantStorageScheme as MerchantStorageScheme,
DbOrderFulfillmentTimeOrigin as OrderFulfillmentTimeOrigin,
DbPaymentMethodIssuerCode as PaymentMethodIssuerCode, DbPaymentSource as PaymentSource,
DbPaymentType as PaymentType, DbPayoutStatus as PayoutStatus, DbPayoutType as PayoutType,
DbProcessTrackerStatus as ProcessTrackerStatus, DbReconStatus as ReconStatus,
DbRefundStatus as RefundStatus, DbRefundType as RefundType, DbRelayStatus as RelayStatus,
DbRelayType as RelayType,
DbRequestIncrementalAuthorization as RequestIncrementalAuthorization,
DbRoleScope as RoleScope, DbRoutingAlgorithmKind as RoutingAlgorithmKind,
DbScaExemptionType as ScaExemptionType,
DbSuccessBasedRoutingConclusiveState as SuccessBasedRoutingConclusiveState,
DbTotpStatus as TotpStatus, DbTransactionType as TransactionType,
DbUserRoleVersion as UserRoleVersion, DbUserStatus as UserStatus,
DbWebhookDeliveryAttempt as WebhookDeliveryAttempt,
};
}
pub use common_enums::*;
use common_utils::pii;
use diesel::{deserialize::FromSqlRow, expression::AsExpression, sql_types::Jsonb};
use router_derive::diesel_enum;
use time::PrimitiveDateTime;
#[derive(
Clone,
Copy,
Debug,
Eq,
PartialEq,
serde::Deserialize,
serde::Serialize,
strum::Display,
strum::EnumString,
)]
#[diesel_enum(storage_type = "db_enum")]
#[serde(rename_all = "snake_case")]
#[strum(serialize_all = "snake_case")]
pub enum RoutingAlgorithmKind {
Single,
Priority,
VolumeSplit,
Advanced,
Dynamic,
}
#[derive(
Clone,
Copy,
Debug,
Eq,
PartialEq,
serde::Deserialize,
serde::Serialize,
strum::Display,
strum::EnumString,
)]
#[diesel_enum(storage_type = "db_enum")]
#[serde(rename_all = "snake_case")]
#[strum(serialize_all = "snake_case")]
pub enum EventObjectType {
PaymentDetails,
RefundDetails,
DisputeDetails,
MandateDetails,
PayoutDetails,
}
// Refund
#[derive(
Clone,
Copy,
Debug,
Default,
Eq,
PartialEq,
serde::Serialize,
serde::Deserialize,
strum::Display,
strum::EnumString,
)]
#[diesel_enum(storage_type = "db_enum")]
#[strum(serialize_all = "snake_case")]
#[serde(rename_all = "snake_case")]
pub enum RefundType {
InstantRefund,
#[default]
RegularRefund,
RetryRefund,
}
// Mandate
#[derive(
Clone,
Copy,
Debug,
Eq,
PartialEq,
Default,
serde::Deserialize,
serde::Serialize,
strum::Display,
strum::EnumString,
)]
#[diesel_enum(storage_type = "db_enum")]
#[serde(rename_all = "snake_case")]
#[strum(serialize_all = "snake_case")]
pub enum MandateType {
SingleUse,
#[default]
MultiUse,
}
#[derive(
serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, FromSqlRow, AsExpression,
)]
#[diesel(sql_type = Jsonb)]
#[serde(rename_all = "snake_case")]
pub struct MandateDetails {
pub update_mandate_id: Option<String>,
}
common_utils::impl_to_sql_from_sql_json!(MandateDetails);
#[derive(
serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, FromSqlRow, AsExpression,
)]
#[diesel(sql_type = Jsonb)]
#[serde(rename_all = "snake_case")]
pub enum MandateDataType {
SingleUse(MandateAmountData),
MultiUse(Option<MandateAmountData>),
}
common_utils::impl_to_sql_from_sql_json!(MandateDataType);
#[derive(Clone, Debug, serde::Serialize, serde::Deserialize, PartialEq, Eq)]
pub struct MandateAmountData {
pub amount: common_utils::types::MinorUnit,
pub currency: Currency,
pub start_date: Option<PrimitiveDateTime>,
pub end_date: Option<PrimitiveDateTime>,
pub metadata: Option<pii::SecretSerdeValue>,
}
#[derive(
Clone,
Copy,
Debug,
Eq,
PartialEq,
serde::Serialize,
serde::Deserialize,
strum::Display,
strum::EnumString,
)]
#[diesel_enum(storage_type = "db_enum")]
#[serde(rename_all = "snake_case")]
#[strum(serialize_all = "snake_case")]
pub enum FraudCheckType {
PreFrm,
PostFrm,
}
#[derive(
Clone,
Copy,
Debug,
Default,
Eq,
PartialEq,
serde::Serialize,
serde::Deserialize,
strum::Display,
strum::EnumString,
)]
#[diesel_enum(storage_type = "text")]
#[strum(serialize_all = "snake_case")]
pub enum FraudCheckLastStep {
#[default]
Processing,
CheckoutOrSale,
TransactionOrRecordRefund,
Fulfillment,
}
#[derive(
Clone,
Copy,
Debug,
Default,
Eq,
PartialEq,
serde::Serialize,
serde::Deserialize,
strum::Display,
strum::EnumString,
)]
#[diesel_enum(storage_type = "db_enum")]
#[serde(rename_all = "snake_case")]
#[strum(serialize_all = "snake_case")]
pub enum UserStatus {
Active,
#[default]
InvitationSent,
}
#[derive(
Clone,
Copy,
Debug,
Eq,
PartialEq,
serde::Deserialize,
serde::Serialize,
strum::Display,
strum::EnumString,
)]
#[router_derive::diesel_enum(storage_type = "db_enum")]
#[serde(rename_all = "snake_case")]
#[strum(serialize_all = "snake_case")]
pub enum DashboardMetadata {
ProductionAgreement,
SetupProcessor,
ConfigureEndpoint,
SetupComplete,
FirstProcessorConnected,
SecondProcessorConnected,
ConfiguredRouting,
TestPayment,
IntegrationMethod,
ConfigurationType,
IntegrationCompleted,
StripeConnected,
PaypalConnected,
SpRoutingConfigured,
Feedback,
ProdIntent,
SpTestPayment,
DownloadWoocom,
ConfigureWoocom,
SetupWoocomWebhook,
IsMultipleConfiguration,
IsChangePasswordRequired,
OnboardingSurvey,
ReconStatus,
}
#[derive(
Clone,
Copy,
Debug,
Default,
Eq,
PartialEq,
serde::Serialize,
serde::Deserialize,
strum::Display,
strum::EnumString,
)]
#[diesel_enum(storage_type = "db_enum")]
#[serde(rename_all = "snake_case")]
#[strum(serialize_all = "snake_case")]
pub enum TotpStatus {
Set,
InProgress,
#[default]
NotSet,
}
#[derive(
Clone,
Copy,
Debug,
Default,
Eq,
PartialEq,
serde::Serialize,
serde::Deserialize,
strum::EnumString,
strum::Display,
)]
#[diesel_enum(storage_type = "db_enum")]
#[serde(rename_all = "snake_case")]
#[strum(serialize_all = "snake_case")]
pub enum UserRoleVersion {
#[default]
V1,
V2,
}
<file_sep path="hyperswitch/crates/router_derive/src/lib.rs" crate="router_derive" role="macro_def">
<|fim_prefix|>
<|meta_start|><|file|> hyperswitch/crates/router_derive/src/lib.rs<|crate|> diesel_models macro=DieselEnum roles=use_site,macro_def use=attribute item=file pack=proc_macro_neighborhoods lang=rust<|meta_end|>
pub fn diesel_enum_derive(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
<|fim_suffix|>
<|fim_middle|>
}
<file_sep path="hyperswitch/crates/router_derive/src/lib.rs" crate="router_derive" role="macro_def">
<|fim_prefix|>
pub fn diesel_enum_derive(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
<|fim_suffix|>
<|fim_middle|>
}
| proc_macro_neighborhoods |
<file_sep path="hyperswitch/crates/diesel_models/src/enums.rs" crate="diesel_models" role="use_site">
#[doc(hidden)]
pub mod diesel_exports {
pub use super::{
DbApiVersion as ApiVersion, DbAttemptStatus as AttemptStatus,
DbAuthenticationType as AuthenticationType, DbBlocklistDataKind as BlocklistDataKind,
DbCaptureMethod as CaptureMethod, DbCaptureStatus as CaptureStatus,
DbCardDiscovery as CardDiscovery, DbConnectorStatus as ConnectorStatus,
DbConnectorType as ConnectorType, DbCountryAlpha2 as CountryAlpha2, DbCurrency as Currency,
DbDashboardMetadata as DashboardMetadata, DbDeleteStatus as DeleteStatus,
DbDisputeStage as DisputeStage, DbDisputeStatus as DisputeStatus,
DbEventClass as EventClass, DbEventObjectType as EventObjectType, DbEventType as EventType,
DbFraudCheckStatus as FraudCheckStatus, DbFraudCheckType as FraudCheckType,
DbFutureUsage as FutureUsage, DbGenericLinkType as GenericLinkType,
DbIntentStatus as IntentStatus, DbMandateStatus as MandateStatus,
DbMandateType as MandateType, DbMerchantStorageScheme as MerchantStorageScheme,
DbOrderFulfillmentTimeOrigin as OrderFulfillmentTimeOrigin,
DbPaymentMethodIssuerCode as PaymentMethodIssuerCode, DbPaymentSource as PaymentSource,
DbPaymentType as PaymentType, DbPayoutStatus as PayoutStatus, DbPayoutType as PayoutType,
DbProcessTrackerStatus as ProcessTrackerStatus, DbReconStatus as ReconStatus,
DbRefundStatus as RefundStatus, DbRefundType as RefundType, DbRelayStatus as RelayStatus,
DbRelayType as RelayType,
DbRequestIncrementalAuthorization as RequestIncrementalAuthorization,
DbRoleScope as RoleScope, DbRoutingAlgorithmKind as RoutingAlgorithmKind,
DbScaExemptionType as ScaExemptionType,
DbSuccessBasedRoutingConclusiveState as SuccessBasedRoutingConclusiveState,
DbTotpStatus as TotpStatus, DbTransactionType as TransactionType,
DbUserRoleVersion as UserRoleVersion, DbUserStatus as UserStatus,
DbWebhookDeliveryAttempt as WebhookDeliveryAttempt,
};
}
pub use common_enums::*;
use common_utils::pii;
use diesel::{deserialize::FromSqlRow, expression::AsExpression, sql_types::Jsonb};
use router_derive::diesel_enum;
use time::PrimitiveDateTime;
#[derive(
Clone,
Copy,
Debug,
Eq,
PartialEq,
serde::Deserialize,
serde::Serialize,
strum::Display,
strum::EnumString,
)]
#[diesel_enum(storage_type = "db_enum")]
#[serde(rename_all = "snake_case")]
#[strum(serialize_all = "snake_case")]
pub enum RoutingAlgorithmKind {
Single,
Priority,
VolumeSplit,
Advanced,
Dynamic,
}
#[derive(
Clone,
Copy,
Debug,
Eq,
PartialEq,
serde::Deserialize,
serde::Serialize,
strum::Display,
strum::EnumString,
)]
#[diesel_enum(storage_type = "db_enum")]
#[serde(rename_all = "snake_case")]
#[strum(serialize_all = "snake_case")]
pub enum EventObjectType {
PaymentDetails,
RefundDetails,
DisputeDetails,
MandateDetails,
PayoutDetails,
}
// Refund
#[derive(
Clone,
Copy,
Debug,
Default,
Eq,
PartialEq,
serde::Serialize,
serde::Deserialize,
strum::Display,
strum::EnumString,
)]
#[diesel_enum(storage_type = "db_enum")]
#[strum(serialize_all = "snake_case")]
#[serde(rename_all = "snake_case")]
pub enum RefundType {
InstantRefund,
#[default]
RegularRefund,
RetryRefund,
}
// Mandate
#[derive(
Clone,
Copy,
Debug,
Eq,
PartialEq,
Default,
serde::Deserialize,
serde::Serialize,
strum::Display,
strum::EnumString,
)]
#[diesel_enum(storage_type = "db_enum")]
#[serde(rename_all = "snake_case")]
#[strum(serialize_all = "snake_case")]
pub enum MandateType {
SingleUse,
#[default]
MultiUse,
}
#[derive(
serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, FromSqlRow, AsExpression,
)]
#[diesel(sql_type = Jsonb)]
#[serde(rename_all = "snake_case")]
pub struct MandateDetails {
pub update_mandate_id: Option<String>,
}
common_utils::impl_to_sql_from_sql_json!(MandateDetails);
#[derive(
serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, FromSqlRow, AsExpression,
)]
#[diesel(sql_type = Jsonb)]
#[serde(rename_all = "snake_case")]
pub enum MandateDataType {
SingleUse(MandateAmountData),
MultiUse(Option<MandateAmountData>),
}
common_utils::impl_to_sql_from_sql_json!(MandateDataType);
#[derive(Clone, Debug, serde::Serialize, serde::Deserialize, PartialEq, Eq)]
pub struct MandateAmountData {
pub amount: common_utils::types::MinorUnit,
pub currency: Currency,
pub start_date: Option<PrimitiveDateTime>,
pub end_date: Option<PrimitiveDateTime>,
pub metadata: Option<pii::SecretSerdeValue>,
}
#[derive(
Clone,
Copy,
Debug,
Eq,
PartialEq,
serde::Serialize,
serde::Deserialize,
strum::Display,
strum::EnumString,
)]
#[diesel_enum(storage_type = "db_enum")]
#[serde(rename_all = "snake_case")]
#[strum(serialize_all = "snake_case")]
pub enum FraudCheckType {
PreFrm,
PostFrm,
}
#[derive(
Clone,
Copy,
Debug,
Default,
Eq,
PartialEq,
serde::Serialize,
serde::Deserialize,
strum::Display,
strum::EnumString,
)]
#[diesel_enum(storage_type = "text")]
#[strum(serialize_all = "snake_case")]
pub enum FraudCheckLastStep {
#[default]
Processing,
CheckoutOrSale,
TransactionOrRecordRefund,
Fulfillment,
}
#[derive(
Clone,
Copy,
Debug,
Default,
Eq,
PartialEq,
serde::Serialize,
serde::Deserialize,
strum::Display,
strum::EnumString,
)]
#[diesel_enum(storage_type = "db_enum")]
#[serde(rename_all = "snake_case")]
#[strum(serialize_all = "snake_case")]
pub enum UserStatus {
Active,
#[default]
InvitationSent,
}
#[derive(
Clone,
Copy,
Debug,
Eq,
PartialEq,
serde::Deserialize,
serde::Serialize,
strum::Display,
strum::EnumString,
)]
#[router_derive::diesel_enum(storage_type = "db_enum")]
#[serde(rename_all = "snake_case")]
#[strum(serialize_all = "snake_case")]
pub enum DashboardMetadata {
ProductionAgreement,
SetupProcessor,
ConfigureEndpoint,
SetupComplete,
FirstProcessorConnected,
SecondProcessorConnected,
ConfiguredRouting,
TestPayment,
IntegrationMethod,
ConfigurationType,
IntegrationCompleted,
StripeConnected,
PaypalConnected,
SpRoutingConfigured,
Feedback,
ProdIntent,
SpTestPayment,
DownloadWoocom,
ConfigureWoocom,
SetupWoocomWebhook,
IsMultipleConfiguration,
IsChangePasswordRequired,
OnboardingSurvey,
ReconStatus,
}
#[derive(
Clone,
Copy,
Debug,
Default,
Eq,
PartialEq,
serde::Serialize,
serde::Deserialize,
strum::Display,
strum::EnumString,
)]
#[diesel_enum(storage_type = "db_enum")]
#[serde(rename_all = "snake_case")]
#[strum(serialize_all = "snake_case")]
pub enum TotpStatus {
Set,
InProgress,
#[default]
NotSet,
}
#[derive(
Clone,
Copy,
Debug,
Default,
Eq,
PartialEq,
serde::Serialize,
serde::Deserialize,
strum::EnumString,
strum::Display,
)]
#[diesel_enum(storage_type = "db_enum")]
#[serde(rename_all = "snake_case")]
#[strum(serialize_all = "snake_case")]
pub enum UserRoleVersion {
#[default]
V1,
V2,
}
<file_sep path="hyperswitch/crates/diesel_models/src/enums.rs" crate="diesel_models" role="use_site">
#[doc(hidden)]
pub mod diesel_exports {
pub use super::{
DbApiVersion as ApiVersion, DbAttemptStatus as AttemptStatus,
DbAuthenticationType as AuthenticationType, DbBlocklistDataKind as BlocklistDataKind,
DbCaptureMethod as CaptureMethod, DbCaptureStatus as CaptureStatus,
DbCardDiscovery as CardDiscovery, DbConnectorStatus as ConnectorStatus,
DbConnectorType as ConnectorType, DbCountryAlpha2 as CountryAlpha2, DbCurrency as Currency,
DbDashboardMetadata as DashboardMetadata, DbDeleteStatus as DeleteStatus,
DbDisputeStage as DisputeStage, DbDisputeStatus as DisputeStatus,
DbEventClass as EventClass, DbEventObjectType as EventObjectType, DbEventType as EventType,
DbFraudCheckStatus as FraudCheckStatus, DbFraudCheckType as FraudCheckType,
DbFutureUsage as FutureUsage, DbGenericLinkType as GenericLinkType,
DbIntentStatus as IntentStatus, DbMandateStatus as MandateStatus,
DbMandateType as MandateType, DbMerchantStorageScheme as MerchantStorageScheme,
DbOrderFulfillmentTimeOrigin as OrderFulfillmentTimeOrigin,
DbPaymentMethodIssuerCode as PaymentMethodIssuerCode, DbPaymentSource as PaymentSource,
DbPaymentType as PaymentType, DbPayoutStatus as PayoutStatus, DbPayoutType as PayoutType,
DbProcessTrackerStatus as ProcessTrackerStatus, DbReconStatus as ReconStatus,
DbRefundStatus as RefundStatus, DbRefundType as RefundType, DbRelayStatus as RelayStatus,
DbRelayType as RelayType,
DbRequestIncrementalAuthorization as RequestIncrementalAuthorization,
DbRoleScope as RoleScope, DbRoutingAlgorithmKind as RoutingAlgorithmKind,
DbScaExemptionType as ScaExemptionType,
DbSuccessBasedRoutingConclusiveState as SuccessBasedRoutingConclusiveState,
DbTotpStatus as TotpStatus, DbTransactionType as TransactionType,
DbUserRoleVersion as UserRoleVersion, DbUserStatus as UserStatus,
DbWebhookDeliveryAttempt as WebhookDeliveryAttempt,
};
}
pub use common_enums::*;
use common_utils::pii;
use diesel::{deserialize::FromSqlRow, expression::AsExpression, sql_types::Jsonb};
use router_derive::diesel_enum;
use time::PrimitiveDateTime;
#[derive(
Clone,
Copy,
Debug,
Eq,
PartialEq,
serde::Deserialize,
serde::Serialize,
strum::Display,
strum::EnumString,
)]
#[diesel_enum(storage_type = "db_enum")]
#[serde(rename_all = "snake_case")]
#[strum(serialize_all = "snake_case")]
pub enum RoutingAlgorithmKind {
Single,
Priority,
VolumeSplit,
Advanced,
Dynamic,
}
#[derive(
Clone,
Copy,
Debug,
Eq,
PartialEq,
serde::Deserialize,
serde::Serialize,
strum::Display,
strum::EnumString,
)]
#[diesel_enum(storage_type = "db_enum")]
#[serde(rename_all = "snake_case")]
#[strum(serialize_all = "snake_case")]
pub enum EventObjectType {
PaymentDetails,
RefundDetails,
DisputeDetails,
MandateDetails,
PayoutDetails,
}
// Refund
#[derive(
Clone,
Copy,
Debug,
Default,
Eq,
PartialEq,
serde::Serialize,
serde::Deserialize,
strum::Display,
strum::EnumString,
)]
#[diesel_enum(storage_type = "db_enum")]
#[strum(serialize_all = "snake_case")]
#[serde(rename_all = "snake_case")]
pub enum RefundType {
InstantRefund,
#[default]
RegularRefund,
RetryRefund,
}
// Mandate
#[derive(
Clone,
Copy,
Debug,
Eq,
PartialEq,
Default,
serde::Deserialize,
serde::Serialize,
strum::Display,
strum::EnumString,
)]
#[diesel_enum(storage_type = "db_enum")]
#[serde(rename_all = "snake_case")]
#[strum(serialize_all = "snake_case")]
pub enum MandateType {
SingleUse,
#[default]
MultiUse,
}
#[derive(
serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, FromSqlRow, AsExpression,
)]
#[diesel(sql_type = Jsonb)]
#[serde(rename_all = "snake_case")]
pub struct MandateDetails {
pub update_mandate_id: Option<String>,
}
common_utils::impl_to_sql_from_sql_json!(MandateDetails);
#[derive(
serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, FromSqlRow, AsExpression,
)]
#[diesel(sql_type = Jsonb)]
#[serde(rename_all = "snake_case")]
pub enum MandateDataType {
SingleUse(MandateAmountData),
MultiUse(Option<MandateAmountData>),
}
common_utils::impl_to_sql_from_sql_json!(MandateDataType);
#[derive(Clone, Debug, serde::Serialize, serde::Deserialize, PartialEq, Eq)]
pub struct MandateAmountData {
pub amount: common_utils::types::MinorUnit,
pub currency: Currency,
pub start_date: Option<PrimitiveDateTime>,
pub end_date: Option<PrimitiveDateTime>,
pub metadata: Option<pii::SecretSerdeValue>,
}
#[derive(
Clone,
Copy,
Debug,
Eq,
PartialEq,
serde::Serialize,
serde::Deserialize,
strum::Display,
strum::EnumString,
)]
#[diesel_enum(storage_type = "db_enum")]
#[serde(rename_all = "snake_case")]
#[strum(serialize_all = "snake_case")]
pub enum FraudCheckType {
PreFrm,
PostFrm,
}
#[derive(
Clone,
Copy,
Debug,
Default,
Eq,
PartialEq,
serde::Serialize,
serde::Deserialize,
strum::Display,
strum::EnumString,
)]
#[diesel_enum(storage_type = "text")]
#[strum(serialize_all = "snake_case")]
pub enum FraudCheckLastStep {
#[default]
Processing,
CheckoutOrSale,
TransactionOrRecordRefund,
Fulfillment,
}
#[derive(
Clone,
Copy,
Debug,
Default,
Eq,
PartialEq,
serde::Serialize,
serde::Deserialize,
strum::Display,
strum::EnumString,
)]
#[diesel_enum(storage_type = "db_enum")]
#[serde(rename_all = "snake_case")]
#[strum(serialize_all = "snake_case")]
pub enum UserStatus {
Active,
#[default]
InvitationSent,
}
#[derive(
Clone,
Copy,
Debug,
Eq,
PartialEq,
serde::Deserialize,
serde::Serialize,
strum::Display,
strum::EnumString,
)]
#[router_derive::diesel_enum(storage_type = "db_enum")]
#[serde(rename_all = "snake_case")]
#[strum(serialize_all = "snake_case")]
pub enum DashboardMetadata {
ProductionAgreement,
SetupProcessor,
ConfigureEndpoint,
SetupComplete,
FirstProcessorConnected,
SecondProcessorConnected,
ConfiguredRouting,
TestPayment,
IntegrationMethod,
ConfigurationType,
IntegrationCompleted,
StripeConnected,
PaypalConnected,
SpRoutingConfigured,
Feedback,
ProdIntent,
SpTestPayment,
DownloadWoocom,
ConfigureWoocom,
SetupWoocomWebhook,
IsMultipleConfiguration,
IsChangePasswordRequired,
OnboardingSurvey,
ReconStatus,
}
#[derive(
Clone,
Copy,
Debug,
Default,
Eq,
PartialEq,
serde::Serialize,
serde::Deserialize,
strum::Display,
strum::EnumString,
)]
#[diesel_enum(storage_type = "db_enum")]
#[serde(rename_all = "snake_case")]
#[strum(serialize_all = "snake_case")]
pub enum TotpStatus {
Set,
InProgress,
#[default]
NotSet,
}
#[derive(
Clone,
Copy,
Debug,
Default,
Eq,
PartialEq,
serde::Serialize,
serde::Deserialize,
strum::EnumString,
strum::Display,
)]
#[diesel_enum(storage_type = "db_enum")]
#[serde(rename_all = "snake_case")]
#[strum(serialize_all = "snake_case")]
pub enum UserRoleVersion {
#[default]
V1,
V2,
}
<file_sep path="hyperswitch/crates/router_derive/src/lib.rs" crate="router_derive" role="macro_def">
<|fim_prefix|>
<|meta_start|><|file|> hyperswitch/crates/router_derive/src/lib.rs<|crate|> diesel_models macro=DieselEnum roles=use_site,macro_def use=attribute item=file pack=proc_macro_neighborhoods lang=rust<|meta_end|>
pub fn diesel_enum_derive(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
<|fim_suffix|>
<|fim_middle|>
}
<file_sep path="hyperswitch/crates/router_derive/src/lib.rs" crate="router_derive" role="macro_def">
<|fim_prefix|>
pub fn diesel_enum_derive(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
<|fim_suffix|>
<|fim_middle|>
}
| proc_macro_neighborhoods |
<file_sep path="hyperswitch/crates/diesel_models/src/dispute.rs" crate="diesel_models" role="use_site">
use common_utils::custom_serde;
use diesel::{AsChangeset, Identifiable, Insertable, Queryable, Selectable};
use masking::Secret;
use serde::Serialize;
use time::PrimitiveDateTime;
use crate::{enums as storage_enums, schema::dispute};
#[derive(Clone, Debug, Insertable, Serialize, router_derive::DebugAsDisplay)]
#[diesel(table_name = dispute)]
#[serde(deny_unknown_fields)]
pub struct DisputeNew {
pub dispute_id: String,
pub amount: String,
pub currency: String,
pub dispute_stage: storage_enums::DisputeStage,
pub dispute_status: storage_enums::DisputeStatus,
pub payment_id: common_utils::id_type::PaymentId,
pub attempt_id: String,
pub merchant_id: common_utils::id_type::MerchantId,
pub connector_status: String,
pub connector_dispute_id: String,
pub connector_reason: Option<String>,
pub connector_reason_code: Option<String>,
pub challenge_required_by: Option<PrimitiveDateTime>,
pub connector_created_at: Option<PrimitiveDateTime>,
pub connector_updated_at: Option<PrimitiveDateTime>,
pub connector: String,
pub evidence: Option<Secret<serde_json::Value>>,
pub profile_id: Option<common_utils::id_type::ProfileId>,
pub merchant_connector_id: Option<common_utils::id_type::MerchantConnectorAccountId>,
pub dispute_amount: i64,
pub organization_id: common_utils::id_type::OrganizationId,
pub dispute_currency: Option<storage_enums::Currency>,
}
#[derive(Clone, Debug, PartialEq, Serialize, Identifiable, Queryable, Selectable)]
#[diesel(table_name = dispute, primary_key(dispute_id), check_for_backend(diesel::pg::Pg))]
pub struct Dispute {
pub dispute_id: String,
pub amount: String,
pub currency: String,
pub dispute_stage: storage_enums::DisputeStage,
pub dispute_status: storage_enums::DisputeStatus,
pub payment_id: common_utils::id_type::PaymentId,
pub attempt_id: String,
pub merchant_id: common_utils::id_type::MerchantId,
pub connector_status: String,
pub connector_dispute_id: String,
pub connector_reason: Option<String>,
pub connector_reason_code: Option<String>,
pub challenge_required_by: Option<PrimitiveDateTime>,
pub connector_created_at: Option<PrimitiveDateTime>,
pub connector_updated_at: Option<PrimitiveDateTime>,
#[serde(with = "custom_serde::iso8601")]
pub created_at: PrimitiveDateTime,
#[serde(with = "custom_serde::iso8601")]
pub modified_at: PrimitiveDateTime,
pub connector: String,
pub evidence: Secret<serde_json::Value>,
pub profile_id: Option<common_utils::id_type::ProfileId>,
pub merchant_connector_id: Option<common_utils::id_type::MerchantConnectorAccountId>,
pub dispute_amount: i64,
pub organization_id: common_utils::id_type::OrganizationId,
pub dispute_currency: Option<storage_enums::Currency>,
}
#[derive(Debug)]
pub enum DisputeUpdate {
Update {
dispute_stage: storage_enums::DisputeStage,
dispute_status: storage_enums::DisputeStatus,
connector_status: String,
connector_reason: Option<String>,
connector_reason_code: Option<String>,
challenge_required_by: Option<PrimitiveDateTime>,
connector_updated_at: Option<PrimitiveDateTime>,
},
StatusUpdate {
dispute_status: storage_enums::DisputeStatus,
connector_status: Option<String>,
},
EvidenceUpdate {
evidence: Secret<serde_json::Value>,
},
}
#[derive(Clone, Debug, AsChangeset, router_derive::DebugAsDisplay)]
#[diesel(table_name = dispute)]
pub struct DisputeUpdateInternal {
dispute_stage: Option<storage_enums::DisputeStage>,
dispute_status: Option<storage_enums::DisputeStatus>,
connector_status: Option<String>,
connector_reason: Option<String>,
connector_reason_code: Option<String>,
challenge_required_by: Option<PrimitiveDateTime>,
connector_updated_at: Option<PrimitiveDateTime>,
modified_at: PrimitiveDateTime,
evidence: Option<Secret<serde_json::Value>>,
}
impl From<DisputeUpdate> for DisputeUpdateInternal {
fn from(merchant_account_update: DisputeUpdate) -> Self {
match merchant_account_update {
DisputeUpdate::Update {
dispute_stage,
dispute_status,
connector_status,
connector_reason,
connector_reason_code,
challenge_required_by,
connector_updated_at,
} => Self {
dispute_stage: Some(dispute_stage),
dispute_status: Some(dispute_status),
connector_status: Some(connector_status),
connector_reason,
connector_reason_code,
challenge_required_by,
connector_updated_at,
modified_at: common_utils::date_time::now(),
evidence: None,
},
DisputeUpdate::StatusUpdate {
dispute_status,
connector_status,
} => Self {
dispute_status: Some(dispute_status),
connector_status,
modified_at: common_utils::date_time::now(),
dispute_stage: None,
connector_reason: None,
connector_reason_code: None,
challenge_required_by: None,
connector_updated_at: None,
evidence: None,
},
DisputeUpdate::EvidenceUpdate { evidence } => Self {
evidence: Some(evidence),
dispute_stage: None,
dispute_status: None,
connector_status: None,
connector_reason: None,
connector_reason_code: None,
challenge_required_by: None,
connector_updated_at: None,
modified_at: common_utils::date_time::now(),
},
}
}
}
<file_sep path="hyperswitch/crates/diesel_models/src/dispute.rs" crate="diesel_models" role="use_site">
use common_utils::custom_serde;
use diesel::{AsChangeset, Identifiable, Insertable, Queryable, Selectable};
use masking::Secret;
use serde::Serialize;
use time::PrimitiveDateTime;
use crate::{enums as storage_enums, schema::dispute};
#[derive(Clone, Debug, Insertable, Serialize, router_derive::DebugAsDisplay)]
#[diesel(table_name = dispute)]
#[serde(deny_unknown_fields)]
pub struct DisputeNew {
pub dispute_id: String,
pub amount: String,
pub currency: String,
pub dispute_stage: storage_enums::DisputeStage,
pub dispute_status: storage_enums::DisputeStatus,
pub payment_id: common_utils::id_type::PaymentId,
pub attempt_id: String,
pub merchant_id: common_utils::id_type::MerchantId,
pub connector_status: String,
pub connector_dispute_id: String,
pub connector_reason: Option<String>,
pub connector_reason_code: Option<String>,
pub challenge_required_by: Option<PrimitiveDateTime>,
pub connector_created_at: Option<PrimitiveDateTime>,
pub connector_updated_at: Option<PrimitiveDateTime>,
pub connector: String,
pub evidence: Option<Secret<serde_json::Value>>,
pub profile_id: Option<common_utils::id_type::ProfileId>,
pub merchant_connector_id: Option<common_utils::id_type::MerchantConnectorAccountId>,
pub dispute_amount: i64,
pub organization_id: common_utils::id_type::OrganizationId,
pub dispute_currency: Option<storage_enums::Currency>,
}
#[derive(Clone, Debug, PartialEq, Serialize, Identifiable, Queryable, Selectable)]
#[diesel(table_name = dispute, primary_key(dispute_id), check_for_backend(diesel::pg::Pg))]
pub struct Dispute {
pub dispute_id: String,
pub amount: String,
pub currency: String,
pub dispute_stage: storage_enums::DisputeStage,
pub dispute_status: storage_enums::DisputeStatus,
pub payment_id: common_utils::id_type::PaymentId,
pub attempt_id: String,
pub merchant_id: common_utils::id_type::MerchantId,
pub connector_status: String,
pub connector_dispute_id: String,
pub connector_reason: Option<String>,
pub connector_reason_code: Option<String>,
pub challenge_required_by: Option<PrimitiveDateTime>,
pub connector_created_at: Option<PrimitiveDateTime>,
pub connector_updated_at: Option<PrimitiveDateTime>,
#[serde(with = "custom_serde::iso8601")]
pub created_at: PrimitiveDateTime,
#[serde(with = "custom_serde::iso8601")]
pub modified_at: PrimitiveDateTime,
pub connector: String,
pub evidence: Secret<serde_json::Value>,
pub profile_id: Option<common_utils::id_type::ProfileId>,
pub merchant_connector_id: Option<common_utils::id_type::MerchantConnectorAccountId>,
pub dispute_amount: i64,
pub organization_id: common_utils::id_type::OrganizationId,
pub dispute_currency: Option<storage_enums::Currency>,
}
#[derive(Debug)]
pub enum DisputeUpdate {
Update {
dispute_stage: storage_enums::DisputeStage,
dispute_status: storage_enums::DisputeStatus,
connector_status: String,
connector_reason: Option<String>,
connector_reason_code: Option<String>,
challenge_required_by: Option<PrimitiveDateTime>,
connector_updated_at: Option<PrimitiveDateTime>,
},
StatusUpdate {
dispute_status: storage_enums::DisputeStatus,
connector_status: Option<String>,
},
EvidenceUpdate {
evidence: Secret<serde_json::Value>,
},
}
#[derive(Clone, Debug, AsChangeset, router_derive::DebugAsDisplay)]
#[diesel(table_name = dispute)]
pub struct DisputeUpdateInternal {
dispute_stage: Option<storage_enums::DisputeStage>,
dispute_status: Option<storage_enums::DisputeStatus>,
connector_status: Option<String>,
connector_reason: Option<String>,
connector_reason_code: Option<String>,
challenge_required_by: Option<PrimitiveDateTime>,
connector_updated_at: Option<PrimitiveDateTime>,
modified_at: PrimitiveDateTime,
evidence: Option<Secret<serde_json::Value>>,
}
impl From<DisputeUpdate> for DisputeUpdateInternal {
fn from(merchant_account_update: DisputeUpdate) -> Self {
match merchant_account_update {
DisputeUpdate::Update {
dispute_stage,
dispute_status,
connector_status,
connector_reason,
connector_reason_code,
challenge_required_by,
connector_updated_at,
} => Self {
dispute_stage: Some(dispute_stage),
dispute_status: Some(dispute_status),
connector_status: Some(connector_status),
connector_reason,
connector_reason_code,
challenge_required_by,
connector_updated_at,
modified_at: common_utils::date_time::now(),
evidence: None,
},
DisputeUpdate::StatusUpdate {
dispute_status,
connector_status,
} => Self {
dispute_status: Some(dispute_status),
connector_status,
modified_at: common_utils::date_time::now(),
dispute_stage: None,
connector_reason: None,
connector_reason_code: None,
challenge_required_by: None,
connector_updated_at: None,
evidence: None,
},
DisputeUpdate::EvidenceUpdate { evidence } => Self {
evidence: Some(evidence),
dispute_stage: None,
dispute_status: None,
connector_status: None,
connector_reason: None,
connector_reason_code: None,
challenge_required_by: None,
connector_updated_at: None,
modified_at: common_utils::date_time::now(),
},
}
}
}
<file_sep path="hyperswitch/crates/router_derive/src/lib.rs" crate="router_derive" role="macro_def">
<|fim_prefix|>
<|meta_start|><|file|> hyperswitch/crates/router_derive/src/lib.rs<|crate|> diesel_models macro=DebugAsDisplay roles=use_site,macro_def use=derive item=file pack=proc_macro_neighborhoods lang=rust<|meta_end|>
pub fn debug_as_display_derive(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
<|fim_suffix|>
<|fim_middle|>
}
<file_sep path="hyperswitch/crates/router_derive/src/lib.rs" crate="router_derive" role="macro_def">
<|fim_prefix|>
pub fn debug_as_display_derive(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
<|fim_suffix|>
<|fim_middle|>
}
| proc_macro_neighborhoods |
<|meta_start|><|file|> hyperswitch/crates/router_derive/src/lib.rs<|crate|> diesel_models macro=DebugAsDisplay roles=use_site,macro_def use=derive item=file pack=proc_macro_neighborhoods lang=rust<|meta_end|>
<file_sep path="hyperswitch/crates/diesel_models/src/payment_attempt.rs" crate="diesel_models" role="use_site">
use common_types::primitive_wrappers::{
ExtendedAuthorizationAppliedBool, RequestExtendedAuthorizationBool,
};
use common_utils::{
id_type, pii,
types::{ConnectorTransactionId, ConnectorTransactionIdTrait, MinorUnit},
};
use diesel::{AsChangeset, Identifiable, Insertable, Queryable, Selectable};
use serde::{Deserialize, Serialize};
use time::PrimitiveDateTime;
use crate::enums as storage_enums;
#[cfg(feature = "v1")]
use crate::schema::payment_attempt;
#[cfg(feature = "v2")]
use crate::schema_v2::payment_attempt;
common_utils::impl_to_sql_from_sql_json!(ConnectorMandateReferenceId);
#[derive(
Clone, Debug, serde::Deserialize, serde::Serialize, Eq, PartialEq, diesel::AsExpression,
)]
#[diesel(sql_type = diesel::sql_types::Jsonb)]
pub struct ConnectorMandateReferenceId {
pub connector_mandate_id: Option<String>,
pub payment_method_id: Option<String>,
pub mandate_metadata: Option<pii::SecretSerdeValue>,
pub connector_mandate_request_reference_id: Option<String>,
}
impl ConnectorMandateReferenceId {
pub fn get_connector_mandate_request_reference_id(&self) -> Option<String> {
self.connector_mandate_request_reference_id.clone()
}
}
#[cfg(feature = "v2")]
#[derive(
Clone, Debug, Eq, PartialEq, Identifiable, Queryable, Serialize, Deserialize, Selectable,
)]
#[diesel(table_name = payment_attempt, primary_key(id), check_for_backend(diesel::pg::Pg))]
pub struct PaymentAttempt {
pub payment_id: id_type::GlobalPaymentId,
pub merchant_id: id_type::MerchantId,
pub status: storage_enums::AttemptStatus,
pub connector: Option<String>,
pub error_message: Option<String>,
pub surcharge_amount: Option<MinorUnit>,
pub payment_method_id: Option<id_type::GlobalPaymentMethodId>,
pub authentication_type: storage_enums::AuthenticationType,
#[serde(with = "common_utils::custom_serde::iso8601")]
pub created_at: PrimitiveDateTime,
#[serde(with = "common_utils::custom_serde::iso8601")]
pub modified_at: PrimitiveDateTime,
#[serde(default, with = "common_utils::custom_serde::iso8601::option")]
pub last_synced: Option<PrimitiveDateTime>,
pub cancellation_reason: Option<String>,
pub amount_to_capture: Option<MinorUnit>,
pub browser_info: Option<common_utils::types::BrowserInformation>,
pub error_code: Option<String>,
pub payment_token: Option<String>,
pub connector_metadata: Option<pii::SecretSerdeValue>,
pub payment_experience: Option<storage_enums::PaymentExperience>,
pub payment_method_data: Option<pii::SecretSerdeValue>,
pub preprocessing_step_id: Option<String>,
pub error_reason: Option<String>,
pub multiple_capture_count: Option<i16>,
pub connector_response_reference_id: Option<String>,
pub amount_capturable: MinorUnit,
pub updated_by: String,
pub merchant_connector_id: Option<id_type::MerchantConnectorAccountId>,
pub encoded_data: Option<masking::Secret<String>>,
pub unified_code: Option<String>,
pub unified_message: Option<String>,
pub net_amount: MinorUnit,
pub external_three_ds_authentication_attempted: Option<bool>,
pub authentication_connector: Option<String>,
pub authentication_id: Option<String>,
pub fingerprint_id: Option<String>,
pub client_source: Option<String>,
pub client_version: Option<String>,
pub customer_acceptance: Option<pii::SecretSerdeValue>,
pub profile_id: id_type::ProfileId,
pub organization_id: id_type::OrganizationId,
pub card_network: Option<String>,
pub shipping_cost: Option<MinorUnit>,
pub order_tax_amount: Option<MinorUnit>,
pub request_extended_authorization: Option<RequestExtendedAuthorizationBool>,
pub extended_authorization_applied: Option<ExtendedAuthorizationAppliedBool>,
pub capture_before: Option<PrimitiveDateTime>,
pub card_discovery: Option<storage_enums::CardDiscovery>,
pub charges: Option<common_types::payments::ConnectorChargeResponseData>,
pub payment_method_type_v2: storage_enums::PaymentMethod,
pub connector_payment_id: Option<ConnectorTransactionId>,
pub payment_method_subtype: storage_enums::PaymentMethodType,
pub routing_result: Option<serde_json::Value>,
pub authentication_applied: Option<common_enums::AuthenticationType>,
pub external_reference_id: Option<String>,
pub tax_on_surcharge: Option<MinorUnit>,
pub payment_method_billing_address: Option<common_utils::encryption::Encryption>,
pub redirection_data: Option<RedirectForm>,
pub connector_payment_data: Option<String>,
pub connector_token_details: Option<ConnectorTokenDetails>,
pub id: id_type::GlobalAttemptId,
pub feature_metadata: Option<PaymentAttemptFeatureMetadata>,
/// This field can be returned for both approved and refused Mastercard payments.
/// This code provides additional information about the type of transaction or the reason why the payment failed.
/// If the payment failed, the network advice code gives guidance on if and when you can retry the payment.
pub network_advice_code: Option<String>,
/// For card errors resulting from a card issuer decline, a brand specific 2, 3, or 4 digit code which indicates the reason the authorization failed.
pub network_decline_code: Option<String>,
/// A string indicating how to proceed with an network error if payment gateway provide one. This is used to understand the network error code better.
pub network_error_message: Option<String>,
}
#[cfg(feature = "v1")]
#[derive(
Clone, Debug, Eq, PartialEq, Identifiable, Queryable, Serialize, Deserialize, Selectable,
)]
#[diesel(table_name = payment_attempt, primary_key(attempt_id, merchant_id), check_for_backend(diesel::pg::Pg))]
pub struct PaymentAttempt {
pub payment_id: id_type::PaymentId,
pub merchant_id: id_type::MerchantId,
pub attempt_id: String,
pub status: storage_enums::AttemptStatus,
pub amount: MinorUnit,
pub currency: Option<storage_enums::Currency>,
pub save_to_locker: Option<bool>,
pub connector: Option<String>,
pub error_message: Option<String>,
pub offer_amount: Option<MinorUnit>,
pub surcharge_amount: Option<MinorUnit>,
pub tax_amount: Option<MinorUnit>,
pub payment_method_id: Option<String>,
pub payment_method: Option<storage_enums::PaymentMethod>,
pub connector_transaction_id: Option<ConnectorTransactionId>,
pub capture_method: Option<storage_enums::CaptureMethod>,
#[serde(default, with = "common_utils::custom_serde::iso8601::option")]
pub capture_on: Option<PrimitiveDateTime>,
pub confirm: bool,
pub authentication_type: Option<storage_enums::AuthenticationType>,
#[serde(with = "common_utils::custom_serde::iso8601")]
pub created_at: PrimitiveDateTime,
#[serde(with = "common_utils::custom_serde::iso8601")]
pub modified_at: PrimitiveDateTime,
#[serde(default, with = "common_utils::custom_serde::iso8601::option")]
pub last_synced: Option<PrimitiveDateTime>,
pub cancellation_reason: Option<String>,
pub amount_to_capture: Option<MinorUnit>,
pub mandate_id: Option<String>,
pub browser_info: Option<serde_json::Value>,
pub error_code: Option<String>,
pub payment_token: Option<String>,
pub connector_metadata: Option<serde_json::Value>,
pub payment_experience: Option<storage_enums::PaymentExperience>,
pub payment_method_type: Option<storage_enums::PaymentMethodType>,
pub payment_method_data: Option<serde_json::Value>,
pub business_sub_label: Option<String>,
pub straight_through_algorithm: Option<serde_json::Value>,
pub preprocessing_step_id: Option<String>,
// providing a location to store mandate details intermediately for transaction
pub mandate_details: Option<storage_enums::MandateDataType>,
pub error_reason: Option<String>,
pub multiple_capture_count: Option<i16>,
// reference to the payment at connector side
pub connector_response_reference_id: Option<String>,
pub amount_capturable: MinorUnit,
pub updated_by: String,
pub merchant_connector_id: Option<id_type::MerchantConnectorAccountId>,
pub authentication_data: Option<serde_json::Value>,
pub encoded_data: Option<String>,
pub unified_code: Option<String>,
pub unified_message: Option<String>,
pub net_amount: Option<MinorUnit>,
pub external_three_ds_authentication_attempted: Option<bool>,
pub authentication_connector: Option<String>,
pub authentication_id: Option<String>,
pub mandate_data: Option<storage_enums::MandateDetails>,
pub fingerprint_id: Option<String>,
pub payment_method_billing_address_id: Option<String>,
pub charge_id: Option<String>,
pub client_source: Option<String>,
pub client_version: Option<String>,
pub customer_acceptance: Option<pii::SecretSerdeValue>,
pub profile_id: id_type::ProfileId,
pub organization_id: id_type::OrganizationId,
pub card_network: Option<String>,
pub shipping_cost: Option<MinorUnit>,
pub order_tax_amount: Option<MinorUnit>,
/// INFO: This field is deprecated and replaced by processor_transaction_data
pub connector_transaction_data: Option<String>,
pub connector_mandate_detail: Option<ConnectorMandateReferenceId>,
pub request_extended_authorization: Option<RequestExtendedAuthorizationBool>,
pub extended_authorization_applied: Option<ExtendedAuthorizationAppliedBool>,
pub capture_before: Option<PrimitiveDateTime>,
pub processor_transaction_data: Option<String>,
pub card_discovery: Option<storage_enums::CardDiscovery>,
pub charges: Option<common_types::payments::ConnectorChargeResponseData>,
pub issuer_error_code: Option<String>,
pub issuer_error_message: Option<String>,
}
#[cfg(feature = "v1")]
impl ConnectorTransactionIdTrait for PaymentAttempt {
fn get_optional_connector_transaction_id(&self) -> Option<&String> {
match self
.connector_transaction_id
.as_ref()
.map(|txn_id| txn_id.get_txn_id(self.processor_transaction_data.as_ref()))
.transpose()
{
Ok(txn_id) => txn_id,
// In case hashed data is missing from DB, use the hashed ID as connector transaction ID
Err(_) => self
.connector_transaction_id
.as_ref()
.map(|txn_id| txn_id.get_id()),
}
}
}
#[cfg(feature = "v2")]
impl ConnectorTransactionIdTrait for PaymentAttempt {
fn get_optional_connector_transaction_id(&self) -> Option<&String> {
match self
.connector_payment_id
.as_ref()
.map(|txn_id| txn_id.get_txn_id(self.connector_payment_data.as_ref()))
.transpose()
{
Ok(txn_id) => txn_id,
// In case hashed data is missing from DB, use the hashed ID as connector payment ID
Err(_) => self
.connector_payment_id
.as_ref()
.map(|txn_id| txn_id.get_id()),
}
}
}
#[cfg(feature = "v2")]
#[derive(
Clone, Debug, PartialEq, Eq, serde::Deserialize, serde::Serialize, diesel::AsExpression,
)]
#[diesel(sql_type = diesel::sql_types::Jsonb)]
pub struct ConnectorTokenDetails {
pub connector_mandate_id: Option<String>,
pub connector_token_request_reference_id: Option<String>,
}
#[cfg(feature = "v2")]
common_utils::impl_to_sql_from_sql_json!(ConnectorTokenDetails);
#[cfg(feature = "v2")]
impl ConnectorTokenDetails {
pub fn get_connector_token_request_reference_id(&self) -> Option<String> {
self.connector_token_request_reference_id.clone()
}
}
#[derive(Clone, Debug, Eq, PartialEq, Queryable, Serialize, Deserialize)]
pub struct PaymentListFilters {
pub connector: Vec<String>,
pub currency: Vec<storage_enums::Currency>,
pub status: Vec<storage_enums::IntentStatus>,
pub payment_method: Vec<storage_enums::PaymentMethod>,
}
#[cfg(feature = "v2")]
#[derive(Clone, Debug, Insertable, router_derive::DebugAsDisplay, Serialize, Deserialize)]
#[diesel(table_name = payment_attempt)]
pub struct PaymentAttemptNew {
pub payment_id: id_type::GlobalPaymentId,
pub merchant_id: id_type::MerchantId,
pub status: storage_enums::AttemptStatus,
pub error_message: Option<String>,
pub surcharge_amount: Option<MinorUnit>,
pub tax_on_surcharge: Option<MinorUnit>,
pub payment_method_id: Option<id_type::GlobalPaymentMethodId>,
pub authentication_type: storage_enums::AuthenticationType,
#[serde(with = "common_utils::custom_serde::iso8601")]
pub created_at: PrimitiveDateTime,
#[serde(with = "common_utils::custom_serde::iso8601")]
pub modified_at: PrimitiveDateTime,
#[serde(default, with = "common_utils::custom_serde::iso8601::option")]
pub last_synced: Option<PrimitiveDateTime>,
pub cancellation_reason: Option<String>,
pub amount_to_capture: Option<MinorUnit>,
pub browser_info: Option<common_utils::types::BrowserInformation>,
pub payment_token: Option<String>,
pub error_code: Option<String>,
pub connector_metadata: Option<pii::SecretSerdeValue>,
pub payment_experience: Option<storage_enums::PaymentExperience>,
pub payment_method_data: Option<pii::SecretSerdeValue>,
pub preprocessing_step_id: Option<String>,
pub error_reason: Option<String>,
pub connector_response_reference_id: Option<String>,
pub multiple_capture_count: Option<i16>,
pub amount_capturable: MinorUnit,
pub updated_by: String,
pub merchant_connector_id: Option<id_type::MerchantConnectorAccountId>,
pub redirection_data: Option<RedirectForm>,
pub encoded_data: Option<masking::Secret<String>>,
pub unified_code: Option<String>,
pub unified_message: Option<String>,
pub net_amount: MinorUnit,
pub external_three_ds_authentication_attempted: Option<bool>,
pub authentication_connector: Option<String>,
pub authentication_id: Option<String>,
pub fingerprint_id: Option<String>,
pub payment_method_billing_address: Option<common_utils::encryption::Encryption>,
pub client_source: Option<String>,
pub client_version: Option<String>,
pub customer_acceptance: Option<pii::SecretSerdeValue>,
pub profile_id: id_type::ProfileId,
pub organization_id: id_type::OrganizationId,
pub card_network: Option<String>,
pub shipping_cost: Option<MinorUnit>,
pub order_tax_amount: Option<MinorUnit>,
pub charges: Option<common_types::payments::ConnectorChargeResponseData>,
pub feature_metadata: Option<PaymentAttemptFeatureMetadata>,
pub payment_method_type_v2: storage_enums::PaymentMethod,
pub connector_payment_id: Option<ConnectorTransactionId>,
pub payment_method_subtype: storage_enums::PaymentMethodType,
pub id: id_type::GlobalAttemptId,
pub connector_token_details: Option<ConnectorTokenDetails>,
pub card_discovery: Option<storage_enums::CardDiscovery>,
pub request_extended_authorization: Option<RequestExtendedAuthorizationBool>,
pub extended_authorization_applied: Option<ExtendedAuthorizationAppliedBool>,
pub capture_before: Option<PrimitiveDateTime>,
pub connector: Option<String>,
pub network_decline_code: Option<String>,
pub network_advice_code: Option<String>,
pub network_error_message: Option<String>,
}
#[cfg(feature = "v1")]
#[derive(Clone, Debug, Insertable, router_derive::DebugAsDisplay, Serialize, Deserialize)]
#[diesel(table_name = payment_attempt)]
pub struct PaymentAttemptNew {
pub payment_id: id_type::PaymentId,
pub merchant_id: id_type::MerchantId,
pub attempt_id: String,
pub status: storage_enums::AttemptStatus,
pub amount: MinorUnit,
pub currency: Option<storage_enums::Currency>,
// pub auto_capture: Option<bool>,
pub save_to_locker: Option<bool>,
pub connector: Option<String>,
pub error_message: Option<String>,
pub offer_amount: Option<MinorUnit>,
pub surcharge_amount: Option<MinorUnit>,
pub tax_amount: Option<MinorUnit>,
pub payment_method_id: Option<String>,
pub payment_method: Option<storage_enums::PaymentMethod>,
pub capture_method: Option<storage_enums::CaptureMethod>,
#[serde(default, with = "common_utils::custom_serde::iso8601::option")]
pub capture_on: Option<PrimitiveDateTime>,
pub confirm: bool,
pub authentication_type: Option<storage_enums::AuthenticationType>,
#[serde(with = "common_utils::custom_serde::iso8601")]
pub created_at: PrimitiveDateTime,
#[serde(with = "common_utils::custom_serde::iso8601")]
pub modified_at: PrimitiveDateTime,
#[serde(default, with = "common_utils::custom_serde::iso8601::option")]
pub last_synced: Option<PrimitiveDateTime>,
pub cancellation_reason: Option<String>,
pub amount_to_capture: Option<MinorUnit>,
pub mandate_id: Option<String>,
pub browser_info: Option<serde_json::Value>,
pub payment_token: Option<String>,
pub error_code: Option<String>,
pub connector_metadata: Option<serde_json::Value>,
pub payment_experience: Option<storage_enums::PaymentExperience>,
pub payment_method_type: Option<storage_enums::PaymentMethodType>,
pub payment_method_data: Option<serde_json::Value>,
pub business_sub_label: Option<String>,
pub straight_through_algorithm: Option<serde_json::Value>,
pub preprocessing_step_id: Option<String>,
pub mandate_details: Option<storage_enums::MandateDataType>,
pub error_reason: Option<String>,
pub connector_response_reference_id: Option<String>,
pub multiple_capture_count: Option<i16>,
pub amount_capturable: MinorUnit,
pub updated_by: String,
pub merchant_connector_id: Option<id_type::MerchantConnectorAccountId>,
pub authentication_data: Option<serde_json::Value>,
pub encoded_data: Option<String>,
pub unified_code: Option<String>,
pub unified_message: Option<String>,
pub net_amount: Option<MinorUnit>,
pub external_three_ds_authentication_attempted: Option<bool>,
pub authentication_connector: Option<String>,
pub authentication_id: Option<String>,
pub mandate_data: Option<storage_enums::MandateDetails>,
pub fingerprint_id: Option<String>,
pub payment_method_billing_address_id: Option<String>,
pub client_source: Option<String>,
pub client_version: Option<String>,
pub customer_acceptance: Option<pii::SecretSerdeValue>,
pub profile_id: id_type::ProfileId,
pub organization_id: id_type::OrganizationId,
pub card_network: Option<String>,
pub shipping_cost: Option<MinorUnit>,
pub order_tax_amount: Option<MinorUnit>,
pub connector_mandate_detail: Option<ConnectorMandateReferenceId>,
pub request_extended_authorization: Option<RequestExtendedAuthorizationBool>,
pub extended_authorization_applied: Option<ExtendedAuthorizationAppliedBool>,
#[serde(default, with = "common_utils::custom_serde::iso8601::option")]
pub capture_before: Option<PrimitiveDateTime>,
pub card_discovery: Option<storage_enums::CardDiscovery>,
}
#[cfg(feature = "v1")]
#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum PaymentAttemptUpdate {
Update {
amount: MinorUnit,
currency: storage_enums::Currency,
status: storage_enums::AttemptStatus,
authentication_type: Option<storage_enums::AuthenticationType>,
payment_method: Option<storage_enums::PaymentMethod>,
payment_token: Option<String>,
payment_method_data: Option<serde_json::Value>,
payment_method_type: Option<storage_enums::PaymentMethodType>,
payment_experience: Option<storage_enums::PaymentExperience>,
business_sub_label: Option<String>,
amount_to_capture: Option<MinorUnit>,
capture_method: Option<storage_enums::CaptureMethod>,
surcharge_amount: Option<MinorUnit>,
tax_amount: Option<MinorUnit>,
fingerprint_id: Option<String>,
payment_method_billing_address_id: Option<String>,
updated_by: String,
},
UpdateTrackers {
payment_token: Option<String>,
connector: Option<String>,
straight_through_algorithm: Option<serde_json::Value>,
amount_capturable: Option<MinorUnit>,
surcharge_amount: Option<MinorUnit>,
tax_amount: Option<MinorUnit>,
updated_by: String,
merchant_connector_id: Option<id_type::MerchantConnectorAccountId>,
},
AuthenticationTypeUpdate {
authentication_type: storage_enums::AuthenticationType,
updated_by: String,
},
ConfirmUpdate {
amount: MinorUnit,
currency: storage_enums::Currency,
status: storage_enums::AttemptStatus,
authentication_type: Option<storage_enums::AuthenticationType>,
capture_method: Option<storage_enums::CaptureMethod>,
payment_method: Option<storage_enums::PaymentMethod>,
browser_info: Option<serde_json::Value>,
connector: Option<String>,
payment_token: Option<String>,
payment_method_data: Option<serde_json::Value>,
payment_method_type: Option<storage_enums::PaymentMethodType>,
payment_experience: Option<storage_enums::PaymentExperience>,
business_sub_label: Option<String>,
straight_through_algorithm: Option<serde_json::Value>,
error_code: Option<Option<String>>,
error_message: Option<Option<String>>,
amount_capturable: Option<MinorUnit>,
surcharge_amount: Option<MinorUnit>,
tax_amount: Option<MinorUnit>,
fingerprint_id: Option<String>,
updated_by: String,
merchant_connector_id: Option<id_type::MerchantConnectorAccountId>,
payment_method_id: Option<String>,
external_three_ds_authentication_attempted: Option<bool>,
authentication_connector: Option<String>,
authentication_id: Option<String>,
payment_method_billing_address_id: Option<String>,
client_source: Option<String>,
client_version: Option<String>,
customer_acceptance: Option<pii::SecretSerdeValue>,
shipping_cost: Option<MinorUnit>,
order_tax_amount: Option<MinorUnit>,
connector_mandate_detail: Option<ConnectorMandateReferenceId>,
card_discovery: Option<storage_enums::CardDiscovery>,
},
VoidUpdate {
status: storage_enums::AttemptStatus,
cancellation_reason: Option<String>,
updated_by: String,
},
PaymentMethodDetailsUpdate {
payment_method_id: Option<String>,
updated_by: String,
},
ConnectorMandateDetailUpdate {
connector_mandate_detail: Option<ConnectorMandateReferenceId>,
updated_by: String,
},
BlocklistUpdate {
status: storage_enums::AttemptStatus,
error_code: Option<Option<String>>,
error_message: Option<Option<String>>,
updated_by: String,
},
RejectUpdate {
status: storage_enums::AttemptStatus,
error_code: Option<Option<String>>,
error_message: Option<Option<String>>,
updated_by: String,
},
ResponseUpdate {
status: storage_enums::AttemptStatus,
connector: Option<String>,
connector_transaction_id: Option<String>,
authentication_type: Option<storage_enums::AuthenticationType>,
payment_method_id: Option<String>,
mandate_id: Option<String>,
connector_metadata: Option<serde_json::Value>,
payment_token: Option<String>,
error_code: Option<Option<String>>,
error_message: Option<Option<String>>,
error_reason: Option<Option<String>>,
connector_response_reference_id: Option<String>,
amount_capturable: Option<MinorUnit>,
updated_by: String,
authentication_data: Option<serde_json::Value>,
encoded_data: Option<String>,
unified_code: Option<Option<String>>,
unified_message: Option<Option<String>>,
capture_before: Option<PrimitiveDateTime>,
extended_authorization_applied: Option<ExtendedAuthorizationAppliedBool>,
payment_method_data: Option<serde_json::Value>,
connector_mandate_detail: Option<ConnectorMandateReferenceId>,
charges: Option<common_types::payments::ConnectorChargeResponseData>,
},
UnresolvedResponseUpdate {
status: storage_enums::AttemptStatus,
connector: Option<String>,
connector_transaction_id: Option<String>,
payment_method_id: Option<String>,
error_code: Option<Option<String>>,
error_message: Option<Option<String>>,
error_reason: Option<Option<String>>,
connector_response_reference_id: Option<String>,
updated_by: String,
},
StatusUpdate {
status: storage_enums::AttemptStatus,
updated_by: String,
},
ErrorUpdate {
connector: Option<String>,
status: storage_enums::AttemptStatus,
error_code: Option<Option<String>>,
error_message: Option<Option<String>>,
error_reason: Option<Option<String>>,
amount_capturable: Option<MinorUnit>,
updated_by: String,
unified_code: Option<Option<String>>,
unified_message: Option<Option<String>>,
connector_transaction_id: Option<String>,
payment_method_data: Option<serde_json::Value>,
authentication_type: Option<storage_enums::AuthenticationType>,
issuer_error_code: Option<String>,
issuer_error_message: Option<String>,
},
CaptureUpdate {
amount_to_capture: Option<MinorUnit>,
multiple_capture_count: Option<i16>,
updated_by: String,
},
AmountToCaptureUpdate {
status: storage_enums::AttemptStatus,
amount_capturable: MinorUnit,
updated_by: String,
},
PreprocessingUpdate {
status: storage_enums::AttemptStatus,
payment_method_id: Option<String>,
connector_metadata: Option<serde_json::Value>,
preprocessing_step_id: Option<String>,
connector_transaction_id: Option<String>,
connector_response_reference_id: Option<String>,
updated_by: String,
},
ConnectorResponse {
authentication_data: Option<serde_json::Value>,
encoded_data: Option<String>,
connector_transaction_id: Option<String>,
connector: Option<String>,
charges: Option<common_types::payments::ConnectorChargeResponseData>,
updated_by: String,
},
IncrementalAuthorizationAmountUpdate {
amount: MinorUnit,
amount_capturable: MinorUnit,
},
AuthenticationUpdate {
status: storage_enums::AttemptStatus,
external_three_ds_authentication_attempted: Option<bool>,
authentication_connector: Option<String>,
authentication_id: Option<String>,
updated_by: String,
},
ManualUpdate {
status: Option<storage_enums::AttemptStatus>,
error_code: Option<String>,
error_message: Option<String>,
error_reason: Option<String>,
updated_by: String,
unified_code: Option<String>,
unified_message: Option<String>,
connector_transaction_id: Option<String>,
},
PostSessionTokensUpdate {
updated_by: String,
connector_metadata: Option<serde_json::Value>,
},
}
#[cfg(feature = "v2")]
#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum PaymentAttemptUpdate {
// Update {
// amount: MinorUnit,
// currency: storage_enums::Currency,
// status: storage_enums::AttemptStatus,
// authentication_type: Option<storage_enums::AuthenticationType>,
// payment_method: Option<storage_enums::PaymentMethod>,
// payment_token: Option<String>,
// payment_method_data: Option<serde_json::Value>,
// payment_method_type: Option<storage_enums::PaymentMethodType>,
// payment_experience: Option<storage_enums::PaymentExperience>,
// business_sub_label: Option<String>,
// amount_to_capture: Option<MinorUnit>,
// capture_method: Option<storage_enums::CaptureMethod>,
// surcharge_amount: Option<MinorUnit>,
// tax_amount: Option<MinorUnit>,
// fingerprint_id: Option<String>,
// payment_method_billing_address_id: Option<String>,
// updated_by: String,
// },
// UpdateTrackers {
// payment_token: Option<String>,
// connector: Option<String>,
// straight_through_algorithm: Option<serde_json::Value>,
// amount_capturable: Option<MinorUnit>,
// surcharge_amount: Option<MinorUnit>,
// tax_amount: Option<MinorUnit>,
// updated_by: String,
// merchant_connector_id: Option<id_type::MerchantConnectorAccountId>,
// },
// AuthenticationTypeUpdate {
// authentication_type: storage_enums::AuthenticationType,
// updated_by: String,
// },
// ConfirmUpdate {
// amount: MinorUnit,
// currency: storage_enums::Currency,
// status: storage_enums::AttemptStatus,
// authentication_type: Option<storage_enums::AuthenticationType>,
// capture_method: Option<storage_enums::CaptureMethod>,
// payment_method: Option<storage_enums::PaymentMethod>,
// browser_info: Option<serde_json::Value>,
// connector: Option<String>,
// payment_token: Option<String>,
// payment_method_data: Option<serde_json::Value>,
// payment_method_type: Option<storage_enums::PaymentMethodType>,
// payment_experience: Option<storage_enums::PaymentExperience>,
// business_sub_label: Option<String>,
// straight_through_algorithm: Option<serde_json::Value>,
// error_code: Option<Option<String>>,
// error_message: Option<Option<String>>,
// amount_capturable: Option<MinorUnit>,
// surcharge_amount: Option<MinorUnit>,
// tax_amount: Option<MinorUnit>,
// fingerprint_id: Option<String>,
// updated_by: String,
// merchant_connector_id: Option<id_type::MerchantConnectorAccountId>,
// payment_method_id: Option<String>,
// external_three_ds_authentication_attempted: Option<bool>,
// authentication_connector: Option<String>,
// authentication_id: Option<String>,
// payment_method_billing_address_id: Option<String>,
// client_source: Option<String>,
// client_version: Option<String>,
// customer_acceptance: Option<pii::SecretSerdeValue>,
// },
// VoidUpdate {
// status: storage_enums::AttemptStatus,
// cancellation_reason: Option<String>,
// updated_by: String,
// },
// PaymentMethodDetailsUpdate {
// payment_method_id: Option<String>,
// updated_by: String,
// },
// ConnectorMandateDetailUpdate {
// connector_mandate_detail: Option<ConnectorMandateReferenceId>,
// updated_by: String,
// }
// BlocklistUpdate {
// status: storage_enums::AttemptStatus,
// error_code: Option<Option<String>>,
// error_message: Option<Option<String>>,
// updated_by: String,
// },
// RejectUpdate {
// status: storage_enums::AttemptStatus,
// error_code: Option<Option<String>>,
// error_message: Option<Option<String>>,
// updated_by: String,
// },
// ResponseUpdate {
// status: storage_enums::AttemptStatus,
// connector: Option<String>,
// connector_transaction_id: Option<String>,
// authentication_type: Option<storage_enums::AuthenticationType>,
// payment_method_id: Option<String>,
// mandate_id: Option<String>,
// connector_metadata: Option<serde_json::Value>,
// payment_token: Option<String>,
// error_code: Option<Option<String>>,
// error_message: Option<Option<String>>,
// error_reason: Option<Option<String>>,
// connector_response_reference_id: Option<String>,
// amount_capturable: Option<MinorUnit>,
// updated_by: String,
// authentication_data: Option<serde_json::Value>,
// encoded_data: Option<String>,
// unified_code: Option<Option<String>>,
// unified_message: Option<Option<String>>,
// payment_method_data: Option<serde_json::Value>,
// charge_id: Option<String>,
// },
// UnresolvedResponseUpdate {
// status: storage_enums::AttemptStatus,
// connector: Option<String>,
// connector_transaction_id: Option<String>,
// payment_method_id: Option<String>,
// error_code: Option<Option<String>>,
// error_message: Option<Option<String>>,
// error_reason: Option<Option<String>>,
// connector_response_reference_id: Option<String>,
// updated_by: String,
// },
// StatusUpdate {
// status: storage_enums::AttemptStatus,
// updated_by: String,
// },
// ErrorUpdate {
// connector: Option<String>,
// status: storage_enums::AttemptStatus,
// error_code: Option<Option<String>>,
// error_message: Option<Option<String>>,
// error_reason: Option<Option<String>>,
// amount_capturable: Option<MinorUnit>,
// updated_by: String,
// unified_code: Option<Option<String>>,
// unified_message: Option<Option<String>>,
// connector_transaction_id: Option<String>,
// payment_method_data: Option<serde_json::Value>,
// authentication_type: Option<storage_enums::AuthenticationType>,
// },
// CaptureUpdate {
// amount_to_capture: Option<MinorUnit>,
// multiple_capture_count: Option<MinorUnit>,
// updated_by: String,
// },
// AmountToCaptureUpdate {
// status: storage_enums::AttemptStatus,
// amount_capturable: MinorUnit,
// updated_by: String,
// },
// PreprocessingUpdate {
// status: storage_enums::AttemptStatus,
// payment_method_id: Option<String>,
// connector_metadata: Option<serde_json::Value>,
// preprocessing_step_id: Option<String>,
// connector_transaction_id: Option<String>,
// connector_response_reference_id: Option<String>,
// updated_by: String,
// },
// ConnectorResponse {
// authentication_data: Option<serde_json::Value>,
// encoded_data: Option<String>,
// connector_transaction_id: Option<String>,
// connector: Option<String>,
// charge_id: Option<String>,
// updated_by: String,
// },
// IncrementalAuthorizationAmountUpdate {
// amount: MinorUnit,
// amount_capturable: MinorUnit,
// },
// AuthenticationUpdate {
// status: storage_enums::AttemptStatus,
// external_three_ds_authentication_attempted: Option<bool>,
// authentication_connector: Option<String>,
// authentication_id: Option<String>,
// updated_by: String,
// },
// ManualUpdate {
// status: Option<storage_enums::AttemptStatus>,
// error_code: Option<String>,
// error_message: Option<String>,
// error_reason: Option<String>,
// updated_by: String,
// unified_code: Option<String>,
// unified_message: Option<String>,
// connector_transaction_id: Option<String>,
// },
}
// TODO: uncomment fields as and when required
#[cfg(feature = "v2")]
#[derive(Clone, Debug, AsChangeset, router_derive::DebugAsDisplay)]
#[diesel(table_name = payment_attempt)]
pub struct PaymentAttemptUpdateInternal {
pub status: Option<storage_enums::AttemptStatus>,
pub authentication_type: Option<storage_enums::AuthenticationType>,
pub error_message: Option<String>,
pub connector_payment_id: Option<String>,
// payment_method_id: Option<String>,
// cancellation_reason: Option<String>,
pub modified_at: PrimitiveDateTime,
pub browser_info: Option<serde_json::Value>,
// payment_token: Option<String>,
pub error_code: Option<String>,
pub connector_metadata: Option<pii::SecretSerdeValue>,
// payment_method_data: Option<serde_json::Value>,
// payment_experience: Option<storage_enums::PaymentExperience>,
// preprocessing_step_id: Option<String>,
pub error_reason: Option<String>,
// connector_response_reference_id: Option<String>,
// multiple_capture_count: Option<i16>,
// pub surcharge_amount: Option<MinorUnit>,
// tax_on_surcharge: Option<MinorUnit>,
pub amount_capturable: Option<MinorUnit>,
pub amount_to_capture: Option<MinorUnit>,
pub updated_by: String,
pub merchant_connector_id: Option<id_type::MerchantConnectorAccountId>,
pub connector: Option<String>,
pub redirection_data: Option<RedirectForm>,
// encoded_data: Option<String>,
pub unified_code: Option<Option<String>>,
pub unified_message: Option<Option<String>>,
// external_three_ds_authentication_attempted: Option<bool>,
// authentication_connector: Option<String>,
// authentication_id: Option<String>,
// fingerprint_id: Option<String>,
// charge_id: Option<String>,
// client_source: Option<String>,
// client_version: Option<String>,
// customer_acceptance: Option<pii::SecretSerdeValue>,
// card_network: Option<String>,
pub connector_token_details: Option<ConnectorTokenDetails>,
pub feature_metadata: Option<PaymentAttemptFeatureMetadata>,
pub network_decline_code: Option<String>,
pub network_advice_code: Option<String>,
pub network_error_message: Option<String>,
}
#[cfg(feature = "v1")]
#[derive(Clone, Debug, AsChangeset, router_derive::DebugAsDisplay)]
#[diesel(table_name = payment_attempt)]
pub struct PaymentAttemptUpdateInternal {
pub amount: Option<MinorUnit>,
pub net_amount: Option<MinorUnit>,
pub currency: Option<storage_enums::Currency>,
pub status: Option<storage_enums::AttemptStatus>,
pub connector_transaction_id: Option<ConnectorTransactionId>,
pub amount_to_capture: Option<MinorUnit>,
pub connector: Option<Option<String>>,
pub authentication_type: Option<storage_enums::AuthenticationType>,
pub payment_method: Option<storage_enums::PaymentMethod>,
pub error_message: Option<Option<String>>,
pub payment_method_id: Option<String>,
pub cancellation_reason: Option<String>,
pub modified_at: PrimitiveDateTime,
pub mandate_id: Option<String>,
pub browser_info: Option<serde_json::Value>,
pub payment_token: Option<String>,
pub error_code: Option<Option<String>>,
pub connector_metadata: Option<serde_json::Value>,
pub payment_method_data: Option<serde_json::Value>,
pub payment_method_type: Option<storage_enums::PaymentMethodType>,
pub payment_experience: Option<storage_enums::PaymentExperience>,
pub business_sub_label: Option<String>,
pub straight_through_algorithm: Option<serde_json::Value>,
pub preprocessing_step_id: Option<String>,
pub error_reason: Option<Option<String>>,
pub capture_method: Option<storage_enums::CaptureMethod>,
pub connector_response_reference_id: Option<String>,
pub multiple_capture_count: Option<i16>,
pub surcharge_amount: Option<MinorUnit>,
pub tax_amount: Option<MinorUnit>,
pub amount_capturable: Option<MinorUnit>,
pub updated_by: String,
pub merchant_connector_id: Option<Option<id_type::MerchantConnectorAccountId>>,
pub authentication_data: Option<serde_json::Value>,
pub encoded_data: Option<String>,
pub unified_code: Option<Option<String>>,
pub unified_message: Option<Option<String>>,
pub external_three_ds_authentication_attempted: Option<bool>,
pub authentication_connector: Option<String>,
pub authentication_id: Option<String>,
pub fingerprint_id: Option<String>,
pub payment_method_billing_address_id: Option<String>,
pub client_source: Option<String>,
pub client_version: Option<String>,
pub customer_acceptance: Option<pii::SecretSerdeValue>,
pub card_network: Option<String>,
pub capture_before: Option<PrimitiveDateTime>,
pub extended_authorization_applied: Option<ExtendedAuthorizationAppliedBool>,
pub shipping_cost: Option<MinorUnit>,
pub order_tax_amount: Option<MinorUnit>,
pub connector_mandate_detail: Option<ConnectorMandateReferenceId>,
pub processor_transaction_data: Option<String>,
pub card_discovery: Option<common_enums::CardDiscovery>,
pub charges: Option<common_types::payments::ConnectorChargeResponseData>,
pub issuer_error_code: Option<String>,
pub issuer_error_message: Option<String>,
}
#[cfg(feature = "v1")]
impl PaymentAttemptUpdateInternal {
pub fn populate_derived_fields(self, source: &PaymentAttempt) -> Self {
let mut update_internal = self;
update_internal.net_amount = Some(
update_internal.amount.unwrap_or(source.amount)
+ update_internal
.surcharge_amount
.or(source.surcharge_amount)
.unwrap_or(MinorUnit::new(0))
+ update_internal
.tax_amount
.or(source.tax_amount)
.unwrap_or(MinorUnit::new(0))
+ update_internal
.shipping_cost
.or(source.shipping_cost)
.unwrap_or(MinorUnit::new(0))
+ update_internal
.order_tax_amount
.or(source.order_tax_amount)
.unwrap_or(MinorUnit::new(0)),
);
update_internal.card_network = update_internal
.payment_method_data
.as_ref()
.and_then(|data| data.as_object())
.and_then(|card| card.get("card"))
.and_then(|data| data.as_object())
.and_then(|card| card.get("card_network"))
.and_then(|network| network.as_str())
.map(|network| network.to_string());
update_internal
}
}
#[cfg(feature = "v2")]
impl PaymentAttemptUpdate {
pub fn apply_changeset(self, source: PaymentAttempt) -> PaymentAttempt {
todo!()
// let PaymentAttemptUpdateInternal {
// net_amount,
// status,
// authentication_type,
// error_message,
// payment_method_id,
// cancellation_reason,
// modified_at: _,
// browser_info,
// payment_token,
// error_code,
// connector_metadata,
// payment_method_data,
// payment_experience,
// straight_through_algorithm,
// preprocessing_step_id,
// error_reason,
// connector_response_reference_id,
// multiple_capture_count,
// surcharge_amount,
// tax_amount,
// amount_capturable,
// updated_by,
// merchant_connector_id,
// authentication_data,
// encoded_data,
// unified_code,
// unified_message,
// external_three_ds_authentication_attempted,
// authentication_connector,
// authentication_id,
// payment_method_billing_address_id,
// fingerprint_id,
// charge_id,
// client_source,
// client_version,
// customer_acceptance,
// card_network,
// } = PaymentAttemptUpdateInternal::from(self).populate_derived_fields(&source);
// PaymentAttempt {
// net_amount: net_amount.or(source.net_amount),
// status: status.unwrap_or(source.status),
// authentication_type: authentication_type.or(source.authentication_type),
// error_message: error_message.unwrap_or(source.error_message),
// payment_method_id: payment_method_id.or(source.payment_method_id),
// cancellation_reason: cancellation_reason.or(source.cancellation_reason),
// modified_at: common_utils::date_time::now(),
// browser_info: browser_info.or(source.browser_info),
// payment_token: payment_token.or(source.payment_token),
// error_code: error_code.unwrap_or(source.error_code),
// connector_metadata: connector_metadata.or(source.connector_metadata),
// payment_method_data: payment_method_data.or(source.payment_method_data),
// payment_experience: payment_experience.or(source.payment_experience),
// straight_through_algorithm: straight_through_algorithm
// .or(source.straight_through_algorithm),
// preprocessing_step_id: preprocessing_step_id.or(source.preprocessing_step_id),
// error_reason: error_reason.unwrap_or(source.error_reason),
// connector_response_reference_id: connector_response_reference_id
// .or(source.connector_response_reference_id),
// multiple_capture_count: multiple_capture_count.or(source.multiple_capture_count),
// surcharge_amount: surcharge_amount.or(source.surcharge_amount),
// tax_amount: tax_amount.or(source.tax_amount),
// amount_capturable: amount_capturable.unwrap_or(source.amount_capturable),
// updated_by,
// merchant_connector_id: merchant_connector_id.unwrap_or(source.merchant_connector_id),
// authentication_data: authentication_data.or(source.authentication_data),
// encoded_data: encoded_data.or(source.encoded_data),
// unified_code: unified_code.unwrap_or(source.unified_code),
// unified_message: unified_message.unwrap_or(source.unified_message),
// external_three_ds_authentication_attempted: external_three_ds_authentication_attempted
// .or(source.external_three_ds_authentication_attempted),
// authentication_connector: authentication_connector.or(source.authentication_connector),
// authentication_id: authentication_id.or(source.authentication_id),
// payment_method_billing_address_id: payment_method_billing_address_id
// .or(source.payment_method_billing_address_id),
// fingerprint_id: fingerprint_id.or(source.fingerprint_id),
// charge_id: charge_id.or(source.charge_id),
// client_source: client_source.or(source.client_source),
// client_version: client_version.or(source.client_version),
// customer_acceptance: customer_acceptance.or(source.customer_acceptance),
// card_network: card_network.or(source.card_network),
// ..source
// }
}
}
#[cfg(feature = "v1")]
impl PaymentAttemptUpdate {
pub fn apply_changeset(self, source: PaymentAttempt) -> PaymentAttempt {
let PaymentAttemptUpdateInternal {
amount,
net_amount,
currency,
status,
connector_transaction_id,
amount_to_capture,
connector,
authentication_type,
payment_method,
error_message,
payment_method_id,
cancellation_reason,
modified_at: _,
mandate_id,
browser_info,
payment_token,
error_code,
connector_metadata,
payment_method_data,
payment_method_type,
payment_experience,
business_sub_label,
straight_through_algorithm,
preprocessing_step_id,
error_reason,
capture_method,
connector_response_reference_id,
multiple_capture_count,
surcharge_amount,
tax_amount,
amount_capturable,
updated_by,
merchant_connector_id,
authentication_data,
encoded_data,
unified_code,
unified_message,
external_three_ds_authentication_attempted,
authentication_connector,
authentication_id,
payment_method_billing_address_id,
fingerprint_id,
client_source,
client_version,
customer_acceptance,
card_network,
shipping_cost,
order_tax_amount,
processor_transaction_data,
connector_mandate_detail,
capture_before,
extended_authorization_applied,
card_discovery,
charges,
issuer_error_code,
issuer_error_message,
} = PaymentAttemptUpdateInternal::from(self).populate_derived_fields(&source);
PaymentAttempt {
amount: amount.unwrap_or(source.amount),
net_amount: net_amount.or(source.net_amount),
currency: currency.or(source.currency),
status: status.unwrap_or(source.status),
connector_transaction_id: connector_transaction_id.or(source.connector_transaction_id),
amount_to_capture: amount_to_capture.or(source.amount_to_capture),
connector: connector.unwrap_or(source.connector),
authentication_type: authentication_type.or(source.authentication_type),
payment_method: payment_method.or(source.payment_method),
error_message: error_message.unwrap_or(source.error_message),
payment_method_id: payment_method_id.or(source.payment_method_id),
cancellation_reason: cancellation_reason.or(source.cancellation_reason),
modified_at: common_utils::date_time::now(),
mandate_id: mandate_id.or(source.mandate_id),
browser_info: browser_info.or(source.browser_info),
payment_token: payment_token.or(source.payment_token),
error_code: error_code.unwrap_or(source.error_code),
connector_metadata: connector_metadata.or(source.connector_metadata),
payment_method_data: payment_method_data.or(source.payment_method_data),
payment_method_type: payment_method_type.or(source.payment_method_type),
payment_experience: payment_experience.or(source.payment_experience),
business_sub_label: business_sub_label.or(source.business_sub_label),
straight_through_algorithm: straight_through_algorithm
.or(source.straight_through_algorithm),
preprocessing_step_id: preprocessing_step_id.or(source.preprocessing_step_id),
error_reason: error_reason.unwrap_or(source.error_reason),
capture_method: capture_method.or(source.capture_method),
connector_response_reference_id: connector_response_reference_id
.or(source.connector_response_reference_id),
multiple_capture_count: multiple_capture_count.or(source.multiple_capture_count),
surcharge_amount: surcharge_amount.or(source.surcharge_amount),
tax_amount: tax_amount.or(source.tax_amount),
amount_capturable: amount_capturable.unwrap_or(source.amount_capturable),
updated_by,
merchant_connector_id: merchant_connector_id.unwrap_or(source.merchant_connector_id),
authentication_data: authentication_data.or(source.authentication_data),
encoded_data: encoded_data.or(source.encoded_data),
unified_code: unified_code.unwrap_or(source.unified_code),
unified_message: unified_message.unwrap_or(source.unified_message),
external_three_ds_authentication_attempted: external_three_ds_authentication_attempted
.or(source.external_three_ds_authentication_attempted),
authentication_connector: authentication_connector.or(source.authentication_connector),
authentication_id: authentication_id.or(source.authentication_id),
payment_method_billing_address_id: payment_method_billing_address_id
.or(source.payment_method_billing_address_id),
fingerprint_id: fingerprint_id.or(source.fingerprint_id),
client_source: client_source.or(source.client_source),
client_version: client_version.or(source.client_version),
customer_acceptance: customer_acceptance.or(source.customer_acceptance),
card_network: card_network.or(source.card_network),
shipping_cost: shipping_cost.or(source.shipping_cost),
order_tax_amount: order_tax_amount.or(source.order_tax_amount),
processor_transaction_data: processor_transaction_data
.or(source.processor_transaction_data),
connector_mandate_detail: connector_mandate_detail.or(source.connector_mandate_detail),
capture_before: capture_before.or(source.capture_before),
extended_authorization_applied: extended_authorization_applied
.or(source.extended_authorization_applied),
card_discovery: card_discovery.or(source.card_discovery),
charges: charges.or(source.charges),
issuer_error_code: issuer_error_code.or(source.issuer_error_code),
issuer_error_message: issuer_error_message.or(source.issuer_error_message),
..source
}
}
}
#[cfg(feature = "v2")]
impl From<PaymentAttemptUpdate> for PaymentAttemptUpdateInternal {
fn from(payment_attempt_update: PaymentAttemptUpdate) -> Self {
todo!()
// match payment_attempt_update {
// PaymentAttemptUpdate::Update {
// amount,
// currency,
// status,
// // connector_transaction_id,
// authentication_type,
// payment_method,
// payment_token,
// payment_method_data,
// payment_method_type,
// payment_experience,
// business_sub_label,
// amount_to_capture,
// capture_method,
// surcharge_amount,
// tax_amount,
// fingerprint_id,
// updated_by,
// payment_method_billing_address_id,
// } => Self {
// status: Some(status),
// // connector_transaction_id,
// authentication_type,
// payment_token,
// modified_at: common_utils::date_time::now(),
// payment_method_data,
// payment_experience,
// surcharge_amount,
// tax_amount,
// fingerprint_id,
// payment_method_billing_address_id,
// updated_by,
// net_amount: None,
// error_message: None,
// payment_method_id: None,
// cancellation_reason: None,
// browser_info: None,
// error_code: None,
// connector_metadata: None,
// straight_through_algorithm: None,
// preprocessing_step_id: None,
// error_reason: None,
// connector_response_reference_id: None,
// multiple_capture_count: None,
// amount_capturable: None,
// merchant_connector_id: None,
// authentication_data: None,
// encoded_data: None,
// unified_code: None,
// unified_message: None,
// external_three_ds_authentication_attempted: None,
// authentication_connector: None,
// authentication_id: None,
// charge_id: None,
// client_source: None,
// client_version: None,
// customer_acceptance: None,
// card_network: None,
// },
// PaymentAttemptUpdate::AuthenticationTypeUpdate {
// authentication_type,
// updated_by,
// } => Self {
// authentication_type: Some(authentication_type),
// modified_at: common_utils::date_time::now(),
// updated_by,
// net_amount: None,
// status: None,
// error_message: None,
// payment_method_id: None,
// cancellation_reason: None,
// browser_info: None,
// payment_token: None,
// error_code: None,
// connector_metadata: None,
// payment_method_data: None,
// payment_experience: None,
// straight_through_algorithm: None,
// preprocessing_step_id: None,
// error_reason: None,
// connector_response_reference_id: None,
// multiple_capture_count: None,
// surcharge_amount: None,
// tax_amount: None,
// amount_capturable: None,
// merchant_connector_id: None,
// authentication_data: None,
// encoded_data: None,
// unified_code: None,
// unified_message: None,
// external_three_ds_authentication_attempted: None,
// authentication_connector: None,
// authentication_id: None,
// fingerprint_id: None,
// payment_method_billing_address_id: None,
// charge_id: None,
// client_source: None,
// client_version: None,
// customer_acceptance: None,
// card_network: None,
// },
// PaymentAttemptUpdate::ConfirmUpdate {
// amount,
// currency,
// authentication_type,
// capture_method,
// status,
// payment_method,
// browser_info,
// connector,
// payment_token,
// payment_method_data,
// payment_method_type,
// payment_experience,
// business_sub_label,
// straight_through_algorithm,
// error_code,
// error_message,
// amount_capturable,
// updated_by,
// merchant_connector_id,
// surcharge_amount,
// tax_amount,
// external_three_ds_authentication_attempted,
// authentication_connector,
// authentication_id,
// payment_method_billing_address_id,
// fingerprint_id,
// payment_method_id,
// client_source,
// client_version,
// customer_acceptance,
// } => Self {
// authentication_type,
// status: Some(status),
// modified_at: common_utils::date_time::now(),
// browser_info,
// payment_token,
// payment_method_data,
// payment_experience,
// straight_through_algorithm,
// error_code,
// error_message,
// amount_capturable,
// updated_by,
// merchant_connector_id: merchant_connector_id.map(Some),
// surcharge_amount,
// tax_amount,
// external_three_ds_authentication_attempted,
// authentication_connector,
// authentication_id,
// payment_method_billing_address_id,
// fingerprint_id,
// payment_method_id,
// client_source,
// client_version,
// customer_acceptance,
// net_amount: None,
// cancellation_reason: None,
// connector_metadata: None,
// preprocessing_step_id: None,
// error_reason: None,
// connector_response_reference_id: None,
// multiple_capture_count: None,
// authentication_data: None,
// encoded_data: None,
// unified_code: None,
// unified_message: None,
// charge_id: None,
// card_network: None,
// },
// PaymentAttemptUpdate::VoidUpdate {
// status,
// cancellation_reason,
// updated_by,
// } => Self {
// status: Some(status),
// cancellation_reason,
// modified_at: common_utils::date_time::now(),
// updated_by,
// net_amount: None,
// authentication_type: None,
// error_message: None,
// payment_method_id: None,
// browser_info: None,
// payment_token: None,
// error_code: None,
// connector_metadata: None,
// payment_method_data: None,
// payment_experience: None,
// straight_through_algorithm: None,
// preprocessing_step_id: None,
// error_reason: None,
// connector_response_reference_id: None,
// multiple_capture_count: None,
// surcharge_amount: None,
// tax_amount: None,
// amount_capturable: None,
// merchant_connector_id: None,
// authentication_data: None,
// encoded_data: None,
// unified_code: None,
// unified_message: None,
// external_three_ds_authentication_attempted: None,
// authentication_connector: None,
// authentication_id: None,
// fingerprint_id: None,
// payment_method_billing_address_id: None,
// charge_id: None,
// client_source: None,
// client_version: None,
// customer_acceptance: None,
// card_network: None,
// },
// PaymentAttemptUpdate::RejectUpdate {
// status,
// error_code,
// error_message,
// updated_by,
// } => Self {
// status: Some(status),
// modified_at: common_utils::date_time::now(),
// error_code,
// error_message,
// updated_by,
// net_amount: None,
// authentication_type: None,
// payment_method_id: None,
// cancellation_reason: None,
// browser_info: None,
// payment_token: None,
// connector_metadata: None,
// payment_method_data: None,
// payment_experience: None,
// straight_through_algorithm: None,
// preprocessing_step_id: None,
// error_reason: None,
// connector_response_reference_id: None,
// multiple_capture_count: None,
// surcharge_amount: None,
// tax_amount: None,
// amount_capturable: None,
// merchant_connector_id: None,
// authentication_data: None,
// encoded_data: None,
// unified_code: None,
// unified_message: None,
// external_three_ds_authentication_attempted: None,
// authentication_connector: None,
// authentication_id: None,
// fingerprint_id: None,
// payment_method_billing_address_id: None,
// charge_id: None,
// client_source: None,
// client_version: None,
// customer_acceptance: None,
// card_network: None,
// },
// PaymentAttemptUpdate::BlocklistUpdate {
// status,
// error_code,
// error_message,
// updated_by,
// } => Self {
// status: Some(status),
// modified_at: common_utils::date_time::now(),
// error_code,
// error_message,
// updated_by,
// merchant_connector_id: Some(None),
// net_amount: None,
// authentication_type: None,
// payment_method_id: None,
// cancellation_reason: None,
// browser_info: None,
// payment_token: None,
// connector_metadata: None,
// payment_method_data: None,
// payment_experience: None,
// straight_through_algorithm: None,
// preprocessing_step_id: None,
// error_reason: None,
// connector_response_reference_id: None,
// multiple_capture_count: None,
// surcharge_amount: None,
// tax_amount: None,
// amount_capturable: None,
// authentication_data: None,
// encoded_data: None,
// unified_code: None,
// unified_message: None,
// external_three_ds_authentication_attempted: None,
// authentication_connector: None,
// authentication_id: None,
// fingerprint_id: None,
// payment_method_billing_address_id: None,
// charge_id: None,
// client_source: None,
// client_version: None,
// customer_acceptance: None,
// card_network: None,
// },
// PaymentAttemptUpdate::ConnectorMandateDetailUpdate {
// connector_mandate_detail,
// updated_by,
// } => Self {
// payment_method_id: None,
// modified_at: common_utils::date_time::now(),
// updated_by,
// amount: None,
// net_amount: None,
// currency: None,
// status: None,
// connector_transaction_id: None,
// amount_to_capture: None,
// connector: None,
// authentication_type: None,
// payment_method: None,
// error_message: None,
// cancellation_reason: None,
// mandate_id: None,
// browser_info: None,
// payment_token: None,
// error_code: None,
// connector_metadata: None,
// payment_method_data: None,
// payment_method_type: None,
// payment_experience: None,
// business_sub_label: None,
// straight_through_algorithm: None,
// preprocessing_step_id: None,
// error_reason: None,
// capture_method: None,
// connector_response_reference_id: None,
// multiple_capture_count: None,
// surcharge_amount: None,
// tax_amount: None,
// amount_capturable: None,
// merchant_connector_id: None,
// authentication_data: None,
// encoded_data: None,
// unified_code: None,
// unified_message: None,
// external_three_ds_authentication_attempted: None,
// authentication_connector: None,
// authentication_id: None,
// fingerprint_id: None,
// payment_method_billing_address_id: None,
// charge_id: None,
// client_source: None,
// client_version: None,
// customer_acceptance: None,
// card_network: None,
// shipping_cost: None,
// order_tax_amount: None,
// processor_transaction_data: None,
// connector_mandate_detail,
// },
// PaymentAttemptUpdate::ConnectorMandateDetailUpdate {
// payment_method_id,
// updated_by,
// } => Self {
// payment_method_id,
// modified_at: common_utils::date_time::now(),
// updated_by,
// net_amount: None,
// status: None,
// authentication_type: None,
// error_message: None,
// cancellation_reason: None,
// browser_info: None,
// payment_token: None,
// error_code: None,
// connector_metadata: None,
// payment_method_data: None,
// payment_experience: None,
// straight_through_algorithm: None,
// preprocessing_step_id: None,
// error_reason: None,
// connector_response_reference_id: None,
// multiple_capture_count: None,
// surcharge_amount: None,
// tax_amount: None,
// amount_capturable: None,
// merchant_connector_id: None,
// authentication_data: None,
// encoded_data: None,
// unified_code: None,
// unified_message: None,
// external_three_ds_authentication_attempted: None,
// authentication_connector: None,
// authentication_id: None,
// fingerprint_id: None,
// payment_method_billing_address_id: None,
// charge_id: None,
// client_source: None,
// client_version: None,
// customer_acceptance: None,
// card_network: None,
// },
// PaymentAttemptUpdate::ResponseUpdate {
// status,
// connector,
// connector_transaction_id,
// authentication_type,
// payment_method_id,
// mandate_id,
// connector_metadata,
// payment_token,
// error_code,
// error_message,
// error_reason,
// connector_response_reference_id,
// amount_capturable,
// updated_by,
// authentication_data,
// encoded_data,
// unified_code,
// unified_message,
// payment_method_data,
// charge_id,
// } => Self {
// status: Some(status),
// authentication_type,
// payment_method_id,
// modified_at: common_utils::date_time::now(),
// connector_metadata,
// error_code,
// error_message,
// payment_token,
// error_reason,
// connector_response_reference_id,
// amount_capturable,
// updated_by,
// authentication_data,
// encoded_data,
// unified_code,
// unified_message,
// payment_method_data,
// charge_id,
// net_amount: None,
// cancellation_reason: None,
// browser_info: None,
// payment_experience: None,
// straight_through_algorithm: None,
// preprocessing_step_id: None,
// multiple_capture_count: None,
// surcharge_amount: None,
// tax_amount: None,
// merchant_connector_id: None,
// external_three_ds_authentication_attempted: None,
// authentication_connector: None,
// authentication_id: None,
// fingerprint_id: None,
// payment_method_billing_address_id: None,
// client_source: None,
// client_version: None,
// customer_acceptance: None,
// card_network: None,
// },
// PaymentAttemptUpdate::ErrorUpdate {
// connector,
// status,
// error_code,
// error_message,
// error_reason,
// amount_capturable,
// updated_by,
// unified_code,
// unified_message,
// connector_transaction_id,
// payment_method_data,
// authentication_type,
// } => Self {
// status: Some(status),
// error_message,
// error_code,
// modified_at: common_utils::date_time::now(),
// error_reason,
// amount_capturable,
// updated_by,
// unified_code,
// unified_message,
// payment_method_data,
// authentication_type,
// net_amount: None,
// payment_method_id: None,
// cancellation_reason: None,
// browser_info: None,
// payment_token: None,
// connector_metadata: None,
// payment_experience: None,
// straight_through_algorithm: None,
// preprocessing_step_id: None,
// connector_response_reference_id: None,
// multiple_capture_count: None,
// surcharge_amount: None,
// tax_amount: None,
// merchant_connector_id: None,
// authentication_data: None,
// encoded_data: None,
// external_three_ds_authentication_attempted: None,
// authentication_connector: None,
// authentication_id: None,
// fingerprint_id: None,
// payment_method_billing_address_id: None,
// charge_id: None,
// client_source: None,
// client_version: None,
// customer_acceptance: None,
// card_network: None,
// },
// PaymentAttemptUpdate::StatusUpdate { status, updated_by } => Self {
// status: Some(status),
// modified_at: common_utils::date_time::now(),
// updated_by,
// net_amount: None,
// authentication_type: None,
// error_message: None,
// payment_method_id: None,
// cancellation_reason: None,
// browser_info: None,
// payment_token: None,
// error_code: None,
// connector_metadata: None,
// payment_method_data: None,
// payment_experience: None,
// straight_through_algorithm: None,
// preprocessing_step_id: None,
// error_reason: None,
// connector_response_reference_id: None,
// multiple_capture_count: None,
// surcharge_amount: None,
// tax_amount: None,
// amount_capturable: None,
// merchant_connector_id: None,
// authentication_data: None,
// encoded_data: None,
// unified_code: None,
// unified_message: None,
// external_three_ds_authentication_attempted: None,
// authentication_connector: None,
// authentication_id: None,
// fingerprint_id: None,
// payment_method_billing_address_id: None,
// charge_id: None,
// client_source: None,
// client_version: None,
// customer_acceptance: None,
// card_network: None,
// },
// PaymentAttemptUpdate::UpdateTrackers {
// payment_token,
// connector,
// straight_through_algorithm,
// amount_capturable,
// surcharge_amount,
// tax_amount,
// updated_by,
// merchant_connector_id,
// } => Self {
// payment_token,
// modified_at: common_utils::date_time::now(),
// straight_through_algorithm,
// amount_capturable,
// surcharge_amount,
// tax_amount,
// updated_by,
// merchant_connector_id: merchant_connector_id.map(Some),
// net_amount: None,
// status: None,
// authentication_type: None,
// error_message: None,
// payment_method_id: None,
// cancellation_reason: None,
// browser_info: None,
// error_code: None,
// connector_metadata: None,
// payment_method_data: None,
// payment_experience: None,
// preprocessing_step_id: None,
// error_reason: None,
// connector_response_reference_id: None,
// multiple_capture_count: None,
// authentication_data: None,
// encoded_data: None,
// unified_code: None,
// unified_message: None,
// external_three_ds_authentication_attempted: None,
// authentication_connector: None,
// authentication_id: None,
// fingerprint_id: None,
// payment_method_billing_address_id: None,
// charge_id: None,
// client_source: None,
// client_version: None,
// customer_acceptance: None,
// card_network: None,
// },
// PaymentAttemptUpdate::UnresolvedResponseUpdate {
// status,
// connector,
// connector_transaction_id,
// payment_method_id,
// error_code,
// error_message,
// error_reason,
// connector_response_reference_id,
// updated_by,
// } => Self {
// status: Some(status),
// payment_method_id,
// modified_at: common_utils::date_time::now(),
// error_code,
// error_message,
// error_reason,
// connector_response_reference_id,
// updated_by,
// net_amount: None,
// authentication_type: None,
// cancellation_reason: None,
// browser_info: None,
// payment_token: None,
// connector_metadata: None,
// payment_method_data: None,
// payment_experience: None,
// straight_through_algorithm: None,
// preprocessing_step_id: None,
// multiple_capture_count: None,
// surcharge_amount: None,
// tax_amount: None,
// amount_capturable: None,
// merchant_connector_id: None,
// authentication_data: None,
// encoded_data: None,
// unified_code: None,
// unified_message: None,
// external_three_ds_authentication_attempted: None,
// authentication_connector: None,
// authentication_id: None,
// fingerprint_id: None,
// payment_method_billing_address_id: None,
// charge_id: None,
// client_source: None,
// client_version: None,
// customer_acceptance: None,
// card_network: None,
// },
// PaymentAttemptUpdate::PreprocessingUpdate {
// status,
// payment_method_id,
// connector_metadata,
// preprocessing_step_id,
// connector_transaction_id,
// connector_response_reference_id,
// updated_by,
// } => Self {
// status: Some(status),
// payment_method_id,
// modified_at: common_utils::date_time::now(),
// connector_metadata,
// preprocessing_step_id,
// connector_response_reference_id,
// updated_by,
// net_amount: None,
// authentication_type: None,
// error_message: None,
// cancellation_reason: None,
// browser_info: None,
// payment_token: None,
// error_code: None,
// payment_method_data: None,
// payment_experience: None,
// straight_through_algorithm: None,
// error_reason: None,
// multiple_capture_count: None,
// surcharge_amount: None,
// tax_amount: None,
// amount_capturable: None,
// merchant_connector_id: None,
// authentication_data: None,
// encoded_data: None,
// unified_code: None,
// unified_message: None,
// external_three_ds_authentication_attempted: None,
// authentication_connector: None,
// authentication_id: None,
// fingerprint_id: None,
// payment_method_billing_address_id: None,
// charge_id: None,
// client_source: None,
// client_version: None,
// customer_acceptance: None,
// card_network: None,
// },
// PaymentAttemptUpdate::CaptureUpdate {
// multiple_capture_count,
// updated_by,
// amount_to_capture,
// } => Self {
// multiple_capture_count,
// modified_at: common_utils::date_time::now(),
// updated_by,
// net_amount: None,
// status: None,
// authentication_type: None,
// error_message: None,
// payment_method_id: None,
// cancellation_reason: None,
// browser_info: None,
// payment_token: None,
// error_code: None,
// connector_metadata: None,
// payment_method_data: None,
// payment_experience: None,
// straight_through_algorithm: None,
// preprocessing_step_id: None,
// error_reason: None,
// connector_response_reference_id: None,
// surcharge_amount: None,
// tax_amount: None,
// amount_capturable: None,
// merchant_connector_id: None,
// authentication_data: None,
// encoded_data: None,
// unified_code: None,
// unified_message: None,
// external_three_ds_authentication_attempted: None,
// authentication_connector: None,
// authentication_id: None,
// fingerprint_id: None,
// payment_method_billing_address_id: None,
// charge_id: None,
// client_source: None,
// client_version: None,
// customer_acceptance: None,
// card_network: None,
// },
// PaymentAttemptUpdate::AmountToCaptureUpdate {
// status,
// amount_capturable,
// updated_by,
// } => Self {
// status: Some(status),
// modified_at: common_utils::date_time::now(),
// amount_capturable: Some(amount_capturable),
// updated_by,
// net_amount: None,
// authentication_type: None,
// error_message: None,
// payment_method_id: None,
// cancellation_reason: None,
// browser_info: None,
// payment_token: None,
// error_code: None,
// connector_metadata: None,
// payment_method_data: None,
// payment_experience: None,
// straight_through_algorithm: None,
// preprocessing_step_id: None,
// error_reason: None,
// connector_response_reference_id: None,
// multiple_capture_count: None,
// surcharge_amount: None,
// tax_amount: None,
// merchant_connector_id: None,
// authentication_data: None,
// encoded_data: None,
// unified_code: None,
// unified_message: None,
// external_three_ds_authentication_attempted: None,
// authentication_connector: None,
// authentication_id: None,
// fingerprint_id: None,
// payment_method_billing_address_id: None,
// charge_id: None,
// client_source: None,
// client_version: None,
// customer_acceptance: None,
// card_network: None,
// },
// PaymentAttemptUpdate::ConnectorResponse {
// authentication_data,
// encoded_data,
// connector_transaction_id,
// connector,
// updated_by,
// charge_id,
// } => Self {
// authentication_data,
// encoded_data,
// modified_at: common_utils::date_time::now(),
// updated_by,
// charge_id,
// net_amount: None,
// status: None,
// authentication_type: None,
// error_message: None,
// payment_method_id: None,
// cancellation_reason: None,
// browser_info: None,
// payment_token: None,
// error_code: None,
// connector_metadata: None,
// payment_method_data: None,
// payment_experience: None,
// straight_through_algorithm: None,
// preprocessing_step_id: None,
// error_reason: None,
// connector_response_reference_id: None,
// multiple_capture_count: None,
// surcharge_amount: None,
// tax_amount: None,
// amount_capturable: None,
// merchant_connector_id: None,
// unified_code: None,
// unified_message: None,
// external_three_ds_authentication_attempted: None,
// authentication_connector: None,
// authentication_id: None,
// fingerprint_id: None,
// payment_method_billing_address_id: None,
// client_source: None,
// client_version: None,
// customer_acceptance: None,
// card_network: None,
// },
// PaymentAttemptUpdate::IncrementalAuthorizationAmountUpdate {
// amount,
// amount_capturable,
// } => Self {
// modified_at: common_utils::date_time::now(),
// amount_capturable: Some(amount_capturable),
// net_amount: None,
// status: None,
// authentication_type: None,
// error_message: None,
// payment_method_id: None,
// cancellation_reason: None,
// browser_info: None,
// payment_token: None,
// error_code: None,
// connector_metadata: None,
// payment_method_data: None,
// payment_experience: None,
// straight_through_algorithm: None,
// preprocessing_step_id: None,
// error_reason: None,
// connector_response_reference_id: None,
// multiple_capture_count: None,
// surcharge_amount: None,
// tax_amount: None,
// updated_by: String::default(),
// merchant_connector_id: None,
// authentication_data: None,
// encoded_data: None,
// unified_code: None,
// unified_message: None,
// external_three_ds_authentication_attempted: None,
// authentication_connector: None,
// authentication_id: None,
// fingerprint_id: None,
// payment_method_billing_address_id: None,
// charge_id: None,
// client_source: None,
// client_version: None,
// customer_acceptance: None,
// card_network: None,
// },
// PaymentAttemptUpdate::AuthenticationUpdate {
// status,
// external_three_ds_authentication_attempted,
// authentication_connector,
// authentication_id,
// updated_by,
// } => Self {
// status: Some(status),
// modified_at: common_utils::date_time::now(),
// external_three_ds_authentication_attempted,
// authentication_connector,
// authentication_id,
// updated_by,
// net_amount: None,
// authentication_type: None,
// error_message: None,
// payment_method_id: None,
// cancellation_reason: None,
// browser_info: None,
// payment_token: None,
// error_code: None,
// connector_metadata: None,
// payment_method_data: None,
// payment_experience: None,
// straight_through_algorithm: None,
// preprocessing_step_id: None,
// error_reason: None,
// connector_response_reference_id: None,
// multiple_capture_count: None,
// surcharge_amount: None,
// tax_amount: None,
// amount_capturable: None,
// merchant_connector_id: None,
// authentication_data: None,
// encoded_data: None,
// unified_code: None,
// unified_message: None,
// fingerprint_id: None,
// payment_method_billing_address_id: None,
// charge_id: None,
// client_source: None,
// client_version: None,
// customer_acceptance: None,
// card_network: None,
// },
// PaymentAttemptUpdate::ManualUpdate {
// status,
// error_code,
// error_message,
// error_reason,
// updated_by,
// unified_code,
// unified_message,
// connector_transaction_id,
// } => Self {
// status,
// error_code: error_code.map(Some),
// modified_at: common_utils::date_time::now(),
// error_message: error_message.map(Some),
// error_reason: error_reason.map(Some),
// updated_by,
// unified_code: unified_code.map(Some),
// unified_message: unified_message.map(Some),
// net_amount: None,
// authentication_type: None,
// payment_method_id: None,
// cancellation_reason: None,
// browser_info: None,
// payment_token: None,
// connector_metadata: None,
// payment_method_data: None,
// payment_experience: None,
// straight_through_algorithm: None,
// preprocessing_step_id: None,
// connector_response_reference_id: None,
// multiple_capture_count: None,
// surcharge_amount: None,
// tax_amount: None,
// amount_capturable: None,
// merchant_connector_id: None,
// authentication_data: None,
// encoded_data: None,
// external_three_ds_authentication_attempted: None,
// authentication_connector: None,
// authentication_id: None,
// fingerprint_id: None,
// payment_method_billing_address_id: None,
// charge_id: None,
// client_source: None,
// client_version: None,
// customer_acceptance: None,
// card_network: None,
// },
// }
}
}
#[cfg(feature = "v1")]
impl From<PaymentAttemptUpdate> for PaymentAttemptUpdateInternal {
fn from(payment_attempt_update: PaymentAttemptUpdate) -> Self {
match payment_attempt_update {
PaymentAttemptUpdate::Update {
amount,
currency,
status,
// connector_transaction_id,
authentication_type,
payment_method,
payment_token,
payment_method_data,
payment_method_type,
payment_experience,
business_sub_label,
amount_to_capture,
capture_method,
surcharge_amount,
tax_amount,
fingerprint_id,
updated_by,
payment_method_billing_address_id,
} => Self {
amount: Some(amount),
currency: Some(currency),
status: Some(status),
// connector_transaction_id,
authentication_type,
payment_method,
payment_token,
modified_at: common_utils::date_time::now(),
payment_method_data,
payment_method_type,
payment_experience,
business_sub_label,
amount_to_capture,
capture_method,
surcharge_amount,
tax_amount,
fingerprint_id,
payment_method_billing_address_id,
updated_by,
net_amount: None,
connector_transaction_id: None,
connector: None,
error_message: None,
payment_method_id: None,
cancellation_reason: None,
mandate_id: None,
browser_info: None,
error_code: None,
connector_metadata: None,
straight_through_algorithm: None,
preprocessing_step_id: None,
error_reason: None,
connector_response_reference_id: None,
multiple_capture_count: None,
amount_capturable: None,
merchant_connector_id: None,
authentication_data: None,
encoded_data: None,
unified_code: None,
unified_message: None,
external_three_ds_authentication_attempted: None,
authentication_connector: None,
authentication_id: None,
client_source: None,
client_version: None,
customer_acceptance: None,
card_network: None,
shipping_cost: None,
capture_before: None,
extended_authorization_applied: None,
order_tax_amount: None,
processor_transaction_data: None,
connector_mandate_detail: None,
card_discovery: None,
charges: None,
issuer_error_code: None,
issuer_error_message: None,
},
PaymentAttemptUpdate::AuthenticationTypeUpdate {
authentication_type,
updated_by,
} => Self {
authentication_type: Some(authentication_type),
modified_at: common_utils::date_time::now(),
updated_by,
amount: None,
net_amount: None,
currency: None,
status: None,
connector_transaction_id: None,
amount_to_capture: None,
connector: None,
payment_method: None,
error_message: None,
payment_method_id: None,
cancellation_reason: None,
mandate_id: None,
browser_info: None,
payment_token: None,
error_code: None,
connector_metadata: None,
payment_method_data: None,
payment_method_type: None,
payment_experience: None,
business_sub_label: None,
straight_through_algorithm: None,
preprocessing_step_id: None,
error_reason: None,
capture_method: None,
connector_response_reference_id: None,
multiple_capture_count: None,
surcharge_amount: None,
tax_amount: None,
amount_capturable: None,
merchant_connector_id: None,
authentication_data: None,
encoded_data: None,
unified_code: None,
unified_message: None,
external_three_ds_authentication_attempted: None,
authentication_connector: None,
authentication_id: None,
fingerprint_id: None,
payment_method_billing_address_id: None,
client_source: None,
client_version: None,
customer_acceptance: None,
card_network: None,
shipping_cost: None,
order_tax_amount: None,
capture_before: None,
extended_authorization_applied: None,
processor_transaction_data: None,
connector_mandate_detail: None,
card_discovery: None,
charges: None,
issuer_error_code: None,
issuer_error_message: None,
},
PaymentAttemptUpdate::ConfirmUpdate {
amount,
currency,
authentication_type,
capture_method,
status,
payment_method,
browser_info,
connector,
payment_token,
payment_method_data,
payment_method_type,
payment_experience,
business_sub_label,
straight_through_algorithm,
error_code,
error_message,
amount_capturable,
updated_by,
merchant_connector_id,
surcharge_amount,
tax_amount,
external_three_ds_authentication_attempted,
authentication_connector,
authentication_id,
payment_method_billing_address_id,
fingerprint_id,
payment_method_id,
client_source,
client_version,
customer_acceptance,
shipping_cost,
order_tax_amount,
connector_mandate_detail,
card_discovery,
} => Self {
amount: Some(amount),
currency: Some(currency),
authentication_type,
status: Some(status),
payment_method,
modified_at: common_utils::date_time::now(),
browser_info,
connector: connector.map(Some),
payment_token,
payment_method_data,
payment_method_type,
payment_experience,
business_sub_label,
straight_through_algorithm,
error_code,
error_message,
amount_capturable,
updated_by,
merchant_connector_id: merchant_connector_id.map(Some),
surcharge_amount,
tax_amount,
external_three_ds_authentication_attempted,
authentication_connector,
authentication_id,
payment_method_billing_address_id,
fingerprint_id,
payment_method_id,
capture_method,
client_source,
client_version,
customer_acceptance,
net_amount: None,
connector_transaction_id: None,
amount_to_capture: None,
cancellation_reason: None,
mandate_id: None,
connector_metadata: None,
preprocessing_step_id: None,
error_reason: None,
connector_response_reference_id: None,
multiple_capture_count: None,
authentication_data: None,
encoded_data: None,
unified_code: None,
unified_message: None,
card_network: None,
shipping_cost,
order_tax_amount,
capture_before: None,
extended_authorization_applied: None,
processor_transaction_data: None,
connector_mandate_detail,
card_discovery,
charges: None,
issuer_error_code: None,
issuer_error_message: None,
},
PaymentAttemptUpdate::VoidUpdate {
status,
cancellation_reason,
updated_by,
} => Self {
status: Some(status),
cancellation_reason,
modified_at: common_utils::date_time::now(),
updated_by,
amount: None,
net_amount: None,
currency: None,
connector_transaction_id: None,
amount_to_capture: None,
connector: None,
authentication_type: None,
payment_method: None,
error_message: None,
payment_method_id: None,
mandate_id: None,
browser_info: None,
payment_token: None,
error_code: None,
connector_metadata: None,
payment_method_data: None,
payment_method_type: None,
payment_experience: None,
business_sub_label: None,
straight_through_algorithm: None,
preprocessing_step_id: None,
error_reason: None,
capture_method: None,
connector_response_reference_id: None,
multiple_capture_count: None,
surcharge_amount: None,
tax_amount: None,
amount_capturable: None,
merchant_connector_id: None,
authentication_data: None,
encoded_data: None,
unified_code: None,
unified_message: None,
external_three_ds_authentication_attempted: None,
authentication_connector: None,
authentication_id: None,
fingerprint_id: None,
payment_method_billing_address_id: None,
client_source: None,
client_version: None,
customer_acceptance: None,
card_network: None,
shipping_cost: None,
order_tax_amount: None,
capture_before: None,
extended_authorization_applied: None,
processor_transaction_data: None,
connector_mandate_detail: None,
card_discovery: None,
charges: None,
issuer_error_code: None,
issuer_error_message: None,
},
PaymentAttemptUpdate::RejectUpdate {
status,
error_code,
error_message,
updated_by,
} => Self {
status: Some(status),
modified_at: common_utils::date_time::now(),
error_code,
error_message,
updated_by,
amount: None,
net_amount: None,
currency: None,
connector_transaction_id: None,
amount_to_capture: None,
connector: None,
authentication_type: None,
payment_method: None,
payment_method_id: None,
cancellation_reason: None,
mandate_id: None,
browser_info: None,
payment_token: None,
connector_metadata: None,
payment_method_data: None,
payment_method_type: None,
payment_experience: None,
business_sub_label: None,
straight_through_algorithm: None,
preprocessing_step_id: None,
error_reason: None,
capture_method: None,
connector_response_reference_id: None,
multiple_capture_count: None,
surcharge_amount: None,
tax_amount: None,
amount_capturable: None,
merchant_connector_id: None,
authentication_data: None,
encoded_data: None,
unified_code: None,
unified_message: None,
external_three_ds_authentication_attempted: None,
authentication_connector: None,
authentication_id: None,
fingerprint_id: None,
payment_method_billing_address_id: None,
client_source: None,
client_version: None,
customer_acceptance: None,
card_network: None,
shipping_cost: None,
order_tax_amount: None,
capture_before: None,
extended_authorization_applied: None,
processor_transaction_data: None,
connector_mandate_detail: None,
card_discovery: None,
charges: None,
issuer_error_code: None,
issuer_error_message: None,
},
PaymentAttemptUpdate::BlocklistUpdate {
status,
error_code,
error_message,
updated_by,
} => Self {
status: Some(status),
modified_at: common_utils::date_time::now(),
error_code,
connector: Some(None),
error_message,
updated_by,
merchant_connector_id: Some(None),
amount: None,
net_amount: None,
currency: None,
connector_transaction_id: None,
amount_to_capture: None,
authentication_type: None,
payment_method: None,
payment_method_id: None,
cancellation_reason: None,
mandate_id: None,
browser_info: None,
payment_token: None,
connector_metadata: None,
payment_method_data: None,
payment_method_type: None,
payment_experience: None,
business_sub_label: None,
straight_through_algorithm: None,
preprocessing_step_id: None,
error_reason: None,
capture_method: None,
connector_response_reference_id: None,
multiple_capture_count: None,
surcharge_amount: None,
tax_amount: None,
amount_capturable: None,
authentication_data: None,
encoded_data: None,
unified_code: None,
unified_message: None,
external_three_ds_authentication_attempted: None,
authentication_connector: None,
authentication_id: None,
fingerprint_id: None,
payment_method_billing_address_id: None,
client_source: None,
client_version: None,
customer_acceptance: None,
card_network: None,
shipping_cost: None,
order_tax_amount: None,
capture_before: None,
extended_authorization_applied: None,
processor_transaction_data: None,
connector_mandate_detail: None,
card_discovery: None,
charges: None,
issuer_error_code: None,
issuer_error_message: None,
},
PaymentAttemptUpdate::ConnectorMandateDetailUpdate {
connector_mandate_detail,
updated_by,
} => Self {
payment_method_id: None,
modified_at: common_utils::date_time::now(),
updated_by,
amount: None,
net_amount: None,
currency: None,
status: None,
connector_transaction_id: None,
amount_to_capture: None,
connector: None,
authentication_type: None,
payment_method: None,
error_message: None,
cancellation_reason: None,
mandate_id: None,
browser_info: None,
payment_token: None,
error_code: None,
connector_metadata: None,
payment_method_data: None,
payment_method_type: None,
payment_experience: None,
business_sub_label: None,
straight_through_algorithm: None,
preprocessing_step_id: None,
error_reason: None,
capture_method: None,
connector_response_reference_id: None,
multiple_capture_count: None,
surcharge_amount: None,
tax_amount: None,
amount_capturable: None,
merchant_connector_id: None,
authentication_data: None,
encoded_data: None,
unified_code: None,
unified_message: None,
external_three_ds_authentication_attempted: None,
authentication_connector: None,
authentication_id: None,
fingerprint_id: None,
payment_method_billing_address_id: None,
client_source: None,
client_version: None,
customer_acceptance: None,
card_network: None,
shipping_cost: None,
order_tax_amount: None,
capture_before: None,
extended_authorization_applied: None,
processor_transaction_data: None,
connector_mandate_detail,
card_discovery: None,
charges: None,
issuer_error_code: None,
issuer_error_message: None,
},
PaymentAttemptUpdate::PaymentMethodDetailsUpdate {
payment_method_id,
updated_by,
} => Self {
payment_method_id,
modified_at: common_utils::date_time::now(),
updated_by,
amount: None,
net_amount: None,
currency: None,
status: None,
connector_transaction_id: None,
amount_to_capture: None,
connector: None,
authentication_type: None,
payment_method: None,
error_message: None,
cancellation_reason: None,
mandate_id: None,
browser_info: None,
payment_token: None,
error_code: None,
connector_metadata: None,
payment_method_data: None,
payment_method_type: None,
payment_experience: None,
business_sub_label: None,
straight_through_algorithm: None,
preprocessing_step_id: None,
error_reason: None,
capture_method: None,
connector_response_reference_id: None,
multiple_capture_count: None,
surcharge_amount: None,
tax_amount: None,
amount_capturable: None,
merchant_connector_id: None,
authentication_data: None,
encoded_data: None,
unified_code: None,
unified_message: None,
external_three_ds_authentication_attempted: None,
authentication_connector: None,
authentication_id: None,
fingerprint_id: None,
payment_method_billing_address_id: None,
client_source: None,
client_version: None,
customer_acceptance: None,
card_network: None,
shipping_cost: None,
order_tax_amount: None,
capture_before: None,
extended_authorization_applied: None,
processor_transaction_data: None,
connector_mandate_detail: None,
card_discovery: None,
charges: None,
issuer_error_code: None,
issuer_error_message: None,
},
PaymentAttemptUpdate::ResponseUpdate {
status,
connector,
connector_transaction_id,
authentication_type,
payment_method_id,
mandate_id,
connector_metadata,
payment_token,
error_code,
error_message,
error_reason,
connector_response_reference_id,
amount_capturable,
updated_by,
authentication_data,
encoded_data,
unified_code,
unified_message,
capture_before,
extended_authorization_applied,
payment_method_data,
connector_mandate_detail,
charges,
} => {
let (connector_transaction_id, processor_transaction_data) =
connector_transaction_id
.map(ConnectorTransactionId::form_id_and_data)
.map(|(txn_id, txn_data)| (Some(txn_id), txn_data))
.unwrap_or((None, None));
Self {
status: Some(status),
connector: connector.map(Some),
connector_transaction_id,
authentication_type,
payment_method_id,
modified_at: common_utils::date_time::now(),
mandate_id,
connector_metadata,
error_code,
error_message,
payment_token,
error_reason,
connector_response_reference_id,
amount_capturable,
updated_by,
authentication_data,
encoded_data,
unified_code,
unified_message,
payment_method_data,
processor_transaction_data,
connector_mandate_detail,
charges,
amount: None,
net_amount: None,
currency: None,
amount_to_capture: None,
payment_method: None,
cancellation_reason: None,
browser_info: None,
payment_method_type: None,
payment_experience: None,
business_sub_label: None,
straight_through_algorithm: None,
preprocessing_step_id: None,
capture_method: None,
multiple_capture_count: None,
surcharge_amount: None,
tax_amount: None,
merchant_connector_id: None,
external_three_ds_authentication_attempted: None,
authentication_connector: None,
authentication_id: None,
fingerprint_id: None,
payment_method_billing_address_id: None,
client_source: None,
client_version: None,
customer_acceptance: None,
card_network: None,
capture_before,
extended_authorization_applied,
shipping_cost: None,
order_tax_amount: None,
card_discovery: None,
issuer_error_code: None,
issuer_error_message: None,
}
}
PaymentAttemptUpdate::ErrorUpdate {
connector,
status,
error_code,
error_message,
error_reason,
amount_capturable,
updated_by,
unified_code,
unified_message,
connector_transaction_id,
payment_method_data,
authentication_type,
issuer_error_code,
issuer_error_message,
} => {
let (connector_transaction_id, processor_transaction_data) =
connector_transaction_id
.map(ConnectorTransactionId::form_id_and_data)
.map(|(txn_id, txn_data)| (Some(txn_id), txn_data))
.unwrap_or((None, None));
Self {
connector: connector.map(Some),
status: Some(status),
error_message,
error_code,
modified_at: common_utils::date_time::now(),
error_reason,
amount_capturable,
updated_by,
unified_code,
unified_message,
connector_transaction_id,
payment_method_data,
authentication_type,
processor_transaction_data,
issuer_error_code,
issuer_error_message,
amount: None,
net_amount: None,
currency: None,
amount_to_capture: None,
payment_method: None,
payment_method_id: None,
cancellation_reason: None,
mandate_id: None,
browser_info: None,
payment_token: None,
connector_metadata: None,
payment_method_type: None,
payment_experience: None,
business_sub_label: None,
straight_through_algorithm: None,
preprocessing_step_id: None,
capture_method: None,
connector_response_reference_id: None,
multiple_capture_count: None,
surcharge_amount: None,
tax_amount: None,
merchant_connector_id: None,
authentication_data: None,
encoded_data: None,
external_three_ds_authentication_attempted: None,
authentication_connector: None,
authentication_id: None,
fingerprint_id: None,
payment_method_billing_address_id: None,
client_source: None,
client_version: None,
customer_acceptance: None,
card_network: None,
capture_before: None,
extended_authorization_applied: None,
shipping_cost: None,
order_tax_amount: None,
connector_mandate_detail: None,
card_discovery: None,
charges: None,
}
}
PaymentAttemptUpdate::StatusUpdate { status, updated_by } => Self {
status: Some(status),
modified_at: common_utils::date_time::now(),
updated_by,
amount: None,
net_amount: None,
currency: None,
connector_transaction_id: None,
amount_to_capture: None,
connector: None,
authentication_type: None,
payment_method: None,
error_message: None,
payment_method_id: None,
cancellation_reason: None,
mandate_id: None,
browser_info: None,
payment_token: None,
error_code: None,
connector_metadata: None,
payment_method_data: None,
payment_method_type: None,
payment_experience: None,
business_sub_label: None,
straight_through_algorithm: None,
preprocessing_step_id: None,
error_reason: None,
capture_method: None,
connector_response_reference_id: None,
multiple_capture_count: None,
surcharge_amount: None,
tax_amount: None,
amount_capturable: None,
merchant_connector_id: None,
authentication_data: None,
encoded_data: None,
unified_code: None,
unified_message: None,
external_three_ds_authentication_attempted: None,
authentication_connector: None,
authentication_id: None,
fingerprint_id: None,
payment_method_billing_address_id: None,
client_source: None,
client_version: None,
customer_acceptance: None,
card_network: None,
shipping_cost: None,
capture_before: None,
extended_authorization_applied: None,
order_tax_amount: None,
processor_transaction_data: None,
connector_mandate_detail: None,
card_discovery: None,
charges: None,
issuer_error_code: None,
issuer_error_message: None,
},
PaymentAttemptUpdate::UpdateTrackers {
payment_token,
connector,
straight_through_algorithm,
amount_capturable,
surcharge_amount,
tax_amount,
updated_by,
merchant_connector_id,
} => Self {
payment_token,
modified_at: common_utils::date_time::now(),
connector: connector.map(Some),
straight_through_algorithm,
amount_capturable,
surcharge_amount,
tax_amount,
updated_by,
merchant_connector_id: merchant_connector_id.map(Some),
amount: None,
net_amount: None,
currency: None,
status: None,
connector_transaction_id: None,
amount_to_capture: None,
authentication_type: None,
payment_method: None,
error_message: None,
payment_method_id: None,
cancellation_reason: None,
mandate_id: None,
browser_info: None,
error_code: None,
connector_metadata: None,
payment_method_data: None,
payment_method_type: None,
payment_experience: None,
business_sub_label: None,
preprocessing_step_id: None,
error_reason: None,
capture_method: None,
connector_response_reference_id: None,
multiple_capture_count: None,
authentication_data: None,
encoded_data: None,
unified_code: None,
unified_message: None,
external_three_ds_authentication_attempted: None,
authentication_connector: None,
authentication_id: None,
fingerprint_id: None,
payment_method_billing_address_id: None,
client_source: None,
client_version: None,
customer_acceptance: None,
card_network: None,
shipping_cost: None,
capture_before: None,
extended_authorization_applied: None,
order_tax_amount: None,
processor_transaction_data: None,
connector_mandate_detail: None,
card_discovery: None,
charges: None,
issuer_error_code: None,
issuer_error_message: None,
},
PaymentAttemptUpdate::UnresolvedResponseUpdate {
status,
connector,
connector_transaction_id,
payment_method_id,
error_code,
error_message,
error_reason,
connector_response_reference_id,
updated_by,
} => {
let (connector_transaction_id, processor_transaction_data) =
connector_transaction_id
.map(ConnectorTransactionId::form_id_and_data)
.map(|(txn_id, txn_data)| (Some(txn_id), txn_data))
.unwrap_or((None, None));
Self {
status: Some(status),
connector: connector.map(Some),
connector_transaction_id,
payment_method_id,
modified_at: common_utils::date_time::now(),
error_code,
error_message,
error_reason,
connector_response_reference_id,
updated_by,
processor_transaction_data,
amount: None,
net_amount: None,
currency: None,
amount_to_capture: None,
authentication_type: None,
payment_method: None,
cancellation_reason: None,
mandate_id: None,
browser_info: None,
payment_token: None,
connector_metadata: None,
payment_method_data: None,
payment_method_type: None,
payment_experience: None,
business_sub_label: None,
straight_through_algorithm: None,
preprocessing_step_id: None,
capture_method: None,
multiple_capture_count: None,
surcharge_amount: None,
tax_amount: None,
amount_capturable: None,
merchant_connector_id: None,
authentication_data: None,
encoded_data: None,
unified_code: None,
unified_message: None,
external_three_ds_authentication_attempted: None,
authentication_connector: None,
authentication_id: None,
fingerprint_id: None,
payment_method_billing_address_id: None,
client_source: None,
client_version: None,
customer_acceptance: None,
card_network: None,
shipping_cost: None,
capture_before: None,
extended_authorization_applied: None,
order_tax_amount: None,
connector_mandate_detail: None,
card_discovery: None,
charges: None,
issuer_error_code: None,
issuer_error_message: None,
}
}
PaymentAttemptUpdate::PreprocessingUpdate {
status,
payment_method_id,
connector_metadata,
preprocessing_step_id,
connector_transaction_id,
connector_response_reference_id,
updated_by,
} => {
let (connector_transaction_id, processor_transaction_data) =
connector_transaction_id
.map(ConnectorTransactionId::form_id_and_data)
.map(|(txn_id, txn_data)| (Some(txn_id), txn_data))
.unwrap_or((None, None));
Self {
status: Some(status),
payment_method_id,
modified_at: common_utils::date_time::now(),
connector_metadata,
preprocessing_step_id,
connector_transaction_id,
connector_response_reference_id,
updated_by,
processor_transaction_data,
amount: None,
net_amount: None,
currency: None,
amount_to_capture: None,
connector: None,
authentication_type: None,
payment_method: None,
error_message: None,
cancellation_reason: None,
mandate_id: None,
browser_info: None,
payment_token: None,
error_code: None,
payment_method_data: None,
payment_method_type: None,
payment_experience: None,
business_sub_label: None,
straight_through_algorithm: None,
error_reason: None,
capture_method: None,
multiple_capture_count: None,
surcharge_amount: None,
tax_amount: None,
amount_capturable: None,
merchant_connector_id: None,
authentication_data: None,
encoded_data: None,
unified_code: None,
unified_message: None,
external_three_ds_authentication_attempted: None,
authentication_connector: None,
authentication_id: None,
fingerprint_id: None,
payment_method_billing_address_id: None,
client_source: None,
client_version: None,
customer_acceptance: None,
card_network: None,
capture_before: None,
extended_authorization_applied: None,
shipping_cost: None,
order_tax_amount: None,
connector_mandate_detail: None,
card_discovery: None,
charges: None,
issuer_error_code: None,
issuer_error_message: None,
}
}
PaymentAttemptUpdate::CaptureUpdate {
multiple_capture_count,
updated_by,
amount_to_capture,
} => Self {
multiple_capture_count,
modified_at: common_utils::date_time::now(),
updated_by,
amount_to_capture,
amount: None,
net_amount: None,
currency: None,
status: None,
connector_transaction_id: None,
connector: None,
authentication_type: None,
payment_method: None,
error_message: None,
payment_method_id: None,
cancellation_reason: None,
mandate_id: None,
browser_info: None,
payment_token: None,
error_code: None,
connector_metadata: None,
payment_method_data: None,
payment_method_type: None,
payment_experience: None,
business_sub_label: None,
straight_through_algorithm: None,
preprocessing_step_id: None,
error_reason: None,
capture_method: None,
connector_response_reference_id: None,
surcharge_amount: None,
tax_amount: None,
amount_capturable: None,
merchant_connector_id: None,
authentication_data: None,
encoded_data: None,
unified_code: None,
unified_message: None,
external_three_ds_authentication_attempted: None,
authentication_connector: None,
authentication_id: None,
fingerprint_id: None,
payment_method_billing_address_id: None,
client_source: None,
client_version: None,
customer_acceptance: None,
card_network: None,
shipping_cost: None,
order_tax_amount: None,
capture_before: None,
extended_authorization_applied: None,
processor_transaction_data: None,
connector_mandate_detail: None,
card_discovery: None,
charges: None,
issuer_error_code: None,
issuer_error_message: None,
},
PaymentAttemptUpdate::AmountToCaptureUpdate {
status,
amount_capturable,
updated_by,
} => Self {
status: Some(status),
modified_at: common_utils::date_time::now(),
amount_capturable: Some(amount_capturable),
updated_by,
amount: None,
net_amount: None,
currency: None,
connector_transaction_id: None,
amount_to_capture: None,
connector: None,
authentication_type: None,
payment_method: None,
error_message: None,
payment_method_id: None,
cancellation_reason: None,
mandate_id: None,
browser_info: None,
payment_token: None,
error_code: None,
connector_metadata: None,
payment_method_data: None,
payment_method_type: None,
payment_experience: None,
business_sub_label: None,
straight_through_algorithm: None,
preprocessing_step_id: None,
error_reason: None,
capture_method: None,
connector_response_reference_id: None,
multiple_capture_count: None,
surcharge_amount: None,
tax_amount: None,
merchant_connector_id: None,
authentication_data: None,
encoded_data: None,
unified_code: None,
unified_message: None,
external_three_ds_authentication_attempted: None,
authentication_connector: None,
authentication_id: None,
fingerprint_id: None,
payment_method_billing_address_id: None,
client_source: None,
client_version: None,
customer_acceptance: None,
card_network: None,
shipping_cost: None,
capture_before: None,
extended_authorization_applied: None,
order_tax_amount: None,
processor_transaction_data: None,
connector_mandate_detail: None,
card_discovery: None,
charges: None,
issuer_error_code: None,
issuer_error_message: None,
},
PaymentAttemptUpdate::ConnectorResponse {
authentication_data,
encoded_data,
connector_transaction_id,
connector,
updated_by,
charges,
} => {
let (connector_transaction_id, processor_transaction_data) =
connector_transaction_id
.map(ConnectorTransactionId::form_id_and_data)
.map(|(txn_id, txn_data)| (Some(txn_id), txn_data))
.unwrap_or((None, None));
Self {
authentication_data,
encoded_data,
connector_transaction_id,
connector: connector.map(Some),
modified_at: common_utils::date_time::now(),
updated_by,
processor_transaction_data,
charges,
amount: None,
net_amount: None,
currency: None,
status: None,
amount_to_capture: None,
authentication_type: None,
payment_method: None,
error_message: None,
payment_method_id: None,
cancellation_reason: None,
mandate_id: None,
browser_info: None,
payment_token: None,
error_code: None,
connector_metadata: None,
payment_method_data: None,
payment_method_type: None,
payment_experience: None,
business_sub_label: None,
straight_through_algorithm: None,
preprocessing_step_id: None,
error_reason: None,
capture_method: None,
connector_response_reference_id: None,
multiple_capture_count: None,
surcharge_amount: None,
tax_amount: None,
amount_capturable: None,
merchant_connector_id: None,
unified_code: None,
unified_message: None,
external_three_ds_authentication_attempted: None,
authentication_connector: None,
authentication_id: None,
fingerprint_id: None,
payment_method_billing_address_id: None,
client_source: None,
client_version: None,
customer_acceptance: None,
card_network: None,
shipping_cost: None,
capture_before: None,
extended_authorization_applied: None,
order_tax_amount: None,
connector_mandate_detail: None,
card_discovery: None,
issuer_error_code: None,
issuer_error_message: None,
}
}
PaymentAttemptUpdate::IncrementalAuthorizationAmountUpdate {
amount,
amount_capturable,
} => Self {
amount: Some(amount),
modified_at: common_utils::date_time::now(),
amount_capturable: Some(amount_capturable),
net_amount: None,
currency: None,
status: None,
connector_transaction_id: None,
amount_to_capture: None,
connector: None,
authentication_type: None,
payment_method: None,
error_message: None,
payment_method_id: None,
cancellation_reason: None,
mandate_id: None,
browser_info: None,
payment_token: None,
error_code: None,
connector_metadata: None,
payment_method_data: None,
payment_method_type: None,
payment_experience: None,
business_sub_label: None,
straight_through_algorithm: None,
preprocessing_step_id: None,
error_reason: None,
capture_method: None,
connector_response_reference_id: None,
multiple_capture_count: None,
surcharge_amount: None,
tax_amount: None,
updated_by: String::default(),
merchant_connector_id: None,
authentication_data: None,
encoded_data: None,
unified_code: None,
unified_message: None,
external_three_ds_authentication_attempted: None,
authentication_connector: None,
authentication_id: None,
fingerprint_id: None,
payment_method_billing_address_id: None,
client_source: None,
client_version: None,
customer_acceptance: None,
card_network: None,
shipping_cost: None,
order_tax_amount: None,
capture_before: None,
extended_authorization_applied: None,
processor_transaction_data: None,
connector_mandate_detail: None,
card_discovery: None,
charges: None,
issuer_error_code: None,
issuer_error_message: None,
},
PaymentAttemptUpdate::AuthenticationUpdate {
status,
external_three_ds_authentication_attempted,
authentication_connector,
authentication_id,
updated_by,
} => Self {
status: Some(status),
modified_at: common_utils::date_time::now(),
external_three_ds_authentication_attempted,
authentication_connector,
authentication_id,
updated_by,
amount: None,
net_amount: None,
currency: None,
connector_transaction_id: None,
amount_to_capture: None,
connector: None,
authentication_type: None,
payment_method: None,
error_message: None,
payment_method_id: None,
cancellation_reason: None,
mandate_id: None,
browser_info: None,
payment_token: None,
error_code: None,
connector_metadata: None,
payment_method_data: None,
payment_method_type: None,
payment_experience: None,
business_sub_label: None,
straight_through_algorithm: None,
preprocessing_step_id: None,
error_reason: None,
capture_method: None,
connector_response_reference_id: None,
multiple_capture_count: None,
surcharge_amount: None,
tax_amount: None,
amount_capturable: None,
merchant_connector_id: None,
authentication_data: None,
encoded_data: None,
unified_code: None,
unified_message: None,
fingerprint_id: None,
payment_method_billing_address_id: None,
client_source: None,
client_version: None,
customer_acceptance: None,
card_network: None,
shipping_cost: None,
order_tax_amount: None,
capture_before: None,
extended_authorization_applied: None,
processor_transaction_data: None,
connector_mandate_detail: None,
card_discovery: None,
charges: None,
issuer_error_code: None,
issuer_error_message: None,
},
PaymentAttemptUpdate::ManualUpdate {
status,
error_code,
error_message,
error_reason,
updated_by,
unified_code,
unified_message,
connector_transaction_id,
} => {
let (connector_transaction_id, processor_transaction_data) =
connector_transaction_id
.map(ConnectorTransactionId::form_id_and_data)
.map(|(txn_id, txn_data)| (Some(txn_id), txn_data))
.unwrap_or((None, None));
Self {
status,
error_code: error_code.map(Some),
modified_at: common_utils::date_time::now(),
error_message: error_message.map(Some),
error_reason: error_reason.map(Some),
updated_by,
unified_code: unified_code.map(Some),
unified_message: unified_message.map(Some),
connector_transaction_id,
processor_transaction_data,
amount: None,
net_amount: None,
currency: None,
amount_to_capture: None,
connector: None,
authentication_type: None,
payment_method: None,
payment_method_id: None,
cancellation_reason: None,
mandate_id: None,
browser_info: None,
payment_token: None,
connector_metadata: None,
payment_method_data: None,
payment_method_type: None,
payment_experience: None,
business_sub_label: None,
straight_through_algorithm: None,
preprocessing_step_id: None,
capture_method: None,
connector_response_reference_id: None,
multiple_capture_count: None,
surcharge_amount: None,
tax_amount: None,
amount_capturable: None,
merchant_connector_id: None,
authentication_data: None,
encoded_data: None,
external_three_ds_authentication_attempted: None,
authentication_connector: None,
authentication_id: None,
fingerprint_id: None,
payment_method_billing_address_id: None,
client_source: None,
client_version: None,
customer_acceptance: None,
card_network: None,
shipping_cost: None,
capture_before: None,
extended_authorization_applied: None,
order_tax_amount: None,
connector_mandate_detail: None,
card_discovery: None,
charges: None,
issuer_error_code: None,
issuer_error_message: None,
}
}
PaymentAttemptUpdate::PostSessionTokensUpdate {
updated_by,
connector_metadata,
} => Self {
status: None,
error_code: None,
modified_at: common_utils::date_time::now(),
error_message: None,
error_reason: None,
updated_by,
unified_code: None,
unified_message: None,
amount: None,
net_amount: None,
currency: None,
connector_transaction_id: None,
amount_to_capture: None,
connector: None,
authentication_type: None,
payment_method: None,
payment_method_id: None,
cancellation_reason: None,
mandate_id: None,
browser_info: None,
payment_token: None,
connector_metadata,
payment_method_data: None,
payment_method_type: None,
payment_experience: None,
business_sub_label: None,
straight_through_algorithm: None,
preprocessing_step_id: None,
capture_method: None,
connector_response_reference_id: None,
multiple_capture_count: None,
surcharge_amount: None,
tax_amount: None,
amount_capturable: None,
merchant_connector_id: None,
authentication_data: None,
encoded_data: None,
external_three_ds_authentication_attempted: None,
authentication_connector: None,
authentication_id: None,
fingerprint_id: None,
payment_method_billing_address_id: None,
client_source: None,
client_version: None,
customer_acceptance: None,
card_network: None,
shipping_cost: None,
order_tax_amount: None,
capture_before: None,
extended_authorization_applied: None,
processor_transaction_data: None,
connector_mandate_detail: None,
card_discovery: None,
charges: None,
issuer_error_code: None,
issuer_error_message: None,
},
}
}
}
#[derive(Eq, PartialEq, Clone, Debug, Deserialize, Serialize, diesel::AsExpression)]
#[diesel(sql_type = diesel::sql_types::Jsonb)]
pub enum RedirectForm {
Form {
endpoint: String,
method: common_utils::request::Method,
form_fields: std::collections::HashMap<String, String>,
},
Html {
html_data: String,
},
BlueSnap {
payment_fields_token: String,
},
CybersourceAuthSetup {
access_token: String,
ddc_url: String,
reference_id: String,
},
CybersourceConsumerAuth {
access_token: String,
step_up_url: String,
},
DeutschebankThreeDSChallengeFlow {
acs_url: String,
creq: String,
},
Payme,
Braintree {
client_token: String,
card_token: String,
bin: String,
acs_url: String,
},
Nmi {
amount: String,
currency: common_enums::Currency,
public_key: masking::Secret<String>,
customer_vault_id: String,
order_id: String,
},
Mifinity {
initialization_token: String,
},
WorldpayDDCForm {
endpoint: common_utils::types::Url,
method: common_utils::request::Method,
form_fields: std::collections::HashMap<String, String>,
collection_id: Option<String>,
},
}
common_utils::impl_to_sql_from_sql_json!(RedirectForm);
#[cfg(feature = "v2")]
#[derive(
Clone, Debug, serde::Deserialize, serde::Serialize, Eq, PartialEq, diesel::AsExpression,
)]
#[diesel(sql_type = diesel::pg::sql_types::Jsonb)]
pub struct PaymentAttemptFeatureMetadata {
pub revenue_recovery: Option<PaymentAttemptRecoveryData>,
}
#[cfg(feature = "v2")]
#[derive(
Clone, Debug, serde::Deserialize, serde::Serialize, Eq, PartialEq, diesel::AsExpression,
)]
#[diesel(sql_type = diesel::pg::sql_types::Jsonb)]
pub struct PaymentAttemptRecoveryData {
pub attempt_triggered_by: common_enums::TriggeredBy,
}
#[cfg(feature = "v2")]
common_utils::impl_to_sql_from_sql_json!(PaymentAttemptFeatureMetadata);
mod tests {
#[test]
fn test_backwards_compatibility() {
let serialized_payment_attempt = r#"{
"payment_id": "PMT123456789",
"merchant_id": "M123456789",
"attempt_id": "ATMPT123456789",
"status": "pending",
"amount": 10000,
"currency": "USD",
"save_to_locker": true,
"connector": "stripe",
"error_message": null,
"offer_amount": 9500,
"surcharge_amount": 500,
"tax_amount": 800,
"payment_method_id": "CRD123456789",
"payment_method": "card",
"connector_transaction_id": "CNTR123456789",
"capture_method": "automatic",
"capture_on": "2022-09-10T10:11:12Z",
"confirm": false,
"authentication_type": "no_three_ds",
"created_at": "2024-02-26T12:00:00Z",
"modified_at": "2024-02-26T12:00:00Z",
"last_synced": null,
"cancellation_reason": null,
"amount_to_capture": 10000,
"mandate_id": null,
"browser_info": {
"user_agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/70.0.3538.110 Safari/537.36",
"accept_header": "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8",
"language": "nl-NL",
"color_depth": 24,
"screen_height": 723,
"screen_width": 1536,
"time_zone": 0,
"java_enabled": true,
"java_script_enabled": true,
"ip_address": "127.0.0.1"
},
"error_code": null,
"payment_token": "TOKEN123456789",
"connector_metadata": null,
"payment_experience": "redirect_to_url",
"payment_method_type": "credit",
"payment_method_data": {
"card": {
"card_number": "4242424242424242",
"card_exp_month": "10",
"card_cvc": "123",
"card_exp_year": "2024",
"card_holder_name": "John Doe"
}
},
"business_sub_label": "Premium",
"straight_through_algorithm": null,
"preprocessing_step_id": null,
"mandate_details": null,
"error_reason": null,
"multiple_capture_count": 0,
"connector_response_reference_id": null,
"amount_capturable": 10000,
"updated_by": "redis_kv",
"merchant_connector_id": "MCN123456789",
"authentication_data": null,
"encoded_data": null,
"unified_code": null,
"unified_message": null,
"net_amount": 10200,
"mandate_data": {
"customer_acceptance": {
"acceptance_type": "offline",
"accepted_at": "1963-05-03T04:07:52.723Z",
"online": {
"ip_address": "127.0.0.1",
"user_agent": "amet irure esse"
}
},
"single_use": {
"amount": 6540,
"currency": "USD"
}
}
},
"fingerprint_id": null
}"#;
let deserialized =
serde_json::from_str::<super::PaymentAttempt>(serialized_payment_attempt);
assert!(deserialized.is_ok());
}
}
| proc_macro_neighborhoods |
<|meta_start|><|file|> hyperswitch/crates/router_derive/src/lib.rs<|crate|> diesel_models macro=DebugAsDisplay roles=use_site,macro_def use=derive item=file pack=proc_macro_neighborhoods lang=rust<|meta_end|>
<file_sep path="hyperswitch/crates/diesel_models/src/payment_attempt.rs" crate="diesel_models" role="use_site">
use common_types::primitive_wrappers::{
ExtendedAuthorizationAppliedBool, RequestExtendedAuthorizationBool,
};
use common_utils::{
id_type, pii,
types::{ConnectorTransactionId, ConnectorTransactionIdTrait, MinorUnit},
};
use diesel::{AsChangeset, Identifiable, Insertable, Queryable, Selectable};
use serde::{Deserialize, Serialize};
use time::PrimitiveDateTime;
use crate::enums as storage_enums;
#[cfg(feature = "v1")]
use crate::schema::payment_attempt;
#[cfg(feature = "v2")]
use crate::schema_v2::payment_attempt;
common_utils::impl_to_sql_from_sql_json!(ConnectorMandateReferenceId);
#[derive(
Clone, Debug, serde::Deserialize, serde::Serialize, Eq, PartialEq, diesel::AsExpression,
)]
#[diesel(sql_type = diesel::sql_types::Jsonb)]
pub struct ConnectorMandateReferenceId {
pub connector_mandate_id: Option<String>,
pub payment_method_id: Option<String>,
pub mandate_metadata: Option<pii::SecretSerdeValue>,
pub connector_mandate_request_reference_id: Option<String>,
}
impl ConnectorMandateReferenceId {
pub fn get_connector_mandate_request_reference_id(&self) -> Option<String> {
self.connector_mandate_request_reference_id.clone()
}
}
#[cfg(feature = "v2")]
#[derive(
Clone, Debug, Eq, PartialEq, Identifiable, Queryable, Serialize, Deserialize, Selectable,
)]
#[diesel(table_name = payment_attempt, primary_key(id), check_for_backend(diesel::pg::Pg))]
pub struct PaymentAttempt {
pub payment_id: id_type::GlobalPaymentId,
pub merchant_id: id_type::MerchantId,
pub status: storage_enums::AttemptStatus,
pub connector: Option<String>,
pub error_message: Option<String>,
pub surcharge_amount: Option<MinorUnit>,
pub payment_method_id: Option<id_type::GlobalPaymentMethodId>,
pub authentication_type: storage_enums::AuthenticationType,
#[serde(with = "common_utils::custom_serde::iso8601")]
pub created_at: PrimitiveDateTime,
#[serde(with = "common_utils::custom_serde::iso8601")]
pub modified_at: PrimitiveDateTime,
#[serde(default, with = "common_utils::custom_serde::iso8601::option")]
pub last_synced: Option<PrimitiveDateTime>,
pub cancellation_reason: Option<String>,
pub amount_to_capture: Option<MinorUnit>,
pub browser_info: Option<common_utils::types::BrowserInformation>,
pub error_code: Option<String>,
pub payment_token: Option<String>,
pub connector_metadata: Option<pii::SecretSerdeValue>,
pub payment_experience: Option<storage_enums::PaymentExperience>,
pub payment_method_data: Option<pii::SecretSerdeValue>,
pub preprocessing_step_id: Option<String>,
pub error_reason: Option<String>,
pub multiple_capture_count: Option<i16>,
pub connector_response_reference_id: Option<String>,
pub amount_capturable: MinorUnit,
pub updated_by: String,
pub merchant_connector_id: Option<id_type::MerchantConnectorAccountId>,
pub encoded_data: Option<masking::Secret<String>>,
pub unified_code: Option<String>,
pub unified_message: Option<String>,
pub net_amount: MinorUnit,
pub external_three_ds_authentication_attempted: Option<bool>,
pub authentication_connector: Option<String>,
pub authentication_id: Option<String>,
pub fingerprint_id: Option<String>,
pub client_source: Option<String>,
pub client_version: Option<String>,
pub customer_acceptance: Option<pii::SecretSerdeValue>,
pub profile_id: id_type::ProfileId,
pub organization_id: id_type::OrganizationId,
pub card_network: Option<String>,
pub shipping_cost: Option<MinorUnit>,
pub order_tax_amount: Option<MinorUnit>,
pub request_extended_authorization: Option<RequestExtendedAuthorizationBool>,
pub extended_authorization_applied: Option<ExtendedAuthorizationAppliedBool>,
pub capture_before: Option<PrimitiveDateTime>,
pub card_discovery: Option<storage_enums::CardDiscovery>,
pub charges: Option<common_types::payments::ConnectorChargeResponseData>,
pub payment_method_type_v2: storage_enums::PaymentMethod,
pub connector_payment_id: Option<ConnectorTransactionId>,
pub payment_method_subtype: storage_enums::PaymentMethodType,
pub routing_result: Option<serde_json::Value>,
pub authentication_applied: Option<common_enums::AuthenticationType>,
pub external_reference_id: Option<String>,
pub tax_on_surcharge: Option<MinorUnit>,
pub payment_method_billing_address: Option<common_utils::encryption::Encryption>,
pub redirection_data: Option<RedirectForm>,
pub connector_payment_data: Option<String>,
pub connector_token_details: Option<ConnectorTokenDetails>,
pub id: id_type::GlobalAttemptId,
pub feature_metadata: Option<PaymentAttemptFeatureMetadata>,
/// This field can be returned for both approved and refused Mastercard payments.
/// This code provides additional information about the type of transaction or the reason why the payment failed.
/// If the payment failed, the network advice code gives guidance on if and when you can retry the payment.
pub network_advice_code: Option<String>,
/// For card errors resulting from a card issuer decline, a brand specific 2, 3, or 4 digit code which indicates the reason the authorization failed.
pub network_decline_code: Option<String>,
/// A string indicating how to proceed with an network error if payment gateway provide one. This is used to understand the network error code better.
pub network_error_message: Option<String>,
}
#[cfg(feature = "v1")]
#[derive(
Clone, Debug, Eq, PartialEq, Identifiable, Queryable, Serialize, Deserialize, Selectable,
)]
#[diesel(table_name = payment_attempt, primary_key(attempt_id, merchant_id), check_for_backend(diesel::pg::Pg))]
pub struct PaymentAttempt {
pub payment_id: id_type::PaymentId,
pub merchant_id: id_type::MerchantId,
pub attempt_id: String,
pub status: storage_enums::AttemptStatus,
pub amount: MinorUnit,
pub currency: Option<storage_enums::Currency>,
pub save_to_locker: Option<bool>,
pub connector: Option<String>,
pub error_message: Option<String>,
pub offer_amount: Option<MinorUnit>,
pub surcharge_amount: Option<MinorUnit>,
pub tax_amount: Option<MinorUnit>,
pub payment_method_id: Option<String>,
pub payment_method: Option<storage_enums::PaymentMethod>,
pub connector_transaction_id: Option<ConnectorTransactionId>,
pub capture_method: Option<storage_enums::CaptureMethod>,
#[serde(default, with = "common_utils::custom_serde::iso8601::option")]
pub capture_on: Option<PrimitiveDateTime>,
pub confirm: bool,
pub authentication_type: Option<storage_enums::AuthenticationType>,
#[serde(with = "common_utils::custom_serde::iso8601")]
pub created_at: PrimitiveDateTime,
#[serde(with = "common_utils::custom_serde::iso8601")]
pub modified_at: PrimitiveDateTime,
#[serde(default, with = "common_utils::custom_serde::iso8601::option")]
pub last_synced: Option<PrimitiveDateTime>,
pub cancellation_reason: Option<String>,
pub amount_to_capture: Option<MinorUnit>,
pub mandate_id: Option<String>,
pub browser_info: Option<serde_json::Value>,
pub error_code: Option<String>,
pub payment_token: Option<String>,
pub connector_metadata: Option<serde_json::Value>,
pub payment_experience: Option<storage_enums::PaymentExperience>,
pub payment_method_type: Option<storage_enums::PaymentMethodType>,
pub payment_method_data: Option<serde_json::Value>,
pub business_sub_label: Option<String>,
pub straight_through_algorithm: Option<serde_json::Value>,
pub preprocessing_step_id: Option<String>,
// providing a location to store mandate details intermediately for transaction
pub mandate_details: Option<storage_enums::MandateDataType>,
pub error_reason: Option<String>,
pub multiple_capture_count: Option<i16>,
// reference to the payment at connector side
pub connector_response_reference_id: Option<String>,
pub amount_capturable: MinorUnit,
pub updated_by: String,
pub merchant_connector_id: Option<id_type::MerchantConnectorAccountId>,
pub authentication_data: Option<serde_json::Value>,
pub encoded_data: Option<String>,
pub unified_code: Option<String>,
pub unified_message: Option<String>,
pub net_amount: Option<MinorUnit>,
pub external_three_ds_authentication_attempted: Option<bool>,
pub authentication_connector: Option<String>,
pub authentication_id: Option<String>,
pub mandate_data: Option<storage_enums::MandateDetails>,
pub fingerprint_id: Option<String>,
pub payment_method_billing_address_id: Option<String>,
pub charge_id: Option<String>,
pub client_source: Option<String>,
pub client_version: Option<String>,
pub customer_acceptance: Option<pii::SecretSerdeValue>,
pub profile_id: id_type::ProfileId,
pub organization_id: id_type::OrganizationId,
pub card_network: Option<String>,
pub shipping_cost: Option<MinorUnit>,
pub order_tax_amount: Option<MinorUnit>,
/// INFO: This field is deprecated and replaced by processor_transaction_data
pub connector_transaction_data: Option<String>,
pub connector_mandate_detail: Option<ConnectorMandateReferenceId>,
pub request_extended_authorization: Option<RequestExtendedAuthorizationBool>,
pub extended_authorization_applied: Option<ExtendedAuthorizationAppliedBool>,
pub capture_before: Option<PrimitiveDateTime>,
pub processor_transaction_data: Option<String>,
pub card_discovery: Option<storage_enums::CardDiscovery>,
pub charges: Option<common_types::payments::ConnectorChargeResponseData>,
pub issuer_error_code: Option<String>,
pub issuer_error_message: Option<String>,
}
#[cfg(feature = "v1")]
impl ConnectorTransactionIdTrait for PaymentAttempt {
fn get_optional_connector_transaction_id(&self) -> Option<&String> {
match self
.connector_transaction_id
.as_ref()
.map(|txn_id| txn_id.get_txn_id(self.processor_transaction_data.as_ref()))
.transpose()
{
Ok(txn_id) => txn_id,
// In case hashed data is missing from DB, use the hashed ID as connector transaction ID
Err(_) => self
.connector_transaction_id
.as_ref()
.map(|txn_id| txn_id.get_id()),
}
}
}
#[cfg(feature = "v2")]
impl ConnectorTransactionIdTrait for PaymentAttempt {
fn get_optional_connector_transaction_id(&self) -> Option<&String> {
match self
.connector_payment_id
.as_ref()
.map(|txn_id| txn_id.get_txn_id(self.connector_payment_data.as_ref()))
.transpose()
{
Ok(txn_id) => txn_id,
// In case hashed data is missing from DB, use the hashed ID as connector payment ID
Err(_) => self
.connector_payment_id
.as_ref()
.map(|txn_id| txn_id.get_id()),
}
}
}
#[cfg(feature = "v2")]
#[derive(
Clone, Debug, PartialEq, Eq, serde::Deserialize, serde::Serialize, diesel::AsExpression,
)]
#[diesel(sql_type = diesel::sql_types::Jsonb)]
pub struct ConnectorTokenDetails {
pub connector_mandate_id: Option<String>,
pub connector_token_request_reference_id: Option<String>,
}
#[cfg(feature = "v2")]
common_utils::impl_to_sql_from_sql_json!(ConnectorTokenDetails);
#[cfg(feature = "v2")]
impl ConnectorTokenDetails {
pub fn get_connector_token_request_reference_id(&self) -> Option<String> {
self.connector_token_request_reference_id.clone()
}
}
#[derive(Clone, Debug, Eq, PartialEq, Queryable, Serialize, Deserialize)]
pub struct PaymentListFilters {
pub connector: Vec<String>,
pub currency: Vec<storage_enums::Currency>,
pub status: Vec<storage_enums::IntentStatus>,
pub payment_method: Vec<storage_enums::PaymentMethod>,
}
#[cfg(feature = "v2")]
#[derive(Clone, Debug, Insertable, router_derive::DebugAsDisplay, Serialize, Deserialize)]
#[diesel(table_name = payment_attempt)]
pub struct PaymentAttemptNew {
pub payment_id: id_type::GlobalPaymentId,
pub merchant_id: id_type::MerchantId,
pub status: storage_enums::AttemptStatus,
pub error_message: Option<String>,
pub surcharge_amount: Option<MinorUnit>,
pub tax_on_surcharge: Option<MinorUnit>,
pub payment_method_id: Option<id_type::GlobalPaymentMethodId>,
pub authentication_type: storage_enums::AuthenticationType,
#[serde(with = "common_utils::custom_serde::iso8601")]
pub created_at: PrimitiveDateTime,
#[serde(with = "common_utils::custom_serde::iso8601")]
pub modified_at: PrimitiveDateTime,
#[serde(default, with = "common_utils::custom_serde::iso8601::option")]
pub last_synced: Option<PrimitiveDateTime>,
pub cancellation_reason: Option<String>,
pub amount_to_capture: Option<MinorUnit>,
pub browser_info: Option<common_utils::types::BrowserInformation>,
pub payment_token: Option<String>,
pub error_code: Option<String>,
pub connector_metadata: Option<pii::SecretSerdeValue>,
pub payment_experience: Option<storage_enums::PaymentExperience>,
pub payment_method_data: Option<pii::SecretSerdeValue>,
pub preprocessing_step_id: Option<String>,
pub error_reason: Option<String>,
pub connector_response_reference_id: Option<String>,
pub multiple_capture_count: Option<i16>,
pub amount_capturable: MinorUnit,
pub updated_by: String,
pub merchant_connector_id: Option<id_type::MerchantConnectorAccountId>,
pub redirection_data: Option<RedirectForm>,
pub encoded_data: Option<masking::Secret<String>>,
pub unified_code: Option<String>,
pub unified_message: Option<String>,
pub net_amount: MinorUnit,
pub external_three_ds_authentication_attempted: Option<bool>,
pub authentication_connector: Option<String>,
pub authentication_id: Option<String>,
pub fingerprint_id: Option<String>,
pub payment_method_billing_address: Option<common_utils::encryption::Encryption>,
pub client_source: Option<String>,
pub client_version: Option<String>,
pub customer_acceptance: Option<pii::SecretSerdeValue>,
pub profile_id: id_type::ProfileId,
pub organization_id: id_type::OrganizationId,
pub card_network: Option<String>,
pub shipping_cost: Option<MinorUnit>,
pub order_tax_amount: Option<MinorUnit>,
pub charges: Option<common_types::payments::ConnectorChargeResponseData>,
pub feature_metadata: Option<PaymentAttemptFeatureMetadata>,
pub payment_method_type_v2: storage_enums::PaymentMethod,
pub connector_payment_id: Option<ConnectorTransactionId>,
pub payment_method_subtype: storage_enums::PaymentMethodType,
pub id: id_type::GlobalAttemptId,
pub connector_token_details: Option<ConnectorTokenDetails>,
pub card_discovery: Option<storage_enums::CardDiscovery>,
pub request_extended_authorization: Option<RequestExtendedAuthorizationBool>,
pub extended_authorization_applied: Option<ExtendedAuthorizationAppliedBool>,
pub capture_before: Option<PrimitiveDateTime>,
pub connector: Option<String>,
pub network_decline_code: Option<String>,
pub network_advice_code: Option<String>,
pub network_error_message: Option<String>,
}
#[cfg(feature = "v1")]
#[derive(Clone, Debug, Insertable, router_derive::DebugAsDisplay, Serialize, Deserialize)]
#[diesel(table_name = payment_attempt)]
pub struct PaymentAttemptNew {
pub payment_id: id_type::PaymentId,
pub merchant_id: id_type::MerchantId,
pub attempt_id: String,
pub status: storage_enums::AttemptStatus,
pub amount: MinorUnit,
pub currency: Option<storage_enums::Currency>,
// pub auto_capture: Option<bool>,
pub save_to_locker: Option<bool>,
pub connector: Option<String>,
pub error_message: Option<String>,
pub offer_amount: Option<MinorUnit>,
pub surcharge_amount: Option<MinorUnit>,
pub tax_amount: Option<MinorUnit>,
pub payment_method_id: Option<String>,
pub payment_method: Option<storage_enums::PaymentMethod>,
pub capture_method: Option<storage_enums::CaptureMethod>,
#[serde(default, with = "common_utils::custom_serde::iso8601::option")]
pub capture_on: Option<PrimitiveDateTime>,
pub confirm: bool,
pub authentication_type: Option<storage_enums::AuthenticationType>,
#[serde(with = "common_utils::custom_serde::iso8601")]
pub created_at: PrimitiveDateTime,
#[serde(with = "common_utils::custom_serde::iso8601")]
pub modified_at: PrimitiveDateTime,
#[serde(default, with = "common_utils::custom_serde::iso8601::option")]
pub last_synced: Option<PrimitiveDateTime>,
pub cancellation_reason: Option<String>,
pub amount_to_capture: Option<MinorUnit>,
pub mandate_id: Option<String>,
pub browser_info: Option<serde_json::Value>,
pub payment_token: Option<String>,
pub error_code: Option<String>,
pub connector_metadata: Option<serde_json::Value>,
pub payment_experience: Option<storage_enums::PaymentExperience>,
pub payment_method_type: Option<storage_enums::PaymentMethodType>,
pub payment_method_data: Option<serde_json::Value>,
pub business_sub_label: Option<String>,
pub straight_through_algorithm: Option<serde_json::Value>,
pub preprocessing_step_id: Option<String>,
pub mandate_details: Option<storage_enums::MandateDataType>,
pub error_reason: Option<String>,
pub connector_response_reference_id: Option<String>,
pub multiple_capture_count: Option<i16>,
pub amount_capturable: MinorUnit,
pub updated_by: String,
pub merchant_connector_id: Option<id_type::MerchantConnectorAccountId>,
pub authentication_data: Option<serde_json::Value>,
pub encoded_data: Option<String>,
pub unified_code: Option<String>,
pub unified_message: Option<String>,
pub net_amount: Option<MinorUnit>,
pub external_three_ds_authentication_attempted: Option<bool>,
pub authentication_connector: Option<String>,
pub authentication_id: Option<String>,
pub mandate_data: Option<storage_enums::MandateDetails>,
pub fingerprint_id: Option<String>,
pub payment_method_billing_address_id: Option<String>,
pub client_source: Option<String>,
pub client_version: Option<String>,
pub customer_acceptance: Option<pii::SecretSerdeValue>,
pub profile_id: id_type::ProfileId,
pub organization_id: id_type::OrganizationId,
pub card_network: Option<String>,
pub shipping_cost: Option<MinorUnit>,
pub order_tax_amount: Option<MinorUnit>,
pub connector_mandate_detail: Option<ConnectorMandateReferenceId>,
pub request_extended_authorization: Option<RequestExtendedAuthorizationBool>,
pub extended_authorization_applied: Option<ExtendedAuthorizationAppliedBool>,
#[serde(default, with = "common_utils::custom_serde::iso8601::option")]
pub capture_before: Option<PrimitiveDateTime>,
pub card_discovery: Option<storage_enums::CardDiscovery>,
}
#[cfg(feature = "v1")]
#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum PaymentAttemptUpdate {
Update {
amount: MinorUnit,
currency: storage_enums::Currency,
status: storage_enums::AttemptStatus,
authentication_type: Option<storage_enums::AuthenticationType>,
payment_method: Option<storage_enums::PaymentMethod>,
payment_token: Option<String>,
payment_method_data: Option<serde_json::Value>,
payment_method_type: Option<storage_enums::PaymentMethodType>,
payment_experience: Option<storage_enums::PaymentExperience>,
business_sub_label: Option<String>,
amount_to_capture: Option<MinorUnit>,
capture_method: Option<storage_enums::CaptureMethod>,
surcharge_amount: Option<MinorUnit>,
tax_amount: Option<MinorUnit>,
fingerprint_id: Option<String>,
payment_method_billing_address_id: Option<String>,
updated_by: String,
},
UpdateTrackers {
payment_token: Option<String>,
connector: Option<String>,
straight_through_algorithm: Option<serde_json::Value>,
amount_capturable: Option<MinorUnit>,
surcharge_amount: Option<MinorUnit>,
tax_amount: Option<MinorUnit>,
updated_by: String,
merchant_connector_id: Option<id_type::MerchantConnectorAccountId>,
},
AuthenticationTypeUpdate {
authentication_type: storage_enums::AuthenticationType,
updated_by: String,
},
ConfirmUpdate {
amount: MinorUnit,
currency: storage_enums::Currency,
status: storage_enums::AttemptStatus,
authentication_type: Option<storage_enums::AuthenticationType>,
capture_method: Option<storage_enums::CaptureMethod>,
payment_method: Option<storage_enums::PaymentMethod>,
browser_info: Option<serde_json::Value>,
connector: Option<String>,
payment_token: Option<String>,
payment_method_data: Option<serde_json::Value>,
payment_method_type: Option<storage_enums::PaymentMethodType>,
payment_experience: Option<storage_enums::PaymentExperience>,
business_sub_label: Option<String>,
straight_through_algorithm: Option<serde_json::Value>,
error_code: Option<Option<String>>,
error_message: Option<Option<String>>,
amount_capturable: Option<MinorUnit>,
surcharge_amount: Option<MinorUnit>,
tax_amount: Option<MinorUnit>,
fingerprint_id: Option<String>,
updated_by: String,
merchant_connector_id: Option<id_type::MerchantConnectorAccountId>,
payment_method_id: Option<String>,
external_three_ds_authentication_attempted: Option<bool>,
authentication_connector: Option<String>,
authentication_id: Option<String>,
payment_method_billing_address_id: Option<String>,
client_source: Option<String>,
client_version: Option<String>,
customer_acceptance: Option<pii::SecretSerdeValue>,
shipping_cost: Option<MinorUnit>,
order_tax_amount: Option<MinorUnit>,
connector_mandate_detail: Option<ConnectorMandateReferenceId>,
card_discovery: Option<storage_enums::CardDiscovery>,
},
VoidUpdate {
status: storage_enums::AttemptStatus,
cancellation_reason: Option<String>,
updated_by: String,
},
PaymentMethodDetailsUpdate {
payment_method_id: Option<String>,
updated_by: String,
},
ConnectorMandateDetailUpdate {
connector_mandate_detail: Option<ConnectorMandateReferenceId>,
updated_by: String,
},
BlocklistUpdate {
status: storage_enums::AttemptStatus,
error_code: Option<Option<String>>,
error_message: Option<Option<String>>,
updated_by: String,
},
RejectUpdate {
status: storage_enums::AttemptStatus,
error_code: Option<Option<String>>,
error_message: Option<Option<String>>,
updated_by: String,
},
ResponseUpdate {
status: storage_enums::AttemptStatus,
connector: Option<String>,
connector_transaction_id: Option<String>,
authentication_type: Option<storage_enums::AuthenticationType>,
payment_method_id: Option<String>,
mandate_id: Option<String>,
connector_metadata: Option<serde_json::Value>,
payment_token: Option<String>,
error_code: Option<Option<String>>,
error_message: Option<Option<String>>,
error_reason: Option<Option<String>>,
connector_response_reference_id: Option<String>,
amount_capturable: Option<MinorUnit>,
updated_by: String,
authentication_data: Option<serde_json::Value>,
encoded_data: Option<String>,
unified_code: Option<Option<String>>,
unified_message: Option<Option<String>>,
capture_before: Option<PrimitiveDateTime>,
extended_authorization_applied: Option<ExtendedAuthorizationAppliedBool>,
payment_method_data: Option<serde_json::Value>,
connector_mandate_detail: Option<ConnectorMandateReferenceId>,
charges: Option<common_types::payments::ConnectorChargeResponseData>,
},
UnresolvedResponseUpdate {
status: storage_enums::AttemptStatus,
connector: Option<String>,
connector_transaction_id: Option<String>,
payment_method_id: Option<String>,
error_code: Option<Option<String>>,
error_message: Option<Option<String>>,
error_reason: Option<Option<String>>,
connector_response_reference_id: Option<String>,
updated_by: String,
},
StatusUpdate {
status: storage_enums::AttemptStatus,
updated_by: String,
},
ErrorUpdate {
connector: Option<String>,
status: storage_enums::AttemptStatus,
error_code: Option<Option<String>>,
error_message: Option<Option<String>>,
error_reason: Option<Option<String>>,
amount_capturable: Option<MinorUnit>,
updated_by: String,
unified_code: Option<Option<String>>,
unified_message: Option<Option<String>>,
connector_transaction_id: Option<String>,
payment_method_data: Option<serde_json::Value>,
authentication_type: Option<storage_enums::AuthenticationType>,
issuer_error_code: Option<String>,
issuer_error_message: Option<String>,
},
CaptureUpdate {
amount_to_capture: Option<MinorUnit>,
multiple_capture_count: Option<i16>,
updated_by: String,
},
AmountToCaptureUpdate {
status: storage_enums::AttemptStatus,
amount_capturable: MinorUnit,
updated_by: String,
},
PreprocessingUpdate {
status: storage_enums::AttemptStatus,
payment_method_id: Option<String>,
connector_metadata: Option<serde_json::Value>,
preprocessing_step_id: Option<String>,
connector_transaction_id: Option<String>,
connector_response_reference_id: Option<String>,
updated_by: String,
},
ConnectorResponse {
authentication_data: Option<serde_json::Value>,
encoded_data: Option<String>,
connector_transaction_id: Option<String>,
connector: Option<String>,
charges: Option<common_types::payments::ConnectorChargeResponseData>,
updated_by: String,
},
IncrementalAuthorizationAmountUpdate {
amount: MinorUnit,
amount_capturable: MinorUnit,
},
AuthenticationUpdate {
status: storage_enums::AttemptStatus,
external_three_ds_authentication_attempted: Option<bool>,
authentication_connector: Option<String>,
authentication_id: Option<String>,
updated_by: String,
},
ManualUpdate {
status: Option<storage_enums::AttemptStatus>,
error_code: Option<String>,
error_message: Option<String>,
error_reason: Option<String>,
updated_by: String,
unified_code: Option<String>,
unified_message: Option<String>,
connector_transaction_id: Option<String>,
},
PostSessionTokensUpdate {
updated_by: String,
connector_metadata: Option<serde_json::Value>,
},
}
#[cfg(feature = "v2")]
#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum PaymentAttemptUpdate {
// Update {
// amount: MinorUnit,
// currency: storage_enums::Currency,
// status: storage_enums::AttemptStatus,
// authentication_type: Option<storage_enums::AuthenticationType>,
// payment_method: Option<storage_enums::PaymentMethod>,
// payment_token: Option<String>,
// payment_method_data: Option<serde_json::Value>,
// payment_method_type: Option<storage_enums::PaymentMethodType>,
// payment_experience: Option<storage_enums::PaymentExperience>,
// business_sub_label: Option<String>,
// amount_to_capture: Option<MinorUnit>,
// capture_method: Option<storage_enums::CaptureMethod>,
// surcharge_amount: Option<MinorUnit>,
// tax_amount: Option<MinorUnit>,
// fingerprint_id: Option<String>,
// payment_method_billing_address_id: Option<String>,
// updated_by: String,
// },
// UpdateTrackers {
// payment_token: Option<String>,
// connector: Option<String>,
// straight_through_algorithm: Option<serde_json::Value>,
// amount_capturable: Option<MinorUnit>,
// surcharge_amount: Option<MinorUnit>,
// tax_amount: Option<MinorUnit>,
// updated_by: String,
// merchant_connector_id: Option<id_type::MerchantConnectorAccountId>,
// },
// AuthenticationTypeUpdate {
// authentication_type: storage_enums::AuthenticationType,
// updated_by: String,
// },
// ConfirmUpdate {
// amount: MinorUnit,
// currency: storage_enums::Currency,
// status: storage_enums::AttemptStatus,
// authentication_type: Option<storage_enums::AuthenticationType>,
// capture_method: Option<storage_enums::CaptureMethod>,
// payment_method: Option<storage_enums::PaymentMethod>,
// browser_info: Option<serde_json::Value>,
// connector: Option<String>,
// payment_token: Option<String>,
// payment_method_data: Option<serde_json::Value>,
// payment_method_type: Option<storage_enums::PaymentMethodType>,
// payment_experience: Option<storage_enums::PaymentExperience>,
// business_sub_label: Option<String>,
// straight_through_algorithm: Option<serde_json::Value>,
// error_code: Option<Option<String>>,
// error_message: Option<Option<String>>,
// amount_capturable: Option<MinorUnit>,
// surcharge_amount: Option<MinorUnit>,
// tax_amount: Option<MinorUnit>,
// fingerprint_id: Option<String>,
// updated_by: String,
// merchant_connector_id: Option<id_type::MerchantConnectorAccountId>,
// payment_method_id: Option<String>,
// external_three_ds_authentication_attempted: Option<bool>,
// authentication_connector: Option<String>,
// authentication_id: Option<String>,
// payment_method_billing_address_id: Option<String>,
// client_source: Option<String>,
// client_version: Option<String>,
// customer_acceptance: Option<pii::SecretSerdeValue>,
// },
// VoidUpdate {
// status: storage_enums::AttemptStatus,
// cancellation_reason: Option<String>,
// updated_by: String,
// },
// PaymentMethodDetailsUpdate {
// payment_method_id: Option<String>,
// updated_by: String,
// },
// ConnectorMandateDetailUpdate {
// connector_mandate_detail: Option<ConnectorMandateReferenceId>,
// updated_by: String,
// }
// BlocklistUpdate {
// status: storage_enums::AttemptStatus,
// error_code: Option<Option<String>>,
// error_message: Option<Option<String>>,
// updated_by: String,
// },
// RejectUpdate {
// status: storage_enums::AttemptStatus,
// error_code: Option<Option<String>>,
// error_message: Option<Option<String>>,
// updated_by: String,
// },
// ResponseUpdate {
// status: storage_enums::AttemptStatus,
// connector: Option<String>,
// connector_transaction_id: Option<String>,
// authentication_type: Option<storage_enums::AuthenticationType>,
// payment_method_id: Option<String>,
// mandate_id: Option<String>,
// connector_metadata: Option<serde_json::Value>,
// payment_token: Option<String>,
// error_code: Option<Option<String>>,
// error_message: Option<Option<String>>,
// error_reason: Option<Option<String>>,
// connector_response_reference_id: Option<String>,
// amount_capturable: Option<MinorUnit>,
// updated_by: String,
// authentication_data: Option<serde_json::Value>,
// encoded_data: Option<String>,
// unified_code: Option<Option<String>>,
// unified_message: Option<Option<String>>,
// payment_method_data: Option<serde_json::Value>,
// charge_id: Option<String>,
// },
// UnresolvedResponseUpdate {
// status: storage_enums::AttemptStatus,
// connector: Option<String>,
// connector_transaction_id: Option<String>,
// payment_method_id: Option<String>,
// error_code: Option<Option<String>>,
// error_message: Option<Option<String>>,
// error_reason: Option<Option<String>>,
// connector_response_reference_id: Option<String>,
// updated_by: String,
// },
// StatusUpdate {
// status: storage_enums::AttemptStatus,
// updated_by: String,
// },
// ErrorUpdate {
// connector: Option<String>,
// status: storage_enums::AttemptStatus,
// error_code: Option<Option<String>>,
// error_message: Option<Option<String>>,
// error_reason: Option<Option<String>>,
// amount_capturable: Option<MinorUnit>,
// updated_by: String,
// unified_code: Option<Option<String>>,
// unified_message: Option<Option<String>>,
// connector_transaction_id: Option<String>,
// payment_method_data: Option<serde_json::Value>,
// authentication_type: Option<storage_enums::AuthenticationType>,
// },
// CaptureUpdate {
// amount_to_capture: Option<MinorUnit>,
// multiple_capture_count: Option<MinorUnit>,
// updated_by: String,
// },
// AmountToCaptureUpdate {
// status: storage_enums::AttemptStatus,
// amount_capturable: MinorUnit,
// updated_by: String,
// },
// PreprocessingUpdate {
// status: storage_enums::AttemptStatus,
// payment_method_id: Option<String>,
// connector_metadata: Option<serde_json::Value>,
// preprocessing_step_id: Option<String>,
// connector_transaction_id: Option<String>,
// connector_response_reference_id: Option<String>,
// updated_by: String,
// },
// ConnectorResponse {
// authentication_data: Option<serde_json::Value>,
// encoded_data: Option<String>,
// connector_transaction_id: Option<String>,
// connector: Option<String>,
// charge_id: Option<String>,
// updated_by: String,
// },
// IncrementalAuthorizationAmountUpdate {
// amount: MinorUnit,
// amount_capturable: MinorUnit,
// },
// AuthenticationUpdate {
// status: storage_enums::AttemptStatus,
// external_three_ds_authentication_attempted: Option<bool>,
// authentication_connector: Option<String>,
// authentication_id: Option<String>,
// updated_by: String,
// },
// ManualUpdate {
// status: Option<storage_enums::AttemptStatus>,
// error_code: Option<String>,
// error_message: Option<String>,
// error_reason: Option<String>,
// updated_by: String,
// unified_code: Option<String>,
// unified_message: Option<String>,
// connector_transaction_id: Option<String>,
// },
}
// TODO: uncomment fields as and when required
#[cfg(feature = "v2")]
#[derive(Clone, Debug, AsChangeset, router_derive::DebugAsDisplay)]
#[diesel(table_name = payment_attempt)]
pub struct PaymentAttemptUpdateInternal {
pub status: Option<storage_enums::AttemptStatus>,
pub authentication_type: Option<storage_enums::AuthenticationType>,
pub error_message: Option<String>,
pub connector_payment_id: Option<String>,
// payment_method_id: Option<String>,
// cancellation_reason: Option<String>,
pub modified_at: PrimitiveDateTime,
pub browser_info: Option<serde_json::Value>,
// payment_token: Option<String>,
pub error_code: Option<String>,
pub connector_metadata: Option<pii::SecretSerdeValue>,
// payment_method_data: Option<serde_json::Value>,
// payment_experience: Option<storage_enums::PaymentExperience>,
// preprocessing_step_id: Option<String>,
pub error_reason: Option<String>,
// connector_response_reference_id: Option<String>,
// multiple_capture_count: Option<i16>,
// pub surcharge_amount: Option<MinorUnit>,
// tax_on_surcharge: Option<MinorUnit>,
pub amount_capturable: Option<MinorUnit>,
pub amount_to_capture: Option<MinorUnit>,
pub updated_by: String,
pub merchant_connector_id: Option<id_type::MerchantConnectorAccountId>,
pub connector: Option<String>,
pub redirection_data: Option<RedirectForm>,
// encoded_data: Option<String>,
pub unified_code: Option<Option<String>>,
pub unified_message: Option<Option<String>>,
// external_three_ds_authentication_attempted: Option<bool>,
// authentication_connector: Option<String>,
// authentication_id: Option<String>,
// fingerprint_id: Option<String>,
// charge_id: Option<String>,
// client_source: Option<String>,
// client_version: Option<String>,
// customer_acceptance: Option<pii::SecretSerdeValue>,
// card_network: Option<String>,
pub connector_token_details: Option<ConnectorTokenDetails>,
pub feature_metadata: Option<PaymentAttemptFeatureMetadata>,
pub network_decline_code: Option<String>,
pub network_advice_code: Option<String>,
pub network_error_message: Option<String>,
}
#[cfg(feature = "v1")]
#[derive(Clone, Debug, AsChangeset, router_derive::DebugAsDisplay)]
#[diesel(table_name = payment_attempt)]
pub struct PaymentAttemptUpdateInternal {
pub amount: Option<MinorUnit>,
pub net_amount: Option<MinorUnit>,
pub currency: Option<storage_enums::Currency>,
pub status: Option<storage_enums::AttemptStatus>,
pub connector_transaction_id: Option<ConnectorTransactionId>,
pub amount_to_capture: Option<MinorUnit>,
pub connector: Option<Option<String>>,
pub authentication_type: Option<storage_enums::AuthenticationType>,
pub payment_method: Option<storage_enums::PaymentMethod>,
pub error_message: Option<Option<String>>,
pub payment_method_id: Option<String>,
pub cancellation_reason: Option<String>,
pub modified_at: PrimitiveDateTime,
pub mandate_id: Option<String>,
pub browser_info: Option<serde_json::Value>,
pub payment_token: Option<String>,
pub error_code: Option<Option<String>>,
pub connector_metadata: Option<serde_json::Value>,
pub payment_method_data: Option<serde_json::Value>,
pub payment_method_type: Option<storage_enums::PaymentMethodType>,
pub payment_experience: Option<storage_enums::PaymentExperience>,
pub business_sub_label: Option<String>,
pub straight_through_algorithm: Option<serde_json::Value>,
pub preprocessing_step_id: Option<String>,
pub error_reason: Option<Option<String>>,
pub capture_method: Option<storage_enums::CaptureMethod>,
pub connector_response_reference_id: Option<String>,
pub multiple_capture_count: Option<i16>,
pub surcharge_amount: Option<MinorUnit>,
pub tax_amount: Option<MinorUnit>,
pub amount_capturable: Option<MinorUnit>,
pub updated_by: String,
pub merchant_connector_id: Option<Option<id_type::MerchantConnectorAccountId>>,
pub authentication_data: Option<serde_json::Value>,
pub encoded_data: Option<String>,
pub unified_code: Option<Option<String>>,
pub unified_message: Option<Option<String>>,
pub external_three_ds_authentication_attempted: Option<bool>,
pub authentication_connector: Option<String>,
pub authentication_id: Option<String>,
pub fingerprint_id: Option<String>,
pub payment_method_billing_address_id: Option<String>,
pub client_source: Option<String>,
pub client_version: Option<String>,
pub customer_acceptance: Option<pii::SecretSerdeValue>,
pub card_network: Option<String>,
pub capture_before: Option<PrimitiveDateTime>,
pub extended_authorization_applied: Option<ExtendedAuthorizationAppliedBool>,
pub shipping_cost: Option<MinorUnit>,
pub order_tax_amount: Option<MinorUnit>,
pub connector_mandate_detail: Option<ConnectorMandateReferenceId>,
pub processor_transaction_data: Option<String>,
pub card_discovery: Option<common_enums::CardDiscovery>,
pub charges: Option<common_types::payments::ConnectorChargeResponseData>,
pub issuer_error_code: Option<String>,
pub issuer_error_message: Option<String>,
}
#[cfg(feature = "v1")]
impl PaymentAttemptUpdateInternal {
pub fn populate_derived_fields(self, source: &PaymentAttempt) -> Self {
let mut update_internal = self;
update_internal.net_amount = Some(
update_internal.amount.unwrap_or(source.amount)
+ update_internal
.surcharge_amount
.or(source.surcharge_amount)
.unwrap_or(MinorUnit::new(0))
+ update_internal
.tax_amount
.or(source.tax_amount)
.unwrap_or(MinorUnit::new(0))
+ update_internal
.shipping_cost
.or(source.shipping_cost)
.unwrap_or(MinorUnit::new(0))
+ update_internal
.order_tax_amount
.or(source.order_tax_amount)
.unwrap_or(MinorUnit::new(0)),
);
update_internal.card_network = update_internal
.payment_method_data
.as_ref()
.and_then(|data| data.as_object())
.and_then(|card| card.get("card"))
.and_then(|data| data.as_object())
.and_then(|card| card.get("card_network"))
.and_then(|network| network.as_str())
.map(|network| network.to_string());
update_internal
}
}
#[cfg(feature = "v2")]
impl PaymentAttemptUpdate {
pub fn apply_changeset(self, source: PaymentAttempt) -> PaymentAttempt {
todo!()
// let PaymentAttemptUpdateInternal {
// net_amount,
// status,
// authentication_type,
// error_message,
// payment_method_id,
// cancellation_reason,
// modified_at: _,
// browser_info,
// payment_token,
// error_code,
// connector_metadata,
// payment_method_data,
// payment_experience,
// straight_through_algorithm,
// preprocessing_step_id,
// error_reason,
// connector_response_reference_id,
// multiple_capture_count,
// surcharge_amount,
// tax_amount,
// amount_capturable,
// updated_by,
// merchant_connector_id,
// authentication_data,
// encoded_data,
// unified_code,
// unified_message,
// external_three_ds_authentication_attempted,
// authentication_connector,
// authentication_id,
// payment_method_billing_address_id,
// fingerprint_id,
// charge_id,
// client_source,
// client_version,
// customer_acceptance,
// card_network,
// } = PaymentAttemptUpdateInternal::from(self).populate_derived_fields(&source);
// PaymentAttempt {
// net_amount: net_amount.or(source.net_amount),
// status: status.unwrap_or(source.status),
// authentication_type: authentication_type.or(source.authentication_type),
// error_message: error_message.unwrap_or(source.error_message),
// payment_method_id: payment_method_id.or(source.payment_method_id),
// cancellation_reason: cancellation_reason.or(source.cancellation_reason),
// modified_at: common_utils::date_time::now(),
// browser_info: browser_info.or(source.browser_info),
// payment_token: payment_token.or(source.payment_token),
// error_code: error_code.unwrap_or(source.error_code),
// connector_metadata: connector_metadata.or(source.connector_metadata),
// payment_method_data: payment_method_data.or(source.payment_method_data),
// payment_experience: payment_experience.or(source.payment_experience),
// straight_through_algorithm: straight_through_algorithm
// .or(source.straight_through_algorithm),
// preprocessing_step_id: preprocessing_step_id.or(source.preprocessing_step_id),
// error_reason: error_reason.unwrap_or(source.error_reason),
// connector_response_reference_id: connector_response_reference_id
// .or(source.connector_response_reference_id),
// multiple_capture_count: multiple_capture_count.or(source.multiple_capture_count),
// surcharge_amount: surcharge_amount.or(source.surcharge_amount),
// tax_amount: tax_amount.or(source.tax_amount),
// amount_capturable: amount_capturable.unwrap_or(source.amount_capturable),
// updated_by,
// merchant_connector_id: merchant_connector_id.unwrap_or(source.merchant_connector_id),
// authentication_data: authentication_data.or(source.authentication_data),
// encoded_data: encoded_data.or(source.encoded_data),
// unified_code: unified_code.unwrap_or(source.unified_code),
// unified_message: unified_message.unwrap_or(source.unified_message),
// external_three_ds_authentication_attempted: external_three_ds_authentication_attempted
// .or(source.external_three_ds_authentication_attempted),
// authentication_connector: authentication_connector.or(source.authentication_connector),
// authentication_id: authentication_id.or(source.authentication_id),
// payment_method_billing_address_id: payment_method_billing_address_id
// .or(source.payment_method_billing_address_id),
// fingerprint_id: fingerprint_id.or(source.fingerprint_id),
// charge_id: charge_id.or(source.charge_id),
// client_source: client_source.or(source.client_source),
// client_version: client_version.or(source.client_version),
// customer_acceptance: customer_acceptance.or(source.customer_acceptance),
// card_network: card_network.or(source.card_network),
// ..source
// }
}
}
#[cfg(feature = "v1")]
impl PaymentAttemptUpdate {
pub fn apply_changeset(self, source: PaymentAttempt) -> PaymentAttempt {
let PaymentAttemptUpdateInternal {
amount,
net_amount,
currency,
status,
connector_transaction_id,
amount_to_capture,
connector,
authentication_type,
payment_method,
error_message,
payment_method_id,
cancellation_reason,
modified_at: _,
mandate_id,
browser_info,
payment_token,
error_code,
connector_metadata,
payment_method_data,
payment_method_type,
payment_experience,
business_sub_label,
straight_through_algorithm,
preprocessing_step_id,
error_reason,
capture_method,
connector_response_reference_id,
multiple_capture_count,
surcharge_amount,
tax_amount,
amount_capturable,
updated_by,
merchant_connector_id,
authentication_data,
encoded_data,
unified_code,
unified_message,
external_three_ds_authentication_attempted,
authentication_connector,
authentication_id,
payment_method_billing_address_id,
fingerprint_id,
client_source,
client_version,
customer_acceptance,
card_network,
shipping_cost,
order_tax_amount,
processor_transaction_data,
connector_mandate_detail,
capture_before,
extended_authorization_applied,
card_discovery,
charges,
issuer_error_code,
issuer_error_message,
} = PaymentAttemptUpdateInternal::from(self).populate_derived_fields(&source);
PaymentAttempt {
amount: amount.unwrap_or(source.amount),
net_amount: net_amount.or(source.net_amount),
currency: currency.or(source.currency),
status: status.unwrap_or(source.status),
connector_transaction_id: connector_transaction_id.or(source.connector_transaction_id),
amount_to_capture: amount_to_capture.or(source.amount_to_capture),
connector: connector.unwrap_or(source.connector),
authentication_type: authentication_type.or(source.authentication_type),
payment_method: payment_method.or(source.payment_method),
error_message: error_message.unwrap_or(source.error_message),
payment_method_id: payment_method_id.or(source.payment_method_id),
cancellation_reason: cancellation_reason.or(source.cancellation_reason),
modified_at: common_utils::date_time::now(),
mandate_id: mandate_id.or(source.mandate_id),
browser_info: browser_info.or(source.browser_info),
payment_token: payment_token.or(source.payment_token),
error_code: error_code.unwrap_or(source.error_code),
connector_metadata: connector_metadata.or(source.connector_metadata),
payment_method_data: payment_method_data.or(source.payment_method_data),
payment_method_type: payment_method_type.or(source.payment_method_type),
payment_experience: payment_experience.or(source.payment_experience),
business_sub_label: business_sub_label.or(source.business_sub_label),
straight_through_algorithm: straight_through_algorithm
.or(source.straight_through_algorithm),
preprocessing_step_id: preprocessing_step_id.or(source.preprocessing_step_id),
error_reason: error_reason.unwrap_or(source.error_reason),
capture_method: capture_method.or(source.capture_method),
connector_response_reference_id: connector_response_reference_id
.or(source.connector_response_reference_id),
multiple_capture_count: multiple_capture_count.or(source.multiple_capture_count),
surcharge_amount: surcharge_amount.or(source.surcharge_amount),
tax_amount: tax_amount.or(source.tax_amount),
amount_capturable: amount_capturable.unwrap_or(source.amount_capturable),
updated_by,
merchant_connector_id: merchant_connector_id.unwrap_or(source.merchant_connector_id),
authentication_data: authentication_data.or(source.authentication_data),
encoded_data: encoded_data.or(source.encoded_data),
unified_code: unified_code.unwrap_or(source.unified_code),
unified_message: unified_message.unwrap_or(source.unified_message),
external_three_ds_authentication_attempted: external_three_ds_authentication_attempted
.or(source.external_three_ds_authentication_attempted),
authentication_connector: authentication_connector.or(source.authentication_connector),
authentication_id: authentication_id.or(source.authentication_id),
payment_method_billing_address_id: payment_method_billing_address_id
.or(source.payment_method_billing_address_id),
fingerprint_id: fingerprint_id.or(source.fingerprint_id),
client_source: client_source.or(source.client_source),
client_version: client_version.or(source.client_version),
customer_acceptance: customer_acceptance.or(source.customer_acceptance),
card_network: card_network.or(source.card_network),
shipping_cost: shipping_cost.or(source.shipping_cost),
order_tax_amount: order_tax_amount.or(source.order_tax_amount),
processor_transaction_data: processor_transaction_data
.or(source.processor_transaction_data),
connector_mandate_detail: connector_mandate_detail.or(source.connector_mandate_detail),
capture_before: capture_before.or(source.capture_before),
extended_authorization_applied: extended_authorization_applied
.or(source.extended_authorization_applied),
card_discovery: card_discovery.or(source.card_discovery),
charges: charges.or(source.charges),
issuer_error_code: issuer_error_code.or(source.issuer_error_code),
issuer_error_message: issuer_error_message.or(source.issuer_error_message),
..source
}
}
}
#[cfg(feature = "v2")]
impl From<PaymentAttemptUpdate> for PaymentAttemptUpdateInternal {
fn from(payment_attempt_update: PaymentAttemptUpdate) -> Self {
todo!()
// match payment_attempt_update {
// PaymentAttemptUpdate::Update {
// amount,
// currency,
// status,
// // connector_transaction_id,
// authentication_type,
// payment_method,
// payment_token,
// payment_method_data,
// payment_method_type,
// payment_experience,
// business_sub_label,
// amount_to_capture,
// capture_method,
// surcharge_amount,
// tax_amount,
// fingerprint_id,
// updated_by,
// payment_method_billing_address_id,
// } => Self {
// status: Some(status),
// // connector_transaction_id,
// authentication_type,
// payment_token,
// modified_at: common_utils::date_time::now(),
// payment_method_data,
// payment_experience,
// surcharge_amount,
// tax_amount,
// fingerprint_id,
// payment_method_billing_address_id,
// updated_by,
// net_amount: None,
// error_message: None,
// payment_method_id: None,
// cancellation_reason: None,
// browser_info: None,
// error_code: None,
// connector_metadata: None,
// straight_through_algorithm: None,
// preprocessing_step_id: None,
// error_reason: None,
// connector_response_reference_id: None,
// multiple_capture_count: None,
// amount_capturable: None,
// merchant_connector_id: None,
// authentication_data: None,
// encoded_data: None,
// unified_code: None,
// unified_message: None,
// external_three_ds_authentication_attempted: None,
// authentication_connector: None,
// authentication_id: None,
// charge_id: None,
// client_source: None,
// client_version: None,
// customer_acceptance: None,
// card_network: None,
// },
// PaymentAttemptUpdate::AuthenticationTypeUpdate {
// authentication_type,
// updated_by,
// } => Self {
// authentication_type: Some(authentication_type),
// modified_at: common_utils::date_time::now(),
// updated_by,
// net_amount: None,
// status: None,
// error_message: None,
// payment_method_id: None,
// cancellation_reason: None,
// browser_info: None,
// payment_token: None,
// error_code: None,
// connector_metadata: None,
// payment_method_data: None,
// payment_experience: None,
// straight_through_algorithm: None,
// preprocessing_step_id: None,
// error_reason: None,
// connector_response_reference_id: None,
// multiple_capture_count: None,
// surcharge_amount: None,
// tax_amount: None,
// amount_capturable: None,
// merchant_connector_id: None,
// authentication_data: None,
// encoded_data: None,
// unified_code: None,
// unified_message: None,
// external_three_ds_authentication_attempted: None,
// authentication_connector: None,
// authentication_id: None,
// fingerprint_id: None,
// payment_method_billing_address_id: None,
// charge_id: None,
// client_source: None,
// client_version: None,
// customer_acceptance: None,
// card_network: None,
// },
// PaymentAttemptUpdate::ConfirmUpdate {
// amount,
// currency,
// authentication_type,
// capture_method,
// status,
// payment_method,
// browser_info,
// connector,
// payment_token,
// payment_method_data,
// payment_method_type,
// payment_experience,
// business_sub_label,
// straight_through_algorithm,
// error_code,
// error_message,
// amount_capturable,
// updated_by,
// merchant_connector_id,
// surcharge_amount,
// tax_amount,
// external_three_ds_authentication_attempted,
// authentication_connector,
// authentication_id,
// payment_method_billing_address_id,
// fingerprint_id,
// payment_method_id,
// client_source,
// client_version,
// customer_acceptance,
// } => Self {
// authentication_type,
// status: Some(status),
// modified_at: common_utils::date_time::now(),
// browser_info,
// payment_token,
// payment_method_data,
// payment_experience,
// straight_through_algorithm,
// error_code,
// error_message,
// amount_capturable,
// updated_by,
// merchant_connector_id: merchant_connector_id.map(Some),
// surcharge_amount,
// tax_amount,
// external_three_ds_authentication_attempted,
// authentication_connector,
// authentication_id,
// payment_method_billing_address_id,
// fingerprint_id,
// payment_method_id,
// client_source,
// client_version,
// customer_acceptance,
// net_amount: None,
// cancellation_reason: None,
// connector_metadata: None,
// preprocessing_step_id: None,
// error_reason: None,
// connector_response_reference_id: None,
// multiple_capture_count: None,
// authentication_data: None,
// encoded_data: None,
// unified_code: None,
// unified_message: None,
// charge_id: None,
// card_network: None,
// },
// PaymentAttemptUpdate::VoidUpdate {
// status,
// cancellation_reason,
// updated_by,
// } => Self {
// status: Some(status),
// cancellation_reason,
// modified_at: common_utils::date_time::now(),
// updated_by,
// net_amount: None,
// authentication_type: None,
// error_message: None,
// payment_method_id: None,
// browser_info: None,
// payment_token: None,
// error_code: None,
// connector_metadata: None,
// payment_method_data: None,
// payment_experience: None,
// straight_through_algorithm: None,
// preprocessing_step_id: None,
// error_reason: None,
// connector_response_reference_id: None,
// multiple_capture_count: None,
// surcharge_amount: None,
// tax_amount: None,
// amount_capturable: None,
// merchant_connector_id: None,
// authentication_data: None,
// encoded_data: None,
// unified_code: None,
// unified_message: None,
// external_three_ds_authentication_attempted: None,
// authentication_connector: None,
// authentication_id: None,
// fingerprint_id: None,
// payment_method_billing_address_id: None,
// charge_id: None,
// client_source: None,
// client_version: None,
// customer_acceptance: None,
// card_network: None,
// },
// PaymentAttemptUpdate::RejectUpdate {
// status,
// error_code,
// error_message,
// updated_by,
// } => Self {
// status: Some(status),
// modified_at: common_utils::date_time::now(),
// error_code,
// error_message,
// updated_by,
// net_amount: None,
// authentication_type: None,
// payment_method_id: None,
// cancellation_reason: None,
// browser_info: None,
// payment_token: None,
// connector_metadata: None,
// payment_method_data: None,
// payment_experience: None,
// straight_through_algorithm: None,
// preprocessing_step_id: None,
// error_reason: None,
// connector_response_reference_id: None,
// multiple_capture_count: None,
// surcharge_amount: None,
// tax_amount: None,
// amount_capturable: None,
// merchant_connector_id: None,
// authentication_data: None,
// encoded_data: None,
// unified_code: None,
// unified_message: None,
// external_three_ds_authentication_attempted: None,
// authentication_connector: None,
// authentication_id: None,
// fingerprint_id: None,
// payment_method_billing_address_id: None,
// charge_id: None,
// client_source: None,
// client_version: None,
// customer_acceptance: None,
// card_network: None,
// },
// PaymentAttemptUpdate::BlocklistUpdate {
// status,
// error_code,
// error_message,
// updated_by,
// } => Self {
// status: Some(status),
// modified_at: common_utils::date_time::now(),
// error_code,
// error_message,
// updated_by,
// merchant_connector_id: Some(None),
// net_amount: None,
// authentication_type: None,
// payment_method_id: None,
// cancellation_reason: None,
// browser_info: None,
// payment_token: None,
// connector_metadata: None,
// payment_method_data: None,
// payment_experience: None,
// straight_through_algorithm: None,
// preprocessing_step_id: None,
// error_reason: None,
// connector_response_reference_id: None,
// multiple_capture_count: None,
// surcharge_amount: None,
// tax_amount: None,
// amount_capturable: None,
// authentication_data: None,
// encoded_data: None,
// unified_code: None,
// unified_message: None,
// external_three_ds_authentication_attempted: None,
// authentication_connector: None,
// authentication_id: None,
// fingerprint_id: None,
// payment_method_billing_address_id: None,
// charge_id: None,
// client_source: None,
// client_version: None,
// customer_acceptance: None,
// card_network: None,
// },
// PaymentAttemptUpdate::ConnectorMandateDetailUpdate {
// connector_mandate_detail,
// updated_by,
// } => Self {
// payment_method_id: None,
// modified_at: common_utils::date_time::now(),
// updated_by,
// amount: None,
// net_amount: None,
// currency: None,
// status: None,
// connector_transaction_id: None,
// amount_to_capture: None,
// connector: None,
// authentication_type: None,
// payment_method: None,
// error_message: None,
// cancellation_reason: None,
// mandate_id: None,
// browser_info: None,
// payment_token: None,
// error_code: None,
// connector_metadata: None,
// payment_method_data: None,
// payment_method_type: None,
// payment_experience: None,
// business_sub_label: None,
// straight_through_algorithm: None,
// preprocessing_step_id: None,
// error_reason: None,
// capture_method: None,
// connector_response_reference_id: None,
// multiple_capture_count: None,
// surcharge_amount: None,
// tax_amount: None,
// amount_capturable: None,
// merchant_connector_id: None,
// authentication_data: None,
// encoded_data: None,
// unified_code: None,
// unified_message: None,
// external_three_ds_authentication_attempted: None,
// authentication_connector: None,
// authentication_id: None,
// fingerprint_id: None,
// payment_method_billing_address_id: None,
// charge_id: None,
// client_source: None,
// client_version: None,
// customer_acceptance: None,
// card_network: None,
// shipping_cost: None,
// order_tax_amount: None,
// processor_transaction_data: None,
// connector_mandate_detail,
// },
// PaymentAttemptUpdate::ConnectorMandateDetailUpdate {
// payment_method_id,
// updated_by,
// } => Self {
// payment_method_id,
// modified_at: common_utils::date_time::now(),
// updated_by,
// net_amount: None,
// status: None,
// authentication_type: None,
// error_message: None,
// cancellation_reason: None,
// browser_info: None,
// payment_token: None,
// error_code: None,
// connector_metadata: None,
// payment_method_data: None,
// payment_experience: None,
// straight_through_algorithm: None,
// preprocessing_step_id: None,
// error_reason: None,
// connector_response_reference_id: None,
// multiple_capture_count: None,
// surcharge_amount: None,
// tax_amount: None,
// amount_capturable: None,
// merchant_connector_id: None,
// authentication_data: None,
// encoded_data: None,
// unified_code: None,
// unified_message: None,
// external_three_ds_authentication_attempted: None,
// authentication_connector: None,
// authentication_id: None,
// fingerprint_id: None,
// payment_method_billing_address_id: None,
// charge_id: None,
// client_source: None,
// client_version: None,
// customer_acceptance: None,
// card_network: None,
// },
// PaymentAttemptUpdate::ResponseUpdate {
// status,
// connector,
// connector_transaction_id,
// authentication_type,
// payment_method_id,
// mandate_id,
// connector_metadata,
// payment_token,
// error_code,
// error_message,
// error_reason,
// connector_response_reference_id,
// amount_capturable,
// updated_by,
// authentication_data,
// encoded_data,
// unified_code,
// unified_message,
// payment_method_data,
// charge_id,
// } => Self {
// status: Some(status),
// authentication_type,
// payment_method_id,
// modified_at: common_utils::date_time::now(),
// connector_metadata,
// error_code,
// error_message,
// payment_token,
// error_reason,
// connector_response_reference_id,
// amount_capturable,
// updated_by,
// authentication_data,
// encoded_data,
// unified_code,
// unified_message,
// payment_method_data,
// charge_id,
// net_amount: None,
// cancellation_reason: None,
// browser_info: None,
// payment_experience: None,
// straight_through_algorithm: None,
// preprocessing_step_id: None,
// multiple_capture_count: None,
// surcharge_amount: None,
// tax_amount: None,
// merchant_connector_id: None,
// external_three_ds_authentication_attempted: None,
// authentication_connector: None,
// authentication_id: None,
// fingerprint_id: None,
// payment_method_billing_address_id: None,
// client_source: None,
// client_version: None,
// customer_acceptance: None,
// card_network: None,
// },
// PaymentAttemptUpdate::ErrorUpdate {
// connector,
// status,
// error_code,
// error_message,
// error_reason,
// amount_capturable,
// updated_by,
// unified_code,
// unified_message,
// connector_transaction_id,
// payment_method_data,
// authentication_type,
// } => Self {
// status: Some(status),
// error_message,
// error_code,
// modified_at: common_utils::date_time::now(),
// error_reason,
// amount_capturable,
// updated_by,
// unified_code,
// unified_message,
// payment_method_data,
// authentication_type,
// net_amount: None,
// payment_method_id: None,
// cancellation_reason: None,
// browser_info: None,
// payment_token: None,
// connector_metadata: None,
// payment_experience: None,
// straight_through_algorithm: None,
// preprocessing_step_id: None,
// connector_response_reference_id: None,
// multiple_capture_count: None,
// surcharge_amount: None,
// tax_amount: None,
// merchant_connector_id: None,
// authentication_data: None,
// encoded_data: None,
// external_three_ds_authentication_attempted: None,
// authentication_connector: None,
// authentication_id: None,
// fingerprint_id: None,
// payment_method_billing_address_id: None,
// charge_id: None,
// client_source: None,
// client_version: None,
// customer_acceptance: None,
// card_network: None,
// },
// PaymentAttemptUpdate::StatusUpdate { status, updated_by } => Self {
// status: Some(status),
// modified_at: common_utils::date_time::now(),
// updated_by,
// net_amount: None,
// authentication_type: None,
// error_message: None,
// payment_method_id: None,
// cancellation_reason: None,
// browser_info: None,
// payment_token: None,
// error_code: None,
// connector_metadata: None,
// payment_method_data: None,
// payment_experience: None,
// straight_through_algorithm: None,
// preprocessing_step_id: None,
// error_reason: None,
// connector_response_reference_id: None,
// multiple_capture_count: None,
// surcharge_amount: None,
// tax_amount: None,
// amount_capturable: None,
// merchant_connector_id: None,
// authentication_data: None,
// encoded_data: None,
// unified_code: None,
// unified_message: None,
// external_three_ds_authentication_attempted: None,
// authentication_connector: None,
// authentication_id: None,
// fingerprint_id: None,
// payment_method_billing_address_id: None,
// charge_id: None,
// client_source: None,
// client_version: None,
// customer_acceptance: None,
// card_network: None,
// },
// PaymentAttemptUpdate::UpdateTrackers {
// payment_token,
// connector,
// straight_through_algorithm,
// amount_capturable,
// surcharge_amount,
// tax_amount,
// updated_by,
// merchant_connector_id,
// } => Self {
// payment_token,
// modified_at: common_utils::date_time::now(),
// straight_through_algorithm,
// amount_capturable,
// surcharge_amount,
// tax_amount,
// updated_by,
// merchant_connector_id: merchant_connector_id.map(Some),
// net_amount: None,
// status: None,
// authentication_type: None,
// error_message: None,
// payment_method_id: None,
// cancellation_reason: None,
// browser_info: None,
// error_code: None,
// connector_metadata: None,
// payment_method_data: None,
// payment_experience: None,
// preprocessing_step_id: None,
// error_reason: None,
// connector_response_reference_id: None,
// multiple_capture_count: None,
// authentication_data: None,
// encoded_data: None,
// unified_code: None,
// unified_message: None,
// external_three_ds_authentication_attempted: None,
// authentication_connector: None,
// authentication_id: None,
// fingerprint_id: None,
// payment_method_billing_address_id: None,
// charge_id: None,
// client_source: None,
// client_version: None,
// customer_acceptance: None,
// card_network: None,
// },
// PaymentAttemptUpdate::UnresolvedResponseUpdate {
// status,
// connector,
// connector_transaction_id,
// payment_method_id,
// error_code,
// error_message,
// error_reason,
// connector_response_reference_id,
// updated_by,
// } => Self {
// status: Some(status),
// payment_method_id,
// modified_at: common_utils::date_time::now(),
// error_code,
// error_message,
// error_reason,
// connector_response_reference_id,
// updated_by,
// net_amount: None,
// authentication_type: None,
// cancellation_reason: None,
// browser_info: None,
// payment_token: None,
// connector_metadata: None,
// payment_method_data: None,
// payment_experience: None,
// straight_through_algorithm: None,
// preprocessing_step_id: None,
// multiple_capture_count: None,
// surcharge_amount: None,
// tax_amount: None,
// amount_capturable: None,
// merchant_connector_id: None,
// authentication_data: None,
// encoded_data: None,
// unified_code: None,
// unified_message: None,
// external_three_ds_authentication_attempted: None,
// authentication_connector: None,
// authentication_id: None,
// fingerprint_id: None,
// payment_method_billing_address_id: None,
// charge_id: None,
// client_source: None,
// client_version: None,
// customer_acceptance: None,
// card_network: None,
// },
// PaymentAttemptUpdate::PreprocessingUpdate {
// status,
// payment_method_id,
// connector_metadata,
// preprocessing_step_id,
// connector_transaction_id,
// connector_response_reference_id,
// updated_by,
// } => Self {
// status: Some(status),
// payment_method_id,
// modified_at: common_utils::date_time::now(),
// connector_metadata,
// preprocessing_step_id,
// connector_response_reference_id,
// updated_by,
// net_amount: None,
// authentication_type: None,
// error_message: None,
// cancellation_reason: None,
// browser_info: None,
// payment_token: None,
// error_code: None,
// payment_method_data: None,
// payment_experience: None,
// straight_through_algorithm: None,
// error_reason: None,
// multiple_capture_count: None,
// surcharge_amount: None,
// tax_amount: None,
// amount_capturable: None,
// merchant_connector_id: None,
// authentication_data: None,
// encoded_data: None,
// unified_code: None,
// unified_message: None,
// external_three_ds_authentication_attempted: None,
// authentication_connector: None,
// authentication_id: None,
// fingerprint_id: None,
// payment_method_billing_address_id: None,
// charge_id: None,
// client_source: None,
// client_version: None,
// customer_acceptance: None,
// card_network: None,
// },
// PaymentAttemptUpdate::CaptureUpdate {
// multiple_capture_count,
// updated_by,
// amount_to_capture,
// } => Self {
// multiple_capture_count,
// modified_at: common_utils::date_time::now(),
// updated_by,
// net_amount: None,
// status: None,
// authentication_type: None,
// error_message: None,
// payment_method_id: None,
// cancellation_reason: None,
// browser_info: None,
// payment_token: None,
// error_code: None,
// connector_metadata: None,
// payment_method_data: None,
// payment_experience: None,
// straight_through_algorithm: None,
// preprocessing_step_id: None,
// error_reason: None,
// connector_response_reference_id: None,
// surcharge_amount: None,
// tax_amount: None,
// amount_capturable: None,
// merchant_connector_id: None,
// authentication_data: None,
// encoded_data: None,
// unified_code: None,
// unified_message: None,
// external_three_ds_authentication_attempted: None,
// authentication_connector: None,
// authentication_id: None,
// fingerprint_id: None,
// payment_method_billing_address_id: None,
// charge_id: None,
// client_source: None,
// client_version: None,
// customer_acceptance: None,
// card_network: None,
// },
// PaymentAttemptUpdate::AmountToCaptureUpdate {
// status,
// amount_capturable,
// updated_by,
// } => Self {
// status: Some(status),
// modified_at: common_utils::date_time::now(),
// amount_capturable: Some(amount_capturable),
// updated_by,
// net_amount: None,
// authentication_type: None,
// error_message: None,
// payment_method_id: None,
// cancellation_reason: None,
// browser_info: None,
// payment_token: None,
// error_code: None,
// connector_metadata: None,
// payment_method_data: None,
// payment_experience: None,
// straight_through_algorithm: None,
// preprocessing_step_id: None,
// error_reason: None,
// connector_response_reference_id: None,
// multiple_capture_count: None,
// surcharge_amount: None,
// tax_amount: None,
// merchant_connector_id: None,
// authentication_data: None,
// encoded_data: None,
// unified_code: None,
// unified_message: None,
// external_three_ds_authentication_attempted: None,
// authentication_connector: None,
// authentication_id: None,
// fingerprint_id: None,
// payment_method_billing_address_id: None,
// charge_id: None,
// client_source: None,
// client_version: None,
// customer_acceptance: None,
// card_network: None,
// },
// PaymentAttemptUpdate::ConnectorResponse {
// authentication_data,
// encoded_data,
// connector_transaction_id,
// connector,
// updated_by,
// charge_id,
// } => Self {
// authentication_data,
// encoded_data,
// modified_at: common_utils::date_time::now(),
// updated_by,
// charge_id,
// net_amount: None,
// status: None,
// authentication_type: None,
// error_message: None,
// payment_method_id: None,
// cancellation_reason: None,
// browser_info: None,
// payment_token: None,
// error_code: None,
// connector_metadata: None,
// payment_method_data: None,
// payment_experience: None,
// straight_through_algorithm: None,
// preprocessing_step_id: None,
// error_reason: None,
// connector_response_reference_id: None,
// multiple_capture_count: None,
// surcharge_amount: None,
// tax_amount: None,
// amount_capturable: None,
// merchant_connector_id: None,
// unified_code: None,
// unified_message: None,
// external_three_ds_authentication_attempted: None,
// authentication_connector: None,
// authentication_id: None,
// fingerprint_id: None,
// payment_method_billing_address_id: None,
// client_source: None,
// client_version: None,
// customer_acceptance: None,
// card_network: None,
// },
// PaymentAttemptUpdate::IncrementalAuthorizationAmountUpdate {
// amount,
// amount_capturable,
// } => Self {
// modified_at: common_utils::date_time::now(),
// amount_capturable: Some(amount_capturable),
// net_amount: None,
// status: None,
// authentication_type: None,
// error_message: None,
// payment_method_id: None,
// cancellation_reason: None,
// browser_info: None,
// payment_token: None,
// error_code: None,
// connector_metadata: None,
// payment_method_data: None,
// payment_experience: None,
// straight_through_algorithm: None,
// preprocessing_step_id: None,
// error_reason: None,
// connector_response_reference_id: None,
// multiple_capture_count: None,
// surcharge_amount: None,
// tax_amount: None,
// updated_by: String::default(),
// merchant_connector_id: None,
// authentication_data: None,
// encoded_data: None,
// unified_code: None,
// unified_message: None,
// external_three_ds_authentication_attempted: None,
// authentication_connector: None,
// authentication_id: None,
// fingerprint_id: None,
// payment_method_billing_address_id: None,
// charge_id: None,
// client_source: None,
// client_version: None,
// customer_acceptance: None,
// card_network: None,
// },
// PaymentAttemptUpdate::AuthenticationUpdate {
// status,
// external_three_ds_authentication_attempted,
// authentication_connector,
// authentication_id,
// updated_by,
// } => Self {
// status: Some(status),
// modified_at: common_utils::date_time::now(),
// external_three_ds_authentication_attempted,
// authentication_connector,
// authentication_id,
// updated_by,
// net_amount: None,
// authentication_type: None,
// error_message: None,
// payment_method_id: None,
// cancellation_reason: None,
// browser_info: None,
// payment_token: None,
// error_code: None,
// connector_metadata: None,
// payment_method_data: None,
// payment_experience: None,
// straight_through_algorithm: None,
// preprocessing_step_id: None,
// error_reason: None,
// connector_response_reference_id: None,
// multiple_capture_count: None,
// surcharge_amount: None,
// tax_amount: None,
// amount_capturable: None,
// merchant_connector_id: None,
// authentication_data: None,
// encoded_data: None,
// unified_code: None,
// unified_message: None,
// fingerprint_id: None,
// payment_method_billing_address_id: None,
// charge_id: None,
// client_source: None,
// client_version: None,
// customer_acceptance: None,
// card_network: None,
// },
// PaymentAttemptUpdate::ManualUpdate {
// status,
// error_code,
// error_message,
// error_reason,
// updated_by,
// unified_code,
// unified_message,
// connector_transaction_id,
// } => Self {
// status,
// error_code: error_code.map(Some),
// modified_at: common_utils::date_time::now(),
// error_message: error_message.map(Some),
// error_reason: error_reason.map(Some),
// updated_by,
// unified_code: unified_code.map(Some),
// unified_message: unified_message.map(Some),
// net_amount: None,
// authentication_type: None,
// payment_method_id: None,
// cancellation_reason: None,
// browser_info: None,
// payment_token: None,
// connector_metadata: None,
// payment_method_data: None,
// payment_experience: None,
// straight_through_algorithm: None,
// preprocessing_step_id: None,
// connector_response_reference_id: None,
// multiple_capture_count: None,
// surcharge_amount: None,
// tax_amount: None,
// amount_capturable: None,
// merchant_connector_id: None,
// authentication_data: None,
// encoded_data: None,
// external_three_ds_authentication_attempted: None,
// authentication_connector: None,
// authentication_id: None,
// fingerprint_id: None,
// payment_method_billing_address_id: None,
// charge_id: None,
// client_source: None,
// client_version: None,
// customer_acceptance: None,
// card_network: None,
// },
// }
}
}
#[cfg(feature = "v1")]
impl From<PaymentAttemptUpdate> for PaymentAttemptUpdateInternal {
fn from(payment_attempt_update: PaymentAttemptUpdate) -> Self {
match payment_attempt_update {
PaymentAttemptUpdate::Update {
amount,
currency,
status,
// connector_transaction_id,
authentication_type,
payment_method,
payment_token,
payment_method_data,
payment_method_type,
payment_experience,
business_sub_label,
amount_to_capture,
capture_method,
surcharge_amount,
tax_amount,
fingerprint_id,
updated_by,
payment_method_billing_address_id,
} => Self {
amount: Some(amount),
currency: Some(currency),
status: Some(status),
// connector_transaction_id,
authentication_type,
payment_method,
payment_token,
modified_at: common_utils::date_time::now(),
payment_method_data,
payment_method_type,
payment_experience,
business_sub_label,
amount_to_capture,
capture_method,
surcharge_amount,
tax_amount,
fingerprint_id,
payment_method_billing_address_id,
updated_by,
net_amount: None,
connector_transaction_id: None,
connector: None,
error_message: None,
payment_method_id: None,
cancellation_reason: None,
mandate_id: None,
browser_info: None,
error_code: None,
connector_metadata: None,
straight_through_algorithm: None,
preprocessing_step_id: None,
error_reason: None,
connector_response_reference_id: None,
multiple_capture_count: None,
amount_capturable: None,
merchant_connector_id: None,
authentication_data: None,
encoded_data: None,
unified_code: None,
unified_message: None,
external_three_ds_authentication_attempted: None,
authentication_connector: None,
authentication_id: None,
client_source: None,
client_version: None,
customer_acceptance: None,
card_network: None,
shipping_cost: None,
capture_before: None,
extended_authorization_applied: None,
order_tax_amount: None,
processor_transaction_data: None,
connector_mandate_detail: None,
card_discovery: None,
charges: None,
issuer_error_code: None,
issuer_error_message: None,
},
PaymentAttemptUpdate::AuthenticationTypeUpdate {
authentication_type,
updated_by,
} => Self {
authentication_type: Some(authentication_type),
modified_at: common_utils::date_time::now(),
updated_by,
amount: None,
net_amount: None,
currency: None,
status: None,
connector_transaction_id: None,
amount_to_capture: None,
connector: None,
payment_method: None,
error_message: None,
payment_method_id: None,
cancellation_reason: None,
mandate_id: None,
browser_info: None,
payment_token: None,
error_code: None,
connector_metadata: None,
payment_method_data: None,
payment_method_type: None,
payment_experience: None,
business_sub_label: None,
straight_through_algorithm: None,
preprocessing_step_id: None,
error_reason: None,
capture_method: None,
connector_response_reference_id: None,
multiple_capture_count: None,
surcharge_amount: None,
tax_amount: None,
amount_capturable: None,
merchant_connector_id: None,
authentication_data: None,
encoded_data: None,
unified_code: None,
unified_message: None,
external_three_ds_authentication_attempted: None,
authentication_connector: None,
authentication_id: None,
fingerprint_id: None,
payment_method_billing_address_id: None,
client_source: None,
client_version: None,
customer_acceptance: None,
card_network: None,
shipping_cost: None,
order_tax_amount: None,
capture_before: None,
extended_authorization_applied: None,
processor_transaction_data: None,
connector_mandate_detail: None,
card_discovery: None,
charges: None,
issuer_error_code: None,
issuer_error_message: None,
},
PaymentAttemptUpdate::ConfirmUpdate {
amount,
currency,
authentication_type,
capture_method,
status,
payment_method,
browser_info,
connector,
payment_token,
payment_method_data,
payment_method_type,
payment_experience,
business_sub_label,
straight_through_algorithm,
error_code,
error_message,
amount_capturable,
updated_by,
merchant_connector_id,
surcharge_amount,
tax_amount,
external_three_ds_authentication_attempted,
authentication_connector,
authentication_id,
payment_method_billing_address_id,
fingerprint_id,
payment_method_id,
client_source,
client_version,
customer_acceptance,
shipping_cost,
order_tax_amount,
connector_mandate_detail,
card_discovery,
} => Self {
amount: Some(amount),
currency: Some(currency),
authentication_type,
status: Some(status),
payment_method,
modified_at: common_utils::date_time::now(),
browser_info,
connector: connector.map(Some),
payment_token,
payment_method_data,
payment_method_type,
payment_experience,
business_sub_label,
straight_through_algorithm,
error_code,
error_message,
amount_capturable,
updated_by,
merchant_connector_id: merchant_connector_id.map(Some),
surcharge_amount,
tax_amount,
external_three_ds_authentication_attempted,
authentication_connector,
authentication_id,
payment_method_billing_address_id,
fingerprint_id,
payment_method_id,
capture_method,
client_source,
client_version,
customer_acceptance,
net_amount: None,
connector_transaction_id: None,
amount_to_capture: None,
cancellation_reason: None,
mandate_id: None,
connector_metadata: None,
preprocessing_step_id: None,
error_reason: None,
connector_response_reference_id: None,
multiple_capture_count: None,
authentication_data: None,
encoded_data: None,
unified_code: None,
unified_message: None,
card_network: None,
shipping_cost,
order_tax_amount,
capture_before: None,
extended_authorization_applied: None,
processor_transaction_data: None,
connector_mandate_detail,
card_discovery,
charges: None,
issuer_error_code: None,
issuer_error_message: None,
},
PaymentAttemptUpdate::VoidUpdate {
status,
cancellation_reason,
updated_by,
} => Self {
status: Some(status),
cancellation_reason,
modified_at: common_utils::date_time::now(),
updated_by,
amount: None,
net_amount: None,
currency: None,
connector_transaction_id: None,
amount_to_capture: None,
connector: None,
authentication_type: None,
payment_method: None,
error_message: None,
payment_method_id: None,
mandate_id: None,
browser_info: None,
payment_token: None,
error_code: None,
connector_metadata: None,
payment_method_data: None,
payment_method_type: None,
payment_experience: None,
business_sub_label: None,
straight_through_algorithm: None,
preprocessing_step_id: None,
error_reason: None,
capture_method: None,
connector_response_reference_id: None,
multiple_capture_count: None,
surcharge_amount: None,
tax_amount: None,
amount_capturable: None,
merchant_connector_id: None,
authentication_data: None,
encoded_data: None,
unified_code: None,
unified_message: None,
external_three_ds_authentication_attempted: None,
authentication_connector: None,
authentication_id: None,
fingerprint_id: None,
payment_method_billing_address_id: None,
client_source: None,
client_version: None,
customer_acceptance: None,
card_network: None,
shipping_cost: None,
order_tax_amount: None,
capture_before: None,
extended_authorization_applied: None,
processor_transaction_data: None,
connector_mandate_detail: None,
card_discovery: None,
charges: None,
issuer_error_code: None,
issuer_error_message: None,
},
PaymentAttemptUpdate::RejectUpdate {
status,
error_code,
error_message,
updated_by,
} => Self {
status: Some(status),
modified_at: common_utils::date_time::now(),
error_code,
error_message,
updated_by,
amount: None,
net_amount: None,
currency: None,
connector_transaction_id: None,
amount_to_capture: None,
connector: None,
authentication_type: None,
payment_method: None,
payment_method_id: None,
cancellation_reason: None,
mandate_id: None,
browser_info: None,
payment_token: None,
connector_metadata: None,
payment_method_data: None,
payment_method_type: None,
payment_experience: None,
business_sub_label: None,
straight_through_algorithm: None,
preprocessing_step_id: None,
error_reason: None,
capture_method: None,
connector_response_reference_id: None,
multiple_capture_count: None,
surcharge_amount: None,
tax_amount: None,
amount_capturable: None,
merchant_connector_id: None,
authentication_data: None,
encoded_data: None,
unified_code: None,
unified_message: None,
external_three_ds_authentication_attempted: None,
authentication_connector: None,
authentication_id: None,
fingerprint_id: None,
payment_method_billing_address_id: None,
client_source: None,
client_version: None,
customer_acceptance: None,
card_network: None,
shipping_cost: None,
order_tax_amount: None,
capture_before: None,
extended_authorization_applied: None,
processor_transaction_data: None,
connector_mandate_detail: None,
card_discovery: None,
charges: None,
issuer_error_code: None,
issuer_error_message: None,
},
PaymentAttemptUpdate::BlocklistUpdate {
status,
error_code,
error_message,
updated_by,
} => Self {
status: Some(status),
modified_at: common_utils::date_time::now(),
error_code,
connector: Some(None),
error_message,
updated_by,
merchant_connector_id: Some(None),
amount: None,
net_amount: None,
currency: None,
connector_transaction_id: None,
amount_to_capture: None,
authentication_type: None,
payment_method: None,
payment_method_id: None,
cancellation_reason: None,
mandate_id: None,
browser_info: None,
payment_token: None,
connector_metadata: None,
payment_method_data: None,
payment_method_type: None,
payment_experience: None,
business_sub_label: None,
straight_through_algorithm: None,
preprocessing_step_id: None,
error_reason: None,
capture_method: None,
connector_response_reference_id: None,
multiple_capture_count: None,
surcharge_amount: None,
tax_amount: None,
amount_capturable: None,
authentication_data: None,
encoded_data: None,
unified_code: None,
unified_message: None,
external_three_ds_authentication_attempted: None,
authentication_connector: None,
authentication_id: None,
fingerprint_id: None,
payment_method_billing_address_id: None,
client_source: None,
client_version: None,
customer_acceptance: None,
card_network: None,
shipping_cost: None,
order_tax_amount: None,
capture_before: None,
extended_authorization_applied: None,
processor_transaction_data: None,
connector_mandate_detail: None,
card_discovery: None,
charges: None,
issuer_error_code: None,
issuer_error_message: None,
},
PaymentAttemptUpdate::ConnectorMandateDetailUpdate {
connector_mandate_detail,
updated_by,
} => Self {
payment_method_id: None,
modified_at: common_utils::date_time::now(),
updated_by,
amount: None,
net_amount: None,
currency: None,
status: None,
connector_transaction_id: None,
amount_to_capture: None,
connector: None,
authentication_type: None,
payment_method: None,
error_message: None,
cancellation_reason: None,
mandate_id: None,
browser_info: None,
payment_token: None,
error_code: None,
connector_metadata: None,
payment_method_data: None,
payment_method_type: None,
payment_experience: None,
business_sub_label: None,
straight_through_algorithm: None,
preprocessing_step_id: None,
error_reason: None,
capture_method: None,
connector_response_reference_id: None,
multiple_capture_count: None,
surcharge_amount: None,
tax_amount: None,
amount_capturable: None,
merchant_connector_id: None,
authentication_data: None,
encoded_data: None,
unified_code: None,
unified_message: None,
external_three_ds_authentication_attempted: None,
authentication_connector: None,
authentication_id: None,
fingerprint_id: None,
payment_method_billing_address_id: None,
client_source: None,
client_version: None,
customer_acceptance: None,
card_network: None,
shipping_cost: None,
order_tax_amount: None,
capture_before: None,
extended_authorization_applied: None,
processor_transaction_data: None,
connector_mandate_detail,
card_discovery: None,
charges: None,
issuer_error_code: None,
issuer_error_message: None,
},
PaymentAttemptUpdate::PaymentMethodDetailsUpdate {
payment_method_id,
updated_by,
} => Self {
payment_method_id,
modified_at: common_utils::date_time::now(),
updated_by,
amount: None,
net_amount: None,
currency: None,
status: None,
connector_transaction_id: None,
amount_to_capture: None,
connector: None,
authentication_type: None,
payment_method: None,
error_message: None,
cancellation_reason: None,
mandate_id: None,
browser_info: None,
payment_token: None,
error_code: None,
connector_metadata: None,
payment_method_data: None,
payment_method_type: None,
payment_experience: None,
business_sub_label: None,
straight_through_algorithm: None,
preprocessing_step_id: None,
error_reason: None,
capture_method: None,
connector_response_reference_id: None,
multiple_capture_count: None,
surcharge_amount: None,
tax_amount: None,
amount_capturable: None,
merchant_connector_id: None,
authentication_data: None,
encoded_data: None,
unified_code: None,
unified_message: None,
external_three_ds_authentication_attempted: None,
authentication_connector: None,
authentication_id: None,
fingerprint_id: None,
payment_method_billing_address_id: None,
client_source: None,
client_version: None,
customer_acceptance: None,
card_network: None,
shipping_cost: None,
order_tax_amount: None,
capture_before: None,
extended_authorization_applied: None,
processor_transaction_data: None,
connector_mandate_detail: None,
card_discovery: None,
charges: None,
issuer_error_code: None,
issuer_error_message: None,
},
PaymentAttemptUpdate::ResponseUpdate {
status,
connector,
connector_transaction_id,
authentication_type,
payment_method_id,
mandate_id,
connector_metadata,
payment_token,
error_code,
error_message,
error_reason,
connector_response_reference_id,
amount_capturable,
updated_by,
authentication_data,
encoded_data,
unified_code,
unified_message,
capture_before,
extended_authorization_applied,
payment_method_data,
connector_mandate_detail,
charges,
} => {
let (connector_transaction_id, processor_transaction_data) =
connector_transaction_id
.map(ConnectorTransactionId::form_id_and_data)
.map(|(txn_id, txn_data)| (Some(txn_id), txn_data))
.unwrap_or((None, None));
Self {
status: Some(status),
connector: connector.map(Some),
connector_transaction_id,
authentication_type,
payment_method_id,
modified_at: common_utils::date_time::now(),
mandate_id,
connector_metadata,
error_code,
error_message,
payment_token,
error_reason,
connector_response_reference_id,
amount_capturable,
updated_by,
authentication_data,
encoded_data,
unified_code,
unified_message,
payment_method_data,
processor_transaction_data,
connector_mandate_detail,
charges,
amount: None,
net_amount: None,
currency: None,
amount_to_capture: None,
payment_method: None,
cancellation_reason: None,
browser_info: None,
payment_method_type: None,
payment_experience: None,
business_sub_label: None,
straight_through_algorithm: None,
preprocessing_step_id: None,
capture_method: None,
multiple_capture_count: None,
surcharge_amount: None,
tax_amount: None,
merchant_connector_id: None,
external_three_ds_authentication_attempted: None,
authentication_connector: None,
authentication_id: None,
fingerprint_id: None,
payment_method_billing_address_id: None,
client_source: None,
client_version: None,
customer_acceptance: None,
card_network: None,
capture_before,
extended_authorization_applied,
shipping_cost: None,
order_tax_amount: None,
card_discovery: None,
issuer_error_code: None,
issuer_error_message: None,
}
}
PaymentAttemptUpdate::ErrorUpdate {
connector,
status,
error_code,
error_message,
error_reason,
amount_capturable,
updated_by,
unified_code,
unified_message,
connector_transaction_id,
payment_method_data,
authentication_type,
issuer_error_code,
issuer_error_message,
} => {
let (connector_transaction_id, processor_transaction_data) =
connector_transaction_id
.map(ConnectorTransactionId::form_id_and_data)
.map(|(txn_id, txn_data)| (Some(txn_id), txn_data))
.unwrap_or((None, None));
Self {
connector: connector.map(Some),
status: Some(status),
error_message,
error_code,
modified_at: common_utils::date_time::now(),
error_reason,
amount_capturable,
updated_by,
unified_code,
unified_message,
connector_transaction_id,
payment_method_data,
authentication_type,
processor_transaction_data,
issuer_error_code,
issuer_error_message,
amount: None,
net_amount: None,
currency: None,
amount_to_capture: None,
payment_method: None,
payment_method_id: None,
cancellation_reason: None,
mandate_id: None,
browser_info: None,
payment_token: None,
connector_metadata: None,
payment_method_type: None,
payment_experience: None,
business_sub_label: None,
straight_through_algorithm: None,
preprocessing_step_id: None,
capture_method: None,
connector_response_reference_id: None,
multiple_capture_count: None,
surcharge_amount: None,
tax_amount: None,
merchant_connector_id: None,
authentication_data: None,
encoded_data: None,
external_three_ds_authentication_attempted: None,
authentication_connector: None,
authentication_id: None,
fingerprint_id: None,
payment_method_billing_address_id: None,
client_source: None,
client_version: None,
customer_acceptance: None,
card_network: None,
capture_before: None,
extended_authorization_applied: None,
shipping_cost: None,
order_tax_amount: None,
connector_mandate_detail: None,
card_discovery: None,
charges: None,
}
}
PaymentAttemptUpdate::StatusUpdate { status, updated_by } => Self {
status: Some(status),
modified_at: common_utils::date_time::now(),
updated_by,
amount: None,
net_amount: None,
currency: None,
connector_transaction_id: None,
amount_to_capture: None,
connector: None,
authentication_type: None,
payment_method: None,
error_message: None,
payment_method_id: None,
cancellation_reason: None,
mandate_id: None,
browser_info: None,
payment_token: None,
error_code: None,
connector_metadata: None,
payment_method_data: None,
payment_method_type: None,
payment_experience: None,
business_sub_label: None,
straight_through_algorithm: None,
preprocessing_step_id: None,
error_reason: None,
capture_method: None,
connector_response_reference_id: None,
multiple_capture_count: None,
surcharge_amount: None,
tax_amount: None,
amount_capturable: None,
merchant_connector_id: None,
authentication_data: None,
encoded_data: None,
unified_code: None,
unified_message: None,
external_three_ds_authentication_attempted: None,
authentication_connector: None,
authentication_id: None,
fingerprint_id: None,
payment_method_billing_address_id: None,
client_source: None,
client_version: None,
customer_acceptance: None,
card_network: None,
shipping_cost: None,
capture_before: None,
extended_authorization_applied: None,
order_tax_amount: None,
processor_transaction_data: None,
connector_mandate_detail: None,
card_discovery: None,
charges: None,
issuer_error_code: None,
issuer_error_message: None,
},
PaymentAttemptUpdate::UpdateTrackers {
payment_token,
connector,
straight_through_algorithm,
amount_capturable,
surcharge_amount,
tax_amount,
updated_by,
merchant_connector_id,
} => Self {
payment_token,
modified_at: common_utils::date_time::now(),
connector: connector.map(Some),
straight_through_algorithm,
amount_capturable,
surcharge_amount,
tax_amount,
updated_by,
merchant_connector_id: merchant_connector_id.map(Some),
amount: None,
net_amount: None,
currency: None,
status: None,
connector_transaction_id: None,
amount_to_capture: None,
authentication_type: None,
payment_method: None,
error_message: None,
payment_method_id: None,
cancellation_reason: None,
mandate_id: None,
browser_info: None,
error_code: None,
connector_metadata: None,
payment_method_data: None,
payment_method_type: None,
payment_experience: None,
business_sub_label: None,
preprocessing_step_id: None,
error_reason: None,
capture_method: None,
connector_response_reference_id: None,
multiple_capture_count: None,
authentication_data: None,
encoded_data: None,
unified_code: None,
unified_message: None,
external_three_ds_authentication_attempted: None,
authentication_connector: None,
authentication_id: None,
fingerprint_id: None,
payment_method_billing_address_id: None,
client_source: None,
client_version: None,
customer_acceptance: None,
card_network: None,
shipping_cost: None,
capture_before: None,
extended_authorization_applied: None,
order_tax_amount: None,
processor_transaction_data: None,
connector_mandate_detail: None,
card_discovery: None,
charges: None,
issuer_error_code: None,
issuer_error_message: None,
},
PaymentAttemptUpdate::UnresolvedResponseUpdate {
status,
connector,
connector_transaction_id,
payment_method_id,
error_code,
error_message,
error_reason,
connector_response_reference_id,
updated_by,
} => {
let (connector_transaction_id, processor_transaction_data) =
connector_transaction_id
.map(ConnectorTransactionId::form_id_and_data)
.map(|(txn_id, txn_data)| (Some(txn_id), txn_data))
.unwrap_or((None, None));
Self {
status: Some(status),
connector: connector.map(Some),
connector_transaction_id,
payment_method_id,
modified_at: common_utils::date_time::now(),
error_code,
error_message,
error_reason,
connector_response_reference_id,
updated_by,
processor_transaction_data,
amount: None,
net_amount: None,
currency: None,
amount_to_capture: None,
authentication_type: None,
payment_method: None,
cancellation_reason: None,
mandate_id: None,
browser_info: None,
payment_token: None,
connector_metadata: None,
payment_method_data: None,
payment_method_type: None,
payment_experience: None,
business_sub_label: None,
straight_through_algorithm: None,
preprocessing_step_id: None,
capture_method: None,
multiple_capture_count: None,
surcharge_amount: None,
tax_amount: None,
amount_capturable: None,
merchant_connector_id: None,
authentication_data: None,
encoded_data: None,
unified_code: None,
unified_message: None,
external_three_ds_authentication_attempted: None,
authentication_connector: None,
authentication_id: None,
fingerprint_id: None,
payment_method_billing_address_id: None,
client_source: None,
client_version: None,
customer_acceptance: None,
card_network: None,
shipping_cost: None,
capture_before: None,
extended_authorization_applied: None,
order_tax_amount: None,
connector_mandate_detail: None,
card_discovery: None,
charges: None,
issuer_error_code: None,
issuer_error_message: None,
}
}
PaymentAttemptUpdate::PreprocessingUpdate {
status,
payment_method_id,
connector_metadata,
preprocessing_step_id,
connector_transaction_id,
connector_response_reference_id,
updated_by,
} => {
let (connector_transaction_id, processor_transaction_data) =
connector_transaction_id
.map(ConnectorTransactionId::form_id_and_data)
.map(|(txn_id, txn_data)| (Some(txn_id), txn_data))
.unwrap_or((None, None));
Self {
status: Some(status),
payment_method_id,
modified_at: common_utils::date_time::now(),
connector_metadata,
preprocessing_step_id,
connector_transaction_id,
connector_response_reference_id,
updated_by,
processor_transaction_data,
amount: None,
net_amount: None,
currency: None,
amount_to_capture: None,
connector: None,
authentication_type: None,
payment_method: None,
error_message: None,
cancellation_reason: None,
mandate_id: None,
browser_info: None,
payment_token: None,
error_code: None,
payment_method_data: None,
payment_method_type: None,
payment_experience: None,
business_sub_label: None,
straight_through_algorithm: None,
error_reason: None,
capture_method: None,
multiple_capture_count: None,
surcharge_amount: None,
tax_amount: None,
amount_capturable: None,
merchant_connector_id: None,
authentication_data: None,
encoded_data: None,
unified_code: None,
unified_message: None,
external_three_ds_authentication_attempted: None,
authentication_connector: None,
authentication_id: None,
fingerprint_id: None,
payment_method_billing_address_id: None,
client_source: None,
client_version: None,
customer_acceptance: None,
card_network: None,
capture_before: None,
extended_authorization_applied: None,
shipping_cost: None,
order_tax_amount: None,
connector_mandate_detail: None,
card_discovery: None,
charges: None,
issuer_error_code: None,
issuer_error_message: None,
}
}
PaymentAttemptUpdate::CaptureUpdate {
multiple_capture_count,
updated_by,
amount_to_capture,
} => Self {
multiple_capture_count,
modified_at: common_utils::date_time::now(),
updated_by,
amount_to_capture,
amount: None,
net_amount: None,
currency: None,
status: None,
connector_transaction_id: None,
connector: None,
authentication_type: None,
payment_method: None,
error_message: None,
payment_method_id: None,
cancellation_reason: None,
mandate_id: None,
browser_info: None,
payment_token: None,
error_code: None,
connector_metadata: None,
payment_method_data: None,
payment_method_type: None,
payment_experience: None,
business_sub_label: None,
straight_through_algorithm: None,
preprocessing_step_id: None,
error_reason: None,
capture_method: None,
connector_response_reference_id: None,
surcharge_amount: None,
tax_amount: None,
amount_capturable: None,
merchant_connector_id: None,
authentication_data: None,
encoded_data: None,
unified_code: None,
unified_message: None,
external_three_ds_authentication_attempted: None,
authentication_connector: None,
authentication_id: None,
fingerprint_id: None,
payment_method_billing_address_id: None,
client_source: None,
client_version: None,
customer_acceptance: None,
card_network: None,
shipping_cost: None,
order_tax_amount: None,
capture_before: None,
extended_authorization_applied: None,
processor_transaction_data: None,
connector_mandate_detail: None,
card_discovery: None,
charges: None,
issuer_error_code: None,
issuer_error_message: None,
},
PaymentAttemptUpdate::AmountToCaptureUpdate {
status,
amount_capturable,
updated_by,
} => Self {
status: Some(status),
modified_at: common_utils::date_time::now(),
amount_capturable: Some(amount_capturable),
updated_by,
amount: None,
net_amount: None,
currency: None,
connector_transaction_id: None,
amount_to_capture: None,
connector: None,
authentication_type: None,
payment_method: None,
error_message: None,
payment_method_id: None,
cancellation_reason: None,
mandate_id: None,
browser_info: None,
payment_token: None,
error_code: None,
connector_metadata: None,
payment_method_data: None,
payment_method_type: None,
payment_experience: None,
business_sub_label: None,
straight_through_algorithm: None,
preprocessing_step_id: None,
error_reason: None,
capture_method: None,
connector_response_reference_id: None,
multiple_capture_count: None,
surcharge_amount: None,
tax_amount: None,
merchant_connector_id: None,
authentication_data: None,
encoded_data: None,
unified_code: None,
unified_message: None,
external_three_ds_authentication_attempted: None,
authentication_connector: None,
authentication_id: None,
fingerprint_id: None,
payment_method_billing_address_id: None,
client_source: None,
client_version: None,
customer_acceptance: None,
card_network: None,
shipping_cost: None,
capture_before: None,
extended_authorization_applied: None,
order_tax_amount: None,
processor_transaction_data: None,
connector_mandate_detail: None,
card_discovery: None,
charges: None,
issuer_error_code: None,
issuer_error_message: None,
},
PaymentAttemptUpdate::ConnectorResponse {
authentication_data,
encoded_data,
connector_transaction_id,
connector,
updated_by,
charges,
} => {
let (connector_transaction_id, processor_transaction_data) =
connector_transaction_id
.map(ConnectorTransactionId::form_id_and_data)
.map(|(txn_id, txn_data)| (Some(txn_id), txn_data))
.unwrap_or((None, None));
Self {
authentication_data,
encoded_data,
connector_transaction_id,
connector: connector.map(Some),
modified_at: common_utils::date_time::now(),
updated_by,
processor_transaction_data,
charges,
amount: None,
net_amount: None,
currency: None,
status: None,
amount_to_capture: None,
authentication_type: None,
payment_method: None,
error_message: None,
payment_method_id: None,
cancellation_reason: None,
mandate_id: None,
browser_info: None,
payment_token: None,
error_code: None,
connector_metadata: None,
payment_method_data: None,
payment_method_type: None,
payment_experience: None,
business_sub_label: None,
straight_through_algorithm: None,
preprocessing_step_id: None,
error_reason: None,
capture_method: None,
connector_response_reference_id: None,
multiple_capture_count: None,
surcharge_amount: None,
tax_amount: None,
amount_capturable: None,
merchant_connector_id: None,
unified_code: None,
unified_message: None,
external_three_ds_authentication_attempted: None,
authentication_connector: None,
authentication_id: None,
fingerprint_id: None,
payment_method_billing_address_id: None,
client_source: None,
client_version: None,
customer_acceptance: None,
card_network: None,
shipping_cost: None,
capture_before: None,
extended_authorization_applied: None,
order_tax_amount: None,
connector_mandate_detail: None,
card_discovery: None,
issuer_error_code: None,
issuer_error_message: None,
}
}
PaymentAttemptUpdate::IncrementalAuthorizationAmountUpdate {
amount,
amount_capturable,
} => Self {
amount: Some(amount),
modified_at: common_utils::date_time::now(),
amount_capturable: Some(amount_capturable),
net_amount: None,
currency: None,
status: None,
connector_transaction_id: None,
amount_to_capture: None,
connector: None,
authentication_type: None,
payment_method: None,
error_message: None,
payment_method_id: None,
cancellation_reason: None,
mandate_id: None,
browser_info: None,
payment_token: None,
error_code: None,
connector_metadata: None,
payment_method_data: None,
payment_method_type: None,
payment_experience: None,
business_sub_label: None,
straight_through_algorithm: None,
preprocessing_step_id: None,
error_reason: None,
capture_method: None,
connector_response_reference_id: None,
multiple_capture_count: None,
surcharge_amount: None,
tax_amount: None,
updated_by: String::default(),
merchant_connector_id: None,
authentication_data: None,
encoded_data: None,
unified_code: None,
unified_message: None,
external_three_ds_authentication_attempted: None,
authentication_connector: None,
authentication_id: None,
fingerprint_id: None,
payment_method_billing_address_id: None,
client_source: None,
client_version: None,
customer_acceptance: None,
card_network: None,
shipping_cost: None,
order_tax_amount: None,
capture_before: None,
extended_authorization_applied: None,
processor_transaction_data: None,
connector_mandate_detail: None,
card_discovery: None,
charges: None,
issuer_error_code: None,
issuer_error_message: None,
},
PaymentAttemptUpdate::AuthenticationUpdate {
status,
external_three_ds_authentication_attempted,
authentication_connector,
authentication_id,
updated_by,
} => Self {
status: Some(status),
modified_at: common_utils::date_time::now(),
external_three_ds_authentication_attempted,
authentication_connector,
authentication_id,
updated_by,
amount: None,
net_amount: None,
currency: None,
connector_transaction_id: None,
amount_to_capture: None,
connector: None,
authentication_type: None,
payment_method: None,
error_message: None,
payment_method_id: None,
cancellation_reason: None,
mandate_id: None,
browser_info: None,
payment_token: None,
error_code: None,
connector_metadata: None,
payment_method_data: None,
payment_method_type: None,
payment_experience: None,
business_sub_label: None,
straight_through_algorithm: None,
preprocessing_step_id: None,
error_reason: None,
capture_method: None,
connector_response_reference_id: None,
multiple_capture_count: None,
surcharge_amount: None,
tax_amount: None,
amount_capturable: None,
merchant_connector_id: None,
authentication_data: None,
encoded_data: None,
unified_code: None,
unified_message: None,
fingerprint_id: None,
payment_method_billing_address_id: None,
client_source: None,
client_version: None,
customer_acceptance: None,
card_network: None,
shipping_cost: None,
order_tax_amount: None,
capture_before: None,
extended_authorization_applied: None,
processor_transaction_data: None,
connector_mandate_detail: None,
card_discovery: None,
charges: None,
issuer_error_code: None,
issuer_error_message: None,
},
PaymentAttemptUpdate::ManualUpdate {
status,
error_code,
error_message,
error_reason,
updated_by,
unified_code,
unified_message,
connector_transaction_id,
} => {
let (connector_transaction_id, processor_transaction_data) =
connector_transaction_id
.map(ConnectorTransactionId::form_id_and_data)
.map(|(txn_id, txn_data)| (Some(txn_id), txn_data))
.unwrap_or((None, None));
Self {
status,
error_code: error_code.map(Some),
modified_at: common_utils::date_time::now(),
error_message: error_message.map(Some),
error_reason: error_reason.map(Some),
updated_by,
unified_code: unified_code.map(Some),
unified_message: unified_message.map(Some),
connector_transaction_id,
processor_transaction_data,
amount: None,
net_amount: None,
currency: None,
amount_to_capture: None,
connector: None,
authentication_type: None,
payment_method: None,
payment_method_id: None,
cancellation_reason: None,
mandate_id: None,
browser_info: None,
payment_token: None,
connector_metadata: None,
payment_method_data: None,
payment_method_type: None,
payment_experience: None,
business_sub_label: None,
straight_through_algorithm: None,
preprocessing_step_id: None,
capture_method: None,
connector_response_reference_id: None,
multiple_capture_count: None,
surcharge_amount: None,
tax_amount: None,
amount_capturable: None,
merchant_connector_id: None,
authentication_data: None,
encoded_data: None,
external_three_ds_authentication_attempted: None,
authentication_connector: None,
authentication_id: None,
fingerprint_id: None,
payment_method_billing_address_id: None,
client_source: None,
client_version: None,
customer_acceptance: None,
card_network: None,
shipping_cost: None,
capture_before: None,
extended_authorization_applied: None,
order_tax_amount: None,
connector_mandate_detail: None,
card_discovery: None,
charges: None,
issuer_error_code: None,
issuer_error_message: None,
}
}
PaymentAttemptUpdate::PostSessionTokensUpdate {
updated_by,
connector_metadata,
} => Self {
status: None,
error_code: None,
modified_at: common_utils::date_time::now(),
error_message: None,
error_reason: None,
updated_by,
unified_code: None,
unified_message: None,
amount: None,
net_amount: None,
currency: None,
connector_transaction_id: None,
amount_to_capture: None,
connector: None,
authentication_type: None,
payment_method: None,
payment_method_id: None,
cancellation_reason: None,
mandate_id: None,
browser_info: None,
payment_token: None,
connector_metadata,
payment_method_data: None,
payment_method_type: None,
payment_experience: None,
business_sub_label: None,
straight_through_algorithm: None,
preprocessing_step_id: None,
capture_method: None,
connector_response_reference_id: None,
multiple_capture_count: None,
surcharge_amount: None,
tax_amount: None,
amount_capturable: None,
merchant_connector_id: None,
authentication_data: None,
encoded_data: None,
external_three_ds_authentication_attempted: None,
authentication_connector: None,
authentication_id: None,
fingerprint_id: None,
payment_method_billing_address_id: None,
client_source: None,
client_version: None,
customer_acceptance: None,
card_network: None,
shipping_cost: None,
order_tax_amount: None,
capture_before: None,
extended_authorization_applied: None,
processor_transaction_data: None,
connector_mandate_detail: None,
card_discovery: None,
charges: None,
issuer_error_code: None,
issuer_error_message: None,
},
}
}
}
#[derive(Eq, PartialEq, Clone, Debug, Deserialize, Serialize, diesel::AsExpression)]
#[diesel(sql_type = diesel::sql_types::Jsonb)]
pub enum RedirectForm {
Form {
endpoint: String,
method: common_utils::request::Method,
form_fields: std::collections::HashMap<String, String>,
},
Html {
html_data: String,
},
BlueSnap {
payment_fields_token: String,
},
CybersourceAuthSetup {
access_token: String,
ddc_url: String,
reference_id: String,
},
CybersourceConsumerAuth {
access_token: String,
step_up_url: String,
},
DeutschebankThreeDSChallengeFlow {
acs_url: String,
creq: String,
},
Payme,
Braintree {
client_token: String,
card_token: String,
bin: String,
acs_url: String,
},
Nmi {
amount: String,
currency: common_enums::Currency,
public_key: masking::Secret<String>,
customer_vault_id: String,
order_id: String,
},
Mifinity {
initialization_token: String,
},
WorldpayDDCForm {
endpoint: common_utils::types::Url,
method: common_utils::request::Method,
form_fields: std::collections::HashMap<String, String>,
collection_id: Option<String>,
},
}
common_utils::impl_to_sql_from_sql_json!(RedirectForm);
#[cfg(feature = "v2")]
#[derive(
Clone, Debug, serde::Deserialize, serde::Serialize, Eq, PartialEq, diesel::AsExpression,
)]
#[diesel(sql_type = diesel::pg::sql_types::Jsonb)]
pub struct PaymentAttemptFeatureMetadata {
pub revenue_recovery: Option<PaymentAttemptRecoveryData>,
}
#[cfg(feature = "v2")]
#[derive(
Clone, Debug, serde::Deserialize, serde::Serialize, Eq, PartialEq, diesel::AsExpression,
)]
#[diesel(sql_type = diesel::pg::sql_types::Jsonb)]
pub struct PaymentAttemptRecoveryData {
pub attempt_triggered_by: common_enums::TriggeredBy,
}
#[cfg(feature = "v2")]
common_utils::impl_to_sql_from_sql_json!(PaymentAttemptFeatureMetadata);
mod tests {
#[test]
fn test_backwards_compatibility() {
let serialized_payment_attempt = r#"{
"payment_id": "PMT123456789",
"merchant_id": "M123456789",
"attempt_id": "ATMPT123456789",
"status": "pending",
"amount": 10000,
"currency": "USD",
"save_to_locker": true,
"connector": "stripe",
"error_message": null,
"offer_amount": 9500,
"surcharge_amount": 500,
"tax_amount": 800,
"payment_method_id": "CRD123456789",
"payment_method": "card",
"connector_transaction_id": "CNTR123456789",
"capture_method": "automatic",
"capture_on": "2022-09-10T10:11:12Z",
"confirm": false,
"authentication_type": "no_three_ds",
"created_at": "2024-02-26T12:00:00Z",
"modified_at": "2024-02-26T12:00:00Z",
"last_synced": null,
"cancellation_reason": null,
"amount_to_capture": 10000,
"mandate_id": null,
"browser_info": {
"user_agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/70.0.3538.110 Safari/537.36",
"accept_header": "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8",
"language": "nl-NL",
"color_depth": 24,
"screen_height": 723,
"screen_width": 1536,
"time_zone": 0,
"java_enabled": true,
"java_script_enabled": true,
"ip_address": "127.0.0.1"
},
"error_code": null,
"payment_token": "TOKEN123456789",
"connector_metadata": null,
"payment_experience": "redirect_to_url",
"payment_method_type": "credit",
"payment_method_data": {
"card": {
"card_number": "4242424242424242",
"card_exp_month": "10",
"card_cvc": "123",
"card_exp_year": "2024",
"card_holder_name": "John Doe"
}
},
"business_sub_label": "Premium",
"straight_through_algorithm": null,
"preprocessing_step_id": null,
"mandate_details": null,
"error_reason": null,
"multiple_capture_count": 0,
"connector_response_reference_id": null,
"amount_capturable": 10000,
"updated_by": "redis_kv",
"merchant_connector_id": "MCN123456789",
"authentication_data": null,
"encoded_data": null,
"unified_code": null,
"unified_message": null,
"net_amount": 10200,
"mandate_data": {
"customer_acceptance": {
"acceptance_type": "offline",
"accepted_at": "1963-05-03T04:07:52.723Z",
"online": {
"ip_address": "127.0.0.1",
"user_agent": "amet irure esse"
}
},
"single_use": {
"amount": 6540,
"currency": "USD"
}
}
},
"fingerprint_id": null
}"#;
let deserialized =
serde_json::from_str::<super::PaymentAttempt>(serialized_payment_attempt);
assert!(deserialized.is_ok());
}
}
| proc_macro_neighborhoods |
<file_sep path="hyperswitch/crates/router_derive/src/lib.rs" crate="router_derive" role="macro_def">
<|fim_prefix|>
<|meta_start|><|file|> hyperswitch/crates/router_derive/src/lib.rs<|crate|> diesel_models macro=DebugAsDisplay roles=use_site,macro_def use=derive item=file pack=proc_macro_neighborhoods lang=rust<|meta_end|>
pub fn debug_as_display_derive(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
<|fim_suffix|>
<|fim_middle|>
}
<file_sep path="hyperswitch/crates/router_derive/src/lib.rs" crate="router_derive" role="macro_def">
<|fim_prefix|>
pub fn debug_as_display_derive(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
<|fim_suffix|>
<|fim_middle|>
}
| proc_macro_neighborhoods |
<|meta_start|><|file|> hyperswitch/crates/router_derive/src/lib.rs<|crate|> diesel_models macro=DebugAsDisplay roles=use_site,macro_def use=derive item=file pack=proc_macro_neighborhoods lang=rust<|meta_end|>
<file_sep path="hyperswitch/crates/diesel_models/src/payment_attempt.rs" crate="diesel_models" role="use_site">
use common_types::primitive_wrappers::{
ExtendedAuthorizationAppliedBool, RequestExtendedAuthorizationBool,
};
use common_utils::{
id_type, pii,
types::{ConnectorTransactionId, ConnectorTransactionIdTrait, MinorUnit},
};
use diesel::{AsChangeset, Identifiable, Insertable, Queryable, Selectable};
use serde::{Deserialize, Serialize};
use time::PrimitiveDateTime;
use crate::enums as storage_enums;
#[cfg(feature = "v1")]
use crate::schema::payment_attempt;
#[cfg(feature = "v2")]
use crate::schema_v2::payment_attempt;
common_utils::impl_to_sql_from_sql_json!(ConnectorMandateReferenceId);
#[derive(
Clone, Debug, serde::Deserialize, serde::Serialize, Eq, PartialEq, diesel::AsExpression,
)]
#[diesel(sql_type = diesel::sql_types::Jsonb)]
pub struct ConnectorMandateReferenceId {
pub connector_mandate_id: Option<String>,
pub payment_method_id: Option<String>,
pub mandate_metadata: Option<pii::SecretSerdeValue>,
pub connector_mandate_request_reference_id: Option<String>,
}
impl ConnectorMandateReferenceId {
pub fn get_connector_mandate_request_reference_id(&self) -> Option<String> {
self.connector_mandate_request_reference_id.clone()
}
}
#[cfg(feature = "v2")]
#[derive(
Clone, Debug, Eq, PartialEq, Identifiable, Queryable, Serialize, Deserialize, Selectable,
)]
#[diesel(table_name = payment_attempt, primary_key(id), check_for_backend(diesel::pg::Pg))]
pub struct PaymentAttempt {
pub payment_id: id_type::GlobalPaymentId,
pub merchant_id: id_type::MerchantId,
pub status: storage_enums::AttemptStatus,
pub connector: Option<String>,
pub error_message: Option<String>,
pub surcharge_amount: Option<MinorUnit>,
pub payment_method_id: Option<id_type::GlobalPaymentMethodId>,
pub authentication_type: storage_enums::AuthenticationType,
#[serde(with = "common_utils::custom_serde::iso8601")]
pub created_at: PrimitiveDateTime,
#[serde(with = "common_utils::custom_serde::iso8601")]
pub modified_at: PrimitiveDateTime,
#[serde(default, with = "common_utils::custom_serde::iso8601::option")]
pub last_synced: Option<PrimitiveDateTime>,
pub cancellation_reason: Option<String>,
pub amount_to_capture: Option<MinorUnit>,
pub browser_info: Option<common_utils::types::BrowserInformation>,
pub error_code: Option<String>,
pub payment_token: Option<String>,
pub connector_metadata: Option<pii::SecretSerdeValue>,
pub payment_experience: Option<storage_enums::PaymentExperience>,
pub payment_method_data: Option<pii::SecretSerdeValue>,
pub preprocessing_step_id: Option<String>,
pub error_reason: Option<String>,
pub multiple_capture_count: Option<i16>,
pub connector_response_reference_id: Option<String>,
pub amount_capturable: MinorUnit,
pub updated_by: String,
pub merchant_connector_id: Option<id_type::MerchantConnectorAccountId>,
pub encoded_data: Option<masking::Secret<String>>,
pub unified_code: Option<String>,
pub unified_message: Option<String>,
pub net_amount: MinorUnit,
pub external_three_ds_authentication_attempted: Option<bool>,
pub authentication_connector: Option<String>,
pub authentication_id: Option<String>,
pub fingerprint_id: Option<String>,
pub client_source: Option<String>,
pub client_version: Option<String>,
pub customer_acceptance: Option<pii::SecretSerdeValue>,
pub profile_id: id_type::ProfileId,
pub organization_id: id_type::OrganizationId,
pub card_network: Option<String>,
pub shipping_cost: Option<MinorUnit>,
pub order_tax_amount: Option<MinorUnit>,
pub request_extended_authorization: Option<RequestExtendedAuthorizationBool>,
pub extended_authorization_applied: Option<ExtendedAuthorizationAppliedBool>,
pub capture_before: Option<PrimitiveDateTime>,
pub card_discovery: Option<storage_enums::CardDiscovery>,
pub charges: Option<common_types::payments::ConnectorChargeResponseData>,
pub payment_method_type_v2: storage_enums::PaymentMethod,
pub connector_payment_id: Option<ConnectorTransactionId>,
pub payment_method_subtype: storage_enums::PaymentMethodType,
pub routing_result: Option<serde_json::Value>,
pub authentication_applied: Option<common_enums::AuthenticationType>,
pub external_reference_id: Option<String>,
pub tax_on_surcharge: Option<MinorUnit>,
pub payment_method_billing_address: Option<common_utils::encryption::Encryption>,
pub redirection_data: Option<RedirectForm>,
pub connector_payment_data: Option<String>,
pub connector_token_details: Option<ConnectorTokenDetails>,
pub id: id_type::GlobalAttemptId,
pub feature_metadata: Option<PaymentAttemptFeatureMetadata>,
/// This field can be returned for both approved and refused Mastercard payments.
/// This code provides additional information about the type of transaction or the reason why the payment failed.
/// If the payment failed, the network advice code gives guidance on if and when you can retry the payment.
pub network_advice_code: Option<String>,
/// For card errors resulting from a card issuer decline, a brand specific 2, 3, or 4 digit code which indicates the reason the authorization failed.
pub network_decline_code: Option<String>,
/// A string indicating how to proceed with an network error if payment gateway provide one. This is used to understand the network error code better.
pub network_error_message: Option<String>,
}
#[cfg(feature = "v1")]
#[derive(
Clone, Debug, Eq, PartialEq, Identifiable, Queryable, Serialize, Deserialize, Selectable,
)]
#[diesel(table_name = payment_attempt, primary_key(attempt_id, merchant_id), check_for_backend(diesel::pg::Pg))]
pub struct PaymentAttempt {
pub payment_id: id_type::PaymentId,
pub merchant_id: id_type::MerchantId,
pub attempt_id: String,
pub status: storage_enums::AttemptStatus,
pub amount: MinorUnit,
pub currency: Option<storage_enums::Currency>,
pub save_to_locker: Option<bool>,
pub connector: Option<String>,
pub error_message: Option<String>,
pub offer_amount: Option<MinorUnit>,
pub surcharge_amount: Option<MinorUnit>,
pub tax_amount: Option<MinorUnit>,
pub payment_method_id: Option<String>,
pub payment_method: Option<storage_enums::PaymentMethod>,
pub connector_transaction_id: Option<ConnectorTransactionId>,
pub capture_method: Option<storage_enums::CaptureMethod>,
#[serde(default, with = "common_utils::custom_serde::iso8601::option")]
pub capture_on: Option<PrimitiveDateTime>,
pub confirm: bool,
pub authentication_type: Option<storage_enums::AuthenticationType>,
#[serde(with = "common_utils::custom_serde::iso8601")]
pub created_at: PrimitiveDateTime,
#[serde(with = "common_utils::custom_serde::iso8601")]
pub modified_at: PrimitiveDateTime,
#[serde(default, with = "common_utils::custom_serde::iso8601::option")]
pub last_synced: Option<PrimitiveDateTime>,
pub cancellation_reason: Option<String>,
pub amount_to_capture: Option<MinorUnit>,
pub mandate_id: Option<String>,
pub browser_info: Option<serde_json::Value>,
pub error_code: Option<String>,
pub payment_token: Option<String>,
pub connector_metadata: Option<serde_json::Value>,
pub payment_experience: Option<storage_enums::PaymentExperience>,
pub payment_method_type: Option<storage_enums::PaymentMethodType>,
pub payment_method_data: Option<serde_json::Value>,
pub business_sub_label: Option<String>,
pub straight_through_algorithm: Option<serde_json::Value>,
pub preprocessing_step_id: Option<String>,
// providing a location to store mandate details intermediately for transaction
pub mandate_details: Option<storage_enums::MandateDataType>,
pub error_reason: Option<String>,
pub multiple_capture_count: Option<i16>,
// reference to the payment at connector side
pub connector_response_reference_id: Option<String>,
pub amount_capturable: MinorUnit,
pub updated_by: String,
pub merchant_connector_id: Option<id_type::MerchantConnectorAccountId>,
pub authentication_data: Option<serde_json::Value>,
pub encoded_data: Option<String>,
pub unified_code: Option<String>,
pub unified_message: Option<String>,
pub net_amount: Option<MinorUnit>,
pub external_three_ds_authentication_attempted: Option<bool>,
pub authentication_connector: Option<String>,
pub authentication_id: Option<String>,
pub mandate_data: Option<storage_enums::MandateDetails>,
pub fingerprint_id: Option<String>,
pub payment_method_billing_address_id: Option<String>,
pub charge_id: Option<String>,
pub client_source: Option<String>,
pub client_version: Option<String>,
pub customer_acceptance: Option<pii::SecretSerdeValue>,
pub profile_id: id_type::ProfileId,
pub organization_id: id_type::OrganizationId,
pub card_network: Option<String>,
pub shipping_cost: Option<MinorUnit>,
pub order_tax_amount: Option<MinorUnit>,
/// INFO: This field is deprecated and replaced by processor_transaction_data
pub connector_transaction_data: Option<String>,
pub connector_mandate_detail: Option<ConnectorMandateReferenceId>,
pub request_extended_authorization: Option<RequestExtendedAuthorizationBool>,
pub extended_authorization_applied: Option<ExtendedAuthorizationAppliedBool>,
pub capture_before: Option<PrimitiveDateTime>,
pub processor_transaction_data: Option<String>,
pub card_discovery: Option<storage_enums::CardDiscovery>,
pub charges: Option<common_types::payments::ConnectorChargeResponseData>,
pub issuer_error_code: Option<String>,
pub issuer_error_message: Option<String>,
}
#[cfg(feature = "v1")]
impl ConnectorTransactionIdTrait for PaymentAttempt {
fn get_optional_connector_transaction_id(&self) -> Option<&String> {
match self
.connector_transaction_id
.as_ref()
.map(|txn_id| txn_id.get_txn_id(self.processor_transaction_data.as_ref()))
.transpose()
{
Ok(txn_id) => txn_id,
// In case hashed data is missing from DB, use the hashed ID as connector transaction ID
Err(_) => self
.connector_transaction_id
.as_ref()
.map(|txn_id| txn_id.get_id()),
}
}
}
#[cfg(feature = "v2")]
impl ConnectorTransactionIdTrait for PaymentAttempt {
fn get_optional_connector_transaction_id(&self) -> Option<&String> {
match self
.connector_payment_id
.as_ref()
.map(|txn_id| txn_id.get_txn_id(self.connector_payment_data.as_ref()))
.transpose()
{
Ok(txn_id) => txn_id,
// In case hashed data is missing from DB, use the hashed ID as connector payment ID
Err(_) => self
.connector_payment_id
.as_ref()
.map(|txn_id| txn_id.get_id()),
}
}
}
#[cfg(feature = "v2")]
#[derive(
Clone, Debug, PartialEq, Eq, serde::Deserialize, serde::Serialize, diesel::AsExpression,
)]
#[diesel(sql_type = diesel::sql_types::Jsonb)]
pub struct ConnectorTokenDetails {
pub connector_mandate_id: Option<String>,
pub connector_token_request_reference_id: Option<String>,
}
#[cfg(feature = "v2")]
common_utils::impl_to_sql_from_sql_json!(ConnectorTokenDetails);
#[cfg(feature = "v2")]
impl ConnectorTokenDetails {
pub fn get_connector_token_request_reference_id(&self) -> Option<String> {
self.connector_token_request_reference_id.clone()
}
}
#[derive(Clone, Debug, Eq, PartialEq, Queryable, Serialize, Deserialize)]
pub struct PaymentListFilters {
pub connector: Vec<String>,
pub currency: Vec<storage_enums::Currency>,
pub status: Vec<storage_enums::IntentStatus>,
pub payment_method: Vec<storage_enums::PaymentMethod>,
}
#[cfg(feature = "v2")]
#[derive(Clone, Debug, Insertable, router_derive::DebugAsDisplay, Serialize, Deserialize)]
#[diesel(table_name = payment_attempt)]
pub struct PaymentAttemptNew {
pub payment_id: id_type::GlobalPaymentId,
pub merchant_id: id_type::MerchantId,
pub status: storage_enums::AttemptStatus,
pub error_message: Option<String>,
pub surcharge_amount: Option<MinorUnit>,
pub tax_on_surcharge: Option<MinorUnit>,
pub payment_method_id: Option<id_type::GlobalPaymentMethodId>,
pub authentication_type: storage_enums::AuthenticationType,
#[serde(with = "common_utils::custom_serde::iso8601")]
pub created_at: PrimitiveDateTime,
#[serde(with = "common_utils::custom_serde::iso8601")]
pub modified_at: PrimitiveDateTime,
#[serde(default, with = "common_utils::custom_serde::iso8601::option")]
pub last_synced: Option<PrimitiveDateTime>,
pub cancellation_reason: Option<String>,
pub amount_to_capture: Option<MinorUnit>,
pub browser_info: Option<common_utils::types::BrowserInformation>,
pub payment_token: Option<String>,
pub error_code: Option<String>,
pub connector_metadata: Option<pii::SecretSerdeValue>,
pub payment_experience: Option<storage_enums::PaymentExperience>,
pub payment_method_data: Option<pii::SecretSerdeValue>,
pub preprocessing_step_id: Option<String>,
pub error_reason: Option<String>,
pub connector_response_reference_id: Option<String>,
pub multiple_capture_count: Option<i16>,
pub amount_capturable: MinorUnit,
pub updated_by: String,
pub merchant_connector_id: Option<id_type::MerchantConnectorAccountId>,
pub redirection_data: Option<RedirectForm>,
pub encoded_data: Option<masking::Secret<String>>,
pub unified_code: Option<String>,
pub unified_message: Option<String>,
pub net_amount: MinorUnit,
pub external_three_ds_authentication_attempted: Option<bool>,
pub authentication_connector: Option<String>,
pub authentication_id: Option<String>,
pub fingerprint_id: Option<String>,
pub payment_method_billing_address: Option<common_utils::encryption::Encryption>,
pub client_source: Option<String>,
pub client_version: Option<String>,
pub customer_acceptance: Option<pii::SecretSerdeValue>,
pub profile_id: id_type::ProfileId,
pub organization_id: id_type::OrganizationId,
pub card_network: Option<String>,
pub shipping_cost: Option<MinorUnit>,
pub order_tax_amount: Option<MinorUnit>,
pub charges: Option<common_types::payments::ConnectorChargeResponseData>,
pub feature_metadata: Option<PaymentAttemptFeatureMetadata>,
pub payment_method_type_v2: storage_enums::PaymentMethod,
pub connector_payment_id: Option<ConnectorTransactionId>,
pub payment_method_subtype: storage_enums::PaymentMethodType,
pub id: id_type::GlobalAttemptId,
pub connector_token_details: Option<ConnectorTokenDetails>,
pub card_discovery: Option<storage_enums::CardDiscovery>,
pub request_extended_authorization: Option<RequestExtendedAuthorizationBool>,
pub extended_authorization_applied: Option<ExtendedAuthorizationAppliedBool>,
pub capture_before: Option<PrimitiveDateTime>,
pub connector: Option<String>,
pub network_decline_code: Option<String>,
pub network_advice_code: Option<String>,
pub network_error_message: Option<String>,
}
#[cfg(feature = "v1")]
#[derive(Clone, Debug, Insertable, router_derive::DebugAsDisplay, Serialize, Deserialize)]
#[diesel(table_name = payment_attempt)]
pub struct PaymentAttemptNew {
pub payment_id: id_type::PaymentId,
pub merchant_id: id_type::MerchantId,
pub attempt_id: String,
pub status: storage_enums::AttemptStatus,
pub amount: MinorUnit,
pub currency: Option<storage_enums::Currency>,
// pub auto_capture: Option<bool>,
pub save_to_locker: Option<bool>,
pub connector: Option<String>,
pub error_message: Option<String>,
pub offer_amount: Option<MinorUnit>,
pub surcharge_amount: Option<MinorUnit>,
pub tax_amount: Option<MinorUnit>,
pub payment_method_id: Option<String>,
pub payment_method: Option<storage_enums::PaymentMethod>,
pub capture_method: Option<storage_enums::CaptureMethod>,
#[serde(default, with = "common_utils::custom_serde::iso8601::option")]
pub capture_on: Option<PrimitiveDateTime>,
pub confirm: bool,
pub authentication_type: Option<storage_enums::AuthenticationType>,
#[serde(with = "common_utils::custom_serde::iso8601")]
pub created_at: PrimitiveDateTime,
#[serde(with = "common_utils::custom_serde::iso8601")]
pub modified_at: PrimitiveDateTime,
#[serde(default, with = "common_utils::custom_serde::iso8601::option")]
pub last_synced: Option<PrimitiveDateTime>,
pub cancellation_reason: Option<String>,
pub amount_to_capture: Option<MinorUnit>,
pub mandate_id: Option<String>,
pub browser_info: Option<serde_json::Value>,
pub payment_token: Option<String>,
pub error_code: Option<String>,
pub connector_metadata: Option<serde_json::Value>,
pub payment_experience: Option<storage_enums::PaymentExperience>,
pub payment_method_type: Option<storage_enums::PaymentMethodType>,
pub payment_method_data: Option<serde_json::Value>,
pub business_sub_label: Option<String>,
pub straight_through_algorithm: Option<serde_json::Value>,
pub preprocessing_step_id: Option<String>,
pub mandate_details: Option<storage_enums::MandateDataType>,
pub error_reason: Option<String>,
pub connector_response_reference_id: Option<String>,
pub multiple_capture_count: Option<i16>,
pub amount_capturable: MinorUnit,
pub updated_by: String,
pub merchant_connector_id: Option<id_type::MerchantConnectorAccountId>,
pub authentication_data: Option<serde_json::Value>,
pub encoded_data: Option<String>,
pub unified_code: Option<String>,
pub unified_message: Option<String>,
pub net_amount: Option<MinorUnit>,
pub external_three_ds_authentication_attempted: Option<bool>,
pub authentication_connector: Option<String>,
pub authentication_id: Option<String>,
pub mandate_data: Option<storage_enums::MandateDetails>,
pub fingerprint_id: Option<String>,
pub payment_method_billing_address_id: Option<String>,
pub client_source: Option<String>,
pub client_version: Option<String>,
pub customer_acceptance: Option<pii::SecretSerdeValue>,
pub profile_id: id_type::ProfileId,
pub organization_id: id_type::OrganizationId,
pub card_network: Option<String>,
pub shipping_cost: Option<MinorUnit>,
pub order_tax_amount: Option<MinorUnit>,
pub connector_mandate_detail: Option<ConnectorMandateReferenceId>,
pub request_extended_authorization: Option<RequestExtendedAuthorizationBool>,
pub extended_authorization_applied: Option<ExtendedAuthorizationAppliedBool>,
#[serde(default, with = "common_utils::custom_serde::iso8601::option")]
pub capture_before: Option<PrimitiveDateTime>,
pub card_discovery: Option<storage_enums::CardDiscovery>,
}
#[cfg(feature = "v1")]
#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum PaymentAttemptUpdate {
Update {
amount: MinorUnit,
currency: storage_enums::Currency,
status: storage_enums::AttemptStatus,
authentication_type: Option<storage_enums::AuthenticationType>,
payment_method: Option<storage_enums::PaymentMethod>,
payment_token: Option<String>,
payment_method_data: Option<serde_json::Value>,
payment_method_type: Option<storage_enums::PaymentMethodType>,
payment_experience: Option<storage_enums::PaymentExperience>,
business_sub_label: Option<String>,
amount_to_capture: Option<MinorUnit>,
capture_method: Option<storage_enums::CaptureMethod>,
surcharge_amount: Option<MinorUnit>,
tax_amount: Option<MinorUnit>,
fingerprint_id: Option<String>,
payment_method_billing_address_id: Option<String>,
updated_by: String,
},
UpdateTrackers {
payment_token: Option<String>,
connector: Option<String>,
straight_through_algorithm: Option<serde_json::Value>,
amount_capturable: Option<MinorUnit>,
surcharge_amount: Option<MinorUnit>,
tax_amount: Option<MinorUnit>,
updated_by: String,
merchant_connector_id: Option<id_type::MerchantConnectorAccountId>,
},
AuthenticationTypeUpdate {
authentication_type: storage_enums::AuthenticationType,
updated_by: String,
},
ConfirmUpdate {
amount: MinorUnit,
currency: storage_enums::Currency,
status: storage_enums::AttemptStatus,
authentication_type: Option<storage_enums::AuthenticationType>,
capture_method: Option<storage_enums::CaptureMethod>,
payment_method: Option<storage_enums::PaymentMethod>,
browser_info: Option<serde_json::Value>,
connector: Option<String>,
payment_token: Option<String>,
payment_method_data: Option<serde_json::Value>,
payment_method_type: Option<storage_enums::PaymentMethodType>,
payment_experience: Option<storage_enums::PaymentExperience>,
business_sub_label: Option<String>,
straight_through_algorithm: Option<serde_json::Value>,
error_code: Option<Option<String>>,
error_message: Option<Option<String>>,
amount_capturable: Option<MinorUnit>,
surcharge_amount: Option<MinorUnit>,
tax_amount: Option<MinorUnit>,
fingerprint_id: Option<String>,
updated_by: String,
merchant_connector_id: Option<id_type::MerchantConnectorAccountId>,
payment_method_id: Option<String>,
external_three_ds_authentication_attempted: Option<bool>,
authentication_connector: Option<String>,
authentication_id: Option<String>,
payment_method_billing_address_id: Option<String>,
client_source: Option<String>,
client_version: Option<String>,
customer_acceptance: Option<pii::SecretSerdeValue>,
shipping_cost: Option<MinorUnit>,
order_tax_amount: Option<MinorUnit>,
connector_mandate_detail: Option<ConnectorMandateReferenceId>,
card_discovery: Option<storage_enums::CardDiscovery>,
},
VoidUpdate {
status: storage_enums::AttemptStatus,
cancellation_reason: Option<String>,
updated_by: String,
},
PaymentMethodDetailsUpdate {
payment_method_id: Option<String>,
updated_by: String,
},
ConnectorMandateDetailUpdate {
connector_mandate_detail: Option<ConnectorMandateReferenceId>,
updated_by: String,
},
BlocklistUpdate {
status: storage_enums::AttemptStatus,
error_code: Option<Option<String>>,
error_message: Option<Option<String>>,
updated_by: String,
},
RejectUpdate {
status: storage_enums::AttemptStatus,
error_code: Option<Option<String>>,
error_message: Option<Option<String>>,
updated_by: String,
},
ResponseUpdate {
status: storage_enums::AttemptStatus,
connector: Option<String>,
connector_transaction_id: Option<String>,
authentication_type: Option<storage_enums::AuthenticationType>,
payment_method_id: Option<String>,
mandate_id: Option<String>,
connector_metadata: Option<serde_json::Value>,
payment_token: Option<String>,
error_code: Option<Option<String>>,
error_message: Option<Option<String>>,
error_reason: Option<Option<String>>,
connector_response_reference_id: Option<String>,
amount_capturable: Option<MinorUnit>,
updated_by: String,
authentication_data: Option<serde_json::Value>,
encoded_data: Option<String>,
unified_code: Option<Option<String>>,
unified_message: Option<Option<String>>,
capture_before: Option<PrimitiveDateTime>,
extended_authorization_applied: Option<ExtendedAuthorizationAppliedBool>,
payment_method_data: Option<serde_json::Value>,
connector_mandate_detail: Option<ConnectorMandateReferenceId>,
charges: Option<common_types::payments::ConnectorChargeResponseData>,
},
UnresolvedResponseUpdate {
status: storage_enums::AttemptStatus,
connector: Option<String>,
connector_transaction_id: Option<String>,
payment_method_id: Option<String>,
error_code: Option<Option<String>>,
error_message: Option<Option<String>>,
error_reason: Option<Option<String>>,
connector_response_reference_id: Option<String>,
updated_by: String,
},
StatusUpdate {
status: storage_enums::AttemptStatus,
updated_by: String,
},
ErrorUpdate {
connector: Option<String>,
status: storage_enums::AttemptStatus,
error_code: Option<Option<String>>,
error_message: Option<Option<String>>,
error_reason: Option<Option<String>>,
amount_capturable: Option<MinorUnit>,
updated_by: String,
unified_code: Option<Option<String>>,
unified_message: Option<Option<String>>,
connector_transaction_id: Option<String>,
payment_method_data: Option<serde_json::Value>,
authentication_type: Option<storage_enums::AuthenticationType>,
issuer_error_code: Option<String>,
issuer_error_message: Option<String>,
},
CaptureUpdate {
amount_to_capture: Option<MinorUnit>,
multiple_capture_count: Option<i16>,
updated_by: String,
},
AmountToCaptureUpdate {
status: storage_enums::AttemptStatus,
amount_capturable: MinorUnit,
updated_by: String,
},
PreprocessingUpdate {
status: storage_enums::AttemptStatus,
payment_method_id: Option<String>,
connector_metadata: Option<serde_json::Value>,
preprocessing_step_id: Option<String>,
connector_transaction_id: Option<String>,
connector_response_reference_id: Option<String>,
updated_by: String,
},
ConnectorResponse {
authentication_data: Option<serde_json::Value>,
encoded_data: Option<String>,
connector_transaction_id: Option<String>,
connector: Option<String>,
charges: Option<common_types::payments::ConnectorChargeResponseData>,
updated_by: String,
},
IncrementalAuthorizationAmountUpdate {
amount: MinorUnit,
amount_capturable: MinorUnit,
},
AuthenticationUpdate {
status: storage_enums::AttemptStatus,
external_three_ds_authentication_attempted: Option<bool>,
authentication_connector: Option<String>,
authentication_id: Option<String>,
updated_by: String,
},
ManualUpdate {
status: Option<storage_enums::AttemptStatus>,
error_code: Option<String>,
error_message: Option<String>,
error_reason: Option<String>,
updated_by: String,
unified_code: Option<String>,
unified_message: Option<String>,
connector_transaction_id: Option<String>,
},
PostSessionTokensUpdate {
updated_by: String,
connector_metadata: Option<serde_json::Value>,
},
}
#[cfg(feature = "v2")]
#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum PaymentAttemptUpdate {
// Update {
// amount: MinorUnit,
// currency: storage_enums::Currency,
// status: storage_enums::AttemptStatus,
// authentication_type: Option<storage_enums::AuthenticationType>,
// payment_method: Option<storage_enums::PaymentMethod>,
// payment_token: Option<String>,
// payment_method_data: Option<serde_json::Value>,
// payment_method_type: Option<storage_enums::PaymentMethodType>,
// payment_experience: Option<storage_enums::PaymentExperience>,
// business_sub_label: Option<String>,
// amount_to_capture: Option<MinorUnit>,
// capture_method: Option<storage_enums::CaptureMethod>,
// surcharge_amount: Option<MinorUnit>,
// tax_amount: Option<MinorUnit>,
// fingerprint_id: Option<String>,
// payment_method_billing_address_id: Option<String>,
// updated_by: String,
// },
// UpdateTrackers {
// payment_token: Option<String>,
// connector: Option<String>,
// straight_through_algorithm: Option<serde_json::Value>,
// amount_capturable: Option<MinorUnit>,
// surcharge_amount: Option<MinorUnit>,
// tax_amount: Option<MinorUnit>,
// updated_by: String,
// merchant_connector_id: Option<id_type::MerchantConnectorAccountId>,
// },
// AuthenticationTypeUpdate {
// authentication_type: storage_enums::AuthenticationType,
// updated_by: String,
// },
// ConfirmUpdate {
// amount: MinorUnit,
// currency: storage_enums::Currency,
// status: storage_enums::AttemptStatus,
// authentication_type: Option<storage_enums::AuthenticationType>,
// capture_method: Option<storage_enums::CaptureMethod>,
// payment_method: Option<storage_enums::PaymentMethod>,
// browser_info: Option<serde_json::Value>,
// connector: Option<String>,
// payment_token: Option<String>,
// payment_method_data: Option<serde_json::Value>,
// payment_method_type: Option<storage_enums::PaymentMethodType>,
// payment_experience: Option<storage_enums::PaymentExperience>,
// business_sub_label: Option<String>,
// straight_through_algorithm: Option<serde_json::Value>,
// error_code: Option<Option<String>>,
// error_message: Option<Option<String>>,
// amount_capturable: Option<MinorUnit>,
// surcharge_amount: Option<MinorUnit>,
// tax_amount: Option<MinorUnit>,
// fingerprint_id: Option<String>,
// updated_by: String,
// merchant_connector_id: Option<id_type::MerchantConnectorAccountId>,
// payment_method_id: Option<String>,
// external_three_ds_authentication_attempted: Option<bool>,
// authentication_connector: Option<String>,
// authentication_id: Option<String>,
// payment_method_billing_address_id: Option<String>,
// client_source: Option<String>,
// client_version: Option<String>,
// customer_acceptance: Option<pii::SecretSerdeValue>,
// },
// VoidUpdate {
// status: storage_enums::AttemptStatus,
// cancellation_reason: Option<String>,
// updated_by: String,
// },
// PaymentMethodDetailsUpdate {
// payment_method_id: Option<String>,
// updated_by: String,
// },
// ConnectorMandateDetailUpdate {
// connector_mandate_detail: Option<ConnectorMandateReferenceId>,
// updated_by: String,
// }
// BlocklistUpdate {
// status: storage_enums::AttemptStatus,
// error_code: Option<Option<String>>,
// error_message: Option<Option<String>>,
// updated_by: String,
// },
// RejectUpdate {
// status: storage_enums::AttemptStatus,
// error_code: Option<Option<String>>,
// error_message: Option<Option<String>>,
// updated_by: String,
// },
// ResponseUpdate {
// status: storage_enums::AttemptStatus,
// connector: Option<String>,
// connector_transaction_id: Option<String>,
// authentication_type: Option<storage_enums::AuthenticationType>,
// payment_method_id: Option<String>,
// mandate_id: Option<String>,
// connector_metadata: Option<serde_json::Value>,
// payment_token: Option<String>,
// error_code: Option<Option<String>>,
// error_message: Option<Option<String>>,
// error_reason: Option<Option<String>>,
// connector_response_reference_id: Option<String>,
// amount_capturable: Option<MinorUnit>,
// updated_by: String,
// authentication_data: Option<serde_json::Value>,
// encoded_data: Option<String>,
// unified_code: Option<Option<String>>,
// unified_message: Option<Option<String>>,
// payment_method_data: Option<serde_json::Value>,
// charge_id: Option<String>,
// },
// UnresolvedResponseUpdate {
// status: storage_enums::AttemptStatus,
// connector: Option<String>,
// connector_transaction_id: Option<String>,
// payment_method_id: Option<String>,
// error_code: Option<Option<String>>,
// error_message: Option<Option<String>>,
// error_reason: Option<Option<String>>,
// connector_response_reference_id: Option<String>,
// updated_by: String,
// },
// StatusUpdate {
// status: storage_enums::AttemptStatus,
// updated_by: String,
// },
// ErrorUpdate {
// connector: Option<String>,
// status: storage_enums::AttemptStatus,
// error_code: Option<Option<String>>,
// error_message: Option<Option<String>>,
// error_reason: Option<Option<String>>,
// amount_capturable: Option<MinorUnit>,
// updated_by: String,
// unified_code: Option<Option<String>>,
// unified_message: Option<Option<String>>,
// connector_transaction_id: Option<String>,
// payment_method_data: Option<serde_json::Value>,
// authentication_type: Option<storage_enums::AuthenticationType>,
// },
// CaptureUpdate {
// amount_to_capture: Option<MinorUnit>,
// multiple_capture_count: Option<MinorUnit>,
// updated_by: String,
// },
// AmountToCaptureUpdate {
// status: storage_enums::AttemptStatus,
// amount_capturable: MinorUnit,
// updated_by: String,
// },
// PreprocessingUpdate {
// status: storage_enums::AttemptStatus,
// payment_method_id: Option<String>,
// connector_metadata: Option<serde_json::Value>,
// preprocessing_step_id: Option<String>,
// connector_transaction_id: Option<String>,
// connector_response_reference_id: Option<String>,
// updated_by: String,
// },
// ConnectorResponse {
// authentication_data: Option<serde_json::Value>,
// encoded_data: Option<String>,
// connector_transaction_id: Option<String>,
// connector: Option<String>,
// charge_id: Option<String>,
// updated_by: String,
// },
// IncrementalAuthorizationAmountUpdate {
// amount: MinorUnit,
// amount_capturable: MinorUnit,
// },
// AuthenticationUpdate {
// status: storage_enums::AttemptStatus,
// external_three_ds_authentication_attempted: Option<bool>,
// authentication_connector: Option<String>,
// authentication_id: Option<String>,
// updated_by: String,
// },
// ManualUpdate {
// status: Option<storage_enums::AttemptStatus>,
// error_code: Option<String>,
// error_message: Option<String>,
// error_reason: Option<String>,
// updated_by: String,
// unified_code: Option<String>,
// unified_message: Option<String>,
// connector_transaction_id: Option<String>,
// },
}
// TODO: uncomment fields as and when required
#[cfg(feature = "v2")]
#[derive(Clone, Debug, AsChangeset, router_derive::DebugAsDisplay)]
#[diesel(table_name = payment_attempt)]
pub struct PaymentAttemptUpdateInternal {
pub status: Option<storage_enums::AttemptStatus>,
pub authentication_type: Option<storage_enums::AuthenticationType>,
pub error_message: Option<String>,
pub connector_payment_id: Option<String>,
// payment_method_id: Option<String>,
// cancellation_reason: Option<String>,
pub modified_at: PrimitiveDateTime,
pub browser_info: Option<serde_json::Value>,
// payment_token: Option<String>,
pub error_code: Option<String>,
pub connector_metadata: Option<pii::SecretSerdeValue>,
// payment_method_data: Option<serde_json::Value>,
// payment_experience: Option<storage_enums::PaymentExperience>,
// preprocessing_step_id: Option<String>,
pub error_reason: Option<String>,
// connector_response_reference_id: Option<String>,
// multiple_capture_count: Option<i16>,
// pub surcharge_amount: Option<MinorUnit>,
// tax_on_surcharge: Option<MinorUnit>,
pub amount_capturable: Option<MinorUnit>,
pub amount_to_capture: Option<MinorUnit>,
pub updated_by: String,
pub merchant_connector_id: Option<id_type::MerchantConnectorAccountId>,
pub connector: Option<String>,
pub redirection_data: Option<RedirectForm>,
// encoded_data: Option<String>,
pub unified_code: Option<Option<String>>,
pub unified_message: Option<Option<String>>,
// external_three_ds_authentication_attempted: Option<bool>,
// authentication_connector: Option<String>,
// authentication_id: Option<String>,
// fingerprint_id: Option<String>,
// charge_id: Option<String>,
// client_source: Option<String>,
// client_version: Option<String>,
// customer_acceptance: Option<pii::SecretSerdeValue>,
// card_network: Option<String>,
pub connector_token_details: Option<ConnectorTokenDetails>,
pub feature_metadata: Option<PaymentAttemptFeatureMetadata>,
pub network_decline_code: Option<String>,
pub network_advice_code: Option<String>,
pub network_error_message: Option<String>,
}
#[cfg(feature = "v1")]
#[derive(Clone, Debug, AsChangeset, router_derive::DebugAsDisplay)]
#[diesel(table_name = payment_attempt)]
pub struct PaymentAttemptUpdateInternal {
pub amount: Option<MinorUnit>,
pub net_amount: Option<MinorUnit>,
pub currency: Option<storage_enums::Currency>,
pub status: Option<storage_enums::AttemptStatus>,
pub connector_transaction_id: Option<ConnectorTransactionId>,
pub amount_to_capture: Option<MinorUnit>,
pub connector: Option<Option<String>>,
pub authentication_type: Option<storage_enums::AuthenticationType>,
pub payment_method: Option<storage_enums::PaymentMethod>,
pub error_message: Option<Option<String>>,
pub payment_method_id: Option<String>,
pub cancellation_reason: Option<String>,
pub modified_at: PrimitiveDateTime,
pub mandate_id: Option<String>,
pub browser_info: Option<serde_json::Value>,
pub payment_token: Option<String>,
pub error_code: Option<Option<String>>,
pub connector_metadata: Option<serde_json::Value>,
pub payment_method_data: Option<serde_json::Value>,
pub payment_method_type: Option<storage_enums::PaymentMethodType>,
pub payment_experience: Option<storage_enums::PaymentExperience>,
pub business_sub_label: Option<String>,
pub straight_through_algorithm: Option<serde_json::Value>,
pub preprocessing_step_id: Option<String>,
pub error_reason: Option<Option<String>>,
pub capture_method: Option<storage_enums::CaptureMethod>,
pub connector_response_reference_id: Option<String>,
pub multiple_capture_count: Option<i16>,
pub surcharge_amount: Option<MinorUnit>,
pub tax_amount: Option<MinorUnit>,
pub amount_capturable: Option<MinorUnit>,
pub updated_by: String,
pub merchant_connector_id: Option<Option<id_type::MerchantConnectorAccountId>>,
pub authentication_data: Option<serde_json::Value>,
pub encoded_data: Option<String>,
pub unified_code: Option<Option<String>>,
pub unified_message: Option<Option<String>>,
pub external_three_ds_authentication_attempted: Option<bool>,
pub authentication_connector: Option<String>,
pub authentication_id: Option<String>,
pub fingerprint_id: Option<String>,
pub payment_method_billing_address_id: Option<String>,
pub client_source: Option<String>,
pub client_version: Option<String>,
pub customer_acceptance: Option<pii::SecretSerdeValue>,
pub card_network: Option<String>,
pub capture_before: Option<PrimitiveDateTime>,
pub extended_authorization_applied: Option<ExtendedAuthorizationAppliedBool>,
pub shipping_cost: Option<MinorUnit>,
pub order_tax_amount: Option<MinorUnit>,
pub connector_mandate_detail: Option<ConnectorMandateReferenceId>,
pub processor_transaction_data: Option<String>,
pub card_discovery: Option<common_enums::CardDiscovery>,
pub charges: Option<common_types::payments::ConnectorChargeResponseData>,
pub issuer_error_code: Option<String>,
pub issuer_error_message: Option<String>,
}
#[cfg(feature = "v1")]
impl PaymentAttemptUpdateInternal {
pub fn populate_derived_fields(self, source: &PaymentAttempt) -> Self {
let mut update_internal = self;
update_internal.net_amount = Some(
update_internal.amount.unwrap_or(source.amount)
+ update_internal
.surcharge_amount
.or(source.surcharge_amount)
.unwrap_or(MinorUnit::new(0))
+ update_internal
.tax_amount
.or(source.tax_amount)
.unwrap_or(MinorUnit::new(0))
+ update_internal
.shipping_cost
.or(source.shipping_cost)
.unwrap_or(MinorUnit::new(0))
+ update_internal
.order_tax_amount
.or(source.order_tax_amount)
.unwrap_or(MinorUnit::new(0)),
);
update_internal.card_network = update_internal
.payment_method_data
.as_ref()
.and_then(|data| data.as_object())
.and_then(|card| card.get("card"))
.and_then(|data| data.as_object())
.and_then(|card| card.get("card_network"))
.and_then(|network| network.as_str())
.map(|network| network.to_string());
update_internal
}
}
#[cfg(feature = "v2")]
impl PaymentAttemptUpdate {
pub fn apply_changeset(self, source: PaymentAttempt) -> PaymentAttempt {
todo!()
// let PaymentAttemptUpdateInternal {
// net_amount,
// status,
// authentication_type,
// error_message,
// payment_method_id,
// cancellation_reason,
// modified_at: _,
// browser_info,
// payment_token,
// error_code,
// connector_metadata,
// payment_method_data,
// payment_experience,
// straight_through_algorithm,
// preprocessing_step_id,
// error_reason,
// connector_response_reference_id,
// multiple_capture_count,
// surcharge_amount,
// tax_amount,
// amount_capturable,
// updated_by,
// merchant_connector_id,
// authentication_data,
// encoded_data,
// unified_code,
// unified_message,
// external_three_ds_authentication_attempted,
// authentication_connector,
// authentication_id,
// payment_method_billing_address_id,
// fingerprint_id,
// charge_id,
// client_source,
// client_version,
// customer_acceptance,
// card_network,
// } = PaymentAttemptUpdateInternal::from(self).populate_derived_fields(&source);
// PaymentAttempt {
// net_amount: net_amount.or(source.net_amount),
// status: status.unwrap_or(source.status),
// authentication_type: authentication_type.or(source.authentication_type),
// error_message: error_message.unwrap_or(source.error_message),
// payment_method_id: payment_method_id.or(source.payment_method_id),
// cancellation_reason: cancellation_reason.or(source.cancellation_reason),
// modified_at: common_utils::date_time::now(),
// browser_info: browser_info.or(source.browser_info),
// payment_token: payment_token.or(source.payment_token),
// error_code: error_code.unwrap_or(source.error_code),
// connector_metadata: connector_metadata.or(source.connector_metadata),
// payment_method_data: payment_method_data.or(source.payment_method_data),
// payment_experience: payment_experience.or(source.payment_experience),
// straight_through_algorithm: straight_through_algorithm
// .or(source.straight_through_algorithm),
// preprocessing_step_id: preprocessing_step_id.or(source.preprocessing_step_id),
// error_reason: error_reason.unwrap_or(source.error_reason),
// connector_response_reference_id: connector_response_reference_id
// .or(source.connector_response_reference_id),
// multiple_capture_count: multiple_capture_count.or(source.multiple_capture_count),
// surcharge_amount: surcharge_amount.or(source.surcharge_amount),
// tax_amount: tax_amount.or(source.tax_amount),
// amount_capturable: amount_capturable.unwrap_or(source.amount_capturable),
// updated_by,
// merchant_connector_id: merchant_connector_id.unwrap_or(source.merchant_connector_id),
// authentication_data: authentication_data.or(source.authentication_data),
// encoded_data: encoded_data.or(source.encoded_data),
// unified_code: unified_code.unwrap_or(source.unified_code),
// unified_message: unified_message.unwrap_or(source.unified_message),
// external_three_ds_authentication_attempted: external_three_ds_authentication_attempted
// .or(source.external_three_ds_authentication_attempted),
// authentication_connector: authentication_connector.or(source.authentication_connector),
// authentication_id: authentication_id.or(source.authentication_id),
// payment_method_billing_address_id: payment_method_billing_address_id
// .or(source.payment_method_billing_address_id),
// fingerprint_id: fingerprint_id.or(source.fingerprint_id),
// charge_id: charge_id.or(source.charge_id),
// client_source: client_source.or(source.client_source),
// client_version: client_version.or(source.client_version),
// customer_acceptance: customer_acceptance.or(source.customer_acceptance),
// card_network: card_network.or(source.card_network),
// ..source
// }
}
}
#[cfg(feature = "v1")]
impl PaymentAttemptUpdate {
pub fn apply_changeset(self, source: PaymentAttempt) -> PaymentAttempt {
let PaymentAttemptUpdateInternal {
amount,
net_amount,
currency,
status,
connector_transaction_id,
amount_to_capture,
connector,
authentication_type,
payment_method,
error_message,
payment_method_id,
cancellation_reason,
modified_at: _,
mandate_id,
browser_info,
payment_token,
error_code,
connector_metadata,
payment_method_data,
payment_method_type,
payment_experience,
business_sub_label,
straight_through_algorithm,
preprocessing_step_id,
error_reason,
capture_method,
connector_response_reference_id,
multiple_capture_count,
surcharge_amount,
tax_amount,
amount_capturable,
updated_by,
merchant_connector_id,
authentication_data,
encoded_data,
unified_code,
unified_message,
external_three_ds_authentication_attempted,
authentication_connector,
authentication_id,
payment_method_billing_address_id,
fingerprint_id,
client_source,
client_version,
customer_acceptance,
card_network,
shipping_cost,
order_tax_amount,
processor_transaction_data,
connector_mandate_detail,
capture_before,
extended_authorization_applied,
card_discovery,
charges,
issuer_error_code,
issuer_error_message,
} = PaymentAttemptUpdateInternal::from(self).populate_derived_fields(&source);
PaymentAttempt {
amount: amount.unwrap_or(source.amount),
net_amount: net_amount.or(source.net_amount),
currency: currency.or(source.currency),
status: status.unwrap_or(source.status),
connector_transaction_id: connector_transaction_id.or(source.connector_transaction_id),
amount_to_capture: amount_to_capture.or(source.amount_to_capture),
connector: connector.unwrap_or(source.connector),
authentication_type: authentication_type.or(source.authentication_type),
payment_method: payment_method.or(source.payment_method),
error_message: error_message.unwrap_or(source.error_message),
payment_method_id: payment_method_id.or(source.payment_method_id),
cancellation_reason: cancellation_reason.or(source.cancellation_reason),
modified_at: common_utils::date_time::now(),
mandate_id: mandate_id.or(source.mandate_id),
browser_info: browser_info.or(source.browser_info),
payment_token: payment_token.or(source.payment_token),
error_code: error_code.unwrap_or(source.error_code),
connector_metadata: connector_metadata.or(source.connector_metadata),
payment_method_data: payment_method_data.or(source.payment_method_data),
payment_method_type: payment_method_type.or(source.payment_method_type),
payment_experience: payment_experience.or(source.payment_experience),
business_sub_label: business_sub_label.or(source.business_sub_label),
straight_through_algorithm: straight_through_algorithm
.or(source.straight_through_algorithm),
preprocessing_step_id: preprocessing_step_id.or(source.preprocessing_step_id),
error_reason: error_reason.unwrap_or(source.error_reason),
capture_method: capture_method.or(source.capture_method),
connector_response_reference_id: connector_response_reference_id
.or(source.connector_response_reference_id),
multiple_capture_count: multiple_capture_count.or(source.multiple_capture_count),
surcharge_amount: surcharge_amount.or(source.surcharge_amount),
tax_amount: tax_amount.or(source.tax_amount),
amount_capturable: amount_capturable.unwrap_or(source.amount_capturable),
updated_by,
merchant_connector_id: merchant_connector_id.unwrap_or(source.merchant_connector_id),
authentication_data: authentication_data.or(source.authentication_data),
encoded_data: encoded_data.or(source.encoded_data),
unified_code: unified_code.unwrap_or(source.unified_code),
unified_message: unified_message.unwrap_or(source.unified_message),
external_three_ds_authentication_attempted: external_three_ds_authentication_attempted
.or(source.external_three_ds_authentication_attempted),
authentication_connector: authentication_connector.or(source.authentication_connector),
authentication_id: authentication_id.or(source.authentication_id),
payment_method_billing_address_id: payment_method_billing_address_id
.or(source.payment_method_billing_address_id),
fingerprint_id: fingerprint_id.or(source.fingerprint_id),
client_source: client_source.or(source.client_source),
client_version: client_version.or(source.client_version),
customer_acceptance: customer_acceptance.or(source.customer_acceptance),
card_network: card_network.or(source.card_network),
shipping_cost: shipping_cost.or(source.shipping_cost),
order_tax_amount: order_tax_amount.or(source.order_tax_amount),
processor_transaction_data: processor_transaction_data
.or(source.processor_transaction_data),
connector_mandate_detail: connector_mandate_detail.or(source.connector_mandate_detail),
capture_before: capture_before.or(source.capture_before),
extended_authorization_applied: extended_authorization_applied
.or(source.extended_authorization_applied),
card_discovery: card_discovery.or(source.card_discovery),
charges: charges.or(source.charges),
issuer_error_code: issuer_error_code.or(source.issuer_error_code),
issuer_error_message: issuer_error_message.or(source.issuer_error_message),
..source
}
}
}
#[cfg(feature = "v2")]
impl From<PaymentAttemptUpdate> for PaymentAttemptUpdateInternal {
fn from(payment_attempt_update: PaymentAttemptUpdate) -> Self {
todo!()
// match payment_attempt_update {
// PaymentAttemptUpdate::Update {
// amount,
// currency,
// status,
// // connector_transaction_id,
// authentication_type,
// payment_method,
// payment_token,
// payment_method_data,
// payment_method_type,
// payment_experience,
// business_sub_label,
// amount_to_capture,
// capture_method,
// surcharge_amount,
// tax_amount,
// fingerprint_id,
// updated_by,
// payment_method_billing_address_id,
// } => Self {
// status: Some(status),
// // connector_transaction_id,
// authentication_type,
// payment_token,
// modified_at: common_utils::date_time::now(),
// payment_method_data,
// payment_experience,
// surcharge_amount,
// tax_amount,
// fingerprint_id,
// payment_method_billing_address_id,
// updated_by,
// net_amount: None,
// error_message: None,
// payment_method_id: None,
// cancellation_reason: None,
// browser_info: None,
// error_code: None,
// connector_metadata: None,
// straight_through_algorithm: None,
// preprocessing_step_id: None,
// error_reason: None,
// connector_response_reference_id: None,
// multiple_capture_count: None,
// amount_capturable: None,
// merchant_connector_id: None,
// authentication_data: None,
// encoded_data: None,
// unified_code: None,
// unified_message: None,
// external_three_ds_authentication_attempted: None,
// authentication_connector: None,
// authentication_id: None,
// charge_id: None,
// client_source: None,
// client_version: None,
// customer_acceptance: None,
// card_network: None,
// },
// PaymentAttemptUpdate::AuthenticationTypeUpdate {
// authentication_type,
// updated_by,
// } => Self {
// authentication_type: Some(authentication_type),
// modified_at: common_utils::date_time::now(),
// updated_by,
// net_amount: None,
// status: None,
// error_message: None,
// payment_method_id: None,
// cancellation_reason: None,
// browser_info: None,
// payment_token: None,
// error_code: None,
// connector_metadata: None,
// payment_method_data: None,
// payment_experience: None,
// straight_through_algorithm: None,
// preprocessing_step_id: None,
// error_reason: None,
// connector_response_reference_id: None,
// multiple_capture_count: None,
// surcharge_amount: None,
// tax_amount: None,
// amount_capturable: None,
// merchant_connector_id: None,
// authentication_data: None,
// encoded_data: None,
// unified_code: None,
// unified_message: None,
// external_three_ds_authentication_attempted: None,
// authentication_connector: None,
// authentication_id: None,
// fingerprint_id: None,
// payment_method_billing_address_id: None,
// charge_id: None,
// client_source: None,
// client_version: None,
// customer_acceptance: None,
// card_network: None,
// },
// PaymentAttemptUpdate::ConfirmUpdate {
// amount,
// currency,
// authentication_type,
// capture_method,
// status,
// payment_method,
// browser_info,
// connector,
// payment_token,
// payment_method_data,
// payment_method_type,
// payment_experience,
// business_sub_label,
// straight_through_algorithm,
// error_code,
// error_message,
// amount_capturable,
// updated_by,
// merchant_connector_id,
// surcharge_amount,
// tax_amount,
// external_three_ds_authentication_attempted,
// authentication_connector,
// authentication_id,
// payment_method_billing_address_id,
// fingerprint_id,
// payment_method_id,
// client_source,
// client_version,
// customer_acceptance,
// } => Self {
// authentication_type,
// status: Some(status),
// modified_at: common_utils::date_time::now(),
// browser_info,
// payment_token,
// payment_method_data,
// payment_experience,
// straight_through_algorithm,
// error_code,
// error_message,
// amount_capturable,
// updated_by,
// merchant_connector_id: merchant_connector_id.map(Some),
// surcharge_amount,
// tax_amount,
// external_three_ds_authentication_attempted,
// authentication_connector,
// authentication_id,
// payment_method_billing_address_id,
// fingerprint_id,
// payment_method_id,
// client_source,
// client_version,
// customer_acceptance,
// net_amount: None,
// cancellation_reason: None,
// connector_metadata: None,
// preprocessing_step_id: None,
// error_reason: None,
// connector_response_reference_id: None,
// multiple_capture_count: None,
// authentication_data: None,
// encoded_data: None,
// unified_code: None,
// unified_message: None,
// charge_id: None,
// card_network: None,
// },
// PaymentAttemptUpdate::VoidUpdate {
// status,
// cancellation_reason,
// updated_by,
// } => Self {
// status: Some(status),
// cancellation_reason,
// modified_at: common_utils::date_time::now(),
// updated_by,
// net_amount: None,
// authentication_type: None,
// error_message: None,
// payment_method_id: None,
// browser_info: None,
// payment_token: None,
// error_code: None,
// connector_metadata: None,
// payment_method_data: None,
// payment_experience: None,
// straight_through_algorithm: None,
// preprocessing_step_id: None,
// error_reason: None,
// connector_response_reference_id: None,
// multiple_capture_count: None,
// surcharge_amount: None,
// tax_amount: None,
// amount_capturable: None,
// merchant_connector_id: None,
// authentication_data: None,
// encoded_data: None,
// unified_code: None,
// unified_message: None,
// external_three_ds_authentication_attempted: None,
// authentication_connector: None,
// authentication_id: None,
// fingerprint_id: None,
// payment_method_billing_address_id: None,
// charge_id: None,
// client_source: None,
// client_version: None,
// customer_acceptance: None,
// card_network: None,
// },
// PaymentAttemptUpdate::RejectUpdate {
// status,
// error_code,
// error_message,
// updated_by,
// } => Self {
// status: Some(status),
// modified_at: common_utils::date_time::now(),
// error_code,
// error_message,
// updated_by,
// net_amount: None,
// authentication_type: None,
// payment_method_id: None,
// cancellation_reason: None,
// browser_info: None,
// payment_token: None,
// connector_metadata: None,
// payment_method_data: None,
// payment_experience: None,
// straight_through_algorithm: None,
// preprocessing_step_id: None,
// error_reason: None,
// connector_response_reference_id: None,
// multiple_capture_count: None,
// surcharge_amount: None,
// tax_amount: None,
// amount_capturable: None,
// merchant_connector_id: None,
// authentication_data: None,
// encoded_data: None,
// unified_code: None,
// unified_message: None,
// external_three_ds_authentication_attempted: None,
// authentication_connector: None,
// authentication_id: None,
// fingerprint_id: None,
// payment_method_billing_address_id: None,
// charge_id: None,
// client_source: None,
// client_version: None,
// customer_acceptance: None,
// card_network: None,
// },
// PaymentAttemptUpdate::BlocklistUpdate {
// status,
// error_code,
// error_message,
// updated_by,
// } => Self {
// status: Some(status),
// modified_at: common_utils::date_time::now(),
// error_code,
// error_message,
// updated_by,
// merchant_connector_id: Some(None),
// net_amount: None,
// authentication_type: None,
// payment_method_id: None,
// cancellation_reason: None,
// browser_info: None,
// payment_token: None,
// connector_metadata: None,
// payment_method_data: None,
// payment_experience: None,
// straight_through_algorithm: None,
// preprocessing_step_id: None,
// error_reason: None,
// connector_response_reference_id: None,
// multiple_capture_count: None,
// surcharge_amount: None,
// tax_amount: None,
// amount_capturable: None,
// authentication_data: None,
// encoded_data: None,
// unified_code: None,
// unified_message: None,
// external_three_ds_authentication_attempted: None,
// authentication_connector: None,
// authentication_id: None,
// fingerprint_id: None,
// payment_method_billing_address_id: None,
// charge_id: None,
// client_source: None,
// client_version: None,
// customer_acceptance: None,
// card_network: None,
// },
// PaymentAttemptUpdate::ConnectorMandateDetailUpdate {
// connector_mandate_detail,
// updated_by,
// } => Self {
// payment_method_id: None,
// modified_at: common_utils::date_time::now(),
// updated_by,
// amount: None,
// net_amount: None,
// currency: None,
// status: None,
// connector_transaction_id: None,
// amount_to_capture: None,
// connector: None,
// authentication_type: None,
// payment_method: None,
// error_message: None,
// cancellation_reason: None,
// mandate_id: None,
// browser_info: None,
// payment_token: None,
// error_code: None,
// connector_metadata: None,
// payment_method_data: None,
// payment_method_type: None,
// payment_experience: None,
// business_sub_label: None,
// straight_through_algorithm: None,
// preprocessing_step_id: None,
// error_reason: None,
// capture_method: None,
// connector_response_reference_id: None,
// multiple_capture_count: None,
// surcharge_amount: None,
// tax_amount: None,
// amount_capturable: None,
// merchant_connector_id: None,
// authentication_data: None,
// encoded_data: None,
// unified_code: None,
// unified_message: None,
// external_three_ds_authentication_attempted: None,
// authentication_connector: None,
// authentication_id: None,
// fingerprint_id: None,
// payment_method_billing_address_id: None,
// charge_id: None,
// client_source: None,
// client_version: None,
// customer_acceptance: None,
// card_network: None,
// shipping_cost: None,
// order_tax_amount: None,
// processor_transaction_data: None,
// connector_mandate_detail,
// },
// PaymentAttemptUpdate::ConnectorMandateDetailUpdate {
// payment_method_id,
// updated_by,
// } => Self {
// payment_method_id,
// modified_at: common_utils::date_time::now(),
// updated_by,
// net_amount: None,
// status: None,
// authentication_type: None,
// error_message: None,
// cancellation_reason: None,
// browser_info: None,
// payment_token: None,
// error_code: None,
// connector_metadata: None,
// payment_method_data: None,
// payment_experience: None,
// straight_through_algorithm: None,
// preprocessing_step_id: None,
// error_reason: None,
// connector_response_reference_id: None,
// multiple_capture_count: None,
// surcharge_amount: None,
// tax_amount: None,
// amount_capturable: None,
// merchant_connector_id: None,
// authentication_data: None,
// encoded_data: None,
// unified_code: None,
// unified_message: None,
// external_three_ds_authentication_attempted: None,
// authentication_connector: None,
// authentication_id: None,
// fingerprint_id: None,
// payment_method_billing_address_id: None,
// charge_id: None,
// client_source: None,
// client_version: None,
// customer_acceptance: None,
// card_network: None,
// },
// PaymentAttemptUpdate::ResponseUpdate {
// status,
// connector,
// connector_transaction_id,
// authentication_type,
// payment_method_id,
// mandate_id,
// connector_metadata,
// payment_token,
// error_code,
// error_message,
// error_reason,
// connector_response_reference_id,
// amount_capturable,
// updated_by,
// authentication_data,
// encoded_data,
// unified_code,
// unified_message,
// payment_method_data,
// charge_id,
// } => Self {
// status: Some(status),
// authentication_type,
// payment_method_id,
// modified_at: common_utils::date_time::now(),
// connector_metadata,
// error_code,
// error_message,
// payment_token,
// error_reason,
// connector_response_reference_id,
// amount_capturable,
// updated_by,
// authentication_data,
// encoded_data,
// unified_code,
// unified_message,
// payment_method_data,
// charge_id,
// net_amount: None,
// cancellation_reason: None,
// browser_info: None,
// payment_experience: None,
// straight_through_algorithm: None,
// preprocessing_step_id: None,
// multiple_capture_count: None,
// surcharge_amount: None,
// tax_amount: None,
// merchant_connector_id: None,
// external_three_ds_authentication_attempted: None,
// authentication_connector: None,
// authentication_id: None,
// fingerprint_id: None,
// payment_method_billing_address_id: None,
// client_source: None,
// client_version: None,
// customer_acceptance: None,
// card_network: None,
// },
// PaymentAttemptUpdate::ErrorUpdate {
// connector,
// status,
// error_code,
// error_message,
// error_reason,
// amount_capturable,
// updated_by,
// unified_code,
// unified_message,
// connector_transaction_id,
// payment_method_data,
// authentication_type,
// } => Self {
// status: Some(status),
// error_message,
// error_code,
// modified_at: common_utils::date_time::now(),
// error_reason,
// amount_capturable,
// updated_by,
// unified_code,
// unified_message,
// payment_method_data,
// authentication_type,
// net_amount: None,
// payment_method_id: None,
// cancellation_reason: None,
// browser_info: None,
// payment_token: None,
// connector_metadata: None,
// payment_experience: None,
// straight_through_algorithm: None,
// preprocessing_step_id: None,
// connector_response_reference_id: None,
// multiple_capture_count: None,
// surcharge_amount: None,
// tax_amount: None,
// merchant_connector_id: None,
// authentication_data: None,
// encoded_data: None,
// external_three_ds_authentication_attempted: None,
// authentication_connector: None,
// authentication_id: None,
// fingerprint_id: None,
// payment_method_billing_address_id: None,
// charge_id: None,
// client_source: None,
// client_version: None,
// customer_acceptance: None,
// card_network: None,
// },
// PaymentAttemptUpdate::StatusUpdate { status, updated_by } => Self {
// status: Some(status),
// modified_at: common_utils::date_time::now(),
// updated_by,
// net_amount: None,
// authentication_type: None,
// error_message: None,
// payment_method_id: None,
// cancellation_reason: None,
// browser_info: None,
// payment_token: None,
// error_code: None,
// connector_metadata: None,
// payment_method_data: None,
// payment_experience: None,
// straight_through_algorithm: None,
// preprocessing_step_id: None,
// error_reason: None,
// connector_response_reference_id: None,
// multiple_capture_count: None,
// surcharge_amount: None,
// tax_amount: None,
// amount_capturable: None,
// merchant_connector_id: None,
// authentication_data: None,
// encoded_data: None,
// unified_code: None,
// unified_message: None,
// external_three_ds_authentication_attempted: None,
// authentication_connector: None,
// authentication_id: None,
// fingerprint_id: None,
// payment_method_billing_address_id: None,
// charge_id: None,
// client_source: None,
// client_version: None,
// customer_acceptance: None,
// card_network: None,
// },
// PaymentAttemptUpdate::UpdateTrackers {
// payment_token,
// connector,
// straight_through_algorithm,
// amount_capturable,
// surcharge_amount,
// tax_amount,
// updated_by,
// merchant_connector_id,
// } => Self {
// payment_token,
// modified_at: common_utils::date_time::now(),
// straight_through_algorithm,
// amount_capturable,
// surcharge_amount,
// tax_amount,
// updated_by,
// merchant_connector_id: merchant_connector_id.map(Some),
// net_amount: None,
// status: None,
// authentication_type: None,
// error_message: None,
// payment_method_id: None,
// cancellation_reason: None,
// browser_info: None,
// error_code: None,
// connector_metadata: None,
// payment_method_data: None,
// payment_experience: None,
// preprocessing_step_id: None,
// error_reason: None,
// connector_response_reference_id: None,
// multiple_capture_count: None,
// authentication_data: None,
// encoded_data: None,
// unified_code: None,
// unified_message: None,
// external_three_ds_authentication_attempted: None,
// authentication_connector: None,
// authentication_id: None,
// fingerprint_id: None,
// payment_method_billing_address_id: None,
// charge_id: None,
// client_source: None,
// client_version: None,
// customer_acceptance: None,
// card_network: None,
// },
// PaymentAttemptUpdate::UnresolvedResponseUpdate {
// status,
// connector,
// connector_transaction_id,
// payment_method_id,
// error_code,
// error_message,
// error_reason,
// connector_response_reference_id,
// updated_by,
// } => Self {
// status: Some(status),
// payment_method_id,
// modified_at: common_utils::date_time::now(),
// error_code,
// error_message,
// error_reason,
// connector_response_reference_id,
// updated_by,
// net_amount: None,
// authentication_type: None,
// cancellation_reason: None,
// browser_info: None,
// payment_token: None,
// connector_metadata: None,
// payment_method_data: None,
// payment_experience: None,
// straight_through_algorithm: None,
// preprocessing_step_id: None,
// multiple_capture_count: None,
// surcharge_amount: None,
// tax_amount: None,
// amount_capturable: None,
// merchant_connector_id: None,
// authentication_data: None,
// encoded_data: None,
// unified_code: None,
// unified_message: None,
// external_three_ds_authentication_attempted: None,
// authentication_connector: None,
// authentication_id: None,
// fingerprint_id: None,
// payment_method_billing_address_id: None,
// charge_id: None,
// client_source: None,
// client_version: None,
// customer_acceptance: None,
// card_network: None,
// },
// PaymentAttemptUpdate::PreprocessingUpdate {
// status,
// payment_method_id,
// connector_metadata,
// preprocessing_step_id,
// connector_transaction_id,
// connector_response_reference_id,
// updated_by,
// } => Self {
// status: Some(status),
// payment_method_id,
// modified_at: common_utils::date_time::now(),
// connector_metadata,
// preprocessing_step_id,
// connector_response_reference_id,
// updated_by,
// net_amount: None,
// authentication_type: None,
// error_message: None,
// cancellation_reason: None,
// browser_info: None,
// payment_token: None,
// error_code: None,
// payment_method_data: None,
// payment_experience: None,
// straight_through_algorithm: None,
// error_reason: None,
// multiple_capture_count: None,
// surcharge_amount: None,
// tax_amount: None,
// amount_capturable: None,
// merchant_connector_id: None,
// authentication_data: None,
// encoded_data: None,
// unified_code: None,
// unified_message: None,
// external_three_ds_authentication_attempted: None,
// authentication_connector: None,
// authentication_id: None,
// fingerprint_id: None,
// payment_method_billing_address_id: None,
// charge_id: None,
// client_source: None,
// client_version: None,
// customer_acceptance: None,
// card_network: None,
// },
// PaymentAttemptUpdate::CaptureUpdate {
// multiple_capture_count,
// updated_by,
// amount_to_capture,
// } => Self {
// multiple_capture_count,
// modified_at: common_utils::date_time::now(),
// updated_by,
// net_amount: None,
// status: None,
// authentication_type: None,
// error_message: None,
// payment_method_id: None,
// cancellation_reason: None,
// browser_info: None,
// payment_token: None,
// error_code: None,
// connector_metadata: None,
// payment_method_data: None,
// payment_experience: None,
// straight_through_algorithm: None,
// preprocessing_step_id: None,
// error_reason: None,
// connector_response_reference_id: None,
// surcharge_amount: None,
// tax_amount: None,
// amount_capturable: None,
// merchant_connector_id: None,
// authentication_data: None,
// encoded_data: None,
// unified_code: None,
// unified_message: None,
// external_three_ds_authentication_attempted: None,
// authentication_connector: None,
// authentication_id: None,
// fingerprint_id: None,
// payment_method_billing_address_id: None,
// charge_id: None,
// client_source: None,
// client_version: None,
// customer_acceptance: None,
// card_network: None,
// },
// PaymentAttemptUpdate::AmountToCaptureUpdate {
// status,
// amount_capturable,
// updated_by,
// } => Self {
// status: Some(status),
// modified_at: common_utils::date_time::now(),
// amount_capturable: Some(amount_capturable),
// updated_by,
// net_amount: None,
// authentication_type: None,
// error_message: None,
// payment_method_id: None,
// cancellation_reason: None,
// browser_info: None,
// payment_token: None,
// error_code: None,
// connector_metadata: None,
// payment_method_data: None,
// payment_experience: None,
// straight_through_algorithm: None,
// preprocessing_step_id: None,
// error_reason: None,
// connector_response_reference_id: None,
// multiple_capture_count: None,
// surcharge_amount: None,
// tax_amount: None,
// merchant_connector_id: None,
// authentication_data: None,
// encoded_data: None,
// unified_code: None,
// unified_message: None,
// external_three_ds_authentication_attempted: None,
// authentication_connector: None,
// authentication_id: None,
// fingerprint_id: None,
// payment_method_billing_address_id: None,
// charge_id: None,
// client_source: None,
// client_version: None,
// customer_acceptance: None,
// card_network: None,
// },
// PaymentAttemptUpdate::ConnectorResponse {
// authentication_data,
// encoded_data,
// connector_transaction_id,
// connector,
// updated_by,
// charge_id,
// } => Self {
// authentication_data,
// encoded_data,
// modified_at: common_utils::date_time::now(),
// updated_by,
// charge_id,
// net_amount: None,
// status: None,
// authentication_type: None,
// error_message: None,
// payment_method_id: None,
// cancellation_reason: None,
// browser_info: None,
// payment_token: None,
// error_code: None,
// connector_metadata: None,
// payment_method_data: None,
// payment_experience: None,
// straight_through_algorithm: None,
// preprocessing_step_id: None,
// error_reason: None,
// connector_response_reference_id: None,
// multiple_capture_count: None,
// surcharge_amount: None,
// tax_amount: None,
// amount_capturable: None,
// merchant_connector_id: None,
// unified_code: None,
// unified_message: None,
// external_three_ds_authentication_attempted: None,
// authentication_connector: None,
// authentication_id: None,
// fingerprint_id: None,
// payment_method_billing_address_id: None,
// client_source: None,
// client_version: None,
// customer_acceptance: None,
// card_network: None,
// },
// PaymentAttemptUpdate::IncrementalAuthorizationAmountUpdate {
// amount,
// amount_capturable,
// } => Self {
// modified_at: common_utils::date_time::now(),
// amount_capturable: Some(amount_capturable),
// net_amount: None,
// status: None,
// authentication_type: None,
// error_message: None,
// payment_method_id: None,
// cancellation_reason: None,
// browser_info: None,
// payment_token: None,
// error_code: None,
// connector_metadata: None,
// payment_method_data: None,
// payment_experience: None,
// straight_through_algorithm: None,
// preprocessing_step_id: None,
// error_reason: None,
// connector_response_reference_id: None,
// multiple_capture_count: None,
// surcharge_amount: None,
// tax_amount: None,
// updated_by: String::default(),
// merchant_connector_id: None,
// authentication_data: None,
// encoded_data: None,
// unified_code: None,
// unified_message: None,
// external_three_ds_authentication_attempted: None,
// authentication_connector: None,
// authentication_id: None,
// fingerprint_id: None,
// payment_method_billing_address_id: None,
// charge_id: None,
// client_source: None,
// client_version: None,
// customer_acceptance: None,
// card_network: None,
// },
// PaymentAttemptUpdate::AuthenticationUpdate {
// status,
// external_three_ds_authentication_attempted,
// authentication_connector,
// authentication_id,
// updated_by,
// } => Self {
// status: Some(status),
// modified_at: common_utils::date_time::now(),
// external_three_ds_authentication_attempted,
// authentication_connector,
// authentication_id,
// updated_by,
// net_amount: None,
// authentication_type: None,
// error_message: None,
// payment_method_id: None,
// cancellation_reason: None,
// browser_info: None,
// payment_token: None,
// error_code: None,
// connector_metadata: None,
// payment_method_data: None,
// payment_experience: None,
// straight_through_algorithm: None,
// preprocessing_step_id: None,
// error_reason: None,
// connector_response_reference_id: None,
// multiple_capture_count: None,
// surcharge_amount: None,
// tax_amount: None,
// amount_capturable: None,
// merchant_connector_id: None,
// authentication_data: None,
// encoded_data: None,
// unified_code: None,
// unified_message: None,
// fingerprint_id: None,
// payment_method_billing_address_id: None,
// charge_id: None,
// client_source: None,
// client_version: None,
// customer_acceptance: None,
// card_network: None,
// },
// PaymentAttemptUpdate::ManualUpdate {
// status,
// error_code,
// error_message,
// error_reason,
// updated_by,
// unified_code,
// unified_message,
// connector_transaction_id,
// } => Self {
// status,
// error_code: error_code.map(Some),
// modified_at: common_utils::date_time::now(),
// error_message: error_message.map(Some),
// error_reason: error_reason.map(Some),
// updated_by,
// unified_code: unified_code.map(Some),
// unified_message: unified_message.map(Some),
// net_amount: None,
// authentication_type: None,
// payment_method_id: None,
// cancellation_reason: None,
// browser_info: None,
// payment_token: None,
// connector_metadata: None,
// payment_method_data: None,
// payment_experience: None,
// straight_through_algorithm: None,
// preprocessing_step_id: None,
// connector_response_reference_id: None,
// multiple_capture_count: None,
// surcharge_amount: None,
// tax_amount: None,
// amount_capturable: None,
// merchant_connector_id: None,
// authentication_data: None,
// encoded_data: None,
// external_three_ds_authentication_attempted: None,
// authentication_connector: None,
// authentication_id: None,
// fingerprint_id: None,
// payment_method_billing_address_id: None,
// charge_id: None,
// client_source: None,
// client_version: None,
// customer_acceptance: None,
// card_network: None,
// },
// }
}
}
#[cfg(feature = "v1")]
impl From<PaymentAttemptUpdate> for PaymentAttemptUpdateInternal {
fn from(payment_attempt_update: PaymentAttemptUpdate) -> Self {
match payment_attempt_update {
PaymentAttemptUpdate::Update {
amount,
currency,
status,
// connector_transaction_id,
authentication_type,
payment_method,
payment_token,
payment_method_data,
payment_method_type,
payment_experience,
business_sub_label,
amount_to_capture,
capture_method,
surcharge_amount,
tax_amount,
fingerprint_id,
updated_by,
payment_method_billing_address_id,
} => Self {
amount: Some(amount),
currency: Some(currency),
status: Some(status),
// connector_transaction_id,
authentication_type,
payment_method,
payment_token,
modified_at: common_utils::date_time::now(),
payment_method_data,
payment_method_type,
payment_experience,
business_sub_label,
amount_to_capture,
capture_method,
surcharge_amount,
tax_amount,
fingerprint_id,
payment_method_billing_address_id,
updated_by,
net_amount: None,
connector_transaction_id: None,
connector: None,
error_message: None,
payment_method_id: None,
cancellation_reason: None,
mandate_id: None,
browser_info: None,
error_code: None,
connector_metadata: None,
straight_through_algorithm: None,
preprocessing_step_id: None,
error_reason: None,
connector_response_reference_id: None,
multiple_capture_count: None,
amount_capturable: None,
merchant_connector_id: None,
authentication_data: None,
encoded_data: None,
unified_code: None,
unified_message: None,
external_three_ds_authentication_attempted: None,
authentication_connector: None,
authentication_id: None,
client_source: None,
client_version: None,
customer_acceptance: None,
card_network: None,
shipping_cost: None,
capture_before: None,
extended_authorization_applied: None,
order_tax_amount: None,
processor_transaction_data: None,
connector_mandate_detail: None,
card_discovery: None,
charges: None,
issuer_error_code: None,
issuer_error_message: None,
},
PaymentAttemptUpdate::AuthenticationTypeUpdate {
authentication_type,
updated_by,
} => Self {
authentication_type: Some(authentication_type),
modified_at: common_utils::date_time::now(),
updated_by,
amount: None,
net_amount: None,
currency: None,
status: None,
connector_transaction_id: None,
amount_to_capture: None,
connector: None,
payment_method: None,
error_message: None,
payment_method_id: None,
cancellation_reason: None,
mandate_id: None,
browser_info: None,
payment_token: None,
error_code: None,
connector_metadata: None,
payment_method_data: None,
payment_method_type: None,
payment_experience: None,
business_sub_label: None,
straight_through_algorithm: None,
preprocessing_step_id: None,
error_reason: None,
capture_method: None,
connector_response_reference_id: None,
multiple_capture_count: None,
surcharge_amount: None,
tax_amount: None,
amount_capturable: None,
merchant_connector_id: None,
authentication_data: None,
encoded_data: None,
unified_code: None,
unified_message: None,
external_three_ds_authentication_attempted: None,
authentication_connector: None,
authentication_id: None,
fingerprint_id: None,
payment_method_billing_address_id: None,
client_source: None,
client_version: None,
customer_acceptance: None,
card_network: None,
shipping_cost: None,
order_tax_amount: None,
capture_before: None,
extended_authorization_applied: None,
processor_transaction_data: None,
connector_mandate_detail: None,
card_discovery: None,
charges: None,
issuer_error_code: None,
issuer_error_message: None,
},
PaymentAttemptUpdate::ConfirmUpdate {
amount,
currency,
authentication_type,
capture_method,
status,
payment_method,
browser_info,
connector,
payment_token,
payment_method_data,
payment_method_type,
payment_experience,
business_sub_label,
straight_through_algorithm,
error_code,
error_message,
amount_capturable,
updated_by,
merchant_connector_id,
surcharge_amount,
tax_amount,
external_three_ds_authentication_attempted,
authentication_connector,
authentication_id,
payment_method_billing_address_id,
fingerprint_id,
payment_method_id,
client_source,
client_version,
customer_acceptance,
shipping_cost,
order_tax_amount,
connector_mandate_detail,
card_discovery,
} => Self {
amount: Some(amount),
currency: Some(currency),
authentication_type,
status: Some(status),
payment_method,
modified_at: common_utils::date_time::now(),
browser_info,
connector: connector.map(Some),
payment_token,
payment_method_data,
payment_method_type,
payment_experience,
business_sub_label,
straight_through_algorithm,
error_code,
error_message,
amount_capturable,
updated_by,
merchant_connector_id: merchant_connector_id.map(Some),
surcharge_amount,
tax_amount,
external_three_ds_authentication_attempted,
authentication_connector,
authentication_id,
payment_method_billing_address_id,
fingerprint_id,
payment_method_id,
capture_method,
client_source,
client_version,
customer_acceptance,
net_amount: None,
connector_transaction_id: None,
amount_to_capture: None,
cancellation_reason: None,
mandate_id: None,
connector_metadata: None,
preprocessing_step_id: None,
error_reason: None,
connector_response_reference_id: None,
multiple_capture_count: None,
authentication_data: None,
encoded_data: None,
unified_code: None,
unified_message: None,
card_network: None,
shipping_cost,
order_tax_amount,
capture_before: None,
extended_authorization_applied: None,
processor_transaction_data: None,
connector_mandate_detail,
card_discovery,
charges: None,
issuer_error_code: None,
issuer_error_message: None,
},
PaymentAttemptUpdate::VoidUpdate {
status,
cancellation_reason,
updated_by,
} => Self {
status: Some(status),
cancellation_reason,
modified_at: common_utils::date_time::now(),
updated_by,
amount: None,
net_amount: None,
currency: None,
connector_transaction_id: None,
amount_to_capture: None,
connector: None,
authentication_type: None,
payment_method: None,
error_message: None,
payment_method_id: None,
mandate_id: None,
browser_info: None,
payment_token: None,
error_code: None,
connector_metadata: None,
payment_method_data: None,
payment_method_type: None,
payment_experience: None,
business_sub_label: None,
straight_through_algorithm: None,
preprocessing_step_id: None,
error_reason: None,
capture_method: None,
connector_response_reference_id: None,
multiple_capture_count: None,
surcharge_amount: None,
tax_amount: None,
amount_capturable: None,
merchant_connector_id: None,
authentication_data: None,
encoded_data: None,
unified_code: None,
unified_message: None,
external_three_ds_authentication_attempted: None,
authentication_connector: None,
authentication_id: None,
fingerprint_id: None,
payment_method_billing_address_id: None,
client_source: None,
client_version: None,
customer_acceptance: None,
card_network: None,
shipping_cost: None,
order_tax_amount: None,
capture_before: None,
extended_authorization_applied: None,
processor_transaction_data: None,
connector_mandate_detail: None,
card_discovery: None,
charges: None,
issuer_error_code: None,
issuer_error_message: None,
},
PaymentAttemptUpdate::RejectUpdate {
status,
error_code,
error_message,
updated_by,
} => Self {
status: Some(status),
modified_at: common_utils::date_time::now(),
error_code,
error_message,
updated_by,
amount: None,
net_amount: None,
currency: None,
connector_transaction_id: None,
amount_to_capture: None,
connector: None,
authentication_type: None,
payment_method: None,
payment_method_id: None,
cancellation_reason: None,
mandate_id: None,
browser_info: None,
payment_token: None,
connector_metadata: None,
payment_method_data: None,
payment_method_type: None,
payment_experience: None,
business_sub_label: None,
straight_through_algorithm: None,
preprocessing_step_id: None,
error_reason: None,
capture_method: None,
connector_response_reference_id: None,
multiple_capture_count: None,
surcharge_amount: None,
tax_amount: None,
amount_capturable: None,
merchant_connector_id: None,
authentication_data: None,
encoded_data: None,
unified_code: None,
unified_message: None,
external_three_ds_authentication_attempted: None,
authentication_connector: None,
authentication_id: None,
fingerprint_id: None,
payment_method_billing_address_id: None,
client_source: None,
client_version: None,
customer_acceptance: None,
card_network: None,
shipping_cost: None,
order_tax_amount: None,
capture_before: None,
extended_authorization_applied: None,
processor_transaction_data: None,
connector_mandate_detail: None,
card_discovery: None,
charges: None,
issuer_error_code: None,
issuer_error_message: None,
},
PaymentAttemptUpdate::BlocklistUpdate {
status,
error_code,
error_message,
updated_by,
} => Self {
status: Some(status),
modified_at: common_utils::date_time::now(),
error_code,
connector: Some(None),
error_message,
updated_by,
merchant_connector_id: Some(None),
amount: None,
net_amount: None,
currency: None,
connector_transaction_id: None,
amount_to_capture: None,
authentication_type: None,
payment_method: None,
payment_method_id: None,
cancellation_reason: None,
mandate_id: None,
browser_info: None,
payment_token: None,
connector_metadata: None,
payment_method_data: None,
payment_method_type: None,
payment_experience: None,
business_sub_label: None,
straight_through_algorithm: None,
preprocessing_step_id: None,
error_reason: None,
capture_method: None,
connector_response_reference_id: None,
multiple_capture_count: None,
surcharge_amount: None,
tax_amount: None,
amount_capturable: None,
authentication_data: None,
encoded_data: None,
unified_code: None,
unified_message: None,
external_three_ds_authentication_attempted: None,
authentication_connector: None,
authentication_id: None,
fingerprint_id: None,
payment_method_billing_address_id: None,
client_source: None,
client_version: None,
customer_acceptance: None,
card_network: None,
shipping_cost: None,
order_tax_amount: None,
capture_before: None,
extended_authorization_applied: None,
processor_transaction_data: None,
connector_mandate_detail: None,
card_discovery: None,
charges: None,
issuer_error_code: None,
issuer_error_message: None,
},
PaymentAttemptUpdate::ConnectorMandateDetailUpdate {
connector_mandate_detail,
updated_by,
} => Self {
payment_method_id: None,
modified_at: common_utils::date_time::now(),
updated_by,
amount: None,
net_amount: None,
currency: None,
status: None,
connector_transaction_id: None,
amount_to_capture: None,
connector: None,
authentication_type: None,
payment_method: None,
error_message: None,
cancellation_reason: None,
mandate_id: None,
browser_info: None,
payment_token: None,
error_code: None,
connector_metadata: None,
payment_method_data: None,
payment_method_type: None,
payment_experience: None,
business_sub_label: None,
straight_through_algorithm: None,
preprocessing_step_id: None,
error_reason: None,
capture_method: None,
connector_response_reference_id: None,
multiple_capture_count: None,
surcharge_amount: None,
tax_amount: None,
amount_capturable: None,
merchant_connector_id: None,
authentication_data: None,
encoded_data: None,
unified_code: None,
unified_message: None,
external_three_ds_authentication_attempted: None,
authentication_connector: None,
authentication_id: None,
fingerprint_id: None,
payment_method_billing_address_id: None,
client_source: None,
client_version: None,
customer_acceptance: None,
card_network: None,
shipping_cost: None,
order_tax_amount: None,
capture_before: None,
extended_authorization_applied: None,
processor_transaction_data: None,
connector_mandate_detail,
card_discovery: None,
charges: None,
issuer_error_code: None,
issuer_error_message: None,
},
PaymentAttemptUpdate::PaymentMethodDetailsUpdate {
payment_method_id,
updated_by,
} => Self {
payment_method_id,
modified_at: common_utils::date_time::now(),
updated_by,
amount: None,
net_amount: None,
currency: None,
status: None,
connector_transaction_id: None,
amount_to_capture: None,
connector: None,
authentication_type: None,
payment_method: None,
error_message: None,
cancellation_reason: None,
mandate_id: None,
browser_info: None,
payment_token: None,
error_code: None,
connector_metadata: None,
payment_method_data: None,
payment_method_type: None,
payment_experience: None,
business_sub_label: None,
straight_through_algorithm: None,
preprocessing_step_id: None,
error_reason: None,
capture_method: None,
connector_response_reference_id: None,
multiple_capture_count: None,
surcharge_amount: None,
tax_amount: None,
amount_capturable: None,
merchant_connector_id: None,
authentication_data: None,
encoded_data: None,
unified_code: None,
unified_message: None,
external_three_ds_authentication_attempted: None,
authentication_connector: None,
authentication_id: None,
fingerprint_id: None,
payment_method_billing_address_id: None,
client_source: None,
client_version: None,
customer_acceptance: None,
card_network: None,
shipping_cost: None,
order_tax_amount: None,
capture_before: None,
extended_authorization_applied: None,
processor_transaction_data: None,
connector_mandate_detail: None,
card_discovery: None,
charges: None,
issuer_error_code: None,
issuer_error_message: None,
},
PaymentAttemptUpdate::ResponseUpdate {
status,
connector,
connector_transaction_id,
authentication_type,
payment_method_id,
mandate_id,
connector_metadata,
payment_token,
error_code,
error_message,
error_reason,
connector_response_reference_id,
amount_capturable,
updated_by,
authentication_data,
encoded_data,
unified_code,
unified_message,
capture_before,
extended_authorization_applied,
payment_method_data,
connector_mandate_detail,
charges,
} => {
let (connector_transaction_id, processor_transaction_data) =
connector_transaction_id
.map(ConnectorTransactionId::form_id_and_data)
.map(|(txn_id, txn_data)| (Some(txn_id), txn_data))
.unwrap_or((None, None));
Self {
status: Some(status),
connector: connector.map(Some),
connector_transaction_id,
authentication_type,
payment_method_id,
modified_at: common_utils::date_time::now(),
mandate_id,
connector_metadata,
error_code,
error_message,
payment_token,
error_reason,
connector_response_reference_id,
amount_capturable,
updated_by,
authentication_data,
encoded_data,
unified_code,
unified_message,
payment_method_data,
processor_transaction_data,
connector_mandate_detail,
charges,
amount: None,
net_amount: None,
currency: None,
amount_to_capture: None,
payment_method: None,
cancellation_reason: None,
browser_info: None,
payment_method_type: None,
payment_experience: None,
business_sub_label: None,
straight_through_algorithm: None,
preprocessing_step_id: None,
capture_method: None,
multiple_capture_count: None,
surcharge_amount: None,
tax_amount: None,
merchant_connector_id: None,
external_three_ds_authentication_attempted: None,
authentication_connector: None,
authentication_id: None,
fingerprint_id: None,
payment_method_billing_address_id: None,
client_source: None,
client_version: None,
customer_acceptance: None,
card_network: None,
capture_before,
extended_authorization_applied,
shipping_cost: None,
order_tax_amount: None,
card_discovery: None,
issuer_error_code: None,
issuer_error_message: None,
}
}
PaymentAttemptUpdate::ErrorUpdate {
connector,
status,
error_code,
error_message,
error_reason,
amount_capturable,
updated_by,
unified_code,
unified_message,
connector_transaction_id,
payment_method_data,
authentication_type,
issuer_error_code,
issuer_error_message,
} => {
let (connector_transaction_id, processor_transaction_data) =
connector_transaction_id
.map(ConnectorTransactionId::form_id_and_data)
.map(|(txn_id, txn_data)| (Some(txn_id), txn_data))
.unwrap_or((None, None));
Self {
connector: connector.map(Some),
status: Some(status),
error_message,
error_code,
modified_at: common_utils::date_time::now(),
error_reason,
amount_capturable,
updated_by,
unified_code,
unified_message,
connector_transaction_id,
payment_method_data,
authentication_type,
processor_transaction_data,
issuer_error_code,
issuer_error_message,
amount: None,
net_amount: None,
currency: None,
amount_to_capture: None,
payment_method: None,
payment_method_id: None,
cancellation_reason: None,
mandate_id: None,
browser_info: None,
payment_token: None,
connector_metadata: None,
payment_method_type: None,
payment_experience: None,
business_sub_label: None,
straight_through_algorithm: None,
preprocessing_step_id: None,
capture_method: None,
connector_response_reference_id: None,
multiple_capture_count: None,
surcharge_amount: None,
tax_amount: None,
merchant_connector_id: None,
authentication_data: None,
encoded_data: None,
external_three_ds_authentication_attempted: None,
authentication_connector: None,
authentication_id: None,
fingerprint_id: None,
payment_method_billing_address_id: None,
client_source: None,
client_version: None,
customer_acceptance: None,
card_network: None,
capture_before: None,
extended_authorization_applied: None,
shipping_cost: None,
order_tax_amount: None,
connector_mandate_detail: None,
card_discovery: None,
charges: None,
}
}
PaymentAttemptUpdate::StatusUpdate { status, updated_by } => Self {
status: Some(status),
modified_at: common_utils::date_time::now(),
updated_by,
amount: None,
net_amount: None,
currency: None,
connector_transaction_id: None,
amount_to_capture: None,
connector: None,
authentication_type: None,
payment_method: None,
error_message: None,
payment_method_id: None,
cancellation_reason: None,
mandate_id: None,
browser_info: None,
payment_token: None,
error_code: None,
connector_metadata: None,
payment_method_data: None,
payment_method_type: None,
payment_experience: None,
business_sub_label: None,
straight_through_algorithm: None,
preprocessing_step_id: None,
error_reason: None,
capture_method: None,
connector_response_reference_id: None,
multiple_capture_count: None,
surcharge_amount: None,
tax_amount: None,
amount_capturable: None,
merchant_connector_id: None,
authentication_data: None,
encoded_data: None,
unified_code: None,
unified_message: None,
external_three_ds_authentication_attempted: None,
authentication_connector: None,
authentication_id: None,
fingerprint_id: None,
payment_method_billing_address_id: None,
client_source: None,
client_version: None,
customer_acceptance: None,
card_network: None,
shipping_cost: None,
capture_before: None,
extended_authorization_applied: None,
order_tax_amount: None,
processor_transaction_data: None,
connector_mandate_detail: None,
card_discovery: None,
charges: None,
issuer_error_code: None,
issuer_error_message: None,
},
PaymentAttemptUpdate::UpdateTrackers {
payment_token,
connector,
straight_through_algorithm,
amount_capturable,
surcharge_amount,
tax_amount,
updated_by,
merchant_connector_id,
} => Self {
payment_token,
modified_at: common_utils::date_time::now(),
connector: connector.map(Some),
straight_through_algorithm,
amount_capturable,
surcharge_amount,
tax_amount,
updated_by,
merchant_connector_id: merchant_connector_id.map(Some),
amount: None,
net_amount: None,
currency: None,
status: None,
connector_transaction_id: None,
amount_to_capture: None,
authentication_type: None,
payment_method: None,
error_message: None,
payment_method_id: None,
cancellation_reason: None,
mandate_id: None,
browser_info: None,
error_code: None,
connector_metadata: None,
payment_method_data: None,
payment_method_type: None,
payment_experience: None,
business_sub_label: None,
preprocessing_step_id: None,
error_reason: None,
capture_method: None,
connector_response_reference_id: None,
multiple_capture_count: None,
authentication_data: None,
encoded_data: None,
unified_code: None,
unified_message: None,
external_three_ds_authentication_attempted: None,
authentication_connector: None,
authentication_id: None,
fingerprint_id: None,
payment_method_billing_address_id: None,
client_source: None,
client_version: None,
customer_acceptance: None,
card_network: None,
shipping_cost: None,
capture_before: None,
extended_authorization_applied: None,
order_tax_amount: None,
processor_transaction_data: None,
connector_mandate_detail: None,
card_discovery: None,
charges: None,
issuer_error_code: None,
issuer_error_message: None,
},
PaymentAttemptUpdate::UnresolvedResponseUpdate {
status,
connector,
connector_transaction_id,
payment_method_id,
error_code,
error_message,
error_reason,
connector_response_reference_id,
updated_by,
} => {
let (connector_transaction_id, processor_transaction_data) =
connector_transaction_id
.map(ConnectorTransactionId::form_id_and_data)
.map(|(txn_id, txn_data)| (Some(txn_id), txn_data))
.unwrap_or((None, None));
Self {
status: Some(status),
connector: connector.map(Some),
connector_transaction_id,
payment_method_id,
modified_at: common_utils::date_time::now(),
error_code,
error_message,
error_reason,
connector_response_reference_id,
updated_by,
processor_transaction_data,
amount: None,
net_amount: None,
currency: None,
amount_to_capture: None,
authentication_type: None,
payment_method: None,
cancellation_reason: None,
mandate_id: None,
browser_info: None,
payment_token: None,
connector_metadata: None,
payment_method_data: None,
payment_method_type: None,
payment_experience: None,
business_sub_label: None,
straight_through_algorithm: None,
preprocessing_step_id: None,
capture_method: None,
multiple_capture_count: None,
surcharge_amount: None,
tax_amount: None,
amount_capturable: None,
merchant_connector_id: None,
authentication_data: None,
encoded_data: None,
unified_code: None,
unified_message: None,
external_three_ds_authentication_attempted: None,
authentication_connector: None,
authentication_id: None,
fingerprint_id: None,
payment_method_billing_address_id: None,
client_source: None,
client_version: None,
customer_acceptance: None,
card_network: None,
shipping_cost: None,
capture_before: None,
extended_authorization_applied: None,
order_tax_amount: None,
connector_mandate_detail: None,
card_discovery: None,
charges: None,
issuer_error_code: None,
issuer_error_message: None,
}
}
PaymentAttemptUpdate::PreprocessingUpdate {
status,
payment_method_id,
connector_metadata,
preprocessing_step_id,
connector_transaction_id,
connector_response_reference_id,
updated_by,
} => {
let (connector_transaction_id, processor_transaction_data) =
connector_transaction_id
.map(ConnectorTransactionId::form_id_and_data)
.map(|(txn_id, txn_data)| (Some(txn_id), txn_data))
.unwrap_or((None, None));
Self {
status: Some(status),
payment_method_id,
modified_at: common_utils::date_time::now(),
connector_metadata,
preprocessing_step_id,
connector_transaction_id,
connector_response_reference_id,
updated_by,
processor_transaction_data,
amount: None,
net_amount: None,
currency: None,
amount_to_capture: None,
connector: None,
authentication_type: None,
payment_method: None,
error_message: None,
cancellation_reason: None,
mandate_id: None,
browser_info: None,
payment_token: None,
error_code: None,
payment_method_data: None,
payment_method_type: None,
payment_experience: None,
business_sub_label: None,
straight_through_algorithm: None,
error_reason: None,
capture_method: None,
multiple_capture_count: None,
surcharge_amount: None,
tax_amount: None,
amount_capturable: None,
merchant_connector_id: None,
authentication_data: None,
encoded_data: None,
unified_code: None,
unified_message: None,
external_three_ds_authentication_attempted: None,
authentication_connector: None,
authentication_id: None,
fingerprint_id: None,
payment_method_billing_address_id: None,
client_source: None,
client_version: None,
customer_acceptance: None,
card_network: None,
capture_before: None,
extended_authorization_applied: None,
shipping_cost: None,
order_tax_amount: None,
connector_mandate_detail: None,
card_discovery: None,
charges: None,
issuer_error_code: None,
issuer_error_message: None,
}
}
PaymentAttemptUpdate::CaptureUpdate {
multiple_capture_count,
updated_by,
amount_to_capture,
} => Self {
multiple_capture_count,
modified_at: common_utils::date_time::now(),
updated_by,
amount_to_capture,
amount: None,
net_amount: None,
currency: None,
status: None,
connector_transaction_id: None,
connector: None,
authentication_type: None,
payment_method: None,
error_message: None,
payment_method_id: None,
cancellation_reason: None,
mandate_id: None,
browser_info: None,
payment_token: None,
error_code: None,
connector_metadata: None,
payment_method_data: None,
payment_method_type: None,
payment_experience: None,
business_sub_label: None,
straight_through_algorithm: None,
preprocessing_step_id: None,
error_reason: None,
capture_method: None,
connector_response_reference_id: None,
surcharge_amount: None,
tax_amount: None,
amount_capturable: None,
merchant_connector_id: None,
authentication_data: None,
encoded_data: None,
unified_code: None,
unified_message: None,
external_three_ds_authentication_attempted: None,
authentication_connector: None,
authentication_id: None,
fingerprint_id: None,
payment_method_billing_address_id: None,
client_source: None,
client_version: None,
customer_acceptance: None,
card_network: None,
shipping_cost: None,
order_tax_amount: None,
capture_before: None,
extended_authorization_applied: None,
processor_transaction_data: None,
connector_mandate_detail: None,
card_discovery: None,
charges: None,
issuer_error_code: None,
issuer_error_message: None,
},
PaymentAttemptUpdate::AmountToCaptureUpdate {
status,
amount_capturable,
updated_by,
} => Self {
status: Some(status),
modified_at: common_utils::date_time::now(),
amount_capturable: Some(amount_capturable),
updated_by,
amount: None,
net_amount: None,
currency: None,
connector_transaction_id: None,
amount_to_capture: None,
connector: None,
authentication_type: None,
payment_method: None,
error_message: None,
payment_method_id: None,
cancellation_reason: None,
mandate_id: None,
browser_info: None,
payment_token: None,
error_code: None,
connector_metadata: None,
payment_method_data: None,
payment_method_type: None,
payment_experience: None,
business_sub_label: None,
straight_through_algorithm: None,
preprocessing_step_id: None,
error_reason: None,
capture_method: None,
connector_response_reference_id: None,
multiple_capture_count: None,
surcharge_amount: None,
tax_amount: None,
merchant_connector_id: None,
authentication_data: None,
encoded_data: None,
unified_code: None,
unified_message: None,
external_three_ds_authentication_attempted: None,
authentication_connector: None,
authentication_id: None,
fingerprint_id: None,
payment_method_billing_address_id: None,
client_source: None,
client_version: None,
customer_acceptance: None,
card_network: None,
shipping_cost: None,
capture_before: None,
extended_authorization_applied: None,
order_tax_amount: None,
processor_transaction_data: None,
connector_mandate_detail: None,
card_discovery: None,
charges: None,
issuer_error_code: None,
issuer_error_message: None,
},
PaymentAttemptUpdate::ConnectorResponse {
authentication_data,
encoded_data,
connector_transaction_id,
connector,
updated_by,
charges,
} => {
let (connector_transaction_id, processor_transaction_data) =
connector_transaction_id
.map(ConnectorTransactionId::form_id_and_data)
.map(|(txn_id, txn_data)| (Some(txn_id), txn_data))
.unwrap_or((None, None));
Self {
authentication_data,
encoded_data,
connector_transaction_id,
connector: connector.map(Some),
modified_at: common_utils::date_time::now(),
updated_by,
processor_transaction_data,
charges,
amount: None,
net_amount: None,
currency: None,
status: None,
amount_to_capture: None,
authentication_type: None,
payment_method: None,
error_message: None,
payment_method_id: None,
cancellation_reason: None,
mandate_id: None,
browser_info: None,
payment_token: None,
error_code: None,
connector_metadata: None,
payment_method_data: None,
payment_method_type: None,
payment_experience: None,
business_sub_label: None,
straight_through_algorithm: None,
preprocessing_step_id: None,
error_reason: None,
capture_method: None,
connector_response_reference_id: None,
multiple_capture_count: None,
surcharge_amount: None,
tax_amount: None,
amount_capturable: None,
merchant_connector_id: None,
unified_code: None,
unified_message: None,
external_three_ds_authentication_attempted: None,
authentication_connector: None,
authentication_id: None,
fingerprint_id: None,
payment_method_billing_address_id: None,
client_source: None,
client_version: None,
customer_acceptance: None,
card_network: None,
shipping_cost: None,
capture_before: None,
extended_authorization_applied: None,
order_tax_amount: None,
connector_mandate_detail: None,
card_discovery: None,
issuer_error_code: None,
issuer_error_message: None,
}
}
PaymentAttemptUpdate::IncrementalAuthorizationAmountUpdate {
amount,
amount_capturable,
} => Self {
amount: Some(amount),
modified_at: common_utils::date_time::now(),
amount_capturable: Some(amount_capturable),
net_amount: None,
currency: None,
status: None,
connector_transaction_id: None,
amount_to_capture: None,
connector: None,
authentication_type: None,
payment_method: None,
error_message: None,
payment_method_id: None,
cancellation_reason: None,
mandate_id: None,
browser_info: None,
payment_token: None,
error_code: None,
connector_metadata: None,
payment_method_data: None,
payment_method_type: None,
payment_experience: None,
business_sub_label: None,
straight_through_algorithm: None,
preprocessing_step_id: None,
error_reason: None,
capture_method: None,
connector_response_reference_id: None,
multiple_capture_count: None,
surcharge_amount: None,
tax_amount: None,
updated_by: String::default(),
merchant_connector_id: None,
authentication_data: None,
encoded_data: None,
unified_code: None,
unified_message: None,
external_three_ds_authentication_attempted: None,
authentication_connector: None,
authentication_id: None,
fingerprint_id: None,
payment_method_billing_address_id: None,
client_source: None,
client_version: None,
customer_acceptance: None,
card_network: None,
shipping_cost: None,
order_tax_amount: None,
capture_before: None,
extended_authorization_applied: None,
processor_transaction_data: None,
connector_mandate_detail: None,
card_discovery: None,
charges: None,
issuer_error_code: None,
issuer_error_message: None,
},
PaymentAttemptUpdate::AuthenticationUpdate {
status,
external_three_ds_authentication_attempted,
authentication_connector,
authentication_id,
updated_by,
} => Self {
status: Some(status),
modified_at: common_utils::date_time::now(),
external_three_ds_authentication_attempted,
authentication_connector,
authentication_id,
updated_by,
amount: None,
net_amount: None,
currency: None,
connector_transaction_id: None,
amount_to_capture: None,
connector: None,
authentication_type: None,
payment_method: None,
error_message: None,
payment_method_id: None,
cancellation_reason: None,
mandate_id: None,
browser_info: None,
payment_token: None,
error_code: None,
connector_metadata: None,
payment_method_data: None,
payment_method_type: None,
payment_experience: None,
business_sub_label: None,
straight_through_algorithm: None,
preprocessing_step_id: None,
error_reason: None,
capture_method: None,
connector_response_reference_id: None,
multiple_capture_count: None,
surcharge_amount: None,
tax_amount: None,
amount_capturable: None,
merchant_connector_id: None,
authentication_data: None,
encoded_data: None,
unified_code: None,
unified_message: None,
fingerprint_id: None,
payment_method_billing_address_id: None,
client_source: None,
client_version: None,
customer_acceptance: None,
card_network: None,
shipping_cost: None,
order_tax_amount: None,
capture_before: None,
extended_authorization_applied: None,
processor_transaction_data: None,
connector_mandate_detail: None,
card_discovery: None,
charges: None,
issuer_error_code: None,
issuer_error_message: None,
},
PaymentAttemptUpdate::ManualUpdate {
status,
error_code,
error_message,
error_reason,
updated_by,
unified_code,
unified_message,
connector_transaction_id,
} => {
let (connector_transaction_id, processor_transaction_data) =
connector_transaction_id
.map(ConnectorTransactionId::form_id_and_data)
.map(|(txn_id, txn_data)| (Some(txn_id), txn_data))
.unwrap_or((None, None));
Self {
status,
error_code: error_code.map(Some),
modified_at: common_utils::date_time::now(),
error_message: error_message.map(Some),
error_reason: error_reason.map(Some),
updated_by,
unified_code: unified_code.map(Some),
unified_message: unified_message.map(Some),
connector_transaction_id,
processor_transaction_data,
amount: None,
net_amount: None,
currency: None,
amount_to_capture: None,
connector: None,
authentication_type: None,
payment_method: None,
payment_method_id: None,
cancellation_reason: None,
mandate_id: None,
browser_info: None,
payment_token: None,
connector_metadata: None,
payment_method_data: None,
payment_method_type: None,
payment_experience: None,
business_sub_label: None,
straight_through_algorithm: None,
preprocessing_step_id: None,
capture_method: None,
connector_response_reference_id: None,
multiple_capture_count: None,
surcharge_amount: None,
tax_amount: None,
amount_capturable: None,
merchant_connector_id: None,
authentication_data: None,
encoded_data: None,
external_three_ds_authentication_attempted: None,
authentication_connector: None,
authentication_id: None,
fingerprint_id: None,
payment_method_billing_address_id: None,
client_source: None,
client_version: None,
customer_acceptance: None,
card_network: None,
shipping_cost: None,
capture_before: None,
extended_authorization_applied: None,
order_tax_amount: None,
connector_mandate_detail: None,
card_discovery: None,
charges: None,
issuer_error_code: None,
issuer_error_message: None,
}
}
PaymentAttemptUpdate::PostSessionTokensUpdate {
updated_by,
connector_metadata,
} => Self {
status: None,
error_code: None,
modified_at: common_utils::date_time::now(),
error_message: None,
error_reason: None,
updated_by,
unified_code: None,
unified_message: None,
amount: None,
net_amount: None,
currency: None,
connector_transaction_id: None,
amount_to_capture: None,
connector: None,
authentication_type: None,
payment_method: None,
payment_method_id: None,
cancellation_reason: None,
mandate_id: None,
browser_info: None,
payment_token: None,
connector_metadata,
payment_method_data: None,
payment_method_type: None,
payment_experience: None,
business_sub_label: None,
straight_through_algorithm: None,
preprocessing_step_id: None,
capture_method: None,
connector_response_reference_id: None,
multiple_capture_count: None,
surcharge_amount: None,
tax_amount: None,
amount_capturable: None,
merchant_connector_id: None,
authentication_data: None,
encoded_data: None,
external_three_ds_authentication_attempted: None,
authentication_connector: None,
authentication_id: None,
fingerprint_id: None,
payment_method_billing_address_id: None,
client_source: None,
client_version: None,
customer_acceptance: None,
card_network: None,
shipping_cost: None,
order_tax_amount: None,
capture_before: None,
extended_authorization_applied: None,
processor_transaction_data: None,
connector_mandate_detail: None,
card_discovery: None,
charges: None,
issuer_error_code: None,
issuer_error_message: None,
},
}
}
}
#[derive(Eq, PartialEq, Clone, Debug, Deserialize, Serialize, diesel::AsExpression)]
#[diesel(sql_type = diesel::sql_types::Jsonb)]
pub enum RedirectForm {
Form {
endpoint: String,
method: common_utils::request::Method,
form_fields: std::collections::HashMap<String, String>,
},
Html {
html_data: String,
},
BlueSnap {
payment_fields_token: String,
},
CybersourceAuthSetup {
access_token: String,
ddc_url: String,
reference_id: String,
},
CybersourceConsumerAuth {
access_token: String,
step_up_url: String,
},
DeutschebankThreeDSChallengeFlow {
acs_url: String,
creq: String,
},
Payme,
Braintree {
client_token: String,
card_token: String,
bin: String,
acs_url: String,
},
Nmi {
amount: String,
currency: common_enums::Currency,
public_key: masking::Secret<String>,
customer_vault_id: String,
order_id: String,
},
Mifinity {
initialization_token: String,
},
WorldpayDDCForm {
endpoint: common_utils::types::Url,
method: common_utils::request::Method,
form_fields: std::collections::HashMap<String, String>,
collection_id: Option<String>,
},
}
common_utils::impl_to_sql_from_sql_json!(RedirectForm);
#[cfg(feature = "v2")]
#[derive(
Clone, Debug, serde::Deserialize, serde::Serialize, Eq, PartialEq, diesel::AsExpression,
)]
#[diesel(sql_type = diesel::pg::sql_types::Jsonb)]
pub struct PaymentAttemptFeatureMetadata {
pub revenue_recovery: Option<PaymentAttemptRecoveryData>,
}
#[cfg(feature = "v2")]
#[derive(
Clone, Debug, serde::Deserialize, serde::Serialize, Eq, PartialEq, diesel::AsExpression,
)]
#[diesel(sql_type = diesel::pg::sql_types::Jsonb)]
pub struct PaymentAttemptRecoveryData {
pub attempt_triggered_by: common_enums::TriggeredBy,
}
#[cfg(feature = "v2")]
common_utils::impl_to_sql_from_sql_json!(PaymentAttemptFeatureMetadata);
mod tests {
#[test]
fn test_backwards_compatibility() {
let serialized_payment_attempt = r#"{
"payment_id": "PMT123456789",
"merchant_id": "M123456789",
"attempt_id": "ATMPT123456789",
"status": "pending",
"amount": 10000,
"currency": "USD",
"save_to_locker": true,
"connector": "stripe",
"error_message": null,
"offer_amount": 9500,
"surcharge_amount": 500,
"tax_amount": 800,
"payment_method_id": "CRD123456789",
"payment_method": "card",
"connector_transaction_id": "CNTR123456789",
"capture_method": "automatic",
"capture_on": "2022-09-10T10:11:12Z",
"confirm": false,
"authentication_type": "no_three_ds",
"created_at": "2024-02-26T12:00:00Z",
"modified_at": "2024-02-26T12:00:00Z",
"last_synced": null,
"cancellation_reason": null,
"amount_to_capture": 10000,
"mandate_id": null,
"browser_info": {
"user_agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/70.0.3538.110 Safari/537.36",
"accept_header": "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8",
"language": "nl-NL",
"color_depth": 24,
"screen_height": 723,
"screen_width": 1536,
"time_zone": 0,
"java_enabled": true,
"java_script_enabled": true,
"ip_address": "127.0.0.1"
},
"error_code": null,
"payment_token": "TOKEN123456789",
"connector_metadata": null,
"payment_experience": "redirect_to_url",
"payment_method_type": "credit",
"payment_method_data": {
"card": {
"card_number": "4242424242424242",
"card_exp_month": "10",
"card_cvc": "123",
"card_exp_year": "2024",
"card_holder_name": "John Doe"
}
},
"business_sub_label": "Premium",
"straight_through_algorithm": null,
"preprocessing_step_id": null,
"mandate_details": null,
"error_reason": null,
"multiple_capture_count": 0,
"connector_response_reference_id": null,
"amount_capturable": 10000,
"updated_by": "redis_kv",
"merchant_connector_id": "MCN123456789",
"authentication_data": null,
"encoded_data": null,
"unified_code": null,
"unified_message": null,
"net_amount": 10200,
"mandate_data": {
"customer_acceptance": {
"acceptance_type": "offline",
"accepted_at": "1963-05-03T04:07:52.723Z",
"online": {
"ip_address": "127.0.0.1",
"user_agent": "amet irure esse"
}
},
"single_use": {
"amount": 6540,
"currency": "USD"
}
}
},
"fingerprint_id": null
}"#;
let deserialized =
serde_json::from_str::<super::PaymentAttempt>(serialized_payment_attempt);
assert!(deserialized.is_ok());
}
}
| proc_macro_neighborhoods |
<|meta_start|><|file|> hyperswitch/crates/router_derive/src/lib.rs<|crate|> diesel_models macro=DebugAsDisplay roles=use_site,macro_def use=derive item=file pack=proc_macro_neighborhoods lang=rust<|meta_end|>
<file_sep path="hyperswitch/crates/diesel_models/src/payment_attempt.rs" crate="diesel_models" role="use_site">
use common_types::primitive_wrappers::{
ExtendedAuthorizationAppliedBool, RequestExtendedAuthorizationBool,
};
use common_utils::{
id_type, pii,
types::{ConnectorTransactionId, ConnectorTransactionIdTrait, MinorUnit},
};
use diesel::{AsChangeset, Identifiable, Insertable, Queryable, Selectable};
use serde::{Deserialize, Serialize};
use time::PrimitiveDateTime;
use crate::enums as storage_enums;
#[cfg(feature = "v1")]
use crate::schema::payment_attempt;
#[cfg(feature = "v2")]
use crate::schema_v2::payment_attempt;
common_utils::impl_to_sql_from_sql_json!(ConnectorMandateReferenceId);
#[derive(
Clone, Debug, serde::Deserialize, serde::Serialize, Eq, PartialEq, diesel::AsExpression,
)]
#[diesel(sql_type = diesel::sql_types::Jsonb)]
pub struct ConnectorMandateReferenceId {
pub connector_mandate_id: Option<String>,
pub payment_method_id: Option<String>,
pub mandate_metadata: Option<pii::SecretSerdeValue>,
pub connector_mandate_request_reference_id: Option<String>,
}
impl ConnectorMandateReferenceId {
pub fn get_connector_mandate_request_reference_id(&self) -> Option<String> {
self.connector_mandate_request_reference_id.clone()
}
}
#[cfg(feature = "v2")]
#[derive(
Clone, Debug, Eq, PartialEq, Identifiable, Queryable, Serialize, Deserialize, Selectable,
)]
#[diesel(table_name = payment_attempt, primary_key(id), check_for_backend(diesel::pg::Pg))]
pub struct PaymentAttempt {
pub payment_id: id_type::GlobalPaymentId,
pub merchant_id: id_type::MerchantId,
pub status: storage_enums::AttemptStatus,
pub connector: Option<String>,
pub error_message: Option<String>,
pub surcharge_amount: Option<MinorUnit>,
pub payment_method_id: Option<id_type::GlobalPaymentMethodId>,
pub authentication_type: storage_enums::AuthenticationType,
#[serde(with = "common_utils::custom_serde::iso8601")]
pub created_at: PrimitiveDateTime,
#[serde(with = "common_utils::custom_serde::iso8601")]
pub modified_at: PrimitiveDateTime,
#[serde(default, with = "common_utils::custom_serde::iso8601::option")]
pub last_synced: Option<PrimitiveDateTime>,
pub cancellation_reason: Option<String>,
pub amount_to_capture: Option<MinorUnit>,
pub browser_info: Option<common_utils::types::BrowserInformation>,
pub error_code: Option<String>,
pub payment_token: Option<String>,
pub connector_metadata: Option<pii::SecretSerdeValue>,
pub payment_experience: Option<storage_enums::PaymentExperience>,
pub payment_method_data: Option<pii::SecretSerdeValue>,
pub preprocessing_step_id: Option<String>,
pub error_reason: Option<String>,
pub multiple_capture_count: Option<i16>,
pub connector_response_reference_id: Option<String>,
pub amount_capturable: MinorUnit,
pub updated_by: String,
pub merchant_connector_id: Option<id_type::MerchantConnectorAccountId>,
pub encoded_data: Option<masking::Secret<String>>,
pub unified_code: Option<String>,
pub unified_message: Option<String>,
pub net_amount: MinorUnit,
pub external_three_ds_authentication_attempted: Option<bool>,
pub authentication_connector: Option<String>,
pub authentication_id: Option<String>,
pub fingerprint_id: Option<String>,
pub client_source: Option<String>,
pub client_version: Option<String>,
pub customer_acceptance: Option<pii::SecretSerdeValue>,
pub profile_id: id_type::ProfileId,
pub organization_id: id_type::OrganizationId,
pub card_network: Option<String>,
pub shipping_cost: Option<MinorUnit>,
pub order_tax_amount: Option<MinorUnit>,
pub request_extended_authorization: Option<RequestExtendedAuthorizationBool>,
pub extended_authorization_applied: Option<ExtendedAuthorizationAppliedBool>,
pub capture_before: Option<PrimitiveDateTime>,
pub card_discovery: Option<storage_enums::CardDiscovery>,
pub charges: Option<common_types::payments::ConnectorChargeResponseData>,
pub payment_method_type_v2: storage_enums::PaymentMethod,
pub connector_payment_id: Option<ConnectorTransactionId>,
pub payment_method_subtype: storage_enums::PaymentMethodType,
pub routing_result: Option<serde_json::Value>,
pub authentication_applied: Option<common_enums::AuthenticationType>,
pub external_reference_id: Option<String>,
pub tax_on_surcharge: Option<MinorUnit>,
pub payment_method_billing_address: Option<common_utils::encryption::Encryption>,
pub redirection_data: Option<RedirectForm>,
pub connector_payment_data: Option<String>,
pub connector_token_details: Option<ConnectorTokenDetails>,
pub id: id_type::GlobalAttemptId,
pub feature_metadata: Option<PaymentAttemptFeatureMetadata>,
/// This field can be returned for both approved and refused Mastercard payments.
/// This code provides additional information about the type of transaction or the reason why the payment failed.
/// If the payment failed, the network advice code gives guidance on if and when you can retry the payment.
pub network_advice_code: Option<String>,
/// For card errors resulting from a card issuer decline, a brand specific 2, 3, or 4 digit code which indicates the reason the authorization failed.
pub network_decline_code: Option<String>,
/// A string indicating how to proceed with an network error if payment gateway provide one. This is used to understand the network error code better.
pub network_error_message: Option<String>,
}
#[cfg(feature = "v1")]
#[derive(
Clone, Debug, Eq, PartialEq, Identifiable, Queryable, Serialize, Deserialize, Selectable,
)]
#[diesel(table_name = payment_attempt, primary_key(attempt_id, merchant_id), check_for_backend(diesel::pg::Pg))]
pub struct PaymentAttempt {
pub payment_id: id_type::PaymentId,
pub merchant_id: id_type::MerchantId,
pub attempt_id: String,
pub status: storage_enums::AttemptStatus,
pub amount: MinorUnit,
pub currency: Option<storage_enums::Currency>,
pub save_to_locker: Option<bool>,
pub connector: Option<String>,
pub error_message: Option<String>,
pub offer_amount: Option<MinorUnit>,
pub surcharge_amount: Option<MinorUnit>,
pub tax_amount: Option<MinorUnit>,
pub payment_method_id: Option<String>,
pub payment_method: Option<storage_enums::PaymentMethod>,
pub connector_transaction_id: Option<ConnectorTransactionId>,
pub capture_method: Option<storage_enums::CaptureMethod>,
#[serde(default, with = "common_utils::custom_serde::iso8601::option")]
pub capture_on: Option<PrimitiveDateTime>,
pub confirm: bool,
pub authentication_type: Option<storage_enums::AuthenticationType>,
#[serde(with = "common_utils::custom_serde::iso8601")]
pub created_at: PrimitiveDateTime,
#[serde(with = "common_utils::custom_serde::iso8601")]
pub modified_at: PrimitiveDateTime,
#[serde(default, with = "common_utils::custom_serde::iso8601::option")]
pub last_synced: Option<PrimitiveDateTime>,
pub cancellation_reason: Option<String>,
pub amount_to_capture: Option<MinorUnit>,
pub mandate_id: Option<String>,
pub browser_info: Option<serde_json::Value>,
pub error_code: Option<String>,
pub payment_token: Option<String>,
pub connector_metadata: Option<serde_json::Value>,
pub payment_experience: Option<storage_enums::PaymentExperience>,
pub payment_method_type: Option<storage_enums::PaymentMethodType>,
pub payment_method_data: Option<serde_json::Value>,
pub business_sub_label: Option<String>,
pub straight_through_algorithm: Option<serde_json::Value>,
pub preprocessing_step_id: Option<String>,
// providing a location to store mandate details intermediately for transaction
pub mandate_details: Option<storage_enums::MandateDataType>,
pub error_reason: Option<String>,
pub multiple_capture_count: Option<i16>,
// reference to the payment at connector side
pub connector_response_reference_id: Option<String>,
pub amount_capturable: MinorUnit,
pub updated_by: String,
pub merchant_connector_id: Option<id_type::MerchantConnectorAccountId>,
pub authentication_data: Option<serde_json::Value>,
pub encoded_data: Option<String>,
pub unified_code: Option<String>,
pub unified_message: Option<String>,
pub net_amount: Option<MinorUnit>,
pub external_three_ds_authentication_attempted: Option<bool>,
pub authentication_connector: Option<String>,
pub authentication_id: Option<String>,
pub mandate_data: Option<storage_enums::MandateDetails>,
pub fingerprint_id: Option<String>,
pub payment_method_billing_address_id: Option<String>,
pub charge_id: Option<String>,
pub client_source: Option<String>,
pub client_version: Option<String>,
pub customer_acceptance: Option<pii::SecretSerdeValue>,
pub profile_id: id_type::ProfileId,
pub organization_id: id_type::OrganizationId,
pub card_network: Option<String>,
pub shipping_cost: Option<MinorUnit>,
pub order_tax_amount: Option<MinorUnit>,
/// INFO: This field is deprecated and replaced by processor_transaction_data
pub connector_transaction_data: Option<String>,
pub connector_mandate_detail: Option<ConnectorMandateReferenceId>,
pub request_extended_authorization: Option<RequestExtendedAuthorizationBool>,
pub extended_authorization_applied: Option<ExtendedAuthorizationAppliedBool>,
pub capture_before: Option<PrimitiveDateTime>,
pub processor_transaction_data: Option<String>,
pub card_discovery: Option<storage_enums::CardDiscovery>,
pub charges: Option<common_types::payments::ConnectorChargeResponseData>,
pub issuer_error_code: Option<String>,
pub issuer_error_message: Option<String>,
}
#[cfg(feature = "v1")]
impl ConnectorTransactionIdTrait for PaymentAttempt {
fn get_optional_connector_transaction_id(&self) -> Option<&String> {
match self
.connector_transaction_id
.as_ref()
.map(|txn_id| txn_id.get_txn_id(self.processor_transaction_data.as_ref()))
.transpose()
{
Ok(txn_id) => txn_id,
// In case hashed data is missing from DB, use the hashed ID as connector transaction ID
Err(_) => self
.connector_transaction_id
.as_ref()
.map(|txn_id| txn_id.get_id()),
}
}
}
#[cfg(feature = "v2")]
impl ConnectorTransactionIdTrait for PaymentAttempt {
fn get_optional_connector_transaction_id(&self) -> Option<&String> {
match self
.connector_payment_id
.as_ref()
.map(|txn_id| txn_id.get_txn_id(self.connector_payment_data.as_ref()))
.transpose()
{
Ok(txn_id) => txn_id,
// In case hashed data is missing from DB, use the hashed ID as connector payment ID
Err(_) => self
.connector_payment_id
.as_ref()
.map(|txn_id| txn_id.get_id()),
}
}
}
#[cfg(feature = "v2")]
#[derive(
Clone, Debug, PartialEq, Eq, serde::Deserialize, serde::Serialize, diesel::AsExpression,
)]
#[diesel(sql_type = diesel::sql_types::Jsonb)]
pub struct ConnectorTokenDetails {
pub connector_mandate_id: Option<String>,
pub connector_token_request_reference_id: Option<String>,
}
#[cfg(feature = "v2")]
common_utils::impl_to_sql_from_sql_json!(ConnectorTokenDetails);
#[cfg(feature = "v2")]
impl ConnectorTokenDetails {
pub fn get_connector_token_request_reference_id(&self) -> Option<String> {
self.connector_token_request_reference_id.clone()
}
}
#[derive(Clone, Debug, Eq, PartialEq, Queryable, Serialize, Deserialize)]
pub struct PaymentListFilters {
pub connector: Vec<String>,
pub currency: Vec<storage_enums::Currency>,
pub status: Vec<storage_enums::IntentStatus>,
pub payment_method: Vec<storage_enums::PaymentMethod>,
}
#[cfg(feature = "v2")]
#[derive(Clone, Debug, Insertable, router_derive::DebugAsDisplay, Serialize, Deserialize)]
#[diesel(table_name = payment_attempt)]
pub struct PaymentAttemptNew {
pub payment_id: id_type::GlobalPaymentId,
pub merchant_id: id_type::MerchantId,
pub status: storage_enums::AttemptStatus,
pub error_message: Option<String>,
pub surcharge_amount: Option<MinorUnit>,
pub tax_on_surcharge: Option<MinorUnit>,
pub payment_method_id: Option<id_type::GlobalPaymentMethodId>,
pub authentication_type: storage_enums::AuthenticationType,
#[serde(with = "common_utils::custom_serde::iso8601")]
pub created_at: PrimitiveDateTime,
#[serde(with = "common_utils::custom_serde::iso8601")]
pub modified_at: PrimitiveDateTime,
#[serde(default, with = "common_utils::custom_serde::iso8601::option")]
pub last_synced: Option<PrimitiveDateTime>,
pub cancellation_reason: Option<String>,
pub amount_to_capture: Option<MinorUnit>,
pub browser_info: Option<common_utils::types::BrowserInformation>,
pub payment_token: Option<String>,
pub error_code: Option<String>,
pub connector_metadata: Option<pii::SecretSerdeValue>,
pub payment_experience: Option<storage_enums::PaymentExperience>,
pub payment_method_data: Option<pii::SecretSerdeValue>,
pub preprocessing_step_id: Option<String>,
pub error_reason: Option<String>,
pub connector_response_reference_id: Option<String>,
pub multiple_capture_count: Option<i16>,
pub amount_capturable: MinorUnit,
pub updated_by: String,
pub merchant_connector_id: Option<id_type::MerchantConnectorAccountId>,
pub redirection_data: Option<RedirectForm>,
pub encoded_data: Option<masking::Secret<String>>,
pub unified_code: Option<String>,
pub unified_message: Option<String>,
pub net_amount: MinorUnit,
pub external_three_ds_authentication_attempted: Option<bool>,
pub authentication_connector: Option<String>,
pub authentication_id: Option<String>,
pub fingerprint_id: Option<String>,
pub payment_method_billing_address: Option<common_utils::encryption::Encryption>,
pub client_source: Option<String>,
pub client_version: Option<String>,
pub customer_acceptance: Option<pii::SecretSerdeValue>,
pub profile_id: id_type::ProfileId,
pub organization_id: id_type::OrganizationId,
pub card_network: Option<String>,
pub shipping_cost: Option<MinorUnit>,
pub order_tax_amount: Option<MinorUnit>,
pub charges: Option<common_types::payments::ConnectorChargeResponseData>,
pub feature_metadata: Option<PaymentAttemptFeatureMetadata>,
pub payment_method_type_v2: storage_enums::PaymentMethod,
pub connector_payment_id: Option<ConnectorTransactionId>,
pub payment_method_subtype: storage_enums::PaymentMethodType,
pub id: id_type::GlobalAttemptId,
pub connector_token_details: Option<ConnectorTokenDetails>,
pub card_discovery: Option<storage_enums::CardDiscovery>,
pub request_extended_authorization: Option<RequestExtendedAuthorizationBool>,
pub extended_authorization_applied: Option<ExtendedAuthorizationAppliedBool>,
pub capture_before: Option<PrimitiveDateTime>,
pub connector: Option<String>,
pub network_decline_code: Option<String>,
pub network_advice_code: Option<String>,
pub network_error_message: Option<String>,
}
#[cfg(feature = "v1")]
#[derive(Clone, Debug, Insertable, router_derive::DebugAsDisplay, Serialize, Deserialize)]
#[diesel(table_name = payment_attempt)]
pub struct PaymentAttemptNew {
pub payment_id: id_type::PaymentId,
pub merchant_id: id_type::MerchantId,
pub attempt_id: String,
pub status: storage_enums::AttemptStatus,
pub amount: MinorUnit,
pub currency: Option<storage_enums::Currency>,
// pub auto_capture: Option<bool>,
pub save_to_locker: Option<bool>,
pub connector: Option<String>,
pub error_message: Option<String>,
pub offer_amount: Option<MinorUnit>,
pub surcharge_amount: Option<MinorUnit>,
pub tax_amount: Option<MinorUnit>,
pub payment_method_id: Option<String>,
pub payment_method: Option<storage_enums::PaymentMethod>,
pub capture_method: Option<storage_enums::CaptureMethod>,
#[serde(default, with = "common_utils::custom_serde::iso8601::option")]
pub capture_on: Option<PrimitiveDateTime>,
pub confirm: bool,
pub authentication_type: Option<storage_enums::AuthenticationType>,
#[serde(with = "common_utils::custom_serde::iso8601")]
pub created_at: PrimitiveDateTime,
#[serde(with = "common_utils::custom_serde::iso8601")]
pub modified_at: PrimitiveDateTime,
#[serde(default, with = "common_utils::custom_serde::iso8601::option")]
pub last_synced: Option<PrimitiveDateTime>,
pub cancellation_reason: Option<String>,
pub amount_to_capture: Option<MinorUnit>,
pub mandate_id: Option<String>,
pub browser_info: Option<serde_json::Value>,
pub payment_token: Option<String>,
pub error_code: Option<String>,
pub connector_metadata: Option<serde_json::Value>,
pub payment_experience: Option<storage_enums::PaymentExperience>,
pub payment_method_type: Option<storage_enums::PaymentMethodType>,
pub payment_method_data: Option<serde_json::Value>,
pub business_sub_label: Option<String>,
pub straight_through_algorithm: Option<serde_json::Value>,
pub preprocessing_step_id: Option<String>,
pub mandate_details: Option<storage_enums::MandateDataType>,
pub error_reason: Option<String>,
pub connector_response_reference_id: Option<String>,
pub multiple_capture_count: Option<i16>,
pub amount_capturable: MinorUnit,
pub updated_by: String,
pub merchant_connector_id: Option<id_type::MerchantConnectorAccountId>,
pub authentication_data: Option<serde_json::Value>,
pub encoded_data: Option<String>,
pub unified_code: Option<String>,
pub unified_message: Option<String>,
pub net_amount: Option<MinorUnit>,
pub external_three_ds_authentication_attempted: Option<bool>,
pub authentication_connector: Option<String>,
pub authentication_id: Option<String>,
pub mandate_data: Option<storage_enums::MandateDetails>,
pub fingerprint_id: Option<String>,
pub payment_method_billing_address_id: Option<String>,
pub client_source: Option<String>,
pub client_version: Option<String>,
pub customer_acceptance: Option<pii::SecretSerdeValue>,
pub profile_id: id_type::ProfileId,
pub organization_id: id_type::OrganizationId,
pub card_network: Option<String>,
pub shipping_cost: Option<MinorUnit>,
pub order_tax_amount: Option<MinorUnit>,
pub connector_mandate_detail: Option<ConnectorMandateReferenceId>,
pub request_extended_authorization: Option<RequestExtendedAuthorizationBool>,
pub extended_authorization_applied: Option<ExtendedAuthorizationAppliedBool>,
#[serde(default, with = "common_utils::custom_serde::iso8601::option")]
pub capture_before: Option<PrimitiveDateTime>,
pub card_discovery: Option<storage_enums::CardDiscovery>,
}
#[cfg(feature = "v1")]
#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum PaymentAttemptUpdate {
Update {
amount: MinorUnit,
currency: storage_enums::Currency,
status: storage_enums::AttemptStatus,
authentication_type: Option<storage_enums::AuthenticationType>,
payment_method: Option<storage_enums::PaymentMethod>,
payment_token: Option<String>,
payment_method_data: Option<serde_json::Value>,
payment_method_type: Option<storage_enums::PaymentMethodType>,
payment_experience: Option<storage_enums::PaymentExperience>,
business_sub_label: Option<String>,
amount_to_capture: Option<MinorUnit>,
capture_method: Option<storage_enums::CaptureMethod>,
surcharge_amount: Option<MinorUnit>,
tax_amount: Option<MinorUnit>,
fingerprint_id: Option<String>,
payment_method_billing_address_id: Option<String>,
updated_by: String,
},
UpdateTrackers {
payment_token: Option<String>,
connector: Option<String>,
straight_through_algorithm: Option<serde_json::Value>,
amount_capturable: Option<MinorUnit>,
surcharge_amount: Option<MinorUnit>,
tax_amount: Option<MinorUnit>,
updated_by: String,
merchant_connector_id: Option<id_type::MerchantConnectorAccountId>,
},
AuthenticationTypeUpdate {
authentication_type: storage_enums::AuthenticationType,
updated_by: String,
},
ConfirmUpdate {
amount: MinorUnit,
currency: storage_enums::Currency,
status: storage_enums::AttemptStatus,
authentication_type: Option<storage_enums::AuthenticationType>,
capture_method: Option<storage_enums::CaptureMethod>,
payment_method: Option<storage_enums::PaymentMethod>,
browser_info: Option<serde_json::Value>,
connector: Option<String>,
payment_token: Option<String>,
payment_method_data: Option<serde_json::Value>,
payment_method_type: Option<storage_enums::PaymentMethodType>,
payment_experience: Option<storage_enums::PaymentExperience>,
business_sub_label: Option<String>,
straight_through_algorithm: Option<serde_json::Value>,
error_code: Option<Option<String>>,
error_message: Option<Option<String>>,
amount_capturable: Option<MinorUnit>,
surcharge_amount: Option<MinorUnit>,
tax_amount: Option<MinorUnit>,
fingerprint_id: Option<String>,
updated_by: String,
merchant_connector_id: Option<id_type::MerchantConnectorAccountId>,
payment_method_id: Option<String>,
external_three_ds_authentication_attempted: Option<bool>,
authentication_connector: Option<String>,
authentication_id: Option<String>,
payment_method_billing_address_id: Option<String>,
client_source: Option<String>,
client_version: Option<String>,
customer_acceptance: Option<pii::SecretSerdeValue>,
shipping_cost: Option<MinorUnit>,
order_tax_amount: Option<MinorUnit>,
connector_mandate_detail: Option<ConnectorMandateReferenceId>,
card_discovery: Option<storage_enums::CardDiscovery>,
},
VoidUpdate {
status: storage_enums::AttemptStatus,
cancellation_reason: Option<String>,
updated_by: String,
},
PaymentMethodDetailsUpdate {
payment_method_id: Option<String>,
updated_by: String,
},
ConnectorMandateDetailUpdate {
connector_mandate_detail: Option<ConnectorMandateReferenceId>,
updated_by: String,
},
BlocklistUpdate {
status: storage_enums::AttemptStatus,
error_code: Option<Option<String>>,
error_message: Option<Option<String>>,
updated_by: String,
},
RejectUpdate {
status: storage_enums::AttemptStatus,
error_code: Option<Option<String>>,
error_message: Option<Option<String>>,
updated_by: String,
},
ResponseUpdate {
status: storage_enums::AttemptStatus,
connector: Option<String>,
connector_transaction_id: Option<String>,
authentication_type: Option<storage_enums::AuthenticationType>,
payment_method_id: Option<String>,
mandate_id: Option<String>,
connector_metadata: Option<serde_json::Value>,
payment_token: Option<String>,
error_code: Option<Option<String>>,
error_message: Option<Option<String>>,
error_reason: Option<Option<String>>,
connector_response_reference_id: Option<String>,
amount_capturable: Option<MinorUnit>,
updated_by: String,
authentication_data: Option<serde_json::Value>,
encoded_data: Option<String>,
unified_code: Option<Option<String>>,
unified_message: Option<Option<String>>,
capture_before: Option<PrimitiveDateTime>,
extended_authorization_applied: Option<ExtendedAuthorizationAppliedBool>,
payment_method_data: Option<serde_json::Value>,
connector_mandate_detail: Option<ConnectorMandateReferenceId>,
charges: Option<common_types::payments::ConnectorChargeResponseData>,
},
UnresolvedResponseUpdate {
status: storage_enums::AttemptStatus,
connector: Option<String>,
connector_transaction_id: Option<String>,
payment_method_id: Option<String>,
error_code: Option<Option<String>>,
error_message: Option<Option<String>>,
error_reason: Option<Option<String>>,
connector_response_reference_id: Option<String>,
updated_by: String,
},
StatusUpdate {
status: storage_enums::AttemptStatus,
updated_by: String,
},
ErrorUpdate {
connector: Option<String>,
status: storage_enums::AttemptStatus,
error_code: Option<Option<String>>,
error_message: Option<Option<String>>,
error_reason: Option<Option<String>>,
amount_capturable: Option<MinorUnit>,
updated_by: String,
unified_code: Option<Option<String>>,
unified_message: Option<Option<String>>,
connector_transaction_id: Option<String>,
payment_method_data: Option<serde_json::Value>,
authentication_type: Option<storage_enums::AuthenticationType>,
issuer_error_code: Option<String>,
issuer_error_message: Option<String>,
},
CaptureUpdate {
amount_to_capture: Option<MinorUnit>,
multiple_capture_count: Option<i16>,
updated_by: String,
},
AmountToCaptureUpdate {
status: storage_enums::AttemptStatus,
amount_capturable: MinorUnit,
updated_by: String,
},
PreprocessingUpdate {
status: storage_enums::AttemptStatus,
payment_method_id: Option<String>,
connector_metadata: Option<serde_json::Value>,
preprocessing_step_id: Option<String>,
connector_transaction_id: Option<String>,
connector_response_reference_id: Option<String>,
updated_by: String,
},
ConnectorResponse {
authentication_data: Option<serde_json::Value>,
encoded_data: Option<String>,
connector_transaction_id: Option<String>,
connector: Option<String>,
charges: Option<common_types::payments::ConnectorChargeResponseData>,
updated_by: String,
},
IncrementalAuthorizationAmountUpdate {
amount: MinorUnit,
amount_capturable: MinorUnit,
},
AuthenticationUpdate {
status: storage_enums::AttemptStatus,
external_three_ds_authentication_attempted: Option<bool>,
authentication_connector: Option<String>,
authentication_id: Option<String>,
updated_by: String,
},
ManualUpdate {
status: Option<storage_enums::AttemptStatus>,
error_code: Option<String>,
error_message: Option<String>,
error_reason: Option<String>,
updated_by: String,
unified_code: Option<String>,
unified_message: Option<String>,
connector_transaction_id: Option<String>,
},
PostSessionTokensUpdate {
updated_by: String,
connector_metadata: Option<serde_json::Value>,
},
}
#[cfg(feature = "v2")]
#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum PaymentAttemptUpdate {
// Update {
// amount: MinorUnit,
// currency: storage_enums::Currency,
// status: storage_enums::AttemptStatus,
// authentication_type: Option<storage_enums::AuthenticationType>,
// payment_method: Option<storage_enums::PaymentMethod>,
// payment_token: Option<String>,
// payment_method_data: Option<serde_json::Value>,
// payment_method_type: Option<storage_enums::PaymentMethodType>,
// payment_experience: Option<storage_enums::PaymentExperience>,
// business_sub_label: Option<String>,
// amount_to_capture: Option<MinorUnit>,
// capture_method: Option<storage_enums::CaptureMethod>,
// surcharge_amount: Option<MinorUnit>,
// tax_amount: Option<MinorUnit>,
// fingerprint_id: Option<String>,
// payment_method_billing_address_id: Option<String>,
// updated_by: String,
// },
// UpdateTrackers {
// payment_token: Option<String>,
// connector: Option<String>,
// straight_through_algorithm: Option<serde_json::Value>,
// amount_capturable: Option<MinorUnit>,
// surcharge_amount: Option<MinorUnit>,
// tax_amount: Option<MinorUnit>,
// updated_by: String,
// merchant_connector_id: Option<id_type::MerchantConnectorAccountId>,
// },
// AuthenticationTypeUpdate {
// authentication_type: storage_enums::AuthenticationType,
// updated_by: String,
// },
// ConfirmUpdate {
// amount: MinorUnit,
// currency: storage_enums::Currency,
// status: storage_enums::AttemptStatus,
// authentication_type: Option<storage_enums::AuthenticationType>,
// capture_method: Option<storage_enums::CaptureMethod>,
// payment_method: Option<storage_enums::PaymentMethod>,
// browser_info: Option<serde_json::Value>,
// connector: Option<String>,
// payment_token: Option<String>,
// payment_method_data: Option<serde_json::Value>,
// payment_method_type: Option<storage_enums::PaymentMethodType>,
// payment_experience: Option<storage_enums::PaymentExperience>,
// business_sub_label: Option<String>,
// straight_through_algorithm: Option<serde_json::Value>,
// error_code: Option<Option<String>>,
// error_message: Option<Option<String>>,
// amount_capturable: Option<MinorUnit>,
// surcharge_amount: Option<MinorUnit>,
// tax_amount: Option<MinorUnit>,
// fingerprint_id: Option<String>,
// updated_by: String,
// merchant_connector_id: Option<id_type::MerchantConnectorAccountId>,
// payment_method_id: Option<String>,
// external_three_ds_authentication_attempted: Option<bool>,
// authentication_connector: Option<String>,
// authentication_id: Option<String>,
// payment_method_billing_address_id: Option<String>,
// client_source: Option<String>,
// client_version: Option<String>,
// customer_acceptance: Option<pii::SecretSerdeValue>,
// },
// VoidUpdate {
// status: storage_enums::AttemptStatus,
// cancellation_reason: Option<String>,
// updated_by: String,
// },
// PaymentMethodDetailsUpdate {
// payment_method_id: Option<String>,
// updated_by: String,
// },
// ConnectorMandateDetailUpdate {
// connector_mandate_detail: Option<ConnectorMandateReferenceId>,
// updated_by: String,
// }
// BlocklistUpdate {
// status: storage_enums::AttemptStatus,
// error_code: Option<Option<String>>,
// error_message: Option<Option<String>>,
// updated_by: String,
// },
// RejectUpdate {
// status: storage_enums::AttemptStatus,
// error_code: Option<Option<String>>,
// error_message: Option<Option<String>>,
// updated_by: String,
// },
// ResponseUpdate {
// status: storage_enums::AttemptStatus,
// connector: Option<String>,
// connector_transaction_id: Option<String>,
// authentication_type: Option<storage_enums::AuthenticationType>,
// payment_method_id: Option<String>,
// mandate_id: Option<String>,
// connector_metadata: Option<serde_json::Value>,
// payment_token: Option<String>,
// error_code: Option<Option<String>>,
// error_message: Option<Option<String>>,
// error_reason: Option<Option<String>>,
// connector_response_reference_id: Option<String>,
// amount_capturable: Option<MinorUnit>,
// updated_by: String,
// authentication_data: Option<serde_json::Value>,
// encoded_data: Option<String>,
// unified_code: Option<Option<String>>,
// unified_message: Option<Option<String>>,
// payment_method_data: Option<serde_json::Value>,
// charge_id: Option<String>,
// },
// UnresolvedResponseUpdate {
// status: storage_enums::AttemptStatus,
// connector: Option<String>,
// connector_transaction_id: Option<String>,
// payment_method_id: Option<String>,
// error_code: Option<Option<String>>,
// error_message: Option<Option<String>>,
// error_reason: Option<Option<String>>,
// connector_response_reference_id: Option<String>,
// updated_by: String,
// },
// StatusUpdate {
// status: storage_enums::AttemptStatus,
// updated_by: String,
// },
// ErrorUpdate {
// connector: Option<String>,
// status: storage_enums::AttemptStatus,
// error_code: Option<Option<String>>,
// error_message: Option<Option<String>>,
// error_reason: Option<Option<String>>,
// amount_capturable: Option<MinorUnit>,
// updated_by: String,
// unified_code: Option<Option<String>>,
// unified_message: Option<Option<String>>,
// connector_transaction_id: Option<String>,
// payment_method_data: Option<serde_json::Value>,
// authentication_type: Option<storage_enums::AuthenticationType>,
// },
// CaptureUpdate {
// amount_to_capture: Option<MinorUnit>,
// multiple_capture_count: Option<MinorUnit>,
// updated_by: String,
// },
// AmountToCaptureUpdate {
// status: storage_enums::AttemptStatus,
// amount_capturable: MinorUnit,
// updated_by: String,
// },
// PreprocessingUpdate {
// status: storage_enums::AttemptStatus,
// payment_method_id: Option<String>,
// connector_metadata: Option<serde_json::Value>,
// preprocessing_step_id: Option<String>,
// connector_transaction_id: Option<String>,
// connector_response_reference_id: Option<String>,
// updated_by: String,
// },
// ConnectorResponse {
// authentication_data: Option<serde_json::Value>,
// encoded_data: Option<String>,
// connector_transaction_id: Option<String>,
// connector: Option<String>,
// charge_id: Option<String>,
// updated_by: String,
// },
// IncrementalAuthorizationAmountUpdate {
// amount: MinorUnit,
// amount_capturable: MinorUnit,
// },
// AuthenticationUpdate {
// status: storage_enums::AttemptStatus,
// external_three_ds_authentication_attempted: Option<bool>,
// authentication_connector: Option<String>,
// authentication_id: Option<String>,
// updated_by: String,
// },
// ManualUpdate {
// status: Option<storage_enums::AttemptStatus>,
// error_code: Option<String>,
// error_message: Option<String>,
// error_reason: Option<String>,
// updated_by: String,
// unified_code: Option<String>,
// unified_message: Option<String>,
// connector_transaction_id: Option<String>,
// },
}
// TODO: uncomment fields as and when required
#[cfg(feature = "v2")]
#[derive(Clone, Debug, AsChangeset, router_derive::DebugAsDisplay)]
#[diesel(table_name = payment_attempt)]
pub struct PaymentAttemptUpdateInternal {
pub status: Option<storage_enums::AttemptStatus>,
pub authentication_type: Option<storage_enums::AuthenticationType>,
pub error_message: Option<String>,
pub connector_payment_id: Option<String>,
// payment_method_id: Option<String>,
// cancellation_reason: Option<String>,
pub modified_at: PrimitiveDateTime,
pub browser_info: Option<serde_json::Value>,
// payment_token: Option<String>,
pub error_code: Option<String>,
pub connector_metadata: Option<pii::SecretSerdeValue>,
// payment_method_data: Option<serde_json::Value>,
// payment_experience: Option<storage_enums::PaymentExperience>,
// preprocessing_step_id: Option<String>,
pub error_reason: Option<String>,
// connector_response_reference_id: Option<String>,
// multiple_capture_count: Option<i16>,
// pub surcharge_amount: Option<MinorUnit>,
// tax_on_surcharge: Option<MinorUnit>,
pub amount_capturable: Option<MinorUnit>,
pub amount_to_capture: Option<MinorUnit>,
pub updated_by: String,
pub merchant_connector_id: Option<id_type::MerchantConnectorAccountId>,
pub connector: Option<String>,
pub redirection_data: Option<RedirectForm>,
// encoded_data: Option<String>,
pub unified_code: Option<Option<String>>,
pub unified_message: Option<Option<String>>,
// external_three_ds_authentication_attempted: Option<bool>,
// authentication_connector: Option<String>,
// authentication_id: Option<String>,
// fingerprint_id: Option<String>,
// charge_id: Option<String>,
// client_source: Option<String>,
// client_version: Option<String>,
// customer_acceptance: Option<pii::SecretSerdeValue>,
// card_network: Option<String>,
pub connector_token_details: Option<ConnectorTokenDetails>,
pub feature_metadata: Option<PaymentAttemptFeatureMetadata>,
pub network_decline_code: Option<String>,
pub network_advice_code: Option<String>,
pub network_error_message: Option<String>,
}
#[cfg(feature = "v1")]
#[derive(Clone, Debug, AsChangeset, router_derive::DebugAsDisplay)]
#[diesel(table_name = payment_attempt)]
pub struct PaymentAttemptUpdateInternal {
pub amount: Option<MinorUnit>,
pub net_amount: Option<MinorUnit>,
pub currency: Option<storage_enums::Currency>,
pub status: Option<storage_enums::AttemptStatus>,
pub connector_transaction_id: Option<ConnectorTransactionId>,
pub amount_to_capture: Option<MinorUnit>,
pub connector: Option<Option<String>>,
pub authentication_type: Option<storage_enums::AuthenticationType>,
pub payment_method: Option<storage_enums::PaymentMethod>,
pub error_message: Option<Option<String>>,
pub payment_method_id: Option<String>,
pub cancellation_reason: Option<String>,
pub modified_at: PrimitiveDateTime,
pub mandate_id: Option<String>,
pub browser_info: Option<serde_json::Value>,
pub payment_token: Option<String>,
pub error_code: Option<Option<String>>,
pub connector_metadata: Option<serde_json::Value>,
pub payment_method_data: Option<serde_json::Value>,
pub payment_method_type: Option<storage_enums::PaymentMethodType>,
pub payment_experience: Option<storage_enums::PaymentExperience>,
pub business_sub_label: Option<String>,
pub straight_through_algorithm: Option<serde_json::Value>,
pub preprocessing_step_id: Option<String>,
pub error_reason: Option<Option<String>>,
pub capture_method: Option<storage_enums::CaptureMethod>,
pub connector_response_reference_id: Option<String>,
pub multiple_capture_count: Option<i16>,
pub surcharge_amount: Option<MinorUnit>,
pub tax_amount: Option<MinorUnit>,
pub amount_capturable: Option<MinorUnit>,
pub updated_by: String,
pub merchant_connector_id: Option<Option<id_type::MerchantConnectorAccountId>>,
pub authentication_data: Option<serde_json::Value>,
pub encoded_data: Option<String>,
pub unified_code: Option<Option<String>>,
pub unified_message: Option<Option<String>>,
pub external_three_ds_authentication_attempted: Option<bool>,
pub authentication_connector: Option<String>,
pub authentication_id: Option<String>,
pub fingerprint_id: Option<String>,
pub payment_method_billing_address_id: Option<String>,
pub client_source: Option<String>,
pub client_version: Option<String>,
pub customer_acceptance: Option<pii::SecretSerdeValue>,
pub card_network: Option<String>,
pub capture_before: Option<PrimitiveDateTime>,
pub extended_authorization_applied: Option<ExtendedAuthorizationAppliedBool>,
pub shipping_cost: Option<MinorUnit>,
pub order_tax_amount: Option<MinorUnit>,
pub connector_mandate_detail: Option<ConnectorMandateReferenceId>,
pub processor_transaction_data: Option<String>,
pub card_discovery: Option<common_enums::CardDiscovery>,
pub charges: Option<common_types::payments::ConnectorChargeResponseData>,
pub issuer_error_code: Option<String>,
pub issuer_error_message: Option<String>,
}
#[cfg(feature = "v1")]
impl PaymentAttemptUpdateInternal {
pub fn populate_derived_fields(self, source: &PaymentAttempt) -> Self {
let mut update_internal = self;
update_internal.net_amount = Some(
update_internal.amount.unwrap_or(source.amount)
+ update_internal
.surcharge_amount
.or(source.surcharge_amount)
.unwrap_or(MinorUnit::new(0))
+ update_internal
.tax_amount
.or(source.tax_amount)
.unwrap_or(MinorUnit::new(0))
+ update_internal
.shipping_cost
.or(source.shipping_cost)
.unwrap_or(MinorUnit::new(0))
+ update_internal
.order_tax_amount
.or(source.order_tax_amount)
.unwrap_or(MinorUnit::new(0)),
);
update_internal.card_network = update_internal
.payment_method_data
.as_ref()
.and_then(|data| data.as_object())
.and_then(|card| card.get("card"))
.and_then(|data| data.as_object())
.and_then(|card| card.get("card_network"))
.and_then(|network| network.as_str())
.map(|network| network.to_string());
update_internal
}
}
#[cfg(feature = "v2")]
impl PaymentAttemptUpdate {
pub fn apply_changeset(self, source: PaymentAttempt) -> PaymentAttempt {
todo!()
// let PaymentAttemptUpdateInternal {
// net_amount,
// status,
// authentication_type,
// error_message,
// payment_method_id,
// cancellation_reason,
// modified_at: _,
// browser_info,
// payment_token,
// error_code,
// connector_metadata,
// payment_method_data,
// payment_experience,
// straight_through_algorithm,
// preprocessing_step_id,
// error_reason,
// connector_response_reference_id,
// multiple_capture_count,
// surcharge_amount,
// tax_amount,
// amount_capturable,
// updated_by,
// merchant_connector_id,
// authentication_data,
// encoded_data,
// unified_code,
// unified_message,
// external_three_ds_authentication_attempted,
// authentication_connector,
// authentication_id,
// payment_method_billing_address_id,
// fingerprint_id,
// charge_id,
// client_source,
// client_version,
// customer_acceptance,
// card_network,
// } = PaymentAttemptUpdateInternal::from(self).populate_derived_fields(&source);
// PaymentAttempt {
// net_amount: net_amount.or(source.net_amount),
// status: status.unwrap_or(source.status),
// authentication_type: authentication_type.or(source.authentication_type),
// error_message: error_message.unwrap_or(source.error_message),
// payment_method_id: payment_method_id.or(source.payment_method_id),
// cancellation_reason: cancellation_reason.or(source.cancellation_reason),
// modified_at: common_utils::date_time::now(),
// browser_info: browser_info.or(source.browser_info),
// payment_token: payment_token.or(source.payment_token),
// error_code: error_code.unwrap_or(source.error_code),
// connector_metadata: connector_metadata.or(source.connector_metadata),
// payment_method_data: payment_method_data.or(source.payment_method_data),
// payment_experience: payment_experience.or(source.payment_experience),
// straight_through_algorithm: straight_through_algorithm
// .or(source.straight_through_algorithm),
// preprocessing_step_id: preprocessing_step_id.or(source.preprocessing_step_id),
// error_reason: error_reason.unwrap_or(source.error_reason),
// connector_response_reference_id: connector_response_reference_id
// .or(source.connector_response_reference_id),
// multiple_capture_count: multiple_capture_count.or(source.multiple_capture_count),
// surcharge_amount: surcharge_amount.or(source.surcharge_amount),
// tax_amount: tax_amount.or(source.tax_amount),
// amount_capturable: amount_capturable.unwrap_or(source.amount_capturable),
// updated_by,
// merchant_connector_id: merchant_connector_id.unwrap_or(source.merchant_connector_id),
// authentication_data: authentication_data.or(source.authentication_data),
// encoded_data: encoded_data.or(source.encoded_data),
// unified_code: unified_code.unwrap_or(source.unified_code),
// unified_message: unified_message.unwrap_or(source.unified_message),
// external_three_ds_authentication_attempted: external_three_ds_authentication_attempted
// .or(source.external_three_ds_authentication_attempted),
// authentication_connector: authentication_connector.or(source.authentication_connector),
// authentication_id: authentication_id.or(source.authentication_id),
// payment_method_billing_address_id: payment_method_billing_address_id
// .or(source.payment_method_billing_address_id),
// fingerprint_id: fingerprint_id.or(source.fingerprint_id),
// charge_id: charge_id.or(source.charge_id),
// client_source: client_source.or(source.client_source),
// client_version: client_version.or(source.client_version),
// customer_acceptance: customer_acceptance.or(source.customer_acceptance),
// card_network: card_network.or(source.card_network),
// ..source
// }
}
}
#[cfg(feature = "v1")]
impl PaymentAttemptUpdate {
pub fn apply_changeset(self, source: PaymentAttempt) -> PaymentAttempt {
let PaymentAttemptUpdateInternal {
amount,
net_amount,
currency,
status,
connector_transaction_id,
amount_to_capture,
connector,
authentication_type,
payment_method,
error_message,
payment_method_id,
cancellation_reason,
modified_at: _,
mandate_id,
browser_info,
payment_token,
error_code,
connector_metadata,
payment_method_data,
payment_method_type,
payment_experience,
business_sub_label,
straight_through_algorithm,
preprocessing_step_id,
error_reason,
capture_method,
connector_response_reference_id,
multiple_capture_count,
surcharge_amount,
tax_amount,
amount_capturable,
updated_by,
merchant_connector_id,
authentication_data,
encoded_data,
unified_code,
unified_message,
external_three_ds_authentication_attempted,
authentication_connector,
authentication_id,
payment_method_billing_address_id,
fingerprint_id,
client_source,
client_version,
customer_acceptance,
card_network,
shipping_cost,
order_tax_amount,
processor_transaction_data,
connector_mandate_detail,
capture_before,
extended_authorization_applied,
card_discovery,
charges,
issuer_error_code,
issuer_error_message,
} = PaymentAttemptUpdateInternal::from(self).populate_derived_fields(&source);
PaymentAttempt {
amount: amount.unwrap_or(source.amount),
net_amount: net_amount.or(source.net_amount),
currency: currency.or(source.currency),
status: status.unwrap_or(source.status),
connector_transaction_id: connector_transaction_id.or(source.connector_transaction_id),
amount_to_capture: amount_to_capture.or(source.amount_to_capture),
connector: connector.unwrap_or(source.connector),
authentication_type: authentication_type.or(source.authentication_type),
payment_method: payment_method.or(source.payment_method),
error_message: error_message.unwrap_or(source.error_message),
payment_method_id: payment_method_id.or(source.payment_method_id),
cancellation_reason: cancellation_reason.or(source.cancellation_reason),
modified_at: common_utils::date_time::now(),
mandate_id: mandate_id.or(source.mandate_id),
browser_info: browser_info.or(source.browser_info),
payment_token: payment_token.or(source.payment_token),
error_code: error_code.unwrap_or(source.error_code),
connector_metadata: connector_metadata.or(source.connector_metadata),
payment_method_data: payment_method_data.or(source.payment_method_data),
payment_method_type: payment_method_type.or(source.payment_method_type),
payment_experience: payment_experience.or(source.payment_experience),
business_sub_label: business_sub_label.or(source.business_sub_label),
straight_through_algorithm: straight_through_algorithm
.or(source.straight_through_algorithm),
preprocessing_step_id: preprocessing_step_id.or(source.preprocessing_step_id),
error_reason: error_reason.unwrap_or(source.error_reason),
capture_method: capture_method.or(source.capture_method),
connector_response_reference_id: connector_response_reference_id
.or(source.connector_response_reference_id),
multiple_capture_count: multiple_capture_count.or(source.multiple_capture_count),
surcharge_amount: surcharge_amount.or(source.surcharge_amount),
tax_amount: tax_amount.or(source.tax_amount),
amount_capturable: amount_capturable.unwrap_or(source.amount_capturable),
updated_by,
merchant_connector_id: merchant_connector_id.unwrap_or(source.merchant_connector_id),
authentication_data: authentication_data.or(source.authentication_data),
encoded_data: encoded_data.or(source.encoded_data),
unified_code: unified_code.unwrap_or(source.unified_code),
unified_message: unified_message.unwrap_or(source.unified_message),
external_three_ds_authentication_attempted: external_three_ds_authentication_attempted
.or(source.external_three_ds_authentication_attempted),
authentication_connector: authentication_connector.or(source.authentication_connector),
authentication_id: authentication_id.or(source.authentication_id),
payment_method_billing_address_id: payment_method_billing_address_id
.or(source.payment_method_billing_address_id),
fingerprint_id: fingerprint_id.or(source.fingerprint_id),
client_source: client_source.or(source.client_source),
client_version: client_version.or(source.client_version),
customer_acceptance: customer_acceptance.or(source.customer_acceptance),
card_network: card_network.or(source.card_network),
shipping_cost: shipping_cost.or(source.shipping_cost),
order_tax_amount: order_tax_amount.or(source.order_tax_amount),
processor_transaction_data: processor_transaction_data
.or(source.processor_transaction_data),
connector_mandate_detail: connector_mandate_detail.or(source.connector_mandate_detail),
capture_before: capture_before.or(source.capture_before),
extended_authorization_applied: extended_authorization_applied
.or(source.extended_authorization_applied),
card_discovery: card_discovery.or(source.card_discovery),
charges: charges.or(source.charges),
issuer_error_code: issuer_error_code.or(source.issuer_error_code),
issuer_error_message: issuer_error_message.or(source.issuer_error_message),
..source
}
}
}
#[cfg(feature = "v2")]
impl From<PaymentAttemptUpdate> for PaymentAttemptUpdateInternal {
fn from(payment_attempt_update: PaymentAttemptUpdate) -> Self {
todo!()
// match payment_attempt_update {
// PaymentAttemptUpdate::Update {
// amount,
// currency,
// status,
// // connector_transaction_id,
// authentication_type,
// payment_method,
// payment_token,
// payment_method_data,
// payment_method_type,
// payment_experience,
// business_sub_label,
// amount_to_capture,
// capture_method,
// surcharge_amount,
// tax_amount,
// fingerprint_id,
// updated_by,
// payment_method_billing_address_id,
// } => Self {
// status: Some(status),
// // connector_transaction_id,
// authentication_type,
// payment_token,
// modified_at: common_utils::date_time::now(),
// payment_method_data,
// payment_experience,
// surcharge_amount,
// tax_amount,
// fingerprint_id,
// payment_method_billing_address_id,
// updated_by,
// net_amount: None,
// error_message: None,
// payment_method_id: None,
// cancellation_reason: None,
// browser_info: None,
// error_code: None,
// connector_metadata: None,
// straight_through_algorithm: None,
// preprocessing_step_id: None,
// error_reason: None,
// connector_response_reference_id: None,
// multiple_capture_count: None,
// amount_capturable: None,
// merchant_connector_id: None,
// authentication_data: None,
// encoded_data: None,
// unified_code: None,
// unified_message: None,
// external_three_ds_authentication_attempted: None,
// authentication_connector: None,
// authentication_id: None,
// charge_id: None,
// client_source: None,
// client_version: None,
// customer_acceptance: None,
// card_network: None,
// },
// PaymentAttemptUpdate::AuthenticationTypeUpdate {
// authentication_type,
// updated_by,
// } => Self {
// authentication_type: Some(authentication_type),
// modified_at: common_utils::date_time::now(),
// updated_by,
// net_amount: None,
// status: None,
// error_message: None,
// payment_method_id: None,
// cancellation_reason: None,
// browser_info: None,
// payment_token: None,
// error_code: None,
// connector_metadata: None,
// payment_method_data: None,
// payment_experience: None,
// straight_through_algorithm: None,
// preprocessing_step_id: None,
// error_reason: None,
// connector_response_reference_id: None,
// multiple_capture_count: None,
// surcharge_amount: None,
// tax_amount: None,
// amount_capturable: None,
// merchant_connector_id: None,
// authentication_data: None,
// encoded_data: None,
// unified_code: None,
// unified_message: None,
// external_three_ds_authentication_attempted: None,
// authentication_connector: None,
// authentication_id: None,
// fingerprint_id: None,
// payment_method_billing_address_id: None,
// charge_id: None,
// client_source: None,
// client_version: None,
// customer_acceptance: None,
// card_network: None,
// },
// PaymentAttemptUpdate::ConfirmUpdate {
// amount,
// currency,
// authentication_type,
// capture_method,
// status,
// payment_method,
// browser_info,
// connector,
// payment_token,
// payment_method_data,
// payment_method_type,
// payment_experience,
// business_sub_label,
// straight_through_algorithm,
// error_code,
// error_message,
// amount_capturable,
// updated_by,
// merchant_connector_id,
// surcharge_amount,
// tax_amount,
// external_three_ds_authentication_attempted,
// authentication_connector,
// authentication_id,
// payment_method_billing_address_id,
// fingerprint_id,
// payment_method_id,
// client_source,
// client_version,
// customer_acceptance,
// } => Self {
// authentication_type,
// status: Some(status),
// modified_at: common_utils::date_time::now(),
// browser_info,
// payment_token,
// payment_method_data,
// payment_experience,
// straight_through_algorithm,
// error_code,
// error_message,
// amount_capturable,
// updated_by,
// merchant_connector_id: merchant_connector_id.map(Some),
// surcharge_amount,
// tax_amount,
// external_three_ds_authentication_attempted,
// authentication_connector,
// authentication_id,
// payment_method_billing_address_id,
// fingerprint_id,
// payment_method_id,
// client_source,
// client_version,
// customer_acceptance,
// net_amount: None,
// cancellation_reason: None,
// connector_metadata: None,
// preprocessing_step_id: None,
// error_reason: None,
// connector_response_reference_id: None,
// multiple_capture_count: None,
// authentication_data: None,
// encoded_data: None,
// unified_code: None,
// unified_message: None,
// charge_id: None,
// card_network: None,
// },
// PaymentAttemptUpdate::VoidUpdate {
// status,
// cancellation_reason,
// updated_by,
// } => Self {
// status: Some(status),
// cancellation_reason,
// modified_at: common_utils::date_time::now(),
// updated_by,
// net_amount: None,
// authentication_type: None,
// error_message: None,
// payment_method_id: None,
// browser_info: None,
// payment_token: None,
// error_code: None,
// connector_metadata: None,
// payment_method_data: None,
// payment_experience: None,
// straight_through_algorithm: None,
// preprocessing_step_id: None,
// error_reason: None,
// connector_response_reference_id: None,
// multiple_capture_count: None,
// surcharge_amount: None,
// tax_amount: None,
// amount_capturable: None,
// merchant_connector_id: None,
// authentication_data: None,
// encoded_data: None,
// unified_code: None,
// unified_message: None,
// external_three_ds_authentication_attempted: None,
// authentication_connector: None,
// authentication_id: None,
// fingerprint_id: None,
// payment_method_billing_address_id: None,
// charge_id: None,
// client_source: None,
// client_version: None,
// customer_acceptance: None,
// card_network: None,
// },
// PaymentAttemptUpdate::RejectUpdate {
// status,
// error_code,
// error_message,
// updated_by,
// } => Self {
// status: Some(status),
// modified_at: common_utils::date_time::now(),
// error_code,
// error_message,
// updated_by,
// net_amount: None,
// authentication_type: None,
// payment_method_id: None,
// cancellation_reason: None,
// browser_info: None,
// payment_token: None,
// connector_metadata: None,
// payment_method_data: None,
// payment_experience: None,
// straight_through_algorithm: None,
// preprocessing_step_id: None,
// error_reason: None,
// connector_response_reference_id: None,
// multiple_capture_count: None,
// surcharge_amount: None,
// tax_amount: None,
// amount_capturable: None,
// merchant_connector_id: None,
// authentication_data: None,
// encoded_data: None,
// unified_code: None,
// unified_message: None,
// external_three_ds_authentication_attempted: None,
// authentication_connector: None,
// authentication_id: None,
// fingerprint_id: None,
// payment_method_billing_address_id: None,
// charge_id: None,
// client_source: None,
// client_version: None,
// customer_acceptance: None,
// card_network: None,
// },
// PaymentAttemptUpdate::BlocklistUpdate {
// status,
// error_code,
// error_message,
// updated_by,
// } => Self {
// status: Some(status),
// modified_at: common_utils::date_time::now(),
// error_code,
// error_message,
// updated_by,
// merchant_connector_id: Some(None),
// net_amount: None,
// authentication_type: None,
// payment_method_id: None,
// cancellation_reason: None,
// browser_info: None,
// payment_token: None,
// connector_metadata: None,
// payment_method_data: None,
// payment_experience: None,
// straight_through_algorithm: None,
// preprocessing_step_id: None,
// error_reason: None,
// connector_response_reference_id: None,
// multiple_capture_count: None,
// surcharge_amount: None,
// tax_amount: None,
// amount_capturable: None,
// authentication_data: None,
// encoded_data: None,
// unified_code: None,
// unified_message: None,
// external_three_ds_authentication_attempted: None,
// authentication_connector: None,
// authentication_id: None,
// fingerprint_id: None,
// payment_method_billing_address_id: None,
// charge_id: None,
// client_source: None,
// client_version: None,
// customer_acceptance: None,
// card_network: None,
// },
// PaymentAttemptUpdate::ConnectorMandateDetailUpdate {
// connector_mandate_detail,
// updated_by,
// } => Self {
// payment_method_id: None,
// modified_at: common_utils::date_time::now(),
// updated_by,
// amount: None,
// net_amount: None,
// currency: None,
// status: None,
// connector_transaction_id: None,
// amount_to_capture: None,
// connector: None,
// authentication_type: None,
// payment_method: None,
// error_message: None,
// cancellation_reason: None,
// mandate_id: None,
// browser_info: None,
// payment_token: None,
// error_code: None,
// connector_metadata: None,
// payment_method_data: None,
// payment_method_type: None,
// payment_experience: None,
// business_sub_label: None,
// straight_through_algorithm: None,
// preprocessing_step_id: None,
// error_reason: None,
// capture_method: None,
// connector_response_reference_id: None,
// multiple_capture_count: None,
// surcharge_amount: None,
// tax_amount: None,
// amount_capturable: None,
// merchant_connector_id: None,
// authentication_data: None,
// encoded_data: None,
// unified_code: None,
// unified_message: None,
// external_three_ds_authentication_attempted: None,
// authentication_connector: None,
// authentication_id: None,
// fingerprint_id: None,
// payment_method_billing_address_id: None,
// charge_id: None,
// client_source: None,
// client_version: None,
// customer_acceptance: None,
// card_network: None,
// shipping_cost: None,
// order_tax_amount: None,
// processor_transaction_data: None,
// connector_mandate_detail,
// },
// PaymentAttemptUpdate::ConnectorMandateDetailUpdate {
// payment_method_id,
// updated_by,
// } => Self {
// payment_method_id,
// modified_at: common_utils::date_time::now(),
// updated_by,
// net_amount: None,
// status: None,
// authentication_type: None,
// error_message: None,
// cancellation_reason: None,
// browser_info: None,
// payment_token: None,
// error_code: None,
// connector_metadata: None,
// payment_method_data: None,
// payment_experience: None,
// straight_through_algorithm: None,
// preprocessing_step_id: None,
// error_reason: None,
// connector_response_reference_id: None,
// multiple_capture_count: None,
// surcharge_amount: None,
// tax_amount: None,
// amount_capturable: None,
// merchant_connector_id: None,
// authentication_data: None,
// encoded_data: None,
// unified_code: None,
// unified_message: None,
// external_three_ds_authentication_attempted: None,
// authentication_connector: None,
// authentication_id: None,
// fingerprint_id: None,
// payment_method_billing_address_id: None,
// charge_id: None,
// client_source: None,
// client_version: None,
// customer_acceptance: None,
// card_network: None,
// },
// PaymentAttemptUpdate::ResponseUpdate {
// status,
// connector,
// connector_transaction_id,
// authentication_type,
// payment_method_id,
// mandate_id,
// connector_metadata,
// payment_token,
// error_code,
// error_message,
// error_reason,
// connector_response_reference_id,
// amount_capturable,
// updated_by,
// authentication_data,
// encoded_data,
// unified_code,
// unified_message,
// payment_method_data,
// charge_id,
// } => Self {
// status: Some(status),
// authentication_type,
// payment_method_id,
// modified_at: common_utils::date_time::now(),
// connector_metadata,
// error_code,
// error_message,
// payment_token,
// error_reason,
// connector_response_reference_id,
// amount_capturable,
// updated_by,
// authentication_data,
// encoded_data,
// unified_code,
// unified_message,
// payment_method_data,
// charge_id,
// net_amount: None,
// cancellation_reason: None,
// browser_info: None,
// payment_experience: None,
// straight_through_algorithm: None,
// preprocessing_step_id: None,
// multiple_capture_count: None,
// surcharge_amount: None,
// tax_amount: None,
// merchant_connector_id: None,
// external_three_ds_authentication_attempted: None,
// authentication_connector: None,
// authentication_id: None,
// fingerprint_id: None,
// payment_method_billing_address_id: None,
// client_source: None,
// client_version: None,
// customer_acceptance: None,
// card_network: None,
// },
// PaymentAttemptUpdate::ErrorUpdate {
// connector,
// status,
// error_code,
// error_message,
// error_reason,
// amount_capturable,
// updated_by,
// unified_code,
// unified_message,
// connector_transaction_id,
// payment_method_data,
// authentication_type,
// } => Self {
// status: Some(status),
// error_message,
// error_code,
// modified_at: common_utils::date_time::now(),
// error_reason,
// amount_capturable,
// updated_by,
// unified_code,
// unified_message,
// payment_method_data,
// authentication_type,
// net_amount: None,
// payment_method_id: None,
// cancellation_reason: None,
// browser_info: None,
// payment_token: None,
// connector_metadata: None,
// payment_experience: None,
// straight_through_algorithm: None,
// preprocessing_step_id: None,
// connector_response_reference_id: None,
// multiple_capture_count: None,
// surcharge_amount: None,
// tax_amount: None,
// merchant_connector_id: None,
// authentication_data: None,
// encoded_data: None,
// external_three_ds_authentication_attempted: None,
// authentication_connector: None,
// authentication_id: None,
// fingerprint_id: None,
// payment_method_billing_address_id: None,
// charge_id: None,
// client_source: None,
// client_version: None,
// customer_acceptance: None,
// card_network: None,
// },
// PaymentAttemptUpdate::StatusUpdate { status, updated_by } => Self {
// status: Some(status),
// modified_at: common_utils::date_time::now(),
// updated_by,
// net_amount: None,
// authentication_type: None,
// error_message: None,
// payment_method_id: None,
// cancellation_reason: None,
// browser_info: None,
// payment_token: None,
// error_code: None,
// connector_metadata: None,
// payment_method_data: None,
// payment_experience: None,
// straight_through_algorithm: None,
// preprocessing_step_id: None,
// error_reason: None,
// connector_response_reference_id: None,
// multiple_capture_count: None,
// surcharge_amount: None,
// tax_amount: None,
// amount_capturable: None,
// merchant_connector_id: None,
// authentication_data: None,
// encoded_data: None,
// unified_code: None,
// unified_message: None,
// external_three_ds_authentication_attempted: None,
// authentication_connector: None,
// authentication_id: None,
// fingerprint_id: None,
// payment_method_billing_address_id: None,
// charge_id: None,
// client_source: None,
// client_version: None,
// customer_acceptance: None,
// card_network: None,
// },
// PaymentAttemptUpdate::UpdateTrackers {
// payment_token,
// connector,
// straight_through_algorithm,
// amount_capturable,
// surcharge_amount,
// tax_amount,
// updated_by,
// merchant_connector_id,
// } => Self {
// payment_token,
// modified_at: common_utils::date_time::now(),
// straight_through_algorithm,
// amount_capturable,
// surcharge_amount,
// tax_amount,
// updated_by,
// merchant_connector_id: merchant_connector_id.map(Some),
// net_amount: None,
// status: None,
// authentication_type: None,
// error_message: None,
// payment_method_id: None,
// cancellation_reason: None,
// browser_info: None,
// error_code: None,
// connector_metadata: None,
// payment_method_data: None,
// payment_experience: None,
// preprocessing_step_id: None,
// error_reason: None,
// connector_response_reference_id: None,
// multiple_capture_count: None,
// authentication_data: None,
// encoded_data: None,
// unified_code: None,
// unified_message: None,
// external_three_ds_authentication_attempted: None,
// authentication_connector: None,
// authentication_id: None,
// fingerprint_id: None,
// payment_method_billing_address_id: None,
// charge_id: None,
// client_source: None,
// client_version: None,
// customer_acceptance: None,
// card_network: None,
// },
// PaymentAttemptUpdate::UnresolvedResponseUpdate {
// status,
// connector,
// connector_transaction_id,
// payment_method_id,
// error_code,
// error_message,
// error_reason,
// connector_response_reference_id,
// updated_by,
// } => Self {
// status: Some(status),
// payment_method_id,
// modified_at: common_utils::date_time::now(),
// error_code,
// error_message,
// error_reason,
// connector_response_reference_id,
// updated_by,
// net_amount: None,
// authentication_type: None,
// cancellation_reason: None,
// browser_info: None,
// payment_token: None,
// connector_metadata: None,
// payment_method_data: None,
// payment_experience: None,
// straight_through_algorithm: None,
// preprocessing_step_id: None,
// multiple_capture_count: None,
// surcharge_amount: None,
// tax_amount: None,
// amount_capturable: None,
// merchant_connector_id: None,
// authentication_data: None,
// encoded_data: None,
// unified_code: None,
// unified_message: None,
// external_three_ds_authentication_attempted: None,
// authentication_connector: None,
// authentication_id: None,
// fingerprint_id: None,
// payment_method_billing_address_id: None,
// charge_id: None,
// client_source: None,
// client_version: None,
// customer_acceptance: None,
// card_network: None,
// },
// PaymentAttemptUpdate::PreprocessingUpdate {
// status,
// payment_method_id,
// connector_metadata,
// preprocessing_step_id,
// connector_transaction_id,
// connector_response_reference_id,
// updated_by,
// } => Self {
// status: Some(status),
// payment_method_id,
// modified_at: common_utils::date_time::now(),
// connector_metadata,
// preprocessing_step_id,
// connector_response_reference_id,
// updated_by,
// net_amount: None,
// authentication_type: None,
// error_message: None,
// cancellation_reason: None,
// browser_info: None,
// payment_token: None,
// error_code: None,
// payment_method_data: None,
// payment_experience: None,
// straight_through_algorithm: None,
// error_reason: None,
// multiple_capture_count: None,
// surcharge_amount: None,
// tax_amount: None,
// amount_capturable: None,
// merchant_connector_id: None,
// authentication_data: None,
// encoded_data: None,
// unified_code: None,
// unified_message: None,
// external_three_ds_authentication_attempted: None,
// authentication_connector: None,
// authentication_id: None,
// fingerprint_id: None,
// payment_method_billing_address_id: None,
// charge_id: None,
// client_source: None,
// client_version: None,
// customer_acceptance: None,
// card_network: None,
// },
// PaymentAttemptUpdate::CaptureUpdate {
// multiple_capture_count,
// updated_by,
// amount_to_capture,
// } => Self {
// multiple_capture_count,
// modified_at: common_utils::date_time::now(),
// updated_by,
// net_amount: None,
// status: None,
// authentication_type: None,
// error_message: None,
// payment_method_id: None,
// cancellation_reason: None,
// browser_info: None,
// payment_token: None,
// error_code: None,
// connector_metadata: None,
// payment_method_data: None,
// payment_experience: None,
// straight_through_algorithm: None,
// preprocessing_step_id: None,
// error_reason: None,
// connector_response_reference_id: None,
// surcharge_amount: None,
// tax_amount: None,
// amount_capturable: None,
// merchant_connector_id: None,
// authentication_data: None,
// encoded_data: None,
// unified_code: None,
// unified_message: None,
// external_three_ds_authentication_attempted: None,
// authentication_connector: None,
// authentication_id: None,
// fingerprint_id: None,
// payment_method_billing_address_id: None,
// charge_id: None,
// client_source: None,
// client_version: None,
// customer_acceptance: None,
// card_network: None,
// },
// PaymentAttemptUpdate::AmountToCaptureUpdate {
// status,
// amount_capturable,
// updated_by,
// } => Self {
// status: Some(status),
// modified_at: common_utils::date_time::now(),
// amount_capturable: Some(amount_capturable),
// updated_by,
// net_amount: None,
// authentication_type: None,
// error_message: None,
// payment_method_id: None,
// cancellation_reason: None,
// browser_info: None,
// payment_token: None,
// error_code: None,
// connector_metadata: None,
// payment_method_data: None,
// payment_experience: None,
// straight_through_algorithm: None,
// preprocessing_step_id: None,
// error_reason: None,
// connector_response_reference_id: None,
// multiple_capture_count: None,
// surcharge_amount: None,
// tax_amount: None,
// merchant_connector_id: None,
// authentication_data: None,
// encoded_data: None,
// unified_code: None,
// unified_message: None,
// external_three_ds_authentication_attempted: None,
// authentication_connector: None,
// authentication_id: None,
// fingerprint_id: None,
// payment_method_billing_address_id: None,
// charge_id: None,
// client_source: None,
// client_version: None,
// customer_acceptance: None,
// card_network: None,
// },
// PaymentAttemptUpdate::ConnectorResponse {
// authentication_data,
// encoded_data,
// connector_transaction_id,
// connector,
// updated_by,
// charge_id,
// } => Self {
// authentication_data,
// encoded_data,
// modified_at: common_utils::date_time::now(),
// updated_by,
// charge_id,
// net_amount: None,
// status: None,
// authentication_type: None,
// error_message: None,
// payment_method_id: None,
// cancellation_reason: None,
// browser_info: None,
// payment_token: None,
// error_code: None,
// connector_metadata: None,
// payment_method_data: None,
// payment_experience: None,
// straight_through_algorithm: None,
// preprocessing_step_id: None,
// error_reason: None,
// connector_response_reference_id: None,
// multiple_capture_count: None,
// surcharge_amount: None,
// tax_amount: None,
// amount_capturable: None,
// merchant_connector_id: None,
// unified_code: None,
// unified_message: None,
// external_three_ds_authentication_attempted: None,
// authentication_connector: None,
// authentication_id: None,
// fingerprint_id: None,
// payment_method_billing_address_id: None,
// client_source: None,
// client_version: None,
// customer_acceptance: None,
// card_network: None,
// },
// PaymentAttemptUpdate::IncrementalAuthorizationAmountUpdate {
// amount,
// amount_capturable,
// } => Self {
// modified_at: common_utils::date_time::now(),
// amount_capturable: Some(amount_capturable),
// net_amount: None,
// status: None,
// authentication_type: None,
// error_message: None,
// payment_method_id: None,
// cancellation_reason: None,
// browser_info: None,
// payment_token: None,
// error_code: None,
// connector_metadata: None,
// payment_method_data: None,
// payment_experience: None,
// straight_through_algorithm: None,
// preprocessing_step_id: None,
// error_reason: None,
// connector_response_reference_id: None,
// multiple_capture_count: None,
// surcharge_amount: None,
// tax_amount: None,
// updated_by: String::default(),
// merchant_connector_id: None,
// authentication_data: None,
// encoded_data: None,
// unified_code: None,
// unified_message: None,
// external_three_ds_authentication_attempted: None,
// authentication_connector: None,
// authentication_id: None,
// fingerprint_id: None,
// payment_method_billing_address_id: None,
// charge_id: None,
// client_source: None,
// client_version: None,
// customer_acceptance: None,
// card_network: None,
// },
// PaymentAttemptUpdate::AuthenticationUpdate {
// status,
// external_three_ds_authentication_attempted,
// authentication_connector,
// authentication_id,
// updated_by,
// } => Self {
// status: Some(status),
// modified_at: common_utils::date_time::now(),
// external_three_ds_authentication_attempted,
// authentication_connector,
// authentication_id,
// updated_by,
// net_amount: None,
// authentication_type: None,
// error_message: None,
// payment_method_id: None,
// cancellation_reason: None,
// browser_info: None,
// payment_token: None,
// error_code: None,
// connector_metadata: None,
// payment_method_data: None,
// payment_experience: None,
// straight_through_algorithm: None,
// preprocessing_step_id: None,
// error_reason: None,
// connector_response_reference_id: None,
// multiple_capture_count: None,
// surcharge_amount: None,
// tax_amount: None,
// amount_capturable: None,
// merchant_connector_id: None,
// authentication_data: None,
// encoded_data: None,
// unified_code: None,
// unified_message: None,
// fingerprint_id: None,
// payment_method_billing_address_id: None,
// charge_id: None,
// client_source: None,
// client_version: None,
// customer_acceptance: None,
// card_network: None,
// },
// PaymentAttemptUpdate::ManualUpdate {
// status,
// error_code,
// error_message,
// error_reason,
// updated_by,
// unified_code,
// unified_message,
// connector_transaction_id,
// } => Self {
// status,
// error_code: error_code.map(Some),
// modified_at: common_utils::date_time::now(),
// error_message: error_message.map(Some),
// error_reason: error_reason.map(Some),
// updated_by,
// unified_code: unified_code.map(Some),
// unified_message: unified_message.map(Some),
// net_amount: None,
// authentication_type: None,
// payment_method_id: None,
// cancellation_reason: None,
// browser_info: None,
// payment_token: None,
// connector_metadata: None,
// payment_method_data: None,
// payment_experience: None,
// straight_through_algorithm: None,
// preprocessing_step_id: None,
// connector_response_reference_id: None,
// multiple_capture_count: None,
// surcharge_amount: None,
// tax_amount: None,
// amount_capturable: None,
// merchant_connector_id: None,
// authentication_data: None,
// encoded_data: None,
// external_three_ds_authentication_attempted: None,
// authentication_connector: None,
// authentication_id: None,
// fingerprint_id: None,
// payment_method_billing_address_id: None,
// charge_id: None,
// client_source: None,
// client_version: None,
// customer_acceptance: None,
// card_network: None,
// },
// }
}
}
#[cfg(feature = "v1")]
impl From<PaymentAttemptUpdate> for PaymentAttemptUpdateInternal {
fn from(payment_attempt_update: PaymentAttemptUpdate) -> Self {
match payment_attempt_update {
PaymentAttemptUpdate::Update {
amount,
currency,
status,
// connector_transaction_id,
authentication_type,
payment_method,
payment_token,
payment_method_data,
payment_method_type,
payment_experience,
business_sub_label,
amount_to_capture,
capture_method,
surcharge_amount,
tax_amount,
fingerprint_id,
updated_by,
payment_method_billing_address_id,
} => Self {
amount: Some(amount),
currency: Some(currency),
status: Some(status),
// connector_transaction_id,
authentication_type,
payment_method,
payment_token,
modified_at: common_utils::date_time::now(),
payment_method_data,
payment_method_type,
payment_experience,
business_sub_label,
amount_to_capture,
capture_method,
surcharge_amount,
tax_amount,
fingerprint_id,
payment_method_billing_address_id,
updated_by,
net_amount: None,
connector_transaction_id: None,
connector: None,
error_message: None,
payment_method_id: None,
cancellation_reason: None,
mandate_id: None,
browser_info: None,
error_code: None,
connector_metadata: None,
straight_through_algorithm: None,
preprocessing_step_id: None,
error_reason: None,
connector_response_reference_id: None,
multiple_capture_count: None,
amount_capturable: None,
merchant_connector_id: None,
authentication_data: None,
encoded_data: None,
unified_code: None,
unified_message: None,
external_three_ds_authentication_attempted: None,
authentication_connector: None,
authentication_id: None,
client_source: None,
client_version: None,
customer_acceptance: None,
card_network: None,
shipping_cost: None,
capture_before: None,
extended_authorization_applied: None,
order_tax_amount: None,
processor_transaction_data: None,
connector_mandate_detail: None,
card_discovery: None,
charges: None,
issuer_error_code: None,
issuer_error_message: None,
},
PaymentAttemptUpdate::AuthenticationTypeUpdate {
authentication_type,
updated_by,
} => Self {
authentication_type: Some(authentication_type),
modified_at: common_utils::date_time::now(),
updated_by,
amount: None,
net_amount: None,
currency: None,
status: None,
connector_transaction_id: None,
amount_to_capture: None,
connector: None,
payment_method: None,
error_message: None,
payment_method_id: None,
cancellation_reason: None,
mandate_id: None,
browser_info: None,
payment_token: None,
error_code: None,
connector_metadata: None,
payment_method_data: None,
payment_method_type: None,
payment_experience: None,
business_sub_label: None,
straight_through_algorithm: None,
preprocessing_step_id: None,
error_reason: None,
capture_method: None,
connector_response_reference_id: None,
multiple_capture_count: None,
surcharge_amount: None,
tax_amount: None,
amount_capturable: None,
merchant_connector_id: None,
authentication_data: None,
encoded_data: None,
unified_code: None,
unified_message: None,
external_three_ds_authentication_attempted: None,
authentication_connector: None,
authentication_id: None,
fingerprint_id: None,
payment_method_billing_address_id: None,
client_source: None,
client_version: None,
customer_acceptance: None,
card_network: None,
shipping_cost: None,
order_tax_amount: None,
capture_before: None,
extended_authorization_applied: None,
processor_transaction_data: None,
connector_mandate_detail: None,
card_discovery: None,
charges: None,
issuer_error_code: None,
issuer_error_message: None,
},
PaymentAttemptUpdate::ConfirmUpdate {
amount,
currency,
authentication_type,
capture_method,
status,
payment_method,
browser_info,
connector,
payment_token,
payment_method_data,
payment_method_type,
payment_experience,
business_sub_label,
straight_through_algorithm,
error_code,
error_message,
amount_capturable,
updated_by,
merchant_connector_id,
surcharge_amount,
tax_amount,
external_three_ds_authentication_attempted,
authentication_connector,
authentication_id,
payment_method_billing_address_id,
fingerprint_id,
payment_method_id,
client_source,
client_version,
customer_acceptance,
shipping_cost,
order_tax_amount,
connector_mandate_detail,
card_discovery,
} => Self {
amount: Some(amount),
currency: Some(currency),
authentication_type,
status: Some(status),
payment_method,
modified_at: common_utils::date_time::now(),
browser_info,
connector: connector.map(Some),
payment_token,
payment_method_data,
payment_method_type,
payment_experience,
business_sub_label,
straight_through_algorithm,
error_code,
error_message,
amount_capturable,
updated_by,
merchant_connector_id: merchant_connector_id.map(Some),
surcharge_amount,
tax_amount,
external_three_ds_authentication_attempted,
authentication_connector,
authentication_id,
payment_method_billing_address_id,
fingerprint_id,
payment_method_id,
capture_method,
client_source,
client_version,
customer_acceptance,
net_amount: None,
connector_transaction_id: None,
amount_to_capture: None,
cancellation_reason: None,
mandate_id: None,
connector_metadata: None,
preprocessing_step_id: None,
error_reason: None,
connector_response_reference_id: None,
multiple_capture_count: None,
authentication_data: None,
encoded_data: None,
unified_code: None,
unified_message: None,
card_network: None,
shipping_cost,
order_tax_amount,
capture_before: None,
extended_authorization_applied: None,
processor_transaction_data: None,
connector_mandate_detail,
card_discovery,
charges: None,
issuer_error_code: None,
issuer_error_message: None,
},
PaymentAttemptUpdate::VoidUpdate {
status,
cancellation_reason,
updated_by,
} => Self {
status: Some(status),
cancellation_reason,
modified_at: common_utils::date_time::now(),
updated_by,
amount: None,
net_amount: None,
currency: None,
connector_transaction_id: None,
amount_to_capture: None,
connector: None,
authentication_type: None,
payment_method: None,
error_message: None,
payment_method_id: None,
mandate_id: None,
browser_info: None,
payment_token: None,
error_code: None,
connector_metadata: None,
payment_method_data: None,
payment_method_type: None,
payment_experience: None,
business_sub_label: None,
straight_through_algorithm: None,
preprocessing_step_id: None,
error_reason: None,
capture_method: None,
connector_response_reference_id: None,
multiple_capture_count: None,
surcharge_amount: None,
tax_amount: None,
amount_capturable: None,
merchant_connector_id: None,
authentication_data: None,
encoded_data: None,
unified_code: None,
unified_message: None,
external_three_ds_authentication_attempted: None,
authentication_connector: None,
authentication_id: None,
fingerprint_id: None,
payment_method_billing_address_id: None,
client_source: None,
client_version: None,
customer_acceptance: None,
card_network: None,
shipping_cost: None,
order_tax_amount: None,
capture_before: None,
extended_authorization_applied: None,
processor_transaction_data: None,
connector_mandate_detail: None,
card_discovery: None,
charges: None,
issuer_error_code: None,
issuer_error_message: None,
},
PaymentAttemptUpdate::RejectUpdate {
status,
error_code,
error_message,
updated_by,
} => Self {
status: Some(status),
modified_at: common_utils::date_time::now(),
error_code,
error_message,
updated_by,
amount: None,
net_amount: None,
currency: None,
connector_transaction_id: None,
amount_to_capture: None,
connector: None,
authentication_type: None,
payment_method: None,
payment_method_id: None,
cancellation_reason: None,
mandate_id: None,
browser_info: None,
payment_token: None,
connector_metadata: None,
payment_method_data: None,
payment_method_type: None,
payment_experience: None,
business_sub_label: None,
straight_through_algorithm: None,
preprocessing_step_id: None,
error_reason: None,
capture_method: None,
connector_response_reference_id: None,
multiple_capture_count: None,
surcharge_amount: None,
tax_amount: None,
amount_capturable: None,
merchant_connector_id: None,
authentication_data: None,
encoded_data: None,
unified_code: None,
unified_message: None,
external_three_ds_authentication_attempted: None,
authentication_connector: None,
authentication_id: None,
fingerprint_id: None,
payment_method_billing_address_id: None,
client_source: None,
client_version: None,
customer_acceptance: None,
card_network: None,
shipping_cost: None,
order_tax_amount: None,
capture_before: None,
extended_authorization_applied: None,
processor_transaction_data: None,
connector_mandate_detail: None,
card_discovery: None,
charges: None,
issuer_error_code: None,
issuer_error_message: None,
},
PaymentAttemptUpdate::BlocklistUpdate {
status,
error_code,
error_message,
updated_by,
} => Self {
status: Some(status),
modified_at: common_utils::date_time::now(),
error_code,
connector: Some(None),
error_message,
updated_by,
merchant_connector_id: Some(None),
amount: None,
net_amount: None,
currency: None,
connector_transaction_id: None,
amount_to_capture: None,
authentication_type: None,
payment_method: None,
payment_method_id: None,
cancellation_reason: None,
mandate_id: None,
browser_info: None,
payment_token: None,
connector_metadata: None,
payment_method_data: None,
payment_method_type: None,
payment_experience: None,
business_sub_label: None,
straight_through_algorithm: None,
preprocessing_step_id: None,
error_reason: None,
capture_method: None,
connector_response_reference_id: None,
multiple_capture_count: None,
surcharge_amount: None,
tax_amount: None,
amount_capturable: None,
authentication_data: None,
encoded_data: None,
unified_code: None,
unified_message: None,
external_three_ds_authentication_attempted: None,
authentication_connector: None,
authentication_id: None,
fingerprint_id: None,
payment_method_billing_address_id: None,
client_source: None,
client_version: None,
customer_acceptance: None,
card_network: None,
shipping_cost: None,
order_tax_amount: None,
capture_before: None,
extended_authorization_applied: None,
processor_transaction_data: None,
connector_mandate_detail: None,
card_discovery: None,
charges: None,
issuer_error_code: None,
issuer_error_message: None,
},
PaymentAttemptUpdate::ConnectorMandateDetailUpdate {
connector_mandate_detail,
updated_by,
} => Self {
payment_method_id: None,
modified_at: common_utils::date_time::now(),
updated_by,
amount: None,
net_amount: None,
currency: None,
status: None,
connector_transaction_id: None,
amount_to_capture: None,
connector: None,
authentication_type: None,
payment_method: None,
error_message: None,
cancellation_reason: None,
mandate_id: None,
browser_info: None,
payment_token: None,
error_code: None,
connector_metadata: None,
payment_method_data: None,
payment_method_type: None,
payment_experience: None,
business_sub_label: None,
straight_through_algorithm: None,
preprocessing_step_id: None,
error_reason: None,
capture_method: None,
connector_response_reference_id: None,
multiple_capture_count: None,
surcharge_amount: None,
tax_amount: None,
amount_capturable: None,
merchant_connector_id: None,
authentication_data: None,
encoded_data: None,
unified_code: None,
unified_message: None,
external_three_ds_authentication_attempted: None,
authentication_connector: None,
authentication_id: None,
fingerprint_id: None,
payment_method_billing_address_id: None,
client_source: None,
client_version: None,
customer_acceptance: None,
card_network: None,
shipping_cost: None,
order_tax_amount: None,
capture_before: None,
extended_authorization_applied: None,
processor_transaction_data: None,
connector_mandate_detail,
card_discovery: None,
charges: None,
issuer_error_code: None,
issuer_error_message: None,
},
PaymentAttemptUpdate::PaymentMethodDetailsUpdate {
payment_method_id,
updated_by,
} => Self {
payment_method_id,
modified_at: common_utils::date_time::now(),
updated_by,
amount: None,
net_amount: None,
currency: None,
status: None,
connector_transaction_id: None,
amount_to_capture: None,
connector: None,
authentication_type: None,
payment_method: None,
error_message: None,
cancellation_reason: None,
mandate_id: None,
browser_info: None,
payment_token: None,
error_code: None,
connector_metadata: None,
payment_method_data: None,
payment_method_type: None,
payment_experience: None,
business_sub_label: None,
straight_through_algorithm: None,
preprocessing_step_id: None,
error_reason: None,
capture_method: None,
connector_response_reference_id: None,
multiple_capture_count: None,
surcharge_amount: None,
tax_amount: None,
amount_capturable: None,
merchant_connector_id: None,
authentication_data: None,
encoded_data: None,
unified_code: None,
unified_message: None,
external_three_ds_authentication_attempted: None,
authentication_connector: None,
authentication_id: None,
fingerprint_id: None,
payment_method_billing_address_id: None,
client_source: None,
client_version: None,
customer_acceptance: None,
card_network: None,
shipping_cost: None,
order_tax_amount: None,
capture_before: None,
extended_authorization_applied: None,
processor_transaction_data: None,
connector_mandate_detail: None,
card_discovery: None,
charges: None,
issuer_error_code: None,
issuer_error_message: None,
},
PaymentAttemptUpdate::ResponseUpdate {
status,
connector,
connector_transaction_id,
authentication_type,
payment_method_id,
mandate_id,
connector_metadata,
payment_token,
error_code,
error_message,
error_reason,
connector_response_reference_id,
amount_capturable,
updated_by,
authentication_data,
encoded_data,
unified_code,
unified_message,
capture_before,
extended_authorization_applied,
payment_method_data,
connector_mandate_detail,
charges,
} => {
let (connector_transaction_id, processor_transaction_data) =
connector_transaction_id
.map(ConnectorTransactionId::form_id_and_data)
.map(|(txn_id, txn_data)| (Some(txn_id), txn_data))
.unwrap_or((None, None));
Self {
status: Some(status),
connector: connector.map(Some),
connector_transaction_id,
authentication_type,
payment_method_id,
modified_at: common_utils::date_time::now(),
mandate_id,
connector_metadata,
error_code,
error_message,
payment_token,
error_reason,
connector_response_reference_id,
amount_capturable,
updated_by,
authentication_data,
encoded_data,
unified_code,
unified_message,
payment_method_data,
processor_transaction_data,
connector_mandate_detail,
charges,
amount: None,
net_amount: None,
currency: None,
amount_to_capture: None,
payment_method: None,
cancellation_reason: None,
browser_info: None,
payment_method_type: None,
payment_experience: None,
business_sub_label: None,
straight_through_algorithm: None,
preprocessing_step_id: None,
capture_method: None,
multiple_capture_count: None,
surcharge_amount: None,
tax_amount: None,
merchant_connector_id: None,
external_three_ds_authentication_attempted: None,
authentication_connector: None,
authentication_id: None,
fingerprint_id: None,
payment_method_billing_address_id: None,
client_source: None,
client_version: None,
customer_acceptance: None,
card_network: None,
capture_before,
extended_authorization_applied,
shipping_cost: None,
order_tax_amount: None,
card_discovery: None,
issuer_error_code: None,
issuer_error_message: None,
}
}
PaymentAttemptUpdate::ErrorUpdate {
connector,
status,
error_code,
error_message,
error_reason,
amount_capturable,
updated_by,
unified_code,
unified_message,
connector_transaction_id,
payment_method_data,
authentication_type,
issuer_error_code,
issuer_error_message,
} => {
let (connector_transaction_id, processor_transaction_data) =
connector_transaction_id
.map(ConnectorTransactionId::form_id_and_data)
.map(|(txn_id, txn_data)| (Some(txn_id), txn_data))
.unwrap_or((None, None));
Self {
connector: connector.map(Some),
status: Some(status),
error_message,
error_code,
modified_at: common_utils::date_time::now(),
error_reason,
amount_capturable,
updated_by,
unified_code,
unified_message,
connector_transaction_id,
payment_method_data,
authentication_type,
processor_transaction_data,
issuer_error_code,
issuer_error_message,
amount: None,
net_amount: None,
currency: None,
amount_to_capture: None,
payment_method: None,
payment_method_id: None,
cancellation_reason: None,
mandate_id: None,
browser_info: None,
payment_token: None,
connector_metadata: None,
payment_method_type: None,
payment_experience: None,
business_sub_label: None,
straight_through_algorithm: None,
preprocessing_step_id: None,
capture_method: None,
connector_response_reference_id: None,
multiple_capture_count: None,
surcharge_amount: None,
tax_amount: None,
merchant_connector_id: None,
authentication_data: None,
encoded_data: None,
external_three_ds_authentication_attempted: None,
authentication_connector: None,
authentication_id: None,
fingerprint_id: None,
payment_method_billing_address_id: None,
client_source: None,
client_version: None,
customer_acceptance: None,
card_network: None,
capture_before: None,
extended_authorization_applied: None,
shipping_cost: None,
order_tax_amount: None,
connector_mandate_detail: None,
card_discovery: None,
charges: None,
}
}
PaymentAttemptUpdate::StatusUpdate { status, updated_by } => Self {
status: Some(status),
modified_at: common_utils::date_time::now(),
updated_by,
amount: None,
net_amount: None,
currency: None,
connector_transaction_id: None,
amount_to_capture: None,
connector: None,
authentication_type: None,
payment_method: None,
error_message: None,
payment_method_id: None,
cancellation_reason: None,
mandate_id: None,
browser_info: None,
payment_token: None,
error_code: None,
connector_metadata: None,
payment_method_data: None,
payment_method_type: None,
payment_experience: None,
business_sub_label: None,
straight_through_algorithm: None,
preprocessing_step_id: None,
error_reason: None,
capture_method: None,
connector_response_reference_id: None,
multiple_capture_count: None,
surcharge_amount: None,
tax_amount: None,
amount_capturable: None,
merchant_connector_id: None,
authentication_data: None,
encoded_data: None,
unified_code: None,
unified_message: None,
external_three_ds_authentication_attempted: None,
authentication_connector: None,
authentication_id: None,
fingerprint_id: None,
payment_method_billing_address_id: None,
client_source: None,
client_version: None,
customer_acceptance: None,
card_network: None,
shipping_cost: None,
capture_before: None,
extended_authorization_applied: None,
order_tax_amount: None,
processor_transaction_data: None,
connector_mandate_detail: None,
card_discovery: None,
charges: None,
issuer_error_code: None,
issuer_error_message: None,
},
PaymentAttemptUpdate::UpdateTrackers {
payment_token,
connector,
straight_through_algorithm,
amount_capturable,
surcharge_amount,
tax_amount,
updated_by,
merchant_connector_id,
} => Self {
payment_token,
modified_at: common_utils::date_time::now(),
connector: connector.map(Some),
straight_through_algorithm,
amount_capturable,
surcharge_amount,
tax_amount,
updated_by,
merchant_connector_id: merchant_connector_id.map(Some),
amount: None,
net_amount: None,
currency: None,
status: None,
connector_transaction_id: None,
amount_to_capture: None,
authentication_type: None,
payment_method: None,
error_message: None,
payment_method_id: None,
cancellation_reason: None,
mandate_id: None,
browser_info: None,
error_code: None,
connector_metadata: None,
payment_method_data: None,
payment_method_type: None,
payment_experience: None,
business_sub_label: None,
preprocessing_step_id: None,
error_reason: None,
capture_method: None,
connector_response_reference_id: None,
multiple_capture_count: None,
authentication_data: None,
encoded_data: None,
unified_code: None,
unified_message: None,
external_three_ds_authentication_attempted: None,
authentication_connector: None,
authentication_id: None,
fingerprint_id: None,
payment_method_billing_address_id: None,
client_source: None,
client_version: None,
customer_acceptance: None,
card_network: None,
shipping_cost: None,
capture_before: None,
extended_authorization_applied: None,
order_tax_amount: None,
processor_transaction_data: None,
connector_mandate_detail: None,
card_discovery: None,
charges: None,
issuer_error_code: None,
issuer_error_message: None,
},
PaymentAttemptUpdate::UnresolvedResponseUpdate {
status,
connector,
connector_transaction_id,
payment_method_id,
error_code,
error_message,
error_reason,
connector_response_reference_id,
updated_by,
} => {
let (connector_transaction_id, processor_transaction_data) =
connector_transaction_id
.map(ConnectorTransactionId::form_id_and_data)
.map(|(txn_id, txn_data)| (Some(txn_id), txn_data))
.unwrap_or((None, None));
Self {
status: Some(status),
connector: connector.map(Some),
connector_transaction_id,
payment_method_id,
modified_at: common_utils::date_time::now(),
error_code,
error_message,
error_reason,
connector_response_reference_id,
updated_by,
processor_transaction_data,
amount: None,
net_amount: None,
currency: None,
amount_to_capture: None,
authentication_type: None,
payment_method: None,
cancellation_reason: None,
mandate_id: None,
browser_info: None,
payment_token: None,
connector_metadata: None,
payment_method_data: None,
payment_method_type: None,
payment_experience: None,
business_sub_label: None,
straight_through_algorithm: None,
preprocessing_step_id: None,
capture_method: None,
multiple_capture_count: None,
surcharge_amount: None,
tax_amount: None,
amount_capturable: None,
merchant_connector_id: None,
authentication_data: None,
encoded_data: None,
unified_code: None,
unified_message: None,
external_three_ds_authentication_attempted: None,
authentication_connector: None,
authentication_id: None,
fingerprint_id: None,
payment_method_billing_address_id: None,
client_source: None,
client_version: None,
customer_acceptance: None,
card_network: None,
shipping_cost: None,
capture_before: None,
extended_authorization_applied: None,
order_tax_amount: None,
connector_mandate_detail: None,
card_discovery: None,
charges: None,
issuer_error_code: None,
issuer_error_message: None,
}
}
PaymentAttemptUpdate::PreprocessingUpdate {
status,
payment_method_id,
connector_metadata,
preprocessing_step_id,
connector_transaction_id,
connector_response_reference_id,
updated_by,
} => {
let (connector_transaction_id, processor_transaction_data) =
connector_transaction_id
.map(ConnectorTransactionId::form_id_and_data)
.map(|(txn_id, txn_data)| (Some(txn_id), txn_data))
.unwrap_or((None, None));
Self {
status: Some(status),
payment_method_id,
modified_at: common_utils::date_time::now(),
connector_metadata,
preprocessing_step_id,
connector_transaction_id,
connector_response_reference_id,
updated_by,
processor_transaction_data,
amount: None,
net_amount: None,
currency: None,
amount_to_capture: None,
connector: None,
authentication_type: None,
payment_method: None,
error_message: None,
cancellation_reason: None,
mandate_id: None,
browser_info: None,
payment_token: None,
error_code: None,
payment_method_data: None,
payment_method_type: None,
payment_experience: None,
business_sub_label: None,
straight_through_algorithm: None,
error_reason: None,
capture_method: None,
multiple_capture_count: None,
surcharge_amount: None,
tax_amount: None,
amount_capturable: None,
merchant_connector_id: None,
authentication_data: None,
encoded_data: None,
unified_code: None,
unified_message: None,
external_three_ds_authentication_attempted: None,
authentication_connector: None,
authentication_id: None,
fingerprint_id: None,
payment_method_billing_address_id: None,
client_source: None,
client_version: None,
customer_acceptance: None,
card_network: None,
capture_before: None,
extended_authorization_applied: None,
shipping_cost: None,
order_tax_amount: None,
connector_mandate_detail: None,
card_discovery: None,
charges: None,
issuer_error_code: None,
issuer_error_message: None,
}
}
PaymentAttemptUpdate::CaptureUpdate {
multiple_capture_count,
updated_by,
amount_to_capture,
} => Self {
multiple_capture_count,
modified_at: common_utils::date_time::now(),
updated_by,
amount_to_capture,
amount: None,
net_amount: None,
currency: None,
status: None,
connector_transaction_id: None,
connector: None,
authentication_type: None,
payment_method: None,
error_message: None,
payment_method_id: None,
cancellation_reason: None,
mandate_id: None,
browser_info: None,
payment_token: None,
error_code: None,
connector_metadata: None,
payment_method_data: None,
payment_method_type: None,
payment_experience: None,
business_sub_label: None,
straight_through_algorithm: None,
preprocessing_step_id: None,
error_reason: None,
capture_method: None,
connector_response_reference_id: None,
surcharge_amount: None,
tax_amount: None,
amount_capturable: None,
merchant_connector_id: None,
authentication_data: None,
encoded_data: None,
unified_code: None,
unified_message: None,
external_three_ds_authentication_attempted: None,
authentication_connector: None,
authentication_id: None,
fingerprint_id: None,
payment_method_billing_address_id: None,
client_source: None,
client_version: None,
customer_acceptance: None,
card_network: None,
shipping_cost: None,
order_tax_amount: None,
capture_before: None,
extended_authorization_applied: None,
processor_transaction_data: None,
connector_mandate_detail: None,
card_discovery: None,
charges: None,
issuer_error_code: None,
issuer_error_message: None,
},
PaymentAttemptUpdate::AmountToCaptureUpdate {
status,
amount_capturable,
updated_by,
} => Self {
status: Some(status),
modified_at: common_utils::date_time::now(),
amount_capturable: Some(amount_capturable),
updated_by,
amount: None,
net_amount: None,
currency: None,
connector_transaction_id: None,
amount_to_capture: None,
connector: None,
authentication_type: None,
payment_method: None,
error_message: None,
payment_method_id: None,
cancellation_reason: None,
mandate_id: None,
browser_info: None,
payment_token: None,
error_code: None,
connector_metadata: None,
payment_method_data: None,
payment_method_type: None,
payment_experience: None,
business_sub_label: None,
straight_through_algorithm: None,
preprocessing_step_id: None,
error_reason: None,
capture_method: None,
connector_response_reference_id: None,
multiple_capture_count: None,
surcharge_amount: None,
tax_amount: None,
merchant_connector_id: None,
authentication_data: None,
encoded_data: None,
unified_code: None,
unified_message: None,
external_three_ds_authentication_attempted: None,
authentication_connector: None,
authentication_id: None,
fingerprint_id: None,
payment_method_billing_address_id: None,
client_source: None,
client_version: None,
customer_acceptance: None,
card_network: None,
shipping_cost: None,
capture_before: None,
extended_authorization_applied: None,
order_tax_amount: None,
processor_transaction_data: None,
connector_mandate_detail: None,
card_discovery: None,
charges: None,
issuer_error_code: None,
issuer_error_message: None,
},
PaymentAttemptUpdate::ConnectorResponse {
authentication_data,
encoded_data,
connector_transaction_id,
connector,
updated_by,
charges,
} => {
let (connector_transaction_id, processor_transaction_data) =
connector_transaction_id
.map(ConnectorTransactionId::form_id_and_data)
.map(|(txn_id, txn_data)| (Some(txn_id), txn_data))
.unwrap_or((None, None));
Self {
authentication_data,
encoded_data,
connector_transaction_id,
connector: connector.map(Some),
modified_at: common_utils::date_time::now(),
updated_by,
processor_transaction_data,
charges,
amount: None,
net_amount: None,
currency: None,
status: None,
amount_to_capture: None,
authentication_type: None,
payment_method: None,
error_message: None,
payment_method_id: None,
cancellation_reason: None,
mandate_id: None,
browser_info: None,
payment_token: None,
error_code: None,
connector_metadata: None,
payment_method_data: None,
payment_method_type: None,
payment_experience: None,
business_sub_label: None,
straight_through_algorithm: None,
preprocessing_step_id: None,
error_reason: None,
capture_method: None,
connector_response_reference_id: None,
multiple_capture_count: None,
surcharge_amount: None,
tax_amount: None,
amount_capturable: None,
merchant_connector_id: None,
unified_code: None,
unified_message: None,
external_three_ds_authentication_attempted: None,
authentication_connector: None,
authentication_id: None,
fingerprint_id: None,
payment_method_billing_address_id: None,
client_source: None,
client_version: None,
customer_acceptance: None,
card_network: None,
shipping_cost: None,
capture_before: None,
extended_authorization_applied: None,
order_tax_amount: None,
connector_mandate_detail: None,
card_discovery: None,
issuer_error_code: None,
issuer_error_message: None,
}
}
PaymentAttemptUpdate::IncrementalAuthorizationAmountUpdate {
amount,
amount_capturable,
} => Self {
amount: Some(amount),
modified_at: common_utils::date_time::now(),
amount_capturable: Some(amount_capturable),
net_amount: None,
currency: None,
status: None,
connector_transaction_id: None,
amount_to_capture: None,
connector: None,
authentication_type: None,
payment_method: None,
error_message: None,
payment_method_id: None,
cancellation_reason: None,
mandate_id: None,
browser_info: None,
payment_token: None,
error_code: None,
connector_metadata: None,
payment_method_data: None,
payment_method_type: None,
payment_experience: None,
business_sub_label: None,
straight_through_algorithm: None,
preprocessing_step_id: None,
error_reason: None,
capture_method: None,
connector_response_reference_id: None,
multiple_capture_count: None,
surcharge_amount: None,
tax_amount: None,
updated_by: String::default(),
merchant_connector_id: None,
authentication_data: None,
encoded_data: None,
unified_code: None,
unified_message: None,
external_three_ds_authentication_attempted: None,
authentication_connector: None,
authentication_id: None,
fingerprint_id: None,
payment_method_billing_address_id: None,
client_source: None,
client_version: None,
customer_acceptance: None,
card_network: None,
shipping_cost: None,
order_tax_amount: None,
capture_before: None,
extended_authorization_applied: None,
processor_transaction_data: None,
connector_mandate_detail: None,
card_discovery: None,
charges: None,
issuer_error_code: None,
issuer_error_message: None,
},
PaymentAttemptUpdate::AuthenticationUpdate {
status,
external_three_ds_authentication_attempted,
authentication_connector,
authentication_id,
updated_by,
} => Self {
status: Some(status),
modified_at: common_utils::date_time::now(),
external_three_ds_authentication_attempted,
authentication_connector,
authentication_id,
updated_by,
amount: None,
net_amount: None,
currency: None,
connector_transaction_id: None,
amount_to_capture: None,
connector: None,
authentication_type: None,
payment_method: None,
error_message: None,
payment_method_id: None,
cancellation_reason: None,
mandate_id: None,
browser_info: None,
payment_token: None,
error_code: None,
connector_metadata: None,
payment_method_data: None,
payment_method_type: None,
payment_experience: None,
business_sub_label: None,
straight_through_algorithm: None,
preprocessing_step_id: None,
error_reason: None,
capture_method: None,
connector_response_reference_id: None,
multiple_capture_count: None,
surcharge_amount: None,
tax_amount: None,
amount_capturable: None,
merchant_connector_id: None,
authentication_data: None,
encoded_data: None,
unified_code: None,
unified_message: None,
fingerprint_id: None,
payment_method_billing_address_id: None,
client_source: None,
client_version: None,
customer_acceptance: None,
card_network: None,
shipping_cost: None,
order_tax_amount: None,
capture_before: None,
extended_authorization_applied: None,
processor_transaction_data: None,
connector_mandate_detail: None,
card_discovery: None,
charges: None,
issuer_error_code: None,
issuer_error_message: None,
},
PaymentAttemptUpdate::ManualUpdate {
status,
error_code,
error_message,
error_reason,
updated_by,
unified_code,
unified_message,
connector_transaction_id,
} => {
let (connector_transaction_id, processor_transaction_data) =
connector_transaction_id
.map(ConnectorTransactionId::form_id_and_data)
.map(|(txn_id, txn_data)| (Some(txn_id), txn_data))
.unwrap_or((None, None));
Self {
status,
error_code: error_code.map(Some),
modified_at: common_utils::date_time::now(),
error_message: error_message.map(Some),
error_reason: error_reason.map(Some),
updated_by,
unified_code: unified_code.map(Some),
unified_message: unified_message.map(Some),
connector_transaction_id,
processor_transaction_data,
amount: None,
net_amount: None,
currency: None,
amount_to_capture: None,
connector: None,
authentication_type: None,
payment_method: None,
payment_method_id: None,
cancellation_reason: None,
mandate_id: None,
browser_info: None,
payment_token: None,
connector_metadata: None,
payment_method_data: None,
payment_method_type: None,
payment_experience: None,
business_sub_label: None,
straight_through_algorithm: None,
preprocessing_step_id: None,
capture_method: None,
connector_response_reference_id: None,
multiple_capture_count: None,
surcharge_amount: None,
tax_amount: None,
amount_capturable: None,
merchant_connector_id: None,
authentication_data: None,
encoded_data: None,
external_three_ds_authentication_attempted: None,
authentication_connector: None,
authentication_id: None,
fingerprint_id: None,
payment_method_billing_address_id: None,
client_source: None,
client_version: None,
customer_acceptance: None,
card_network: None,
shipping_cost: None,
capture_before: None,
extended_authorization_applied: None,
order_tax_amount: None,
connector_mandate_detail: None,
card_discovery: None,
charges: None,
issuer_error_code: None,
issuer_error_message: None,
}
}
PaymentAttemptUpdate::PostSessionTokensUpdate {
updated_by,
connector_metadata,
} => Self {
status: None,
error_code: None,
modified_at: common_utils::date_time::now(),
error_message: None,
error_reason: None,
updated_by,
unified_code: None,
unified_message: None,
amount: None,
net_amount: None,
currency: None,
connector_transaction_id: None,
amount_to_capture: None,
connector: None,
authentication_type: None,
payment_method: None,
payment_method_id: None,
cancellation_reason: None,
mandate_id: None,
browser_info: None,
payment_token: None,
connector_metadata,
payment_method_data: None,
payment_method_type: None,
payment_experience: None,
business_sub_label: None,
straight_through_algorithm: None,
preprocessing_step_id: None,
capture_method: None,
connector_response_reference_id: None,
multiple_capture_count: None,
surcharge_amount: None,
tax_amount: None,
amount_capturable: None,
merchant_connector_id: None,
authentication_data: None,
encoded_data: None,
external_three_ds_authentication_attempted: None,
authentication_connector: None,
authentication_id: None,
fingerprint_id: None,
payment_method_billing_address_id: None,
client_source: None,
client_version: None,
customer_acceptance: None,
card_network: None,
shipping_cost: None,
order_tax_amount: None,
capture_before: None,
extended_authorization_applied: None,
processor_transaction_data: None,
connector_mandate_detail: None,
card_discovery: None,
charges: None,
issuer_error_code: None,
issuer_error_message: None,
},
}
}
}
#[derive(Eq, PartialEq, Clone, Debug, Deserialize, Serialize, diesel::AsExpression)]
#[diesel(sql_type = diesel::sql_types::Jsonb)]
pub enum RedirectForm {
Form {
endpoint: String,
method: common_utils::request::Method,
form_fields: std::collections::HashMap<String, String>,
},
Html {
html_data: String,
},
BlueSnap {
payment_fields_token: String,
},
CybersourceAuthSetup {
access_token: String,
ddc_url: String,
reference_id: String,
},
CybersourceConsumerAuth {
access_token: String,
step_up_url: String,
},
DeutschebankThreeDSChallengeFlow {
acs_url: String,
creq: String,
},
Payme,
Braintree {
client_token: String,
card_token: String,
bin: String,
acs_url: String,
},
Nmi {
amount: String,
currency: common_enums::Currency,
public_key: masking::Secret<String>,
customer_vault_id: String,
order_id: String,
},
Mifinity {
initialization_token: String,
},
WorldpayDDCForm {
endpoint: common_utils::types::Url,
method: common_utils::request::Method,
form_fields: std::collections::HashMap<String, String>,
collection_id: Option<String>,
},
}
common_utils::impl_to_sql_from_sql_json!(RedirectForm);
#[cfg(feature = "v2")]
#[derive(
Clone, Debug, serde::Deserialize, serde::Serialize, Eq, PartialEq, diesel::AsExpression,
)]
#[diesel(sql_type = diesel::pg::sql_types::Jsonb)]
pub struct PaymentAttemptFeatureMetadata {
pub revenue_recovery: Option<PaymentAttemptRecoveryData>,
}
#[cfg(feature = "v2")]
#[derive(
Clone, Debug, serde::Deserialize, serde::Serialize, Eq, PartialEq, diesel::AsExpression,
)]
#[diesel(sql_type = diesel::pg::sql_types::Jsonb)]
pub struct PaymentAttemptRecoveryData {
pub attempt_triggered_by: common_enums::TriggeredBy,
}
#[cfg(feature = "v2")]
common_utils::impl_to_sql_from_sql_json!(PaymentAttemptFeatureMetadata);
mod tests {
#[test]
fn test_backwards_compatibility() {
let serialized_payment_attempt = r#"{
"payment_id": "PMT123456789",
"merchant_id": "M123456789",
"attempt_id": "ATMPT123456789",
"status": "pending",
"amount": 10000,
"currency": "USD",
"save_to_locker": true,
"connector": "stripe",
"error_message": null,
"offer_amount": 9500,
"surcharge_amount": 500,
"tax_amount": 800,
"payment_method_id": "CRD123456789",
"payment_method": "card",
"connector_transaction_id": "CNTR123456789",
"capture_method": "automatic",
"capture_on": "2022-09-10T10:11:12Z",
"confirm": false,
"authentication_type": "no_three_ds",
"created_at": "2024-02-26T12:00:00Z",
"modified_at": "2024-02-26T12:00:00Z",
"last_synced": null,
"cancellation_reason": null,
"amount_to_capture": 10000,
"mandate_id": null,
"browser_info": {
"user_agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/70.0.3538.110 Safari/537.36",
"accept_header": "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8",
"language": "nl-NL",
"color_depth": 24,
"screen_height": 723,
"screen_width": 1536,
"time_zone": 0,
"java_enabled": true,
"java_script_enabled": true,
"ip_address": "127.0.0.1"
},
"error_code": null,
"payment_token": "TOKEN123456789",
"connector_metadata": null,
"payment_experience": "redirect_to_url",
"payment_method_type": "credit",
"payment_method_data": {
"card": {
"card_number": "4242424242424242",
"card_exp_month": "10",
"card_cvc": "123",
"card_exp_year": "2024",
"card_holder_name": "John Doe"
}
},
"business_sub_label": "Premium",
"straight_through_algorithm": null,
"preprocessing_step_id": null,
"mandate_details": null,
"error_reason": null,
"multiple_capture_count": 0,
"connector_response_reference_id": null,
"amount_capturable": 10000,
"updated_by": "redis_kv",
"merchant_connector_id": "MCN123456789",
"authentication_data": null,
"encoded_data": null,
"unified_code": null,
"unified_message": null,
"net_amount": 10200,
"mandate_data": {
"customer_acceptance": {
"acceptance_type": "offline",
"accepted_at": "1963-05-03T04:07:52.723Z",
"online": {
"ip_address": "127.0.0.1",
"user_agent": "amet irure esse"
}
},
"single_use": {
"amount": 6540,
"currency": "USD"
}
}
},
"fingerprint_id": null
}"#;
let deserialized =
serde_json::from_str::<super::PaymentAttempt>(serialized_payment_attempt);
assert!(deserialized.is_ok());
}
}
| proc_macro_neighborhoods |
<file_sep path="hyperswitch/crates/router_derive/src/lib.rs" crate="router_derive" role="macro_def">
<|fim_prefix|>
<|meta_start|><|file|> hyperswitch/crates/router_derive/src/lib.rs<|crate|> diesel_models macro=DebugAsDisplay roles=use_site,macro_def use=derive item=file pack=proc_macro_neighborhoods lang=rust<|meta_end|>
pub fn debug_as_display_derive(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
<|fim_suffix|>
<|fim_middle|>
}
<file_sep path="hyperswitch/crates/router_derive/src/lib.rs" crate="router_derive" role="macro_def">
<|fim_prefix|>
pub fn debug_as_display_derive(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
<|fim_suffix|>
<|fim_middle|>
}
| proc_macro_neighborhoods |
<|meta_start|><|file|> hyperswitch/crates/router_derive/src/lib.rs<|crate|> diesel_models macro=DebugAsDisplay roles=use_site,macro_def use=derive item=file pack=proc_macro_neighborhoods lang=rust<|meta_end|>
<file_sep path="hyperswitch/crates/diesel_models/src/payment_attempt.rs" crate="diesel_models" role="use_site">
use common_types::primitive_wrappers::{
ExtendedAuthorizationAppliedBool, RequestExtendedAuthorizationBool,
};
use common_utils::{
id_type, pii,
types::{ConnectorTransactionId, ConnectorTransactionIdTrait, MinorUnit},
};
use diesel::{AsChangeset, Identifiable, Insertable, Queryable, Selectable};
use serde::{Deserialize, Serialize};
use time::PrimitiveDateTime;
use crate::enums as storage_enums;
#[cfg(feature = "v1")]
use crate::schema::payment_attempt;
#[cfg(feature = "v2")]
use crate::schema_v2::payment_attempt;
common_utils::impl_to_sql_from_sql_json!(ConnectorMandateReferenceId);
#[derive(
Clone, Debug, serde::Deserialize, serde::Serialize, Eq, PartialEq, diesel::AsExpression,
)]
#[diesel(sql_type = diesel::sql_types::Jsonb)]
pub struct ConnectorMandateReferenceId {
pub connector_mandate_id: Option<String>,
pub payment_method_id: Option<String>,
pub mandate_metadata: Option<pii::SecretSerdeValue>,
pub connector_mandate_request_reference_id: Option<String>,
}
impl ConnectorMandateReferenceId {
pub fn get_connector_mandate_request_reference_id(&self) -> Option<String> {
self.connector_mandate_request_reference_id.clone()
}
}
#[cfg(feature = "v2")]
#[derive(
Clone, Debug, Eq, PartialEq, Identifiable, Queryable, Serialize, Deserialize, Selectable,
)]
#[diesel(table_name = payment_attempt, primary_key(id), check_for_backend(diesel::pg::Pg))]
pub struct PaymentAttempt {
pub payment_id: id_type::GlobalPaymentId,
pub merchant_id: id_type::MerchantId,
pub status: storage_enums::AttemptStatus,
pub connector: Option<String>,
pub error_message: Option<String>,
pub surcharge_amount: Option<MinorUnit>,
pub payment_method_id: Option<id_type::GlobalPaymentMethodId>,
pub authentication_type: storage_enums::AuthenticationType,
#[serde(with = "common_utils::custom_serde::iso8601")]
pub created_at: PrimitiveDateTime,
#[serde(with = "common_utils::custom_serde::iso8601")]
pub modified_at: PrimitiveDateTime,
#[serde(default, with = "common_utils::custom_serde::iso8601::option")]
pub last_synced: Option<PrimitiveDateTime>,
pub cancellation_reason: Option<String>,
pub amount_to_capture: Option<MinorUnit>,
pub browser_info: Option<common_utils::types::BrowserInformation>,
pub error_code: Option<String>,
pub payment_token: Option<String>,
pub connector_metadata: Option<pii::SecretSerdeValue>,
pub payment_experience: Option<storage_enums::PaymentExperience>,
pub payment_method_data: Option<pii::SecretSerdeValue>,
pub preprocessing_step_id: Option<String>,
pub error_reason: Option<String>,
pub multiple_capture_count: Option<i16>,
pub connector_response_reference_id: Option<String>,
pub amount_capturable: MinorUnit,
pub updated_by: String,
pub merchant_connector_id: Option<id_type::MerchantConnectorAccountId>,
pub encoded_data: Option<masking::Secret<String>>,
pub unified_code: Option<String>,
pub unified_message: Option<String>,
pub net_amount: MinorUnit,
pub external_three_ds_authentication_attempted: Option<bool>,
pub authentication_connector: Option<String>,
pub authentication_id: Option<String>,
pub fingerprint_id: Option<String>,
pub client_source: Option<String>,
pub client_version: Option<String>,
pub customer_acceptance: Option<pii::SecretSerdeValue>,
pub profile_id: id_type::ProfileId,
pub organization_id: id_type::OrganizationId,
pub card_network: Option<String>,
pub shipping_cost: Option<MinorUnit>,
pub order_tax_amount: Option<MinorUnit>,
pub request_extended_authorization: Option<RequestExtendedAuthorizationBool>,
pub extended_authorization_applied: Option<ExtendedAuthorizationAppliedBool>,
pub capture_before: Option<PrimitiveDateTime>,
pub card_discovery: Option<storage_enums::CardDiscovery>,
pub charges: Option<common_types::payments::ConnectorChargeResponseData>,
pub payment_method_type_v2: storage_enums::PaymentMethod,
pub connector_payment_id: Option<ConnectorTransactionId>,
pub payment_method_subtype: storage_enums::PaymentMethodType,
pub routing_result: Option<serde_json::Value>,
pub authentication_applied: Option<common_enums::AuthenticationType>,
pub external_reference_id: Option<String>,
pub tax_on_surcharge: Option<MinorUnit>,
pub payment_method_billing_address: Option<common_utils::encryption::Encryption>,
pub redirection_data: Option<RedirectForm>,
pub connector_payment_data: Option<String>,
pub connector_token_details: Option<ConnectorTokenDetails>,
pub id: id_type::GlobalAttemptId,
pub feature_metadata: Option<PaymentAttemptFeatureMetadata>,
/// This field can be returned for both approved and refused Mastercard payments.
/// This code provides additional information about the type of transaction or the reason why the payment failed.
/// If the payment failed, the network advice code gives guidance on if and when you can retry the payment.
pub network_advice_code: Option<String>,
/// For card errors resulting from a card issuer decline, a brand specific 2, 3, or 4 digit code which indicates the reason the authorization failed.
pub network_decline_code: Option<String>,
/// A string indicating how to proceed with an network error if payment gateway provide one. This is used to understand the network error code better.
pub network_error_message: Option<String>,
}
#[cfg(feature = "v1")]
#[derive(
Clone, Debug, Eq, PartialEq, Identifiable, Queryable, Serialize, Deserialize, Selectable,
)]
#[diesel(table_name = payment_attempt, primary_key(attempt_id, merchant_id), check_for_backend(diesel::pg::Pg))]
pub struct PaymentAttempt {
pub payment_id: id_type::PaymentId,
pub merchant_id: id_type::MerchantId,
pub attempt_id: String,
pub status: storage_enums::AttemptStatus,
pub amount: MinorUnit,
pub currency: Option<storage_enums::Currency>,
pub save_to_locker: Option<bool>,
pub connector: Option<String>,
pub error_message: Option<String>,
pub offer_amount: Option<MinorUnit>,
pub surcharge_amount: Option<MinorUnit>,
pub tax_amount: Option<MinorUnit>,
pub payment_method_id: Option<String>,
pub payment_method: Option<storage_enums::PaymentMethod>,
pub connector_transaction_id: Option<ConnectorTransactionId>,
pub capture_method: Option<storage_enums::CaptureMethod>,
#[serde(default, with = "common_utils::custom_serde::iso8601::option")]
pub capture_on: Option<PrimitiveDateTime>,
pub confirm: bool,
pub authentication_type: Option<storage_enums::AuthenticationType>,
#[serde(with = "common_utils::custom_serde::iso8601")]
pub created_at: PrimitiveDateTime,
#[serde(with = "common_utils::custom_serde::iso8601")]
pub modified_at: PrimitiveDateTime,
#[serde(default, with = "common_utils::custom_serde::iso8601::option")]
pub last_synced: Option<PrimitiveDateTime>,
pub cancellation_reason: Option<String>,
pub amount_to_capture: Option<MinorUnit>,
pub mandate_id: Option<String>,
pub browser_info: Option<serde_json::Value>,
pub error_code: Option<String>,
pub payment_token: Option<String>,
pub connector_metadata: Option<serde_json::Value>,
pub payment_experience: Option<storage_enums::PaymentExperience>,
pub payment_method_type: Option<storage_enums::PaymentMethodType>,
pub payment_method_data: Option<serde_json::Value>,
pub business_sub_label: Option<String>,
pub straight_through_algorithm: Option<serde_json::Value>,
pub preprocessing_step_id: Option<String>,
// providing a location to store mandate details intermediately for transaction
pub mandate_details: Option<storage_enums::MandateDataType>,
pub error_reason: Option<String>,
pub multiple_capture_count: Option<i16>,
// reference to the payment at connector side
pub connector_response_reference_id: Option<String>,
pub amount_capturable: MinorUnit,
pub updated_by: String,
pub merchant_connector_id: Option<id_type::MerchantConnectorAccountId>,
pub authentication_data: Option<serde_json::Value>,
pub encoded_data: Option<String>,
pub unified_code: Option<String>,
pub unified_message: Option<String>,
pub net_amount: Option<MinorUnit>,
pub external_three_ds_authentication_attempted: Option<bool>,
pub authentication_connector: Option<String>,
pub authentication_id: Option<String>,
pub mandate_data: Option<storage_enums::MandateDetails>,
pub fingerprint_id: Option<String>,
pub payment_method_billing_address_id: Option<String>,
pub charge_id: Option<String>,
pub client_source: Option<String>,
pub client_version: Option<String>,
pub customer_acceptance: Option<pii::SecretSerdeValue>,
pub profile_id: id_type::ProfileId,
pub organization_id: id_type::OrganizationId,
pub card_network: Option<String>,
pub shipping_cost: Option<MinorUnit>,
pub order_tax_amount: Option<MinorUnit>,
/// INFO: This field is deprecated and replaced by processor_transaction_data
pub connector_transaction_data: Option<String>,
pub connector_mandate_detail: Option<ConnectorMandateReferenceId>,
pub request_extended_authorization: Option<RequestExtendedAuthorizationBool>,
pub extended_authorization_applied: Option<ExtendedAuthorizationAppliedBool>,
pub capture_before: Option<PrimitiveDateTime>,
pub processor_transaction_data: Option<String>,
pub card_discovery: Option<storage_enums::CardDiscovery>,
pub charges: Option<common_types::payments::ConnectorChargeResponseData>,
pub issuer_error_code: Option<String>,
pub issuer_error_message: Option<String>,
}
#[cfg(feature = "v1")]
impl ConnectorTransactionIdTrait for PaymentAttempt {
fn get_optional_connector_transaction_id(&self) -> Option<&String> {
match self
.connector_transaction_id
.as_ref()
.map(|txn_id| txn_id.get_txn_id(self.processor_transaction_data.as_ref()))
.transpose()
{
Ok(txn_id) => txn_id,
// In case hashed data is missing from DB, use the hashed ID as connector transaction ID
Err(_) => self
.connector_transaction_id
.as_ref()
.map(|txn_id| txn_id.get_id()),
}
}
}
#[cfg(feature = "v2")]
impl ConnectorTransactionIdTrait for PaymentAttempt {
fn get_optional_connector_transaction_id(&self) -> Option<&String> {
match self
.connector_payment_id
.as_ref()
.map(|txn_id| txn_id.get_txn_id(self.connector_payment_data.as_ref()))
.transpose()
{
Ok(txn_id) => txn_id,
// In case hashed data is missing from DB, use the hashed ID as connector payment ID
Err(_) => self
.connector_payment_id
.as_ref()
.map(|txn_id| txn_id.get_id()),
}
}
}
#[cfg(feature = "v2")]
#[derive(
Clone, Debug, PartialEq, Eq, serde::Deserialize, serde::Serialize, diesel::AsExpression,
)]
#[diesel(sql_type = diesel::sql_types::Jsonb)]
pub struct ConnectorTokenDetails {
pub connector_mandate_id: Option<String>,
pub connector_token_request_reference_id: Option<String>,
}
#[cfg(feature = "v2")]
common_utils::impl_to_sql_from_sql_json!(ConnectorTokenDetails);
#[cfg(feature = "v2")]
impl ConnectorTokenDetails {
pub fn get_connector_token_request_reference_id(&self) -> Option<String> {
self.connector_token_request_reference_id.clone()
}
}
#[derive(Clone, Debug, Eq, PartialEq, Queryable, Serialize, Deserialize)]
pub struct PaymentListFilters {
pub connector: Vec<String>,
pub currency: Vec<storage_enums::Currency>,
pub status: Vec<storage_enums::IntentStatus>,
pub payment_method: Vec<storage_enums::PaymentMethod>,
}
#[cfg(feature = "v2")]
#[derive(Clone, Debug, Insertable, router_derive::DebugAsDisplay, Serialize, Deserialize)]
#[diesel(table_name = payment_attempt)]
pub struct PaymentAttemptNew {
pub payment_id: id_type::GlobalPaymentId,
pub merchant_id: id_type::MerchantId,
pub status: storage_enums::AttemptStatus,
pub error_message: Option<String>,
pub surcharge_amount: Option<MinorUnit>,
pub tax_on_surcharge: Option<MinorUnit>,
pub payment_method_id: Option<id_type::GlobalPaymentMethodId>,
pub authentication_type: storage_enums::AuthenticationType,
#[serde(with = "common_utils::custom_serde::iso8601")]
pub created_at: PrimitiveDateTime,
#[serde(with = "common_utils::custom_serde::iso8601")]
pub modified_at: PrimitiveDateTime,
#[serde(default, with = "common_utils::custom_serde::iso8601::option")]
pub last_synced: Option<PrimitiveDateTime>,
pub cancellation_reason: Option<String>,
pub amount_to_capture: Option<MinorUnit>,
pub browser_info: Option<common_utils::types::BrowserInformation>,
pub payment_token: Option<String>,
pub error_code: Option<String>,
pub connector_metadata: Option<pii::SecretSerdeValue>,
pub payment_experience: Option<storage_enums::PaymentExperience>,
pub payment_method_data: Option<pii::SecretSerdeValue>,
pub preprocessing_step_id: Option<String>,
pub error_reason: Option<String>,
pub connector_response_reference_id: Option<String>,
pub multiple_capture_count: Option<i16>,
pub amount_capturable: MinorUnit,
pub updated_by: String,
pub merchant_connector_id: Option<id_type::MerchantConnectorAccountId>,
pub redirection_data: Option<RedirectForm>,
pub encoded_data: Option<masking::Secret<String>>,
pub unified_code: Option<String>,
pub unified_message: Option<String>,
pub net_amount: MinorUnit,
pub external_three_ds_authentication_attempted: Option<bool>,
pub authentication_connector: Option<String>,
pub authentication_id: Option<String>,
pub fingerprint_id: Option<String>,
pub payment_method_billing_address: Option<common_utils::encryption::Encryption>,
pub client_source: Option<String>,
pub client_version: Option<String>,
pub customer_acceptance: Option<pii::SecretSerdeValue>,
pub profile_id: id_type::ProfileId,
pub organization_id: id_type::OrganizationId,
pub card_network: Option<String>,
pub shipping_cost: Option<MinorUnit>,
pub order_tax_amount: Option<MinorUnit>,
pub charges: Option<common_types::payments::ConnectorChargeResponseData>,
pub feature_metadata: Option<PaymentAttemptFeatureMetadata>,
pub payment_method_type_v2: storage_enums::PaymentMethod,
pub connector_payment_id: Option<ConnectorTransactionId>,
pub payment_method_subtype: storage_enums::PaymentMethodType,
pub id: id_type::GlobalAttemptId,
pub connector_token_details: Option<ConnectorTokenDetails>,
pub card_discovery: Option<storage_enums::CardDiscovery>,
pub request_extended_authorization: Option<RequestExtendedAuthorizationBool>,
pub extended_authorization_applied: Option<ExtendedAuthorizationAppliedBool>,
pub capture_before: Option<PrimitiveDateTime>,
pub connector: Option<String>,
pub network_decline_code: Option<String>,
pub network_advice_code: Option<String>,
pub network_error_message: Option<String>,
}
#[cfg(feature = "v1")]
#[derive(Clone, Debug, Insertable, router_derive::DebugAsDisplay, Serialize, Deserialize)]
#[diesel(table_name = payment_attempt)]
pub struct PaymentAttemptNew {
pub payment_id: id_type::PaymentId,
pub merchant_id: id_type::MerchantId,
pub attempt_id: String,
pub status: storage_enums::AttemptStatus,
pub amount: MinorUnit,
pub currency: Option<storage_enums::Currency>,
// pub auto_capture: Option<bool>,
pub save_to_locker: Option<bool>,
pub connector: Option<String>,
pub error_message: Option<String>,
pub offer_amount: Option<MinorUnit>,
pub surcharge_amount: Option<MinorUnit>,
pub tax_amount: Option<MinorUnit>,
pub payment_method_id: Option<String>,
pub payment_method: Option<storage_enums::PaymentMethod>,
pub capture_method: Option<storage_enums::CaptureMethod>,
#[serde(default, with = "common_utils::custom_serde::iso8601::option")]
pub capture_on: Option<PrimitiveDateTime>,
pub confirm: bool,
pub authentication_type: Option<storage_enums::AuthenticationType>,
#[serde(with = "common_utils::custom_serde::iso8601")]
pub created_at: PrimitiveDateTime,
#[serde(with = "common_utils::custom_serde::iso8601")]
pub modified_at: PrimitiveDateTime,
#[serde(default, with = "common_utils::custom_serde::iso8601::option")]
pub last_synced: Option<PrimitiveDateTime>,
pub cancellation_reason: Option<String>,
pub amount_to_capture: Option<MinorUnit>,
pub mandate_id: Option<String>,
pub browser_info: Option<serde_json::Value>,
pub payment_token: Option<String>,
pub error_code: Option<String>,
pub connector_metadata: Option<serde_json::Value>,
pub payment_experience: Option<storage_enums::PaymentExperience>,
pub payment_method_type: Option<storage_enums::PaymentMethodType>,
pub payment_method_data: Option<serde_json::Value>,
pub business_sub_label: Option<String>,
pub straight_through_algorithm: Option<serde_json::Value>,
pub preprocessing_step_id: Option<String>,
pub mandate_details: Option<storage_enums::MandateDataType>,
pub error_reason: Option<String>,
pub connector_response_reference_id: Option<String>,
pub multiple_capture_count: Option<i16>,
pub amount_capturable: MinorUnit,
pub updated_by: String,
pub merchant_connector_id: Option<id_type::MerchantConnectorAccountId>,
pub authentication_data: Option<serde_json::Value>,
pub encoded_data: Option<String>,
pub unified_code: Option<String>,
pub unified_message: Option<String>,
pub net_amount: Option<MinorUnit>,
pub external_three_ds_authentication_attempted: Option<bool>,
pub authentication_connector: Option<String>,
pub authentication_id: Option<String>,
pub mandate_data: Option<storage_enums::MandateDetails>,
pub fingerprint_id: Option<String>,
pub payment_method_billing_address_id: Option<String>,
pub client_source: Option<String>,
pub client_version: Option<String>,
pub customer_acceptance: Option<pii::SecretSerdeValue>,
pub profile_id: id_type::ProfileId,
pub organization_id: id_type::OrganizationId,
pub card_network: Option<String>,
pub shipping_cost: Option<MinorUnit>,
pub order_tax_amount: Option<MinorUnit>,
pub connector_mandate_detail: Option<ConnectorMandateReferenceId>,
pub request_extended_authorization: Option<RequestExtendedAuthorizationBool>,
pub extended_authorization_applied: Option<ExtendedAuthorizationAppliedBool>,
#[serde(default, with = "common_utils::custom_serde::iso8601::option")]
pub capture_before: Option<PrimitiveDateTime>,
pub card_discovery: Option<storage_enums::CardDiscovery>,
}
#[cfg(feature = "v1")]
#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum PaymentAttemptUpdate {
Update {
amount: MinorUnit,
currency: storage_enums::Currency,
status: storage_enums::AttemptStatus,
authentication_type: Option<storage_enums::AuthenticationType>,
payment_method: Option<storage_enums::PaymentMethod>,
payment_token: Option<String>,
payment_method_data: Option<serde_json::Value>,
payment_method_type: Option<storage_enums::PaymentMethodType>,
payment_experience: Option<storage_enums::PaymentExperience>,
business_sub_label: Option<String>,
amount_to_capture: Option<MinorUnit>,
capture_method: Option<storage_enums::CaptureMethod>,
surcharge_amount: Option<MinorUnit>,
tax_amount: Option<MinorUnit>,
fingerprint_id: Option<String>,
payment_method_billing_address_id: Option<String>,
updated_by: String,
},
UpdateTrackers {
payment_token: Option<String>,
connector: Option<String>,
straight_through_algorithm: Option<serde_json::Value>,
amount_capturable: Option<MinorUnit>,
surcharge_amount: Option<MinorUnit>,
tax_amount: Option<MinorUnit>,
updated_by: String,
merchant_connector_id: Option<id_type::MerchantConnectorAccountId>,
},
AuthenticationTypeUpdate {
authentication_type: storage_enums::AuthenticationType,
updated_by: String,
},
ConfirmUpdate {
amount: MinorUnit,
currency: storage_enums::Currency,
status: storage_enums::AttemptStatus,
authentication_type: Option<storage_enums::AuthenticationType>,
capture_method: Option<storage_enums::CaptureMethod>,
payment_method: Option<storage_enums::PaymentMethod>,
browser_info: Option<serde_json::Value>,
connector: Option<String>,
payment_token: Option<String>,
payment_method_data: Option<serde_json::Value>,
payment_method_type: Option<storage_enums::PaymentMethodType>,
payment_experience: Option<storage_enums::PaymentExperience>,
business_sub_label: Option<String>,
straight_through_algorithm: Option<serde_json::Value>,
error_code: Option<Option<String>>,
error_message: Option<Option<String>>,
amount_capturable: Option<MinorUnit>,
surcharge_amount: Option<MinorUnit>,
tax_amount: Option<MinorUnit>,
fingerprint_id: Option<String>,
updated_by: String,
merchant_connector_id: Option<id_type::MerchantConnectorAccountId>,
payment_method_id: Option<String>,
external_three_ds_authentication_attempted: Option<bool>,
authentication_connector: Option<String>,
authentication_id: Option<String>,
payment_method_billing_address_id: Option<String>,
client_source: Option<String>,
client_version: Option<String>,
customer_acceptance: Option<pii::SecretSerdeValue>,
shipping_cost: Option<MinorUnit>,
order_tax_amount: Option<MinorUnit>,
connector_mandate_detail: Option<ConnectorMandateReferenceId>,
card_discovery: Option<storage_enums::CardDiscovery>,
},
VoidUpdate {
status: storage_enums::AttemptStatus,
cancellation_reason: Option<String>,
updated_by: String,
},
PaymentMethodDetailsUpdate {
payment_method_id: Option<String>,
updated_by: String,
},
ConnectorMandateDetailUpdate {
connector_mandate_detail: Option<ConnectorMandateReferenceId>,
updated_by: String,
},
BlocklistUpdate {
status: storage_enums::AttemptStatus,
error_code: Option<Option<String>>,
error_message: Option<Option<String>>,
updated_by: String,
},
RejectUpdate {
status: storage_enums::AttemptStatus,
error_code: Option<Option<String>>,
error_message: Option<Option<String>>,
updated_by: String,
},
ResponseUpdate {
status: storage_enums::AttemptStatus,
connector: Option<String>,
connector_transaction_id: Option<String>,
authentication_type: Option<storage_enums::AuthenticationType>,
payment_method_id: Option<String>,
mandate_id: Option<String>,
connector_metadata: Option<serde_json::Value>,
payment_token: Option<String>,
error_code: Option<Option<String>>,
error_message: Option<Option<String>>,
error_reason: Option<Option<String>>,
connector_response_reference_id: Option<String>,
amount_capturable: Option<MinorUnit>,
updated_by: String,
authentication_data: Option<serde_json::Value>,
encoded_data: Option<String>,
unified_code: Option<Option<String>>,
unified_message: Option<Option<String>>,
capture_before: Option<PrimitiveDateTime>,
extended_authorization_applied: Option<ExtendedAuthorizationAppliedBool>,
payment_method_data: Option<serde_json::Value>,
connector_mandate_detail: Option<ConnectorMandateReferenceId>,
charges: Option<common_types::payments::ConnectorChargeResponseData>,
},
UnresolvedResponseUpdate {
status: storage_enums::AttemptStatus,
connector: Option<String>,
connector_transaction_id: Option<String>,
payment_method_id: Option<String>,
error_code: Option<Option<String>>,
error_message: Option<Option<String>>,
error_reason: Option<Option<String>>,
connector_response_reference_id: Option<String>,
updated_by: String,
},
StatusUpdate {
status: storage_enums::AttemptStatus,
updated_by: String,
},
ErrorUpdate {
connector: Option<String>,
status: storage_enums::AttemptStatus,
error_code: Option<Option<String>>,
error_message: Option<Option<String>>,
error_reason: Option<Option<String>>,
amount_capturable: Option<MinorUnit>,
updated_by: String,
unified_code: Option<Option<String>>,
unified_message: Option<Option<String>>,
connector_transaction_id: Option<String>,
payment_method_data: Option<serde_json::Value>,
authentication_type: Option<storage_enums::AuthenticationType>,
issuer_error_code: Option<String>,
issuer_error_message: Option<String>,
},
CaptureUpdate {
amount_to_capture: Option<MinorUnit>,
multiple_capture_count: Option<i16>,
updated_by: String,
},
AmountToCaptureUpdate {
status: storage_enums::AttemptStatus,
amount_capturable: MinorUnit,
updated_by: String,
},
PreprocessingUpdate {
status: storage_enums::AttemptStatus,
payment_method_id: Option<String>,
connector_metadata: Option<serde_json::Value>,
preprocessing_step_id: Option<String>,
connector_transaction_id: Option<String>,
connector_response_reference_id: Option<String>,
updated_by: String,
},
ConnectorResponse {
authentication_data: Option<serde_json::Value>,
encoded_data: Option<String>,
connector_transaction_id: Option<String>,
connector: Option<String>,
charges: Option<common_types::payments::ConnectorChargeResponseData>,
updated_by: String,
},
IncrementalAuthorizationAmountUpdate {
amount: MinorUnit,
amount_capturable: MinorUnit,
},
AuthenticationUpdate {
status: storage_enums::AttemptStatus,
external_three_ds_authentication_attempted: Option<bool>,
authentication_connector: Option<String>,
authentication_id: Option<String>,
updated_by: String,
},
ManualUpdate {
status: Option<storage_enums::AttemptStatus>,
error_code: Option<String>,
error_message: Option<String>,
error_reason: Option<String>,
updated_by: String,
unified_code: Option<String>,
unified_message: Option<String>,
connector_transaction_id: Option<String>,
},
PostSessionTokensUpdate {
updated_by: String,
connector_metadata: Option<serde_json::Value>,
},
}
#[cfg(feature = "v2")]
#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum PaymentAttemptUpdate {
// Update {
// amount: MinorUnit,
// currency: storage_enums::Currency,
// status: storage_enums::AttemptStatus,
// authentication_type: Option<storage_enums::AuthenticationType>,
// payment_method: Option<storage_enums::PaymentMethod>,
// payment_token: Option<String>,
// payment_method_data: Option<serde_json::Value>,
// payment_method_type: Option<storage_enums::PaymentMethodType>,
// payment_experience: Option<storage_enums::PaymentExperience>,
// business_sub_label: Option<String>,
// amount_to_capture: Option<MinorUnit>,
// capture_method: Option<storage_enums::CaptureMethod>,
// surcharge_amount: Option<MinorUnit>,
// tax_amount: Option<MinorUnit>,
// fingerprint_id: Option<String>,
// payment_method_billing_address_id: Option<String>,
// updated_by: String,
// },
// UpdateTrackers {
// payment_token: Option<String>,
// connector: Option<String>,
// straight_through_algorithm: Option<serde_json::Value>,
// amount_capturable: Option<MinorUnit>,
// surcharge_amount: Option<MinorUnit>,
// tax_amount: Option<MinorUnit>,
// updated_by: String,
// merchant_connector_id: Option<id_type::MerchantConnectorAccountId>,
// },
// AuthenticationTypeUpdate {
// authentication_type: storage_enums::AuthenticationType,
// updated_by: String,
// },
// ConfirmUpdate {
// amount: MinorUnit,
// currency: storage_enums::Currency,
// status: storage_enums::AttemptStatus,
// authentication_type: Option<storage_enums::AuthenticationType>,
// capture_method: Option<storage_enums::CaptureMethod>,
// payment_method: Option<storage_enums::PaymentMethod>,
// browser_info: Option<serde_json::Value>,
// connector: Option<String>,
// payment_token: Option<String>,
// payment_method_data: Option<serde_json::Value>,
// payment_method_type: Option<storage_enums::PaymentMethodType>,
// payment_experience: Option<storage_enums::PaymentExperience>,
// business_sub_label: Option<String>,
// straight_through_algorithm: Option<serde_json::Value>,
// error_code: Option<Option<String>>,
// error_message: Option<Option<String>>,
// amount_capturable: Option<MinorUnit>,
// surcharge_amount: Option<MinorUnit>,
// tax_amount: Option<MinorUnit>,
// fingerprint_id: Option<String>,
// updated_by: String,
// merchant_connector_id: Option<id_type::MerchantConnectorAccountId>,
// payment_method_id: Option<String>,
// external_three_ds_authentication_attempted: Option<bool>,
// authentication_connector: Option<String>,
// authentication_id: Option<String>,
// payment_method_billing_address_id: Option<String>,
// client_source: Option<String>,
// client_version: Option<String>,
// customer_acceptance: Option<pii::SecretSerdeValue>,
// },
// VoidUpdate {
// status: storage_enums::AttemptStatus,
// cancellation_reason: Option<String>,
// updated_by: String,
// },
// PaymentMethodDetailsUpdate {
// payment_method_id: Option<String>,
// updated_by: String,
// },
// ConnectorMandateDetailUpdate {
// connector_mandate_detail: Option<ConnectorMandateReferenceId>,
// updated_by: String,
// }
// BlocklistUpdate {
// status: storage_enums::AttemptStatus,
// error_code: Option<Option<String>>,
// error_message: Option<Option<String>>,
// updated_by: String,
// },
// RejectUpdate {
// status: storage_enums::AttemptStatus,
// error_code: Option<Option<String>>,
// error_message: Option<Option<String>>,
// updated_by: String,
// },
// ResponseUpdate {
// status: storage_enums::AttemptStatus,
// connector: Option<String>,
// connector_transaction_id: Option<String>,
// authentication_type: Option<storage_enums::AuthenticationType>,
// payment_method_id: Option<String>,
// mandate_id: Option<String>,
// connector_metadata: Option<serde_json::Value>,
// payment_token: Option<String>,
// error_code: Option<Option<String>>,
// error_message: Option<Option<String>>,
// error_reason: Option<Option<String>>,
// connector_response_reference_id: Option<String>,
// amount_capturable: Option<MinorUnit>,
// updated_by: String,
// authentication_data: Option<serde_json::Value>,
// encoded_data: Option<String>,
// unified_code: Option<Option<String>>,
// unified_message: Option<Option<String>>,
// payment_method_data: Option<serde_json::Value>,
// charge_id: Option<String>,
// },
// UnresolvedResponseUpdate {
// status: storage_enums::AttemptStatus,
// connector: Option<String>,
// connector_transaction_id: Option<String>,
// payment_method_id: Option<String>,
// error_code: Option<Option<String>>,
// error_message: Option<Option<String>>,
// error_reason: Option<Option<String>>,
// connector_response_reference_id: Option<String>,
// updated_by: String,
// },
// StatusUpdate {
// status: storage_enums::AttemptStatus,
// updated_by: String,
// },
// ErrorUpdate {
// connector: Option<String>,
// status: storage_enums::AttemptStatus,
// error_code: Option<Option<String>>,
// error_message: Option<Option<String>>,
// error_reason: Option<Option<String>>,
// amount_capturable: Option<MinorUnit>,
// updated_by: String,
// unified_code: Option<Option<String>>,
// unified_message: Option<Option<String>>,
// connector_transaction_id: Option<String>,
// payment_method_data: Option<serde_json::Value>,
// authentication_type: Option<storage_enums::AuthenticationType>,
// },
// CaptureUpdate {
// amount_to_capture: Option<MinorUnit>,
// multiple_capture_count: Option<MinorUnit>,
// updated_by: String,
// },
// AmountToCaptureUpdate {
// status: storage_enums::AttemptStatus,
// amount_capturable: MinorUnit,
// updated_by: String,
// },
// PreprocessingUpdate {
// status: storage_enums::AttemptStatus,
// payment_method_id: Option<String>,
// connector_metadata: Option<serde_json::Value>,
// preprocessing_step_id: Option<String>,
// connector_transaction_id: Option<String>,
// connector_response_reference_id: Option<String>,
// updated_by: String,
// },
// ConnectorResponse {
// authentication_data: Option<serde_json::Value>,
// encoded_data: Option<String>,
// connector_transaction_id: Option<String>,
// connector: Option<String>,
// charge_id: Option<String>,
// updated_by: String,
// },
// IncrementalAuthorizationAmountUpdate {
// amount: MinorUnit,
// amount_capturable: MinorUnit,
// },
// AuthenticationUpdate {
// status: storage_enums::AttemptStatus,
// external_three_ds_authentication_attempted: Option<bool>,
// authentication_connector: Option<String>,
// authentication_id: Option<String>,
// updated_by: String,
// },
// ManualUpdate {
// status: Option<storage_enums::AttemptStatus>,
// error_code: Option<String>,
// error_message: Option<String>,
// error_reason: Option<String>,
// updated_by: String,
// unified_code: Option<String>,
// unified_message: Option<String>,
// connector_transaction_id: Option<String>,
// },
}
// TODO: uncomment fields as and when required
#[cfg(feature = "v2")]
#[derive(Clone, Debug, AsChangeset, router_derive::DebugAsDisplay)]
#[diesel(table_name = payment_attempt)]
pub struct PaymentAttemptUpdateInternal {
pub status: Option<storage_enums::AttemptStatus>,
pub authentication_type: Option<storage_enums::AuthenticationType>,
pub error_message: Option<String>,
pub connector_payment_id: Option<String>,
// payment_method_id: Option<String>,
// cancellation_reason: Option<String>,
pub modified_at: PrimitiveDateTime,
pub browser_info: Option<serde_json::Value>,
// payment_token: Option<String>,
pub error_code: Option<String>,
pub connector_metadata: Option<pii::SecretSerdeValue>,
// payment_method_data: Option<serde_json::Value>,
// payment_experience: Option<storage_enums::PaymentExperience>,
// preprocessing_step_id: Option<String>,
pub error_reason: Option<String>,
// connector_response_reference_id: Option<String>,
// multiple_capture_count: Option<i16>,
// pub surcharge_amount: Option<MinorUnit>,
// tax_on_surcharge: Option<MinorUnit>,
pub amount_capturable: Option<MinorUnit>,
pub amount_to_capture: Option<MinorUnit>,
pub updated_by: String,
pub merchant_connector_id: Option<id_type::MerchantConnectorAccountId>,
pub connector: Option<String>,
pub redirection_data: Option<RedirectForm>,
// encoded_data: Option<String>,
pub unified_code: Option<Option<String>>,
pub unified_message: Option<Option<String>>,
// external_three_ds_authentication_attempted: Option<bool>,
// authentication_connector: Option<String>,
// authentication_id: Option<String>,
// fingerprint_id: Option<String>,
// charge_id: Option<String>,
// client_source: Option<String>,
// client_version: Option<String>,
// customer_acceptance: Option<pii::SecretSerdeValue>,
// card_network: Option<String>,
pub connector_token_details: Option<ConnectorTokenDetails>,
pub feature_metadata: Option<PaymentAttemptFeatureMetadata>,
pub network_decline_code: Option<String>,
pub network_advice_code: Option<String>,
pub network_error_message: Option<String>,
}
#[cfg(feature = "v1")]
#[derive(Clone, Debug, AsChangeset, router_derive::DebugAsDisplay)]
#[diesel(table_name = payment_attempt)]
pub struct PaymentAttemptUpdateInternal {
pub amount: Option<MinorUnit>,
pub net_amount: Option<MinorUnit>,
pub currency: Option<storage_enums::Currency>,
pub status: Option<storage_enums::AttemptStatus>,
pub connector_transaction_id: Option<ConnectorTransactionId>,
pub amount_to_capture: Option<MinorUnit>,
pub connector: Option<Option<String>>,
pub authentication_type: Option<storage_enums::AuthenticationType>,
pub payment_method: Option<storage_enums::PaymentMethod>,
pub error_message: Option<Option<String>>,
pub payment_method_id: Option<String>,
pub cancellation_reason: Option<String>,
pub modified_at: PrimitiveDateTime,
pub mandate_id: Option<String>,
pub browser_info: Option<serde_json::Value>,
pub payment_token: Option<String>,
pub error_code: Option<Option<String>>,
pub connector_metadata: Option<serde_json::Value>,
pub payment_method_data: Option<serde_json::Value>,
pub payment_method_type: Option<storage_enums::PaymentMethodType>,
pub payment_experience: Option<storage_enums::PaymentExperience>,
pub business_sub_label: Option<String>,
pub straight_through_algorithm: Option<serde_json::Value>,
pub preprocessing_step_id: Option<String>,
pub error_reason: Option<Option<String>>,
pub capture_method: Option<storage_enums::CaptureMethod>,
pub connector_response_reference_id: Option<String>,
pub multiple_capture_count: Option<i16>,
pub surcharge_amount: Option<MinorUnit>,
pub tax_amount: Option<MinorUnit>,
pub amount_capturable: Option<MinorUnit>,
pub updated_by: String,
pub merchant_connector_id: Option<Option<id_type::MerchantConnectorAccountId>>,
pub authentication_data: Option<serde_json::Value>,
pub encoded_data: Option<String>,
pub unified_code: Option<Option<String>>,
pub unified_message: Option<Option<String>>,
pub external_three_ds_authentication_attempted: Option<bool>,
pub authentication_connector: Option<String>,
pub authentication_id: Option<String>,
pub fingerprint_id: Option<String>,
pub payment_method_billing_address_id: Option<String>,
pub client_source: Option<String>,
pub client_version: Option<String>,
pub customer_acceptance: Option<pii::SecretSerdeValue>,
pub card_network: Option<String>,
pub capture_before: Option<PrimitiveDateTime>,
pub extended_authorization_applied: Option<ExtendedAuthorizationAppliedBool>,
pub shipping_cost: Option<MinorUnit>,
pub order_tax_amount: Option<MinorUnit>,
pub connector_mandate_detail: Option<ConnectorMandateReferenceId>,
pub processor_transaction_data: Option<String>,
pub card_discovery: Option<common_enums::CardDiscovery>,
pub charges: Option<common_types::payments::ConnectorChargeResponseData>,
pub issuer_error_code: Option<String>,
pub issuer_error_message: Option<String>,
}
#[cfg(feature = "v1")]
impl PaymentAttemptUpdateInternal {
pub fn populate_derived_fields(self, source: &PaymentAttempt) -> Self {
let mut update_internal = self;
update_internal.net_amount = Some(
update_internal.amount.unwrap_or(source.amount)
+ update_internal
.surcharge_amount
.or(source.surcharge_amount)
.unwrap_or(MinorUnit::new(0))
+ update_internal
.tax_amount
.or(source.tax_amount)
.unwrap_or(MinorUnit::new(0))
+ update_internal
.shipping_cost
.or(source.shipping_cost)
.unwrap_or(MinorUnit::new(0))
+ update_internal
.order_tax_amount
.or(source.order_tax_amount)
.unwrap_or(MinorUnit::new(0)),
);
update_internal.card_network = update_internal
.payment_method_data
.as_ref()
.and_then(|data| data.as_object())
.and_then(|card| card.get("card"))
.and_then(|data| data.as_object())
.and_then(|card| card.get("card_network"))
.and_then(|network| network.as_str())
.map(|network| network.to_string());
update_internal
}
}
#[cfg(feature = "v2")]
impl PaymentAttemptUpdate {
pub fn apply_changeset(self, source: PaymentAttempt) -> PaymentAttempt {
todo!()
// let PaymentAttemptUpdateInternal {
// net_amount,
// status,
// authentication_type,
// error_message,
// payment_method_id,
// cancellation_reason,
// modified_at: _,
// browser_info,
// payment_token,
// error_code,
// connector_metadata,
// payment_method_data,
// payment_experience,
// straight_through_algorithm,
// preprocessing_step_id,
// error_reason,
// connector_response_reference_id,
// multiple_capture_count,
// surcharge_amount,
// tax_amount,
// amount_capturable,
// updated_by,
// merchant_connector_id,
// authentication_data,
// encoded_data,
// unified_code,
// unified_message,
// external_three_ds_authentication_attempted,
// authentication_connector,
// authentication_id,
// payment_method_billing_address_id,
// fingerprint_id,
// charge_id,
// client_source,
// client_version,
// customer_acceptance,
// card_network,
// } = PaymentAttemptUpdateInternal::from(self).populate_derived_fields(&source);
// PaymentAttempt {
// net_amount: net_amount.or(source.net_amount),
// status: status.unwrap_or(source.status),
// authentication_type: authentication_type.or(source.authentication_type),
// error_message: error_message.unwrap_or(source.error_message),
// payment_method_id: payment_method_id.or(source.payment_method_id),
// cancellation_reason: cancellation_reason.or(source.cancellation_reason),
// modified_at: common_utils::date_time::now(),
// browser_info: browser_info.or(source.browser_info),
// payment_token: payment_token.or(source.payment_token),
// error_code: error_code.unwrap_or(source.error_code),
// connector_metadata: connector_metadata.or(source.connector_metadata),
// payment_method_data: payment_method_data.or(source.payment_method_data),
// payment_experience: payment_experience.or(source.payment_experience),
// straight_through_algorithm: straight_through_algorithm
// .or(source.straight_through_algorithm),
// preprocessing_step_id: preprocessing_step_id.or(source.preprocessing_step_id),
// error_reason: error_reason.unwrap_or(source.error_reason),
// connector_response_reference_id: connector_response_reference_id
// .or(source.connector_response_reference_id),
// multiple_capture_count: multiple_capture_count.or(source.multiple_capture_count),
// surcharge_amount: surcharge_amount.or(source.surcharge_amount),
// tax_amount: tax_amount.or(source.tax_amount),
// amount_capturable: amount_capturable.unwrap_or(source.amount_capturable),
// updated_by,
// merchant_connector_id: merchant_connector_id.unwrap_or(source.merchant_connector_id),
// authentication_data: authentication_data.or(source.authentication_data),
// encoded_data: encoded_data.or(source.encoded_data),
// unified_code: unified_code.unwrap_or(source.unified_code),
// unified_message: unified_message.unwrap_or(source.unified_message),
// external_three_ds_authentication_attempted: external_three_ds_authentication_attempted
// .or(source.external_three_ds_authentication_attempted),
// authentication_connector: authentication_connector.or(source.authentication_connector),
// authentication_id: authentication_id.or(source.authentication_id),
// payment_method_billing_address_id: payment_method_billing_address_id
// .or(source.payment_method_billing_address_id),
// fingerprint_id: fingerprint_id.or(source.fingerprint_id),
// charge_id: charge_id.or(source.charge_id),
// client_source: client_source.or(source.client_source),
// client_version: client_version.or(source.client_version),
// customer_acceptance: customer_acceptance.or(source.customer_acceptance),
// card_network: card_network.or(source.card_network),
// ..source
// }
}
}
#[cfg(feature = "v1")]
impl PaymentAttemptUpdate {
pub fn apply_changeset(self, source: PaymentAttempt) -> PaymentAttempt {
let PaymentAttemptUpdateInternal {
amount,
net_amount,
currency,
status,
connector_transaction_id,
amount_to_capture,
connector,
authentication_type,
payment_method,
error_message,
payment_method_id,
cancellation_reason,
modified_at: _,
mandate_id,
browser_info,
payment_token,
error_code,
connector_metadata,
payment_method_data,
payment_method_type,
payment_experience,
business_sub_label,
straight_through_algorithm,
preprocessing_step_id,
error_reason,
capture_method,
connector_response_reference_id,
multiple_capture_count,
surcharge_amount,
tax_amount,
amount_capturable,
updated_by,
merchant_connector_id,
authentication_data,
encoded_data,
unified_code,
unified_message,
external_three_ds_authentication_attempted,
authentication_connector,
authentication_id,
payment_method_billing_address_id,
fingerprint_id,
client_source,
client_version,
customer_acceptance,
card_network,
shipping_cost,
order_tax_amount,
processor_transaction_data,
connector_mandate_detail,
capture_before,
extended_authorization_applied,
card_discovery,
charges,
issuer_error_code,
issuer_error_message,
} = PaymentAttemptUpdateInternal::from(self).populate_derived_fields(&source);
PaymentAttempt {
amount: amount.unwrap_or(source.amount),
net_amount: net_amount.or(source.net_amount),
currency: currency.or(source.currency),
status: status.unwrap_or(source.status),
connector_transaction_id: connector_transaction_id.or(source.connector_transaction_id),
amount_to_capture: amount_to_capture.or(source.amount_to_capture),
connector: connector.unwrap_or(source.connector),
authentication_type: authentication_type.or(source.authentication_type),
payment_method: payment_method.or(source.payment_method),
error_message: error_message.unwrap_or(source.error_message),
payment_method_id: payment_method_id.or(source.payment_method_id),
cancellation_reason: cancellation_reason.or(source.cancellation_reason),
modified_at: common_utils::date_time::now(),
mandate_id: mandate_id.or(source.mandate_id),
browser_info: browser_info.or(source.browser_info),
payment_token: payment_token.or(source.payment_token),
error_code: error_code.unwrap_or(source.error_code),
connector_metadata: connector_metadata.or(source.connector_metadata),
payment_method_data: payment_method_data.or(source.payment_method_data),
payment_method_type: payment_method_type.or(source.payment_method_type),
payment_experience: payment_experience.or(source.payment_experience),
business_sub_label: business_sub_label.or(source.business_sub_label),
straight_through_algorithm: straight_through_algorithm
.or(source.straight_through_algorithm),
preprocessing_step_id: preprocessing_step_id.or(source.preprocessing_step_id),
error_reason: error_reason.unwrap_or(source.error_reason),
capture_method: capture_method.or(source.capture_method),
connector_response_reference_id: connector_response_reference_id
.or(source.connector_response_reference_id),
multiple_capture_count: multiple_capture_count.or(source.multiple_capture_count),
surcharge_amount: surcharge_amount.or(source.surcharge_amount),
tax_amount: tax_amount.or(source.tax_amount),
amount_capturable: amount_capturable.unwrap_or(source.amount_capturable),
updated_by,
merchant_connector_id: merchant_connector_id.unwrap_or(source.merchant_connector_id),
authentication_data: authentication_data.or(source.authentication_data),
encoded_data: encoded_data.or(source.encoded_data),
unified_code: unified_code.unwrap_or(source.unified_code),
unified_message: unified_message.unwrap_or(source.unified_message),
external_three_ds_authentication_attempted: external_three_ds_authentication_attempted
.or(source.external_three_ds_authentication_attempted),
authentication_connector: authentication_connector.or(source.authentication_connector),
authentication_id: authentication_id.or(source.authentication_id),
payment_method_billing_address_id: payment_method_billing_address_id
.or(source.payment_method_billing_address_id),
fingerprint_id: fingerprint_id.or(source.fingerprint_id),
client_source: client_source.or(source.client_source),
client_version: client_version.or(source.client_version),
customer_acceptance: customer_acceptance.or(source.customer_acceptance),
card_network: card_network.or(source.card_network),
shipping_cost: shipping_cost.or(source.shipping_cost),
order_tax_amount: order_tax_amount.or(source.order_tax_amount),
processor_transaction_data: processor_transaction_data
.or(source.processor_transaction_data),
connector_mandate_detail: connector_mandate_detail.or(source.connector_mandate_detail),
capture_before: capture_before.or(source.capture_before),
extended_authorization_applied: extended_authorization_applied
.or(source.extended_authorization_applied),
card_discovery: card_discovery.or(source.card_discovery),
charges: charges.or(source.charges),
issuer_error_code: issuer_error_code.or(source.issuer_error_code),
issuer_error_message: issuer_error_message.or(source.issuer_error_message),
..source
}
}
}
#[cfg(feature = "v2")]
impl From<PaymentAttemptUpdate> for PaymentAttemptUpdateInternal {
fn from(payment_attempt_update: PaymentAttemptUpdate) -> Self {
todo!()
// match payment_attempt_update {
// PaymentAttemptUpdate::Update {
// amount,
// currency,
// status,
// // connector_transaction_id,
// authentication_type,
// payment_method,
// payment_token,
// payment_method_data,
// payment_method_type,
// payment_experience,
// business_sub_label,
// amount_to_capture,
// capture_method,
// surcharge_amount,
// tax_amount,
// fingerprint_id,
// updated_by,
// payment_method_billing_address_id,
// } => Self {
// status: Some(status),
// // connector_transaction_id,
// authentication_type,
// payment_token,
// modified_at: common_utils::date_time::now(),
// payment_method_data,
// payment_experience,
// surcharge_amount,
// tax_amount,
// fingerprint_id,
// payment_method_billing_address_id,
// updated_by,
// net_amount: None,
// error_message: None,
// payment_method_id: None,
// cancellation_reason: None,
// browser_info: None,
// error_code: None,
// connector_metadata: None,
// straight_through_algorithm: None,
// preprocessing_step_id: None,
// error_reason: None,
// connector_response_reference_id: None,
// multiple_capture_count: None,
// amount_capturable: None,
// merchant_connector_id: None,
// authentication_data: None,
// encoded_data: None,
// unified_code: None,
// unified_message: None,
// external_three_ds_authentication_attempted: None,
// authentication_connector: None,
// authentication_id: None,
// charge_id: None,
// client_source: None,
// client_version: None,
// customer_acceptance: None,
// card_network: None,
// },
// PaymentAttemptUpdate::AuthenticationTypeUpdate {
// authentication_type,
// updated_by,
// } => Self {
// authentication_type: Some(authentication_type),
// modified_at: common_utils::date_time::now(),
// updated_by,
// net_amount: None,
// status: None,
// error_message: None,
// payment_method_id: None,
// cancellation_reason: None,
// browser_info: None,
// payment_token: None,
// error_code: None,
// connector_metadata: None,
// payment_method_data: None,
// payment_experience: None,
// straight_through_algorithm: None,
// preprocessing_step_id: None,
// error_reason: None,
// connector_response_reference_id: None,
// multiple_capture_count: None,
// surcharge_amount: None,
// tax_amount: None,
// amount_capturable: None,
// merchant_connector_id: None,
// authentication_data: None,
// encoded_data: None,
// unified_code: None,
// unified_message: None,
// external_three_ds_authentication_attempted: None,
// authentication_connector: None,
// authentication_id: None,
// fingerprint_id: None,
// payment_method_billing_address_id: None,
// charge_id: None,
// client_source: None,
// client_version: None,
// customer_acceptance: None,
// card_network: None,
// },
// PaymentAttemptUpdate::ConfirmUpdate {
// amount,
// currency,
// authentication_type,
// capture_method,
// status,
// payment_method,
// browser_info,
// connector,
// payment_token,
// payment_method_data,
// payment_method_type,
// payment_experience,
// business_sub_label,
// straight_through_algorithm,
// error_code,
// error_message,
// amount_capturable,
// updated_by,
// merchant_connector_id,
// surcharge_amount,
// tax_amount,
// external_three_ds_authentication_attempted,
// authentication_connector,
// authentication_id,
// payment_method_billing_address_id,
// fingerprint_id,
// payment_method_id,
// client_source,
// client_version,
// customer_acceptance,
// } => Self {
// authentication_type,
// status: Some(status),
// modified_at: common_utils::date_time::now(),
// browser_info,
// payment_token,
// payment_method_data,
// payment_experience,
// straight_through_algorithm,
// error_code,
// error_message,
// amount_capturable,
// updated_by,
// merchant_connector_id: merchant_connector_id.map(Some),
// surcharge_amount,
// tax_amount,
// external_three_ds_authentication_attempted,
// authentication_connector,
// authentication_id,
// payment_method_billing_address_id,
// fingerprint_id,
// payment_method_id,
// client_source,
// client_version,
// customer_acceptance,
// net_amount: None,
// cancellation_reason: None,
// connector_metadata: None,
// preprocessing_step_id: None,
// error_reason: None,
// connector_response_reference_id: None,
// multiple_capture_count: None,
// authentication_data: None,
// encoded_data: None,
// unified_code: None,
// unified_message: None,
// charge_id: None,
// card_network: None,
// },
// PaymentAttemptUpdate::VoidUpdate {
// status,
// cancellation_reason,
// updated_by,
// } => Self {
// status: Some(status),
// cancellation_reason,
// modified_at: common_utils::date_time::now(),
// updated_by,
// net_amount: None,
// authentication_type: None,
// error_message: None,
// payment_method_id: None,
// browser_info: None,
// payment_token: None,
// error_code: None,
// connector_metadata: None,
// payment_method_data: None,
// payment_experience: None,
// straight_through_algorithm: None,
// preprocessing_step_id: None,
// error_reason: None,
// connector_response_reference_id: None,
// multiple_capture_count: None,
// surcharge_amount: None,
// tax_amount: None,
// amount_capturable: None,
// merchant_connector_id: None,
// authentication_data: None,
// encoded_data: None,
// unified_code: None,
// unified_message: None,
// external_three_ds_authentication_attempted: None,
// authentication_connector: None,
// authentication_id: None,
// fingerprint_id: None,
// payment_method_billing_address_id: None,
// charge_id: None,
// client_source: None,
// client_version: None,
// customer_acceptance: None,
// card_network: None,
// },
// PaymentAttemptUpdate::RejectUpdate {
// status,
// error_code,
// error_message,
// updated_by,
// } => Self {
// status: Some(status),
// modified_at: common_utils::date_time::now(),
// error_code,
// error_message,
// updated_by,
// net_amount: None,
// authentication_type: None,
// payment_method_id: None,
// cancellation_reason: None,
// browser_info: None,
// payment_token: None,
// connector_metadata: None,
// payment_method_data: None,
// payment_experience: None,
// straight_through_algorithm: None,
// preprocessing_step_id: None,
// error_reason: None,
// connector_response_reference_id: None,
// multiple_capture_count: None,
// surcharge_amount: None,
// tax_amount: None,
// amount_capturable: None,
// merchant_connector_id: None,
// authentication_data: None,
// encoded_data: None,
// unified_code: None,
// unified_message: None,
// external_three_ds_authentication_attempted: None,
// authentication_connector: None,
// authentication_id: None,
// fingerprint_id: None,
// payment_method_billing_address_id: None,
// charge_id: None,
// client_source: None,
// client_version: None,
// customer_acceptance: None,
// card_network: None,
// },
// PaymentAttemptUpdate::BlocklistUpdate {
// status,
// error_code,
// error_message,
// updated_by,
// } => Self {
// status: Some(status),
// modified_at: common_utils::date_time::now(),
// error_code,
// error_message,
// updated_by,
// merchant_connector_id: Some(None),
// net_amount: None,
// authentication_type: None,
// payment_method_id: None,
// cancellation_reason: None,
// browser_info: None,
// payment_token: None,
// connector_metadata: None,
// payment_method_data: None,
// payment_experience: None,
// straight_through_algorithm: None,
// preprocessing_step_id: None,
// error_reason: None,
// connector_response_reference_id: None,
// multiple_capture_count: None,
// surcharge_amount: None,
// tax_amount: None,
// amount_capturable: None,
// authentication_data: None,
// encoded_data: None,
// unified_code: None,
// unified_message: None,
// external_three_ds_authentication_attempted: None,
// authentication_connector: None,
// authentication_id: None,
// fingerprint_id: None,
// payment_method_billing_address_id: None,
// charge_id: None,
// client_source: None,
// client_version: None,
// customer_acceptance: None,
// card_network: None,
// },
// PaymentAttemptUpdate::ConnectorMandateDetailUpdate {
// connector_mandate_detail,
// updated_by,
// } => Self {
// payment_method_id: None,
// modified_at: common_utils::date_time::now(),
// updated_by,
// amount: None,
// net_amount: None,
// currency: None,
// status: None,
// connector_transaction_id: None,
// amount_to_capture: None,
// connector: None,
// authentication_type: None,
// payment_method: None,
// error_message: None,
// cancellation_reason: None,
// mandate_id: None,
// browser_info: None,
// payment_token: None,
// error_code: None,
// connector_metadata: None,
// payment_method_data: None,
// payment_method_type: None,
// payment_experience: None,
// business_sub_label: None,
// straight_through_algorithm: None,
// preprocessing_step_id: None,
// error_reason: None,
// capture_method: None,
// connector_response_reference_id: None,
// multiple_capture_count: None,
// surcharge_amount: None,
// tax_amount: None,
// amount_capturable: None,
// merchant_connector_id: None,
// authentication_data: None,
// encoded_data: None,
// unified_code: None,
// unified_message: None,
// external_three_ds_authentication_attempted: None,
// authentication_connector: None,
// authentication_id: None,
// fingerprint_id: None,
// payment_method_billing_address_id: None,
// charge_id: None,
// client_source: None,
// client_version: None,
// customer_acceptance: None,
// card_network: None,
// shipping_cost: None,
// order_tax_amount: None,
// processor_transaction_data: None,
// connector_mandate_detail,
// },
// PaymentAttemptUpdate::ConnectorMandateDetailUpdate {
// payment_method_id,
// updated_by,
// } => Self {
// payment_method_id,
// modified_at: common_utils::date_time::now(),
// updated_by,
// net_amount: None,
// status: None,
// authentication_type: None,
// error_message: None,
// cancellation_reason: None,
// browser_info: None,
// payment_token: None,
// error_code: None,
// connector_metadata: None,
// payment_method_data: None,
// payment_experience: None,
// straight_through_algorithm: None,
// preprocessing_step_id: None,
// error_reason: None,
// connector_response_reference_id: None,
// multiple_capture_count: None,
// surcharge_amount: None,
// tax_amount: None,
// amount_capturable: None,
// merchant_connector_id: None,
// authentication_data: None,
// encoded_data: None,
// unified_code: None,
// unified_message: None,
// external_three_ds_authentication_attempted: None,
// authentication_connector: None,
// authentication_id: None,
// fingerprint_id: None,
// payment_method_billing_address_id: None,
// charge_id: None,
// client_source: None,
// client_version: None,
// customer_acceptance: None,
// card_network: None,
// },
// PaymentAttemptUpdate::ResponseUpdate {
// status,
// connector,
// connector_transaction_id,
// authentication_type,
// payment_method_id,
// mandate_id,
// connector_metadata,
// payment_token,
// error_code,
// error_message,
// error_reason,
// connector_response_reference_id,
// amount_capturable,
// updated_by,
// authentication_data,
// encoded_data,
// unified_code,
// unified_message,
// payment_method_data,
// charge_id,
// } => Self {
// status: Some(status),
// authentication_type,
// payment_method_id,
// modified_at: common_utils::date_time::now(),
// connector_metadata,
// error_code,
// error_message,
// payment_token,
// error_reason,
// connector_response_reference_id,
// amount_capturable,
// updated_by,
// authentication_data,
// encoded_data,
// unified_code,
// unified_message,
// payment_method_data,
// charge_id,
// net_amount: None,
// cancellation_reason: None,
// browser_info: None,
// payment_experience: None,
// straight_through_algorithm: None,
// preprocessing_step_id: None,
// multiple_capture_count: None,
// surcharge_amount: None,
// tax_amount: None,
// merchant_connector_id: None,
// external_three_ds_authentication_attempted: None,
// authentication_connector: None,
// authentication_id: None,
// fingerprint_id: None,
// payment_method_billing_address_id: None,
// client_source: None,
// client_version: None,
// customer_acceptance: None,
// card_network: None,
// },
// PaymentAttemptUpdate::ErrorUpdate {
// connector,
// status,
// error_code,
// error_message,
// error_reason,
// amount_capturable,
// updated_by,
// unified_code,
// unified_message,
// connector_transaction_id,
// payment_method_data,
// authentication_type,
// } => Self {
// status: Some(status),
// error_message,
// error_code,
// modified_at: common_utils::date_time::now(),
// error_reason,
// amount_capturable,
// updated_by,
// unified_code,
// unified_message,
// payment_method_data,
// authentication_type,
// net_amount: None,
// payment_method_id: None,
// cancellation_reason: None,
// browser_info: None,
// payment_token: None,
// connector_metadata: None,
// payment_experience: None,
// straight_through_algorithm: None,
// preprocessing_step_id: None,
// connector_response_reference_id: None,
// multiple_capture_count: None,
// surcharge_amount: None,
// tax_amount: None,
// merchant_connector_id: None,
// authentication_data: None,
// encoded_data: None,
// external_three_ds_authentication_attempted: None,
// authentication_connector: None,
// authentication_id: None,
// fingerprint_id: None,
// payment_method_billing_address_id: None,
// charge_id: None,
// client_source: None,
// client_version: None,
// customer_acceptance: None,
// card_network: None,
// },
// PaymentAttemptUpdate::StatusUpdate { status, updated_by } => Self {
// status: Some(status),
// modified_at: common_utils::date_time::now(),
// updated_by,
// net_amount: None,
// authentication_type: None,
// error_message: None,
// payment_method_id: None,
// cancellation_reason: None,
// browser_info: None,
// payment_token: None,
// error_code: None,
// connector_metadata: None,
// payment_method_data: None,
// payment_experience: None,
// straight_through_algorithm: None,
// preprocessing_step_id: None,
// error_reason: None,
// connector_response_reference_id: None,
// multiple_capture_count: None,
// surcharge_amount: None,
// tax_amount: None,
// amount_capturable: None,
// merchant_connector_id: None,
// authentication_data: None,
// encoded_data: None,
// unified_code: None,
// unified_message: None,
// external_three_ds_authentication_attempted: None,
// authentication_connector: None,
// authentication_id: None,
// fingerprint_id: None,
// payment_method_billing_address_id: None,
// charge_id: None,
// client_source: None,
// client_version: None,
// customer_acceptance: None,
// card_network: None,
// },
// PaymentAttemptUpdate::UpdateTrackers {
// payment_token,
// connector,
// straight_through_algorithm,
// amount_capturable,
// surcharge_amount,
// tax_amount,
// updated_by,
// merchant_connector_id,
// } => Self {
// payment_token,
// modified_at: common_utils::date_time::now(),
// straight_through_algorithm,
// amount_capturable,
// surcharge_amount,
// tax_amount,
// updated_by,
// merchant_connector_id: merchant_connector_id.map(Some),
// net_amount: None,
// status: None,
// authentication_type: None,
// error_message: None,
// payment_method_id: None,
// cancellation_reason: None,
// browser_info: None,
// error_code: None,
// connector_metadata: None,
// payment_method_data: None,
// payment_experience: None,
// preprocessing_step_id: None,
// error_reason: None,
// connector_response_reference_id: None,
// multiple_capture_count: None,
// authentication_data: None,
// encoded_data: None,
// unified_code: None,
// unified_message: None,
// external_three_ds_authentication_attempted: None,
// authentication_connector: None,
// authentication_id: None,
// fingerprint_id: None,
// payment_method_billing_address_id: None,
// charge_id: None,
// client_source: None,
// client_version: None,
// customer_acceptance: None,
// card_network: None,
// },
// PaymentAttemptUpdate::UnresolvedResponseUpdate {
// status,
// connector,
// connector_transaction_id,
// payment_method_id,
// error_code,
// error_message,
// error_reason,
// connector_response_reference_id,
// updated_by,
// } => Self {
// status: Some(status),
// payment_method_id,
// modified_at: common_utils::date_time::now(),
// error_code,
// error_message,
// error_reason,
// connector_response_reference_id,
// updated_by,
// net_amount: None,
// authentication_type: None,
// cancellation_reason: None,
// browser_info: None,
// payment_token: None,
// connector_metadata: None,
// payment_method_data: None,
// payment_experience: None,
// straight_through_algorithm: None,
// preprocessing_step_id: None,
// multiple_capture_count: None,
// surcharge_amount: None,
// tax_amount: None,
// amount_capturable: None,
// merchant_connector_id: None,
// authentication_data: None,
// encoded_data: None,
// unified_code: None,
// unified_message: None,
// external_three_ds_authentication_attempted: None,
// authentication_connector: None,
// authentication_id: None,
// fingerprint_id: None,
// payment_method_billing_address_id: None,
// charge_id: None,
// client_source: None,
// client_version: None,
// customer_acceptance: None,
// card_network: None,
// },
// PaymentAttemptUpdate::PreprocessingUpdate {
// status,
// payment_method_id,
// connector_metadata,
// preprocessing_step_id,
// connector_transaction_id,
// connector_response_reference_id,
// updated_by,
// } => Self {
// status: Some(status),
// payment_method_id,
// modified_at: common_utils::date_time::now(),
// connector_metadata,
// preprocessing_step_id,
// connector_response_reference_id,
// updated_by,
// net_amount: None,
// authentication_type: None,
// error_message: None,
// cancellation_reason: None,
// browser_info: None,
// payment_token: None,
// error_code: None,
// payment_method_data: None,
// payment_experience: None,
// straight_through_algorithm: None,
// error_reason: None,
// multiple_capture_count: None,
// surcharge_amount: None,
// tax_amount: None,
// amount_capturable: None,
// merchant_connector_id: None,
// authentication_data: None,
// encoded_data: None,
// unified_code: None,
// unified_message: None,
// external_three_ds_authentication_attempted: None,
// authentication_connector: None,
// authentication_id: None,
// fingerprint_id: None,
// payment_method_billing_address_id: None,
// charge_id: None,
// client_source: None,
// client_version: None,
// customer_acceptance: None,
// card_network: None,
// },
// PaymentAttemptUpdate::CaptureUpdate {
// multiple_capture_count,
// updated_by,
// amount_to_capture,
// } => Self {
// multiple_capture_count,
// modified_at: common_utils::date_time::now(),
// updated_by,
// net_amount: None,
// status: None,
// authentication_type: None,
// error_message: None,
// payment_method_id: None,
// cancellation_reason: None,
// browser_info: None,
// payment_token: None,
// error_code: None,
// connector_metadata: None,
// payment_method_data: None,
// payment_experience: None,
// straight_through_algorithm: None,
// preprocessing_step_id: None,
// error_reason: None,
// connector_response_reference_id: None,
// surcharge_amount: None,
// tax_amount: None,
// amount_capturable: None,
// merchant_connector_id: None,
// authentication_data: None,
// encoded_data: None,
// unified_code: None,
// unified_message: None,
// external_three_ds_authentication_attempted: None,
// authentication_connector: None,
// authentication_id: None,
// fingerprint_id: None,
// payment_method_billing_address_id: None,
// charge_id: None,
// client_source: None,
// client_version: None,
// customer_acceptance: None,
// card_network: None,
// },
// PaymentAttemptUpdate::AmountToCaptureUpdate {
// status,
// amount_capturable,
// updated_by,
// } => Self {
// status: Some(status),
// modified_at: common_utils::date_time::now(),
// amount_capturable: Some(amount_capturable),
// updated_by,
// net_amount: None,
// authentication_type: None,
// error_message: None,
// payment_method_id: None,
// cancellation_reason: None,
// browser_info: None,
// payment_token: None,
// error_code: None,
// connector_metadata: None,
// payment_method_data: None,
// payment_experience: None,
// straight_through_algorithm: None,
// preprocessing_step_id: None,
// error_reason: None,
// connector_response_reference_id: None,
// multiple_capture_count: None,
// surcharge_amount: None,
// tax_amount: None,
// merchant_connector_id: None,
// authentication_data: None,
// encoded_data: None,
// unified_code: None,
// unified_message: None,
// external_three_ds_authentication_attempted: None,
// authentication_connector: None,
// authentication_id: None,
// fingerprint_id: None,
// payment_method_billing_address_id: None,
// charge_id: None,
// client_source: None,
// client_version: None,
// customer_acceptance: None,
// card_network: None,
// },
// PaymentAttemptUpdate::ConnectorResponse {
// authentication_data,
// encoded_data,
// connector_transaction_id,
// connector,
// updated_by,
// charge_id,
// } => Self {
// authentication_data,
// encoded_data,
// modified_at: common_utils::date_time::now(),
// updated_by,
// charge_id,
// net_amount: None,
// status: None,
// authentication_type: None,
// error_message: None,
// payment_method_id: None,
// cancellation_reason: None,
// browser_info: None,
// payment_token: None,
// error_code: None,
// connector_metadata: None,
// payment_method_data: None,
// payment_experience: None,
// straight_through_algorithm: None,
// preprocessing_step_id: None,
// error_reason: None,
// connector_response_reference_id: None,
// multiple_capture_count: None,
// surcharge_amount: None,
// tax_amount: None,
// amount_capturable: None,
// merchant_connector_id: None,
// unified_code: None,
// unified_message: None,
// external_three_ds_authentication_attempted: None,
// authentication_connector: None,
// authentication_id: None,
// fingerprint_id: None,
// payment_method_billing_address_id: None,
// client_source: None,
// client_version: None,
// customer_acceptance: None,
// card_network: None,
// },
// PaymentAttemptUpdate::IncrementalAuthorizationAmountUpdate {
// amount,
// amount_capturable,
// } => Self {
// modified_at: common_utils::date_time::now(),
// amount_capturable: Some(amount_capturable),
// net_amount: None,
// status: None,
// authentication_type: None,
// error_message: None,
// payment_method_id: None,
// cancellation_reason: None,
// browser_info: None,
// payment_token: None,
// error_code: None,
// connector_metadata: None,
// payment_method_data: None,
// payment_experience: None,
// straight_through_algorithm: None,
// preprocessing_step_id: None,
// error_reason: None,
// connector_response_reference_id: None,
// multiple_capture_count: None,
// surcharge_amount: None,
// tax_amount: None,
// updated_by: String::default(),
// merchant_connector_id: None,
// authentication_data: None,
// encoded_data: None,
// unified_code: None,
// unified_message: None,
// external_three_ds_authentication_attempted: None,
// authentication_connector: None,
// authentication_id: None,
// fingerprint_id: None,
// payment_method_billing_address_id: None,
// charge_id: None,
// client_source: None,
// client_version: None,
// customer_acceptance: None,
// card_network: None,
// },
// PaymentAttemptUpdate::AuthenticationUpdate {
// status,
// external_three_ds_authentication_attempted,
// authentication_connector,
// authentication_id,
// updated_by,
// } => Self {
// status: Some(status),
// modified_at: common_utils::date_time::now(),
// external_three_ds_authentication_attempted,
// authentication_connector,
// authentication_id,
// updated_by,
// net_amount: None,
// authentication_type: None,
// error_message: None,
// payment_method_id: None,
// cancellation_reason: None,
// browser_info: None,
// payment_token: None,
// error_code: None,
// connector_metadata: None,
// payment_method_data: None,
// payment_experience: None,
// straight_through_algorithm: None,
// preprocessing_step_id: None,
// error_reason: None,
// connector_response_reference_id: None,
// multiple_capture_count: None,
// surcharge_amount: None,
// tax_amount: None,
// amount_capturable: None,
// merchant_connector_id: None,
// authentication_data: None,
// encoded_data: None,
// unified_code: None,
// unified_message: None,
// fingerprint_id: None,
// payment_method_billing_address_id: None,
// charge_id: None,
// client_source: None,
// client_version: None,
// customer_acceptance: None,
// card_network: None,
// },
// PaymentAttemptUpdate::ManualUpdate {
// status,
// error_code,
// error_message,
// error_reason,
// updated_by,
// unified_code,
// unified_message,
// connector_transaction_id,
// } => Self {
// status,
// error_code: error_code.map(Some),
// modified_at: common_utils::date_time::now(),
// error_message: error_message.map(Some),
// error_reason: error_reason.map(Some),
// updated_by,
// unified_code: unified_code.map(Some),
// unified_message: unified_message.map(Some),
// net_amount: None,
// authentication_type: None,
// payment_method_id: None,
// cancellation_reason: None,
// browser_info: None,
// payment_token: None,
// connector_metadata: None,
// payment_method_data: None,
// payment_experience: None,
// straight_through_algorithm: None,
// preprocessing_step_id: None,
// connector_response_reference_id: None,
// multiple_capture_count: None,
// surcharge_amount: None,
// tax_amount: None,
// amount_capturable: None,
// merchant_connector_id: None,
// authentication_data: None,
// encoded_data: None,
// external_three_ds_authentication_attempted: None,
// authentication_connector: None,
// authentication_id: None,
// fingerprint_id: None,
// payment_method_billing_address_id: None,
// charge_id: None,
// client_source: None,
// client_version: None,
// customer_acceptance: None,
// card_network: None,
// },
// }
}
}
#[cfg(feature = "v1")]
impl From<PaymentAttemptUpdate> for PaymentAttemptUpdateInternal {
fn from(payment_attempt_update: PaymentAttemptUpdate) -> Self {
match payment_attempt_update {
PaymentAttemptUpdate::Update {
amount,
currency,
status,
// connector_transaction_id,
authentication_type,
payment_method,
payment_token,
payment_method_data,
payment_method_type,
payment_experience,
business_sub_label,
amount_to_capture,
capture_method,
surcharge_amount,
tax_amount,
fingerprint_id,
updated_by,
payment_method_billing_address_id,
} => Self {
amount: Some(amount),
currency: Some(currency),
status: Some(status),
// connector_transaction_id,
authentication_type,
payment_method,
payment_token,
modified_at: common_utils::date_time::now(),
payment_method_data,
payment_method_type,
payment_experience,
business_sub_label,
amount_to_capture,
capture_method,
surcharge_amount,
tax_amount,
fingerprint_id,
payment_method_billing_address_id,
updated_by,
net_amount: None,
connector_transaction_id: None,
connector: None,
error_message: None,
payment_method_id: None,
cancellation_reason: None,
mandate_id: None,
browser_info: None,
error_code: None,
connector_metadata: None,
straight_through_algorithm: None,
preprocessing_step_id: None,
error_reason: None,
connector_response_reference_id: None,
multiple_capture_count: None,
amount_capturable: None,
merchant_connector_id: None,
authentication_data: None,
encoded_data: None,
unified_code: None,
unified_message: None,
external_three_ds_authentication_attempted: None,
authentication_connector: None,
authentication_id: None,
client_source: None,
client_version: None,
customer_acceptance: None,
card_network: None,
shipping_cost: None,
capture_before: None,
extended_authorization_applied: None,
order_tax_amount: None,
processor_transaction_data: None,
connector_mandate_detail: None,
card_discovery: None,
charges: None,
issuer_error_code: None,
issuer_error_message: None,
},
PaymentAttemptUpdate::AuthenticationTypeUpdate {
authentication_type,
updated_by,
} => Self {
authentication_type: Some(authentication_type),
modified_at: common_utils::date_time::now(),
updated_by,
amount: None,
net_amount: None,
currency: None,
status: None,
connector_transaction_id: None,
amount_to_capture: None,
connector: None,
payment_method: None,
error_message: None,
payment_method_id: None,
cancellation_reason: None,
mandate_id: None,
browser_info: None,
payment_token: None,
error_code: None,
connector_metadata: None,
payment_method_data: None,
payment_method_type: None,
payment_experience: None,
business_sub_label: None,
straight_through_algorithm: None,
preprocessing_step_id: None,
error_reason: None,
capture_method: None,
connector_response_reference_id: None,
multiple_capture_count: None,
surcharge_amount: None,
tax_amount: None,
amount_capturable: None,
merchant_connector_id: None,
authentication_data: None,
encoded_data: None,
unified_code: None,
unified_message: None,
external_three_ds_authentication_attempted: None,
authentication_connector: None,
authentication_id: None,
fingerprint_id: None,
payment_method_billing_address_id: None,
client_source: None,
client_version: None,
customer_acceptance: None,
card_network: None,
shipping_cost: None,
order_tax_amount: None,
capture_before: None,
extended_authorization_applied: None,
processor_transaction_data: None,
connector_mandate_detail: None,
card_discovery: None,
charges: None,
issuer_error_code: None,
issuer_error_message: None,
},
PaymentAttemptUpdate::ConfirmUpdate {
amount,
currency,
authentication_type,
capture_method,
status,
payment_method,
browser_info,
connector,
payment_token,
payment_method_data,
payment_method_type,
payment_experience,
business_sub_label,
straight_through_algorithm,
error_code,
error_message,
amount_capturable,
updated_by,
merchant_connector_id,
surcharge_amount,
tax_amount,
external_three_ds_authentication_attempted,
authentication_connector,
authentication_id,
payment_method_billing_address_id,
fingerprint_id,
payment_method_id,
client_source,
client_version,
customer_acceptance,
shipping_cost,
order_tax_amount,
connector_mandate_detail,
card_discovery,
} => Self {
amount: Some(amount),
currency: Some(currency),
authentication_type,
status: Some(status),
payment_method,
modified_at: common_utils::date_time::now(),
browser_info,
connector: connector.map(Some),
payment_token,
payment_method_data,
payment_method_type,
payment_experience,
business_sub_label,
straight_through_algorithm,
error_code,
error_message,
amount_capturable,
updated_by,
merchant_connector_id: merchant_connector_id.map(Some),
surcharge_amount,
tax_amount,
external_three_ds_authentication_attempted,
authentication_connector,
authentication_id,
payment_method_billing_address_id,
fingerprint_id,
payment_method_id,
capture_method,
client_source,
client_version,
customer_acceptance,
net_amount: None,
connector_transaction_id: None,
amount_to_capture: None,
cancellation_reason: None,
mandate_id: None,
connector_metadata: None,
preprocessing_step_id: None,
error_reason: None,
connector_response_reference_id: None,
multiple_capture_count: None,
authentication_data: None,
encoded_data: None,
unified_code: None,
unified_message: None,
card_network: None,
shipping_cost,
order_tax_amount,
capture_before: None,
extended_authorization_applied: None,
processor_transaction_data: None,
connector_mandate_detail,
card_discovery,
charges: None,
issuer_error_code: None,
issuer_error_message: None,
},
PaymentAttemptUpdate::VoidUpdate {
status,
cancellation_reason,
updated_by,
} => Self {
status: Some(status),
cancellation_reason,
modified_at: common_utils::date_time::now(),
updated_by,
amount: None,
net_amount: None,
currency: None,
connector_transaction_id: None,
amount_to_capture: None,
connector: None,
authentication_type: None,
payment_method: None,
error_message: None,
payment_method_id: None,
mandate_id: None,
browser_info: None,
payment_token: None,
error_code: None,
connector_metadata: None,
payment_method_data: None,
payment_method_type: None,
payment_experience: None,
business_sub_label: None,
straight_through_algorithm: None,
preprocessing_step_id: None,
error_reason: None,
capture_method: None,
connector_response_reference_id: None,
multiple_capture_count: None,
surcharge_amount: None,
tax_amount: None,
amount_capturable: None,
merchant_connector_id: None,
authentication_data: None,
encoded_data: None,
unified_code: None,
unified_message: None,
external_three_ds_authentication_attempted: None,
authentication_connector: None,
authentication_id: None,
fingerprint_id: None,
payment_method_billing_address_id: None,
client_source: None,
client_version: None,
customer_acceptance: None,
card_network: None,
shipping_cost: None,
order_tax_amount: None,
capture_before: None,
extended_authorization_applied: None,
processor_transaction_data: None,
connector_mandate_detail: None,
card_discovery: None,
charges: None,
issuer_error_code: None,
issuer_error_message: None,
},
PaymentAttemptUpdate::RejectUpdate {
status,
error_code,
error_message,
updated_by,
} => Self {
status: Some(status),
modified_at: common_utils::date_time::now(),
error_code,
error_message,
updated_by,
amount: None,
net_amount: None,
currency: None,
connector_transaction_id: None,
amount_to_capture: None,
connector: None,
authentication_type: None,
payment_method: None,
payment_method_id: None,
cancellation_reason: None,
mandate_id: None,
browser_info: None,
payment_token: None,
connector_metadata: None,
payment_method_data: None,
payment_method_type: None,
payment_experience: None,
business_sub_label: None,
straight_through_algorithm: None,
preprocessing_step_id: None,
error_reason: None,
capture_method: None,
connector_response_reference_id: None,
multiple_capture_count: None,
surcharge_amount: None,
tax_amount: None,
amount_capturable: None,
merchant_connector_id: None,
authentication_data: None,
encoded_data: None,
unified_code: None,
unified_message: None,
external_three_ds_authentication_attempted: None,
authentication_connector: None,
authentication_id: None,
fingerprint_id: None,
payment_method_billing_address_id: None,
client_source: None,
client_version: None,
customer_acceptance: None,
card_network: None,
shipping_cost: None,
order_tax_amount: None,
capture_before: None,
extended_authorization_applied: None,
processor_transaction_data: None,
connector_mandate_detail: None,
card_discovery: None,
charges: None,
issuer_error_code: None,
issuer_error_message: None,
},
PaymentAttemptUpdate::BlocklistUpdate {
status,
error_code,
error_message,
updated_by,
} => Self {
status: Some(status),
modified_at: common_utils::date_time::now(),
error_code,
connector: Some(None),
error_message,
updated_by,
merchant_connector_id: Some(None),
amount: None,
net_amount: None,
currency: None,
connector_transaction_id: None,
amount_to_capture: None,
authentication_type: None,
payment_method: None,
payment_method_id: None,
cancellation_reason: None,
mandate_id: None,
browser_info: None,
payment_token: None,
connector_metadata: None,
payment_method_data: None,
payment_method_type: None,
payment_experience: None,
business_sub_label: None,
straight_through_algorithm: None,
preprocessing_step_id: None,
error_reason: None,
capture_method: None,
connector_response_reference_id: None,
multiple_capture_count: None,
surcharge_amount: None,
tax_amount: None,
amount_capturable: None,
authentication_data: None,
encoded_data: None,
unified_code: None,
unified_message: None,
external_three_ds_authentication_attempted: None,
authentication_connector: None,
authentication_id: None,
fingerprint_id: None,
payment_method_billing_address_id: None,
client_source: None,
client_version: None,
customer_acceptance: None,
card_network: None,
shipping_cost: None,
order_tax_amount: None,
capture_before: None,
extended_authorization_applied: None,
processor_transaction_data: None,
connector_mandate_detail: None,
card_discovery: None,
charges: None,
issuer_error_code: None,
issuer_error_message: None,
},
PaymentAttemptUpdate::ConnectorMandateDetailUpdate {
connector_mandate_detail,
updated_by,
} => Self {
payment_method_id: None,
modified_at: common_utils::date_time::now(),
updated_by,
amount: None,
net_amount: None,
currency: None,
status: None,
connector_transaction_id: None,
amount_to_capture: None,
connector: None,
authentication_type: None,
payment_method: None,
error_message: None,
cancellation_reason: None,
mandate_id: None,
browser_info: None,
payment_token: None,
error_code: None,
connector_metadata: None,
payment_method_data: None,
payment_method_type: None,
payment_experience: None,
business_sub_label: None,
straight_through_algorithm: None,
preprocessing_step_id: None,
error_reason: None,
capture_method: None,
connector_response_reference_id: None,
multiple_capture_count: None,
surcharge_amount: None,
tax_amount: None,
amount_capturable: None,
merchant_connector_id: None,
authentication_data: None,
encoded_data: None,
unified_code: None,
unified_message: None,
external_three_ds_authentication_attempted: None,
authentication_connector: None,
authentication_id: None,
fingerprint_id: None,
payment_method_billing_address_id: None,
client_source: None,
client_version: None,
customer_acceptance: None,
card_network: None,
shipping_cost: None,
order_tax_amount: None,
capture_before: None,
extended_authorization_applied: None,
processor_transaction_data: None,
connector_mandate_detail,
card_discovery: None,
charges: None,
issuer_error_code: None,
issuer_error_message: None,
},
PaymentAttemptUpdate::PaymentMethodDetailsUpdate {
payment_method_id,
updated_by,
} => Self {
payment_method_id,
modified_at: common_utils::date_time::now(),
updated_by,
amount: None,
net_amount: None,
currency: None,
status: None,
connector_transaction_id: None,
amount_to_capture: None,
connector: None,
authentication_type: None,
payment_method: None,
error_message: None,
cancellation_reason: None,
mandate_id: None,
browser_info: None,
payment_token: None,
error_code: None,
connector_metadata: None,
payment_method_data: None,
payment_method_type: None,
payment_experience: None,
business_sub_label: None,
straight_through_algorithm: None,
preprocessing_step_id: None,
error_reason: None,
capture_method: None,
connector_response_reference_id: None,
multiple_capture_count: None,
surcharge_amount: None,
tax_amount: None,
amount_capturable: None,
merchant_connector_id: None,
authentication_data: None,
encoded_data: None,
unified_code: None,
unified_message: None,
external_three_ds_authentication_attempted: None,
authentication_connector: None,
authentication_id: None,
fingerprint_id: None,
payment_method_billing_address_id: None,
client_source: None,
client_version: None,
customer_acceptance: None,
card_network: None,
shipping_cost: None,
order_tax_amount: None,
capture_before: None,
extended_authorization_applied: None,
processor_transaction_data: None,
connector_mandate_detail: None,
card_discovery: None,
charges: None,
issuer_error_code: None,
issuer_error_message: None,
},
PaymentAttemptUpdate::ResponseUpdate {
status,
connector,
connector_transaction_id,
authentication_type,
payment_method_id,
mandate_id,
connector_metadata,
payment_token,
error_code,
error_message,
error_reason,
connector_response_reference_id,
amount_capturable,
updated_by,
authentication_data,
encoded_data,
unified_code,
unified_message,
capture_before,
extended_authorization_applied,
payment_method_data,
connector_mandate_detail,
charges,
} => {
let (connector_transaction_id, processor_transaction_data) =
connector_transaction_id
.map(ConnectorTransactionId::form_id_and_data)
.map(|(txn_id, txn_data)| (Some(txn_id), txn_data))
.unwrap_or((None, None));
Self {
status: Some(status),
connector: connector.map(Some),
connector_transaction_id,
authentication_type,
payment_method_id,
modified_at: common_utils::date_time::now(),
mandate_id,
connector_metadata,
error_code,
error_message,
payment_token,
error_reason,
connector_response_reference_id,
amount_capturable,
updated_by,
authentication_data,
encoded_data,
unified_code,
unified_message,
payment_method_data,
processor_transaction_data,
connector_mandate_detail,
charges,
amount: None,
net_amount: None,
currency: None,
amount_to_capture: None,
payment_method: None,
cancellation_reason: None,
browser_info: None,
payment_method_type: None,
payment_experience: None,
business_sub_label: None,
straight_through_algorithm: None,
preprocessing_step_id: None,
capture_method: None,
multiple_capture_count: None,
surcharge_amount: None,
tax_amount: None,
merchant_connector_id: None,
external_three_ds_authentication_attempted: None,
authentication_connector: None,
authentication_id: None,
fingerprint_id: None,
payment_method_billing_address_id: None,
client_source: None,
client_version: None,
customer_acceptance: None,
card_network: None,
capture_before,
extended_authorization_applied,
shipping_cost: None,
order_tax_amount: None,
card_discovery: None,
issuer_error_code: None,
issuer_error_message: None,
}
}
PaymentAttemptUpdate::ErrorUpdate {
connector,
status,
error_code,
error_message,
error_reason,
amount_capturable,
updated_by,
unified_code,
unified_message,
connector_transaction_id,
payment_method_data,
authentication_type,
issuer_error_code,
issuer_error_message,
} => {
let (connector_transaction_id, processor_transaction_data) =
connector_transaction_id
.map(ConnectorTransactionId::form_id_and_data)
.map(|(txn_id, txn_data)| (Some(txn_id), txn_data))
.unwrap_or((None, None));
Self {
connector: connector.map(Some),
status: Some(status),
error_message,
error_code,
modified_at: common_utils::date_time::now(),
error_reason,
amount_capturable,
updated_by,
unified_code,
unified_message,
connector_transaction_id,
payment_method_data,
authentication_type,
processor_transaction_data,
issuer_error_code,
issuer_error_message,
amount: None,
net_amount: None,
currency: None,
amount_to_capture: None,
payment_method: None,
payment_method_id: None,
cancellation_reason: None,
mandate_id: None,
browser_info: None,
payment_token: None,
connector_metadata: None,
payment_method_type: None,
payment_experience: None,
business_sub_label: None,
straight_through_algorithm: None,
preprocessing_step_id: None,
capture_method: None,
connector_response_reference_id: None,
multiple_capture_count: None,
surcharge_amount: None,
tax_amount: None,
merchant_connector_id: None,
authentication_data: None,
encoded_data: None,
external_three_ds_authentication_attempted: None,
authentication_connector: None,
authentication_id: None,
fingerprint_id: None,
payment_method_billing_address_id: None,
client_source: None,
client_version: None,
customer_acceptance: None,
card_network: None,
capture_before: None,
extended_authorization_applied: None,
shipping_cost: None,
order_tax_amount: None,
connector_mandate_detail: None,
card_discovery: None,
charges: None,
}
}
PaymentAttemptUpdate::StatusUpdate { status, updated_by } => Self {
status: Some(status),
modified_at: common_utils::date_time::now(),
updated_by,
amount: None,
net_amount: None,
currency: None,
connector_transaction_id: None,
amount_to_capture: None,
connector: None,
authentication_type: None,
payment_method: None,
error_message: None,
payment_method_id: None,
cancellation_reason: None,
mandate_id: None,
browser_info: None,
payment_token: None,
error_code: None,
connector_metadata: None,
payment_method_data: None,
payment_method_type: None,
payment_experience: None,
business_sub_label: None,
straight_through_algorithm: None,
preprocessing_step_id: None,
error_reason: None,
capture_method: None,
connector_response_reference_id: None,
multiple_capture_count: None,
surcharge_amount: None,
tax_amount: None,
amount_capturable: None,
merchant_connector_id: None,
authentication_data: None,
encoded_data: None,
unified_code: None,
unified_message: None,
external_three_ds_authentication_attempted: None,
authentication_connector: None,
authentication_id: None,
fingerprint_id: None,
payment_method_billing_address_id: None,
client_source: None,
client_version: None,
customer_acceptance: None,
card_network: None,
shipping_cost: None,
capture_before: None,
extended_authorization_applied: None,
order_tax_amount: None,
processor_transaction_data: None,
connector_mandate_detail: None,
card_discovery: None,
charges: None,
issuer_error_code: None,
issuer_error_message: None,
},
PaymentAttemptUpdate::UpdateTrackers {
payment_token,
connector,
straight_through_algorithm,
amount_capturable,
surcharge_amount,
tax_amount,
updated_by,
merchant_connector_id,
} => Self {
payment_token,
modified_at: common_utils::date_time::now(),
connector: connector.map(Some),
straight_through_algorithm,
amount_capturable,
surcharge_amount,
tax_amount,
updated_by,
merchant_connector_id: merchant_connector_id.map(Some),
amount: None,
net_amount: None,
currency: None,
status: None,
connector_transaction_id: None,
amount_to_capture: None,
authentication_type: None,
payment_method: None,
error_message: None,
payment_method_id: None,
cancellation_reason: None,
mandate_id: None,
browser_info: None,
error_code: None,
connector_metadata: None,
payment_method_data: None,
payment_method_type: None,
payment_experience: None,
business_sub_label: None,
preprocessing_step_id: None,
error_reason: None,
capture_method: None,
connector_response_reference_id: None,
multiple_capture_count: None,
authentication_data: None,
encoded_data: None,
unified_code: None,
unified_message: None,
external_three_ds_authentication_attempted: None,
authentication_connector: None,
authentication_id: None,
fingerprint_id: None,
payment_method_billing_address_id: None,
client_source: None,
client_version: None,
customer_acceptance: None,
card_network: None,
shipping_cost: None,
capture_before: None,
extended_authorization_applied: None,
order_tax_amount: None,
processor_transaction_data: None,
connector_mandate_detail: None,
card_discovery: None,
charges: None,
issuer_error_code: None,
issuer_error_message: None,
},
PaymentAttemptUpdate::UnresolvedResponseUpdate {
status,
connector,
connector_transaction_id,
payment_method_id,
error_code,
error_message,
error_reason,
connector_response_reference_id,
updated_by,
} => {
let (connector_transaction_id, processor_transaction_data) =
connector_transaction_id
.map(ConnectorTransactionId::form_id_and_data)
.map(|(txn_id, txn_data)| (Some(txn_id), txn_data))
.unwrap_or((None, None));
Self {
status: Some(status),
connector: connector.map(Some),
connector_transaction_id,
payment_method_id,
modified_at: common_utils::date_time::now(),
error_code,
error_message,
error_reason,
connector_response_reference_id,
updated_by,
processor_transaction_data,
amount: None,
net_amount: None,
currency: None,
amount_to_capture: None,
authentication_type: None,
payment_method: None,
cancellation_reason: None,
mandate_id: None,
browser_info: None,
payment_token: None,
connector_metadata: None,
payment_method_data: None,
payment_method_type: None,
payment_experience: None,
business_sub_label: None,
straight_through_algorithm: None,
preprocessing_step_id: None,
capture_method: None,
multiple_capture_count: None,
surcharge_amount: None,
tax_amount: None,
amount_capturable: None,
merchant_connector_id: None,
authentication_data: None,
encoded_data: None,
unified_code: None,
unified_message: None,
external_three_ds_authentication_attempted: None,
authentication_connector: None,
authentication_id: None,
fingerprint_id: None,
payment_method_billing_address_id: None,
client_source: None,
client_version: None,
customer_acceptance: None,
card_network: None,
shipping_cost: None,
capture_before: None,
extended_authorization_applied: None,
order_tax_amount: None,
connector_mandate_detail: None,
card_discovery: None,
charges: None,
issuer_error_code: None,
issuer_error_message: None,
}
}
PaymentAttemptUpdate::PreprocessingUpdate {
status,
payment_method_id,
connector_metadata,
preprocessing_step_id,
connector_transaction_id,
connector_response_reference_id,
updated_by,
} => {
let (connector_transaction_id, processor_transaction_data) =
connector_transaction_id
.map(ConnectorTransactionId::form_id_and_data)
.map(|(txn_id, txn_data)| (Some(txn_id), txn_data))
.unwrap_or((None, None));
Self {
status: Some(status),
payment_method_id,
modified_at: common_utils::date_time::now(),
connector_metadata,
preprocessing_step_id,
connector_transaction_id,
connector_response_reference_id,
updated_by,
processor_transaction_data,
amount: None,
net_amount: None,
currency: None,
amount_to_capture: None,
connector: None,
authentication_type: None,
payment_method: None,
error_message: None,
cancellation_reason: None,
mandate_id: None,
browser_info: None,
payment_token: None,
error_code: None,
payment_method_data: None,
payment_method_type: None,
payment_experience: None,
business_sub_label: None,
straight_through_algorithm: None,
error_reason: None,
capture_method: None,
multiple_capture_count: None,
surcharge_amount: None,
tax_amount: None,
amount_capturable: None,
merchant_connector_id: None,
authentication_data: None,
encoded_data: None,
unified_code: None,
unified_message: None,
external_three_ds_authentication_attempted: None,
authentication_connector: None,
authentication_id: None,
fingerprint_id: None,
payment_method_billing_address_id: None,
client_source: None,
client_version: None,
customer_acceptance: None,
card_network: None,
capture_before: None,
extended_authorization_applied: None,
shipping_cost: None,
order_tax_amount: None,
connector_mandate_detail: None,
card_discovery: None,
charges: None,
issuer_error_code: None,
issuer_error_message: None,
}
}
PaymentAttemptUpdate::CaptureUpdate {
multiple_capture_count,
updated_by,
amount_to_capture,
} => Self {
multiple_capture_count,
modified_at: common_utils::date_time::now(),
updated_by,
amount_to_capture,
amount: None,
net_amount: None,
currency: None,
status: None,
connector_transaction_id: None,
connector: None,
authentication_type: None,
payment_method: None,
error_message: None,
payment_method_id: None,
cancellation_reason: None,
mandate_id: None,
browser_info: None,
payment_token: None,
error_code: None,
connector_metadata: None,
payment_method_data: None,
payment_method_type: None,
payment_experience: None,
business_sub_label: None,
straight_through_algorithm: None,
preprocessing_step_id: None,
error_reason: None,
capture_method: None,
connector_response_reference_id: None,
surcharge_amount: None,
tax_amount: None,
amount_capturable: None,
merchant_connector_id: None,
authentication_data: None,
encoded_data: None,
unified_code: None,
unified_message: None,
external_three_ds_authentication_attempted: None,
authentication_connector: None,
authentication_id: None,
fingerprint_id: None,
payment_method_billing_address_id: None,
client_source: None,
client_version: None,
customer_acceptance: None,
card_network: None,
shipping_cost: None,
order_tax_amount: None,
capture_before: None,
extended_authorization_applied: None,
processor_transaction_data: None,
connector_mandate_detail: None,
card_discovery: None,
charges: None,
issuer_error_code: None,
issuer_error_message: None,
},
PaymentAttemptUpdate::AmountToCaptureUpdate {
status,
amount_capturable,
updated_by,
} => Self {
status: Some(status),
modified_at: common_utils::date_time::now(),
amount_capturable: Some(amount_capturable),
updated_by,
amount: None,
net_amount: None,
currency: None,
connector_transaction_id: None,
amount_to_capture: None,
connector: None,
authentication_type: None,
payment_method: None,
error_message: None,
payment_method_id: None,
cancellation_reason: None,
mandate_id: None,
browser_info: None,
payment_token: None,
error_code: None,
connector_metadata: None,
payment_method_data: None,
payment_method_type: None,
payment_experience: None,
business_sub_label: None,
straight_through_algorithm: None,
preprocessing_step_id: None,
error_reason: None,
capture_method: None,
connector_response_reference_id: None,
multiple_capture_count: None,
surcharge_amount: None,
tax_amount: None,
merchant_connector_id: None,
authentication_data: None,
encoded_data: None,
unified_code: None,
unified_message: None,
external_three_ds_authentication_attempted: None,
authentication_connector: None,
authentication_id: None,
fingerprint_id: None,
payment_method_billing_address_id: None,
client_source: None,
client_version: None,
customer_acceptance: None,
card_network: None,
shipping_cost: None,
capture_before: None,
extended_authorization_applied: None,
order_tax_amount: None,
processor_transaction_data: None,
connector_mandate_detail: None,
card_discovery: None,
charges: None,
issuer_error_code: None,
issuer_error_message: None,
},
PaymentAttemptUpdate::ConnectorResponse {
authentication_data,
encoded_data,
connector_transaction_id,
connector,
updated_by,
charges,
} => {
let (connector_transaction_id, processor_transaction_data) =
connector_transaction_id
.map(ConnectorTransactionId::form_id_and_data)
.map(|(txn_id, txn_data)| (Some(txn_id), txn_data))
.unwrap_or((None, None));
Self {
authentication_data,
encoded_data,
connector_transaction_id,
connector: connector.map(Some),
modified_at: common_utils::date_time::now(),
updated_by,
processor_transaction_data,
charges,
amount: None,
net_amount: None,
currency: None,
status: None,
amount_to_capture: None,
authentication_type: None,
payment_method: None,
error_message: None,
payment_method_id: None,
cancellation_reason: None,
mandate_id: None,
browser_info: None,
payment_token: None,
error_code: None,
connector_metadata: None,
payment_method_data: None,
payment_method_type: None,
payment_experience: None,
business_sub_label: None,
straight_through_algorithm: None,
preprocessing_step_id: None,
error_reason: None,
capture_method: None,
connector_response_reference_id: None,
multiple_capture_count: None,
surcharge_amount: None,
tax_amount: None,
amount_capturable: None,
merchant_connector_id: None,
unified_code: None,
unified_message: None,
external_three_ds_authentication_attempted: None,
authentication_connector: None,
authentication_id: None,
fingerprint_id: None,
payment_method_billing_address_id: None,
client_source: None,
client_version: None,
customer_acceptance: None,
card_network: None,
shipping_cost: None,
capture_before: None,
extended_authorization_applied: None,
order_tax_amount: None,
connector_mandate_detail: None,
card_discovery: None,
issuer_error_code: None,
issuer_error_message: None,
}
}
PaymentAttemptUpdate::IncrementalAuthorizationAmountUpdate {
amount,
amount_capturable,
} => Self {
amount: Some(amount),
modified_at: common_utils::date_time::now(),
amount_capturable: Some(amount_capturable),
net_amount: None,
currency: None,
status: None,
connector_transaction_id: None,
amount_to_capture: None,
connector: None,
authentication_type: None,
payment_method: None,
error_message: None,
payment_method_id: None,
cancellation_reason: None,
mandate_id: None,
browser_info: None,
payment_token: None,
error_code: None,
connector_metadata: None,
payment_method_data: None,
payment_method_type: None,
payment_experience: None,
business_sub_label: None,
straight_through_algorithm: None,
preprocessing_step_id: None,
error_reason: None,
capture_method: None,
connector_response_reference_id: None,
multiple_capture_count: None,
surcharge_amount: None,
tax_amount: None,
updated_by: String::default(),
merchant_connector_id: None,
authentication_data: None,
encoded_data: None,
unified_code: None,
unified_message: None,
external_three_ds_authentication_attempted: None,
authentication_connector: None,
authentication_id: None,
fingerprint_id: None,
payment_method_billing_address_id: None,
client_source: None,
client_version: None,
customer_acceptance: None,
card_network: None,
shipping_cost: None,
order_tax_amount: None,
capture_before: None,
extended_authorization_applied: None,
processor_transaction_data: None,
connector_mandate_detail: None,
card_discovery: None,
charges: None,
issuer_error_code: None,
issuer_error_message: None,
},
PaymentAttemptUpdate::AuthenticationUpdate {
status,
external_three_ds_authentication_attempted,
authentication_connector,
authentication_id,
updated_by,
} => Self {
status: Some(status),
modified_at: common_utils::date_time::now(),
external_three_ds_authentication_attempted,
authentication_connector,
authentication_id,
updated_by,
amount: None,
net_amount: None,
currency: None,
connector_transaction_id: None,
amount_to_capture: None,
connector: None,
authentication_type: None,
payment_method: None,
error_message: None,
payment_method_id: None,
cancellation_reason: None,
mandate_id: None,
browser_info: None,
payment_token: None,
error_code: None,
connector_metadata: None,
payment_method_data: None,
payment_method_type: None,
payment_experience: None,
business_sub_label: None,
straight_through_algorithm: None,
preprocessing_step_id: None,
error_reason: None,
capture_method: None,
connector_response_reference_id: None,
multiple_capture_count: None,
surcharge_amount: None,
tax_amount: None,
amount_capturable: None,
merchant_connector_id: None,
authentication_data: None,
encoded_data: None,
unified_code: None,
unified_message: None,
fingerprint_id: None,
payment_method_billing_address_id: None,
client_source: None,
client_version: None,
customer_acceptance: None,
card_network: None,
shipping_cost: None,
order_tax_amount: None,
capture_before: None,
extended_authorization_applied: None,
processor_transaction_data: None,
connector_mandate_detail: None,
card_discovery: None,
charges: None,
issuer_error_code: None,
issuer_error_message: None,
},
PaymentAttemptUpdate::ManualUpdate {
status,
error_code,
error_message,
error_reason,
updated_by,
unified_code,
unified_message,
connector_transaction_id,
} => {
let (connector_transaction_id, processor_transaction_data) =
connector_transaction_id
.map(ConnectorTransactionId::form_id_and_data)
.map(|(txn_id, txn_data)| (Some(txn_id), txn_data))
.unwrap_or((None, None));
Self {
status,
error_code: error_code.map(Some),
modified_at: common_utils::date_time::now(),
error_message: error_message.map(Some),
error_reason: error_reason.map(Some),
updated_by,
unified_code: unified_code.map(Some),
unified_message: unified_message.map(Some),
connector_transaction_id,
processor_transaction_data,
amount: None,
net_amount: None,
currency: None,
amount_to_capture: None,
connector: None,
authentication_type: None,
payment_method: None,
payment_method_id: None,
cancellation_reason: None,
mandate_id: None,
browser_info: None,
payment_token: None,
connector_metadata: None,
payment_method_data: None,
payment_method_type: None,
payment_experience: None,
business_sub_label: None,
straight_through_algorithm: None,
preprocessing_step_id: None,
capture_method: None,
connector_response_reference_id: None,
multiple_capture_count: None,
surcharge_amount: None,
tax_amount: None,
amount_capturable: None,
merchant_connector_id: None,
authentication_data: None,
encoded_data: None,
external_three_ds_authentication_attempted: None,
authentication_connector: None,
authentication_id: None,
fingerprint_id: None,
payment_method_billing_address_id: None,
client_source: None,
client_version: None,
customer_acceptance: None,
card_network: None,
shipping_cost: None,
capture_before: None,
extended_authorization_applied: None,
order_tax_amount: None,
connector_mandate_detail: None,
card_discovery: None,
charges: None,
issuer_error_code: None,
issuer_error_message: None,
}
}
PaymentAttemptUpdate::PostSessionTokensUpdate {
updated_by,
connector_metadata,
} => Self {
status: None,
error_code: None,
modified_at: common_utils::date_time::now(),
error_message: None,
error_reason: None,
updated_by,
unified_code: None,
unified_message: None,
amount: None,
net_amount: None,
currency: None,
connector_transaction_id: None,
amount_to_capture: None,
connector: None,
authentication_type: None,
payment_method: None,
payment_method_id: None,
cancellation_reason: None,
mandate_id: None,
browser_info: None,
payment_token: None,
connector_metadata,
payment_method_data: None,
payment_method_type: None,
payment_experience: None,
business_sub_label: None,
straight_through_algorithm: None,
preprocessing_step_id: None,
capture_method: None,
connector_response_reference_id: None,
multiple_capture_count: None,
surcharge_amount: None,
tax_amount: None,
amount_capturable: None,
merchant_connector_id: None,
authentication_data: None,
encoded_data: None,
external_three_ds_authentication_attempted: None,
authentication_connector: None,
authentication_id: None,
fingerprint_id: None,
payment_method_billing_address_id: None,
client_source: None,
client_version: None,
customer_acceptance: None,
card_network: None,
shipping_cost: None,
order_tax_amount: None,
capture_before: None,
extended_authorization_applied: None,
processor_transaction_data: None,
connector_mandate_detail: None,
card_discovery: None,
charges: None,
issuer_error_code: None,
issuer_error_message: None,
},
}
}
}
#[derive(Eq, PartialEq, Clone, Debug, Deserialize, Serialize, diesel::AsExpression)]
#[diesel(sql_type = diesel::sql_types::Jsonb)]
pub enum RedirectForm {
Form {
endpoint: String,
method: common_utils::request::Method,
form_fields: std::collections::HashMap<String, String>,
},
Html {
html_data: String,
},
BlueSnap {
payment_fields_token: String,
},
CybersourceAuthSetup {
access_token: String,
ddc_url: String,
reference_id: String,
},
CybersourceConsumerAuth {
access_token: String,
step_up_url: String,
},
DeutschebankThreeDSChallengeFlow {
acs_url: String,
creq: String,
},
Payme,
Braintree {
client_token: String,
card_token: String,
bin: String,
acs_url: String,
},
Nmi {
amount: String,
currency: common_enums::Currency,
public_key: masking::Secret<String>,
customer_vault_id: String,
order_id: String,
},
Mifinity {
initialization_token: String,
},
WorldpayDDCForm {
endpoint: common_utils::types::Url,
method: common_utils::request::Method,
form_fields: std::collections::HashMap<String, String>,
collection_id: Option<String>,
},
}
common_utils::impl_to_sql_from_sql_json!(RedirectForm);
#[cfg(feature = "v2")]
#[derive(
Clone, Debug, serde::Deserialize, serde::Serialize, Eq, PartialEq, diesel::AsExpression,
)]
#[diesel(sql_type = diesel::pg::sql_types::Jsonb)]
pub struct PaymentAttemptFeatureMetadata {
pub revenue_recovery: Option<PaymentAttemptRecoveryData>,
}
#[cfg(feature = "v2")]
#[derive(
Clone, Debug, serde::Deserialize, serde::Serialize, Eq, PartialEq, diesel::AsExpression,
)]
#[diesel(sql_type = diesel::pg::sql_types::Jsonb)]
pub struct PaymentAttemptRecoveryData {
pub attempt_triggered_by: common_enums::TriggeredBy,
}
#[cfg(feature = "v2")]
common_utils::impl_to_sql_from_sql_json!(PaymentAttemptFeatureMetadata);
mod tests {
#[test]
fn test_backwards_compatibility() {
let serialized_payment_attempt = r#"{
"payment_id": "PMT123456789",
"merchant_id": "M123456789",
"attempt_id": "ATMPT123456789",
"status": "pending",
"amount": 10000,
"currency": "USD",
"save_to_locker": true,
"connector": "stripe",
"error_message": null,
"offer_amount": 9500,
"surcharge_amount": 500,
"tax_amount": 800,
"payment_method_id": "CRD123456789",
"payment_method": "card",
"connector_transaction_id": "CNTR123456789",
"capture_method": "automatic",
"capture_on": "2022-09-10T10:11:12Z",
"confirm": false,
"authentication_type": "no_three_ds",
"created_at": "2024-02-26T12:00:00Z",
"modified_at": "2024-02-26T12:00:00Z",
"last_synced": null,
"cancellation_reason": null,
"amount_to_capture": 10000,
"mandate_id": null,
"browser_info": {
"user_agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/70.0.3538.110 Safari/537.36",
"accept_header": "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8",
"language": "nl-NL",
"color_depth": 24,
"screen_height": 723,
"screen_width": 1536,
"time_zone": 0,
"java_enabled": true,
"java_script_enabled": true,
"ip_address": "127.0.0.1"
},
"error_code": null,
"payment_token": "TOKEN123456789",
"connector_metadata": null,
"payment_experience": "redirect_to_url",
"payment_method_type": "credit",
"payment_method_data": {
"card": {
"card_number": "4242424242424242",
"card_exp_month": "10",
"card_cvc": "123",
"card_exp_year": "2024",
"card_holder_name": "John Doe"
}
},
"business_sub_label": "Premium",
"straight_through_algorithm": null,
"preprocessing_step_id": null,
"mandate_details": null,
"error_reason": null,
"multiple_capture_count": 0,
"connector_response_reference_id": null,
"amount_capturable": 10000,
"updated_by": "redis_kv",
"merchant_connector_id": "MCN123456789",
"authentication_data": null,
"encoded_data": null,
"unified_code": null,
"unified_message": null,
"net_amount": 10200,
"mandate_data": {
"customer_acceptance": {
"acceptance_type": "offline",
"accepted_at": "1963-05-03T04:07:52.723Z",
"online": {
"ip_address": "127.0.0.1",
"user_agent": "amet irure esse"
}
},
"single_use": {
"amount": 6540,
"currency": "USD"
}
}
},
"fingerprint_id": null
}"#;
let deserialized =
serde_json::from_str::<super::PaymentAttempt>(serialized_payment_attempt);
assert!(deserialized.is_ok());
}
}
| proc_macro_neighborhoods |
<|meta_start|><|file|> hyperswitch/crates/router_derive/src/lib.rs<|crate|> diesel_models macro=DebugAsDisplay roles=use_site,macro_def use=derive item=file pack=proc_macro_neighborhoods lang=rust<|meta_end|>
<file_sep path="hyperswitch/crates/diesel_models/src/payment_attempt.rs" crate="diesel_models" role="use_site">
use common_types::primitive_wrappers::{
ExtendedAuthorizationAppliedBool, RequestExtendedAuthorizationBool,
};
use common_utils::{
id_type, pii,
types::{ConnectorTransactionId, ConnectorTransactionIdTrait, MinorUnit},
};
use diesel::{AsChangeset, Identifiable, Insertable, Queryable, Selectable};
use serde::{Deserialize, Serialize};
use time::PrimitiveDateTime;
use crate::enums as storage_enums;
#[cfg(feature = "v1")]
use crate::schema::payment_attempt;
#[cfg(feature = "v2")]
use crate::schema_v2::payment_attempt;
common_utils::impl_to_sql_from_sql_json!(ConnectorMandateReferenceId);
#[derive(
Clone, Debug, serde::Deserialize, serde::Serialize, Eq, PartialEq, diesel::AsExpression,
)]
#[diesel(sql_type = diesel::sql_types::Jsonb)]
pub struct ConnectorMandateReferenceId {
pub connector_mandate_id: Option<String>,
pub payment_method_id: Option<String>,
pub mandate_metadata: Option<pii::SecretSerdeValue>,
pub connector_mandate_request_reference_id: Option<String>,
}
impl ConnectorMandateReferenceId {
pub fn get_connector_mandate_request_reference_id(&self) -> Option<String> {
self.connector_mandate_request_reference_id.clone()
}
}
#[cfg(feature = "v2")]
#[derive(
Clone, Debug, Eq, PartialEq, Identifiable, Queryable, Serialize, Deserialize, Selectable,
)]
#[diesel(table_name = payment_attempt, primary_key(id), check_for_backend(diesel::pg::Pg))]
pub struct PaymentAttempt {
pub payment_id: id_type::GlobalPaymentId,
pub merchant_id: id_type::MerchantId,
pub status: storage_enums::AttemptStatus,
pub connector: Option<String>,
pub error_message: Option<String>,
pub surcharge_amount: Option<MinorUnit>,
pub payment_method_id: Option<id_type::GlobalPaymentMethodId>,
pub authentication_type: storage_enums::AuthenticationType,
#[serde(with = "common_utils::custom_serde::iso8601")]
pub created_at: PrimitiveDateTime,
#[serde(with = "common_utils::custom_serde::iso8601")]
pub modified_at: PrimitiveDateTime,
#[serde(default, with = "common_utils::custom_serde::iso8601::option")]
pub last_synced: Option<PrimitiveDateTime>,
pub cancellation_reason: Option<String>,
pub amount_to_capture: Option<MinorUnit>,
pub browser_info: Option<common_utils::types::BrowserInformation>,
pub error_code: Option<String>,
pub payment_token: Option<String>,
pub connector_metadata: Option<pii::SecretSerdeValue>,
pub payment_experience: Option<storage_enums::PaymentExperience>,
pub payment_method_data: Option<pii::SecretSerdeValue>,
pub preprocessing_step_id: Option<String>,
pub error_reason: Option<String>,
pub multiple_capture_count: Option<i16>,
pub connector_response_reference_id: Option<String>,
pub amount_capturable: MinorUnit,
pub updated_by: String,
pub merchant_connector_id: Option<id_type::MerchantConnectorAccountId>,
pub encoded_data: Option<masking::Secret<String>>,
pub unified_code: Option<String>,
pub unified_message: Option<String>,
pub net_amount: MinorUnit,
pub external_three_ds_authentication_attempted: Option<bool>,
pub authentication_connector: Option<String>,
pub authentication_id: Option<String>,
pub fingerprint_id: Option<String>,
pub client_source: Option<String>,
pub client_version: Option<String>,
pub customer_acceptance: Option<pii::SecretSerdeValue>,
pub profile_id: id_type::ProfileId,
pub organization_id: id_type::OrganizationId,
pub card_network: Option<String>,
pub shipping_cost: Option<MinorUnit>,
pub order_tax_amount: Option<MinorUnit>,
pub request_extended_authorization: Option<RequestExtendedAuthorizationBool>,
pub extended_authorization_applied: Option<ExtendedAuthorizationAppliedBool>,
pub capture_before: Option<PrimitiveDateTime>,
pub card_discovery: Option<storage_enums::CardDiscovery>,
pub charges: Option<common_types::payments::ConnectorChargeResponseData>,
pub payment_method_type_v2: storage_enums::PaymentMethod,
pub connector_payment_id: Option<ConnectorTransactionId>,
pub payment_method_subtype: storage_enums::PaymentMethodType,
pub routing_result: Option<serde_json::Value>,
pub authentication_applied: Option<common_enums::AuthenticationType>,
pub external_reference_id: Option<String>,
pub tax_on_surcharge: Option<MinorUnit>,
pub payment_method_billing_address: Option<common_utils::encryption::Encryption>,
pub redirection_data: Option<RedirectForm>,
pub connector_payment_data: Option<String>,
pub connector_token_details: Option<ConnectorTokenDetails>,
pub id: id_type::GlobalAttemptId,
pub feature_metadata: Option<PaymentAttemptFeatureMetadata>,
/// This field can be returned for both approved and refused Mastercard payments.
/// This code provides additional information about the type of transaction or the reason why the payment failed.
/// If the payment failed, the network advice code gives guidance on if and when you can retry the payment.
pub network_advice_code: Option<String>,
/// For card errors resulting from a card issuer decline, a brand specific 2, 3, or 4 digit code which indicates the reason the authorization failed.
pub network_decline_code: Option<String>,
/// A string indicating how to proceed with an network error if payment gateway provide one. This is used to understand the network error code better.
pub network_error_message: Option<String>,
}
#[cfg(feature = "v1")]
#[derive(
Clone, Debug, Eq, PartialEq, Identifiable, Queryable, Serialize, Deserialize, Selectable,
)]
#[diesel(table_name = payment_attempt, primary_key(attempt_id, merchant_id), check_for_backend(diesel::pg::Pg))]
pub struct PaymentAttempt {
pub payment_id: id_type::PaymentId,
pub merchant_id: id_type::MerchantId,
pub attempt_id: String,
pub status: storage_enums::AttemptStatus,
pub amount: MinorUnit,
pub currency: Option<storage_enums::Currency>,
pub save_to_locker: Option<bool>,
pub connector: Option<String>,
pub error_message: Option<String>,
pub offer_amount: Option<MinorUnit>,
pub surcharge_amount: Option<MinorUnit>,
pub tax_amount: Option<MinorUnit>,
pub payment_method_id: Option<String>,
pub payment_method: Option<storage_enums::PaymentMethod>,
pub connector_transaction_id: Option<ConnectorTransactionId>,
pub capture_method: Option<storage_enums::CaptureMethod>,
#[serde(default, with = "common_utils::custom_serde::iso8601::option")]
pub capture_on: Option<PrimitiveDateTime>,
pub confirm: bool,
pub authentication_type: Option<storage_enums::AuthenticationType>,
#[serde(with = "common_utils::custom_serde::iso8601")]
pub created_at: PrimitiveDateTime,
#[serde(with = "common_utils::custom_serde::iso8601")]
pub modified_at: PrimitiveDateTime,
#[serde(default, with = "common_utils::custom_serde::iso8601::option")]
pub last_synced: Option<PrimitiveDateTime>,
pub cancellation_reason: Option<String>,
pub amount_to_capture: Option<MinorUnit>,
pub mandate_id: Option<String>,
pub browser_info: Option<serde_json::Value>,
pub error_code: Option<String>,
pub payment_token: Option<String>,
pub connector_metadata: Option<serde_json::Value>,
pub payment_experience: Option<storage_enums::PaymentExperience>,
pub payment_method_type: Option<storage_enums::PaymentMethodType>,
pub payment_method_data: Option<serde_json::Value>,
pub business_sub_label: Option<String>,
pub straight_through_algorithm: Option<serde_json::Value>,
pub preprocessing_step_id: Option<String>,
// providing a location to store mandate details intermediately for transaction
pub mandate_details: Option<storage_enums::MandateDataType>,
pub error_reason: Option<String>,
pub multiple_capture_count: Option<i16>,
// reference to the payment at connector side
pub connector_response_reference_id: Option<String>,
pub amount_capturable: MinorUnit,
pub updated_by: String,
pub merchant_connector_id: Option<id_type::MerchantConnectorAccountId>,
pub authentication_data: Option<serde_json::Value>,
pub encoded_data: Option<String>,
pub unified_code: Option<String>,
pub unified_message: Option<String>,
pub net_amount: Option<MinorUnit>,
pub external_three_ds_authentication_attempted: Option<bool>,
pub authentication_connector: Option<String>,
pub authentication_id: Option<String>,
pub mandate_data: Option<storage_enums::MandateDetails>,
pub fingerprint_id: Option<String>,
pub payment_method_billing_address_id: Option<String>,
pub charge_id: Option<String>,
pub client_source: Option<String>,
pub client_version: Option<String>,
pub customer_acceptance: Option<pii::SecretSerdeValue>,
pub profile_id: id_type::ProfileId,
pub organization_id: id_type::OrganizationId,
pub card_network: Option<String>,
pub shipping_cost: Option<MinorUnit>,
pub order_tax_amount: Option<MinorUnit>,
/// INFO: This field is deprecated and replaced by processor_transaction_data
pub connector_transaction_data: Option<String>,
pub connector_mandate_detail: Option<ConnectorMandateReferenceId>,
pub request_extended_authorization: Option<RequestExtendedAuthorizationBool>,
pub extended_authorization_applied: Option<ExtendedAuthorizationAppliedBool>,
pub capture_before: Option<PrimitiveDateTime>,
pub processor_transaction_data: Option<String>,
pub card_discovery: Option<storage_enums::CardDiscovery>,
pub charges: Option<common_types::payments::ConnectorChargeResponseData>,
pub issuer_error_code: Option<String>,
pub issuer_error_message: Option<String>,
}
#[cfg(feature = "v1")]
impl ConnectorTransactionIdTrait for PaymentAttempt {
fn get_optional_connector_transaction_id(&self) -> Option<&String> {
match self
.connector_transaction_id
.as_ref()
.map(|txn_id| txn_id.get_txn_id(self.processor_transaction_data.as_ref()))
.transpose()
{
Ok(txn_id) => txn_id,
// In case hashed data is missing from DB, use the hashed ID as connector transaction ID
Err(_) => self
.connector_transaction_id
.as_ref()
.map(|txn_id| txn_id.get_id()),
}
}
}
#[cfg(feature = "v2")]
impl ConnectorTransactionIdTrait for PaymentAttempt {
fn get_optional_connector_transaction_id(&self) -> Option<&String> {
match self
.connector_payment_id
.as_ref()
.map(|txn_id| txn_id.get_txn_id(self.connector_payment_data.as_ref()))
.transpose()
{
Ok(txn_id) => txn_id,
// In case hashed data is missing from DB, use the hashed ID as connector payment ID
Err(_) => self
.connector_payment_id
.as_ref()
.map(|txn_id| txn_id.get_id()),
}
}
}
#[cfg(feature = "v2")]
#[derive(
Clone, Debug, PartialEq, Eq, serde::Deserialize, serde::Serialize, diesel::AsExpression,
)]
#[diesel(sql_type = diesel::sql_types::Jsonb)]
pub struct ConnectorTokenDetails {
pub connector_mandate_id: Option<String>,
pub connector_token_request_reference_id: Option<String>,
}
#[cfg(feature = "v2")]
common_utils::impl_to_sql_from_sql_json!(ConnectorTokenDetails);
#[cfg(feature = "v2")]
impl ConnectorTokenDetails {
pub fn get_connector_token_request_reference_id(&self) -> Option<String> {
self.connector_token_request_reference_id.clone()
}
}
#[derive(Clone, Debug, Eq, PartialEq, Queryable, Serialize, Deserialize)]
pub struct PaymentListFilters {
pub connector: Vec<String>,
pub currency: Vec<storage_enums::Currency>,
pub status: Vec<storage_enums::IntentStatus>,
pub payment_method: Vec<storage_enums::PaymentMethod>,
}
#[cfg(feature = "v2")]
#[derive(Clone, Debug, Insertable, router_derive::DebugAsDisplay, Serialize, Deserialize)]
#[diesel(table_name = payment_attempt)]
pub struct PaymentAttemptNew {
pub payment_id: id_type::GlobalPaymentId,
pub merchant_id: id_type::MerchantId,
pub status: storage_enums::AttemptStatus,
pub error_message: Option<String>,
pub surcharge_amount: Option<MinorUnit>,
pub tax_on_surcharge: Option<MinorUnit>,
pub payment_method_id: Option<id_type::GlobalPaymentMethodId>,
pub authentication_type: storage_enums::AuthenticationType,
#[serde(with = "common_utils::custom_serde::iso8601")]
pub created_at: PrimitiveDateTime,
#[serde(with = "common_utils::custom_serde::iso8601")]
pub modified_at: PrimitiveDateTime,
#[serde(default, with = "common_utils::custom_serde::iso8601::option")]
pub last_synced: Option<PrimitiveDateTime>,
pub cancellation_reason: Option<String>,
pub amount_to_capture: Option<MinorUnit>,
pub browser_info: Option<common_utils::types::BrowserInformation>,
pub payment_token: Option<String>,
pub error_code: Option<String>,
pub connector_metadata: Option<pii::SecretSerdeValue>,
pub payment_experience: Option<storage_enums::PaymentExperience>,
pub payment_method_data: Option<pii::SecretSerdeValue>,
pub preprocessing_step_id: Option<String>,
pub error_reason: Option<String>,
pub connector_response_reference_id: Option<String>,
pub multiple_capture_count: Option<i16>,
pub amount_capturable: MinorUnit,
pub updated_by: String,
pub merchant_connector_id: Option<id_type::MerchantConnectorAccountId>,
pub redirection_data: Option<RedirectForm>,
pub encoded_data: Option<masking::Secret<String>>,
pub unified_code: Option<String>,
pub unified_message: Option<String>,
pub net_amount: MinorUnit,
pub external_three_ds_authentication_attempted: Option<bool>,
pub authentication_connector: Option<String>,
pub authentication_id: Option<String>,
pub fingerprint_id: Option<String>,
pub payment_method_billing_address: Option<common_utils::encryption::Encryption>,
pub client_source: Option<String>,
pub client_version: Option<String>,
pub customer_acceptance: Option<pii::SecretSerdeValue>,
pub profile_id: id_type::ProfileId,
pub organization_id: id_type::OrganizationId,
pub card_network: Option<String>,
pub shipping_cost: Option<MinorUnit>,
pub order_tax_amount: Option<MinorUnit>,
pub charges: Option<common_types::payments::ConnectorChargeResponseData>,
pub feature_metadata: Option<PaymentAttemptFeatureMetadata>,
pub payment_method_type_v2: storage_enums::PaymentMethod,
pub connector_payment_id: Option<ConnectorTransactionId>,
pub payment_method_subtype: storage_enums::PaymentMethodType,
pub id: id_type::GlobalAttemptId,
pub connector_token_details: Option<ConnectorTokenDetails>,
pub card_discovery: Option<storage_enums::CardDiscovery>,
pub request_extended_authorization: Option<RequestExtendedAuthorizationBool>,
pub extended_authorization_applied: Option<ExtendedAuthorizationAppliedBool>,
pub capture_before: Option<PrimitiveDateTime>,
pub connector: Option<String>,
pub network_decline_code: Option<String>,
pub network_advice_code: Option<String>,
pub network_error_message: Option<String>,
}
#[cfg(feature = "v1")]
#[derive(Clone, Debug, Insertable, router_derive::DebugAsDisplay, Serialize, Deserialize)]
#[diesel(table_name = payment_attempt)]
pub struct PaymentAttemptNew {
pub payment_id: id_type::PaymentId,
pub merchant_id: id_type::MerchantId,
pub attempt_id: String,
pub status: storage_enums::AttemptStatus,
pub amount: MinorUnit,
pub currency: Option<storage_enums::Currency>,
// pub auto_capture: Option<bool>,
pub save_to_locker: Option<bool>,
pub connector: Option<String>,
pub error_message: Option<String>,
pub offer_amount: Option<MinorUnit>,
pub surcharge_amount: Option<MinorUnit>,
pub tax_amount: Option<MinorUnit>,
pub payment_method_id: Option<String>,
pub payment_method: Option<storage_enums::PaymentMethod>,
pub capture_method: Option<storage_enums::CaptureMethod>,
#[serde(default, with = "common_utils::custom_serde::iso8601::option")]
pub capture_on: Option<PrimitiveDateTime>,
pub confirm: bool,
pub authentication_type: Option<storage_enums::AuthenticationType>,
#[serde(with = "common_utils::custom_serde::iso8601")]
pub created_at: PrimitiveDateTime,
#[serde(with = "common_utils::custom_serde::iso8601")]
pub modified_at: PrimitiveDateTime,
#[serde(default, with = "common_utils::custom_serde::iso8601::option")]
pub last_synced: Option<PrimitiveDateTime>,
pub cancellation_reason: Option<String>,
pub amount_to_capture: Option<MinorUnit>,
pub mandate_id: Option<String>,
pub browser_info: Option<serde_json::Value>,
pub payment_token: Option<String>,
pub error_code: Option<String>,
pub connector_metadata: Option<serde_json::Value>,
pub payment_experience: Option<storage_enums::PaymentExperience>,
pub payment_method_type: Option<storage_enums::PaymentMethodType>,
pub payment_method_data: Option<serde_json::Value>,
pub business_sub_label: Option<String>,
pub straight_through_algorithm: Option<serde_json::Value>,
pub preprocessing_step_id: Option<String>,
pub mandate_details: Option<storage_enums::MandateDataType>,
pub error_reason: Option<String>,
pub connector_response_reference_id: Option<String>,
pub multiple_capture_count: Option<i16>,
pub amount_capturable: MinorUnit,
pub updated_by: String,
pub merchant_connector_id: Option<id_type::MerchantConnectorAccountId>,
pub authentication_data: Option<serde_json::Value>,
pub encoded_data: Option<String>,
pub unified_code: Option<String>,
pub unified_message: Option<String>,
pub net_amount: Option<MinorUnit>,
pub external_three_ds_authentication_attempted: Option<bool>,
pub authentication_connector: Option<String>,
pub authentication_id: Option<String>,
pub mandate_data: Option<storage_enums::MandateDetails>,
pub fingerprint_id: Option<String>,
pub payment_method_billing_address_id: Option<String>,
pub client_source: Option<String>,
pub client_version: Option<String>,
pub customer_acceptance: Option<pii::SecretSerdeValue>,
pub profile_id: id_type::ProfileId,
pub organization_id: id_type::OrganizationId,
pub card_network: Option<String>,
pub shipping_cost: Option<MinorUnit>,
pub order_tax_amount: Option<MinorUnit>,
pub connector_mandate_detail: Option<ConnectorMandateReferenceId>,
pub request_extended_authorization: Option<RequestExtendedAuthorizationBool>,
pub extended_authorization_applied: Option<ExtendedAuthorizationAppliedBool>,
#[serde(default, with = "common_utils::custom_serde::iso8601::option")]
pub capture_before: Option<PrimitiveDateTime>,
pub card_discovery: Option<storage_enums::CardDiscovery>,
}
#[cfg(feature = "v1")]
#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum PaymentAttemptUpdate {
Update {
amount: MinorUnit,
currency: storage_enums::Currency,
status: storage_enums::AttemptStatus,
authentication_type: Option<storage_enums::AuthenticationType>,
payment_method: Option<storage_enums::PaymentMethod>,
payment_token: Option<String>,
payment_method_data: Option<serde_json::Value>,
payment_method_type: Option<storage_enums::PaymentMethodType>,
payment_experience: Option<storage_enums::PaymentExperience>,
business_sub_label: Option<String>,
amount_to_capture: Option<MinorUnit>,
capture_method: Option<storage_enums::CaptureMethod>,
surcharge_amount: Option<MinorUnit>,
tax_amount: Option<MinorUnit>,
fingerprint_id: Option<String>,
payment_method_billing_address_id: Option<String>,
updated_by: String,
},
UpdateTrackers {
payment_token: Option<String>,
connector: Option<String>,
straight_through_algorithm: Option<serde_json::Value>,
amount_capturable: Option<MinorUnit>,
surcharge_amount: Option<MinorUnit>,
tax_amount: Option<MinorUnit>,
updated_by: String,
merchant_connector_id: Option<id_type::MerchantConnectorAccountId>,
},
AuthenticationTypeUpdate {
authentication_type: storage_enums::AuthenticationType,
updated_by: String,
},
ConfirmUpdate {
amount: MinorUnit,
currency: storage_enums::Currency,
status: storage_enums::AttemptStatus,
authentication_type: Option<storage_enums::AuthenticationType>,
capture_method: Option<storage_enums::CaptureMethod>,
payment_method: Option<storage_enums::PaymentMethod>,
browser_info: Option<serde_json::Value>,
connector: Option<String>,
payment_token: Option<String>,
payment_method_data: Option<serde_json::Value>,
payment_method_type: Option<storage_enums::PaymentMethodType>,
payment_experience: Option<storage_enums::PaymentExperience>,
business_sub_label: Option<String>,
straight_through_algorithm: Option<serde_json::Value>,
error_code: Option<Option<String>>,
error_message: Option<Option<String>>,
amount_capturable: Option<MinorUnit>,
surcharge_amount: Option<MinorUnit>,
tax_amount: Option<MinorUnit>,
fingerprint_id: Option<String>,
updated_by: String,
merchant_connector_id: Option<id_type::MerchantConnectorAccountId>,
payment_method_id: Option<String>,
external_three_ds_authentication_attempted: Option<bool>,
authentication_connector: Option<String>,
authentication_id: Option<String>,
payment_method_billing_address_id: Option<String>,
client_source: Option<String>,
client_version: Option<String>,
customer_acceptance: Option<pii::SecretSerdeValue>,
shipping_cost: Option<MinorUnit>,
order_tax_amount: Option<MinorUnit>,
connector_mandate_detail: Option<ConnectorMandateReferenceId>,
card_discovery: Option<storage_enums::CardDiscovery>,
},
VoidUpdate {
status: storage_enums::AttemptStatus,
cancellation_reason: Option<String>,
updated_by: String,
},
PaymentMethodDetailsUpdate {
payment_method_id: Option<String>,
updated_by: String,
},
ConnectorMandateDetailUpdate {
connector_mandate_detail: Option<ConnectorMandateReferenceId>,
updated_by: String,
},
BlocklistUpdate {
status: storage_enums::AttemptStatus,
error_code: Option<Option<String>>,
error_message: Option<Option<String>>,
updated_by: String,
},
RejectUpdate {
status: storage_enums::AttemptStatus,
error_code: Option<Option<String>>,
error_message: Option<Option<String>>,
updated_by: String,
},
ResponseUpdate {
status: storage_enums::AttemptStatus,
connector: Option<String>,
connector_transaction_id: Option<String>,
authentication_type: Option<storage_enums::AuthenticationType>,
payment_method_id: Option<String>,
mandate_id: Option<String>,
connector_metadata: Option<serde_json::Value>,
payment_token: Option<String>,
error_code: Option<Option<String>>,
error_message: Option<Option<String>>,
error_reason: Option<Option<String>>,
connector_response_reference_id: Option<String>,
amount_capturable: Option<MinorUnit>,
updated_by: String,
authentication_data: Option<serde_json::Value>,
encoded_data: Option<String>,
unified_code: Option<Option<String>>,
unified_message: Option<Option<String>>,
capture_before: Option<PrimitiveDateTime>,
extended_authorization_applied: Option<ExtendedAuthorizationAppliedBool>,
payment_method_data: Option<serde_json::Value>,
connector_mandate_detail: Option<ConnectorMandateReferenceId>,
charges: Option<common_types::payments::ConnectorChargeResponseData>,
},
UnresolvedResponseUpdate {
status: storage_enums::AttemptStatus,
connector: Option<String>,
connector_transaction_id: Option<String>,
payment_method_id: Option<String>,
error_code: Option<Option<String>>,
error_message: Option<Option<String>>,
error_reason: Option<Option<String>>,
connector_response_reference_id: Option<String>,
updated_by: String,
},
StatusUpdate {
status: storage_enums::AttemptStatus,
updated_by: String,
},
ErrorUpdate {
connector: Option<String>,
status: storage_enums::AttemptStatus,
error_code: Option<Option<String>>,
error_message: Option<Option<String>>,
error_reason: Option<Option<String>>,
amount_capturable: Option<MinorUnit>,
updated_by: String,
unified_code: Option<Option<String>>,
unified_message: Option<Option<String>>,
connector_transaction_id: Option<String>,
payment_method_data: Option<serde_json::Value>,
authentication_type: Option<storage_enums::AuthenticationType>,
issuer_error_code: Option<String>,
issuer_error_message: Option<String>,
},
CaptureUpdate {
amount_to_capture: Option<MinorUnit>,
multiple_capture_count: Option<i16>,
updated_by: String,
},
AmountToCaptureUpdate {
status: storage_enums::AttemptStatus,
amount_capturable: MinorUnit,
updated_by: String,
},
PreprocessingUpdate {
status: storage_enums::AttemptStatus,
payment_method_id: Option<String>,
connector_metadata: Option<serde_json::Value>,
preprocessing_step_id: Option<String>,
connector_transaction_id: Option<String>,
connector_response_reference_id: Option<String>,
updated_by: String,
},
ConnectorResponse {
authentication_data: Option<serde_json::Value>,
encoded_data: Option<String>,
connector_transaction_id: Option<String>,
connector: Option<String>,
charges: Option<common_types::payments::ConnectorChargeResponseData>,
updated_by: String,
},
IncrementalAuthorizationAmountUpdate {
amount: MinorUnit,
amount_capturable: MinorUnit,
},
AuthenticationUpdate {
status: storage_enums::AttemptStatus,
external_three_ds_authentication_attempted: Option<bool>,
authentication_connector: Option<String>,
authentication_id: Option<String>,
updated_by: String,
},
ManualUpdate {
status: Option<storage_enums::AttemptStatus>,
error_code: Option<String>,
error_message: Option<String>,
error_reason: Option<String>,
updated_by: String,
unified_code: Option<String>,
unified_message: Option<String>,
connector_transaction_id: Option<String>,
},
PostSessionTokensUpdate {
updated_by: String,
connector_metadata: Option<serde_json::Value>,
},
}
#[cfg(feature = "v2")]
#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum PaymentAttemptUpdate {
// Update {
// amount: MinorUnit,
// currency: storage_enums::Currency,
// status: storage_enums::AttemptStatus,
// authentication_type: Option<storage_enums::AuthenticationType>,
// payment_method: Option<storage_enums::PaymentMethod>,
// payment_token: Option<String>,
// payment_method_data: Option<serde_json::Value>,
// payment_method_type: Option<storage_enums::PaymentMethodType>,
// payment_experience: Option<storage_enums::PaymentExperience>,
// business_sub_label: Option<String>,
// amount_to_capture: Option<MinorUnit>,
// capture_method: Option<storage_enums::CaptureMethod>,
// surcharge_amount: Option<MinorUnit>,
// tax_amount: Option<MinorUnit>,
// fingerprint_id: Option<String>,
// payment_method_billing_address_id: Option<String>,
// updated_by: String,
// },
// UpdateTrackers {
// payment_token: Option<String>,
// connector: Option<String>,
// straight_through_algorithm: Option<serde_json::Value>,
// amount_capturable: Option<MinorUnit>,
// surcharge_amount: Option<MinorUnit>,
// tax_amount: Option<MinorUnit>,
// updated_by: String,
// merchant_connector_id: Option<id_type::MerchantConnectorAccountId>,
// },
// AuthenticationTypeUpdate {
// authentication_type: storage_enums::AuthenticationType,
// updated_by: String,
// },
// ConfirmUpdate {
// amount: MinorUnit,
// currency: storage_enums::Currency,
// status: storage_enums::AttemptStatus,
// authentication_type: Option<storage_enums::AuthenticationType>,
// capture_method: Option<storage_enums::CaptureMethod>,
// payment_method: Option<storage_enums::PaymentMethod>,
// browser_info: Option<serde_json::Value>,
// connector: Option<String>,
// payment_token: Option<String>,
// payment_method_data: Option<serde_json::Value>,
// payment_method_type: Option<storage_enums::PaymentMethodType>,
// payment_experience: Option<storage_enums::PaymentExperience>,
// business_sub_label: Option<String>,
// straight_through_algorithm: Option<serde_json::Value>,
// error_code: Option<Option<String>>,
// error_message: Option<Option<String>>,
// amount_capturable: Option<MinorUnit>,
// surcharge_amount: Option<MinorUnit>,
// tax_amount: Option<MinorUnit>,
// fingerprint_id: Option<String>,
// updated_by: String,
// merchant_connector_id: Option<id_type::MerchantConnectorAccountId>,
// payment_method_id: Option<String>,
// external_three_ds_authentication_attempted: Option<bool>,
// authentication_connector: Option<String>,
// authentication_id: Option<String>,
// payment_method_billing_address_id: Option<String>,
// client_source: Option<String>,
// client_version: Option<String>,
// customer_acceptance: Option<pii::SecretSerdeValue>,
// },
// VoidUpdate {
// status: storage_enums::AttemptStatus,
// cancellation_reason: Option<String>,
// updated_by: String,
// },
// PaymentMethodDetailsUpdate {
// payment_method_id: Option<String>,
// updated_by: String,
// },
// ConnectorMandateDetailUpdate {
// connector_mandate_detail: Option<ConnectorMandateReferenceId>,
// updated_by: String,
// }
// BlocklistUpdate {
// status: storage_enums::AttemptStatus,
// error_code: Option<Option<String>>,
// error_message: Option<Option<String>>,
// updated_by: String,
// },
// RejectUpdate {
// status: storage_enums::AttemptStatus,
// error_code: Option<Option<String>>,
// error_message: Option<Option<String>>,
// updated_by: String,
// },
// ResponseUpdate {
// status: storage_enums::AttemptStatus,
// connector: Option<String>,
// connector_transaction_id: Option<String>,
// authentication_type: Option<storage_enums::AuthenticationType>,
// payment_method_id: Option<String>,
// mandate_id: Option<String>,
// connector_metadata: Option<serde_json::Value>,
// payment_token: Option<String>,
// error_code: Option<Option<String>>,
// error_message: Option<Option<String>>,
// error_reason: Option<Option<String>>,
// connector_response_reference_id: Option<String>,
// amount_capturable: Option<MinorUnit>,
// updated_by: String,
// authentication_data: Option<serde_json::Value>,
// encoded_data: Option<String>,
// unified_code: Option<Option<String>>,
// unified_message: Option<Option<String>>,
// payment_method_data: Option<serde_json::Value>,
// charge_id: Option<String>,
// },
// UnresolvedResponseUpdate {
// status: storage_enums::AttemptStatus,
// connector: Option<String>,
// connector_transaction_id: Option<String>,
// payment_method_id: Option<String>,
// error_code: Option<Option<String>>,
// error_message: Option<Option<String>>,
// error_reason: Option<Option<String>>,
// connector_response_reference_id: Option<String>,
// updated_by: String,
// },
// StatusUpdate {
// status: storage_enums::AttemptStatus,
// updated_by: String,
// },
// ErrorUpdate {
// connector: Option<String>,
// status: storage_enums::AttemptStatus,
// error_code: Option<Option<String>>,
// error_message: Option<Option<String>>,
// error_reason: Option<Option<String>>,
// amount_capturable: Option<MinorUnit>,
// updated_by: String,
// unified_code: Option<Option<String>>,
// unified_message: Option<Option<String>>,
// connector_transaction_id: Option<String>,
// payment_method_data: Option<serde_json::Value>,
// authentication_type: Option<storage_enums::AuthenticationType>,
// },
// CaptureUpdate {
// amount_to_capture: Option<MinorUnit>,
// multiple_capture_count: Option<MinorUnit>,
// updated_by: String,
// },
// AmountToCaptureUpdate {
// status: storage_enums::AttemptStatus,
// amount_capturable: MinorUnit,
// updated_by: String,
// },
// PreprocessingUpdate {
// status: storage_enums::AttemptStatus,
// payment_method_id: Option<String>,
// connector_metadata: Option<serde_json::Value>,
// preprocessing_step_id: Option<String>,
// connector_transaction_id: Option<String>,
// connector_response_reference_id: Option<String>,
// updated_by: String,
// },
// ConnectorResponse {
// authentication_data: Option<serde_json::Value>,
// encoded_data: Option<String>,
// connector_transaction_id: Option<String>,
// connector: Option<String>,
// charge_id: Option<String>,
// updated_by: String,
// },
// IncrementalAuthorizationAmountUpdate {
// amount: MinorUnit,
// amount_capturable: MinorUnit,
// },
// AuthenticationUpdate {
// status: storage_enums::AttemptStatus,
// external_three_ds_authentication_attempted: Option<bool>,
// authentication_connector: Option<String>,
// authentication_id: Option<String>,
// updated_by: String,
// },
// ManualUpdate {
// status: Option<storage_enums::AttemptStatus>,
// error_code: Option<String>,
// error_message: Option<String>,
// error_reason: Option<String>,
// updated_by: String,
// unified_code: Option<String>,
// unified_message: Option<String>,
// connector_transaction_id: Option<String>,
// },
}
// TODO: uncomment fields as and when required
#[cfg(feature = "v2")]
#[derive(Clone, Debug, AsChangeset, router_derive::DebugAsDisplay)]
#[diesel(table_name = payment_attempt)]
pub struct PaymentAttemptUpdateInternal {
pub status: Option<storage_enums::AttemptStatus>,
pub authentication_type: Option<storage_enums::AuthenticationType>,
pub error_message: Option<String>,
pub connector_payment_id: Option<String>,
// payment_method_id: Option<String>,
// cancellation_reason: Option<String>,
pub modified_at: PrimitiveDateTime,
pub browser_info: Option<serde_json::Value>,
// payment_token: Option<String>,
pub error_code: Option<String>,
pub connector_metadata: Option<pii::SecretSerdeValue>,
// payment_method_data: Option<serde_json::Value>,
// payment_experience: Option<storage_enums::PaymentExperience>,
// preprocessing_step_id: Option<String>,
pub error_reason: Option<String>,
// connector_response_reference_id: Option<String>,
// multiple_capture_count: Option<i16>,
// pub surcharge_amount: Option<MinorUnit>,
// tax_on_surcharge: Option<MinorUnit>,
pub amount_capturable: Option<MinorUnit>,
pub amount_to_capture: Option<MinorUnit>,
pub updated_by: String,
pub merchant_connector_id: Option<id_type::MerchantConnectorAccountId>,
pub connector: Option<String>,
pub redirection_data: Option<RedirectForm>,
// encoded_data: Option<String>,
pub unified_code: Option<Option<String>>,
pub unified_message: Option<Option<String>>,
// external_three_ds_authentication_attempted: Option<bool>,
// authentication_connector: Option<String>,
// authentication_id: Option<String>,
// fingerprint_id: Option<String>,
// charge_id: Option<String>,
// client_source: Option<String>,
// client_version: Option<String>,
// customer_acceptance: Option<pii::SecretSerdeValue>,
// card_network: Option<String>,
pub connector_token_details: Option<ConnectorTokenDetails>,
pub feature_metadata: Option<PaymentAttemptFeatureMetadata>,
pub network_decline_code: Option<String>,
pub network_advice_code: Option<String>,
pub network_error_message: Option<String>,
}
#[cfg(feature = "v1")]
#[derive(Clone, Debug, AsChangeset, router_derive::DebugAsDisplay)]
#[diesel(table_name = payment_attempt)]
pub struct PaymentAttemptUpdateInternal {
pub amount: Option<MinorUnit>,
pub net_amount: Option<MinorUnit>,
pub currency: Option<storage_enums::Currency>,
pub status: Option<storage_enums::AttemptStatus>,
pub connector_transaction_id: Option<ConnectorTransactionId>,
pub amount_to_capture: Option<MinorUnit>,
pub connector: Option<Option<String>>,
pub authentication_type: Option<storage_enums::AuthenticationType>,
pub payment_method: Option<storage_enums::PaymentMethod>,
pub error_message: Option<Option<String>>,
pub payment_method_id: Option<String>,
pub cancellation_reason: Option<String>,
pub modified_at: PrimitiveDateTime,
pub mandate_id: Option<String>,
pub browser_info: Option<serde_json::Value>,
pub payment_token: Option<String>,
pub error_code: Option<Option<String>>,
pub connector_metadata: Option<serde_json::Value>,
pub payment_method_data: Option<serde_json::Value>,
pub payment_method_type: Option<storage_enums::PaymentMethodType>,
pub payment_experience: Option<storage_enums::PaymentExperience>,
pub business_sub_label: Option<String>,
pub straight_through_algorithm: Option<serde_json::Value>,
pub preprocessing_step_id: Option<String>,
pub error_reason: Option<Option<String>>,
pub capture_method: Option<storage_enums::CaptureMethod>,
pub connector_response_reference_id: Option<String>,
pub multiple_capture_count: Option<i16>,
pub surcharge_amount: Option<MinorUnit>,
pub tax_amount: Option<MinorUnit>,
pub amount_capturable: Option<MinorUnit>,
pub updated_by: String,
pub merchant_connector_id: Option<Option<id_type::MerchantConnectorAccountId>>,
pub authentication_data: Option<serde_json::Value>,
pub encoded_data: Option<String>,
pub unified_code: Option<Option<String>>,
pub unified_message: Option<Option<String>>,
pub external_three_ds_authentication_attempted: Option<bool>,
pub authentication_connector: Option<String>,
pub authentication_id: Option<String>,
pub fingerprint_id: Option<String>,
pub payment_method_billing_address_id: Option<String>,
pub client_source: Option<String>,
pub client_version: Option<String>,
pub customer_acceptance: Option<pii::SecretSerdeValue>,
pub card_network: Option<String>,
pub capture_before: Option<PrimitiveDateTime>,
pub extended_authorization_applied: Option<ExtendedAuthorizationAppliedBool>,
pub shipping_cost: Option<MinorUnit>,
pub order_tax_amount: Option<MinorUnit>,
pub connector_mandate_detail: Option<ConnectorMandateReferenceId>,
pub processor_transaction_data: Option<String>,
pub card_discovery: Option<common_enums::CardDiscovery>,
pub charges: Option<common_types::payments::ConnectorChargeResponseData>,
pub issuer_error_code: Option<String>,
pub issuer_error_message: Option<String>,
}
#[cfg(feature = "v1")]
impl PaymentAttemptUpdateInternal {
pub fn populate_derived_fields(self, source: &PaymentAttempt) -> Self {
let mut update_internal = self;
update_internal.net_amount = Some(
update_internal.amount.unwrap_or(source.amount)
+ update_internal
.surcharge_amount
.or(source.surcharge_amount)
.unwrap_or(MinorUnit::new(0))
+ update_internal
.tax_amount
.or(source.tax_amount)
.unwrap_or(MinorUnit::new(0))
+ update_internal
.shipping_cost
.or(source.shipping_cost)
.unwrap_or(MinorUnit::new(0))
+ update_internal
.order_tax_amount
.or(source.order_tax_amount)
.unwrap_or(MinorUnit::new(0)),
);
update_internal.card_network = update_internal
.payment_method_data
.as_ref()
.and_then(|data| data.as_object())
.and_then(|card| card.get("card"))
.and_then(|data| data.as_object())
.and_then(|card| card.get("card_network"))
.and_then(|network| network.as_str())
.map(|network| network.to_string());
update_internal
}
}
#[cfg(feature = "v2")]
impl PaymentAttemptUpdate {
pub fn apply_changeset(self, source: PaymentAttempt) -> PaymentAttempt {
todo!()
// let PaymentAttemptUpdateInternal {
// net_amount,
// status,
// authentication_type,
// error_message,
// payment_method_id,
// cancellation_reason,
// modified_at: _,
// browser_info,
// payment_token,
// error_code,
// connector_metadata,
// payment_method_data,
// payment_experience,
// straight_through_algorithm,
// preprocessing_step_id,
// error_reason,
// connector_response_reference_id,
// multiple_capture_count,
// surcharge_amount,
// tax_amount,
// amount_capturable,
// updated_by,
// merchant_connector_id,
// authentication_data,
// encoded_data,
// unified_code,
// unified_message,
// external_three_ds_authentication_attempted,
// authentication_connector,
// authentication_id,
// payment_method_billing_address_id,
// fingerprint_id,
// charge_id,
// client_source,
// client_version,
// customer_acceptance,
// card_network,
// } = PaymentAttemptUpdateInternal::from(self).populate_derived_fields(&source);
// PaymentAttempt {
// net_amount: net_amount.or(source.net_amount),
// status: status.unwrap_or(source.status),
// authentication_type: authentication_type.or(source.authentication_type),
// error_message: error_message.unwrap_or(source.error_message),
// payment_method_id: payment_method_id.or(source.payment_method_id),
// cancellation_reason: cancellation_reason.or(source.cancellation_reason),
// modified_at: common_utils::date_time::now(),
// browser_info: browser_info.or(source.browser_info),
// payment_token: payment_token.or(source.payment_token),
// error_code: error_code.unwrap_or(source.error_code),
// connector_metadata: connector_metadata.or(source.connector_metadata),
// payment_method_data: payment_method_data.or(source.payment_method_data),
// payment_experience: payment_experience.or(source.payment_experience),
// straight_through_algorithm: straight_through_algorithm
// .or(source.straight_through_algorithm),
// preprocessing_step_id: preprocessing_step_id.or(source.preprocessing_step_id),
// error_reason: error_reason.unwrap_or(source.error_reason),
// connector_response_reference_id: connector_response_reference_id
// .or(source.connector_response_reference_id),
// multiple_capture_count: multiple_capture_count.or(source.multiple_capture_count),
// surcharge_amount: surcharge_amount.or(source.surcharge_amount),
// tax_amount: tax_amount.or(source.tax_amount),
// amount_capturable: amount_capturable.unwrap_or(source.amount_capturable),
// updated_by,
// merchant_connector_id: merchant_connector_id.unwrap_or(source.merchant_connector_id),
// authentication_data: authentication_data.or(source.authentication_data),
// encoded_data: encoded_data.or(source.encoded_data),
// unified_code: unified_code.unwrap_or(source.unified_code),
// unified_message: unified_message.unwrap_or(source.unified_message),
// external_three_ds_authentication_attempted: external_three_ds_authentication_attempted
// .or(source.external_three_ds_authentication_attempted),
// authentication_connector: authentication_connector.or(source.authentication_connector),
// authentication_id: authentication_id.or(source.authentication_id),
// payment_method_billing_address_id: payment_method_billing_address_id
// .or(source.payment_method_billing_address_id),
// fingerprint_id: fingerprint_id.or(source.fingerprint_id),
// charge_id: charge_id.or(source.charge_id),
// client_source: client_source.or(source.client_source),
// client_version: client_version.or(source.client_version),
// customer_acceptance: customer_acceptance.or(source.customer_acceptance),
// card_network: card_network.or(source.card_network),
// ..source
// }
}
}
#[cfg(feature = "v1")]
impl PaymentAttemptUpdate {
pub fn apply_changeset(self, source: PaymentAttempt) -> PaymentAttempt {
let PaymentAttemptUpdateInternal {
amount,
net_amount,
currency,
status,
connector_transaction_id,
amount_to_capture,
connector,
authentication_type,
payment_method,
error_message,
payment_method_id,
cancellation_reason,
modified_at: _,
mandate_id,
browser_info,
payment_token,
error_code,
connector_metadata,
payment_method_data,
payment_method_type,
payment_experience,
business_sub_label,
straight_through_algorithm,
preprocessing_step_id,
error_reason,
capture_method,
connector_response_reference_id,
multiple_capture_count,
surcharge_amount,
tax_amount,
amount_capturable,
updated_by,
merchant_connector_id,
authentication_data,
encoded_data,
unified_code,
unified_message,
external_three_ds_authentication_attempted,
authentication_connector,
authentication_id,
payment_method_billing_address_id,
fingerprint_id,
client_source,
client_version,
customer_acceptance,
card_network,
shipping_cost,
order_tax_amount,
processor_transaction_data,
connector_mandate_detail,
capture_before,
extended_authorization_applied,
card_discovery,
charges,
issuer_error_code,
issuer_error_message,
} = PaymentAttemptUpdateInternal::from(self).populate_derived_fields(&source);
PaymentAttempt {
amount: amount.unwrap_or(source.amount),
net_amount: net_amount.or(source.net_amount),
currency: currency.or(source.currency),
status: status.unwrap_or(source.status),
connector_transaction_id: connector_transaction_id.or(source.connector_transaction_id),
amount_to_capture: amount_to_capture.or(source.amount_to_capture),
connector: connector.unwrap_or(source.connector),
authentication_type: authentication_type.or(source.authentication_type),
payment_method: payment_method.or(source.payment_method),
error_message: error_message.unwrap_or(source.error_message),
payment_method_id: payment_method_id.or(source.payment_method_id),
cancellation_reason: cancellation_reason.or(source.cancellation_reason),
modified_at: common_utils::date_time::now(),
mandate_id: mandate_id.or(source.mandate_id),
browser_info: browser_info.or(source.browser_info),
payment_token: payment_token.or(source.payment_token),
error_code: error_code.unwrap_or(source.error_code),
connector_metadata: connector_metadata.or(source.connector_metadata),
payment_method_data: payment_method_data.or(source.payment_method_data),
payment_method_type: payment_method_type.or(source.payment_method_type),
payment_experience: payment_experience.or(source.payment_experience),
business_sub_label: business_sub_label.or(source.business_sub_label),
straight_through_algorithm: straight_through_algorithm
.or(source.straight_through_algorithm),
preprocessing_step_id: preprocessing_step_id.or(source.preprocessing_step_id),
error_reason: error_reason.unwrap_or(source.error_reason),
capture_method: capture_method.or(source.capture_method),
connector_response_reference_id: connector_response_reference_id
.or(source.connector_response_reference_id),
multiple_capture_count: multiple_capture_count.or(source.multiple_capture_count),
surcharge_amount: surcharge_amount.or(source.surcharge_amount),
tax_amount: tax_amount.or(source.tax_amount),
amount_capturable: amount_capturable.unwrap_or(source.amount_capturable),
updated_by,
merchant_connector_id: merchant_connector_id.unwrap_or(source.merchant_connector_id),
authentication_data: authentication_data.or(source.authentication_data),
encoded_data: encoded_data.or(source.encoded_data),
unified_code: unified_code.unwrap_or(source.unified_code),
unified_message: unified_message.unwrap_or(source.unified_message),
external_three_ds_authentication_attempted: external_three_ds_authentication_attempted
.or(source.external_three_ds_authentication_attempted),
authentication_connector: authentication_connector.or(source.authentication_connector),
authentication_id: authentication_id.or(source.authentication_id),
payment_method_billing_address_id: payment_method_billing_address_id
.or(source.payment_method_billing_address_id),
fingerprint_id: fingerprint_id.or(source.fingerprint_id),
client_source: client_source.or(source.client_source),
client_version: client_version.or(source.client_version),
customer_acceptance: customer_acceptance.or(source.customer_acceptance),
card_network: card_network.or(source.card_network),
shipping_cost: shipping_cost.or(source.shipping_cost),
order_tax_amount: order_tax_amount.or(source.order_tax_amount),
processor_transaction_data: processor_transaction_data
.or(source.processor_transaction_data),
connector_mandate_detail: connector_mandate_detail.or(source.connector_mandate_detail),
capture_before: capture_before.or(source.capture_before),
extended_authorization_applied: extended_authorization_applied
.or(source.extended_authorization_applied),
card_discovery: card_discovery.or(source.card_discovery),
charges: charges.or(source.charges),
issuer_error_code: issuer_error_code.or(source.issuer_error_code),
issuer_error_message: issuer_error_message.or(source.issuer_error_message),
..source
}
}
}
#[cfg(feature = "v2")]
impl From<PaymentAttemptUpdate> for PaymentAttemptUpdateInternal {
fn from(payment_attempt_update: PaymentAttemptUpdate) -> Self {
todo!()
// match payment_attempt_update {
// PaymentAttemptUpdate::Update {
// amount,
// currency,
// status,
// // connector_transaction_id,
// authentication_type,
// payment_method,
// payment_token,
// payment_method_data,
// payment_method_type,
// payment_experience,
// business_sub_label,
// amount_to_capture,
// capture_method,
// surcharge_amount,
// tax_amount,
// fingerprint_id,
// updated_by,
// payment_method_billing_address_id,
// } => Self {
// status: Some(status),
// // connector_transaction_id,
// authentication_type,
// payment_token,
// modified_at: common_utils::date_time::now(),
// payment_method_data,
// payment_experience,
// surcharge_amount,
// tax_amount,
// fingerprint_id,
// payment_method_billing_address_id,
// updated_by,
// net_amount: None,
// error_message: None,
// payment_method_id: None,
// cancellation_reason: None,
// browser_info: None,
// error_code: None,
// connector_metadata: None,
// straight_through_algorithm: None,
// preprocessing_step_id: None,
// error_reason: None,
// connector_response_reference_id: None,
// multiple_capture_count: None,
// amount_capturable: None,
// merchant_connector_id: None,
// authentication_data: None,
// encoded_data: None,
// unified_code: None,
// unified_message: None,
// external_three_ds_authentication_attempted: None,
// authentication_connector: None,
// authentication_id: None,
// charge_id: None,
// client_source: None,
// client_version: None,
// customer_acceptance: None,
// card_network: None,
// },
// PaymentAttemptUpdate::AuthenticationTypeUpdate {
// authentication_type,
// updated_by,
// } => Self {
// authentication_type: Some(authentication_type),
// modified_at: common_utils::date_time::now(),
// updated_by,
// net_amount: None,
// status: None,
// error_message: None,
// payment_method_id: None,
// cancellation_reason: None,
// browser_info: None,
// payment_token: None,
// error_code: None,
// connector_metadata: None,
// payment_method_data: None,
// payment_experience: None,
// straight_through_algorithm: None,
// preprocessing_step_id: None,
// error_reason: None,
// connector_response_reference_id: None,
// multiple_capture_count: None,
// surcharge_amount: None,
// tax_amount: None,
// amount_capturable: None,
// merchant_connector_id: None,
// authentication_data: None,
// encoded_data: None,
// unified_code: None,
// unified_message: None,
// external_three_ds_authentication_attempted: None,
// authentication_connector: None,
// authentication_id: None,
// fingerprint_id: None,
// payment_method_billing_address_id: None,
// charge_id: None,
// client_source: None,
// client_version: None,
// customer_acceptance: None,
// card_network: None,
// },
// PaymentAttemptUpdate::ConfirmUpdate {
// amount,
// currency,
// authentication_type,
// capture_method,
// status,
// payment_method,
// browser_info,
// connector,
// payment_token,
// payment_method_data,
// payment_method_type,
// payment_experience,
// business_sub_label,
// straight_through_algorithm,
// error_code,
// error_message,
// amount_capturable,
// updated_by,
// merchant_connector_id,
// surcharge_amount,
// tax_amount,
// external_three_ds_authentication_attempted,
// authentication_connector,
// authentication_id,
// payment_method_billing_address_id,
// fingerprint_id,
// payment_method_id,
// client_source,
// client_version,
// customer_acceptance,
// } => Self {
// authentication_type,
// status: Some(status),
// modified_at: common_utils::date_time::now(),
// browser_info,
// payment_token,
// payment_method_data,
// payment_experience,
// straight_through_algorithm,
// error_code,
// error_message,
// amount_capturable,
// updated_by,
// merchant_connector_id: merchant_connector_id.map(Some),
// surcharge_amount,
// tax_amount,
// external_three_ds_authentication_attempted,
// authentication_connector,
// authentication_id,
// payment_method_billing_address_id,
// fingerprint_id,
// payment_method_id,
// client_source,
// client_version,
// customer_acceptance,
// net_amount: None,
// cancellation_reason: None,
// connector_metadata: None,
// preprocessing_step_id: None,
// error_reason: None,
// connector_response_reference_id: None,
// multiple_capture_count: None,
// authentication_data: None,
// encoded_data: None,
// unified_code: None,
// unified_message: None,
// charge_id: None,
// card_network: None,
// },
// PaymentAttemptUpdate::VoidUpdate {
// status,
// cancellation_reason,
// updated_by,
// } => Self {
// status: Some(status),
// cancellation_reason,
// modified_at: common_utils::date_time::now(),
// updated_by,
// net_amount: None,
// authentication_type: None,
// error_message: None,
// payment_method_id: None,
// browser_info: None,
// payment_token: None,
// error_code: None,
// connector_metadata: None,
// payment_method_data: None,
// payment_experience: None,
// straight_through_algorithm: None,
// preprocessing_step_id: None,
// error_reason: None,
// connector_response_reference_id: None,
// multiple_capture_count: None,
// surcharge_amount: None,
// tax_amount: None,
// amount_capturable: None,
// merchant_connector_id: None,
// authentication_data: None,
// encoded_data: None,
// unified_code: None,
// unified_message: None,
// external_three_ds_authentication_attempted: None,
// authentication_connector: None,
// authentication_id: None,
// fingerprint_id: None,
// payment_method_billing_address_id: None,
// charge_id: None,
// client_source: None,
// client_version: None,
// customer_acceptance: None,
// card_network: None,
// },
// PaymentAttemptUpdate::RejectUpdate {
// status,
// error_code,
// error_message,
// updated_by,
// } => Self {
// status: Some(status),
// modified_at: common_utils::date_time::now(),
// error_code,
// error_message,
// updated_by,
// net_amount: None,
// authentication_type: None,
// payment_method_id: None,
// cancellation_reason: None,
// browser_info: None,
// payment_token: None,
// connector_metadata: None,
// payment_method_data: None,
// payment_experience: None,
// straight_through_algorithm: None,
// preprocessing_step_id: None,
// error_reason: None,
// connector_response_reference_id: None,
// multiple_capture_count: None,
// surcharge_amount: None,
// tax_amount: None,
// amount_capturable: None,
// merchant_connector_id: None,
// authentication_data: None,
// encoded_data: None,
// unified_code: None,
// unified_message: None,
// external_three_ds_authentication_attempted: None,
// authentication_connector: None,
// authentication_id: None,
// fingerprint_id: None,
// payment_method_billing_address_id: None,
// charge_id: None,
// client_source: None,
// client_version: None,
// customer_acceptance: None,
// card_network: None,
// },
// PaymentAttemptUpdate::BlocklistUpdate {
// status,
// error_code,
// error_message,
// updated_by,
// } => Self {
// status: Some(status),
// modified_at: common_utils::date_time::now(),
// error_code,
// error_message,
// updated_by,
// merchant_connector_id: Some(None),
// net_amount: None,
// authentication_type: None,
// payment_method_id: None,
// cancellation_reason: None,
// browser_info: None,
// payment_token: None,
// connector_metadata: None,
// payment_method_data: None,
// payment_experience: None,
// straight_through_algorithm: None,
// preprocessing_step_id: None,
// error_reason: None,
// connector_response_reference_id: None,
// multiple_capture_count: None,
// surcharge_amount: None,
// tax_amount: None,
// amount_capturable: None,
// authentication_data: None,
// encoded_data: None,
// unified_code: None,
// unified_message: None,
// external_three_ds_authentication_attempted: None,
// authentication_connector: None,
// authentication_id: None,
// fingerprint_id: None,
// payment_method_billing_address_id: None,
// charge_id: None,
// client_source: None,
// client_version: None,
// customer_acceptance: None,
// card_network: None,
// },
// PaymentAttemptUpdate::ConnectorMandateDetailUpdate {
// connector_mandate_detail,
// updated_by,
// } => Self {
// payment_method_id: None,
// modified_at: common_utils::date_time::now(),
// updated_by,
// amount: None,
// net_amount: None,
// currency: None,
// status: None,
// connector_transaction_id: None,
// amount_to_capture: None,
// connector: None,
// authentication_type: None,
// payment_method: None,
// error_message: None,
// cancellation_reason: None,
// mandate_id: None,
// browser_info: None,
// payment_token: None,
// error_code: None,
// connector_metadata: None,
// payment_method_data: None,
// payment_method_type: None,
// payment_experience: None,
// business_sub_label: None,
// straight_through_algorithm: None,
// preprocessing_step_id: None,
// error_reason: None,
// capture_method: None,
// connector_response_reference_id: None,
// multiple_capture_count: None,
// surcharge_amount: None,
// tax_amount: None,
// amount_capturable: None,
// merchant_connector_id: None,
// authentication_data: None,
// encoded_data: None,
// unified_code: None,
// unified_message: None,
// external_three_ds_authentication_attempted: None,
// authentication_connector: None,
// authentication_id: None,
// fingerprint_id: None,
// payment_method_billing_address_id: None,
// charge_id: None,
// client_source: None,
// client_version: None,
// customer_acceptance: None,
// card_network: None,
// shipping_cost: None,
// order_tax_amount: None,
// processor_transaction_data: None,
// connector_mandate_detail,
// },
// PaymentAttemptUpdate::ConnectorMandateDetailUpdate {
// payment_method_id,
// updated_by,
// } => Self {
// payment_method_id,
// modified_at: common_utils::date_time::now(),
// updated_by,
// net_amount: None,
// status: None,
// authentication_type: None,
// error_message: None,
// cancellation_reason: None,
// browser_info: None,
// payment_token: None,
// error_code: None,
// connector_metadata: None,
// payment_method_data: None,
// payment_experience: None,
// straight_through_algorithm: None,
// preprocessing_step_id: None,
// error_reason: None,
// connector_response_reference_id: None,
// multiple_capture_count: None,
// surcharge_amount: None,
// tax_amount: None,
// amount_capturable: None,
// merchant_connector_id: None,
// authentication_data: None,
// encoded_data: None,
// unified_code: None,
// unified_message: None,
// external_three_ds_authentication_attempted: None,
// authentication_connector: None,
// authentication_id: None,
// fingerprint_id: None,
// payment_method_billing_address_id: None,
// charge_id: None,
// client_source: None,
// client_version: None,
// customer_acceptance: None,
// card_network: None,
// },
// PaymentAttemptUpdate::ResponseUpdate {
// status,
// connector,
// connector_transaction_id,
// authentication_type,
// payment_method_id,
// mandate_id,
// connector_metadata,
// payment_token,
// error_code,
// error_message,
// error_reason,
// connector_response_reference_id,
// amount_capturable,
// updated_by,
// authentication_data,
// encoded_data,
// unified_code,
// unified_message,
// payment_method_data,
// charge_id,
// } => Self {
// status: Some(status),
// authentication_type,
// payment_method_id,
// modified_at: common_utils::date_time::now(),
// connector_metadata,
// error_code,
// error_message,
// payment_token,
// error_reason,
// connector_response_reference_id,
// amount_capturable,
// updated_by,
// authentication_data,
// encoded_data,
// unified_code,
// unified_message,
// payment_method_data,
// charge_id,
// net_amount: None,
// cancellation_reason: None,
// browser_info: None,
// payment_experience: None,
// straight_through_algorithm: None,
// preprocessing_step_id: None,
// multiple_capture_count: None,
// surcharge_amount: None,
// tax_amount: None,
// merchant_connector_id: None,
// external_three_ds_authentication_attempted: None,
// authentication_connector: None,
// authentication_id: None,
// fingerprint_id: None,
// payment_method_billing_address_id: None,
// client_source: None,
// client_version: None,
// customer_acceptance: None,
// card_network: None,
// },
// PaymentAttemptUpdate::ErrorUpdate {
// connector,
// status,
// error_code,
// error_message,
// error_reason,
// amount_capturable,
// updated_by,
// unified_code,
// unified_message,
// connector_transaction_id,
// payment_method_data,
// authentication_type,
// } => Self {
// status: Some(status),
// error_message,
// error_code,
// modified_at: common_utils::date_time::now(),
// error_reason,
// amount_capturable,
// updated_by,
// unified_code,
// unified_message,
// payment_method_data,
// authentication_type,
// net_amount: None,
// payment_method_id: None,
// cancellation_reason: None,
// browser_info: None,
// payment_token: None,
// connector_metadata: None,
// payment_experience: None,
// straight_through_algorithm: None,
// preprocessing_step_id: None,
// connector_response_reference_id: None,
// multiple_capture_count: None,
// surcharge_amount: None,
// tax_amount: None,
// merchant_connector_id: None,
// authentication_data: None,
// encoded_data: None,
// external_three_ds_authentication_attempted: None,
// authentication_connector: None,
// authentication_id: None,
// fingerprint_id: None,
// payment_method_billing_address_id: None,
// charge_id: None,
// client_source: None,
// client_version: None,
// customer_acceptance: None,
// card_network: None,
// },
// PaymentAttemptUpdate::StatusUpdate { status, updated_by } => Self {
// status: Some(status),
// modified_at: common_utils::date_time::now(),
// updated_by,
// net_amount: None,
// authentication_type: None,
// error_message: None,
// payment_method_id: None,
// cancellation_reason: None,
// browser_info: None,
// payment_token: None,
// error_code: None,
// connector_metadata: None,
// payment_method_data: None,
// payment_experience: None,
// straight_through_algorithm: None,
// preprocessing_step_id: None,
// error_reason: None,
// connector_response_reference_id: None,
// multiple_capture_count: None,
// surcharge_amount: None,
// tax_amount: None,
// amount_capturable: None,
// merchant_connector_id: None,
// authentication_data: None,
// encoded_data: None,
// unified_code: None,
// unified_message: None,
// external_three_ds_authentication_attempted: None,
// authentication_connector: None,
// authentication_id: None,
// fingerprint_id: None,
// payment_method_billing_address_id: None,
// charge_id: None,
// client_source: None,
// client_version: None,
// customer_acceptance: None,
// card_network: None,
// },
// PaymentAttemptUpdate::UpdateTrackers {
// payment_token,
// connector,
// straight_through_algorithm,
// amount_capturable,
// surcharge_amount,
// tax_amount,
// updated_by,
// merchant_connector_id,
// } => Self {
// payment_token,
// modified_at: common_utils::date_time::now(),
// straight_through_algorithm,
// amount_capturable,
// surcharge_amount,
// tax_amount,
// updated_by,
// merchant_connector_id: merchant_connector_id.map(Some),
// net_amount: None,
// status: None,
// authentication_type: None,
// error_message: None,
// payment_method_id: None,
// cancellation_reason: None,
// browser_info: None,
// error_code: None,
// connector_metadata: None,
// payment_method_data: None,
// payment_experience: None,
// preprocessing_step_id: None,
// error_reason: None,
// connector_response_reference_id: None,
// multiple_capture_count: None,
// authentication_data: None,
// encoded_data: None,
// unified_code: None,
// unified_message: None,
// external_three_ds_authentication_attempted: None,
// authentication_connector: None,
// authentication_id: None,
// fingerprint_id: None,
// payment_method_billing_address_id: None,
// charge_id: None,
// client_source: None,
// client_version: None,
// customer_acceptance: None,
// card_network: None,
// },
// PaymentAttemptUpdate::UnresolvedResponseUpdate {
// status,
// connector,
// connector_transaction_id,
// payment_method_id,
// error_code,
// error_message,
// error_reason,
// connector_response_reference_id,
// updated_by,
// } => Self {
// status: Some(status),
// payment_method_id,
// modified_at: common_utils::date_time::now(),
// error_code,
// error_message,
// error_reason,
// connector_response_reference_id,
// updated_by,
// net_amount: None,
// authentication_type: None,
// cancellation_reason: None,
// browser_info: None,
// payment_token: None,
// connector_metadata: None,
// payment_method_data: None,
// payment_experience: None,
// straight_through_algorithm: None,
// preprocessing_step_id: None,
// multiple_capture_count: None,
// surcharge_amount: None,
// tax_amount: None,
// amount_capturable: None,
// merchant_connector_id: None,
// authentication_data: None,
// encoded_data: None,
// unified_code: None,
// unified_message: None,
// external_three_ds_authentication_attempted: None,
// authentication_connector: None,
// authentication_id: None,
// fingerprint_id: None,
// payment_method_billing_address_id: None,
// charge_id: None,
// client_source: None,
// client_version: None,
// customer_acceptance: None,
// card_network: None,
// },
// PaymentAttemptUpdate::PreprocessingUpdate {
// status,
// payment_method_id,
// connector_metadata,
// preprocessing_step_id,
// connector_transaction_id,
// connector_response_reference_id,
// updated_by,
// } => Self {
// status: Some(status),
// payment_method_id,
// modified_at: common_utils::date_time::now(),
// connector_metadata,
// preprocessing_step_id,
// connector_response_reference_id,
// updated_by,
// net_amount: None,
// authentication_type: None,
// error_message: None,
// cancellation_reason: None,
// browser_info: None,
// payment_token: None,
// error_code: None,
// payment_method_data: None,
// payment_experience: None,
// straight_through_algorithm: None,
// error_reason: None,
// multiple_capture_count: None,
// surcharge_amount: None,
// tax_amount: None,
// amount_capturable: None,
// merchant_connector_id: None,
// authentication_data: None,
// encoded_data: None,
// unified_code: None,
// unified_message: None,
// external_three_ds_authentication_attempted: None,
// authentication_connector: None,
// authentication_id: None,
// fingerprint_id: None,
// payment_method_billing_address_id: None,
// charge_id: None,
// client_source: None,
// client_version: None,
// customer_acceptance: None,
// card_network: None,
// },
// PaymentAttemptUpdate::CaptureUpdate {
// multiple_capture_count,
// updated_by,
// amount_to_capture,
// } => Self {
// multiple_capture_count,
// modified_at: common_utils::date_time::now(),
// updated_by,
// net_amount: None,
// status: None,
// authentication_type: None,
// error_message: None,
// payment_method_id: None,
// cancellation_reason: None,
// browser_info: None,
// payment_token: None,
// error_code: None,
// connector_metadata: None,
// payment_method_data: None,
// payment_experience: None,
// straight_through_algorithm: None,
// preprocessing_step_id: None,
// error_reason: None,
// connector_response_reference_id: None,
// surcharge_amount: None,
// tax_amount: None,
// amount_capturable: None,
// merchant_connector_id: None,
// authentication_data: None,
// encoded_data: None,
// unified_code: None,
// unified_message: None,
// external_three_ds_authentication_attempted: None,
// authentication_connector: None,
// authentication_id: None,
// fingerprint_id: None,
// payment_method_billing_address_id: None,
// charge_id: None,
// client_source: None,
// client_version: None,
// customer_acceptance: None,
// card_network: None,
// },
// PaymentAttemptUpdate::AmountToCaptureUpdate {
// status,
// amount_capturable,
// updated_by,
// } => Self {
// status: Some(status),
// modified_at: common_utils::date_time::now(),
// amount_capturable: Some(amount_capturable),
// updated_by,
// net_amount: None,
// authentication_type: None,
// error_message: None,
// payment_method_id: None,
// cancellation_reason: None,
// browser_info: None,
// payment_token: None,
// error_code: None,
// connector_metadata: None,
// payment_method_data: None,
// payment_experience: None,
// straight_through_algorithm: None,
// preprocessing_step_id: None,
// error_reason: None,
// connector_response_reference_id: None,
// multiple_capture_count: None,
// surcharge_amount: None,
// tax_amount: None,
// merchant_connector_id: None,
// authentication_data: None,
// encoded_data: None,
// unified_code: None,
// unified_message: None,
// external_three_ds_authentication_attempted: None,
// authentication_connector: None,
// authentication_id: None,
// fingerprint_id: None,
// payment_method_billing_address_id: None,
// charge_id: None,
// client_source: None,
// client_version: None,
// customer_acceptance: None,
// card_network: None,
// },
// PaymentAttemptUpdate::ConnectorResponse {
// authentication_data,
// encoded_data,
// connector_transaction_id,
// connector,
// updated_by,
// charge_id,
// } => Self {
// authentication_data,
// encoded_data,
// modified_at: common_utils::date_time::now(),
// updated_by,
// charge_id,
// net_amount: None,
// status: None,
// authentication_type: None,
// error_message: None,
// payment_method_id: None,
// cancellation_reason: None,
// browser_info: None,
// payment_token: None,
// error_code: None,
// connector_metadata: None,
// payment_method_data: None,
// payment_experience: None,
// straight_through_algorithm: None,
// preprocessing_step_id: None,
// error_reason: None,
// connector_response_reference_id: None,
// multiple_capture_count: None,
// surcharge_amount: None,
// tax_amount: None,
// amount_capturable: None,
// merchant_connector_id: None,
// unified_code: None,
// unified_message: None,
// external_three_ds_authentication_attempted: None,
// authentication_connector: None,
// authentication_id: None,
// fingerprint_id: None,
// payment_method_billing_address_id: None,
// client_source: None,
// client_version: None,
// customer_acceptance: None,
// card_network: None,
// },
// PaymentAttemptUpdate::IncrementalAuthorizationAmountUpdate {
// amount,
// amount_capturable,
// } => Self {
// modified_at: common_utils::date_time::now(),
// amount_capturable: Some(amount_capturable),
// net_amount: None,
// status: None,
// authentication_type: None,
// error_message: None,
// payment_method_id: None,
// cancellation_reason: None,
// browser_info: None,
// payment_token: None,
// error_code: None,
// connector_metadata: None,
// payment_method_data: None,
// payment_experience: None,
// straight_through_algorithm: None,
// preprocessing_step_id: None,
// error_reason: None,
// connector_response_reference_id: None,
// multiple_capture_count: None,
// surcharge_amount: None,
// tax_amount: None,
// updated_by: String::default(),
// merchant_connector_id: None,
// authentication_data: None,
// encoded_data: None,
// unified_code: None,
// unified_message: None,
// external_three_ds_authentication_attempted: None,
// authentication_connector: None,
// authentication_id: None,
// fingerprint_id: None,
// payment_method_billing_address_id: None,
// charge_id: None,
// client_source: None,
// client_version: None,
// customer_acceptance: None,
// card_network: None,
// },
// PaymentAttemptUpdate::AuthenticationUpdate {
// status,
// external_three_ds_authentication_attempted,
// authentication_connector,
// authentication_id,
// updated_by,
// } => Self {
// status: Some(status),
// modified_at: common_utils::date_time::now(),
// external_three_ds_authentication_attempted,
// authentication_connector,
// authentication_id,
// updated_by,
// net_amount: None,
// authentication_type: None,
// error_message: None,
// payment_method_id: None,
// cancellation_reason: None,
// browser_info: None,
// payment_token: None,
// error_code: None,
// connector_metadata: None,
// payment_method_data: None,
// payment_experience: None,
// straight_through_algorithm: None,
// preprocessing_step_id: None,
// error_reason: None,
// connector_response_reference_id: None,
// multiple_capture_count: None,
// surcharge_amount: None,
// tax_amount: None,
// amount_capturable: None,
// merchant_connector_id: None,
// authentication_data: None,
// encoded_data: None,
// unified_code: None,
// unified_message: None,
// fingerprint_id: None,
// payment_method_billing_address_id: None,
// charge_id: None,
// client_source: None,
// client_version: None,
// customer_acceptance: None,
// card_network: None,
// },
// PaymentAttemptUpdate::ManualUpdate {
// status,
// error_code,
// error_message,
// error_reason,
// updated_by,
// unified_code,
// unified_message,
// connector_transaction_id,
// } => Self {
// status,
// error_code: error_code.map(Some),
// modified_at: common_utils::date_time::now(),
// error_message: error_message.map(Some),
// error_reason: error_reason.map(Some),
// updated_by,
// unified_code: unified_code.map(Some),
// unified_message: unified_message.map(Some),
// net_amount: None,
// authentication_type: None,
// payment_method_id: None,
// cancellation_reason: None,
// browser_info: None,
// payment_token: None,
// connector_metadata: None,
// payment_method_data: None,
// payment_experience: None,
// straight_through_algorithm: None,
// preprocessing_step_id: None,
// connector_response_reference_id: None,
// multiple_capture_count: None,
// surcharge_amount: None,
// tax_amount: None,
// amount_capturable: None,
// merchant_connector_id: None,
// authentication_data: None,
// encoded_data: None,
// external_three_ds_authentication_attempted: None,
// authentication_connector: None,
// authentication_id: None,
// fingerprint_id: None,
// payment_method_billing_address_id: None,
// charge_id: None,
// client_source: None,
// client_version: None,
// customer_acceptance: None,
// card_network: None,
// },
// }
}
}
#[cfg(feature = "v1")]
impl From<PaymentAttemptUpdate> for PaymentAttemptUpdateInternal {
fn from(payment_attempt_update: PaymentAttemptUpdate) -> Self {
match payment_attempt_update {
PaymentAttemptUpdate::Update {
amount,
currency,
status,
// connector_transaction_id,
authentication_type,
payment_method,
payment_token,
payment_method_data,
payment_method_type,
payment_experience,
business_sub_label,
amount_to_capture,
capture_method,
surcharge_amount,
tax_amount,
fingerprint_id,
updated_by,
payment_method_billing_address_id,
} => Self {
amount: Some(amount),
currency: Some(currency),
status: Some(status),
// connector_transaction_id,
authentication_type,
payment_method,
payment_token,
modified_at: common_utils::date_time::now(),
payment_method_data,
payment_method_type,
payment_experience,
business_sub_label,
amount_to_capture,
capture_method,
surcharge_amount,
tax_amount,
fingerprint_id,
payment_method_billing_address_id,
updated_by,
net_amount: None,
connector_transaction_id: None,
connector: None,
error_message: None,
payment_method_id: None,
cancellation_reason: None,
mandate_id: None,
browser_info: None,
error_code: None,
connector_metadata: None,
straight_through_algorithm: None,
preprocessing_step_id: None,
error_reason: None,
connector_response_reference_id: None,
multiple_capture_count: None,
amount_capturable: None,
merchant_connector_id: None,
authentication_data: None,
encoded_data: None,
unified_code: None,
unified_message: None,
external_three_ds_authentication_attempted: None,
authentication_connector: None,
authentication_id: None,
client_source: None,
client_version: None,
customer_acceptance: None,
card_network: None,
shipping_cost: None,
capture_before: None,
extended_authorization_applied: None,
order_tax_amount: None,
processor_transaction_data: None,
connector_mandate_detail: None,
card_discovery: None,
charges: None,
issuer_error_code: None,
issuer_error_message: None,
},
PaymentAttemptUpdate::AuthenticationTypeUpdate {
authentication_type,
updated_by,
} => Self {
authentication_type: Some(authentication_type),
modified_at: common_utils::date_time::now(),
updated_by,
amount: None,
net_amount: None,
currency: None,
status: None,
connector_transaction_id: None,
amount_to_capture: None,
connector: None,
payment_method: None,
error_message: None,
payment_method_id: None,
cancellation_reason: None,
mandate_id: None,
browser_info: None,
payment_token: None,
error_code: None,
connector_metadata: None,
payment_method_data: None,
payment_method_type: None,
payment_experience: None,
business_sub_label: None,
straight_through_algorithm: None,
preprocessing_step_id: None,
error_reason: None,
capture_method: None,
connector_response_reference_id: None,
multiple_capture_count: None,
surcharge_amount: None,
tax_amount: None,
amount_capturable: None,
merchant_connector_id: None,
authentication_data: None,
encoded_data: None,
unified_code: None,
unified_message: None,
external_three_ds_authentication_attempted: None,
authentication_connector: None,
authentication_id: None,
fingerprint_id: None,
payment_method_billing_address_id: None,
client_source: None,
client_version: None,
customer_acceptance: None,
card_network: None,
shipping_cost: None,
order_tax_amount: None,
capture_before: None,
extended_authorization_applied: None,
processor_transaction_data: None,
connector_mandate_detail: None,
card_discovery: None,
charges: None,
issuer_error_code: None,
issuer_error_message: None,
},
PaymentAttemptUpdate::ConfirmUpdate {
amount,
currency,
authentication_type,
capture_method,
status,
payment_method,
browser_info,
connector,
payment_token,
payment_method_data,
payment_method_type,
payment_experience,
business_sub_label,
straight_through_algorithm,
error_code,
error_message,
amount_capturable,
updated_by,
merchant_connector_id,
surcharge_amount,
tax_amount,
external_three_ds_authentication_attempted,
authentication_connector,
authentication_id,
payment_method_billing_address_id,
fingerprint_id,
payment_method_id,
client_source,
client_version,
customer_acceptance,
shipping_cost,
order_tax_amount,
connector_mandate_detail,
card_discovery,
} => Self {
amount: Some(amount),
currency: Some(currency),
authentication_type,
status: Some(status),
payment_method,
modified_at: common_utils::date_time::now(),
browser_info,
connector: connector.map(Some),
payment_token,
payment_method_data,
payment_method_type,
payment_experience,
business_sub_label,
straight_through_algorithm,
error_code,
error_message,
amount_capturable,
updated_by,
merchant_connector_id: merchant_connector_id.map(Some),
surcharge_amount,
tax_amount,
external_three_ds_authentication_attempted,
authentication_connector,
authentication_id,
payment_method_billing_address_id,
fingerprint_id,
payment_method_id,
capture_method,
client_source,
client_version,
customer_acceptance,
net_amount: None,
connector_transaction_id: None,
amount_to_capture: None,
cancellation_reason: None,
mandate_id: None,
connector_metadata: None,
preprocessing_step_id: None,
error_reason: None,
connector_response_reference_id: None,
multiple_capture_count: None,
authentication_data: None,
encoded_data: None,
unified_code: None,
unified_message: None,
card_network: None,
shipping_cost,
order_tax_amount,
capture_before: None,
extended_authorization_applied: None,
processor_transaction_data: None,
connector_mandate_detail,
card_discovery,
charges: None,
issuer_error_code: None,
issuer_error_message: None,
},
PaymentAttemptUpdate::VoidUpdate {
status,
cancellation_reason,
updated_by,
} => Self {
status: Some(status),
cancellation_reason,
modified_at: common_utils::date_time::now(),
updated_by,
amount: None,
net_amount: None,
currency: None,
connector_transaction_id: None,
amount_to_capture: None,
connector: None,
authentication_type: None,
payment_method: None,
error_message: None,
payment_method_id: None,
mandate_id: None,
browser_info: None,
payment_token: None,
error_code: None,
connector_metadata: None,
payment_method_data: None,
payment_method_type: None,
payment_experience: None,
business_sub_label: None,
straight_through_algorithm: None,
preprocessing_step_id: None,
error_reason: None,
capture_method: None,
connector_response_reference_id: None,
multiple_capture_count: None,
surcharge_amount: None,
tax_amount: None,
amount_capturable: None,
merchant_connector_id: None,
authentication_data: None,
encoded_data: None,
unified_code: None,
unified_message: None,
external_three_ds_authentication_attempted: None,
authentication_connector: None,
authentication_id: None,
fingerprint_id: None,
payment_method_billing_address_id: None,
client_source: None,
client_version: None,
customer_acceptance: None,
card_network: None,
shipping_cost: None,
order_tax_amount: None,
capture_before: None,
extended_authorization_applied: None,
processor_transaction_data: None,
connector_mandate_detail: None,
card_discovery: None,
charges: None,
issuer_error_code: None,
issuer_error_message: None,
},
PaymentAttemptUpdate::RejectUpdate {
status,
error_code,
error_message,
updated_by,
} => Self {
status: Some(status),
modified_at: common_utils::date_time::now(),
error_code,
error_message,
updated_by,
amount: None,
net_amount: None,
currency: None,
connector_transaction_id: None,
amount_to_capture: None,
connector: None,
authentication_type: None,
payment_method: None,
payment_method_id: None,
cancellation_reason: None,
mandate_id: None,
browser_info: None,
payment_token: None,
connector_metadata: None,
payment_method_data: None,
payment_method_type: None,
payment_experience: None,
business_sub_label: None,
straight_through_algorithm: None,
preprocessing_step_id: None,
error_reason: None,
capture_method: None,
connector_response_reference_id: None,
multiple_capture_count: None,
surcharge_amount: None,
tax_amount: None,
amount_capturable: None,
merchant_connector_id: None,
authentication_data: None,
encoded_data: None,
unified_code: None,
unified_message: None,
external_three_ds_authentication_attempted: None,
authentication_connector: None,
authentication_id: None,
fingerprint_id: None,
payment_method_billing_address_id: None,
client_source: None,
client_version: None,
customer_acceptance: None,
card_network: None,
shipping_cost: None,
order_tax_amount: None,
capture_before: None,
extended_authorization_applied: None,
processor_transaction_data: None,
connector_mandate_detail: None,
card_discovery: None,
charges: None,
issuer_error_code: None,
issuer_error_message: None,
},
PaymentAttemptUpdate::BlocklistUpdate {
status,
error_code,
error_message,
updated_by,
} => Self {
status: Some(status),
modified_at: common_utils::date_time::now(),
error_code,
connector: Some(None),
error_message,
updated_by,
merchant_connector_id: Some(None),
amount: None,
net_amount: None,
currency: None,
connector_transaction_id: None,
amount_to_capture: None,
authentication_type: None,
payment_method: None,
payment_method_id: None,
cancellation_reason: None,
mandate_id: None,
browser_info: None,
payment_token: None,
connector_metadata: None,
payment_method_data: None,
payment_method_type: None,
payment_experience: None,
business_sub_label: None,
straight_through_algorithm: None,
preprocessing_step_id: None,
error_reason: None,
capture_method: None,
connector_response_reference_id: None,
multiple_capture_count: None,
surcharge_amount: None,
tax_amount: None,
amount_capturable: None,
authentication_data: None,
encoded_data: None,
unified_code: None,
unified_message: None,
external_three_ds_authentication_attempted: None,
authentication_connector: None,
authentication_id: None,
fingerprint_id: None,
payment_method_billing_address_id: None,
client_source: None,
client_version: None,
customer_acceptance: None,
card_network: None,
shipping_cost: None,
order_tax_amount: None,
capture_before: None,
extended_authorization_applied: None,
processor_transaction_data: None,
connector_mandate_detail: None,
card_discovery: None,
charges: None,
issuer_error_code: None,
issuer_error_message: None,
},
PaymentAttemptUpdate::ConnectorMandateDetailUpdate {
connector_mandate_detail,
updated_by,
} => Self {
payment_method_id: None,
modified_at: common_utils::date_time::now(),
updated_by,
amount: None,
net_amount: None,
currency: None,
status: None,
connector_transaction_id: None,
amount_to_capture: None,
connector: None,
authentication_type: None,
payment_method: None,
error_message: None,
cancellation_reason: None,
mandate_id: None,
browser_info: None,
payment_token: None,
error_code: None,
connector_metadata: None,
payment_method_data: None,
payment_method_type: None,
payment_experience: None,
business_sub_label: None,
straight_through_algorithm: None,
preprocessing_step_id: None,
error_reason: None,
capture_method: None,
connector_response_reference_id: None,
multiple_capture_count: None,
surcharge_amount: None,
tax_amount: None,
amount_capturable: None,
merchant_connector_id: None,
authentication_data: None,
encoded_data: None,
unified_code: None,
unified_message: None,
external_three_ds_authentication_attempted: None,
authentication_connector: None,
authentication_id: None,
fingerprint_id: None,
payment_method_billing_address_id: None,
client_source: None,
client_version: None,
customer_acceptance: None,
card_network: None,
shipping_cost: None,
order_tax_amount: None,
capture_before: None,
extended_authorization_applied: None,
processor_transaction_data: None,
connector_mandate_detail,
card_discovery: None,
charges: None,
issuer_error_code: None,
issuer_error_message: None,
},
PaymentAttemptUpdate::PaymentMethodDetailsUpdate {
payment_method_id,
updated_by,
} => Self {
payment_method_id,
modified_at: common_utils::date_time::now(),
updated_by,
amount: None,
net_amount: None,
currency: None,
status: None,
connector_transaction_id: None,
amount_to_capture: None,
connector: None,
authentication_type: None,
payment_method: None,
error_message: None,
cancellation_reason: None,
mandate_id: None,
browser_info: None,
payment_token: None,
error_code: None,
connector_metadata: None,
payment_method_data: None,
payment_method_type: None,
payment_experience: None,
business_sub_label: None,
straight_through_algorithm: None,
preprocessing_step_id: None,
error_reason: None,
capture_method: None,
connector_response_reference_id: None,
multiple_capture_count: None,
surcharge_amount: None,
tax_amount: None,
amount_capturable: None,
merchant_connector_id: None,
authentication_data: None,
encoded_data: None,
unified_code: None,
unified_message: None,
external_three_ds_authentication_attempted: None,
authentication_connector: None,
authentication_id: None,
fingerprint_id: None,
payment_method_billing_address_id: None,
client_source: None,
client_version: None,
customer_acceptance: None,
card_network: None,
shipping_cost: None,
order_tax_amount: None,
capture_before: None,
extended_authorization_applied: None,
processor_transaction_data: None,
connector_mandate_detail: None,
card_discovery: None,
charges: None,
issuer_error_code: None,
issuer_error_message: None,
},
PaymentAttemptUpdate::ResponseUpdate {
status,
connector,
connector_transaction_id,
authentication_type,
payment_method_id,
mandate_id,
connector_metadata,
payment_token,
error_code,
error_message,
error_reason,
connector_response_reference_id,
amount_capturable,
updated_by,
authentication_data,
encoded_data,
unified_code,
unified_message,
capture_before,
extended_authorization_applied,
payment_method_data,
connector_mandate_detail,
charges,
} => {
let (connector_transaction_id, processor_transaction_data) =
connector_transaction_id
.map(ConnectorTransactionId::form_id_and_data)
.map(|(txn_id, txn_data)| (Some(txn_id), txn_data))
.unwrap_or((None, None));
Self {
status: Some(status),
connector: connector.map(Some),
connector_transaction_id,
authentication_type,
payment_method_id,
modified_at: common_utils::date_time::now(),
mandate_id,
connector_metadata,
error_code,
error_message,
payment_token,
error_reason,
connector_response_reference_id,
amount_capturable,
updated_by,
authentication_data,
encoded_data,
unified_code,
unified_message,
payment_method_data,
processor_transaction_data,
connector_mandate_detail,
charges,
amount: None,
net_amount: None,
currency: None,
amount_to_capture: None,
payment_method: None,
cancellation_reason: None,
browser_info: None,
payment_method_type: None,
payment_experience: None,
business_sub_label: None,
straight_through_algorithm: None,
preprocessing_step_id: None,
capture_method: None,
multiple_capture_count: None,
surcharge_amount: None,
tax_amount: None,
merchant_connector_id: None,
external_three_ds_authentication_attempted: None,
authentication_connector: None,
authentication_id: None,
fingerprint_id: None,
payment_method_billing_address_id: None,
client_source: None,
client_version: None,
customer_acceptance: None,
card_network: None,
capture_before,
extended_authorization_applied,
shipping_cost: None,
order_tax_amount: None,
card_discovery: None,
issuer_error_code: None,
issuer_error_message: None,
}
}
PaymentAttemptUpdate::ErrorUpdate {
connector,
status,
error_code,
error_message,
error_reason,
amount_capturable,
updated_by,
unified_code,
unified_message,
connector_transaction_id,
payment_method_data,
authentication_type,
issuer_error_code,
issuer_error_message,
} => {
let (connector_transaction_id, processor_transaction_data) =
connector_transaction_id
.map(ConnectorTransactionId::form_id_and_data)
.map(|(txn_id, txn_data)| (Some(txn_id), txn_data))
.unwrap_or((None, None));
Self {
connector: connector.map(Some),
status: Some(status),
error_message,
error_code,
modified_at: common_utils::date_time::now(),
error_reason,
amount_capturable,
updated_by,
unified_code,
unified_message,
connector_transaction_id,
payment_method_data,
authentication_type,
processor_transaction_data,
issuer_error_code,
issuer_error_message,
amount: None,
net_amount: None,
currency: None,
amount_to_capture: None,
payment_method: None,
payment_method_id: None,
cancellation_reason: None,
mandate_id: None,
browser_info: None,
payment_token: None,
connector_metadata: None,
payment_method_type: None,
payment_experience: None,
business_sub_label: None,
straight_through_algorithm: None,
preprocessing_step_id: None,
capture_method: None,
connector_response_reference_id: None,
multiple_capture_count: None,
surcharge_amount: None,
tax_amount: None,
merchant_connector_id: None,
authentication_data: None,
encoded_data: None,
external_three_ds_authentication_attempted: None,
authentication_connector: None,
authentication_id: None,
fingerprint_id: None,
payment_method_billing_address_id: None,
client_source: None,
client_version: None,
customer_acceptance: None,
card_network: None,
capture_before: None,
extended_authorization_applied: None,
shipping_cost: None,
order_tax_amount: None,
connector_mandate_detail: None,
card_discovery: None,
charges: None,
}
}
PaymentAttemptUpdate::StatusUpdate { status, updated_by } => Self {
status: Some(status),
modified_at: common_utils::date_time::now(),
updated_by,
amount: None,
net_amount: None,
currency: None,
connector_transaction_id: None,
amount_to_capture: None,
connector: None,
authentication_type: None,
payment_method: None,
error_message: None,
payment_method_id: None,
cancellation_reason: None,
mandate_id: None,
browser_info: None,
payment_token: None,
error_code: None,
connector_metadata: None,
payment_method_data: None,
payment_method_type: None,
payment_experience: None,
business_sub_label: None,
straight_through_algorithm: None,
preprocessing_step_id: None,
error_reason: None,
capture_method: None,
connector_response_reference_id: None,
multiple_capture_count: None,
surcharge_amount: None,
tax_amount: None,
amount_capturable: None,
merchant_connector_id: None,
authentication_data: None,
encoded_data: None,
unified_code: None,
unified_message: None,
external_three_ds_authentication_attempted: None,
authentication_connector: None,
authentication_id: None,
fingerprint_id: None,
payment_method_billing_address_id: None,
client_source: None,
client_version: None,
customer_acceptance: None,
card_network: None,
shipping_cost: None,
capture_before: None,
extended_authorization_applied: None,
order_tax_amount: None,
processor_transaction_data: None,
connector_mandate_detail: None,
card_discovery: None,
charges: None,
issuer_error_code: None,
issuer_error_message: None,
},
PaymentAttemptUpdate::UpdateTrackers {
payment_token,
connector,
straight_through_algorithm,
amount_capturable,
surcharge_amount,
tax_amount,
updated_by,
merchant_connector_id,
} => Self {
payment_token,
modified_at: common_utils::date_time::now(),
connector: connector.map(Some),
straight_through_algorithm,
amount_capturable,
surcharge_amount,
tax_amount,
updated_by,
merchant_connector_id: merchant_connector_id.map(Some),
amount: None,
net_amount: None,
currency: None,
status: None,
connector_transaction_id: None,
amount_to_capture: None,
authentication_type: None,
payment_method: None,
error_message: None,
payment_method_id: None,
cancellation_reason: None,
mandate_id: None,
browser_info: None,
error_code: None,
connector_metadata: None,
payment_method_data: None,
payment_method_type: None,
payment_experience: None,
business_sub_label: None,
preprocessing_step_id: None,
error_reason: None,
capture_method: None,
connector_response_reference_id: None,
multiple_capture_count: None,
authentication_data: None,
encoded_data: None,
unified_code: None,
unified_message: None,
external_three_ds_authentication_attempted: None,
authentication_connector: None,
authentication_id: None,
fingerprint_id: None,
payment_method_billing_address_id: None,
client_source: None,
client_version: None,
customer_acceptance: None,
card_network: None,
shipping_cost: None,
capture_before: None,
extended_authorization_applied: None,
order_tax_amount: None,
processor_transaction_data: None,
connector_mandate_detail: None,
card_discovery: None,
charges: None,
issuer_error_code: None,
issuer_error_message: None,
},
PaymentAttemptUpdate::UnresolvedResponseUpdate {
status,
connector,
connector_transaction_id,
payment_method_id,
error_code,
error_message,
error_reason,
connector_response_reference_id,
updated_by,
} => {
let (connector_transaction_id, processor_transaction_data) =
connector_transaction_id
.map(ConnectorTransactionId::form_id_and_data)
.map(|(txn_id, txn_data)| (Some(txn_id), txn_data))
.unwrap_or((None, None));
Self {
status: Some(status),
connector: connector.map(Some),
connector_transaction_id,
payment_method_id,
modified_at: common_utils::date_time::now(),
error_code,
error_message,
error_reason,
connector_response_reference_id,
updated_by,
processor_transaction_data,
amount: None,
net_amount: None,
currency: None,
amount_to_capture: None,
authentication_type: None,
payment_method: None,
cancellation_reason: None,
mandate_id: None,
browser_info: None,
payment_token: None,
connector_metadata: None,
payment_method_data: None,
payment_method_type: None,
payment_experience: None,
business_sub_label: None,
straight_through_algorithm: None,
preprocessing_step_id: None,
capture_method: None,
multiple_capture_count: None,
surcharge_amount: None,
tax_amount: None,
amount_capturable: None,
merchant_connector_id: None,
authentication_data: None,
encoded_data: None,
unified_code: None,
unified_message: None,
external_three_ds_authentication_attempted: None,
authentication_connector: None,
authentication_id: None,
fingerprint_id: None,
payment_method_billing_address_id: None,
client_source: None,
client_version: None,
customer_acceptance: None,
card_network: None,
shipping_cost: None,
capture_before: None,
extended_authorization_applied: None,
order_tax_amount: None,
connector_mandate_detail: None,
card_discovery: None,
charges: None,
issuer_error_code: None,
issuer_error_message: None,
}
}
PaymentAttemptUpdate::PreprocessingUpdate {
status,
payment_method_id,
connector_metadata,
preprocessing_step_id,
connector_transaction_id,
connector_response_reference_id,
updated_by,
} => {
let (connector_transaction_id, processor_transaction_data) =
connector_transaction_id
.map(ConnectorTransactionId::form_id_and_data)
.map(|(txn_id, txn_data)| (Some(txn_id), txn_data))
.unwrap_or((None, None));
Self {
status: Some(status),
payment_method_id,
modified_at: common_utils::date_time::now(),
connector_metadata,
preprocessing_step_id,
connector_transaction_id,
connector_response_reference_id,
updated_by,
processor_transaction_data,
amount: None,
net_amount: None,
currency: None,
amount_to_capture: None,
connector: None,
authentication_type: None,
payment_method: None,
error_message: None,
cancellation_reason: None,
mandate_id: None,
browser_info: None,
payment_token: None,
error_code: None,
payment_method_data: None,
payment_method_type: None,
payment_experience: None,
business_sub_label: None,
straight_through_algorithm: None,
error_reason: None,
capture_method: None,
multiple_capture_count: None,
surcharge_amount: None,
tax_amount: None,
amount_capturable: None,
merchant_connector_id: None,
authentication_data: None,
encoded_data: None,
unified_code: None,
unified_message: None,
external_three_ds_authentication_attempted: None,
authentication_connector: None,
authentication_id: None,
fingerprint_id: None,
payment_method_billing_address_id: None,
client_source: None,
client_version: None,
customer_acceptance: None,
card_network: None,
capture_before: None,
extended_authorization_applied: None,
shipping_cost: None,
order_tax_amount: None,
connector_mandate_detail: None,
card_discovery: None,
charges: None,
issuer_error_code: None,
issuer_error_message: None,
}
}
PaymentAttemptUpdate::CaptureUpdate {
multiple_capture_count,
updated_by,
amount_to_capture,
} => Self {
multiple_capture_count,
modified_at: common_utils::date_time::now(),
updated_by,
amount_to_capture,
amount: None,
net_amount: None,
currency: None,
status: None,
connector_transaction_id: None,
connector: None,
authentication_type: None,
payment_method: None,
error_message: None,
payment_method_id: None,
cancellation_reason: None,
mandate_id: None,
browser_info: None,
payment_token: None,
error_code: None,
connector_metadata: None,
payment_method_data: None,
payment_method_type: None,
payment_experience: None,
business_sub_label: None,
straight_through_algorithm: None,
preprocessing_step_id: None,
error_reason: None,
capture_method: None,
connector_response_reference_id: None,
surcharge_amount: None,
tax_amount: None,
amount_capturable: None,
merchant_connector_id: None,
authentication_data: None,
encoded_data: None,
unified_code: None,
unified_message: None,
external_three_ds_authentication_attempted: None,
authentication_connector: None,
authentication_id: None,
fingerprint_id: None,
payment_method_billing_address_id: None,
client_source: None,
client_version: None,
customer_acceptance: None,
card_network: None,
shipping_cost: None,
order_tax_amount: None,
capture_before: None,
extended_authorization_applied: None,
processor_transaction_data: None,
connector_mandate_detail: None,
card_discovery: None,
charges: None,
issuer_error_code: None,
issuer_error_message: None,
},
PaymentAttemptUpdate::AmountToCaptureUpdate {
status,
amount_capturable,
updated_by,
} => Self {
status: Some(status),
modified_at: common_utils::date_time::now(),
amount_capturable: Some(amount_capturable),
updated_by,
amount: None,
net_amount: None,
currency: None,
connector_transaction_id: None,
amount_to_capture: None,
connector: None,
authentication_type: None,
payment_method: None,
error_message: None,
payment_method_id: None,
cancellation_reason: None,
mandate_id: None,
browser_info: None,
payment_token: None,
error_code: None,
connector_metadata: None,
payment_method_data: None,
payment_method_type: None,
payment_experience: None,
business_sub_label: None,
straight_through_algorithm: None,
preprocessing_step_id: None,
error_reason: None,
capture_method: None,
connector_response_reference_id: None,
multiple_capture_count: None,
surcharge_amount: None,
tax_amount: None,
merchant_connector_id: None,
authentication_data: None,
encoded_data: None,
unified_code: None,
unified_message: None,
external_three_ds_authentication_attempted: None,
authentication_connector: None,
authentication_id: None,
fingerprint_id: None,
payment_method_billing_address_id: None,
client_source: None,
client_version: None,
customer_acceptance: None,
card_network: None,
shipping_cost: None,
capture_before: None,
extended_authorization_applied: None,
order_tax_amount: None,
processor_transaction_data: None,
connector_mandate_detail: None,
card_discovery: None,
charges: None,
issuer_error_code: None,
issuer_error_message: None,
},
PaymentAttemptUpdate::ConnectorResponse {
authentication_data,
encoded_data,
connector_transaction_id,
connector,
updated_by,
charges,
} => {
let (connector_transaction_id, processor_transaction_data) =
connector_transaction_id
.map(ConnectorTransactionId::form_id_and_data)
.map(|(txn_id, txn_data)| (Some(txn_id), txn_data))
.unwrap_or((None, None));
Self {
authentication_data,
encoded_data,
connector_transaction_id,
connector: connector.map(Some),
modified_at: common_utils::date_time::now(),
updated_by,
processor_transaction_data,
charges,
amount: None,
net_amount: None,
currency: None,
status: None,
amount_to_capture: None,
authentication_type: None,
payment_method: None,
error_message: None,
payment_method_id: None,
cancellation_reason: None,
mandate_id: None,
browser_info: None,
payment_token: None,
error_code: None,
connector_metadata: None,
payment_method_data: None,
payment_method_type: None,
payment_experience: None,
business_sub_label: None,
straight_through_algorithm: None,
preprocessing_step_id: None,
error_reason: None,
capture_method: None,
connector_response_reference_id: None,
multiple_capture_count: None,
surcharge_amount: None,
tax_amount: None,
amount_capturable: None,
merchant_connector_id: None,
unified_code: None,
unified_message: None,
external_three_ds_authentication_attempted: None,
authentication_connector: None,
authentication_id: None,
fingerprint_id: None,
payment_method_billing_address_id: None,
client_source: None,
client_version: None,
customer_acceptance: None,
card_network: None,
shipping_cost: None,
capture_before: None,
extended_authorization_applied: None,
order_tax_amount: None,
connector_mandate_detail: None,
card_discovery: None,
issuer_error_code: None,
issuer_error_message: None,
}
}
PaymentAttemptUpdate::IncrementalAuthorizationAmountUpdate {
amount,
amount_capturable,
} => Self {
amount: Some(amount),
modified_at: common_utils::date_time::now(),
amount_capturable: Some(amount_capturable),
net_amount: None,
currency: None,
status: None,
connector_transaction_id: None,
amount_to_capture: None,
connector: None,
authentication_type: None,
payment_method: None,
error_message: None,
payment_method_id: None,
cancellation_reason: None,
mandate_id: None,
browser_info: None,
payment_token: None,
error_code: None,
connector_metadata: None,
payment_method_data: None,
payment_method_type: None,
payment_experience: None,
business_sub_label: None,
straight_through_algorithm: None,
preprocessing_step_id: None,
error_reason: None,
capture_method: None,
connector_response_reference_id: None,
multiple_capture_count: None,
surcharge_amount: None,
tax_amount: None,
updated_by: String::default(),
merchant_connector_id: None,
authentication_data: None,
encoded_data: None,
unified_code: None,
unified_message: None,
external_three_ds_authentication_attempted: None,
authentication_connector: None,
authentication_id: None,
fingerprint_id: None,
payment_method_billing_address_id: None,
client_source: None,
client_version: None,
customer_acceptance: None,
card_network: None,
shipping_cost: None,
order_tax_amount: None,
capture_before: None,
extended_authorization_applied: None,
processor_transaction_data: None,
connector_mandate_detail: None,
card_discovery: None,
charges: None,
issuer_error_code: None,
issuer_error_message: None,
},
PaymentAttemptUpdate::AuthenticationUpdate {
status,
external_three_ds_authentication_attempted,
authentication_connector,
authentication_id,
updated_by,
} => Self {
status: Some(status),
modified_at: common_utils::date_time::now(),
external_three_ds_authentication_attempted,
authentication_connector,
authentication_id,
updated_by,
amount: None,
net_amount: None,
currency: None,
connector_transaction_id: None,
amount_to_capture: None,
connector: None,
authentication_type: None,
payment_method: None,
error_message: None,
payment_method_id: None,
cancellation_reason: None,
mandate_id: None,
browser_info: None,
payment_token: None,
error_code: None,
connector_metadata: None,
payment_method_data: None,
payment_method_type: None,
payment_experience: None,
business_sub_label: None,
straight_through_algorithm: None,
preprocessing_step_id: None,
error_reason: None,
capture_method: None,
connector_response_reference_id: None,
multiple_capture_count: None,
surcharge_amount: None,
tax_amount: None,
amount_capturable: None,
merchant_connector_id: None,
authentication_data: None,
encoded_data: None,
unified_code: None,
unified_message: None,
fingerprint_id: None,
payment_method_billing_address_id: None,
client_source: None,
client_version: None,
customer_acceptance: None,
card_network: None,
shipping_cost: None,
order_tax_amount: None,
capture_before: None,
extended_authorization_applied: None,
processor_transaction_data: None,
connector_mandate_detail: None,
card_discovery: None,
charges: None,
issuer_error_code: None,
issuer_error_message: None,
},
PaymentAttemptUpdate::ManualUpdate {
status,
error_code,
error_message,
error_reason,
updated_by,
unified_code,
unified_message,
connector_transaction_id,
} => {
let (connector_transaction_id, processor_transaction_data) =
connector_transaction_id
.map(ConnectorTransactionId::form_id_and_data)
.map(|(txn_id, txn_data)| (Some(txn_id), txn_data))
.unwrap_or((None, None));
Self {
status,
error_code: error_code.map(Some),
modified_at: common_utils::date_time::now(),
error_message: error_message.map(Some),
error_reason: error_reason.map(Some),
updated_by,
unified_code: unified_code.map(Some),
unified_message: unified_message.map(Some),
connector_transaction_id,
processor_transaction_data,
amount: None,
net_amount: None,
currency: None,
amount_to_capture: None,
connector: None,
authentication_type: None,
payment_method: None,
payment_method_id: None,
cancellation_reason: None,
mandate_id: None,
browser_info: None,
payment_token: None,
connector_metadata: None,
payment_method_data: None,
payment_method_type: None,
payment_experience: None,
business_sub_label: None,
straight_through_algorithm: None,
preprocessing_step_id: None,
capture_method: None,
connector_response_reference_id: None,
multiple_capture_count: None,
surcharge_amount: None,
tax_amount: None,
amount_capturable: None,
merchant_connector_id: None,
authentication_data: None,
encoded_data: None,
external_three_ds_authentication_attempted: None,
authentication_connector: None,
authentication_id: None,
fingerprint_id: None,
payment_method_billing_address_id: None,
client_source: None,
client_version: None,
customer_acceptance: None,
card_network: None,
shipping_cost: None,
capture_before: None,
extended_authorization_applied: None,
order_tax_amount: None,
connector_mandate_detail: None,
card_discovery: None,
charges: None,
issuer_error_code: None,
issuer_error_message: None,
}
}
PaymentAttemptUpdate::PostSessionTokensUpdate {
updated_by,
connector_metadata,
} => Self {
status: None,
error_code: None,
modified_at: common_utils::date_time::now(),
error_message: None,
error_reason: None,
updated_by,
unified_code: None,
unified_message: None,
amount: None,
net_amount: None,
currency: None,
connector_transaction_id: None,
amount_to_capture: None,
connector: None,
authentication_type: None,
payment_method: None,
payment_method_id: None,
cancellation_reason: None,
mandate_id: None,
browser_info: None,
payment_token: None,
connector_metadata,
payment_method_data: None,
payment_method_type: None,
payment_experience: None,
business_sub_label: None,
straight_through_algorithm: None,
preprocessing_step_id: None,
capture_method: None,
connector_response_reference_id: None,
multiple_capture_count: None,
surcharge_amount: None,
tax_amount: None,
amount_capturable: None,
merchant_connector_id: None,
authentication_data: None,
encoded_data: None,
external_three_ds_authentication_attempted: None,
authentication_connector: None,
authentication_id: None,
fingerprint_id: None,
payment_method_billing_address_id: None,
client_source: None,
client_version: None,
customer_acceptance: None,
card_network: None,
shipping_cost: None,
order_tax_amount: None,
capture_before: None,
extended_authorization_applied: None,
processor_transaction_data: None,
connector_mandate_detail: None,
card_discovery: None,
charges: None,
issuer_error_code: None,
issuer_error_message: None,
},
}
}
}
#[derive(Eq, PartialEq, Clone, Debug, Deserialize, Serialize, diesel::AsExpression)]
#[diesel(sql_type = diesel::sql_types::Jsonb)]
pub enum RedirectForm {
Form {
endpoint: String,
method: common_utils::request::Method,
form_fields: std::collections::HashMap<String, String>,
},
Html {
html_data: String,
},
BlueSnap {
payment_fields_token: String,
},
CybersourceAuthSetup {
access_token: String,
ddc_url: String,
reference_id: String,
},
CybersourceConsumerAuth {
access_token: String,
step_up_url: String,
},
DeutschebankThreeDSChallengeFlow {
acs_url: String,
creq: String,
},
Payme,
Braintree {
client_token: String,
card_token: String,
bin: String,
acs_url: String,
},
Nmi {
amount: String,
currency: common_enums::Currency,
public_key: masking::Secret<String>,
customer_vault_id: String,
order_id: String,
},
Mifinity {
initialization_token: String,
},
WorldpayDDCForm {
endpoint: common_utils::types::Url,
method: common_utils::request::Method,
form_fields: std::collections::HashMap<String, String>,
collection_id: Option<String>,
},
}
common_utils::impl_to_sql_from_sql_json!(RedirectForm);
#[cfg(feature = "v2")]
#[derive(
Clone, Debug, serde::Deserialize, serde::Serialize, Eq, PartialEq, diesel::AsExpression,
)]
#[diesel(sql_type = diesel::pg::sql_types::Jsonb)]
pub struct PaymentAttemptFeatureMetadata {
pub revenue_recovery: Option<PaymentAttemptRecoveryData>,
}
#[cfg(feature = "v2")]
#[derive(
Clone, Debug, serde::Deserialize, serde::Serialize, Eq, PartialEq, diesel::AsExpression,
)]
#[diesel(sql_type = diesel::pg::sql_types::Jsonb)]
pub struct PaymentAttemptRecoveryData {
pub attempt_triggered_by: common_enums::TriggeredBy,
}
#[cfg(feature = "v2")]
common_utils::impl_to_sql_from_sql_json!(PaymentAttemptFeatureMetadata);
mod tests {
#[test]
fn test_backwards_compatibility() {
let serialized_payment_attempt = r#"{
"payment_id": "PMT123456789",
"merchant_id": "M123456789",
"attempt_id": "ATMPT123456789",
"status": "pending",
"amount": 10000,
"currency": "USD",
"save_to_locker": true,
"connector": "stripe",
"error_message": null,
"offer_amount": 9500,
"surcharge_amount": 500,
"tax_amount": 800,
"payment_method_id": "CRD123456789",
"payment_method": "card",
"connector_transaction_id": "CNTR123456789",
"capture_method": "automatic",
"capture_on": "2022-09-10T10:11:12Z",
"confirm": false,
"authentication_type": "no_three_ds",
"created_at": "2024-02-26T12:00:00Z",
"modified_at": "2024-02-26T12:00:00Z",
"last_synced": null,
"cancellation_reason": null,
"amount_to_capture": 10000,
"mandate_id": null,
"browser_info": {
"user_agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/70.0.3538.110 Safari/537.36",
"accept_header": "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8",
"language": "nl-NL",
"color_depth": 24,
"screen_height": 723,
"screen_width": 1536,
"time_zone": 0,
"java_enabled": true,
"java_script_enabled": true,
"ip_address": "127.0.0.1"
},
"error_code": null,
"payment_token": "TOKEN123456789",
"connector_metadata": null,
"payment_experience": "redirect_to_url",
"payment_method_type": "credit",
"payment_method_data": {
"card": {
"card_number": "4242424242424242",
"card_exp_month": "10",
"card_cvc": "123",
"card_exp_year": "2024",
"card_holder_name": "John Doe"
}
},
"business_sub_label": "Premium",
"straight_through_algorithm": null,
"preprocessing_step_id": null,
"mandate_details": null,
"error_reason": null,
"multiple_capture_count": 0,
"connector_response_reference_id": null,
"amount_capturable": 10000,
"updated_by": "redis_kv",
"merchant_connector_id": "MCN123456789",
"authentication_data": null,
"encoded_data": null,
"unified_code": null,
"unified_message": null,
"net_amount": 10200,
"mandate_data": {
"customer_acceptance": {
"acceptance_type": "offline",
"accepted_at": "1963-05-03T04:07:52.723Z",
"online": {
"ip_address": "127.0.0.1",
"user_agent": "amet irure esse"
}
},
"single_use": {
"amount": 6540,
"currency": "USD"
}
}
},
"fingerprint_id": null
}"#;
let deserialized =
serde_json::from_str::<super::PaymentAttempt>(serialized_payment_attempt);
assert!(deserialized.is_ok());
}
}
| proc_macro_neighborhoods |
<file_sep path="hyperswitch/crates/router_derive/src/lib.rs" crate="router_derive" role="macro_def">
<|fim_prefix|>
<|meta_start|><|file|> hyperswitch/crates/router_derive/src/lib.rs<|crate|> diesel_models macro=DebugAsDisplay roles=use_site,macro_def use=derive item=file pack=proc_macro_neighborhoods lang=rust<|meta_end|>
pub fn debug_as_display_derive(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
<|fim_suffix|>
<|fim_middle|>
}
<file_sep path="hyperswitch/crates/router_derive/src/lib.rs" crate="router_derive" role="macro_def">
<|fim_prefix|>
pub fn debug_as_display_derive(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
<|fim_suffix|>
<|fim_middle|>
}
| proc_macro_neighborhoods |
<file_sep path="hyperswitch/crates/router_derive/src/lib.rs" crate="router_derive" role="macro_def">
pub fn debug_as_display_derive(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
let ast = syn::parse_macro_input!(input as syn::DeriveInput);
let tokens =
macros::debug_as_display_inner(&ast).unwrap_or_else(|error| error.to_compile_error());
tokens.into()
}
<file_sep path="hyperswitch/crates/router_derive/src/lib.rs" crate="router_derive" role="macro_def">
pub fn debug_as_display_derive(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
let ast = syn::parse_macro_input!(input as syn::DeriveInput);
let tokens =
macros::debug_as_display_inner(&ast).unwrap_or_else(|error| error.to_compile_error());
tokens.into()
}
<file_sep path="hyperswitch/crates/diesel_models/src/role.rs" crate="diesel_models" role="use_site">
<|fim_prefix|>
<|meta_start|><|file|> hyperswitch/crates/router_derive/src/lib.rs<|crate|> diesel_models macro=DebugAsDisplay roles=macro_def,use_site use=derive item=file pack=proc_macro_neighborhoods lang=rust<|meta_end|>
pub struct Role {
<|fim_suffix|>
<|fim_middle|>
}
<file_sep path="hyperswitch/crates/diesel_models/src/role.rs" crate="diesel_models" role="use_site">
<|fim_prefix|>
pub struct Role {
<|fim_suffix|>
<|fim_middle|>
}
| proc_macro_neighborhoods |
<file_sep path="hyperswitch/crates/router_derive/src/lib.rs" crate="router_derive" role="macro_def">
pub fn debug_as_display_derive(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
let ast = syn::parse_macro_input!(input as syn::DeriveInput);
let tokens =
macros::debug_as_display_inner(&ast).unwrap_or_else(|error| error.to_compile_error());
tokens.into()
}
<file_sep path="hyperswitch/crates/router_derive/src/lib.rs" crate="router_derive" role="macro_def">
pub fn debug_as_display_derive(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
let ast = syn::parse_macro_input!(input as syn::DeriveInput);
let tokens =
macros::debug_as_display_inner(&ast).unwrap_or_else(|error| error.to_compile_error());
tokens.into()
}
<file_sep path="hyperswitch/crates/diesel_models/src/role.rs" crate="diesel_models" role="use_site">
<|fim_prefix|>
<|meta_start|><|file|> hyperswitch/crates/router_derive/src/lib.rs<|crate|> diesel_models macro=DebugAsDisplay roles=macro_def,use_site use=derive item=file pack=proc_macro_neighborhoods lang=rust<|meta_end|>
pub struct Role {
<|fim_suffix|>
<|fim_middle|>
}
<file_sep path="hyperswitch/crates/diesel_models/src/role.rs" crate="diesel_models" role="use_site">
<|fim_prefix|>
pub struct Role {
<|fim_suffix|>
<|fim_middle|>
}
| proc_macro_neighborhoods |
<file_sep path="hyperswitch/crates/router_derive/src/lib.rs" crate="router_derive" role="macro_def">
pub fn debug_as_display_derive(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
let ast = syn::parse_macro_input!(input as syn::DeriveInput);
let tokens =
macros::debug_as_display_inner(&ast).unwrap_or_else(|error| error.to_compile_error());
tokens.into()
}
<file_sep path="hyperswitch/crates/router_derive/src/lib.rs" crate="router_derive" role="macro_def">
pub fn debug_as_display_derive(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
let ast = syn::parse_macro_input!(input as syn::DeriveInput);
let tokens =
macros::debug_as_display_inner(&ast).unwrap_or_else(|error| error.to_compile_error());
tokens.into()
}
<file_sep path="hyperswitch/crates/diesel_models/src/dispute.rs" crate="diesel_models" role="use_site">
<|fim_prefix|>
<|meta_start|><|file|> hyperswitch/crates/router_derive/src/lib.rs<|crate|> diesel_models macro=DebugAsDisplay roles=macro_def,use_site use=derive item=file pack=proc_macro_neighborhoods lang=rust<|meta_end|>
pub struct DisputeNew {
<|fim_suffix|>
<|fim_middle|>
}
<file_sep path="hyperswitch/crates/diesel_models/src/dispute.rs" crate="diesel_models" role="use_site">
<|fim_prefix|>
pub struct DisputeNew {
<|fim_suffix|>
<|fim_middle|>
}
| proc_macro_neighborhoods |
<file_sep path="hyperswitch/crates/router_derive/src/lib.rs" crate="router_derive" role="macro_def">
pub fn debug_as_display_derive(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
let ast = syn::parse_macro_input!(input as syn::DeriveInput);
let tokens =
macros::debug_as_display_inner(&ast).unwrap_or_else(|error| error.to_compile_error());
tokens.into()
}
<file_sep path="hyperswitch/crates/router_derive/src/lib.rs" crate="router_derive" role="macro_def">
pub fn debug_as_display_derive(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
let ast = syn::parse_macro_input!(input as syn::DeriveInput);
let tokens =
macros::debug_as_display_inner(&ast).unwrap_or_else(|error| error.to_compile_error());
tokens.into()
}
<file_sep path="hyperswitch/crates/diesel_models/src/dispute.rs" crate="diesel_models" role="use_site">
<|fim_prefix|>
<|meta_start|><|file|> hyperswitch/crates/router_derive/src/lib.rs<|crate|> diesel_models macro=DebugAsDisplay roles=macro_def,use_site use=derive item=file pack=proc_macro_neighborhoods lang=rust<|meta_end|>
pub struct DisputeNew {
<|fim_suffix|>
<|fim_middle|>
}
<file_sep path="hyperswitch/crates/diesel_models/src/dispute.rs" crate="diesel_models" role="use_site">
<|fim_prefix|>
pub struct DisputeNew {
<|fim_suffix|>
<|fim_middle|>
}
| proc_macro_neighborhoods |
<file_sep path="hyperswitch/crates/router_derive/src/lib.rs" crate="router_derive" role="macro_def">
pub fn debug_as_display_derive(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
let ast = syn::parse_macro_input!(input as syn::DeriveInput);
let tokens =
macros::debug_as_display_inner(&ast).unwrap_or_else(|error| error.to_compile_error());
tokens.into()
}
<file_sep path="hyperswitch/crates/router_derive/src/lib.rs" crate="router_derive" role="macro_def">
pub fn debug_as_display_derive(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
let ast = syn::parse_macro_input!(input as syn::DeriveInput);
let tokens =
macros::debug_as_display_inner(&ast).unwrap_or_else(|error| error.to_compile_error());
tokens.into()
}
<file_sep path="hyperswitch/crates/hyperswitch_domain_models/src/payments/payment_intent.rs" crate="hyperswitch_domain_models" role="use_site">
<|fim_prefix|>
<|meta_start|><|file|> hyperswitch/crates/router_derive/src/lib.rs<|crate|> hyperswitch_domain_models macro=DebugAsDisplay roles=macro_def,use_site use=derive item=file pack=proc_macro_neighborhoods lang=rust<|meta_end|>
pub struct CustomerData {
<|fim_suffix|>
<|fim_middle|>
}
<file_sep path="hyperswitch/crates/hyperswitch_domain_models/src/payments/payment_intent.rs" crate="hyperswitch_domain_models" role="use_site">
<|fim_prefix|>
pub struct CustomerData {
<|fim_suffix|>
<|fim_middle|>
}
| proc_macro_neighborhoods |
<file_sep path="hyperswitch/crates/router_derive/src/lib.rs" crate="router_derive" role="macro_def">
pub fn debug_as_display_derive(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
let ast = syn::parse_macro_input!(input as syn::DeriveInput);
let tokens =
macros::debug_as_display_inner(&ast).unwrap_or_else(|error| error.to_compile_error());
tokens.into()
}
<file_sep path="hyperswitch/crates/router_derive/src/lib.rs" crate="router_derive" role="macro_def">
pub fn debug_as_display_derive(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
let ast = syn::parse_macro_input!(input as syn::DeriveInput);
let tokens =
macros::debug_as_display_inner(&ast).unwrap_or_else(|error| error.to_compile_error());
tokens.into()
}
<file_sep path="hyperswitch/crates/diesel_models/src/payment_attempt.rs" crate="diesel_models" role="use_site">
<|fim_prefix|>
<|meta_start|><|file|> hyperswitch/crates/router_derive/src/lib.rs<|crate|> diesel_models macro=DebugAsDisplay roles=macro_def,use_site use=derive item=file pack=proc_macro_neighborhoods lang=rust<|meta_end|>
pub struct ConnectorMandateReferenceId {
<|fim_suffix|>
<|fim_middle|>
}
<file_sep path="hyperswitch/crates/diesel_models/src/payment_attempt.rs" crate="diesel_models" role="use_site">
<|fim_prefix|>
pub struct ConnectorMandateReferenceId {
<|fim_suffix|>
<|fim_middle|>
}
| proc_macro_neighborhoods |
<file_sep path="hyperswitch/crates/router_derive/src/lib.rs" crate="router_derive" role="macro_def">
pub fn debug_as_display_derive(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
let ast = syn::parse_macro_input!(input as syn::DeriveInput);
let tokens =
macros::debug_as_display_inner(&ast).unwrap_or_else(|error| error.to_compile_error());
tokens.into()
}
<file_sep path="hyperswitch/crates/router_derive/src/lib.rs" crate="router_derive" role="macro_def">
pub fn debug_as_display_derive(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
let ast = syn::parse_macro_input!(input as syn::DeriveInput);
let tokens =
macros::debug_as_display_inner(&ast).unwrap_or_else(|error| error.to_compile_error());
tokens.into()
}
<file_sep path="hyperswitch/crates/diesel_models/src/payment_attempt.rs" crate="diesel_models" role="use_site">
<|fim_prefix|>
<|meta_start|><|file|> hyperswitch/crates/router_derive/src/lib.rs<|crate|> diesel_models macro=DebugAsDisplay roles=macro_def,use_site use=derive item=file pack=proc_macro_neighborhoods lang=rust<|meta_end|>
pub struct ConnectorMandateReferenceId {
<|fim_suffix|>
<|fim_middle|>
}
<file_sep path="hyperswitch/crates/diesel_models/src/payment_attempt.rs" crate="diesel_models" role="use_site">
<|fim_prefix|>
pub struct ConnectorMandateReferenceId {
<|fim_suffix|>
<|fim_middle|>
}
| proc_macro_neighborhoods |
<file_sep path="hyperswitch/crates/router_derive/src/lib.rs" crate="router_derive" role="macro_def">
pub fn debug_as_display_derive(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
let ast = syn::parse_macro_input!(input as syn::DeriveInput);
let tokens =
macros::debug_as_display_inner(&ast).unwrap_or_else(|error| error.to_compile_error());
tokens.into()
}
<file_sep path="hyperswitch/crates/router_derive/src/lib.rs" crate="router_derive" role="macro_def">
pub fn debug_as_display_derive(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
let ast = syn::parse_macro_input!(input as syn::DeriveInput);
let tokens =
macros::debug_as_display_inner(&ast).unwrap_or_else(|error| error.to_compile_error());
tokens.into()
}
<file_sep path="hyperswitch/crates/diesel_models/src/payment_attempt.rs" crate="diesel_models" role="use_site">
<|fim_prefix|>
<|meta_start|><|file|> hyperswitch/crates/router_derive/src/lib.rs<|crate|> diesel_models macro=DebugAsDisplay roles=macro_def,use_site use=derive item=file pack=proc_macro_neighborhoods lang=rust<|meta_end|>
pub struct ConnectorMandateReferenceId {
<|fim_suffix|>
<|fim_middle|>
}
<file_sep path="hyperswitch/crates/diesel_models/src/payment_attempt.rs" crate="diesel_models" role="use_site">
<|fim_prefix|>
pub struct ConnectorMandateReferenceId {
<|fim_suffix|>
<|fim_middle|>
}
| proc_macro_neighborhoods |
<file_sep path="hyperswitch/crates/diesel_models/src/role.rs" crate="diesel_models" role="use_site">
use common_utils::id_type;
use diesel::{AsChangeset, Identifiable, Insertable, Queryable, Selectable};
use time::PrimitiveDateTime;
use crate::{enums, schema::roles};
#[derive(Clone, Debug, Identifiable, Queryable, Selectable)]
#[diesel(table_name = roles, primary_key(role_id), check_for_backend(diesel::pg::Pg))]
pub struct Role {
pub role_name: String,
pub role_id: String,
pub merchant_id: id_type::MerchantId,
pub org_id: id_type::OrganizationId,
#[diesel(deserialize_as = super::DieselArray<enums::PermissionGroup>)]
pub groups: Vec<enums::PermissionGroup>,
pub scope: enums::RoleScope,
pub created_at: PrimitiveDateTime,
pub created_by: String,
pub last_modified_at: PrimitiveDateTime,
pub last_modified_by: String,
pub entity_type: enums::EntityType,
pub profile_id: Option<id_type::ProfileId>,
pub tenant_id: id_type::TenantId,
}
#[derive(router_derive::Setter, Clone, Debug, Insertable, router_derive::DebugAsDisplay)]
#[diesel(table_name = roles)]
pub struct RoleNew {
pub role_name: String,
pub role_id: String,
pub merchant_id: id_type::MerchantId,
pub org_id: id_type::OrganizationId,
#[diesel(deserialize_as = super::DieselArray<enums::PermissionGroup>)]
pub groups: Vec<enums::PermissionGroup>,
pub scope: enums::RoleScope,
pub created_at: PrimitiveDateTime,
pub created_by: String,
pub last_modified_at: PrimitiveDateTime,
pub last_modified_by: String,
pub entity_type: enums::EntityType,
pub profile_id: Option<id_type::ProfileId>,
pub tenant_id: id_type::TenantId,
}
#[derive(Clone, Debug, AsChangeset, router_derive::DebugAsDisplay)]
#[diesel(table_name = roles)]
pub struct RoleUpdateInternal {
groups: Option<Vec<enums::PermissionGroup>>,
role_name: Option<String>,
last_modified_by: String,
last_modified_at: PrimitiveDateTime,
}
pub enum RoleUpdate {
UpdateDetails {
groups: Option<Vec<enums::PermissionGroup>>,
role_name: Option<String>,
last_modified_at: PrimitiveDateTime,
last_modified_by: String,
},
}
impl From<RoleUpdate> for RoleUpdateInternal {
fn from(value: RoleUpdate) -> Self {
match value {
RoleUpdate::UpdateDetails {
groups,
role_name,
last_modified_by,
last_modified_at,
} => Self {
groups,
role_name,
last_modified_at,
last_modified_by,
},
}
}
}
#[derive(Clone, Debug)]
pub enum ListRolesByEntityPayload {
Profile(id_type::MerchantId, id_type::ProfileId),
Merchant(id_type::MerchantId),
Organization,
}
<file_sep path="hyperswitch/crates/diesel_models/src/role.rs" crate="diesel_models" role="use_site">
use common_utils::id_type;
use diesel::{AsChangeset, Identifiable, Insertable, Queryable, Selectable};
use time::PrimitiveDateTime;
use crate::{enums, schema::roles};
#[derive(Clone, Debug, Identifiable, Queryable, Selectable)]
#[diesel(table_name = roles, primary_key(role_id), check_for_backend(diesel::pg::Pg))]
pub struct Role {
pub role_name: String,
pub role_id: String,
pub merchant_id: id_type::MerchantId,
pub org_id: id_type::OrganizationId,
#[diesel(deserialize_as = super::DieselArray<enums::PermissionGroup>)]
pub groups: Vec<enums::PermissionGroup>,
pub scope: enums::RoleScope,
pub created_at: PrimitiveDateTime,
pub created_by: String,
pub last_modified_at: PrimitiveDateTime,
pub last_modified_by: String,
pub entity_type: enums::EntityType,
pub profile_id: Option<id_type::ProfileId>,
pub tenant_id: id_type::TenantId,
}
#[derive(router_derive::Setter, Clone, Debug, Insertable, router_derive::DebugAsDisplay)]
#[diesel(table_name = roles)]
pub struct RoleNew {
pub role_name: String,
pub role_id: String,
pub merchant_id: id_type::MerchantId,
pub org_id: id_type::OrganizationId,
#[diesel(deserialize_as = super::DieselArray<enums::PermissionGroup>)]
pub groups: Vec<enums::PermissionGroup>,
pub scope: enums::RoleScope,
pub created_at: PrimitiveDateTime,
pub created_by: String,
pub last_modified_at: PrimitiveDateTime,
pub last_modified_by: String,
pub entity_type: enums::EntityType,
pub profile_id: Option<id_type::ProfileId>,
pub tenant_id: id_type::TenantId,
}
#[derive(Clone, Debug, AsChangeset, router_derive::DebugAsDisplay)]
#[diesel(table_name = roles)]
pub struct RoleUpdateInternal {
groups: Option<Vec<enums::PermissionGroup>>,
role_name: Option<String>,
last_modified_by: String,
last_modified_at: PrimitiveDateTime,
}
pub enum RoleUpdate {
UpdateDetails {
groups: Option<Vec<enums::PermissionGroup>>,
role_name: Option<String>,
last_modified_at: PrimitiveDateTime,
last_modified_by: String,
},
}
impl From<RoleUpdate> for RoleUpdateInternal {
fn from(value: RoleUpdate) -> Self {
match value {
RoleUpdate::UpdateDetails {
groups,
role_name,
last_modified_by,
last_modified_at,
} => Self {
groups,
role_name,
last_modified_at,
last_modified_by,
},
}
}
}
#[derive(Clone, Debug)]
pub enum ListRolesByEntityPayload {
Profile(id_type::MerchantId, id_type::ProfileId),
Merchant(id_type::MerchantId),
Organization,
}
<file_sep path="hyperswitch/crates/router_derive/src/lib.rs" crate="router_derive" role="macro_def">
<|fim_prefix|>
<|meta_start|><|file|> hyperswitch/crates/router_derive/src/lib.rs<|crate|> diesel_models macro=DebugAsDisplay roles=use_site,macro_def use=derive item=file pack=proc_macro_neighborhoods lang=rust<|meta_end|>
pub fn debug_as_display_derive(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
<|fim_suffix|>
<|fim_middle|>
}
<file_sep path="hyperswitch/crates/router_derive/src/lib.rs" crate="router_derive" role="macro_def">
<|fim_prefix|>
pub fn debug_as_display_derive(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
<|fim_suffix|>
<|fim_middle|>
}
| proc_macro_neighborhoods |
<file_sep path="hyperswitch/crates/diesel_models/src/role.rs" crate="diesel_models" role="use_site">
use common_utils::id_type;
use diesel::{AsChangeset, Identifiable, Insertable, Queryable, Selectable};
use time::PrimitiveDateTime;
use crate::{enums, schema::roles};
#[derive(Clone, Debug, Identifiable, Queryable, Selectable)]
#[diesel(table_name = roles, primary_key(role_id), check_for_backend(diesel::pg::Pg))]
pub struct Role {
pub role_name: String,
pub role_id: String,
pub merchant_id: id_type::MerchantId,
pub org_id: id_type::OrganizationId,
#[diesel(deserialize_as = super::DieselArray<enums::PermissionGroup>)]
pub groups: Vec<enums::PermissionGroup>,
pub scope: enums::RoleScope,
pub created_at: PrimitiveDateTime,
pub created_by: String,
pub last_modified_at: PrimitiveDateTime,
pub last_modified_by: String,
pub entity_type: enums::EntityType,
pub profile_id: Option<id_type::ProfileId>,
pub tenant_id: id_type::TenantId,
}
#[derive(router_derive::Setter, Clone, Debug, Insertable, router_derive::DebugAsDisplay)]
#[diesel(table_name = roles)]
pub struct RoleNew {
pub role_name: String,
pub role_id: String,
pub merchant_id: id_type::MerchantId,
pub org_id: id_type::OrganizationId,
#[diesel(deserialize_as = super::DieselArray<enums::PermissionGroup>)]
pub groups: Vec<enums::PermissionGroup>,
pub scope: enums::RoleScope,
pub created_at: PrimitiveDateTime,
pub created_by: String,
pub last_modified_at: PrimitiveDateTime,
pub last_modified_by: String,
pub entity_type: enums::EntityType,
pub profile_id: Option<id_type::ProfileId>,
pub tenant_id: id_type::TenantId,
}
#[derive(Clone, Debug, AsChangeset, router_derive::DebugAsDisplay)]
#[diesel(table_name = roles)]
pub struct RoleUpdateInternal {
groups: Option<Vec<enums::PermissionGroup>>,
role_name: Option<String>,
last_modified_by: String,
last_modified_at: PrimitiveDateTime,
}
pub enum RoleUpdate {
UpdateDetails {
groups: Option<Vec<enums::PermissionGroup>>,
role_name: Option<String>,
last_modified_at: PrimitiveDateTime,
last_modified_by: String,
},
}
impl From<RoleUpdate> for RoleUpdateInternal {
fn from(value: RoleUpdate) -> Self {
match value {
RoleUpdate::UpdateDetails {
groups,
role_name,
last_modified_by,
last_modified_at,
} => Self {
groups,
role_name,
last_modified_at,
last_modified_by,
},
}
}
}
#[derive(Clone, Debug)]
pub enum ListRolesByEntityPayload {
Profile(id_type::MerchantId, id_type::ProfileId),
Merchant(id_type::MerchantId),
Organization,
}
<file_sep path="hyperswitch/crates/diesel_models/src/role.rs" crate="diesel_models" role="use_site">
use common_utils::id_type;
use diesel::{AsChangeset, Identifiable, Insertable, Queryable, Selectable};
use time::PrimitiveDateTime;
use crate::{enums, schema::roles};
#[derive(Clone, Debug, Identifiable, Queryable, Selectable)]
#[diesel(table_name = roles, primary_key(role_id), check_for_backend(diesel::pg::Pg))]
pub struct Role {
pub role_name: String,
pub role_id: String,
pub merchant_id: id_type::MerchantId,
pub org_id: id_type::OrganizationId,
#[diesel(deserialize_as = super::DieselArray<enums::PermissionGroup>)]
pub groups: Vec<enums::PermissionGroup>,
pub scope: enums::RoleScope,
pub created_at: PrimitiveDateTime,
pub created_by: String,
pub last_modified_at: PrimitiveDateTime,
pub last_modified_by: String,
pub entity_type: enums::EntityType,
pub profile_id: Option<id_type::ProfileId>,
pub tenant_id: id_type::TenantId,
}
#[derive(router_derive::Setter, Clone, Debug, Insertable, router_derive::DebugAsDisplay)]
#[diesel(table_name = roles)]
pub struct RoleNew {
pub role_name: String,
pub role_id: String,
pub merchant_id: id_type::MerchantId,
pub org_id: id_type::OrganizationId,
#[diesel(deserialize_as = super::DieselArray<enums::PermissionGroup>)]
pub groups: Vec<enums::PermissionGroup>,
pub scope: enums::RoleScope,
pub created_at: PrimitiveDateTime,
pub created_by: String,
pub last_modified_at: PrimitiveDateTime,
pub last_modified_by: String,
pub entity_type: enums::EntityType,
pub profile_id: Option<id_type::ProfileId>,
pub tenant_id: id_type::TenantId,
}
#[derive(Clone, Debug, AsChangeset, router_derive::DebugAsDisplay)]
#[diesel(table_name = roles)]
pub struct RoleUpdateInternal {
groups: Option<Vec<enums::PermissionGroup>>,
role_name: Option<String>,
last_modified_by: String,
last_modified_at: PrimitiveDateTime,
}
pub enum RoleUpdate {
UpdateDetails {
groups: Option<Vec<enums::PermissionGroup>>,
role_name: Option<String>,
last_modified_at: PrimitiveDateTime,
last_modified_by: String,
},
}
impl From<RoleUpdate> for RoleUpdateInternal {
fn from(value: RoleUpdate) -> Self {
match value {
RoleUpdate::UpdateDetails {
groups,
role_name,
last_modified_by,
last_modified_at,
} => Self {
groups,
role_name,
last_modified_at,
last_modified_by,
},
}
}
}
#[derive(Clone, Debug)]
pub enum ListRolesByEntityPayload {
Profile(id_type::MerchantId, id_type::ProfileId),
Merchant(id_type::MerchantId),
Organization,
}
<file_sep path="hyperswitch/crates/router_derive/src/lib.rs" crate="router_derive" role="macro_def">
<|fim_prefix|>
<|meta_start|><|file|> hyperswitch/crates/router_derive/src/lib.rs<|crate|> diesel_models macro=DebugAsDisplay roles=use_site,macro_def use=derive item=file pack=proc_macro_neighborhoods lang=rust<|meta_end|>
pub fn debug_as_display_derive(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
<|fim_suffix|>
<|fim_middle|>
}
<file_sep path="hyperswitch/crates/router_derive/src/lib.rs" crate="router_derive" role="macro_def">
<|fim_prefix|>
pub fn debug_as_display_derive(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
<|fim_suffix|>
<|fim_middle|>
}
| proc_macro_neighborhoods |
<file_sep path="hyperswitch/crates/euclid/src/enums.rs" crate="euclid" role="macro_def">
macro_rules! collect_variants {
($the_enum:ident) => {
impl $crate::enums::CollectVariants for $the_enum {
fn variants<T>() -> T
where
T: FromIterator<String>,
{
Self::VARIANTS.iter().map(|s| String::from(*s)).collect()
}
}
};
}
<file_sep path="hyperswitch/crates/euclid/src/enums.rs" crate="euclid" role="macro_def">
macro_rules! collect_variants {
($the_enum:ident) => {
impl $crate::enums::CollectVariants for $the_enum {
fn variants<T>() -> T
where
T: FromIterator<String>,
{
Self::VARIANTS.iter().map(|s| String::from(*s)).collect()
}
}
};
}
<file_sep path="hyperswitch/crates/euclid/src/enums.rs" crate="euclid" role="use_site">
<|fim_prefix|>
<|meta_start|><|file|> hyperswitch/crates/euclid/src/enums.rs<|crate|> euclid macro=collect_variants roles=macro_def,use_site use=invoke item=file pack=proc_macro_neighborhoods lang=rust<|meta_end|>
pub enum MandateAcceptanceType {
<|fim_suffix|>
<|fim_middle|>
}
<file_sep path="hyperswitch/crates/euclid/src/enums.rs" crate="euclid" role="use_site">
<|fim_prefix|>
pub enum MandateAcceptanceType {
<|fim_suffix|>
<|fim_middle|>
}
| proc_macro_neighborhoods |
<file_sep path="hyperswitch/crates/euclid/src/enums.rs" crate="euclid" role="use_site">
collect_variants!(Country);
<file_sep path="hyperswitch/crates/euclid/src/enums.rs" crate="euclid" role="use_site">
collect_variants!(Country);
<file_sep path="hyperswitch/crates/euclid/src/enums.rs" crate="euclid" role="macro_def">
<|fim_prefix|>
<|meta_start|><|file|> hyperswitch/crates/euclid/src/enums.rs<|crate|> euclid macro=collect_variants roles=use_site,macro_def use=invoke item=file pack=proc_macro_neighborhoods lang=rust<|meta_end|>
pub use common_enums::{
<|fim_suffix|>
<|fim_middle|>
}
<file_sep path="hyperswitch/crates/euclid/src/enums.rs" crate="euclid" role="macro_def">
<|fim_prefix|>
pub use common_enums::{
<|fim_suffix|>
<|fim_middle|>
}
| proc_macro_neighborhoods |
<file_sep path="hyperswitch/crates/euclid/src/enums.rs" crate="euclid" role="use_site">
collect_variants!(Currency);
<file_sep path="hyperswitch/crates/euclid/src/enums.rs" crate="euclid" role="use_site">
collect_variants!(Currency);
<file_sep path="hyperswitch/crates/euclid/src/enums.rs" crate="euclid" role="macro_def">
<|fim_prefix|>
<|meta_start|><|file|> hyperswitch/crates/euclid/src/enums.rs<|crate|> euclid macro=collect_variants roles=use_site,macro_def use=invoke item=file pack=proc_macro_neighborhoods lang=rust<|meta_end|>
pub use common_enums::{
<|fim_suffix|>
<|fim_middle|>
}
<file_sep path="hyperswitch/crates/euclid/src/enums.rs" crate="euclid" role="macro_def">
<|fim_prefix|>
pub use common_enums::{
<|fim_suffix|>
<|fim_middle|>
}
| proc_macro_neighborhoods |
<file_sep path="hyperswitch/crates/euclid/src/enums.rs" crate="euclid" role="macro_def">
macro_rules! collect_variants {
($the_enum:ident) => {
impl $crate::enums::CollectVariants for $the_enum {
fn variants<T>() -> T
where
T: FromIterator<String>,
{
Self::VARIANTS.iter().map(|s| String::from(*s)).collect()
}
}
};
}
<file_sep path="hyperswitch/crates/euclid/src/enums.rs" crate="euclid" role="macro_def">
macro_rules! collect_variants {
($the_enum:ident) => {
impl $crate::enums::CollectVariants for $the_enum {
fn variants<T>() -> T
where
T: FromIterator<String>,
{
Self::VARIANTS.iter().map(|s| String::from(*s)).collect()
}
}
};
}
<file_sep path="hyperswitch/crates/euclid/src/enums.rs" crate="euclid" role="use_site">
<|fim_prefix|>
<|meta_start|><|file|> hyperswitch/crates/euclid/src/enums.rs<|crate|> euclid macro=collect_variants roles=macro_def,use_site use=invoke item=file pack=proc_macro_neighborhoods lang=rust<|meta_end|>
pub enum MandateAcceptanceType {
<|fim_suffix|>
<|fim_middle|>
}
<file_sep path="hyperswitch/crates/euclid/src/enums.rs" crate="euclid" role="use_site">
<|fim_prefix|>
pub enum MandateAcceptanceType {
<|fim_suffix|>
<|fim_middle|>
}
| proc_macro_neighborhoods |
<file_sep path="hyperswitch/crates/euclid/src/enums.rs" crate="euclid" role="use_site">
collect_variants!(SetupFutureUsage);
<file_sep path="hyperswitch/crates/euclid/src/enums.rs" crate="euclid" role="use_site">
collect_variants!(SetupFutureUsage);
<file_sep path="hyperswitch/crates/euclid/src/enums.rs" crate="euclid" role="macro_def">
<|fim_prefix|>
<|meta_start|><|file|> hyperswitch/crates/euclid/src/enums.rs<|crate|> euclid macro=collect_variants roles=use_site,macro_def use=invoke item=file pack=proc_macro_neighborhoods lang=rust<|meta_end|>
pub use common_enums::{
<|fim_suffix|>
<|fim_middle|>
}
<file_sep path="hyperswitch/crates/euclid/src/enums.rs" crate="euclid" role="macro_def">
<|fim_prefix|>
pub use common_enums::{
<|fim_suffix|>
<|fim_middle|>
}
| proc_macro_neighborhoods |
<file_sep path="hyperswitch/crates/euclid/src/enums.rs" crate="euclid" role="macro_def">
macro_rules! collect_variants {
($the_enum:ident) => {
impl $crate::enums::CollectVariants for $the_enum {
fn variants<T>() -> T
where
T: FromIterator<String>,
{
Self::VARIANTS.iter().map(|s| String::from(*s)).collect()
}
}
};
}
<file_sep path="hyperswitch/crates/euclid/src/enums.rs" crate="euclid" role="macro_def">
macro_rules! collect_variants {
($the_enum:ident) => {
impl $crate::enums::CollectVariants for $the_enum {
fn variants<T>() -> T
where
T: FromIterator<String>,
{
Self::VARIANTS.iter().map(|s| String::from(*s)).collect()
}
}
};
}
<file_sep path="hyperswitch/crates/euclid/src/enums.rs" crate="euclid" role="use_site">
<|fim_prefix|>
<|meta_start|><|file|> hyperswitch/crates/euclid/src/enums.rs<|crate|> euclid macro=collect_variants roles=macro_def,use_site use=invoke item=file pack=proc_macro_neighborhoods lang=rust<|meta_end|>
pub enum MandateAcceptanceType {
<|fim_suffix|>
<|fim_middle|>
}
<file_sep path="hyperswitch/crates/euclid/src/enums.rs" crate="euclid" role="use_site">
<|fim_prefix|>
pub enum MandateAcceptanceType {
<|fim_suffix|>
<|fim_middle|>
}
| proc_macro_neighborhoods |
<file_sep path="hyperswitch/crates/euclid/src/enums.rs" crate="euclid" role="use_site">
collect_variants!(CaptureMethod);
<file_sep path="hyperswitch/crates/euclid/src/enums.rs" crate="euclid" role="use_site">
collect_variants!(CaptureMethod);
<file_sep path="hyperswitch/crates/euclid/src/enums.rs" crate="euclid" role="macro_def">
<|fim_prefix|>
<|meta_start|><|file|> hyperswitch/crates/euclid/src/enums.rs<|crate|> euclid macro=collect_variants roles=use_site,macro_def use=invoke item=file pack=proc_macro_neighborhoods lang=rust<|meta_end|>
pub use common_enums::{
<|fim_suffix|>
<|fim_middle|>
}
<file_sep path="hyperswitch/crates/euclid/src/enums.rs" crate="euclid" role="macro_def">
<|fim_prefix|>
pub use common_enums::{
<|fim_suffix|>
<|fim_middle|>
}
| proc_macro_neighborhoods |
<file_sep path="hyperswitch/crates/euclid/src/types.rs" crate="euclid" role="use_site">
enums::collect_variants!(EuclidKey);
<file_sep path="hyperswitch/crates/euclid/src/types.rs" crate="euclid" role="use_site">
enums::collect_variants!(EuclidKey);
<file_sep path="hyperswitch/crates/euclid/src/enums.rs" crate="euclid" role="macro_def">
<|fim_prefix|>
<|meta_start|><|file|> hyperswitch/crates/euclid/src/enums.rs<|crate|> euclid macro=collect_variants roles=use_site,macro_def use=invoke item=file pack=proc_macro_neighborhoods lang=rust<|meta_end|>
pub use common_enums::{
<|fim_suffix|>
<|fim_middle|>
}
<file_sep path="hyperswitch/crates/euclid/src/enums.rs" crate="euclid" role="macro_def">
<|fim_prefix|>
pub use common_enums::{
<|fim_suffix|>
<|fim_middle|>
}
| proc_macro_neighborhoods |
<file_sep path="hyperswitch/crates/euclid/src/enums.rs" crate="euclid" role="macro_def">
macro_rules! collect_variants {
($the_enum:ident) => {
impl $crate::enums::CollectVariants for $the_enum {
fn variants<T>() -> T
where
T: FromIterator<String>,
{
Self::VARIANTS.iter().map(|s| String::from(*s)).collect()
}
}
};
}
<file_sep path="hyperswitch/crates/euclid/src/enums.rs" crate="euclid" role="macro_def">
macro_rules! collect_variants {
($the_enum:ident) => {
impl $crate::enums::CollectVariants for $the_enum {
fn variants<T>() -> T
where
T: FromIterator<String>,
{
Self::VARIANTS.iter().map(|s| String::from(*s)).collect()
}
}
};
}
<file_sep path="hyperswitch/crates/euclid/src/enums.rs" crate="euclid" role="use_site">
<|fim_prefix|>
<|meta_start|><|file|> hyperswitch/crates/euclid/src/enums.rs<|crate|> euclid macro=collect_variants roles=macro_def,use_site use=invoke item=file pack=proc_macro_neighborhoods lang=rust<|meta_end|>
pub enum MandateAcceptanceType {
<|fim_suffix|>
<|fim_middle|>
}
<file_sep path="hyperswitch/crates/euclid/src/enums.rs" crate="euclid" role="use_site">
<|fim_prefix|>
pub enum MandateAcceptanceType {
<|fim_suffix|>
<|fim_middle|>
}
| proc_macro_neighborhoods |
<file_sep path="hyperswitch/crates/euclid/src/enums.rs" crate="euclid" role="use_site">
collect_variants!(PayoutBankTransferType);
<file_sep path="hyperswitch/crates/euclid/src/enums.rs" crate="euclid" role="use_site">
collect_variants!(PayoutBankTransferType);
<file_sep path="hyperswitch/crates/euclid/src/enums.rs" crate="euclid" role="macro_def">
<|fim_prefix|>
<|meta_start|><|file|> hyperswitch/crates/euclid/src/enums.rs<|crate|> euclid macro=collect_variants roles=use_site,macro_def use=invoke item=file pack=proc_macro_neighborhoods lang=rust<|meta_end|>
pub use common_enums::{
<|fim_suffix|>
<|fim_middle|>
}
<file_sep path="hyperswitch/crates/euclid/src/enums.rs" crate="euclid" role="macro_def">
<|fim_prefix|>
pub use common_enums::{
<|fim_suffix|>
<|fim_middle|>
}
| proc_macro_neighborhoods |
<file_sep path="hyperswitch/crates/euclid/src/enums.rs" crate="euclid" role="macro_def">
macro_rules! collect_variants {
($the_enum:ident) => {
impl $crate::enums::CollectVariants for $the_enum {
fn variants<T>() -> T
where
T: FromIterator<String>,
{
Self::VARIANTS.iter().map(|s| String::from(*s)).collect()
}
}
};
}
<file_sep path="hyperswitch/crates/euclid/src/enums.rs" crate="euclid" role="macro_def">
macro_rules! collect_variants {
($the_enum:ident) => {
impl $crate::enums::CollectVariants for $the_enum {
fn variants<T>() -> T
where
T: FromIterator<String>,
{
Self::VARIANTS.iter().map(|s| String::from(*s)).collect()
}
}
};
}
<file_sep path="hyperswitch/crates/euclid/src/enums.rs" crate="euclid" role="use_site">
<|fim_prefix|>
<|meta_start|><|file|> hyperswitch/crates/euclid/src/enums.rs<|crate|> euclid macro=collect_variants roles=macro_def,use_site use=invoke item=file pack=proc_macro_neighborhoods lang=rust<|meta_end|>
pub enum MandateAcceptanceType {
<|fim_suffix|>
<|fim_middle|>
}
<file_sep path="hyperswitch/crates/euclid/src/enums.rs" crate="euclid" role="use_site">
<|fim_prefix|>
pub enum MandateAcceptanceType {
<|fim_suffix|>
<|fim_middle|>
}
| proc_macro_neighborhoods |
<file_sep path="hyperswitch/crates/euclid/src/enums.rs" crate="euclid" role="macro_def">
macro_rules! collect_variants {
($the_enum:ident) => {
impl $crate::enums::CollectVariants for $the_enum {
fn variants<T>() -> T
where
T: FromIterator<String>,
{
Self::VARIANTS.iter().map(|s| String::from(*s)).collect()
}
}
};
}
<file_sep path="hyperswitch/crates/euclid/src/enums.rs" crate="euclid" role="macro_def">
macro_rules! collect_variants {
($the_enum:ident) => {
impl $crate::enums::CollectVariants for $the_enum {
fn variants<T>() -> T
where
T: FromIterator<String>,
{
Self::VARIANTS.iter().map(|s| String::from(*s)).collect()
}
}
};
}
<file_sep path="hyperswitch/crates/euclid/src/types.rs" crate="euclid" role="use_site">
<|fim_prefix|>
<|meta_start|><|file|> hyperswitch/crates/euclid/src/enums.rs<|crate|> euclid macro=collect_variants roles=macro_def,use_site use=invoke item=file pack=proc_macro_neighborhoods lang=rust<|meta_end|>
pub enum EuclidKey {
<|fim_suffix|>
<|fim_middle|>
}
<file_sep path="hyperswitch/crates/euclid/src/types.rs" crate="euclid" role="use_site">
<|fim_prefix|>
pub enum EuclidKey {
<|fim_suffix|>
<|fim_middle|>
}
| proc_macro_neighborhoods |
<file_sep path="hyperswitch/crates/euclid/src/enums.rs" crate="euclid" role="macro_def">
macro_rules! collect_variants {
($the_enum:ident) => {
impl $crate::enums::CollectVariants for $the_enum {
fn variants<T>() -> T
where
T: FromIterator<String>,
{
Self::VARIANTS.iter().map(|s| String::from(*s)).collect()
}
}
};
}
<file_sep path="hyperswitch/crates/euclid/src/enums.rs" crate="euclid" role="macro_def">
macro_rules! collect_variants {
($the_enum:ident) => {
impl $crate::enums::CollectVariants for $the_enum {
fn variants<T>() -> T
where
T: FromIterator<String>,
{
Self::VARIANTS.iter().map(|s| String::from(*s)).collect()
}
}
};
}
<file_sep path="hyperswitch/crates/euclid/src/enums.rs" crate="euclid" role="use_site">
<|fim_prefix|>
<|meta_start|><|file|> hyperswitch/crates/euclid/src/enums.rs<|crate|> euclid macro=collect_variants roles=macro_def,use_site use=invoke item=file pack=proc_macro_neighborhoods lang=rust<|meta_end|>
pub enum MandateAcceptanceType {
<|fim_suffix|>
<|fim_middle|>
}
<file_sep path="hyperswitch/crates/euclid/src/enums.rs" crate="euclid" role="use_site">
<|fim_prefix|>
pub enum MandateAcceptanceType {
<|fim_suffix|>
<|fim_middle|>
}
| proc_macro_neighborhoods |
<file_sep path="hyperswitch/crates/euclid/src/enums.rs" crate="euclid" role="use_site">
collect_variants!(PayoutType);
<file_sep path="hyperswitch/crates/euclid/src/enums.rs" crate="euclid" role="use_site">
collect_variants!(PayoutType);
<file_sep path="hyperswitch/crates/euclid/src/enums.rs" crate="euclid" role="macro_def">
<|fim_prefix|>
<|meta_start|><|file|> hyperswitch/crates/euclid/src/enums.rs<|crate|> euclid macro=collect_variants roles=use_site,macro_def use=invoke item=file pack=proc_macro_neighborhoods lang=rust<|meta_end|>
pub use common_enums::{
<|fim_suffix|>
<|fim_middle|>
}
<file_sep path="hyperswitch/crates/euclid/src/enums.rs" crate="euclid" role="macro_def">
<|fim_prefix|>
pub use common_enums::{
<|fim_suffix|>
<|fim_middle|>
}
| proc_macro_neighborhoods |
<file_sep path="hyperswitch/crates/euclid/src/frontend/dir.rs" crate="euclid" role="macro_def">
macro_rules! dirval {
(Connector = $name:ident) => {
$crate::frontend::dir::DirValue::Connector(Box::new(
$crate::frontend::ast::ConnectorChoice {
connector: $crate::enums::RoutableConnectors::$name,
},
))
};
($key:ident = $val:ident) => {{
pub use $crate::frontend::dir::enums::*;
$crate::frontend::dir::DirValue::$key($key::$val)
}};
($key:ident = $num:literal) => {{
$crate::frontend::dir::DirValue::$key($crate::types::NumValue {
number: common_utils::types::MinorUnit::new($num),
refinement: None,
})
}};
($key:ident s= $str:literal) => {{
$crate::frontend::dir::DirValue::$key($crate::types::StrValue {
value: $str.to_string(),
})
}};
($key:literal = $str:literal) => {{
$crate::frontend::dir::DirValue::MetaData($crate::types::MetadataValue {
key: $key.to_string(),
value: $str.to_string(),
})
}};
}
<file_sep path="hyperswitch/crates/euclid/src/frontend/dir.rs" crate="euclid" role="macro_def">
macro_rules! dirval {
(Connector = $name:ident) => {
$crate::frontend::dir::DirValue::Connector(Box::new(
$crate::frontend::ast::ConnectorChoice {
connector: $crate::enums::RoutableConnectors::$name,
},
))
};
($key:ident = $val:ident) => {{
pub use $crate::frontend::dir::enums::*;
$crate::frontend::dir::DirValue::$key($key::$val)
}};
($key:ident = $num:literal) => {{
$crate::frontend::dir::DirValue::$key($crate::types::NumValue {
number: common_utils::types::MinorUnit::new($num),
refinement: None,
})
}};
($key:ident s= $str:literal) => {{
$crate::frontend::dir::DirValue::$key($crate::types::StrValue {
value: $str.to_string(),
})
}};
($key:literal = $str:literal) => {{
$crate::frontend::dir::DirValue::MetaData($crate::types::MetadataValue {
key: $key.to_string(),
value: $str.to_string(),
})
}};
}
<file_sep path="hyperswitch/crates/euclid/src/frontend/dir/transformers.rs" crate="euclid" role="use_site">
<|fim_prefix|>
<|meta_start|><|file|> hyperswitch/crates/euclid/src/frontend/dir.rs<|crate|> euclid macro=dirval roles=macro_def,use_site use=invoke item=fn pack=proc_macro_neighborhoods lang=rust<|meta_end|>
fn into_dir_value(self) -> Result<dir::DirValue, AnalysisErrorType> {
<|fim_suffix|>
<|fim_middle|>
}
<file_sep path="hyperswitch/crates/euclid/src/frontend/dir/transformers.rs" crate="euclid" role="use_site">
<|fim_prefix|>
fn into_dir_value(self) -> Result<dir::DirValue, AnalysisErrorType> {
<|fim_suffix|>
<|fim_middle|>
}
| proc_macro_neighborhoods |
<file_sep path="hyperswitch/crates/euclid/src/frontend/dir/transformers.rs" crate="euclid" role="use_site">
global_enums::PaymentMethodType::Venmo => Ok(dirval!(WalletType = Venmo)),
<file_sep path="hyperswitch/crates/euclid/src/frontend/dir/transformers.rs" crate="euclid" role="use_site">
global_enums::PaymentMethodType::Venmo => Ok(dirval!(WalletType = Venmo)),
<file_sep path="hyperswitch/crates/euclid/src/frontend/dir.rs" crate="euclid" role="macro_def">
<|fim_prefix|>
<|meta_start|><|file|> hyperswitch/crates/euclid/src/frontend/dir.rs<|crate|> euclid macro=dirval roles=use_site,macro_def use=invoke item=fn pack=proc_macro_neighborhoods lang=rust<|meta_end|>
//! Domain Intermediate Representation
pub mod enums;
pub mod lowering;
pub mod transformers;
use strum::IntoEnumIterator;
// use common_utils::types::MinorUnit;
use crate::{
<|fim_suffix|>
<|fim_middle|>
}
<file_sep path="hyperswitch/crates/euclid/src/frontend/dir.rs" crate="euclid" role="macro_def">
<|fim_prefix|>
//! Domain Intermediate Representation
pub mod enums;
pub mod lowering;
pub mod transformers;
use strum::IntoEnumIterator;
// use common_utils::types::MinorUnit;
use crate::{
<|fim_suffix|>
<|fim_middle|>
}
| proc_macro_neighborhoods |
<file_sep path="hyperswitch/crates/euclid/src/frontend/dir.rs" crate="euclid" role="macro_def">
macro_rules! dirval {
(Connector = $name:ident) => {
$crate::frontend::dir::DirValue::Connector(Box::new(
$crate::frontend::ast::ConnectorChoice {
connector: $crate::enums::RoutableConnectors::$name,
},
))
};
($key:ident = $val:ident) => {{
pub use $crate::frontend::dir::enums::*;
$crate::frontend::dir::DirValue::$key($key::$val)
}};
($key:ident = $num:literal) => {{
$crate::frontend::dir::DirValue::$key($crate::types::NumValue {
number: common_utils::types::MinorUnit::new($num),
refinement: None,
})
}};
($key:ident s= $str:literal) => {{
$crate::frontend::dir::DirValue::$key($crate::types::StrValue {
value: $str.to_string(),
})
}};
($key:literal = $str:literal) => {{
$crate::frontend::dir::DirValue::MetaData($crate::types::MetadataValue {
key: $key.to_string(),
value: $str.to_string(),
})
}};
}
<file_sep path="hyperswitch/crates/euclid/src/frontend/dir.rs" crate="euclid" role="macro_def">
macro_rules! dirval {
(Connector = $name:ident) => {
$crate::frontend::dir::DirValue::Connector(Box::new(
$crate::frontend::ast::ConnectorChoice {
connector: $crate::enums::RoutableConnectors::$name,
},
))
};
($key:ident = $val:ident) => {{
pub use $crate::frontend::dir::enums::*;
$crate::frontend::dir::DirValue::$key($key::$val)
}};
($key:ident = $num:literal) => {{
$crate::frontend::dir::DirValue::$key($crate::types::NumValue {
number: common_utils::types::MinorUnit::new($num),
refinement: None,
})
}};
($key:ident s= $str:literal) => {{
$crate::frontend::dir::DirValue::$key($crate::types::StrValue {
value: $str.to_string(),
})
}};
($key:literal = $str:literal) => {{
$crate::frontend::dir::DirValue::MetaData($crate::types::MetadataValue {
key: $key.to_string(),
value: $str.to_string(),
})
}};
}
<file_sep path="hyperswitch/crates/euclid/src/frontend/dir/transformers.rs" crate="euclid" role="use_site">
<|fim_prefix|>
<|meta_start|><|file|> hyperswitch/crates/euclid/src/frontend/dir.rs<|crate|> euclid macro=dirval roles=macro_def,use_site use=invoke item=fn pack=proc_macro_neighborhoods lang=rust<|meta_end|>
fn into_dir_value(self) -> Result<dir::DirValue, AnalysisErrorType> {
<|fim_suffix|>
<|fim_middle|>
}
<file_sep path="hyperswitch/crates/euclid/src/frontend/dir/transformers.rs" crate="euclid" role="use_site">
<|fim_prefix|>
fn into_dir_value(self) -> Result<dir::DirValue, AnalysisErrorType> {
<|fim_suffix|>
<|fim_middle|>
}
| proc_macro_neighborhoods |
<file_sep path="hyperswitch/crates/euclid/src/frontend/dir.rs" crate="euclid" role="macro_def">
macro_rules! dirval {
(Connector = $name:ident) => {
$crate::frontend::dir::DirValue::Connector(Box::new(
$crate::frontend::ast::ConnectorChoice {
connector: $crate::enums::RoutableConnectors::$name,
},
))
};
($key:ident = $val:ident) => {{
pub use $crate::frontend::dir::enums::*;
$crate::frontend::dir::DirValue::$key($key::$val)
}};
($key:ident = $num:literal) => {{
$crate::frontend::dir::DirValue::$key($crate::types::NumValue {
number: common_utils::types::MinorUnit::new($num),
refinement: None,
})
}};
($key:ident s= $str:literal) => {{
$crate::frontend::dir::DirValue::$key($crate::types::StrValue {
value: $str.to_string(),
})
}};
($key:literal = $str:literal) => {{
$crate::frontend::dir::DirValue::MetaData($crate::types::MetadataValue {
key: $key.to_string(),
value: $str.to_string(),
})
}};
}
<file_sep path="hyperswitch/crates/euclid/src/frontend/dir.rs" crate="euclid" role="macro_def">
macro_rules! dirval {
(Connector = $name:ident) => {
$crate::frontend::dir::DirValue::Connector(Box::new(
$crate::frontend::ast::ConnectorChoice {
connector: $crate::enums::RoutableConnectors::$name,
},
))
};
($key:ident = $val:ident) => {{
pub use $crate::frontend::dir::enums::*;
$crate::frontend::dir::DirValue::$key($key::$val)
}};
($key:ident = $num:literal) => {{
$crate::frontend::dir::DirValue::$key($crate::types::NumValue {
number: common_utils::types::MinorUnit::new($num),
refinement: None,
})
}};
($key:ident s= $str:literal) => {{
$crate::frontend::dir::DirValue::$key($crate::types::StrValue {
value: $str.to_string(),
})
}};
($key:literal = $str:literal) => {{
$crate::frontend::dir::DirValue::MetaData($crate::types::MetadataValue {
key: $key.to_string(),
value: $str.to_string(),
})
}};
}
<file_sep path="hyperswitch/crates/euclid/src/frontend/dir/transformers.rs" crate="euclid" role="use_site">
<|fim_prefix|>
<|meta_start|><|file|> hyperswitch/crates/euclid/src/frontend/dir.rs<|crate|> euclid macro=dirval roles=macro_def,use_site use=invoke item=fn pack=proc_macro_neighborhoods lang=rust<|meta_end|>
fn into_dir_value(self) -> Result<dir::DirValue, AnalysisErrorType> {
<|fim_suffix|>
<|fim_middle|>
}
<file_sep path="hyperswitch/crates/euclid/src/frontend/dir/transformers.rs" crate="euclid" role="use_site">
<|fim_prefix|>
fn into_dir_value(self) -> Result<dir::DirValue, AnalysisErrorType> {
<|fim_suffix|>
<|fim_middle|>
}
| proc_macro_neighborhoods |
<file_sep path="hyperswitch/crates/euclid/src/frontend/dir/transformers.rs" crate="euclid" role="use_site">
global_enums::PaymentMethodType::Oxxo => Ok(dirval!(VoucherType = Oxxo)),
<file_sep path="hyperswitch/crates/euclid/src/frontend/dir/transformers.rs" crate="euclid" role="use_site">
global_enums::PaymentMethodType::Oxxo => Ok(dirval!(VoucherType = Oxxo)),
<file_sep path="hyperswitch/crates/euclid/src/frontend/dir.rs" crate="euclid" role="macro_def">
<|fim_prefix|>
<|meta_start|><|file|> hyperswitch/crates/euclid/src/frontend/dir.rs<|crate|> euclid macro=dirval roles=use_site,macro_def use=invoke item=fn pack=proc_macro_neighborhoods lang=rust<|meta_end|>
//! Domain Intermediate Representation
pub mod enums;
pub mod lowering;
pub mod transformers;
use strum::IntoEnumIterator;
// use common_utils::types::MinorUnit;
use crate::{
<|fim_suffix|>
<|fim_middle|>
}
<file_sep path="hyperswitch/crates/euclid/src/frontend/dir.rs" crate="euclid" role="macro_def">
<|fim_prefix|>
//! Domain Intermediate Representation
pub mod enums;
pub mod lowering;
pub mod transformers;
use strum::IntoEnumIterator;
// use common_utils::types::MinorUnit;
use crate::{
<|fim_suffix|>
<|fim_middle|>
}
| proc_macro_neighborhoods |
<file_sep path="hyperswitch/crates/euclid/src/frontend/dir/transformers.rs" crate="euclid" role="use_site">
Ok(dirval!(CardRedirectType = CardRedirect))
<file_sep path="hyperswitch/crates/euclid/src/frontend/dir/transformers.rs" crate="euclid" role="use_site">
Ok(dirval!(CardRedirectType = CardRedirect))
<file_sep path="hyperswitch/crates/euclid/src/frontend/dir.rs" crate="euclid" role="macro_def">
<|fim_prefix|>
<|meta_start|><|file|> hyperswitch/crates/euclid/src/frontend/dir.rs<|crate|> euclid macro=dirval roles=use_site,macro_def use=invoke item=fn pack=proc_macro_neighborhoods lang=rust<|meta_end|>
//! Domain Intermediate Representation
pub mod enums;
pub mod lowering;
pub mod transformers;
use strum::IntoEnumIterator;
// use common_utils::types::MinorUnit;
use crate::{
<|fim_suffix|>
<|fim_middle|>
}
<file_sep path="hyperswitch/crates/euclid/src/frontend/dir.rs" crate="euclid" role="macro_def">
<|fim_prefix|>
//! Domain Intermediate Representation
pub mod enums;
pub mod lowering;
pub mod transformers;
use strum::IntoEnumIterator;
// use common_utils::types::MinorUnit;
use crate::{
<|fim_suffix|>
<|fim_middle|>
}
| proc_macro_neighborhoods |
<file_sep path="hyperswitch/crates/euclid/src/frontend/dir/transformers.rs" crate="euclid" role="use_site">
Ok(dirval!(OpenBankingType = OpenBankingPIS))
<file_sep path="hyperswitch/crates/euclid/src/frontend/dir/transformers.rs" crate="euclid" role="use_site">
Ok(dirval!(OpenBankingType = OpenBankingPIS))
<file_sep path="hyperswitch/crates/euclid/src/frontend/dir.rs" crate="euclid" role="macro_def">
<|fim_prefix|>
<|meta_start|><|file|> hyperswitch/crates/euclid/src/frontend/dir.rs<|crate|> euclid macro=dirval roles=use_site,macro_def use=invoke item=fn pack=proc_macro_neighborhoods lang=rust<|meta_end|>
//! Domain Intermediate Representation
pub mod enums;
pub mod lowering;
pub mod transformers;
use strum::IntoEnumIterator;
// use common_utils::types::MinorUnit;
use crate::{
<|fim_suffix|>
<|fim_middle|>
}
<file_sep path="hyperswitch/crates/euclid/src/frontend/dir.rs" crate="euclid" role="macro_def">
<|fim_prefix|>
//! Domain Intermediate Representation
pub mod enums;
pub mod lowering;
pub mod transformers;
use strum::IntoEnumIterator;
// use common_utils::types::MinorUnit;
use crate::{
<|fim_suffix|>
<|fim_middle|>
}
| proc_macro_neighborhoods |
<file_sep path="hyperswitch/crates/euclid/src/frontend/dir/transformers.rs" crate="euclid" role="use_site">
Ok(dirval!(MobilePaymentType = DirectCarrierBilling))
<file_sep path="hyperswitch/crates/euclid/src/frontend/dir/transformers.rs" crate="euclid" role="use_site">
Ok(dirval!(MobilePaymentType = DirectCarrierBilling))
<file_sep path="hyperswitch/crates/euclid/src/frontend/dir.rs" crate="euclid" role="macro_def">
<|fim_prefix|>
<|meta_start|><|file|> hyperswitch/crates/euclid/src/frontend/dir.rs<|crate|> euclid macro=dirval roles=use_site,macro_def use=invoke item=fn pack=proc_macro_neighborhoods lang=rust<|meta_end|>
//! Domain Intermediate Representation
pub mod enums;
pub mod lowering;
pub mod transformers;
use strum::IntoEnumIterator;
// use common_utils::types::MinorUnit;
use crate::{
<|fim_suffix|>
<|fim_middle|>
}
<file_sep path="hyperswitch/crates/euclid/src/frontend/dir.rs" crate="euclid" role="macro_def">
<|fim_prefix|>
//! Domain Intermediate Representation
pub mod enums;
pub mod lowering;
pub mod transformers;
use strum::IntoEnumIterator;
// use common_utils::types::MinorUnit;
use crate::{
<|fim_suffix|>
<|fim_middle|>
}
| proc_macro_neighborhoods |
<file_sep path="hyperswitch/crates/euclid/src/frontend/dir/transformers.rs" crate="euclid" role="use_site">
global_enums::PaymentMethodType::Mifinity => Ok(dirval!(WalletType = Mifinity)),
<file_sep path="hyperswitch/crates/euclid/src/frontend/dir/transformers.rs" crate="euclid" role="use_site">
global_enums::PaymentMethodType::Mifinity => Ok(dirval!(WalletType = Mifinity)),
<file_sep path="hyperswitch/crates/euclid/src/frontend/dir.rs" crate="euclid" role="macro_def">
<|fim_prefix|>
<|meta_start|><|file|> hyperswitch/crates/euclid/src/frontend/dir.rs<|crate|> euclid macro=dirval roles=use_site,macro_def use=invoke item=fn pack=proc_macro_neighborhoods lang=rust<|meta_end|>
//! Domain Intermediate Representation
pub mod enums;
pub mod lowering;
pub mod transformers;
use strum::IntoEnumIterator;
// use common_utils::types::MinorUnit;
use crate::{
<|fim_suffix|>
<|fim_middle|>
}
<file_sep path="hyperswitch/crates/euclid/src/frontend/dir.rs" crate="euclid" role="macro_def">
<|fim_prefix|>
//! Domain Intermediate Representation
pub mod enums;
pub mod lowering;
pub mod transformers;
use strum::IntoEnumIterator;
// use common_utils::types::MinorUnit;
use crate::{
<|fim_suffix|>
<|fim_middle|>
}
| proc_macro_neighborhoods |
<file_sep path="hyperswitch/crates/euclid/src/frontend/dir.rs" crate="euclid" role="macro_def">
macro_rules! dirval {
(Connector = $name:ident) => {
$crate::frontend::dir::DirValue::Connector(Box::new(
$crate::frontend::ast::ConnectorChoice {
connector: $crate::enums::RoutableConnectors::$name,
},
))
};
($key:ident = $val:ident) => {{
pub use $crate::frontend::dir::enums::*;
$crate::frontend::dir::DirValue::$key($key::$val)
}};
($key:ident = $num:literal) => {{
$crate::frontend::dir::DirValue::$key($crate::types::NumValue {
number: common_utils::types::MinorUnit::new($num),
refinement: None,
})
}};
($key:ident s= $str:literal) => {{
$crate::frontend::dir::DirValue::$key($crate::types::StrValue {
value: $str.to_string(),
})
}};
($key:literal = $str:literal) => {{
$crate::frontend::dir::DirValue::MetaData($crate::types::MetadataValue {
key: $key.to_string(),
value: $str.to_string(),
})
}};
}
<file_sep path="hyperswitch/crates/euclid/src/frontend/dir.rs" crate="euclid" role="macro_def">
macro_rules! dirval {
(Connector = $name:ident) => {
$crate::frontend::dir::DirValue::Connector(Box::new(
$crate::frontend::ast::ConnectorChoice {
connector: $crate::enums::RoutableConnectors::$name,
},
))
};
($key:ident = $val:ident) => {{
pub use $crate::frontend::dir::enums::*;
$crate::frontend::dir::DirValue::$key($key::$val)
}};
($key:ident = $num:literal) => {{
$crate::frontend::dir::DirValue::$key($crate::types::NumValue {
number: common_utils::types::MinorUnit::new($num),
refinement: None,
})
}};
($key:ident s= $str:literal) => {{
$crate::frontend::dir::DirValue::$key($crate::types::StrValue {
value: $str.to_string(),
})
}};
($key:literal = $str:literal) => {{
$crate::frontend::dir::DirValue::MetaData($crate::types::MetadataValue {
key: $key.to_string(),
value: $str.to_string(),
})
}};
}
<file_sep path="hyperswitch/crates/euclid/src/frontend/dir/transformers.rs" crate="euclid" role="use_site">
<|fim_prefix|>
<|meta_start|><|file|> hyperswitch/crates/euclid/src/frontend/dir.rs<|crate|> euclid macro=dirval roles=macro_def,use_site use=invoke item=fn pack=proc_macro_neighborhoods lang=rust<|meta_end|>
fn into_dir_value(self) -> Result<dir::DirValue, AnalysisErrorType> {
<|fim_suffix|>
<|fim_middle|>
}
<file_sep path="hyperswitch/crates/euclid/src/frontend/dir/transformers.rs" crate="euclid" role="use_site">
<|fim_prefix|>
fn into_dir_value(self) -> Result<dir::DirValue, AnalysisErrorType> {
<|fim_suffix|>
<|fim_middle|>
}
| proc_macro_neighborhoods |
<file_sep path="hyperswitch/crates/euclid/src/frontend/dir/transformers.rs" crate="euclid" role="use_site">
global_enums::PaymentMethodType::Paze => Ok(dirval!(WalletType = Paze)),
<file_sep path="hyperswitch/crates/euclid/src/frontend/dir/transformers.rs" crate="euclid" role="use_site">
global_enums::PaymentMethodType::Paze => Ok(dirval!(WalletType = Paze)),
<file_sep path="hyperswitch/crates/euclid/src/frontend/dir.rs" crate="euclid" role="macro_def">
<|fim_prefix|>
<|meta_start|><|file|> hyperswitch/crates/euclid/src/frontend/dir.rs<|crate|> euclid macro=dirval roles=use_site,macro_def use=invoke item=fn pack=proc_macro_neighborhoods lang=rust<|meta_end|>
//! Domain Intermediate Representation
pub mod enums;
pub mod lowering;
pub mod transformers;
use strum::IntoEnumIterator;
// use common_utils::types::MinorUnit;
use crate::{
<|fim_suffix|>
<|fim_middle|>
}
<file_sep path="hyperswitch/crates/euclid/src/frontend/dir.rs" crate="euclid" role="macro_def">
<|fim_prefix|>
//! Domain Intermediate Representation
pub mod enums;
pub mod lowering;
pub mod transformers;
use strum::IntoEnumIterator;
// use common_utils::types::MinorUnit;
use crate::{
<|fim_suffix|>
<|fim_middle|>
}
| proc_macro_neighborhoods |
<file_sep path="hyperswitch/crates/euclid/src/frontend/dir/transformers.rs" crate="euclid" role="use_site">
global_enums::PaymentMethodType::Eft => Ok(dirval!(BankRedirectType = Eft)),
<file_sep path="hyperswitch/crates/euclid/src/frontend/dir/transformers.rs" crate="euclid" role="use_site">
global_enums::PaymentMethodType::Eft => Ok(dirval!(BankRedirectType = Eft)),
<file_sep path="hyperswitch/crates/euclid/src/frontend/dir.rs" crate="euclid" role="macro_def">
<|fim_prefix|>
<|meta_start|><|file|> hyperswitch/crates/euclid/src/frontend/dir.rs<|crate|> euclid macro=dirval roles=use_site,macro_def use=invoke item=fn pack=proc_macro_neighborhoods lang=rust<|meta_end|>
//! Domain Intermediate Representation
pub mod enums;
pub mod lowering;
pub mod transformers;
use strum::IntoEnumIterator;
// use common_utils::types::MinorUnit;
use crate::{
<|fim_suffix|>
<|fim_middle|>
}
<file_sep path="hyperswitch/crates/euclid/src/frontend/dir.rs" crate="euclid" role="macro_def">
<|fim_prefix|>
//! Domain Intermediate Representation
pub mod enums;
pub mod lowering;
pub mod transformers;
use strum::IntoEnumIterator;
// use common_utils::types::MinorUnit;
use crate::{
<|fim_suffix|>
<|fim_middle|>
}
| proc_macro_neighborhoods |
<file_sep path="hyperswitch/crates/euclid/src/frontend/dir.rs" crate="euclid" role="macro_def">
macro_rules! dirval {
(Connector = $name:ident) => {
$crate::frontend::dir::DirValue::Connector(Box::new(
$crate::frontend::ast::ConnectorChoice {
connector: $crate::enums::RoutableConnectors::$name,
},
))
};
($key:ident = $val:ident) => {{
pub use $crate::frontend::dir::enums::*;
$crate::frontend::dir::DirValue::$key($key::$val)
}};
($key:ident = $num:literal) => {{
$crate::frontend::dir::DirValue::$key($crate::types::NumValue {
number: common_utils::types::MinorUnit::new($num),
refinement: None,
})
}};
($key:ident s= $str:literal) => {{
$crate::frontend::dir::DirValue::$key($crate::types::StrValue {
value: $str.to_string(),
})
}};
($key:literal = $str:literal) => {{
$crate::frontend::dir::DirValue::MetaData($crate::types::MetadataValue {
key: $key.to_string(),
value: $str.to_string(),
})
}};
}
<file_sep path="hyperswitch/crates/euclid/src/frontend/dir.rs" crate="euclid" role="macro_def">
macro_rules! dirval {
(Connector = $name:ident) => {
$crate::frontend::dir::DirValue::Connector(Box::new(
$crate::frontend::ast::ConnectorChoice {
connector: $crate::enums::RoutableConnectors::$name,
},
))
};
($key:ident = $val:ident) => {{
pub use $crate::frontend::dir::enums::*;
$crate::frontend::dir::DirValue::$key($key::$val)
}};
($key:ident = $num:literal) => {{
$crate::frontend::dir::DirValue::$key($crate::types::NumValue {
number: common_utils::types::MinorUnit::new($num),
refinement: None,
})
}};
($key:ident s= $str:literal) => {{
$crate::frontend::dir::DirValue::$key($crate::types::StrValue {
value: $str.to_string(),
})
}};
($key:literal = $str:literal) => {{
$crate::frontend::dir::DirValue::MetaData($crate::types::MetadataValue {
key: $key.to_string(),
value: $str.to_string(),
})
}};
}
<file_sep path="hyperswitch/crates/euclid/src/frontend/dir/transformers.rs" crate="euclid" role="use_site">
<|fim_prefix|>
<|meta_start|><|file|> hyperswitch/crates/euclid/src/frontend/dir.rs<|crate|> euclid macro=dirval roles=macro_def,use_site use=invoke item=fn pack=proc_macro_neighborhoods lang=rust<|meta_end|>
fn into_dir_value(self) -> Result<dir::DirValue, AnalysisErrorType> {
<|fim_suffix|>
<|fim_middle|>
}
<file_sep path="hyperswitch/crates/euclid/src/frontend/dir/transformers.rs" crate="euclid" role="use_site">
<|fim_prefix|>
fn into_dir_value(self) -> Result<dir::DirValue, AnalysisErrorType> {
<|fim_suffix|>
<|fim_middle|>
}
| proc_macro_neighborhoods |
<file_sep path="hyperswitch/crates/euclid/src/frontend/dir.rs" crate="euclid" role="macro_def">
macro_rules! dirval {
(Connector = $name:ident) => {
$crate::frontend::dir::DirValue::Connector(Box::new(
$crate::frontend::ast::ConnectorChoice {
connector: $crate::enums::RoutableConnectors::$name,
},
))
};
($key:ident = $val:ident) => {{
pub use $crate::frontend::dir::enums::*;
$crate::frontend::dir::DirValue::$key($key::$val)
}};
($key:ident = $num:literal) => {{
$crate::frontend::dir::DirValue::$key($crate::types::NumValue {
number: common_utils::types::MinorUnit::new($num),
refinement: None,
})
}};
($key:ident s= $str:literal) => {{
$crate::frontend::dir::DirValue::$key($crate::types::StrValue {
value: $str.to_string(),
})
}};
($key:literal = $str:literal) => {{
$crate::frontend::dir::DirValue::MetaData($crate::types::MetadataValue {
key: $key.to_string(),
value: $str.to_string(),
})
}};
}
<file_sep path="hyperswitch/crates/euclid/src/frontend/dir.rs" crate="euclid" role="macro_def">
macro_rules! dirval {
(Connector = $name:ident) => {
$crate::frontend::dir::DirValue::Connector(Box::new(
$crate::frontend::ast::ConnectorChoice {
connector: $crate::enums::RoutableConnectors::$name,
},
))
};
($key:ident = $val:ident) => {{
pub use $crate::frontend::dir::enums::*;
$crate::frontend::dir::DirValue::$key($key::$val)
}};
($key:ident = $num:literal) => {{
$crate::frontend::dir::DirValue::$key($crate::types::NumValue {
number: common_utils::types::MinorUnit::new($num),
refinement: None,
})
}};
($key:ident s= $str:literal) => {{
$crate::frontend::dir::DirValue::$key($crate::types::StrValue {
value: $str.to_string(),
})
}};
($key:literal = $str:literal) => {{
$crate::frontend::dir::DirValue::MetaData($crate::types::MetadataValue {
key: $key.to_string(),
value: $str.to_string(),
})
}};
}
<file_sep path="hyperswitch/crates/euclid/src/frontend/dir/transformers.rs" crate="euclid" role="use_site">
<|fim_prefix|>
<|meta_start|><|file|> hyperswitch/crates/euclid/src/frontend/dir.rs<|crate|> euclid macro=dirval roles=macro_def,use_site use=invoke item=fn pack=proc_macro_neighborhoods lang=rust<|meta_end|>
fn into_dir_value(self) -> Result<dir::DirValue, AnalysisErrorType> {
<|fim_suffix|>
<|fim_middle|>
}
<file_sep path="hyperswitch/crates/euclid/src/frontend/dir/transformers.rs" crate="euclid" role="use_site">
<|fim_prefix|>
fn into_dir_value(self) -> Result<dir::DirValue, AnalysisErrorType> {
<|fim_suffix|>
<|fim_middle|>
}
| proc_macro_neighborhoods |
<file_sep path="hyperswitch/crates/euclid/src/frontend/ast/lowering.rs" crate="euclid" role="macro_def">
macro_rules! lower_metadata {
($key:ident, $value:ident) => {
match $value {
ast::ValueType::MetadataVariant(md) => {
Ok(vec![dir::DirValue::$key(types::MetadataValue {
key: md.key,
value: md.value,
})])
}
_ => Err(AnalysisErrorType::InvalidType {
key: dir::DirKeyKind::$key.to_string(),
expected: DataType::MetadataValue,
got: $value.get_type(),
}),
}
};
}
<file_sep path="hyperswitch/crates/euclid/src/frontend/ast/lowering.rs" crate="euclid" role="macro_def">
macro_rules! lower_metadata {
($key:ident, $value:ident) => {
match $value {
ast::ValueType::MetadataVariant(md) => {
Ok(vec![dir::DirValue::$key(types::MetadataValue {
key: md.key,
value: md.value,
})])
}
_ => Err(AnalysisErrorType::InvalidType {
key: dir::DirKeyKind::$key.to_string(),
expected: DataType::MetadataValue,
got: $value.get_type(),
}),
}
};
}
<file_sep path="hyperswitch/crates/euclid/src/frontend/ast/lowering.rs" crate="euclid" role="use_site">
<|fim_prefix|>
<|meta_start|><|file|> hyperswitch/crates/euclid/src/frontend/ast/lowering.rs<|crate|> euclid macro=lower_metadata roles=macro_def,use_site use=invoke item=fn pack=proc_macro_neighborhoods lang=rust<|meta_end|>
fn lower_comparison_inner<O: EuclidDirFilter>(
comp: ast::Comparison,
) -> Result<Vec<dir::DirValue>, AnalysisErrorType> {
<|fim_suffix|>
<|fim_middle|>
}
<file_sep path="hyperswitch/crates/euclid/src/frontend/ast/lowering.rs" crate="euclid" role="use_site">
<|fim_prefix|>
fn lower_comparison_inner<O: EuclidDirFilter>(
comp: ast::Comparison,
) -> Result<Vec<dir::DirValue>, AnalysisErrorType> {
<|fim_suffix|>
<|fim_middle|>
}
| proc_macro_neighborhoods |
<file_sep path="hyperswitch/crates/euclid/src/frontend/ast/lowering.rs" crate="euclid" role="use_site">
dir::DirKeyKind::MetaData => lower_metadata!(MetaData, value),
<file_sep path="hyperswitch/crates/euclid/src/frontend/ast/lowering.rs" crate="euclid" role="use_site">
dir::DirKeyKind::MetaData => lower_metadata!(MetaData, value),
<file_sep path="hyperswitch/crates/euclid/src/frontend/ast/lowering.rs" crate="euclid" role="macro_def">
<|fim_prefix|>
<|meta_start|><|file|> hyperswitch/crates/euclid/src/frontend/ast/lowering.rs<|crate|> euclid macro=lower_metadata roles=use_site,macro_def use=invoke item=fn pack=proc_macro_neighborhoods lang=rust<|meta_end|>
//! Analysis for the Lowering logic in ast
//!
//!Certain functions that can be used to perform the complete lowering of ast to dir.
//!This includes lowering of enums, numbers, strings as well as Comparison logics.
use std::str::FromStr;
use crate::{
<|fim_suffix|>
<|fim_middle|>
}
<file_sep path="hyperswitch/crates/euclid/src/frontend/ast/lowering.rs" crate="euclid" role="macro_def">
<|fim_prefix|>
//! Analysis for the Lowering logic in ast
//!
//!Certain functions that can be used to perform the complete lowering of ast to dir.
//!This includes lowering of enums, numbers, strings as well as Comparison logics.
use std::str::FromStr;
use crate::{
<|fim_suffix|>
<|fim_middle|>
}
| proc_macro_neighborhoods |
<file_sep path="hyperswitch/crates/euclid/src/frontend/ast/lowering.rs" crate="euclid" role="macro_def">
macro_rules! lower_str {
($key:ident, $value:ident $(, $validation_closure:expr)?) => {
match $value {
ast::ValueType::StrValue(st) => {
$($validation_closure(&st)?;)?
Ok(vec![dir::DirValue::$key(types::StrValue { value: st })])
}
_ => Err(AnalysisErrorType::InvalidType {
key: dir::DirKeyKind::$key.to_string(),
expected: DataType::StrValue,
got: $value.get_type(),
}),
}
};
}
<file_sep path="hyperswitch/crates/euclid/src/frontend/ast/lowering.rs" crate="euclid" role="macro_def">
macro_rules! lower_str {
($key:ident, $value:ident $(, $validation_closure:expr)?) => {
match $value {
ast::ValueType::StrValue(st) => {
$($validation_closure(&st)?;)?
Ok(vec![dir::DirValue::$key(types::StrValue { value: st })])
}
_ => Err(AnalysisErrorType::InvalidType {
key: dir::DirKeyKind::$key.to_string(),
expected: DataType::StrValue,
got: $value.get_type(),
}),
}
};
}
<file_sep path="hyperswitch/crates/euclid/src/frontend/ast/lowering.rs" crate="euclid" role="use_site">
<|fim_prefix|>
<|meta_start|><|file|> hyperswitch/crates/euclid/src/frontend/ast/lowering.rs<|crate|> euclid macro=lower_str roles=macro_def,use_site use=invoke item=fn pack=proc_macro_neighborhoods lang=rust<|meta_end|>
fn lower_comparison_inner<O: EuclidDirFilter>(
comp: ast::Comparison,
) -> Result<Vec<dir::DirValue>, AnalysisErrorType> {
<|fim_suffix|>
<|fim_middle|>
}
<file_sep path="hyperswitch/crates/euclid/src/frontend/ast/lowering.rs" crate="euclid" role="use_site">
<|fim_prefix|>
fn lower_comparison_inner<O: EuclidDirFilter>(
comp: ast::Comparison,
) -> Result<Vec<dir::DirValue>, AnalysisErrorType> {
<|fim_suffix|>
<|fim_middle|>
}
| proc_macro_neighborhoods |
<file_sep path="hyperswitch/crates/euclid/src/frontend/ast/lowering.rs" crate="euclid" role="macro_def">
macro_rules! lower_str {
($key:ident, $value:ident $(, $validation_closure:expr)?) => {
match $value {
ast::ValueType::StrValue(st) => {
$($validation_closure(&st)?;)?
Ok(vec![dir::DirValue::$key(types::StrValue { value: st })])
}
_ => Err(AnalysisErrorType::InvalidType {
key: dir::DirKeyKind::$key.to_string(),
expected: DataType::StrValue,
got: $value.get_type(),
}),
}
};
}
<file_sep path="hyperswitch/crates/euclid/src/frontend/ast/lowering.rs" crate="euclid" role="macro_def">
macro_rules! lower_str {
($key:ident, $value:ident $(, $validation_closure:expr)?) => {
match $value {
ast::ValueType::StrValue(st) => {
$($validation_closure(&st)?;)?
Ok(vec![dir::DirValue::$key(types::StrValue { value: st })])
}
_ => Err(AnalysisErrorType::InvalidType {
key: dir::DirKeyKind::$key.to_string(),
expected: DataType::StrValue,
got: $value.get_type(),
}),
}
};
}
<file_sep path="hyperswitch/crates/euclid/src/frontend/ast/lowering.rs" crate="euclid" role="use_site">
<|fim_prefix|>
<|meta_start|><|file|> hyperswitch/crates/euclid/src/frontend/ast/lowering.rs<|crate|> euclid macro=lower_str roles=macro_def,use_site use=invoke item=fn pack=proc_macro_neighborhoods lang=rust<|meta_end|>
fn lower_comparison_inner<O: EuclidDirFilter>(
comp: ast::Comparison,
) -> Result<Vec<dir::DirValue>, AnalysisErrorType> {
<|fim_suffix|>
<|fim_middle|>
}
<file_sep path="hyperswitch/crates/euclid/src/frontend/ast/lowering.rs" crate="euclid" role="use_site">
<|fim_prefix|>
fn lower_comparison_inner<O: EuclidDirFilter>(
comp: ast::Comparison,
) -> Result<Vec<dir::DirValue>, AnalysisErrorType> {
<|fim_suffix|>
<|fim_middle|>
}
| proc_macro_neighborhoods |
<file_sep path="hyperswitch/crates/euclid/src/frontend/ast/lowering.rs" crate="euclid" role="use_site">
dir::DirKeyKind::BusinessLabel => lower_str!(BusinessLabel, value),
<file_sep path="hyperswitch/crates/euclid/src/frontend/ast/lowering.rs" crate="euclid" role="use_site">
dir::DirKeyKind::BusinessLabel => lower_str!(BusinessLabel, value),
<file_sep path="hyperswitch/crates/euclid/src/frontend/ast/lowering.rs" crate="euclid" role="macro_def">
<|fim_prefix|>
<|meta_start|><|file|> hyperswitch/crates/euclid/src/frontend/ast/lowering.rs<|crate|> euclid macro=lower_str roles=use_site,macro_def use=invoke item=fn pack=proc_macro_neighborhoods lang=rust<|meta_end|>
//! Analysis for the Lowering logic in ast
//!
//!Certain functions that can be used to perform the complete lowering of ast to dir.
//!This includes lowering of enums, numbers, strings as well as Comparison logics.
use std::str::FromStr;
use crate::{
<|fim_suffix|>
<|fim_middle|>
}
<file_sep path="hyperswitch/crates/euclid/src/frontend/ast/lowering.rs" crate="euclid" role="macro_def">
<|fim_prefix|>
//! Analysis for the Lowering logic in ast
//!
//!Certain functions that can be used to perform the complete lowering of ast to dir.
//!This includes lowering of enums, numbers, strings as well as Comparison logics.
use std::str::FromStr;
use crate::{
<|fim_suffix|>
<|fim_middle|>
}
| proc_macro_neighborhoods |
<file_sep path="hyperswitch/crates/euclid/src/frontend/ast/lowering.rs" crate="euclid" role="macro_def">
macro_rules! lower_number {
($key:ident, $value:ident, $comp:ident) => {
match $value {
ast::ValueType::Number(num) => Ok(vec![dir::DirValue::$key(types::NumValue {
number: num,
refinement: $comp.into(),
})]),
ast::ValueType::NumberArray(na) => na
.into_iter()
.map(|num| {
Ok(dir::DirValue::$key(types::NumValue {
number: num,
refinement: $comp.clone().into(),
}))
})
.collect(),
ast::ValueType::NumberComparisonArray(nca) => nca
.into_iter()
.map(|nc| {
Ok(dir::DirValue::$key(types::NumValue {
number: nc.number,
refinement: nc.comparison_type.into(),
}))
})
.collect(),
_ => Err(AnalysisErrorType::InvalidType {
key: dir::DirKeyKind::$key.to_string(),
expected: DataType::Number,
got: $value.get_type(),
}),
}
};
}
<file_sep path="hyperswitch/crates/euclid/src/frontend/ast/lowering.rs" crate="euclid" role="macro_def">
macro_rules! lower_number {
($key:ident, $value:ident, $comp:ident) => {
match $value {
ast::ValueType::Number(num) => Ok(vec![dir::DirValue::$key(types::NumValue {
number: num,
refinement: $comp.into(),
})]),
ast::ValueType::NumberArray(na) => na
.into_iter()
.map(|num| {
Ok(dir::DirValue::$key(types::NumValue {
number: num,
refinement: $comp.clone().into(),
}))
})
.collect(),
ast::ValueType::NumberComparisonArray(nca) => nca
.into_iter()
.map(|nc| {
Ok(dir::DirValue::$key(types::NumValue {
number: nc.number,
refinement: nc.comparison_type.into(),
}))
})
.collect(),
_ => Err(AnalysisErrorType::InvalidType {
key: dir::DirKeyKind::$key.to_string(),
expected: DataType::Number,
got: $value.get_type(),
}),
}
};
}
<file_sep path="hyperswitch/crates/euclid/src/frontend/ast/lowering.rs" crate="euclid" role="use_site">
<|fim_prefix|>
<|meta_start|><|file|> hyperswitch/crates/euclid/src/frontend/ast/lowering.rs<|crate|> euclid macro=lower_number roles=macro_def,use_site use=invoke item=fn pack=proc_macro_neighborhoods lang=rust<|meta_end|>
fn lower_comparison_inner<O: EuclidDirFilter>(
comp: ast::Comparison,
) -> Result<Vec<dir::DirValue>, AnalysisErrorType> {
<|fim_suffix|>
<|fim_middle|>
}
<file_sep path="hyperswitch/crates/euclid/src/frontend/ast/lowering.rs" crate="euclid" role="use_site">
<|fim_prefix|>
fn lower_comparison_inner<O: EuclidDirFilter>(
comp: ast::Comparison,
) -> Result<Vec<dir::DirValue>, AnalysisErrorType> {
<|fim_suffix|>
<|fim_middle|>
}
| proc_macro_neighborhoods |
<file_sep path="hyperswitch/crates/euclid/src/frontend/ast/lowering.rs" crate="euclid" role="use_site">
dir::DirKeyKind::PaymentAmount => lower_number!(PaymentAmount, value, comparison),
<file_sep path="hyperswitch/crates/euclid/src/frontend/ast/lowering.rs" crate="euclid" role="use_site">
dir::DirKeyKind::PaymentAmount => lower_number!(PaymentAmount, value, comparison),
<file_sep path="hyperswitch/crates/euclid/src/frontend/ast/lowering.rs" crate="euclid" role="macro_def">
<|fim_prefix|>
<|meta_start|><|file|> hyperswitch/crates/euclid/src/frontend/ast/lowering.rs<|crate|> euclid macro=lower_number roles=use_site,macro_def use=invoke item=fn pack=proc_macro_neighborhoods lang=rust<|meta_end|>
//! Analysis for the Lowering logic in ast
//!
//!Certain functions that can be used to perform the complete lowering of ast to dir.
//!This includes lowering of enums, numbers, strings as well as Comparison logics.
use std::str::FromStr;
use crate::{
<|fim_suffix|>
<|fim_middle|>
}
<file_sep path="hyperswitch/crates/euclid/src/frontend/ast/lowering.rs" crate="euclid" role="macro_def">
<|fim_prefix|>
//! Analysis for the Lowering logic in ast
//!
//!Certain functions that can be used to perform the complete lowering of ast to dir.
//!This includes lowering of enums, numbers, strings as well as Comparison logics.
use std::str::FromStr;
use crate::{
<|fim_suffix|>
<|fim_middle|>
}
| proc_macro_neighborhoods |
<file_sep path="hyperswitch/crates/euclid/src/frontend/ast/lowering.rs" crate="euclid" role="macro_def">
macro_rules! lower_enum {
($key:ident, $value:ident) => {
match $value {
ast::ValueType::EnumVariant(ev) => Ok(vec![dir::DirValue::$key(
dir_enums::$key::from_str(&ev).map_err(|_| AnalysisErrorType::InvalidVariant {
key: dir::DirKeyKind::$key.to_string(),
got: ev,
expected: dir_enums::$key::variants(),
})?,
)]),
ast::ValueType::EnumVariantArray(eva) => eva
.into_iter()
.map(|ev| {
Ok(dir::DirValue::$key(
dir_enums::$key::from_str(&ev).map_err(|_| {
AnalysisErrorType::InvalidVariant {
key: dir::DirKeyKind::$key.to_string(),
got: ev,
expected: dir_enums::$key::variants(),
}
})?,
))
})
.collect(),
_ => Err(AnalysisErrorType::InvalidType {
key: dir::DirKeyKind::$key.to_string(),
expected: DataType::EnumVariant,
got: $value.get_type(),
}),
}
};
}
<file_sep path="hyperswitch/crates/euclid/src/frontend/ast/lowering.rs" crate="euclid" role="macro_def">
macro_rules! lower_enum {
($key:ident, $value:ident) => {
match $value {
ast::ValueType::EnumVariant(ev) => Ok(vec![dir::DirValue::$key(
dir_enums::$key::from_str(&ev).map_err(|_| AnalysisErrorType::InvalidVariant {
key: dir::DirKeyKind::$key.to_string(),
got: ev,
expected: dir_enums::$key::variants(),
})?,
)]),
ast::ValueType::EnumVariantArray(eva) => eva
.into_iter()
.map(|ev| {
Ok(dir::DirValue::$key(
dir_enums::$key::from_str(&ev).map_err(|_| {
AnalysisErrorType::InvalidVariant {
key: dir::DirKeyKind::$key.to_string(),
got: ev,
expected: dir_enums::$key::variants(),
}
})?,
))
})
.collect(),
_ => Err(AnalysisErrorType::InvalidType {
key: dir::DirKeyKind::$key.to_string(),
expected: DataType::EnumVariant,
got: $value.get_type(),
}),
}
};
}
<file_sep path="hyperswitch/crates/euclid/src/frontend/ast/lowering.rs" crate="euclid" role="use_site">
<|fim_prefix|>
<|meta_start|><|file|> hyperswitch/crates/euclid/src/frontend/ast/lowering.rs<|crate|> euclid macro=lower_enum roles=macro_def,use_site use=invoke item=fn pack=proc_macro_neighborhoods lang=rust<|meta_end|>
fn lower_comparison_inner<O: EuclidDirFilter>(
comp: ast::Comparison,
) -> Result<Vec<dir::DirValue>, AnalysisErrorType> {
<|fim_suffix|>
<|fim_middle|>
}
<file_sep path="hyperswitch/crates/euclid/src/frontend/ast/lowering.rs" crate="euclid" role="use_site">
<|fim_prefix|>
fn lower_comparison_inner<O: EuclidDirFilter>(
comp: ast::Comparison,
) -> Result<Vec<dir::DirValue>, AnalysisErrorType> {
<|fim_suffix|>
<|fim_middle|>
}
| proc_macro_neighborhoods |
<file_sep path="hyperswitch/crates/euclid/src/frontend/ast/lowering.rs" crate="euclid" role="macro_def">
macro_rules! lower_enum {
($key:ident, $value:ident) => {
match $value {
ast::ValueType::EnumVariant(ev) => Ok(vec![dir::DirValue::$key(
dir_enums::$key::from_str(&ev).map_err(|_| AnalysisErrorType::InvalidVariant {
key: dir::DirKeyKind::$key.to_string(),
got: ev,
expected: dir_enums::$key::variants(),
})?,
)]),
ast::ValueType::EnumVariantArray(eva) => eva
.into_iter()
.map(|ev| {
Ok(dir::DirValue::$key(
dir_enums::$key::from_str(&ev).map_err(|_| {
AnalysisErrorType::InvalidVariant {
key: dir::DirKeyKind::$key.to_string(),
got: ev,
expected: dir_enums::$key::variants(),
}
})?,
))
})
.collect(),
_ => Err(AnalysisErrorType::InvalidType {
key: dir::DirKeyKind::$key.to_string(),
expected: DataType::EnumVariant,
got: $value.get_type(),
}),
}
};
}
<file_sep path="hyperswitch/crates/euclid/src/frontend/ast/lowering.rs" crate="euclid" role="macro_def">
macro_rules! lower_enum {
($key:ident, $value:ident) => {
match $value {
ast::ValueType::EnumVariant(ev) => Ok(vec![dir::DirValue::$key(
dir_enums::$key::from_str(&ev).map_err(|_| AnalysisErrorType::InvalidVariant {
key: dir::DirKeyKind::$key.to_string(),
got: ev,
expected: dir_enums::$key::variants(),
})?,
)]),
ast::ValueType::EnumVariantArray(eva) => eva
.into_iter()
.map(|ev| {
Ok(dir::DirValue::$key(
dir_enums::$key::from_str(&ev).map_err(|_| {
AnalysisErrorType::InvalidVariant {
key: dir::DirKeyKind::$key.to_string(),
got: ev,
expected: dir_enums::$key::variants(),
}
})?,
))
})
.collect(),
_ => Err(AnalysisErrorType::InvalidType {
key: dir::DirKeyKind::$key.to_string(),
expected: DataType::EnumVariant,
got: $value.get_type(),
}),
}
};
}
<file_sep path="hyperswitch/crates/euclid/src/frontend/ast/lowering.rs" crate="euclid" role="use_site">
<|fim_prefix|>
<|meta_start|><|file|> hyperswitch/crates/euclid/src/frontend/ast/lowering.rs<|crate|> euclid macro=lower_enum roles=macro_def,use_site use=invoke item=fn pack=proc_macro_neighborhoods lang=rust<|meta_end|>
fn lower_comparison_inner<O: EuclidDirFilter>(
comp: ast::Comparison,
) -> Result<Vec<dir::DirValue>, AnalysisErrorType> {
<|fim_suffix|>
<|fim_middle|>
}
<file_sep path="hyperswitch/crates/euclid/src/frontend/ast/lowering.rs" crate="euclid" role="use_site">
<|fim_prefix|>
fn lower_comparison_inner<O: EuclidDirFilter>(
comp: ast::Comparison,
) -> Result<Vec<dir::DirValue>, AnalysisErrorType> {
<|fim_suffix|>
<|fim_middle|>
}
| proc_macro_neighborhoods |
<file_sep path="hyperswitch/crates/euclid/src/frontend/ast/lowering.rs" crate="euclid" role="use_site">
dir::DirKeyKind::VoucherType => lower_enum!(VoucherType, value),
<file_sep path="hyperswitch/crates/euclid/src/frontend/ast/lowering.rs" crate="euclid" role="use_site">
dir::DirKeyKind::VoucherType => lower_enum!(VoucherType, value),
<file_sep path="hyperswitch/crates/euclid/src/frontend/ast/lowering.rs" crate="euclid" role="macro_def">
<|fim_prefix|>
<|meta_start|><|file|> hyperswitch/crates/euclid/src/frontend/ast/lowering.rs<|crate|> euclid macro=lower_enum roles=use_site,macro_def use=invoke item=fn pack=proc_macro_neighborhoods lang=rust<|meta_end|>
//! Analysis for the Lowering logic in ast
//!
//!Certain functions that can be used to perform the complete lowering of ast to dir.
//!This includes lowering of enums, numbers, strings as well as Comparison logics.
use std::str::FromStr;
use crate::{
<|fim_suffix|>
<|fim_middle|>
}
<file_sep path="hyperswitch/crates/euclid/src/frontend/ast/lowering.rs" crate="euclid" role="macro_def">
<|fim_prefix|>
//! Analysis for the Lowering logic in ast
//!
//!Certain functions that can be used to perform the complete lowering of ast to dir.
//!This includes lowering of enums, numbers, strings as well as Comparison logics.
use std::str::FromStr;
use crate::{
<|fim_suffix|>
<|fim_middle|>
}
| proc_macro_neighborhoods |
<file_sep path="hyperswitch/crates/euclid/src/frontend/ast/lowering.rs" crate="euclid" role="use_site">
dir::DirKeyKind::OpenBankingType => lower_enum!(OpenBankingType, value),
<file_sep path="hyperswitch/crates/euclid/src/frontend/ast/lowering.rs" crate="euclid" role="use_site">
dir::DirKeyKind::OpenBankingType => lower_enum!(OpenBankingType, value),
<file_sep path="hyperswitch/crates/euclid/src/frontend/ast/lowering.rs" crate="euclid" role="macro_def">
<|fim_prefix|>
<|meta_start|><|file|> hyperswitch/crates/euclid/src/frontend/ast/lowering.rs<|crate|> euclid macro=lower_enum roles=use_site,macro_def use=invoke item=fn pack=proc_macro_neighborhoods lang=rust<|meta_end|>
//! Analysis for the Lowering logic in ast
//!
//!Certain functions that can be used to perform the complete lowering of ast to dir.
//!This includes lowering of enums, numbers, strings as well as Comparison logics.
use std::str::FromStr;
use crate::{
<|fim_suffix|>
<|fim_middle|>
}
<file_sep path="hyperswitch/crates/euclid/src/frontend/ast/lowering.rs" crate="euclid" role="macro_def">
<|fim_prefix|>
//! Analysis for the Lowering logic in ast
//!
//!Certain functions that can be used to perform the complete lowering of ast to dir.
//!This includes lowering of enums, numbers, strings as well as Comparison logics.
use std::str::FromStr;
use crate::{
<|fim_suffix|>
<|fim_middle|>
}
| proc_macro_neighborhoods |
<file_sep path="hyperswitch/crates/euclid/src/frontend/ast/lowering.rs" crate="euclid" role="use_site">
dir::DirKeyKind::CardRedirectType => lower_enum!(CardRedirectType, value),
<file_sep path="hyperswitch/crates/euclid/src/frontend/ast/lowering.rs" crate="euclid" role="use_site">
dir::DirKeyKind::CardRedirectType => lower_enum!(CardRedirectType, value),
<file_sep path="hyperswitch/crates/euclid/src/frontend/ast/lowering.rs" crate="euclid" role="macro_def">
<|fim_prefix|>
<|meta_start|><|file|> hyperswitch/crates/euclid/src/frontend/ast/lowering.rs<|crate|> euclid macro=lower_enum roles=use_site,macro_def use=invoke item=fn pack=proc_macro_neighborhoods lang=rust<|meta_end|>
//! Analysis for the Lowering logic in ast
//!
//!Certain functions that can be used to perform the complete lowering of ast to dir.
//!This includes lowering of enums, numbers, strings as well as Comparison logics.
use std::str::FromStr;
use crate::{
<|fim_suffix|>
<|fim_middle|>
}
<file_sep path="hyperswitch/crates/euclid/src/frontend/ast/lowering.rs" crate="euclid" role="macro_def">
<|fim_prefix|>
//! Analysis for the Lowering logic in ast
//!
//!Certain functions that can be used to perform the complete lowering of ast to dir.
//!This includes lowering of enums, numbers, strings as well as Comparison logics.
use std::str::FromStr;
use crate::{
<|fim_suffix|>
<|fim_middle|>
}
| proc_macro_neighborhoods |
<file_sep path="hyperswitch/crates/euclid/src/frontend/ast/lowering.rs" crate="euclid" role="use_site">
dir::DirKeyKind::BankTransferType => lower_enum!(BankTransferType, value),
<file_sep path="hyperswitch/crates/euclid/src/frontend/ast/lowering.rs" crate="euclid" role="use_site">
dir::DirKeyKind::BankTransferType => lower_enum!(BankTransferType, value),
<file_sep path="hyperswitch/crates/euclid/src/frontend/ast/lowering.rs" crate="euclid" role="macro_def">
<|fim_prefix|>
<|meta_start|><|file|> hyperswitch/crates/euclid/src/frontend/ast/lowering.rs<|crate|> euclid macro=lower_enum roles=use_site,macro_def use=invoke item=fn pack=proc_macro_neighborhoods lang=rust<|meta_end|>
//! Analysis for the Lowering logic in ast
//!
//!Certain functions that can be used to perform the complete lowering of ast to dir.
//!This includes lowering of enums, numbers, strings as well as Comparison logics.
use std::str::FromStr;
use crate::{
<|fim_suffix|>
<|fim_middle|>
}
<file_sep path="hyperswitch/crates/euclid/src/frontend/ast/lowering.rs" crate="euclid" role="macro_def">
<|fim_prefix|>
//! Analysis for the Lowering logic in ast
//!
//!Certain functions that can be used to perform the complete lowering of ast to dir.
//!This includes lowering of enums, numbers, strings as well as Comparison logics.
use std::str::FromStr;
use crate::{
<|fim_suffix|>
<|fim_middle|>
}
| proc_macro_neighborhoods |
<file_sep path="hyperswitch/crates/euclid/src/frontend/ast/lowering.rs" crate="euclid" role="macro_def">
macro_rules! lower_enum {
($key:ident, $value:ident) => {
match $value {
ast::ValueType::EnumVariant(ev) => Ok(vec![dir::DirValue::$key(
dir_enums::$key::from_str(&ev).map_err(|_| AnalysisErrorType::InvalidVariant {
key: dir::DirKeyKind::$key.to_string(),
got: ev,
expected: dir_enums::$key::variants(),
})?,
)]),
ast::ValueType::EnumVariantArray(eva) => eva
.into_iter()
.map(|ev| {
Ok(dir::DirValue::$key(
dir_enums::$key::from_str(&ev).map_err(|_| {
AnalysisErrorType::InvalidVariant {
key: dir::DirKeyKind::$key.to_string(),
got: ev,
expected: dir_enums::$key::variants(),
}
})?,
))
})
.collect(),
_ => Err(AnalysisErrorType::InvalidType {
key: dir::DirKeyKind::$key.to_string(),
expected: DataType::EnumVariant,
got: $value.get_type(),
}),
}
};
}
<file_sep path="hyperswitch/crates/euclid/src/frontend/ast/lowering.rs" crate="euclid" role="macro_def">
macro_rules! lower_enum {
($key:ident, $value:ident) => {
match $value {
ast::ValueType::EnumVariant(ev) => Ok(vec![dir::DirValue::$key(
dir_enums::$key::from_str(&ev).map_err(|_| AnalysisErrorType::InvalidVariant {
key: dir::DirKeyKind::$key.to_string(),
got: ev,
expected: dir_enums::$key::variants(),
})?,
)]),
ast::ValueType::EnumVariantArray(eva) => eva
.into_iter()
.map(|ev| {
Ok(dir::DirValue::$key(
dir_enums::$key::from_str(&ev).map_err(|_| {
AnalysisErrorType::InvalidVariant {
key: dir::DirKeyKind::$key.to_string(),
got: ev,
expected: dir_enums::$key::variants(),
}
})?,
))
})
.collect(),
_ => Err(AnalysisErrorType::InvalidType {
key: dir::DirKeyKind::$key.to_string(),
expected: DataType::EnumVariant,
got: $value.get_type(),
}),
}
};
}
<file_sep path="hyperswitch/crates/euclid/src/frontend/ast/lowering.rs" crate="euclid" role="use_site">
<|fim_prefix|>
<|meta_start|><|file|> hyperswitch/crates/euclid/src/frontend/ast/lowering.rs<|crate|> euclid macro=lower_enum roles=macro_def,use_site use=invoke item=fn pack=proc_macro_neighborhoods lang=rust<|meta_end|>
fn lower_comparison_inner<O: EuclidDirFilter>(
comp: ast::Comparison,
) -> Result<Vec<dir::DirValue>, AnalysisErrorType> {
<|fim_suffix|>
<|fim_middle|>
}
<file_sep path="hyperswitch/crates/euclid/src/frontend/ast/lowering.rs" crate="euclid" role="use_site">
<|fim_prefix|>
fn lower_comparison_inner<O: EuclidDirFilter>(
comp: ast::Comparison,
) -> Result<Vec<dir::DirValue>, AnalysisErrorType> {
<|fim_suffix|>
<|fim_middle|>
}
| proc_macro_neighborhoods |
<file_sep path="hyperswitch/crates/euclid/src/frontend/ast/lowering.rs" crate="euclid" role="macro_def">
macro_rules! lower_enum {
($key:ident, $value:ident) => {
match $value {
ast::ValueType::EnumVariant(ev) => Ok(vec![dir::DirValue::$key(
dir_enums::$key::from_str(&ev).map_err(|_| AnalysisErrorType::InvalidVariant {
key: dir::DirKeyKind::$key.to_string(),
got: ev,
expected: dir_enums::$key::variants(),
})?,
)]),
ast::ValueType::EnumVariantArray(eva) => eva
.into_iter()
.map(|ev| {
Ok(dir::DirValue::$key(
dir_enums::$key::from_str(&ev).map_err(|_| {
AnalysisErrorType::InvalidVariant {
key: dir::DirKeyKind::$key.to_string(),
got: ev,
expected: dir_enums::$key::variants(),
}
})?,
))
})
.collect(),
_ => Err(AnalysisErrorType::InvalidType {
key: dir::DirKeyKind::$key.to_string(),
expected: DataType::EnumVariant,
got: $value.get_type(),
}),
}
};
}
<file_sep path="hyperswitch/crates/euclid/src/frontend/ast/lowering.rs" crate="euclid" role="macro_def">
macro_rules! lower_enum {
($key:ident, $value:ident) => {
match $value {
ast::ValueType::EnumVariant(ev) => Ok(vec![dir::DirValue::$key(
dir_enums::$key::from_str(&ev).map_err(|_| AnalysisErrorType::InvalidVariant {
key: dir::DirKeyKind::$key.to_string(),
got: ev,
expected: dir_enums::$key::variants(),
})?,
)]),
ast::ValueType::EnumVariantArray(eva) => eva
.into_iter()
.map(|ev| {
Ok(dir::DirValue::$key(
dir_enums::$key::from_str(&ev).map_err(|_| {
AnalysisErrorType::InvalidVariant {
key: dir::DirKeyKind::$key.to_string(),
got: ev,
expected: dir_enums::$key::variants(),
}
})?,
))
})
.collect(),
_ => Err(AnalysisErrorType::InvalidType {
key: dir::DirKeyKind::$key.to_string(),
expected: DataType::EnumVariant,
got: $value.get_type(),
}),
}
};
}
<file_sep path="hyperswitch/crates/euclid/src/frontend/ast/lowering.rs" crate="euclid" role="use_site">
<|fim_prefix|>
<|meta_start|><|file|> hyperswitch/crates/euclid/src/frontend/ast/lowering.rs<|crate|> euclid macro=lower_enum roles=macro_def,use_site use=invoke item=fn pack=proc_macro_neighborhoods lang=rust<|meta_end|>
fn lower_comparison_inner<O: EuclidDirFilter>(
comp: ast::Comparison,
) -> Result<Vec<dir::DirValue>, AnalysisErrorType> {
<|fim_suffix|>
<|fim_middle|>
}
<file_sep path="hyperswitch/crates/euclid/src/frontend/ast/lowering.rs" crate="euclid" role="use_site">
<|fim_prefix|>
fn lower_comparison_inner<O: EuclidDirFilter>(
comp: ast::Comparison,
) -> Result<Vec<dir::DirValue>, AnalysisErrorType> {
<|fim_suffix|>
<|fim_middle|>
}
| proc_macro_neighborhoods |
<file_sep path="hyperswitch/crates/euclid/src/frontend/ast/lowering.rs" crate="euclid" role="macro_def">
macro_rules! lower_enum {
($key:ident, $value:ident) => {
match $value {
ast::ValueType::EnumVariant(ev) => Ok(vec![dir::DirValue::$key(
dir_enums::$key::from_str(&ev).map_err(|_| AnalysisErrorType::InvalidVariant {
key: dir::DirKeyKind::$key.to_string(),
got: ev,
expected: dir_enums::$key::variants(),
})?,
)]),
ast::ValueType::EnumVariantArray(eva) => eva
.into_iter()
.map(|ev| {
Ok(dir::DirValue::$key(
dir_enums::$key::from_str(&ev).map_err(|_| {
AnalysisErrorType::InvalidVariant {
key: dir::DirKeyKind::$key.to_string(),
got: ev,
expected: dir_enums::$key::variants(),
}
})?,
))
})
.collect(),
_ => Err(AnalysisErrorType::InvalidType {
key: dir::DirKeyKind::$key.to_string(),
expected: DataType::EnumVariant,
got: $value.get_type(),
}),
}
};
}
<file_sep path="hyperswitch/crates/euclid/src/frontend/ast/lowering.rs" crate="euclid" role="macro_def">
macro_rules! lower_enum {
($key:ident, $value:ident) => {
match $value {
ast::ValueType::EnumVariant(ev) => Ok(vec![dir::DirValue::$key(
dir_enums::$key::from_str(&ev).map_err(|_| AnalysisErrorType::InvalidVariant {
key: dir::DirKeyKind::$key.to_string(),
got: ev,
expected: dir_enums::$key::variants(),
})?,
)]),
ast::ValueType::EnumVariantArray(eva) => eva
.into_iter()
.map(|ev| {
Ok(dir::DirValue::$key(
dir_enums::$key::from_str(&ev).map_err(|_| {
AnalysisErrorType::InvalidVariant {
key: dir::DirKeyKind::$key.to_string(),
got: ev,
expected: dir_enums::$key::variants(),
}
})?,
))
})
.collect(),
_ => Err(AnalysisErrorType::InvalidType {
key: dir::DirKeyKind::$key.to_string(),
expected: DataType::EnumVariant,
got: $value.get_type(),
}),
}
};
}
<file_sep path="hyperswitch/crates/euclid/src/frontend/ast/lowering.rs" crate="euclid" role="use_site">
<|fim_prefix|>
<|meta_start|><|file|> hyperswitch/crates/euclid/src/frontend/ast/lowering.rs<|crate|> euclid macro=lower_enum roles=macro_def,use_site use=invoke item=fn pack=proc_macro_neighborhoods lang=rust<|meta_end|>
fn lower_comparison_inner<O: EuclidDirFilter>(
comp: ast::Comparison,
) -> Result<Vec<dir::DirValue>, AnalysisErrorType> {
<|fim_suffix|>
<|fim_middle|>
}
<file_sep path="hyperswitch/crates/euclid/src/frontend/ast/lowering.rs" crate="euclid" role="use_site">
<|fim_prefix|>
fn lower_comparison_inner<O: EuclidDirFilter>(
comp: ast::Comparison,
) -> Result<Vec<dir::DirValue>, AnalysisErrorType> {
<|fim_suffix|>
<|fim_middle|>
}
| proc_macro_neighborhoods |
<file_sep path="hyperswitch/crates/euclid/src/frontend/ast/lowering.rs" crate="euclid" role="use_site">
dir::DirKeyKind::RealTimePaymentType => lower_enum!(RealTimePaymentType, value),
<file_sep path="hyperswitch/crates/euclid/src/frontend/ast/lowering.rs" crate="euclid" role="use_site">
dir::DirKeyKind::RealTimePaymentType => lower_enum!(RealTimePaymentType, value),
<file_sep path="hyperswitch/crates/euclid/src/frontend/ast/lowering.rs" crate="euclid" role="macro_def">
<|fim_prefix|>
<|meta_start|><|file|> hyperswitch/crates/euclid/src/frontend/ast/lowering.rs<|crate|> euclid macro=lower_enum roles=use_site,macro_def use=invoke item=fn pack=proc_macro_neighborhoods lang=rust<|meta_end|>
//! Analysis for the Lowering logic in ast
//!
//!Certain functions that can be used to perform the complete lowering of ast to dir.
//!This includes lowering of enums, numbers, strings as well as Comparison logics.
use std::str::FromStr;
use crate::{
<|fim_suffix|>
<|fim_middle|>
}
<file_sep path="hyperswitch/crates/euclid/src/frontend/ast/lowering.rs" crate="euclid" role="macro_def">
<|fim_prefix|>
//! Analysis for the Lowering logic in ast
//!
//!Certain functions that can be used to perform the complete lowering of ast to dir.
//!This includes lowering of enums, numbers, strings as well as Comparison logics.
use std::str::FromStr;
use crate::{
<|fim_suffix|>
<|fim_middle|>
}
| proc_macro_neighborhoods |
<file_sep path="hyperswitch/crates/euclid/src/frontend/ast/lowering.rs" crate="euclid" role="macro_def">
macro_rules! lower_enum {
($key:ident, $value:ident) => {
match $value {
ast::ValueType::EnumVariant(ev) => Ok(vec![dir::DirValue::$key(
dir_enums::$key::from_str(&ev).map_err(|_| AnalysisErrorType::InvalidVariant {
key: dir::DirKeyKind::$key.to_string(),
got: ev,
expected: dir_enums::$key::variants(),
})?,
)]),
ast::ValueType::EnumVariantArray(eva) => eva
.into_iter()
.map(|ev| {
Ok(dir::DirValue::$key(
dir_enums::$key::from_str(&ev).map_err(|_| {
AnalysisErrorType::InvalidVariant {
key: dir::DirKeyKind::$key.to_string(),
got: ev,
expected: dir_enums::$key::variants(),
}
})?,
))
})
.collect(),
_ => Err(AnalysisErrorType::InvalidType {
key: dir::DirKeyKind::$key.to_string(),
expected: DataType::EnumVariant,
got: $value.get_type(),
}),
}
};
}
<file_sep path="hyperswitch/crates/euclid/src/frontend/ast/lowering.rs" crate="euclid" role="macro_def">
macro_rules! lower_enum {
($key:ident, $value:ident) => {
match $value {
ast::ValueType::EnumVariant(ev) => Ok(vec![dir::DirValue::$key(
dir_enums::$key::from_str(&ev).map_err(|_| AnalysisErrorType::InvalidVariant {
key: dir::DirKeyKind::$key.to_string(),
got: ev,
expected: dir_enums::$key::variants(),
})?,
)]),
ast::ValueType::EnumVariantArray(eva) => eva
.into_iter()
.map(|ev| {
Ok(dir::DirValue::$key(
dir_enums::$key::from_str(&ev).map_err(|_| {
AnalysisErrorType::InvalidVariant {
key: dir::DirKeyKind::$key.to_string(),
got: ev,
expected: dir_enums::$key::variants(),
}
})?,
))
})
.collect(),
_ => Err(AnalysisErrorType::InvalidType {
key: dir::DirKeyKind::$key.to_string(),
expected: DataType::EnumVariant,
got: $value.get_type(),
}),
}
};
}
<file_sep path="hyperswitch/crates/euclid/src/frontend/ast/lowering.rs" crate="euclid" role="use_site">
<|fim_prefix|>
<|meta_start|><|file|> hyperswitch/crates/euclid/src/frontend/ast/lowering.rs<|crate|> euclid macro=lower_enum roles=macro_def,use_site use=invoke item=fn pack=proc_macro_neighborhoods lang=rust<|meta_end|>
fn lower_comparison_inner<O: EuclidDirFilter>(
comp: ast::Comparison,
) -> Result<Vec<dir::DirValue>, AnalysisErrorType> {
<|fim_suffix|>
<|fim_middle|>
}
<file_sep path="hyperswitch/crates/euclid/src/frontend/ast/lowering.rs" crate="euclid" role="use_site">
<|fim_prefix|>
fn lower_comparison_inner<O: EuclidDirFilter>(
comp: ast::Comparison,
) -> Result<Vec<dir::DirValue>, AnalysisErrorType> {
<|fim_suffix|>
<|fim_middle|>
}
| proc_macro_neighborhoods |
<file_sep path="hyperswitch/crates/euclid/src/frontend/ast/lowering.rs" crate="euclid" role="use_site">
dir::DirKeyKind::GiftCardType => lower_enum!(GiftCardType, value),
<file_sep path="hyperswitch/crates/euclid/src/frontend/ast/lowering.rs" crate="euclid" role="use_site">
dir::DirKeyKind::GiftCardType => lower_enum!(GiftCardType, value),
<file_sep path="hyperswitch/crates/euclid/src/frontend/ast/lowering.rs" crate="euclid" role="macro_def">
<|fim_prefix|>
<|meta_start|><|file|> hyperswitch/crates/euclid/src/frontend/ast/lowering.rs<|crate|> euclid macro=lower_enum roles=use_site,macro_def use=invoke item=fn pack=proc_macro_neighborhoods lang=rust<|meta_end|>
//! Analysis for the Lowering logic in ast
//!
//!Certain functions that can be used to perform the complete lowering of ast to dir.
//!This includes lowering of enums, numbers, strings as well as Comparison logics.
use std::str::FromStr;
use crate::{
<|fim_suffix|>
<|fim_middle|>
}
<file_sep path="hyperswitch/crates/euclid/src/frontend/ast/lowering.rs" crate="euclid" role="macro_def">
<|fim_prefix|>
//! Analysis for the Lowering logic in ast
//!
//!Certain functions that can be used to perform the complete lowering of ast to dir.
//!This includes lowering of enums, numbers, strings as well as Comparison logics.
use std::str::FromStr;
use crate::{
<|fim_suffix|>
<|fim_middle|>
}
| proc_macro_neighborhoods |
<file_sep path="hyperswitch/crates/euclid/src/frontend/ast/lowering.rs" crate="euclid" role="macro_def">
macro_rules! lower_enum {
($key:ident, $value:ident) => {
match $value {
ast::ValueType::EnumVariant(ev) => Ok(vec![dir::DirValue::$key(
dir_enums::$key::from_str(&ev).map_err(|_| AnalysisErrorType::InvalidVariant {
key: dir::DirKeyKind::$key.to_string(),
got: ev,
expected: dir_enums::$key::variants(),
})?,
)]),
ast::ValueType::EnumVariantArray(eva) => eva
.into_iter()
.map(|ev| {
Ok(dir::DirValue::$key(
dir_enums::$key::from_str(&ev).map_err(|_| {
AnalysisErrorType::InvalidVariant {
key: dir::DirKeyKind::$key.to_string(),
got: ev,
expected: dir_enums::$key::variants(),
}
})?,
))
})
.collect(),
_ => Err(AnalysisErrorType::InvalidType {
key: dir::DirKeyKind::$key.to_string(),
expected: DataType::EnumVariant,
got: $value.get_type(),
}),
}
};
}
<file_sep path="hyperswitch/crates/euclid/src/frontend/ast/lowering.rs" crate="euclid" role="macro_def">
macro_rules! lower_enum {
($key:ident, $value:ident) => {
match $value {
ast::ValueType::EnumVariant(ev) => Ok(vec![dir::DirValue::$key(
dir_enums::$key::from_str(&ev).map_err(|_| AnalysisErrorType::InvalidVariant {
key: dir::DirKeyKind::$key.to_string(),
got: ev,
expected: dir_enums::$key::variants(),
})?,
)]),
ast::ValueType::EnumVariantArray(eva) => eva
.into_iter()
.map(|ev| {
Ok(dir::DirValue::$key(
dir_enums::$key::from_str(&ev).map_err(|_| {
AnalysisErrorType::InvalidVariant {
key: dir::DirKeyKind::$key.to_string(),
got: ev,
expected: dir_enums::$key::variants(),
}
})?,
))
})
.collect(),
_ => Err(AnalysisErrorType::InvalidType {
key: dir::DirKeyKind::$key.to_string(),
expected: DataType::EnumVariant,
got: $value.get_type(),
}),
}
};
}
<file_sep path="hyperswitch/crates/euclid/src/frontend/ast/lowering.rs" crate="euclid" role="use_site">
<|fim_prefix|>
<|meta_start|><|file|> hyperswitch/crates/euclid/src/frontend/ast/lowering.rs<|crate|> euclid macro=lower_enum roles=macro_def,use_site use=invoke item=fn pack=proc_macro_neighborhoods lang=rust<|meta_end|>
fn lower_comparison_inner<O: EuclidDirFilter>(
comp: ast::Comparison,
) -> Result<Vec<dir::DirValue>, AnalysisErrorType> {
<|fim_suffix|>
<|fim_middle|>
}
<file_sep path="hyperswitch/crates/euclid/src/frontend/ast/lowering.rs" crate="euclid" role="use_site">
<|fim_prefix|>
fn lower_comparison_inner<O: EuclidDirFilter>(
comp: ast::Comparison,
) -> Result<Vec<dir::DirValue>, AnalysisErrorType> {
<|fim_suffix|>
<|fim_middle|>
}
| proc_macro_neighborhoods |
<file_sep path="hyperswitch/crates/euclid/src/frontend/ast/lowering.rs" crate="euclid" role="macro_def">
macro_rules! lower_enum {
($key:ident, $value:ident) => {
match $value {
ast::ValueType::EnumVariant(ev) => Ok(vec![dir::DirValue::$key(
dir_enums::$key::from_str(&ev).map_err(|_| AnalysisErrorType::InvalidVariant {
key: dir::DirKeyKind::$key.to_string(),
got: ev,
expected: dir_enums::$key::variants(),
})?,
)]),
ast::ValueType::EnumVariantArray(eva) => eva
.into_iter()
.map(|ev| {
Ok(dir::DirValue::$key(
dir_enums::$key::from_str(&ev).map_err(|_| {
AnalysisErrorType::InvalidVariant {
key: dir::DirKeyKind::$key.to_string(),
got: ev,
expected: dir_enums::$key::variants(),
}
})?,
))
})
.collect(),
_ => Err(AnalysisErrorType::InvalidType {
key: dir::DirKeyKind::$key.to_string(),
expected: DataType::EnumVariant,
got: $value.get_type(),
}),
}
};
}
<file_sep path="hyperswitch/crates/euclid/src/frontend/ast/lowering.rs" crate="euclid" role="macro_def">
macro_rules! lower_enum {
($key:ident, $value:ident) => {
match $value {
ast::ValueType::EnumVariant(ev) => Ok(vec![dir::DirValue::$key(
dir_enums::$key::from_str(&ev).map_err(|_| AnalysisErrorType::InvalidVariant {
key: dir::DirKeyKind::$key.to_string(),
got: ev,
expected: dir_enums::$key::variants(),
})?,
)]),
ast::ValueType::EnumVariantArray(eva) => eva
.into_iter()
.map(|ev| {
Ok(dir::DirValue::$key(
dir_enums::$key::from_str(&ev).map_err(|_| {
AnalysisErrorType::InvalidVariant {
key: dir::DirKeyKind::$key.to_string(),
got: ev,
expected: dir_enums::$key::variants(),
}
})?,
))
})
.collect(),
_ => Err(AnalysisErrorType::InvalidType {
key: dir::DirKeyKind::$key.to_string(),
expected: DataType::EnumVariant,
got: $value.get_type(),
}),
}
};
}
<file_sep path="hyperswitch/crates/euclid/src/frontend/ast/lowering.rs" crate="euclid" role="use_site">
<|fim_prefix|>
<|meta_start|><|file|> hyperswitch/crates/euclid/src/frontend/ast/lowering.rs<|crate|> euclid macro=lower_enum roles=macro_def,use_site use=invoke item=fn pack=proc_macro_neighborhoods lang=rust<|meta_end|>
fn lower_comparison_inner<O: EuclidDirFilter>(
comp: ast::Comparison,
) -> Result<Vec<dir::DirValue>, AnalysisErrorType> {
<|fim_suffix|>
<|fim_middle|>
}
<file_sep path="hyperswitch/crates/euclid/src/frontend/ast/lowering.rs" crate="euclid" role="use_site">
<|fim_prefix|>
fn lower_comparison_inner<O: EuclidDirFilter>(
comp: ast::Comparison,
) -> Result<Vec<dir::DirValue>, AnalysisErrorType> {
<|fim_suffix|>
<|fim_middle|>
}
| proc_macro_neighborhoods |
<file_sep path="hyperswitch/crates/router_env/src/metrics.rs" crate="router_env" role="macro_def">
macro_rules! metric_attributes {
($(($key:expr, $value:expr $(,)?)),+ $(,)?) => {
&[$($crate::opentelemetry::KeyValue::new($key, $value)),+]
};
}
<file_sep path="hyperswitch/crates/router_env/src/metrics.rs" crate="router_env" role="macro_def">
macro_rules! metric_attributes {
($(($key:expr, $value:expr $(,)?)),+ $(,)?) => {
&[$($crate::opentelemetry::KeyValue::new($key, $value)),+]
};
}
<file_sep path="hyperswitch/crates/router/src/utils.rs" crate="router" role="use_site">
<|fim_prefix|>
<|meta_start|><|file|> hyperswitch/crates/router_env/src/metrics.rs<|crate|> router macro=metric_attributes roles=macro_def,use_site use=invoke item=fn pack=proc_macro_neighborhoods lang=rust<|meta_end|>
pub fn add_apple_pay_payment_status_metrics(
payment_attempt_status: enums::AttemptStatus,
apple_pay_flow: Option<domain::ApplePayFlow>,
connector: Option<String>,
merchant_id: id_type::MerchantId,
) {
<|fim_suffix|>
<|fim_middle|>
}
<file_sep path="hyperswitch/crates/router/src/utils.rs" crate="router" role="use_site">
<|fim_prefix|>
pub fn add_apple_pay_payment_status_metrics(
payment_attempt_status: enums::AttemptStatus,
apple_pay_flow: Option<domain::ApplePayFlow>,
connector: Option<String>,
merchant_id: id_type::MerchantId,
) {
<|fim_suffix|>
<|fim_middle|>
}
| proc_macro_neighborhoods |
<file_sep path="hyperswitch/crates/router/src/utils.rs" crate="router" role="use_site">
router_env::metric_attributes!(
(
"connector",
connector.to_owned().unwrap_or("null".to_string()),
),
("merchant_id", merchant_id.clone()),
),
<file_sep path="hyperswitch/crates/router/src/utils.rs" crate="router" role="use_site">
router_env::metric_attributes!(
(
"connector",
connector.to_owned().unwrap_or("null".to_string()),
),
("merchant_id", merchant_id.clone()),
),
<file_sep path="hyperswitch/crates/router_env/src/metrics.rs" crate="router_env" role="macro_def">
<|fim_prefix|>
<|meta_start|><|file|> hyperswitch/crates/router_env/src/metrics.rs<|crate|> router macro=metric_attributes roles=use_site,macro_def use=invoke item=fn pack=proc_macro_neighborhoods lang=rust<|meta_end|>
//! Utilities to easily create opentelemetry contexts, meters and metrics.
/// Create a global [`Meter`][Meter] with the specified name and an optional description.
///
/// [Meter]: opentelemetry::metrics::Meter
#[macro_export]
macro_rules! global_meter {
<|fim_suffix|>
<|fim_middle|>
}
<file_sep path="hyperswitch/crates/router_env/src/metrics.rs" crate="router_env" role="macro_def">
<|fim_prefix|>
//! Utilities to easily create opentelemetry contexts, meters and metrics.
/// Create a global [`Meter`][Meter] with the specified name and an optional description.
///
/// [Meter]: opentelemetry::metrics::Meter
#[macro_export]
macro_rules! global_meter {
<|fim_suffix|>
<|fim_middle|>
}
| proc_macro_neighborhoods |
<file_sep path="hyperswitch/crates/router/src/utils.rs" crate="router" role="use_site">
router_env::metric_attributes!(
(
"connector",
connector.to_owned().unwrap_or("null".to_string()),
),
("merchant_id", merchant_id.clone()),
),
<file_sep path="hyperswitch/crates/router/src/utils.rs" crate="router" role="use_site">
router_env::metric_attributes!(
(
"connector",
connector.to_owned().unwrap_or("null".to_string()),
),
("merchant_id", merchant_id.clone()),
),
<file_sep path="hyperswitch/crates/router_env/src/metrics.rs" crate="router_env" role="macro_def">
<|fim_prefix|>
<|meta_start|><|file|> hyperswitch/crates/router_env/src/metrics.rs<|crate|> router macro=metric_attributes roles=use_site,macro_def use=invoke item=fn pack=proc_macro_neighborhoods lang=rust<|meta_end|>
//! Utilities to easily create opentelemetry contexts, meters and metrics.
/// Create a global [`Meter`][Meter] with the specified name and an optional description.
///
/// [Meter]: opentelemetry::metrics::Meter
#[macro_export]
macro_rules! global_meter {
<|fim_suffix|>
<|fim_middle|>
}
<file_sep path="hyperswitch/crates/router_env/src/metrics.rs" crate="router_env" role="macro_def">
<|fim_prefix|>
//! Utilities to easily create opentelemetry contexts, meters and metrics.
/// Create a global [`Meter`][Meter] with the specified name and an optional description.
///
/// [Meter]: opentelemetry::metrics::Meter
#[macro_export]
macro_rules! global_meter {
<|fim_suffix|>
<|fim_middle|>
}
| proc_macro_neighborhoods |
<file_sep path="hyperswitch/crates/router/src/core/routing/helpers.rs" crate="router" role="use_site">
router_env::metric_attributes!(
(
"tenant",
state.tenant.tenant_id.get_string_repr().to_owned(),
),
(
"merchant_profile_id",
format!(
"{}:{}",
payment_attempt.merchant_id.get_string_repr(),
payment_attempt.profile_id.get_string_repr()
),
),
(
"contract_based_routing_connector",
first_contract_based_connector.to_string(),
),
(
"contract_based_routing_connector_score",
connector_score.to_string(),
),
(
"current_payment_count_contract_based_routing_connector",
current_payment_cnt.to_string(),
),
("payment_connector", payment_connector.to_string()),
(
"currency",
payment_attempt
.currency
.map_or_else(|| "None".to_string(), |currency| currency.to_string()),
),
(
"payment_method",
payment_attempt.payment_method.map_or_else(
|| "None".to_string(),
|payment_method| payment_method.to_string(),
),
),
(
"payment_method_type",
payment_attempt.payment_method_type.map_or_else(
|| "None".to_string(),
|payment_method_type| payment_method_type.to_string(),
),
),
(
"capture_method",
payment_attempt.capture_method.map_or_else(
|| "None".to_string(),
|capture_method| capture_method.to_string(),
),
),
(
"authentication_type",
payment_attempt.authentication_type.map_or_else(
|| "None".to_string(),
|authentication_type| authentication_type.to_string(),
),
),
("payment_status", payment_attempt.status.to_string()),
),
<file_sep path="hyperswitch/crates/router/src/core/routing/helpers.rs" crate="router" role="use_site">
router_env::metric_attributes!(
(
"tenant",
state.tenant.tenant_id.get_string_repr().to_owned(),
),
(
"merchant_profile_id",
format!(
"{}:{}",
payment_attempt.merchant_id.get_string_repr(),
payment_attempt.profile_id.get_string_repr()
),
),
(
"contract_based_routing_connector",
first_contract_based_connector.to_string(),
),
(
"contract_based_routing_connector_score",
connector_score.to_string(),
),
(
"current_payment_count_contract_based_routing_connector",
current_payment_cnt.to_string(),
),
("payment_connector", payment_connector.to_string()),
(
"currency",
payment_attempt
.currency
.map_or_else(|| "None".to_string(), |currency| currency.to_string()),
),
(
"payment_method",
payment_attempt.payment_method.map_or_else(
|| "None".to_string(),
|payment_method| payment_method.to_string(),
),
),
(
"payment_method_type",
payment_attempt.payment_method_type.map_or_else(
|| "None".to_string(),
|payment_method_type| payment_method_type.to_string(),
),
),
(
"capture_method",
payment_attempt.capture_method.map_or_else(
|| "None".to_string(),
|capture_method| capture_method.to_string(),
),
),
(
"authentication_type",
payment_attempt.authentication_type.map_or_else(
|| "None".to_string(),
|authentication_type| authentication_type.to_string(),
),
),
("payment_status", payment_attempt.status.to_string()),
),
<file_sep path="hyperswitch/crates/router_env/src/metrics.rs" crate="router_env" role="macro_def">
<|fim_prefix|>
<|meta_start|><|file|> hyperswitch/crates/router_env/src/metrics.rs<|crate|> router macro=metric_attributes roles=use_site,macro_def use=invoke item=fn pack=proc_macro_neighborhoods lang=rust<|meta_end|>
//! Utilities to easily create opentelemetry contexts, meters and metrics.
/// Create a global [`Meter`][Meter] with the specified name and an optional description.
///
/// [Meter]: opentelemetry::metrics::Meter
#[macro_export]
macro_rules! global_meter {
<|fim_suffix|>
<|fim_middle|>
}
<file_sep path="hyperswitch/crates/router_env/src/metrics.rs" crate="router_env" role="macro_def">
<|fim_prefix|>
//! Utilities to easily create opentelemetry contexts, meters and metrics.
/// Create a global [`Meter`][Meter] with the specified name and an optional description.
///
/// [Meter]: opentelemetry::metrics::Meter
#[macro_export]
macro_rules! global_meter {
<|fim_suffix|>
<|fim_middle|>
}
| proc_macro_neighborhoods |
<file_sep path="hyperswitch/crates/router/src/utils.rs" crate="router" role="use_site">
router_env::metric_attributes!(
(
"connector",
connector.to_owned().unwrap_or("null".to_string()),
),
("merchant_id", merchant_id.clone()),
),
<file_sep path="hyperswitch/crates/router/src/utils.rs" crate="router" role="use_site">
router_env::metric_attributes!(
(
"connector",
connector.to_owned().unwrap_or("null".to_string()),
),
("merchant_id", merchant_id.clone()),
),
<file_sep path="hyperswitch/crates/router_env/src/metrics.rs" crate="router_env" role="macro_def">
<|fim_prefix|>
<|meta_start|><|file|> hyperswitch/crates/router_env/src/metrics.rs<|crate|> router macro=metric_attributes roles=use_site,macro_def use=invoke item=fn pack=proc_macro_neighborhoods lang=rust<|meta_end|>
//! Utilities to easily create opentelemetry contexts, meters and metrics.
/// Create a global [`Meter`][Meter] with the specified name and an optional description.
///
/// [Meter]: opentelemetry::metrics::Meter
#[macro_export]
macro_rules! global_meter {
<|fim_suffix|>
<|fim_middle|>
}
<file_sep path="hyperswitch/crates/router_env/src/metrics.rs" crate="router_env" role="macro_def">
<|fim_prefix|>
//! Utilities to easily create opentelemetry contexts, meters and metrics.
/// Create a global [`Meter`][Meter] with the specified name and an optional description.
///
/// [Meter]: opentelemetry::metrics::Meter
#[macro_export]
macro_rules! global_meter {
<|fim_suffix|>
<|fim_middle|>
}
| proc_macro_neighborhoods |
<file_sep path="hyperswitch/crates/router_env/src/metrics.rs" crate="router_env" role="macro_def">
macro_rules! metric_attributes {
($(($key:expr, $value:expr $(,)?)),+ $(,)?) => {
&[$($crate::opentelemetry::KeyValue::new($key, $value)),+]
};
}
<file_sep path="hyperswitch/crates/router_env/src/metrics.rs" crate="router_env" role="macro_def">
macro_rules! metric_attributes {
($(($key:expr, $value:expr $(,)?)),+ $(,)?) => {
&[$($crate::opentelemetry::KeyValue::new($key, $value)),+]
};
}
<file_sep path="hyperswitch/crates/router/src/core/routing/helpers.rs" crate="router" role="use_site">
<|fim_prefix|>
<|meta_start|><|file|> hyperswitch/crates/router_env/src/metrics.rs<|crate|> router macro=metric_attributes roles=macro_def,use_site use=invoke item=fn pack=proc_macro_neighborhoods lang=rust<|meta_end|>
pub async fn default_specific_dynamic_routing_setup(
state: &SessionState,
key_store: domain::MerchantKeyStore,
business_profile: domain::Profile,
feature_to_enable: routing_types::DynamicRoutingFeatures,
mut dynamic_routing_algo_ref: routing_types::DynamicRoutingAlgorithmRef,
dynamic_routing_type: routing_types::DynamicRoutingType,
) -> RouterResult<ApplicationResponse<routing_types::RoutingDictionaryRecord>> {
<|fim_suffix|>
<|fim_middle|>
}
<file_sep path="hyperswitch/crates/router/src/core/routing/helpers.rs" crate="router" role="use_site">
<|fim_prefix|>
pub async fn default_specific_dynamic_routing_setup(
state: &SessionState,
key_store: domain::MerchantKeyStore,
business_profile: domain::Profile,
feature_to_enable: routing_types::DynamicRoutingFeatures,
mut dynamic_routing_algo_ref: routing_types::DynamicRoutingAlgorithmRef,
dynamic_routing_type: routing_types::DynamicRoutingType,
) -> RouterResult<ApplicationResponse<routing_types::RoutingDictionaryRecord>> {
<|fim_suffix|>
<|fim_middle|>
}
| proc_macro_neighborhoods |
<file_sep path="hyperswitch/crates/router_env/src/metrics.rs" crate="router_env" role="macro_def">
macro_rules! metric_attributes {
($(($key:expr, $value:expr $(,)?)),+ $(,)?) => {
&[$($crate::opentelemetry::KeyValue::new($key, $value)),+]
};
}
<file_sep path="hyperswitch/crates/router_env/src/metrics.rs" crate="router_env" role="macro_def">
macro_rules! metric_attributes {
($(($key:expr, $value:expr $(,)?)),+ $(,)?) => {
&[$($crate::opentelemetry::KeyValue::new($key, $value)),+]
};
}
<file_sep path="hyperswitch/crates/router/src/utils.rs" crate="router" role="use_site">
<|fim_prefix|>
<|meta_start|><|file|> hyperswitch/crates/router_env/src/metrics.rs<|crate|> router macro=metric_attributes roles=macro_def,use_site use=invoke item=fn pack=proc_macro_neighborhoods lang=rust<|meta_end|>
pub fn add_apple_pay_payment_status_metrics(
payment_attempt_status: enums::AttemptStatus,
apple_pay_flow: Option<domain::ApplePayFlow>,
connector: Option<String>,
merchant_id: id_type::MerchantId,
) {
<|fim_suffix|>
<|fim_middle|>
}
<file_sep path="hyperswitch/crates/router/src/utils.rs" crate="router" role="use_site">
<|fim_prefix|>
pub fn add_apple_pay_payment_status_metrics(
payment_attempt_status: enums::AttemptStatus,
apple_pay_flow: Option<domain::ApplePayFlow>,
connector: Option<String>,
merchant_id: id_type::MerchantId,
) {
<|fim_suffix|>
<|fim_middle|>
}
| proc_macro_neighborhoods |
<file_sep path="hyperswitch/crates/router_env/src/metrics.rs" crate="router_env" role="macro_def">
macro_rules! metric_attributes {
($(($key:expr, $value:expr $(,)?)),+ $(,)?) => {
&[$($crate::opentelemetry::KeyValue::new($key, $value)),+]
};
}
<file_sep path="hyperswitch/crates/router_env/src/metrics.rs" crate="router_env" role="macro_def">
macro_rules! metric_attributes {
($(($key:expr, $value:expr $(,)?)),+ $(,)?) => {
&[$($crate::opentelemetry::KeyValue::new($key, $value)),+]
};
}
<file_sep path="hyperswitch/crates/router/src/utils.rs" crate="router" role="use_site">
<|fim_prefix|>
<|meta_start|><|file|> hyperswitch/crates/router_env/src/metrics.rs<|crate|> router macro=metric_attributes roles=macro_def,use_site use=invoke item=fn pack=proc_macro_neighborhoods lang=rust<|meta_end|>
pub fn add_apple_pay_payment_status_metrics(
payment_attempt_status: enums::AttemptStatus,
apple_pay_flow: Option<domain::ApplePayFlow>,
connector: Option<String>,
merchant_id: id_type::MerchantId,
) {
<|fim_suffix|>
<|fim_middle|>
}
<file_sep path="hyperswitch/crates/router/src/utils.rs" crate="router" role="use_site">
<|fim_prefix|>
pub fn add_apple_pay_payment_status_metrics(
payment_attempt_status: enums::AttemptStatus,
apple_pay_flow: Option<domain::ApplePayFlow>,
connector: Option<String>,
merchant_id: id_type::MerchantId,
) {
<|fim_suffix|>
<|fim_middle|>
}
| proc_macro_neighborhoods |
<file_sep path="hyperswitch/crates/router_env/src/metrics.rs" crate="router_env" role="macro_def">
macro_rules! metric_attributes {
($(($key:expr, $value:expr $(,)?)),+ $(,)?) => {
&[$($crate::opentelemetry::KeyValue::new($key, $value)),+]
};
}
<file_sep path="hyperswitch/crates/router_env/src/metrics.rs" crate="router_env" role="macro_def">
macro_rules! metric_attributes {
($(($key:expr, $value:expr $(,)?)),+ $(,)?) => {
&[$($crate::opentelemetry::KeyValue::new($key, $value)),+]
};
}
<file_sep path="hyperswitch/crates/router/src/utils.rs" crate="router" role="use_site">
<|fim_prefix|>
<|meta_start|><|file|> hyperswitch/crates/router_env/src/metrics.rs<|crate|> router macro=metric_attributes roles=macro_def,use_site use=invoke item=fn pack=proc_macro_neighborhoods lang=rust<|meta_end|>
pub fn add_apple_pay_payment_status_metrics(
payment_attempt_status: enums::AttemptStatus,
apple_pay_flow: Option<domain::ApplePayFlow>,
connector: Option<String>,
merchant_id: id_type::MerchantId,
) {
<|fim_suffix|>
<|fim_middle|>
}
<file_sep path="hyperswitch/crates/router/src/utils.rs" crate="router" role="use_site">
<|fim_prefix|>
pub fn add_apple_pay_payment_status_metrics(
payment_attempt_status: enums::AttemptStatus,
apple_pay_flow: Option<domain::ApplePayFlow>,
connector: Option<String>,
merchant_id: id_type::MerchantId,
) {
<|fim_suffix|>
<|fim_middle|>
}
| proc_macro_neighborhoods |
<file_sep path="hyperswitch/crates/router_env/src/metrics.rs" crate="router_env" role="macro_def">
macro_rules! metric_attributes {
($(($key:expr, $value:expr $(,)?)),+ $(,)?) => {
&[$($crate::opentelemetry::KeyValue::new($key, $value)),+]
};
}
<file_sep path="hyperswitch/crates/router_env/src/metrics.rs" crate="router_env" role="macro_def">
macro_rules! metric_attributes {
($(($key:expr, $value:expr $(,)?)),+ $(,)?) => {
&[$($crate::opentelemetry::KeyValue::new($key, $value)),+]
};
}
<file_sep path="hyperswitch/crates/router/src/core/routing/helpers.rs" crate="router" role="use_site">
<|fim_prefix|>
<|meta_start|><|file|> hyperswitch/crates/router_env/src/metrics.rs<|crate|> router macro=metric_attributes roles=macro_def,use_site use=invoke item=fn pack=proc_macro_neighborhoods lang=rust<|meta_end|>
pub async fn default_specific_dynamic_routing_setup(
state: &SessionState,
key_store: domain::MerchantKeyStore,
business_profile: domain::Profile,
feature_to_enable: routing_types::DynamicRoutingFeatures,
mut dynamic_routing_algo_ref: routing_types::DynamicRoutingAlgorithmRef,
dynamic_routing_type: routing_types::DynamicRoutingType,
) -> RouterResult<ApplicationResponse<routing_types::RoutingDictionaryRecord>> {
<|fim_suffix|>
<|fim_middle|>
}
<file_sep path="hyperswitch/crates/router/src/core/routing/helpers.rs" crate="router" role="use_site">
<|fim_prefix|>
pub async fn default_specific_dynamic_routing_setup(
state: &SessionState,
key_store: domain::MerchantKeyStore,
business_profile: domain::Profile,
feature_to_enable: routing_types::DynamicRoutingFeatures,
mut dynamic_routing_algo_ref: routing_types::DynamicRoutingAlgorithmRef,
dynamic_routing_type: routing_types::DynamicRoutingType,
) -> RouterResult<ApplicationResponse<routing_types::RoutingDictionaryRecord>> {
<|fim_suffix|>
<|fim_middle|>
}
| proc_macro_neighborhoods |
<file_sep path="hyperswitch/crates/router_env/src/metrics.rs" crate="router_env" role="macro_def">
macro_rules! metric_attributes {
($(($key:expr, $value:expr $(,)?)),+ $(,)?) => {
&[$($crate::opentelemetry::KeyValue::new($key, $value)),+]
};
}
<file_sep path="hyperswitch/crates/router_env/src/metrics.rs" crate="router_env" role="macro_def">
macro_rules! metric_attributes {
($(($key:expr, $value:expr $(,)?)),+ $(,)?) => {
&[$($crate::opentelemetry::KeyValue::new($key, $value)),+]
};
}
<file_sep path="hyperswitch/crates/router/src/utils.rs" crate="router" role="use_site">
<|fim_prefix|>
<|meta_start|><|file|> hyperswitch/crates/router_env/src/metrics.rs<|crate|> router macro=metric_attributes roles=macro_def,use_site use=invoke item=fn pack=proc_macro_neighborhoods lang=rust<|meta_end|>
pub fn add_apple_pay_payment_status_metrics(
payment_attempt_status: enums::AttemptStatus,
apple_pay_flow: Option<domain::ApplePayFlow>,
connector: Option<String>,
merchant_id: id_type::MerchantId,
) {
<|fim_suffix|>
<|fim_middle|>
}
<file_sep path="hyperswitch/crates/router/src/utils.rs" crate="router" role="use_site">
<|fim_prefix|>
pub fn add_apple_pay_payment_status_metrics(
payment_attempt_status: enums::AttemptStatus,
apple_pay_flow: Option<domain::ApplePayFlow>,
connector: Option<String>,
merchant_id: id_type::MerchantId,
) {
<|fim_suffix|>
<|fim_middle|>
}
| proc_macro_neighborhoods |
<file_sep path="hyperswitch/crates/router/src/utils.rs" crate="router" role="use_site">
router_env::metric_attributes!(
(
"connector",
connector.to_owned().unwrap_or("null".to_string()),
),
("merchant_id", merchant_id.clone()),
),
<file_sep path="hyperswitch/crates/router/src/utils.rs" crate="router" role="use_site">
router_env::metric_attributes!(
(
"connector",
connector.to_owned().unwrap_or("null".to_string()),
),
("merchant_id", merchant_id.clone()),
),
<file_sep path="hyperswitch/crates/router_env/src/metrics.rs" crate="router_env" role="macro_def">
<|fim_prefix|>
<|meta_start|><|file|> hyperswitch/crates/router_env/src/metrics.rs<|crate|> router macro=metric_attributes roles=use_site,macro_def use=invoke item=fn pack=proc_macro_neighborhoods lang=rust<|meta_end|>
//! Utilities to easily create opentelemetry contexts, meters and metrics.
/// Create a global [`Meter`][Meter] with the specified name and an optional description.
///
/// [Meter]: opentelemetry::metrics::Meter
#[macro_export]
macro_rules! global_meter {
<|fim_suffix|>
<|fim_middle|>
}
<file_sep path="hyperswitch/crates/router_env/src/metrics.rs" crate="router_env" role="macro_def">
<|fim_prefix|>
//! Utilities to easily create opentelemetry contexts, meters and metrics.
/// Create a global [`Meter`][Meter] with the specified name and an optional description.
///
/// [Meter]: opentelemetry::metrics::Meter
#[macro_export]
macro_rules! global_meter {
<|fim_suffix|>
<|fim_middle|>
}
| proc_macro_neighborhoods |
<file_sep path="hyperswitch/crates/router/src/utils.rs" crate="router" role="use_site">
router_env::metric_attributes!(
(
"connector",
connector.to_owned().unwrap_or("null".to_string()),
),
("merchant_id", merchant_id.clone()),
),
<file_sep path="hyperswitch/crates/router/src/utils.rs" crate="router" role="use_site">
router_env::metric_attributes!(
(
"connector",
connector.to_owned().unwrap_or("null".to_string()),
),
("merchant_id", merchant_id.clone()),
),
<file_sep path="hyperswitch/crates/router_env/src/metrics.rs" crate="router_env" role="macro_def">
<|fim_prefix|>
<|meta_start|><|file|> hyperswitch/crates/router_env/src/metrics.rs<|crate|> router macro=metric_attributes roles=use_site,macro_def use=invoke item=fn pack=proc_macro_neighborhoods lang=rust<|meta_end|>
//! Utilities to easily create opentelemetry contexts, meters and metrics.
/// Create a global [`Meter`][Meter] with the specified name and an optional description.
///
/// [Meter]: opentelemetry::metrics::Meter
#[macro_export]
macro_rules! global_meter {
<|fim_suffix|>
<|fim_middle|>
}
<file_sep path="hyperswitch/crates/router_env/src/metrics.rs" crate="router_env" role="macro_def">
<|fim_prefix|>
//! Utilities to easily create opentelemetry contexts, meters and metrics.
/// Create a global [`Meter`][Meter] with the specified name and an optional description.
///
/// [Meter]: opentelemetry::metrics::Meter
#[macro_export]
macro_rules! global_meter {
<|fim_suffix|>
<|fim_middle|>
}
| proc_macro_neighborhoods |
<file_sep path="hyperswitch/crates/router/src/utils.rs" crate="router" role="use_site">
router_env::metric_attributes!(
(
"connector",
connector.to_owned().unwrap_or("null".to_string()),
),
("merchant_id", merchant_id.clone()),
),
<file_sep path="hyperswitch/crates/router/src/utils.rs" crate="router" role="use_site">
router_env::metric_attributes!(
(
"connector",
connector.to_owned().unwrap_or("null".to_string()),
),
("merchant_id", merchant_id.clone()),
),
<file_sep path="hyperswitch/crates/router_env/src/metrics.rs" crate="router_env" role="macro_def">
<|fim_prefix|>
<|meta_start|><|file|> hyperswitch/crates/router_env/src/metrics.rs<|crate|> router macro=metric_attributes roles=use_site,macro_def use=invoke item=fn pack=proc_macro_neighborhoods lang=rust<|meta_end|>
//! Utilities to easily create opentelemetry contexts, meters and metrics.
/// Create a global [`Meter`][Meter] with the specified name and an optional description.
///
/// [Meter]: opentelemetry::metrics::Meter
#[macro_export]
macro_rules! global_meter {
<|fim_suffix|>
<|fim_middle|>
}
<file_sep path="hyperswitch/crates/router_env/src/metrics.rs" crate="router_env" role="macro_def">
<|fim_prefix|>
//! Utilities to easily create opentelemetry contexts, meters and metrics.
/// Create a global [`Meter`][Meter] with the specified name and an optional description.
///
/// [Meter]: opentelemetry::metrics::Meter
#[macro_export]
macro_rules! global_meter {
<|fim_suffix|>
<|fim_middle|>
}
| proc_macro_neighborhoods |
<file_sep path="hyperswitch/crates/storage_impl/src/metrics.rs" crate="storage_impl" role="use_site">
gauge_metric!(IN_MEMORY_CACHE_ENTRY_COUNT, GLOBAL_METER);
<file_sep path="hyperswitch/crates/storage_impl/src/metrics.rs" crate="storage_impl" role="use_site">
gauge_metric!(IN_MEMORY_CACHE_ENTRY_COUNT, GLOBAL_METER);
<file_sep path="hyperswitch/crates/router_env/src/metrics.rs" crate="router_env" role="macro_def">
<|fim_prefix|>
<|meta_start|><|file|> hyperswitch/crates/router_env/src/metrics.rs<|crate|> storage_impl macro=gauge_metric roles=use_site,macro_def use=invoke item=file pack=proc_macro_neighborhoods lang=rust<|meta_end|>
//! Utilities to easily create opentelemetry contexts, meters and metrics.
/// Create a global [`Meter`][Meter] with the specified name and an optional description.
///
/// [Meter]: opentelemetry::metrics::Meter
#[macro_export]
macro_rules! global_meter {
<|fim_suffix|>
<|fim_middle|>
}
<file_sep path="hyperswitch/crates/router_env/src/metrics.rs" crate="router_env" role="macro_def">
<|fim_prefix|>
//! Utilities to easily create opentelemetry contexts, meters and metrics.
/// Create a global [`Meter`][Meter] with the specified name and an optional description.
///
/// [Meter]: opentelemetry::metrics::Meter
#[macro_export]
macro_rules! global_meter {
<|fim_suffix|>
<|fim_middle|>
}
| proc_macro_neighborhoods |
<file_sep path="hyperswitch/crates/router_env/src/metrics.rs" crate="router_env" role="macro_def">
macro_rules! gauge_metric {
($name:ident, $meter:ident) => {
pub(crate) static $name: once_cell::sync::Lazy<$crate::opentelemetry::metrics::Gauge<u64>> =
once_cell::sync::Lazy::new(|| $meter.u64_gauge(stringify!($name)).build());
};
($name:ident, $meter:ident, description:literal) => {
#[doc = $description]
pub(crate) static $name: once_cell::sync::Lazy<$crate::opentelemetry::metrics::Gauge<u64>> =
once_cell::sync::Lazy::new(|| {
$meter
.u64_gauge(stringify!($name))
.with_description($description)
.build()
});
};
}
<file_sep path="hyperswitch/crates/router_env/src/metrics.rs" crate="router_env" role="macro_def">
macro_rules! gauge_metric {
($name:ident, $meter:ident) => {
pub(crate) static $name: once_cell::sync::Lazy<$crate::opentelemetry::metrics::Gauge<u64>> =
once_cell::sync::Lazy::new(|| $meter.u64_gauge(stringify!($name)).build());
};
($name:ident, $meter:ident, description:literal) => {
#[doc = $description]
pub(crate) static $name: once_cell::sync::Lazy<$crate::opentelemetry::metrics::Gauge<u64>> =
once_cell::sync::Lazy::new(|| {
$meter
.u64_gauge(stringify!($name))
.with_description($description)
.build()
});
};
}
<file_sep path="hyperswitch/crates/storage_impl/src/metrics.rs" crate="storage_impl" role="use_site">
<|fim_prefix|>
<|meta_start|><|file|> hyperswitch/crates/router_env/src/metrics.rs<|crate|> storage_impl macro=gauge_metric roles=macro_def,use_site use=invoke item=file pack=proc_macro_neighborhoods lang=rust<|meta_end|>
use router_env::{
<|fim_suffix|>
<|fim_middle|>
};
global_meter!(GLOBAL_METER, "ROUTER_API");
counter_metric!(KV_MISS, GLOBAL_METER); // No. of KV misses
// Metrics for KV
counter_metric!(KV_OPERATION_SUCCESSFUL, GLOBAL_METER);
counter_metric!(KV_OPERATION_FAILED, GLOBAL_METER);
counter_metric!(KV_PUSHED_TO_DRAINER, GLOBAL_METER);
counter_metric!(KV_FAILED_TO_PUSH_TO_DRAINER, GLOBAL_METER);
counter_metric!(KV_SOFT_KILL_ACTIVE_UPDATE, GLOBAL_METER);
// Metrics for In-memory cache
gauge_metric!(IN_MEMORY_CACHE_ENTRY_COUNT, GLOBAL_METER);
counter_metric!(IN_MEMORY_CACHE_HIT, GLOBAL_METER);
counter_metric!(IN_MEMORY_CACHE_MISS, GLOBAL_METER);
counter_metric!(IN_MEMORY_CACHE_EVICTION_COUNT, GLOBAL_METER);
<file_sep path="hyperswitch/crates/storage_impl/src/metrics.rs" crate="storage_impl" role="use_site">
<|fim_prefix|>
use router_env::{
<|fim_suffix|>
<|fim_middle|>
};
global_meter!(GLOBAL_METER, "ROUTER_API");
counter_metric!(KV_MISS, GLOBAL_METER); // No. of KV misses
// Metrics for KV
counter_metric!(KV_OPERATION_SUCCESSFUL, GLOBAL_METER);
counter_metric!(KV_OPERATION_FAILED, GLOBAL_METER);
counter_metric!(KV_PUSHED_TO_DRAINER, GLOBAL_METER);
counter_metric!(KV_FAILED_TO_PUSH_TO_DRAINER, GLOBAL_METER);
counter_metric!(KV_SOFT_KILL_ACTIVE_UPDATE, GLOBAL_METER);
// Metrics for In-memory cache
gauge_metric!(IN_MEMORY_CACHE_ENTRY_COUNT, GLOBAL_METER);
counter_metric!(IN_MEMORY_CACHE_HIT, GLOBAL_METER);
counter_metric!(IN_MEMORY_CACHE_MISS, GLOBAL_METER);
counter_metric!(IN_MEMORY_CACHE_EVICTION_COUNT, GLOBAL_METER);
| proc_macro_neighborhoods |
<file_sep path="hyperswitch/crates/drainer/src/metrics.rs" crate="drainer" role="use_site">
histogram_metric_u64!(DRAINER_DELAY_SECONDS, DRAINER_METER); // Time in (s) seconds
<file_sep path="hyperswitch/crates/drainer/src/metrics.rs" crate="drainer" role="use_site">
histogram_metric_u64!(DRAINER_DELAY_SECONDS, DRAINER_METER); // Time in (s) seconds
<file_sep path="hyperswitch/crates/router_env/src/metrics.rs" crate="router_env" role="macro_def">
<|fim_prefix|>
<|meta_start|><|file|> hyperswitch/crates/router_env/src/metrics.rs<|crate|> drainer macro=histogram_metric_u64 roles=use_site,macro_def use=invoke item=file pack=proc_macro_neighborhoods lang=rust<|meta_end|>
//! Utilities to easily create opentelemetry contexts, meters and metrics.
/// Create a global [`Meter`][Meter] with the specified name and an optional description.
///
/// [Meter]: opentelemetry::metrics::Meter
#[macro_export]
macro_rules! global_meter {
<|fim_suffix|>
<|fim_middle|>
}
<file_sep path="hyperswitch/crates/router_env/src/metrics.rs" crate="router_env" role="macro_def">
<|fim_prefix|>
//! Utilities to easily create opentelemetry contexts, meters and metrics.
/// Create a global [`Meter`][Meter] with the specified name and an optional description.
///
/// [Meter]: opentelemetry::metrics::Meter
#[macro_export]
macro_rules! global_meter {
<|fim_suffix|>
<|fim_middle|>
}
| proc_macro_neighborhoods |
<file_sep path="hyperswitch/crates/router_env/src/metrics.rs" crate="router_env" role="macro_def">
macro_rules! histogram_metric_u64 {
($name:ident, $meter:ident) => {
pub(crate) static $name: once_cell::sync::Lazy<
$crate::opentelemetry::metrics::Histogram<u64>,
> = once_cell::sync::Lazy::new(|| {
$meter
.u64_histogram(stringify!($name))
.with_boundaries($crate::metrics::f64_histogram_buckets())
.build()
});
};
($name:ident, $meter:ident, $description:literal) => {
#[doc = $description]
pub(crate) static $name: once_cell::sync::Lazy<
$crate::opentelemetry::metrics::Histogram<u64>,
> = once_cell::sync::Lazy::new(|| {
$meter
.u64_histogram(stringify!($name))
.with_description($description)
.with_boundaries($crate::metrics::f64_histogram_buckets())
.build()
});
};
}
<file_sep path="hyperswitch/crates/router_env/src/metrics.rs" crate="router_env" role="macro_def">
macro_rules! histogram_metric_u64 {
($name:ident, $meter:ident) => {
pub(crate) static $name: once_cell::sync::Lazy<
$crate::opentelemetry::metrics::Histogram<u64>,
> = once_cell::sync::Lazy::new(|| {
$meter
.u64_histogram(stringify!($name))
.with_boundaries($crate::metrics::f64_histogram_buckets())
.build()
});
};
($name:ident, $meter:ident, $description:literal) => {
#[doc = $description]
pub(crate) static $name: once_cell::sync::Lazy<
$crate::opentelemetry::metrics::Histogram<u64>,
> = once_cell::sync::Lazy::new(|| {
$meter
.u64_histogram(stringify!($name))
.with_description($description)
.with_boundaries($crate::metrics::f64_histogram_buckets())
.build()
});
};
}
<file_sep path="hyperswitch/crates/drainer/src/metrics.rs" crate="drainer" role="use_site">
<|fim_prefix|>
<|meta_start|><|file|> hyperswitch/crates/router_env/src/metrics.rs<|crate|> drainer macro=histogram_metric_u64 roles=macro_def,use_site use=invoke item=file pack=proc_macro_neighborhoods lang=rust<|meta_end|>
use router_env::{
<|fim_suffix|>
<|fim_middle|>
};
global_meter!(DRAINER_METER, "DRAINER");
counter_metric!(JOBS_PICKED_PER_STREAM, DRAINER_METER);
counter_metric!(CYCLES_COMPLETED_SUCCESSFULLY, DRAINER_METER);
counter_metric!(CYCLES_COMPLETED_UNSUCCESSFULLY, DRAINER_METER);
counter_metric!(ERRORS_WHILE_QUERY_EXECUTION, DRAINER_METER);
counter_metric!(SUCCESSFUL_QUERY_EXECUTION, DRAINER_METER);
counter_metric!(SHUTDOWN_SIGNAL_RECEIVED, DRAINER_METER);
counter_metric!(SUCCESSFUL_SHUTDOWN, DRAINER_METER);
counter_metric!(STREAM_EMPTY, DRAINER_METER);
counter_metric!(STREAM_PARSE_FAIL, DRAINER_METER);
counter_metric!(DRAINER_HEALTH, DRAINER_METER);
histogram_metric_f64!(QUERY_EXECUTION_TIME, DRAINER_METER); // Time in (ms) milliseconds
histogram_metric_f64!(REDIS_STREAM_READ_TIME, DRAINER_METER); // Time in (ms) milliseconds
histogram_metric_f64!(REDIS_STREAM_TRIM_TIME, DRAINER_METER); // Time in (ms) milliseconds
histogram_metric_f64!(CLEANUP_TIME, DRAINER_METER); // Time in (ms) milliseconds
histogram_metric_u64!(DRAINER_DELAY_SECONDS, DRAINER_METER); // Time in (s) seconds
<file_sep path="hyperswitch/crates/drainer/src/metrics.rs" crate="drainer" role="use_site">
<|fim_prefix|>
use router_env::{
<|fim_suffix|>
<|fim_middle|>
};
global_meter!(DRAINER_METER, "DRAINER");
counter_metric!(JOBS_PICKED_PER_STREAM, DRAINER_METER);
counter_metric!(CYCLES_COMPLETED_SUCCESSFULLY, DRAINER_METER);
counter_metric!(CYCLES_COMPLETED_UNSUCCESSFULLY, DRAINER_METER);
counter_metric!(ERRORS_WHILE_QUERY_EXECUTION, DRAINER_METER);
counter_metric!(SUCCESSFUL_QUERY_EXECUTION, DRAINER_METER);
counter_metric!(SHUTDOWN_SIGNAL_RECEIVED, DRAINER_METER);
counter_metric!(SUCCESSFUL_SHUTDOWN, DRAINER_METER);
counter_metric!(STREAM_EMPTY, DRAINER_METER);
counter_metric!(STREAM_PARSE_FAIL, DRAINER_METER);
counter_metric!(DRAINER_HEALTH, DRAINER_METER);
histogram_metric_f64!(QUERY_EXECUTION_TIME, DRAINER_METER); // Time in (ms) milliseconds
histogram_metric_f64!(REDIS_STREAM_READ_TIME, DRAINER_METER); // Time in (ms) milliseconds
histogram_metric_f64!(REDIS_STREAM_TRIM_TIME, DRAINER_METER); // Time in (ms) milliseconds
histogram_metric_f64!(CLEANUP_TIME, DRAINER_METER); // Time in (ms) milliseconds
histogram_metric_u64!(DRAINER_DELAY_SECONDS, DRAINER_METER); // Time in (s) seconds
| proc_macro_neighborhoods |
<file_sep path="hyperswitch/crates/router_env/src/metrics.rs" crate="router_env" role="macro_def">
macro_rules! histogram_metric_u64 {
($name:ident, $meter:ident) => {
pub(crate) static $name: once_cell::sync::Lazy<
$crate::opentelemetry::metrics::Histogram<u64>,
> = once_cell::sync::Lazy::new(|| {
$meter
.u64_histogram(stringify!($name))
.with_boundaries($crate::metrics::f64_histogram_buckets())
.build()
});
};
($name:ident, $meter:ident, $description:literal) => {
#[doc = $description]
pub(crate) static $name: once_cell::sync::Lazy<
$crate::opentelemetry::metrics::Histogram<u64>,
> = once_cell::sync::Lazy::new(|| {
$meter
.u64_histogram(stringify!($name))
.with_description($description)
.with_boundaries($crate::metrics::f64_histogram_buckets())
.build()
});
};
}
<file_sep path="hyperswitch/crates/router_env/src/metrics.rs" crate="router_env" role="macro_def">
macro_rules! histogram_metric_u64 {
($name:ident, $meter:ident) => {
pub(crate) static $name: once_cell::sync::Lazy<
$crate::opentelemetry::metrics::Histogram<u64>,
> = once_cell::sync::Lazy::new(|| {
$meter
.u64_histogram(stringify!($name))
.with_boundaries($crate::metrics::f64_histogram_buckets())
.build()
});
};
($name:ident, $meter:ident, $description:literal) => {
#[doc = $description]
pub(crate) static $name: once_cell::sync::Lazy<
$crate::opentelemetry::metrics::Histogram<u64>,
> = once_cell::sync::Lazy::new(|| {
$meter
.u64_histogram(stringify!($name))
.with_description($description)
.with_boundaries($crate::metrics::f64_histogram_buckets())
.build()
});
};
}
<file_sep path="hyperswitch/crates/analytics/src/metrics.rs" crate="analytics" role="use_site">
<|fim_prefix|>
<|meta_start|><|file|> hyperswitch/crates/router_env/src/metrics.rs<|crate|> analytics macro=histogram_metric_u64 roles=macro_def,use_site use=invoke item=file pack=proc_macro_neighborhoods lang=rust<|meta_end|>
use router_env::{
<|fim_suffix|>
<|fim_middle|>
};
global_meter!(GLOBAL_METER, "ROUTER_API");
histogram_metric_f64!(METRIC_FETCH_TIME, GLOBAL_METER);
histogram_metric_u64!(BUCKETS_FETCHED, GLOBAL_METER);
pub mod request;
<file_sep path="hyperswitch/crates/analytics/src/metrics.rs" crate="analytics" role="use_site">
<|fim_prefix|>
use router_env::{
<|fim_suffix|>
<|fim_middle|>
};
global_meter!(GLOBAL_METER, "ROUTER_API");
histogram_metric_f64!(METRIC_FETCH_TIME, GLOBAL_METER);
histogram_metric_u64!(BUCKETS_FETCHED, GLOBAL_METER);
pub mod request;
| proc_macro_neighborhoods |
<file_sep path="hyperswitch/crates/router_env/src/metrics.rs" crate="router_env" role="macro_def">
macro_rules! histogram_metric_f64 {
($name:ident, $meter:ident) => {
pub(crate) static $name: once_cell::sync::Lazy<
$crate::opentelemetry::metrics::Histogram<f64>,
> = once_cell::sync::Lazy::new(|| {
$meter
.f64_histogram(stringify!($name))
.with_boundaries($crate::metrics::f64_histogram_buckets())
.build()
});
};
($name:ident, $meter:ident, $description:literal) => {
#[doc = $description]
pub(crate) static $name: once_cell::sync::Lazy<
$crate::opentelemetry::metrics::Histogram<f64>,
> = once_cell::sync::Lazy::new(|| {
$meter
.f64_histogram(stringify!($name))
.with_description($description)
.with_boundaries($crate::metrics::f64_histogram_buckets())
.build()
});
};
}
<file_sep path="hyperswitch/crates/router_env/src/metrics.rs" crate="router_env" role="macro_def">
macro_rules! histogram_metric_f64 {
($name:ident, $meter:ident) => {
pub(crate) static $name: once_cell::sync::Lazy<
$crate::opentelemetry::metrics::Histogram<f64>,
> = once_cell::sync::Lazy::new(|| {
$meter
.f64_histogram(stringify!($name))
.with_boundaries($crate::metrics::f64_histogram_buckets())
.build()
});
};
($name:ident, $meter:ident, $description:literal) => {
#[doc = $description]
pub(crate) static $name: once_cell::sync::Lazy<
$crate::opentelemetry::metrics::Histogram<f64>,
> = once_cell::sync::Lazy::new(|| {
$meter
.f64_histogram(stringify!($name))
.with_description($description)
.with_boundaries($crate::metrics::f64_histogram_buckets())
.build()
});
};
}
<file_sep path="hyperswitch/crates/router/src/routes/metrics.rs" crate="router" role="use_site">
<|fim_prefix|>
<|meta_start|><|file|> hyperswitch/crates/router_env/src/metrics.rs<|crate|> router macro=histogram_metric_f64 roles=macro_def,use_site use=invoke item=file pack=proc_macro_neighborhoods lang=rust<|meta_end|>
pub mod bg_metrics_collector;
pub mod request;
pub mod utils;
use router_env::{
<|fim_suffix|>
<|fim_middle|>
};
global_meter!(GLOBAL_METER, "ROUTER_API");
counter_metric!(HEALTH_METRIC, GLOBAL_METER); // No. of health API hits
counter_metric!(KV_MISS, GLOBAL_METER); // No. of KV misses
// API Level Metrics
counter_metric!(REQUESTS_RECEIVED, GLOBAL_METER);
counter_metric!(REQUEST_STATUS, GLOBAL_METER);
histogram_metric_f64!(REQUEST_TIME, GLOBAL_METER);
histogram_metric_f64!(EXTERNAL_REQUEST_TIME, GLOBAL_METER);
// Operation Level Metrics
counter_metric!(PAYMENT_OPS_COUNT, GLOBAL_METER);
counter_metric!(PAYMENT_COUNT, GLOBAL_METER);
counter_metric!(SUCCESSFUL_PAYMENT, GLOBAL_METER);
//TODO: This can be removed, added for payment list debugging
histogram_metric_f64!(PAYMENT_LIST_LATENCY, GLOBAL_METER);
counter_metric!(REFUND_COUNT, GLOBAL_METER);
counter_metric!(SUCCESSFUL_REFUND, GLOBAL_METER);
counter_metric!(PAYMENT_CANCEL_COUNT, GLOBAL_METER);
counter_metric!(SUCCESSFUL_CANCEL, GLOBAL_METER);
counter_metric!(MANDATE_COUNT, GLOBAL_METER);
counter_metric!(SUBSEQUENT_MANDATE_PAYMENT, GLOBAL_METER);
// Manual retry metrics
counter_metric!(MANUAL_RETRY_REQUEST_COUNT, GLOBAL_METER);
counter_metric!(MANUAL_RETRY_COUNT, GLOBAL_METER);
counter_metric!(MANUAL_RETRY_VALIDATION_FAILED, GLOBAL_METER);
counter_metric!(STORED_TO_LOCKER, GLOBAL_METER);
counter_metric!(GET_FROM_LOCKER, GLOBAL_METER);
counter_metric!(DELETE_FROM_LOCKER, GLOBAL_METER);
counter_metric!(CREATED_TOKENIZED_CARD, GLOBAL_METER);
counter_metric!(DELETED_TOKENIZED_CARD, GLOBAL_METER);
counter_metric!(GET_TOKENIZED_CARD, GLOBAL_METER);
counter_metric!(TOKENIZED_DATA_COUNT, GLOBAL_METER); // Tokenized data added
counter_metric!(RETRIED_DELETE_DATA_COUNT, GLOBAL_METER); // Tokenized data retried
counter_metric!(CUSTOMER_CREATED, GLOBAL_METER);
counter_metric!(CUSTOMER_REDACTED, GLOBAL_METER);
counter_metric!(API_KEY_CREATED, GLOBAL_METER);
counter_metric!(API_KEY_REVOKED, GLOBAL_METER);
counter_metric!(MCA_CREATE, GLOBAL_METER);
// Flow Specific Metrics
histogram_metric_f64!(CONNECTOR_REQUEST_TIME, GLOBAL_METER);
counter_metric!(SESSION_TOKEN_CREATED, GLOBAL_METER);
counter_metric!(CONNECTOR_CALL_COUNT, GLOBAL_METER); // Attributes needed
counter_metric!(THREE_DS_PAYMENT_COUNT, GLOBAL_METER);
counter_metric!(THREE_DS_DOWNGRADE_COUNT, GLOBAL_METER);
counter_metric!(RESPONSE_DESERIALIZATION_FAILURE, GLOBAL_METER);
counter_metric!(CONNECTOR_ERROR_RESPONSE_COUNT, GLOBAL_METER);
counter_metric!(REQUEST_TIMEOUT_COUNT, GLOBAL_METER);
counter_metric!(EXECUTE_PRETASK_COUNT, GLOBAL_METER);
counter_metric!(CONNECTOR_PAYMENT_METHOD_TOKENIZATION, GLOBAL_METER);
counter_metric!(PREPROCESSING_STEPS_COUNT, GLOBAL_METER);
counter_metric!(CONNECTOR_CUSTOMER_CREATE, GLOBAL_METER);
counter_metric!(REDIRECTION_TRIGGERED, GLOBAL_METER);
// Connector Level Metric
counter_metric!(REQUEST_BUILD_FAILURE, GLOBAL_METER);
// Connector http status code metrics
counter_metric!(CONNECTOR_HTTP_STATUS_CODE_1XX_COUNT, GLOBAL_METER);
counter_metric!(CONNECTOR_HTTP_STATUS_CODE_2XX_COUNT, GLOBAL_METER);
counter_metric!(CONNECTOR_HTTP_STATUS_CODE_3XX_COUNT, GLOBAL_METER);
counter_metric!(CONNECTOR_HTTP_STATUS_CODE_4XX_COUNT, GLOBAL_METER);
counter_metric!(CONNECTOR_HTTP_STATUS_CODE_5XX_COUNT, GLOBAL_METER);
// Service Level
counter_metric!(CARD_LOCKER_FAILURES, GLOBAL_METER);
counter_metric!(CARD_LOCKER_SUCCESSFUL_RESPONSE, GLOBAL_METER);
counter_metric!(TEMP_LOCKER_FAILURES, GLOBAL_METER);
histogram_metric_f64!(CARD_ADD_TIME, GLOBAL_METER);
histogram_metric_f64!(CARD_GET_TIME, GLOBAL_METER);
histogram_metric_f64!(CARD_DELETE_TIME, GLOBAL_METER);
// Apple Pay Flow Metrics
counter_metric!(APPLE_PAY_MANUAL_FLOW, GLOBAL_METER);
counter_metric!(APPLE_PAY_SIMPLIFIED_FLOW, GLOBAL_METER);
counter_metric!(APPLE_PAY_MANUAL_FLOW_SUCCESSFUL_PAYMENT, GLOBAL_METER);
counter_metric!(APPLE_PAY_SIMPLIFIED_FLOW_SUCCESSFUL_PAYMENT, GLOBAL_METER);
counter_metric!(APPLE_PAY_MANUAL_FLOW_FAILED_PAYMENT, GLOBAL_METER);
counter_metric!(APPLE_PAY_SIMPLIFIED_FLOW_FAILED_PAYMENT, GLOBAL_METER);
// Metrics for Payment Auto Retries
counter_metric!(AUTO_RETRY_CONNECTION_CLOSED, GLOBAL_METER);
counter_metric!(AUTO_RETRY_ELIGIBLE_REQUEST_COUNT, GLOBAL_METER);
counter_metric!(AUTO_RETRY_GSM_MISS_COUNT, GLOBAL_METER);
counter_metric!(AUTO_RETRY_GSM_FETCH_FAILURE_COUNT, GLOBAL_METER);
counter_metric!(AUTO_RETRY_GSM_MATCH_COUNT, GLOBAL_METER);
counter_metric!(AUTO_RETRY_EXHAUSTED_COUNT, GLOBAL_METER);
counter_metric!(AUTO_RETRY_PAYMENT_COUNT, GLOBAL_METER);
// Metrics for Payout Auto Retries
counter_metric!(AUTO_PAYOUT_RETRY_ELIGIBLE_REQUEST_COUNT, GLOBAL_METER);
counter_metric!(AUTO_PAYOUT_RETRY_GSM_MISS_COUNT, GLOBAL_METER);
counter_metric!(AUTO_PAYOUT_RETRY_GSM_FETCH_FAILURE_COUNT, GLOBAL_METER);
counter_metric!(AUTO_PAYOUT_RETRY_GSM_MATCH_COUNT, GLOBAL_METER);
counter_metric!(AUTO_PAYOUT_RETRY_EXHAUSTED_COUNT, GLOBAL_METER);
counter_metric!(AUTO_RETRY_PAYOUT_COUNT, GLOBAL_METER);
// Scheduler / Process Tracker related metrics
counter_metric!(TASKS_ADDED_COUNT, GLOBAL_METER); // Tasks added to process tracker
counter_metric!(TASK_ADDITION_FAILURES_COUNT, GLOBAL_METER); // Failures in task addition to process tracker
counter_metric!(TASKS_RESET_COUNT, GLOBAL_METER); // Tasks reset in process tracker for requeue flow
// Access token metrics
//
// A counter to indicate the number of new access tokens created
counter_metric!(ACCESS_TOKEN_CREATION, GLOBAL_METER);
// A counter to indicate the access token cache hits
counter_metric!(ACCESS_TOKEN_CACHE_HIT, GLOBAL_METER);
// A counter to indicate the access token cache miss
counter_metric!(ACCESS_TOKEN_CACHE_MISS, GLOBAL_METER);
// A counter to indicate the integrity check failures
counter_metric!(INTEGRITY_CHECK_FAILED, GLOBAL_METER);
// Network Tokenization metrics
histogram_metric_f64!(GENERATE_NETWORK_TOKEN_TIME, GLOBAL_METER);
histogram_metric_f64!(FETCH_NETWORK_TOKEN_TIME, GLOBAL_METER);
histogram_metric_f64!(DELETE_NETWORK_TOKEN_TIME, GLOBAL_METER);
histogram_metric_f64!(CHECK_NETWORK_TOKEN_STATUS_TIME, GLOBAL_METER);
// A counter to indicate allowed payment method types mismatch
counter_metric!(PAYMENT_METHOD_TYPES_MISCONFIGURATION_METRIC, GLOBAL_METER);
<file_sep path="hyperswitch/crates/router/src/routes/metrics.rs" crate="router" role="use_site">
<|fim_prefix|>
pub mod bg_metrics_collector;
pub mod request;
pub mod utils;
use router_env::{
<|fim_suffix|>
<|fim_middle|>
};
global_meter!(GLOBAL_METER, "ROUTER_API");
counter_metric!(HEALTH_METRIC, GLOBAL_METER); // No. of health API hits
counter_metric!(KV_MISS, GLOBAL_METER); // No. of KV misses
// API Level Metrics
counter_metric!(REQUESTS_RECEIVED, GLOBAL_METER);
counter_metric!(REQUEST_STATUS, GLOBAL_METER);
histogram_metric_f64!(REQUEST_TIME, GLOBAL_METER);
histogram_metric_f64!(EXTERNAL_REQUEST_TIME, GLOBAL_METER);
// Operation Level Metrics
counter_metric!(PAYMENT_OPS_COUNT, GLOBAL_METER);
counter_metric!(PAYMENT_COUNT, GLOBAL_METER);
counter_metric!(SUCCESSFUL_PAYMENT, GLOBAL_METER);
//TODO: This can be removed, added for payment list debugging
histogram_metric_f64!(PAYMENT_LIST_LATENCY, GLOBAL_METER);
counter_metric!(REFUND_COUNT, GLOBAL_METER);
counter_metric!(SUCCESSFUL_REFUND, GLOBAL_METER);
counter_metric!(PAYMENT_CANCEL_COUNT, GLOBAL_METER);
counter_metric!(SUCCESSFUL_CANCEL, GLOBAL_METER);
counter_metric!(MANDATE_COUNT, GLOBAL_METER);
counter_metric!(SUBSEQUENT_MANDATE_PAYMENT, GLOBAL_METER);
// Manual retry metrics
counter_metric!(MANUAL_RETRY_REQUEST_COUNT, GLOBAL_METER);
counter_metric!(MANUAL_RETRY_COUNT, GLOBAL_METER);
counter_metric!(MANUAL_RETRY_VALIDATION_FAILED, GLOBAL_METER);
counter_metric!(STORED_TO_LOCKER, GLOBAL_METER);
counter_metric!(GET_FROM_LOCKER, GLOBAL_METER);
counter_metric!(DELETE_FROM_LOCKER, GLOBAL_METER);
counter_metric!(CREATED_TOKENIZED_CARD, GLOBAL_METER);
counter_metric!(DELETED_TOKENIZED_CARD, GLOBAL_METER);
counter_metric!(GET_TOKENIZED_CARD, GLOBAL_METER);
counter_metric!(TOKENIZED_DATA_COUNT, GLOBAL_METER); // Tokenized data added
counter_metric!(RETRIED_DELETE_DATA_COUNT, GLOBAL_METER); // Tokenized data retried
counter_metric!(CUSTOMER_CREATED, GLOBAL_METER);
counter_metric!(CUSTOMER_REDACTED, GLOBAL_METER);
counter_metric!(API_KEY_CREATED, GLOBAL_METER);
counter_metric!(API_KEY_REVOKED, GLOBAL_METER);
counter_metric!(MCA_CREATE, GLOBAL_METER);
// Flow Specific Metrics
histogram_metric_f64!(CONNECTOR_REQUEST_TIME, GLOBAL_METER);
counter_metric!(SESSION_TOKEN_CREATED, GLOBAL_METER);
counter_metric!(CONNECTOR_CALL_COUNT, GLOBAL_METER); // Attributes needed
counter_metric!(THREE_DS_PAYMENT_COUNT, GLOBAL_METER);
counter_metric!(THREE_DS_DOWNGRADE_COUNT, GLOBAL_METER);
counter_metric!(RESPONSE_DESERIALIZATION_FAILURE, GLOBAL_METER);
counter_metric!(CONNECTOR_ERROR_RESPONSE_COUNT, GLOBAL_METER);
counter_metric!(REQUEST_TIMEOUT_COUNT, GLOBAL_METER);
counter_metric!(EXECUTE_PRETASK_COUNT, GLOBAL_METER);
counter_metric!(CONNECTOR_PAYMENT_METHOD_TOKENIZATION, GLOBAL_METER);
counter_metric!(PREPROCESSING_STEPS_COUNT, GLOBAL_METER);
counter_metric!(CONNECTOR_CUSTOMER_CREATE, GLOBAL_METER);
counter_metric!(REDIRECTION_TRIGGERED, GLOBAL_METER);
// Connector Level Metric
counter_metric!(REQUEST_BUILD_FAILURE, GLOBAL_METER);
// Connector http status code metrics
counter_metric!(CONNECTOR_HTTP_STATUS_CODE_1XX_COUNT, GLOBAL_METER);
counter_metric!(CONNECTOR_HTTP_STATUS_CODE_2XX_COUNT, GLOBAL_METER);
counter_metric!(CONNECTOR_HTTP_STATUS_CODE_3XX_COUNT, GLOBAL_METER);
counter_metric!(CONNECTOR_HTTP_STATUS_CODE_4XX_COUNT, GLOBAL_METER);
counter_metric!(CONNECTOR_HTTP_STATUS_CODE_5XX_COUNT, GLOBAL_METER);
// Service Level
counter_metric!(CARD_LOCKER_FAILURES, GLOBAL_METER);
counter_metric!(CARD_LOCKER_SUCCESSFUL_RESPONSE, GLOBAL_METER);
counter_metric!(TEMP_LOCKER_FAILURES, GLOBAL_METER);
histogram_metric_f64!(CARD_ADD_TIME, GLOBAL_METER);
histogram_metric_f64!(CARD_GET_TIME, GLOBAL_METER);
histogram_metric_f64!(CARD_DELETE_TIME, GLOBAL_METER);
// Apple Pay Flow Metrics
counter_metric!(APPLE_PAY_MANUAL_FLOW, GLOBAL_METER);
counter_metric!(APPLE_PAY_SIMPLIFIED_FLOW, GLOBAL_METER);
counter_metric!(APPLE_PAY_MANUAL_FLOW_SUCCESSFUL_PAYMENT, GLOBAL_METER);
counter_metric!(APPLE_PAY_SIMPLIFIED_FLOW_SUCCESSFUL_PAYMENT, GLOBAL_METER);
counter_metric!(APPLE_PAY_MANUAL_FLOW_FAILED_PAYMENT, GLOBAL_METER);
counter_metric!(APPLE_PAY_SIMPLIFIED_FLOW_FAILED_PAYMENT, GLOBAL_METER);
// Metrics for Payment Auto Retries
counter_metric!(AUTO_RETRY_CONNECTION_CLOSED, GLOBAL_METER);
counter_metric!(AUTO_RETRY_ELIGIBLE_REQUEST_COUNT, GLOBAL_METER);
counter_metric!(AUTO_RETRY_GSM_MISS_COUNT, GLOBAL_METER);
counter_metric!(AUTO_RETRY_GSM_FETCH_FAILURE_COUNT, GLOBAL_METER);
counter_metric!(AUTO_RETRY_GSM_MATCH_COUNT, GLOBAL_METER);
counter_metric!(AUTO_RETRY_EXHAUSTED_COUNT, GLOBAL_METER);
counter_metric!(AUTO_RETRY_PAYMENT_COUNT, GLOBAL_METER);
// Metrics for Payout Auto Retries
counter_metric!(AUTO_PAYOUT_RETRY_ELIGIBLE_REQUEST_COUNT, GLOBAL_METER);
counter_metric!(AUTO_PAYOUT_RETRY_GSM_MISS_COUNT, GLOBAL_METER);
counter_metric!(AUTO_PAYOUT_RETRY_GSM_FETCH_FAILURE_COUNT, GLOBAL_METER);
counter_metric!(AUTO_PAYOUT_RETRY_GSM_MATCH_COUNT, GLOBAL_METER);
counter_metric!(AUTO_PAYOUT_RETRY_EXHAUSTED_COUNT, GLOBAL_METER);
counter_metric!(AUTO_RETRY_PAYOUT_COUNT, GLOBAL_METER);
// Scheduler / Process Tracker related metrics
counter_metric!(TASKS_ADDED_COUNT, GLOBAL_METER); // Tasks added to process tracker
counter_metric!(TASK_ADDITION_FAILURES_COUNT, GLOBAL_METER); // Failures in task addition to process tracker
counter_metric!(TASKS_RESET_COUNT, GLOBAL_METER); // Tasks reset in process tracker for requeue flow
// Access token metrics
//
// A counter to indicate the number of new access tokens created
counter_metric!(ACCESS_TOKEN_CREATION, GLOBAL_METER);
// A counter to indicate the access token cache hits
counter_metric!(ACCESS_TOKEN_CACHE_HIT, GLOBAL_METER);
// A counter to indicate the access token cache miss
counter_metric!(ACCESS_TOKEN_CACHE_MISS, GLOBAL_METER);
// A counter to indicate the integrity check failures
counter_metric!(INTEGRITY_CHECK_FAILED, GLOBAL_METER);
// Network Tokenization metrics
histogram_metric_f64!(GENERATE_NETWORK_TOKEN_TIME, GLOBAL_METER);
histogram_metric_f64!(FETCH_NETWORK_TOKEN_TIME, GLOBAL_METER);
histogram_metric_f64!(DELETE_NETWORK_TOKEN_TIME, GLOBAL_METER);
histogram_metric_f64!(CHECK_NETWORK_TOKEN_STATUS_TIME, GLOBAL_METER);
// A counter to indicate allowed payment method types mismatch
counter_metric!(PAYMENT_METHOD_TYPES_MISCONFIGURATION_METRIC, GLOBAL_METER);
| proc_macro_neighborhoods |
<file_sep path="hyperswitch/crates/router/src/routes/metrics.rs" crate="router" role="use_site">
histogram_metric_f64!(GENERATE_NETWORK_TOKEN_TIME, GLOBAL_METER);
<file_sep path="hyperswitch/crates/router/src/routes/metrics.rs" crate="router" role="use_site">
histogram_metric_f64!(GENERATE_NETWORK_TOKEN_TIME, GLOBAL_METER);
<file_sep path="hyperswitch/crates/router_env/src/metrics.rs" crate="router_env" role="macro_def">
<|fim_prefix|>
<|meta_start|><|file|> hyperswitch/crates/router_env/src/metrics.rs<|crate|> router macro=histogram_metric_f64 roles=use_site,macro_def use=invoke item=file pack=proc_macro_neighborhoods lang=rust<|meta_end|>
//! Utilities to easily create opentelemetry contexts, meters and metrics.
/// Create a global [`Meter`][Meter] with the specified name and an optional description.
///
/// [Meter]: opentelemetry::metrics::Meter
#[macro_export]
macro_rules! global_meter {
<|fim_suffix|>
<|fim_middle|>
}
<file_sep path="hyperswitch/crates/router_env/src/metrics.rs" crate="router_env" role="macro_def">
<|fim_prefix|>
//! Utilities to easily create opentelemetry contexts, meters and metrics.
/// Create a global [`Meter`][Meter] with the specified name and an optional description.
///
/// [Meter]: opentelemetry::metrics::Meter
#[macro_export]
macro_rules! global_meter {
<|fim_suffix|>
<|fim_middle|>
}
| proc_macro_neighborhoods |
<file_sep path="hyperswitch/crates/router_env/src/metrics.rs" crate="router_env" role="macro_def">
macro_rules! histogram_metric_f64 {
($name:ident, $meter:ident) => {
pub(crate) static $name: once_cell::sync::Lazy<
$crate::opentelemetry::metrics::Histogram<f64>,
> = once_cell::sync::Lazy::new(|| {
$meter
.f64_histogram(stringify!($name))
.with_boundaries($crate::metrics::f64_histogram_buckets())
.build()
});
};
($name:ident, $meter:ident, $description:literal) => {
#[doc = $description]
pub(crate) static $name: once_cell::sync::Lazy<
$crate::opentelemetry::metrics::Histogram<f64>,
> = once_cell::sync::Lazy::new(|| {
$meter
.f64_histogram(stringify!($name))
.with_description($description)
.with_boundaries($crate::metrics::f64_histogram_buckets())
.build()
});
};
}
<file_sep path="hyperswitch/crates/router_env/src/metrics.rs" crate="router_env" role="macro_def">
macro_rules! histogram_metric_f64 {
($name:ident, $meter:ident) => {
pub(crate) static $name: once_cell::sync::Lazy<
$crate::opentelemetry::metrics::Histogram<f64>,
> = once_cell::sync::Lazy::new(|| {
$meter
.f64_histogram(stringify!($name))
.with_boundaries($crate::metrics::f64_histogram_buckets())
.build()
});
};
($name:ident, $meter:ident, $description:literal) => {
#[doc = $description]
pub(crate) static $name: once_cell::sync::Lazy<
$crate::opentelemetry::metrics::Histogram<f64>,
> = once_cell::sync::Lazy::new(|| {
$meter
.f64_histogram(stringify!($name))
.with_description($description)
.with_boundaries($crate::metrics::f64_histogram_buckets())
.build()
});
};
}
<file_sep path="hyperswitch/crates/router/src/routes/metrics.rs" crate="router" role="use_site">
<|fim_prefix|>
<|meta_start|><|file|> hyperswitch/crates/router_env/src/metrics.rs<|crate|> router macro=histogram_metric_f64 roles=macro_def,use_site use=invoke item=file pack=proc_macro_neighborhoods lang=rust<|meta_end|>
pub mod bg_metrics_collector;
pub mod request;
pub mod utils;
use router_env::{
<|fim_suffix|>
<|fim_middle|>
};
global_meter!(GLOBAL_METER, "ROUTER_API");
counter_metric!(HEALTH_METRIC, GLOBAL_METER); // No. of health API hits
counter_metric!(KV_MISS, GLOBAL_METER); // No. of KV misses
// API Level Metrics
counter_metric!(REQUESTS_RECEIVED, GLOBAL_METER);
counter_metric!(REQUEST_STATUS, GLOBAL_METER);
histogram_metric_f64!(REQUEST_TIME, GLOBAL_METER);
histogram_metric_f64!(EXTERNAL_REQUEST_TIME, GLOBAL_METER);
// Operation Level Metrics
counter_metric!(PAYMENT_OPS_COUNT, GLOBAL_METER);
counter_metric!(PAYMENT_COUNT, GLOBAL_METER);
counter_metric!(SUCCESSFUL_PAYMENT, GLOBAL_METER);
//TODO: This can be removed, added for payment list debugging
histogram_metric_f64!(PAYMENT_LIST_LATENCY, GLOBAL_METER);
counter_metric!(REFUND_COUNT, GLOBAL_METER);
counter_metric!(SUCCESSFUL_REFUND, GLOBAL_METER);
counter_metric!(PAYMENT_CANCEL_COUNT, GLOBAL_METER);
counter_metric!(SUCCESSFUL_CANCEL, GLOBAL_METER);
counter_metric!(MANDATE_COUNT, GLOBAL_METER);
counter_metric!(SUBSEQUENT_MANDATE_PAYMENT, GLOBAL_METER);
// Manual retry metrics
counter_metric!(MANUAL_RETRY_REQUEST_COUNT, GLOBAL_METER);
counter_metric!(MANUAL_RETRY_COUNT, GLOBAL_METER);
counter_metric!(MANUAL_RETRY_VALIDATION_FAILED, GLOBAL_METER);
counter_metric!(STORED_TO_LOCKER, GLOBAL_METER);
counter_metric!(GET_FROM_LOCKER, GLOBAL_METER);
counter_metric!(DELETE_FROM_LOCKER, GLOBAL_METER);
counter_metric!(CREATED_TOKENIZED_CARD, GLOBAL_METER);
counter_metric!(DELETED_TOKENIZED_CARD, GLOBAL_METER);
counter_metric!(GET_TOKENIZED_CARD, GLOBAL_METER);
counter_metric!(TOKENIZED_DATA_COUNT, GLOBAL_METER); // Tokenized data added
counter_metric!(RETRIED_DELETE_DATA_COUNT, GLOBAL_METER); // Tokenized data retried
counter_metric!(CUSTOMER_CREATED, GLOBAL_METER);
counter_metric!(CUSTOMER_REDACTED, GLOBAL_METER);
counter_metric!(API_KEY_CREATED, GLOBAL_METER);
counter_metric!(API_KEY_REVOKED, GLOBAL_METER);
counter_metric!(MCA_CREATE, GLOBAL_METER);
// Flow Specific Metrics
histogram_metric_f64!(CONNECTOR_REQUEST_TIME, GLOBAL_METER);
counter_metric!(SESSION_TOKEN_CREATED, GLOBAL_METER);
counter_metric!(CONNECTOR_CALL_COUNT, GLOBAL_METER); // Attributes needed
counter_metric!(THREE_DS_PAYMENT_COUNT, GLOBAL_METER);
counter_metric!(THREE_DS_DOWNGRADE_COUNT, GLOBAL_METER);
counter_metric!(RESPONSE_DESERIALIZATION_FAILURE, GLOBAL_METER);
counter_metric!(CONNECTOR_ERROR_RESPONSE_COUNT, GLOBAL_METER);
counter_metric!(REQUEST_TIMEOUT_COUNT, GLOBAL_METER);
counter_metric!(EXECUTE_PRETASK_COUNT, GLOBAL_METER);
counter_metric!(CONNECTOR_PAYMENT_METHOD_TOKENIZATION, GLOBAL_METER);
counter_metric!(PREPROCESSING_STEPS_COUNT, GLOBAL_METER);
counter_metric!(CONNECTOR_CUSTOMER_CREATE, GLOBAL_METER);
counter_metric!(REDIRECTION_TRIGGERED, GLOBAL_METER);
// Connector Level Metric
counter_metric!(REQUEST_BUILD_FAILURE, GLOBAL_METER);
// Connector http status code metrics
counter_metric!(CONNECTOR_HTTP_STATUS_CODE_1XX_COUNT, GLOBAL_METER);
counter_metric!(CONNECTOR_HTTP_STATUS_CODE_2XX_COUNT, GLOBAL_METER);
counter_metric!(CONNECTOR_HTTP_STATUS_CODE_3XX_COUNT, GLOBAL_METER);
counter_metric!(CONNECTOR_HTTP_STATUS_CODE_4XX_COUNT, GLOBAL_METER);
counter_metric!(CONNECTOR_HTTP_STATUS_CODE_5XX_COUNT, GLOBAL_METER);
// Service Level
counter_metric!(CARD_LOCKER_FAILURES, GLOBAL_METER);
counter_metric!(CARD_LOCKER_SUCCESSFUL_RESPONSE, GLOBAL_METER);
counter_metric!(TEMP_LOCKER_FAILURES, GLOBAL_METER);
histogram_metric_f64!(CARD_ADD_TIME, GLOBAL_METER);
histogram_metric_f64!(CARD_GET_TIME, GLOBAL_METER);
histogram_metric_f64!(CARD_DELETE_TIME, GLOBAL_METER);
// Apple Pay Flow Metrics
counter_metric!(APPLE_PAY_MANUAL_FLOW, GLOBAL_METER);
counter_metric!(APPLE_PAY_SIMPLIFIED_FLOW, GLOBAL_METER);
counter_metric!(APPLE_PAY_MANUAL_FLOW_SUCCESSFUL_PAYMENT, GLOBAL_METER);
counter_metric!(APPLE_PAY_SIMPLIFIED_FLOW_SUCCESSFUL_PAYMENT, GLOBAL_METER);
counter_metric!(APPLE_PAY_MANUAL_FLOW_FAILED_PAYMENT, GLOBAL_METER);
counter_metric!(APPLE_PAY_SIMPLIFIED_FLOW_FAILED_PAYMENT, GLOBAL_METER);
// Metrics for Payment Auto Retries
counter_metric!(AUTO_RETRY_CONNECTION_CLOSED, GLOBAL_METER);
counter_metric!(AUTO_RETRY_ELIGIBLE_REQUEST_COUNT, GLOBAL_METER);
counter_metric!(AUTO_RETRY_GSM_MISS_COUNT, GLOBAL_METER);
counter_metric!(AUTO_RETRY_GSM_FETCH_FAILURE_COUNT, GLOBAL_METER);
counter_metric!(AUTO_RETRY_GSM_MATCH_COUNT, GLOBAL_METER);
counter_metric!(AUTO_RETRY_EXHAUSTED_COUNT, GLOBAL_METER);
counter_metric!(AUTO_RETRY_PAYMENT_COUNT, GLOBAL_METER);
// Metrics for Payout Auto Retries
counter_metric!(AUTO_PAYOUT_RETRY_ELIGIBLE_REQUEST_COUNT, GLOBAL_METER);
counter_metric!(AUTO_PAYOUT_RETRY_GSM_MISS_COUNT, GLOBAL_METER);
counter_metric!(AUTO_PAYOUT_RETRY_GSM_FETCH_FAILURE_COUNT, GLOBAL_METER);
counter_metric!(AUTO_PAYOUT_RETRY_GSM_MATCH_COUNT, GLOBAL_METER);
counter_metric!(AUTO_PAYOUT_RETRY_EXHAUSTED_COUNT, GLOBAL_METER);
counter_metric!(AUTO_RETRY_PAYOUT_COUNT, GLOBAL_METER);
// Scheduler / Process Tracker related metrics
counter_metric!(TASKS_ADDED_COUNT, GLOBAL_METER); // Tasks added to process tracker
counter_metric!(TASK_ADDITION_FAILURES_COUNT, GLOBAL_METER); // Failures in task addition to process tracker
counter_metric!(TASKS_RESET_COUNT, GLOBAL_METER); // Tasks reset in process tracker for requeue flow
// Access token metrics
//
// A counter to indicate the number of new access tokens created
counter_metric!(ACCESS_TOKEN_CREATION, GLOBAL_METER);
// A counter to indicate the access token cache hits
counter_metric!(ACCESS_TOKEN_CACHE_HIT, GLOBAL_METER);
// A counter to indicate the access token cache miss
counter_metric!(ACCESS_TOKEN_CACHE_MISS, GLOBAL_METER);
// A counter to indicate the integrity check failures
counter_metric!(INTEGRITY_CHECK_FAILED, GLOBAL_METER);
// Network Tokenization metrics
histogram_metric_f64!(GENERATE_NETWORK_TOKEN_TIME, GLOBAL_METER);
histogram_metric_f64!(FETCH_NETWORK_TOKEN_TIME, GLOBAL_METER);
histogram_metric_f64!(DELETE_NETWORK_TOKEN_TIME, GLOBAL_METER);
histogram_metric_f64!(CHECK_NETWORK_TOKEN_STATUS_TIME, GLOBAL_METER);
// A counter to indicate allowed payment method types mismatch
counter_metric!(PAYMENT_METHOD_TYPES_MISCONFIGURATION_METRIC, GLOBAL_METER);
<file_sep path="hyperswitch/crates/router/src/routes/metrics.rs" crate="router" role="use_site">
<|fim_prefix|>
pub mod bg_metrics_collector;
pub mod request;
pub mod utils;
use router_env::{
<|fim_suffix|>
<|fim_middle|>
};
global_meter!(GLOBAL_METER, "ROUTER_API");
counter_metric!(HEALTH_METRIC, GLOBAL_METER); // No. of health API hits
counter_metric!(KV_MISS, GLOBAL_METER); // No. of KV misses
// API Level Metrics
counter_metric!(REQUESTS_RECEIVED, GLOBAL_METER);
counter_metric!(REQUEST_STATUS, GLOBAL_METER);
histogram_metric_f64!(REQUEST_TIME, GLOBAL_METER);
histogram_metric_f64!(EXTERNAL_REQUEST_TIME, GLOBAL_METER);
// Operation Level Metrics
counter_metric!(PAYMENT_OPS_COUNT, GLOBAL_METER);
counter_metric!(PAYMENT_COUNT, GLOBAL_METER);
counter_metric!(SUCCESSFUL_PAYMENT, GLOBAL_METER);
//TODO: This can be removed, added for payment list debugging
histogram_metric_f64!(PAYMENT_LIST_LATENCY, GLOBAL_METER);
counter_metric!(REFUND_COUNT, GLOBAL_METER);
counter_metric!(SUCCESSFUL_REFUND, GLOBAL_METER);
counter_metric!(PAYMENT_CANCEL_COUNT, GLOBAL_METER);
counter_metric!(SUCCESSFUL_CANCEL, GLOBAL_METER);
counter_metric!(MANDATE_COUNT, GLOBAL_METER);
counter_metric!(SUBSEQUENT_MANDATE_PAYMENT, GLOBAL_METER);
// Manual retry metrics
counter_metric!(MANUAL_RETRY_REQUEST_COUNT, GLOBAL_METER);
counter_metric!(MANUAL_RETRY_COUNT, GLOBAL_METER);
counter_metric!(MANUAL_RETRY_VALIDATION_FAILED, GLOBAL_METER);
counter_metric!(STORED_TO_LOCKER, GLOBAL_METER);
counter_metric!(GET_FROM_LOCKER, GLOBAL_METER);
counter_metric!(DELETE_FROM_LOCKER, GLOBAL_METER);
counter_metric!(CREATED_TOKENIZED_CARD, GLOBAL_METER);
counter_metric!(DELETED_TOKENIZED_CARD, GLOBAL_METER);
counter_metric!(GET_TOKENIZED_CARD, GLOBAL_METER);
counter_metric!(TOKENIZED_DATA_COUNT, GLOBAL_METER); // Tokenized data added
counter_metric!(RETRIED_DELETE_DATA_COUNT, GLOBAL_METER); // Tokenized data retried
counter_metric!(CUSTOMER_CREATED, GLOBAL_METER);
counter_metric!(CUSTOMER_REDACTED, GLOBAL_METER);
counter_metric!(API_KEY_CREATED, GLOBAL_METER);
counter_metric!(API_KEY_REVOKED, GLOBAL_METER);
counter_metric!(MCA_CREATE, GLOBAL_METER);
// Flow Specific Metrics
histogram_metric_f64!(CONNECTOR_REQUEST_TIME, GLOBAL_METER);
counter_metric!(SESSION_TOKEN_CREATED, GLOBAL_METER);
counter_metric!(CONNECTOR_CALL_COUNT, GLOBAL_METER); // Attributes needed
counter_metric!(THREE_DS_PAYMENT_COUNT, GLOBAL_METER);
counter_metric!(THREE_DS_DOWNGRADE_COUNT, GLOBAL_METER);
counter_metric!(RESPONSE_DESERIALIZATION_FAILURE, GLOBAL_METER);
counter_metric!(CONNECTOR_ERROR_RESPONSE_COUNT, GLOBAL_METER);
counter_metric!(REQUEST_TIMEOUT_COUNT, GLOBAL_METER);
counter_metric!(EXECUTE_PRETASK_COUNT, GLOBAL_METER);
counter_metric!(CONNECTOR_PAYMENT_METHOD_TOKENIZATION, GLOBAL_METER);
counter_metric!(PREPROCESSING_STEPS_COUNT, GLOBAL_METER);
counter_metric!(CONNECTOR_CUSTOMER_CREATE, GLOBAL_METER);
counter_metric!(REDIRECTION_TRIGGERED, GLOBAL_METER);
// Connector Level Metric
counter_metric!(REQUEST_BUILD_FAILURE, GLOBAL_METER);
// Connector http status code metrics
counter_metric!(CONNECTOR_HTTP_STATUS_CODE_1XX_COUNT, GLOBAL_METER);
counter_metric!(CONNECTOR_HTTP_STATUS_CODE_2XX_COUNT, GLOBAL_METER);
counter_metric!(CONNECTOR_HTTP_STATUS_CODE_3XX_COUNT, GLOBAL_METER);
counter_metric!(CONNECTOR_HTTP_STATUS_CODE_4XX_COUNT, GLOBAL_METER);
counter_metric!(CONNECTOR_HTTP_STATUS_CODE_5XX_COUNT, GLOBAL_METER);
// Service Level
counter_metric!(CARD_LOCKER_FAILURES, GLOBAL_METER);
counter_metric!(CARD_LOCKER_SUCCESSFUL_RESPONSE, GLOBAL_METER);
counter_metric!(TEMP_LOCKER_FAILURES, GLOBAL_METER);
histogram_metric_f64!(CARD_ADD_TIME, GLOBAL_METER);
histogram_metric_f64!(CARD_GET_TIME, GLOBAL_METER);
histogram_metric_f64!(CARD_DELETE_TIME, GLOBAL_METER);
// Apple Pay Flow Metrics
counter_metric!(APPLE_PAY_MANUAL_FLOW, GLOBAL_METER);
counter_metric!(APPLE_PAY_SIMPLIFIED_FLOW, GLOBAL_METER);
counter_metric!(APPLE_PAY_MANUAL_FLOW_SUCCESSFUL_PAYMENT, GLOBAL_METER);
counter_metric!(APPLE_PAY_SIMPLIFIED_FLOW_SUCCESSFUL_PAYMENT, GLOBAL_METER);
counter_metric!(APPLE_PAY_MANUAL_FLOW_FAILED_PAYMENT, GLOBAL_METER);
counter_metric!(APPLE_PAY_SIMPLIFIED_FLOW_FAILED_PAYMENT, GLOBAL_METER);
// Metrics for Payment Auto Retries
counter_metric!(AUTO_RETRY_CONNECTION_CLOSED, GLOBAL_METER);
counter_metric!(AUTO_RETRY_ELIGIBLE_REQUEST_COUNT, GLOBAL_METER);
counter_metric!(AUTO_RETRY_GSM_MISS_COUNT, GLOBAL_METER);
counter_metric!(AUTO_RETRY_GSM_FETCH_FAILURE_COUNT, GLOBAL_METER);
counter_metric!(AUTO_RETRY_GSM_MATCH_COUNT, GLOBAL_METER);
counter_metric!(AUTO_RETRY_EXHAUSTED_COUNT, GLOBAL_METER);
counter_metric!(AUTO_RETRY_PAYMENT_COUNT, GLOBAL_METER);
// Metrics for Payout Auto Retries
counter_metric!(AUTO_PAYOUT_RETRY_ELIGIBLE_REQUEST_COUNT, GLOBAL_METER);
counter_metric!(AUTO_PAYOUT_RETRY_GSM_MISS_COUNT, GLOBAL_METER);
counter_metric!(AUTO_PAYOUT_RETRY_GSM_FETCH_FAILURE_COUNT, GLOBAL_METER);
counter_metric!(AUTO_PAYOUT_RETRY_GSM_MATCH_COUNT, GLOBAL_METER);
counter_metric!(AUTO_PAYOUT_RETRY_EXHAUSTED_COUNT, GLOBAL_METER);
counter_metric!(AUTO_RETRY_PAYOUT_COUNT, GLOBAL_METER);
// Scheduler / Process Tracker related metrics
counter_metric!(TASKS_ADDED_COUNT, GLOBAL_METER); // Tasks added to process tracker
counter_metric!(TASK_ADDITION_FAILURES_COUNT, GLOBAL_METER); // Failures in task addition to process tracker
counter_metric!(TASKS_RESET_COUNT, GLOBAL_METER); // Tasks reset in process tracker for requeue flow
// Access token metrics
//
// A counter to indicate the number of new access tokens created
counter_metric!(ACCESS_TOKEN_CREATION, GLOBAL_METER);
// A counter to indicate the access token cache hits
counter_metric!(ACCESS_TOKEN_CACHE_HIT, GLOBAL_METER);
// A counter to indicate the access token cache miss
counter_metric!(ACCESS_TOKEN_CACHE_MISS, GLOBAL_METER);
// A counter to indicate the integrity check failures
counter_metric!(INTEGRITY_CHECK_FAILED, GLOBAL_METER);
// Network Tokenization metrics
histogram_metric_f64!(GENERATE_NETWORK_TOKEN_TIME, GLOBAL_METER);
histogram_metric_f64!(FETCH_NETWORK_TOKEN_TIME, GLOBAL_METER);
histogram_metric_f64!(DELETE_NETWORK_TOKEN_TIME, GLOBAL_METER);
histogram_metric_f64!(CHECK_NETWORK_TOKEN_STATUS_TIME, GLOBAL_METER);
// A counter to indicate allowed payment method types mismatch
counter_metric!(PAYMENT_METHOD_TYPES_MISCONFIGURATION_METRIC, GLOBAL_METER);
| proc_macro_neighborhoods |
<file_sep path="hyperswitch/crates/router_env/src/metrics.rs" crate="router_env" role="macro_def">
macro_rules! histogram_metric_f64 {
($name:ident, $meter:ident) => {
pub(crate) static $name: once_cell::sync::Lazy<
$crate::opentelemetry::metrics::Histogram<f64>,
> = once_cell::sync::Lazy::new(|| {
$meter
.f64_histogram(stringify!($name))
.with_boundaries($crate::metrics::f64_histogram_buckets())
.build()
});
};
($name:ident, $meter:ident, $description:literal) => {
#[doc = $description]
pub(crate) static $name: once_cell::sync::Lazy<
$crate::opentelemetry::metrics::Histogram<f64>,
> = once_cell::sync::Lazy::new(|| {
$meter
.f64_histogram(stringify!($name))
.with_description($description)
.with_boundaries($crate::metrics::f64_histogram_buckets())
.build()
});
};
}
<file_sep path="hyperswitch/crates/router_env/src/metrics.rs" crate="router_env" role="macro_def">
macro_rules! histogram_metric_f64 {
($name:ident, $meter:ident) => {
pub(crate) static $name: once_cell::sync::Lazy<
$crate::opentelemetry::metrics::Histogram<f64>,
> = once_cell::sync::Lazy::new(|| {
$meter
.f64_histogram(stringify!($name))
.with_boundaries($crate::metrics::f64_histogram_buckets())
.build()
});
};
($name:ident, $meter:ident, $description:literal) => {
#[doc = $description]
pub(crate) static $name: once_cell::sync::Lazy<
$crate::opentelemetry::metrics::Histogram<f64>,
> = once_cell::sync::Lazy::new(|| {
$meter
.f64_histogram(stringify!($name))
.with_description($description)
.with_boundaries($crate::metrics::f64_histogram_buckets())
.build()
});
};
}
<file_sep path="hyperswitch/crates/hyperswitch_domain_models/src/type_encryption.rs" crate="hyperswitch_domain_models" role="use_site">
<|fim_prefix|>
<|meta_start|><|file|> hyperswitch/crates/router_env/src/metrics.rs<|crate|> hyperswitch_domain_models macro=histogram_metric_f64 roles=macro_def,use_site use=invoke item=mod pack=proc_macro_neighborhoods lang=rust<|meta_end|>
pub(crate) mod metrics {
<|fim_suffix|>
<|fim_middle|>
}
<file_sep path="hyperswitch/crates/hyperswitch_domain_models/src/type_encryption.rs" crate="hyperswitch_domain_models" role="use_site">
<|fim_prefix|>
pub(crate) mod metrics {
<|fim_suffix|>
<|fim_middle|>
}
| proc_macro_neighborhoods |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.