X-Git-Url: http://these/git/?a=blobdiff_plain;f=crates%2Fapub%2Fsrc%2Factivities%2Fblock%2Fundo_block_user.rs;h=f683497945e52974d2061dbbb494db41a6bcd679;hb=e9e76549a88cfbdab36f00d302cceabcaaa24f4c;hp=130b1eb506d796b7ffd60dc2713fee3ec94bfe22;hpb=3aa3d75a1e04b6ed4bc7566f86f45e6883c5c39b;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 130b1eb5..f6834979 100644 --- a/crates/apub/src/activities/block/undo_block_user.rs +++ b/crates/apub/src/activities/block/undo_block_user.rs @@ -1,34 +1,33 @@ 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_activity, verify_is_public, }, activity_lists::AnnouncableActivities, - 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}, }; -use activitystreams_kinds::{activity::UndoType, public}; -use lemmy_api_common::utils::blocking; -use lemmy_apub_lib::{ - data::Data, - object_id::ObjectId, - traits::{ActivityHandler, ActorType}, - verify::verify_domains_match, +use activitypub_federation::{ + config::Data, + kinds::{activity::UndoType, public}, + protocol::verification::verify_domains_match, + traits::{ActivityHandler, Actor}, }; +use lemmy_api_common::context::LemmyContext; use lemmy_db_schema::{ source::{ community::{CommunityPersonBan, CommunityPersonBanForm}, moderator::{ModBan, ModBanForm, ModBanFromCommunity, ModBanFromCommunityForm}, - person::Person, + person::{Person, PersonUpdateForm}, }, traits::{Bannable, Crud}, }; -use lemmy_utils::LemmyError; -use lemmy_websocket::LemmyContext; +use lemmy_utils::error::LemmyError; +use url::Url; impl UndoBlockUser { #[tracing::instrument(skip_all)] @@ -37,82 +36,81 @@ 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; + + fn id(&self) -> &Url { + &self.id + } + + fn actor(&self) -> &Url { + self.actor.inner() + } #[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_activity(&self.id, self.actor.inner(), &context.settings())?; 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> { + 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, context.client(), request_counter) - .await?; - let blocked_person = self - .object - .object - .dereference(context, context.client(), request_counter) - .await?; - match self - .object - .target - .dereference(context, context.client(), 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::builder() + .banned(Some(false)) + .ban_expires(Some(expires)) + .build(), + ) + .await?; // write mod log let form = ModBanForm { @@ -122,7 +120,7 @@ impl ActivityHandler for UndoBlockUser { 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 { @@ -130,10 +128,7 @@ 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 { @@ -144,25 +139,10 @@ impl ActivityHandler for UndoBlockUser { 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 - } -}