diff --git a/crates/service/web/storyteller_web/src/http_server/endpoints/engine/create_scene_handler.rs b/crates/service/web/storyteller_web/src/http_server/endpoints/engine/create_scene_handler.rs new file mode 100644 index 0000000000..f4edb9992e --- /dev/null +++ b/crates/service/web/storyteller_web/src/http_server/endpoints/engine/create_scene_handler.rs @@ -0,0 +1,39 @@ +use std::collections::HashSet; +use std::sync::Arc; + +use actix_multipart::Multipart; +use actix_web::{HttpRequest, HttpResponse, web}; +use once_cell::sync::Lazy; + +use tokens::tokens::media_files::MediaFileToken; + +use crate::http_server::endpoints::media_uploads::common::handle_upload::handle_upload; +use crate::http_server::endpoints::media_uploads::common::upload_error::UploadError; +use crate::server_state::ServerState; + +#[derive(Serialize)] +pub struct CreateSceneSuccessResponse { + pub success: bool, + pub media_file_token: MediaFileToken, +} + +pub async fn create_scene_handler( + http_request: HttpRequest, + server_state: web::Data>, + mut multipart_payload: Multipart, +) -> Result { + + // TODO(bt): Handle upload / save. + + let response = CreateSceneSuccessResponse { + success: true, + media_file_token: MediaFileToken::new_from_str("TODO"), + }; + + let body = serde_json::to_string(&response) + .map_err(|e| UploadError::ServerError)?; + + return Ok(HttpResponse::Ok() + .content_type("application/json") + .body(body)); +} diff --git a/crates/service/web/storyteller_web/src/http_server/endpoints/engine/get_scene_handler.rs b/crates/service/web/storyteller_web/src/http_server/endpoints/engine/get_scene_handler.rs new file mode 100644 index 0000000000..faa220ca3d --- /dev/null +++ b/crates/service/web/storyteller_web/src/http_server/endpoints/engine/get_scene_handler.rs @@ -0,0 +1,167 @@ +use std::fmt; +use std::sync::Arc; + +use actix_web::{HttpMessage, HttpRequest, HttpResponse, web}; +use actix_web::error::ResponseError; +use actix_web::http::StatusCode; +use actix_web::web::Path; +use chrono::{DateTime, Utc}; +use log::warn; +use utoipa::ToSchema; + +use buckets::public::media_files::bucket_file_path::MediaFileBucketPath; +use enums::by_table::media_files::media_file_type::MediaFileType; +use enums::by_table::model_weights::weights_category::WeightsCategory; +use enums::by_table::model_weights::weights_types::WeightsType; +use enums::common::visibility::Visibility; +use mysql_queries::queries::media_files::get_media_file::get_media_file; +use mysql_queries::queries::tts::tts_results::query_tts_result::select_tts_result_by_token; +use tokens::tokens::media_files::MediaFileToken; +use tokens::tokens::model_weights::ModelWeightToken; +use users_component::common_responses::user_details_lite::UserDetailsLight; + +use crate::http_server::common_responses::simple_entity_stats::SimpleEntityStats; +use crate::http_server::web_utils::response_error_helpers::to_simple_json_error; +use crate::server_state::ServerState; + +/// For the URL PathInfo +#[derive(Deserialize, ToSchema)] +pub struct GetScenePathInfo { + token: MediaFileToken, +} + +#[derive(Serialize, ToSchema)] +pub struct GetSceneSuccessResponse { + pub success: bool, + pub media_file: MediaFileInfo, +} + +#[derive(Serialize, ToSchema)] +pub struct MediaFileInfo { + pub token: MediaFileToken, + + /// Type of media will dictate which fields are populated and what + /// the frontend should display (eg. video player vs audio player). + pub media_type: MediaFileType, + + /// URL to the media file + pub public_bucket_path: String, + + pub created_at: DateTime, + pub updated_at: DateTime, +} + +#[derive(Debug, ToSchema)] +pub enum GetSceneError { + ServerError, + NotFound, +} + +impl ResponseError for GetSceneError { + fn status_code(&self) -> StatusCode { + match *self { + GetSceneError::ServerError => StatusCode::INTERNAL_SERVER_ERROR, + GetSceneError::NotFound => StatusCode::NOT_FOUND, + } + } + + fn error_response(&self) -> HttpResponse { + let error_reason = match self { + GetSceneError::ServerError => "server error".to_string(), + GetSceneError::NotFound => "not found".to_string(), + }; + + to_simple_json_error(&error_reason, self.status_code()) + } +} + +// NB: Not using derive_more::Display since Clion doesn't understand it. +impl fmt::Display for GetSceneError { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + write!(f, "{:?}", self) + } +} + +#[utoipa::path( + get, + path = "/v1/engine/scene/{token}", + responses( + (status = 200, description = "Found", body = GetSceneSuccessResponse), + (status = 404, description = "Not found", body = GetSceneError), + (status = 500, description = "Server error", body = GetSceneError), + ), + params( + ("path" = GetScenePathInfo, description = "Path for Request") + ) +)] +pub async fn get_scene_handler( + http_request: HttpRequest, + path: Path, + server_state: web::Data>) -> Result +{ + let media_file_token = path.into_inner().token; + + let response = modern_media_file_lookup(&media_file_token, + false, &server_state).await?; + + let body = serde_json::to_string(&response) + .map_err(|e| GetSceneError::ServerError)?; + + Ok(HttpResponse::Ok() + .content_type("application/json") + .body(body)) +} + +async fn modern_media_file_lookup( + media_file_token: &MediaFileToken, + show_deleted_results: bool, + server_state: &ServerState, +) -> Result { + + let result = get_media_file( + media_file_token, + show_deleted_results, + &server_state.mysql_pool + ).await; + + let result = match result { + Err(e) => { + warn!("query error: {:?}", e); + return Err(GetSceneError::ServerError); + } + Ok(None) => return Err(GetSceneError::NotFound), + Ok(Some(result)) => result, + }; + + let public_bucket_path = MediaFileBucketPath::from_object_hash( + &result.public_bucket_directory_hash, + result.maybe_public_bucket_prefix.as_deref(), + result.maybe_public_bucket_extension.as_deref()) + .get_full_object_path_str() + .to_string(); + + let maybe_cover_image_public_bucket_path = match result.maybe_model_cover_image_public_bucket_hash + .as_deref() + { + None => None, + Some(hash) => Some(MediaFileBucketPath::from_object_hash( + &hash, + result.maybe_model_cover_image_public_bucket_prefix.as_deref(), + result.maybe_model_cover_image_public_bucket_extension.as_deref()) + .get_full_object_path_str() + .to_string() + ) + }; + + Ok(GetSceneSuccessResponse { + success: true, + media_file: MediaFileInfo { + token: result.token, + media_type: result.media_type, + public_bucket_path, + created_at: result.created_at, + updated_at: result.updated_at, + }, + }) +} + diff --git a/crates/service/web/storyteller_web/src/http_server/endpoints/engine/mod.rs b/crates/service/web/storyteller_web/src/http_server/endpoints/engine/mod.rs new file mode 100644 index 0000000000..a5224f9d91 --- /dev/null +++ b/crates/service/web/storyteller_web/src/http_server/endpoints/engine/mod.rs @@ -0,0 +1,3 @@ +pub mod create_scene_handler; +pub mod get_scene_handler; +pub mod update_scene_handler; \ No newline at end of file diff --git a/crates/service/web/storyteller_web/src/http_server/endpoints/engine/update_scene_handler.rs b/crates/service/web/storyteller_web/src/http_server/endpoints/engine/update_scene_handler.rs new file mode 100644 index 0000000000..7dc34bdaa9 --- /dev/null +++ b/crates/service/web/storyteller_web/src/http_server/endpoints/engine/update_scene_handler.rs @@ -0,0 +1,39 @@ +use std::collections::HashSet; +use std::sync::Arc; + +use actix_multipart::Multipart; +use actix_web::{HttpRequest, HttpResponse, web}; +use once_cell::sync::Lazy; + +use tokens::tokens::media_files::MediaFileToken; + +use crate::http_server::endpoints::media_uploads::common::handle_upload::handle_upload; +use crate::http_server::endpoints::media_uploads::common::upload_error::UploadError; +use crate::server_state::ServerState; + +#[derive(Serialize)] +pub struct UpdateSceneSuccessResponse { + pub success: bool, + pub media_file_token: MediaFileToken, +} + +pub async fn update_scene_handler( + http_request: HttpRequest, + server_state: web::Data>, + mut multipart_payload: Multipart, +) -> Result { + + // TODO(bt): Handle upload / save. + + let response = UpdateSceneSuccessResponse { + success: true, + media_file_token: MediaFileToken::new_from_str("TODO"), + }; + + let body = serde_json::to_string(&response) + .map_err(|e| UploadError::ServerError)?; + + return Ok(HttpResponse::Ok() + .content_type("application/json") + .body(body)); +} 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 8e1e55a6e2..cb85cdcf40 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 @@ -4,6 +4,7 @@ pub mod categories; pub mod comments; pub mod conversion; pub mod download_job; +pub mod engine; pub mod events; pub mod flags; pub mod image_gen; @@ -13,6 +14,7 @@ pub mod leaderboard; pub mod media_files; pub mod media_uploads; pub mod misc; +pub mod mocap; pub mod moderation; pub mod service; pub mod stats; @@ -29,5 +31,4 @@ pub mod voice_conversion; pub mod voice_designer; pub mod w2l; pub mod weights; -pub(crate) mod mocap; -pub(crate) mod workflows; +pub mod workflows; diff --git a/crates/service/web/storyteller_web/src/routes.rs b/crates/service/web/storyteller_web/src/routes.rs index 09199c2dae..0eb4aefed7 100644 --- a/crates/service/web/storyteller_web/src/routes.rs +++ b/crates/service/web/storyteller_web/src/routes.rs @@ -30,6 +30,9 @@ use crate::http_server::endpoints::conversion::enqueue_bvh_to_workflow_handler:: use crate::http_server::endpoints::conversion::enqueue_fbx_to_gltf_handler::enqueue_fbx_to_gltf_handler; use crate::http_server::endpoints::download_job::enqueue_generic_download::enqueue_generic_download_handler; use crate::http_server::endpoints::download_job::get_generic_upload_job_status::get_generic_download_job_status_handler; +use crate::http_server::endpoints::engine::create_scene_handler::create_scene_handler; +use crate::http_server::endpoints::engine::get_scene_handler::get_scene_handler; +use crate::http_server::endpoints::engine::update_scene_handler::update_scene_handler; use crate::http_server::endpoints::events::list_events::list_events_handler; use crate::http_server::endpoints::flags::design_refresh_flag::disable_design_refresh_flag_handler::disable_design_refresh_flag_handler; use crate::http_server::endpoints::flags::design_refresh_flag::enable_design_refresh_flag_handler::enable_design_refresh_flag_handler; @@ -202,8 +205,10 @@ pub fn add_routes (app: App, server_environment: ServerEnvironment) -> app = add_user_rating_routes(app); /* /v1/user_rating/... */ app = add_subscription_routes(app); /* /v1/subscriptions/... */ app = add_voice_designer_routes(app); /* /v1/voice_designer */ - app = add_image_gen_routes(app); - app = add_weights_routes(app); + app = add_image_gen_routes(app); + app = add_weights_routes(app); + app = add_engine_routes(app); /* /v1/engine/... */ + // if server_environment == ServerEnvironment::Development { // // } @@ -1352,4 +1357,28 @@ fn add_weights_routes(app: App) -> App .route("/list", web::get().to(list_available_weights_handler)) .route("/list_featured", web::get().to(list_featured_weights_handler)) ) -} \ No newline at end of file +} +// ==================== Engine Routes ==================== + +fn add_engine_routes(app: App) -> App + where + B: MessageBody, + T: ServiceFactory< + ServiceRequest, + Config = (), + Response = ServiceResponse, + Error = Error, + InitError = () + > +{ + app.service(web::scope("/v1/engine") + .service(web::resource("/create_scene") + .route(web::post().to(create_scene_handler)) + .route(web::head().to(|| HttpResponse::Ok())) + ) + .service(web::resource("/scene/{token}") + .route(web::get().to(get_scene_handler)) + .route(web::post().to(update_scene_handler)) + ) + ) +}