feat(router): added incoming dispute webhooks flow (#769)

Co-authored-by: Sangamesh <[email protected]>
Co-authored-by: sai harsha <[email protected]>
Co-authored-by: Arun Raj M <[email protected]>

Author: 4 people

crates/api_models/src/disputes.rs

@@ -1 +1,38 @@
+use masking::Serialize;
+use utoipa::ToSchema;
 
+use super::enums::{DisputeStage, DisputeStatus};
+
+#[derive(Default, Clone, Debug, Serialize, ToSchema)]
+pub struct DisputeResponse {
+    /// The identifier for dispute
+    pub dispute_id: String,
+    /// The identifier for payment_intent
+    pub payment_id: String,
+    /// The identifier for payment_attempt
+    pub attempt_id: String,
+    /// The dispute amount
+    pub amount: String,
+    /// The three-letter ISO currency code
+    pub currency: String,
+    /// Stage of the dispute
+    pub dispute_stage: DisputeStage,
+    /// Status of the dispute
+    pub dispute_status: DisputeStatus,
+    /// Status of the dispute sent by connector
+    pub connector_status: String,
+    /// Dispute id sent by connector
+    pub connector_dispute_id: String,
+    /// Reason of dispute sent by connector
+    pub connector_reason: Option<String>,
+    /// Reason code of dispute sent by connector
+    pub connector_reason_code: Option<String>,
+    /// Evidence deadline of dispute sent by connector
+    pub challenge_required_by: Option<String>,
+    /// Dispute created time sent by connector
+    pub created_at: Option<String>,
+    /// Dispute updated time sent by connector
+    pub updated_at: Option<String>,
+    /// Time at which dispute is received
+    pub received_at: String,
+}

crates/api_models/src/enums.rs

@@ -267,6 +267,13 @@ pub enum EventType {
     PaymentSucceeded,
     RefundSucceeded,
     RefundFailed,
+    DisputeOpened,
+    DisputeExpired,
+    DisputeAccepted,
+    DisputeCancelled,
+    DisputeChallenged,
+    DisputeWon,
+    DisputeLost,
 }
 
 #[derive(
@@ -767,3 +774,51 @@ impl From<AttemptStatus> for IntentStatus {
         }
     }
 }
+
+#[derive(
+    Clone,
+    Default,
+    Debug,
+    Eq,
+    Hash,
+    PartialEq,
+    serde::Deserialize,
+    serde::Serialize,
+    strum::Display,
+    strum::EnumString,
+    frunk::LabelledGeneric,
+    ToSchema,
+)]
+pub enum DisputeStage {
+    PreDispute,
+    #[default]
+    Dispute,
+    PreArbitration,
+}
+
+#[derive(
+    Clone,
+    Debug,
+    Default,
+    Eq,
+    Hash,
+    PartialEq,
+    serde::Deserialize,
+    serde::Serialize,
+    strum::Display,
+    strum::EnumString,
+    frunk::LabelledGeneric,
+    ToSchema,
+)]
+pub enum DisputeStatus {
+    #[default]
+    DisputeOpened,
+    DisputeExpired,
+    DisputeAccepted,
+    DisputeCancelled,
+    DisputeChallenged,
+    // dispute has been successfully challenged by the merchant
+    DisputeWon,
+    // dispute has been unsuccessfully challenged
+    DisputeLost,
+}

crates/api_models/src/webhooks.rs

@@ -2,7 +2,7 @@ use common_utils::custom_serde;
 use serde::{Deserialize, Serialize};
 use time::PrimitiveDateTime;
 
-use crate::{enums as api_enums, payments, refunds};
+use crate::{disputes, enums as api_enums, payments, refunds};
 
 #[derive(Clone, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
 #[serde(rename_all = "snake_case")]
@@ -11,12 +11,22 @@ pub enum IncomingWebhookEvent {
     PaymentIntentSuccess,
     RefundFailure,
     RefundSuccess,
+    DisputeOpened,
+    DisputeExpired,
+    DisputeAccepted,
+    DisputeCancelled,
+    DisputeChallenged,
+    // dispute has been successfully challenged by the merchant
+    DisputeWon,
+    // dispute has been unsuccessfully challenged
+    DisputeLost,
     EndpointVerification,
 }
 
 pub enum WebhookFlow {
     Payment,
     Refund,
+    Dispute,
     Subscription,
     ReturnResponse,
 }
@@ -28,6 +38,13 @@ impl From<IncomingWebhookEvent> for WebhookFlow {
             IncomingWebhookEvent::PaymentIntentSuccess => Self::Payment,
             IncomingWebhookEvent::RefundSuccess => Self::Refund,
             IncomingWebhookEvent::RefundFailure => Self::Refund,
+            IncomingWebhookEvent::DisputeOpened => Self::Dispute,
+            IncomingWebhookEvent::DisputeAccepted => Self::Dispute,
+            IncomingWebhookEvent::DisputeExpired => Self::Dispute,
+            IncomingWebhookEvent::DisputeCancelled => Self::Dispute,
+            IncomingWebhookEvent::DisputeChallenged => Self::Dispute,
+            IncomingWebhookEvent::DisputeWon => Self::Dispute,
+            IncomingWebhookEvent::DisputeLost => Self::Dispute,
             IncomingWebhookEvent::EndpointVerification => Self::ReturnResponse,
         }
     }
@@ -73,6 +90,7 @@ pub struct OutgoingWebhook {
 pub enum OutgoingWebhookContent {
     PaymentDetails(payments::PaymentsResponse),
     RefundDetails(refunds::RefundResponse),
+    DisputeDetails(Box<disputes::DisputeResponse>),
 }
 
 pub trait OutgoingWebhookType: Serialize + From<OutgoingWebhook> + Sync + Send {}

crates/router/src/compatibility/stripe/webhooks.rs

@@ -1,4 +1,7 @@
-use api_models::webhooks::{self as api};
+use api_models::{
+    enums::DisputeStatus,
+    webhooks::{self as api},
+};
 use serde::Serialize;
 
 use super::{
@@ -20,6 +23,57 @@ impl api::OutgoingWebhookType for StripeOutgoingWebhook {}
 pub enum StripeWebhookObject {
     PaymentIntent(StripePaymentIntentResponse),
     Refund(StripeRefundResponse),
+    Dispute(StripeDisputeResponse),
+}
+
+#[derive(Serialize)]
+pub struct StripeDisputeResponse {
+    pub id: String,
+    pub amount: String,
+    pub currency: String,
+    pub payment_intent: String,
+    pub reason: Option<String>,
+    pub status: StripeDisputeStatus,
+}
+
+#[derive(Serialize)]
+#[serde(rename_all = "snake_case")]
+pub enum StripeDisputeStatus {
+    WarningNeedsResponse,
+    WarningUnderReview,
+    WarningClosed,
+    NeedsResponse,
+    UnderReview,
+    ChargeRefunded,
+    Won,
+    Lost,
+}
+
+impl From<api_models::disputes::DisputeResponse> for StripeDisputeResponse {
+    fn from(res: api_models::disputes::DisputeResponse) -> Self {
+        Self {
+            id: res.dispute_id,
+            amount: res.amount,
+            currency: res.currency,
+            payment_intent: res.payment_id,
+            reason: res.connector_reason,
+            status: StripeDisputeStatus::from(res.dispute_status),
+        }
+    }
+}
+
+impl From<DisputeStatus> for StripeDisputeStatus {
+    fn from(status: DisputeStatus) -> Self {
+        match status {
+            DisputeStatus::DisputeOpened => Self::WarningNeedsResponse,
+            DisputeStatus::DisputeExpired => Self::Lost,
+            DisputeStatus::DisputeAccepted => Self::Lost,
+            DisputeStatus::DisputeCancelled => Self::WarningClosed,
+            DisputeStatus::DisputeChallenged => Self::WarningUnderReview,
+            DisputeStatus::DisputeWon => Self::Won,
+            DisputeStatus::DisputeLost => Self::Lost,
+        }
+    }
 }
 
 impl From<api::OutgoingWebhook> for StripeOutgoingWebhook {
@@ -40,6 +94,9 @@ impl From<api::OutgoingWebhookContent> for StripeWebhookObject {
                 Self::PaymentIntent(payment.into())
             }
             api::OutgoingWebhookContent::RefundDetails(refund) => Self::Refund(refund.into()),
+            api::OutgoingWebhookContent::DisputeDetails(dispute) => {
+                Self::Dispute((*dispute).into())
+            }
         }
     }
 }
@@ -49,6 +106,7 @@ impl StripeWebhookObject {
         match self {
             Self::PaymentIntent(p) => p.id.to_owned(),
             Self::Refund(r) => Some(r.id.to_owned()),
+            Self::Dispute(d) => Some(d.id.to_owned()),
         }
     }
 }

crates/router/src/connector/adyen.rs

@@ -2,6 +2,7 @@ mod transformers;
 
 use std::fmt::Debug;
 
+use api_models::webhooks::IncomingWebhookEvent;
 use base64::Engine;
 use error_stack::{IntoReport, ResultExt};
 use router_env::{instrument, tracing};
@@ -17,6 +18,7 @@ use crate::{
     types::{
         self,
         api::{self, ConnectorCommon},
+        transformers::ForeignFrom,
     },
     utils::{self, crypto, ByteSliceExt, BytesExt, OptionExt},
 };
@@ -719,27 +721,38 @@ impl api::IncomingWebhook for Adyen {
     ) -> CustomResult<api_models::webhooks::ObjectReferenceId, errors::ConnectorError> {
         let notif = get_webhook_object_from_body(request.body)
             .change_context(errors::ConnectorError::WebhookReferenceIdNotFound)?;
-        match notif.event_code {
-            adyen::WebhookEventCode::Authorisation => {
-                Ok(api_models::webhooks::ObjectReferenceId::PaymentId(
-                    api_models::payments::PaymentIdType::ConnectorTransactionId(
-                        notif.psp_reference,
-                    ),
-                ))
-            }
-            _ => Ok(api_models::webhooks::ObjectReferenceId::RefundId(
+        if adyen::is_transaction_event(&notif.event_code) {
+            return Ok(api_models::webhooks::ObjectReferenceId::PaymentId(
+                api_models::payments::PaymentIdType::ConnectorTransactionId(notif.psp_reference),
+            ));
+        }
+        if adyen::is_refund_event(&notif.event_code) {
+            return Ok(api_models::webhooks::ObjectReferenceId::RefundId(
                 api_models::webhooks::RefundIdType::ConnectorRefundId(notif.psp_reference),
-            )),
+            ));
         }
+        if adyen::is_chargeback_event(&notif.event_code) {
+            return Ok(api_models::webhooks::ObjectReferenceId::PaymentId(
+                api_models::payments::PaymentIdType::ConnectorTransactionId(
+                    notif
+                        .original_reference
+                        .ok_or(errors::ConnectorError::WebhookReferenceIdNotFound)?,
+                ),
+            ));
+        }
+        Err(errors::ConnectorError::WebhookReferenceIdNotFound).into_report()
     }
 
     fn get_webhook_event_type(
         &self,
         request: &api::IncomingWebhookRequestDetails<'_>,
-    ) -> CustomResult<api::IncomingWebhookEvent, errors::ConnectorError> {
+    ) -> CustomResult<IncomingWebhookEvent, errors::ConnectorError> {
         let notif = get_webhook_object_from_body(request.body)
             .change_context(errors::ConnectorError::WebhookEventTypeNotFound)?;
-        Ok(notif.event_code.into())
+        Ok(IncomingWebhookEvent::foreign_from((
+            notif.event_code,
+            notif.additional_data.dispute_status,
+        )))
     }
 
     fn get_webhook_resource_object(
@@ -767,4 +780,24 @@ impl api::IncomingWebhook for Adyen {
             "[accepted]".to_string(),
         ))
     }
+
+    fn get_dispute_details(
+        &self,
+        request: &api_models::webhooks::IncomingWebhookRequestDetails<'_>,
+    ) -> CustomResult<api::disputes::DisputePayload, errors::ConnectorError> {
+        let notif = get_webhook_object_from_body(request.body)
+            .change_context(errors::ConnectorError::WebhookBodyDecodingFailed)?;
+        Ok(api::disputes::DisputePayload {
+            amount: notif.amount.value.to_string(),
+            currency: notif.amount.currency,
+            dispute_stage: api_models::enums::DisputeStage::from(notif.event_code.clone()),
+            connector_dispute_id: notif.psp_reference,
+            connector_reason: notif.reason,
+            connector_reason_code: notif.additional_data.chargeback_reason_code,
+            challenge_required_by: notif.additional_data.defense_period_ends_at,
+            connector_status: notif.event_code.to_string(),
+            created_at: notif.event_date.clone(),
+            updated_at: notif.event_date,
+        })
+    }
 }