feat(routing): elimination routing switch for toggling the feature

api-reference-v2/openapi_spec.json

@@ -1278,7 +1278,7 @@
         ],
         "summary": "Routing - Create",
         "description": "Create a routing algorithm",
-        "operationId": "Create a routing algprithm",
+        "operationId": "Create a routing algorithm",
         "requestBody": {
           "content": {
             "application/json": {

api-reference/openapi_spec.json

@@ -3931,7 +3931,7 @@
         ],
         "summary": "Routing - Toggle success based dynamic routing for profile",
         "description": "Create a success based dynamic routing algorithm",
-        "operationId": "Toggle success based dynamic routing algprithm",
+        "operationId": "Toggle success based dynamic routing algorithm",
         "parameters": [
           {
             "name": "account_id",
@@ -3957,7 +3957,7 @@
             "description": "Feature to enable for success based routing",
             "required": true,
             "schema": {
-              "$ref": "#/components/schemas/SuccessBasedRoutingFeatures"
+              "$ref": "#/components/schemas/DynamicRoutingFeatures"
             }
           }
         ],
@@ -10236,6 +10236,14 @@
           }
         }
       },
+      "DynamicRoutingFeatures": {
+        "type": "string",
+        "enum": [
+          "metrics",
+          "dynamic_connector_selection",
+          "none"
+        ]
+      },
       "EnabledPaymentMethod": {
         "type": "object",
         "description": "Object for EnabledPaymentMethod",
@@ -23852,14 +23860,6 @@
           "destination"
         ]
       },
-      "SuccessBasedRoutingFeatures": {
-        "type": "string",
-        "enum": [
-          "metrics",
-          "dynamic_connector_selection",
-          "none"
-        ]
-      },
       "SurchargeDetailsResponse": {
         "type": "object",
         "required": [
@@ -24076,6 +24076,28 @@
           }
         }
       },
+      "ToggleDynamicRoutingPath": {
+        "type": "object",
+        "required": [
+          "profile_id"
+        ],
+        "properties": {
+          "profile_id": {
+            "type": "string"
+          }
+        }
+      },
+      "ToggleDynamicRoutingQuery": {
+        "type": "object",
+        "required": [
+          "enable"
+        ],
+        "properties": {
+          "enable": {
+            "$ref": "#/components/schemas/DynamicRoutingFeatures"
+          }
+        }
+      },
       "ToggleKVRequest": {
         "type": "object",
         "required": [
@@ -24109,28 +24131,6 @@
           }
         }
       },
-      "ToggleSuccessBasedRoutingPath": {
-        "type": "object",
-        "required": [
-          "profile_id"
-        ],
-        "properties": {
-          "profile_id": {
-            "type": "string"
-          }
-        }
-      },
-      "ToggleSuccessBasedRoutingQuery": {
-        "type": "object",
-        "required": [
-          "enable"
-        ],
-        "properties": {
-          "enable": {
-            "$ref": "#/components/schemas/SuccessBasedRoutingFeatures"
-          }
-        }
-      },
       "TouchNGoRedirection": {
         "type": "object"
       },

crates/api_models/src/events/routing.rs

@@ -6,7 +6,7 @@ use crate::routing::{
     RoutingLinkWrapper, RoutingPayloadWrapper, RoutingRetrieveLinkQuery,
     RoutingRetrieveLinkQueryWrapper, RoutingRetrieveQuery, SuccessBasedRoutingConfig,
     SuccessBasedRoutingPayloadWrapper, SuccessBasedRoutingUpdateConfigQuery,
-    ToggleSuccessBasedRoutingQuery, ToggleSuccessBasedRoutingWrapper,
+    ToggleDynamicRoutingQuery, ToggleDynamicRoutingWrapper,
 };
 
 impl ApiEventMetric for RoutingKind {
@@ -79,7 +79,7 @@ impl ApiEventMetric for RoutingRetrieveLinkQueryWrapper {
     }
 }
 
-impl ApiEventMetric for ToggleSuccessBasedRoutingQuery {
+impl ApiEventMetric for ToggleDynamicRoutingQuery {
     fn get_api_event_type(&self) -> Option<ApiEventsType> {
         Some(ApiEventsType::Routing)
     }
@@ -97,7 +97,7 @@ impl ApiEventMetric for SuccessBasedRoutingPayloadWrapper {
     }
 }
 
-impl ApiEventMetric for ToggleSuccessBasedRoutingWrapper {
+impl ApiEventMetric for ToggleDynamicRoutingWrapper {
     fn get_api_event_type(&self) -> Option<ApiEventsType> {
         Some(ApiEventsType::Routing)
     }

crates/api_models/src/routing.rs

@@ -523,18 +523,118 @@ pub struct DynamicAlgorithmWithTimestamp<T> {
 #[derive(Debug, Default, Clone, serde::Serialize, serde::Deserialize)]
 pub struct DynamicRoutingAlgorithmRef {
     pub success_based_algorithm: Option<SuccessBasedAlgorithm>,
+    pub elimination_routing_algorithm: Option<EliminationRoutingAlgorithm>,
+}
+
+pub trait DynamicRoutingAlgoAccessor {
+    fn get_algorithm_id_with_timestamp(
+        self,
+    ) -> DynamicAlgorithmWithTimestamp<common_utils::id_type::RoutingId>;
+    fn get_enabled_features(&mut self) -> &mut DynamicRoutingFeatures;
+}
+
+impl DynamicRoutingAlgoAccessor for SuccessBasedAlgorithm {
+    fn get_algorithm_id_with_timestamp(
+        self,
+    ) -> DynamicAlgorithmWithTimestamp<common_utils::id_type::RoutingId> {
+        self.algorithm_id_with_timestamp
+    }
+    fn get_enabled_features(&mut self) -> &mut DynamicRoutingFeatures {
+        &mut self.enabled_feature
+    }
+}
+
+impl DynamicRoutingAlgoAccessor for EliminationRoutingAlgorithm {
+    fn get_algorithm_id_with_timestamp(
+        self,
+    ) -> DynamicAlgorithmWithTimestamp<common_utils::id_type::RoutingId> {
+        self.algorithm_id_with_timestamp
+    }
+    fn get_enabled_features(&mut self) -> &mut DynamicRoutingFeatures {
+        &mut self.enabled_feature
+    }
+}
+
+impl EliminationRoutingAlgorithm {
+    pub fn new(
+        algorithm_id_with_timestamp: DynamicAlgorithmWithTimestamp<
+            common_utils::id_type::RoutingId,
+        >,
+    ) -> Self {
+        Self {
+            algorithm_id_with_timestamp,
+            enabled_feature: DynamicRoutingFeatures::None,
+        }
+    }
+}
+
+impl SuccessBasedAlgorithm {
+    pub fn new(
+        algorithm_id_with_timestamp: DynamicAlgorithmWithTimestamp<
+            common_utils::id_type::RoutingId,
+        >,
+    ) -> Self {
+        Self {
+            algorithm_id_with_timestamp,
+            enabled_feature: DynamicRoutingFeatures::None,
+        }
+    }
+}
+
+impl DynamicRoutingAlgorithmRef {
+    pub fn update(&mut self, new: Self) {
+        if let Some(elimination_routing_algorithm) = new.elimination_routing_algorithm {
+            self.elimination_routing_algorithm = Some(elimination_routing_algorithm)
+        }
+        if let Some(success_based_algorithm) = new.success_based_algorithm {
+            self.success_based_algorithm = Some(success_based_algorithm)
+        }
+    }
+
+    pub fn update_specific_ref(
+        &mut self,
+        algo_type: DynamicRoutingType,
+        feature_to_enable: DynamicRoutingFeatures,
+    ) {
+        match algo_type {
+            DynamicRoutingType::SuccessRateBasedRouting => {
+                self.success_based_algorithm
+                    .as_mut()
+                    .map(|algo| algo.enabled_feature = feature_to_enable);
+            }
+            DynamicRoutingType::EliminationRouting => {
+                self.elimination_routing_algorithm
+                    .as_mut()
+                    .map(|algo| algo.enabled_feature = feature_to_enable);
+            }
+        }
+    }
 }
 
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct SuccessBasedAlgorithm {
     pub algorithm_id_with_timestamp:
         DynamicAlgorithmWithTimestamp<common_utils::id_type::RoutingId>,
     #[serde(default)]
-    pub enabled_feature: SuccessBasedRoutingFeatures,
+    pub enabled_feature: DynamicRoutingFeatures,
+}
+
+#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
+pub struct EliminationRoutingAlgorithm {
+    pub algorithm_id_with_timestamp:
+        DynamicAlgorithmWithTimestamp<common_utils::id_type::RoutingId>,
+    #[serde(default)]
+    pub enabled_feature: DynamicRoutingFeatures,
+}
+
+impl EliminationRoutingAlgorithm {
+    pub fn update_enabled_features(&mut self, feature_to_enable: DynamicRoutingFeatures) {
+        self.enabled_feature = feature_to_enable
+    }
 }
 
 impl SuccessBasedAlgorithm {
-    pub fn update_enabled_features(&mut self, feature_to_enable: SuccessBasedRoutingFeatures) {
+    pub fn update_enabled_features(&mut self, feature_to_enable: DynamicRoutingFeatures) {
         self.enabled_feature = feature_to_enable
     }
 }
@@ -543,26 +643,40 @@ impl DynamicRoutingAlgorithmRef {
     pub fn update_algorithm_id(
         &mut self,
         new_id: common_utils::id_type::RoutingId,
-        enabled_feature: SuccessBasedRoutingFeatures,
+        enabled_feature: DynamicRoutingFeatures,
+        dynamic_routing_type: DynamicRoutingType,
     ) {
-        self.success_based_algorithm = Some(SuccessBasedAlgorithm {
-            algorithm_id_with_timestamp: DynamicAlgorithmWithTimestamp {
-                algorithm_id: Some(new_id),
-                timestamp: common_utils::date_time::now_unix_timestamp(),
-            },
-            enabled_feature,
-        })
+        match dynamic_routing_type {
+            DynamicRoutingType::SuccessRateBasedRouting => {
+                self.success_based_algorithm = Some(SuccessBasedAlgorithm {
+                    algorithm_id_with_timestamp: DynamicAlgorithmWithTimestamp {
+                        algorithm_id: Some(new_id),
+                        timestamp: common_utils::date_time::now_unix_timestamp(),
+                    },
+                    enabled_feature,
+                })
+            }
+            DynamicRoutingType::EliminationRouting => {
+                self.elimination_routing_algorithm = Some(EliminationRoutingAlgorithm {
+                    algorithm_id_with_timestamp: DynamicAlgorithmWithTimestamp {
+                        algorithm_id: Some(new_id),
+                        timestamp: common_utils::date_time::now_unix_timestamp(),
+                    },
+                    enabled_feature,
+                })
+            }
+        };
     }
 }
 
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize, ToSchema)]
-pub struct ToggleSuccessBasedRoutingQuery {
-    pub enable: SuccessBasedRoutingFeatures,
+pub struct ToggleDynamicRoutingQuery {
+    pub enable: DynamicRoutingFeatures,
 }
 
 #[derive(Debug, Default, Clone, serde::Serialize, serde::Deserialize, PartialEq, Eq, ToSchema)]
 #[serde(rename_all = "snake_case")]
-pub enum SuccessBasedRoutingFeatures {
+pub enum DynamicRoutingFeatures {
     Metrics,
     DynamicConnectorSelection,
     #[default]
@@ -578,26 +692,52 @@ pub struct SuccessBasedRoutingUpdateConfigQuery {
 }
 
 #[derive(Clone, Debug, serde::Deserialize, serde::Serialize)]
-pub struct ToggleSuccessBasedRoutingWrapper {
+pub struct ToggleDynamicRoutingWrapper {
     pub profile_id: common_utils::id_type::ProfileId,
-    pub feature_to_enable: SuccessBasedRoutingFeatures,
+    pub feature_to_enable: DynamicRoutingFeatures,
 }
 
 #[derive(Clone, Debug, serde::Deserialize, serde::Serialize, ToSchema)]
-pub struct ToggleSuccessBasedRoutingPath {
+pub struct ToggleDynamicRoutingPath {
     #[schema(value_type = String)]
     pub profile_id: common_utils::id_type::ProfileId,
 }
+
+#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, ToSchema)]
+pub struct EliminationRoutingConfig {
+    pub params: Option<Vec<DynamicRoutingConfigParams>>,
+    // pub labels: Option<Vec<String>>,
+    pub elimination_analyser_config: Option<EliminationAnalyserConfig>,
+}
+
+#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, ToSchema)]
+pub struct EliminationAnalyserConfig {
+    pub bucket_size: Option<u32>,
+    pub bucket_ttl_in_mins: Option<f64>,
+}
+
+impl Default for EliminationRoutingConfig {
+    fn default() -> Self {
+        Self {
+            params: Some(vec![DynamicRoutingConfigParams::PaymentMethod]),
+            elimination_analyser_config: Some(EliminationAnalyserConfig {
+                bucket_size: Some(5),
+                bucket_ttl_in_mins: Some(2.0),
+            }),
+        }
+    }
+}
+
 #[derive(serde::Serialize, serde::Deserialize, Debug, Clone, ToSchema)]
 pub struct SuccessBasedRoutingConfig {
-    pub params: Option<Vec<SuccessBasedRoutingConfigParams>>,
+    pub params: Option<Vec<DynamicRoutingConfigParams>>,
     pub config: Option<SuccessBasedRoutingConfigBody>,
 }
 
 impl Default for SuccessBasedRoutingConfig {
     fn default() -> Self {
         Self {
-            params: Some(vec![SuccessBasedRoutingConfigParams::PaymentMethod]),
+            params: Some(vec![DynamicRoutingConfigParams::PaymentMethod]),
             config: Some(SuccessBasedRoutingConfigBody {
                 min_aggregates_size: Some(2),
                 default_success_rate: Some(100.0),
@@ -612,7 +752,7 @@ impl Default for SuccessBasedRoutingConfig {
 }
 
 #[derive(serde::Serialize, serde::Deserialize, Debug, Clone, ToSchema, strum::Display)]
-pub enum SuccessBasedRoutingConfigParams {
+pub enum DynamicRoutingConfigParams {
     PaymentMethod,
     PaymentMethodType,
     AuthenticationType,
@@ -643,6 +783,12 @@ pub struct SuccessBasedRoutingPayloadWrapper {
     pub profile_id: common_utils::id_type::ProfileId,
 }
 
+#[derive(Debug, Clone, strum::Display, serde::Serialize, serde::Deserialize)]
+pub enum DynamicRoutingType {
+    SuccessRateBasedRouting,
+    EliminationRouting,
+}
+
 impl SuccessBasedRoutingConfig {
     pub fn update(&mut self, new: Self) {
         if let Some(params) = new.params {