cross-cutting moderator lookup

This commit is contained in:
Brandon Thomas committed 2024-05-15 13:00:14 -07:00
1 parent 6cfa67de7f
commit 181efc0b94
4 files changed
+79 -48

No files matched your search

@@ -23,6 +23,7 @@ use user_input_common::check_for_slurs::contains_slurs;
use user_input_common::markdown_to_html::markdown_to_html;
use crate::http_server::endpoints::moderation::user_feature_flags::edit_user_feature_flags_handler::EditUserFeatureFlagsError;
use crate::http_server::web_utils::require_moderator::{require_moderator, RequireModeratorError};
use crate::http_server::web_utils::response_error_helpers::to_simple_json_error;
use crate::server_state::ServerState;
@@ -30,6 +31,7 @@ use crate::server_state::ServerState;
pub struct CreateBetaKeysRequest {
uuid_idempotency_token: String,
maybe_referrer_username: Option<String>,
number_of_keys: u32,
}
#[derive(Serialize, ToSchema)]
@@ -93,36 +95,13 @@ pub async fn create_beta_keys_handler(
server_state: web::Data<Arc<ServerState>>,
) -> Result<HttpResponse, CreateBetaKeysError>
{
let mut mysql_connection = server_state.mysql_pool
.acquire()
let user_session = require_moderator(&http_request, &server_state)
.await
.map_err(|err| {
warn!("MySql pool error: {:?}", err);
CreateBetaKeysError::ServerError
.map_err(|err| match err {
RequireModeratorError::ServerError => CreateBetaKeysError::ServerError,
RequireModeratorError::NotAuthorized => CreateBetaKeysError::NotAuthorized,
})?;
let maybe_user_session = server_state
.session_checker
.maybe_get_user_session_from_connection(&http_request, &mut mysql_connection)
.await
.map_err(|e| {
warn!("Session checker error: {:?}", e);
CreateBetaKeysError::ServerError
})?;
let user_session = match maybe_user_session {
Some(session) => session,
None => {
warn!("not logged in");
return Err(CreateBetaKeysError::NotAuthorized);
}
};
if !user_session.can_ban_users {
warn!("user is not allowed to add bans: {:?}", user_session.user_token.as_str());
return Err(CreateBetaKeysError::NotAuthorized);
}
// TODO(bt,2024-05-13): Create beta key records
let response = CreateBetaKeysSuccessResponse {
@@ -137,3 +116,4 @@ pub async fn create_beta_keys_handler(
.content_type("application/json")
.body(body))
}
@@ -9,13 +9,13 @@ use log::{log, warn};
use serde::Serialize;
use sqlx::MySqlPool;
use utoipa::ToSchema;
use errors::AnyhowResult;
use mysql_queries::queries::generic_inference::web::get_inference_job_status::get_inference_job_status;
use mysql_queries::queries::media_files::get::get_media_file::get_media_file;
use mysql_queries::queries::model_weights::get::get_weight::get_weight_by_token;
use mysql_queries::queries::model_weights::model_weight_info_lite::get_model_weight_info_lite::get_model_weight_info_lite;
use mysql_queries::queries::prompts::get_prompt::get_prompt;
use mysql_queries::queries::tts::tts_inference_jobs::get_pending_tts_inference_job_detailed_stats::{get_pending_tts_inference_job_detailed_stats, PendingCountResult};
use mysql_queries::queries::users::user_profiles::get_user_profile_by_token::get_user_profile_by_token;
use mysql_queries::queries::users::user_profiles::get_user_profile_by_username::get_user_profile_by_username;
@@ -26,6 +26,7 @@ use tokens::tokens::model_weights::ModelWeightToken;
use tokens::tokens::prompts::PromptToken;
use tokens::tokens::users::UserToken;
use crate::http_server::web_utils::require_moderator::{require_moderator, RequireModeratorError};
use crate::http_server::web_utils::serialize_as_json_error::serialize_as_json_error;
use crate::server_state::ServerState;
@@ -86,29 +87,13 @@ pub async fn moderator_get_token_info_handler(
server_state: web::Data<Arc<ServerState>>
) -> Result<HttpResponse, ModeratorTokenInfoError> {
let maybe_user_session = server_state
.session_checker
.maybe_get_user_session(&http_request, &server_state.mysql_pool)
let user_session = require_moderator(&http_request, &server_state)
.await
.map_err(|e| {
warn!("Session checker error: {:?}", e);
ModeratorTokenInfoError::ServerError
.map_err(|err| match err {
RequireModeratorError::ServerError => ModeratorTokenInfoError::ServerError,
RequireModeratorError::NotAuthorized => ModeratorTokenInfoError::Unauthorized,
})?;
let user_session = match maybe_user_session {
Some(session) => session,
None => {
warn!("not logged in");
return Err(ModeratorTokenInfoError::Unauthorized);
}
};
// TODO: Not a good fit for this permission.
if !user_session.can_ban_users {
warn!("user is not allowed to view bans: {:?}", user_session.user_token);
return Err(ModeratorTokenInfoError::Unauthorized);
}
let token = path.token.trim();
let maybe_result = get_entity_from_token(&server_state.mysql_pool, &path.token)
.await
@@ -2,6 +2,7 @@ pub mod get_host_header;
pub mod handle_multipart_error;
pub mod read_multipart_field_bytes;
pub mod redis_rate_limiter;
pub mod require_moderator;
pub mod response_error_helpers;
pub mod response_success_helpers;
pub mod serialize_as_json_error;
@@ -0,0 +1,65 @@
use std::error::Error;
use std::fmt::{Display, Formatter};
use actix_web::HttpRequest;
use log::warn;
use mysql_queries::queries::users::user_sessions::get_user_session_by_token::SessionUserRecord;
use crate::http_server::endpoints::beta_keys::create_beta_keys_handler::CreateBetaKeysError;
use crate::server_state::ServerState;
#[derive(Debug)]
pub enum RequireModeratorError {
ServerError,
NotAuthorized,
}
impl Display for RequireModeratorError {
fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
match self {
Self::ServerError => write!(f, "ServerError"),
Self::NotAuthorized => write!(f, "NotAuthorized"),
}
}
}
impl Error for RequireModeratorError {}
pub async fn require_moderator(
http_request: &HttpRequest,
server_state: &ServerState,
) -> Result<SessionUserRecord, RequireModeratorError> {
let mut mysql_connection = server_state.mysql_pool
.acquire()
.await
.map_err(|err| {
warn!("MySql pool error: {:?}", err);
RequireModeratorError::ServerError
})?;
let maybe_user_session = server_state
.session_checker
.maybe_get_user_session_from_connection(&http_request, &mut mysql_connection)
.await
.map_err(|e| {
warn!("Session checker error: {:?}", e);
RequireModeratorError::ServerError
})?;
let user_session = match maybe_user_session {
Some(session) => session,
None => {
warn!("not logged in");
return Err(RequireModeratorError::NotAuthorized);
}
};
if !user_session.can_ban_users {
warn!("user is not a moderator: {:?}", user_session.user_token.as_str());
return Err(RequireModeratorError::NotAuthorized);
}
Ok(user_session)
}