diff --git a/crates/lib/mysql_queries/src/queries/beta_keys/get_beta_key_by_value.rs b/crates/lib/mysql_queries/src/queries/beta_keys/get_beta_key_by_value.rs new file mode 100644 index 0000000000..edefea1b83 --- /dev/null +++ b/crates/lib/mysql_queries/src/queries/beta_keys/get_beta_key_by_value.rs @@ -0,0 +1,119 @@ +use anyhow::anyhow; +use chrono::{DateTime, Utc}; +use sqlx::{Executor, MySql}; +use enums::by_table::beta_keys::beta_key_product::BetaKeyProduct; + +use enums::by_table::comments::comment_entity_type::CommentEntityType; +use errors::AnyhowResult; +use tokens::tokens::beta_keys::BetaKeyToken; +use tokens::tokens::comments::CommentToken; +use tokens::tokens::users::UserToken; + +pub struct BetaKey { + pub token: BetaKeyToken, + + pub product: BetaKeyProduct, + pub key_value: String, + + pub maybe_referrer_user_token: Option, + pub maybe_referrer_username: Option, + pub maybe_referrer_display_name: Option, + pub maybe_referrer_gravatar_hash: Option, + + pub maybe_redeemer_user_token: Option, + pub maybe_redeemer_username: Option, + pub maybe_redeemer_display_name: Option, + pub maybe_redeemer_gravatar_hash: Option, + + pub created_at: DateTime, + pub maybe_redeemed_at: Option>, +} + +pub async fn get_beta_key_by_value<'e, 'c, E>( + key_value: &'e str, + mysql_executor: E +) + -> AnyhowResult> + where E: 'e + Executor<'c, Database = MySql> +{ + + let maybe_results = sqlx::query_as!( + RawRecord, + r#" +SELECT + b.token as `token: tokens::tokens::beta_keys::BetaKeyToken`, + + b.product as `product: enums::by_table::beta_keys::beta_key_product::BetaKeyProduct`, + b.key_value, + + b.maybe_referrer_user_token as `maybe_referrer_user_token: tokens::tokens::users::UserToken`, + referrer.username as maybe_referrer_username, + referrer.display_name as maybe_referrer_display_name, + referrer.email_gravatar_hash as maybe_referrer_gravatar_hash, + + b.maybe_redeemer_user_token as `maybe_redeemer_user_token: tokens::tokens::users::UserToken`, + redeemer.username as maybe_redeemer_username, + redeemer.display_name as maybe_redeemer_display_name, + redeemer.email_gravatar_hash as maybe_redeemer_gravatar_hash, + + b.created_at, + b.maybe_redeemed_at + +FROM beta_keys AS b + +LEFT OUTER JOIN users AS referrer + ON b.maybe_referrer_user_token = referrer.token + +LEFT OUTER JOIN users AS redeemer + ON b.maybe_redeemer_user_token = redeemer.token + +WHERE + b.key_value = ? + "#, + key_value + ) + .fetch_one(mysql_executor) + .await; + + match maybe_results { + Ok(record) => Ok(Some(BetaKey { + token: record.token, + product: record.product, + key_value: record.key_value, + maybe_referrer_user_token: record.maybe_referrer_user_token, + maybe_referrer_username: record.maybe_referrer_username, + maybe_referrer_display_name: record.maybe_referrer_display_name, + maybe_referrer_gravatar_hash: record.maybe_referrer_gravatar_hash, + maybe_redeemer_user_token: record.maybe_redeemer_user_token, + maybe_redeemer_username: record.maybe_redeemer_username, + maybe_redeemer_display_name: record.maybe_redeemer_display_name, + maybe_redeemer_gravatar_hash: record.maybe_redeemer_gravatar_hash, + created_at: record.created_at, + maybe_redeemed_at: record.maybe_redeemed_at, + })), + Err(err) => match err { + sqlx::Error::RowNotFound => Ok(None), + _ => Err(anyhow!("Error querying: {:?}", err)), + } + } +} + +pub struct RawRecord { + token: BetaKeyToken, + + product: BetaKeyProduct, + key_value: String, + + maybe_referrer_user_token: Option, + maybe_referrer_username: Option, + maybe_referrer_display_name: Option, + maybe_referrer_gravatar_hash: Option, + + maybe_redeemer_user_token: Option, + maybe_redeemer_username: Option, + maybe_redeemer_display_name: Option, + maybe_redeemer_gravatar_hash: Option, + + created_at: DateTime, + maybe_redeemed_at: Option>, +} diff --git a/crates/lib/mysql_queries/src/queries/beta_keys/list_beta_keys.rs b/crates/lib/mysql_queries/src/queries/beta_keys/list_beta_keys.rs index cf3279c7f7..4ca1cd9a96 100644 --- a/crates/lib/mysql_queries/src/queries/beta_keys/list_beta_keys.rs +++ b/crates/lib/mysql_queries/src/queries/beta_keys/list_beta_keys.rs @@ -1,24 +1,12 @@ -use std::collections::HashSet; use chrono::{DateTime, Utc}; use sqlx::{FromRow, MySql, MySqlPool, QueryBuilder, Row}; use sqlx::mysql::MySqlRow; -use enums::by_table::beta_keys::beta_key_product::BetaKeyProduct; -use enums::by_table::media_files::media_file_animation_type::MediaFileAnimationType; -use enums::by_table::media_files::media_file_class::MediaFileClass; -use enums::by_table::media_files::media_file_engine_category::MediaFileEngineCategory; -use enums::by_table::media_files::media_file_origin_category::MediaFileOriginCategory; -use enums::by_table::media_files::media_file_origin_model_type::MediaFileOriginModelType; -use enums::by_table::media_files::media_file_origin_product_category::MediaFileOriginProductCategory; -use enums::by_table::media_files::media_file_type::MediaFileType; -use enums::common::view_as::ViewAs; -use enums::common::visibility::Visibility; +use enums::by_table::beta_keys::beta_key_product::BetaKeyProduct; use enums::traits::mysql_from_row::MySqlFromRow; use errors::AnyhowResult; use tokens::tokens::beta_keys::BetaKeyToken; -use tokens::tokens::media_files::MediaFileToken; use tokens::tokens::users::UserToken; -use crate::payloads::prompt_args::prompt_inner_payload::PromptInnerPayload; pub struct BetaKeyListPage { pub records: Vec, @@ -144,6 +132,8 @@ SELECT b.created_at, b.maybe_redeemed_at +FROM beta_keys AS b + LEFT OUTER JOIN users AS referrer ON b.maybe_referrer_user_token = referrer.token diff --git a/crates/lib/mysql_queries/src/queries/beta_keys/mod.rs b/crates/lib/mysql_queries/src/queries/beta_keys/mod.rs index af4e067902..d28146d767 100644 --- a/crates/lib/mysql_queries/src/queries/beta_keys/mod.rs +++ b/crates/lib/mysql_queries/src/queries/beta_keys/mod.rs @@ -1,2 +1,3 @@ +pub mod get_beta_key_by_value; pub mod insert_batch_beta_keys; pub mod list_beta_keys; \ No newline at end of file diff --git a/crates/service/web/storyteller_web/src/http_server/endpoints/beta_keys/list_beta_keys_handler.rs b/crates/service/web/storyteller_web/src/http_server/endpoints/beta_keys/list_beta_keys_handler.rs index 3cf1dc37ba..ba80f1191a 100644 --- a/crates/service/web/storyteller_web/src/http_server/endpoints/beta_keys/list_beta_keys_handler.rs +++ b/crates/service/web/storyteller_web/src/http_server/endpoints/beta_keys/list_beta_keys_handler.rs @@ -31,10 +31,12 @@ use crate::http_server::common_responses::media_file_origin_details::MediaFileOr use crate::http_server::common_responses::pagination_cursors::PaginationCursors; use crate::http_server::common_responses::simple_entity_stats::SimpleEntityStats; use crate::http_server::endpoints::beta_keys::create_beta_keys_handler::CreateBetaKeysError; +use crate::http_server::endpoints::events::list_events::ListEventsError; use crate::http_server::endpoints::media_files::list::helpers::get_scoped_engine_categories::get_scoped_engine_categories; use crate::http_server::endpoints::media_files::list::helpers::get_scoped_media_classes::get_scoped_media_classes; use crate::http_server::endpoints::media_files::list::helpers::get_scoped_media_types::get_scoped_media_types; use crate::http_server::web_utils::require_moderator::{require_moderator, RequireModeratorError}; +use crate::http_server::web_utils::require_user_session::{require_user_session, RequireUserSessionError}; use crate::server_state::ServerState; use crate::util::allowed_explore_media_access::allowed_explore_media_access; @@ -112,26 +114,14 @@ pub async fn list_beta_keys_handler( query: Query, server_state: web::Data> ) -> Result { - let maybe_user_session = server_state - .session_checker - .maybe_get_user_session(&http_request, &server_state.mysql_pool) + let user_session = require_user_session(&http_request, &server_state) .await - .map_err(|e| { - warn!("Session checker error: {:?}", e); - ListBetaKeysError::ServerError + .map_err(|err| match err { + RequireUserSessionError::ServerError => ListBetaKeysError::ServerError, + RequireUserSessionError::NotAuthorized => ListBetaKeysError::NotAuthorized, })?; - let mut is_mod = false; - - let user_session = match maybe_user_session { - None => { - return Err(ListBetaKeysError::NotAuthorized); - }, - Some(session) => { - is_mod = session.can_ban_users; - session - }, - }; + let mut is_mod = user_session.can_ban_users; let mut maybe_scope_user_token = None; diff --git a/crates/service/web/storyteller_web/src/http_server/endpoints/beta_keys/redeem_beta_key_handler.rs b/crates/service/web/storyteller_web/src/http_server/endpoints/beta_keys/redeem_beta_key_handler.rs index 4c460e95f1..6af7c3869f 100644 --- a/crates/service/web/storyteller_web/src/http_server/endpoints/beta_keys/redeem_beta_key_handler.rs +++ b/crates/service/web/storyteller_web/src/http_server/endpoints/beta_keys/redeem_beta_key_handler.rs @@ -9,6 +9,7 @@ use utoipa::ToSchema; use enums::by_table::comments::comment_entity_type::CommentEntityType; use http_server_common::request::get_request_ip::get_request_ip; +use mysql_queries::queries::beta_keys::get_beta_key_by_value::get_beta_key_by_value; use mysql_queries::queries::comments::comment_entity_token::CommentEntityToken; use mysql_queries::queries::comments::insert_comment::{insert_comment, InsertCommentArgs}; use tokens::tokens::comments::CommentToken; @@ -22,7 +23,10 @@ use tokens::tokens::w2l_templates::W2lTemplateToken; use user_input_common::check_for_slurs::contains_slurs; use user_input_common::markdown_to_html::markdown_to_html; +use crate::http_server::endpoints::beta_keys::list_beta_keys_handler::ListBetaKeysError; use crate::http_server::endpoints::moderation::user_feature_flags::edit_user_feature_flags_handler::EditUserFeatureFlagsError; +use crate::http_server::web_utils::require_moderator::RequireModeratorError; +use crate::http_server::web_utils::require_user_session::{require_user_session, RequireUserSessionError}; use crate::http_server::web_utils::response_error_helpers::to_simple_json_error; use crate::server_state::ServerState; @@ -40,6 +44,7 @@ pub struct RedeemBetaKeySuccessResponse { pub enum RedeemBetaKeyError { BadInput(String), NotAuthorized, + NotFound, ServerError, } @@ -48,6 +53,7 @@ impl ResponseError for RedeemBetaKeyError { match *self { RedeemBetaKeyError::BadInput(_) => StatusCode::BAD_REQUEST, RedeemBetaKeyError::NotAuthorized => StatusCode::UNAUTHORIZED, + RedeemBetaKeyError::NotFound => StatusCode::NOT_FOUND, RedeemBetaKeyError::ServerError => StatusCode::INTERNAL_SERVER_ERROR, } } @@ -56,6 +62,7 @@ impl ResponseError for RedeemBetaKeyError { let error_reason = match self { RedeemBetaKeyError::BadInput(reason) => reason.to_string(), RedeemBetaKeyError::NotAuthorized => "unauthorized".to_string(), + RedeemBetaKeyError::NotFound => "not found".to_string(), RedeemBetaKeyError::ServerError => "server error".to_string(), }; @@ -79,6 +86,7 @@ impl fmt::Display for RedeemBetaKeyError { (status = 200, description = "Success", body = RedeemBetaKeySuccessResponse), (status = 400, description = "Bad input", body = RedeemBetaKeyError), (status = 401, description = "Not authorized", body = RedeemBetaKeyError), + (status = 404, description = "Not found", body = RedeemBetaKeyError), (status = 500, description = "Server error", body = RedeemBetaKeyError), ), params( @@ -91,38 +99,29 @@ pub async fn redeem_beta_key_handler( server_state: web::Data>, ) -> Result { - let mut mysql_connection = server_state.mysql_pool - .acquire() + let user_session = require_user_session(&http_request, &server_state) + .await + .map_err(|err| match err { + RequireUserSessionError::ServerError => RedeemBetaKeyError::ServerError, + RequireUserSessionError::NotAuthorized => RedeemBetaKeyError::NotAuthorized, + })?; + + let maybe_beta_key = get_beta_key_by_value(&request.beta_key, &server_state.mysql_pool) .await .map_err(|err| { - warn!("MySql pool error: {:?}", err); + warn!("Error getting beta key by value: {:?}", &err); RedeemBetaKeyError::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); - RedeemBetaKeyError::ServerError - })?; - - let user_session = match maybe_user_session { - Some(session) => session, - None => { - warn!("not logged in"); - return Err(RedeemBetaKeyError::NotAuthorized); - } + let beta_key = match maybe_beta_key { + Some(beta_key) => beta_key, + None => return Err(RedeemBetaKeyError::NotFound), }; - if !user_session.can_ban_users { - warn!("user is not allowed to add bans: {:?}", user_session.user_token.as_str()); - return Err(RedeemBetaKeyError::NotAuthorized); + if beta_key.maybe_redeemed_at.is_some() || beta_key.maybe_redeemer_user_token.is_some() { + return Err(RedeemBetaKeyError::BadInput("beta key already redeemed".to_string())); } - // TODO(bt,2024-05-13): Create beta key records - let response = RedeemBetaKeySuccessResponse { success: true, }; diff --git a/crates/service/web/storyteller_web/src/http_server/web_utils/mod.rs b/crates/service/web/storyteller_web/src/http_server/web_utils/mod.rs index 7d9afbdf4c..ae531e3f9a 100644 --- a/crates/service/web/storyteller_web/src/http_server/web_utils/mod.rs +++ b/crates/service/web/storyteller_web/src/http_server/web_utils/mod.rs @@ -3,6 +3,7 @@ pub mod handle_multipart_error; pub mod read_multipart_field_bytes; pub mod redis_rate_limiter; pub mod require_moderator; +pub mod require_user_session; pub mod response_error_helpers; pub mod response_success_helpers; pub mod serialize_as_json_error; \ No newline at end of file diff --git a/crates/service/web/storyteller_web/src/http_server/web_utils/require_user_session.rs b/crates/service/web/storyteller_web/src/http_server/web_utils/require_user_session.rs new file mode 100644 index 0000000000..64dbd1cc29 --- /dev/null +++ b/crates/service/web/storyteller_web/src/http_server/web_utils/require_user_session.rs @@ -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 RequireUserSessionError { + ServerError, + NotAuthorized, +} + +impl Display for RequireUserSessionError { + fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { + match self { + Self::ServerError => write!(f, "ServerError"), + Self::NotAuthorized => write!(f, "NotAuthorized"), + } + } +} + +impl Error for RequireUserSessionError {} + +pub async fn require_user_session( + http_request: &HttpRequest, + server_state: &ServerState, +) -> Result { + + let mut mysql_connection = server_state.mysql_pool + .acquire() + .await + .map_err(|err| { + warn!("MySql pool error: {:?}", err); + RequireUserSessionError::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); + RequireUserSessionError::ServerError + })?; + + let user_session = match maybe_user_session { + Some(session) => session, + None => { + warn!("not logged in"); + return Err(RequireUserSessionError::NotAuthorized); + } + }; + + if user_session.is_banned { + warn!("user is banned: {:?}", user_session.user_token.as_str()); + return Err(RequireUserSessionError::NotAuthorized); + } + + Ok(user_session) +}