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_site).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_site).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   let user_lang = LanguageId::new(user.local_user.interface_language.clone());
 456   Lang::from_language_id(&user_lang).unwrap_or_else(|| {
 457     let en = LanguageId::new("en");
 458     Lang::from_language_id(&en).expect("default language")
 459   })
 460 }
 461
 462 pub fn send_application_approved_email(
 463   user: &LocalUserView,
 464   settings: &Settings,
 465 ) -> Result<(), LemmyError> {
 466   let email = &user.local_user.email.to_owned().expect("email");
 467   let lang = get_interface_language(user);
 468   let subject = lang.registration_approved_subject(&user.person.actor_id);
 469   let body = lang.registration_approved_body(&settings.hostname);
 470   send_email(&subject, email, &user.person.name, &body, settings)
 471 }
 472
 473 pub async fn check_registration_application(
 474   site: &Site,
 475   local_user_view: &LocalUserView,
 476   pool: &DbPool,
 477 ) -> Result<(), LemmyError> {
 478   if site.require_application
 479     && !local_user_view.local_user.accepted_application
 480     && !local_user_view.person.admin
 481   {
 482     // Fetch the registration, see if its denied
 483     let local_user_id = local_user_view.local_user.id;
 484     let registration = blocking(pool, move |conn| {
 485       RegistrationApplication::find_by_local_user_id(conn, local_user_id)
 486     })
 487     .await??;
 488     if let Some(deny_reason) = registration.deny_reason {
 489       let lang = get_interface_language(local_user_view);
 490       let registration_denied_message = format!("{}: {}", lang.registration_denied(), &deny_reason);
 491       return Err(LemmyError::from_message(&registration_denied_message));
 492     } else {
 493       return Err(LemmyError::from_message("registration_application_pending"));
 494     }
 495   }
 496   Ok(())
 497 }
 498
 499 /// TODO this check should be removed after https://github.com/LemmyNet/lemmy/issues/868 is done.
 500 pub async fn check_private_instance_and_federation_enabled(
 501   pool: &DbPool,
 502   settings: &Settings,
 503 ) -> Result<(), LemmyError> {
 504   let site_opt = blocking(pool, Site::read_local_site).await?;
 505
 506   if let Ok(site) = site_opt {
 507     if site.private_instance && settings.federation.enabled {
 508       return Err(LemmyError::from_message(
 509         "Cannot have both private instance and federation enabled.",
 510       ));
 511     }
 512   }
 513   Ok(())
 514 }
 515
 516 pub async fn purge_image_posts_for_person(
 517   banned_person_id: PersonId,
 518   pool: &DbPool,
 519   settings: &Settings,
 520   client: &ClientWithMiddleware,
 521 ) -> Result<(), LemmyError> {
 522   let posts = blocking(pool, move |conn: &mut _| {
 523     Post::fetch_pictrs_posts_for_creator(conn, banned_person_id)
 524   })
 525   .await??;
 526   for post in posts {
 527     if let Some(url) = post.url {
 528       purge_image_from_pictrs(client, settings, &url).await.ok();
 529     }
 530     if let Some(thumbnail_url) = post.thumbnail_url {
 531       purge_image_from_pictrs(client, settings, &thumbnail_url)
 532         .await
 533         .ok();
 534     }
 535   }
 536
 537   blocking(pool, move |conn| {
 538     Post::remove_pictrs_post_images_and_thumbnails_for_creator(conn, banned_person_id)
 539   })
 540   .await??;
 541
 542   Ok(())
 543 }
 544
 545 pub async fn purge_image_posts_for_community(
 546   banned_community_id: CommunityId,
 547   pool: &DbPool,
 548   settings: &Settings,
 549   client: &ClientWithMiddleware,
 550 ) -> Result<(), LemmyError> {
 551   let posts = blocking(pool, move |conn: &mut _| {
 552     Post::fetch_pictrs_posts_for_community(conn, banned_community_id)
 553   })
 554   .await??;
 555   for post in posts {
 556     if let Some(url) = post.url {
 557       purge_image_from_pictrs(client, settings, &url).await.ok();
 558     }
 559     if let Some(thumbnail_url) = post.thumbnail_url {
 560       purge_image_from_pictrs(client, settings, &thumbnail_url)
 561         .await
 562         .ok();
 563     }
 564   }
 565
 566   blocking(pool, move |conn| {
 567     Post::remove_pictrs_post_images_and_thumbnails_for_community(conn, banned_community_id)
 568   })
 569   .await??;
 570
 571   Ok(())
 572 }
 573
 574 pub async fn remove_user_data(
 575   banned_person_id: PersonId,
 576   pool: &DbPool,
 577   settings: &Settings,
 578   client: &ClientWithMiddleware,
 579 ) -> Result<(), LemmyError> {
 580   // Purge user images
 581   let person = blocking(pool, move |conn| Person::read(conn, banned_person_id)).await??;
 582   if let Some(avatar) = person.avatar {
 583     purge_image_from_pictrs(client, settings, &avatar)
 584       .await
 585       .ok();
 586   }
 587   if let Some(banner) = person.banner {
 588     purge_image_from_pictrs(client, settings, &banner)
 589       .await
 590       .ok();
 591   }
 592
 593   // Update the fields to None
 594   blocking(pool, move |conn| {
 595     Person::remove_avatar_and_banner(conn, banned_person_id)
 596   })
 597   .await??;
 598
 599   // Posts
 600   blocking(pool, move |conn: &mut _| {
 601     Post::update_removed_for_creator(conn, banned_person_id, None, true)
 602   })
 603   .await??;
 604
 605   // Purge image posts
 606   purge_image_posts_for_person(banned_person_id, pool, settings, client).await?;
 607
 608   // Communities
 609   // Remove all communities where they're the top mod
 610   // for now, remove the communities manually
 611   let first_mod_communities = blocking(pool, move |conn: &mut _| {
 612     CommunityModeratorView::get_community_first_mods(conn)
 613   })
 614   .await??;
 615
 616   // Filter to only this banned users top communities
 617   let banned_user_first_communities: Vec<CommunityModeratorView> = first_mod_communities
 618     .into_iter()
 619     .filter(|fmc| fmc.moderator.id == banned_person_id)
 620     .collect();
 621
 622   for first_mod_community in banned_user_first_communities {
 623     let community_id = first_mod_community.community.id;
 624     blocking(pool, move |conn: &mut _| {
 625       Community::update_removed(conn, community_id, true)
 626     })
 627     .await??;
 628
 629     // Delete the community images
 630     if let Some(icon) = first_mod_community.community.icon {
 631       purge_image_from_pictrs(client, settings, &icon).await.ok();
 632     }
 633     if let Some(banner) = first_mod_community.community.banner {
 634       purge_image_from_pictrs(client, settings, &banner)
 635         .await
 636         .ok();
 637     }
 638     // Update the fields to None
 639     blocking(pool, move |conn| {
 640       Community::remove_avatar_and_banner(conn, community_id)
 641     })
 642     .await??;
 643   }
 644
 645   // Comments
 646   blocking(pool, move |conn: &mut _| {
 647     Comment::update_removed_for_creator(conn, banned_person_id, true)
 648   })
 649   .await??;
 650
 651   Ok(())
 652 }
 653
 654 pub async fn remove_user_data_in_community(
 655   community_id: CommunityId,
 656   banned_person_id: PersonId,
 657   pool: &DbPool,
 658 ) -> Result<(), LemmyError> {
 659   // Posts
 660   blocking(pool, move |conn| {
 661     Post::update_removed_for_creator(conn, banned_person_id, Some(community_id), true)
 662   })
 663   .await??;
 664
 665   // Comments
 666   // TODO Diesel doesn't allow updates with joins, so this has to be a loop
 667   let comments = blocking(pool, move |conn| {
 668     CommentQuery::builder()
 669       .conn(conn)
 670       .creator_id(Some(banned_person_id))
 671       .community_id(Some(community_id))
 672       .limit(Some(i64::MAX))
 673       .build()
 674       .list()
 675   })
 676   .await??;
 677
 678   for comment_view in &comments {
 679     let comment_id = comment_view.comment.id;
 680     blocking(pool, move |conn| {
 681       Comment::update_removed(conn, comment_id, true)
 682     })
 683     .await??;
 684   }
 685
 686   Ok(())
 687 }
 688
 689 pub async fn delete_user_account(
 690   person_id: PersonId,
 691   pool: &DbPool,
 692   settings: &Settings,
 693   client: &ClientWithMiddleware,
 694 ) -> Result<(), LemmyError> {
 695   // Delete their images
 696   let person = blocking(pool, move |conn| Person::read(conn, person_id)).await??;
 697   if let Some(avatar) = person.avatar {
 698     purge_image_from_pictrs(client, settings, &avatar)
 699       .await
 700       .ok();
 701   }
 702   if let Some(banner) = person.banner {
 703     purge_image_from_pictrs(client, settings, &banner)
 704       .await
 705       .ok();
 706   }
 707   // No need to update avatar and banner, those are handled in Person::delete_account
 708
 709   // Comments
 710   let permadelete = move |conn: &mut _| Comment::permadelete_for_creator(conn, person_id);
 711   blocking(pool, permadelete)
 712     .await?
 713     .map_err(|e| LemmyError::from_error_message(e, "couldnt_update_comment"))?;
 714
 715   // Posts
 716   let permadelete = move |conn: &mut _| Post::permadelete_for_creator(conn, person_id);
 717   blocking(pool, permadelete)
 718     .await?
 719     .map_err(|e| LemmyError::from_error_message(e, "couldnt_update_post"))?;
 720
 721   // Purge image posts
 722   purge_image_posts_for_person(person_id, pool, settings, client).await?;
 723
 724   blocking(pool, move |conn| Person::delete_account(conn, person_id)).await??;
 725
 726   Ok(())
 727 }
 728
 729 pub async fn listing_type_with_site_default(
 730   listing_type: Option<ListingType>,
 731   pool: &DbPool,
 732 ) -> Result<ListingType, LemmyError> {
 733   Ok(match listing_type {
 734     Some(l) => l,
 735     None => {
 736       let site = blocking(pool, Site::read_local_site).await??;
 737       ListingType::from_str(&site.default_post_listing_type)?
 738     }
 739   })
 740 }