X-Git-Url: http://these/git/?a=blobdiff_plain;f=crates%2Fapub%2Fsrc%2Factivities%2Fblock%2Fundo_block_user.rs;h=91cafa0a555cf42a43064b0c2941b20e39911053;hb=969f8b2ce9cd80492eb5e556ce3bda95c9b892b3;hp=a6865303821204ba02b99d7e87fba1c3ecf16d5b;hpb=a2a594b7635db2241602be56250f7d9bf992f7b9;p=lemmy.git diff --git a/crates/apub/src/activities/block/undo_block_user.rs b/crates/apub/src/activities/block/undo_block_user.rs index a6865303..91cafa0a 100644 --- a/crates/apub/src/activities/block/undo_block_user.rs +++ b/crates/apub/src/activities/block/undo_block_user.rs @@ -1,35 +1,32 @@ use crate::{ activities::{ - block::{generate_cc, generate_instance_inboxes, SiteOrCommunity}, - community::{announce::GetCommunity, send_activity_in_community}, + block::{generate_cc, SiteOrCommunity}, + community::send_activity_in_community, generate_activity_id, send_lemmy_activity, verify_is_public, }, activity_lists::AnnouncableActivities, - local_instance, - objects::{community::ApubCommunity, person::ApubPerson}, + insert_received_activity, + objects::{instance::remote_instance_inboxes, person::ApubPerson}, protocol::activities::block::{block_user::BlockUser, undo_block_user::UndoBlockUser}, - ActorType, }; use activitypub_federation::{ - core::object_id::ObjectId, - data::Data, - traits::ActivityHandler, - utils::verify_domains_match, + config::Data, + kinds::{activity::UndoType, public}, + protocol::verification::verify_domains_match, + traits::{ActivityHandler, Actor}, }; -use activitystreams_kinds::{activity::UndoType, public}; -use lemmy_api_common::utils::blocking; +use lemmy_api_common::{context::LemmyContext, utils::sanitize_html_opt}; use lemmy_db_schema::{ source::{ community::{CommunityPersonBan, CommunityPersonBanForm}, moderator::{ModBan, ModBanForm, ModBanFromCommunity, ModBanFromCommunityForm}, - person::Person, + person::{Person, PersonUpdateForm}, }, traits::{Bannable, Crud}, }; use lemmy_utils::error::LemmyError; -use lemmy_websocket::LemmyContext; use url::Url; impl UndoBlockUser { @@ -39,39 +36,44 @@ impl UndoBlockUser { user: &ApubPerson, mod_: &ApubPerson, reason: Option, - context: &LemmyContext, + context: &Data, ) -> Result<(), LemmyError> { let block = BlockUser::new(target, user, mod_, None, reason, None, context).await?; + let audience = if let SiteOrCommunity::Community(c) = target { + Some(c.id().into()) + } else { + None + }; let id = generate_activity_id( UndoType::Undo, &context.settings().get_protocol_and_hostname(), )?; let undo = UndoBlockUser { - actor: ObjectId::new(mod_.actor_id()), + actor: mod_.id().into(), to: vec![public()], object: block, - cc: generate_cc(target, context.pool()).await?, + cc: generate_cc(target, &mut context.pool()).await?, kind: UndoType::Undo, id: id.clone(), - unparsed: Default::default(), + audience, }; - let inboxes = vec![user.shared_inbox_or_inbox_url()]; + let mut inboxes = vec![user.shared_inbox_or_inbox()]; match target { SiteOrCommunity::Site(_) => { - let inboxes = generate_instance_inboxes(user, context.pool()).await?; - send_lemmy_activity(context, &undo, &id, mod_, inboxes, false).await + inboxes.append(&mut remote_instance_inboxes(&mut context.pool()).await?); + send_lemmy_activity(context, undo, mod_, inboxes, false).await } SiteOrCommunity::Community(c) => { let activity = AnnouncableActivities::UndoBlockUser(undo); - send_activity_in_community(activity, &id, mod_, c, inboxes, context).await + send_activity_in_community(activity, mod_, c, inboxes, true, context).await } } } } -#[async_trait::async_trait(?Send)] +#[async_trait::async_trait] impl ActivityHandler for UndoBlockUser { type DataType = LemmyContext; type Error = LemmyError; @@ -85,55 +87,41 @@ impl ActivityHandler for UndoBlockUser { } #[tracing::instrument(skip_all)] - async fn verify( - &self, - context: &Data, - request_counter: &mut i32, - ) -> Result<(), LemmyError> { + async fn verify(&self, context: &Data) -> Result<(), LemmyError> { + insert_received_activity(&self.id, context).await?; verify_is_public(&self.to, &self.cc)?; verify_domains_match(self.actor.inner(), self.object.actor.inner())?; - self.object.verify(context, request_counter).await?; + self.object.verify(context).await?; Ok(()) } #[tracing::instrument(skip_all)] - async fn receive( - self, - context: &Data, - request_counter: &mut i32, - ) -> Result<(), LemmyError> { - let instance = local_instance(context); + async fn receive(self, context: &Data) -> Result<(), LemmyError> { let expires = self.object.expires.map(|u| u.naive_local()); - let mod_person = self - .actor - .dereference::(context, instance, request_counter) - .await?; - let blocked_person = self - .object - .object - .dereference::(context, instance, request_counter) - .await?; - match self - .object - .target - .dereference::(context, instance, request_counter) - .await? - { + let mod_person = self.actor.dereference(context).await?; + let blocked_person = self.object.object.dereference(context).await?; + match self.object.target.dereference(context).await? { SiteOrCommunity::Site(_site) => { - let blocked_person = blocking(context.pool(), move |conn| { - Person::ban_person(conn, blocked_person.id, false, expires) - }) - .await??; + let blocked_person = Person::update( + &mut context.pool(), + blocked_person.id, + &PersonUpdateForm { + banned: Some(false), + ban_expires: Some(expires), + ..Default::default() + }, + ) + .await?; // write mod log let form = ModBanForm { mod_person_id: mod_person.id, other_person_id: blocked_person.id, - reason: self.object.summary, + reason: sanitize_html_opt(&self.object.summary), banned: Some(false), expires, }; - blocking(context.pool(), move |conn| ModBan::create(conn, &form)).await??; + ModBan::create(&mut context.pool(), &form).await?; } SiteOrCommunity::Community(community) => { let community_user_ban_form = CommunityPersonBanForm { @@ -141,39 +129,21 @@ impl ActivityHandler for UndoBlockUser { person_id: blocked_person.id, expires: None, }; - blocking(context.pool(), move |conn: &'_ _| { - CommunityPersonBan::unban(conn, &community_user_ban_form) - }) - .await??; + CommunityPersonBan::unban(&mut context.pool(), &community_user_ban_form).await?; // write to mod log let form = ModBanFromCommunityForm { mod_person_id: mod_person.id, other_person_id: blocked_person.id, community_id: community.id, - reason: self.object.summary, + reason: sanitize_html_opt(&self.object.summary), banned: Some(false), expires, }; - blocking(context.pool(), move |conn| { - ModBanFromCommunity::create(conn, &form) - }) - .await??; + ModBanFromCommunity::create(&mut context.pool(), &form).await?; } } Ok(()) } } - -#[async_trait::async_trait(?Send)] -impl GetCommunity for UndoBlockUser { - #[tracing::instrument(skip_all)] - async fn get_community( - &self, - context: &LemmyContext, - request_counter: &mut i32, - ) -> Result { - self.object.get_community(context, request_counter).await - } -}