Cleanup

src/funcs.rs

@@ -1,30 +0,0 @@
-use poise::serenity_prelude::{ActivityData, OnlineStatus};
-
-use crate::types::ServerResponse;
-
-pub fn set_presence(ctx: &poise::serenity_prelude::Context, status: ServerResponse) {
-    ctx.set_presence(
-        Some(ActivityData::custom(match status.online() {
-            true => {
-                format!(
-                    "{}/{} players online {}",
-                    status.players().unwrap(),
-                    status.max().unwrap(),
-                    if let Some(version) = status.version() {
-                        format!("v{}", version)
-                    } else {
-                        "".into()
-                    }
-                )
-            }
-            false => "Server offline!".to_string(),
-        })),
-        match status.online() {
-            true => match status.is_full() {
-                true => OnlineStatus::Idle,
-                false => OnlineStatus::Online,
-            },
-            false => OnlineStatus::DoNotDisturb,
-        },
-    );
-}

src/handlers/minecraft.rs

@@ -19,6 +19,7 @@ struct ApiResponsePlayers {
 }
 
 #[derive(Deserialize, Debug)]
+#[allow(dead_code)]
 struct Motd {
     raw: Vec<String>,
     clean: Vec<String>,
@@ -26,6 +27,7 @@ struct Motd {
 }
 
 #[derive(Debug)]
+#[allow(dead_code)]
 pub struct OnlineResponse {
     searchable_name: String,
     reported_name: String,
@@ -47,9 +49,18 @@ impl ServerOnlineResponse for OnlineResponse {
     fn version(&self) -> &String {
         &self.version
     }
+
+    fn readable_name(&self) -> &String {
+        &self.clean_name
+    }
+
+    fn searchable_name(&self) -> &String {
+        &self.searchable_name
+    }
 }
 
 pub struct Server {
+    #[allow(dead_code)]
     token: String,
     addr: Url,
 }
@@ -86,22 +97,21 @@ impl ServerInfo for Server {
                 let json = answer.json::<ApiResponse>().await.unwrap();
                 //println!("{}", answer.text().await.unwrap());
                 //ServerResponse::Offline
-                
+
                 match json.online {
                     true => {
                         let motd = json.motd.as_ref().unwrap();
                         self::ServerResponse::Online(OnlineResponse {
-                        searchable_name: motd.clean.get(0).unwrap().into(),
+                            searchable_name: self.addr.host().unwrap().to_string(),
-                        reported_name: motd.clean.get(0).unwrap().into(),
+                            reported_name: motd.clean.first().unwrap().into(),
-                        clean_name: motd.clean.get(0).unwrap().into(),
+                            clean_name: motd.clean.first().unwrap().into(),
-                        players_online: json.players.unwrap().online,
+                            players_online: json.players.unwrap().online,
-                        player_limit: json.players.unwrap().max,
+                            player_limit: json.players.unwrap().max,
-                        version: json.version.unwrap(),
+                            version: json.version.unwrap(),
-                })
+                        })
                     }
                     false => ServerResponse::Offline,
                 }
-                
             }
         }
     }

src/main.rs

@@ -1,17 +1,30 @@
 mod handlers;
 mod types;
 
-use crate::{handlers::minecraft, types::ServerInfo};
+use crate::{
-
+    handlers::minecraft,
-use tokio;
+    types::{ServerInfo, ServerOnlineResponse, ServerResponse},
+};
 
 #[tokio::main]
 async fn main() {
-    println!("Hello world!");
     let mc = minecraft::Server::new(
         "foo".into(),
         "http://dawn.shibedrill.site".try_into().unwrap(),
     );
     let results = mc.poll().await;
-    println!("{:#?}", results);
+    match results {
+        ServerResponse::Error(err) => println!("Error: {}", err),
+        ServerResponse::Offline => println!("Offline"),
+        ServerResponse::Online(online_info) => {
+            println!(
+                "Name: {}\nAddress: {}\nVersion: {}\nPlayers: {}/{}",
+                online_info.readable_name(),
+                online_info.searchable_name(),
+                online_info.version(),
+                online_info.players_online(),
+                online_info.player_limit()
+            )
+        }
+    }
 }

src/types.rs

@@ -1,4 +1,3 @@
-use std::net::IpAddr;
 use url::Url;
 
 #[derive(Debug)]
@@ -12,8 +11,11 @@ pub trait ServerOnlineResponse {
     fn players_online(&self) -> u64;
     fn player_limit(&self) -> u64;
     fn version(&self) -> &String;
+    fn searchable_name(&self) -> &String;
+    fn readable_name(&self) -> &String;
 }
 
+#[allow(dead_code)]
 pub trait ServerInfo {
     fn new(token: String, addr: Url) -> Self;