X-Git-Url: http://these/git/?a=blobdiff_plain;f=crates%2Fapub%2Fsrc%2Factivities%2Fdeletion%2Fmod.rs;h=e03074f19d96531c32065b76dc8a641796eea375;hb=70fae9d68d65b1e4d153e30d3c065cc315b75eaf;hp=350773f42b356fbf3658a2bfe8c1aee8550a06e6;hpb=f6f169b4eb7542825cf17712b474b6a6ab71cb64;p=lemmy.git diff --git a/crates/apub/src/activities/deletion/mod.rs b/crates/apub/src/activities/deletion/mod.rs index 350773f4..e03074f1 100644 --- a/crates/apub/src/activities/deletion/mod.rs +++ b/crates/apub/src/activities/deletion/mod.rs @@ -1,209 +1,298 @@ 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::person::get_or_fetch_and_upsert_person, - ActorType, + 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 lemmy_api_common::blocking; -use lemmy_apub_lib::{verify_domains_match, ActivityFields}; -use lemmy_db_queries::{ - source::{comment::Comment_, community::Community_, post::Post_}, - ApubObject, +use activitypub_federation::{ + config::Data, + fetch::object_id::ObjectId, + kinds::public, + protocol::verification::verify_domains_match, + traits::{Actor, Object}, }; +use lemmy_api_common::context::LemmyContext; use lemmy_db_schema::{ - source::{comment::Comment, community::Community, person::Person, post::Post}, - DbUrl, -}; -use lemmy_utils::LemmyError; -use lemmy_websocket::{ - send::{send_comment_ws_message_simple, send_community_ws_message, send_post_ws_message}, - LemmyContext, - UserOperationCrud, + 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, deleted: bool, - context: &LemmyContext, + context: &Data, ) -> 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, + deleted: bool, + context: Data, ) -> 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, +) -> 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), - Comment(Box), - Post(Box), + 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, ) -> Result { - let id: DbUrl = ap_id.clone().into(); - - if let Some(c) = DeletableObjects::read_type_from_db::(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) = ApubPost::read_from_id(ap_id.clone(), context).await? { + return Ok(DeletableObjects::Post(p)); } - if let Some(p) = DeletableObjects::read_type_from_db::(id.clone(), context).await? { - return Ok(DeletableObjects::Post(Box::new(p))); + if let Some(c) = ApubComment::read_from_id(ap_id.clone(), context).await? { + return Ok(DeletableObjects::Comment(c)); } - if let Some(c) = DeletableObjects::read_type_from_db::(id.clone(), context).await? { - return Ok(DeletableObjects::Comment(Box::new(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( - ap_id: DbUrl, - context: &LemmyContext, - ) -> Result, LemmyError> { - blocking(context.pool(), move |conn| { - Type::read_from_apub_id(conn, &ap_id).ok() - }) - .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: &Url, + activity: &Delete, is_mod_action: bool, - context: &LemmyContext, - request_counter: &mut i32, + context: &Data, ) -> Result<(), LemmyError> { - let object = DeletableObjects::read_from_db(object, context).await?; + 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(activity.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(activity.actor(), c.actor_id(), context).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, object_id: &Url, - community_id: &Url, + community: &ApubCommunity, is_mod_action: bool, - context: &LemmyContext, - request_counter: &mut i32, + context: &Data, ) -> Result<(), LemmyError> { - verify_person_in_community(activity.actor(), community_id, context, request_counter).await?; + verify_person_in_community(actor, community, context).await?; if is_mod_action { - verify_mod_action(activity.actor(), community_id.clone(), context).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: &Url, - ws_messages: WebsocketMessages, + actor: &ObjectId, deleted: bool, - context: &LemmyContext, - request_counter: &mut i32, + context: &Data, ) -> Result<(), LemmyError> { match DeletableObjects::read_from_db(object, context).await? { DeletableObjects::Community(community) => { if community.local { - let mod_ = get_or_fetch_and_upsert_person(actor, 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(())