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   from_opt_str_to_opt_enum,
  20   source::{
  21     comment::Comment_,
  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     local_user::{LocalUser, LocalUserForm},
  37     moderator::*,
  38     password_reset_request::*,
  39     person::*,
  40     person_mention::*,
  41     post::Post,
  42     private_message::PrivateMessage,
  43     site::*,
  44   },
  45 };
  46 use lemmy_db_views::{
  47   comment_report_view::CommentReportView,
  48   comment_view::CommentQueryBuilder,
  49   local_user_view::LocalUserView,
  50   post_report_view::PostReportView,
  51 };
  52 use lemmy_db_views_actor::{
  53   community_follower_view::CommunityFollowerView,
  54   person_mention_view::{PersonMentionQueryBuilder, PersonMentionView},
  55   person_view::PersonViewSafe,
  56 };
  57 use lemmy_utils::{
  58   claims::Claims,
  59   email::send_email,
  60   location_info,
  61   settings::structs::Settings,
  62   utils::{generate_random_string, is_valid_display_name, is_valid_matrix_id, naive_from_unix},
  63   ApiError,
  64   ConnectionId,
  65   LemmyError,
  66 };
  67 use lemmy_websocket::{
  68   messages::{CaptchaItem, SendAllMessage, SendUserRoomMessage},
  69   LemmyContext,
  70   UserOperation,
  71 };
  72
  73 #[async_trait::async_trait(?Send)]
  74 impl Perform for Login {
  75   type Response = LoginResponse;
  76
  77   async fn perform(
  78     &self,
  79     context: &Data<LemmyContext>,
  80     _websocket_id: Option<ConnectionId>,
  81   ) -> Result<LoginResponse, LemmyError> {
  82     let data: &Login = self;
  83
  84     // Fetch that username / email
  85     let username_or_email = data.username_or_email.clone();
  86     let local_user_view = blocking(context.pool(), move |conn| {
  87       LocalUserView::find_by_email_or_name(conn, &username_or_email)
  88     })
  89     .await?
  90     .map_err(|_| ApiError::err("couldnt_find_that_username_or_email"))?;
  91
  92     // Verify the password
  93     let valid: bool = verify(
  94       &data.password,
  95       &local_user_view.local_user.password_encrypted,
  96     )
  97     .unwrap_or(false);
  98     if !valid {
  99       return Err(ApiError::err("password_incorrect").into());
 100     }
 101
 102     // Return the jwt
 103     Ok(LoginResponse {
 104       jwt: Claims::jwt(local_user_view.local_user.id.0)?,
 105     })
 106   }
 107 }
 108
 109 #[async_trait::async_trait(?Send)]
 110 impl Perform for GetCaptcha {
 111   type Response = GetCaptchaResponse;
 112
 113   async fn perform(
 114     &self,
 115     context: &Data<LemmyContext>,
 116     _websocket_id: Option<ConnectionId>,
 117   ) -> Result<Self::Response, LemmyError> {
 118     let captcha_settings = Settings::get().captcha;
 119
 120     if !captcha_settings.enabled {
 121       return Ok(GetCaptchaResponse { ok: None });
 122     }
 123
 124     let captcha = match captcha_settings.difficulty.as_str() {
 125       "easy" => gen(Difficulty::Easy),
 126       "medium" => gen(Difficulty::Medium),
 127       "hard" => gen(Difficulty::Hard),
 128       _ => gen(Difficulty::Medium),
 129     };
 130
 131     let answer = captcha.chars_as_string();
 132
 133     let png = captcha.as_base64().expect("failed to generate captcha");
 134
 135     let uuid = uuid::Uuid::new_v4().to_string();
 136
 137     let wav = captcha_as_wav_base64(&captcha);
 138
 139     let captcha_item = CaptchaItem {
 140       answer,
 141       uuid: uuid.to_owned(),
 142       expires: naive_now() + Duration::minutes(10), // expires in 10 minutes
 143     };
 144
 145     // Stores the captcha item on the queue
 146     context.chat_server().do_send(captcha_item);
 147
 148     Ok(GetCaptchaResponse {
 149       ok: Some(CaptchaResponse { png, wav, uuid }),
 150     })
 151   }
 152 }
 153
 154 #[async_trait::async_trait(?Send)]
 155 impl Perform for SaveUserSettings {
 156   type Response = LoginResponse;
 157
 158   async fn perform(
 159     &self,
 160     context: &Data<LemmyContext>,
 161     _websocket_id: Option<ConnectionId>,
 162   ) -> Result<LoginResponse, LemmyError> {
 163     let data: &SaveUserSettings = self;
 164     let local_user_view = get_local_user_view_from_jwt(&data.auth, context.pool()).await?;
 165
 166     let avatar = diesel_option_overwrite_to_url(&data.avatar)?;
 167     let banner = diesel_option_overwrite_to_url(&data.banner)?;
 168     let email = diesel_option_overwrite(&data.email);
 169     let bio = diesel_option_overwrite(&data.bio);
 170     let display_name = diesel_option_overwrite(&data.display_name);
 171     let matrix_user_id = diesel_option_overwrite(&data.matrix_user_id);
 172     let bot_account = data.bot_account;
 173
 174     if let Some(Some(bio)) = &bio {
 175       if bio.chars().count() > 300 {
 176         return Err(ApiError::err("bio_length_overflow").into());
 177       }
 178     }
 179
 180     if let Some(Some(display_name)) = &display_name {
 181       if !is_valid_display_name(display_name.trim()) {
 182         return Err(ApiError::err("invalid_username").into());
 183       }
 184     }
 185
 186     if let Some(Some(matrix_user_id)) = &matrix_user_id {
 187       if !is_valid_matrix_id(matrix_user_id) {
 188         return Err(ApiError::err("invalid_matrix_id").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       display_name,
 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       bot_account,
 218     };
 219
 220     let person_res = blocking(context.pool(), move |conn| {
 221       Person::update(conn, person_id, &person_form)
 222     })
 223     .await?;
 224     let _updated_person: Person = match person_res {
 225       Ok(p) => p,
 226       Err(_) => {
 227         return Err(ApiError::err("user_already_exists").into());
 228       }
 229     };
 230
 231     let local_user_form = LocalUserForm {
 232       person_id,
 233       email,
 234       password_encrypted,
 235       show_nsfw: data.show_nsfw,
 236       show_bot_accounts: data.show_bot_accounts,
 237       show_scores: data.show_scores,
 238       theme: data.theme.to_owned(),
 239       default_sort_type,
 240       default_listing_type,
 241       lang: data.lang.to_owned(),
 242       show_avatars: data.show_avatars,
 243       show_read_posts: data.show_read_posts,
 244       show_new_post_notifs: data.show_new_post_notifs,
 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.unwrap_or(false) {
 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       // Remove all communities where they're the top mod
 411       // TODO couldn't get group by's working in diesel,
 412       // for now, remove the communities manually
 413
 414       // Comments
 415       blocking(context.pool(), move |conn: &'_ _| {
 416         Comment::update_removed_for_creator(conn, banned_person_id, true)
 417       })
 418       .await??;
 419     }
 420
 421     // Mod tables
 422     let expires = data.expires.map(naive_from_unix);
 423
 424     let form = ModBanForm {
 425       mod_person_id: local_user_view.person.id,
 426       other_person_id: data.person_id,
 427       reason: data.reason.to_owned(),
 428       banned: Some(data.ban),
 429       expires,
 430     };
 431
 432     blocking(context.pool(), move |conn| ModBan::create(conn, &form)).await??;
 433
 434     let person_id = data.person_id;
 435     let person_view = blocking(context.pool(), move |conn| {
 436       PersonViewSafe::read(conn, person_id)
 437     })
 438     .await??;
 439
 440     let res = BanPersonResponse {
 441       person_view,
 442       banned: data.ban,
 443     };
 444
 445     context.chat_server().do_send(SendAllMessage {
 446       op: UserOperation::BanPerson,
 447       response: res.clone(),
 448       websocket_id,
 449     });
 450
 451     Ok(res)
 452   }
 453 }
 454
 455 #[async_trait::async_trait(?Send)]
 456 impl Perform for GetReplies {
 457   type Response = GetRepliesResponse;
 458
 459   async fn perform(
 460     &self,
 461     context: &Data<LemmyContext>,
 462     _websocket_id: Option<ConnectionId>,
 463   ) -> Result<GetRepliesResponse, LemmyError> {
 464     let data: &GetReplies = self;
 465     let local_user_view = get_local_user_view_from_jwt(&data.auth, context.pool()).await?;
 466
 467     let sort: Option<SortType> = from_opt_str_to_opt_enum(&data.sort);
 468
 469     let page = data.page;
 470     let limit = data.limit;
 471     let unread_only = data.unread_only;
 472     let person_id = local_user_view.person.id;
 473     let show_bot_accounts = local_user_view.local_user.show_bot_accounts;
 474
 475     let replies = blocking(context.pool(), move |conn| {
 476       CommentQueryBuilder::create(conn)
 477         .sort(sort)
 478         .unread_only(unread_only)
 479         .recipient_id(person_id)
 480         .show_bot_accounts(show_bot_accounts)
 481         .my_person_id(person_id)
 482         .page(page)
 483         .limit(limit)
 484         .list()
 485     })
 486     .await??;
 487
 488     Ok(GetRepliesResponse { replies })
 489   }
 490 }
 491
 492 #[async_trait::async_trait(?Send)]
 493 impl Perform for GetPersonMentions {
 494   type Response = GetPersonMentionsResponse;
 495
 496   async fn perform(
 497     &self,
 498     context: &Data<LemmyContext>,
 499     _websocket_id: Option<ConnectionId>,
 500   ) -> Result<GetPersonMentionsResponse, LemmyError> {
 501     let data: &GetPersonMentions = self;
 502     let local_user_view = get_local_user_view_from_jwt(&data.auth, context.pool()).await?;
 503
 504     let sort: Option<SortType> = from_opt_str_to_opt_enum(&data.sort);
 505
 506     let page = data.page;
 507     let limit = data.limit;
 508     let unread_only = data.unread_only;
 509     let person_id = local_user_view.person.id;
 510     let mentions = blocking(context.pool(), move |conn| {
 511       PersonMentionQueryBuilder::create(conn)
 512         .recipient_id(person_id)
 513         .my_person_id(person_id)
 514         .sort(sort)
 515         .unread_only(unread_only)
 516         .page(page)
 517         .limit(limit)
 518         .list()
 519     })
 520     .await??;
 521
 522     Ok(GetPersonMentionsResponse { mentions })
 523   }
 524 }
 525
 526 #[async_trait::async_trait(?Send)]
 527 impl Perform for MarkPersonMentionAsRead {
 528   type Response = PersonMentionResponse;
 529
 530   async fn perform(
 531     &self,
 532     context: &Data<LemmyContext>,
 533     _websocket_id: Option<ConnectionId>,
 534   ) -> Result<PersonMentionResponse, LemmyError> {
 535     let data: &MarkPersonMentionAsRead = self;
 536     let local_user_view = get_local_user_view_from_jwt(&data.auth, context.pool()).await?;
 537
 538     let person_mention_id = data.person_mention_id;
 539     let read_person_mention = blocking(context.pool(), move |conn| {
 540       PersonMention::read(conn, person_mention_id)
 541     })
 542     .await??;
 543
 544     if local_user_view.person.id != read_person_mention.recipient_id {
 545       return Err(ApiError::err("couldnt_update_comment").into());
 546     }
 547
 548     let person_mention_id = read_person_mention.id;
 549     let read = data.read;
 550     let update_mention =
 551       move |conn: &'_ _| PersonMention::update_read(conn, person_mention_id, read);
 552     if blocking(context.pool(), update_mention).await?.is_err() {
 553       return Err(ApiError::err("couldnt_update_comment").into());
 554     };
 555
 556     let person_mention_id = read_person_mention.id;
 557     let person_id = local_user_view.person.id;
 558     let person_mention_view = blocking(context.pool(), move |conn| {
 559       PersonMentionView::read(conn, person_mention_id, Some(person_id))
 560     })
 561     .await??;
 562
 563     Ok(PersonMentionResponse {
 564       person_mention_view,
 565     })
 566   }
 567 }
 568
 569 #[async_trait::async_trait(?Send)]
 570 impl Perform for MarkAllAsRead {
 571   type Response = GetRepliesResponse;
 572
 573   async fn perform(
 574     &self,
 575     context: &Data<LemmyContext>,
 576     _websocket_id: Option<ConnectionId>,
 577   ) -> Result<GetRepliesResponse, LemmyError> {
 578     let data: &MarkAllAsRead = self;
 579     let local_user_view = get_local_user_view_from_jwt(&data.auth, context.pool()).await?;
 580
 581     let person_id = local_user_view.person.id;
 582     let replies = blocking(context.pool(), move |conn| {
 583       CommentQueryBuilder::create(conn)
 584         .my_person_id(person_id)
 585         .recipient_id(person_id)
 586         .unread_only(true)
 587         .page(1)
 588         .limit(999)
 589         .list()
 590     })
 591     .await??;
 592
 593     // TODO: this should probably be a bulk operation
 594     // Not easy to do as a bulk operation,
 595     // because recipient_id isn't in the comment table
 596     for comment_view in &replies {
 597       let reply_id = comment_view.comment.id;
 598       let mark_as_read = move |conn: &'_ _| Comment::update_read(conn, reply_id, true);
 599       if blocking(context.pool(), mark_as_read).await?.is_err() {
 600         return Err(ApiError::err("couldnt_update_comment").into());
 601       }
 602     }
 603
 604     // Mark all user mentions as read
 605     let update_person_mentions =
 606       move |conn: &'_ _| PersonMention::mark_all_as_read(conn, person_id);
 607     if blocking(context.pool(), update_person_mentions)
 608       .await?
 609       .is_err()
 610     {
 611       return Err(ApiError::err("couldnt_update_comment").into());
 612     }
 613
 614     // Mark all private_messages as read
 615     let update_pm = move |conn: &'_ _| PrivateMessage::mark_all_as_read(conn, person_id);
 616     if blocking(context.pool(), update_pm).await?.is_err() {
 617       return Err(ApiError::err("couldnt_update_private_message").into());
 618     }
 619
 620     Ok(GetRepliesResponse { replies: vec![] })
 621   }
 622 }
 623
 624 #[async_trait::async_trait(?Send)]
 625 impl Perform for PasswordReset {
 626   type Response = PasswordResetResponse;
 627
 628   async fn perform(
 629     &self,
 630     context: &Data<LemmyContext>,
 631     _websocket_id: Option<ConnectionId>,
 632   ) -> Result<PasswordResetResponse, LemmyError> {
 633     let data: &PasswordReset = self;
 634
 635     // Fetch that email
 636     let email = data.email.clone();
 637     let local_user_view = blocking(context.pool(), move |conn| {
 638       LocalUserView::find_by_email(conn, &email)
 639     })
 640     .await?
 641     .map_err(|_| ApiError::err("couldnt_find_that_username_or_email"))?;
 642
 643     // Generate a random token
 644     let token = generate_random_string();
 645
 646     // Insert the row
 647     let token2 = token.clone();
 648     let local_user_id = local_user_view.local_user.id;
 649     blocking(context.pool(), move |conn| {
 650       PasswordResetRequest::create_token(conn, local_user_id, &token2)
 651     })
 652     .await??;
 653
 654     // Email the pure token to the user.
 655     // TODO no i18n support here.
 656     let email = &local_user_view.local_user.email.expect("email");
 657     let subject = &format!("Password reset for {}", local_user_view.person.name);
 658     let hostname = &Settings::get().get_protocol_and_hostname();
 659     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);
 660     send_email(subject, email, &local_user_view.person.name, html)
 661       .map_err(|e| ApiError::err(&e))?;
 662
 663     Ok(PasswordResetResponse {})
 664   }
 665 }
 666
 667 #[async_trait::async_trait(?Send)]
 668 impl Perform for PasswordChange {
 669   type Response = LoginResponse;
 670
 671   async fn perform(
 672     &self,
 673     context: &Data<LemmyContext>,
 674     _websocket_id: Option<ConnectionId>,
 675   ) -> Result<LoginResponse, LemmyError> {
 676     let data: &PasswordChange = self;
 677
 678     // Fetch the user_id from the token
 679     let token = data.token.clone();
 680     let local_user_id = blocking(context.pool(), move |conn| {
 681       PasswordResetRequest::read_from_token(conn, &token).map(|p| p.local_user_id)
 682     })
 683     .await??;
 684
 685     password_length_check(&data.password)?;
 686
 687     // Make sure passwords match
 688     if data.password != data.password_verify {
 689       return Err(ApiError::err("passwords_dont_match").into());
 690     }
 691
 692     // Update the user with the new password
 693     let password = data.password.clone();
 694     let updated_local_user = blocking(context.pool(), move |conn| {
 695       LocalUser::update_password(conn, local_user_id, &password)
 696     })
 697     .await?
 698     .map_err(|_| ApiError::err("couldnt_update_user"))?;
 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 = blocking(context.pool(), move |conn| {
 777       CommunityFollowerView::for_person(conn, person_id)
 778     })
 779     .await?
 780     .map_err(|_| ApiError::err("system_err_login"))?;
 781
 782     // Return the jwt
 783     Ok(GetFollowedCommunitiesResponse { communities })
 784   }
 785 }