crates/apub/src/activities/community/undo_block_user.rs

   1 use crate::{
   2   activities::{
   3     community::{announce::AnnouncableActivities, block_user::BlockUserFromCommunity},
   4     generate_activity_id,
   5     verify_activity,
   6     verify_mod_action,
   7     verify_person_in_community,
   8   },
   9   activity_queue::send_to_community_new,
  10   extensions::context::lemmy_context,
  11   fetcher::object_id::ObjectId,
  12   ActorType,
  13 };
  14 use activitystreams::{
  15   activity::kind::UndoType,
  16   base::AnyBase,
  17   primitives::OneOrMany,
  18   unparsed::Unparsed,
  19 };
  20 use lemmy_api_common::blocking;
  21 use lemmy_apub_lib::{values::PublicUrl, ActivityFields, ActivityHandler};
  22 use lemmy_db_queries::Bannable;
  23 use lemmy_db_schema::source::{
  24   community::{Community, CommunityPersonBan, CommunityPersonBanForm},
  25   person::Person,
  26 };
  27 use lemmy_utils::LemmyError;
  28 use lemmy_websocket::LemmyContext;
  29 use serde::{Deserialize, Serialize};
  30 use url::Url;
  31
  32 #[derive(Clone, Debug, Deserialize, Serialize, ActivityFields)]
  33 #[serde(rename_all = "camelCase")]
  34 pub struct UndoBlockUserFromCommunity {
  35   actor: ObjectId<Person>,
  36   to: [PublicUrl; 1],
  37   object: BlockUserFromCommunity,
  38   cc: [ObjectId<Community>; 1],
  39   #[serde(rename = "type")]
  40   kind: UndoType,
  41   id: Url,
  42   #[serde(rename = "@context")]
  43   context: OneOrMany<AnyBase>,
  44   #[serde(flatten)]
  45   unparsed: Unparsed,
  46 }
  47
  48 impl UndoBlockUserFromCommunity {
  49   pub async fn send(
  50     community: &Community,
  51     target: &Person,
  52     actor: &Person,
  53     context: &LemmyContext,
  54   ) -> Result<(), LemmyError> {
  55     let block = BlockUserFromCommunity::new(community, target, actor)?;
  56
  57     let id = generate_activity_id(UndoType::Undo)?;
  58     let undo = UndoBlockUserFromCommunity {
  59       actor: ObjectId::new(actor.actor_id()),
  60       to: [PublicUrl::Public],
  61       object: block,
  62       cc: [ObjectId::new(community.actor_id())],
  63       kind: UndoType::Undo,
  64       id: id.clone(),
  65       context: lemmy_context(),
  66       unparsed: Default::default(),
  67     };
  68
  69     let activity = AnnouncableActivities::UndoBlockUserFromCommunity(undo);
  70     let inboxes = vec![target.get_shared_inbox_or_inbox_url()];
  71     send_to_community_new(activity, &id, actor, community, inboxes, context).await
  72   }
  73 }
  74
  75 #[async_trait::async_trait(?Send)]
  76 impl ActivityHandler for UndoBlockUserFromCommunity {
  77   async fn verify(
  78     &self,
  79     context: &LemmyContext,
  80     request_counter: &mut i32,
  81   ) -> Result<(), LemmyError> {
  82     verify_activity(self)?;
  83     verify_person_in_community(&self.actor, &self.cc[0], context, request_counter).await?;
  84     verify_mod_action(&self.actor, self.cc[0].clone(), context).await?;
  85     self.object.verify(context, request_counter).await?;
  86     Ok(())
  87   }
  88
  89   async fn receive(
  90     self,
  91     context: &LemmyContext,
  92     request_counter: &mut i32,
  93   ) -> Result<(), LemmyError> {
  94     let community = self.cc[0].dereference(context, request_counter).await?;
  95     let blocked_user = self
  96       .object
  97       .object
  98       .dereference(context, request_counter)
  99       .await?;
 100
 101     let community_user_ban_form = CommunityPersonBanForm {
 102       community_id: community.id,
 103       person_id: blocked_user.id,
 104     };
 105
 106     blocking(context.pool(), move |conn: &'_ _| {
 107       CommunityPersonBan::unban(conn, &community_user_ban_form)
 108     })
 109     .await??;
 110
 111     Ok(())
 112   }
 113 }