Applied clippy rules

src/main.rs

@@ -1,5 +1,5 @@
 #![feature(async_closure)]
-use std::{process, time::Duration, collections::HashMap};
+use std::{ process, time::Duration, collections::HashMap };
 
 use axum::{extract::FromRef, http::StatusCode, routing::post, Json, Router, response::IntoResponse};
 
@@ -14,6 +14,7 @@ use automation::{
 };
 use dotenvy::dotenv;
 use rumqttc::{AsyncClient, MqttOptions, Transport, matches};
+use tokio::task::JoinHandle;
 use tracing::{debug, error, info, metadata::LevelFilter};
 use futures::future::join_all;
 
@@ -92,6 +93,60 @@ async fn app() -> anyhow::Result<()> {
         debug_bridge::start(presence.clone(), light_sensor.clone(), config, client.clone());
     }
 
+    // Super hacky implementation for the washing machine, just for testing
+    {
+        let mut handle = None::<JoinHandle<()>>;
+        let mut mqtt = mqtt.subscribe();
+        client.subscribe("zigbee2mqtt/bathroom/washing", rumqttc::QoS::AtLeastOnce).await.unwrap();
+        tokio::spawn(async move {
+            if let Some(ntfy) = ntfy {
+                loop {
+                    let message = mqtt.recv().await.unwrap();
+
+                    if !matches(&message.topic, "zigbee2mqtt/bathroom/washing") {
+                        continue;
+                    }
+
+                    let map: HashMap<String, serde_json::Value> = serde_json::from_slice(&message.payload).unwrap();
+                    debug!("Test: {:?}", map);
+
+                    let strength = match map.get("strength").map(|value| value.as_i64().unwrap()) {
+                        Some(s) => s,
+                        None => continue,
+                    };
+
+                    if strength > 15 {
+                        debug!("Strength over 15");
+
+                        // Update of strength over 15 which means we are still running, cancel any
+                        // running timer
+                        if let Some(handle) = handle.take() {
+                            handle.abort();
+                        }
+
+                        // Start a new timer, if the timer runs out we have not had an update of
+                        // more then 15 in the last timeout period, assume we are done, notify user
+                        let ntfy = ntfy.clone();
+                        handle = Some(
+                            tokio::spawn(async move {
+                                debug!("Starting timeout of 10 min for washing machine...");
+                                tokio::time::sleep(Duration::from_secs(10*60)).await;
+                                debug!("Notifying user!");
+
+                                let notification = ntfy::Notification::new()
+                                    .set_title("Laundy is done")
+                                    .set_message("Do not forget to hang it!")
+                                    .set_priority(ntfy::Priority::High);
+
+                                ntfy.send(notification).await.ok();
+                            })
+                        );
+                    }
+                }
+            }
+        });
+    }
+
     let devices = devices::start(mqtt.subscribe(), presence.clone(), light_sensor.clone());
     join_all(
         config
@@ -125,7 +180,7 @@ async fn app() -> anyhow::Result<()> {
 
             debug!(username = user.preferred_username, "{result:#?}");
 
-            return (StatusCode::OK, Json(result)).into_response();
+            (StatusCode::OK, Json(result)).into_response()
         }),
     );