X-Git-Url: http://these/git/?a=blobdiff_plain;f=crates%2Fapub%2Fsrc%2Factivities%2Fdeletion%2Fundo_delete.rs;h=541a7455fe376082931f957524c859bcdd357236;hb=e9e76549a88cfbdab36f00d302cceabcaaa24f4c;hp=d2816b114ca84c603453804fc6a722b2558812f2;hpb=271785b7fbe824628d79187f33be3c2e75f42d1b;p=lemmy.git

diff --git a/crates/apub/src/activities/deletion/undo_delete.rs b/crates/apub/src/activities/deletion/undo_delete.rs
index d2816b11..541a7455 100644
--- a/crates/apub/src/activities/deletion/undo_delete.rs
+++ b/crates/apub/src/activities/deletion/undo_delete.rs
@@ -1,182 +1,154 @@
 use crate::{
   activities::{
-    community::{
-      announce::{AnnouncableActivities, GetCommunity},
-      send_to_community,
-    },
-    deletion::{
-      delete::Delete,
-      receive_delete_action,
-      verify_delete_activity,
-      DeletableObjects,
-      WebsocketMessages,
-    },
+    deletion::{receive_delete_action, verify_delete_activity, DeletableObjects},
     generate_activity_id,
-    verify_activity,
-    verify_is_public,
   },
-  context::lemmy_context,
-  fetcher::object_id::ObjectId,
-  objects::{community::ApubCommunity, person::ApubPerson},
-};
-use activitystreams::{
-  activity::kind::UndoType,
-  base::AnyBase,
-  primitives::OneOrMany,
-  public,
-  unparsed::Unparsed,
-};
-use anyhow::anyhow;
-use lemmy_api_common::blocking;
-use lemmy_apub_lib::{
-  data::Data,
-  traits::{ActivityFields, ActivityHandler, ActorType},
+  insert_received_activity,
+  objects::person::ApubPerson,
+  protocol::activities::deletion::{delete::Delete, undo_delete::UndoDelete},
 };
-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 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 serde::{Deserialize, Serialize};
+use lemmy_utils::error::{LemmyError, LemmyErrorType};
 use url::Url;
 
-#[derive(Clone, Debug, Deserialize, Serialize, ActivityFields)]
-#[serde(rename_all = "camelCase")]
-pub struct UndoDelete {
-  actor: ObjectId<ApubPerson>,
-  to: Vec<Url>,
-  object: Delete,
-  cc: [ObjectId<ApubCommunity>; 1],
-  #[serde(rename = "type")]
-  kind: UndoType,
-  id: Url,
-  #[serde(rename = "@context")]
-  context: OneOrMany<AnyBase>,
-  #[serde(flatten)]
-  unparsed: Unparsed,
-}
-
-#[async_trait::async_trait(?Send)]
+#[async_trait::async_trait]
 impl ActivityHandler for UndoDelete {
   type DataType = LemmyContext;
-  async fn verify(
-    &self,
-    context: &Data<LemmyContext>,
-    request_counter: &mut i32,
-  ) -> Result<(), LemmyError> {
-    verify_is_public(&self.to)?;
-    verify_activity(self, &context.settings())?;
-    self.object.verify(context, request_counter).await?;
-    verify_delete_activity(
-      &self.object.object,
-      self,
-      &self.cc[0],
-      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<Self::DataType>) -> 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<LemmyContext>,
-    request_counter: &mut i32,
-  ) -> Result<(), LemmyError> {
+  #[tracing::instrument(skip_all)]
+  async fn receive(self, context: &Data<LemmyContext>) -> 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,
-        WebsocketMessages {
-          community: UserOperationCrud::EditCommunity,
-          post: UserOperationCrud::EditPost,
-          comment: UserOperationCrud::EditComment,
-        },
-        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<String>,
-    context: &LemmyContext,
-  ) -> Result<(), LemmyError> {
-    let object = Delete::new(actor, community, object_id, summary, context)?;
+    context: &Data<LemmyContext>,
+  ) -> Result<UndoDelete, LemmyError> {
+    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<Url> = community.map(|c| c.actor_id.clone().into());
+    Ok(UndoDelete {
+      actor: actor.actor_id.clone().into(),
+      to: vec![to],
       object,
-      cc: [ObjectId::new(community.actor_id())],
+      cc: cc.into_iter().collect(),
       kind: UndoType::Undo,
-      id: id.clone(),
-      context: lemmy_context(),
-      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<LemmyContext>,
   ) -> 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<ApubCommunity, LemmyError> {
-    self.object.get_community(context, request_counter).await
-  }
-}