initial code

src/framework.rs

@@ -0,0 +1,123 @@
+use async_trait::async_trait;
+
+use serenity::{
+    client::Context,
+    framework::Framework,
+    model::channel::Message,
+};
+
+use std::{
+    collections::HashSet,
+    hash::{
+        Hash,
+        Hasher
+    },
+};
+
+use serenity::framework::standard::CommandFn;
+
+pub enum PermissionLevel {
+    Unrestricted,
+    Managed,
+    Restricted,
+}
+
+pub struct Command {
+    name: String,
+    required_perms: PermissionLevel,
+    can_blacklist: bool,
+    supports_dm: bool,
+    func: CommandFn,
+}
+
+impl Hash for Command {
+    fn hash<H: Hasher>(&self, state: &mut H) {
+        self.name.hash(state);
+    }
+}
+
+impl PartialEq for Command {
+    fn eq(&self, other: &Self) -> bool {
+        self.name == other.name
+    }
+}
+
+impl Eq for Command {}
+
+// create event handler for bot
+pub struct RegexFramework {
+    commands: HashSet<Command>,
+    command_names: String,
+    default_prefix: String,
+    ignore_bots: bool,
+}
+
+impl Command {
+    pub fn from(name: &str, required_perms: PermissionLevel, func: CommandFn) -> Self {
+        Command {
+            name: name.to_string(),
+            required_perms,
+            can_blacklist: true,
+            supports_dm: false,
+            func,
+        }
+    }
+
+    pub fn can_blacklist(&mut self, can_blacklist: bool) -> &mut Self {
+        self.can_blacklist = can_blacklist;
+
+        self
+    }
+
+    pub fn supports_dm(&mut self, supports_dm: bool) -> &mut Self {
+        self.supports_dm = supports_dm;
+
+        self
+    }
+}
+
+impl RegexFramework {
+    pub fn new() -> Self {
+        Self {
+            commands: HashSet::new(),
+            command_names: String::new(),
+            default_prefix: String::from("$"),
+            ignore_bots: true,
+        }
+    }
+
+    pub fn default_prefix(mut self, new_prefix: &str) -> Self {
+        self.default_prefix = new_prefix.to_string();
+
+        self
+    }
+
+    pub fn ignore_bots(mut self, ignore_bots: bool) -> Self {
+        self.ignore_bots = ignore_bots;
+
+        self
+    }
+
+    pub fn add_command(mut self, command: Command) -> Self {
+        self.commands.insert(command);
+
+        self
+    }
+
+    pub fn build(mut self) -> Self {
+        self.command_names = self.commands
+            .iter()
+            .map(|c| c.name.clone())
+            .collect::<Vec<String>>()
+            .join("|");
+
+        self
+    }
+}
+
+#[async_trait]
+impl Framework for RegexFramework {
+    async fn dispatch(&self, ctx: Context, msg: Message) {
+        println!("Message received! command_names=={}", self.command_names);
+    }
+}

src/main.rs

@@ -0,0 +1,77 @@
+mod framework;
+
+use serenity::{
+    client::{
+        bridge::gateway::GatewayIntents,
+        Client, Context,
+    },
+    model::{
+        channel::{
+            Message,
+        },
+    },
+    framework::standard::{
+        Args, CommandResult,
+        macros::{
+            command,
+        }
+    },
+    prelude::TypeMapKey,
+};
+
+use sqlx::{
+    Pool,
+    mysql::{
+        MySqlConnection,
+    }
+};
+
+use dotenv::dotenv;
+
+use std::{
+    sync::Arc,
+    env,
+};
+
+use crate::framework::{RegexFramework, Command, PermissionLevel};
+
+struct SQLPool;
+
+impl TypeMapKey for SQLPool {
+    type Value = Pool<MySqlConnection>;
+}
+
+struct ReqwestClient;
+
+impl TypeMapKey for ReqwestClient {
+    type Value = Arc<reqwest::Client>;
+}
+
+static THEME_COLOR: u32 = 0x00e0f3;
+
+#[tokio::main]
+async fn main() -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
+    dotenv()?;
+
+    let framework = RegexFramework::new()
+        .ignore_bots(true)
+        .default_prefix("$")
+        .add_command(Command::from("help", PermissionLevel::Unrestricted, help_command))
+        .build();
+
+    let mut client = Client::new(&env::var("DISCORD_TOKEN").expect("Missing DISCORD_TOKEN from environment"))
+        .intents(GatewayIntents::GUILD_MESSAGES | GatewayIntents::GUILDS | GatewayIntents::DIRECT_MESSAGES)
+        .framework(framework)
+        .await.expect("Error occured creating client");
+
+    client.start_autosharded().await?;
+
+    Ok(())
+}
+
+#[command]
+async fn help_command(_ctx: &Context, _msg: &Message, _args: Args) -> CommandResult {
+    println!("Help command called");
+
+    Ok(())
+}