Add back color commands

src/discord/color.rs

@@ -1,96 +1,96 @@
-use crate::{command, group};
+use crate::discord::Context;
-use serenity::builder::EditRole;
+use crate::error::Error;
-use serenity::client::Context;
+use poise::serenity_prelude::builder::EditRole;
-use serenity::framework::standard::{Args, CommandResult};
+use poise::serenity_prelude::model::Colour;
-use serenity::model::channel::Message;
-use serenity::model::Colour;
 
-#[group]
+#[poise::command(prefix_command, guild_only)]
-#[commands(set_color, remove_color)]
+pub async fn set_color(
-pub struct Color;
+    ctx: Context<'_>,
+    #[description = "Color you want your role to be"]
+    #[rest]
+    color: String,
+) -> Result<(), Error> {
+    let mut color_parts = color.split(" ");
 
-#[command]
+    let color = if color_parts.clone().count() == 3 {
-#[example("#35BB1D")]
+        let r = color_parts
-#[example("0x35BB1D")]
+            .next()
-#[example("53 187 29")]
+            .unwrap()
-#[description("Set your name color.")]
+            .parse::<u8>()
-#[min_args(1)]
+            .map_err(|_| Error::ParseFailure)?;
-#[max_args(3)]
+        let g = color_parts
-#[only_in(guilds)]
+            .next()
-async fn set_color(ctx: &Context, msg: &Message, mut args: Args) -> CommandResult {
+            .unwrap()
-    let color = if args.len() == 3 {
+            .parse::<u8>()
-        let r = args.parse::<u8>()?;
+            .map_err(|_| Error::ParseFailure)?;
-        args.advance();
+        let b = color_parts
-        let g = args.parse::<u8>()?;
+            .next()
-        args.advance();
+            .unwrap()
-        let b = args.parse::<u8>()?;
+            .parse::<u8>()
-        args.advance();
+            .map_err(|_| Error::ParseFailure)?;
         Colour::from_rgb(r, g, b)
     } else {
-        let color_str = args.rest();
+        let color_str = color_parts.next().unwrap();
 
         if color_str.starts_with("0x") || color_str.starts_with('#') {
             let color_str = color_str.replace("0x", "").replace('#', "");
-            let val = u32::from_str_radix(&color_str, 16)?;
+            let val = u32::from_str_radix(&color_str, 16).map_err(|_| Error::ParseFailure)?;
 
             Colour::new(val)
         } else {
-            Colour::new(color_str.parse()?)
+            Colour::new(color_str.parse().map_err(|_| Error::ParseFailure)?)
         }
     };
 
-    let role = if let Some(role) = msg.member.as_ref().unwrap().roles.iter().find(|r| {
+    let guild_id = ctx.guild_id().unwrap();
-        ctx.cache
+    let member = ctx.author_member().await.unwrap();
-            .role(msg.guild_id.unwrap(), **r)
+
-            .unwrap()
+    let roles = member.roles(&ctx.cache()).unwrap();
-            .name
+
-            .contains("COwOlor")
+    let color_role = roles.iter().find(|role| role.name.contains("COwOlor"));
-    }) {
+
-        *role
+    let color_role = if let Some(color_role) = color_role {
+        color_role.id
     } else {
-        msg.guild_id
+        guild_id
-            .unwrap()
             .create_role(
-                &ctx.http,
+                ctx.http(),
-                EditRole::new().name(&format!("{} COwOlor", msg.author.name)),
+                EditRole::new().name(format!("{} COwOlor", ctx.author().name)),
             )
             .await?
             .id
     };
 
-    msg.guild_id
+    guild_id
-        .unwrap()
+        .edit_role(&ctx.http(), color_role, EditRole::new().colour(color))
-        .edit_role(&ctx.http, role, EditRole::new().colour(color))
         .await?;
 
-    msg.guild_id
+    ctx.author_member()
-        .unwrap()
-        .member(&ctx.http, msg.author.id)
         .await
         .unwrap()
-        .add_role(&ctx.http, role)
+        .add_role(&ctx.http(), color_role)
         .await?;
 
-    msg.reply(&ctx.http, "Color set!").await?;
+    ctx.reply("Be not afraid child, I have bestowed onto you your color. May your soul rest now.")
+        .await?;
 
     Ok(())
 }
 
-#[command]
+#[poise::command(prefix_command, guild_only)]
-#[max_args(0)]
+pub async fn remove_color(ctx: Context<'_>) -> Result<(), Error> {
-#[only_in(guilds)]
+    let guild_id = ctx.guild_id().unwrap();
-#[description("Remove your name color.")]
+    let member = ctx.author_member().await.unwrap();
-async fn remove_color(ctx: &Context, msg: &Message, _args: Args) -> CommandResult {
+    let roles = member.roles(&ctx.cache()).unwrap();
-    if let Some(role) = msg.member.as_ref().unwrap().roles.iter().find(|r| {
+    let color_role = roles.iter().find(|role| role.name.contains("COwOlor"));
-        ctx.cache
+
-            .role(msg.guild_id.unwrap(), **r)
+    if let Some(role) = color_role {
-            .unwrap()
+        guild_id.delete_role(ctx.http(), role.id).await?;
-            .name
+        ctx.reply("Color removed!").await?;
-            .contains("COwOlor")
+    } else {
-    }) {
+        ctx.reply("My child, I can't remove what has never existed.")
-        msg.guild_id.unwrap().delete_role(&ctx.http, role).await?;
+            .await?;
     }
 
-    msg.reply(&ctx.http, "Color removed!").await?;
     Ok(())
 }

src/discord/mod.rs

@@ -2,11 +2,11 @@ mod admin;
 mod album;
 mod birthday;
 mod celeryman;
+mod color;
 
 use crate::config::GlobalData;
 use crate::error::Error;
 use log::info;
-use magick_rust::bindings::wchar_t;
 use std::sync::Arc;
 use std::time::Duration;
 
@@ -119,6 +119,8 @@ pub async fn run_bot(global_data: GlobalData) {
             celeryman::nudetayne(),
             celeryman::celeryman(),
             celeryman::tayne(),
+            color::set_color(),
+            color::remove_color(),
         ],
         event_handler: |ctx, event, framework, data| {
             Box::pin(event_handler(ctx, event, framework, data))

src/error.rs

@@ -1,6 +1,6 @@
 use crate::user;
 use serde::ser::StdError;
-use std::fmt::{Display, Formatter};
+use std::fmt::{write, Display, Formatter};
 
 #[derive(Debug)]
 #[allow(clippy::enum_variant_names)]
@@ -13,6 +13,7 @@ pub enum Error {
     UserError(user::UserError),
     DbError(j_db::error::JDbError),
     ReqwestError(reqwest::Error),
+    ParseFailure,
 }
 
 impl StdError for Error {}
@@ -63,6 +64,7 @@ impl Display for Error {
             Error::UserError(e) => write!(f, "User error: {}", e),
             Error::DbError(e) => write!(f, "DB error: {}", e),
             Error::ReqwestError(e) => write!(f, "Reqwest Error: {}", e),
+            Error::ParseFailure => write!(f, "Failed to parse something or other"),
         }
     }
 }