crates/apub/src/activities/deletion/undo_delete.rs

   1 use crate::{
   2   activities::{
   3     community::{announce::GetCommunity, send_to_community},
   4     deletion::{receive_delete_action, verify_delete_activity, DeletableObjects},
   5     generate_activity_id,
   6     verify_activity,
   7     verify_is_public,
   8   },
   9   activity_lists::AnnouncableActivities,
  10   objects::{community::ApubCommunity, person::ApubPerson},
  11   protocol::activities::deletion::{delete::Delete, undo_delete::UndoDelete},
  12 };
  13 use activitystreams::{activity::kind::UndoType, public};
  14 use anyhow::anyhow;
  15 use lemmy_api_common::blocking;
  16 use lemmy_apub_lib::{
  17   data::Data,
  18   object_id::ObjectId,
  19   traits::{ActivityHandler, ActorType},
  20 };
  21 use lemmy_db_schema::source::{comment::Comment, community::Community, post::Post};
  22 use lemmy_utils::LemmyError;
  23 use lemmy_websocket::{
  24   send::{send_comment_ws_message_simple, send_community_ws_message, send_post_ws_message},
  25   LemmyContext,
  26   UserOperationCrud,
  27 };
  28 use url::Url;
  29
  30 #[async_trait::async_trait(?Send)]
  31 impl ActivityHandler for UndoDelete {
  32   type DataType = LemmyContext;
  33   async fn verify(
  34     &self,
  35     context: &Data<LemmyContext>,
  36     request_counter: &mut i32,
  37   ) -> Result<(), LemmyError> {
  38     verify_is_public(&self.to, &self.cc)?;
  39     verify_activity(&self.id, self.actor.inner(), &context.settings())?;
  40     self.object.verify(context, request_counter).await?;
  41     let community = self.get_community(context, request_counter).await?;
  42     verify_delete_activity(
  43       &self.object.object,
  44       &self.actor,
  45       &community,
  46       self.object.summary.is_some(),
  47       context,
  48       request_counter,
  49     )
  50     .await?;
  51     Ok(())
  52   }
  53
  54   async fn receive(
  55     self,
  56     context: &Data<LemmyContext>,
  57     request_counter: &mut i32,
  58   ) -> Result<(), LemmyError> {
  59     if self.object.summary.is_some() {
  60       UndoDelete::receive_undo_remove_action(&self.object.object, context).await
  61     } else {
  62       receive_delete_action(
  63         &self.object.object,
  64         &self.actor,
  65         false,
  66         context,
  67         request_counter,
  68       )
  69       .await
  70     }
  71   }
  72 }
  73
  74 impl UndoDelete {
  75   pub(in crate::activities::deletion) async fn send(
  76     actor: &ApubPerson,
  77     community: &ApubCommunity,
  78     object_id: Url,
  79     summary: Option<String>,
  80     context: &LemmyContext,
  81   ) -> Result<(), LemmyError> {
  82     let object = Delete::new(actor, community, object_id, summary, context)?;
  83
  84     let id = generate_activity_id(
  85       UndoType::Undo,
  86       &context.settings().get_protocol_and_hostname(),
  87     )?;
  88     let undo = UndoDelete {
  89       actor: ObjectId::new(actor.actor_id()),
  90       to: vec![public()],
  91       object,
  92       cc: vec![community.actor_id()],
  93       kind: UndoType::Undo,
  94       id: id.clone(),
  95       unparsed: Default::default(),
  96     };
  97
  98     let activity = AnnouncableActivities::UndoDelete(undo);
  99     send_to_community(activity, &id, actor, community, vec![], context).await
 100   }
 101
 102   pub(in crate::activities) async fn receive_undo_remove_action(
 103     object: &Url,
 104     context: &LemmyContext,
 105   ) -> Result<(), LemmyError> {
 106     use UserOperationCrud::*;
 107     match DeletableObjects::read_from_db(object, context).await? {
 108       DeletableObjects::Community(community) => {
 109         if community.local {
 110           return Err(anyhow!("Only local admin can restore community").into());
 111         }
 112         let deleted_community = blocking(context.pool(), move |conn| {
 113           Community::update_removed(conn, community.id, false)
 114         })
 115         .await??;
 116         send_community_ws_message(deleted_community.id, EditCommunity, None, None, context).await?;
 117       }
 118       DeletableObjects::Post(post) => {
 119         let removed_post = blocking(context.pool(), move |conn| {
 120           Post::update_removed(conn, post.id, false)
 121         })
 122         .await??;
 123         send_post_ws_message(removed_post.id, EditPost, None, None, context).await?;
 124       }
 125       DeletableObjects::Comment(comment) => {
 126         let removed_comment = blocking(context.pool(), move |conn| {
 127           Comment::update_removed(conn, comment.id, false)
 128         })
 129         .await??;
 130         send_comment_ws_message_simple(removed_comment.id, EditComment, context).await?;
 131       }
 132     }
 133     Ok(())
 134   }
 135 }
 136
 137 #[async_trait::async_trait(?Send)]
 138 impl GetCommunity for UndoDelete {
 139   async fn get_community(
 140     &self,
 141     context: &LemmyContext,
 142     request_counter: &mut i32,
 143   ) -> Result<ApubCommunity, LemmyError> {
 144     self.object.get_community(context, request_counter).await
 145   }
 146 }