crates/api_common/src/utils.rs

   1 use crate::{request::purge_image_from_pictrs, sensitive::Sensitive, site::FederatedInstances};
   2 use chrono::NaiveDateTime;
   3 use lemmy_db_schema::{
   4   impls::person::is_banned,
   5   newtypes::{CommunityId, LocalUserId, PersonId, PostId},
   6   source::{
   7     comment::{Comment, CommentUpdateForm},
   8     community::{Community, CommunityUpdateForm},
   9     email_verification::{EmailVerification, EmailVerificationForm},
  10     instance::Instance,
  11     local_site::LocalSite,
  12     local_site_rate_limit::LocalSiteRateLimit,
  13     password_reset_request::PasswordResetRequest,
  14     person::{Person, PersonUpdateForm},
  15     person_block::PersonBlock,
  16     post::{Post, PostRead, PostReadForm},
  17     registration_application::RegistrationApplication,
  18     secret::Secret,
  19   },
  20   traits::{Crud, Readable},
  21   utils::DbPool,
  22   ListingType,
  23 };
  24 use lemmy_db_views::{
  25   comment_view::CommentQuery,
  26   structs::{LocalUserSettingsView, LocalUserView},
  27 };
  28 use lemmy_db_views_actor::structs::{
  29   CommunityModeratorView,
  30   CommunityPersonBanView,
  31   CommunityView,
  32 };
  33 use lemmy_utils::{
  34   claims::Claims,
  35   email::{send_email, translations::Lang},
  36   error::LemmyError,
  37   rate_limit::RateLimitConfig,
  38   settings::structs::Settings,
  39   utils::{build_slur_regex, generate_random_string},
  40 };
  41 use regex::Regex;
  42 use reqwest_middleware::ClientWithMiddleware;
  43 use rosetta_i18n::{Language, LanguageId};
  44 use std::str::FromStr;
  45 use tracing::warn;
  46
  47 pub async fn blocking<F, T>(pool: &DbPool, f: F) -> Result<T, LemmyError>
  48 where
  49   F: FnOnce(&mut diesel::PgConnection) -> T + Send + 'static,
  50   T: Send + 'static,
  51 {
  52   let pool = pool.clone();
  53   let blocking_span = tracing::info_span!("blocking operation");
  54   actix_web::web::block(move || {
  55     let entered = blocking_span.enter();
  56     let mut conn = pool.get()?;
  57     let res = (f)(&mut conn);
  58     drop(entered);
  59     Ok(res) as Result<T, LemmyError>
  60   })
  61   .await?
  62 }
  63
  64 #[tracing::instrument(skip_all)]
  65 pub async fn is_mod_or_admin(
  66   pool: &DbPool,
  67   person_id: PersonId,
  68   community_id: CommunityId,
  69 ) -> Result<(), LemmyError> {
  70   let is_mod_or_admin = blocking(pool, move |conn| {
  71     CommunityView::is_mod_or_admin(conn, person_id, community_id)
  72   })
  73   .await?;
  74   if !is_mod_or_admin {
  75     return Err(LemmyError::from_message("not_a_mod_or_admin"));
  76   }
  77   Ok(())
  78 }
  79
  80 pub fn is_admin(local_user_view: &LocalUserView) -> Result<(), LemmyError> {
  81   if !local_user_view.person.admin {
  82     return Err(LemmyError::from_message("not_an_admin"));
  83   }
  84   Ok(())
  85 }
  86
  87 #[tracing::instrument(skip_all)]
  88 pub async fn get_post(post_id: PostId, pool: &DbPool) -> Result<Post, LemmyError> {
  89   blocking(pool, move |conn| Post::read(conn, post_id))
  90     .await?
  91     .map_err(|e| LemmyError::from_error_message(e, "couldnt_find_post"))
  92 }
  93
  94 #[tracing::instrument(skip_all)]
  95 pub async fn mark_post_as_read(
  96   person_id: PersonId,
  97   post_id: PostId,
  98   pool: &DbPool,
  99 ) -> Result<PostRead, LemmyError> {
 100   let post_read_form = PostReadForm { post_id, person_id };
 101
 102   blocking(pool, move |conn| {
 103     PostRead::mark_as_read(conn, &post_read_form)
 104   })
 105   .await?
 106   .map_err(|e| LemmyError::from_error_message(e, "couldnt_mark_post_as_read"))
 107 }
 108
 109 #[tracing::instrument(skip_all)]
 110 pub async fn mark_post_as_unread(
 111   person_id: PersonId,
 112   post_id: PostId,
 113   pool: &DbPool,
 114 ) -> Result<usize, LemmyError> {
 115   let post_read_form = PostReadForm { post_id, person_id };
 116
 117   blocking(pool, move |conn| {
 118     PostRead::mark_as_unread(conn, &post_read_form)
 119   })
 120   .await?
 121   .map_err(|e| LemmyError::from_error_message(e, "couldnt_mark_post_as_read"))
 122 }
 123
 124 #[tracing::instrument(skip_all)]
 125 pub async fn get_local_user_view_from_jwt(
 126   jwt: &str,
 127   pool: &DbPool,
 128   secret: &Secret,
 129 ) -> Result<LocalUserView, LemmyError> {
 130   let claims = Claims::decode(jwt, &secret.jwt_secret)
 131     .map_err(|e| e.with_message("not_logged_in"))?
 132     .claims;
 133   let local_user_id = LocalUserId(claims.sub);
 134   let local_user_view =
 135     blocking(pool, move |conn| LocalUserView::read(conn, local_user_id)).await??;
 136   check_user_valid(
 137     local_user_view.person.banned,
 138     local_user_view.person.ban_expires,
 139     local_user_view.person.deleted,
 140   )?;
 141
 142   check_validator_time(&local_user_view.local_user.validator_time, &claims)?;
 143
 144   Ok(local_user_view)
 145 }
 146
 147 /// Checks if user's token was issued before user's password reset.
 148 pub fn check_validator_time(
 149   validator_time: &NaiveDateTime,
 150   claims: &Claims,
 151 ) -> Result<(), LemmyError> {
 152   let user_validation_time = validator_time.timestamp();
 153   if user_validation_time > claims.iat {
 154     Err(LemmyError::from_message("not_logged_in"))
 155   } else {
 156     Ok(())
 157   }
 158 }
 159
 160 #[tracing::instrument(skip_all)]
 161 pub async fn get_local_user_view_from_jwt_opt(
 162   jwt: Option<&Sensitive<String>>,
 163   pool: &DbPool,
 164   secret: &Secret,
 165 ) -> Result<Option<LocalUserView>, LemmyError> {
 166   match jwt {
 167     Some(jwt) => Ok(Some(get_local_user_view_from_jwt(jwt, pool, secret).await?)),
 168     None => Ok(None),
 169   }
 170 }
 171
 172 #[tracing::instrument(skip_all)]
 173 pub async fn get_local_user_settings_view_from_jwt_opt(
 174   jwt: Option<&Sensitive<String>>,
 175   pool: &DbPool,
 176   secret: &Secret,
 177 ) -> Result<Option<LocalUserSettingsView>, LemmyError> {
 178   match jwt {
 179     Some(jwt) => {
 180       let claims = Claims::decode(jwt.as_ref(), &secret.jwt_secret)
 181         .map_err(|e| e.with_message("not_logged_in"))?
 182         .claims;
 183       let local_user_id = LocalUserId(claims.sub);
 184       let local_user_view = blocking(pool, move |conn| {
 185         LocalUserSettingsView::read(conn, local_user_id)
 186       })
 187       .await??;
 188       check_user_valid(
 189         local_user_view.person.banned,
 190         local_user_view.person.ban_expires,
 191         local_user_view.person.deleted,
 192       )?;
 193
 194       check_validator_time(&local_user_view.local_user.validator_time, &claims)?;
 195
 196       Ok(Some(local_user_view))
 197     }
 198     None => Ok(None),
 199   }
 200 }
 201 pub fn check_user_valid(
 202   banned: bool,
 203   ban_expires: Option<NaiveDateTime>,
 204   deleted: bool,
 205 ) -> Result<(), LemmyError> {
 206   // Check for a site ban
 207   if is_banned(banned, ban_expires) {
 208     return Err(LemmyError::from_message("site_ban"));
 209   }
 210
 211   // check for account deletion
 212   if deleted {
 213     return Err(LemmyError::from_message("deleted"));
 214   }
 215
 216   Ok(())
 217 }
 218
 219 #[tracing::instrument(skip_all)]
 220 pub async fn check_community_ban(
 221   person_id: PersonId,
 222   community_id: CommunityId,
 223   pool: &DbPool,
 224 ) -> Result<(), LemmyError> {
 225   let is_banned =
 226     move |conn: &mut _| CommunityPersonBanView::get(conn, person_id, community_id).is_ok();
 227   if blocking(pool, is_banned).await? {
 228     Err(LemmyError::from_message("community_ban"))
 229   } else {
 230     Ok(())
 231   }
 232 }
 233
 234 #[tracing::instrument(skip_all)]
 235 pub async fn check_community_deleted_or_removed(
 236   community_id: CommunityId,
 237   pool: &DbPool,
 238 ) -> Result<(), LemmyError> {
 239   let community = blocking(pool, move |conn| Community::read(conn, community_id))
 240     .await?
 241     .map_err(|e| LemmyError::from_error_message(e, "couldnt_find_community"))?;
 242   if community.deleted || community.removed {
 243     Err(LemmyError::from_message("deleted"))
 244   } else {
 245     Ok(())
 246   }
 247 }
 248
 249 pub fn check_post_deleted_or_removed(post: &Post) -> Result<(), LemmyError> {
 250   if post.deleted || post.removed {
 251     Err(LemmyError::from_message("deleted"))
 252   } else {
 253     Ok(())
 254   }
 255 }
 256
 257 #[tracing::instrument(skip_all)]
 258 pub async fn check_person_block(
 259   my_id: PersonId,
 260   potential_blocker_id: PersonId,
 261   pool: &DbPool,
 262 ) -> Result<(), LemmyError> {
 263   let is_blocked = move |conn: &mut _| PersonBlock::read(conn, potential_blocker_id, my_id).is_ok();
 264   if blocking(pool, is_blocked).await? {
 265     Err(LemmyError::from_message("person_block"))
 266   } else {
 267     Ok(())
 268   }
 269 }
 270
 271 #[tracing::instrument(skip_all)]
 272 pub fn check_downvotes_enabled(score: i16, local_site: &LocalSite) -> Result<(), LemmyError> {
 273   if score == -1 && !local_site.enable_downvotes {
 274     return Err(LemmyError::from_message("downvotes_disabled"));
 275   }
 276   Ok(())
 277 }
 278
 279 #[tracing::instrument(skip_all)]
 280 pub fn check_private_instance(
 281   local_user_view: &Option<LocalUserView>,
 282   local_site: &LocalSite,
 283 ) -> Result<(), LemmyError> {
 284   if local_user_view.is_none() && local_site.private_instance {
 285     return Err(LemmyError::from_message("instance_is_private"));
 286   }
 287   Ok(())
 288 }
 289
 290 #[tracing::instrument(skip_all)]
 291 pub async fn build_federated_instances(
 292   local_site: &LocalSite,
 293   pool: &DbPool,
 294 ) -> Result<Option<FederatedInstances>, LemmyError> {
 295   if local_site.federation_enabled {
 296     // TODO I hate that this requires 3 queries
 297     let linked = blocking(pool, Instance::linked).await??;
 298     let allowed = blocking(pool, Instance::allowlist).await??;
 299     let blocked = blocking(pool, Instance::blocklist).await??;
 300
 301     // These can return empty vectors, so convert them to options
 302     let allowed = (!allowed.is_empty()).then(|| allowed);
 303     let blocked = (!blocked.is_empty()).then(|| blocked);
 304
 305     Ok(Some(FederatedInstances {
 306       linked,
 307       allowed,
 308       blocked,
 309     }))
 310   } else {
 311     Ok(None)
 312   }
 313 }
 314
 315 /// Checks the password length
 316 pub fn password_length_check(pass: &str) -> Result<(), LemmyError> {
 317   if !(10..=60).contains(&pass.chars().count()) {
 318     Err(LemmyError::from_message("invalid_password"))
 319   } else {
 320     Ok(())
 321   }
 322 }
 323
 324 /// Checks the site description length
 325 pub fn site_description_length_check(description: &str) -> Result<(), LemmyError> {
 326   if description.len() > 150 {
 327     Err(LemmyError::from_message("site_description_length_overflow"))
 328   } else {
 329     Ok(())
 330   }
 331 }
 332
 333 /// Checks for a honeypot. If this field is filled, fail the rest of the function
 334 pub fn honeypot_check(honeypot: &Option<String>) -> Result<(), LemmyError> {
 335   if honeypot.is_some() {
 336     Err(LemmyError::from_message("honeypot_fail"))
 337   } else {
 338     Ok(())
 339   }
 340 }
 341
 342 pub fn send_email_to_user(
 343   local_user_view: &LocalUserView,
 344   subject: &str,
 345   body: &str,
 346   settings: &Settings,
 347 ) {
 348   if local_user_view.person.banned || !local_user_view.local_user.send_notifications_to_email {
 349     return;
 350   }
 351
 352   if let Some(user_email) = &local_user_view.local_user.email {
 353     match send_email(
 354       subject,
 355       user_email,
 356       &local_user_view.person.name,
 357       body,
 358       settings,
 359     ) {
 360       Ok(_o) => _o,
 361       Err(e) => warn!("{}", e),
 362     };
 363   }
 364 }
 365
 366 pub async fn send_password_reset_email(
 367   user: &LocalUserView,
 368   pool: &DbPool,
 369   settings: &Settings,
 370 ) -> Result<(), LemmyError> {
 371   // Generate a random token
 372   let token = generate_random_string();
 373
 374   // Insert the row
 375   let token2 = token.clone();
 376   let local_user_id = user.local_user.id;
 377   blocking(pool, move |conn| {
 378     PasswordResetRequest::create_token(conn, local_user_id, &token2)
 379   })
 380   .await??;
 381
 382   let email = &user.local_user.email.to_owned().expect("email");
 383   let lang = get_interface_language(user);
 384   let subject = &lang.password_reset_subject(&user.person.name);
 385   let protocol_and_hostname = settings.get_protocol_and_hostname();
 386   let reset_link = format!("{}/password_change/{}", protocol_and_hostname, &token);
 387   let body = &lang.password_reset_body(reset_link, &user.person.name);
 388   send_email(subject, email, &user.person.name, body, settings)
 389 }
 390
 391 /// Send a verification email
 392 pub async fn send_verification_email(
 393   user: &LocalUserView,
 394   new_email: &str,
 395   pool: &DbPool,
 396   settings: &Settings,
 397 ) -> Result<(), LemmyError> {
 398   let form = EmailVerificationForm {
 399     local_user_id: user.local_user.id,
 400     email: new_email.to_string(),
 401     verification_token: generate_random_string(),
 402   };
 403   let verify_link = format!(
 404     "{}/verify_email/{}",
 405     settings.get_protocol_and_hostname(),
 406     &form.verification_token
 407   );
 408   blocking(pool, move |conn| EmailVerification::create(conn, &form)).await??;
 409
 410   let lang = get_interface_language(user);
 411   let subject = lang.verify_email_subject(&settings.hostname);
 412   let body = lang.verify_email_body(&settings.hostname, &user.person.name, verify_link);
 413   send_email(&subject, new_email, &user.person.name, &body, settings)?;
 414
 415   Ok(())
 416 }
 417
 418 pub fn send_email_verification_success(
 419   user: &LocalUserView,
 420   settings: &Settings,
 421 ) -> Result<(), LemmyError> {
 422   let email = &user.local_user.email.to_owned().expect("email");
 423   let lang = get_interface_language(user);
 424   let subject = &lang.email_verified_subject(&user.person.actor_id);
 425   let body = &lang.email_verified_body();
 426   send_email(subject, email, &user.person.name, body, settings)
 427 }
 428
 429 pub fn get_interface_language(user: &LocalUserView) -> Lang {
 430   lang_str_to_lang(&user.local_user.interface_language)
 431 }
 432
 433 pub fn get_interface_language_from_settings(user: &LocalUserSettingsView) -> Lang {
 434   lang_str_to_lang(&user.local_user.interface_language)
 435 }
 436
 437 fn lang_str_to_lang(lang: &str) -> Lang {
 438   let lang_id = LanguageId::new(lang);
 439   Lang::from_language_id(&lang_id).unwrap_or_else(|| {
 440     let en = LanguageId::new("en");
 441     Lang::from_language_id(&en).expect("default language")
 442   })
 443 }
 444
 445 pub fn local_site_rate_limit_to_rate_limit_config(
 446   local_site_rate_limit: &LocalSiteRateLimit,
 447 ) -> RateLimitConfig {
 448   let l = local_site_rate_limit;
 449   RateLimitConfig {
 450     message: l.message,
 451     message_per_second: l.message_per_second,
 452     post: l.post,
 453     post_per_second: l.post_per_second,
 454     register: l.register,
 455     register_per_second: l.register_per_second,
 456     image: l.image,
 457     image_per_second: l.image_per_second,
 458     comment: l.comment,
 459     comment_per_second: l.comment_per_second,
 460     search: l.search,
 461     search_per_second: l.search_per_second,
 462   }
 463 }
 464
 465 pub fn local_site_to_slur_regex(local_site: &LocalSite) -> Option<Regex> {
 466   build_slur_regex(local_site.slur_filter_regex.as_deref())
 467 }
 468
 469 pub fn local_site_opt_to_slur_regex(local_site: &Option<LocalSite>) -> Option<Regex> {
 470   local_site
 471     .as_ref()
 472     .map(local_site_to_slur_regex)
 473     .unwrap_or(None)
 474 }
 475
 476 pub fn send_application_approved_email(
 477   user: &LocalUserView,
 478   settings: &Settings,
 479 ) -> Result<(), LemmyError> {
 480   let email = &user.local_user.email.to_owned().expect("email");
 481   let lang = get_interface_language(user);
 482   let subject = lang.registration_approved_subject(&user.person.actor_id);
 483   let body = lang.registration_approved_body(&settings.hostname);
 484   send_email(&subject, email, &user.person.name, &body, settings)
 485 }
 486
 487 /// Send a new applicant email notification to all admins
 488 pub async fn send_new_applicant_email_to_admins(
 489   applicant_username: &str,
 490   pool: &DbPool,
 491   settings: &Settings,
 492 ) -> Result<(), LemmyError> {
 493   // Collect the admins with emails
 494   let admins = blocking(pool, move |conn| {
 495     LocalUserSettingsView::list_admins_with_emails(conn)
 496   })
 497   .await??;
 498
 499   let applications_link = &format!(
 500     "{}/registration_applications",
 501     settings.get_protocol_and_hostname(),
 502   );
 503
 504   for admin in &admins {
 505     let email = &admin.local_user.email.to_owned().expect("email");
 506     let lang = get_interface_language_from_settings(admin);
 507     let subject = lang.new_application_subject(applicant_username, &settings.hostname);
 508     let body = lang.new_application_body(applications_link);
 509     send_email(&subject, email, &admin.person.name, &body, settings)?;
 510   }
 511   Ok(())
 512 }
 513
 514 pub async fn check_registration_application(
 515   local_user_view: &LocalUserView,
 516   local_site: &LocalSite,
 517   pool: &DbPool,
 518 ) -> Result<(), LemmyError> {
 519   if local_site.require_application
 520     && !local_user_view.local_user.accepted_application
 521     && !local_user_view.person.admin
 522   {
 523     // Fetch the registration, see if its denied
 524     let local_user_id = local_user_view.local_user.id;
 525     let registration = blocking(pool, move |conn| {
 526       RegistrationApplication::find_by_local_user_id(conn, local_user_id)
 527     })
 528     .await??;
 529     if let Some(deny_reason) = registration.deny_reason {
 530       let lang = get_interface_language(local_user_view);
 531       let registration_denied_message = format!("{}: {}", lang.registration_denied(), &deny_reason);
 532       return Err(LemmyError::from_message(&registration_denied_message));
 533     } else {
 534       return Err(LemmyError::from_message("registration_application_pending"));
 535     }
 536   }
 537   Ok(())
 538 }
 539
 540 pub fn check_private_instance_and_federation_enabled(
 541   local_site: &LocalSite,
 542 ) -> Result<(), LemmyError> {
 543   if local_site.private_instance && local_site.federation_enabled {
 544     return Err(LemmyError::from_message(
 545       "Cannot have both private instance and federation enabled.",
 546     ));
 547   }
 548   Ok(())
 549 }
 550
 551 pub async fn purge_image_posts_for_person(
 552   banned_person_id: PersonId,
 553   pool: &DbPool,
 554   settings: &Settings,
 555   client: &ClientWithMiddleware,
 556 ) -> Result<(), LemmyError> {
 557   let posts = blocking(pool, move |conn: &mut _| {
 558     Post::fetch_pictrs_posts_for_creator(conn, banned_person_id)
 559   })
 560   .await??;
 561   for post in posts {
 562     if let Some(url) = post.url {
 563       purge_image_from_pictrs(client, settings, &url).await.ok();
 564     }
 565     if let Some(thumbnail_url) = post.thumbnail_url {
 566       purge_image_from_pictrs(client, settings, &thumbnail_url)
 567         .await
 568         .ok();
 569     }
 570   }
 571
 572   blocking(pool, move |conn| {
 573     Post::remove_pictrs_post_images_and_thumbnails_for_creator(conn, banned_person_id)
 574   })
 575   .await??;
 576
 577   Ok(())
 578 }
 579
 580 pub async fn purge_image_posts_for_community(
 581   banned_community_id: CommunityId,
 582   pool: &DbPool,
 583   settings: &Settings,
 584   client: &ClientWithMiddleware,
 585 ) -> Result<(), LemmyError> {
 586   let posts = blocking(pool, move |conn: &mut _| {
 587     Post::fetch_pictrs_posts_for_community(conn, banned_community_id)
 588   })
 589   .await??;
 590   for post in posts {
 591     if let Some(url) = post.url {
 592       purge_image_from_pictrs(client, settings, &url).await.ok();
 593     }
 594     if let Some(thumbnail_url) = post.thumbnail_url {
 595       purge_image_from_pictrs(client, settings, &thumbnail_url)
 596         .await
 597         .ok();
 598     }
 599   }
 600
 601   blocking(pool, move |conn| {
 602     Post::remove_pictrs_post_images_and_thumbnails_for_community(conn, banned_community_id)
 603   })
 604   .await??;
 605
 606   Ok(())
 607 }
 608
 609 pub async fn remove_user_data(
 610   banned_person_id: PersonId,
 611   pool: &DbPool,
 612   settings: &Settings,
 613   client: &ClientWithMiddleware,
 614 ) -> Result<(), LemmyError> {
 615   // Purge user images
 616   let person = blocking(pool, move |conn| Person::read(conn, banned_person_id)).await??;
 617   if let Some(avatar) = person.avatar {
 618     purge_image_from_pictrs(client, settings, &avatar)
 619       .await
 620       .ok();
 621   }
 622   if let Some(banner) = person.banner {
 623     purge_image_from_pictrs(client, settings, &banner)
 624       .await
 625       .ok();
 626   }
 627
 628   // Update the fields to None
 629   blocking(pool, move |conn| {
 630     Person::update(
 631       conn,
 632       banned_person_id,
 633       &PersonUpdateForm::builder()
 634         .avatar(Some(None))
 635         .banner(Some(None))
 636         .build(),
 637     )
 638   })
 639   .await??;
 640
 641   // Posts
 642   blocking(pool, move |conn: &mut _| {
 643     Post::update_removed_for_creator(conn, banned_person_id, None, true)
 644   })
 645   .await??;
 646
 647   // Purge image posts
 648   purge_image_posts_for_person(banned_person_id, pool, settings, client).await?;
 649
 650   // Communities
 651   // Remove all communities where they're the top mod
 652   // for now, remove the communities manually
 653   let first_mod_communities = blocking(pool, move |conn: &mut _| {
 654     CommunityModeratorView::get_community_first_mods(conn)
 655   })
 656   .await??;
 657
 658   // Filter to only this banned users top communities
 659   let banned_user_first_communities: Vec<CommunityModeratorView> = first_mod_communities
 660     .into_iter()
 661     .filter(|fmc| fmc.moderator.id == banned_person_id)
 662     .collect();
 663
 664   for first_mod_community in banned_user_first_communities {
 665     let community_id = first_mod_community.community.id;
 666     blocking(pool, move |conn| {
 667       Community::update(
 668         conn,
 669         community_id,
 670         &CommunityUpdateForm::builder().removed(Some(true)).build(),
 671       )
 672     })
 673     .await??;
 674
 675     // Delete the community images
 676     if let Some(icon) = first_mod_community.community.icon {
 677       purge_image_from_pictrs(client, settings, &icon).await.ok();
 678     }
 679     if let Some(banner) = first_mod_community.community.banner {
 680       purge_image_from_pictrs(client, settings, &banner)
 681         .await
 682         .ok();
 683     }
 684     // Update the fields to None
 685     blocking(pool, move |conn| {
 686       Community::update(
 687         conn,
 688         community_id,
 689         &CommunityUpdateForm::builder()
 690           .icon(Some(None))
 691           .banner(Some(None))
 692           .build(),
 693       )
 694     })
 695     .await??;
 696   }
 697
 698   // Comments
 699   blocking(pool, move |conn: &mut _| {
 700     Comment::update_removed_for_creator(conn, banned_person_id, true)
 701   })
 702   .await??;
 703
 704   Ok(())
 705 }
 706
 707 pub async fn remove_user_data_in_community(
 708   community_id: CommunityId,
 709   banned_person_id: PersonId,
 710   pool: &DbPool,
 711 ) -> Result<(), LemmyError> {
 712   // Posts
 713   blocking(pool, move |conn| {
 714     Post::update_removed_for_creator(conn, banned_person_id, Some(community_id), true)
 715   })
 716   .await??;
 717
 718   // Comments
 719   // TODO Diesel doesn't allow updates with joins, so this has to be a loop
 720   let comments = blocking(pool, move |conn| {
 721     CommentQuery::builder()
 722       .conn(conn)
 723       .creator_id(Some(banned_person_id))
 724       .community_id(Some(community_id))
 725       .limit(Some(i64::MAX))
 726       .build()
 727       .list()
 728   })
 729   .await??;
 730
 731   for comment_view in &comments {
 732     let comment_id = comment_view.comment.id;
 733     blocking(pool, move |conn| {
 734       Comment::update(
 735         conn,
 736         comment_id,
 737         &CommentUpdateForm::builder().removed(Some(true)).build(),
 738       )
 739     })
 740     .await??;
 741   }
 742
 743   Ok(())
 744 }
 745
 746 pub async fn delete_user_account(
 747   person_id: PersonId,
 748   pool: &DbPool,
 749   settings: &Settings,
 750   client: &ClientWithMiddleware,
 751 ) -> Result<(), LemmyError> {
 752   // Delete their images
 753   let person = blocking(pool, move |conn| Person::read(conn, person_id)).await??;
 754   if let Some(avatar) = person.avatar {
 755     purge_image_from_pictrs(client, settings, &avatar)
 756       .await
 757       .ok();
 758   }
 759   if let Some(banner) = person.banner {
 760     purge_image_from_pictrs(client, settings, &banner)
 761       .await
 762       .ok();
 763   }
 764   // No need to update avatar and banner, those are handled in Person::delete_account
 765
 766   // Comments
 767   let permadelete = move |conn: &mut _| Comment::permadelete_for_creator(conn, person_id);
 768   blocking(pool, permadelete)
 769     .await?
 770     .map_err(|e| LemmyError::from_error_message(e, "couldnt_update_comment"))?;
 771
 772   // Posts
 773   let permadelete = move |conn: &mut _| Post::permadelete_for_creator(conn, person_id);
 774   blocking(pool, permadelete)
 775     .await?
 776     .map_err(|e| LemmyError::from_error_message(e, "couldnt_update_post"))?;
 777
 778   // Purge image posts
 779   purge_image_posts_for_person(person_id, pool, settings, client).await?;
 780
 781   blocking(pool, move |conn| Person::delete_account(conn, person_id)).await??;
 782
 783   Ok(())
 784 }
 785
 786 pub fn listing_type_with_site_default(
 787   listing_type: Option<ListingType>,
 788   local_site: &LocalSite,
 789 ) -> Result<ListingType, LemmyError> {
 790   Ok(listing_type.unwrap_or(ListingType::from_str(
 791     &local_site.default_post_listing_type,
 792   )?))
 793 }
 794
 795 #[cfg(test)]
 796 mod tests {
 797   use crate::utils::password_length_check;
 798
 799   #[test]
 800   #[rustfmt::skip]
 801   fn password_length() {
 802     assert!(password_length_check("Õ¼¾°3yË,o¸ãtÌÈú|ÇÁÙAøüÒI©·¤(T]/ð>æºWæ[C¤bªWöaÃÎñ·{=û³&§½K/c").is_ok());
 803     assert!(password_length_check("1234567890").is_ok());
 804     assert!(password_length_check("short").is_err());
 805     assert!(password_length_check("looooooooooooooooooooooooooooooooooooooooooooooooooooooooooong").is_err());
 806   }
 807 }