crates/api/src/local_user.rs

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