Split bot and service

service/src/main.rs

@@ -2,117 +2,15 @@ extern crate diesel;
 #[macro_use]
 extern crate diesel_migrations;
 
-use std::collections::{HashSet, HashMap};
 use std::env;
-use std::sync::Arc;
 
 use actix_web::{HttpServer, App};
-use commands::audio::{create_response, AudioConfig, AudioConfigs};
 
 use dotenv::dotenv;
-use log::{error, warn, info};
-use serenity::async_trait;
-use serenity::framework::StandardFramework;
-use serenity::model::application::interaction::Interaction;
-use serenity::model::gateway::Ready;
-use serenity::model::channel::Message;
-use serenity::http::Http;
-use serenity::prelude::*;
-use songbird::SerenityInit;
+use log::{error, info};
 
-use crate::commands::oai::GPTModel;
-
-mod commands;
 mod error_handler;
 mod db;
-struct Handler {
-  // Open AI Config
-  oai: Option<commands::oai::OAI>
-}
-
-#[async_trait]
-impl EventHandler for Handler {
-  async fn message(&self, ctx: Context, msg: Message) {
-    // Ignore messages from bots
-    if msg.author.bot {
-      return;
-    }
-    match &self.oai {
-      Some(oai) => {
-        match msg.mentions_me(&ctx.http).await {
-          Ok(mentioned) => {
-            let bot_in_thread = match msg.channel_id.get_thread_members(&ctx.http).await {
-              Ok(t) => {
-                match t.iter().find(|t| t.user_id.unwrap().0 == ctx.cache.current_user_id().0) {
-                  Some(_) => true,
-                  None => false
-                }
-              }
-              Err(_) => false
-            };
-            if mentioned || bot_in_thread {
-              commands::oai::generate_response(&ctx, &msg, oai).await;
-            }
-          }
-          Err(why) => warn!("Could not check mentions: {:?}", why)
-        };
-      }
-      None => {}
-    }
-  }
-
-  async fn interaction_create(&self, ctx: Context, interaction: Interaction) {
-    if let Interaction::ApplicationCommand(command) = interaction {
-      match command.data.name.as_str() {
-        "play" => commands::audio::play::run(&ctx, &command).await,
-        "stop" => commands::audio::stop::run(&ctx, &command).await,
-        "pause" => commands::audio::pause::run(&ctx, &command).await,
-        "resume" => commands::audio::resume::run(&ctx, &command).await,
-        "skip" => commands::audio::skip::run(&ctx, &command).await,
-        "volume" => commands::audio::volume::run(&ctx, &command).await,
-        _ => {
-          let content: String = match command.data.name.as_str() {
-            "ping" => commands::ping::run(&command.data.options),
-            _ => "Unknown command".to_string()
-          };
-    
-          if let Err(why) = create_response(&ctx, &command, content).await {
-            warn!("Cannot respond to slash command: {}", why);
-          }
-        }
-      }
-    }
-  }
-
-  async fn ready(&self, ctx: Context, ready: Ready) {
-    if ready.guilds.is_empty() {
-      warn!("No ready guilds found");
-    }
-    for guild in ready.guilds {
-      let audio_config_lock = {
-        let data_read = ctx.data.read().await;
-        data_read.get::<AudioConfigs>().expect("Expected AudioConfigs in TypeMap.").clone()
-      };
-      {
-        let mut audio_configs = audio_config_lock.write().await;
-        let _ = audio_configs.insert(guild.id, AudioConfig { volume: 1.0 });
-      }
-      let commands = guild.id.set_application_commands(&ctx.http, |commands| {
-        commands.create_application_command(|command: &mut serenity::builder::CreateApplicationCommand| { commands::ping::register(command) })
-          .create_application_command(|command: &mut serenity::builder::CreateApplicationCommand| { commands::audio::play::register(command) })
-          .create_application_command(|command: &mut serenity::builder::CreateApplicationCommand| { commands::audio::stop::register(command) })
-          .create_application_command(|command: &mut serenity::builder::CreateApplicationCommand| { commands::audio::pause::register(command) })
-          .create_application_command(|command: &mut serenity::builder::CreateApplicationCommand| { commands::audio::resume::register(command) })
-          .create_application_command(|command: &mut serenity::builder::CreateApplicationCommand| { commands::audio::skip::register(command) })
-          .create_application_command(|command: &mut serenity::builder::CreateApplicationCommand| { commands::audio::volume::register(command) })
-      }).await;
-      match commands {
-        Ok(c) => info!("Registered {} commands for guild {}", c.len(), guild.id.0),
-        Err(why) => error!("Could not register commands for guild {}: {:?}", guild.id.0, why)
-      };
-    }
-  }
-}
 
 #[actix_web::main]
 async fn main() -> std::io::Result<()> {
@@ -121,13 +19,12 @@ async fn main() -> std::io::Result<()> {
   db::init();
   db::load_data();
 
-  // setup_discord_bot();
-
   let host = env::var("SERVICE_HOST").unwrap_or("localhost".to_string());
   let port = env::var("SERVICE_PORT").unwrap_or("5000".to_string());
 
   match HttpServer::new(|| {
     App::new()
+      .configure(db::messages::init_routes)
       .configure(db::spells::init_routes)
   })
   .bind(format!("{}:{}", host, port)) {
@@ -143,65 +40,3 @@ async fn main() -> std::io::Result<()> {
   .run()
   .await
 }
-
-fn setup_discord_bot() {
-  tokio::spawn(async {
-    let token: String = env::var("DISCORD_TOKEN").expect("Expected a token in the environment");
-    let intents: GatewayIntents = GatewayIntents::all();
-
-    let http: Http = Http::new(&token);
-    let (owners, _bot_id) = match http.get_current_application_info().await {
-      Ok(info) => {
-        let mut owners: HashSet<serenity::model::id::UserId> = HashSet::new();
-        if let Some(team) = info.team {
-          owners.insert(team.owner_user_id);
-        } else {
-          owners.insert(info.owner.id);
-        }
-        match http.get_current_user().await {
-          Ok(bot) => (owners, bot.id),
-          Err(why) => panic!("Could not access the bot id: {:?}", why)
-        }
-      },
-      Err(why) => panic!("Could not access application info: {:?}", why)
-    };
-    
-    let handler = match env::var("OPENAI_API_KEY") {
-      Ok(token) => {
-        info!("Loaded OpenAI token");
-        Handler {
-          oai: Some(commands::oai::OAI {
-            client: reqwest::Client::new(),
-            base_url: "https://api.openai.com/v1".to_string(),
-            max_attempts: 5,
-            token,
-            max_context_questions: 30,
-            max_tokens: 2048,
-            default_model: GPTModel::GPT35Turbo,
-          })
-        }
-      }
-      Err(err) => {
-        warn!("Could not load OpenAI token: {}", err);
-        Handler { oai: None }
-      }
-    };
-
-    let mut client = Client::builder(token, intents)
-      .event_handler(handler)
-      .framework(StandardFramework::new()
-      .configure(|c| c.owners(owners)))
-      .register_songbird()
-      .await
-      .expect("Error creating client");
-
-    {
-      let mut data = client.data.write().await;
-      data.insert::<AudioConfigs>(Arc::new(RwLock::new(HashMap::default())));
-    }
-
-    if let Err(why) = client.start_autosharded().await {
-      error!("An error occurred while running the client: {:?}", why);
-    }
-  });
-}