diff --git a/debug/mysql/badges.sh b/debug/mysql/badges.sh new file mode 100755 index 0000000000..ecc8cad037 --- /dev/null +++ b/debug/mysql/badges.sh @@ -0,0 +1,7 @@ +#!/bin/bash +# ONLY FOR LOCAL DEV +mysql -u storyteller \ + -ppassword \ + -h localhost \ + -D storyteller \ + -e "select * from badges\G" diff --git a/migrations/2021-05-15-212920_badges/up.sql b/migrations/2021-05-15-212920_badges/up.sql index 31e2ccf155..0b6e499cea 100644 --- a/migrations/2021-05-15-212920_badges/up.sql +++ b/migrations/2021-05-15-212920_badges/up.sql @@ -31,6 +31,9 @@ CREATE TABLE user_badges ( user_token VARCHAR(32) NOT NULL, badge_slug VARCHAR(32) NOT NULL, + created_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP, + updated_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP, + -- INDICES -- PRIMARY KEY (id), KEY fk_user_token (user_token), diff --git a/seed/bootstrap_inserts_roles_etc.sh b/seed/bootstrap_inserts_roles_etc.sh index 109a1213ad..0c30f7959b 100755 --- a/seed/bootstrap_inserts_roles_etc.sh +++ b/seed/bootstrap_inserts_roles_etc.sh @@ -1,12 +1,20 @@ #!/bin/bash # ONLY FOR LOCAL DEV - # --default-character-set=UTF8mb4 \ + +echo 'Inserting System User Roles...' mysql -u storyteller \ -ppassword \ -h localhost \ -D storyteller \ -e "source ./seed/sql/system_roles.sql" +echo 'Inserting Badges...' +mysql -u storyteller \ + -ppassword \ + -h localhost \ + -D storyteller \ + -e "source ./seed/sql/user_badges.sql" + diff --git a/seed/sql/user_badges.sql b/seed/sql/user_badges.sql new file mode 100644 index 0000000000..5e05455939 --- /dev/null +++ b/seed/sql/user_badges.sql @@ -0,0 +1,146 @@ +-- USER SIGNUP / TIME LIMITED + +INSERT INTO badges +SET + slug = 'early_user', + title = 'Early Adopter of Vocodes', + description = 'Early Adopter of Vocodes', + image_url = ''; + +-- TTS MODEL UPLOADS + +INSERT INTO badges +SET + slug = 'tts_model_uploader_1', + title = 'Uploaded 1 TTS Model', + description = 'Uploaded 1 TTS model to Vocodes', + image_url = ''; + +INSERT INTO badges +SET + slug = 'tts_model_uploader_5', + title = 'Uploaded 5 TTS Models', + description = 'Uploaded 5 TTS models to Vocodes', + image_url = ''; + +INSERT INTO badges +SET + slug = 'tts_model_uploader_10', + title = 'Uploaded 10 TTS Models', + description = 'Uploaded 10 TTS models to Vocodes', + image_url = ''; + +INSERT INTO badges +SET + slug = 'tts_model_uploader_20', + title = 'Uploaded 20 TTS Models', + description = 'Uploaded 20 TTS models to Vocodes', + image_url = ''; + +INSERT INTO badges +SET + slug = 'tts_model_uploader_50', + title = 'Uploaded 50 TTS Models', + description = 'Uploaded 50 TTS models to Vocodes', + image_url = ''; + +INSERT INTO badges +SET + slug = 'tts_model_uploader_100', + title = 'Uploaded 100 TTS Models', + description = 'Uploaded 100 TTS models to Vocodes', + image_url = ''; + +INSERT INTO badges +SET + slug = 'tts_model_uploader_150', + title = 'Uploaded 150 TTS Models', + description = 'Uploaded 150 TTS models to Vocodes', + image_url = ''; + +INSERT INTO badges +SET + slug = 'tts_model_uploader_200', + title = 'Uploaded 200 TTS Models', + description = 'Uploaded 200 TTS models to Vocodes', + image_url = ''; + +INSERT INTO badges +SET + slug = 'tts_model_uploader_250', + title = 'Uploaded 250 TTS Models', + description = 'Uploaded 250 TTS models to Vocodes', + image_url = ''; + +-- W2L TEMPLATE UPLOADS + +INSERT INTO badges +SET + slug = 'w2l_template_uploader_1', + title = 'Uploaded 1 W2L Template', + description = 'Uploaded 1 W2L Template to Vocodes', + image_url = ''; + +INSERT INTO badges +SET + slug = 'w2l_template_uploader_10', + title = 'Uploaded 10 W2L Templates', + description = 'Uploaded 10 W2L Templates to Vocodes', + image_url = ''; + +INSERT INTO badges +SET + slug = 'w2l_template_uploader_50', + title = 'Uploaded 50 W2L Templates', + description = 'Uploaded 50 W2L Templates to Vocodes', + image_url = ''; + +INSERT INTO badges +SET + slug = 'w2l_template_uploader_100', + title = 'Uploaded 100 W2L Templates', + description = 'Uploaded 100 W2L Templates to Vocodes', + image_url = ''; + +INSERT INTO badges +SET + slug = 'w2l_template_uploader_200', + title = 'Uploaded 200 W2L Templates', + description = 'Uploaded 200 W2L Templates to Vocodes', + image_url = ''; + +INSERT INTO badges +SET + slug = 'w2l_template_uploader_500', + title = 'Uploaded 500 W2L Templates', + description = 'Uploaded 500 W2L Templates to Vocodes', + image_url = ''; + +INSERT INTO badges +SET + slug = 'w2l_template_uploader_1000', + title = 'Uploaded 1000 W2L Templates', + description = 'Uploaded 1000 W2L Templates to Vocodes', + image_url = ''; + +INSERT INTO badges +SET + slug = 'w2l_template_uploader_2000', + title = 'Uploaded 2000 W2L Templates', + description = 'Uploaded 2000 W2L Templates to Vocodes', + image_url = ''; + +INSERT INTO badges +SET + slug = 'w2l_template_uploader_5000', + title = 'Uploaded 5000 W2L Templates', + description = 'Uploaded 5000 W2L Templates to Vocodes', + image_url = ''; + +INSERT INTO badges +SET + slug = 'w2l_template_uploader_10000', + title = 'Uploaded 10000 W2L Templates', + description = 'Uploaded 10000 W2L Templates to Vocodes', + image_url = ''; + diff --git a/src/common_queries/badge_granter.rs b/src/common_queries/badge_granter.rs new file mode 100644 index 0000000000..7c19b458eb --- /dev/null +++ b/src/common_queries/badge_granter.rs @@ -0,0 +1,366 @@ +use anyhow::anyhow; +use crate::common_queries::tokens::Tokens; +use crate::util::anyhow_result::AnyhowResult; +use crate::util::random_prefix_crockford_token::random_prefix_crockford_token; +use log::{warn,info}; +use sqlx::error::Error::Database; +use sqlx::mysql::MySqlDone; +use sqlx::{MySqlPool}; +use std::sync::Arc; +use crate::common_queries::firehose_publisher::FirehosePublisher; + +#[derive(Debug, Clone, Copy)] +pub enum UserBadge { + // Granted for early vocodes users. + EarlyUser, + + // Granted for uploading models + TtsModelUploader1, + TtsModelUploader5, + TtsModelUploader10, + TtsModelUploader20, + TtsModelUploader50, + TtsModelUploader100, + TtsModelUploader150, + TtsModelUploader200, + TtsModelUploader250, + + // Granted for uploading templates + W2lTemplateUploader1, + W2lTemplateUploader10, + W2lTemplateUploader50, + W2lTemplateUploader100, + W2lTemplateUploader200, + W2lTemplateUploader500, + W2lTemplateUploader1000, + W2lTemplateUploader2000, + W2lTemplateUploader5000, + W2lTemplateUploader10000, + + //// Granted for using models + //TtsInferenceUser100, + //TtsInferenceUser500, + //TtsInferenceUser1000, + //TtsInferenceUser10000, + //TtsInferenceUser100000, + + //// Granted for using templates + //W2lInferenceUser100, + //W2lInferenceUser500, + //W2lInferenceUser1000, + //W2lInferenceUser10000, + //W2lInferenceUser100000, +} + +impl UserBadge { + pub fn to_db_value(&self) -> &'static str { + match self { + UserBadge::EarlyUser => "early_user", + UserBadge::TtsModelUploader1 => "tts_model_uploader_1", + UserBadge::TtsModelUploader5 => "tts_model_uploader_5", + UserBadge::TtsModelUploader10 => "tts_model_uploader_10", + UserBadge::TtsModelUploader20 => "tts_model_uploader_20", + UserBadge::TtsModelUploader50 => "tts_model_uploader_50", + UserBadge::TtsModelUploader100 => "tts_model_uploader_100", + UserBadge::TtsModelUploader150 => "tts_model_uploader_150", + UserBadge::TtsModelUploader200 => "tts_model_uploader_200", + UserBadge::TtsModelUploader250 => "tts_model_uploader_250", + UserBadge::W2lTemplateUploader1 => "w2l_template_uploader_1", + UserBadge::W2lTemplateUploader10 => "w2l_template_uploader_10", + UserBadge::W2lTemplateUploader50 => "w2l_template_uploader_50", + UserBadge::W2lTemplateUploader100 => "w2l_template_uploader_100", + UserBadge::W2lTemplateUploader200 => "w2l_template_uploader_200", + UserBadge::W2lTemplateUploader500 => "w2l_template_uploader_500", + UserBadge::W2lTemplateUploader1000 => "w2l_template_uploader_1000", + UserBadge::W2lTemplateUploader2000 => "w2l_template_uploader_2000", + UserBadge::W2lTemplateUploader5000 => "w2l_template_uploader_5000", + UserBadge::W2lTemplateUploader10000 => "w2l_template_uploader_10000", + //UserBadge::TtsInferenceUser100 => "tts_inference_100", + //UserBadge::TtsInferenceUser500 => "tts_inference_500", + //UserBadge::TtsInferenceUser1000 => "tts_inference_1000", + //UserBadge::TtsInferenceUser10000 =>"tts_inference_10000", + //UserBadge::TtsInferenceUser100000 => "tts_inference_100000", + //UserBadge::W2lInferenceUser100 => "w2l_inference_100", + //UserBadge::W2lInferenceUser500 => "w2l_inference_500", + //UserBadge::W2lInferenceUser1000 => "w2l_inference_1000", + //UserBadge::W2lInferenceUser10000 => "w2l_inference_10000", + //UserBadge::W2lInferenceUser100000 => "w2l_inference_100000", + } + } +} + +#[derive(Clone)] +pub struct BadgeGranter { + pub mysql_pool: MySqlPool, + pub firehose_publisher: FirehosePublisher, // NB: Type is Copy/Clone safe due to internal Arc. +} + +struct ExistenceRecord { + pub does_exist: i64, +} + +struct CountRecord { + pub count: i64, +} + +impl BadgeGranter { + + pub async fn grant_early_user_badge(&self, user_token: &str) -> AnyhowResult<()> { + let _record_id = self.insert( + UserBadge::EarlyUser, + user_token, + ).await?; + Ok(()) + } + + /// This needs to be called *after* successful upload. + pub async fn maybe_grant_tts_model_uploads_badge(&self, user_token: &str) -> AnyhowResult<()> { + let count = self.count_tts_models_uploaded(user_token).await?; + + let mut maybe_badge = None; + + if count >= 250 { + maybe_badge = Some(UserBadge::TtsModelUploader250); + } else if count >= 200 { + maybe_badge = Some(UserBadge::TtsModelUploader200); + } else if count >= 150 { + maybe_badge = Some(UserBadge::TtsModelUploader150); + } else if count >= 100 { + maybe_badge = Some(UserBadge::TtsModelUploader100); + } else if count >= 50 { + maybe_badge = Some(UserBadge::TtsModelUploader50); + } else if count >= 20 { + maybe_badge = Some(UserBadge::TtsModelUploader20); + } else if count >= 10 { + maybe_badge = Some(UserBadge::TtsModelUploader10); + } else if count >= 5 { + maybe_badge = Some(UserBadge::TtsModelUploader5); + } else if count >= 1 { + maybe_badge = Some(UserBadge::TtsModelUploader1); + } + + let badge = match maybe_badge { + Some(badge) => badge, + None => return Ok(()), + }; + + if self.has_badge(user_token, badge).await? { + return Ok(()) + } + + let _record_id = self.insert( + badge, + user_token, + ).await?; + + self.firehose_publisher.publish_user_badge_granted(user_token, badge.to_db_value()) + .await?; + + Ok(()) + } + + + /// This needs to be called *after* successful upload. + pub async fn maybe_grant_w2l_template_uploads_badge(&self, user_token: &str) -> AnyhowResult<()> { + let count = self.count_w2l_templates_uploaded(user_token).await?; + + let mut maybe_badge = None; + + if count >= 10000 { + maybe_badge = Some(UserBadge::W2lTemplateUploader10000); + } else if count >= 5000 { + maybe_badge = Some(UserBadge::W2lTemplateUploader5000); + } else if count >= 2000 { + maybe_badge = Some(UserBadge::W2lTemplateUploader2000); + } else if count >= 1000 { + maybe_badge = Some(UserBadge::W2lTemplateUploader1000); + } else if count >= 500 { + maybe_badge = Some(UserBadge::W2lTemplateUploader500); + } else if count >= 200 { + maybe_badge = Some(UserBadge::W2lTemplateUploader200); + } else if count >= 100 { + maybe_badge = Some(UserBadge::W2lTemplateUploader100); + } else if count >= 50 { + maybe_badge = Some(UserBadge::W2lTemplateUploader50); + } else if count >= 10 { + maybe_badge = Some(UserBadge::W2lTemplateUploader10); + } else if count >= 1 { + maybe_badge = Some(UserBadge::W2lTemplateUploader1); + } + + let badge = match maybe_badge { + Some(badge) => badge, + None => return Ok(()), + }; + + if self.has_badge(user_token, badge).await? { + return Ok(()) + } + + let _record_id = self.insert( + badge, + user_token, + ).await?; + + self.firehose_publisher.publish_user_badge_granted(user_token, badge.to_db_value()) + .await?; + + Ok(()) + } + + + // ======================================================================= + + pub async fn has_badge(&self, user_token: &str, user_badge: UserBadge) -> AnyhowResult { + let maybe_result = sqlx::query_as!( + ExistenceRecord, + r#" +SELECT 1 as does_exist +FROM user_badges +WHERE + user_token = ? +AND + badge_slug = ? +LIMIT 1 + "#, + user_token, + user_badge.to_db_value() + ) + .fetch_one(&self.mysql_pool) + .await; + + let exists = match maybe_result { + Ok(_record) => true, + Err(err) => { + match err { + RowNotFound => false, + _ => { + warn!("query error: {:?}", err); + return Err(anyhow!("error querying: {:?}", err)); + } + } + } + }; + + Ok(exists) + } + + // ======================================================================= + + async fn count_tts_models_uploaded( + &self, + user_token: &str, + ) -> AnyhowResult { + // NB: This could get expensive! + let maybe_result = sqlx::query_as!( + CountRecord, + r#" +SELECT count(*) as count +FROM tts_models +WHERE + creator_user_token = ? +LIMIT 1 + "#, + user_token + ) + .fetch_one(&self.mysql_pool) + .await; + + self.handle_count_query(maybe_result) + } + + async fn count_w2l_templates_uploaded( + &self, + user_token: &str, + ) -> AnyhowResult { + // NB: This could get expensive! + // Especially at the scale we'll likely have W2L templates. + let maybe_result = sqlx::query_as!( + CountRecord, + r#" +SELECT count(*) as count +FROM w2l_templates +WHERE + creator_user_token = ? +LIMIT 1 + "#, + user_token + ) + .fetch_one(&self.mysql_pool) + .await; + + self.handle_count_query(maybe_result) + } + + async fn insert( + &self, + user_badge: UserBadge, + user_token: &str, + ) -> AnyhowResult { + let query_result = sqlx::query!( + r#" +INSERT INTO user_badges +SET + user_token = ?, + badge_slug = ? + "#, + user_token, + user_badge.to_db_value(), + ) + .execute(&self.mysql_pool) + .await; + + let record_id = Self::handle_results(query_result)?; + Ok(record_id) + } + + fn handle_results(query_result: Result) -> AnyhowResult { + let record_id = match query_result { + Ok(res) => { + res.last_insert_id() + }, + Err(err) => { + warn!("Insert badge record DB error: {:?}", err); + + // NB: SQLSTATE[23000]: Integrity constraint violation + // NB: MySQL Error Code 1062: Duplicate key insertion (this is harder to access) + match err { + Database(err) => { + let maybe_code = err.code().map(|c| c.into_owned()); + /*match maybe_code.as_deref() { + Some("23000") => { + if err.message().contains("username") { + return Err(UsernameTaken); + } else if err.message().contains("email_address") { + return Err(EmailTaken); + } + } + _ => {}, + }*/ + }, + _ => {}, + } + return Err(anyhow!("Error inserting record")); + } + }; + + Ok(record_id) + } + + fn handle_count_query(&self, query_result: Result) -> AnyhowResult { + let count = match query_result { + Ok(record) => record.count as u64, + Err(err) => { + match err { + RowNotFound => 0, + _ => { + warn!("query error: {:?}", err); + return Err(anyhow!("error querying: {:?}", err)); + } + } + } + }; + + Ok(count) + } +} diff --git a/src/common_queries/firehose_publisher.rs b/src/common_queries/firehose_publisher.rs index 4574d47c62..512e2d7d05 100644 --- a/src/common_queries/firehose_publisher.rs +++ b/src/common_queries/firehose_publisher.rs @@ -12,6 +12,9 @@ use std::sync::Arc; enum FirehoseEvent { UserSignUp, + // We don't publish for all badges (eg. early user signup) + UserBadgeGranted, + TtsModelUploadStarted, TtsModelUploadCompleted, TtsInferenceStarted, @@ -34,6 +37,7 @@ impl FirehoseEvent { pub fn to_db_value(&self) -> &'static str { match self { FirehoseEvent::UserSignUp => "user_sign_up", + FirehoseEvent::UserBadgeGranted=> "user_badge_granted", FirehoseEvent::TtsModelUploadStarted => "tts_model_upload_started", FirehoseEvent::TtsModelUploadCompleted => "tts_model_upload_completed", FirehoseEvent::TtsInferenceStarted => "tts_inference_started", @@ -69,6 +73,16 @@ impl FirehosePublisher { Ok(()) } + pub async fn publish_user_badge_granted(&self, user_token: &str, badge_slug: &str) -> AnyhowResult<()> { + let _record_id = self.insert( + FirehoseEvent::UserBadgeGranted, + Some(user_token), + Some(badge_slug), + None, + ).await?; + Ok(()) + } + pub async fn enqueue_tts_model_upload(&self, user_token: &str, job_token: &str) -> AnyhowResult<()> { let _record_id = self.insert( FirehoseEvent::TtsModelUploadStarted, diff --git a/src/common_queries/mod.rs b/src/common_queries/mod.rs index fcff225d6a..b35e0e5e98 100644 --- a/src/common_queries/mod.rs +++ b/src/common_queries/mod.rs @@ -1,3 +1,4 @@ +pub mod badge_granter; pub mod badges; pub mod firehose_publisher; pub mod list_ip_bans; diff --git a/src/http_server/endpoints/users/create_account.rs b/src/http_server/endpoints/users/create_account.rs index 812edc2cce..e077105def 100644 --- a/src/http_server/endpoints/users/create_account.rs +++ b/src/http_server/endpoints/users/create_account.rs @@ -190,6 +190,14 @@ VALUES ( ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ? ) info!("new user id: {}", record_id); + // TODO: Remove me in the future. Too lazy to check the date, plus this will + // vary with adoption rate. + server_state.badge_granter.grant_early_user_badge(&user_token) + .await + .map_err(|e| { + warn!("error creating badge: {:?}", e); + CreateAccountError::ServerError + })?; let create_session_result = create_session_for_user(&user_token, &ip_address, &server_state.mysql_pool).await; diff --git a/src/main.rs b/src/main.rs index a41789fa43..349fa4605a 100644 --- a/src/main.rs +++ b/src/main.rs @@ -32,6 +32,7 @@ use actix_cors::Cors; use actix_http::http; use actix_web::middleware::{Logger, DefaultHeaders}; use actix_web::{HttpServer, web, HttpResponse, App}; +use crate::common_queries::badge_granter::BadgeGranter; use crate::common_queries::firehose_publisher::FirehosePublisher; use crate::http_server::endpoints::default_route_404::default_route_404; use crate::http_server::endpoints::events::list_events::list_events_handler; @@ -77,6 +78,7 @@ use crate::http_server::endpoints::w2l::get_w2l_template_use_count::get_w2l_temp use crate::http_server::endpoints::w2l::get_w2l_upload_template_job_status::get_w2l_upload_template_job_status_handler; use crate::http_server::endpoints::w2l::list_w2l_templates::list_w2l_templates_handler; use crate::http_server::endpoints::w2l::set_w2l_template_mod_approval::set_w2l_template_mod_approval_handler; +use crate::http_server::middleware::ip_filter_middleware::IpFilter; use crate::http_server::web_utils::cookie_manager::CookieManager; use crate::http_server::web_utils::session_checker::SessionChecker; use crate::server_state::{ServerState, EnvConfig}; @@ -97,7 +99,6 @@ use sqlx::MySqlPool; use sqlx::mysql::MySqlPoolOptions; use std::sync::Arc; use std::time::Duration; -use crate::http_server::middleware::ip_filter_middleware::IpFilter; // TODO TODO TODO TODO // TODO TODO TODO TODO @@ -168,6 +169,11 @@ async fn main() -> AnyhowResult<()> { mysql_pool: pool.clone(), // NB: Pool is clone/sync/send-safe }; + let badge_granter = BadgeGranter { + mysql_pool: pool.clone(), // NB: Pool is clone/sync/send-safe + firehose_publisher: firehose_publisher.clone(), // NB: Also safe + }; + let redis_manager = RedisConnectionManager::new(redis_connection_string)?; let redis_pool = r2d2::Pool::builder() @@ -244,6 +250,7 @@ async fn main() -> AnyhowResult<()> { mysql_pool: pool, redis_pool, firehose_publisher, + badge_granter, cookie_manager, session_checker, private_bucket_client, diff --git a/src/server_state.rs b/src/server_state.rs index 8f80606658..c40e7bd2c9 100644 --- a/src/server_state.rs +++ b/src/server_state.rs @@ -1,11 +1,12 @@ +use crate::common_queries::badge_granter::BadgeGranter; use crate::common_queries::firehose_publisher::FirehosePublisher; use crate::http_server::web_utils::cookie_manager::CookieManager; use crate::http_server::web_utils::session_checker::SessionChecker; +use crate::threads::ip_banlist_set::IpBanlistSet; use crate::util::buckets::bucket_client::BucketClient; use crate::util::encrypted_sort_id::SortKeyCrypto; use r2d2_redis::{r2d2, RedisConnectionManager}; use sqlx::MySqlPool; -use crate::threads::ip_banlist_set::IpBanlistSet; /// State that is injected into every endpoint. #[derive(Clone)] @@ -24,6 +25,7 @@ pub struct ServerState { pub session_checker: SessionChecker, pub firehose_publisher: FirehosePublisher, + pub badge_granter: BadgeGranter, pub private_bucket_client: BucketClient, pub public_bucket_client: BucketClient, diff --git a/src/tts_download_job.rs b/src/tts_download_job.rs index 5013688834..e5bdf69be3 100644 --- a/src/tts_download_job.rs +++ b/src/tts_download_job.rs @@ -21,6 +21,7 @@ pub mod util; use anyhow::anyhow; use chrono::Utc; use crate::common_env::CommonEnv; +use crate::common_queries::badge_granter::BadgeGranter; use crate::common_queries::firehose_publisher::FirehosePublisher; use crate::job_queries::tts_download_job_queries::TtsUploadJobRecord; use crate::job_queries::tts_download_job_queries::grab_job_lock_and_mark_pending; @@ -69,6 +70,7 @@ struct Downloader { pub mysql_pool: MySqlPool, pub bucket_client: BucketClient, pub firehose_publisher: FirehosePublisher, + pub badge_granter: BadgeGranter, pub google_drive_downloader: GoogleDriveDownloadCommand, pub bucket_path_unifier: BucketPathUnifier, @@ -148,6 +150,11 @@ async fn main() -> AnyhowResult<()> { mysql_pool: mysql_pool.clone(), // NB: Pool is sync/send/clone-safe }; + let badge_granter = BadgeGranter { + mysql_pool: mysql_pool.clone(), // NB: Pool is sync/send/clone-safe + firehose_publisher: firehose_publisher.clone(), // NB: Also safe + }; + let py_code_directory = easyenv::get_env_string_required(ENV_CODE_DIRECTORY)?; let py_script_name = easyenv::get_env_string_required(ENV_MODEL_CHECK_SCRIPT_NAME)?; @@ -167,6 +174,7 @@ async fn main() -> AnyhowResult<()> { bucket_path_unifier: BucketPathUnifier::default_paths(), bucket_root_tts_model_uploads: bucket_root.to_string(), firehose_publisher, + badge_granter, tts_check: tts_model_check_command, job_batch_wait_millis: common_env.job_batch_wait_millis, job_max_attempts: common_env.job_max_attempts as i32, @@ -351,6 +359,13 @@ async fn process_job(downloader: &Downloader, job: &TtsUploadJobRecord) -> Anyho anyhow!("error publishing event") })?; + downloader.badge_granter.maybe_grant_tts_model_uploads_badge(&job.creator_user_token) + .await + .map_err(|e| { + warn!("error maybe awarding badge: {:?}", e); + anyhow!("error maybe awarding badge") + })?; + info!("Job done: {}", job.id); Ok(()) diff --git a/src/w2l_download_job.rs b/src/w2l_download_job.rs index 68af39d48b..e18dda4e37 100644 --- a/src/w2l_download_job.rs +++ b/src/w2l_download_job.rs @@ -21,6 +21,7 @@ pub mod util; use anyhow::anyhow; use chrono::Utc; use crate::common_env::CommonEnv; +use crate::common_queries::badge_granter::BadgeGranter; use crate::common_queries::firehose_publisher::FirehosePublisher; use crate::job_queries::w2l_download_job_queries::W2lTemplateUploadJobRecord; use crate::job_queries::w2l_download_job_queries::grab_job_lock_and_mark_pending; @@ -83,6 +84,7 @@ struct Downloader { pub public_bucket_client: BucketClient, pub firehose_publisher: FirehosePublisher, + pub badge_granter: BadgeGranter, pub google_drive_downloader: GoogleDriveDownloadCommand, pub w2l_processor: Wav2LipPreprocessClient, @@ -195,6 +197,11 @@ async fn main() -> AnyhowResult<()> { mysql_pool: mysql_pool.clone(), // NB: Pool is sync/send/clone-safe }; + let badge_granter = BadgeGranter { + mysql_pool: mysql_pool.clone(), // NB: Pool is sync/send/clone-safe + firehose_publisher: firehose_publisher.clone(), // NB: Also safe + }; + let common_env = CommonEnv::read_from_env()?; let downloader = Downloader { @@ -205,6 +212,7 @@ async fn main() -> AnyhowResult<()> { download_script, google_drive_downloader, firehose_publisher, + badge_granter, ffmpeg_image_preview_generator: FfmpegGeneratePreviewImageCommand {}, ffmpeg_video_preview_generator: FfmpegGeneratePreviewVideoCommand {}, imagemagick_image_preview_generator: ImagemagickGeneratePreviewImageCommand {}, @@ -551,6 +559,13 @@ async fn process_job(downloader: &Downloader, job: &W2lTemplateUploadJobRecord) anyhow!("error publishing event") })?; + downloader.badge_granter.maybe_grant_w2l_template_uploads_badge(&job.creator_user_token) + .await + .map_err(|e| { + warn!("error maybe awarding badge: {:?}", e); + anyhow!("error maybe awarding badge") + })?; + if downloader.debug_job_end_sleep_millis != 0 { warn!("Debug sleep after job end: {} ms", downloader.debug_job_end_sleep_millis); thread::sleep(Duration::from_millis(downloader.debug_job_end_sleep_millis));