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, context)?;
  56
  57     let id = generate_activity_id(
  58       UndoType::Undo,
  59       &context.settings().get_protocol_and_hostname(),
  60     )?;
  61     let undo = UndoBlockUserFromCommunity {
  62       actor: ObjectId::new(actor.actor_id()),
  63       to: [PublicUrl::Public],
  64       object: block,
  65       cc: [ObjectId::new(community.actor_id())],
  66       kind: UndoType::Undo,
  67       id: id.clone(),
  68       context: lemmy_context(),
  69       unparsed: Default::default(),
  70     };
  71
  72     let activity = AnnouncableActivities::UndoBlockUserFromCommunity(undo);
  73     let inboxes = vec![target.get_shared_inbox_or_inbox_url()];
  74     send_to_community_new(activity, &id, actor, community, inboxes, context).await
  75   }
  76 }
  77
  78 #[async_trait::async_trait(?Send)]
  79 impl ActivityHandler for UndoBlockUserFromCommunity {
  80   async fn verify(
  81     &self,
  82     context: &LemmyContext,
  83     request_counter: &mut i32,
  84   ) -> Result<(), LemmyError> {
  85     verify_activity(self, &context.settings())?;
  86     verify_person_in_community(&self.actor, &self.cc[0], context, request_counter).await?;
  87     verify_mod_action(&self.actor, self.cc[0].clone(), context).await?;
  88     self.object.verify(context, request_counter).await?;
  89     Ok(())
  90   }
  91
  92   async fn receive(
  93     self,
  94     context: &LemmyContext,
  95     request_counter: &mut i32,
  96   ) -> Result<(), LemmyError> {
  97     let community = self.cc[0].dereference(context, request_counter).await?;
  98     let blocked_user = self
  99       .object
 100       .object
 101       .dereference(context, request_counter)
 102       .await?;
 103
 104     let community_user_ban_form = CommunityPersonBanForm {
 105       community_id: community.id,
 106       person_id: blocked_user.id,
 107     };
 108
 109     blocking(context.pool(), move |conn: &'_ _| {
 110       CommunityPersonBan::unban(conn, &community_user_ban_form)
 111     })
 112     .await??;
 113
 114     Ok(())
 115   }
 116 }