Moved bot api files

service/src/bot/commands/audio/play.rs

@@ -9,8 +9,7 @@ use serenity::model::application::interaction::application_command::ApplicationC
 use siren::ServiceError;
 use songbird::{EventHandler, Songbird};
 
-use crate::bot::commands::audio::{leave, add_song, get_songbird};
-use crate::storage::guilds::QueryGuild;
+use crate::bot::{guilds::QueryGuild, commands::audio::{leave, add_song, get_songbird}};
 
 use super::{create_response, edit_response, join_by_user};
 

service/src/bot/commands/audio/volume.rs

@@ -7,7 +7,7 @@ use serenity::builder::CreateApplicationCommand;
 use serenity::model::application::interaction::application_command::ApplicationCommandInteraction;
 use songbird::Songbird;
 
-use crate::storage::guilds::InsertGuild;
+use crate::bot::guilds::InsertGuild;
 
 use super::{get_songbird, create_response, edit_response};
 

service/src/bot/guilds/model.rs

@@ -0,0 +1,43 @@
+use diesel::prelude::*;
+use serde::{Serialize, Deserialize};
+use siren::ServiceError;
+
+use crate::storage::{schema::guilds, connection};
+
+#[derive(Queryable, QueryableByName, Serialize, Deserialize)]
+#[diesel(table_name = guilds)]
+pub struct QueryGuild {
+  pub id: i64,
+  pub bot_id: i64,
+  pub volume: i32
+}
+
+impl QueryGuild {
+  pub fn get(id: i64) -> Result<Self, ServiceError> {
+    let mut conn = connection()?;
+    let guild = guilds::table.filter(guilds::id.eq(id)).first(&mut conn)?;
+    Ok(guild)
+  }
+}
+
+#[derive(Insertable, AsChangeset, Serialize, Deserialize)]
+#[diesel(table_name = guilds)]
+pub struct InsertGuild {
+  pub id: i64,
+  pub bot_id: i64,
+  pub volume: i32
+}
+
+impl InsertGuild {
+  pub fn insert(guild: Self) -> Result<QueryGuild, ServiceError> {
+    let mut conn = connection()?;
+    let guild = diesel::insert_into(guilds::table).values(guild).get_result(&mut conn)?;
+    Ok(guild)
+  }
+
+  pub fn update_audio(id: i64, volume: i32) -> Result<QueryGuild, ServiceError> {
+    let mut conn = connection()?;
+    let guild = diesel::update(guilds::table.filter(guilds::id.eq(id))).set(guilds::volume.eq(volume)).get_result(&mut conn)?;
+    Ok(guild)
+  }
+}

service/src/bot/guilds/routes.rs

@@ -1,18 +1,16 @@
 use std::{sync::Arc, pin::Pin};
 
 use actix_web::{get, post, web, HttpResponse, ResponseError};
-use log::warn;
 use serde::{Serialize, Deserialize};
 use serenity::model::prelude::{GuildChannel, ChannelType};
 use siren::{ServiceError, Response};
 
-use crate::{AppState, bot::commands::audio::{play::play_track, join}, storage::guilds::QueryGuild, auth::{JwtAuth, verify_role}};
+use crate::{AppState, bot::commands::audio::{play::play_track, join}, bot::guilds::QueryGuild, auth::{JwtAuth, verify_role}};
 
 #[get("/guilds")]
 async fn get_guilds(data: web::Data<Arc<AppState>>, auth: JwtAuth) -> HttpResponse {
-  let _ = match verify_role(&auth, "admin") {
-    Ok(_) => {},
-    Err(err) => return ResponseError::error_response(&err)
+  if let Err(err) = verify_role(&auth, "admin") {
+    return ResponseError::error_response(&err)
   };
   let guild_results = &data.http.get_guilds(None, None).await;
   let guilds = match guild_results {
@@ -30,9 +28,8 @@ async fn get_guilds(data: web::Data<Arc<AppState>>, auth: JwtAuth) -> HttpRespon
 
 #[get("/{id}/text")]
 async fn get_text_channels(id: web::Path<String>, data: web::Data<Arc<AppState>>, auth: JwtAuth) -> HttpResponse {
-  let _ = match verify_role(&auth, "admin") {
-    Ok(_) => {},
-    Err(err) => return ResponseError::error_response(&err)
+  if let Err(err) = verify_role(&auth, "admin") {
+    return ResponseError::error_response(&err)
   };
   let channel_results = &data.http.get_channels(id.parse::<u64>().unwrap()).await;
   let channels = match channel_results {
@@ -50,9 +47,8 @@ async fn get_text_channels(id: web::Path<String>, data: web::Data<Arc<AppState>>
 
 #[get("/{id}/voice")]
 async fn get_voice_channels(id: web::Path<String>, data: web::Data<Arc<AppState>>, auth: JwtAuth) -> HttpResponse {
-  let _ = match verify_role(&auth, "admin") {
-    Ok(_) => {},
-    Err(err) => return ResponseError::error_response(&err)
+  if let Err(err) = verify_role(&auth, "admin") {
+    return ResponseError::error_response(&err)
   };
   let channel_results = &data.http.get_channels(id.parse::<u64>().unwrap()).await;
   let channels = match channel_results {
@@ -75,9 +71,8 @@ struct ChannelMessage {
 
 #[post("/{guild_id}/text/{channel_id}/message")]
 async fn send_message(path: web::Path<(String, String)>, text: web::Json<ChannelMessage>, data: web::Data<Arc<AppState>>, auth: JwtAuth) -> HttpResponse {
-  let _ = match verify_role(&auth, "admin") {
-    Ok(_) => {},
-    Err(err) => return ResponseError::error_response(&err)
+  if let Err(err) = verify_role(&auth, "admin") {
+    return ResponseError::error_response(&err)
   };
   let (guild_id, channel_id) = path.into_inner();
   let guild_id = match guild_id.parse::<u64>() {
@@ -136,9 +131,8 @@ struct PlayRequest {
 
 #[post("/{guild_id}/voice/{channel_id}/play")]
 async fn play(path: web::Path<(String, String)>, play_request: web::Json<PlayRequest>, data: web::Data<Arc<AppState>>, auth: JwtAuth) -> HttpResponse {
-  let _ = match verify_role(&auth, "admin") {
-    Ok(_) => {},
-    Err(err) => return ResponseError::error_response(&err)
+  if let Err(err) = verify_role(&auth, "admin") {
+    return ResponseError::error_response(&err)
   };
   let (guild_id, channel_id) = path.into_inner();
   let guild_id = match guild_id.parse::<u64>() {
@@ -186,9 +180,8 @@ async fn play(path: web::Path<(String, String)>, play_request: web::Json<PlayReq
 
 #[post("/{guild_id}/voice/stop")]
 async fn stop(path: web::Path<String>, data: web::Data<Arc<AppState>>, auth: JwtAuth) -> HttpResponse {
-  let _ = match verify_role(&auth, "admin") {
-    Ok(_) => {},
-    Err(err) => return ResponseError::error_response(&err)
+  if let Err(err) = verify_role(&auth, "admin") {
+    return ResponseError::error_response(&err)
   };
   let guild_id = path.into_inner();
   let guild_id = match guild_id.parse::<u64>() {
@@ -211,9 +204,8 @@ async fn stop(path: web::Path<String>, data: web::Data<Arc<AppState>>, auth: Jwt
 
 #[post("/{guild_id}/voice/resume")]
 async fn resume(path: web::Path<String>, data: web::Data<Arc<AppState>>, auth: JwtAuth) -> HttpResponse {
-  let _ = match verify_role(&auth, "admin") {
-    Ok(_) => {},
-    Err(err) => return ResponseError::error_response(&err)
+  if let Err(err) = verify_role(&auth, "admin") {
+    return ResponseError::error_response(&err)
   };
   let guild_id = path.into_inner();
   let guild_id = match guild_id.parse::<u64>() {
@@ -241,9 +233,8 @@ async fn resume(path: web::Path<String>, data: web::Data<Arc<AppState>>, auth: J
 
 #[post("/{guild_id}/voice/pause")]
 async fn pause(path: web::Path<String>, data: web::Data<Arc<AppState>>, auth: JwtAuth) -> HttpResponse {
-  let _ = match verify_role(&auth, "admin") {
-    Ok(_) => {},
-    Err(err) => return ResponseError::error_response(&err)
+  if let Err(err) = verify_role(&auth, "admin") {
+    return ResponseError::error_response(&err)
   };
   let guild_id = path.into_inner();
   let guild_id = match guild_id.parse::<u64>() {
@@ -276,9 +267,8 @@ struct SetVolume {
 
 #[get("/{guild_id}/voice/volume")]
 async fn get_volume(path: web::Path<String>, auth: JwtAuth) -> HttpResponse {
-  let _ = match verify_role(&auth, "admin") {
-    Ok(_) => {},
-    Err(err) => return ResponseError::error_response(&err)
+  if let Err(err) = verify_role(&auth, "admin") {
+    return ResponseError::error_response(&err)
   };
   let guild_id = path.into_inner();
   let guild_id = match guild_id.parse::<u64>() {
@@ -306,9 +296,8 @@ async fn get_volume(path: web::Path<String>, auth: JwtAuth) -> HttpResponse {
 
 #[post("/{guild_id}/voice/volume")]
 async fn set_volume(path: web::Path<String>, volume: web::Json::<SetVolume>, data: web::Data<Arc<AppState>>, auth: JwtAuth) -> HttpResponse {
-  let _ = match verify_role(&auth, "admin") {
-    Ok(_) => {},
-    Err(err) => return ResponseError::error_response(&err)
+  if let Err(err) = verify_role(&auth, "admin") {
+    return ResponseError::error_response(&err)
   };
   let guild_id = path.into_inner();
   let guild_id = match guild_id.parse::<u64>() {
@@ -337,9 +326,8 @@ async fn set_volume(path: web::Path<String>, volume: web::Json::<SetVolume>, dat
 
 #[post("/{guild_id}/voice/skip")]
 async fn skip(path: web::Path<String>, data: web::Data<Arc<AppState>>, auth: JwtAuth) -> HttpResponse {
-  let _ = match verify_role(&auth, "admin") {
-    Ok(_) => {},
-    Err(err) => return ResponseError::error_response(&err)
+  if let Err(err) = verify_role(&auth, "admin") {
+    return ResponseError::error_response(&err)
   };
   let guild_id = path.into_inner();
   let guild_id = match guild_id.parse::<u64>() {

service/src/bot/handler.rs

@@ -5,7 +5,7 @@ use serenity::model::gateway::Ready;
 use serenity::model::channel::Message;
 use serenity::prelude::*;
 
-use crate::storage::guilds::InsertGuild;
+use crate::bot::guilds::InsertGuild;
 
 use super::commands;
 use super::commands::audio::create_response;

service/src/bot/messages/mod.rs

@@ -0,0 +1,5 @@
+mod model;
+mod routes;
+
+pub use model::*;
+pub use routes::init_routes;

service/src/bot/messages/model.rs

@@ -0,0 +1,150 @@
+use diesel::prelude::*;
+use serde::{Deserialize, Serialize};
+use siren::ServiceError;
+
+use crate::storage::{schema::messages::{self}, connection};
+
+#[derive(Queryable, Selectable, Serialize, Deserialize)]
+#[diesel(table_name = messages)]
+pub struct QueryMessage {
+  pub id: String,
+  pub guild_id: i64,
+  pub channel_id: i64,
+  pub user_id: i64,
+  pub created: i64,
+  pub model: String,
+  pub request: String,
+  pub response: String,
+  pub request_tags: Vec<String>,
+  pub response_tags: Vec<String>,
+}
+
+pub struct QueryFilters {
+  pub by_id: Option<String>,
+  pub by_guild_id: Option<i64>,
+  pub by_channel_id: Option<i64>,
+  pub by_user_id: Option<i64>,
+  pub by_model: Option<String>,
+  pub by_request: Option<String>,
+  pub by_response: Option<String>,
+  pub by_request_tags: Option<Vec<String>>,
+  pub by_response_tags: Option<Vec<String>>
+}
+
+impl Default for QueryFilters {
+  fn default() -> Self {
+    QueryFilters {
+      by_id: None,
+      by_guild_id: None,
+      by_channel_id: None,
+      by_user_id: None,
+      by_model: None,
+      by_request: None,
+      by_response: None,
+      by_request_tags: None,
+      by_response_tags: None
+    }
+  }
+}
+
+impl QueryMessage {
+  pub fn get_all(filters: &QueryFilters, limit: i32, page: i32) -> Result<Vec<Self>, ServiceError> {
+    let mut conn = connection()?;
+    let mut query = messages::table.limit(limit as i64).order(messages::created.asc()).into_boxed();
+    // Limit query to page and limit
+    let offset = (page - 1) * limit;
+    query = query.offset(offset as i64);
+    // Apply filters
+    if let Some(id) = &filters.by_id {
+      query = query.filter(messages::id.eq(id));
+    }
+    if let Some(guild_id) = &filters.by_guild_id {
+      query = query.filter(messages::guild_id.eq(guild_id));
+    }
+    if let Some(channel_id) = &filters.by_channel_id {
+      query = query.filter(messages::channel_id.eq(channel_id));
+    }
+    if let Some(user_id) = &filters.by_user_id {
+      query = query.filter(messages::user_id.eq(user_id));
+    }
+    if let Some(model) = &filters.by_model {
+      query = query.filter(messages::model.eq(model));
+    }
+    if let Some(request) = &filters.by_request {
+      query = query.filter(messages::request.eq(request));
+    }
+    if let Some(response) = &filters.by_response {
+      query = query.filter(messages::response.eq(response));
+    }
+    if let Some(request_tags) = &filters.by_request_tags {
+      query = query.filter(messages::request_tags.eq(request_tags));
+    }
+    if let Some(response_tags) = &filters.by_response_tags {
+      query = query.filter(messages::response_tags.eq(response_tags));
+    }
+    // Execute query
+    let messages = query.load::<Self>(&mut conn)?;
+    Ok(messages)
+  }
+
+  pub fn get_count(fitlers: &QueryFilters) -> Result<i64, ServiceError> {
+    let mut conn = connection()?;
+    let mut query = messages::table.into_boxed();
+    // Apply filters
+    if let Some(id) = &fitlers.by_id {
+      query = query.filter(messages::id.eq(id));
+    }
+    if let Some(guild_id) = &fitlers.by_guild_id {
+      query = query.filter(messages::guild_id.eq(guild_id));
+    }
+    if let Some(channel_id) = &fitlers.by_channel_id {
+      query = query.filter(messages::channel_id.eq(channel_id));
+    }
+    if let Some(user_id) = &fitlers.by_user_id {
+      query = query.filter(messages::user_id.eq(user_id));
+    }
+    if let Some(model) = &fitlers.by_model {
+      query = query.filter(messages::model.eq(model));
+    }
+    if let Some(request) = &fitlers.by_request {
+      query = query.filter(messages::request.eq(request));
+    }
+    if let Some(response) = &fitlers.by_response {
+      query = query.filter(messages::response.eq(response));
+    }
+    if let Some(request_tags) = &fitlers.by_request_tags {
+      query = query.filter(messages::request_tags.eq(request_tags));
+    }
+    if let Some(response_tags) = &fitlers.by_response_tags {
+      query = query.filter(messages::response_tags.eq(response_tags));
+    }
+    // Execute query
+    let count = query.count().get_result::<i64>(&mut conn)?;
+    Ok(count)
+  }
+}
+
+#[derive(Insertable, AsChangeset, Serialize, Deserialize)]
+#[diesel(table_name = messages)]
+pub struct InsertMessage {
+  pub id: String,
+  pub guild_id: i64,
+  pub channel_id: i64,
+  pub user_id: i64,
+  pub created: i64,
+  pub model: String,
+  pub request: String,
+  pub response: String,
+  pub request_tags: Vec<String>,
+  pub response_tags: Vec<String>,
+}
+
+impl InsertMessage {
+  pub fn insert(message: Self) -> Result<QueryMessage, ServiceError> {
+    let mut conn = connection()?;
+    let message = diesel::insert_into(messages::table)
+      .values(message)
+      .get_result(&mut conn)?;
+    Ok(message)
+  }
+}

service/src/bot/messages/routes.rs

@@ -0,0 +1,88 @@
+use actix_web::{get, post, web, HttpResponse, HttpRequest, ResponseError};
+use log::error;
+use serde::{Serialize, Deserialize};
+use siren::{Response, Metadata, ServiceError};
+
+use crate::{bot::messages::{QueryMessage, QueryFilters, InsertMessage}, auth::{JwtAuth, verify_role}};
+
+#[derive(Serialize, Deserialize)]
+struct GetAllParams {
+  id: Option<String>,
+  guild_id: Option<i64>,
+  channel_id: Option<i64>,
+  user_id: Option<i64>,
+  model: Option<String>,
+  request: Option<String>,
+  response: Option<String>,
+  request_tags: Option<Vec<String>>,
+  response_tags: Option<Vec<String>>,
+  limit: Option<i32>,
+  page: Option<i32>,
+}
+
+#[get("/messages")]
+async fn get_all(req: HttpRequest, auth: JwtAuth) -> HttpResponse {
+  let _ = match verify_role(&auth, "admin") {
+    Ok(_) => {},
+    Err(err) => return ResponseError::error_response(&err)
+  };
+  let params = match web::Query::<GetAllParams>::from_query(req.query_string()) {
+    Ok(params) => params,
+    Err(err) => return ResponseError::error_response(&ServiceError {
+      status: 422,
+      message: err.to_string()
+    })
+  };
+  let mut filters = QueryFilters::default();
+  filters.by_id = params.id.clone();
+  filters.by_guild_id = params.guild_id;
+  filters.by_channel_id = params.channel_id;
+  filters.by_user_id = params.user_id;
+  filters.by_model = params.model.clone();
+  filters.by_request = params.request.clone();
+  filters.by_response = params.response.clone();
+  filters.by_request_tags = params.request_tags.clone();
+  filters.by_response_tags = params.response_tags.clone();
+  let limit = params.limit.unwrap_or(100);
+  let total_count = QueryMessage::get_count(&filters).unwrap();
+  let max_page = std::cmp::max((total_count as f64 / limit as f64).ceil() as i32, 1);
+  let page = std::cmp::min(std::cmp::max(params.page.unwrap_or(1), 1), max_page);
+  
+  match QueryMessage::get_all(&filters, limit, page) {
+    Ok(messages) => {
+      HttpResponse::Ok().json(Response {
+        data: messages,
+        metadata: Some(Metadata {
+          total: total_count as i32,
+          limit,
+          page,
+          pages: max_page
+        })
+      })
+    },
+    Err(err) => {
+      error!("{:?}", err.message);
+      ResponseError::error_response(&err)
+    }
+  }
+}
+
+#[post("/messages")]
+async fn create(message: web::Json<InsertMessage>, auth: JwtAuth) -> HttpResponse {
+  let _ = match verify_role(&auth, "admin") {
+    Ok(_) => {},
+    Err(err) => return ResponseError::error_response(&err)
+  };
+  match InsertMessage::insert(message.into_inner()) {
+    Ok(message) => HttpResponse::Created().json(message),
+    Err(err) => {
+      error!("{:?}", err.message);
+      ResponseError::error_response(&err)
+    }
+  }
+}
+
+pub fn init_routes(config: &mut web::ServiceConfig) {
+  config.service(get_all);
+  config.service(create);
+}

service/src/bot/mod.rs

@@ -1,3 +1,4 @@
-pub mod api;
 pub mod commands;
+pub mod guilds;
 pub mod handler;
+pub mod messages;