feat(disputes): add filters for disputes list

crates/api_models/src/disputes.rs

@@ -1,11 +1,13 @@
 use std::collections::HashMap;
 
+use common_utils::types::TimeRange;
 use masking::{Deserialize, Serialize};
+use serde::de::Error;
 use time::PrimitiveDateTime;
 use utoipa::ToSchema;
 
 use super::enums::{DisputeStage, DisputeStatus};
-use crate::files;
+use crate::{admin::MerchantConnectorInfo, enums, files};
 
 #[derive(Clone, Debug, Serialize, ToSchema, Eq, PartialEq)]
 pub struct DisputeResponse {
@@ -108,41 +110,51 @@ pub struct DisputeEvidenceBlock {
     pub file_metadata_response: files::FileMetadataResponse,
 }
 
-#[derive(Clone, Debug, Deserialize, ToSchema, Serialize)]
+#[derive(Clone, Debug, Deserialize, Serialize, ToSchema)]
 #[serde(deny_unknown_fields)]
-pub struct DisputeListConstraints {
-    /// limit on the number of objects to return
-    pub limit: Option<i64>,
+pub struct DisputeListGetConstraints {
+    /// The identifier for dispute
+    pub dispute_id: Option<String>,
+    /// The payment_id against which dispute is raised
+    pub payment_id: Option<common_utils::id_type::PaymentId>,
+    /// Limit on the number of objects to return
+    pub limit: Option<u32>,
+    /// The starting point within a list of object
+    pub offset: Option<u32>,
     /// The identifier for business profile
     #[schema(value_type = Option<String>)]
     pub profile_id: Option<common_utils::id_type::ProfileId>,
-    /// status of the dispute
-    pub dispute_status: Option<DisputeStatus>,
-    /// stage of the dispute
-    pub dispute_stage: Option<DisputeStage>,
-    /// reason for the dispute
+    /// The comma separated list of status of the disputes
+    #[serde(default, deserialize_with = "parse_comma_separated")]
+    pub dispute_status: Option<Vec<DisputeStatus>>,
+    /// The comma separated list of stages of the disputes
+    #[serde(default, deserialize_with = "parse_comma_separated")]
+    pub dispute_stage: Option<Vec<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>,
+    /// The comma separated list of connectors linked to disputes
+    #[serde(default, deserialize_with = "parse_comma_separated")]
+    pub connector: Option<Vec<String>>,
+    /// The comma separated list of currencies of the disputes
+    #[serde(default, deserialize_with = "parse_comma_separated")]
+    pub currency: Option<Vec<common_enums::Currency>>,
+    /// The merchant connector id to filter the disputes list
+    pub merchant_connector_id: Option<common_utils::id_type::MerchantConnectorAccountId>,
+    /// The time range for which objects are needed. TimeRange has two fields start_time and end_time from which objects can be filtered as per required scenarios (created_at, time less than, greater than etc).
+    #[serde(flatten)]
+    pub time_range: Option<TimeRange>,
+}
+
+#[derive(Clone, Debug, serde::Serialize, ToSchema)]
+pub struct DisputeListFilters {
+    /// The map of available connector filters, where the key is the connector name and the value is a list of MerchantConnectorInfo instances
+    pub connector: HashMap<String, Vec<MerchantConnectorInfo>>,
+    /// The list of available currency filters
+    pub currency: Vec<enums::Currency>,
+    /// The list of available dispute status filters
+    pub dispute_status: Vec<DisputeStatus>,
+    /// The list of available dispute stage filters
+    pub dispute_stage: Vec<DisputeStage>,
 }
 
 #[derive(Default, Clone, Debug, Serialize, Deserialize, ToSchema)]
@@ -216,3 +228,19 @@ pub struct DisputesAggregateResponse {
     /// Different status of disputes with their count
     pub status_with_count: HashMap<DisputeStatus, i64>,
 }
+
+fn parse_comma_separated<'de, D, T>(v: D) -> Result<Option<Vec<T>>, D::Error>
+where
+    D: serde::Deserializer<'de>,
+    T: std::str::FromStr,
+    <T as std::str::FromStr>::Err: std::fmt::Debug + std::fmt::Display + std::error::Error,
+{
+    let output = Option::<&str>::deserialize(v)?;
+    output
+        .map(|s| {
+            s.split(",")
+                .map(|x| x.parse::<T>().map_err(D::Error::custom))
+                .collect::<Result<_, _>>()
+        })
+        .transpose()
+}

crates/api_models/src/events.rs

@@ -73,7 +73,7 @@ impl_api_event_type!(
         RetrievePaymentLinkRequest,
         PaymentLinkListConstraints,
         MandateId,
-        DisputeListConstraints,
+        DisputeListGetConstraints,
         RetrieveApiKeyResponse,
         ProfileResponse,
         ProfileUpdate,
@@ -168,3 +168,9 @@ impl ApiEventMetric for PaymentMethodIntentCreate {
         Some(ApiEventsType::PaymentMethodCreate)
     }
 }
+
+impl ApiEventMetric for DisputeListFilters {
+    fn get_api_event_type(&self) -> Option<ApiEventsType> {
+        Some(ApiEventsType::ResourceListAPI)
+    }
+}

crates/common_enums/src/enums.rs

@@ -1817,6 +1817,7 @@ pub enum CardNetwork {
     serde::Deserialize,
     serde::Serialize,
     strum::Display,
+    strum::EnumIter,
     strum::EnumString,
     ToSchema,
 )]

crates/hyperswitch_domain_models/src/disputes.rs

@@ -0,0 +1,89 @@
+use crate::errors;
+
+pub struct DisputeListConstraints {
+    pub dispute_id: Option<String>,
+    pub payment_id: Option<common_utils::id_type::PaymentId>,
+    pub limit: Option<u32>,
+    pub offset: Option<u32>,
+    pub profile_id: Option<Vec<common_utils::id_type::ProfileId>>,
+    pub dispute_status: Option<Vec<common_enums::DisputeStatus>>,
+    pub dispute_stage: Option<Vec<common_enums::DisputeStage>>,
+    pub reason: Option<String>,
+    pub connector: Option<Vec<String>>,
+    pub merchant_connector_id: Option<common_utils::id_type::MerchantConnectorAccountId>,
+    pub currency: Option<Vec<common_enums::Currency>>,
+    pub time_range: Option<common_utils::types::TimeRange>,
+}
+
+impl
+    TryFrom<(
+        api_models::disputes::DisputeListGetConstraints,
+        Option<Vec<common_utils::id_type::ProfileId>>,
+    )> for DisputeListConstraints
+{
+    type Error = error_stack::Report<errors::api_error_response::ApiErrorResponse>;
+    fn try_from(
+        (value, auth_profile_id_list): (
+            api_models::disputes::DisputeListGetConstraints,
+            Option<Vec<common_utils::id_type::ProfileId>>,
+        ),
+    ) -> Result<Self, Self::Error> {
+        let api_models::disputes::DisputeListGetConstraints {
+            dispute_id,
+            payment_id,
+            limit,
+            offset,
+            profile_id,
+            dispute_status,
+            dispute_stage,
+            reason,
+            connector,
+            merchant_connector_id,
+            currency,
+            time_range,
+        } = value;
+        let profile_id_from_request_body = profile_id;
+        // Match both the profile ID from the request body and the list of authenticated profile IDs coming from auth layer
+        let profile_id_list = match (profile_id_from_request_body, auth_profile_id_list) {
+            (None, None) => None,
+            // Case when the request body profile ID is None, but authenticated profile IDs are available, return the auth list
+            (None, Some(auth_profile_id_list)) => Some(auth_profile_id_list),
+            // Case when the request body profile ID is provided, but the auth list is None, create a vector with the request body profile ID
+            (Some(profile_id_from_request_body), None) => Some(vec![profile_id_from_request_body]),
+            (Some(profile_id_from_request_body), Some(auth_profile_id_list)) => {
+                // Check if the profile ID from the request body is present in the authenticated profile ID list
+                let profile_id_from_request_body_is_available_in_auth_profile_id_list =
+                    auth_profile_id_list.contains(&profile_id_from_request_body);
+
+                if profile_id_from_request_body_is_available_in_auth_profile_id_list {
+                    Some(vec![profile_id_from_request_body])
+                } else {
+                    // If the profile ID is not valid, return an error indicating access is not available
+                    return Err(error_stack::Report::new(
+                        errors::api_error_response::ApiErrorResponse::PreconditionFailed {
+                            message: format!(
+                                "Access not available for the given profile_id {:?}",
+                                profile_id_from_request_body
+                            ),
+                        },
+                    ));
+                }
+            }
+        };
+
+        Ok(Self {
+            dispute_id,
+            payment_id,
+            limit,
+            offset,
+            profile_id: profile_id_list,
+            dispute_status,
+            dispute_stage,
+            reason,
+            connector,
+            merchant_connector_id,
+            currency,
+            time_range,
+        })
+    }
+}

crates/hyperswitch_domain_models/src/lib.rs

@@ -3,6 +3,7 @@ pub mod behaviour;
 pub mod business_profile;
 pub mod consts;
 pub mod customer;
+pub mod disputes;
 pub mod errors;
 pub mod mandates;
 pub mod merchant_account;

crates/router/src/core/disputes.rs

@@ -1,11 +1,13 @@
-use api_models::{disputes as dispute_models, files as files_api_models};
+use std::collections::HashMap;
+
+use api_models::{
+    admin::MerchantConnectorInfo, disputes as dispute_models, files as files_api_models,
+};
 use common_utils::ext_traits::{Encode, ValueExt};
 use error_stack::ResultExt;
 use router_env::{instrument, tracing};
-pub mod transformers;
-use std::collections::HashMap;
-
 use strum::IntoEnumIterator;
+pub mod transformers;
 
 use super::{
     errors::{self, ConnectorErrorExt, RouterResponse, StorageErrorExt},
@@ -48,12 +50,13 @@ pub async fn retrieve_dispute(
 pub async fn retrieve_disputes_list(
     state: SessionState,
     merchant_account: domain::MerchantAccount,
-    _profile_id_list: Option<Vec<common_utils::id_type::ProfileId>>,
-    constraints: api_models::disputes::DisputeListConstraints,
+    profile_id_list: Option<Vec<common_utils::id_type::ProfileId>>,
+    constraints: api_models::disputes::DisputeListGetConstraints,
 ) -> RouterResponse<Vec<api_models::disputes::DisputeResponse>> {
+    let dispute_list_constraints = &(constraints.clone(), profile_id_list.clone()).try_into()?;
     let disputes = state
         .store
-        .find_disputes_by_merchant_id(merchant_account.get_id(), constraints)
+        .find_disputes_by_constraints(merchant_account.get_id(), dispute_list_constraints)
         .await
         .to_not_found_response(errors::ApiErrorResponse::InternalServerError)
         .attach_printable("Unable to retrieve disputes")?;
@@ -76,6 +79,59 @@ pub async fn accept_dispute(
     todo!()
 }
 
+#[instrument(skip(state))]
+pub async fn get_filters_for_disputes(
+    state: SessionState,
+    merchant_account: domain::MerchantAccount,
+    profile_id_list: Option<Vec<common_utils::id_type::ProfileId>>,
+) -> RouterResponse<api_models::disputes::DisputeListFilters> {
+    let merchant_connector_accounts = if let services::ApplicationResponse::Json(data) =
+        super::admin::list_payment_connectors(
+            state,
+            merchant_account.get_id().to_owned(),
+            profile_id_list,
+        )
+        .await?
+    {
+        data
+    } else {
+        return Err(error_stack::report!(
+            errors::ApiErrorResponse::InternalServerError
+        ))
+        .attach_printable(
+            "Failed to retrieve merchant connector accounts while fetching dispute list filters.",
+        );
+    };
+
+    let connector_map = merchant_connector_accounts
+        .into_iter()
+        .filter_map(|merchant_connector_account| {
+            merchant_connector_account
+                .connector_label
+                .clone()
+                .map(|label| {
+                    let info = merchant_connector_account.to_merchant_connector_info(&label);
+                    (merchant_connector_account.connector_name, info)
+                })
+        })
+        .fold(
+            HashMap::new(),
+            |mut map: HashMap<String, Vec<MerchantConnectorInfo>>, (connector_name, info)| {
+                map.entry(connector_name).or_default().push(info);
+                map
+            },
+        );
+
+    Ok(services::ApplicationResponse::Json(
+        api_models::disputes::DisputeListFilters {
+            connector: connector_map,
+            currency: storage_enums::Currency::iter().collect(),
+            dispute_status: storage_enums::DisputeStatus::iter().collect(),
+            dispute_stage: storage_enums::DisputeStage::iter().collect(),
+        },
+    ))
+}
+
 #[cfg(feature = "v1")]
 #[instrument(skip(state))]
 pub async fn accept_dispute(