feat(router): added dispute retrieve and dispute list apis (#842)

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,4 +1,5 @@
-use masking::Serialize;
+use masking::{Deserialize, Serialize};
+use time::PrimitiveDateTime;
 use utoipa::ToSchema;
 
 use super::enums::{DisputeStage, DisputeStatus};
@@ -19,6 +20,8 @@ pub struct DisputeResponse {
     pub dispute_stage: DisputeStage,
     /// Status of the dispute
     pub dispute_status: DisputeStatus,
+    /// connector to which dispute is associated with
+    pub connector: String,
     /// Status of the dispute sent by connector
     pub connector_status: String,
     /// Dispute id sent by connector
@@ -36,3 +39,37 @@ pub struct DisputeResponse {
     /// Time at which dispute is received
     pub received_at: String,
 }
+
+#[derive(Clone, Debug, Deserialize, ToSchema)]
+#[serde(deny_unknown_fields)]
+pub struct DisputeListConstraints {
+    /// limit on the number of objects to return
+    pub limit: Option<i64>,
+    /// status of the dispute
+    pub dispute_status: Option<DisputeStatus>,
+    /// stage of the dispute
+    pub dispute_stage: Option<DisputeStage>,
+    /// reason for the dispute
+    pub reason: Option<String>,
+    /// connector linked to dispute
+    pub connector: Option<String>,
+    /// The time at which dispute is received
+    #[schema(example = "2022-09-10T10:11:12Z")]
+    pub received_time: Option<PrimitiveDateTime>,
+    /// Time less than the dispute received time
+    #[schema(example = "2022-09-10T10:11:12Z")]
+    #[serde(rename = "received_time.lt")]
+    pub received_time_lt: Option<PrimitiveDateTime>,
+    /// Time greater than the dispute received time
+    #[schema(example = "2022-09-10T10:11:12Z")]
+    #[serde(rename = "received_time.gt")]
+    pub received_time_gt: Option<PrimitiveDateTime>,
+    /// Time less than or equals to the dispute received time
+    #[schema(example = "2022-09-10T10:11:12Z")]
+    #[serde(rename = "received_time.lte")]
+    pub received_time_lte: Option<PrimitiveDateTime>,
+    /// Time greater than or equals to the dispute received time
+    #[schema(example = "2022-09-10T10:11:12Z")]
+    #[serde(rename = "received_time.gte")]
+    pub received_time_gte: Option<PrimitiveDateTime>,
+}

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

@@ -180,6 +180,8 @@ pub enum StripeErrorCode {
 
     #[error(error_type = StripeErrorType::HyperswitchError, code = "", message = "The connector provided in the request is incorrect or not available")]
     IncorrectConnectorNameGiven,
+    #[error(error_type = StripeErrorType::HyperswitchError, code = "", message = "No such {object}: '{id}'")]
+    ResourceMissing { object: String, id: String },
     // [#216]: https://github.com/juspay/hyperswitch/issues/216
     // Implement the remaining stripe error codes
 
@@ -460,6 +462,10 @@ impl From<errors::ApiErrorResponse> for StripeErrorCode {
             errors::ApiErrorResponse::DuplicatePayment { payment_id } => {
                 Self::DuplicatePayment { payment_id }
             }
+            errors::ApiErrorResponse::DisputeNotFound { dispute_id } => Self::ResourceMissing {
+                object: "dispute".to_owned(),
+                id: dispute_id,
+            },
             errors::ApiErrorResponse::NotSupported { .. } => Self::InternalServerError,
         }
     }
@@ -507,7 +513,8 @@ impl actix_web::ResponseError for StripeErrorCode {
             | Self::PaymentIntentMandateInvalid { .. }
             | Self::PaymentIntentUnexpectedState { .. }
             | Self::DuplicatePayment { .. }
-            | Self::IncorrectConnectorNameGiven => StatusCode::BAD_REQUEST,
+            | Self::IncorrectConnectorNameGiven
+            | Self::ResourceMissing { .. } => StatusCode::BAD_REQUEST,
             Self::RefundFailed
             | Self::InternalServerError
             | Self::MandateActive

crates/router/src/core.rs

@@ -3,6 +3,7 @@ pub mod api_keys;
 pub mod cards_info;
 pub mod configs;
 pub mod customers;
+pub mod disputes;
 pub mod errors;
 pub mod mandate;
 pub mod metrics;

crates/router/src/core/disputes.rs

@@ -0,0 +1,47 @@
+use router_env::{instrument, tracing};
+
+use super::errors::{self, RouterResponse, StorageErrorExt};
+use crate::{
+    routes::AppState,
+    services,
+    types::{api::disputes, storage, transformers::ForeignFrom},
+};
+
+#[instrument(skip(state))]
+pub async fn retrieve_dispute(
+    state: &AppState,
+    merchant_account: storage::MerchantAccount,
+    req: disputes::DisputeId,
+) -> RouterResponse<api_models::disputes::DisputeResponse> {
+    let dispute = state
+        .store
+        .find_dispute_by_merchant_id_dispute_id(&merchant_account.merchant_id, &req.dispute_id)
+        .await
+        .map_err(|error| {
+            error.to_not_found_response(errors::ApiErrorResponse::DisputeNotFound {
+                dispute_id: req.dispute_id,
+            })
+        })?;
+    let dispute_response = api_models::disputes::DisputeResponse::foreign_from(dispute);
+    Ok(services::ApplicationResponse::Json(dispute_response))
+}
+
+#[instrument(skip(state))]
+pub async fn retrieve_disputes_list(
+    state: &AppState,
+    merchant_account: storage::MerchantAccount,
+    constraints: api_models::disputes::DisputeListConstraints,
+) -> RouterResponse<Vec<api_models::disputes::DisputeResponse>> {
+    let disputes = state
+        .store
+        .find_disputes_by_merchant_id(&merchant_account.merchant_id, constraints)
+        .await
+        .map_err(|error| {
+            error.to_not_found_response(errors::ApiErrorResponse::InternalServerError)
+        })?;
+    let disputes_list = disputes
+        .into_iter()
+        .map(api_models::disputes::DisputeResponse::foreign_from)
+        .collect();
+    Ok(services::ApplicationResponse::Json(disputes_list))
+}

crates/router/src/core/errors/api_error_response.rs

@@ -158,6 +158,8 @@ pub enum ApiErrorResponse {
     IncorrectConnectorNameGiven,
     #[error(error_type = ErrorType::ObjectNotFound, code = "HE_04", message = "Address does not exist in our records")]
     AddressNotFound,
+    #[error(error_type = ErrorType::ObjectNotFound, code = "HE_04", message = "Dispute does not exist in our records")]
+    DisputeNotFound { dispute_id: String },
     #[error(error_type = ErrorType::InvalidRequestError, code = "HE_04", message = "Card with the provided iin does not exist")]
     InvalidCardIin,
     #[error(error_type = ErrorType::InvalidRequestError, code = "HE_04", message = "The provided card IIN length is invalid, please provide an iin with 6 or 8 digits")]
@@ -253,7 +255,8 @@ impl actix_web::ResponseError for ApiErrorResponse {
             Self::DuplicateMerchantAccount
             | Self::DuplicateMerchantConnectorAccount
             | Self::DuplicatePaymentMethod
-            | Self::DuplicateMandate => StatusCode::BAD_REQUEST, // 400
+            | Self::DuplicateMandate
+            | Self::DisputeNotFound { .. } => StatusCode::BAD_REQUEST, // 400
             Self::ReturnUrlUnavailable => StatusCode::SERVICE_UNAVAILABLE, // 503
             Self::PaymentNotSucceeded => StatusCode::BAD_REQUEST,          // 400
             Self::NotImplemented { .. } => StatusCode::NOT_IMPLEMENTED,    // 501
@@ -444,6 +447,9 @@ impl common_utils::errors::ErrorSwitch<api_models::errors::types::ApiErrorRespon
             Self::FlowNotSupported { flow, connector } => {
                 AER::BadRequest(ApiError::new("IR", 20, format!("{flow} flow not supported"), Some(Extra {connector: Some(connector.to_owned()), ..Default::default()}))) //FIXME: error message
             },
+            Self::DisputeNotFound { .. } => {
+                AER::NotFound(ApiError::new("HE", 2, "Dispute does not exist in our records", None))
+            },
         }
     }
 }

crates/router/src/core/webhooks.rs

@@ -228,9 +228,9 @@ async fn get_or_update_dispute_object(
     option_dispute: Option<storage_models::dispute::Dispute>,
     dispute_details: api::disputes::DisputePayload,
     merchant_id: &str,
-    payment_id: &str,
-    attempt_id: &str,
+    payment_attempt: &storage_models::payment_attempt::PaymentAttempt,
     event_type: api_models::webhooks::IncomingWebhookEvent,
+    connector_name: &str,
 ) -> CustomResult<storage_models::dispute::Dispute, errors::WebhooksFlowError> {
     let db = &*state.store;
     match option_dispute {
@@ -246,8 +246,9 @@ async fn get_or_update_dispute_object(
                     .foreign_try_into()
                     .into_report()
                     .change_context(errors::WebhooksFlowError::DisputeCoreFailed)?,
-                payment_id: payment_id.to_owned(),
-                attempt_id: attempt_id.to_owned(),
+                payment_id: payment_attempt.payment_id.to_owned(),
+                connector: connector_name.to_owned(),
+                attempt_id: payment_attempt.attempt_id.to_owned(),
                 merchant_id: merchant_id.to_owned(),
                 connector_status: dispute_details.connector_status,
                 connector_dispute_id: dispute_details.connector_dispute_id,
@@ -327,18 +328,12 @@ async fn disputes_incoming_webhook_flow<W: api::OutgoingWebhookType>(
             option_dispute,
             dispute_details,
             &merchant_account.merchant_id,
-            &payment_attempt.payment_id,
-            &payment_attempt.attempt_id,
+            &payment_attempt,
             event_type.clone(),
+            connector.id(),
         )
         .await?;
-        let disputes_response = Box::new(
-            dispute_object
-                .clone()
-                .foreign_try_into()
-                .into_report()
-                .change_context(errors::WebhooksFlowError::DisputeCoreFailed)?,
-        );
+        let disputes_response = Box::new(dispute_object.clone().foreign_into());
         let event_type: enums::EventType = dispute_object
             .dispute_status
             .foreign_try_into()

crates/router/src/db/dispute.rs

@@ -4,7 +4,7 @@ use super::{MockDb, Store};
 use crate::{
     connection,
     core::errors::{self, CustomResult},
-    types::storage,
+    types::storage::{self, DisputeDbExt},
 };
 
 #[async_trait::async_trait]
@@ -21,6 +21,18 @@ pub trait DisputeInterface {
         connector_dispute_id: &str,
     ) -> CustomResult<Option<storage::Dispute>, errors::StorageError>;
 
+    async fn find_dispute_by_merchant_id_dispute_id(
+        &self,
+        merchant_id: &str,
+        dispute_id: &str,
+    ) -> CustomResult<storage::Dispute, errors::StorageError>;
+
+    async fn find_disputes_by_merchant_id(
+        &self,
+        merchant_id: &str,
+        dispute_constraints: api_models::disputes::DisputeListConstraints,
+    ) -> CustomResult<Vec<storage::Dispute>, errors::StorageError>;
+
     async fn update_dispute(
         &self,
         this: storage::Dispute,
@@ -60,6 +72,30 @@ impl DisputeInterface for Store {
         .into_report()
     }
 
+    async fn find_dispute_by_merchant_id_dispute_id(
+        &self,
+        merchant_id: &str,
+        dispute_id: &str,
+    ) -> CustomResult<storage::Dispute, errors::StorageError> {
+        let conn = connection::pg_connection_read(self).await?;
+        storage::Dispute::find_by_merchant_id_dispute_id(&conn, merchant_id, dispute_id)
+            .await
+            .map_err(Into::into)
+            .into_report()
+    }
+
+    async fn find_disputes_by_merchant_id(
+        &self,
+        merchant_id: &str,
+        dispute_constraints: api_models::disputes::DisputeListConstraints,
+    ) -> CustomResult<Vec<storage::Dispute>, errors::StorageError> {
+        let conn = connection::pg_connection_read(self).await?;
+        storage::Dispute::filter_by_constraints(&conn, merchant_id, dispute_constraints)
+            .await
+            .map_err(Into::into)
+            .into_report()
+    }
+
     async fn update_dispute(
         &self,
         this: storage::Dispute,
@@ -92,6 +128,24 @@ impl DisputeInterface for MockDb {
         Err(errors::StorageError::MockDbError)?
     }
 
+    async fn find_dispute_by_merchant_id_dispute_id(
+        &self,
+        _merchant_id: &str,
+        _dispute_id: &str,
+    ) -> CustomResult<storage::Dispute, errors::StorageError> {
+        // TODO: Implement function for `MockDb`
+        Err(errors::StorageError::MockDbError)?
+    }
+
+    async fn find_disputes_by_merchant_id(
+        &self,
+        _merchant_id: &str,
+        _dispute_constraints: api_models::disputes::DisputeListConstraints,
+    ) -> CustomResult<Vec<storage::Dispute>, errors::StorageError> {
+        // TODO: Implement function for `MockDb`
+        Err(errors::StorageError::MockDbError)?
+    }
+
     async fn update_dispute(
         &self,
         _this: storage::Dispute,

crates/router/src/lib.rs

@@ -115,7 +115,8 @@ pub fn mk_app(
     {
         server_app = server_app
             .service(routes::MerchantAccount::server(state.clone()))
-            .service(routes::ApiKeys::server(state.clone()));
+            .service(routes::ApiKeys::server(state.clone()))
+            .service(routes::Disputes::server(state.clone()));
     }
 
     #[cfg(feature = "stripe")]

crates/router/src/openapi.rs

@@ -57,6 +57,7 @@ Never share your secret api keys. Keep them guarded and secure.
         (name = "Mandates", description = "Manage mandates"),
         (name = "Customers", description = "Create and manage customers"),
         (name = "Payment Methods", description = "Create and manage payment methods of customers"),
+        (name = "Disputes", description = "Manage disputes"),
         // (name = "API Key", description = "Create and manage API Keys"),
     ),
     paths(
@@ -100,6 +101,8 @@ Never share your secret api keys. Keep them guarded and secure.
         // crate::routes::api_keys::api_key_update,
         // crate::routes::api_keys::api_key_revoke,
         // crate::routes::api_keys::api_key_list,
+        crate::routes::disputes::retrieve_disputes_list,
+        crate::routes::disputes::retrieve_dispute,
     ),
     components(schemas(
         crate::types::api::refunds::RefundRequest,
@@ -143,9 +146,12 @@ Never share your secret api keys. Keep them guarded and secure.
         api_models::enums::PaymentExperience,
         api_models::enums::BankNames,
         api_models::enums::CardNetwork,
+        api_models::enums::DisputeStage,
+        api_models::enums::DisputeStatus,
         api_models::enums::CountryCode,
         api_models::admin::MerchantConnector,
         api_models::admin::PaymentMethodsEnabled,
+        api_models::disputes::DisputeResponse,
         api_models::payments::AddressDetails,
         api_models::payments::Address,
         api_models::payments::BankRedirectData,

crates/router/src/routes.rs

@@ -4,6 +4,7 @@ pub mod app;
 pub mod cards_info;
 pub mod configs;
 pub mod customers;
+pub mod disputes;
 pub mod ephemeral_key;
 pub mod health;
 pub mod mandates;
@@ -15,8 +16,9 @@ pub mod refunds;
 pub mod webhooks;
 
 pub use self::app::{
-    ApiKeys, AppState, Cards, Configs, Customers, EphemeralKey, Health, Mandates, MerchantAccount,
-    MerchantConnectorAccount, PaymentMethods, Payments, Payouts, Refunds, Webhooks,
+    ApiKeys, AppState, Cards, Configs, Customers, Disputes, EphemeralKey, Health, Mandates,
+    MerchantAccount, MerchantConnectorAccount, PaymentMethods, Payments, Payouts, Refunds,
+    Webhooks,
 };
 #[cfg(feature = "stripe")]
 pub use super::compatibility::stripe::StripeApis;