moover_rust/src/main.rs

use poise::samples::{register_globally, register_in_guild};
use serenity::async_trait;
use serenity::prelude::GatewayIntents;
use serenity::client::Context;
use serenity::model::gateway::Ready;
use serenity::all::{EventHandler, GuildId, Message};
use serenity::Client;

use tokio_cron_scheduler::{JobScheduler, Job};
use util::security::dotenv_var;

mod message_handler;
use message_handler::handle;

use std::future::Future;
use std::pin::Pin;
use std::sync::Arc;
use std::time::Duration;

mod commands;
mod util;

mod other;
use other::notice;

mod types;

struct Handler;

use commands::say::say;
use types::Error;

async fn on_error(error: poise::FrameworkError<'_, (), Error>) {
    match error {
        poise::FrameworkError::Setup { error, .. } => panic!("Failed to start bot: {:?}", error),
        poise::FrameworkError::Command { error, ctx, .. } => {
            println!("Error in command `{}`: {:?}", ctx.command().name, error,);
        }
        error => {
            if let Err(e) = poise::builtins::on_error(error).await {
                println!("Error while handling error: {}", e)
            }
        }
    }
}

#[async_trait]
impl EventHandler for Handler {
    async fn message(&self, ctx: Context, msg: Message) {
        handle(ctx, msg).await;
    }

    async fn ready(&self, ctx: Context, ready: Ready) {
        println!("{} v0.3 is connected!", ready.user.name);

        #[cfg(feature="RELEASE")] {
            use util::debug::hello;
            hello(ctx.http.clone()).await;
        }

        let sched = JobScheduler::new().await.unwrap();

        let job_closure = move |_, _| -> Pin<Box<dyn Future<Output = ()> + Send>> {
            let ctx_clone = ctx.clone();
            Box::pin( async move {
                notice::notice_wrapper(ctx_clone).await;
            })
        };

        sched.add(Job::new_async("0 0 13 * * *", job_closure).expect("Cron job not set up correctly")).await.unwrap();
        sched.start().await.unwrap();
    }
}

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    use anyhow::Context;

    // create poise framework for registering commands
    let options = poise::FrameworkOptions {
        commands: vec![say()],
        prefix_options: poise::PrefixFrameworkOptions {
            prefix: Some("/".into()),
            edit_tracker: Some(Arc::new(poise::EditTracker::for_timespan(
                Duration::from_secs(3600),
            ))),
            ..Default::default()
        },
        on_error: |err| Box::pin(on_error(err)),
        command_check: Some(|ctx| {
            Box::pin(async move {
                return Ok(!ctx.author().bot)
            })
        }),
        ..Default::default()
    };

    let debug_guild_id = dotenv_var("DEBUG_GUILD_ID")
        .context("DEBUG_GUILD_ID not found in env")?
        .parse::<u64>().unwrap();

    let framework = poise::Framework::builder()
        .setup(move |ctx, _ready, framework| {
            Box::pin(async move {
                register_in_guild(ctx, &framework.options().commands, GuildId::new(debug_guild_id)).await?;
                Ok(())
            })
        })
        .options(options)
        .build();

    let token_str = "TOKEN";

    #[cfg(feature="DEBUG")]
    let token_str = "DEBUGTOKEN";

    let token = dotenv_var(token_str).context("TOKEN not found in env")?;

    let intents = GatewayIntents::GUILD_MESSAGES | GatewayIntents::MESSAGE_CONTENT;    

    let mut client = Client::builder(&token, intents)
        .event_handler(Handler)
        .framework(framework)
        .await
        .context("Failed to build client")?;

    client.start().await?;
    Ok(())
}