X-Git-Url: http://these/git/?a=blobdiff_plain;f=crates%2Fapub%2Fsrc%2Factivities%2Fdeletion%2Fundo_delete.rs;h=541a7455fe376082931f957524c859bcdd357236;hb=e9e76549a88cfbdab36f00d302cceabcaaa24f4c;hp=2de4aefd3e8268a0baf6cd6ba260325e7b2bea30;hpb=a83113935d824d86d3e5000db50c10c44d84f8d0;p=lemmy.git diff --git a/crates/apub/src/activities/deletion/undo_delete.rs b/crates/apub/src/activities/deletion/undo_delete.rs index 2de4aefd..541a7455 100644 --- a/crates/apub/src/activities/deletion/undo_delete.rs +++ b/crates/apub/src/activities/deletion/undo_delete.rs @@ -1,148 +1,154 @@ -use activitystreams::{activity::kind::UndoType, public}; -use anyhow::anyhow; -use url::Url; - -use lemmy_api_common::blocking; -use lemmy_apub_lib::{ - data::Data, - traits::{ActivityHandler, ActorType}, -}; -use lemmy_db_schema::source::{comment::Comment, community::Community, 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 crate::{ activities::{ - community::{announce::GetCommunity, send_to_community}, deletion::{receive_delete_action, verify_delete_activity, DeletableObjects}, generate_activity_id, - verify_activity, - verify_is_public, }, - activity_lists::AnnouncableActivities, - fetcher::object_id::ObjectId, - objects::{community::ApubCommunity, person::ApubPerson}, + insert_received_activity, + objects::person::ApubPerson, protocol::activities::deletion::{delete::Delete, undo_delete::UndoDelete}, }; +use activitypub_federation::{config::Data, kinds::activity::UndoType, traits::ActivityHandler}; +use lemmy_api_common::context::LemmyContext; +use lemmy_db_schema::{ + source::{ + comment::{Comment, CommentUpdateForm}, + community::{Community, CommunityUpdateForm}, + moderator::{ + ModRemoveComment, + ModRemoveCommentForm, + ModRemoveCommunity, + ModRemoveCommunityForm, + ModRemovePost, + ModRemovePostForm, + }, + post::{Post, PostUpdateForm}, + }, + traits::Crud, +}; +use lemmy_utils::error::{LemmyError, LemmyErrorType}; +use url::Url; -#[async_trait::async_trait(?Send)] +#[async_trait::async_trait] impl ActivityHandler for UndoDelete { type DataType = LemmyContext; - async fn verify( - &self, - context: &Data, - request_counter: &mut i32, - ) -> Result<(), LemmyError> { - verify_is_public(&self.to)?; - verify_activity(self, &context.settings())?; - self.object.verify(context, request_counter).await?; - let community = self.get_community(context, request_counter).await?; - verify_delete_activity( - &self.object.object, - self, - &community, - self.object.summary.is_some(), - context, - request_counter, - ) - .await?; + type Error = LemmyError; + + fn id(&self) -> &Url { + &self.id + } + + fn actor(&self) -> &Url { + self.actor.inner() + } + + async fn verify(&self, data: &Data) -> Result<(), Self::Error> { + insert_received_activity(&self.id, data).await?; + self.object.verify(data).await?; + verify_delete_activity(&self.object, self.object.summary.is_some(), data).await?; Ok(()) } - async fn receive( - self, - context: &Data, - request_counter: &mut i32, - ) -> Result<(), LemmyError> { + #[tracing::instrument(skip_all)] + async fn receive(self, context: &Data) -> Result<(), LemmyError> { if self.object.summary.is_some() { - UndoDelete::receive_undo_remove_action(&self.object.object, context).await - } else { - receive_delete_action( - &self.object.object, - &self.actor, - false, + UndoDelete::receive_undo_remove_action( + &self.actor.dereference(context).await?, + self.object.object.id(), context, - request_counter, ) .await + } else { + receive_delete_action(self.object.object.id(), &self.actor, false, context).await } } } impl UndoDelete { - pub(in crate::activities::deletion) async fn send( + #[tracing::instrument(skip_all)] + pub(in crate::activities::deletion) fn new( actor: &ApubPerson, - community: &ApubCommunity, - object_id: Url, + object: DeletableObjects, + to: Url, + community: Option<&Community>, summary: Option, - context: &LemmyContext, - ) -> Result<(), LemmyError> { - let object = Delete::new(actor, community, object_id, summary, context)?; + context: &Data, + ) -> Result { + let object = Delete::new(actor, object, to.clone(), community, summary, context)?; let id = generate_activity_id( UndoType::Undo, &context.settings().get_protocol_and_hostname(), )?; - let undo = UndoDelete { - actor: ObjectId::new(actor.actor_id()), - to: vec![public()], + let cc: Option = community.map(|c| c.actor_id.clone().into()); + Ok(UndoDelete { + actor: actor.actor_id.clone().into(), + to: vec![to], object, - cc: vec![community.actor_id()], + cc: cc.into_iter().collect(), kind: UndoType::Undo, - id: id.clone(), - unparsed: Default::default(), - }; - - let activity = AnnouncableActivities::UndoDelete(undo); - send_to_community(activity, &id, actor, community, vec![], context).await + id, + audience: community.map(|c| c.actor_id.clone().into()), + }) } + #[tracing::instrument(skip_all)] pub(in crate::activities) async fn receive_undo_remove_action( + actor: &ApubPerson, object: &Url, - context: &LemmyContext, + context: &Data, ) -> Result<(), LemmyError> { - use UserOperationCrud::*; match DeletableObjects::read_from_db(object, context).await? { DeletableObjects::Community(community) => { if community.local { - return Err(anyhow!("Only local admin can restore community").into()); + return Err(LemmyErrorType::OnlyLocalAdminCanRestoreCommunity)?; } - let deleted_community = blocking(context.pool(), move |conn| { - Community::update_removed(conn, community.id, false) - }) - .await??; - send_community_ws_message(deleted_community.id, EditCommunity, None, None, context).await?; + let form = ModRemoveCommunityForm { + mod_person_id: actor.id, + community_id: community.id, + removed: Some(false), + reason: None, + expires: None, + }; + ModRemoveCommunity::create(&mut context.pool(), &form).await?; + Community::update( + &mut context.pool(), + community.id, + &CommunityUpdateForm::builder().removed(Some(false)).build(), + ) + .await?; } DeletableObjects::Post(post) => { - let removed_post = blocking(context.pool(), move |conn| { - Post::update_removed(conn, post.id, false) - }) - .await??; - send_post_ws_message(removed_post.id, EditPost, None, None, context).await?; + let form = ModRemovePostForm { + mod_person_id: actor.id, + post_id: post.id, + removed: Some(false), + reason: None, + }; + ModRemovePost::create(&mut context.pool(), &form).await?; + Post::update( + &mut context.pool(), + post.id, + &PostUpdateForm::builder().removed(Some(false)).build(), + ) + .await?; } DeletableObjects::Comment(comment) => { - let removed_comment = blocking(context.pool(), move |conn| { - Comment::update_removed(conn, comment.id, false) - }) - .await??; - send_comment_ws_message_simple(removed_comment.id, EditComment, context).await?; + let form = ModRemoveCommentForm { + mod_person_id: actor.id, + comment_id: comment.id, + removed: Some(false), + reason: None, + }; + ModRemoveComment::create(&mut context.pool(), &form).await?; + Comment::update( + &mut context.pool(), + comment.id, + &CommentUpdateForm::builder().removed(Some(false)).build(), + ) + .await?; } + DeletableObjects::PrivateMessage(_) => unimplemented!(), } Ok(()) } } - -#[async_trait::async_trait(?Send)] -impl GetCommunity for UndoDelete { - async fn get_community( - &self, - context: &LemmyContext, - request_counter: &mut i32, - ) -> Result { - self.object.get_community(context, request_counter).await - } -}