add media files & model weights to bookmarks/ratings/comments

crates/_types/enums/src/by_table/comments/comment_entity_type.rs

@@ -13,6 +13,14 @@ pub enum CommentEntityType {
   #[serde(rename = "user")]
   User,
 
+  /// MediaFile
+  #[serde(rename = "media_file")]
+  MediaFile,
+
+  /// Model Weight
+  #[serde(rename = "model_weight")]
+  ModelWeight,
+
   /// TTS model (architecture does not matter)
   #[serde(rename = "tts_model")]
   TtsModel,
@@ -39,6 +47,8 @@ impl CommentEntityType {
   pub fn to_str(&self) -> &'static str {
     match self {
       Self::User => "user",
+      Self::MediaFile => "media_file",
+      Self::ModelWeight => "model_weight",
       Self::TtsModel => "tts_model",
       Self::TtsResult => "tts_result",
       Self::W2lTemplate => "w2l_template",
@@ -49,6 +59,8 @@ impl CommentEntityType {
   pub fn from_str(value: &str) -> Result<Self, String> {
     match value {
       "user" => Ok(Self::User),
+      "media_file" => Ok(Self::MediaFile),
+      "model_weight" => Ok(Self::ModelWeight),
       "tts_model" => Ok(Self::TtsModel),
       "tts_result" => Ok(Self::TtsResult),
       "w2l_template" => Ok(Self::W2lTemplate),
@@ -69,6 +81,8 @@ mod tests {
     #[test]
     fn test_serialization() {
       assert_serialization(CommentEntityType::User, "user");
+      assert_serialization(CommentEntityType::MediaFile, "media_file");
+      assert_serialization(CommentEntityType::ModelWeight, "model_weight");
       assert_serialization(CommentEntityType::TtsModel, "tts_model");
       assert_serialization(CommentEntityType::TtsResult, "tts_result");
       assert_serialization(CommentEntityType::W2lTemplate, "w2l_template");
@@ -82,6 +96,8 @@ mod tests {
     #[test]
     fn test_to_str() {
       assert_eq!(CommentEntityType::User.to_str(), "user");
+      assert_eq!(CommentEntityType::MediaFile.to_str(), "media_file");
+      assert_eq!(CommentEntityType::ModelWeight.to_str(), "model_weight");
       assert_eq!(CommentEntityType::TtsModel.to_str(), "tts_model");
       assert_eq!(CommentEntityType::TtsResult.to_str(), "tts_result");
       assert_eq!(CommentEntityType::W2lTemplate.to_str(), "w2l_template");
@@ -91,6 +107,8 @@ mod tests {
     #[test]
     fn test_from_str() {
       assert_eq!(CommentEntityType::from_str("user").unwrap(), CommentEntityType::User);
+      assert_eq!(CommentEntityType::from_str("media_file").unwrap(), CommentEntityType::MediaFile);
+      assert_eq!(CommentEntityType::from_str("model_weight").unwrap(), CommentEntityType::ModelWeight);
       assert_eq!(CommentEntityType::from_str("tts_model").unwrap(), CommentEntityType::TtsModel);
       assert_eq!(CommentEntityType::from_str("tts_result").unwrap(), CommentEntityType::TtsResult);
       assert_eq!(CommentEntityType::from_str("w2l_template").unwrap(), CommentEntityType::W2lTemplate);

crates/_types/enums/src/by_table/user_bookmarks/user_bookmark_entity_type.rs

@@ -33,6 +33,10 @@ pub enum UserBookmarkEntityType {
     #[serde(rename = "media_file")]
     MediaFile,
 
+    /// Model Weight
+    #[serde(rename = "model_weight")]
+    ModelWeight,
+
     /// VoiceConversionModel
     #[serde(rename = "voice_conversion_model")]
     VoiceConversionModel,
@@ -56,6 +60,7 @@ impl UserBookmarkEntityType {
             Self::W2lTemplate => "w2l_template",
             Self::W2lResult => "w2l_result",
             Self::MediaFile => "media_file",
+            Self::ModelWeight => "model_weight",
             Self::VoiceConversionModel => "voice_conversion_model",
             Self::ZsVoice => "zs_voice",
         }
@@ -69,6 +74,7 @@ impl UserBookmarkEntityType {
             "w2l_template" => Ok(Self::W2lTemplate),
             "w2l_result" => Ok(Self::W2lResult),
             "media_file" => Ok(Self::MediaFile),
+            "model_weight" => Ok(Self::ModelWeight),
             "voice_conversion_model" => Ok(Self::VoiceConversionModel),
             "zs_voice" => Ok(Self::ZsVoice),
             _ => Err(format!("invalid value: {:?}", value)),
@@ -92,6 +98,7 @@ mod tests {
             assert_serialization(UserBookmarkEntityType::W2lTemplate, "w2l_template");
             assert_serialization(UserBookmarkEntityType::W2lResult, "w2l_result");
             assert_serialization(UserBookmarkEntityType::MediaFile, "media_file");
+            assert_serialization(UserBookmarkEntityType::ModelWeight, "model_weight");
             assert_serialization(UserBookmarkEntityType::VoiceConversionModel, "voice_conversion_model");
             assert_serialization(UserBookmarkEntityType::ZsVoice, "zs_voice");
         }
@@ -108,6 +115,7 @@ mod tests {
             assert_eq!(UserBookmarkEntityType::W2lTemplate.to_str(), "w2l_template");
             assert_eq!(UserBookmarkEntityType::W2lResult.to_str(), "w2l_result");
             assert_eq!(UserBookmarkEntityType::MediaFile.to_str(), "media_file");
+            assert_eq!(UserBookmarkEntityType::ModelWeight.to_str(), "model_weight");
             assert_eq!(UserBookmarkEntityType::VoiceConversionModel.to_str(), "voice_conversion_model");
             assert_eq!(UserBookmarkEntityType::ZsVoice.to_str(), "zs_voice");
         }
@@ -120,6 +128,7 @@ mod tests {
             assert_eq!(UserBookmarkEntityType::from_str("w2l_template").unwrap(), UserBookmarkEntityType::W2lTemplate);
             assert_eq!(UserBookmarkEntityType::from_str("w2l_result").unwrap(), UserBookmarkEntityType::W2lResult);
             assert_eq!(UserBookmarkEntityType::from_str("media_file").unwrap(), UserBookmarkEntityType::MediaFile);
+            assert_eq!(UserBookmarkEntityType::from_str("model_weight").unwrap(), UserBookmarkEntityType::ModelWeight);
             assert_eq!(UserBookmarkEntityType::from_str("voice_conversion_model").unwrap(), UserBookmarkEntityType::VoiceConversionModel);
             assert_eq!(UserBookmarkEntityType::from_str("zs_voice").unwrap(), UserBookmarkEntityType::ZsVoice);
             assert!(UserBookmarkEntityType::from_str("foo").is_err());

crates/_types/enums/src/by_table/user_ratings/entity_type.rs

@@ -9,6 +9,13 @@ use strum::EnumIter;
 #[cfg_attr(test, derive(EnumIter, EnumCount))]
 #[derive(Clone, Copy, Eq, PartialEq, Hash, Deserialize, Serialize)]
 pub enum UserRatingEntityType {
+  /// MediaFile
+  #[serde(rename = "media_file")]
+  MediaFile,
+
+  /// Model Weight
+  #[serde(rename = "model_weight")]
+  ModelWeight,
   /// TTS model (architecture does not matter)
   #[serde(rename = "tts_model")]
   TtsModel,
@@ -34,6 +41,8 @@ impl_mysql_enum_coders!(UserRatingEntityType);
 impl UserRatingEntityType {
   pub fn to_str(&self) -> &'static str {
     match self {
+      Self::MediaFile => "media_file",
+      Self::ModelWeight => "model_weight",
       Self::TtsModel => "tts_model",
       Self::TtsResult => "tts_result",
       Self::W2lTemplate => "w2l_template",
@@ -43,6 +52,8 @@ impl UserRatingEntityType {
 
   pub fn from_str(value: &str) -> Result<Self, String> {
     match value {
+      "media_file" => Ok(Self::MediaFile),
+      "model_weight" => Ok(Self::ModelWeight),
       "tts_model" => Ok(Self::TtsModel),
       "tts_result" => Ok(Self::TtsResult),
       "w2l_template" => Ok(Self::W2lTemplate),
@@ -66,6 +77,8 @@ mod tests {
       assert_serialization(UserRatingEntityType::TtsResult, "tts_result");
       assert_serialization(UserRatingEntityType::W2lTemplate, "w2l_template");
       assert_serialization(UserRatingEntityType::W2lResult, "w2l_result");
+      assert_serialization(UserRatingEntityType::MediaFile, "media_file");
+      assert_serialization(UserRatingEntityType::ModelWeight, "model_weight");
     }
   }
 
@@ -78,6 +91,8 @@ mod tests {
       assert_eq!(UserRatingEntityType::TtsResult.to_str(), "tts_result");
       assert_eq!(UserRatingEntityType::W2lTemplate.to_str(), "w2l_template");
       assert_eq!(UserRatingEntityType::W2lResult.to_str(), "w2l_result");
+      assert_eq!(UserRatingEntityType::MediaFile.to_str(), "media_file");
+      assert_eq!(UserRatingEntityType::ModelWeight.to_str(), "model_weight");
     }
 
     #[test]
@@ -86,6 +101,8 @@ mod tests {
       assert_eq!(UserRatingEntityType::from_str("tts_result").unwrap(), UserRatingEntityType::TtsResult);
       assert_eq!(UserRatingEntityType::from_str("w2l_template").unwrap(), UserRatingEntityType::W2lTemplate);
       assert_eq!(UserRatingEntityType::from_str("w2l_result").unwrap(), UserRatingEntityType::W2lResult);
+      assert_eq!(UserRatingEntityType::from_str("media_file").unwrap(), UserRatingEntityType::MediaFile);
+      assert_eq!(UserRatingEntityType::from_str("model_weight").unwrap(), UserRatingEntityType::ModelWeight);
       assert!(UserRatingEntityType::from_str("foo").is_err());
     }
   }

crates/lib/mysql_queries/src/composite_keys/by_table/user_ratings/user_rating_entity.rs

@@ -1,4 +1,6 @@
 use enums::by_table::user_ratings::entity_type::UserRatingEntityType;
+use tokens::tokens::media_files::MediaFileToken;
+use tokens::tokens::model_weights::ModelWeightToken;
 use tokens::tokens::tts_models::TtsModelToken;
 use tokens::tokens::w2l_templates::W2lTemplateToken;
 
@@ -14,6 +16,8 @@ use tokens::tokens::w2l_templates::W2lTemplateToken;
 pub enum UserRatingEntity {
   TtsModel(TtsModelToken),
   W2lTemplate(W2lTemplateToken),
+  MediaFile(MediaFileToken),
+  ModelWeight(ModelWeightToken),
 }
 
 // TODO: Make traits for these? Maybe overkill.
@@ -22,6 +26,8 @@ impl UserRatingEntity {
     match self {
       UserRatingEntity::TtsModel(_) => UserRatingEntityType::TtsModel,
       UserRatingEntity::W2lTemplate(_) => UserRatingEntityType::W2lTemplate,
+      UserRatingEntity::MediaFile(_) => UserRatingEntityType::MediaFile,
+      UserRatingEntity::ModelWeight(_) => UserRatingEntityType::ModelWeight,
     }
   }
 
@@ -29,6 +35,8 @@ impl UserRatingEntity {
     match self {
       UserRatingEntity::TtsModel(token) => token.as_str(),
       UserRatingEntity::W2lTemplate(token) => token.as_str(),
+      UserRatingEntity::MediaFile(token) => token.as_str(),
+      UserRatingEntity::ModelWeight(token) => token.as_str(),
     }
   }
 }

crates/lib/mysql_queries/src/queries/comments/comment_entity_token.rs

@@ -1,10 +1,14 @@
 use enums::by_table::comments::comment_entity_type::CommentEntityType;
+use tokens::tokens::media_files::MediaFileToken;
+use tokens::tokens::model_weights::ModelWeightToken;
 use tokens::tokens::tts_models::TtsModelToken;
 use tokens::tokens::w2l_templates::W2lTemplateToken;
 use tokens::tokens::users::UserToken;
 
 pub enum CommentEntityToken {
   User(UserToken),
+  MediaFile(MediaFileToken),
+  ModelWeight(ModelWeightToken),
   TtsModel(TtsModelToken),
   TtsResult(String), // TODO: Strong type
   W2lTemplate(W2lTemplateToken),
@@ -16,6 +20,8 @@ impl CommentEntityToken {
   pub fn from_entity_type_and_token(entity_type: CommentEntityType, token: &str) -> Self {
     match entity_type {
       CommentEntityType::User => Self::User(UserToken::new_from_str(token)),
+      CommentEntityType::MediaFile => Self::MediaFile(MediaFileToken::new_from_str(token)),
+      CommentEntityType::ModelWeight => Self::ModelWeight(ModelWeightToken::new_from_str(token)),
       CommentEntityType::TtsModel => Self::TtsModel(TtsModelToken::new_from_str(token)),
       CommentEntityType::TtsResult => Self::TtsResult(token.to_string()),
       CommentEntityType::W2lTemplate => Self::W2lTemplate(W2lTemplateToken::new_from_str(token)),
@@ -26,6 +32,8 @@ impl CommentEntityToken {
   pub fn get_composite_keys(&self) -> (CommentEntityType, &str) {
     let (entity_type, entity_token) = match self {
       CommentEntityToken::User(user_token) => (CommentEntityType::User, user_token.as_str()),
+      CommentEntityToken::MediaFile(media_file_token) => (CommentEntityType::MediaFile, media_file_token.as_str()),
+      CommentEntityToken::ModelWeight(model_weight_token) => (CommentEntityType::ModelWeight, model_weight_token.as_str()),
       CommentEntityToken::TtsModel(tts_model_token) => (CommentEntityType::TtsModel, tts_model_token.as_str()),
       CommentEntityToken::TtsResult(tts_result_token) => (CommentEntityType::TtsResult, tts_result_token.as_str()),
       CommentEntityToken::W2lTemplate(w2l_template_token) => (CommentEntityType::W2lTemplate, w2l_template_token.as_str()),

crates/lib/mysql_queries/src/queries/user_bookmarks/list_user_bookmarks_result.rs

@@ -70,6 +70,7 @@ impl RawUserBookmarkRecord {
               MediaFileType::Image => Some("image media file".to_string()),
               MediaFileType::Video => Some("video media file".to_string()),
             }),
+        UserBookmarkEntityType::ModelWeight => None,
         UserBookmarkEntityType::VoiceConversionModel => self.maybe_descriptive_text_voice_conversion_model_title,
         UserBookmarkEntityType::ZsVoice => self.maybe_descriptive_text_zs_voice_title,
       },

crates/lib/mysql_queries/src/queries/user_bookmarks/user_bookmark_entity_token.rs

@@ -1,5 +1,6 @@
 use enums::by_table::user_bookmarks::user_bookmark_entity_type::UserBookmarkEntityType;
 use tokens::tokens::media_files::MediaFileToken;
+use tokens::tokens::model_weights::ModelWeightToken;
 use tokens::tokens::tts_models::TtsModelToken;
 use tokens::tokens::tts_results::TtsResultToken;
 use tokens::tokens::users::UserToken;
@@ -15,6 +16,7 @@ pub enum UserBookmarkEntityToken {
   W2lTemplate(W2lTemplateToken),
   W2lResult(W2lResultToken),
   MediaFile(MediaFileToken),
+  ModelWeight(ModelWeightToken),
   VoiceConversionModel(VoiceConversionModelToken),
   ZsVoice(ZsVoiceToken),
 }
@@ -28,6 +30,7 @@ impl UserBookmarkEntityToken {
       UserBookmarkEntityType::W2lTemplate => Self::W2lTemplate(W2lTemplateToken::new_from_str(token)),
       UserBookmarkEntityType::W2lResult => Self::W2lResult(W2lResultToken::new_from_str(token)),
       UserBookmarkEntityType::MediaFile => Self::MediaFile(MediaFileToken::new_from_str(token)),
+      UserBookmarkEntityType::ModelWeight => Self::ModelWeight(ModelWeightToken::new_from_str(token)),
       UserBookmarkEntityType::VoiceConversionModel => Self::VoiceConversionModel(VoiceConversionModelToken::new_from_str(token)),
       UserBookmarkEntityType::ZsVoice => Self::ZsVoice(ZsVoiceToken::new_from_str(token)),
     }
@@ -41,6 +44,7 @@ impl UserBookmarkEntityToken {
       UserBookmarkEntityToken::W2lTemplate(w2l_template_token) => (UserBookmarkEntityType::W2lTemplate, w2l_template_token.as_str()),
       UserBookmarkEntityToken::W2lResult(w2l_result_token) => (UserBookmarkEntityType::W2lResult, w2l_result_token.as_str()),
       UserBookmarkEntityToken::MediaFile(media_file_token) => (UserBookmarkEntityType::MediaFile, media_file_token.as_str()),
+      UserBookmarkEntityToken::ModelWeight(model_weight_token) => (UserBookmarkEntityType::ModelWeight, model_weight_token.as_str()),
       UserBookmarkEntityToken::VoiceConversionModel(voice_conversion_model_token) => (UserBookmarkEntityType::VoiceConversionModel, voice_conversion_model_token.as_str()),
       UserBookmarkEntityToken::ZsVoice(zs_voice_token) => (UserBookmarkEntityType::ZsVoice, zs_voice_token.as_str()),
     }

crates/service/web/storyteller_web/src/http_server/endpoints/user_ratings/get_user_rating_handler.rs

@@ -9,6 +9,8 @@ use enums::by_table::user_ratings::rating_value::UserRatingValue;
 use http_server_common::response::serialize_as_json_error::serialize_as_json_error;
 use mysql_queries::composite_keys::by_table::user_ratings::user_rating_entity::UserRatingEntity;
 use mysql_queries::queries::users::user_ratings::get_user_rating::{Args, get_user_rating};
+use tokens::tokens::media_files::MediaFileToken;
+use tokens::tokens::model_weights::ModelWeightToken;
 use tokens::tokens::tts_models::TtsModelToken;
 use tokens::tokens::w2l_templates::W2lTemplateToken;
 
@@ -105,6 +107,12 @@ pub async fn get_user_rating_handler(
     UserRatingEntityType::W2lTemplate => UserRatingEntity::W2lTemplate(
       W2lTemplateToken::new_from_str(&path.entity_token)),
 
+    UserRatingEntityType::MediaFile => UserRatingEntity::MediaFile(
+      MediaFileToken::new_from_str(&path.entity_token)),
+
+    UserRatingEntityType::ModelWeight => UserRatingEntity::ModelWeight(
+      ModelWeightToken::new_from_str(&path.entity_token)),
+
     // TODO: We'll handle ratings of more types in the future.
     UserRatingEntityType::W2lResult | UserRatingEntityType::TtsResult =>
       return Err(GetUserRatingError::BadInput("type not yet supported".to_string()))

crates/service/web/storyteller_web/src/http_server/endpoints/user_ratings/set_user_rating_handler.rs

@@ -11,6 +11,8 @@ use http_server_common::response::serialize_as_json_error::serialize_as_json_err
 use mysql_queries::composite_keys::by_table::user_ratings::user_rating_entity::UserRatingEntity;
 use mysql_queries::queries::users::user_ratings::update_tts_model_ratings::update_tts_model_ratings;
 use mysql_queries::queries::users::user_ratings::upsert_user_rating::{Args, upsert_user_rating};
+use tokens::tokens::media_files::MediaFileToken;
+use tokens::tokens::model_weights::ModelWeightToken;
 use tokens::tokens::tts_models::TtsModelToken;
 use tokens::tokens::w2l_templates::W2lTemplateToken;
 
@@ -103,6 +105,12 @@ pub async fn set_user_rating_handler(
     UserRatingEntityType::TtsModel => UserRatingEntity::TtsModel(
       TtsModelToken::new_from_str(&request.entity_token)),
 
+    UserRatingEntityType::MediaFile => UserRatingEntity::MediaFile(
+      MediaFileToken::new_from_str(&request.entity_token)),
+
+    UserRatingEntityType::ModelWeight => UserRatingEntity::ModelWeight(
+      ModelWeightToken::new_from_str(&request.entity_token)),
+
     UserRatingEntityType::W2lTemplate => UserRatingEntity::W2lTemplate(
       W2lTemplateToken::new_from_str(&request.entity_token)),