Replace Option<bool> with bool for PostQuery and CommentQuery (#3819) (#3857)

[lemmy.git] / crates / api / src / community / block.rs

diff --git a/crates/api/src/community/block.rs b/crates/api/src/community/block.rs
index 4f740c916971182931600786dcfcbb24f000a5e2..f27b7c01bd80a5b195dffe10ac2e2b088479c046 100644 (file)
--- a/crates/api/src/community/block.rs
+++ b/crates/api/src/community/block.rs
@@ -1,79 +1,71 @@
-use crate::Perform;
-use actix_web::web::Data;
+use activitypub_federation::config::Data;
+use actix_web::web::Json;
 use lemmy_api_common::{
   community::{BlockCommunity, BlockCommunityResponse},
-  utils::{blocking, get_local_user_view_from_jwt},
+  context::LemmyContext,
+  send_activity::{ActivityChannel, SendActivityData},
+  utils::local_user_view_from_jwt,
 };
-use lemmy_apub::protocol::activities::following::undo_follow::UndoFollowCommunity;
 use lemmy_db_schema::{
   source::{
-    community::{Community, CommunityFollower, CommunityFollowerForm},
+    community::{CommunityFollower, CommunityFollowerForm},
     community_block::{CommunityBlock, CommunityBlockForm},
   },
-  traits::{Blockable, Crud, Followable},
+  traits::{Blockable, Followable},
 };
 use lemmy_db_views_actor::structs::CommunityView;
-use lemmy_utils::{ConnectionId, LemmyError};
-use lemmy_websocket::LemmyContext;
+use lemmy_utils::error::{LemmyError, LemmyErrorExt, LemmyErrorType};
 
-#[async_trait::async_trait(?Send)]
-impl Perform for BlockCommunity {
-  type Response = BlockCommunityResponse;
+#[tracing::instrument(skip(context))]
+pub async fn block_community(
+  data: Json<BlockCommunity>,
+  context: Data<LemmyContext>,
+) -> Result<Json<BlockCommunityResponse>, LemmyError> {
+  let local_user_view = local_user_view_from_jwt(&data.auth, &context).await?;
 
-  #[tracing::instrument(skip(context, _websocket_id))]
-  async fn perform(
-    &self,
-    context: &Data<LemmyContext>,
-    _websocket_id: Option<ConnectionId>,
-  ) -> Result<BlockCommunityResponse, LemmyError> {
-    let data: &BlockCommunity = self;
-    let local_user_view =
-      get_local_user_view_from_jwt(&data.auth, context.pool(), context.secret()).await?;
+  let community_id = data.community_id;
+  let person_id = local_user_view.person.id;
+  let community_block_form = CommunityBlockForm {
+    person_id,
+    community_id,
+  };
 
-    let community_id = data.community_id;
-    let person_id = local_user_view.person.id;
-    let community_block_form = CommunityBlockForm {
+  if data.block {
+    CommunityBlock::block(&mut context.pool(), &community_block_form)
+      .await
+      .with_lemmy_type(LemmyErrorType::CommunityBlockAlreadyExists)?;
+
+    // Also, unfollow the community, and send a federated unfollow
+    let community_follower_form = CommunityFollowerForm {
+      community_id: data.community_id,
       person_id,
-      community_id,
+      pending: false,
     };
 
-    if data.block {
-      let block = move |conn: &'_ _| CommunityBlock::block(conn, &community_block_form);
-      blocking(context.pool(), block)
-        .await?
-        .map_err(|e| LemmyError::from_error_message(e, "community_block_already_exists"))?;
-
-      // Also, unfollow the community, and send a federated unfollow
-      let community_follower_form = CommunityFollowerForm {
-        community_id: data.community_id,
-        person_id,
-        pending: false,
-      };
-      blocking(context.pool(), move |conn: &'_ _| {
-        CommunityFollower::unfollow(conn, &community_follower_form)
-      })
-      .await?
+    CommunityFollower::unfollow(&mut context.pool(), &community_follower_form)
+      .await
       .ok();
-      let community = blocking(context.pool(), move |conn| {
-        Community::read(conn, community_id)
-      })
-      .await??;
-      UndoFollowCommunity::send(&local_user_view.person.into(), &community.into(), context).await?;
-    } else {
-      let unblock = move |conn: &'_ _| CommunityBlock::unblock(conn, &community_block_form);
-      blocking(context.pool(), unblock)
-        .await?
-        .map_err(|e| LemmyError::from_error_message(e, "community_block_already_exists"))?;
-    }
+  } else {
+    CommunityBlock::unblock(&mut context.pool(), &community_block_form)
+      .await
+      .with_lemmy_type(LemmyErrorType::CommunityBlockAlreadyExists)?;
+  }
 
-    let community_view = blocking(context.pool(), move |conn| {
-      CommunityView::read(conn, community_id, Some(person_id))
-    })
-    .await??;
+  let community_view =
+    CommunityView::read(&mut context.pool(), community_id, Some(person_id), false).await?;
 
-    Ok(BlockCommunityResponse {
-      blocked: data.block,
-      community_view,
-    })
-  }
+  ActivityChannel::submit_activity(
+    SendActivityData::FollowCommunity(
+      community_view.community.clone(),
+      local_user_view.person.clone(),
+      false,
+    ),
+    &context,
+  )
+  .await?;
+
+  Ok(Json(BlockCommunityResponse {
+    blocked: data.block,
+    community_view,
+  }))
 }