user badges + user badge granter + integrated into grant call sites

This commit is contained in:
Brandon Thomas committed 2021-06-27 00:03:48 -04:00
1 parent 0ca7ceadab
commit 6b745fd3b0
12 files changed
+595 -3

No files matched your search

+7
View File
@@ -0,0 +1,7 @@
#!/bin/bash
# ONLY FOR LOCAL DEV
mysql -u storyteller \
-ppassword \
-h localhost \
-D storyteller \
-e "select * from badges\G"
@@ -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),
+9 -1
View File
@@ -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"
+146
View File
@@ -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 = '';
+366
View File
@@ -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<bool> {
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<u64> {
// 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<u64> {
// 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<u64> {
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<MySqlDone, sqlx::Error>) -> AnyhowResult<u64> {
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<CountRecord, sqlx::Error>) -> AnyhowResult<u64> {
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)
}
}
+14
View File
@@ -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,
+1
View File
@@ -1,3 +1,4 @@
pub mod badge_granter;
pub mod badges;
pub mod firehose_publisher;
pub mod list_ip_bans;
@@ -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;
+8 -1
View File
@@ -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,
+3 -1
View File
@@ -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,
+15
View File
@@ -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(())
+15
View File
@@ -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));