From b3ee7bb1f72c5b4886b6e9eb0b7de69bc25293a1 Mon Sep 17 00:00:00 2001 From: Brandon Thomas Date: Tue, 17 Aug 2021 03:00:55 -0400 Subject: [PATCH] Update result visibility (new endpoint) --- .../endpoints/tts/edit_tts_model.rs | 10 +- .../endpoints/tts/edit_tts_result.rs | 186 ++++++++++++++++++ src/http_server/endpoints/tts/mod.rs | 1 + src/main.rs | 6 + 4 files changed, 198 insertions(+), 5 deletions(-) create mode 100644 src/http_server/endpoints/tts/edit_tts_result.rs diff --git a/src/http_server/endpoints/tts/edit_tts_model.rs b/src/http_server/endpoints/tts/edit_tts_model.rs index c02f3afb83..644c4b434f 100644 --- a/src/http_server/endpoints/tts/edit_tts_model.rs +++ b/src/http_server/endpoints/tts/edit_tts_model.rs @@ -56,7 +56,7 @@ pub struct EditTtsModelRequest { pub enum EditTtsModelError { BadInput(String), NotAuthorized, - TemplateNotFound, + ModelNotFound, ServerError, } @@ -65,7 +65,7 @@ impl ResponseError for EditTtsModelError { match *self { EditTtsModelError::BadInput(_) => StatusCode::BAD_REQUEST, EditTtsModelError::NotAuthorized => StatusCode::UNAUTHORIZED, - EditTtsModelError::TemplateNotFound => StatusCode::NOT_FOUND, + EditTtsModelError::ModelNotFound => StatusCode::NOT_FOUND, EditTtsModelError::ServerError => StatusCode::INTERNAL_SERVER_ERROR, } } @@ -74,7 +74,7 @@ impl ResponseError for EditTtsModelError { let error_reason = match self { EditTtsModelError::BadInput(reason) => reason.to_string(), EditTtsModelError::NotAuthorized=> "unauthorized".to_string(), - EditTtsModelError::TemplateNotFound => "not found".to_string(), + EditTtsModelError::ModelNotFound => "not found".to_string(), EditTtsModelError::ServerError => "server error".to_string(), }; @@ -121,11 +121,11 @@ pub async fn edit_tts_model_handler( }, Ok(None) => { warn!("could not find model"); - return Err(EditTtsModelError::TemplateNotFound); + return Err(EditTtsModelError::ModelNotFound); }, Err(err) => { warn!("error looking up model: {:?}", err); - return Err(EditTtsModelError::TemplateNotFound); + return Err(EditTtsModelError::ModelNotFound); }, }; diff --git a/src/http_server/endpoints/tts/edit_tts_result.rs b/src/http_server/endpoints/tts/edit_tts_result.rs new file mode 100644 index 0000000000..cd57d8db75 --- /dev/null +++ b/src/http_server/endpoints/tts/edit_tts_result.rs @@ -0,0 +1,186 @@ +use actix_http::Error; +use actix_http::http::header; +use actix_web::cookie::Cookie; +use actix_web::dev::HttpResponseBuilder; +use actix_web::error::ResponseError; +use actix_web::http::StatusCode; +use actix_web::web::{Path, Json}; +use actix_web::{Responder, web, HttpResponse, error, HttpRequest}; +use crate::database::enums::record_visibility::RecordVisibility; +use crate::database::queries::query_tts_model::select_tts_model_by_token; +use crate::database::queries::query_tts_result::select_tts_result_by_token; +use crate::http_server::web_utils::ip_address::get_request_ip; +use crate::http_server::web_utils::response_error_helpers::to_simple_json_error; +use crate::http_server::web_utils::response_success_helpers::simple_json_success; +use crate::server_state::ServerState; +use crate::util::email_to_gravatar::email_to_gravatar; +use crate::util::markdown_to_html::markdown_to_html; +use crate::util::random_crockford_token::random_crockford_token; +use crate::util::random_prefix_crockford_token::random_prefix_crockford_token; +use crate::validations::check_for_slurs::contains_slurs; +use derive_more::{Display, Error}; +use log::{info, warn, log}; +use regex::Regex; +use sqlx::MySqlPool; +use sqlx::error::DatabaseError; +use sqlx::error::Error::Database; +use sqlx::mysql::MySqlDatabaseError; +use std::sync::Arc; + +/// For the URL PathInfo +#[derive(Deserialize)] +pub struct EditTtsResultPathInfo { + token: String, +} + +#[derive(Deserialize)] +pub struct EditTtsResultRequest { + // ========== Author + Moderator options ========== + pub creator_set_visibility: Option, +} + +#[derive(Debug, Display)] +pub enum EditTtsResultError { + BadInput(String), + NotAuthorized, + ResultNotFound, + ServerError, +} + +impl ResponseError for EditTtsResultError { + fn status_code(&self) -> StatusCode { + match *self { + EditTtsResultError::BadInput(_) => StatusCode::BAD_REQUEST, + EditTtsResultError::NotAuthorized => StatusCode::UNAUTHORIZED, + EditTtsResultError::ResultNotFound => StatusCode::NOT_FOUND, + EditTtsResultError::ServerError => StatusCode::INTERNAL_SERVER_ERROR, + } + } + + fn error_response(&self) -> HttpResponse { + let error_reason = match self { + EditTtsResultError::BadInput(reason) => reason.to_string(), + EditTtsResultError::NotAuthorized=> "unauthorized".to_string(), + EditTtsResultError::ResultNotFound => "not found".to_string(), + EditTtsResultError::ServerError => "server error".to_string(), + }; + + to_simple_json_error(&error_reason, self.status_code()) + } +} + +pub async fn edit_tts_inference_result_handler( + http_request: HttpRequest, + path: Path, + request: web::Json, + server_state: web::Data>) -> Result +{ + let maybe_user_session = server_state + .session_checker + .maybe_get_user_session(&http_request, &server_state.mysql_pool) + .await + .map_err(|e| { + warn!("Session checker error: {:?}", e); + EditTtsResultError::ServerError + })?; + + let user_session = match maybe_user_session { + Some(session) => session, + None => { + warn!("not logged in"); + return Err(EditTtsResultError::NotAuthorized); + } + }; + + // NB: Moderators can see deleted results. + // Original creators cannot see them (unless they're moderators!) + let show_deleted_results = user_session.can_delete_other_users_tts_results; + + // Moderators get to see all the fields. + let is_moderator = user_session.can_delete_other_users_tts_results + || user_session.can_edit_other_users_tts_models; // TODO: Not an exact permission fit + + let inference_result_query_result = select_tts_result_by_token( + &path.token, + show_deleted_results, + &server_state.mysql_pool + ).await; + + let mut inference_result = match inference_result_query_result { + Err(e) => { + warn!("query error: {:?}", e); + return Err(EditTtsResultError::ServerError); + } + Ok(None) => return Err(EditTtsResultError::ResultNotFound), + Ok(Some(inference_result)) => inference_result, + }; + + // NB: Second set of permission checks + let mut is_author = false; + if let Some(creator_user_token) = inference_result.maybe_creator_user_token.as_deref() { + is_author = creator_user_token == &user_session.user_token; + } + + if !is_author && !is_moderator { + warn!("user is not allowed to edit result: {}", user_session.user_token); + return Err(EditTtsResultError::NotAuthorized); + } + + // Author + Mod fields. + // These fields must be present on all requests. + let mut creator_set_visibility = RecordVisibility::Public; + + if let Some(visibility) = request.creator_set_visibility.as_deref() { + creator_set_visibility = RecordVisibility::from_str(visibility) + .map_err(|_| EditTtsResultError::BadInput("bad record visibility".to_string()))?; + } + + let ip_address = get_request_ip(&http_request); + + let query_result = if is_author { + // TODO: Don't update the original IP address. Create a new field. + // We need to store the IP address details. + sqlx::query!( + r#" +UPDATE tts_results +SET + creator_set_visibility = ?, + creator_ip_address = ? +WHERE token = ? +LIMIT 1 + "#, + &creator_set_visibility.to_str(), + &ip_address, + &inference_result.tts_result_token, + ) + .execute(&server_state.mysql_pool) + .await + } else { + // We need to store the moderator details. + sqlx::query!( + r#" +UPDATE tts_results +SET + creator_set_visibility = ?, + maybe_mod_user_token = ? +WHERE token = ? +LIMIT 1 + "#, + &creator_set_visibility.to_str(), + &user_session.user_token, + &inference_result.tts_result_token, + ) + .execute(&server_state.mysql_pool) + .await + }; + + match query_result { + Ok(_) => {}, + Err(err) => { + warn!("Update TTS result DB error: {:?}", err); + return Err(EditTtsResultError::ServerError); + } + }; + + Ok(simple_json_success()) +} diff --git a/src/http_server/endpoints/tts/mod.rs b/src/http_server/endpoints/tts/mod.rs index 6c8b4f674f..5d7e38d8c1 100644 --- a/src/http_server/endpoints/tts/mod.rs +++ b/src/http_server/endpoints/tts/mod.rs @@ -1,6 +1,7 @@ pub mod delete_tts_model; pub mod delete_tts_result; pub mod edit_tts_model; +pub mod edit_tts_result; pub mod enqueue_infer_tts; pub mod enqueue_upload_tts_model; pub mod get_tts_inference_job_status; diff --git a/src/main.rs b/src/main.rs index 89f16e8264..58c3bcd4ac 100644 --- a/src/main.rs +++ b/src/main.rs @@ -100,6 +100,7 @@ use sqlx::MySqlPool; use sqlx::mysql::MySqlPoolOptions; use std::sync::Arc; use std::time::Duration; +use crate::http_server::endpoints::tts::edit_tts_result::edit_tts_inference_result_handler; // TODO TODO TODO TODO // TODO TODO TODO TODO @@ -432,6 +433,11 @@ pub async fn serve(server_state: ServerState) -> AnyhowResult<()> .route(web::get().to(get_tts_inference_result_handler)) .route(web::head().to(|| HttpResponse::Ok())) ) + .service( + web::resource("/result/{token}/edit") + .route(web::post().to(edit_tts_inference_result_handler)) + .route(web::head().to(|| HttpResponse::Ok())) + ) .service( web::resource("/result/{token}/delete") .route(web::post().to(delete_tts_inference_result_handler))