use crate::{
activities::{
- deletion::{delete::Delete, undo_delete::UndoDelete},
+ community::send_activity_in_community,
+ send_lemmy_activity,
+ verify_is_public,
verify_mod_action,
+ verify_person,
verify_person_in_community,
},
- fetcher::object_id::ObjectId,
+ activity_lists::AnnouncableActivities,
+ objects::{
+ comment::ApubComment,
+ community::ApubCommunity,
+ person::ApubPerson,
+ post::ApubPost,
+ private_message::ApubPrivateMessage,
+ },
+ protocol::{
+ activities::deletion::{delete::Delete, undo_delete::UndoDelete},
+ InCommunity,
+ },
};
-use diesel::PgConnection;
-use lemmy_api_common::blocking;
-use lemmy_apub_lib::{
- traits::{ActivityFields, ActorType, ApubObject},
- verify::verify_domains_match,
+use activitypub_federation::{
+ config::Data,
+ fetch::object_id::ObjectId,
+ kinds::public,
+ protocol::verification::verify_domains_match,
+ traits::{Actor, Object},
};
-use lemmy_db_queries::source::{comment::Comment_, community::Community_, post::Post_};
-use lemmy_db_schema::source::{comment::Comment, community::Community, person::Person, post::Post};
-use lemmy_utils::LemmyError;
-use lemmy_websocket::{
- send::{send_comment_ws_message_simple, send_community_ws_message, send_post_ws_message},
- LemmyContext,
- UserOperationCrud,
+use lemmy_api_common::context::LemmyContext;
+use lemmy_db_schema::{
+ newtypes::CommunityId,
+ source::{
+ comment::{Comment, CommentUpdateForm},
+ community::{Community, CommunityUpdateForm},
+ person::Person,
+ post::{Post, PostUpdateForm},
+ private_message::{PrivateMessage, PrivateMessageUpdateForm},
+ },
+ traits::Crud,
};
+use lemmy_utils::error::LemmyError;
+use std::ops::Deref;
use url::Url;
pub mod delete;
+pub mod delete_user;
pub mod undo_delete;
-pub async fn send_apub_delete(
- actor: &Person,
- community: &Community,
- object_id: Url,
+/// Parameter `reason` being set indicates that this is a removal by a mod. If its unset, this
+/// action was done by a normal user.
+#[tracing::instrument(skip_all)]
+pub(crate) async fn send_apub_delete_in_community(
+ actor: Person,
+ community: Community,
+ object: DeletableObjects,
+ reason: Option<String>,
deleted: bool,
- context: &LemmyContext,
+ context: &Data<LemmyContext>,
) -> Result<(), LemmyError> {
- if deleted {
- Delete::send(actor, community, object_id, None, context).await
+ let actor = ApubPerson::from(actor);
+ let is_mod_action = reason.is_some();
+ let activity = if deleted {
+ let delete = Delete::new(&actor, object, public(), Some(&community), reason, context)?;
+ AnnouncableActivities::Delete(delete)
} else {
- UndoDelete::send(actor, community, object_id, None, context).await
- }
+ let undo = UndoDelete::new(&actor, object, public(), Some(&community), reason, context)?;
+ AnnouncableActivities::UndoDelete(undo)
+ };
+ send_activity_in_community(
+ activity,
+ &actor,
+ &community.into(),
+ vec![],
+ is_mod_action,
+ context,
+ )
+ .await
}
-// TODO: remove reason is actually optional in lemmy. we set an empty string in that case, but its
-// ugly
-pub async fn send_apub_remove(
- actor: &Person,
- community: &Community,
- object_id: Url,
- reason: String,
- removed: bool,
- context: &LemmyContext,
+/// Parameter `reason` being set indicates that this is a removal by a mod. If its unset, this
+/// action was done by a normal user.
+#[tracing::instrument(skip_all)]
+pub(crate) async fn send_apub_delete_in_community_new(
+ actor: Person,
+ community_id: CommunityId,
+ object: DeletableObjects,
+ reason: Option<String>,
+ deleted: bool,
+ context: Data<LemmyContext>,
) -> Result<(), LemmyError> {
- if removed {
- Delete::send(actor, community, object_id, Some(reason), context).await
+ let community = Community::read(&mut context.pool(), community_id).await?;
+ let actor = ApubPerson::from(actor);
+ let is_mod_action = reason.is_some();
+ let activity = if deleted {
+ let delete = Delete::new(&actor, object, public(), Some(&community), reason, &context)?;
+ AnnouncableActivities::Delete(delete)
} else {
- UndoDelete::send(actor, community, object_id, Some(reason), context).await
- }
+ let undo = UndoDelete::new(&actor, object, public(), Some(&community), reason, &context)?;
+ AnnouncableActivities::UndoDelete(undo)
+ };
+ send_activity_in_community(
+ activity,
+ &actor,
+ &community.into(),
+ vec![],
+ is_mod_action,
+ &context,
+ )
+ .await
+}
+
+#[tracing::instrument(skip_all)]
+pub(crate) async fn send_apub_delete_private_message(
+ actor: &ApubPerson,
+ pm: PrivateMessage,
+ deleted: bool,
+ context: Data<LemmyContext>,
+) -> Result<(), LemmyError> {
+ let recipient_id = pm.recipient_id;
+ let recipient: ApubPerson = Person::read(&mut context.pool(), recipient_id)
+ .await?
+ .into();
+
+ let deletable = DeletableObjects::PrivateMessage(pm.into());
+ let inbox = vec![recipient.shared_inbox_or_inbox()];
+ if deleted {
+ let delete = Delete::new(actor, deletable, recipient.id(), None, None, &context)?;
+ send_lemmy_activity(&context, delete, actor, inbox, true).await?;
+ } else {
+ let undo = UndoDelete::new(actor, deletable, recipient.id(), None, None, &context)?;
+ send_lemmy_activity(&context, undo, actor, inbox, true).await?;
+ };
+ Ok(())
}
pub enum DeletableObjects {
- Community(Box<Community>),
- Comment(Box<Comment>),
- Post(Box<Post>),
+ Community(ApubCommunity),
+ Comment(ApubComment),
+ Post(ApubPost),
+ PrivateMessage(ApubPrivateMessage),
}
impl DeletableObjects {
+ #[tracing::instrument(skip_all)]
pub(crate) async fn read_from_db(
ap_id: &Url,
- context: &LemmyContext,
+ context: &Data<LemmyContext>,
) -> Result<DeletableObjects, LemmyError> {
- if let Some(c) =
- DeletableObjects::read_type_from_db::<Community>(ap_id.clone(), context).await?
- {
- return Ok(DeletableObjects::Community(Box::new(c)));
+ if let Some(c) = ApubCommunity::read_from_id(ap_id.clone(), context).await? {
+ return Ok(DeletableObjects::Community(c));
}
- if let Some(p) = DeletableObjects::read_type_from_db::<Post>(ap_id.clone(), context).await? {
- return Ok(DeletableObjects::Post(Box::new(p)));
+ if let Some(p) = ApubPost::read_from_id(ap_id.clone(), context).await? {
+ return Ok(DeletableObjects::Post(p));
}
- if let Some(c) = DeletableObjects::read_type_from_db::<Comment>(ap_id.clone(), context).await? {
- return Ok(DeletableObjects::Comment(Box::new(c)));
+ if let Some(c) = ApubComment::read_from_id(ap_id.clone(), context).await? {
+ return Ok(DeletableObjects::Comment(c));
+ }
+ if let Some(p) = ApubPrivateMessage::read_from_id(ap_id.clone(), context).await? {
+ return Ok(DeletableObjects::PrivateMessage(p));
}
Err(diesel::NotFound.into())
}
- // TODO: a method like this should be provided by fetcher module
- async fn read_type_from_db<Type>(
- ap_id: Url,
- context: &LemmyContext,
- ) -> Result<Option<Type>, LemmyError>
- where
- Type: ApubObject<DataType = PgConnection> + Send + 'static,
- {
- blocking(context.pool(), move |conn| {
- Type::read_from_apub_id(conn, ap_id)
- })
- .await?
+ pub(crate) fn id(&self) -> Url {
+ match self {
+ DeletableObjects::Community(c) => c.id(),
+ DeletableObjects::Comment(c) => c.ap_id.clone().into(),
+ DeletableObjects::Post(p) => p.ap_id.clone().into(),
+ DeletableObjects::PrivateMessage(p) => p.ap_id.clone().into(),
+ }
}
}
+#[tracing::instrument(skip_all)]
pub(in crate::activities) async fn verify_delete_activity(
- object: &Url,
- activity: &dyn ActivityFields,
- community_id: &ObjectId<Community>,
+ activity: &Delete,
is_mod_action: bool,
- context: &LemmyContext,
- request_counter: &mut i32,
+ context: &Data<LemmyContext>,
) -> Result<(), LemmyError> {
- let object = DeletableObjects::read_from_db(object, context).await?;
- let actor = ObjectId::new(activity.actor().clone());
+ let object = DeletableObjects::read_from_db(activity.object.id(), context).await?;
match object {
- DeletableObjects::Community(c) => {
- if c.local {
+ DeletableObjects::Community(community) => {
+ verify_is_public(&activity.to, &[])?;
+ if community.local {
// can only do this check for local community, in remote case it would try to fetch the
// deleted community (which fails)
- verify_person_in_community(&actor, community_id, context, request_counter).await?;
+ verify_person_in_community(&activity.actor, &community, context).await?;
}
// community deletion is always a mod (or admin) action
- verify_mod_action(
- &actor,
- ObjectId::new(c.actor_id()),
- context,
- request_counter,
- )
- .await?;
+ verify_mod_action(&activity.actor, activity.object.id(), community.id, context).await?;
}
DeletableObjects::Post(p) => {
- verify_delete_activity_post_or_comment(
- activity,
- &p.ap_id.into(),
- community_id,
+ verify_is_public(&activity.to, &[])?;
+ verify_delete_post_or_comment(
+ &activity.actor,
+ &p.ap_id.clone().into(),
+ &activity.community(context).await?,
is_mod_action,
context,
- request_counter,
)
.await?;
}
DeletableObjects::Comment(c) => {
- verify_delete_activity_post_or_comment(
- activity,
- &c.ap_id.into(),
- community_id,
+ verify_is_public(&activity.to, &[])?;
+ verify_delete_post_or_comment(
+ &activity.actor,
+ &c.ap_id.clone().into(),
+ &activity.community(context).await?,
is_mod_action,
context,
- request_counter,
)
.await?;
}
+ DeletableObjects::PrivateMessage(_) => {
+ verify_person(&activity.actor, context).await?;
+ verify_domains_match(activity.actor.inner(), activity.object.id())?;
+ }
}
Ok(())
}
-async fn verify_delete_activity_post_or_comment(
- activity: &dyn ActivityFields,
+#[tracing::instrument(skip_all)]
+async fn verify_delete_post_or_comment(
+ actor: &ObjectId<ApubPerson>,
object_id: &Url,
- community_id: &ObjectId<Community>,
+ community: &ApubCommunity,
is_mod_action: bool,
- context: &LemmyContext,
- request_counter: &mut i32,
+ context: &Data<LemmyContext>,
) -> Result<(), LemmyError> {
- let actor = ObjectId::new(activity.actor().clone());
- verify_person_in_community(&actor, community_id, context, request_counter).await?;
+ verify_person_in_community(actor, community, context).await?;
if is_mod_action {
- verify_mod_action(&actor, community_id.clone(), context, request_counter).await?;
+ verify_mod_action(actor, object_id, community.id, context).await?;
} else {
// domain of post ap_id and post.creator ap_id are identical, so we just check the former
- verify_domains_match(activity.actor(), object_id)?;
+ verify_domains_match(actor.inner(), object_id)?;
}
Ok(())
}
-struct WebsocketMessages {
- community: UserOperationCrud,
- post: UserOperationCrud,
- comment: UserOperationCrud,
-}
-
/// Write deletion or restoring of an object to the database, and send websocket message.
-/// TODO: we should do something similar for receive_remove_action(), but its much more complicated
-/// because of the mod log
+#[tracing::instrument(skip_all)]
async fn receive_delete_action(
object: &Url,
- actor: &ObjectId<Person>,
- ws_messages: WebsocketMessages,
+ actor: &ObjectId<ApubPerson>,
deleted: bool,
- context: &LemmyContext,
- request_counter: &mut i32,
+ context: &Data<LemmyContext>,
) -> Result<(), LemmyError> {
match DeletableObjects::read_from_db(object, context).await? {
DeletableObjects::Community(community) => {
if community.local {
- let mod_ = actor.dereference(context, request_counter).await?;
- let object = community.actor_id();
- send_apub_delete(&mod_, &community.clone(), object, true, context).await?;
+ let mod_: Person = actor.dereference(context).await?.deref().clone();
+ let object = DeletableObjects::Community(community.clone());
+ let c: Community = community.deref().clone();
+ send_apub_delete_in_community(mod_, c, object, None, true, context).await?;
}
- let community = blocking(context.pool(), move |conn| {
- Community::update_deleted(conn, community.id, deleted)
- })
- .await??;
- send_community_ws_message(community.id, ws_messages.community, None, None, context).await?;
+ Community::update(
+ &mut context.pool(),
+ community.id,
+ &CommunityUpdateForm::builder()
+ .deleted(Some(deleted))
+ .build(),
+ )
+ .await?;
}
DeletableObjects::Post(post) => {
- let deleted_post = blocking(context.pool(), move |conn| {
- Post::update_deleted(conn, post.id, deleted)
- })
- .await??;
- send_post_ws_message(deleted_post.id, ws_messages.post, None, None, context).await?;
+ if deleted != post.deleted {
+ Post::update(
+ &mut context.pool(),
+ post.id,
+ &PostUpdateForm::builder().deleted(Some(deleted)).build(),
+ )
+ .await?;
+ }
}
DeletableObjects::Comment(comment) => {
- let deleted_comment = blocking(context.pool(), move |conn| {
- Comment::update_deleted(conn, comment.id, deleted)
- })
- .await??;
- send_comment_ws_message_simple(deleted_comment.id, ws_messages.comment, context).await?;
+ if deleted != comment.deleted {
+ Comment::update(
+ &mut context.pool(),
+ comment.id,
+ &CommentUpdateForm::builder().deleted(Some(deleted)).build(),
+ )
+ .await?;
+ }
+ }
+ DeletableObjects::PrivateMessage(pm) => {
+ PrivateMessage::update(
+ &mut context.pool(),
+ pm.id,
+ &PrivateMessageUpdateForm::builder()
+ .deleted(Some(deleted))
+ .build(),
+ )
+ .await?;
}
}
Ok(())