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

   1 use crate::{
   2   activities::{
   3     deletion::{delete::Delete, undo_delete::UndoDelete},
   4     verify_mod_action,
   5     verify_person_in_community,
   6   },
   7   fetcher::object_id::ObjectId,
   8   ActorType,
   9 };
  10 use lemmy_api_common::blocking;
  11 use lemmy_apub_lib::{verify_domains_match, ActivityFields};
  12 use lemmy_db_queries::{
  13   source::{comment::Comment_, community::Community_, post::Post_},
  14   ApubObject,
  15 };
  16 use lemmy_db_schema::{
  17   source::{comment::Comment, community::Community, person::Person, post::Post},
  18   DbUrl,
  19 };
  20 use lemmy_utils::LemmyError;
  21 use lemmy_websocket::{
  22   send::{send_comment_ws_message_simple, send_community_ws_message, send_post_ws_message},
  23   LemmyContext,
  24   UserOperationCrud,
  25 };
  26 use url::Url;
  27
  28 pub mod delete;
  29 pub mod undo_delete;
  30
  31 pub async fn send_apub_delete(
  32   actor: &Person,
  33   community: &Community,
  34   object_id: Url,
  35   deleted: bool,
  36   context: &LemmyContext,
  37 ) -> Result<(), LemmyError> {
  38   if deleted {
  39     Delete::send(actor, community, object_id, None, context).await
  40   } else {
  41     UndoDelete::send(actor, community, object_id, None, context).await
  42   }
  43 }
  44
  45 // TODO: remove reason is actually optional in lemmy. we set an empty string in that case, but its
  46 //       ugly
  47 pub async fn send_apub_remove(
  48   actor: &Person,
  49   community: &Community,
  50   object_id: Url,
  51   reason: String,
  52   removed: bool,
  53   context: &LemmyContext,
  54 ) -> Result<(), LemmyError> {
  55   if removed {
  56     Delete::send(actor, community, object_id, Some(reason), context).await
  57   } else {
  58     UndoDelete::send(actor, community, object_id, Some(reason), context).await
  59   }
  60 }
  61
  62 pub enum DeletableObjects {
  63   Community(Box<Community>),
  64   Comment(Box<Comment>),
  65   Post(Box<Post>),
  66 }
  67
  68 impl DeletableObjects {
  69   pub(crate) async fn read_from_db(
  70     ap_id: &Url,
  71     context: &LemmyContext,
  72   ) -> Result<DeletableObjects, LemmyError> {
  73     let id: DbUrl = ap_id.clone().into();
  74
  75     if let Some(c) = DeletableObjects::read_type_from_db::<Community>(id.clone(), context).await? {
  76       return Ok(DeletableObjects::Community(Box::new(c)));
  77     }
  78     if let Some(p) = DeletableObjects::read_type_from_db::<Post>(id.clone(), context).await? {
  79       return Ok(DeletableObjects::Post(Box::new(p)));
  80     }
  81     if let Some(c) = DeletableObjects::read_type_from_db::<Comment>(id.clone(), context).await? {
  82       return Ok(DeletableObjects::Comment(Box::new(c)));
  83     }
  84     Err(diesel::NotFound.into())
  85   }
  86
  87   // TODO: a method like this should be provided by fetcher module
  88   async fn read_type_from_db<Type: ApubObject + Send + 'static>(
  89     ap_id: DbUrl,
  90     context: &LemmyContext,
  91   ) -> Result<Option<Type>, LemmyError> {
  92     blocking(context.pool(), move |conn| {
  93       Type::read_from_apub_id(conn, &ap_id).ok()
  94     })
  95     .await
  96   }
  97 }
  98
  99 pub(in crate::activities) async fn verify_delete_activity(
 100   object: &Url,
 101   activity: &dyn ActivityFields,
 102   community_id: &ObjectId<Community>,
 103   is_mod_action: bool,
 104   context: &LemmyContext,
 105   request_counter: &mut i32,
 106 ) -> Result<(), LemmyError> {
 107   let object = DeletableObjects::read_from_db(object, context).await?;
 108   let actor = ObjectId::new(activity.actor().clone());
 109   match object {
 110     DeletableObjects::Community(c) => {
 111       if c.local {
 112         // can only do this check for local community, in remote case it would try to fetch the
 113         // deleted community (which fails)
 114         verify_person_in_community(&actor, community_id, context, request_counter).await?;
 115       }
 116       // community deletion is always a mod (or admin) action
 117       verify_mod_action(&actor, ObjectId::new(c.actor_id()), context).await?;
 118     }
 119     DeletableObjects::Post(p) => {
 120       verify_delete_activity_post_or_comment(
 121         activity,
 122         &p.ap_id.into(),
 123         community_id,
 124         is_mod_action,
 125         context,
 126         request_counter,
 127       )
 128       .await?;
 129     }
 130     DeletableObjects::Comment(c) => {
 131       verify_delete_activity_post_or_comment(
 132         activity,
 133         &c.ap_id.into(),
 134         community_id,
 135         is_mod_action,
 136         context,
 137         request_counter,
 138       )
 139       .await?;
 140     }
 141   }
 142   Ok(())
 143 }
 144
 145 async fn verify_delete_activity_post_or_comment(
 146   activity: &dyn ActivityFields,
 147   object_id: &Url,
 148   community_id: &ObjectId<Community>,
 149   is_mod_action: bool,
 150   context: &LemmyContext,
 151   request_counter: &mut i32,
 152 ) -> Result<(), LemmyError> {
 153   let actor = ObjectId::new(activity.actor().clone());
 154   verify_person_in_community(&actor, community_id, context, request_counter).await?;
 155   if is_mod_action {
 156     verify_mod_action(&actor, community_id.clone(), context).await?;
 157   } else {
 158     // domain of post ap_id and post.creator ap_id are identical, so we just check the former
 159     verify_domains_match(activity.actor(), object_id)?;
 160   }
 161   Ok(())
 162 }
 163
 164 struct WebsocketMessages {
 165   community: UserOperationCrud,
 166   post: UserOperationCrud,
 167   comment: UserOperationCrud,
 168 }
 169
 170 /// Write deletion or restoring of an object to the database, and send websocket message.
 171 /// TODO: we should do something similar for receive_remove_action(), but its much more complicated
 172 ///       because of the mod log
 173 async fn receive_delete_action(
 174   object: &Url,
 175   actor: &ObjectId<Person>,
 176   ws_messages: WebsocketMessages,
 177   deleted: bool,
 178   context: &LemmyContext,
 179   request_counter: &mut i32,
 180 ) -> Result<(), LemmyError> {
 181   match DeletableObjects::read_from_db(object, context).await? {
 182     DeletableObjects::Community(community) => {
 183       if community.local {
 184         let mod_ = actor.dereference(context, request_counter).await?;
 185         let object = community.actor_id();
 186         send_apub_delete(&mod_, &community.clone(), object, true, context).await?;
 187       }
 188
 189       let community = blocking(context.pool(), move |conn| {
 190         Community::update_deleted(conn, community.id, deleted)
 191       })
 192       .await??;
 193       send_community_ws_message(community.id, ws_messages.community, None, None, context).await?;
 194     }
 195     DeletableObjects::Post(post) => {
 196       let deleted_post = blocking(context.pool(), move |conn| {
 197         Post::update_deleted(conn, post.id, deleted)
 198       })
 199       .await??;
 200       send_post_ws_message(deleted_post.id, ws_messages.post, None, None, context).await?;
 201     }
 202     DeletableObjects::Comment(comment) => {
 203       let deleted_comment = blocking(context.pool(), move |conn| {
 204         Comment::update_deleted(conn, comment.id, deleted)
 205       })
 206       .await??;
 207       send_comment_ws_message_simple(deleted_comment.id, ws_messages.comment, context).await?;
 208     }
 209   }
 210   Ok(())
 211 }