write engine types

crates/lib/mysql_queries/src/queries/media_files/create/insert_media_file_from_file_upload.rs

@@ -3,7 +3,9 @@ use sqlx;
 use sqlx::MySqlPool;
 
 use enums::by_table::generic_synthetic_ids::id_category::IdCategory;
+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_product_category::MediaFileOriginProductCategory;
 use enums::by_table::media_files::media_file_subtype::MediaFileSubtype;
@@ -25,17 +27,19 @@ pub enum UploadType {
 pub struct InsertMediaFileFromUploadArgs<'a> {
   pub pool: &'a MySqlPool,
 
+  pub media_file_type: MediaFileType,
+  pub maybe_media_class: Option<MediaFileClass>,
+
+  pub upload_type: UploadType,
+
+  pub maybe_engine_category: Option<MediaFileEngineCategory>,
+  pub maybe_animation_type: Option<MediaFileAnimationType>,
+
   pub maybe_creator_user_token: Option<&'a UserToken>,
   pub maybe_creator_anonymous_visitor_token: Option<&'a AnonymousVisitorTrackingToken>,
   pub creator_ip_address: &'a str,
   pub creator_set_visibility: Visibility,
 
-  pub upload_type: UploadType,
-
-  pub media_file_type: MediaFileType,
-  pub maybe_media_class: Option<MediaFileClass>,
-  pub maybe_media_subtype: Option<MediaFileSubtype>,
-
   pub maybe_mime_type: Option<&'a str>,
   pub file_size_bytes: u64,
   pub duration_millis: u64,
@@ -88,8 +92,6 @@ pub async fn insert_media_file_from_file_upload(
 
   const ORIGIN_PRODUCT_CATEGORY : MediaFileOriginProductCategory = MediaFileOriginProductCategory::Unknown;
 
-  let media_class = args.maybe_media_class.unwrap_or(MediaFileClass::Unknown);
-
   let record_id = {
     let query_result = sqlx::query!(
         r#"
@@ -97,15 +99,15 @@ INSERT INTO media_files
 SET
   token = ?,
 
+  media_class = ?,
+  media_type = ?,
+
   origin_category = ?,
   origin_product_category = ?,
 
-  maybe_origin_model_type = NULL,
-  maybe_origin_model_token = NULL,
+  maybe_engine_category = ?,
+  maybe_animation_type = ?,
 
-  media_type = ?,
-  media_class = ?,
-  maybe_media_subtype = ?,
   maybe_mime_type = ?,
   file_size_bytes = ?,
 
@@ -124,17 +126,25 @@ SET
   creator_set_visibility = ?,
 
   maybe_creator_file_synthetic_id = ?,
-  maybe_creator_category_synthetic_id = ?
+  maybe_creator_category_synthetic_id = ?,
+
+  maybe_origin_model_type = NULL,
+  maybe_origin_model_token = NULL
         "#,
       token.as_str(),
 
+      args.maybe_media_class
+        .map(|media_class| media_class.to_str())
+        .unwrap_or_else(|| MediaFileClass::Unknown.to_str()),
+
+      args.media_file_type.to_str(),
+
       origin_category.to_str(),
       ORIGIN_PRODUCT_CATEGORY.to_str(),
 
-      args.media_file_type.to_str(),
-      media_class.to_str(),
-      args.maybe_media_subtype.map(|s| s.to_str()),
-      
+      args.maybe_engine_category.map(|s| s.to_str()),
+      args.maybe_animation_type.map(|s| s.to_str()),
+
       args.maybe_mime_type,
       args.file_size_bytes,
 

crates/service/web/storyteller_web/src/http_server/endpoints/engine/create_scene_handler.rs

@@ -10,6 +10,7 @@ use utoipa::ToSchema;
 
 use buckets::public::media_files::bucket_file_path::MediaFileBucketPath;
 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_subtype::MediaFileSubtype;
 use enums::by_table::media_files::media_file_type::MediaFileType;
 use enums::common::visibility::Visibility;
@@ -195,14 +196,15 @@ pub async fn create_scene_handler(
 
   // TODO(bt, 2024-02-22): This should be a transaction.
   let (token, record_id) = insert_media_file_from_file_upload(InsertMediaFileFromUploadArgs {
+    maybe_media_class: Some(MediaFileClass::Dimensional),
+    media_file_type: MediaFileType::SceneRon,
     maybe_creator_user_token: maybe_user_token.as_ref(),
     maybe_creator_anonymous_visitor_token: maybe_avt_token.as_ref(),
     creator_ip_address: &ip_address,
     creator_set_visibility: Visibility::Public,
     upload_type: UploadType::StorytellerEngine,
-    media_file_type: MediaFileType::SceneRon,
-    maybe_media_class: Some(MediaFileClass::Dimensional),
-    maybe_media_subtype: Some(MediaFileSubtype::StorytellerScene),
+    maybe_engine_category: Some(MediaFileEngineCategory::Scene),
+    maybe_animation_type: None,
     maybe_mime_type: Some(mime_type),
     file_size_bytes: file_size_bytes as u64,
     duration_millis: 0, // None

crates/service/web/storyteller_web/src/http_server/endpoints/engine/process_upload_media_file.rs

@@ -323,15 +323,16 @@ pub async fn process_upload_media_file(
       })?;
 
   let (token, record_id) = insert_media_file_from_file_upload(InsertMediaFileFromUploadArgs {
+    maybe_media_class: None,
+    media_file_type,
     maybe_creator_user_token: maybe_user_token.as_ref(),
     maybe_creator_anonymous_visitor_token: maybe_avt_token.as_ref(),
     creator_ip_address: &ip_address,
     creator_set_visibility,
     upload_type,
-    media_file_type,
+    maybe_engine_category: None,
+    maybe_animation_type: None,
     maybe_mime_type: Some(mime_type),
-    maybe_media_class: None,
-    maybe_media_subtype: None,
     file_size_bytes: file_size_bytes as u64,
     duration_millis: 0, // TODO
     sha256_checksum: &hash,

crates/service/web/storyteller_web/src/http_server/endpoints/media_files/upload/upload_engine_asset/drain_multipart_request.rs

@@ -3,7 +3,9 @@ use actix_web::web::BytesMut;
 use anyhow::anyhow;
 use futures::TryStreamExt;
 use log::warn;
+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_subtype::MediaFileSubtype;
 
 use errors::AnyhowResult;
@@ -15,13 +17,18 @@ pub struct MediaFileUploadData {
   pub uuid_idempotency_token: Option<String>,
   pub file_name: Option<String>,
   pub file_bytes: Option<BytesMut>,
-  pub media_file_subtype: Option<MediaFileSubtype>,
 
   // Optional: title of the scene (media_files' maybe_title)
-  pub title: Option<String>,
+  pub maybe_title: Option<String>,
 
   // Optional: visibility
-  pub visibility: Option<String>,
+  pub maybe_visibility: Option<String>,
+
+  // Optional: visibility
+  pub maybe_engine_category: Option<MediaFileEngineCategory>,
+
+  // Optional: visibility
+  pub maybe_animation_type: Option<MediaFileAnimationType>,
 }
 
 /// Pull common parts out of multipart media HTTP requests, typically for handling file uploads.
@@ -29,10 +36,10 @@ pub async fn drain_multipart_request(mut multipart_payload: Multipart) -> Anyhow
   let mut uuid_idempotency_token = None;
   let mut file_bytes = None;
   let mut file_name = None;
-  //let mut media_file_class = None;
-  let mut media_file_subtype = None;
   let mut title = None;
   let mut visibility = None;
+  let mut maybe_engine_category = None;
+  let mut maybe_animation_type = None;
 
   while let Ok(Some(mut field)) = multipart_payload.try_next().await {
     let mut field_name = None;
@@ -61,32 +68,45 @@ pub async fn drain_multipart_request(mut multipart_payload: Multipart) -> Anyhow
               err
             })?;
       },
-      Some("media_file_subtype") => {
-        media_file_subtype = read_multipart_field_as_text(&mut field).await
-            .map_err(|err| {
-              warn!("Error reading source: {:?}", &err);
-              err
-            })?
-            .map(|field| MediaFileSubtype::from_str(&field))
-            .transpose()
-            .map_err(|err| {
-              warn!("Wrong MediaFileSubtype: {:?}", &err);
-              anyhow!("Wrong MediaFileSubtype: {:?}", &err)
-            })?;
-      },
-      //Some("media_file_class") => {
-      //  media_file_class = read_multipart_field_as_text(&mut field).await
+      //Some("media_file_subtype") => {
+      //  media_file_subtype = read_multipart_field_as_text(&mut field).await
       //      .map_err(|err| {
       //        warn!("Error reading source: {:?}", &err);
       //        err
       //      })?
-      //      .map(|field| MediaFileClass::from_str(&field))
+      //      .map(|field| MediaFileSubtype::from_str(&field))
       //      .transpose()
       //      .map_err(|err| {
-      //        warn!("Wrong MediaFileClass: {:?}", &err);
-      //        anyhow!("Wrong MediaFileClass: {:?}", &err)
+      //        warn!("Wrong MediaFileSubtype: {:?}", &err);
+      //        anyhow!("Wrong MediaFileSubtype: {:?}", &err)
       //      })?;
       //},
+      Some("engine_category") => {
+        maybe_engine_category = read_multipart_field_as_text(&mut field).await
+            .map_err(|err| {
+              warn!("Error reading source: {:?}", &err);
+              err
+            })?
+            .map(|field| MediaFileEngineCategory::from_str(&field))
+            .transpose()
+            .map_err(|err| {
+              warn!("Wrong MediaFileEngineCategory: {:?}", &err);
+              anyhow!("Wrong MediaFileEngineCategory: {:?}", &err)
+            })?;
+      },
+      Some("animation_type") => {
+        maybe_animation_type = read_multipart_field_as_text(&mut field).await
+            .map_err(|err| {
+              warn!("Error reading source: {:?}", &err);
+              err
+            })?
+            .map(|field| MediaFileAnimationType::from_str(&field))
+            .transpose()
+            .map_err(|err| {
+              warn!("Wrong MediaFileAnimationType: {:?}", &err);
+              anyhow!("Wrong MediaFileAnimationType: {:?}", &err)
+            })?;
+      },
       Some("title") => {
         title = read_multipart_field_as_text(&mut field).await
             .map_err(|e| {
@@ -109,8 +129,9 @@ pub async fn drain_multipart_request(mut multipart_payload: Multipart) -> Anyhow
     uuid_idempotency_token,
     file_name,
     file_bytes,
-    media_file_subtype,
-    title,
-    visibility,
+    maybe_title: title,
+    maybe_visibility: visibility,
+    maybe_engine_category,
+    maybe_animation_type,
   })
 }

crates/service/web/storyteller_web/src/http_server/endpoints/media_files/upload/upload_engine_asset/upload_engine_asset_media_file_handler.rs

@@ -124,7 +124,7 @@ pub async fn upload_engine_asset_media_file_handler(
 
   // ==================== UPLOAD METADATA ==================== //
 
-  let creator_set_visibility = upload_media_request.visibility
+  let creator_set_visibility = upload_media_request.maybe_visibility
       .as_deref()
       .map(|visibility| Visibility::from_str(visibility))
       .transpose()
@@ -207,19 +207,20 @@ pub async fn upload_engine_asset_media_file_handler(
 
   // TODO(bt, 2024-02-22): This should be a transaction.
   let (token, record_id) = insert_media_file_from_file_upload(InsertMediaFileFromUploadArgs {
+    maybe_media_class: Some(MediaFileClass::Dimensional),
+    media_file_type,
     maybe_creator_user_token: maybe_user_token.as_ref(),
     maybe_creator_anonymous_visitor_token: maybe_avt_token.as_ref(),
     creator_ip_address: &ip_address,
     creator_set_visibility,
     upload_type: UploadType::Filesystem,
-    media_file_type,
-    maybe_media_class: Some(MediaFileClass::Dimensional),
-    maybe_media_subtype: upload_media_request.media_file_subtype,
+    maybe_engine_category: upload_media_request.maybe_engine_category,
+    maybe_animation_type: upload_media_request.maybe_animation_type,
     maybe_mime_type: Some(mimetype),
     file_size_bytes: file_size_bytes as u64,
     duration_millis: 0,
     sha256_checksum: &hash,
-    maybe_title: upload_media_request.title.as_deref(),
+    maybe_title: upload_media_request.maybe_title.as_deref(),
     public_bucket_directory_hash: public_upload_path.get_object_hash(),
     maybe_public_bucket_prefix: PREFIX,
     maybe_public_bucket_extension: Some(suffix),

crates/service/web/storyteller_web/src/http_server/endpoints/media_files/upload/upload_generic/process_upload_media_file.rs

@@ -333,14 +333,15 @@ pub async fn process_upload_media_file(
       })?;
 
   let (token, record_id) = insert_media_file_from_file_upload(InsertMediaFileFromUploadArgs {
+    maybe_media_class: None,
+    media_file_type,
     maybe_creator_user_token: maybe_user_token.as_ref(),
     maybe_creator_anonymous_visitor_token: maybe_avt_token.as_ref(),
     creator_ip_address: &ip_address,
     creator_set_visibility,
     upload_type,
-    media_file_type,
-    maybe_media_class: None,
-    maybe_media_subtype: None,
+    maybe_engine_category: None,
+    maybe_animation_type: None,
     maybe_mime_type: Some(mime_type),
     file_size_bytes: file_size_bytes as u64,
     duration_millis: 0, // TODO

crates/service/web/storyteller_web/src/http_server/endpoints/media_files/upload/upload_video/upload_video_media_file_handler.rs

@@ -218,14 +218,15 @@ pub async fn upload_video_media_file_handler(
 
   // TODO(bt, 2024-02-22): This should be a transaction.
   let (token, record_id) = insert_media_file_from_file_upload(InsertMediaFileFromUploadArgs {
+    maybe_media_class: Some(MediaFileClass::Video),
+    media_file_type: MediaFileType::Video,
     maybe_creator_user_token: maybe_user_token.as_ref(),
     maybe_creator_anonymous_visitor_token: maybe_avt_token.as_ref(),
     creator_ip_address: &ip_address,
     creator_set_visibility,
     upload_type,
-    maybe_media_subtype: None,
-    maybe_media_class: Some(MediaFileClass::Video),
-    media_file_type: MediaFileType::Video,
+    maybe_engine_category: None,
+    maybe_animation_type: None,
     maybe_mime_type: Some(mimetype),
     file_size_bytes: file_size_bytes as u64,
     duration_millis: mp4_info.duration_millis as u64,