Added missing new file

crates/lib/mysql_queries/src/queries/media_files/insert_media_file_from_zero_shot_tts.rs

@@ -0,0 +1,157 @@
+use anyhow::anyhow;
+use sqlx;
+use sqlx::MySqlPool;
+
+use enums::by_table::generic_synthetic_ids::id_category::IdCategory;
+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 errors::AnyhowResult;
+use tokens::tokens::media_files::MediaFileToken;
+use tokens::tokens::users::UserToken;
+
+use crate::queries::generic_inference::job::list_available_generic_inference_jobs::AvailableInferenceJob;
+use crate::queries::generic_synthetic_ids::transactional_increment_generic_synthetic_id::transactional_increment_generic_synthetic_id;
+// thought about this it seems like this can be a bit more geneneric instead of having this we can ... 
+pub struct InsertArgs<'a> {
+  pub pool: &'a MySqlPool,
+  pub job: &'a AvailableInferenceJob,
+
+  pub maybe_mime_type: Option<&'a str>,
+  pub file_size_bytes: u64,
+  pub sha256_checksum: &'a str,
+  // TODO: Media duration.
+  //pub duration_millis: u64,
+
+  pub public_bucket_directory_hash: &'a str,
+  pub maybe_public_bucket_prefix: Option<&'a str>,
+  pub maybe_public_bucket_extension: Option<&'a str>,
+
+  pub is_on_prem: bool,
+  pub worker_hostname: &'a str,
+  pub worker_cluster: &'a str,
+
+}
+pub async fn insert_media_file_from_face_zero_shot(
+    args: InsertArgs<'_>
+  ) -> AnyhowResult<(MediaFileToken, u64)>
+  {
+
+    let result_token = MediaFileToken::generate();
+
+    let mut maybe_creator_file_synthetic_id : Option<u64> = None;
+    let mut maybe_creator_category_synthetic_id : Option<u64> = None;
+  
+    let mut transaction = args.pool.begin().await?;
+  
+    // create a user token
+    if let Some(creator_user_token) = args.job.maybe_creator_user_token.as_deref() {
+      let user_token = UserToken::new_from_str(creator_user_token);
+  
+      let next_media_file_id = transactional_increment_generic_synthetic_id(
+        &user_token,
+        IdCategory::MediaFile,
+        &mut transaction
+      ).await?;
+  
+      let next_lipsync_id = transactional_increment_generic_synthetic_id(
+        &user_token,
+        IdCategory::ZeroShotTTS,
+        &mut transaction
+      ).await?;
+  
+      maybe_creator_file_synthetic_id = Some(next_media_file_id);
+      maybe_creator_category_synthetic_id = Some(next_lipsync_id);
+    }
+
+    // TODO: Ask if it make sense to use ONE function to do the insert 
+    // Since fill this out apart of the funtion this seems like the only thing to change.
+    const ORIGIN_CATEGORY : MediaFileOriginCategory = MediaFileOriginCategory::Inference;
+    const ORIGIN_PRODUCT_CATEGORY : MediaFileOriginProductCategory = MediaFileOriginProductCategory::ZeroShotVoice;
+    const ORIGIN_MODEL_TYPE : MediaFileOriginModelType = MediaFileOriginModelType::VallEX;
+    const MEDIA_TYPE : MediaFileType = MediaFileType::Audio;
+
+    let record_id = {
+        let query_result = sqlx::query!(
+            r#"
+    INSERT INTO media_files
+    SET
+      token = ?,
+    
+      origin_category = ?,
+      origin_product_category = ?,
+      maybe_origin_model_type = ?,
+    
+      media_type = ?,
+      maybe_mime_type = ?,
+      file_size_bytes = ?,
+    
+      checksum_sha2 = ?,
+    
+      public_bucket_directory_hash = ?,
+      maybe_public_bucket_prefix = ?,
+      maybe_public_bucket_extension = ?,
+    
+      maybe_creator_user_token = ?,
+      creator_ip_address = ?,
+    
+      creator_set_visibility = ?,
+    
+      maybe_creator_file_synthetic_id = ?,
+      maybe_creator_category_synthetic_id = ?,
+    
+      is_generated_on_prem = ?,
+      generated_by_worker = ?,
+      generated_by_cluster = ?
+    
+            "#,
+          result_token.as_str(),
+    
+          ORIGIN_CATEGORY.to_str(),
+          ORIGIN_PRODUCT_CATEGORY.to_str(),
+          ORIGIN_MODEL_TYPE.to_str(),
+    
+          MEDIA_TYPE.to_str(),
+          args.maybe_mime_type,
+          args.file_size_bytes,
+    
+          args.sha256_checksum,
+    
+          args.public_bucket_directory_hash,
+          args.maybe_public_bucket_prefix,
+          args.maybe_public_bucket_extension,
+    
+          args.job.maybe_creator_user_token,
+          args.job.creator_ip_address,
+    
+          args.job.creator_set_visibility.to_str(),
+    
+          maybe_creator_file_synthetic_id,
+          maybe_creator_category_synthetic_id,
+    
+          args.is_on_prem,
+          args.worker_hostname,
+          args.worker_cluster
+        )
+            .execute(&mut transaction)
+            .await;
+    
+        let record_id = match query_result {
+          Ok(res) => {
+            res.last_insert_id()
+          },
+          Err(err) => {
+            // TODO: handle better
+            //transaction.rollback().await?;
+            return Err(anyhow!("Mysql error: {:?}", err));
+          }
+        };
+    
+        record_id
+      };
+    
+      transaction.commit().await?;
+    
+      Ok((result_token, record_id))
+  }