From ece5654c14e9fb4b3be3e4c0658165ff343010fc Mon Sep 17 00:00:00 2001
From: Paul-Christian Volkmer <code@pcvolkmer.de>
Date: Sun, 7 Sep 2025 11:39:09 +0200
Subject: [PATCH] refactor: replace nested if..let with let..else

---
 src/main.rs | 104 ++++++++++++++++++++++++++--------------------------
 1 file changed, 53 insertions(+), 51 deletions(-)

diff --git a/src/main.rs b/src/main.rs
index 5e6f3de..4a8bc38 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -136,63 +136,65 @@ async fn main() -> Result<(), Box<dyn Error>> {
         .create()?;
 
     while let Ok(msg) = consumer.recv().await {
-        if let Some(Ok(payload)) = msg.payload_view::<str>() {
-            if let Some(Ok(key)) = msg.key_view::<str>() {
-                let Ok(payload) = serde_json::from_str::<Mtb>(payload) else {
-                    error!("Error deserializing payload");
-                    continue;
+        let Some(Ok(payload)) = msg.payload_view::<str>() else {
+            error!("Error getting payload");
+            continue;
+        };
+
+        let Ok(payload) = serde_json::from_str::<Mtb>(payload) else {
+            error!("Error deserializing payload");
+            continue;
+        };
+
+        let Some(Ok(key)) = msg.key_view::<str>() else {
+            error!("Error getting key");
+            continue;
+        };
+
+        let request_id = extract_request_id(&msg).unwrap_or_default();
+
+        match handle_record(payload).await {
+            Err(err) => error!("{}", err),
+            Ok(response) => {
+                let response_payload = ResponsePayload {
+                    request_id: request_id.to_string(),
+                    status_code: response.status_code,
+                    status_body: serde_json::from_str::<Value>(&response.status_body)
+                        .unwrap_or(json!({})),
                 };
+                let response_payload = serde_json::to_string(&response_payload)?;
 
-                let request_id = extract_request_id(&msg).unwrap_or_default();
+                let response_record = FutureRecord::to(&CONFIG.response_topic)
+                    .key(key)
+                    .payload(&response_payload);
 
-                match handle_record(payload).await {
-                    Err(err) => error!("{}", err),
-                    Ok(response) => {
-                        let response_payload = ResponsePayload {
-                            request_id: request_id.to_string(),
-                            status_code: response.status_code,
-                            status_body: serde_json::from_str::<Value>(&response.status_body)
-                                .unwrap_or(json!({})),
-                        };
-                        let response_payload = serde_json::to_string(&response_payload)?;
-
-                        let response_record = FutureRecord::to(&CONFIG.response_topic)
-                            .key(key)
-                            .payload(&response_payload);
-
-                        match if let Some(headers) = msg.headers() {
-                            producer
-                                .send(
-                                    response_record.headers(headers.detach()),
-                                    Duration::from_secs(1),
-                                )
-                                .await
-                        } else {
-                            producer.send(response_record, Duration::from_secs(1)).await
-                        } {
-                            Ok(_) => {
-                                info!("Response for '{request_id}' sent successfully");
-                            }
-                            Err((err, _)) => {
-                                error!("Could not send response for '{request_id}': {err}");
-                            }
-                        }
-
-                        if response.has_valid_response_code() {
-                            consumer.commit_message(&msg, CommitMode::Async)?;
-                        } else {
-                            warn!(
-                                "Unexpected Status Code for Request '{}': HTTP {}",
-                                &request_id, response.status_code
-                            );
-                        }
+                match if let Some(headers) = msg.headers() {
+                    producer
+                        .send(
+                            response_record.headers(headers.detach()),
+                            Duration::from_secs(1),
+                        )
+                        .await
+                } else {
+                    producer.send(response_record, Duration::from_secs(1)).await
+                } {
+                    Ok(_) => {
+                        info!("Response for '{request_id}' sent successfully");
+                    }
+                    Err((err, _)) => {
+                        error!("Could not send response for '{request_id}': {err}");
                     }
                 }
-            } else {
-                error!("Error getting key");
+
+                if response.has_valid_response_code() {
+                    consumer.commit_message(&msg, CommitMode::Async)?;
+                } else {
+                    warn!(
+                        "Unexpected Status Code for Request '{}': HTTP {}",
+                        &request_id, response.status_code
+                    );
+                }
             }
-        } else {
-            error!("Error getting payload");
         }
     }