diff --git a/_migrations/2022-12-15-060826_media_uploads/up.sql b/_migrations/2022-12-15-060826_media_uploads/up.sql index e78bd1f33e..98f599199a 100644 --- a/_migrations/2022-12-15-060826_media_uploads/up.sql +++ b/_migrations/2022-12-15-060826_media_uploads/up.sql @@ -60,6 +60,8 @@ CREATE TABLE media_uploads ( -- ========== UPLOAD, TRANSCODING, AND TRUNCATION DETAILS ========== + -- TODO(bt, 2022-12-20): Before landing, rename this field be better and indicate this + -- is a *directory*. Add a second field to contain the default file name. -- The directory this media is uploaded to will be exclusive for this file. -- Only this given record will live in this bucket, but the directory may include -- other transcodings or truncations. diff --git a/crates/lib/database_queries/src/mediators/firehose_publisher.rs b/crates/lib/database_queries/src/mediators/firehose_publisher.rs index 203554fafa..5cdff00101 100644 --- a/crates/lib/database_queries/src/mediators/firehose_publisher.rs +++ b/crates/lib/database_queries/src/mediators/firehose_publisher.rs @@ -6,12 +6,15 @@ use sqlx::error::Error::Database; use sqlx::mysql::MySqlQueryResult; use sqlx::{MySqlPool}; use std::sync::Arc; +use tokens::files::media_upload::MediaUploadToken; +use tokens::users::user::UserToken; +// TODO(bt, 2022-12-19): Convert this to a database 'enum'. Also, create an 'enums' package similar to 'tokens'. #[derive(Debug, Clone, Copy)] enum FirehoseEvent { UserSignUp, - // We don't publish for all badges (eg. early user signup) + // NB: We don't publish for all badges (eg. early user signup) UserBadgeGranted, TtsModelUploadStarted, @@ -27,6 +30,9 @@ enum FirehoseEvent { GenericDownloadStarted, GenericDownloadCompleted, + MediaUploaded, + + // TODO(bt, 2022-12-19): Are the following unused, merely planned (?) TwitterMention, TwitterRetweet, DiscordJoin, @@ -48,14 +54,17 @@ impl FirehoseEvent { FirehoseEvent::W2lTemplateUploadCompleted => "w2l_template_upload_completed", FirehoseEvent::W2lInferenceStarted => "w2l_inference_started", FirehoseEvent::W2lInferenceCompleted => "w2l_inference_completed", + FirehoseEvent::GenericDownloadStarted => "generic_download_started", + FirehoseEvent::GenericDownloadCompleted => "generic_download_completed", + FirehoseEvent::MediaUploaded => "media_uploaded", + + // Are the following unused (?) FirehoseEvent::TwitterMention => "twitter_mention", FirehoseEvent::TwitterRetweet => "twitter_retweet", FirehoseEvent::DiscordJoin => "discord_join", FirehoseEvent::DiscordMessage => "discord_message", FirehoseEvent::TwitchSubscribe => "twitch_subscribe", FirehoseEvent::TwitchFollow => "twitch_follow", - FirehoseEvent::GenericDownloadStarted => "generic_download_started", - FirehoseEvent::GenericDownloadCompleted => "generic_download_completed", } } } @@ -198,6 +207,16 @@ impl FirehosePublisher { Ok(()) } + pub async fn publish_media_uploaded(&self, maybe_user_token: Option<&UserToken>, upload_token: &MediaUploadToken) -> AnyhowResult<()> { + let _record_id = self.insert( + FirehoseEvent::MediaUploaded, + maybe_user_token.map(|u| u.as_str()), + Some(upload_token.as_str()), + Some(upload_token.as_str()), + ).await?; + Ok(()) + } + // ======================================================================= async fn insert( @@ -237,6 +256,8 @@ SET Ok(res) => { res.last_insert_id() }, + // TODO(bt, 2022-12-20): I've never richly handled database errors/error codes. + // I should revisit these in the future and consider some kind of middleware. Err(err) => { warn!("Insert record DB error: {:?}", err); diff --git a/crates/lib/database_queries/src/queries/media_uploads/insert_media_upload.rs b/crates/lib/database_queries/src/queries/media_uploads/insert_media_upload.rs new file mode 100644 index 0000000000..50d12b8713 --- /dev/null +++ b/crates/lib/database_queries/src/queries/media_uploads/insert_media_upload.rs @@ -0,0 +1,100 @@ +use anyhow::anyhow; +use container_common::anyhow_result::AnyhowResult; +use reusable_types::db::enums::entity_visibility::EntityVisibility; +use reusable_types::db::enums::media_upload_type::MediaUploadType; +use sqlx::MySqlPool; +use reusable_types::db::payloads::MediaUploadDetails; +use tokens::files::media_upload::MediaUploadToken; +use tokens::users::user::UserToken; + +pub struct Args <'a> { + pub token: &'a MediaUploadToken, + pub uuid_idempotency_token: &'a str, + + pub media_type: MediaUploadType, + pub maybe_original_filename: Option<&'a str>, + pub original_file_size_bytes: u64, + pub original_duration_millis: u64, + pub maybe_original_mime_type: Option<&'a str>, + pub maybe_original_audio_encoding: Option<&'a str>, + pub maybe_original_video_encoding: Option<&'a str>, + pub maybe_original_frame_width: Option, + pub maybe_original_frame_height: Option, + pub checksum_sha2: &'a str, + + pub public_bucket_directory_full_path: &'a str, + pub extra_file_modification_info: MediaUploadDetails, + + pub maybe_creator_user_token: Option<&'a UserToken>, + pub maybe_creator_anonymous_visitor_token: Option<&'a str>, + pub creator_ip_address: &'a str, + pub creator_set_visibility: EntityVisibility, + + pub maybe_creator_synthetic_id: Option, + + pub mysql_pool: &'a MySqlPool, +} + +pub async fn insert_media_upload(args: Args<'_>) -> AnyhowResult { + + let query = sqlx::query!( + r#" +INSERT INTO media_uploads +SET + token = ?, + uuid_idempotency_token = ?, + + media_type = ?, + maybe_original_filename = ?, + original_file_size_bytes = ?, + original_duration_millis = ?, + maybe_original_mime_type = ?, + maybe_original_audio_encoding = ?, + maybe_original_video_encoding = ?, + maybe_original_frame_width = ?, + maybe_original_frame_height = ?, + checksum_sha2 = ?, + + public_bucket_directory_full_path = ?, + extra_file_modification_info = ?, + + maybe_creator_user_token = ?, + maybe_creator_anonymous_visitor_token = ?, + creator_ip_address = ?, + creator_set_visibility = ?, + + maybe_creator_synthetic_id = ? + "#, + args.token, + args.uuid_idempotency_token, + + args.media_type, + args.maybe_original_filename, + args.original_file_size_bytes, + args.original_duration_millis, + args.maybe_original_mime_type, + args.maybe_original_audio_encoding, + args.maybe_original_video_encoding, + args.maybe_original_frame_width, + args.maybe_original_frame_height, + args.checksum_sha2, + + args.public_bucket_directory_full_path, + "", // TODO: args.extra_file_modification_info, + + args.maybe_creator_user_token, + args.maybe_creator_anonymous_visitor_token, + args.creator_ip_address, + args.creator_set_visibility, + + args.maybe_creator_synthetic_id, + ); + + let query_result = query.execute(args.mysql_pool) + .await; + + match query_result { + Ok(res) => Ok(res.last_insert_id()), + Err(err) => Err(anyhow!("error inserting new media upload: {:?}", err)), + } +} diff --git a/crates/lib/database_queries/src/queries/media_uploads/mod.rs b/crates/lib/database_queries/src/queries/media_uploads/mod.rs new file mode 100644 index 0000000000..d8571ca39b --- /dev/null +++ b/crates/lib/database_queries/src/queries/media_uploads/mod.rs @@ -0,0 +1 @@ +pub mod insert_media_upload; \ No newline at end of file diff --git a/crates/lib/database_queries/src/queries/mod.rs b/crates/lib/database_queries/src/queries/mod.rs index ca02151cc0..b15d0be795 100644 --- a/crates/lib/database_queries/src/queries/mod.rs +++ b/crates/lib/database_queries/src/queries/mod.rs @@ -4,6 +4,7 @@ pub mod generic_download; pub mod generic_inference; pub mod health_check; pub mod ip_bans; +pub mod media_uploads; pub mod model_categories; pub mod stats; pub mod tts; diff --git a/crates/lib/database_queries/src/queries/users/user_sessions/get_user_session_by_token.rs b/crates/lib/database_queries/src/queries/users/user_sessions/get_user_session_by_token.rs index 9d848bd0e3..a6c3f65cdf 100644 --- a/crates/lib/database_queries/src/queries/users/user_sessions/get_user_session_by_token.rs +++ b/crates/lib/database_queries/src/queries/users/user_sessions/get_user_session_by_token.rs @@ -9,9 +9,10 @@ use crate::helpers::boolean_converters::{nullable_i8_to_optional_bool, i8_to_boo use log::warn; use sqlx::MySql; use sqlx::pool::PoolConnection; +use tokens::users::user::UserToken; pub struct SessionUserRecord { - pub user_token: String, + pub user_token: String, // TODO(bt, 2022-12-20): Convert to strongly-typed `UserToken` pub username: String, pub display_name: String, @@ -65,6 +66,13 @@ pub struct SessionUserRecord { pub can_delete_users: bool, } +impl SessionUserRecord { + // TODO(bt, 2022-12-20): Convert all users of the bare record to using `UserToken`, then get rid of this method. + pub fn get_strongly_typed_user_token(&self) -> UserToken { + UserToken::new_from_str(&self.user_token) + } +} + pub async fn get_user_session_by_token( mysql_connection: &mut PoolConnection, session_token: &str, diff --git a/crates/lib/reusable_types/src/db/enums/media_upload_type.rs b/crates/lib/reusable_types/src/db/enums/media_upload_type.rs new file mode 100644 index 0000000000..c16c49e9a1 --- /dev/null +++ b/crates/lib/reusable_types/src/db/enums/media_upload_type.rs @@ -0,0 +1,53 @@ +/// Used in the `media_uploads` table. +/// +/// DO NOT CHANGE VALUES WITHOUT A MIGRATION STRATEGY. +#[derive(Clone, Copy, Eq, PartialEq, Debug, Deserialize, Serialize, sqlx::Type)] +#[serde(rename_all = "lowercase")] +#[sqlx(rename_all = "lowercase")] +pub enum MediaUploadType { + Audio, + Video, +} + +/// NB: Legacy API for older code. +impl MediaUploadType { + pub fn to_str(&self) -> &'static str { + match self { + Self::Audio => "audio", + Self::Video => "video", + } + } + + pub fn from_str(value: &str) -> Result { + match value { + "audio" => Ok(Self::Audio), + "video" => Ok(Self::Video), + _ => Err(format!("invalid value: {:?}", value)), + } + } +} + +#[cfg(test)] +mod tests { + use crate::db::enums::media_upload_type::MediaUploadType; + use crate::test_helpers::assert_serialization; + + #[test] + fn test_serialization() { + assert_serialization(MediaUploadType::Audio, "audio"); + assert_serialization(MediaUploadType::Video, "video"); + } + + #[test] + fn test_to_str() { + assert_eq!(MediaUploadType::Audio.to_str(), "audio"); + assert_eq!(MediaUploadType::Video.to_str(), "video"); + } + + #[test] + fn test_from_str() { + assert_eq!(MediaUploadType::from_str("audio").unwrap(), MediaUploadType::Audio); + assert_eq!(MediaUploadType::from_str("video").unwrap(), MediaUploadType::Video); + assert!(MediaUploadType::from_str("foo").is_err()); + } +} diff --git a/crates/lib/reusable_types/src/db/enums/mod.rs b/crates/lib/reusable_types/src/db/enums/mod.rs index 1e65a74f6b..351ce576b3 100644 --- a/crates/lib/reusable_types/src/db/enums/mod.rs +++ b/crates/lib/reusable_types/src/db/enums/mod.rs @@ -4,4 +4,5 @@ pub mod entity_visibility; pub mod generic_download_type; pub mod generic_inference_type; +pub mod media_upload_type; pub mod vocoder_type; diff --git a/crates/lib/reusable_types/src/db/payloads/media_upload_details.rs b/crates/lib/reusable_types/src/db/payloads/media_upload_details.rs new file mode 100644 index 0000000000..e69de29bb2 diff --git a/crates/lib/reusable_types/src/db/payloads/mod.rs b/crates/lib/reusable_types/src/db/payloads/mod.rs index e69de29bb2..8d819959a6 100644 --- a/crates/lib/reusable_types/src/db/payloads/mod.rs +++ b/crates/lib/reusable_types/src/db/payloads/mod.rs @@ -0,0 +1,5 @@ +pub mod media_upload_details; + +/// NB: All fields should be *optional*! +pub struct MediaUploadDetails { +} diff --git a/crates/lib/tokens/src/files/media_upload.rs b/crates/lib/tokens/src/files/media_upload.rs new file mode 100644 index 0000000000..542983a739 --- /dev/null +++ b/crates/lib/tokens/src/files/media_upload.rs @@ -0,0 +1,12 @@ +use crate::prefixes::EntityType; +use serde::Deserialize; +use serde::Serialize; +use std::fmt::Debug; + +/// The primary key for user media uploads (images, video, etc.) +#[derive(Clone, PartialEq, Eq, sqlx::Type, Debug, Serialize, Deserialize)] +#[sqlx(transparent)] +pub struct MediaUploadToken(String); + +impl_string_token!(MediaUploadToken); +impl_crockford_generator!(MediaUploadToken, 32usize, EntityType::DownloadJob, CrockfordLower); diff --git a/crates/lib/tokens/src/files/mod.rs b/crates/lib/tokens/src/files/mod.rs new file mode 100644 index 0000000000..740382ea60 --- /dev/null +++ b/crates/lib/tokens/src/files/mod.rs @@ -0,0 +1 @@ +pub mod media_upload; \ No newline at end of file diff --git a/crates/lib/tokens/src/lib.rs b/crates/lib/tokens/src/lib.rs index 7de58f9d9e..9495b78bb6 100644 --- a/crates/lib/tokens/src/lib.rs +++ b/crates/lib/tokens/src/lib.rs @@ -37,6 +37,7 @@ mod macros; pub (crate) mod prefixes; +pub mod files; pub mod jobs; pub mod users; pub mod voice_conversion; diff --git a/crates/lib/tokens/src/prefixes.rs b/crates/lib/tokens/src/prefixes.rs index 4d7566fd43..6508b68a82 100644 --- a/crates/lib/tokens/src/prefixes.rs +++ b/crates/lib/tokens/src/prefixes.rs @@ -15,6 +15,7 @@ use strum::EnumIter; pub(crate) enum EntityType { DownloadJob, InferenceJob, + MediaUpload, User, VoiceConversionModel, } @@ -25,6 +26,7 @@ impl EntityType { match self { Self::DownloadJob => "jdown_", // NB: Was "JGUP:" Self::InferenceJob => "jinf_", + Self::MediaUpload => "mu_", Self::User => "U:", // NB: Old-style prefix. Self::VoiceConversionModel => "voco_", } diff --git a/crates/service/web/storyteller_web/src/http_server/endpoints/media_uploads/drain_multipart_request.rs b/crates/service/web/storyteller_web/src/http_server/endpoints/media_uploads/drain_multipart_request.rs new file mode 100644 index 0000000000..c9d90a31ae --- /dev/null +++ b/crates/service/web/storyteller_web/src/http_server/endpoints/media_uploads/drain_multipart_request.rs @@ -0,0 +1,57 @@ +use actix_multipart::Field; +use actix_multipart::Multipart; +use actix_web::web::BytesMut; +use container_common::anyhow_result::AnyhowResult; +use crate::http_server::web_utils::read_multipart_field_bytes::{checked_read_multipart_bytes, read_multipart_field_as_text}; +use futures::TryStreamExt; +use log::warn; + +pub struct UploadMediaRequest { + pub uuid_idempotency_token: Option, + pub file_name: Option, + pub file_bytes: Option, +} + +/// Pull common parts out of multipart media HTTP requests, typically for handling file uploads. +pub async fn drain_multipart_request(mut multipart_payload: Multipart) -> AnyhowResult { + let mut uuid_idempotency_token = None; + let mut file_bytes = None; + let mut file_name = None; + + while let Ok(Some(mut field)) = multipart_payload.try_next().await { + let mut field_name = None; + let mut field_filename = None; + + if let Some(content_disposition) = field.content_disposition() { + field_name = content_disposition.get_name() + .map(|s| s.to_string()); + field_filename = content_disposition.get_filename() // NB: Only used for the file bytes. + .map(|s| s.to_string()); + } + + match field_name.as_deref() { + Some("uuid_idempotency_token") => { + uuid_idempotency_token = read_multipart_field_as_text(&mut field).await + .map_err(|e| { + warn!("Error reading idempotency token: {:}", e); + e + })?; + }, + Some("file_bytes") => { + file_name = field_filename.clone(); + file_bytes = checked_read_multipart_bytes(&mut field).await + .map_err(|e| { + warn!("Error reading audio upload: {:}", e); + e + })?; + }, + _ => continue, + } + } + + Ok(UploadMediaRequest { + uuid_idempotency_token, + file_name, + file_bytes, + }) +} diff --git a/crates/service/web/storyteller_web/src/http_server/endpoints/media_uploads/mod.rs b/crates/service/web/storyteller_web/src/http_server/endpoints/media_uploads/mod.rs new file mode 100644 index 0000000000..91cf062fc9 --- /dev/null +++ b/crates/service/web/storyteller_web/src/http_server/endpoints/media_uploads/mod.rs @@ -0,0 +1,3 @@ +pub mod drain_multipart_request; +pub mod upload_audio; +pub mod upload_video; \ No newline at end of file diff --git a/crates/service/web/storyteller_web/src/http_server/endpoints/media_uploads/upload_audio.rs b/crates/service/web/storyteller_web/src/http_server/endpoints/media_uploads/upload_audio.rs new file mode 100644 index 0000000000..412672b308 --- /dev/null +++ b/crates/service/web/storyteller_web/src/http_server/endpoints/media_uploads/upload_audio.rs @@ -0,0 +1,187 @@ +use actix_http::Error; +use actix_http::http::header; +use actix_multipart::Multipart; +use actix_web::HttpResponseBuilder; +use actix_web::cookie::Cookie; +use actix_web::error::ResponseError; +use actix_web::http::StatusCode; +use actix_web::{Responder, web, HttpResponse, error, HttpRequest}; +use config::bad_urls::is_bad_tts_model_download_url; +use crate::http_server::endpoints::media_uploads::drain_multipart_request::drain_multipart_request; +use crate::http_server::web_utils::response_error_helpers::to_simple_json_error; +use crate::server_state::ServerState; +use crate::validations::model_uploads::validate_model_title; +use crate::validations::validate_idempotency_token_format::validate_idempotency_token_format; +use database_queries::column_types::record_visibility::RecordVisibility; +use database_queries::queries::media_uploads::insert_media_upload::{Args, insert_media_upload}; +use database_queries::tokens::Tokens; +use http_server_common::request::get_request_ip::get_request_ip; +use http_server_common::response::serialize_as_json_error::serialize_as_json_error; +use log::{info, warn, log}; +use regex::Regex; +use reusable_types::db::enums::entity_visibility::EntityVisibility; +use reusable_types::db::enums::generic_download_type::GenericDownloadType; +use reusable_types::db::enums::media_upload_type::MediaUploadType; +use reusable_types::db::payloads::MediaUploadDetails; +use sqlx::error::DatabaseError; +use sqlx::error::Error::Database; +use sqlx::mysql::MySqlDatabaseError; +use std::fmt; +use std::sync::Arc; +use tokens::files::media_upload::MediaUploadToken; + +#[derive(Serialize)] +pub struct UploadAudioSuccessResponse { + pub success: bool, + pub upload_token: MediaUploadToken, +} + +#[derive(Debug, Serialize)] +pub enum UploadAudioError { + BadInput(String), + NotAuthorized, + MustBeLoggedIn, + ServerError, + RateLimited, +} + +impl ResponseError for UploadAudioError { + fn status_code(&self) -> StatusCode { + match *self { + UploadAudioError::BadInput(_) => StatusCode::BAD_REQUEST, + UploadAudioError::NotAuthorized => StatusCode::UNAUTHORIZED, + UploadAudioError::MustBeLoggedIn => StatusCode::UNAUTHORIZED, + UploadAudioError::ServerError => StatusCode::INTERNAL_SERVER_ERROR, + UploadAudioError::RateLimited => StatusCode::TOO_MANY_REQUESTS, + } + } + + fn error_response(&self) -> HttpResponse { + serialize_as_json_error(self) + } +} + +// NB: Not using derive_more::Display since Clion doesn't understand it. +impl fmt::Display for UploadAudioError { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + write!(f, "{:?}", self) + } +} + +pub async fn upload_audio_handler( + http_request: HttpRequest, + server_state: web::Data>, + mut multipart_payload: Multipart, +) -> Result { + + // ==================== READ SESSION ==================== // + + 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); + UploadAudioError::ServerError + })?; + + // ==================== RATE LIMIT ==================== // + + let rate_limiter = match maybe_user_session { + None => &server_state.redis_rate_limiters.logged_out, + Some(ref user) => { + if user.is_banned { + return Err(UploadAudioError::NotAuthorized); + } + &server_state.redis_rate_limiters.logged_in + }, + }; + + if let Err(_err) = rate_limiter.rate_limit_request(&http_request) { + return Err(UploadAudioError::RateLimited); + } + + if let Err(_err) = server_state.redis_rate_limiters.model_upload.rate_limit_request(&http_request) { + return Err(UploadAudioError::RateLimited); + } + + // ==================== READ MULTIPART REQUEST ==================== // + + let upload_media_request = drain_multipart_request(multipart_payload) + .await + .map_err(|e| { + // TODO: Error handling could be nicer. + UploadAudioError::BadInput("bad request".to_string()) + })?; + + + let uuid_idempotency_token = upload_media_request.uuid_idempotency_token + .ok_or(UploadAudioError::BadInput("no uuid".to_string()))?; + + if let Err(reason) = validate_idempotency_token_format(&uuid_idempotency_token) { + return Err(UploadAudioError::BadInput(reason)); + } + + let creator_set_visibility = maybe_user_session + .as_ref() + .map(|user_session| user_session.preferred_tts_result_visibility) + .unwrap_or(RecordVisibility::Public); + + let ip_address = get_request_ip(&http_request); + + let maybe_user_token = maybe_user_session + .map(|session| session.get_strongly_typed_user_token()); + + let token = MediaUploadToken::generate(); + + let record_id = insert_media_upload(Args { + token: &token, + uuid_idempotency_token: &uuid_idempotency_token, + media_type: MediaUploadType::Audio, + maybe_original_filename: upload_media_request.file_name.as_deref(), + original_file_size_bytes: 0, + original_duration_millis: 0, + maybe_original_mime_type: None, + maybe_original_audio_encoding: None, + maybe_original_video_encoding: None, + maybe_original_frame_width: None, + maybe_original_frame_height: None, + checksum_sha2: "", + public_bucket_directory_full_path: "", + extra_file_modification_info: MediaUploadDetails {}, // TODO + maybe_creator_user_token: maybe_user_token.as_ref(), + maybe_creator_anonymous_visitor_token: None, + creator_ip_address: &ip_address, + creator_set_visibility: EntityVisibility::Public, // TODO: Combine these two types. + maybe_creator_synthetic_id: None, + mysql_pool: &server_state.mysql_pool, + }) + .await + .map_err(|err| { + warn!("New generic download creation DB error: {:?}", err); + UploadAudioError::ServerError + })?; + + info!("new media upload id: {}", record_id); + + server_state.firehose_publisher.publish_media_uploaded( + maybe_user_token.as_ref(), + &token) + .await + .map_err(|e| { + warn!("error publishing event: {:?}", e); + UploadAudioError::ServerError + })?; + + let response = UploadAudioSuccessResponse { + success: true, + upload_token: token, + }; + + let body = serde_json::to_string(&response) + .map_err(|e| UploadAudioError::ServerError)?; + + Ok(HttpResponse::Ok() + .content_type("application/json") + .body(body)) +} diff --git a/crates/service/web/storyteller_web/src/http_server/endpoints/media_uploads/upload_video.rs b/crates/service/web/storyteller_web/src/http_server/endpoints/media_uploads/upload_video.rs new file mode 100644 index 0000000000..e69de29bb2 diff --git a/crates/service/web/storyteller_web/src/http_server/endpoints/mod.rs b/crates/service/web/storyteller_web/src/http_server/endpoints/mod.rs index 40244a9277..aaa72c4f1c 100644 --- a/crates/service/web/storyteller_web/src/http_server/endpoints/mod.rs +++ b/crates/service/web/storyteller_web/src/http_server/endpoints/mod.rs @@ -5,6 +5,7 @@ pub mod events; pub mod flags; pub mod investor_demo; pub mod leaderboard; +pub mod media_uploads; pub mod misc; pub mod moderation; pub mod service; diff --git a/crates/service/web/storyteller_web/src/routes.rs b/crates/service/web/storyteller_web/src/routes.rs index 80698ac7fb..c9f4db34b9 100644 --- a/crates/service/web/storyteller_web/src/routes.rs +++ b/crates/service/web/storyteller_web/src/routes.rs @@ -21,6 +21,7 @@ use crate::http_server::endpoints::flags::design_refresh_flag::enable_design_ref use crate::http_server::endpoints::investor_demo::disable_demo_mode_handler::disable_demo_mode_handler; use crate::http_server::endpoints::investor_demo::enable_demo_mode_handler::enable_demo_mode_handler; use crate::http_server::endpoints::leaderboard::get_leaderboard::leaderboard_handler; +use crate::http_server::endpoints::media_uploads::upload_audio::upload_audio_handler; use crate::http_server::endpoints::misc::default_route_404::default_route_404; use crate::http_server::endpoints::misc::detect_locale_handler::detect_locale_handler; use crate::http_server::endpoints::misc::enable_alpha_easy_handler::enable_alpha_easy_handler; @@ -37,6 +38,7 @@ use crate::http_server::endpoints::moderation::ip_bans::list_ip_bans::list_ip_ba use crate::http_server::endpoints::moderation::jobs::get_tts_inference_queue_count::get_tts_inference_queue_count_handler; use crate::http_server::endpoints::moderation::jobs::get_w2l_inference_queue_count::get_w2l_inference_queue_count_handler; use crate::http_server::endpoints::moderation::jobs::kill_tts_inference_jobs::kill_tts_inference_jobs_handler; +use crate::http_server::endpoints::moderation::stats::get_on_prem_worker_stats::get_on_prem_worker_stats_handler; use crate::http_server::endpoints::moderation::stats::get_voice_count_stats::get_voice_count_stats_handler; use crate::http_server::endpoints::moderation::user_bans::ban_user::ban_user_handler; use crate::http_server::endpoints::moderation::user_bans::list_banned_users::list_banned_users_handler; @@ -97,7 +99,6 @@ use crate::http_server::endpoints::w2l::set_w2l_template_mod_approval::set_w2l_t use users_component::default_routes::add_suggested_api_v1_account_creation_and_session_routes; use users_component::endpoints::edit_profile_handler::edit_profile_handler; use users_component::endpoints::get_profile_handler::get_profile_handler; -use crate::http_server::endpoints::moderation::stats::get_on_prem_worker_stats::get_on_prem_worker_stats_handler; pub fn add_routes (app: App) -> App where @@ -122,7 +123,8 @@ pub fn add_routes (app: App) -> App app = add_twitch_routes(app); /* /twitch */ // TODO: MAYBE TEMPORARY app = add_investor_demo_routes(app); /* /demo_mode */ // TODO: DEFINITELY TEMPORARY app = add_flag_routes(app); /* /flag */ - app = add_desktop_app_routes(app); /* /api/v1/vc/... */ + app = add_desktop_app_routes(app); /* /v1/vc/... */ + app = add_media_upload_routes(app); /* /v1/media_upload/... */ // From components app = add_suggested_api_v1_account_creation_and_session_routes(app); // /create_account, /session, /login, /logout @@ -776,6 +778,27 @@ fn add_desktop_app_routes (app: App) -> App ) } +// ==================== MEDIA UPLOAD ROUTES ==================== + +fn add_media_upload_routes (app: App) -> App + where + B: MessageBody, + T: ServiceFactory< + ServiceRequest, + Config = (), + Response = ServiceResponse, + Error = Error, + InitError = (), + >, +{ + app.service(web::scope("/v1/media_upload") + .service(web::resource("/upload_audio") + .route(web::post().to(upload_audio_handler)) + .route(web::head().to(|| HttpResponse::Ok())) + ) + ) +} + // ==================== TWITCH ROUTES ==================== // TODO: Maybe move these into an "oauth-gateway" type http service.