use crate::{
activities::{
- block::{generate_cc, generate_instance_inboxes, SiteOrCommunity},
+ block::{generate_cc, SiteOrCommunity},
community::{announce::GetCommunity, send_activity_in_community},
generate_activity_id,
send_lemmy_activity,
},
activity_lists::AnnouncableActivities,
local_instance,
- objects::{community::ApubCommunity, person::ApubPerson},
+ objects::{community::ApubCommunity, instance::remote_instance_inboxes, person::ApubPerson},
protocol::activities::block::block_user::BlockUser,
ActorType,
};
use activitypub_federation::{
core::object_id::ObjectId,
data::Data,
- traits::ActivityHandler,
+ traits::{ActivityHandler, Actor},
utils::verify_domains_match,
};
use activitystreams_kinds::{activity::BlockType, public};
},
traits::{Bannable, Crud, Followable},
};
-use lemmy_utils::{error::LemmyError, settings::structs::Settings, utils::convert_datetime};
+use lemmy_utils::{error::LemmyError, utils::convert_datetime};
use lemmy_websocket::LemmyContext;
use url::Url;
context,
)
.await?;
- let block_id = block.id.clone();
match target {
SiteOrCommunity::Site(_) => {
- let inboxes = generate_instance_inboxes(user, context.pool()).await?;
- send_lemmy_activity(context, &block, &block_id, mod_, inboxes, false).await
+ let inboxes = remote_instance_inboxes(context.pool()).await?;
+ send_lemmy_activity(context, block, mod_, inboxes, false).await
}
SiteOrCommunity::Community(c) => {
let activity = AnnouncableActivities::BlockUser(block);
- let inboxes = vec![user.shared_inbox_or_inbox_url()];
- send_activity_in_community(activity, &block_id, mod_, c, inboxes, context).await
+ let inboxes = vec![user.shared_inbox_or_inbox()];
+ send_activity_in_community(activity, mod_, c, inboxes, context).await
}
}
}
verify_is_public(&self.to, &self.cc)?;
match self
.target
- .dereference::<LemmyError>(context, local_instance(context), request_counter)
+ .dereference(context, local_instance(context), request_counter)
.await?
{
SiteOrCommunity::Site(site) => {
let domain = self.object.inner().domain().expect("url needs domain");
- if Settings::get().hostname == domain {
+ if context.settings().hostname == domain {
return Err(
anyhow!("Site bans from remote instance can't affect user's home instance").into(),
);
let expires = self.expires.map(|u| u.naive_local());
let mod_person = self
.actor
- .dereference::<LemmyError>(context, local_instance(context), request_counter)
+ .dereference(context, local_instance(context), request_counter)
.await?;
let blocked_person = self
.object
- .dereference::<LemmyError>(context, local_instance(context), request_counter)
+ .dereference(context, local_instance(context), request_counter)
.await?;
let target = self
.target
- .dereference::<LemmyError>(context, local_instance(context), request_counter)
+ .dereference(context, local_instance(context), request_counter)
.await?;
match target {
SiteOrCommunity::Site(_site) => {
})
.await??;
if self.remove_data.unwrap_or(false) {
- remove_user_data(blocked_person.id, context.pool()).await?;
+ remove_user_data(
+ blocked_person.id,
+ context.pool(),
+ context.settings(),
+ context.client(),
+ )
+ .await?;
}
// write mod log
person_id: blocked_person.id,
pending: false,
};
- blocking(context.pool(), move |conn: &'_ _| {
+ blocking(context.pool(), move |conn: &mut _| {
CommunityFollower::unfollow(conn, &community_follower_form)
})
.await?
) -> Result<ApubCommunity, LemmyError> {
let target = self
.target
- .dereference::<LemmyError>(context, local_instance(context), request_counter)
+ .dereference(context, local_instance(context), request_counter)
.await?;
match target {
SiteOrCommunity::Community(c) => Ok(c),