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