1 files changed, 49 insertions, 36 deletions

diff --git a/src/commands/sound_levels.rs b/src/commands/sound_levels.rs
index d913d06..db0b6a6 100644
--- a/src/commands/sound_levels.rs
+++ b/src/commands/sound_levels.rs
@@ -6,94 +6,107 @@ use log::{
 };
 use serenity::{
     framework::standard::{
-        Args,
         macros::command,
+        Args,
+        CommandError,
+        CommandResult,
     },
+    futures::TryFutureExt,
     model::channel::Message,
     prelude::*,
 };
 
 use crate::{
-    Result,
+    audio::{
+        PlayQueue,
+        VoiceManager,
+    },
+    util,
     CONFIG,
-    audio::{PlayQueue, VoiceManager},
-    util::CtxExt,
 };
 
 pub const DEFAULT_VOLUME: f32 = 0.20;
 const MAX_VOLUME: f32 = 5.0;
 
 #[command]
-pub fn mute(ctx: &mut Context, _: &Message, _: Args) -> Result<()> {
-    let mgr_lock = ctx.data.write().get::<VoiceManager>().cloned().unwrap();
+pub async fn mute(ctx: &Context, _: &Message, _: Args) -> CommandResult {
+    let mgr_lock = ctx.data.write().await.get::<VoiceManager>().cloned().unwrap();
     let mut manager = mgr_lock.lock();
 
-    manager.get_mut(CONFIG.discord.guild())
-        .map(|handler| {
-            if handler.self_mute {
-                trace!("Already muted.")
-            } else {
-                handler.mute(true);
-                trace!("Muted");
-            }
-        });
+    manager.get_mut(CONFIG.discord.guild()).map(|handler| {
+        if handler.self_mute {
+            trace!("Already muted.")
+        } else {
+            handler.mute(true);
+            trace!("Muted");
+        }
+    });
 
     Ok(())
 }
 
 #[command]
-pub fn unmute(ctx: &mut Context, msg: &Message, _: Args) -> Result<()> {
-    let mgr_lock = ctx.data.write().get::<VoiceManager>().cloned().unwrap();
+pub async fn unmute(ctx: &Context, msg: &Message, _: Args) -> CommandResult {
+    let mgr_lock = ctx.data.write().await.get::<VoiceManager>().cloned().unwrap();
     let mut manager = mgr_lock.lock();
 
-    manager.get_mut(CONFIG.discord.guild())
-        .map(|handler| {
-            if !handler.self_mute {
-                trace!("Already unmuted.")
-            } else {
-                handler.mute(false);
-                trace!("Unmuted");
-                let _ = ctx.send(msg.channel_id, "REEEEEEEEEEEEEE", msg.tts);
-            }
-        });
+    if let Some(handler) = manager.get_mut(CONFIG.discord.guild()) {
+        if !handler.self_mute {
+            trace!("Already unmuted.")
+        } else {
+            handler.mute(false);
+            trace!("Unmuted");
+            let _ = util::send(ctx, msg.channel_id, "REEEEEEEEEEEEEE", msg.tts)
+                .map_err(CommandError::from)
+                .await;
+        }
+    }
 
     Ok(())
 }
 
 #[command]
-pub fn volume(ctx: &mut Context, msg: &Message, mut args: Args) -> Result<()> {
+pub async fn volume(ctx: &Context, msg: &Message, mut args: Args) -> CommandResult {
     if args.len() == 0 {
         let vol = {
-            let queue_lock = ctx.data.write().get::<PlayQueue>().cloned().unwrap();
+            let queue_lock = ctx.data.write().await.get::<PlayQueue>().cloned().unwrap();
             let play_queue = queue_lock.read().unwrap();
             (play_queue.volume / DEFAULT_VOLUME * 100.0) as usize
         };
 
         trace!("reporting volume {}", vol);
 
-        return ctx.send(msg.channel_id, &format!("volume: {}%", vol), msg.tts);
+        return util::send(ctx, msg.channel_id, &format!("volume: {}%", vol), msg.tts)
+            .map_err(CommandError::from)
+            .await;
     }
 
     let vol: usize = match args.single::<f32>() {
         Ok(vol) if vol.is_nan() => {
             warn!("reporting NaN volume");
-            return ctx.send(msg.channel_id, "you're a fuck", msg.tts);
+            return util::send(ctx, msg.channel_id, "you're a fuck", msg.tts)
+                .map_err(CommandError::from)
+                .await;
         },
         Ok(vol) => vol as usize,
         Err(e) => {
             error!("parsing volume arg: {}", e);
-            return ctx.send(msg.channel_id, "???????", msg.tts)
+            return util::send(ctx, msg.channel_id, "???????", msg.tts)
+                .map_err(CommandError::from)
+                .await;
         },
     };
 
-    let mut vol: f32 = (vol as f32)/100.0;  // force aliasing to reasonable values
+    let mut vol: f32 = (vol as f32) / 100.0; // force aliasing to reasonable values
     let adjusted_text = if vol > MAX_VOLUME {
         format!(" ({:.0}% max)", MAX_VOLUME * 100.0)
-    } else { "".to_owned() };
+    } else {
+        "".to_owned()
+    };
 
     vol = vol.clamp(0.0, MAX_VOLUME);
 
-    let queue_lock = ctx.data.write().get::<PlayQueue>().cloned().unwrap();
+    let queue_lock = ctx.data.write().await.get::<PlayQueue>().cloned().unwrap();
 
     {
         let mut play_queue = queue_lock.write().unwrap();
@@ -101,7 +114,7 @@ pub fn volume(ctx: &mut Context, msg: &Message, mut args: Args) -> Result<()> {
         info!("volume updated to {}", vol);
     }
 
-    ctx.send(msg.channel_id, format!("volume adjusted{}", adjusted_text), msg.tts)?;
+    util::send(ctx, msg.channel_id, format!("volume adjusted{}", adjusted_text), msg.tts).await?;
 
     {
         let play_queue = queue_lock.read().unwrap();