crates/api/src/local_user.rs

   1 use crate::{captcha_espeak_wav_base64, Perform};
   2 use actix_web::web::Data;
   3 use anyhow::Context;
   4 use bcrypt::verify;
   5 use captcha::{gen, Difficulty};
   6 use chrono::Duration;
   7 use lemmy_api_common::{
   8   blocking,
   9   collect_moderated_communities,
  10   community::{GetFollowedCommunities, GetFollowedCommunitiesResponse},
  11   get_local_user_view_from_jwt,
  12   is_admin,
  13   password_length_check,
  14   person::*,
  15 };
  16 use lemmy_db_queries::{
  17   diesel_option_overwrite,
  18   diesel_option_overwrite_to_url,
  19   source::{
  20     comment::Comment_,
  21     community::Community_,
  22     local_user::LocalUser_,
  23     password_reset_request::PasswordResetRequest_,
  24     person::Person_,
  25     person_mention::PersonMention_,
  26     post::Post_,
  27     private_message::PrivateMessage_,
  28   },
  29   Crud,
  30   SortType,
  31 };
  32 use lemmy_db_schema::{
  33   naive_now,
  34   source::{
  35     comment::Comment,
  36     community::*,
  37     local_user::{LocalUser, LocalUserForm},
  38     moderator::*,
  39     password_reset_request::*,
  40     person::*,
  41     person_mention::*,
  42     post::Post,
  43     private_message::PrivateMessage,
  44     site::*,
  45   },
  46 };
  47 use lemmy_db_views::{
  48   comment_report_view::CommentReportView,
  49   comment_view::CommentQueryBuilder,
  50   local_user_view::LocalUserView,
  51   post_report_view::PostReportView,
  52 };
  53 use lemmy_db_views_actor::{
  54   community_follower_view::CommunityFollowerView,
  55   person_mention_view::{PersonMentionQueryBuilder, PersonMentionView},
  56   person_view::PersonViewSafe,
  57 };
  58 use lemmy_utils::{
  59   claims::Claims,
  60   email::send_email,
  61   location_info,
  62   settings::structs::Settings,
  63   utils::{generate_random_string, is_valid_preferred_username, naive_from_unix},
  64   ApiError,
  65   ConnectionId,
  66   LemmyError,
  67 };
  68 use lemmy_websocket::{
  69   messages::{CaptchaItem, SendAllMessage, SendUserRoomMessage},
  70   LemmyContext,
  71   UserOperation,
  72 };
  73 use std::str::FromStr;
  74
  75 #[async_trait::async_trait(?Send)]
  76 impl Perform for Login {
  77   type Response = LoginResponse;
  78
  79   async fn perform(
  80     &self,
  81     context: &Data<LemmyContext>,
  82     _websocket_id: Option<ConnectionId>,
  83   ) -> Result<LoginResponse, LemmyError> {
  84     let data: &Login = &self;
  85
  86     // Fetch that username / email
  87     let username_or_email = data.username_or_email.clone();
  88     let local_user_view = match blocking(context.pool(), move |conn| {
  89       LocalUserView::find_by_email_or_name(conn, &username_or_email)
  90     })
  91     .await?
  92     {
  93       Ok(uv) => uv,
  94       Err(_e) => return Err(ApiError::err("couldnt_find_that_username_or_email").into()),
  95     };
  96
  97     // Verify the password
  98     let valid: bool = verify(
  99       &data.password,
 100       &local_user_view.local_user.password_encrypted,
 101     )
 102     .unwrap_or(false);
 103     if !valid {
 104       return Err(ApiError::err("password_incorrect").into());
 105     }
 106
 107     // Return the jwt
 108     Ok(LoginResponse {
 109       jwt: Claims::jwt(local_user_view.local_user.id.0)?,
 110     })
 111   }
 112 }
 113
 114 #[async_trait::async_trait(?Send)]
 115 impl Perform for GetCaptcha {
 116   type Response = GetCaptchaResponse;
 117
 118   async fn perform(
 119     &self,
 120     context: &Data<LemmyContext>,
 121     _websocket_id: Option<ConnectionId>,
 122   ) -> Result<Self::Response, LemmyError> {
 123     let captcha_settings = Settings::get().captcha();
 124
 125     if !captcha_settings.enabled {
 126       return Ok(GetCaptchaResponse { ok: None });
 127     }
 128
 129     let captcha = match captcha_settings.difficulty.as_str() {
 130       "easy" => gen(Difficulty::Easy),
 131       "medium" => gen(Difficulty::Medium),
 132       "hard" => gen(Difficulty::Hard),
 133       _ => gen(Difficulty::Medium),
 134     };
 135
 136     let answer = captcha.chars_as_string();
 137
 138     let png_byte_array = captcha.as_png().expect("failed to generate captcha");
 139
 140     let png = base64::encode(png_byte_array);
 141
 142     let uuid = uuid::Uuid::new_v4().to_string();
 143
 144     let wav = captcha_espeak_wav_base64(&answer).ok();
 145
 146     let captcha_item = CaptchaItem {
 147       answer,
 148       uuid: uuid.to_owned(),
 149       expires: naive_now() + Duration::minutes(10), // expires in 10 minutes
 150     };
 151
 152     // Stores the captcha item on the queue
 153     context.chat_server().do_send(captcha_item);
 154
 155     Ok(GetCaptchaResponse {
 156       ok: Some(CaptchaResponse { png, wav, uuid }),
 157     })
 158   }
 159 }
 160
 161 #[async_trait::async_trait(?Send)]
 162 impl Perform for SaveUserSettings {
 163   type Response = LoginResponse;
 164
 165   async fn perform(
 166     &self,
 167     context: &Data<LemmyContext>,
 168     _websocket_id: Option<ConnectionId>,
 169   ) -> Result<LoginResponse, LemmyError> {
 170     let data: &SaveUserSettings = &self;
 171     let local_user_view = get_local_user_view_from_jwt(&data.auth, context.pool()).await?;
 172
 173     let avatar = diesel_option_overwrite_to_url(&data.avatar)?;
 174     let banner = diesel_option_overwrite_to_url(&data.banner)?;
 175     let email = diesel_option_overwrite(&data.email);
 176     let bio = diesel_option_overwrite(&data.bio);
 177     let preferred_username = diesel_option_overwrite(&data.preferred_username);
 178     let matrix_user_id = diesel_option_overwrite(&data.matrix_user_id);
 179
 180     if let Some(Some(bio)) = &bio {
 181       if bio.chars().count() > 300 {
 182         return Err(ApiError::err("bio_length_overflow").into());
 183       }
 184     }
 185
 186     if let Some(Some(preferred_username)) = &preferred_username {
 187       if !is_valid_preferred_username(preferred_username.trim()) {
 188         return Err(ApiError::err("invalid_username").into());
 189       }
 190     }
 191
 192     let local_user_id = local_user_view.local_user.id;
 193     let person_id = local_user_view.person.id;
 194     let default_listing_type = data.default_listing_type;
 195     let default_sort_type = data.default_sort_type;
 196     let password_encrypted = local_user_view.local_user.password_encrypted;
 197
 198     let person_form = PersonForm {
 199       name: local_user_view.person.name,
 200       avatar,
 201       banner,
 202       inbox_url: None,
 203       preferred_username,
 204       published: None,
 205       updated: Some(naive_now()),
 206       banned: None,
 207       deleted: None,
 208       actor_id: None,
 209       bio,
 210       local: None,
 211       admin: None,
 212       private_key: None,
 213       public_key: None,
 214       last_refreshed_at: None,
 215       shared_inbox_url: None,
 216       matrix_user_id,
 217     };
 218
 219     let person_res = blocking(context.pool(), move |conn| {
 220       Person::update(conn, person_id, &person_form)
 221     })
 222     .await?;
 223     let _updated_person: Person = match person_res {
 224       Ok(p) => p,
 225       Err(_) => {
 226         return Err(ApiError::err("user_already_exists").into());
 227       }
 228     };
 229
 230     let local_user_form = LocalUserForm {
 231       person_id,
 232       email,
 233       password_encrypted,
 234       show_nsfw: data.show_nsfw,
 235       theme: data.theme.to_owned(),
 236       default_sort_type,
 237       default_listing_type,
 238       lang: data.lang.to_owned(),
 239       show_avatars: data.show_avatars,
 240       send_notifications_to_email: data.send_notifications_to_email,
 241     };
 242
 243     let local_user_res = blocking(context.pool(), move |conn| {
 244       LocalUser::update(conn, local_user_id, &local_user_form)
 245     })
 246     .await?;
 247     let updated_local_user = match local_user_res {
 248       Ok(u) => u,
 249       Err(e) => {
 250         let err_type = if e.to_string()
 251           == "duplicate key value violates unique constraint \"local_user_email_key\""
 252         {
 253           "email_already_exists"
 254         } else {
 255           "user_already_exists"
 256         };
 257
 258         return Err(ApiError::err(err_type).into());
 259       }
 260     };
 261
 262     // Return the jwt
 263     Ok(LoginResponse {
 264       jwt: Claims::jwt(updated_local_user.id.0)?,
 265     })
 266   }
 267 }
 268
 269 #[async_trait::async_trait(?Send)]
 270 impl Perform for ChangePassword {
 271   type Response = LoginResponse;
 272
 273   async fn perform(
 274     &self,
 275     context: &Data<LemmyContext>,
 276     _websocket_id: Option<ConnectionId>,
 277   ) -> Result<LoginResponse, LemmyError> {
 278     let data: &ChangePassword = &self;
 279     let local_user_view = get_local_user_view_from_jwt(&data.auth, context.pool()).await?;
 280
 281     password_length_check(&data.new_password)?;
 282
 283     // Make sure passwords match
 284     if data.new_password != data.new_password_verify {
 285       return Err(ApiError::err("passwords_dont_match").into());
 286     }
 287
 288     // Check the old password
 289     let valid: bool = verify(
 290       &data.old_password,
 291       &local_user_view.local_user.password_encrypted,
 292     )
 293     .unwrap_or(false);
 294     if !valid {
 295       return Err(ApiError::err("password_incorrect").into());
 296     }
 297
 298     let local_user_id = local_user_view.local_user.id;
 299     let new_password = data.new_password.to_owned();
 300     let updated_local_user = blocking(context.pool(), move |conn| {
 301       LocalUser::update_password(conn, local_user_id, &new_password)
 302     })
 303     .await??;
 304
 305     // Return the jwt
 306     Ok(LoginResponse {
 307       jwt: Claims::jwt(updated_local_user.id.0)?,
 308     })
 309   }
 310 }
 311
 312 #[async_trait::async_trait(?Send)]
 313 impl Perform for AddAdmin {
 314   type Response = AddAdminResponse;
 315
 316   async fn perform(
 317     &self,
 318     context: &Data<LemmyContext>,
 319     websocket_id: Option<ConnectionId>,
 320   ) -> Result<AddAdminResponse, LemmyError> {
 321     let data: &AddAdmin = &self;
 322     let local_user_view = get_local_user_view_from_jwt(&data.auth, context.pool()).await?;
 323
 324     // Make sure user is an admin
 325     is_admin(&local_user_view)?;
 326
 327     let added = data.added;
 328     let added_person_id = data.person_id;
 329     let added_admin = match blocking(context.pool(), move |conn| {
 330       Person::add_admin(conn, added_person_id, added)
 331     })
 332     .await?
 333     {
 334       Ok(a) => a,
 335       Err(_) => {
 336         return Err(ApiError::err("couldnt_update_user").into());
 337       }
 338     };
 339
 340     // Mod tables
 341     let form = ModAddForm {
 342       mod_person_id: local_user_view.person.id,
 343       other_person_id: added_admin.id,
 344       removed: Some(!data.added),
 345     };
 346
 347     blocking(context.pool(), move |conn| ModAdd::create(conn, &form)).await??;
 348
 349     let site_creator_id = blocking(context.pool(), move |conn| {
 350       Site::read(conn, 1).map(|s| s.creator_id)
 351     })
 352     .await??;
 353
 354     let mut admins = blocking(context.pool(), move |conn| PersonViewSafe::admins(conn)).await??;
 355     let creator_index = admins
 356       .iter()
 357       .position(|r| r.person.id == site_creator_id)
 358       .context(location_info!())?;
 359     let creator_person = admins.remove(creator_index);
 360     admins.insert(0, creator_person);
 361
 362     let res = AddAdminResponse { admins };
 363
 364     context.chat_server().do_send(SendAllMessage {
 365       op: UserOperation::AddAdmin,
 366       response: res.clone(),
 367       websocket_id,
 368     });
 369
 370     Ok(res)
 371   }
 372 }
 373
 374 #[async_trait::async_trait(?Send)]
 375 impl Perform for BanPerson {
 376   type Response = BanPersonResponse;
 377
 378   async fn perform(
 379     &self,
 380     context: &Data<LemmyContext>,
 381     websocket_id: Option<ConnectionId>,
 382   ) -> Result<BanPersonResponse, LemmyError> {
 383     let data: &BanPerson = &self;
 384     let local_user_view = get_local_user_view_from_jwt(&data.auth, context.pool()).await?;
 385
 386     // Make sure user is an admin
 387     is_admin(&local_user_view)?;
 388
 389     let ban = data.ban;
 390     let banned_person_id = data.person_id;
 391     let ban_person = move |conn: &'_ _| Person::ban_person(conn, banned_person_id, ban);
 392     if blocking(context.pool(), ban_person).await?.is_err() {
 393       return Err(ApiError::err("couldnt_update_user").into());
 394     }
 395
 396     // Remove their data if that's desired
 397     if data.remove_data {
 398       // Posts
 399       blocking(context.pool(), move |conn: &'_ _| {
 400         Post::update_removed_for_creator(conn, banned_person_id, None, true)
 401       })
 402       .await??;
 403
 404       // Communities
 405       blocking(context.pool(), move |conn: &'_ _| {
 406         Community::update_removed_for_creator(conn, banned_person_id, true)
 407       })
 408       .await??;
 409
 410       // Comments
 411       blocking(context.pool(), move |conn: &'_ _| {
 412         Comment::update_removed_for_creator(conn, banned_person_id, true)
 413       })
 414       .await??;
 415     }
 416
 417     // Mod tables
 418     let expires = data.expires.map(naive_from_unix);
 419
 420     let form = ModBanForm {
 421       mod_person_id: local_user_view.person.id,
 422       other_person_id: data.person_id,
 423       reason: data.reason.to_owned(),
 424       banned: Some(data.ban),
 425       expires,
 426     };
 427
 428     blocking(context.pool(), move |conn| ModBan::create(conn, &form)).await??;
 429
 430     let person_id = data.person_id;
 431     let person_view = blocking(context.pool(), move |conn| {
 432       PersonViewSafe::read(conn, person_id)
 433     })
 434     .await??;
 435
 436     let res = BanPersonResponse {
 437       person_view,
 438       banned: data.ban,
 439     };
 440
 441     context.chat_server().do_send(SendAllMessage {
 442       op: UserOperation::BanPerson,
 443       response: res.clone(),
 444       websocket_id,
 445     });
 446
 447     Ok(res)
 448   }
 449 }
 450
 451 #[async_trait::async_trait(?Send)]
 452 impl Perform for GetReplies {
 453   type Response = GetRepliesResponse;
 454
 455   async fn perform(
 456     &self,
 457     context: &Data<LemmyContext>,
 458     _websocket_id: Option<ConnectionId>,
 459   ) -> Result<GetRepliesResponse, LemmyError> {
 460     let data: &GetReplies = &self;
 461     let local_user_view = get_local_user_view_from_jwt(&data.auth, context.pool()).await?;
 462
 463     let sort = SortType::from_str(&data.sort)?;
 464
 465     let page = data.page;
 466     let limit = data.limit;
 467     let unread_only = data.unread_only;
 468     let person_id = local_user_view.person.id;
 469     let replies = blocking(context.pool(), move |conn| {
 470       CommentQueryBuilder::create(conn)
 471         .sort(&sort)
 472         .unread_only(unread_only)
 473         .recipient_id(person_id)
 474         .my_person_id(person_id)
 475         .page(page)
 476         .limit(limit)
 477         .list()
 478     })
 479     .await??;
 480
 481     Ok(GetRepliesResponse { replies })
 482   }
 483 }
 484
 485 #[async_trait::async_trait(?Send)]
 486 impl Perform for GetPersonMentions {
 487   type Response = GetPersonMentionsResponse;
 488
 489   async fn perform(
 490     &self,
 491     context: &Data<LemmyContext>,
 492     _websocket_id: Option<ConnectionId>,
 493   ) -> Result<GetPersonMentionsResponse, LemmyError> {
 494     let data: &GetPersonMentions = &self;
 495     let local_user_view = get_local_user_view_from_jwt(&data.auth, context.pool()).await?;
 496
 497     let sort = SortType::from_str(&data.sort)?;
 498
 499     let page = data.page;
 500     let limit = data.limit;
 501     let unread_only = data.unread_only;
 502     let person_id = local_user_view.person.id;
 503     let mentions = blocking(context.pool(), move |conn| {
 504       PersonMentionQueryBuilder::create(conn)
 505         .recipient_id(person_id)
 506         .my_person_id(person_id)
 507         .sort(&sort)
 508         .unread_only(unread_only)
 509         .page(page)
 510         .limit(limit)
 511         .list()
 512     })
 513     .await??;
 514
 515     Ok(GetPersonMentionsResponse { mentions })
 516   }
 517 }
 518
 519 #[async_trait::async_trait(?Send)]
 520 impl Perform for MarkPersonMentionAsRead {
 521   type Response = PersonMentionResponse;
 522
 523   async fn perform(
 524     &self,
 525     context: &Data<LemmyContext>,
 526     _websocket_id: Option<ConnectionId>,
 527   ) -> Result<PersonMentionResponse, LemmyError> {
 528     let data: &MarkPersonMentionAsRead = &self;
 529     let local_user_view = get_local_user_view_from_jwt(&data.auth, context.pool()).await?;
 530
 531     let person_mention_id = data.person_mention_id;
 532     let read_person_mention = blocking(context.pool(), move |conn| {
 533       PersonMention::read(conn, person_mention_id)
 534     })
 535     .await??;
 536
 537     if local_user_view.person.id != read_person_mention.recipient_id {
 538       return Err(ApiError::err("couldnt_update_comment").into());
 539     }
 540
 541     let person_mention_id = read_person_mention.id;
 542     let read = data.read;
 543     let update_mention =
 544       move |conn: &'_ _| PersonMention::update_read(conn, person_mention_id, read);
 545     if blocking(context.pool(), update_mention).await?.is_err() {
 546       return Err(ApiError::err("couldnt_update_comment").into());
 547     };
 548
 549     let person_mention_id = read_person_mention.id;
 550     let person_id = local_user_view.person.id;
 551     let person_mention_view = blocking(context.pool(), move |conn| {
 552       PersonMentionView::read(conn, person_mention_id, Some(person_id))
 553     })
 554     .await??;
 555
 556     Ok(PersonMentionResponse {
 557       person_mention_view,
 558     })
 559   }
 560 }
 561
 562 #[async_trait::async_trait(?Send)]
 563 impl Perform for MarkAllAsRead {
 564   type Response = GetRepliesResponse;
 565
 566   async fn perform(
 567     &self,
 568     context: &Data<LemmyContext>,
 569     _websocket_id: Option<ConnectionId>,
 570   ) -> Result<GetRepliesResponse, LemmyError> {
 571     let data: &MarkAllAsRead = &self;
 572     let local_user_view = get_local_user_view_from_jwt(&data.auth, context.pool()).await?;
 573
 574     let person_id = local_user_view.person.id;
 575     let replies = blocking(context.pool(), move |conn| {
 576       CommentQueryBuilder::create(conn)
 577         .my_person_id(person_id)
 578         .recipient_id(person_id)
 579         .unread_only(true)
 580         .page(1)
 581         .limit(999)
 582         .list()
 583     })
 584     .await??;
 585
 586     // TODO: this should probably be a bulk operation
 587     // Not easy to do as a bulk operation,
 588     // because recipient_id isn't in the comment table
 589     for comment_view in &replies {
 590       let reply_id = comment_view.comment.id;
 591       let mark_as_read = move |conn: &'_ _| Comment::update_read(conn, reply_id, true);
 592       if blocking(context.pool(), mark_as_read).await?.is_err() {
 593         return Err(ApiError::err("couldnt_update_comment").into());
 594       }
 595     }
 596
 597     // Mark all user mentions as read
 598     let update_person_mentions =
 599       move |conn: &'_ _| PersonMention::mark_all_as_read(conn, person_id);
 600     if blocking(context.pool(), update_person_mentions)
 601       .await?
 602       .is_err()
 603     {
 604       return Err(ApiError::err("couldnt_update_comment").into());
 605     }
 606
 607     // Mark all private_messages as read
 608     let update_pm = move |conn: &'_ _| PrivateMessage::mark_all_as_read(conn, person_id);
 609     if blocking(context.pool(), update_pm).await?.is_err() {
 610       return Err(ApiError::err("couldnt_update_private_message").into());
 611     }
 612
 613     Ok(GetRepliesResponse { replies: vec![] })
 614   }
 615 }
 616
 617 #[async_trait::async_trait(?Send)]
 618 impl Perform for PasswordReset {
 619   type Response = PasswordResetResponse;
 620
 621   async fn perform(
 622     &self,
 623     context: &Data<LemmyContext>,
 624     _websocket_id: Option<ConnectionId>,
 625   ) -> Result<PasswordResetResponse, LemmyError> {
 626     let data: &PasswordReset = &self;
 627
 628     // Fetch that email
 629     let email = data.email.clone();
 630     let local_user_view = match blocking(context.pool(), move |conn| {
 631       LocalUserView::find_by_email(conn, &email)
 632     })
 633     .await?
 634     {
 635       Ok(lu) => lu,
 636       Err(_e) => return Err(ApiError::err("couldnt_find_that_username_or_email").into()),
 637     };
 638
 639     // Generate a random token
 640     let token = generate_random_string();
 641
 642     // Insert the row
 643     let token2 = token.clone();
 644     let local_user_id = local_user_view.local_user.id;
 645     blocking(context.pool(), move |conn| {
 646       PasswordResetRequest::create_token(conn, local_user_id, &token2)
 647     })
 648     .await??;
 649
 650     // Email the pure token to the user.
 651     // TODO no i18n support here.
 652     let email = &local_user_view.local_user.email.expect("email");
 653     let subject = &format!("Password reset for {}", local_user_view.person.name);
 654     let hostname = &Settings::get().get_protocol_and_hostname();
 655     let html = &format!("<h1>Password Reset Request for {}</h1><br><a href={}/password_change/{}>Click here to reset your password</a>", local_user_view.person.name, hostname, &token);
 656     match send_email(subject, email, &local_user_view.person.name, html) {
 657       Ok(_o) => _o,
 658       Err(_e) => return Err(ApiError::err(&_e).into()),
 659     };
 660
 661     Ok(PasswordResetResponse {})
 662   }
 663 }
 664
 665 #[async_trait::async_trait(?Send)]
 666 impl Perform for PasswordChange {
 667   type Response = LoginResponse;
 668
 669   async fn perform(
 670     &self,
 671     context: &Data<LemmyContext>,
 672     _websocket_id: Option<ConnectionId>,
 673   ) -> Result<LoginResponse, LemmyError> {
 674     let data: &PasswordChange = &self;
 675
 676     // Fetch the user_id from the token
 677     let token = data.token.clone();
 678     let local_user_id = blocking(context.pool(), move |conn| {
 679       PasswordResetRequest::read_from_token(conn, &token).map(|p| p.local_user_id)
 680     })
 681     .await??;
 682
 683     password_length_check(&data.password)?;
 684
 685     // Make sure passwords match
 686     if data.password != data.password_verify {
 687       return Err(ApiError::err("passwords_dont_match").into());
 688     }
 689
 690     // Update the user with the new password
 691     let password = data.password.clone();
 692     let updated_local_user = match blocking(context.pool(), move |conn| {
 693       LocalUser::update_password(conn, local_user_id, &password)
 694     })
 695     .await?
 696     {
 697       Ok(u) => u,
 698       Err(_e) => return Err(ApiError::err("couldnt_update_user").into()),
 699     };
 700
 701     // Return the jwt
 702     Ok(LoginResponse {
 703       jwt: Claims::jwt(updated_local_user.id.0)?,
 704     })
 705   }
 706 }
 707
 708 #[async_trait::async_trait(?Send)]
 709 impl Perform for GetReportCount {
 710   type Response = GetReportCountResponse;
 711
 712   async fn perform(
 713     &self,
 714     context: &Data<LemmyContext>,
 715     websocket_id: Option<ConnectionId>,
 716   ) -> Result<GetReportCountResponse, LemmyError> {
 717     let data: &GetReportCount = &self;
 718     let local_user_view = get_local_user_view_from_jwt(&data.auth, context.pool()).await?;
 719
 720     let person_id = local_user_view.person.id;
 721     let community_id = data.community;
 722     let community_ids =
 723       collect_moderated_communities(person_id, community_id, context.pool()).await?;
 724
 725     let res = {
 726       if community_ids.is_empty() {
 727         GetReportCountResponse {
 728           community: None,
 729           comment_reports: 0,
 730           post_reports: 0,
 731         }
 732       } else {
 733         let ids = community_ids.clone();
 734         let comment_reports = blocking(context.pool(), move |conn| {
 735           CommentReportView::get_report_count(conn, &ids)
 736         })
 737         .await??;
 738
 739         let ids = community_ids.clone();
 740         let post_reports = blocking(context.pool(), move |conn| {
 741           PostReportView::get_report_count(conn, &ids)
 742         })
 743         .await??;
 744
 745         GetReportCountResponse {
 746           community: data.community,
 747           comment_reports,
 748           post_reports,
 749         }
 750       }
 751     };
 752
 753     context.chat_server().do_send(SendUserRoomMessage {
 754       op: UserOperation::GetReportCount,
 755       response: res.clone(),
 756       local_recipient_id: local_user_view.local_user.id,
 757       websocket_id,
 758     });
 759
 760     Ok(res)
 761   }
 762 }
 763
 764 #[async_trait::async_trait(?Send)]
 765 impl Perform for GetFollowedCommunities {
 766   type Response = GetFollowedCommunitiesResponse;
 767
 768   async fn perform(
 769     &self,
 770     context: &Data<LemmyContext>,
 771     _websocket_id: Option<ConnectionId>,
 772   ) -> Result<GetFollowedCommunitiesResponse, LemmyError> {
 773     let data: &GetFollowedCommunities = &self;
 774     let local_user_view = get_local_user_view_from_jwt(&data.auth, context.pool()).await?;
 775
 776     let person_id = local_user_view.person.id;
 777     let communities = match blocking(context.pool(), move |conn| {
 778       CommunityFollowerView::for_person(conn, person_id)
 779     })
 780     .await?
 781     {
 782       Ok(communities) => communities,
 783       _ => return Err(ApiError::err("system_err_login").into()),
 784     };
 785
 786     // Return the jwt
 787     Ok(GetFollowedCommunitiesResponse { communities })
 788   }
 789 }