Implemented basic stats functionality and started setting up menu

src/network/mod.rs

@@ -11,6 +11,7 @@ pub(crate) mod radarr;
 pub enum RadarrEvent {
   HealthCheck,
   GetOverview,
+  GetStatus,
 }
 
 pub struct Network<'a> {

src/network/radarr.rs

@@ -1,3 +1,5 @@
+use std::borrow::Borrow;
+
 use anyhow::Result;
 use log::{debug, error};
 use reqwest::RequestBuilder;
@@ -9,71 +11,116 @@ use crate::app::RadarrConfig;
 use crate::network::{Network, RadarrEvent};
 
 impl RadarrEvent {
-    const fn resource(self) -> &'static str {
-        match self {
-            RadarrEvent::HealthCheck => "/health",
-            RadarrEvent::GetOverview => "/diskspace"
-        }
+  const fn resource(self) -> &'static str {
+    match self {
+      RadarrEvent::HealthCheck => "/health",
+      RadarrEvent::GetOverview => "/diskspace",
+      RadarrEvent::GetStatus => "/system/status",
     }
+  }
 }
 
 #[derive(Serialize, Deserialize, Debug)]
 #[serde(rename_all = "camelCase")]
 pub struct DiskSpace {
-    pub path: String,
-    pub label: String,
-    pub free_space: Number,
-    pub total_space: Number
+  pub path: String,
+  pub label: String,
+  pub free_space: Number,
+  pub total_space: Number,
+}
+
+#[derive(Deserialize, Debug)]
+pub struct SystemStatus {
+  version: String,
 }
 
 impl<'a> Network<'a> {
-    pub async fn handle_radarr_event(&self, radarr_event: RadarrEvent) {
-        match radarr_event {
-            RadarrEvent::HealthCheck => {
-                self.healthcheck(RadarrEvent::HealthCheck.resource()).await;
-            }
-            RadarrEvent::GetOverview => {
-                match self.diskspace(RadarrEvent::GetOverview.resource()).await {
-                    Ok(disk_space_vec) => {
-                        let mut app = self.app.lock().await;
-                        app.data.radarr_data = RadarrData::from(&disk_space_vec[0]);
-                    }
-                    Err(e) => {
-                        error!("Failed to fetch disk space. {:?}", e);
-                    }
-                }
-            }
+  pub async fn handle_radarr_event(&self, radarr_event: RadarrEvent) {
+    match radarr_event {
+      RadarrEvent::HealthCheck => {
+        self.healthcheck(RadarrEvent::HealthCheck.resource()).await;
+      }
+      RadarrEvent::GetOverview => match self.diskspace(RadarrEvent::GetOverview.resource()).await {
+        Ok(disk_space_vec) => {
+          let mut app = self.app.lock().await;
+          let DiskSpace {
+            free_space,
+            total_space,
+            ..
+          } = &disk_space_vec[0];
+          app.data.radarr_data.free_space = free_space.as_u64().unwrap();
+          app.data.radarr_data.total_space = total_space.as_u64().unwrap();
         }
-
-        let mut app = self.app.lock().await;
-        app.reset();
-    }
-
-    async fn healthcheck(&self, resource: &str) {
-        if let Err(e) = self.call_radarr_api(resource).await.send().await {
-            error!("Healthcheck failed. {:?}", e)
+        Err(e) => {
+          error!("Failed to fetch disk space. {:?}", e);
         }
+      },
+      RadarrEvent::GetStatus => match self.status(RadarrEvent::GetStatus.resource()).await {
+        Ok(system_status) => {
+          let mut app = self.app.lock().await;
+          app.data.radarr_data.version = system_status.version;
+        }
+        Err(e) => {
+          error!("Failed to fetch system status. {:?}", e);
+        }
+      },
     }
 
-    async fn diskspace(&self, resource: &str) -> Result<Vec<DiskSpace>> {
-        debug!("Handling diskspace event: {:?}", resource);
+    let mut app = self.app.lock().await;
+    app.reset();
+  }
 
-        Ok(
-            self.call_radarr_api(resource)
-                .await
-                .send()
-                .await?
-                .json::<Vec<DiskSpace>>()
-                .await?
-        )
+  async fn healthcheck(&self, resource: &str) {
+    if let Err(e) = self.call_radarr_api(resource).await.send().await {
+      error!("Healthcheck failed. {:?}", e)
     }
+  }
 
-    async fn call_radarr_api(&self, resource: &str) -> RequestBuilder {
-        debug!("Creating RequestBuilder for resource: {:?}", resource);
-        let app = self.app.lock().await;
-        let RadarrConfig {  host, port, api_token } = &app.config.radarr;
+  async fn diskspace(&self, resource: &str) -> Result<Vec<DiskSpace>> {
+    debug!("Handling diskspace event: {:?}", resource);
 
-        app.client.get(format!("http://{}:{}/api/v3{}", host, port.unwrap_or(7878), resource))
-            .header("X-Api-Key", api_token)
-    }
-}
+    Ok(
+      self
+        .call_radarr_api(resource)
+        .await
+        .send()
+        .await?
+        .json::<Vec<DiskSpace>>()
+        .await?,
+    )
+  }
+
+  async fn status(&self, resource: &str) -> Result<SystemStatus> {
+    debug!("Handling system status event: {:?}", resource);
+
+    Ok(
+      self
+        .call_radarr_api(resource)
+        .await
+        .send()
+        .await?
+        .json::<SystemStatus>()
+        .await?,
+    )
+  }
+
+  async fn call_radarr_api(&self, resource: &str) -> RequestBuilder {
+    debug!("Creating RequestBuilder for resource: {:?}", resource);
+    let app = self.app.lock().await;
+    let RadarrConfig {
+      host,
+      port,
+      api_token,
+    } = &app.config.radarr;
+
+    app
+      .client
+      .get(format!(
+        "http://{}:{}/api/v3{}",
+        host,
+        port.unwrap_or(7878),
+        resource
+      ))
+      .header("X-Api-Key", api_token)
+  }
+}