[commands] util: steal

Author: 7596ff

Cargo.lock

@@ -23,11 +23,13 @@ tokio = "0.2"
 base64 = "0.12"
 chrono = "0.4"
 futures-util = "0.3"
+http = "0.2"
 image = "0.23"
 isahc = "0.9"
 lazy_static = { version = "1.4", default-features = false }
 rand = "0.7"
 rarity-permission-calculator = { branch = "main", default-features = false, git = "https://github.com/rarity-rs/permission-calculator" }
+regex = "1.3"
 serde = "1.0"
 serde_json = "1.0"
 shellwords = { version = "1.1", default-features = false }

Cargo.toml

@@ -13,6 +13,7 @@
 `owo`: What's this?
 `ping`: Pong!
 `shuffle`: Shuffle a list of things. Use quotes around "two or more words".
+`steal <emoji> [<name>]`: Steal a custom emoji from another server. Optionally provide a new name. Also accepts an image link.
 
 **Information**
 Prefix: `katze`

help.txt

@@ -1,13 +1,22 @@
-use std::fmt::Write;
+use std::{convert::TryFrom, fmt::Write};
 
-use anyhow::Result;
+use anyhow::{anyhow, Result};
 use chrono::DateTime;
+use futures_util::io::AsyncReadExt;
+use http::uri::Uri;
+use lazy_static::lazy_static;
 use rand::seq::SliceRandom;
+use regex::Regex;
+use twilight::model::channel::ReactionType;
 
-use crate::model::{MessageContext, Response};
+use crate::model::{MessageContext, Response, ResponseReaction};
 
 const HELP_TEXT: &str = include_str!("../../help.txt");
 
+lazy_static! {
+    static ref EMOJI: Regex = Regex::new("<:([[:word:]]+):([[:digit:]]+)>").unwrap();
+}
+
 pub async fn avatar(context: &mut MessageContext) -> Result<Response> {
     let found_user = context.find_member().await?;
 
@@ -79,3 +88,62 @@ pub async fn shuffle(context: &mut MessageContext) -> Result<Response> {
     let reply = context.reply(content).await?;
     Ok(Response::Message(reply))
 }
+
+pub async fn steal(context: &mut MessageContext) -> Result<Response> {
+    if let Some(emoji) = context.next() {
+        // create variables that hold the chain of information priority
+        let mut uri: Option<Uri> = Uri::try_from(&emoji).ok();
+        let mut name: Option<String> = None;
+
+        // set the uri and name from a custom emoji match
+        if uri.is_none() {
+            let caps = EMOJI.captures(&emoji).ok_or_else(|| anyhow!("No match."))?;
+            let formatted = format!(
+                "https://cdn.discordapp.com/emojis/{}.png?v=1",
+                caps.get(2).ok_or_else(|| anyhow!("no match 2"))?.as_str()
+            );
+
+            uri = Uri::try_from(formatted).ok();
+            name = caps.get(1).map(|m| String::from(m.as_str()));
+        }
+
+        // override the name if there is another argument
+        if let Some(arg_name) = context.next() {
+            name = Some(arg_name);
+        }
+
+        // default the name to emoji if none
+        if name.is_none() {
+            name = Some("emoji".into());
+        }
+
+        // upload the emoji if everything checks out
+        if uri.is_some() && name.is_some() {
+            let mut resp = isahc::get_async(uri.unwrap()).await?;
+            let mut buffer: Vec<u8> = Vec::new();
+            resp.body_mut().read_to_end(&mut buffer).await?;
+
+            let emoji = context
+                .http
+                .create_emoji(
+                    context.message.guild_id.unwrap(),
+                    name.unwrap(),
+                    format!("data:image/png;base64,{}", base64::encode(buffer)),
+                )
+                .await?;
+
+            context.react(ResponseReaction::Success.value()).await?;
+            context
+                .react(ReactionType::Custom {
+                    animated: emoji.animated,
+                    id: emoji.id,
+                    name: Some(emoji.name),
+                })
+                .await?;
+            return Ok(Response::Reaction);
+        }
+    }
+
+    let reply = context.reply("USAGE: katze steal <emoji> [<name>]").await?;
+    Ok(Response::Message(reply))
+}

src/commands/util.rs

@@ -35,6 +35,7 @@ pub async fn handle(mut context: MessageContext) -> Result<()> {
             }
             "show" => commands::rotate::show(&mut context).await,
             "shuffle" => commands::util::shuffle(&mut context).await,
+            "steal" => commands::util::steal(&mut context).await,
             _ => Ok(Response::None),
         };