Reading owner ID from the application info

Adds logging of DM messages

src/commands/admin.rs

@@ -0,0 +1,4 @@
+
+use serenity::prelude::*;
+use serenity::model::prelude::*;
+use serenity::model::channel::Message;

src/commands/mod.rs

@@ -0,0 +1,24 @@
+// use serenity::async_trait;
+use serenity::prelude::*;
+use serenity::model::channel::Message;
+// use serenity::model::gateway::Ready;
+// use serenity::model::prelude::*;
+
+pub mod test;
+
+use crate::utils;
+
+pub async fn parse(ctx: Context, msg: Message)
+{
+    if let Some(server_id) = msg.guild_id
+    {        
+        if server_id == utils::ADMIN_SERVER_ID && msg.channel_id == utils::ADMIN_COMMAND_CHANNEL_ID
+        {
+            test::parse_command(ctx, msg, server_id).await;
+        }
+    }
+    else 
+    {
+        utils::Logger::log_message(ctx, &format!("DM Received from {}: {}", msg.author.name, msg.content)).await;
+    }
+}

src/commands/test.rs

@@ -0,0 +1,59 @@
+
+// use serenity::async_trait;
+use serenity::model::channel::Message;
+// use serenity::model::gateway::Ready;
+use serenity::prelude::*;
+use serenity::model::prelude::*;
+
+use crate::utils;
+
+
+pub async fn parse_command(ctx: Context, msg: Message, server_id: GuildId)
+{
+    
+    if server_id == utils::ADMIN_SERVER_ID
+    {
+        if msg.content == ".log_test"
+        {
+            utils::Logger::log_message(ctx, "This is a test log message!").await;
+            return;
+        }
+    }
+
+    if msg.content == ".role_test"
+    {
+        let test_role = RoleId(1129106677619228702 as u64);
+        if let Err(why) = server_id.edit_member(&ctx, msg.author, |m|
+            {
+                if let Some(mut member) = msg.member
+                {
+                    member.roles.push(test_role);
+                    return m.roles(member.roles);
+                }
+
+                m
+            }).await
+            {
+                utils::Logger::log_error(ctx, &format!("Error updating roles: {:?}", why)).await;
+            }
+            else
+            {
+                let role = &server_id.roles(&ctx).await.unwrap()[&test_role];
+                if let Err(why) = msg.channel_id.say(&ctx.http, format!("{} role added!", role)).await
+                {
+                    utils::Logger::log_error(ctx, &format!("Error sending message: {:?}", why)).await;
+                }
+            }
+            return;
+        }
+    
+
+    if msg.content == ".randomizer"
+    {
+        let item = utils::get_random_item();
+        if let Err(why) = msg.channel_id.say(&ctx.http, format!("You found {}!", item)).await 
+        {
+            println!("Error sending message: {:?}", why);
+        }
+    }
+}

src/main.rs

@@ -1,15 +1,16 @@
 
-
 mod commands;
 mod data_loader;
 mod utils;
 
+use std::collections::HashSet;
 
 use serenity::async_trait;
-use serenity::model::channel::Message;
-use serenity::model::gateway::Ready;
 use serenity::prelude::*;
 use serenity::model::prelude::*;
+use serenity::model::channel::Message;
+use serenity::model::gateway::Ready;
+use serenity::http::Http;
 
 struct Handler;
 
@@ -23,52 +24,7 @@ impl EventHandler for Handler
     // events can be dispatched simultaneously.
     async fn message(&self, ctx: Context, msg: Message) 
     {
-
+       commands::parse(ctx, msg).await;
-        if let Some(server_id) = msg.guild_id
-        {
-            let sm_speedrun_server_id = 98929157894836224;
-            let guru_test_server_id = 483735475283165195;
-            
-            if server_id == sm_speedrun_server_id || server_id == guru_test_server_id
-            {
-                if msg.content == ".role_test"
-                {
-                    let test_role = RoleId(1129106677619228702 as u64);
-                    if let Err(why) = server_id.edit_member(&ctx, msg.author, |m|
-                        {
-                            if let Some(mut member) = msg.member
-                            {
-                                member.roles.push(test_role);
-                                return m.roles(member.roles);
-                            }
-
-                            m
-                        }).await
-                        {
-                            println!("Error updating roles: {:?}", why);
-                        }
-                        else
-                        {
-                            let role = &server_id.roles(&ctx).await.unwrap()[&test_role];
-                            if let Err(why) = msg.channel_id.say(&ctx.http, format!("{} role added!", role)).await
-                            {
-                                println!("Error sending message: {:?}", why);
-                            }
-                        }
-                }
-                
-
-                if msg.content == ".randomizer"
-                {
-                    let item = utils::get_random_item();
-                    if let Err(why) = msg.channel_id.say(&ctx.http, format!("You found {}!", item)).await 
-                    {
-                        println!("Error sending message: {:?}", why);
-                    }
-                }
-            }
-        } 
-        
         
     }
 
@@ -93,6 +49,16 @@ async fn main()
         Err(why) => panic!("Could not load app token: {}", why),
     };
 
+     // Fetch the application owner id
+     let http = Http::new(&token);
+     let owner = match http.get_current_application_info().await 
+     {
+        Ok(info) => info.owner.id,
+        Err(why) => panic!("Could not access application info: {:?}", why),
+    };
+
+
+
     println!("Connecting...");
 
     let intents = GatewayIntents::GUILD_MESSAGES
@@ -104,6 +70,10 @@ async fn main()
     // by Discord for bot users.
     let mut client = Client::builder(&token, intents).event_handler(Handler).await.expect("Err creating client");
 
+    // TODO: See link for how to add global data to the client:
+    // https://github.com/serenity-rs/serenity/blob/current/examples/e12_global_data/src/main.rs
+    // client.data.write().await.insert::<UserId>(owner);
+
     // Finally, start a single shard, and start listening to events.
     //
     // Shards will automatically attempt to reconnect, and will perform

src/utils.rs

@@ -1,4 +1,39 @@
+
 use rand::prelude::*;
+use serenity::{client::Context, model::prelude::ChannelId};
+
+
+pub const ADMIN_SERVER_ID: u64 = 483735475283165195;
+pub const ADMIN_COMMAND_CHANNEL_ID: u64 = 1130607621699809443;
+pub const MAIN_LOG_CHANNEL_ID: u64 = 1130607583007363074;
+pub const ERROR_LOG_CHANNEL_ID: u64 = 1130607602221461564;
+
+pub struct Logger
+{
+
+}
+
+impl Logger
+{
+    pub async fn log_message(ctx: Context, msg: &str)
+    {
+        let channel = ChannelId(MAIN_LOG_CHANNEL_ID);
+        if let Err(why) = channel.say(ctx, msg).await
+        {
+            println!("Failed to log message: {} -- Reason: {}", msg, why);
+        }
+    }
+
+    pub async fn log_error(ctx: Context, msg: &str)
+    {
+        let channel = ChannelId(ERROR_LOG_CHANNEL_ID);
+        if let Err(why) = channel.say(ctx, msg).await
+        {
+            println!("Failed to log an error: {} -- Reason: {}", msg, why);
+        }
+    }
+}
+        
 
 pub fn get_random_item() -> String
 {
@@ -34,5 +69,3 @@ pub fn get_random_item() -> String
     }
         
 }
-
-