mirror of
https://github.com/storytold/artcraft.git
synced 2026-11-15 22:32:13 +00:00
Endpoint for audio uploading
This commit is contained in:
1 parent
8591f74ff2
commit
deb3671be6
20 files changed
+485
-6
No files matched your search
@@ -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.
|
||||
|
||||
@@ -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);
|
||||
|
||||
|
||||
@@ -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<u64>,
|
||||
pub maybe_original_frame_height: Option<u64>,
|
||||
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<u64>,
|
||||
|
||||
pub mysql_pool: &'a MySqlPool,
|
||||
}
|
||||
|
||||
pub async fn insert_media_upload(args: Args<'_>) -> AnyhowResult<u64> {
|
||||
|
||||
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)),
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1 @@
|
||||
pub mod insert_media_upload;
|
||||
@@ -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;
|
||||
|
||||
+9
-1
@@ -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<MySql>,
|
||||
session_token: &str,
|
||||
|
||||
@@ -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<Self, String> {
|
||||
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());
|
||||
}
|
||||
}
|
||||
@@ -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;
|
||||
Whitespace-only changes.
@@ -0,0 +1,5 @@
|
||||
pub mod media_upload_details;
|
||||
|
||||
/// NB: All fields should be *optional*!
|
||||
pub struct MediaUploadDetails {
|
||||
}
|
||||
@@ -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);
|
||||
@@ -0,0 +1 @@
|
||||
pub mod media_upload;
|
||||
@@ -37,6 +37,7 @@ mod macros;
|
||||
|
||||
pub (crate) mod prefixes;
|
||||
|
||||
pub mod files;
|
||||
pub mod jobs;
|
||||
pub mod users;
|
||||
pub mod voice_conversion;
|
||||
@@ -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_",
|
||||
}
|
||||
|
||||
+57
@@ -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<String>,
|
||||
pub file_name: Option<String>,
|
||||
pub file_bytes: Option<BytesMut>,
|
||||
}
|
||||
|
||||
/// 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<UploadMediaRequest> {
|
||||
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,
|
||||
})
|
||||
}
|
||||
@@ -0,0 +1,3 @@
|
||||
pub mod drain_multipart_request;
|
||||
pub mod upload_audio;
|
||||
pub mod upload_video;
|
||||
+187
@@ -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<Arc<ServerState>>,
|
||||
mut multipart_payload: Multipart,
|
||||
) -> Result<HttpResponse, UploadAudioError> {
|
||||
|
||||
// ==================== 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))
|
||||
}
|
||||
Whitespace-only changes.
@@ -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;
|
||||
|
||||
@@ -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<T, B> (app: App<T, B>) -> App<T, B>
|
||||
where
|
||||
@@ -122,7 +123,8 @@ pub fn add_routes<T, B> (app: App<T, B>) -> App<T, B>
|
||||
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<T, B> (app: App<T, B>) -> App<T, B>
|
||||
)
|
||||
}
|
||||
|
||||
// ==================== MEDIA UPLOAD ROUTES ====================
|
||||
|
||||
fn add_media_upload_routes<T, B> (app: App<T, B>) -> App<T, B>
|
||||
where
|
||||
B: MessageBody,
|
||||
T: ServiceFactory<
|
||||
ServiceRequest,
|
||||
Config = (),
|
||||
Response = ServiceResponse<B>,
|
||||
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.
|
||||
|
||||
Reference in new issue
Block a user