spectate command; remove spectate from ST; currently_playing improvements

src/main.rs

@@ -1,6 +1,6 @@
 use std::{future::Future, io, path::Path};
 
-use ::serenity::all::{ChannelId, EditMember, GuildId, UserId};
+use ::serenity::all::{ChannelId, GuildId, Mentionable, UserId};
 use eyre::{Context as _, Error, OptionExt, Result};
 use futures::{FutureExt, StreamExt, TryStreamExt};
 use poise::serenity_prelude as serenity;
@@ -267,62 +267,81 @@ async fn st(ctx: Context<'_>) -> Result<()> {
         .guild_id()
         .ok_or_eyre("This bot only works in servers")?;
     let GuildData { st, .. } = ctx.data().get(guild).await?;
+    let sender = ctx.author().id;
 
     futures::future::try_join_all(guild.members(&ctx, None, None).await?.into_iter().map(
-        |mut member| async move {
+        |member| async move {
-            match (&member.user == ctx.author(), member.roles.contains(&st)) {
+            match (sender == member.user.id, member.roles.contains(&st)) {
                 (true, true) | (false, false) => Ok(()),
-                (true, false) => {
+                (true, false) => member.add_role(&ctx, st).await,
-                    member
+                (false, true) => member.remove_role(&ctx, st).await,
-                        .edit(
-                            &ctx,
-                            EditMember::new().nickname(format!("(ST) {}", member.display_name())),
-                        )
-                        .await?;
-                    member.add_role(&ctx, st).await
-                }
-                (false, true) => {
-                    member
-                        .edit(
-                            &ctx,
-                            EditMember::new().nickname(
-                                member
-                                    .display_name()
-                                    .strip_prefix("(ST) ")
-                                    .unwrap_or(member.display_name()),
-                            ),
-                        )
-                        .await?;
-
-                    member.remove_role(&ctx, st).await
-                }
             }
         },
     ))
     .await?;
 
-    ctx.reply("You have been granted ST").await?;
+    ctx.reply("You are now the ST").await?;
+
     Ok(())
 }
 
 #[poise::command(slash_command, ephemeral)]
 #[tracing::instrument]
-async fn currently_playing(ctx: Context<'_>, players: Vec<serenity::UserId>) -> Result<()> {
+async fn spectate(ctx: Context<'_>, player: Option<serenity::UserId>) -> Result<()> {
     let guild = ctx
         .guild_id()
         .ok_or_eyre("This bot only works in servers")?;
-    let GuildData {
+    let GuildData { st, .. } = ctx.data().get(guild).await?;
-        currently_playing, ..
+
-    } = ctx.data().get(guild).await?;
+    let member = guild
-    for player in &players {
+        .member(&ctx, player.unwrap_or(ctx.author().id))
-        guild
-            .member(&ctx, player)
-            .await?
-            .add_role(&ctx, currently_playing)
-            .await?;
-    }
-    ctx.reply(format!("Given {} members currently playing", players.len()))
         .await?;
+
+    let msg = if member.roles.contains(&st) {
+        member.remove_role(&ctx, st).await?;
+        "no longer a spectator"
+    } else {
+        member.add_role(&ctx, st).await?;
+        "now a spectator"
+    };
+
+    ctx.reply(if player.is_some() {
+        format!("{} is {}", member.mention(), msg)
+    } else {
+        format!("You are {}", msg)
+    })
+    .await?;
+
+    Ok(())
+}
+
+#[poise::command(slash_command, ephemeral)]
+#[tracing::instrument]
+async fn currently_playing(ctx: Context<'_>, player: Option<serenity::UserId>) -> Result<()> {
+    let guild = ctx
+        .guild_id()
+        .ok_or_eyre("This bot only works in servers")?;
+    let GuildData { currently_playing, .. } = ctx.data().get(guild).await?;
+
+    let member = guild
+        .member(&ctx, player.unwrap_or(ctx.author().id))
+        .await?;
+
+    let msg = if member.roles.contains(&currently_playing) {
+        member.remove_role(&ctx, currently_playing).await?;
+        "no longer"
+    } else {
+        member.add_role(&ctx, currently_playing).await?;
+        "now"
+    };
+
+    ctx.reply(if player.is_some() {
+        format!("{} is {} {}", member.mention(), msg, currently_playing.mention())
+    } else {
+        format!("You are {} {}", msg, currently_playing.mention())
+    })
+    .await?;
+
     Ok(())
 }
 
@@ -363,7 +382,6 @@ async fn register_commands(
     Ok(())
 }
 
-#[tracing::instrument(skip(ctx, framework))]
 async fn on_event(
     ctx: &serenity::Context,
     event: &serenity::FullEvent,
@@ -405,6 +423,7 @@ async fn main() -> Result<()> {
                 dusk(),
                 dawn(),
                 st(),
+                spectate(),
                 currently_playing(),
                 join(),
                 configure(),