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