get beta key (todo: redeem)

This commit is contained in:
Brandon Thomas committed 2024-05-15 14:37:32 -07:00
1 parent ee8c3cfb1a
commit 6d42b2bf44
7 files changed
+218 -53

No files matched your search

@@ -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<UserToken>,
pub maybe_referrer_username: Option<String>,
pub maybe_referrer_display_name: Option<String>,
pub maybe_referrer_gravatar_hash: Option<String>,
pub maybe_redeemer_user_token: Option<UserToken>,
pub maybe_redeemer_username: Option<String>,
pub maybe_redeemer_display_name: Option<String>,
pub maybe_redeemer_gravatar_hash: Option<String>,
pub created_at: DateTime<Utc>,
pub maybe_redeemed_at: Option<DateTime<Utc>>,
}
pub async fn get_beta_key_by_value<'e, 'c, E>(
key_value: &'e str,
mysql_executor: E
)
-> AnyhowResult<Option<BetaKey>>
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<UserToken>,
maybe_referrer_username: Option<String>,
maybe_referrer_display_name: Option<String>,
maybe_referrer_gravatar_hash: Option<String>,
maybe_redeemer_user_token: Option<UserToken>,
maybe_redeemer_username: Option<String>,
maybe_redeemer_display_name: Option<String>,
maybe_redeemer_gravatar_hash: Option<String>,
created_at: DateTime<Utc>,
maybe_redeemed_at: Option<DateTime<Utc>>,
}
@@ -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<BetaKeyListItem>,
@@ -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
@@ -1,2 +1,3 @@
pub mod get_beta_key_by_value;
pub mod insert_batch_beta_keys;
pub mod list_beta_keys;
@@ -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<ListBetaKeysQueryParams>,
server_state: web::Data<Arc<ServerState>>
) -> Result<HttpResponse, ListBetaKeysError> {
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;
@@ -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<Arc<ServerState>>,
) -> Result<HttpResponse, RedeemBetaKeyError>
{
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,
};
@@ -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;
@@ -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<SessionUserRecord, RequireUserSessionError> {
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)
}