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