adds utils methods send_msg and add_role

.gitignore

@@ -14,6 +14,7 @@ Cargo.lock
 # MSVC Windows builds of rustc generate these, which store debugging information
 *.pdb
 
+.vscode/
 
 # SECRETS
 secrets/

src/commands/mod.rs

@@ -23,11 +23,13 @@ pub async fn parse(ctx: Context, msg: Message)
         if server_id == utils::ADMIN_SERVER_ID && msg.channel_id == utils::ADMIN_COMMAND_CHANNEL_ID
         {
             test::parse_command(ctx, msg, server_id).await;
+            return;
         }
 
         if server_id == utils::SM_SERVER_ID
         {
-
+            sm_server::parse_command(ctx, msg, server_id).await;
+            return;
         }
     }
     else 

src/commands/sm_server.rs

@@ -3,25 +3,32 @@ use serenity::prelude::*;
 use serenity::model::prelude::*;
 use serenity::model::channel::Message;
 
-
 use crate::utils;
 
+// COLOR ROLE IDS
+
+
+
 pub async fn parse_command(ctx: Context, msg: Message, server_id: GuildId)
 {
-    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);
-        }
-    }
-
     let command_lower = msg.content.to_lowercase();
     let mut command_iter = command_lower.split_whitespace();
     let command_start = command_iter.next();
 
+    if command_start == Some(".randomizer")
+    {
+        let item = utils::get_random_item();
+        utils::send_msg(ctx, msg.channel_id, &format!("You found {}!", item)).await;
+        return;
+    }
+
     if command_start == Some(".color")
+    {
+        utils::send_msg(ctx, msg.channel_id, "Valid colors are: green blue red purple pink yellow orange").await;
+        return;
+    }
+
+    if command_start == Some(".setcolor")
     {
         if let Some(arg) = command_iter.next()
         {

src/commands/test.rs

@@ -11,6 +11,7 @@ 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"
@@ -18,32 +19,65 @@ pub async fn parse_command(ctx: Context, msg: Message, server_id: GuildId)
             utils::Logger::log_message(ctx, "This is a test log message!").await;
             return;
         }
+
+        if msg.content == ".shutdown"
+        {
+            return;
+        }
+    }
+
+    let command_lower = msg.content.to_lowercase();
+    let mut command_iter = command_lower.split_whitespace();
+    let command_start = command_iter.next();
+
+    if command_start == Some(".argstest")
+    {
+        if let Some(arg) = command_iter.next()
+        {
+            match arg
+            {
+                "red" => utils::send_msg(ctx, msg.channel_id, "arg was red!").await,
+
+                _ => utils::Logger::log_error(ctx, &format!("unknown .argstest argument: {}", arg)).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|
+        match utils::add_role(ctx.clone(), msg.author.id, test_role, server_id).await
-            {
+        {
-                if let Some(mut member) = msg.member
+            Ok(role) => utils::send_msg(ctx, msg.channel_id, &format!("Added role {:?}", role.name)).await,
-                {
+            Err(why) => utils::Logger::log_error(ctx, &format!("failed to add role to user - {}", why)).await,
-                    member.roles.push(test_role);
+        }
-                    return m.roles(member.roles);
+
-                }
+        return;
-
+
-                m
+
-            }).await
+        // if let Err(why) = server_id.edit_member(&ctx, msg.author, |m|
-            {
+        //     {
-                utils::Logger::log_error(ctx, &format!("Error updating roles: {:?}", why)).await;
+        //         if let Some(mut member) = msg.member
-            }
+        //         {
-            else
+        //             member.roles.push(test_role);
-            {
+        //             return m.roles(member.roles);
-                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
+
-                {
+        //         m
-                    utils::Logger::log_error(ctx, &format!("Error sending message: {:?}", why)).await;
+        //     }).await
-                }
+            
-            }
+        //     {
-            return;
+        //         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;
         }
 }

src/utils.rs

@@ -1,6 +1,6 @@
 
 use rand::prelude::*;
-use serenity::{client::Context, model::prelude::ChannelId};
+use serenity::{client::Context, model::{user::User, prelude::{Role, ChannelId, GuildId, RoleId, UserId}}};
 
 
 pub const SM_SERVER_ID: u64 = 98929157894836224;
@@ -9,10 +9,7 @@ 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
+pub struct Logger;
-{
-
-}
 
 impl Logger
 {
@@ -35,6 +32,34 @@ impl Logger
     }
 }
 
+pub async fn send_msg(ctx: Context, channel: ChannelId, msg: &str)
+{
+    if let Err(why) = channel.say(&ctx.http, msg).await 
+    {
+        Logger::log_error(ctx, &format!("Error sending message: {:?}\nto channel: {:?}", why, channel)).await;
+    }
+}
+
+pub async fn add_role(ctx: Context, user_id: UserId, role_id: RoleId, server_id: GuildId) -> Result<Role, String>
+{
+    if let Ok(mut member) = server_id.member(&ctx, user_id).await
+    {
+        if let Err(why) = member.add_role(&ctx.http, role_id).await
+        {
+            return Err(why.to_string());
+        }
+
+        match &server_id.roles(&ctx).await
+        {
+            Ok(roles) => return Ok(roles[&role_id].clone()),
+            Err(why) => return Err(why.to_string()),
+        }
+    }
+    else
+    {
+        return Err(String::from("Could not get member from the server"));
+    }
+}
 
 pub fn get_random_item() -> String
 {