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

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