A first pass at user / community blocking. #426

LemmyNet · Nutomic · Aug 19, 2021 · May 9, 2021 · May 10, 2021 · Aug 4, 2021
commit 9e8a4807ece1f260b4a9856847713c580df8a1eb
@@ -4,6 +4,7 @@ use lemmy_api_common::{
   blocking,
   check_community_ban,
   check_downvotes_enabled,
+  check_person_block,
   comment::*,
   get_local_user_view_from_jwt,
 };
@@ -151,6 +152,13 @@ impl Perform for CreateCommentLike {
     )
     .await?;
 
+    check_person_block(
+      local_user_view.person.id,
+      orig_comment.get_recipient_id(),
+      context.pool(),
+    )
+    .await?;
+
     // Add parent user to recipients
     let recipient_id = orig_comment.get_recipient_id();
     if let Ok(local_recipient) = blocking(context.pool(), move |conn| {

@@ -18,13 +18,15 @@ use lemmy_apub::{
 use lemmy_db_queries::{
   source::{comment::Comment_, community::CommunityModerator_, post::Post_},
   Bannable,
+  Blockable,
   Crud,
   Followable,
   Joinable,
 };
 use lemmy_db_schema::source::{
   comment::Comment,
   community::*,
+  community_block::{CommunityBlock, CommunityBlockForm},
   moderator::*,
   person::Person,
   post::Post,
@@ -107,6 +109,48 @@ impl Perform for FollowCommunity {
   }
 }
 
+#[async_trait::async_trait(?Send)]
+impl Perform for BlockCommunity {
+  type Response = CommunityResponse;
+
+  async fn perform(
+    &self,
+    context: &Data<LemmyContext>,
+    _websocket_id: Option<ConnectionId>,
+  ) -> Result<CommunityResponse, LemmyError> {
+    let data: &BlockCommunity = &self;
+    let local_user_view = get_local_user_view_from_jwt(&data.auth, context.pool()).await?;
+
+    let community_id = data.community_id;
+    let person_id = local_user_view.person.id;
+    let community_block_form = CommunityBlockForm {
+      person_id,
+      community_id,
+    };
+
+    if data.block {
+      let block = move |conn: &'_ _| CommunityBlock::block(conn, &community_block_form);
+      if blocking(context.pool(), block).await?.is_err() {
+        return Err(ApiError::err("community_block_already_exists").into());
+      }
+    } else {
+      let unblock = move |conn: &'_ _| CommunityBlock::unblock(conn, &community_block_form);
+      if blocking(context.pool(), unblock).await?.is_err() {
+        return Err(ApiError::err("community_block_already_exists").into());
+      }
+    }
+
+    // TODO does any federated stuff need to be done here?
+
+    let community_view = blocking(context.pool(), move |conn| {
+      CommunityView::read(conn, community_id, Some(person_id))
+    })
+    .await??;
+
+    Ok(CommunityResponse { community_view })
+  }
+}
+
 #[async_trait::async_trait(?Send)]
 impl Perform for BanFromCommunity {
   type Response = BanFromCommunityResponse;

@@ -39,9 +39,15 @@ pub async fn match_websocket_operation(
     UserOperation::GetReplies => do_websocket_operation::<GetReplies>(context, id, op, data).await,
     UserOperation::AddAdmin => do_websocket_operation::<AddAdmin>(context, id, op, data).await,
     UserOperation::BanPerson => do_websocket_operation::<BanPerson>(context, id, op, data).await,
+    UserOperation::BlockPerson => {
+      do_websocket_operation::<BlockPerson>(context, id, op, data).await
+    }
     UserOperation::GetPersonMentions => {
       do_websocket_operation::<GetPersonMentions>(context, id, op, data).await
     }
+    UserOperation::GetBlockedPersons => {
+      do_websocket_operation::<GetBlockedPersons>(context, id, op, data).await
+    }
     UserOperation::MarkPersonMentionAsRead => {
       do_websocket_operation::<MarkPersonMentionAsRead>(context, id, op, data).await
     }
@@ -95,9 +101,15 @@ pub async fn match_websocket_operation(
     UserOperation::FollowCommunity => {
       do_websocket_operation::<FollowCommunity>(context, id, op, data).await
     }
+    UserOperation::BlockCommunity => {
+      do_websocket_operation::<BlockCommunity>(context, id, op, data).await
+    }
     UserOperation::GetFollowedCommunities => {
       do_websocket_operation::<GetFollowedCommunities>(context, id, op, data).await
     }
+    UserOperation::GetBlockedCommunities => {
+      do_websocket_operation::<GetBlockedCommunities>(context, id, op, data).await
+    }
     UserOperation::BanFromCommunity => {
       do_websocket_operation::<BanFromCommunity>(context, id, op, data).await
     }

@@ -7,7 +7,12 @@ use chrono::Duration;
 use lemmy_api_common::{
   blocking,
   collect_moderated_communities,
-  community::{GetFollowedCommunities, GetFollowedCommunitiesResponse},
+  community::{
+    GetBlockedCommunities,
+    GetBlockedCommunitiesResponse,
+    GetFollowedCommunities,
+    GetFollowedCommunitiesResponse,
+  },
   get_local_user_view_from_jwt,
   is_admin,
   password_length_check,
@@ -27,6 +32,7 @@ use lemmy_db_queries::{
     post::Post_,
     private_message::PrivateMessage_,
   },
+  Blockable,
   Crud,
   SortType,
 };
@@ -39,6 +45,7 @@ use lemmy_db_schema::{
     moderator::*,
     password_reset_request::*,
     person::*,
+    person_block::{PersonBlock, PersonBlockForm},
     person_mention::*,
     post::Post,
     private_message::PrivateMessage,
@@ -52,8 +59,10 @@ use lemmy_db_views::{
   post_report_view::PostReportView,
 };
 use lemmy_db_views_actor::{
+  community_block_view::CommunityBlockView,
   community_follower_view::CommunityFollowerView,
   community_moderator_view::CommunityModeratorView,
+  person_block_view::PersonBlockView,
   person_mention_view::{PersonMentionQueryBuilder, PersonMentionView},
   person_view::PersonViewSafe,
 };
@@ -471,6 +480,53 @@ impl Perform for BanPerson {
   }
 }
 
+#[async_trait::async_trait(?Send)]
+impl Perform for BlockPerson {
+  type Response = BlockPersonResponse;
+
+  async fn perform(
+    &self,
+    context: &Data<LemmyContext>,
+    _websocket_id: Option<ConnectionId>,
+  ) -> Result<BlockPersonResponse, LemmyError> {
+    let data: &BlockPerson = &self;
+    let local_user_view = get_local_user_view_from_jwt(&data.auth, context.pool()).await?;
+
+    let recipient_id = data.person_id;
+    let person_id = local_user_view.person.id;
+    let community_block_form = PersonBlockForm {
+      person_id,
+      recipient_id,
+    };
+
+    if data.block {
+      let block = move |conn: &'_ _| PersonBlock::block(conn, &community_block_form);
+      if blocking(context.pool(), block).await?.is_err() {
+        return Err(ApiError::err("person_block_already_exists").into());
+      }
+    } else {
+      let unblock = move |conn: &'_ _| PersonBlock::unblock(conn, &community_block_form);
+      if blocking(context.pool(), unblock).await?.is_err() {
+        return Err(ApiError::err("person_block_already_exists").into());
+      }
+    }
+
+    // TODO does any federated stuff need to be done here?
+
+    let person_view = blocking(context.pool(), move |conn| {
+      PersonViewSafe::read(conn, recipient_id)
+    })
+    .await??;
+
+    let res = BlockPersonResponse {
+      person_view,
+      blocked: data.block,
+    };
+
+    Ok(res)
+  }
+}
+
 #[async_trait::async_trait(?Send)]
 impl Perform for GetReplies {
   type Response = GetRepliesResponse;
@@ -802,3 +858,51 @@ impl Perform for GetFollowedCommunities {
     Ok(GetFollowedCommunitiesResponse { communities })
   }
 }
+
+#[async_trait::async_trait(?Send)]
+impl Perform for GetBlockedCommunities {
+  type Response = GetBlockedCommunitiesResponse;
+
+  async fn perform(
+    &self,
+    context: &Data<LemmyContext>,
+    _websocket_id: Option<ConnectionId>,
+  ) -> Result<GetBlockedCommunitiesResponse, LemmyError> {
+    let data: &GetBlockedCommunities = &self;
+    let local_user_view = get_local_user_view_from_jwt(&data.auth, context.pool()).await?;
+
+    let person_id = local_user_view.person.id;
+    let communities = blocking(context.pool(), move |conn| {
+      CommunityBlockView::for_person(conn, person_id)
+    })
+    .await?
+    .map_err(|_| ApiError::err("system_err_login"))?;
+
+    // Return the jwt
+    Ok(GetBlockedCommunitiesResponse { communities })
+  }
+}
+
+#[async_trait::async_trait(?Send)]
+impl Perform for GetBlockedPersons {
+  type Response = GetBlockedPersonsResponse;
+
+  async fn perform(
+    &self,
+    context: &Data<LemmyContext>,
+    _websocket_id: Option<ConnectionId>,
+  ) -> Result<GetBlockedPersonsResponse, LemmyError> {
+    let data: &GetBlockedPersons = &self;
+    let local_user_view = get_local_user_view_from_jwt(&data.auth, context.pool()).await?;
+
+    let person_id = local_user_view.person.id;
+    let persons = blocking(context.pool(), move |conn| {
+      PersonBlockView::for_person(conn, person_id)
+    })
+    .await?
+    .map_err(|_| ApiError::err("system_err_login"))?;
+
+    // Return the jwt
+    Ok(GetBlockedPersonsResponse { persons })
+  }
+}
@@ -4,6 +4,7 @@ use lemmy_api_common::{
   blocking,
   check_community_ban,
   check_downvotes_enabled,
+  check_person_block,
   get_local_user_view_from_jwt,
   is_mod_or_admin,
   mark_post_as_read,
@@ -48,6 +49,8 @@ impl Perform for CreatePostLike {
 
     check_community_ban(local_user_view.person.id, post.community_id, context.pool()).await?;
 
+    check_person_block(local_user_view.person.id, post.creator_id, context.pool()).await?;
+
     let like_form = PostLikeForm {
       post_id: data.post_id,
       person_id: local_user_view.person.id,

@@ -1,5 +1,6 @@
 use lemmy_db_schema::{CommunityId, PersonId};
 use lemmy_db_views_actor::{
+  community_block_view::CommunityBlockView,
   community_follower_view::CommunityFollowerView,
   community_moderator_view::CommunityModeratorView,
   community_view::CommunityView,
@@ -116,6 +117,13 @@ pub struct FollowCommunity {
   pub auth: String,
 }
 
+#[derive(Deserialize)]
+pub struct BlockCommunity {
+  pub community_id: CommunityId,
+  pub block: bool,
+  pub auth: String,
+}
+
 #[derive(Deserialize)]
 pub struct GetFollowedCommunities {
   pub auth: String,
@@ -126,6 +134,16 @@ pub struct GetFollowedCommunitiesResponse {
   pub communities: Vec<CommunityFollowerView>,
 }
 
+#[derive(Deserialize)]
+pub struct GetBlockedCommunities {
+  pub auth: String,
+}
+
+#[derive(Serialize)]
+pub struct GetBlockedCommunitiesResponse {
+  pub communities: Vec<CommunityBlockView>,
+}
+
 #[derive(Deserialize)]
 pub struct TransferCommunity {
   pub community_id: CommunityId,

@@ -10,6 +10,7 @@ use diesel::PgConnection;
 use lemmy_db_queries::{
   source::{
     community::{CommunityModerator_, Community_},
+    person_block::PersonBlock_,
     site::Site_,
   },
   Crud,
@@ -21,6 +22,7 @@ use lemmy_db_schema::{
     comment::Comment,
     community::{Community, CommunityModerator},
     person::Person,
+    person_block::PersonBlock,
     person_mention::{PersonMention, PersonMentionForm},
     post::{Post, PostRead, PostReadForm},
     site::Site,
@@ -353,6 +355,20 @@ pub async fn check_community_ban(
   }
 }
 
+pub async fn check_person_block(
+  person_id: PersonId,
+  recipient_id: PersonId,
+  pool: &DbPool,
+) -> Result<(), LemmyError> {
+  // TODO the person and recipient might be reversed
+  let is_blocked = move |conn: &'_ _| PersonBlock::read(conn, person_id, recipient_id).is_ok();
+  if blocking(pool, is_blocked).await? {
+    Err(ApiError::err("person_block").into())
+  } else {
+    Ok(())
+  }
+}
+
 pub async fn check_downvotes_enabled(score: i16, pool: &DbPool) -> Result<(), LemmyError> {
   if score == -1 {
     let site = blocking(pool, move |conn| Site::read_simple(conn)).await??;